gui.h

Go to the documentation of this file.

//& *** (c) 2006-2011 The HPGCC3 Team ***
//& Claudio Lapilli
//& Ingo Blank
//&
//& This file is licensed under the terms and conditions of the
//& HPGCC3 license that is included with the source distribution.
//& *** (c) 2006-2011 The HPGCC3 Team ***


#ifndef GUI_H_
#define GUI_H_

#ifndef GGL_H_
#include <ggl.h>
#endif

#ifndef GSTRING_H_
#include <gstring.h>
#endif
#ifndef RESOURCES_H_
#include <resources.h>
#endif


// PHYSICAL SCREEN SIZE
#define SCREEN_W 160
#define SCREEN_H 80
// LOGICAL (VISIBLE) SCREEN SIZE
#define USERSCREEN_W 131
#define USERSCREEN_H 80

// STYLE DEFINITION CONSTANTS
#define CAPTIONHEIGHT 7
#define SOFTMENUHEIGHT 6
#define SCROLLBARWIDTH 3
#define BORDERWIDTH 1 

#define CURSORBLINKSPEED 40000


class gForm;
class gSoftMenu;
class gApplication;
class gControl;

// CLASS DEFINITIONS

struct gUpdate {
        int clipx,clipy,clipx2,clipy2; // CLIPPING RECTANGLE WITHIN THAT SURFACE
};


struct gEvent {
        unsigned int Type;      // MESSAGE
        unsigned int Arg;       // OPTIONAL ARGUMENT
        unsigned int Data;      // OPTIONAL DATA POINTER/INTEGER/ETC.
        
};

typedef BOOL (*gEvHandler)(gEvent *e,gControl *_This);


struct gEvHandlerList {
        unsigned int Type;
        unsigned int Value;
        unsigned int Mask;
        gEvHandler Action;
        gEvHandlerList *Next;
};




enum gGraphicCommands {
        GCMD_END=0,
        GCMD_SETCLIP,
        GCMD_DRAWICON,
        GCMD_VLINE,
        GCMD_HLINE,
        GCMD_RECT
};

enum gColors {
        GWHITE=0,
        GGRAY1=0x11111111,
        GGRAY2=0x22222222,
        GGRAY3=0x33333333,
        GGRAY4=0x44444444,
        GGRAY5=0x55555555,
        GGRAY6=0x66666666,
        GGRAY7=0x77777777,
        GGRAY8=0x88888888,
        GGRAY9=0x99999999,
        GGRAY10=0xaaaaaaaa,
        GGRAY11=0xbbbbbbbb,
        GGRAY12=0xcccccccc,
        GGRAY13=0xdddddddd,
        GGRAY14=0xeeeeeeee,
        GBLACK=0xffffffff,
};

enum gAppFlags {
        GAPP_EXIT=1,
        GAPP_NEXTFORM,
        GAPP_PREVFORM
};

enum gEvTypes {
        GEVENT_NONE=0,
        GEVENT_KEYB=1,
        GEVENT_IDLE,
        GEVENT_GUI,
        GEVENT_TMR,
        GEVENT_SD,
        GEVENT_SERIAL
};

enum gEvGui {
        GEVGUI_GETFOCUS=1,
        GEVGUI_LOSEFOCUS,
        GEVGUI_FORMCREATE,
        GEVGUI_FORMOPEN,
        GEVGUI_FORMCLOSE,
        GEVGUI_FORMEXIT,
        GEVGUI_NEWFORM,
        GEVGUI_CHANGEFORM,
        GEVGUI_QUERYCLOSE,
        GEVGUI_BEFORECHANGE,
        GEVGUI_AFTERCHANGE,
        GEVGUI_BEFORECOLLAPSE,
        GEVGUI_AFTERCOLLAPSE,
        GEVGUI_BEFOREEXPAND,
        GEVGUI_AFTEREXPAND,
        GEVGUI_BEFORECHECK,
        GEVGUI_AFTERCHECK,
        GEVGUI_ENTER
};

enum gSystemFonts {
        FONT_MINI=-6,
        FONT_TINY=5,
        FONT_SYSTEM6=6,
        FONT_SYSTEM7=7,
        FONT_SYSTEM8=8
};

struct gFontData {
        unsigned int Signature;
        unsigned int BitmapWidth;
        unsigned int BitmapHeight;
        unsigned int BitmapSize;
        unsigned int WidthMap[256];
        unsigned int Bitmap[1]; 
};

class gFont {
public:
        gFontData *FontData;
        int MaxWidth;
        int TextWidth(char *Text);
        inline int CharWidth(char T) {  return ((int)(FontData->WidthMap[(int)T]))>>16; }
        inline int TextHeight() { return FontData->BitmapHeight; };
        gFont() {};
        gFont(int height);
        gFont(gFontData *data);
};



// GENERIC GUI CONTROL
class gControl {

        virtual void vTable();
        
public:
        gglsurface drawsurf;
        int posx,posy;                  // POSITION OF THE CONTROL IN PARENT COORDINATES
        int sizex,sizey;                // SIZE OF THE CONTROL (AND THE DRAWING SURFACE)
        int clipx,clipy,clipx2,clipy2;  // CURRENT CLIPPING AREA
        int ncx,ncy,ncwidth,ncheight;   // NON-CLIENT AREA VIEW POSITION
        int viewx,viewy;                                        // SCROLL POSITION OF CLIENT AREA VIEW
        int vieww,viewh;
        BOOL scrollh,scrollv;
        
        gEvHandler *RedrawBk;   // REDRAW BACKGROUND, CAN BE OVERRIDEN WITHOUT DECLARING NEW CLASS
        unsigned int *CtlData;  // ARBITRARY DATA - CONTROL-DEPENDENT
        gControl *FirstChild,*LastChild;
        gControl *Next,*Prev;
        gControl *Parent,*UpdateFirst;
        gEvHandlerList *Events;
        
        // PURE VIRTUAL MEMBERS
        virtual void Update(gUpdate *);
        virtual BOOL AcceptFocus() { return FALSE; }
        
        // IMPURE VIRTUAL MEMBERS, PASS EVENTS TO HANDLERS & PROPAGATE TO CHILDS
        virtual BOOL DefaultEvent(gEvent *);
        virtual BOOL DoEvent(gEvent *);
        virtual BOOL DoEventExclusive(gEvent *);
        
        
        // MANAGEMENT MEMBERS
        void AddChild(gControl&);
        void RemoveChild(gControl&);
        void AddHandler(unsigned int Type,unsigned int Mask,unsigned int Arg,gEvHandler Function);
        void RemoveHandler(unsigned int Type,unsigned int Mask=0,unsigned int Arg=0);
        gEvHandler GetHandler(unsigned int Type,unsigned int Mask=0,unsigned int Arg=0);
        void InsufMemoryError();
        gApplication *GetApplication();
        
        
        
        // GRAPHIC ROUTINES TO DRAW IN THE CLIENT AREA WITH CLIPPING
        
        // CLIENT AREA MANAGEMENT
        virtual void DrawVScrollBar();                  // REDRAW SCROLL BAR
        virtual void DrawHScrollBar();                  // REDRAW SCROLL BAR
        virtual void SetViewPos(int x,int y) {};        // SCROLL VIEWPORT TO GIVEN POSITION
        virtual void SetViewX(int x);                   // SCROLL ONLY HORIZONTALLY
        virtual void SetViewY(int y);                   // SCROLL ONLY VERTICALLY
        virtual void EnsureVisible(int x1,int y1,int x2,int y2) {};
        
        
        
        
        // GRAPHIC MANAGEMENT
        virtual void SetVisible(BOOL visible) {};
        virtual BOOL IsVisible() {return TRUE; }
        virtual BOOL Resize(int width,int height);
        virtual void Move(int x,int y);
        virtual void ParentToClient(int &x,int &y);
        virtual void ClientToParent(int &x,int &y);
        virtual void ClipToView(gUpdate *u);
        virtual void Invalidate(gUpdate *u,gControl *Sender=NULL);
        virtual void Invalidate(gControl *Sender=NULL);
        
        inline static unsigned int SolidColor(int c) { return ggl_mkcolor(c); }

        // CUSTOM DRAW BACKGROUND
        virtual void RedrawBackground(gUpdate *);

        // FLAT COLOR ROUTINES
        virtual void HLine(int y,int x1,int x2,int pattern);
        virtual void VLine(int x,int y1,int y2,int pattern);
        virtual void Line(int x,int y,int x2,int y2,int pattern);
        virtual void Rect(int x1,int y1,int x2,int y2,int pattern);
        virtual void RectP(int x1,int y1,int x2,int y2,int *Pattern);
        virtual void Plot(int x1,int y1,int color);
        virtual int GetPixel(int x1,int y1);
        
        // TEXT OUTPUT ROUTINES
        virtual void DrawText(int x,int y,char *Text,gFont *Font,int color);
        virtual void DrawTextBk(int x,int y,char *Text,gFont *Font,int color,int BkColor);
        
        // BITMAPS AND ICON ROUTINES
        virtual void DrawIcon(int x,int y,unsigned int *IconData,int width,int height);
        virtual void DrawIconPartial(int x,int y,unsigned int *IconData,int iconwidth,int iconx,int icony,int width,int height);

        // CLIPPING ROUTINES
        virtual void SetClipRegion(int x1,int y1,int x2,int y2);
        virtual void ClearClipRegion();
        
        // CONSTRUCTORS/DESTRUCTORS
        gControl();
        gControl(gControl& _Parent);
        virtual ~gControl();
};


// INTERNAL DATA STRUCTURE FOR OPEN LOOPS
struct gLoopData {
        int BackupFlags;
        int BackupResult;
        gControl *Idleptr;
};


// IMPLEMENT THE HARDWARE LAYER AND MAIN EVENT PUMP


class gApplication: public gControl {
        virtual void vTable();
public:
        unsigned int *screenbuffer;
        int contrastlevel;
        int invx,invy,invx2,invy2;              // INVALID AREA
        volatile unsigned int RunLoopFlags;
        int RunResult;
        gControl *CurrentForm;
        gString Clipboard;
        
        int Run(gForm *Main=NULL);
        int RunInternalLoop();
        gLoopData *StartOpenLoop(gForm *main=NULL);
        BOOL RunOpenLoopOnce(gLoopData *v);
        int EndOpenLoop(gLoopData *v);
        void CloseAllAndExit();
        void Terminate(int result);
        BOOL QueryTerminate();
        void Update(gUpdate *u);
        void Update();
        virtual void Invalidate(gControl *Sender=NULL);
        virtual void Invalidate(gUpdate *u,gControl *Sender=NULL);
        void OpenNewForm(gControl *ptr);
        void CloseForm(gControl *ptr);
        void SetCurrentForm(gControl *ptr);
        gApplication();
        virtual ~gApplication();
        
};


enum gFormStyles {
        
        S_TOPCAPTION = 1,
        S_BOTTOMCAPTION = 2,
        S_SINGLESTATUSLINE = 4,
        S_DOUBLESTATUSLINE = 8,
        S_TOPSTATUS = 16,
        S_FORCEVSCROLL = 32,
        S_FORCEHSCROLL = 64,
        S_FORMBORDER = 128,
        S_SHADE = 256,
        // 512 NOT USED FOR COMPATIBILITY W/OTHER CONTROLS STYLES
        S_SINGLESOFTMENU = 1024,
        S_EXSOFTMENU = 2048,
        S_FULLSCREEN = 4096
        
};

enum gStateFlags {
        STAT_VISIBLE=1,
        STAT_FOCUS=2
};

class gForm : public gControl {
        virtual void vTable();

public: 
        int StateFlags;
        gSoftMenu *SoftMenu;
        char *Caption;
        gFormStyles StyleFlags;
        gControl *Focus;

        virtual void Update(gUpdate *u);
        virtual void Initialize(unsigned int *Data);
        virtual void Destroy(unsigned int *Data);

        virtual void RedrawBackground(gUpdate *u);
        virtual void RedrawNonClient();
        virtual BOOL DoEvent(gEvent *);
        virtual BOOL DefaultEvent(gEvent *);
        
        void AddSoftMenu(gSoftMenu *menu);
        void HideSoftMenu();
        void ShowSoftMenu();
        
        gForm(gControl& Parent,const char *_Caption,gFormStyles _Style);                 // FULL SCREEN FORM
        gForm(gControl& Parent,const char *_Caption,gFormStyles _Style,int clientwidth,int clientheight);       // FULL SCREEN FORM W/ARBITRARY CLIENT AREA SIZE
        gForm(gControl& Parent,const char *_Caption,gFormStyles _Style,int x,int y,int width,int height); // WINDOWED FORM
        gForm(gControl& Parent,const char *_Caption,gFormStyles _Style,int x,int y,int width,int height,int clientwidth,int clientheight); // WINDOWED FORM
        virtual ~gForm();
};

struct gSoftMenuItem {
        int State;
        char Name[8];           // MAX 7 CHARS + NULL TERMINATOR
        gEvHandler Action;
};

class gSoftMenu : public gControl {
        virtual void vTable();
public:
        int Style;
        int Visible;
        int Numitems,ShowItem;
        gSoftMenuItem *Items;
        
        virtual void SetVisible(BOOL _Visible);
        virtual BOOL IsVisible();
        virtual void DrawMenuLabel(gControl *P,int x,int y,int item);
        virtual void Update(gUpdate *u);
        virtual BOOL DefaultEvent(gEvent *);
        virtual void Invalidate(gControl *Sender=NULL);
        
        void ClearItems();
        void AddItem(const char *Name,gEvHandler Function);
        void AddItemList(struct gSoftMenuItem *List, int numitems);
        void ChangeItem(int number,const char *Name,gEvHandler Function);
        
        virtual void NextPage();
        virtual void PrevPage();
        
        
        gSoftMenu(gControl& Parent,int Style);
        gSoftMenu(gControl& Parent,int Style,struct gSoftMenuItem *List, int numitems);
        
        virtual ~gSoftMenu();
};


class gStaticText : public gControl {
        virtual void vTable();

public:
        char *Text;
        gFont Font;
        int Color;

        virtual void Update(gUpdate *u);
        void SetText(const char *text);
        const char *GetText();
        gStaticText(gControl& Parent,int x, int y,const char *Text,gFont *f,int color);
        virtual ~gStaticText();
};

class gStaticTextWrap : public gStaticText 
{
        virtual void vTable();
public:
        int maxwidth;
        
        virtual void Update(gUpdate *);
        virtual void SetText(const char *);
        void RecalcSize();
        static void CalcSize(const char *_text,gFont *font,int maxwidth,int *width,int *height);
        gStaticTextWrap(gControl& _Parent,int x,int y, int width, const char *_Text,gFont *f,int color);
        
        virtual ~gStaticTextWrap();
};




enum gStyles {
        S_UNCHECKED=0,
        S_CHECK = 1,
        S_DOT,
        S_PLUS,
        S_MINUS,
        S_UNKNOWN,
        S_SELECTED=8,
        S_MULTILINE=16, // CONTROL CAN CONTAIN MORE THAN ONE LINE OF TEXT
        S_HSCROLLBAR=32, // CONTROL WILL DISPLAY A HORIZONTAL SCROLL BAR
        S_VSCROLLBAR=64, // CONTROL WILL DISPLAY A VERTICAL SCROLL BAR
        S_HASBORDER=128,  // CONTROL HAS A BORDER AROUND IT
        S_FOCUSED=512

};


class gCheckBox : public gControl {
        virtual void vTable();

public:
        int TypeFlags;
        int State;
        
        virtual BOOL AcceptFocus() { return TRUE; }
        virtual void Update(gUpdate *u);
        void SetState(int state);
        int GetState();
        virtual void DrawCheck(int state);
        virtual BOOL DefaultEvent(gEvent *);
        
        gCheckBox(gControl& Parent,int x, int y, gStyles Type=S_CHECK);         // STANDARD CHECKBOX
        virtual ~gCheckBox();
};




enum gEditStates {
        ES_SHOWCURSOR =1,
        ES_CURSORBLINK=2,
        ES_RDONLY=4,
        ES_SINGLELINE=8,
        ES_LIMITEDIT=16,
        ES_OVERWRITE=32
};


#define TRIM_BEGIN      0
#define TRIM_END        1



class gEditBox : public gControl {
        virtual void vTable();

public:
        gString Text;
        int CursorPos,CursorLine;
        int SelStart,SelEnd;
        gFont Font;
        int Color,BkColor,SelColor;
        int DispLines;
        int TotalLines;
        int ViewLine;
        int EditMin,EditMax;
        unsigned int State;
        int Cursorx,Cursory,Targetx;
        gglsurface cursorbk;
        tmr_t lastblink;
        int InputMode;
        int StyleFlags;

        virtual BOOL AcceptFocus() { return TRUE; }
        virtual void Update(gUpdate *u);
        virtual BOOL DefaultEvent(gEvent *);
        
        // DRAWING FUNCTIONS
        void RedrawFrame();
        void DrawVScrollBar();
        void InvalidateVScrollBar();
        void DrawLine(int LineOffset,int x, int y);
        void ScrollDown1Line(int ytop);
        void ScrollUp1Line(int ybot);
        void ScrollRight(int shift);
        void ScrollLeft(int shift);
        

        void DrawAllLines();
        void ClrEOL(int x,int y);
        void CursorOff();
        void CursorOn();
        void HideCursor();
        void UnhideCursor();
        void StartCursorBlink();
        void StopCursorBlink();
        
        // INPUT RELATED FUNCTIONS
        void CursorUp();
        void CursorDown();
        void CursorRight();
        void CursorLeft();
        void ViewUp();
        void ViewDown();
        void ViewRight();
        void ViewLeft();
        void ViewPageUp();
        void ViewPageDown();
        void ViewHome();
        void ViewEnd();
        void ViewEndOfText();
        void ViewStartOfText();

        void PageUp();
        void PageDown();
        void Home();
        void End();
        void MoveCursor(int Offset);
        void EndOfText();
        void StartOfText();
        void InsertChar(int character);
        void DelChar(int backspace);
        void RemoveText(int StartPos,int EndPos);
        void InsertText(int StartPos,int Length,gString& s);
        void InsertText(int StartPos,int Length,char *string);
        void BeginSelection();
        void EndSelection();
        void Copy();
        void Cut();
        void Paste();
        void BackSpace();
        void Delete();

        void SetEditLimits(int StartPos,int EndPos);
        void ClearEditLimits();
        void GetEditLimits(int *StartPos,int *EndPos);
        BOOL IsReadOnly();
        void SetReadOnly(BOOL rdonly);
        void SetOverwriteMode(BOOL ovrwrite);
        // LOAD/SAVE
        void SetText(const char *text);
        int GetText(char *data,int maxbytes);
        int GetText(char *data,int maxbytes,int StartPos,int EndPos);
        
        void LimitTextSize(int limit,int trimwhere);
        
        inline int Strlen() { return Text.Strlen(); } 
        gEditBox(gControl& Parent,int x, int y,int width,int height,gStyles Style, gFont *f);
        virtual ~gEditBox();
};

// LIST BOXES / TREES

#define ITEM_GROUP 16   // ALLOCATE GROUPS OF 16 ITEMS, NO LESS TO AVOID HEAP TRASHING
#define CHECKHEIGHT 6   // HEIGHT OF CHECKBOX MARK = minimum height of item
#define LEVELWIDTH 8    // DEFINE HOW MUCH TO THE RIGHT ON EACH SUBLEVEL
#define CHECKWIDTH 8
#define CHECKBMPWIDTH 48

enum gListStates {
        LS_HASCHECK =1,
        LS_CHECKED = 2,
        LS_UNKNOWN = 4,
        LS_HIDDEN = 8,
        LS_SELECTED = 16,
        LS_EXPANDABLE = 32,
        LS_EXPANDED = 64
};

struct gListItem {
        int TreeLevel;
        int StateFlags;
        char *Text;
        int Data;
};


class gListBox : public gControl {
        virtual void vTable();
        
public:
        gListItem *Items;
        int NumItems,MaxItems,DispItems;
        int ViewItem,SelectedItem;
        int ItemHeight,MaxWidth;
        int Color,BkColor,SelColor;
        int StyleFlags;
        gFont Font;
        
        void SetItemList(gListItem *List,int NumItems);
        void InsertItem(int Index,char *Text, int TreeLevel,int StateFlags,int Data);
        void RemoveItem(int Index);
        void AddItem(char *Text, int TreeLevel,int StateFlags,int Data);
        gListItem *GetItem(int Index);  
        
        void SetSelection(int Index);
        int NextItem(int Index);
        int NextVisibleItem(int Index);
        int PrevVisibleItem(int Index);
        int PrevItem(int Index);
        int ChildItem(int Index);
        int ParentItem(int Index);
        char *FullPath(int BaseIndex,int Index,const char *Separator);
        
        void Select(int Index);
        void Unselect(int Index);
        void Hide(int Index);
        void Unhide(int Index);
        void Expand(int Index);
        void Collapse(int Index);
        void ExpandAll(int Index);
        void CollapseAll(int Index);
        BOOL HasChildren(int Index);
        BOOL IsExpanded(int Index);
        void SetCheck(int Index,BOOL value);
        BOOL IsChecked(int Index);

        
        
        BOOL ReallocList(int _NumItems);
        void ListChanged();
        void RedrawAll();
        void RedrawSingleItem(int Index);

        BOOL MoveSelectionUp(int nlines);
        BOOL MoveSelectionDown(int nlines);
        void EnsureVisible(int Index);
        virtual int CalcItemWidth(int Index);
        virtual BOOL DrawItem(int Index,int y);
        
        virtual BOOL AcceptFocus() { return TRUE; }
        virtual void Update(gUpdate *u);
        void RedrawFrame();
        void DrawVScrollBar();
        void DrawHScrollBar();
        void InvalidateVScrollBar();
        virtual BOOL DefaultEvent(gEvent *e);

        
        gListBox(gControl& Parent,int x,int y,int w,int h,int Style,gFont *Font);
        ~gListBox();
};

// MESSAGE BOXES

enum gMsgBoxStyle {
        S_OKCANCEL=0,
        S_YESNO,
        S_RETRYCANCEL,
        S_OKONLY
};
enum gMsgBoxResult {
        S_OK = 0,
        S_YES = 0,
        S_RETRY = 0,
        S_NO = -1,
        S_CANCEL = -1
};

gMsgBoxResult gDoMessageBox(gApplication *app,const char *Title,const char *Message,gMsgBoxStyle Flags);



// STANDARD EVENT HANDLERS
BOOL gOKEvent(gEvent *e,gControl *This);
BOOL gCancelEvent(gEvent *e,gControl *This);
BOOL gDoNothingEvent(gEvent *e,gControl *This);



#endif /*GUI_H_*/