KSG-Framework/Rahmen.cpp

#include "Rahmen.h"
#include "Punkt.h"
#include "Bild.h"
#include "Scroll.h"
#include "ToolTip.h"
#include "Text.h"

using namespace Framework;

// Inhalt der Rahmen Klasse aus Rahmen.h
// Konstruktor 
Rahmen::Rahmen()
    : Zeichnung(),
    br( 1 ),
    farbe( 0xFF000000 ),
    alpha( 0 ),
    breaks( 0 )
{}

// Destruktor
Rahmen::~Rahmen()
{}

// nicht constant 
void Rahmen::setRamenBreite( int br ) // setzt die Breite des Rahmens
{
    this->br = br;
    rend = 1;
}

// wenn dieser Flag gesetzt wird, wird der Rahmen gestrichelt gezeichnet
//  br: 1 -> gestrichelt, 0 -> durchgehend
void Rahmen::setBreaks( bool br )
{
    breaks = br;
}

void Rahmen::setAlpha( bool a ) // Legt fest, ob der Alphawert der Farbe berücksichtigt werden soll
{
    alpha = a;
    rend = 1;
}

void Rahmen::setFarbe( int f ) // Legt die Farbe des Rahmens fest
{
    farbe = f;
    rend = 1;
}

int Rahmen::getFarbe() const // Gibt die Farbe des Ramens zurück
{
    return farbe;
}

bool Rahmen::hatAlpha() const // Gibt zurück, ob der Alphawert der Farbe beachtet wird
{
    return alpha;
}

int Rahmen::getRBreite() const // Gibt die Breite des Rahmens zurück
{
    return br;
}

// Gibt 1 zurück, falls der Rahmen gestrichelt gezeichnet wird
bool Rahmen::hasBreaks() const
{
    return breaks;
}


// Inhalt der LRahmen Klasse aus Rahmen.h
// Konstruktor 
LRahmen::LRahmen()
    : Rahmen()
{}

// Destruktor
LRahmen::~LRahmen()
{}

void LRahmen::render( Bild &Obj ) // Zeichnet den Rahmen in das RenderZeichnung
{
    Zeichnung::render( Obj );
    int x = pos.x;
    int y = pos.y;
    int b = x + gr.x - 1;
    int h = y + gr.y - 1;
    if( !breaks )
    {
        if( alpha )
        {
            for( int i = 0; i < br; ++i )
            {
                Obj.drawLinieHAlpha( x + i + 1, y + i, gr.x - i * 2 - 1, farbe );
                Obj.drawLinieVAlpha( b - i, y + i + 1, gr.y - i * 2 - 2, farbe );
                Obj.drawLinieHAlpha( x + i + 1, h - i, gr.x - i * 2 - 1, farbe );
                Obj.drawLinieVAlpha( x + i, y + i, gr.y - i * 2, farbe );
            }
        }
        else
        {
            for( int i = 0; i < br; ++i )
            {
                Obj.drawLinieH( x + i + 1, y + i, gr.x - i * 2 - 1, farbe );
                Obj.drawLinieV( b - i, y + i + 1, gr.y - i * 2 - 2, farbe );
                Obj.drawLinieH( x + i + 1, h - i, gr.x - i * 2 - 1, farbe );
                Obj.drawLinieV( x + i, y + i, gr.y - i * 2, farbe );
            }
        }
    }
    else
    {
        if( alpha )
        {
            for( int i = 0; i < br; ++i )
            {
                for( int x = pos.x; x < pos.x + gr.x; x += 20 )
                {
                    Obj.drawLinieHAlpha( x + i + 1, y + i, min( 10, gr.x - i * 2 - 1 + pos.x - x ), farbe );
                    Obj.drawLinieHAlpha( x + i + 1, h - i, min( 10, gr.x - i * 2 - 1 + pos.x - x ), farbe );
                }
                for( int y = pos.y; y < pos.y + gr.y; y += 20 )
                {
                    Obj.drawLinieVAlpha( b - i, y + i + 1, min( 10, gr.y - i * 2 - 2 + pos.y - y ), farbe );
                    Obj.drawLinieVAlpha( x + i, y + i, min( 10, gr.y - i * 2 + pos.y - y ), farbe );
                }
            }
        }
        else
        {
            for( int i = 0; i < br; ++i )
            {
                for( int x = pos.x; x < pos.x + gr.x; x += 20 )
                {
                    Obj.drawLinieH( x + i + 1, y + i, min( 10, gr.x - i * 2 - 1 + pos.x - x ), farbe );
                    Obj.drawLinieH( x + i + 1, h - i, min( 10, gr.x - i * 2 - 1 + pos.x - x ), farbe );
                }
                for( int y = pos.y; y < pos.y + gr.y; y += 20 )
                {
                    Obj.drawLinieV( b - i, y + i + 1, min( 10, gr.y - i * 2 - 2 + pos.y - y ), farbe );
                    Obj.drawLinieV( x + i, y + i, min( 10, gr.y - i * 2 + pos.y - y ), farbe );
                }
            }
        }
    }
}

Zeichnung *LRahmen::dublizieren() const // Kopiert das Zeichnung
{
    Rahmen *obj = new LRahmen();
    obj->setPosition( pos );
    obj->setSize( gr );
    obj->setMausEreignisParameter( makParam );
    obj->setTastaturEreignisParameter( takParam );
    obj->setMausEreignis( mak );
    obj->setTastaturEreignis( tak );
    if( toolTip )
        obj->setToolTipZ( (ToolTip*)toolTip->dublizieren() );
    obj->setBreaks( breaks );
    obj->setAlpha( alpha );
    obj->setFarbe( farbe );
    obj->setRamenBreite( br );
    return obj;
}


// Inhalt der Rahmen3D Klasse aus Rahmen.h
// Konstruktor 
Rahmen3D::Rahmen3D()
    : Rahmen()
{
    alpha = 1;
    farbe = 0x70FFFFFF;
    br = 5;
}

// Destruktor
Rahmen3D::~Rahmen3D()
{}

void Rahmen3D::render( Bild &Obj ) // Zeichnet den Rahmen in das RenderZeichnung
{
    Zeichnung::render( Obj );
    int x = pos.x;
    int y = pos.y;
    int b = x + gr.x - 1;
    int h = y + gr.y - 1;
    int fcomp = ( farbe & 0xFF000000 ) | ( ~farbe & 0x00FFFFFF );
    if( !breaks )
    {
        if( alpha )
        {
            for( int i = 0; i < br; ++i )
            {
                Obj.drawLinieHAlpha( x + i + 1, y + i, gr.x - i * 2 - 1, farbe );
                Obj.drawLinieVAlpha( b - i, y + i + 1, gr.y - i * 2 - 2, farbe );
                Obj.drawLinieHAlpha( x + i + 1, h - i, gr.x - i * 2 - 1, fcomp );
                Obj.drawLinieVAlpha( x + i, y + i, gr.y - i * 2, fcomp );
            }
        }
        else
        {
            for( int i = 0; i < br; ++i )
            {
                Obj.drawLinieH( x + i + 1, y + i, gr.x - i * 2 - 1, farbe );
                Obj.drawLinieV( b - i, y + i + 1, gr.y - i * 2 - 2, farbe );
                Obj.drawLinieH( x + i + 1, h - i, gr.x - i * 2 - 1, fcomp );
                Obj.drawLinieV( x + i, y + i, gr.y - i * 2, fcomp );
            }
        }
    }
    else
    {
        if( alpha )
        {
            for( int i = 0; i < br; ++i )
            {
                for( int x = pos.x; x < pos.x + gr.x; x += 20 )
                {
                    Obj.drawLinieHAlpha( x + i + 1, y + i, min( 10, gr.x - i * 2 - 1 + pos.x - x ), farbe );
                    Obj.drawLinieHAlpha( x + i + 1, h - i, min( 10, gr.x - i * 2 - 1 + pos.x - x ), fcomp );
                }
                for( int y = pos.y; y < pos.y + gr.y; y += 20 )
                {
                    Obj.drawLinieVAlpha( b - i, y + i + 1, min( 10, gr.y - i * 2 - 2 + pos.y - y ), farbe );
                    Obj.drawLinieVAlpha( x + i, y + i, min( 10, gr.y - i * 2 + pos.y - y ), fcomp );
                }
            }
        }
        else
        {
            for( int i = 0; i < br; ++i )
            {
                for( int x = pos.x; x < pos.x + gr.x; x += 20 )
                {
                    Obj.drawLinieH( x + i + 1, y + i, min( 10, gr.x - i * 2 - 1 + pos.x - x ), farbe );
                    Obj.drawLinieH( x + i + 1, h - i, min( 10, gr.x - i * 2 - 1 + pos.x - x ), fcomp );
                }
                for( int y = pos.y; y < pos.y + gr.y; y += 20 )
                {
                    Obj.drawLinieV( b - i, y + i + 1, min( 10, gr.y - i * 2 - 2 + pos.y - y ), farbe );
                    Obj.drawLinieV( x + i, y + i, min( 10, gr.y - i * 2 + pos.y - y ), fcomp );
                }
            }
        }
    }
}

Zeichnung *Rahmen3D::dublizieren() const // Kopiert das Zeichnung
{
    Rahmen *obj = new Rahmen3D();
    obj->setPosition( pos );
    obj->setSize( gr );
    obj->setMausEreignisParameter( makParam );
    obj->setTastaturEreignisParameter( takParam );
    obj->setMausEreignis( mak );
    obj->setTastaturEreignis( tak );
    if( toolTip )
        obj->setToolTipZ( (ToolTip*)toolTip->dublizieren() );
    obj->setBreaks( breaks );
    obj->setAlpha( alpha );
    obj->setFarbe( farbe );
    obj->setRamenBreite( br );
    return obj;
}