fastgl.h

/*
    OpenGUI - Drawing & Windowing library

    Copyright (C) 1996,2005  Marian Krivos

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    nezmar@atlas.sk

    fastgl.h   - declarations of many objects for FastGL

  $Id: fastgl.h,v 1.62 2005/02/09 10:23:45 majo Exp $
*/

#ifndef __WINDOW_H
#define __WINDOW_H

#include "fgcolor.h"
#include "base.h"
#include <tinycfg.h>

#include <list>     // for window and control lists.

#ifdef FG_NAMESPACE
namespace fgl {
#endif

/* HJH modification: protect compiler options for structure alignment and enum
 * size if the compiler is Borland C++ */
#ifdef __BORLANDC__
#pragma option push -b
#pragma option push -a4
#endif

enum
{
    BNORMAL = 7,
    BMASK = BNORMAL,
    BPUSHED = 3,
    BDISABLED = 5
};

#define FGFONT_TITLE    FONTSYS
#define FGFONT_MENU     FONTSYSLIGHT
#define FGFONT_BUTTON   FONTSYSLIGHT


#define IM          CScheme->window_fore // CBLACK standard menu fore & background colors

#define PM          CScheme->window_back

const unsigned  WFRAMED =       0x0001;
const unsigned  WTITLED =   0x0002;
const unsigned  WMODAL =        0x0004;
const unsigned  WNOTIFY =   0x0008;
const unsigned  WHIDEN =        0x0010;
const unsigned  WUNMOVED =  0x0020;
const unsigned  WMENU =     0x0040;
const unsigned  WNOPICTO =  0x0080;
const unsigned  WBITMAP =   0x0100;
const unsigned  WCLICKABLE =    0x0200;
const unsigned  WDIRTY =        0x0400;
const unsigned  WUSESELECTEDCONTROL =   0x0800;
const unsigned  WLOCKED =   0x1000;
const unsigned  WTRIGGER =  0x2000;
const unsigned  WLASTFOCUS =    0x4000;
const unsigned  WSIZEABLE = 0x8000;
const unsigned  WUSELAST =  0x00010000;
const unsigned  WMINIMIZE = 0x00020000;
const unsigned  WSTATUSBAR =    0x00040000;
//const unsigned    WEXIST =        0x00080000;
const unsigned  WGLCONTEXT =    0x00100000;
const unsigned  WNOTEBOOK = 0x00200000;
const unsigned  WBACK = 0x00400000;
const unsigned  WCENTRED =  0x00800000;
const unsigned  WESCAPE  =  0x01000000;
const unsigned  WALIGNED =  0x02000000;
const unsigned  WFASTMOVE = 0x04000000;
const unsigned  WTOP =  0x08000000;
const unsigned  WNOICON =   0x10000000;
const unsigned  WNODRAWFROMCONSTRUCTOR = 0x20000000;
const unsigned  WICONWINDOWTYPE =   0x40000000;
const unsigned  WMENUWINDOWTYPE =   0x80000000;
const unsigned  WSTANDARD = (WTITLED|WFRAMED);

const unsigned  APP_WINDOWDATABASE =        1;
const unsigned  APP_CFG =               2;
const unsigned  APP_ENABLEALTX =            4;
const unsigned  APP_MAGNIFIER =         8;
const unsigned  APP_ROOTWINDOW =            16;
const unsigned  APP_ENABLEEFECTS =      0x20;
const unsigned APP_ALL =                    0x1F;
const unsigned  APP_LOCALDIR =          0x80000000;

enum ENUM_OS { OSTYPE_LINUX=1, OSTYPE_MSDOS, OSTYPE_WIN32, OSTYPE_QNX };

enum MODAL_RETURN
{   mrNone   =  -1,
    mrOk     =  -2,
    mrCancel =  -3,
    mrYes    =  -2,
    mrNo     =  -3,
    mrAll    =  -4,
    mrIgnore =  -5,
    mrClose  =  -6,
    mrQuit   =  -7,
    mrRetry  =  -8,
    mrUnknown=  -9
};

class FGBaseGui;
class FGFileDialog;
class FGColorDialog;
class FGControl;
class FGWindow;
class FGMenuWindow;
class FGBitmap;
class FGEditBox;
class FGButtonGroup;
class FGListBox;
class FGPushButton  ;
class FGRadioButton;
class FGCheckBox;
class FGBaseMenuItem;
class FGPushButton;
class FGSlider;

#define FGCheckButton FGCheckBox
#define FGPointButton FGRadioButton
#define AddPointButton AddRadioButton
#define AddCheckButton AddCheckBox

extern "C" void IError(char *s, int flag);

struct FGColorScheme
{
    int     window_back;
    int     window_fore;
    int     active_title;
    int     inactive_title;
    int     wnd_bord1;
    int     wnd_bord2;
    int     wnd_bord3;
    int     statusbar;
    int     menu_back;
    int     menu_fore;
    int     menu_back_active;
    int     menu_fore_active;
    int     button_fore;
    int     button_back;
    int     button_fore_pushed;
    int     button_back_pushed;
    int     button_bord1;
    int     button_bord2;
    int     button_bord3;
    int     edit_background_active;
    int     edit_foreground;
    int     edit_border;
    int     edit_background;
    int     slider;
    int     menuwindow_back;
    int     menuwindow_fore;
    int     menuwindow_frame;
    int     pdmenu_back_active;
    int     pdmenu_fore_active;
    int     pdmenu_gray;
    int     pdmenu_color_of_frame;
    int     edit_fore_disable;
    int     notebook_active;
    int     slider_disable;
  public:
    FGColorScheme();
};

// subbitmap

extern FGColorScheme * CScheme;

typedef unsigned int (*TimerCall)(unsigned int);

#define TIMER_RESOLUTION    10  /* Experimentally determined */

class FGTimer : public FGConnector
{
    protected:
        friend void             HandleAlarm(int sig);
        int                     state;
        static void             StartTicks(void);
    public:
        FGTimer(unsigned int val, TimerCall cb)
        {
            state = SetTimer(val, cb);
        }
        FGTimer(TimerCall cb)
        {
            state = SetTimer(0, cb);
        }
        virtual ~FGTimer()
        {
            TimerQuit();
        }
        static int          SetTimer(unsigned int val, TimerCall cb);
        static unsigned int GetTicks(void);
        static void         Delay(unsigned int);
        static int          TimerInit(void);
        static void         TimerQuit(void);
};

class FGEvent
{
        friend class FGBaseGui;
        friend class FGApp;
        int     type;
        int     key;
        int     buttons, x, y, w, h;
        int     guiType;

        static  const char *eventName[];
    protected:
    public:
        FGWindow    *wnd;
        int     GetObjectType(void) const { return guiType; }
        FGControl *accel;
        FGEvent(int T=NOEVENT,  int K=0, int X=0, int Y=0, int W=0, int H=0)
            : type(T), key(K), x(X), y(Y), w(W), h(H), guiType(0), wnd(0), accel(0)
        {
        }
        int     GetKey(void)  const { return key;   }
        const char  *GetName(void)  const { if (type<0 || type>=LASTEVENT) return eventName[LASTEVENT]; return eventName[type]; }
        int     GetType(void)  const { return   type; }
        static const char* GetKeySymbolName(unsigned int code);
        int     GetButtons(void)  const {   return buttons; }
        int     GetX(void)  const { return  x; }
        int     GetY(void)  const { return  y; }
        int     GetW(void)  const { return  w; }
        int     GetH(void)  const { return  h; }
};

typedef void (*TimerProc)(int);
typedef void (*GuiHwnd)(FGEvent *);
typedef int (*MainHwnd)(FGEvent *);
typedef FGControl * CallBack;
typedef void (*FGListBoxCallBack)(int flag, FGWindow *wnd, int x, int y, void *data, int index);
typedef void (*FileDialogCallBack)(char * filename, FGFileDialog *);
typedef void (*ColorDialogCallBack)(FGPixel color);
typedef void (*FontDialogCallBack)(int f);

typedef void (*ControlCall)(FGControl *);


class FGBaseGui : public FGDrawBuffer
{
    protected:
        enum bs { EBOX_LOW=1, EBOX_UPR, BDOWN, BUP, WHIDE, WVISIBLE, WDEACTIVE, WACTIVE };

        int         x;
        int         y;
        void*       tab_page_controls;  // to test who is who
        void*       private_data;
        void*       user_data;
        unsigned    ink;
        unsigned    paper;
        bool        temporary_hidden;

        void        FGAPI Resize(int dx, int dy);
        void        frame(void);
        virtual     void DrawAsSelected(void) {}

        virtual     ~FGBaseGui();

    public:
        FGBaseGui(int   xs, int ys, int ws, int hs, const char *nm, ObjectType typ, FGPixel i, FGPixel p, long flag);

        unsigned    FGAPI GetInk(void)  const { return ink; }
        unsigned    FGAPI GetPaper(void)  const { return paper; }

        bool        IsVisible(void)  const  { return ! ( (status&WHIDEN) || temporary_hidden ); }
        void        SetColors(void)
        {
            set_colors(ink, paper);
        }
        int         GetX(void)  const { return  x; }
        int         GetY(void)  const { return  y; }
        virtual void OnFocus(void) { }
        virtual void OnLostFocus(void) { }
        void*       GetPrivateData(void) const { return private_data; }
        void        SetPrivateData(void* val) { private_data = val; }
        void*       GetUserData(void) const { return user_data; }
        void        SetUserData(void* val) { user_data = val; }
};

#ifndef __GNUC__
#pragma pack(1)
#endif

class FGBitmap : public FGDrawBuffer
{
    public:
        enum ReturnValues { IMAGE_OK, IMAGE_FILE_NOT_FOUND, IMAGE_UNKNOWN_FORMAT,
            IMAGE_UNSUPPORTED_FORMAT, IMAGE_FILE_WRITE_ERROR };
    private:
        struct RGB3
        {
            char bBlue;              /* Blue component of the color definition */
            char bGreen;             /* Green component of the color definition*/
            char bRed;               /* Red component of the color definition  */
        };
        struct RGB4
        {
            char bBlue;              /* Blue component of the color definition */
            char bGreen;             /* Green component of the color definition*/
            char bRed;               /* Red component of the color definition  */
            char fcOptions;          /* Reserved, must be zero                 */
        };
        struct bitmap_file_header
        {
            unsigned short  usType;
            unsigned short  cbSizeLow, cbSizeHigh;
            short           reserve1, reserve2;
        };
        struct bitmap_info
        {
            unsigned short  imageOffset;
            short           reserve;
        };
        struct bitmap_info_header1
        {
          unsigned long  size;
          unsigned short cx;               /* Bit-map width in pels                  */
          unsigned short cy;               /* Bit-map height in pels                 */
          unsigned short cPlanes;          /* Number of bit planes                   */
          unsigned short cBitCount;        /* Number of bits per pel within a plane  */
          unsigned long  ulCompression;    /* Compression scheme used to store the bitmap */
          unsigned long  cbImage;          /* Length of bit-map storage data in chars*/
          unsigned long  cxResolution;     /* x resolution of target device          */
          unsigned long  cyResolution;     /* y resolution of target device          */
          unsigned long  cclrUsed;         /* Number of color indices used           */
          unsigned long  cclrImportant;    /* Number of important color indices      */
        };
        struct bitmap_info_header2
        {
          unsigned long  size;
          unsigned long  cx;               /* Bit-map width in pels                  */
          unsigned long  cy;               /* Bit-map height in pels                 */
          unsigned short cPlanes;          /* Number of bit planes                   */
          unsigned short cBitCount;        /* Number of bits per pel within a plane  */
          unsigned long  ulCompression;    /* Compression scheme used to store the bitmap */
          unsigned long  cbImage;          /* Length of bit-map storage data in chars*/
          unsigned long  cxResolution;     /* x resolution of target device          */
          unsigned long  cyResolution;     /* y resolution of target device          */
          unsigned long  cclrUsed;         /* Number of color indices used           */
          unsigned long  cclrImportant;    /* Number of important color indices      */
        };

        void init(void);
        bitmap_file_header  bmfh;
        bitmap_info         bmi;
        union {
            bitmap_info_header1 bmih1;
            bitmap_info_header2 bmih2;
        } bmih;
        union {
            RGB3 rgb3[256];
            RGB4 rgb4[256];
        } rgb;

        int*        cUsedTable;
        int         format;             // IMAGE_*
        char        szLastError[256];   //debugging

        void        DoPalette(int);
        void        RGBtoBGR(unsigned char *buffer, unsigned char *input, int length);

        ReturnValues pcx(char *n, int& one, unsigned int& bits, unsigned int& c);
        ReturnValues bmp(char *n, int& one, unsigned int& bits, unsigned int& c);
        ReturnValues gif(char *n, int& one, unsigned int& bits, unsigned int& c);
        ReturnValues jpg(char *n, int& one, unsigned int& bits, unsigned int& c);
        ReturnValues png(char *n, int& one, unsigned int& bits, unsigned int& c);
        ReturnValues tga(char *n, int& one, unsigned int& bits, unsigned int& c);
        ReturnValues tiff(char *n, int& one, unsigned int& bits, unsigned int& c);

        int detect(const char *);

    public:
        enum ImageFormats { IMAGE_AUTO, IMAGE_BMP, IMAGE_GIF, IMAGE_TGA,
            IMAGE_PNG, IMAGE_JPG, IMAGE_TIF, IMAGE_PCX, IMAGE_UNKNOWN,
            IMAGE_LAST };
        FGBitmap();
        FGBitmap(const char *name);
        FGBitmap(FGDrawBuffer *);
        FGBitmap(int,int,FGPixel=CBLACK);
        FGBitmap(FGBitmap& old) : FGDrawBuffer(old)
        {
            bmfh = old.bmfh;
            bmi = old.bmi;
            bmih = old.bmih;
            rgb = old.rgb;
            cUsedTable = 0;
#ifdef INDEX_COLORS
            if (old.cUsedTable)
            {
                cUsedTable = new int[256];
                memcpy(cUsedTable, old.cUsedTable, sizeof(long)*256);
            }
#endif
        }
        virtual ~FGBitmap();
        ReturnValues BitmapSave(const char *, bool convert=false);
        ReturnValues JpegSave(const char *name);
        ReturnValues PngSave(const char *name);

        ReturnValues LoadImage(const char* name, int imagefmt = IMAGE_AUTO);
        ReturnValues SaveImage(const char* name, int imagefmt);

};
#ifndef __GNUC__
#pragma pack()
#endif

class FGButtonGroup
{
        friend class FGControl;
        FGControl*  curr;
        FGControl** array;
        int         count;
        int         size;
        int         type; // 1-check,point; 2-push; 0 undefined

    public:
        FGButtonGroup(int maximum=32)
        {
            size = maximum;
            count = type = 0;
            curr = 0;
            array = new FGControl *[size];
        }
        FGButtonGroup(const FGButtonGroup& old)
        {
            size = old.size;
            count = old.count;
            type = old.type;
            curr = old.curr;
            array = new FGControl *[size];
            for(int i=0; i<count; i++)
            {
                array[i] = old.array[i];
            }
        }
        ~FGButtonGroup() { delete [] array; }
        void FGAPI AddToGroup(FGControl *p, int activ = 0);
        void FGAPI Clear(void) { type = count = 0; curr = 0; }
        void FGAPI RefreshGroup(FGControl *c);
        void FGAPI DisableGroup(void);
        void FGAPI EnableGroup(void);
};


class FGControl :   public FGBaseGui
{
        friend class FGWindow;
        friend class FGMenuWindow;
        friend class FGButtonGroup;
        friend class FGApp;
        friend class FGControlContainer;

        ControlCall GetHandler(void)  const { return fnc; }

        void        RegisterToGroup(FGButtonGroup *g) { grp = g;}
        void        RefreshGroup(void);
        void        RemoveFromGroup(void) { grp = 0; }
        static      FGControl * ButtonFind(FGEvent *e,int   n);

    protected:
        int         local_id;
        int         key;            // hotkey
        ControlCall fnc;            // handler
        FGWindow*   owner;          // owner of this object
        FGButtonGroup *grp;         // if is group members
        char*       closure_name;

        FGControl(int   xs, int ys, int ws, int hs, const char *nm, ObjectType typ, int key, FGWindow *, ControlCall f, FGPixel p, FGPixel i, void* user_data);
        virtual     ~FGControl();

        int         GetXr(void);
        int         GetYr(void);
        void        Underscore(int xo, int yo, int c);
        void        update_owner(void);
        virtual     void ClickDown(void) {}
        virtual     void WheelSpin(int) {}  // -1 up, 1 down
        virtual     void GetHints(int& xx, int& yy, int& ww, int& hh) { xx = x; yy = y; ww = w; hh = h; }
        virtual     void DrawAsSelected(void);
        bool        IsYourTabPage(void);
        bool        IsSelected(void);
        virtual     FGPixel GetColorOfFrame(void) const { return CYELLOW; }
    public:
        virtual     void draw(void) {}
        virtual     void SetName(const char *s) { FGDrawBuffer::SetName(s); draw(); }
        virtual     void OnActivate(void) { RunSignal(); }
        void        SetKey(int k) { if (k>='a' && k<='z') k = toupper(k); key=k; draw(); }
        int         GetKey(void) const { return key; }
        void        Enable(void);
        void        Disable(void);
        virtual     void ClickUp(int a);  // if TRUE, so call handler
        void        SetTrigger(int a) { if (a) status |= WTRIGGER;  else    status &= (~WTRIGGER);  draw();}
        int         GetTrigger(void) const { return status&WTRIGGER?1:0;    }
        FGWindow        *GetOwner(void) const { return owner;   }
        int         GetLocalId() const { return local_id; }
        void        SetInk(FGPixel i) { state._ink = ink = i; draw(); }
        void        SetPaper(FGPixel p) { state._paper = paper = p; draw(); }
        void        SetFont(unsigned f) { set_font(f); draw(); }
        void        SetHandler(ControlCall w) { fnc=w; }
        void        AttachSignalName(const char* val);
        const char* GetSignalName() { return closure_name; }
        static      void Close(CallBack cb);
        static      void Quit(CallBack cb);

        virtual const double ToDouble() const { assert(!"Not implemented!!!"); return 0; }
        virtual const int ToInteger() const { assert(!"Not implemented!!!"); return 0; }
        virtual const char* ToString() const { assert(!"Not implemented!!!"); return 0; }
};

class FGLabel : public FGControl
{
    protected:
        void ClickUp(int a);
        unsigned int is_transparent:1;
        virtual ~FGLabel() { }
    public:
        // redraws object completely
        virtual void draw(void);
        FGLabel(int xs, int ys, const char *nm, int key, FGWindow *w, ControlCall f, unsigned i, unsigned p, void* user_data);
        void SetTransparent(void) { is_transparent = 1; draw(); }
};

class FGPanel : public FGControl
{
    protected:
        FGPixel ink1, ink2;
        virtual ~FGPanel() { }
    public:
        // redraws object completely
        virtual void draw(void);
        FGPanel(int xs, int ys, int ws, int hs, const char *nm, FGWindow *w, int i1, int i2, int p);
};

class FGImage : public FGControl
{
    protected:
        FGDrawBuffer*   bitmap;
        virtual ~FGImage() { }
    public:
        virtual void draw(void);
        FGImage(int xs, int ys, FGDrawBuffer* img, FGWindow *w);
};

class FGText : public FGControl
{
    protected:
        virtual ~FGText() { }
    public:
        FGText(int xs, int ys, const char *nm, FGWindow *w, int i, int p);
        // redraws object completely
        virtual void draw(void);
};

class FGPushButton : public FGControl {
        FGDrawBuffer*   icon;
        FGDrawBuffer*   pushed;
        FGDrawBuffer*   disabled;
        FGPixel         back_pushed;
        FGPixel         fore_pushed;
    protected:
        virtual ~FGPushButton() { }
    public:
        FGPushButton(int xs, int ys, int ws, int hs, const char *nm, int key, FGWindow *w, ControlCall f, void* user_data)
            : FGControl(xs, ys, ws, hs, nm, PUSHBUTTON, key, w, f, CWHITE, CBLACK, user_data)
            {
                set_font(FGFONT_BUTTON);
                icon = 0;
                pushed = disabled = 0;
                ink = CScheme->button_fore;
                paper = CScheme->button_back;
                back_pushed = CScheme->button_back_pushed;
                fore_pushed = CScheme->button_fore_pushed;
                draw();
            }
        FGPushButton(int xs, int ys, int key, FGWindow *w, FGDrawBuffer *bm, ControlCall f, void* user_data)
            : FGControl(xs, ys, bm->GetW() + 4, bm->GetH() + 4, "", PUSHBUTTON_IMAGE, key, w, f, CWHITE, CBLACK, user_data)
            {
                set_font(FONTSYS);
                icon = bm;
                pushed = disabled = 0;
                draw();
            }
        FGPushButton(int xs, int ys, int ws, int hs, const char* nm, int key, FGWindow *w, FGDrawBuffer *bm, ControlCall f, void* user_data)
            : FGControl(xs, ys, ws, hs, nm, PUSHBUTTON_IMAGE, key, w, f, CWHITE, CBLACK, user_data)
            {
                set_font(FONTSYS);
                icon = bm;
                pushed = disabled = 0;
                draw();
            }
        void ClickDown(void);
        void ClickUp(int);
        void Push(void);
        void Release(void);
        // redraws object completely
        virtual void draw(void);
        void AddBitmaps(FGDrawBuffer* push=0, FGDrawBuffer* disable=0)
        {
            pushed = push;
            disabled = disable;
            draw();
        }
};

class FGCheckBox :  public FGControl {
    protected:
        int     mask;
        int     * variable;
        virtual ~FGCheckBox() { }
    public:
        FGCheckBox(int m, int   xs, int ys, const char *nm, int key, FGWindow   *w, int fg, int bg, ControlCall f, int *var, void* user_data)
            : FGControl(xs, ys, strlen(nm)?strlen(nm)*8+20:16, 16, nm, CHECKBUTTON, key, w, f, bg, fg, user_data)
            {
                set_font(FGFONT_BUTTON);
                variable = var;
                mask = m;
                if (variable) SetTrigger(*variable&mask); else draw();
            }
        FGCheckBox(int  xs, int ys, const char *nm, int key, FGWindow   *w, int fg, int bg, ControlCall f, bool *var, void* user_data)
            : FGControl(xs, ys, strlen(nm)?strlen(nm)*8+20:16, 16, nm, CHECKBUTTON, key, w, f,bg,fg, user_data)
            {
                set_font(FGFONT_BUTTON);
                variable = (int *)var;
                mask = 1;
                if (variable) SetTrigger(*variable&mask); else draw();
            }
        void ChangeItem(int *v) { variable = v; SetTrigger(*variable&mask); draw(); }
        void ChangeItem(bool *v) { variable = (int *)v; SetTrigger(*variable&mask); draw(); }
        // redraws object completely
        virtual void draw(void);
        virtual const int ToInteger() const { return *variable; }
};

class FGRadioButton :   public FGControl {
    protected:
        int     mask;
        int     * variable;
        virtual ~FGRadioButton() { }
    public:
        FGRadioButton(int m, int xs, int ys, const char *nm, int key, FGWindow  *w, int fg, int bg, ControlCall f, int *var, void* user_data)
            : FGControl(xs, ys, strlen(nm)?strlen(nm)*8+20:16, 16, nm, POINTBUTTON, key, w, f,bg,fg,user_data)
            {
                set_font(FGFONT_BUTTON);
                variable = var;
                mask = m;
                if (variable) SetTrigger(*variable&mask); else draw();
            }
        FGRadioButton(int m, int xs, int ys, const char *nm, int key, FGWindow  *w, int fg, int bg, ControlCall f, bool *var, void* user_data)
            : FGControl(xs, ys, strlen(nm)?strlen(nm)*8+20:16, 16, nm, POINTBUTTON, key, w, f,bg,fg,user_data)
            {
                set_font(FGFONT_BUTTON);
                variable = (int *)var;
                mask = m;
                if (variable) SetTrigger(*variable&mask); else draw();
            }
        void ChangeItem(int *v) { variable = v; SetTrigger(*v&mask); draw(); }
        void ChangeItem(bool *v) { variable = (int *)v; SetTrigger(*variable&mask); draw(); }
        // redraws object completely
        virtual void draw(void);
        virtual const int ToInteger() const { return *variable; }
};

class FGTwoStateButton : public FGRadioButton
{
    protected:
        virtual ~FGTwoStateButton() { }
    public:
        FGTwoStateButton(int xs, int ys, int ws, int hs, const char *nm, int key, FGWindow *wnd, int *var, ControlCall f, void* user_data) :
            FGRadioButton(1, xs,ys,"", key, wnd, 0, 15, f, var, user_data)
        {
            Resize(ws-w, hs-h);
            SetName(nm); // ma v sebe draw
        }
        // redraws object completely
        virtual void draw(void);
};

class FGEditBox :   public FGControl
{
    public:
        static const int bufsize = 252;
    private:
        friend class FGUpDown;
        friend class FGWindow;

        enum dtype { EDIT_INT, EDIT_STRING, EDIT_DOUBLE};

        void init(void);
        void UpDown(double step)
        {
            if (data_type==EDIT_INT)
            {
                 *(int  *)ptr += int(step);
            }
            else if (data_type==EDIT_DOUBLE)
            {
                 *(double *)ptr += step;
            }
            TestRange();
        }
        void TestRange(void)
        {
            if (check_range==0) return;
            if (data_type==EDIT_INT)
            {
                int dato = *(int *)ptr;
                if (dato<min) *(int *)ptr = min;
                else if (dato>max) *(int *)ptr = max;
            }
            else if (data_type==EDIT_DOUBLE)
            {
                double dato = *(double *)ptr;
                if (dato<mind) *(double *)ptr = mind;
                else if (dato>maxd) *(double *)ptr = maxd;
            }
        }
        int inputproc(unsigned);
        void input(void);
        void FlushInput(bool reset=false)
        {
            if (isinput)                   // if input, force ESC
            {
                inputproc(reset ? ESC : CR);
            }
        }
        virtual void WheelSpin(int direction)
        {
            if (direction<0) UpDown(-1);
            else UpDown(1);
            draw();
            if (fnc)
                fnc(this);
        }

    protected:
        int     w1,w2,min,max;
        dtype   data_type;
        unsigned first:1,passwd:1,check_range:1,hex:1,caps:2,isinput:1;
        double  mind,maxd;
        void  * ptr;
        char    buf[bufsize];
        static  char clip[bufsize];
        static  int is_clip;
        int     pos, maxpos, iline, icol, offset, size;

        virtual void draw(bool cursor, bool first_time=false);
        virtual ~FGEditBox();

    public:
        // redraws object completely
        virtual void draw(void);
        const double ToDouble() const { if (data_type!=EDIT_DOUBLE) assert(!"Not a double type!!!"); return *(double*)ptr; }
        const int ToInteger() const { if (data_type!=EDIT_INT) assert(!"Not an integer type!!!"); return *(int*)ptr; }
        const char* ToString() const { if (data_type!=EDIT_STRING) assert(!"Not a string type!!!"); return (const char*)ptr; }
        void ClickUp(int state=1);
        void PasswdMode(int m) { passwd = m; draw(); }
        void HexMode(int m) { hex = m; draw(); }
        void CapsMode(int m);
        void ChangeItem(int *p)
        {
            assert(data_type==EDIT_INT);
            ptr = p;
            draw();
        }
        void ChangeItem(char *p)
        {
            assert(data_type==EDIT_STRING);
            ptr= p;
            draw();
        }
        void ChangeItem(double *p)
        {
            assert(data_type==EDIT_DOUBLE);
            ptr = p;
            draw();
        }
        void SetRange(double mi, double ma)
        {
            assert(data_type==EDIT_DOUBLE);
            mind = mi;
            maxd = ma;
            TestRange();
            draw();
        }
        void SetRange(int mi, int ma)
        {
            assert(data_type==EDIT_INT);
            min = mi;
            max = ma;
            TestRange();
            draw();
        }
        void SetSize(int ns)
        {
            pos = offset = 0;
            if(ns>0 && ns<bufsize)
            {
                size = ns;
                draw();
            }
        }
        void Disable(void);
        FGEditBox(int xs,   int ys, int ws1, int ws2, const char *nm, int   key, FGWindow *w,   int *pt, int ink, int paper, ControlCall f, int mn, int mx, int check, void* user_data);
        FGEditBox(int sz, int   xs, int ys, int ws1, int ws2, const char *nm,   int key, FGWindow   *w, char *pt, int ink, int paper, ControlCall f, void* user_data);
        FGEditBox(int xs,   int ys, int ws1, int ws2, const char *nm, int   key, FGWindow *w,   double *pt, int ink, int paper, ControlCall f, double mn, double mx, int check, void* user_data);
};

class FGProgressBar : public FGControl
{
    protected:
        int     steps, value;
        int     sirka;
        virtual ~FGProgressBar() { }
    public:
        void    draw(void);
        void    FGAPI setProgress(int a) { if (a>=0 && a<=steps) value = a; draw(); }
        int FGAPI progress(void) const { return value; }
        FGProgressBar(FGWindow *w, int xx, int yy, int ww, int hh, int s);
};

class FGBaseMenu : public   FGControl
{
    protected:
        virtual ~FGBaseMenu() { }
    public:
        // redraws object completely
        virtual void draw(void);
        void DrawAsSelected(void);
        virtual void ClickUp(int a);  // if TRUE, so call handler
        FGBaseMenu(const char *nm, int key, FGWindow *w, ControlCall f, int font, void* user_data);
        virtual     FGPixel GetColorOfFrame(void) const { return CYELLOW; }
};

class FGBaseMenuItem : public   FGControl
{
    protected:
        virtual ~FGBaseMenuItem() { }
    public:
        // redraws object completely
        virtual void draw(void);
        void DrawAsSelected(void);
        virtual void ClickUp(int a);  // if TRUE, so call handler
        FGBaseMenuItem(const char *nm, int key, FGMenuWindow *w, ControlCall f, int font, void* user_data);
        virtual     FGPixel GetColorOfFrame(void) const { return CScheme->pdmenu_color_of_frame; }
};

class FGSlider  : public FGControl
{
    protected:
        virtual void draw(void) {}
        int     minv,maxv,*val,steps,smer; // 0 je vodorovny, 1 zvysly
        void    frame(int,int,int,int,int f=0);
        virtual void ClickDown(void);
        virtual void WheelSpin(int direction)
        {
            if (direction<0) StepDown();
            else if (direction>0) StepUp();
        }
        void StepDown(void)
        {
            modify(*val-minv-steps);
        }
        void StepUp(void)
        {
            modify(*val-minv+steps);
        }
        virtual ~FGSlider() { }
    public:
        void    modify(int);
        void    redraw(void)
        {
            ControlCall tmp = fnc;
            fnc = 0;
            draw();
            fnc = tmp;
        }
        FGSlider(FGWindow *win, int xs, int ys, int ws, int hs, int minimal, int maximal, int s, int *v, ControlCall f, void* user_data) :
            FGControl(xs, ys, ws, hs, 0, SLIDEBAR, 0, win, f, CWHITE, CBLACK, user_data), minv(0), maxv(0)
        {
            if (minimal>maximal)
            {
                minv = maximal;
                maxv = minimal;
            }
            else
            {
                minv = minimal;
                maxv = maximal;
            }
            if (*v<minv)
                *v=minv;
            if (*v>maxv)
                *v=maxv;
            val  = v;
            steps= s;
            smer = h>w;
        }
        virtual const int ToInteger() const { return *val; }
};

class FGSlideBarH : public FGSlider
{
    protected:
        virtual ~FGSlideBarH() { }

    public:
        FGSlideBarH(int x, int y, int min, int max, int step, int *val, FGWindow *win, ControlCall f, void* user_data):
            FGSlider(win,x,y,(max-min)/step+16+12+38,16,min,max,step,val,0,user_data)
        {
            draw();
            fnc = f;
        }
        // redraws object completely
        virtual void draw(void);
};

class FGSlideBarV : public FGSlider
{
    protected:
        virtual ~FGSlideBarV() { }
    public:
        FGSlideBarV(int x, int y, int min, int max, int step, int *val, FGWindow *win, ControlCall f, void* user_data):
            FGSlider(win,x,y,16,(max-min)/step+16+12+38,min,max,step,val,0,user_data)
        {
            draw();
            fnc = f;
        }
        virtual void draw(void);
};

class FGControlContainer : public std::list<FGControl *>
{
        FGControl* default_control;
        const char* idstring;
        int width, ypos, flag;
    public:
        FGControlContainer(const FGControlContainer& old);
        FGControlContainer(const char *s, int y);
        ~FGControlContainer();

        const char  *GetString(void) { return idstring; }
        int         GetWidth(void) { return width; }
        int         GetY(void) { return ypos; }
        int         GetFlag(void) { return flag; }
        void        SetFlag(int f) { flag = f; }
        void        SetDefaultControl(FGControl* ctrl);
        FGControl*  GetDefaultControl(void);
        void        SetNextControl(void);
        void        SetPreviousControl(void);
        void        Rename(const char *);
};

typedef FGControlContainer::iterator FGControlIterator;

typedef std::list<FGControlContainer> FGControlBox;
typedef FGControlBox::iterator FGControlBoxIterator;

class FGWindow : public FGBaseGui
{
        friend  class FGControl;
        friend  class FGPanel;
        friend  class FGEditBox;
        friend  class FGBaseMenu;
        friend  class FGApp;

        FGControlBox ctrl_list;             // list of FGControlContainer(s)
        FGControlBoxIterator Buttony;       // for current buttons, labels ... etc.
        const char* current_tab_page;
        int         c_menupos;

        int         ctrl_counter;           // to generate proper local_id for controls
        unsigned    first_draw:1,
                    changed:1;              //

        int         xpos;                   // lineto x
        int         ypos;                   // lineto y

        void        (*handler)(FGEvent  *);
        FGControl   *call_handler; // set if need call handler (in translateevent)
        void        (*CallWindowHook)(int x, int y, int& nx, int& ny, int);

        // for locking dynamic (WindowMove(), WindowLine() ... )
        FGMutex     StateMutex;
        int         state_locked;
        static FGMutex WindowListMutex;

        FGPixel     statuscolor;
        FGEditBox   *ininput;
        int         icon_x, icon_y;
        FGWindow    **itself;
        FGWindow    *iconized;

        FGWindow(FGWindow **, FGPixel);     // root window
        virtual int iconize(int xs, int ys);
        int     FGAPI Rozporcuj(int X1, int Y1, int X2, int Y2, int *in, int *out);
        void    FGAPI Relocate(int xx, int yy);
        static  void FindNextFindow(void);
        FGEditBox* FGAPI FindNextControl(void);
        int     FGAPI TitleFind(FGEvent *e);
        void    FGAPI WindowUpdate(int dx, int dy, int all=0);
        void    FGAPI ResetActive(void)
        {
            call_handler = 0;
        }
        FGControl * FGAPI IsActive(void)
        {
            return call_handler;
        }
        int     FGAPI IsInInput(void) const { return !!ininput; }
        void    FGAPI SetInInput(FGEditBox *e)
        {
            ininput = e;
        }
        void    FGAPI WindowInputChar(unsigned c)
        {
            ininput->inputproc(c);
        }
        void    FGAPI WindowUpdateBlock(int x, int y, int w, int h);

        void    FGAPI SetNextTabPage(void);
        void    FGAPI DrawTabPages(void);
        bool    FGAPI ClickTabPage(int, int);
        void    FGAPI RelocateTabPage(int xx, int yy);

        void    FGAPI puts(const char *s) { while(*s) wputc(*s++);  }
        void    FGAPI wputc(int);
        void    FGAPI move(int x=0, int y=0) { wputc(-1); xpos=x; ypos=y; }
        int     FGAPI GetXM(int);
        int     FGAPI GetYM(void);
        FGControlContainer* GetBaseControls(void) { return & (*ctrl_list.begin()); }
    protected:
        FGDrawBuffer    *icon;

        virtual void    FGAPI RepaintBlock(int x,   int y, int w, int h);
        void    FGAPI init(void);
        void    FGAPI default_clipping(void);
        long    FGAPI WindowStatus(long status);
        virtual void WindowPiktograms(int x, int y);
        virtual void WindowDrawTitle(int color); // old virtual
    public:
        // redraws object completely
        virtual void draw(void);
        void    FGAPI SetDefaultControl(FGControl* ctrl)
        {
            Buttony->SetDefaultControl(ctrl);
        }
        void    SetNextControl(void)
        {
            Buttony->SetNextControl();
        }
        void    SetPreviousControl(void)
        {
            Buttony->SetPreviousControl();
        }
        FGControl* GetDefaultControl(void)
        {
            return Buttony->GetDefaultControl();
        }
        void    InstallWindowHook(void(*hook)(int, int, int&, int&, int))
        {
            CallWindowHook = hook;
        }
        void    SetActive(FGControl *c);
        void    RunHandler(void);
        static  void ShowAll(void);
        static  void FGAPI WindowVirtualRoot(int, int, int, int);

        void    StateLock(void)
        {
            StateMutex.Lock();
            state_locked++;
        }
        void    StateUnlock(void)
        {
            StateMutex.Unlock();
            state_locked--;
        }
        // the window notify interface
        void    FGAPI SetChange(void) { changed = 1; }
        void    FGAPI ResetChange(void) { changed = 0; }
        bool    FGAPI ShowNotify(void);
        void    AbsToWindowPosition(int& _x, int& _y) { _x -= x; _y -= y; }
        void    FGAPI SetIconPosition(int x, int y) { icon_x = x; icon_y = y; }
        int     FGAPI IsIconized(void) const { return !!(int)iconized; }
        int     FGAPI WindowIconize(void);
        int     FGAPI WindowIconize(int, int);
        void    FGAPI WindowAttachIcon(FGDrawBuffer *ico) { icon = ico; }

        FGControlBoxIterator GetCurrentControls(void) { return Buttony; }

        void    FGAPI WindowRepaint(int xr, int yr, int w, int h);
        void    FGAPI WindowRepaintUser(int xr, int yr, int w, int h);

        FGWindow(FGWindow **, int xs, int ys, int ws, int hs, const char *nm,   GuiHwnd=0, int i=IM, int p=PM, int flag=WTITLED|WFRAMED, void* user_data = UNDEFINED_USER_DATA);
        virtual ~FGWindow();
        bool    WindowClose(void);
        bool    FGAPI WindowFlushInput(void)
        {
            if (ininput)
            {
                WindowInputChar(CR);
                ininput = 0;
                return true;
            }
            return false;
        }

        FGPushButton*       AddPushButton(int xs, int ys, int ws, int hs, const char *nm, int key=0, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA);
        FGPushButton*       AddPushButton(int xs, int ys, int ws, int hs, const char *nm, int key, FGDrawBuffer *bm, ControlCall f, void* user_data = UNDEFINED_USER_DATA);
        FGPushButton*       AddPushButton(int xs, int ys, int key, FGDrawBuffer *bm, ControlCall f, void* user_data = UNDEFINED_USER_DATA);
        FGSlideBarH*        AddSlideBarH(int xs, int ys, int min, int max, int step, int *val, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA);
        FGSlideBarV*        AddSlideBarV(int xs, int ys, int min, int max, int step, int *val, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA);
        FGCheckBox*      AddCheckBox(int    xs, int ys, const char *nm, int key=0, int * variable=0, ControlCall=0, void* user_data = UNDEFINED_USER_DATA);
        FGCheckBox*      AddCheckBox(int    xs, int ys, const char *nm, int key, bool * variable, ControlCall=0, void* user_data = UNDEFINED_USER_DATA);
        FGRadioButton*      AddRadioButton(int  xs, int ys, const char *nm, int key=0, int * variable=0, ControlCall=0, void* user_data = UNDEFINED_USER_DATA);
        FGCheckBox*      AddCheckBoxMask(int mask, int xs, int ys,  const char *nm, int key=0, int * variable=0, ControlCall=0, void* user_data = UNDEFINED_USER_DATA);
        FGRadioButton*      AddRadioButtonMask(int mask, int xs, int ys,    const char *nm, int key=0, int * variable=0, ControlCall=0, void* user_data = UNDEFINED_USER_DATA);
        FGTwoStateButton*   AddTwoStateButton(int   xs, int ys, int w, int h, const char *nm, int key=0, int * variable=0, ControlCall=0, void* user_data = UNDEFINED_USER_DATA);
        FGEditBox*          AddEditBox(int  xs, int ys, int ws1, int ws2, const char *nm,   int key, int *p, ControlCall f, int min, int max, void* user_data = UNDEFINED_USER_DATA);
        FGEditBox*          AddEditBox(int  xs, int ys, int ws1, int ws2, const char *nm,   int key, int *p, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA);
        FGEditBox*          AddEditBox(int  xs, int ys, int ws1, int ws2, const char *nm,   int key, char *p, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA);
        FGEditBox*          AddEditBox(int sz, int  xs, int ys, int ws1, int ws2, const char *nm,   int key, char *p, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA);
        FGEditBox*          AddEditBox(int  xs, int ys, int ws1, int ws2, const char *nm,   int key, double *p, ControlCall f, double min, double max, void* user_data = UNDEFINED_USER_DATA);
        FGEditBox*          AddEditBox(int  xs, int ys, int ws1, int ws2, const char *nm,   int key, double *p, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA);
        FGBaseMenu*         AddBaseMenu(const char *nm, int key=0, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA);
        FGProgressBar*      AddProgressBar(int xs, int ys, int ws, int hs, int size);
        FGListBox*          AddListBox(int xs, int ys, int w, int h, int dropdown, FGListBoxCallBack drawone=0, void* userdata = 0);
        FGLabel*            AddLabel(int x, int y, const char *s, int key=0, ControlCall f=0, unsigned  i = UNDEFINED_COLOR, unsigned p = UNDEFINED_COLOR, void* user_data = UNDEFINED_USER_DATA);
        FGPanel*            AddPanel(int, int, int, int, const char *s=0, unsigned paper = UNDEFINED_COLOR, unsigned ink=CWHITED, unsigned ink2=CDARK);
        FGText*             AddText(int x, int y, const char *s, unsigned ink = UNDEFINED_COLOR, unsigned paper = UNDEFINED_COLOR);
        FGImage*            AddImage(int x, int y, FGDrawBuffer* img);

        void        FGAPI WindowText(int x, int y, const char *s, unsigned Ink = UNDEFINED_COLOR, unsigned Paper = UNDEFINED_COLOR);

        void        FGAPI WindowText(int x, int y, const char *s, FGFontProperty * f, unsigned color, unsigned bk);
        void        FGAPI WindowTextUTF8(int x, int y, const char *s, FGFontProperty * f, unsigned color, unsigned bk);
        void        FGAPI WindowTextUnicode(int x, int y, const unsigned short *s, FGFontProperty * f, unsigned color, unsigned bk);

        void        FGAPI WindowPanel(int, int, int, int, const char *s=0, int unsigned = CWHITED, unsigned ink2=CDARK);

        void        FGAPI WindowBox(int x, int y, int a, int b, unsigned color = UNDEFINED_COLOR);

        void        FGAPI WindowPixel(int x,    int y, unsigned color = UNDEFINED_COLOR);

        void        FGAPI WindowRect(int    x, int y, int a, int b, unsigned color = UNDEFINED_COLOR);

        void        FGAPI WindowPatternRect(int x, int y, int a, int b, FGPattern *);

        void        FGAPI WindowLine(int    x, int y, int a, int b, unsigned color = UNDEFINED_COLOR);
        void        FGAPI WindowPatternLine(int x, int y, int a, int b, FGPattern *p=&PatternDot);

        void        FGAPI WindowDrawCircle(int x, int y, int    r, unsigned color = UNDEFINED_COLOR);
        void        FGAPI WindowFillCircle(int x, int y, int    r, unsigned color = UNDEFINED_COLOR);

        void        FGAPI WindowDrawEllipse(int x, int y, int   rx, int ry, unsigned color = UNDEFINED_COLOR);
        void        FGAPI WindowFillEllipse(int x, int y, int   rx, int ry, unsigned color = UNDEFINED_COLOR);

        void        FGAPI WindowDrawArc(int x, int y, double ang1, double ang2, int r, unsigned color = UNDEFINED_COLOR);

        FGRect      FGAPI WindowFillPolygon(const FGPointArray& , unsigned col = UNDEFINED_COLOR);
        void        FGAPI WindowDrawPolygon(const FGPointArray&, unsigned col = UNDEFINED_COLOR);

        FGRect      FGAPI WindowFillTriangle(int x1, int y1, int x2, int y2, int x3, int y3, unsigned col = UNDEFINED_COLOR);

        void        FGAPI WindowSpline(FGPoint points[4], unsigned color = UNDEFINED_COLOR);

        void        FGAPI WindowScrollDown(int xx, int yy, int ww, int hh ,int about);
        void        FGAPI WindowScrollUp(int xx, int yy, int ww, int hh ,int about);
        void        FGAPI WindowScrollLeft(int xx, int yy, int ww, int hh ,int about);
        void        FGAPI WindowScrollRight(int xx, int yy, int ww, int hh ,int about);

        void        FGAPI WindowStatusBar(int, const char *s, int c=CBLACK);

        int         printf(const char * , ... );
        int         printf(int,int,const char *, ... );

        void        FGAPI SendEvent(int event, int key=0, int x=0, int y=0)
        {
            FGEvent e(event,key,x,y);
            SendToWindow(&e);
        }
        void        FGAPI SendEvent(int event, int x, int y, int ww, int hh)
        {
            FGEvent e(event,0,x,y,ww,hh);
            SendToWindow(&e);
        }
        void        FGAPI SendToWindow(FGEvent *p);

        void        FGAPI WindowLock(void) {    status|=WLOCKED; }
        void        FGAPI WindowUnLock(void);
        void        FGAPI WindowResize(int, int);
        void        FGAPI WindowMove(int,int);
        void        FGAPI WindowFocus(void);
        void        FGAPI WindowShape(int, int, int, int);
        void        FGAPI WindowPutBitmap(int x,    int y, int xs, int ys,  int w, int h, FGDrawBuffer *p);
        #define     WindowCopyFrom WindowPutBitmap
        void        FGAPI WindowGetBitmap(int x,    int y,  int xs, int ys, int w, int h, FGDrawBuffer *p);
        MODAL_RETURN FGAPI ShowModal(void);
        bool        FGAPI WindowSetWorkRect(int,int,int,int);

        void        FGAPI RedrawControls(void);
        void        FGAPI RemoveControls(void);
        void        FGAPI RemoveControls(FGControlBoxIterator iter);
        bool        FGAPI RemoveControl(FGControlBoxIterator iter, FGControl* ctrl);
        void        FGAPI RemoveControl(FGControl* ctrl);
        void        FGAPI DisableControls(void);
        void        FGAPI DisableControls(FGControlBoxIterator iter);
        void        FGAPI EnableControls(void);
        void        FGAPI EnableControls(FGControlBoxIterator iter);
        void        FGAPI SetInk(FGPixel i)
        {
            state._ink = ink = i;
        }
        void        FGAPI SetPaper(FGPixel p)
        {
            state._paper = paper = p;
        }
        void        FGAPI SetName(const char *s);
        bool        FGAPI AddTabPage(const char *name);
        const char* FGAPI GetCurrentTabPage(void)
        {
            return current_tab_page;
        }
        void FGAPI SetTabPage(const char *name);
        void FGAPI DeleteTabPages(void);
        void FGAPI DeleteTabPage(const char *name);
        int  GetNumberOfTabPages(void);
        // the virtual callback interface

        virtual void OnKeyPress(int akey) { }
        virtual void OnMouseMove(int x, int y) { }
        virtual void OnClick(int x, int y) { }
        virtual void OnDoubleClick(int x, int y) { }
        virtual void OnMiddleButton(int, int) { }
        virtual void OnContextPopup(int x, int y) { }
        virtual void OnWheel(int x, int y, int delta) { }
        virtual void OnPaint(void) { }
        virtual void OnStartDrag(int , int, int) {}
        virtual void OnEndDrag(int ,int, int, int, int) {}
        virtual void OnMove(int dx, int dy) { }
        virtual void OnResize(int dx, int dy) { }
        virtual void OnIconize(void) { }
        virtual void OnAccelerator(FGControl *which) { }
        virtual void OnTabSwitch(const char *) { }
};

typedef std::list<FGWindow *> FGWindowContainer;
typedef FGWindowContainer::iterator FGWindowIterator;
typedef FGWindowContainer::reverse_iterator FGWindowRIterator;

class FGApp : public FGConnector
{
        static const int pathsize = 256;
        friend class FGWindow;
        int mouseflag;
        static  int     fulldrag;
        static FGWindowContainer Windows;
        static FGWindow* Current;
        int XX, YY;
        bool locked;
        static FGInputDevice *user_input_drv;
        static int  __fg_fps, __fg_fps_total;
        int         mousefirst;
        static int  current_mouse_x;
        static int  current_mouse_y;
        int         current_mouse_buttons;
        int         old_mouse_x;
        int         old_mouse_y;
        int         old_mouse_buttons;
        int         window_drag_in_action;
        int         button_reached;
        int         window_resize_in_action;
        int         window_resize_width;
        int         window_resize_height;
        int         tmp_event;
        int         drag_width, drag_height;
        int         clickx, clicky, clickw, clickh;
        int         selection_steps;

        FGControl *idcb;
        FGControl *idc2;
        FGWindow *drag_window;
        static int repeat_status, repeat_delay1, repeat_delay2;
        FGEvent *hold_event;
        static bool is_ctrl, is_alt, is_shift;

        enum { MAX_EVENT_QUEQUE=32  }; // numbers of events to app per one user event

        void blue_rect(int x, int y, int w, int h);
        void blue_rect2(int x, int y, int w, int h);
        void AutoRepeatStart(FGControl *);
        void AutoRepeatDo(void);
        void AutoRepeatEnd(void);
        void DoubleClick(int& event);

        static  FGEvent queque[MAX_EVENT_QUEQUE];
        static  void (*DelayProc)(void);
        static  void (*OnEverySecond)(int);
        static  int quequeIndex;
        static  FGWindow *Root;
        static  MainHwnd appHandler;
        static  unsigned long ticks;
        static  int ctrl_break;
        static  int startXdrag;
        static  int startYdrag;
        static  int endXdrag;
        static  int endYdrag;
        static void (*DragShape)(int , int ,int , int );
        static FGPixel __p4[8];
        static FGPattern __patt;
        void CallDelayProc(void)
        {
            if (DelayProc)
            {
                DelayProc();
                return;
            }
            else if (OnIdle() == true)
            {
                return ;
            }
            // wait 10 msec if nothing to do
            delay(10);
        }
        void GetUserEvent(FGEvent& e, int);
        void TranslateUserEvent(FGEvent& e);
        void ButtonClick(FGEvent& e, FGControl* ctrl);
        void Timer(void);
        int isgmkey(int k);

    protected:
        static void SetCurrentWindow(FGWindow* novy) { Current = novy; }
        static void RemoveIterator(FGWindow* wnd);
        static FGWindowIterator GetIterator(FGWindow* Colise);
        static FGWindowRIterator GetRIterator(FGWindow* Colise);
        static  FGWindow* WindowFind(FGEvent *e);
        static FGWindow* GetLastWindow(void)
        {
            return *(Windows.rbegin());
        }
        static FGWindow* WindowFind(int idw);
        static void FGAPI intersect(FGWindow* This, int, int, int, int);
        static FGAPI int _over(int, int, int, int, int xx, int yy, int ww, int hh);
        static FGWindow* OverSprite(FGWindowRIterator This, FGWindowRIterator _od, int  x, int y, int w, int h);
        static FGWindow* FGAPI OdkryteOkno(FGWindowRIterator This, FGWindowRIterator pokial, int x, int y, int w, int h);
        static void FGAPI DestroyWindow(void);
        static int NumberOfWindow(void)
        {
            return Windows.size();
        }
        static void AddWindowToList(FGWindow* wnd, int where);

    public:
        static FGWindow* GetCurrentWindow(void);
        int  RemoveMousePointer(void);
        void ShowMousePointer(void);
        int get_key(void);
        static  const FGMouseCursor *__fg_cursor;
        static  int     flags;
        static  int     video;
        static  int     background;
        static  int     Argc;
        static  char    **Argv;
        static  char    * name;
        static  char    *homedir;
        static  char    currdir[pathsize];
        static  int     ttf_support;
        void SetDelayProc(void (*fnc)(void))
        {
            DelayProc = fnc;
        }
        void UpdateMousePointer(void);
        static void SaveScreen(void);
        static void DisableCtrlBreak(void)
        {
            ctrl_break ^= 1;
        }
        static void SetWindowMoveStyle(int a)
        {
            fulldrag = a;
        }
        FGApp(int m, int& argc, char **& argv, int bck, int appFlags=APP_ENABLEALTX);
        virtual ~FGApp();
        static  void FGAPI SendToApp(FGEvent    *x);
        void    FGAPI Run(MainHwnd hwnd=0);
        void    FGAPI FGYield(void);
        static  void AppDone(void)
        {
            FGEvent e(QUITEVENT);
            SendToApp(&e);
        }
        static  void AppClose(void)
        {
            FGEvent e(CLOSEEVENT);
            SendToApp(&e);
        }
        void    SetTimerProc(TimerProc p, int t=1000)
        {
            OnEverySecond = p;
            ticks = t;
        }
        static FGWindow * GetRootWindow(void)
        {
            return Root;
        }
        MODAL_RETURN FGAPI RunModal(FGWindow *which);
        static int  GetMouseX(void)
        {
            return current_mouse_x;
        }
        static int  GetMouseY(void)
        {
            return current_mouse_y;
        }
        static bool IsShift(void);
        static bool IsCtrl(void);
        static bool IsAlt(void);

        static void set_mmx(void);
        static void reset_mmx(void);
        static int test_mmx(void);

        static void SetCaption(char *new_name);

        const FGMouseCursor * CursorLoad(const FGMouseCursor *cur);

        int EnableBuffering(int mode);
        int Flip(void);
        void DisableBuffering(void);

        ENUM_OS GetOS(void);

        static void GetDragVector(int &x, int &y, int &w, int &h);
        static void SetDragShape(void(*a)(int,int,int,int)=0);
        static void SetRepeatDelay(int  c1, int c2);

        static void SetInputDevice(FGInputDevice *idev) { user_input_drv = idev; }
        void ResetInputDevice(void) { user_input_drv = 0; }

        void LockInput(void) { locked = true; }
        void UnlockInput(void) { locked = false; }

        // Object-oriented API via overloaded methods
        virtual void OnKeyPress(int) { }
        virtual void OnMouseMove(int , int) { }
        virtual void OnClick(int, int) { }
        virtual void OnDoubleClick(int, int) { }
        virtual void OnMiddleButton(int, int) { }
        virtual void OnContextPopup(int, int) { }
        virtual void OnWheel(int x, int y, int delta) { }
        virtual void OnStartDrag(int , int, int) {}
        virtual void OnEndDrag(int ,int, int, int, int) {}
        virtual void OnCursorOut(int)
        {
        }
        virtual bool OnIdle(void)
        {
            return false;   // returns true if do some work
        }
        virtual void OnTimer(int secs)
        {
        }
        virtual void OnTabSwitch(const char *) { }
};

extern FGApp *cApp;

class FGMenuWindow : public FGWindow
{
        friend class FGWindow;
        friend class FGBaseMenuItem;

        int     offset;

        static GuiHwnd Proc;
        static FGMenuWindow *   CurrentMenu;
        static void MenuWindowHandler(FGEvent *p);

        void _initmw(GuiHwnd proc)
        {
            offset = 0;
            Proc = proc;
            CurrentMenu = this;
            set_font(FGFONT_MENU);
        }
        int GetXM(void) const
        {
            return 4;
        }
        int GetYM(int a)
        {
            return (offset+=a,offset-a);
        }
    public:
        FGMenuWindow(int x, int y, int w,   int h, GuiHwnd proc=0, void* user_data = UNDEFINED_USER_DATA ):
            FGWindow(0,x,y,w,h,"", MenuWindowHandler, CScheme->menuwindow_fore, CScheme->menuwindow_back,WFRAMED|WNOPICTO|WMENUWINDOWTYPE|WNODRAWFROMCONSTRUCTOR|WUSESELECTEDCONTROL, user_data)
        {
            draw();
            _initmw(proc);
        }
        FGMenuWindow(int w, int h, GuiHwnd proc=0, void* user_data = UNDEFINED_USER_DATA );

        virtual ~FGMenuWindow()
        {
            CurrentMenu = 0;
        }

        virtual void draw(void);

        FGBaseMenuItem* AddMenu(char *nm,   int key=0, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA );
        FGLabel*        AddLabel(char *nm, int key=0, ControlCall f=0, unsigned i = UNDEFINED_COLOR, unsigned p = UNDEFINED_COLOR, void* user_data = UNDEFINED_USER_DATA );
        FGText*         AddText(const char *s, unsigned ink = UNDEFINED_COLOR, unsigned paper = UNDEFINED_COLOR, void* user_data = UNDEFINED_USER_DATA );
        FGCheckBox*     AddCheckBox(char *nm, int key=0, int * variable=0, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA );
        FGCheckBox*     AddCheckBox(char *nm, int key=0, bool * variable=0, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA );
        FGRadioButton*  AddRadioButton(char *nm, int key=0, int * variable=0, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA );
        FGRadioButton*  AddRadioButton(char *nm, int key=0, bool * variable=0, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA );
        FGCheckBox*     AddCheckBoxMask(int, char *nm, int key=0, int * variable=0, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA );
        FGRadioButton*  AddRadioButtonMask(int, char *nm, int key=0, int * variable=0, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA );
        FGEditBox*      AddEditBox(int  ws1, int ws2, char *nm, int key, int *p,ControlCall f, int min, int max, void* user_data = UNDEFINED_USER_DATA );
        FGEditBox*      AddEditBox(int  ws1, int ws2, char *nm, int key, int *p, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA );
        FGEditBox*      AddEditBox(int  ws1, int ws2, char *nm, int key, char *p, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA );
        FGEditBox*      AddEditBox(int sz, int  ws1, int ws2, char *nm, int key, char *p, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA );
        FGEditBox*      AddEditBox(int  ws1, int ws2, char *nm, int key, double *p, ControlCall f, double min, double max, void* user_data = UNDEFINED_USER_DATA );
        FGEditBox*      AddEditBox(int  ws1, int ws2, char *nm, int key, double *p, ControlCall f=0, void* user_data = UNDEFINED_USER_DATA );
        void            Separator(void);
};

class FGDialog
{
        FGWindow* wnd;
        FGControl* ctrl;
        unsigned width;

    public:
        FGDialog(char* format, ...);
        FGDialog(unsigned ink, unsigned paper, const char* title, char* format, ...);
        ~FGDialog()
        {
            delete wnd;
        }
        FGWindow* GetWindow(void) { return wnd; }
        MODAL_RETURN ShowOk(void);
        MODAL_RETURN ShowYesNo(void);
        MODAL_RETURN ShowRetryIgnoreCancel(void);
};

//---------------------------------------------------------------------------

unsigned int CalculateCRC(unsigned StartCRC, void *Addr, unsigned Size);

extern ConfigInterface *cCfg;

//---------------------------------------------------------------------------

typedef void ( * XUIEventHandler )(CallBack cb, void* user_data);
typedef void ( * XUIEnterHandlerText )(CallBack cb, const char* text, void* user_data);
typedef void ( * XUIEnterHandlerInteger )(CallBack cb, const int integer, void* user_data);
typedef void ( * XUIEnterHandlerDouble )(CallBack cb, const double integer, void* user_data);
typedef void ( * XUIWindowHandler )(FGEvent* event, void* user_data);
struct FGClosure
{
    static const int name_size = 48;
    enum { ON_CLICK, ON_INTEGER_CHANGE, ON_DOUBLE_CHANGE, ON_TEXT_CHANGE, HANDLER };
    char event_name[name_size];
    union {
        XUIEventHandler function;
        XUIWindowHandler handler;
        XUIEnterHandlerText text_handler;
        XUIEnterHandlerInteger int_handler;
        XUIEnterHandlerDouble dbl_handler;
        };
    void* user_data;
    int type;

    FGClosure(const char* n, XUIEventHandler func = 0, void* user_data = 0);
    FGClosure(const char* n, XUIEnterHandlerText func = 0, void* user_data = 0);
    FGClosure(const char* n, XUIEnterHandlerInteger func = 0, void* user_data = 0);
    FGClosure(const char* n, XUIEnterHandlerDouble func = 0, void* user_data = 0);
    FGClosure(const char* n, XUIWindowHandler hwnd = 0, void* user_data = 0);
};

typedef std::list<FGClosure> ClosureList;
typedef ClosureList::iterator ClosureIterator;

void RegisterOnClickSignal(const char* signal_name, XUIEventHandler fnc, void* user_data = 0);
void RegisterOnEnterSignal(const char* signal_name, XUIEnterHandlerText fnc, void* user_data = 0);
void RegisterOnEnterSignal(const char* signal_name, XUIEnterHandlerInteger fnc, void* user_data = 0);
void RegisterOnEnterSignal(const char* signal_name, XUIEnterHandlerDouble fnc, void* user_data = 0);
void RegisterControl(FGControl* ctrl, XUIEventHandler fnc, void* user_data);

bool ChangeSignalData(const char* signal_name, void* func, void* user_data);
bool DeregisterSignal(const char* signal_name, void* func);
bool DeregisterSignal(const char* signal_name, void* func, void* data);

void RegisterWindowHandler(const char* handler_name, XUIWindowHandler fnc, void* user_data = 0);

void CallClosure(const char* signal_name, CallBack cb);
void CallClosure(const char* signal_name, CallBack cb, int value);
void CallClosure(const char* signal_name, FGEvent* e);
void CallClosureDebug();

void GetTempName(char* buffer, int size);

//---------------------------------------------------------------------------

#ifdef FG_NAMESPACE
}
#endif

#ifdef __BORLANDC__
#pragma option pop /* pop -a switch */
#pragma option pop /* pop -b */
#endif

#endif

---