---

gui.h

Go to the documentation of this file.

// OMICRON ENGINE HEADER FILE
//
// --------------------------------------------------------------------------
// Copyright (C) 2001-2002 by Bjoern Paetzel <kolrabi@gmx.de>
//
// This file is part of the Omicron Engine.
//
// The Omicron Engine is free software; you can redistribute it and/or modify
// it under the terms of the  GNU General Public License  as published by the
// Free Software Foundation;  either version  2  of the License,  or (at your
// option) any later version.
//
// The Omicron Engine  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 General Public License
// for more details.
//
// You should have  received a copy of the  GNU General Public License  along
// with The Omicron Engine;  if not,  write to the  Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
//
// --------------------------------------------------------------------------
// Last modified:       $Date: 2002/12/07 19:02:17 $
// By           :       $Author: kolrabi $
// $Id: gui.h,v 1.1.1.1 2002/12/07 19:02:17 kolrabi Exp $ 

/*

  $Log: gui.h,v $
  Revision 1.1.1.1  2002/12/07 19:02:17  kolrabi
  initial release


*/

#include            "forward.h"

/****************************************************************************
 ****************************************************************************
 * DEFINES ******************************************************************
 ****************************************************************************
 ****************************************************************************/

/* UI DEFS ******************************************************************/

// EVENTS ////////////////////////////////////////////////////////////////////

// generic events

// control receives focus
#define             UIE_GETFOCUS                1001

// control lost focus
#define             UIE_LOSTFOCUS               1002

// a control sent a command
#define             UIE_COMMAND                 1003

// mouse events

// mouse has been moved over control
#define             UIE_MOUSEMOVE               2001

// mouse button has been pressed over control
#define             UIE_MOUSEDOWN               2002

// mouse button has been released over control
#define             UIE_MOUSEUP                 2003

// mouse enters control
#define             UIE_MOUSEOVER               2004

// mouse leaves control
#define             UIE_MOUSEOUT                2005

// mouse wheel has been moved
#define             UIE_MOUSEWHEEL              2006

// mouse has clicked (pressed and released on control)
#define             UIE_MOUSECLICK              2007

// key events

// a character key has been pressed
#define             UIE_CHAR                    3001

// a key has been pressed
#define             UIE_KEYDOWN                 3002

// a key has been released
#define             UIE_KEYUP                   3003

// parent control has been resized
#define             UIE_PARENTSIZE              4001

// KEY FLAGS /////////////////////////////////////////////////////////////////

// ctrl key is pressed
#define             UI_KEYFLAG_CTRL             (1<<0)

// shift key is pressed
#define             UI_KEYFLAG_SHIFT            (1<<1)

// alt key is pressed
#define             UI_KEYFLAG_ALT              (1<<2)

// alt gr key is pressed
#define             UI_KEYFLAG_ALTGR            (1<<3)
 
// GUI KEY DEFINITIONS ///////////////////////////////////////////////////////

// backspace
#define             UI_KEY_BACKSPACE            0x0008

// tabulator
#define             UI_KEY_TAB                  0x0009

// delete
#define             UI_KEY_DELETE               0x007F
 
// left cursor key
#define             UI_KEY_LEFT                 0x0101

// right cursor key
#define             UI_KEY_RIGHT                0x0102

// up cursor key
#define             UI_KEY_UP                   0x0103

// down cursor key
#define             UI_KEY_DOWN                 0x0104

// there's no key like home
#define             UI_KEY_HOME                 0x0105

// the end is near
#define             UI_KEY_END                  0x0106

// GUI COLOR INDICES /////////////////////////////////////////////////////////

// 3D-control face color
#define             UIC_FACE                    1

// 3D-control light side color
#define             UIC_LIGHT                   2

// 3D-control dark side color
#define             UIC_SHADOW                  3

// 3D-control highlighting color
#define             UIC_HIGHLIGHT               4

// selection color
#define             UIC_SELECTION               5

// color of focus rect
#define             UIC_FOCUS                   6

// general border color
#define             UIC_BORDER                  7

// edit control background color
#define             UIC_EDIT                    8

// enabled text color
#define             UIC_TEXT                    9

// disabled text color
#define             UIC_DISABLED                10

// window background color
#define             UIC_WINDOW                  11

// black
#define             UIC_BLACK                   12

#define             UIC_COUNT                   13

// GUI CONTROL STYLE FLAGS ///////////////////////////////////////////////////

// control's outer border is raised
#define             UI_BORDER_OUTERRAISED       (1<<0)

// control's outer border is sunken
#define             UI_BORDER_OUTERSUNKEN       (1<<1)

// control's inner border is raised
#define             UI_BORDER_INNERRAISED       (1<<2)

// control's inner border is sunken
#define             UI_BORDER_INNERSUNKEN       (1<<3)

// control has a raised border
#define             UI_BORDER_RAISED            5

// control has a sunken border
#define             UI_BORDER_SUNKEN            10

// control has a flat border
#define             UI_BORDER_FLAT              (1<<4)

// control does not need to fill background on redraw
#define             UI_TRANSPARENT              (1<<5)

// check button flag
#define             UI_CHECK_BUTTON             (1<<6)

// GUI PREDEFINED IMAGE INDICES //////////////////////////////////////////////

// window widgets' image
#define             UII_WINDOW                  0

// checkbox state image
#define             UII_CHECKBOX                1

// slider control image
#define             UII_SLIDER                  2

// cursor image
#define             UII_CURSOR                  3

// total number of gui images
#define             UII_COUNT                   4

// GUI MOUSE POINTER VALUES //////////////////////////////////////////////////

// standard pointer
#define             UIP_POINTER                 0

// busy pointer
#define             UIP_WAIT                    1

// text input pointer
#define             UIP_TEXT                    2

// horizontal resize pointer
#define             UIP_RESIZEH                 3

// vertical resize pointer
#define             UIP_RESIZEV                 4

// diagonal resize pointer
#define             UIP_RESIZEDIAG1             5

// diagonal resize pointer
#define             UIP_RESIZEDIAG2             6

// unused, but what the heck
#define             UIP_POINTER2                7

// total number of pointers
#define             UIP_COUNT                   8

// GUI FONT INDICES //////////////////////////////////////////////////////////

// x8 font, variable width
#define             UIF_FONT8                   0

// x16 font, variable width
#define             UIF_FONT16                  1

// 8x8 font, fixed width
#define             UIF_FONT8_FIXED             2

// 16x16 font, fixed width
#define             UIF_FONT16_FIXED            3

// total number of gui fonts
#define             UIF_COUNT                   4

/****************************************************************************
 ****************************************************************************
 * TYPES ********************************************************************
 ****************************************************************************
 ****************************************************************************/

//#ifndef             OMICRON_UI_TYPES_DEFINED
//#define             OMICRON_UI_TYPES_DEFINED

struct uievent_s
{
    ulong           event;              
    slong           x,y;                
    ushort          key;                
    ushort          mod;                
    class uiobject_c  *   obj;             
};

/***************************************************************************
 ***************************************************************************
 * MAIN GUI CONTROLLER CLASS ***********************************************
 ***************************************************************************
 ***************************************************************************/

/* GENERIC UI OBJECT *******************************************************/

class uiobject_c
{
protected:

    friend class    gui_c;

    struct font_s   *fnt;               

    char            *classname;         
    ulong           id;                 

    sshort          posx, posy;         
    ushort          width, height;      

    image_c         *img;               

    list_c<uiobject_c> *children;          
    uiobject_c      *parent;            

    bool            needsrefresh;       
    bool            visible;            
    bool            disabled;           

    ulong           styleflags;         

    char            *text;              

    sshort          growth[4];          

    color_t         bgcolor;            

    bool            movable;            
    bool            mousedrag;          
    slong           dragdownx, 
                    dragdowny;          

    ushort          cursor;             

public:

    // ctor, dtor
                    uiobject_c();
    virtual         ~uiobject_c();

    // child functions
    
    virtual void                        
        add_child(uiobject_c *obj);

    virtual void                        
        remove_child(uiobject_c *obj);

    virtual void                        
        bring_child_to_front(uiobject_c *obj);

    virtual inline list_c<uiobject_c> * 
        get_children();

    uiobject_c                          
        *get_object(ulong id);

    uiobject_c                          
        *find_mouse_object(ushort mx, ushort my);

    // drawing etc
    void                                
        draw(image_c *dst);

    void                                
        refresh();

    virtual void                        
        paint();

    // position and size
    virtual void                        
        move(sshort x, sshort y);

    virtual void                        
        resize(ushort w, ushort h);

    // property functions
    inline sshort                       
        get_posx();

    inline sshort                       
        get_posy();

    inline ushort                       
        get_width();

    inline ushort                       
        get_height();

    inline void                         
        set_id(ulong i);

    inline ulong                        
        get_id();

    inline void                         
        set_visible(bool v);

    inline bool                         
        is_visible();

    inline void                         
        set_enabled(bool e);

    inline bool                         
        is_enabled();

    void                                
        set_growth(sshort x, sshort y, sshort w, sshort h);

    inline void                         
        set_bgcolor(color_t color);

    inline color_t                      
        get_bgcolor();

    inline void                         
        set_style(ulong style);

    inline ulong                        
        get_style();

    virtual inline ushort               
        get_cursor();

    virtual void                        
        set_text(const char *txt);

    inline void
        set_font(struct font_s *f);

    sshort                              
        get_screenposx();

    sshort                              
        get_screenposy();

    // misc
    virtual void                        
        event(uievent_s *eve);

    virtual inline const char *         
        get_classname();

    inline void                         
        set_needs_refresh();
};

// inlines

inline const char *uiobject_c::get_classname()
{ 
    AssertThisValue("generic"); 
    return classname; 
}

inline list_c<uiobject_c> *uiobject_c::get_children()
{
    AssertThisV;    return children; 
}

inline void uiobject_c::set_needs_refresh()
{ 
    AssertThis;

    needsrefresh = true; 
    if (parent && parent!=this) 
        parent->set_needs_refresh(); 
}

inline sshort uiobject_c::get_posx()
{
    AssertThisV;    return posx;
}

inline sshort uiobject_c::get_posy()
{
    AssertThisV;    return posy;
}

inline ushort uiobject_c::get_width()
{
    AssertThisV;    return width;
}

inline ushort uiobject_c::get_height()
{
    AssertThisV;    return height;
}

inline void uiobject_c::set_id(ulong i)
{
    AssertThis;     id = i;
}

inline ulong uiobject_c::get_id()
{
    AssertThisV;    return id;
}

inline void uiobject_c::set_visible(bool v)
{ 
    AssertThis;     visible = v;    
}

inline bool uiobject_c::is_visible()
{ 
    AssertThisV;    return visible; 
}

inline void uiobject_c::set_enabled(bool e) 
{ 
    AssertThis;     disabled = !e;  
}

inline bool uiobject_c::is_enabled()
{ 
    AssertThisV;    return !disabled;
}

inline void uiobject_c::set_bgcolor(color_t color)
{ 
    AssertThis; bgcolor = color; 
}

inline color_t uiobject_c::get_bgcolor()
{ 
    AssertThisV; return bgcolor; 
}

inline void uiobject_c::set_style(ulong style)
{ 
    AssertThis; styleflags = style; 
}

inline ulong uiobject_c::get_style()
{ 
    AssertThisV; return styleflags; 
}

inline ushort uiobject_c::get_cursor()
{
    AssertThisV; return cursor;
}

inline void uiobject_c::set_font(struct font_s *f)
{
    AssertThis;     fnt = f; set_needs_refresh();
}


/***************************************************************************
 ***************************************************************************
 * GUI BUTTON CLASS ********************************************************
 ***************************************************************************
 ***************************************************************************/

class uibutton_c:public uiobject_c
{
protected:

    bool            hilite;             
    bool            pressed;            

public:

    // ctor, dtor
                    uibutton_c();
    virtual         ~uibutton_c();


    virtual void    event(uievent_s *eve);
    virtual void    paint();
};

/* LABEL OBJECT ************************************************************/

class uilabel_c:public uiobject_c
{
protected:

    bool            wordwrap;           


public:

    // ctor, dtor
                    uilabel_c();
    virtual         ~uilabel_c();


    virtual void    paint();
    inline void     set_wordwrap(bool ww);
};

// inlines

inline void uilabel_c::set_wordwrap(bool ww)
{
    AssertThis;     wordwrap = ww;
}



/***************************************************************************
 ***************************************************************************
 * GUI EDIT FIELD CLASS ****************************************************
 ***************************************************************************
 ***************************************************************************/

class uiedit_c:public uiobject_c
{
protected:

    sshort          selstart;           
    sshort          selend;             
    sshort          cursorpos;          

    bool            hilite;             
    bool            mousedown;          

    sshort          left;               

    ushort                              
        find_pos_for_point(ushort x);

public:

    // ctor, dtor
                    uiedit_c();
    virtual         ~uiedit_c();


    virtual void    
        paint();

    virtual void    
        event(uievent_s *eve);

    void                                
        replace_selection(char *txt);

    inline ushort
        get_cursor();
};

inline ushort uiedit_c::get_cursor()
{
    AssertThisV;    return UIP_TEXT;
}


/***************************************************************************
 ***************************************************************************
 * GUI WINDOW CLASS ********************************************************
 ***************************************************************************
 ***************************************************************************/

class uiwindow_c:public uiobject_c
{
protected:

    uiobject_c      *clientarea;        
    uilabel_c       *statuswindow;      
    bool            showstatus;         

public:

    // ctor, dtor
                    uiwindow_c();
    virtual         ~uiwindow_c();


    inline void                         
        add_child(uiobject_c *obj);

    inline void                         
        remove_child(uiobject_c *obj);

    inline void                         
        bring_child_to_front(uiobject_c *obj);

    inline list_c<uiobject_c> *                     
        get_children();

    virtual void
        event(uievent_s *eve);

    virtual void
        paint();

    virtual void
        resize(ushort w, ushort h);

    inline uiobject_c *                 
        get_client_area();
    
    inline uilabel_c *                  
        get_status_window();

    inline void                         
        show_status(bool s);
};

// inlines
inline void uiwindow_c::add_child(uiobject_c *obj)
{
    AssertThis;     if (clientarea) clientarea->add_child(obj);
}

inline void uiwindow_c::remove_child(uiobject_c *obj)
{
    AssertThis;     if (clientarea) clientarea->remove_child(obj);
}

inline void uiwindow_c::bring_child_to_front(uiobject_c *obj)
{
    AssertThis;     if (clientarea) clientarea->bring_child_to_front(obj);
}

inline list_c<uiobject_c> *uiwindow_c::get_children()
{ 
    AssertThisV;    if (clientarea) return clientarea->get_children();
    return NULL;
}

inline uiobject_c *uiwindow_c::get_client_area()
{ 
    AssertThisV;    return clientarea; 
}

inline uilabel_c *uiwindow_c::get_status_window()
{
    AssertThisV;    return statuswindow; 
}

inline void uiwindow_c::show_status(bool s)
{ 
    AssertThis;

    showstatus = s; 
    set_needs_refresh(); 
    statuswindow->set_visible(s);
};

/***************************************************************************
 ***************************************************************************
 * GUI CHECKBUTTON CLASS ***************************************************
 ***************************************************************************
 ***************************************************************************/

class uicheckbutton_c:public uibutton_c
{
protected:

    bool            radio;              
    bool            checked;            

public:

    // ctor, dtor
                    uicheckbutton_c();
                    ~uicheckbutton_c();


    virtual void 
        event(uievent_s *eve);

    virtual void 
        paint();

    inline void                         
        set_checked(bool c);

    inline bool                         
        is_checked();

    inline void                         
        set_radio(bool r);
};

inline void uicheckbutton_c::set_checked(bool c)
{ 
    AssertThis;
    checked = c; 
    set_needs_refresh(); 
}

inline bool uicheckbutton_c::is_checked()
{
    AssertThisV;
    return checked; 
}

inline void uicheckbutton_c::set_radio(bool r)
{ 
    AssertThis;
    radio = r; 
    set_needs_refresh(); 
}

/***************************************************************************
 ***************************************************************************
 * GUI SLIDER CLASS ********************************************************
 ***************************************************************************
 ***************************************************************************/

class uislider_c:public uiobject_c
{
protected:

    float           min,                
                    max,                
                    pos;                

public:

                    uislider_c();
    virtual         ~uislider_c();

    virtual void
        paint();

    virtual void 
        event(uievent_s *eve);

    inline void 
        set_min(float m);

    inline void 
        set_max(float m);

    inline void 
        set_pos(float p);

    inline float
        get_min();

    inline float
        get_max();

    inline float
        get_pos();

    void 
        set_text(const char *txt);

    inline ushort
        get_cursor();
};

inline void uislider_c::set_min(float m)
{ 
    AssertThis;
    min = m; 
    set_needs_refresh(); 
}

inline void uislider_c::set_max(float m)
{ 
    AssertThis;
    max = m; 
    set_needs_refresh(); 
}

inline void uislider_c::set_pos(float p)
{ 
    AssertThis;
    pos = p; 
    set_needs_refresh(); 
}

inline float uislider_c::get_min()
{ 
    AssertThisV;
    return min;
}

inline float uislider_c::get_max()
{ 
    AssertThisV;
    return max;
}

inline float uislider_c::get_pos()
{ 
    AssertThisV;
    return pos;
}

inline ushort uislider_c::get_cursor()
{
    AssertThisV;
    if (width>height)
        return UIP_RESIZEH; 
    return UIP_RESIZEV;
}

//#endif

class gui_c
{
protected:

    uiobject_c      *desktop;           
    uiobject_c      *focus,             
                    *mouseobj,          
                    *lmouseobj;         

    ushort          cursor;             

    sshort          cursorx,            
                    cursory;

    sshort          cursorlx,           
                    cursorly;

    sshort          cursordx,           
                    cursordy;

    struct font_s   *font[UIF_COUNT];   

    color_t         colors[UIC_COUNT];

    class animation_c *images;          

    ushort          lastkeydown;        
    ulong           keydownstarttime;   
    ulong           keylastrepeattime;  

    ushort          currentkeymod;      

public:

                    gui_c();
                    ~gui_c();

    inline uiobject_c *                 
        get_focus();

    inline void                         
        set_focus(uiobject_c *f);

    inline uiobject_c *                 
        get_desktop();

    void                                
        draw();

    void                                
        update();

    color_t                             
        get_color(ulong nr);

    class animation_c *                 
        get_image(ulong nr);

    inline struct font_s *              
        get_font(ulong font);

    void                                
        send_generic_event(uiobject_c *obj, ushort event);

    void                                
        send_mouse_event(uiobject_c *obj, ushort event);

    void                                
        send_keyboard_event(uiobject_c *obj, ushort event, ushort key);

    ushort                              
        get_key_ascii(uchar key);

    inline sshort                       
        get_cursor_x();

    inline sshort                       
        get_cursor_y();

    inline sshort                       
        get_cursor_dx();

    inline sshort                       
        get_cursor_dy();

    void                                
        load(const char *fname);
};

// inlines

inline uiobject_c *gui_c::get_focus()
{ 
    AssertThisV;    return focus; 
}

inline void gui_c::set_focus(uiobject_c *obj)
{ 
    AssertThis;     focus = obj;
}

inline color_t gui_c::get_color(ulong nr)
{
    AssertThisV;
    AssertReturnValue2(nr>=0, nr<UIC_COUNT, 0);
    return colors[nr];
}

inline struct font_s *gui_c::get_font(ulong nr)
{
    AssertThisV;    return font[nr];
}

inline uiobject_c *gui_c::get_desktop()
{ 
    AssertThisV;    return desktop; 
}

inline sshort gui_c::get_cursor_x() 
{ 
    AssertThisV;    return cursorx; 
}

inline sshort gui_c::get_cursor_y() 
{ 
    AssertThisV;    return cursory; 
}

inline sshort gui_c::get_cursor_dx() 
{ 
    AssertThisV;    return cursordx; 
}

inline sshort gui_c::get_cursor_dy() 
{ 
    AssertThisV;    return cursordy; 
}

---