[title = Graph13 Ktphanesi]Aadaki kaynak kod "Tr-Demoscene: http://www.tr-demoscene.info/" forumunda yalnzca eitici olmas amacyla yaynladm bir 13h (320x200x256) grafik modu ktphanesinin gelitirilmi versiyonudur ve Turbo C++ ile derlenebilir. Ufak deiikliklerle dier DOS tabanl derleyicilere de modifiye edilmesi mmkndr.

Aslnda bu ktphane tek dosyadan ibaret deildi ancak hem dergiye eklenmesini kolaylatrmak, hem de birden fazla dosya ieren projeleri derlemede sorun yaayan balang seviyesindeki C/C++ programclarn dnerek tm fonksiyonlar tek bir CPP dosyasnda birletirdim. Normal koullarda projelerinizi dosyalara blerek gelitirmenizi ve her .c/.cpp dosyas iin bir .h (header) dosyas kullanmanz tavsiye ederim.

Tr-Demoscene forumunda yaynlanan versiyonda snflarda private deiken kullanm yoktu, snflarn tm deikenleri dorudan eriilebilir bir ekilde public tanmlanmt. Bu aslnda yaln bir kullanmdr ve zel bir amac olmad srece genellikle tembellik belirtisidir. Bu yeni versiyonda tembellik etmeyip, snflar olmas gerektii yapya evirdim. Private deiken kullanm zellikle hafzada oluabilecek baz tamalar nlemek iin ideal bir kullanmdr.

Bu kaynak kodu yaynlamakdaki amacm, bu saatten sonra DOS'da 13h modunda bireyler yaplmasna yardmc olmak deil, nesneye ynelik programlama (OOP) konusunda elinizde aklamal bir kaynak kod bulunmasnn yararl olacan dnmemdir. Kodun iersinde yeterli yorum olduu iin daha fazla aklama yapmaya gerek duymuyorum. zellikle overloaded fonksiyon ve overloaded methodlar; yani ayn isme sahip ye fonksiyonlarn ve bu fonksiyonlarn parametrelerinden dier snflarn nasl kullanldn incelemenizi tavsiye ediyorum.
[img = CTR data/articles/Graph13/graph13.gif]Plazma'nn ilerleyen saylar iin OOP konusunda Win32 tabanl ktphane ve programlar da hazrlamay dnyorum. Ancak ncelikle elimizdekilerden kurtulalm...

Nesneye ynelik programlama konusunda balang seviyesinde olanlara baarlar ve iyi almalar dilerim.

Not: Kaynak kodu renklendirme zellii olan bir C editrnde ya da C dosyalarn renklendirebilen bir text editrde incelemenizi tavsiye ederim.
[code]/**
 * Icerikler
 */
#include 
#include 
#include 

/**
 * Tanimlar
 */
#define CHAR03 0x03
#define INT_VIDEO 0x10
#define VGA13 0x13

/**
 * Siniflar
 */

// POINT2D Sinifi
class POINT2D
{
    public:
    POINT2D();
    POINT2D(POINT2D *p2dPoint);
    POINT2D(int xVal, int yVal);
    ~POINT2D();
    int getX();
    int getY();
    void setX(int newX);
    void setY(int newY);
    private:
    int x;
    int y;
};

void POINT2D::POINT2D()
{
    // Bos
}

void POINT2D::POINT2D(POINT2D *p2dPoint)
{
    x = p2dPoint->x;
    y = p2dPoint->y;
}

void POINT2D::POINT2D(int xVal, int yVal)
{
    x = xVal;
    y = yVal;
}

void POINT2D::~POINT2D()
{
    // Bos
}

int POINT2D::getX()
{
    return x;
}

int POINT2D::getY()
{
    return y;
}

void POINT2D::setX(int newX)
{
    x = newX;
}

void POINT2D::setY(int newY)
{
    y = newY;
}

// RECT Sinifi
class RECT
{
    public:
    RECT();
    RECT(RECT *rctRect);
    RECT(POINT2D *p2dPoint1, POINT2D *p2dPoint2);
    RECT(int x1Val, int y1Val, int x2Val, int y2Val);
    ~RECT();
    int getX1();
    int getY1();
    int getX2();
    int getY2();
    void setX1(int newX1);
    void setY1(int newY1);
    void setX2(int newX2);
    void setY2(int newY2);
    private:
    int x1;
    int y1;
    int x2;
    int y2;
};

void RECT::RECT()
{
    // Bos
}

void RECT::RECT(RECT *rctRect)
{
    x1 = rctRect->x1;
    y1 = rctRect->y1;
    x2 = rctRect->x2;
    y2 = rctRect->y2;
}

void RECT::RECT(POINT2D *p2dPoint1, POINT2D *p2dPoint2)
{
    x1 = p2dPoint1->getX();
    y1 = p2dPoint1->getY();
    x2 = p2dPoint2->getX();
    y2 = p2dPoint2->getY();
}

void RECT::RECT(int x1Val, int y1Val, int x2Val, int y2Val)
{
    x1 = x1Val;
    y1 = y1Val;
    x2 = x2Val;
    y2 = y2Val;
}

void RECT::~RECT()
{
    // Bos
}

int RECT::getX1()
{
    return x1;
}

int RECT::getY1()
{
    return y1;
}

int RECT::getX2()
{
    return x2;
}

int RECT::getY2()
{
    return y2;
}

void RECT::setX1(int newX1)
{
    x1 = newX1;
}

void RECT::setY1(int newY1)
{
    y1 = newY1;
}

void RECT::setX2(int newX2)
{
    x2 = newX2;
}

void RECT::setY2(int newY2)
{
    y2 = newY2;
}

// RGB Sinifi
class RGB
{
    public:
    RGB();
    RGB(RGB *rgbColor);
    RGB(unsigned char rVal, unsigned char gVal, unsigned char bVal);
    ~RGB();
    int getR();
    int getG();
    int getB();
    void setR(int newR);
    void setG(int newG);
    void setB(int newB);
    private:
    unsigned char r;
    unsigned char g;
    unsigned char b;
};

void RGB::RGB()
{
    // bos
}

void RGB::RGB(RGB *rgbColor)
{
    r = rgbColor->r;
    g = rgbColor->g;
    b = rgbColor->b;
}

void RGB::RGB(unsigned char rVal, unsigned char gVal, unsigned char bVal)
{
    r = rVal;
    g = gVal;
    b = bVal;
}

void RGB::~RGB()
{
    // bos
}

int RGB::getR()
{
    return r;
}

int RGB::getG()
{
    return g;
}

int RGB::getB()
{
    return b;
}

void RGB::setR(int newR)
{
    r = newR;
}

void RGB::setG(int newG)
{
    g = newG;
}

void RGB::setB(int newB)
{
    b = newB;
}

/**
 * Global Degiskenler
 */
char far *VGAMAP = (char far *) MK_FP(0xA000, 0);

/**
 * Prototip Fonksiyonlar
 */
void SetScreen(int screenMode);
RGB  GetColor(unsigned char color);
void SetColor(unsigned char color, unsigned char r, unsigned char g, unsigned char b);
void SetColor(unsigned char color, RGB *rgbColor);
void CycleLeft(unsigned char continues);
void CycleRight(unsigned char continues);
void Plot(unsigned int x, unsigned char y, unsigned char color);
void Plot(POINT2D *p2dPoint, unsigned char color);
void DrawLine(int x1, int y1, int x2, int y2, unsigned char color);
void DrawLine(POINT2D *p2dPoint1, POINT2D *p2dPoint2, unsigned char color);
void DrawLine(RECT *rctRect, unsigned char color);
void DrawRectangle(int x1, int y1, int x2, int y2, unsigned char color);
void DrawRectangle(POINT2D *p2dPoint1, POINT2D *p2dPoint2, unsigned char color);
void DrawRectangle(RECT *rctRect, unsigned char color);
void DrawCircle(int cx, int cy, int r, unsigned char color);
void DrawCircle(POINT2D *p2dPoint, int r, unsigned char color);
void FillRectangle(int x1, int y1, int x2, int y2, unsigned char color);
void FillRectangle(POINT2D *p2dPoint1, POINT2D *p2dPoint2, unsigned char color);
void FillRectangle(RECT *rctRect, unsigned char color);
void FillCircle(int cx, int cy, int r, unsigned char color);
void FillCircle(POINT2D *p2dPoint, int r, unsigned char color);

/**
 * Ana Fonksiyon
 */
void main()
{
    // Degisken tanimlari
    int x, y, i;
    POINT2D myPoint1;
    POINT2D myPoint2(40, 40);
    RECT myRect1;
    myPoint1.setX(30);
    myPoint1.setY(30);

    // 320x200 256 renk ekran moduna gec
    SetScreen(VGA13);

    // Palet olustur
    // 0 - 63 kizmizi tonlari (0   : en koyu @siyah; 63  : en acik @kirmizi)
    // 64 - 127 yesil tonlari (64  : en koyu @siyah; 127 : en acik @yesil)
    // 128 - 191 mavi tonlari (128 : en koyu @siyah; 191 : en acik @mavi)
    // 192 - 255 gri tonlari  (192 : en koyu @siyah; 255 : en acik @beyaz)
    for(i = 0; i <= 63; i++)
        SetColor(i, i, 0, 0); // kirmizi
    for(i = 64; i <= 127; i++)
        SetColor(i, 0, (i - 64), 0); // yesil
    for(i = 128; i <= 191; i++)
        SetColor(i, 0, 0, (i - 128)); // mavi
    for(i = 192; i <= 255; i++)
        SetColor(i, (i - 192), (i - 192), (i - 192)); // gri

    // Ekrana birkac ornek nokta bas
    Plot(30, 40, 234); // Birinci kullanim bicimi
    Plot(&myPoint1, 60); // Ikinci kullanim bicimi
    Plot(&myPoint2, 92);
    Plot(&POINT2D(40, 30), 182); // Ucuncu kullanim bicimi

    // Ekrana birkac ornek cizgi cek
    // Cizgilerin baslangic ve bitislerini plot ile isaretle

    // Cizgi 1
    myPoint1.setX(80);    myPoint1.setY(150);
    myPoint2.setX(213);    myPoint2.setY(48);
    DrawLine(&myPoint1, &myPoint2, 63);
    Plot(&myPoint1, 255);
    Plot(&myPoint2, 255);

    // Cizgi 2
    myPoint1.setX(80);    myPoint1.setY(48);
    myPoint2.setX(213);    myPoint2.setY(150);
    DrawLine(&myPoint1, &myPoint2, 63);
    Plot(&myPoint1, 255);
    Plot(&myPoint2, 255);

    // Cizgi 3
    myPoint1.setX(40);    myPoint1.setY(110);
    myPoint2.setX(77);    myPoint2.setY(121);
    myRect1 = &RECT(&myPoint1, &myPoint2);
    DrawLine(&myRect1, 63);
    Plot(&myPoint1, 255);
    Plot(&myPoint2, 255);

    // Cizgilerden bir daire ciz
    for(i = 0; i < 512; i++)
    {
        x = 250 + 55 * cos((float)i / 256 * M_PI);
        y = 100 + 55 * sin((float)i / 256 * M_PI);
        DrawLine(250, 100, x, y, x + y);
    }

    // Ekrana birkac ornek dikdortgen ciz

    // Dikdortgen 1
    DrawRectangle(70, 170, 10, 183, 49);

    // Dikdortgen 2
    myPoint1.setX(80);    myPoint1.setY(160);
    myPoint2.setX(95);    myPoint2.setY(190);
    DrawRectangle(&myPoint1, &myPoint2, 117);

    // Dikdortgen 3
    myRect1.setX1(170);    myRect1.setY1(160);
    myRect1.setX2(105);    myRect1.setY2(190);
    DrawRectangle(&myRect1, 185);

    // Ekrana birkac ornek ici dolu dikdortgen ciz

    // Ici Dolu Dikdortgen 1
    FillRectangle(68, 172, 12, 181, 49);

    // Ici Dolu Dikdortgen 2
    myPoint1.setX(85);    myPoint1.setY(165);
    myPoint2.setX(90);    myPoint2.setY(185);
    FillRectangle(&myPoint1, &myPoint2, 127);

    // Ici Dolu Dikdortgen 3
    myRect1.setX1(250);    myRect1.setY1(165);
    myRect1.setX2(310);    myRect1.setY2(185);
    FillRectangle(&myRect1, 63);

    // Ekrana birkac ornek cember ciz

    // Cember 1
    DrawCircle(100, 100, 20, 255);

    // Diger ic ice dizilmis cemberler
    myPoint1 = &POINT2D(150, 40);
    for(i = 0; i < 30; i++)
        DrawCircle(&myPoint1, i, i * 12);

    // Ekrana birkac ornek daire ciz

    // Daire 1
    FillCircle(100, 100, 18, 44);

    // Diger ic ice dizilmis daireler
    myPoint1 = &POINT2D(96, 30);
    for(i = 20; i >= 0; i--)
        FillCircle(&myPoint1, i, i * 16);

    // Bir tusa basilana kadar bekle
    getch();

    // Renkleri kaydir
    while(!kbhit())
    {
        CycleLeft(1);
        delay(50);
    }
    getch();
    while(!kbhit())
    {
        CycleRight(0);
        delay(50);
    }

    // 80x25 karakter ekran moduna gec
    SetScreen(CHAR03);
}

/**
 * Name  : SetScreen
 * Desc  : 0x10 interruptini kullanarak ekran modunu degistirir.
 * Input : (int)screenMode
 */
void SetScreen(int screenMode)
{
    union REGS regs;
    regs.x.ax = screenMode;
    int86(INT_VIDEO, &regs, &regs);
}

/**
 * Name  : GetColor
 * Desc  : Parametreden gelen siradaki palet rengini okur.
 * Input : (unsigned char)color
 * Output: (RGB)
 */
RGB GetColor(unsigned char color)
{
    RGB rgbColor;
    outportb(0x3c7, color);
    rgbColor.setR(inportb(0x3c9));
    rgbColor.setG(inportb(0x3c9));
    rgbColor.setB(inportb(0x3c9));
    return rgbColor;
}

/**
 * Name  : SetColor
 * Desc  : Palet renklerini degistirir.
 * Input : (unsigned char)color
 *         (unsigned char)r
 *         (unsigned char)g
 *         (unsigned char)b
 */
void SetColor(unsigned char color, unsigned char r, unsigned char g, unsigned char b)
{
    outportb(0x3c8, color);
    outportb(0x3c9, r);
    outportb(0x3c9, g);
    outportb(0x3c9, b);
}

/**
 * Name  : SetColor
 * Desc  : Overloaded SetColor fonksiyonu. (r,g,b) renklerini
 *         RGB sinifindan tek bir degiskenden alir.
 * Input : (unsigned char)color
 *         (RGB *)rgbColor
 */
void SetColor(unsigned char color, RGB *rgbColor)
{
    outportb(0x3c8, color);
    outportb(0x3c9, rgbColor->getR());
    outportb(0x3c9, rgbColor->getG());
    outportb(0x3c9, rgbColor->getB());
}

/**
 * Name  : CycleLeft
 * Desc  : Palet renklerini sola kaydirir
 * Input : (unsigned char)continues
 */
void CycleLeft(unsigned char continues)
{
    RGB rgbTemp;
    int i;
    if(continues == 1)
        rgbTemp = &GetColor(0);
    for(i = 0; i <= 254; i++)
        SetColor(i, &GetColor(i + 1));
    if(continues == 1)
        SetColor(255, &rgbTemp);
}

/**
 * Name  : CycleRight
 * Desc  : Palet renklerini saga kaydirir
 * Input : (unsigned char)continues
 */
void CycleRight(unsigned char continues)
{
    RGB rgbTemp;
    int i;
    if(continues == 1)
        rgbTemp = &GetColor(255);
    for(i = 255; i >= 1; i--)
        SetColor(i, &GetColor(i - 1));
    if(continues == 1)
        SetColor(0, &rgbTemp);
}

/**
 * Name  : Plot
 * Desc  : Parametreden gelen (x,y) koordinatlarina, yine parametreden
 *         gelen rengi basar.
 * Input : (unsigned int)x
 *         (unsigned char)y
 *         (unsigned char)color
 */
void Plot(unsigned int x, unsigned char y, unsigned char color)
{
    /********************************
    *      Formulun Cikarilisi      *
    *********************************
    * (y * 320) + x =>              *
    * (y * 256) + (y * 64) + x =>   *
    * (y * 2^8) + (y * 2^6) + x =>  *
    * (y << 8) + (y << 6) + x       *
    ********************************/
    VGAMAP@(y << 8) + (y << 6) + x = color;
}

/**
 * Name  : Plot
 * Desc  : Overloaded Plot fonksiyonu. (x,y) koordinatlarini POINT2D
 *         sinifindan tek bir degiskenden alir.
 * Input : (POINT2D *)p2dPoint
 *         (unsigned char)color
 */
void Plot(POINT2D *p2dPoint, unsigned char color)
{
    VGAMAP@(p2dPoint->getY() << 8) + (p2dPoint->getY() << 6) + p2dPoint->getX() = color;
}

/**
 * Name  : DrawLine
 * Desc  : Parametreden gelen (x1,y1)-(x2,y2) koordinatlari arasina
 *         cizgi ceker. 'a ihtiyac duymaz.
 *         Bresenham algoritmasi kullanir.
 * Input : (int)x1
 *         (int)y1
 *         (int)x2
 *         (int)y2
 *         (unsigned char)color
 */
void DrawLine(int x1, int y1, int x2, int y2, unsigned char color)
{
    int dx, dy, x, y, a = 0;
    dx = (x1 - x2 > 0) ? x1 - x2 : x2 - x1; // Yatay duzlemdeki genislik
    dy = (y1 - y2 > 0) ? y1 - y2 : y2 - y1; // Dikey duzlemdeki uzunluk
    if(dx > dy) // Yatay duzlemde genis ise
    {
        x = x1;
        y = y1;
        while(1)
        {
            Plot(x, y, color);
            a += dy;
            if(a >= dx)
            {
                a -= dx;
                y += (y1 > y2) ? -1 : 1;
            }
            if(x == x2)
                break;
            x += (x1 > x2) ? -1 : 1;
        }
    }
    else // Dikey duzlemde uzun ise
    {
        x = x1;
        y = y1;
        while(1)
        {
            Plot(x, y, color);
            a += dx;
            if(a >= dy)
            {
                a -= dy;
                x += (x1 > x2) ? -1 : 1;
            }
            if(y == y2)
                break;
            y += (y1 > y2) ? -1 : 1;
        }
    }
}

/**
 * Name  : DrawLine
 * Desc  : Overloaded DrawLine fonksiyonu. (x1,y1) ve (x2,y2) yerine
 *         POINT2D sinifindan iki degisken kullanilir.
 * Input : (POINT2D *)p2dPoint1
 *         (POINT2D *)p2dPoint2
 *         (unsigned char)color
 */
void DrawLine(POINT2D *p2dPoint1, POINT2D *p2dPoint2, unsigned char color)
{
    DrawLine(p2dPoint1->getX(), p2dPoint1->getY(), p2dPoint2->getX(), p2dPoint2->getY(), color);
}

/**
 * Name  : DrawLine
 * Desc  : Overloaded DrawLine fonksiyonu. (x1,y1) ve (x2,y2) yerine
 *         RECT sinifindan bir degisken kullanilir.
 * Input : (RECT *)rctRect
 *         (unsigned char)color
 */
void DrawLine(RECT *rctRect, unsigned char color)
{
    DrawLine(rctRect->getX1(), rctRect->getY1(), rctRect->getX2(), rctRect->getY2(), color);
}

/**
 * Name  : DrawRectangle
 * Desc  : Parametreden gelen (x1,y1)-(x2,y2) koordinatlari arasina
 *         dikdortgen ceker. 'a ihtiyac duymaz.
 * Input : (int)x1
 *         (int)y1
 *         (int)x2
 *         (int)y2
 *         (unsigned char)color
 */
void DrawRectangle(int x1, int y1, int x2, int y2, unsigned char color)
{
    int x, y;

    // Yatay cizgiler
    if(x1 < x2)
    {
        for(x = x1; x <= x2; x++)
        {
            Plot(x, y1, color);
            Plot(x, y2, color);
        }
    }
    else
    {
        for(x = x2; x <= x1; x++)
        {
            Plot(x, y1, color);
            Plot(x, y2, color);
        }
    }

    // Dikey Cizgiler
    if(y1 < y2)
    {
        for(y = y1; y <= y2; y++)
        {
            Plot(x1, y, color);
            Plot(x2, y, color);
        }
    }
    else
    {
        for(y = y2; y <= y1; y++)
        {
            Plot(x1, y, color);
            Plot(x2, y, color);
        }
    }
}

/**
 * Name  : DrawRectangle
 * Desc  : Overloaded DrawRectangle fonksiyonu. (x1,y1) ve (x2,y2) yerine
 *         POINT2D sinifindan iki degisken kullanilir.
 * Input : (POINT2D *)p2dPoint1
 *         (POINT2D *)p2dPoint2
 *         (unsigned char)color
 */
void DrawRectangle(POINT2D *p2dPoint1, POINT2D *p2dPoint2, unsigned char color)
{
    DrawRectangle(p2dPoint1->getX(), p2dPoint1->getY(), p2dPoint2->getX(), p2dPoint2->getY(), color);
}

/**
 * Name  : DrawRectangle
 * Desc  : Overloaded DrawRectangle fonksiyonu. (x1,y1) ve (x2,y2) yerine
 *         RECT sinifindan bir degisken kullanilir.
 * Input : (RECT *)rctRect
 *         (unsigned char)color
 */
void DrawRectangle(RECT *rctRect, unsigned char color)
{
    DrawRectangle(rctRect->getX1(), rctRect->getY1(), rctRect->getX2(), rctRect->getY2(), color);
}

/**
 * Name  : DrawCircle
 * Desc  : Parametreden gelen (x,y) koordinatlarindan itibaren r
 *         yaricapli cember cizer. Bresenham algoritmasi kullanir.
 *         'a ihtiyac duymaz.
 * Input : (int)x
 *         (int)y
 *         (int)r
 *         (unsigned char)color
 */
void DrawCircle(int cx, int cy, int r, unsigned char color)
{
    int x, y, a;

    // Ilk yariyi ciz
    x = r;
    y = 0;
    a = 0;
    while(x >= y)
    {
        Plot(cx + x, cy + y, color);
        Plot(cx + x, cy - y, color);
        Plot(cx - x, cy + y, color);
        Plot(cx - x, cy - y, color);
        y++;
        a += y;
        if(a > x)
        {
            x--;
            a -= x;
        }
    }

    // Ikinci yariyi ciz
    x = 0;
    y = r;
    a = 0;
    while(y >= x)
    {
        Plot(cx + x, cy + y, color);
        Plot(cx + x, cy - y, color);
        Plot(cx - x, cy + y, color);
        Plot(cx - x, cy - y, color);
        x++;
        a += x;
        if(a > y)
        {
            y--;
            a -= y;
        }
    }
}

/**
 * Name  : DrawCircle
 * Desc  : Overloaded DrawCircle fonksiyonu. (x1,y1) yerine POINT2D
 *         sinifindan bir degisken kullanilir.
 * Input : (POINT2D *)p2dPoint
 *         (int)r
 *         (unsigned char)color
 */
void DrawCircle(POINT2D *p2dPoint, int r, unsigned char color)
{
    DrawCircle(p2dPoint->getX(), p2dPoint->getY(), r, color);
}

/**
 * Name  : FillRectangle
 * Desc  : Parametreden gelen (x1,y1)-(x2,y2) koordinatlari arasina
 *         ici dolu dikdortgen ceker. 'a ihtiyac duymaz.
 * Input : (int)x1
 *         (int)y1
 *         (int)x2
 *         (int)y2
 *         (unsigned char)color
 */
void FillRectangle(int x1, int y1, int x2, int y2, unsigned char color)
{
    int x, y;
    if(y1 < y2)
    {
        for(y = y1; y <= y2; y++)
        {
            if(x1 < x2)
            {
                for(x = x1; x <= x2; x++)
                    Plot(x, y, color);
            }
            else
            {
                for(x = x2; x <= x1; x++)
                    Plot(x, y, color);
            }
        }
    }
    else
    {
        for(y = y2; y <= y1; y++)
        {
            if(x1 < x2)
            {
                for(x = x1; x <= x2; x++)
                    Plot(x, y, color);
            }
            else
            {
                for(x = x2; x <= x1; x++)
                    Plot(x, y, color);
            }
        }
    }
}

/**
 * Name  : FillRectangle
 * Desc  : Overloaded FillRectangle fonksiyonu. (x1,y1) ve (x2,y2) yerine
 *         POINT2D sinifindan iki degisken kullanilir.
 * Input : (POINT2D *)p2dPoint1
 *         (POINT2D *)p2dPoint2
 *         (unsigned char)color
 */
void FillRectangle(POINT2D *p2dPoint1, POINT2D *p2dPoint2, unsigned char color)
{
    FillRectangle(p2dPoint1->getX(), p2dPoint1->getY(), p2dPoint2->getX(), p2dPoint2->getY(), color);
}

/**
 * Name  : FillRectangle
 * Desc  : Overloaded FillRectangle fonksiyonu. (x1,y1) ve (x2,y2) yerine
 *         RECT sinifindan bir degisken kullanilir.
 * Input : (RECT *)rctRect
 *         (unsigned char)color
 */
void FillRectangle(RECT *rctRect, unsigned char color)
{
    FillRectangle(rctRect->getX1(), rctRect->getY1(), rctRect->getX2(), rctRect->getY2(), color);
}

/**
 * Name  : FillCircle
 * Desc  : Parametreden gelen (x,y) koordinatlarindan itibaren r
 *         yaricapli daire cizer. Bresenham algoritmasi kullanir.
 *         'a ihtiyac duymaz.
 * Input : (int)x
 *         (int)y
 *         (int)r
 *         (unsigned char)color
 */
void FillCircle(int cx, int cy, int r, unsigned char color)
{
    int x, y, i, a;

    // Ilk yariyi ciz
    x = r;
    y = 0;
    a = 0;
    while(x >= y)
    {
        for(i = cx - x; i <= cx + x; i++)
        {
            Plot(i, cy + y, color);
            Plot(i, cy - y, color);
        }
        y++;
        a += y;
        if(a > x)
        {
            x--;
            a -= x;
        }
    }

    // Ikinci yariyi ciz
    x = 0;
    y = r;
    a = 0;
    while(y >= x)
    {
        for(i = cx - x; i <= cx + x; i++)
        {
            Plot(i, cy + y, color);
            Plot(i, cy - y, color);
        }
        x++;
        a += x;
        if(a > y)
        {
            y--;
            a -= y;
        }
    }
}

/**
 * Name  : FillCircle
 * Desc  : Overloaded FillCircle fonksiyonu. (x1,y1) yerine POINT2D
 *         sinifindan bir degisken kullanilir.
 * Input : (POINT2D *)p2dPoint
 *         (int)r
 *         (unsigned char)color
 */
void FillCircle(POINT2D *p2dPoint, int r, unsigned char color)
{
    FillCircle(p2dPoint->getX(), p2dPoint->getY(), r, color);
}[/code]

Benimle irtibata gemek isteyenler iin e-mail adresim;
[url = mailto:skate@glance.ws]skate <at> glance <dot> ws[/url]

[b]Emir Akaydn
Skate / Glance[/b]