widgets.h

/*
    OpenGUI - Drawing & Windowing library

    Copyright (C) 1996,2004  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
    declarations for widgets

  $Id: widgets.h,v 1.18 2005/01/31 08:44:59 majo Exp $

  $Log: widgets.h,v $
  Revision 1.18  2005/01/31 08:44:59  majo
  doxy, aliases

  Revision 1.17  2005/01/31 07:46:30  majo
  fgx + pointbutton&checkbutton rename

  Revision 1.15  2005/01/03 07:47:19  majo
  xmas, gradient, lrmi

  Revision 1.14  2004/11/05 07:59:25  majo
  update FGEditBox

  Revision 1.13  2004/09/29 10:32:05  majo
  stabilized TabPages

  Revision 1.12.2.1  2004/09/07 11:41:09  majo
  verzia 5.0.0 alpha1
  new containers for Windows & Controls

  Revision 1.12  2004/05/30 11:52:55  majo
  dox

  Revision 1.11  2004/04/16 08:58:19  majo
  added FGRadioGroup::SetUserData(void *)

  Revision 1.10  2004/03/24 20:06:54  majo

  WIN32 compiling

  Revision 1.9  2004/03/24 18:44:43  majo
  update FGColorPicker dox

  Revision 1.8  2004/03/24 17:13:58  majo
  added FGXColor
  added FGColorPicker

  Revision 1.7  2004/03/17 21:19:12  majo
  added FGColor, FGImage

  Revision 1.6  2004/02/23 20:08:01  majo
  all classes are with prefix FG* on now
  polygon functions uses FGPointArray from now
  class GuiEvent is renamed to FGEvent
  some by parameters overloaded methods was removed (class FGWindow)
  many other small changes

  Revision 1.5  2004/02/12 17:52:11  majo
  *

  Revision 1.4  2004/02/10 16:18:59  majo
  fixed compile warnings

  Revision 1.3  2004/02/10 16:16:53  majo
  added method: bool FGFileDialog::TestForOvervrite(void)

  Revision 1.2  2004/01/28 18:08:58  majo
  header file cleanups - widgets.h no more include fastgl.h

  Revision 1.1.1.1  2004/01/22 16:25:08  majo
  initial release

*/

//
//  WIDGETS.CC      20.11.1998
//

#ifndef _WIDGETS_H_
#define _WIDGETS_H_

#include <sys/stat.h>
#include <string.h>

#ifdef __WATCOMC__
#ifdef __DOS__
#include <direct.h>
#else
#include <dirent.h>
#endif // dos
#elif !defined(_MSC_VER)
#include <dirent.h>
#endif // watcom

#ifdef __BORLANDC__
#include <dir.h>
#endif

#ifdef _MSC_VER
#include <direct.h>
#include "mydirent.h"
#endif

#ifdef __BORLANDC__
#pragma option push -b
#pragma option push -a4
#endif

#ifdef FG_NAMESPACE
namespace fgl {
#endif

const unsigned FDIALOG_OPEN = 1;
const unsigned FDIALOG_SAVE = 2;
const unsigned FDIALOG_MODAL = 4;
const unsigned FDIALOG_SAVEDIR = 8;
const unsigned FDIALOG_MULTISELECT = 16;

struct mydirent
{
    struct dirent item;
    bool        type;   // 0 for dir, 1 for file
    bool        selected;
    mydirent() { memset(this, 0, sizeof(*this)); }
};

class FGFileDialog : public FGConnector
{
    public:
        enum    { name_width=200, max_pathlen=512 };
    private:
        char    path[max_pathlen];
        char    tmppath[max_pathlen];
        char    filename[max_pathlen];
        char    *filter;
        int     mode;
        int     files,fls,dirs;
        int     maxfiles;
        FileDialogCallBack fileselect2;
        void    reload(void);
        FGWindow    *wnd;
        FGEditBox *nameEBox;
        struct  mydirent *filebuffer, *unused;
        int     param;
        FGListBox *list;
        FGListBox *list2;
        FGPushButton *ok, *cancel, *mkdir, *home, *updir;
        int     mdir;
//      int     num_of_selected;

        int     Selected();
        void    Refresh(char *);
        bool    SelectFile(void);
        void    _init(char *dir, char *flt, char *namewnd, int m, int ink, int paper);

        static  void InputName(CallBack);
        static  void Mkdir(CallBack);
        static  void Ok(CallBack);
        static  void Updir(CallBack);
        static  void Home(CallBack);
        static  void myproc(FGEvent *p);
        static  void drawone(int flag, FGWindow *wnd,int x,int y,void *str,int index);
        static  void drawone2(int flag, FGWindow *wnd,int x,int y,void *str,int index);
        static  char delimiter[2];
    protected:
    public:
        FGFileDialog(FileDialogCallBack filesel, char *dir=0, char *flt=0, char *namewnd="File Dialog", int m=FDIALOG_OPEN, int ink=0, int paper=PM);
        virtual ~FGFileDialog()
        {
            delete [] filebuffer;
            if (wnd) /* if (wnd->GetStatus() & WEXIST) */ delete wnd;
        }
        char*   FGAPI GetDir(void) { return path; }
        char*   FGAPI GetName(void) { return filename; }
        void FGAPI BuildFullPathname(char *buffer);
        void FGAPI BuildRelativePathname(char *buffer);
        void    FGAPI SetDir(char *d) { strcpy(path, d); reload(); }
        void    FGAPI SetFilter(char *f) { filter=f; reload(); }
        void    FGAPI SetMode(int m) { mode=m; }
        bool TestForOverwrite(void);
};

class FGTextEditor : public FGConnector
{
    public:
        enum    { FGMAX_LINE=32768, FGMAX_LINESIZE=512 };
    private:
        class FGLINE
        {
            public:
                unsigned size;              /* amount of memory allocated */
                unsigned char *text;         /* the characters */
        };

        class FGBUFFER
        {
            public:
            char name[256];              /* name of the file */
            char buffer[FGMAX_LINESIZE];   /* name of the file */
            int  posx, posy;
            int  line;                      /* cursor position within the line */
            int  lines;                  // all lines
            int  flags;                  /* flags about the buffer state */
            int  top;                    /* top line on the screen */
            int  ovr;
            int  hscroll;                /* offset when screen is scrolled sideways */
            int  sel_line1;               /* line that the selection began at */
            int  sel_pos1;                /* selection offset within the line */
            int  sel_line2;               /* offset in lines from sel_line to cursor */
            int  sel_pos2;                /* selection offset within the line */
            FGBUFFER()
            {
                memset(this,0,sizeof(*this));
            }
        };

    protected:
        FGWindow *Text_EditorPtr;
        FGWindow *OptionsPtr;
        FGWindow *String_SearchPtr;
        int lfonly, font_save;
        FGBUFFER buf;
        FGLINE text[FGMAX_LINE];
        char s[1028];
        int WX, WY;
        char srch_str[33];
        int last_found;
        int _font;
        int TABSIZE;
        int nodraw,inblock,ronly;
        int X, Y, W, H;
        FGTextEditor **self;
//
        void FGAPI file(void);
        int  FGAPI _memcmp(unsigned char *from, unsigned char *co, unsigned kolko, unsigned l);
        int  FGAPI Find(int from, int count, int size);
        void FGAPI Clear(void);
        void FGAPI _goto(void);
        static void SearchProc(FGEvent *p);
        void FGAPI search(void);
        static void SetFont(CallBack);
        static void OptionsProc(FGEvent *p);
        static void file_proc(CallBack);
        void FGAPI options(void);
        static char* FGAPI terminate(char *s);
        FGLINE* FGAPI create_line(char *s, int at);
        void FGAPI Init(void);
        void FGAPI SaveAsBuffer2(void);
        void FGAPI OpenBuffer2(void);
        static void OpenBuffer1(char *s, FGFileDialog *);
        static void SaveAsBuffer1(char *s, FGFileDialog *);
        void FGAPI ShowCursor(int trigger);
        void FGAPI ShowLine(int scr, char *s);
        int  FGAPI isempty(char *s);
        void FGAPI CKey(int k);
        void FGAPI Key(int k);
        void FGAPI SaveChanges(void);
        static void Text_EditorProc(FGEvent *p);
        void FGAPI Open(char *s);
        void FGAPI Destruct(void);
    public:
        FGTextEditor(FGTextEditor **e=0, char *arg="Untitled", int font=FONT0816, int ink=CGRAY3, int paper=CBLACK, int flags = WSTANDARD|WMENU|WSTATUSBAR|WSIZEABLE|WNOTIFY|WMINIMIZE|WUSELAST|WNOPICTO);
        virtual ~FGTextEditor();
        void FGAPI ShowBuffer(int top=0);
        void FGAPI NewBuffer(void);
        void FGAPI OpenBuffer(char *s);
        void FGAPI ReopenBuffer(void);
        void FGAPI SaveBuffer(void);
        void FGAPI SaveAsBuffer(char *s);
        void FGAPI Close(void);
        void FGAPI Goto(int);
        void FGAPI ReadOnlyMode(void) { ronly = 1; Text_EditorPtr->ResetChange(); };
        void FGAPI SetFocus(void) { Text_EditorPtr->WindowFocus(); }
        int  FGAPI AppendLine(char *str);
};

class FGColorDialog : public FGConnector
{
        FGWindow    *wnd;
        ColorDialogCallBack fnc;
        int         curr;
        unsigned    color;
        FGSlideBarV *sl1, *sl2, *sl3;
        int     cd_r, cd_g, cd_b;

        static unsigned int custom_colors[256];
        void FGAPI FocusTo(int a);
        static void CSliderFnc(CallBack cb);
        static void SetColorsProc(FGEvent *p);
        void UpdatePalette(void);
    protected:
    public:
        virtual ~FGColorDialog()
        {
            if (wnd) /*if (wnd->GetStatus() & WEXIST)*/ delete wnd;
        }
        FGColorDialog(char *capture, ColorDialogCallBack f, FGPixel bgc=PM);
        static int FGAPI Import(char *name);
        static int FGAPI Export(char *name);
        unsigned int* FGAPI GetColors(void)
        {
            return custom_colors;
        }
};

const unsigned FONT_DIALOG_FIXED = 1;
const unsigned FONT_DIALOG_VARIABLE = 2;
const unsigned FONT_DIALOG_ALL = (FONT_DIALOG_FIXED | FONT_DIALOG_VARIABLE);

class FGFontDialog : public FGConnector
{
        FGWindow    *wnd;
        FontDialogCallBack userfnc;
        int     curr;
        FGListBox *lb;
        static void SetFontProc(FGEvent *p);
        void ShowFont(void);
    public:
        FGFontDialog(FontDialogCallBack f, int which=FONT_DIALOG_ALL, char *capture="Font selection dialog", FGPixel bgc=PM);
        virtual ~FGFontDialog()
        {
        }
};

class FGUpDown
{
        FGPushButton *up, *down;
        FGEditBox *eb;
        float step;
        static void handler1(CallBack);
        static void handler2(CallBack);

    public:
        FGUpDown(FGEditBox *eb, float _step);
        void Disable(void)
        {
            up->Disable();
            down->Disable();
            eb->Disable();
        }
        void Enable(void)
        {
            up->Enable();
            down->Enable();
            eb->Enable();
        }
};

class FGWidgetContainer
{
    protected:
        void *ptr;

    public:
        FGWidgetContainer();
        ~FGWidgetContainer();
        void DisableContainer(void);
        void EnableContainer(void);
        void AddToContainer(FGControl *);
        void SetUserData(void* val);

};

class FGRadioGroup : public FGWidgetContainer
{
    protected:
        FGButtonGroup*      grp;
        unsigned            id;
        int*                value;
        int                 current;
        int                 count;
        void                (*userfnc)(FGControl* ,int);

        static void callback(CallBack cb)
        {
            FGRadioGroup* _THIS = (FGRadioGroup *)cb->GetPrivateData();
            _THIS->current = cb->GetId() - _THIS->id;
            if (_THIS->value) *_THIS->value = _THIS->current;
            if (_THIS->userfnc)
                _THIS->userfnc(cb, _THIS->current);
        }
    public:
        FGRadioGroup(int x, int y, char *names[], int *init_value, void (*cb)(FGControl* ,int), FGWindow* w, int step=20);
        virtual ~FGRadioGroup()
        {
            if (grp) delete grp;
            grp = 0;
        }
        void ChangeItem(int* new_value);
};

class FGRadioGroupVertical : public FGRadioGroup
{
        FGControl* DrawOne(int x, int y, int offset, char* name, int key, FGWindow* w, ControlCall cb)
        {
            return w->AddRadioButton(x, y+offset, name, key, 0, cb);
        }
    public:
        FGRadioGroupVertical(int x, int y, char *names[], int keys[], int *init_value, void (*cb)(FGControl* ,int), FGWindow* w, int step=20)
         : FGRadioGroup(x,y,names,init_value,cb,w,step)
         {
             FGControl *c;
             for(int i=0; i<count; i++)
             {
                 c = DrawOne(x, y, i*step, names[i], keys[i], w, callback);
                 if (i==0) id = c->GetId();
                 c->SetPrivateData((void *)this);
                 grp->AddToGroup(c, init_value ? i == *init_value : 0);
                 AddToContainer(c);
             }
         }
};

class FGRadioGroupHorizontal : public FGRadioGroup
{
        FGControl* DrawOne(int x, int y, int offset, char* name, int key, FGWindow* w, ControlCall cb)
        {
            return w->AddRadioButton(x+offset, y, name, key, 0, cb);
        }
    public:
        FGRadioGroupHorizontal(int x, int y, char *names[], int keys[], int *init_value, void (*cb)(FGControl* ,int), FGWindow* w, int step)
        : FGRadioGroup(x,y,names,init_value,cb,w,step)
        {
            FGControl *c;
            for(int i=0; i<count; i++)
            {
                c = DrawOne(x, y, i*step, names[i], keys[i], w, callback);
                if (i==0) id = c->GetId();
                c->SetPrivateData((void *)this);
                grp->AddToGroup(c, init_value ? i == *init_value : 0);
                AddToContainer(c);
            }
        }
};

class FGColorPicker
{
        FGWindow*   wnd;
        FGColor*    base_color;
        FGColor     the_color;

        FGControl*  ctrl_sat;
        FGControl*  ctrl_lum;
        FGControl*  ctrl_hue;
        FGControl*  ctrl_r;
        FGControl*  ctrl_g;
        FGControl*  ctrl_b;

        int         m_saturation;
        int         m_luminance;
        int         m_hue;

        int         m_r;
        int         m_g;
        int         m_b;

        static void PickerProc(FGEvent* e);
        void DrawColorCircle(void);
        static void Ok(CallBack cb)
        {
            FGColorPicker *_THIS = (FGColorPicker *)cb->GetOwner()->GetUserData();
            * (_THIS->base_color) = _THIS->the_color;
            cb->Close(cb);
        }
        static void DrawColorHSV(CallBack cb)
        {
            FGColorPicker *_THIS = (FGColorPicker *)cb->GetOwner()->GetUserData();
            _THIS->the_color.SetHLS(_THIS->m_hue, _THIS->m_luminance/100., _THIS->m_saturation/100.);
            _THIS->DrawColor();
        }
        static void DrawColorRGB(CallBack cb)
        {
            FGColorPicker *_THIS = (FGColorPicker *)cb->GetOwner()->GetUserData();
            _THIS->the_color.SetRGB(_THIS->m_r, _THIS->m_g, _THIS->m_b);
            _THIS->DrawColor();
        }
        void SetState(FGColor& c)
        {
            the_color = c;
            m_saturation = int(the_color.GetSaturation()*100.);
            m_luminance = int(the_color.GetLuminance()*100.);
            m_hue = int(the_color.GetHue());
            m_r = the_color.GetRed();
            m_g = the_color.GetGreen();
            m_b = the_color.GetBlue();
            DrawColor();
        }
        void DrawColor(void);
        void Box(int x, int y, FGColor paper);
    public:
        FGColorPicker(FGColor* _base_color);
        ~FGColorPicker()
        {
            delete wnd;
            wnd = 0;
        }
};

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

#ifdef FG_NAMESPACE
}
#endif

#endif

---