Fui.h

Go to the documentation of this file.

/*
 * Fui.h
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2003 Chris Wallace
 *
 * Fly! Legacy 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.
 *
 * Fly! Legacy 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 Fly! Legacy; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#ifndef FUI_H
#define FUI_H

#include "../Include/FlyLegacy.h"
#include <list>
#include <vector>
#include <stack>
#include <map>
#include <string>
#include <stdio.h>


//
// The following enum defines unique window IDs for all window types.  It is used
//   as a means for applications to avoid using the same ID for different window types
//
enum EFuiWindowIdentifier
{
  FUI_WINDOW_FRAME_RATE              = 'fpsw',
  FUI_WINDOW_SITUATION_LOAD          = 'Load',
  FUI_WINDOW_SITUATION_SAVE          = 'Save',
  FUI_WINDOW_SITUATION_SAVE_AS       = 'SavA',
  FUI_WINDOW_QUIT                    = 'Quit',
  FUI_WINDOW_OPTIONS_SCENERY         = 'tree',
  FUI_WINDOW_OPTIONS_REALISM         = 'real',
  FUI_WINDOW_OPTIONS_STARTUP         = 'gogo',
  FUI_WINDOW_OPTIONS_COCKPIT         = 'cock',
  FUI_WINDOW_OPTIONS_TEST_CONTROLS   = 'test',
  FUI_WINDOW_OPTIONS_KEYS_BUTTONS    = 'real',
  FUI_WINDOW_OPTIONS_DATE_TIME       = 'date',
  FUI_WINDOW_OPTIONS_SOUND           = 'SndO',
  FUI_WINDOW_ADVENTURES              = 'fnow',
  FUI_WINDOW_QUICKFLIGHT             = 'gogo',    // Duplicate?
  FUI_WINDOW_TELEPORT                = 'goto',
  FUI_WINDOW_TELEPORT_DIRECTORY      = 'wdir',
  FUI_WINDOW_TELEPORT_ALERT          = 'alrt',
  FUI_WINDOW_AIRCRAFT_OPTIONS        = 'aplo',
  FUI_WINDOW_AIRCRAFT_CG             = 'cgin',
  FUI_WINDOW_AIRCRAFT_AUTOTUNE       = 'tune',
  FUI_WINDOW_AIRCRAFT_FUEL           = 'fuel',
  FUI_WINDOW_AIRCRAFT_WEIGHT_BALANCE = 'phat',
  FUI_WINDOW_AIRCRAFT_DAMAGE         = 'ouch',
  FUI_WINDOW_AIRCRAFT_SELECT         = 'sela',
  FUI_WINDOW_WEATHER_METAR           = 'meta',
  FUI_WINDOW_WEATHER_OTHER           = 'env+',
  FUI_WINDOW_WEATHER_WINDS           = 'wind',
  FUI_WINDOW_WEATHER_CLOUDS          = 'clds',
  FUI_WINDOW_WEATHER_SKY_TWEAKER     = 'skyc',
  FUI_WINDOW_WEATHER_OVERVIEW        = 'envr',
  FUI_WINDOW_INSTANT_REPLAY          = 'insR',
  FUI_WINDOW_AXIS                    = 'axis',
  FUI_WINDOW_MAP                     = 'smap',
  FUI_WINDOW_VECTOR_MAP              = 'mapw',
};


enum EFuiComponentTypes
{
  COMPONENT_WINDOW = 'wind',
  COMPONENT_BUTTON = 'butn',
  COMPONENT_DOUBLE_BUTTON = 'dbtn',
  COMPONENT_DEFAULT_BUTTON = 'okbn',
  COMPONENT_CHECKBOX = 'chkb',        // Was 'chek' in SDK ??
  COMPONENT_RADIOBUTTON = 'radb',     // Was 'radi' in SDK ??
  COMPONENT_LABEL = 'labl',
  COMPONENT_LINE = 'line',
  COMPONENT_BOX = 'box_',
  COMPONENT_PICTURE = 'pict',
  COMPONENT_POPUPMENU = 'popu',
  COMPONENT_MENUBAR = 'mbar',
  COMPONENT_SCROLLBAR = 'scrl',
  COMPONENT_SLIDER = 'slid',
  COMPONENT_GROUPBOX = 'grbx',        // Was 'gbox' in SDK ??
  COMPONENT_GAUGE = 'gage',
  COMPONENT_LIST = 'list',
  COMPONENT_SCROLLAREA = 'scla',
  COMPONENT_TEXTFIELD = 'edit',       // Was 'txtf' in SDK ??
  COMPONENT_TEXTAREA = 'txta',
  COMPONENT_PROGRESS = 'prog',
  COMPONENT_MAP = 'map_',
  COMPONENT_TABPAGE = 'ntab',         // Was 'ntab' in SDK ??
  COMPONENT_TABBUTTON = 'tabb',
  COMPONENT_TABCONTROL = 'tabs',      // Was 'tabs' in SDK ??
  COMPONENT_GRAPH = 'grph',
  
//  COMPONENT_EDIT =  'edit',
  COMPONENT_WINDOW_MENUBAR = 'wmbr',
  COMPONENT_MENU = 'mnu2',
  COMPONENT_DLLVIEW = 'DLLV',
  COMPONENT_DISCLOSURE = 'disc',
  COMPONENT_CANVAS = 'canv',
  COMPONENT_RUNWAY_CANVAS = 'rcvs',
  COMPONENT_MARQUEE = 'mrqe',
  COMPONENT_HORIZ_MARQUEE = 'hmrq',
  COMPONENT_WINDOW_NORESIZE = 'winn',
  COMPONENT_TITLE = 'titl',
  COMPONENT_PALETTE_WINDOW = 'pwin',
  COMPONENT_PALETTE_WINDOW_TITLE = 'wint',
  COMPONENT_CLOSE_BUTTON = 'clos',
  COMPONENT_MINIMIZE_BUTTON = 'mini',
  COMPONENT_ZOOM_BUTTON = 'zoom'
};

enum EFuiEvents
{
  EVENT_IDCHANGED   ='dtid',
  EVENT_HIDDEN    ='hide',  
  EVENT_SHOWN   ='show',
  EVENT_ENABLED   ='enbl',  
  EVENT_DISABLED    ='!enb',
  EVENT_RESIZED   ='size',
  EVENT_MOVED   ='move',
  EVENT_RENAMED   ='name',
  EVENT_COMPONENTDIED = 'dead',
  EVENT_CHECKED   = 'chek', 
  EVENT_UNCHECKED   = 'uchk',
  EVENT_SELECTITEM  = 'slct',
  EVENT_BUTTONPRESSED = 'actn',
  EVENT_TEXTCHANGED = 'delt',
  EVENT_TEXTSET   = 'tset',
  EVENT_VALUECHANGED  = 'valu',
  EVENT_OPENWINDOW  ='open',
  EVENT_CLOSEWINDOW ='clos',
  EVENT_TITLECHANGED  ='titl',
  EVENT_FOCUSLOST   = '!foc',
  EVENT_FOCUSGAINED = 'foci',
  EVENT_WIDGETTYPECHANGED = 'widg',
  EVENT_DIALOGDISMISSED = 'dlog',
  EVENT_DIALOGDISMISSEDOK = 'dlOK',
  EVENT_DIALOGDISMISSEDCANCEL = 'dlCn',
  EVENT_UPDATE = 'updt',
  EVENT_ANYSUBEVENT = 0,    
  EVENT_NOSUBEVENT  = 0
};

enum EFuiBinding {
  BIND_H_LEFT       = 1<<0,
  BIND_H_RIGHT      = 1<<1,
  BIND_H_CENTER     = 1<<2,
  BIND_V_TOP        = 1<<4,
  BIND_V_BOTTOM     = 1<<5,
  BIND_V_CENTER     = 1<<6
};

enum EFuiJustify {
  JUSTIFY_H_LEFT      = 1<<0,
  JUSTIFY_H_RIGHT     = 1<<1,
  JUSTIFY_H_CENTER    = 1<<2,
  JUSTIFY_V_TOP       = 1<<4,
  JUSTIFY_V_BOTTOM    = 1<<5,
  JUSTIFY_V_CENTER    = 1<<6
};

enum EFuiLayer {
  LAYER_NORMAL,
  LAYER_FLOATING,
  LAYER_MODAL,
  LAYER_FRONTMOST
};


//
// Forward declare all class types
//
class CFuiComponent;
class CFuiPicture;
class CFuiButton;
class CFuiCloseButton;
class CFuiMiniButton;
class CFuiZoomButton;
class CFuiWindowTitle;
class CFuiWindow;


//
// Type definition for FUI event callback.  Applications must provide a pointer
//   to a function of this type to handle callbacks for windows that they create.
//
typedef void(*FuiEventNoticeCb)(Tag window,
                                Tag component,
                                EFuiEvents event,
                                EFuiEvents subevent);

//
// Base class for all FUI components
//
class CFuiComponent : public CStreamObject
{
public:
  // Constructors / destructor
  CFuiComponent (int x = 0, int y = 0, int w = 0, int h = 0, Tag window = 0);
  virtual ~CFuiComponent (void);

  // CStreamObject methods
  virtual int         Read (SStream *stream, Tag tag);
  virtual void        ReadFinished (void);

  // CFuiComponent methods
  inline bool         IsType (EFuiComponentTypes type) { return (this->type == type); }
  virtual void        SetParentWindowId (Tag parentWindowId);
  inline Tag          GetId (void) { return id; }
  inline void         Show (void) { show = true; }
  inline void         Hide (void) { show = false; }
  inline void         Enable (void) { enable = true; }
  inline void         Disable (void) { enable = false; }
  inline char*        GetText (void) { return text; }
  virtual void        SetText (const char* text);
  virtual void        SetPosition (int x, int y);
  virtual void        SetParentPosition (int xParent, int yParent);
  virtual void        SetSize (int w, int h);
  virtual void        SetPositionSize (int x, int y, int w, int h);
  virtual bool        MouseHit (int x, int y);
  virtual bool        MouseMove (int x, int y);
  virtual bool        MouseClick (int x, int y, EMouseButton button);
  virtual bool        MouseStopClick (int x, int y, EMouseButton button);

  // @todo Make pure virtual
  virtual void        Draw (void);

protected:
  void                MakeSurface (void);

protected:
  Tag                 parentWindowId;   

  EFuiComponentTypes  type;             // Component type
  Tag                 id;               // Unique identifier
  int                 bind;             // Parent binding flags
  char                widgetName[64];   // Widget name
  Tag                 widgetTag;        // Widget tag
  char                text[256];        // Component label
  int                 xParent, yParent; // Absolute location of parent origin
  int                 x, y;             // Location relative to parent
  int                 w, h;             // Component size
  int                 enable;           // Enabled = 1, grayed-out = 0
  int                 show;             // Visible = 1, invisible = 0
  Tag                 fontTag;          // Theme definition
  SFont               *font;

  SSurface            *surface;
};


//
// CFuiPicture
//
class CFuiPicture : public CFuiComponent
{
public:
  // Constructors / destructor
  CFuiPicture (int x = 0, int y = 0, int w = 0, int h = 0, Tag window = 0);
  virtual ~CFuiPicture (void);

  // CStreamObject methods
  virtual int Read (SStream *stream, Tag tag);
  virtual void ReadFinished (void);

  // CFuiComponent methods
  virtual void Draw (void);

  // CFuiPicture methods
  virtual void SetBitmap (SBitmap *bm);
  virtual void DrawTiledBitmap (SBitmap *bitmap);
  virtual void DrawNoTiling (void);
  virtual void SetFrame (int i);

protected:
  SBitmap       *bm;                
  bool          destroyBitmap;      
//  SBitmap       *bmTheme;       // Bitmap (PBM/PBG)
//  SBitmap       *bmBack;        // Bitmap (PBM/PBG)
  int           lastFrame;         
  int           frame;             
};


//
// CFuiButton
//
class CFuiButton : public CFuiComponent
{
public:
  // Constructors / destructor
  CFuiButton (int x = 0, int y = 0, int w = 0, int h = 0, Tag window = 0);

  // CStreamObject methods
  virtual int  Read (SStream *stream, Tag tag);
  virtual void ReadFinished (void);

  // CFuiComponent methods
  virtual void        Draw (void);
  virtual void        SetParentPosition (int xParent, int yParent);
  virtual bool        MouseMove (int x, int y);
  virtual bool        MouseClick (int x, int y, EMouseButton button);
  virtual bool        MouseStopClick (int x, int y, EMouseButton button);

  // CFuiButton methods
  void Fill (void);             

protected:
  int               ok;         // OK button
  int               canc;       // Cancel button
  int               rrpt;       // Repeat
  float             rate;       // Repeat rate
  char              psiz[64];
  int               xLsiz, yLsiz;
  int               xBsiz, yBsiz;

  SBitmap*          bmLeft;
  SBitmap*          bmBack;
  SBitmap*          bmRight;
  CFuiPicture*      left;
  CFuiPicture*      back;
  CFuiPicture*      right;
  unsigned int      colText;

  bool              state;
};


//
// CFuiWindowTitle
//
class CFuiWindowTitle : public CFuiComponent
{
public:
  // Constructors / destructor
  CFuiWindowTitle (int x = 0, int y = 0, int w = 0, int h = 0, Tag window = 0);

  // CStreamObject methods

  // CFuiComponent methods
  void      Draw (void);
  void      SetParentPosition (int xParent, int yParent);

  // CFuiWindowTitle methods
  void      Fill (void);

protected:
  SBitmap*                    bmBack;         // Backdrop bitmap
  SBitmap*                    bmAltBack;      // Alternate bitmap (?)
  SBitmap*                    bmLeft;         // Left side bitmap
  SBitmap*                    bmRight;        // Right side bitmap
  unsigned int                colText;        // Text colour

  CFuiPicture                 *back;
  CFuiPicture                 *left;
  CFuiPicture                 *right;

  std::vector<CFuiComponent*> childVector;    // Vector of child components
};

//
// CFuiCloseButton
//
class CFuiCloseButton : public CFuiComponent
{
public:
  // Constructors / destructor
  CFuiCloseButton (int x = 0, int y = 0, int w = 0, int h = 0, Tag window = 0);

  // CStreamObject methods

  // CFuiComponent methods
  virtual void        Draw (void);
  virtual void        SetParentPosition (int xParent, int yParent);
  virtual bool        MouseMove (int x, int y);
  virtual bool        MouseClick (int x, int y, EMouseButton button);
  virtual bool        MouseStopClick (int x, int y, EMouseButton button);

  // CFuiCloseButton methods
  void Fill (void);             

protected:
  SBitmap*                    bmBack;         
  CFuiPicture                 *back;          
  bool                        state;          
};

//
// CFuiMinimizeButton
//
class CFuiMinimizeButton : public CFuiComponent
{
public:
  // Constructors / destructor
  CFuiMinimizeButton (int x = 0, int y = 0, int w = 0, int h = 0, Tag window = 0);

  // CStreamObject methods

  // CFuiComponent methods
  virtual void        Draw (void);
  virtual void        SetParentPosition (int xParent, int yParent);
  virtual bool        MouseMove (int x, int y);
  virtual bool        MouseClick (int x, int y, EMouseButton button);
  virtual bool        MouseStopClick (int x, int y, EMouseButton button);

  // CFuiCloseButton methods
  void Fill (void);             

protected:
  SBitmap*                    bmBack;         
  CFuiPicture                 *back;          
  bool                        state;          
};

//
// CFuiZoomButton
//
class CFuiZoomButton : public CFuiComponent
{
public:
  // Constructors / destructor
  CFuiZoomButton (int x = 0, int y = 0, int w = 0, int h = 0, Tag window = 0);

  // CStreamObject methods

  // CFuiComponent methods
  virtual void        Draw (void);
  virtual void        SetParentPosition (int xParent, int yParent);
  virtual bool        MouseMove (int x, int y);
  virtual bool        MouseClick (int x, int y, EMouseButton button);
  virtual bool        MouseStopClick (int x, int y, EMouseButton button);

  // CFuiCloseButton methods
  void Fill (void);             

protected:
  SBitmap*                    bmBack;         
  CFuiPicture                 *back;          
  bool                        state;          
};

typedef enum {
  FUI_WINDOW_INIT,
  FUI_WINDOW_OPEN,
  FUI_WINDOW_CLOSED,
  FUI_WINDOW_MOVE
} EFuiWindowState;


//
// CFuiWindow
//
class CFuiWindow : public CFuiComponent
{
public:
  // Constructors / destructor
  CFuiWindow (const char* winFilename, Tag tag, FuiEventNoticeCb handler = NULL);
  ~CFuiWindow (void);

  // CStreamObject methods
  virtual int         Read (SStream *stream, Tag tag);
  virtual void        ReadFinished (void);

  // CFuiComponent methods
  virtual void        Draw (void);
  virtual void        Draw (SSurface *surface);
  virtual bool        MouseMove (int x, int y);
  virtual bool        MouseClick (int x, int y, EMouseButton button);
  virtual bool        MouseStopClick (int x, int y, EMouseButton button);
  virtual void        SetPosition (int x, int y);

  // ???
  static void         ParseThemeElement (const char* s);
  
  // CFuiWindow methods
  EFuiWindowState     GetState (void);
  void                SetTitle (const char* title);
  CFuiComponent*      GetComponent (Tag component);
  void                GenerateEventNotice (Tag componentId,
                                           EFuiEvents event,
                                           EFuiEvents subevent);
  void                Close ();

protected:
  EFuiWindowState   state;          
  Tag               windowId;       

  int               xWsiz, yWsiz;   // Window size
  int               x1, y1, x2, y2; // Initial position?
  int               title;      // Title bar
  int               close;      // Close button
  int               mini;       // Minimize button
  int               zoom;       // Maximize button
  int               resize;     // Window is resizeable
  int               border;     // Border is present
  int               borderSize; // Border thickness
  int               move;       // Window is movable
  EFuiLayer         layer;      // Drawing layer
  int               trns;       // ???
  int               save;       // ???

  char              winFilename[64];
  FuiEventNoticeCb  handler;

  SBitmap           *bmBack;
  SBitmap           *bmTop;
  SBitmap           *bmBottom;
  SBitmap           *bmLeft;
  SBitmap           *bmRight;
  SBitmap           *bmTopLeft;
  SBitmap           *bmTopRight;
  SBitmap           *bmBottomLeft;
  SBitmap           *bmBottomRight;

  std::list<CFuiComponent*>  decorationList;    // Window decoration components
  std::list<CFuiComponent*>  childList;         // Child components

  CFuiWindowTitle   *windowTitle;
  CFuiComponent     *btnClose;
  CFuiComponent     *btnMini;
  CFuiComponent     *btnZoom;

  int               lastX, lastY;               
};

//
// CFuiPopupMenu
//
class CFuiPopupMenu : public CFuiButton
{
public:
  // Constructors / destructor
  CFuiPopupMenu (int x = 0, int y = 0, int w = 0, int h = 0, Tag window = 0);

  // CStreamObject methods
  virtual int       Read (SStream *stream, Tag tag);
  virtual void      ReadFinished (void);

  // CFuiComponent methods
  void Draw (void);
  void SetParentPosition (int xParent, int yParent);

  // CFuiPopupMenu methods
  void ClearItems (void);
  void AddItem (Tag item, const char *label);
  void AddSeparator (void);
  void RemoveItem (Tag item);
  void SelectItem (Tag item);
  Tag  GetItemSelection (char *outText);

protected:
  int               just1, just2, just3;

  SBitmap           *bmBack;
  SBitmap           *bmLeft;
  SBitmap           *bmRight;

  unsigned int      colText, colSelection;

  std::list<CFuiComponent*>    decorationList; 
  std::map<Tag, std::string>   items;          
  Tag                          selection;      
  bool                         popupActive;    
  int                          xText, yText;   
};

//
// CFuiCheckbox
//
class CFuiCheckbox : public CFuiComponent
{
public:
  // Constructors / destructor
  CFuiCheckbox (int x = 0, int y = 0, int w = 0, int h = 0, Tag window = 0);

  // CStreamObject methods
  virtual int  Read (SStream *stream, Tag tag);
  virtual void ReadFinished (void);

  // CFuiComponent methods
  void Draw (void);
  bool MouseClick (int x, int y, EMouseButton button);
  bool MouseStopClick (int x, int y, EMouseButton button);

  // CFuiCheckbox methods
  int  GetState (void);         
  void SetState (int);          

protected:
  SBitmap   *bmBack;            
  int       state;              
  bool      pressed;            
};

//
// CFuiRadioButton
//
class CFuiRadioButton : public CFuiComponent
{
public:
  // Constructors / destructor
  CFuiRadioButton (int x = 0, int y = 0, int w = 0, int h = 0, Tag window = 0);

  // CStreamObject methods
  virtual int  Read (SStream *stream, Tag tag);
  virtual void ReadFinished (void);

  // CFuiComponent methods
  virtual void Draw (void);
  virtual bool MouseClick (int x, int y, EMouseButton button);
  virtual bool MouseStopClick (int x, int y, EMouseButton button);

  // CFuiRadioButton methods
  int  GetState (void);         
  void SetState (int);          

protected:
  SBitmap   *bmBack;            
  int       state;              
  bool      pressed;            
};

//
// CFuiLabel
//
class CFuiLabel : public CFuiComponent
{
public:
  // Constructors / destructor
  CFuiLabel (int x = 0, int y = 0, int w = 0, int h = 0, Tag window = 0);

  // CStreamObject methods
  virtual int  Read (SStream *stream, Tag tag);
  virtual void ReadFinished (void);

  // CFuiComponent methods
  void Draw (void);

  // CFuiLabel methods
  void SetColour (unsigned int colour); 

protected:
  int           just;       // Justification mask; see EFuiJustify
  int           wrap;       // Word-wrap flag
  unsigned int  colText;    // Text colour
  unsigned int  colShadow;  // Shadow colour
  bool          useShadow;  // Use shadowed text
};

//
// CFuiLine
//
#define FUI_LINE_HORIZONTAL   0
#define FUI_LINE_VERTICAL     1

class CFuiLine : public CFuiComponent
{
public:
  // Constructors / destructor
  CFuiLine (int x = 0, int y = 0, int w = 0, int h = 0, Tag window = 0);

  // CStreamObject methods
  virtual int  Read (SStream *stream, Tag tag);
  virtual void ReadFinished (void);

  // CFuiComponent methods
  void Draw (void);

protected:
  int           direction;      
  int           thickness;      

  unsigned int  colLine;        
};

//
// CFuiBox
//
class CFuiBox : public CFuiComponent
{
public:
  // Constructors / destructor
  CFuiBox (int x = 0, int y = 0, int w = 0, int h = 0, Tag window = 0);

  // CStreamObject methods
  virtual int  Read (SStream *stream, Tag tag);
  virtual void ReadFinished (void);

  // CFuiComponent methods
  void Draw (void);

protected:
  SBitmap       *bmBack;
  SBitmap       *bmTop;
  SBitmap       *bmBottom;
  SBitmap       *bmLeft;
  SBitmap       *bmRight;
  SBitmap       *bmTopLeft;
  SBitmap       *bmTopRight;
  SBitmap       *bmBottomLeft;
  SBitmap       *bmBottomRight;

  int           thickness;       
  unsigned int  colLine;         
  unsigned int  colFill;         
};


struct SMenuBarItem {
  Tag           tag;
  char          text[64];
};

//
// CFuiMenuBar
//
class CFuiMenuBar : public CFuiComponent
{
public:
  // Constructors / destructor

  // CStreamObject methods

protected:
  Tag         menuTag;
  char        menuString[64];
  // item list as STL vector or map
};

//
// CFuiScrollBar
//
class CFuiScrollBar : public CFuiComponent
{
public:
  // Constructors / destructor

  // CStreamObject methods

protected:

};

//
// CFuiSlider
//
class CFuiSlider : public CFuiComponent
{
public:
  // Constructors / destructor
  CFuiSlider (int x = 0, int y = 0, int w = 0, int h = 0, Tag window = 0);

  // CStreamObject methods
  virtual int  Read (SStream *stream, Tag tag);
  virtual void ReadFinished (void);

  // CFuiComponent methods
  void Draw (void);
  void SetParentPosition (int xParent, int yParent);

  // CFuiSlider methods
  void  SetMajorTickSpacing (float spacing);
  void  SetMinorTickSpacing (float spacing);
  void  SetSnapToTicks (int snapFlag);
  void  SetDrawMajorTicks (int drawFlag);
  void  SetDrawMinorTicks (int drawFlag);
  float GetMajorTickSpacing (void);
  float GetMinorTickSpacing (void);
  int   GetSnapToTicks (void);
  int   GetDrawMajorTicks (void);
  int   GetDrawMinorTicks (void);

protected:
  SBitmap       *bmBack;
  SBitmap       *bmAltBack;
  SBitmap       *bmHThumb;
  SBitmap       *bmVThumb;
  SBitmap       *bmHLTick;
  SBitmap       *bmHSTick;
  SBitmap       *bmVLTick;
  SBitmap       *bmVSTick;

  CFuiPicture   *back;

  float       maxv, minv;       // Min/Max values
  float       curv;             // ??? Curvature?
  float       majt;             // Major tick interval
  int         dmjt;             // Display major ticks
  float       mint;             // Minor tick interval
  int         dmnt;             // Display minor ticks
  int         snap;             // Snap to ticks
  Tag         link;             // Linked FUI component

  bool        vertical;         // Vertical orientation
};

//
// CFuiGroupBox
//
class CFuiGroupBox : public CFuiComponent
{
public:
  // Constructors / destructor
  CFuiGroupBox (int x = 0, int y = 0, int w = 0, int h = 0, Tag window = 0);

  // CStreamObject methods
  virtual int  Read (SStream *stream, Tag tag);
  virtual void ReadFinished (void);

  // CFuiComponent methods
  virtual bool        MouseMove (int x, int y);
  virtual bool        MouseClick (int x, int y, EMouseButton button);
  virtual bool        MouseStopClick (int x, int y, EMouseButton button);
  void Draw (void);
  void SetParentPosition (int xParent, int yParent);

protected:
  SBitmap       *bmBack;
  SBitmap       *bmTop;
  SBitmap       *bmBottom;
  SBitmap       *bmLeft;
  SBitmap       *bmRight;
  SBitmap       *bmTopLeft;
  SBitmap       *bmTopRight;
  SBitmap       *bmBottomLeft;
  SBitmap       *bmBottomRight;

  bool          transparent;                   
  unsigned int  colText;                       
  int           xText;                         
  std::list<CFuiComponent *>   decorationList; 
  std::list<CFuiComponent *>   childList;      
};

//
// CFuiGauge
//
class CFuiGauge : public CFuiComponent
{
public:
  // Constructors / destructor

  // CStreamObject methods

protected:
};

//
// CFuiList
//
class CFuiListRow {
public:
  // Constructors / destructor
  CFuiListRow (void);

  // CFuiListRow methods
  void          SetHeight (unsigned int height);
  unsigned int  GetHeight (void);
  void          SetText (const char *text);
  const char *  GetText (void);

protected:
  unsigned int    height;  
  std::string     text;    
};

class CFuiListColumn {
public:
  // Constructors / destructor
  CFuiListColumn (void);

  // CFuiListColumn methods
  void          SetWidth (unsigned int width);
  unsigned int  GetWidth (void);
  void          SetTitle (const char *title);
  void          AddRow (CFuiListRow row);
  void          DeleteRow (unsigned int row);
  void          DeleteAllRows (void);
  CFuiListRow&  GetRow (unsigned int i);
  unsigned int  GetRowCount (void);

protected:
  unsigned int              width;    
  unsigned int              minWidth; 
  std::string               title;    
  std::vector<CFuiListRow>  rows;     
};

class CFuiList : public CFuiComponent
{
public:
  // Constructors / destructor
  CFuiList (int x = 0, int y = 0, int w = 0, int h = 0, Tag window = 0);

  // CStreamObject methods
  virtual int Read (SStream *stream, Tag tag);
  virtual void ReadFinished (void);

  // CFuiComponent methods
  void Draw (void);
  void SetParentPosition (int xParent, int yParent);

  // CFuiList methods
  void          ScrollToRow (unsigned int row);
  void          ScrollToColumn (unsigned int column);
  unsigned int  GetRowCount (void);
  unsigned int  GetColumnCount (void);
  void          AddColumn (unsigned int width, char *title);  // neg. width is "minimum"
  void          DeleteColumn (unsigned int column);
  void          DeleteAllColumns (void);
  void          SetColumnWidth (unsigned int column, unsigned int width);
  void          AddRow (unsigned int height);
  void          DeleteRow (unsigned int row);
  void          DeleteAllRows (void);
  unsigned int  CountSelectedRows (void);
  unsigned int  GetSelectedRow (unsigned int index);
  void          SelectRow (unsigned int row);
  void          ClearSelection (void);
  void          SetCellText (unsigned int row, unsigned int column, char *text);
  void          SetCellIcon (unsigned int row, unsigned int column, char *filename);
  void          ClearCellText (unsigned int row, unsigned int column);
  void          ClearCellIcon (unsigned int row, unsigned int column);
  void          GetCellText (unsigned int row, unsigned int column, char *outtext);

protected:
  int       utit;         
  int       usrr;
  int       multiselect;  
  int       vscroll;      
  int       hscroll;      
  int       dwidth;       
  int       dheight;      
  int       autowidth;    
  bool      noBackground; 

  SBitmap       *bmBack;
  SBitmap       *bmTop;
  SBitmap       *bmBottom;
  SBitmap       *bmLeft;
  SBitmap       *bmRight;
  SBitmap       *bmTopLeft;
  SBitmap       *bmTopRight;
  SBitmap       *bmBottomLeft;
  SBitmap       *bmBottomRight;
  SBitmap       *bmHighlight;

  unsigned int  colText;
  unsigned int  colTextHighlight;
  unsigned int  colHighlight;

  std::list<CFuiComponent *>    decorationList; 
  unsigned int                  nRows;
  std::vector<CFuiListColumn>   cols;

  unsigned int                  scrollRow;
  unsigned int                  scrollCol;
};

//
// CFuiScrollArea
//
class CFuiScrollArea : public CFuiComponent
{
public:
  // Constructors / destructor

  // CStreamObject methods

protected:

};

//
// CFuiTextField
//
class CFuiTextField : public CFuiComponent
{
public:
  // Constructors / destructor
  CFuiTextField (int x = 0, int y = 0, int w = 0, int h = 0, Tag window = 0);
  ~CFuiTextField (void);

  // CStreamObject methods
  virtual int  Read (SStream *stream, Tag tag);
  virtual void ReadFinished (void);

  // CFuiComponent methods
  void SetParentPosition (int xParent, int yParent);
  void Draw (void);

  // CFuiTextField methods
  void SetMaxChars (int maxChars);
  int  GetMaxChars (void);
  void UsePassword (int passwordFlag);
  int  IsPassword (void);
  int  GetLength (void);
  void SetText (char *text);
  char* GetText(void);
  void  SetSelection(int firstChar, int lastChar);
  void  GetSelection(int *firstChar, int *lastChar);

protected:
  SBitmap       *bmBack;
  SBitmap       *bmTop;
  SBitmap       *bmBottom;
  SBitmap       *bmLeft;
  SBitmap       *bmRight;
  SBitmap       *bmTopLeft;
  SBitmap       *bmTopRight;
  SBitmap       *bmBottomLeft;
  SBitmap       *bmBottomRight;

  unsigned int  colText;
  unsigned int  colHighlight;
  unsigned int  colTextHighlight;
  unsigned int  colLine;
  unsigned int  colFill;
  unsigned int  colFillDisabled;
  unsigned int  colCaret;
  bool          ignore_background;

  int           pass;                 
  int           nChars;               
  int           numb;                 
  char*         data;                 

  std::list<CFuiComponent *>  decorationList;
};


//
// CFuiTextArea
//
class CFuiTextArea : public CFuiComponent
{
public:
  // Constructors / destructor

  // CStreamObject methods

protected:
};

//
// CFuiProgress
//
class CFuiProgress : public CFuiComponent
{
public:
  // Constructors / destructor

  // CStreamObject methods

protected:

};

//
// CFuiMap
//
class CFuiMap : public CFuiComponent
{
public:
  // Constructors / destructor

  // CStreamObject methods

protected:

};

//
// CFuiTabPage
//
class CFuiTabPage : public CFuiComponent
{
public:
  // Constructors / destructor

  // CStreamObject methods

protected:

};

//
// CFuiTabButton
//
class CFuiTabButton : public CFuiComponent
{
public:
  // Constructors / destructor

  // CStreamObject methods

protected:

};

//
// CFuiTabControl
//
class CFuiTabControl : public CFuiComponent
{
public:
  // Constructors / destructor

  // CStreamObject methods

protected:

};


//
// CFuiGraphTrace
//
typedef enum {
  FUI_GRAPH_TRACE_POINT     = 0,
  FUI_GRAPH_TRACE_LINE      = 1
};

typedef struct {
  float   x, y;
} SFuiGraphTracePoint;

class CFuiGraphTrace {
public:
  // Constructors / destructor
  CFuiGraphTrace (Tag id, int type);

  // CFuiGraphTrace methods
  void  AddPoint (float x, float y);
  void  ClearPoints (void);
  void  SetRange (float minX, float minY, float maxX, float maxY);
  void  SetColour (unsigned int colour);
  void  Draw (SSurface *surface);

protected:
  Tag                               id;
  int                               type;
  unsigned int                      colour;
  float                             minX, maxX;
  float                             minY, maxY;
  std::vector<SFuiGraphTracePoint>  points;
};

//
// CFuiGraph
//
class CFuiGraph : public CFuiComponent {
public:
  // Constructors / destructor
  CFuiGraph (void);

  // CStreamObject methods
  virtual int  Read (SStream *stream, Tag tag);

  // CFuiComponent methods
  void Draw (void);

  // CFuiGraph methods
  void  AddTrace (Tag traceID, int traceType);
  void  RemoveTrace (Tag traceID);
  void  RemoveAllTraces (void);
  void  AddTracePoint (Tag traceID, float x, float y);
  void  ClearTracePoints (Tag traceID);
  void  SetTraceRange (Tag traceID, float minX, float minY, float maxX, float maxY);
  void  SetTraceColour (Tag traceID, unsigned int colour);
  void  SetUseGrid (int useGrid);
  void  SetGridRange (float minX, float minY, float maxX, float maxY);
  void  SetGridSpacing (float stepX, float stepY);
  void  SetGridColour (unsigned int colour);
  void  SetGridBackColour (unsigned int colour);
  void  GetGridRange (float *minX, float *minY, float *maxX, float *maxY);
  void  GetGridSpacing (float *stepX, float *stepY);

protected:
  bool      useGrid;      // Display grid lines
  float     minX, maxX;   // Horizontal grid range
  float     minY, maxY;   // Vertical grid range
  float     stepX, stepY; // Grid spacing

  unsigned long                 bgColour;     // Background colour
  unsigned long                 gridColour;   // Grid colour
  std::map<Tag,CFuiGraphTrace*> traces;       // Graph traces
};

//
// CFuiMarquee
//
class CFuiMarquee : public CFuiComponent
{
public:
  // Constructors / destructor

  // CStreamObject methods

protected:
  int       just;         // Justification
  int       wrap;         // Wrap (1) or clip (0)
  int       rateX, rateY; // Scroll rates
  char      file[64];     // Text filename
};

//
// CFuiHorizontalMarquee
//
class CFuiHorizontalMarquee : public CFuiComponent
{
public:
  // Constructors / destructor

  // CStreamObject methods

protected:
  int       rateX;        // Scroll rate
};

//
// CFuiTextPopup
//
// A text popup is a simple text message typically used for user notification
//   (such as Slew or Pause mode, temporary messages)
//
class CFuiTextPopup : public CFuiComponent
{
public:
  // Constructors / destructor

  // CFuiComponent methods
  void SetText (const char *text);

protected:
};


enum EFuiThemeColourType {
  THEME_COLOUR_TEXT           =  0,
  THEME_COLOUR_SHADOW         =  1,
  THEME_COLOUR_SELECTION      =  2,
  THEME_COLOUR_HILITE         =  3,
  THEME_COLOUR_TEXTHILITE     =  4,
  THEME_COLOUR_LINE           =  5,
  THEME_COLOUR_TEXTGREY       =  6,
  THEME_COLOUR_FILL           =  7,
  THEME_COLOUR_FILLDISABLED   =  8,
  THEME_COLOUR_CARET          =  9,
  THEME_COLOUR_BORDER         = 10,
  THEME_COLOUR_BACK           = 11,
  THEME_COLOUR_TRACE          = 12,
  THEME_COLOUR_MAX
};

enum EFuiThemeSizeType {
  THEME_SIZE_SMALL          = 0,
  THEME_SIZE_NORMAL         = 1,
  THEME_SIZE_LARGE          = 2,
  THEME_SIZE_SMALL_INLINE   = 3,
  THEME_SIZE_NORMAL_INLINE  = 4,
  THEME_SIZE_LARGE_INLINE   = 5,
  THEME_SIZE_MAX
};

enum EFuiThemeFlagType {
  THEME_FLAG_DONT_DRAW_BACKGROUND      =  0,
  THEME_FLAG_IGNORE_BITMAP_BACKGROUND  =  1,
  THEME_FLAG_USE_SHADOW                =  2,
  THEME_FLAG_MAX
};

  
//
// CFuiThemeWidget
//
// Theme components applicable to a specific widget type
//
class CFuiThemeWidget
{
public:
  // Constructors / destructor
  CFuiThemeWidget (void);
  ~CFuiThemeWidget (void);

  // CFuiThemeWidget methods
  void          ParseBitmap (char* s);
  void          ParseColour (char* s);
  void          ParseSize (char* s);
  void          ParseFrameRate (char *s);
  void          ParseThickness (char *s);
  void          ParseComponentName (char *s, std::string type);
  void          ParseButtonWidth (char *s);

  void          SetName (const char* s);
  SBitmap      *GetBitmap (std::string name);
  unsigned int  GetColour (std::string name);
  void          SetFlag (std::string name);
  bool          GetFlag (std::string name);
  const char*   GetComponentName (std::string name);

  void          Print (FILE *f);

protected:
  char                                name[64];         // Widget name
  std::map<std::string,SBitmap*>      bmMap;            // Map of bitmap elements
  std::map<std::string,unsigned int>  colourMap;        // Map of colour elements
  std::vector<std::string>            flagVector;       // Vector of enabled flags
  std::map<std::string,std::string>   componentNameMap; // Map of sub-component names
  int                                 framerate;
  int                                 thickness;
  int                                 buttonWidth;
};
  
  
//
// CFuiTheme
//
// "Themes" encapsulate the visual style elements applied to all FUI components.
//
class CFuiTheme
{
public:
  // Constructors / destructor
  CFuiTheme (void);
  CFuiTheme (const char* themeFilename);
  ~CFuiTheme (void);

  // CFuiTheme methods
  CFuiThemeWidget* GetWidget (std::string name);
  void             Print (FILE *f);

protected:
  char                                   name[64];       // Theme name
  Tag                                    id;             // Unique ID
  std::map<std::string,CFuiThemeWidget*> widgetMap;
};


//
// CFuiManager
//
class CFuiManager
{
public:
  // Constructors / destructor
  CFuiManager (void);
  ~CFuiManager (void);

  // CFuiManager methods
  void             CreateFuiWindow (FuiEventNoticeCb handler,
                                    Tag id, const char* winFilename);
  void             DestroyFuiWindow (Tag id);
  bool             IsWindowCreated (Tag id);
  void             Draw (void);
  CFuiTheme*       GetTheme (Tag tag);
  CFuiThemeWidget* GetThemeWidget (Tag tag, std::string name);
  void             GainFocus (Tag windowID, Tag componentID);
  void             LoseFocus (Tag windowID, Tag componentID);
  void             GenerateEventNotice (Tag windowId,
                                        Tag componentId,
                                        EFuiEvents event,
                                        EFuiEvents subevent);
  void             DrawNoticeToUser (const char *text, float timeout);

  // Mouse tracking methods
  bool   MouseMove (int x, int y);
  bool   MouseClick (int x, int y, EMouseButton button);
  bool   MouseStopClick (int x, int y, EMouseButton button);

  // Miscellaneous
  CFuiWindow*    GetFuiWindow (Tag window);
  static Tag     GetComponentType (const char* name);
  void           Print (FILE *f);

protected:
  std::map<Tag,CFuiWindow*>       windowMap;
  std::map<Tag,CFuiTheme*>        themeMap;
  CFuiTextPopup                   *slew;
  CFuiTextPopup                   *pause;

  CFuiTextPopup                   *usermsg;
  bool                            userMsgActive;
  float                           userMsgExpiry;
  
public:
  // Access functions for applications to get/set widget state
  void  SetWindowTitle (Tag window, const char* title);

  void  SetComponentText (Tag window, Tag component, const char* text);

  void  SetLabelColour (Tag window, Tag labelID, unsigned int colour);

  int   GetCheckboxState(Tag windowID, Tag checkID);
  void  SetCheckboxState(Tag windowID, Tag checkID, int state);

  int   GetRadioState(Tag windowID, Tag radioID);
  void  SetRadioState(Tag windowID, Tag radioID, int state);

  void  SetTextMaxChars(Tag windowID, Tag textID, int maxChars);
  int   GetTextMaxChars(Tag windowID, Tag textID);
  void  UseTextPassword(Tag windowID, Tag textID, int passwordFlag);
  int   IsTextPassword(Tag windowID, Tag textID);
  int   GetTextLength(Tag windowID, Tag textID);
  void  SetTextText(Tag windowID, Tag textID, char *text);
  char* GetTextText(Tag windowID, Tag textID);
  void  SetTextSelection(Tag windowID, Tag textID, int firstChar, int lastChar);
  void  GetTextSelection(Tag windowID, Tag textID, int *firstChar, int *lastChar);

  void  AddPopupItem (Tag windowID, Tag popupID, Tag itemID, const char *label);
  void  AddPopupSeperator (Tag windowID, Tag popupID);
  void  RemovePopupItem (Tag windowID, Tag popupID, Tag itemID);
  void  ClearPopupItems (Tag windowID, Tag popupID);
  void  SelectPopupItem (Tag windowID, Tag popupID, Tag itemID);
  Tag   GetPopupItemSelection (Tag windowID, Tag popupID, char *outText);

  void  SetGroupBoxLabel (Tag windowID, Tag groupID, char *label);

  void  SetSliderMajorTickSpacing (Tag windowID, Tag sliderID, float spacing);
  void  SetSliderMinorTickSpacing (Tag windowID, Tag sliderID, float spacing);
  void  SetSliderSnapToTicks (Tag windowID, Tag sliderID, int snapFlag);
  void  SetSliderDrawMajorTicks (Tag windowID, Tag sliderID, int drawFlag);
  void  SetSliderDrawMinorTicks (Tag windowID, Tag sliderID, int drawFlag);
  float GetSliderMajorTickSpacing (Tag windowID, Tag sliderID);
  float GetSliderMinorTickSpacing (Tag windowID, Tag sliderID);
  int   GetSliderSnapToTicks (Tag windowID, Tag sliderID);
  int   GetSliderDrawMajorTicks (Tag windowID, Tag sliderID);
  int   GetSliderDrawMinorTicks (Tag windowID, Tag sliderID);
  void  SetSliderLabel (Tag windowID, Tag sliderID, char *label);

  void  ScrollListToRow (Tag windowID, Tag listID, int row);
  void  ScrollListToColumn (Tag windowID, Tag listID, int column);
  int   GetListRowCount (Tag windowID, Tag listID);
  int   GetListColumnCount (Tag windowID, Tag listID);
  void  AddListColumn (Tag windowID, Tag listID, int width, char *title); // neg. width is "minimum" width
  void  DeleteListColumn (Tag windowID, Tag listID, int column);
  void  DeleteAllListColumns (Tag windowID, Tag listID);
  void  SetListColumnWidth (Tag windowID, Tag listID, int column, int width);
  void  AddListRow (Tag windowID, Tag listID, int height);
  void  DeleteListRow (Tag windowID, Tag listID, int row);
  void  DeleteAllListRows (Tag windowID, Tag listID);
  int   CountListSelectedRows (Tag windowID, Tag listID);
  int   GetListSelectedRow (Tag windowID, Tag listID, int index);
  void  SelectListRow (Tag windowID, Tag listID, int row);
  void  ClearListSelection (Tag windowID, Tag listID);
  void  SetListCellText (Tag windowID, Tag listID, int row, int column, char *text);
  void  SetListCellIcon (Tag windowID, Tag listID, int row, int column, char *filename);
  void  ClearListCellText (Tag windowID, Tag listID, int row, int column);
  void  ClearListCellIcon (Tag windowID, Tag listID, int row, int column);
  void  GetListCellText (Tag windowID, Tag listID, int row, int column, char *outtext);

  void  AddGraphTrace(Tag windowID, Tag graphID, Tag traceID, int traceType);
  void  RemoveGraphTrace(Tag windowID, Tag graphID, Tag traceID);
  void  RemoveAllGraphTraces(Tag windowID, Tag graphID);
  void  AddGraphTracePoint(Tag windowID, Tag graphID, Tag traceID, float x, float y);
  void  ClearGraphTracePoints(Tag windowID, Tag graphID, Tag traceID);
  void  SetGraphTraceRange(Tag windowID, Tag graphID, Tag traceID, float minX, float minY, float maxX, float maxY);
  void  SetGraphTraceColour(Tag windowID, Tag graphID, Tag traceID, unsigned int colour);
  void  SetGraphUseGrid(Tag windowID, Tag graphID, int useGrid);
  void  SetGraphGridRange(Tag windowID, Tag graphID, float minX, float minY, float maxX, float maxY);
  void  SetGraphGridSpacing(Tag windowID, Tag graphID, float xStep, float yStep);
  void  SetGridColour(Tag windowID, Tag graphID, unsigned int colour);
  void  SetGridBackColour(Tag windowID, Tag graphID, unsigned int colour);
  void  GetGraphGridRange(Tag windowID, Tag graphID, float *minX, float *minY, float *maxX, float *maxY);
  void  GetGraphGridSpacing(Tag windowID, Tag graphID, float *xStep, float *yStep);

protected:
  CFuiComponent*  FindComponent (Tag windowID, Tag id);
  CFuiLabel*      FindLabel (Tag windowID, Tag labelID);
  CFuiCheckbox*   FindCheckbox (Tag windowID, Tag checkboxID);
  CFuiList*       FindList (Tag windowID, Tag listID);
  CFuiSlider*     FindSlider (Tag windowID, Tag sliderID);
  CFuiGraph*      FindGraph (Tag windowID, Tag graphID);
};

/*
  void  SetScrollbarMin(Tag windowID, Tag scrollID, float min);
  void  SetScrollbarMax(Tag windowID, Tag scrollID, float max);
  void  SetScrollbarValue(Tag windowID, Tag scrollID, float value);
  float GetScrollbarMin(Tag windowID, Tag scrollID);
  float GetScrollbarMax(Tag windowID, Tag scrollID);
  float GetScrollbarValue(Tag windowID, Tag scrollID);
  void  SetScrollbarPageSize(Tag windowID, Tag scrollID, float pageSize);
  float GetScrollbarPageSize(Tag windowID, Tag scrollID);

void  APIAddUIMenu(unsigned long windowID, unsigned long menubarID, unsigned long menuID, const char *label);
void  APIAddUIMenuItem(unsigned long windowID, unsigned long menubarID, unsigned long menuID, unsigned long itemID, const char *label);
void  APIAddUIMenuSeperator(unsigned long windowID, unsigned long menubarID, unsigned long menuID);
void  APIRemoveUIMenuItem(unsigned long windowID, unsigned long menubarID, unsigned long menuID, unsigned long itemID);
void  APIClearUIMenuItems(unsigned long windowID, unsigned long menubarID, unsigned long menuID);
void  APICheckUIMenuItem(unsigned long windowID, unsigned long menubarID, unsigned long menuID, unsigned long itemID, int checked);
void  APIEnableUIMenuItem(unsigned long windowID, unsigned long menubarID, unsigned long menuID, unsigned long itemID, int enabled);

void  APISetUIRadioGroupSelection(unsigned long windowID, unsigned long groupID, unsigned long radioID);
unsigned long APIGetUIRadioGroupSelection(unsigned long windowID, unsigned long groupID);

void  APISetUIProgressIndeterminate(unsigned long windowID, unsigned long progressID, int flag);
int APIGetUIProgressIndeterminate(unsigned long windowID, unsigned long progressID);
void  APISetUIProgressMin(unsigned long windowID, unsigned long progressID, int min);
int APIGetUIProgressMin(unsigned long windowID, unsigned long progressID);
void  APISetUIProgressMax(unsigned long windowID, unsigned long progressID, int max);
int APIGetUIProgressMax(unsigned long windowID, unsigned long progressID);
void  APISetUIProgressValue(unsigned long windowID, unsigned long progressID, int value);
int APIGetUIProgressValue(unsigned long windowID, unsigned long progressID);

*/

void ReplayNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent);
void AxisNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent);
void VectorMapNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent);
void MapNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent);
void FrameRateNotify (Tag id, Tag component, EFuiEvents event, EFuiEvents subevent);

#endif // FUI_H

Documentation generated by