FXApp.h

Go to the documentation of this file.

#ifndef FX_DISABLEGUI
/********************************************************************************
*                                                                               *
*                     A p p l i c a t i o n   O b j e c t                       *
*                                                                               *
*********************************************************************************
* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
*********************************************************************************
* This library is free software; you can redistribute it and/or                 *
* modify it under the terms of the GNU Lesser General Public                    *
* License as published by the Free Software Foundation; either                  *
* version 2.1 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             *
* Lesser General Public License for more details.                               *
*                                                                               *
* You should have received a copy of the GNU Lesser General Public              *
* License along with this library; if not, write to the Free Software           *
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
*********************************************************************************
* $Id: FXApp.h,v 1.230 2006/01/22 17:57:58 fox Exp $                            *
********************************************************************************/
#ifndef FXAPP_H
#define FXAPP_H

#ifndef FXOBJECT_H
#include "FXObject.h"
#endif
#include "FXRectangle.h"
#include "FXHash.h"
#include "FXRectangle.h"
#include "FXRegistry.h"

namespace FX {


// Forward declarations
class FXId;

class FXApp;
class FXWindow;
class FXIcon;
class FXBitmap;
class FXCursor;
class FXRootWindow;
class FXMainWindow;
class FXPopup;
class FXFont;
class FXDC;
class FXDCWindow;
class FXVisual;
class FXGLVisual;
class FXGLContext;
//class FXTranslator;
class FXComposeContext;

// Opaque FOX objects
struct FXTimer;
struct FXChore;
struct FXSignal;
struct FXRepaint;
struct FXInput;
struct FXAsyncMsg;
struct FXInvocation;
struct FXAppDestructUpcall;


enum FXInputMode {
  INPUT_NONE   = 0,                 
  INPUT_READ   = 1,                 
  INPUT_WRITE  = 2,                 
  INPUT_EXCEPT = 4                  
  };


enum FXModality {
  MODAL_FOR_NONE,                 
  MODAL_FOR_WINDOW,               
  MODAL_FOR_POPUP                 
  };


enum FXDefaultCursor {
  DEF_ARROW_CURSOR,                     
  DEF_RARROW_CURSOR,                    
  DEF_TEXT_CURSOR,                      
  DEF_HSPLIT_CURSOR,                    
  DEF_VSPLIT_CURSOR,                    
  DEF_XSPLIT_CURSOR,                    
  DEF_SWATCH_CURSOR,                    
  DEF_MOVE_CURSOR,                      
  DEF_DRAGH_CURSOR,                     
  DEF_DRAGV_CURSOR,                     
  DEF_DRAGTL_CURSOR,                    
  DEF_DRAGBR_CURSOR=DEF_DRAGTL_CURSOR,  
  DEF_DRAGTR_CURSOR,                    
  DEF_DRAGBL_CURSOR=DEF_DRAGTR_CURSOR,  
  DEF_DNDSTOP_CURSOR,                   
  DEF_DNDCOPY_CURSOR,                   
  DEF_DNDMOVE_CURSOR,                   
  DEF_DNDLINK_CURSOR,                   
  DEF_CROSSHAIR_CURSOR,                 
  DEF_CORNERNE_CURSOR,                  
  DEF_CORNERNW_CURSOR,                  
  DEF_CORNERSE_CURSOR,                  
  DEF_CORNERSW_CURSOR,                  
  DEF_HELP_CURSOR,                      
  DEF_HAND_CURSOR,                      
  DEF_ROTATE_CURSOR,                    
  DEF_WAIT_CURSOR                       
  };



struct FXAPI FXEvent {
  FXuint      type;           
  FXuint      time;           
  FXint       win_x;          
  FXint       win_y;          
  FXint       root_x;         
  FXint       root_y;         
  FXint       state;          
  FXint       code;           
  FXString    text;           
  FXint       last_x;         
  FXint       last_y;         
  FXint       click_x;        
  FXint       click_y;        
  FXint       rootclick_x;    
  FXint       rootclick_y;    
  FXuint      click_time;     
  FXuint      click_button;   
  FXint       click_count;    
  FXbool      moved;          
  FXRectangle rect;           
  FXbool      synthetic;      
  FXDragType  target;         
  };


class FXAPI FXLockable {
public:
  virtual ~FXLockable() { }
  virtual void lock() { }               
  virtual void unlock() { }             
  };


class FXAPI FXEventLoop : public FXLockable, public FXObject {
  FXDECLARE(FXEventLoop)

protected:
  friend class FXApp;
  friend class FXPopup;
  friend class FXWindow;
  friend class FXDockHandler;
  template<typename type> friend class FXEventLoop_Static;

  FXApp           *app;                 // Back link to application object
  FXHash           hash;                // Window handle hash table
  FXWindow        *activeWindow;        // Active toplevel window
  FXWindow        *cursorWindow;        // Window under the cursor
  FXWindow        *mouseGrabWindow;     // Window which grabbed the mouse
  FXWindow        *keyboardGrabWindow;  // Window which grabbed the keyboard
  FXWindow        *keyWindow;           // Window in which keyboard key was pressed
  FXWindow        *selectionWindow;     // Selection window
  FXWindow        *clipboardWindow;     // Clipboard window
  FXWindow        *dropWindow;          // Drop target window
  FXWindow        *dragWindow;          // Drag source window
  FXWindow        *refresher;           // GUI refresher pointer
  FXWindow        *refresherstop;       // GUI refresher end pointer
  FXPopup         *popupWindow;         // Current popup window
  FXRootWindow    *root;                // Root window
  FXTimer         *timers;              // List of timers, sorted by time
  FXChore         *chores;              // List of chores
  FXRepaint       *repaints;            // Unhandled repaint rectangles
  FXTimer         *timerrecs;           // List of recycled timer records
  FXChore         *chorerecs;           // List of recycled chore records
  FXRepaint       *repaintrecs;         // List of recycled repaint records
  FXInvocation    *invocation;          // Modal loop invocation
  FXSignal        *signals;             // Array of signal records
  FXint            nsignals;            // Number of signals
  FXEvent          event;               // Event
  FXInput         *inputs;              // Input file descriptors being watched
  FXint            ninputs;             // Number of inputs
  FXint            maxinput;            // Maximum input number
  FXAsyncMsg      *asyncmsgs;           // Asynchronously posted messages
  FXAsyncMsg      *asyncmsgsrecs;       // Recycled asynchronously posted messages
  bool            &initialized;         // FXApp has been initialized
  void           *&display;             // Display we're talking to


  // Platform dependent private stuff
#ifndef WIN32
  void           *&xim;                 // Input method
  void            *r_fds;               // Set of file descriptors for read
  void            *w_fds;               // Set of file descriptors for write
  void            *e_fds;               // Set of file descriptors for exceptions
  int              latch[2];            // Used to latch event loop

#else
  void           **handles;             // Waitable object handles
  void            *lastmovehwnd;
  long            lastmovelParam;
  void            *oldhwnd;
  void            *latch;               // Used to latch event loop
  FXuint          repostimer;           // Used to ensure timers & chores work
  FXuint          msgloopcount;         // How many times the message loop has run modally
  FXuint          tickmsgloopcount;     // Msg loop count at last tick

#endif

  // Internal helper functions
  FXEventLoop(const FXEventLoop&);
  FXEventLoop &operator=(const FXEventLoop&);
  void setup();
  static void signalhandler(int sig);
  static void immediatesignalhandler(int sig);
  void leaveWindow(FXWindow *window,FXWindow *ancestor);
  void enterWindow(FXWindow *window,FXWindow *ancestor);
  void selectionSetData(const FXWindow* window,FXDragType type,FXuchar* data,FXuint size);
  void selectionGetData(const FXWindow* window,FXDragType type,FXuchar*& data,FXuint& size);
  void selectionGetTypes(const FXWindow* window,FXDragType*& types,FXuint& numtypes);
  void clipboardSetData(const FXWindow* window,FXDragType type,FXuchar* data,FXuint size);
  void clipboardGetData(const FXWindow* window,FXDragType type,FXuchar*& data,FXuint& size);
  void clipboardGetTypes(const FXWindow* window,FXDragType*& types,FXuint& numtypes);
  void dragdropSetData(const FXWindow* window,FXDragType type,FXuchar* data,FXuint size);
  void dragdropGetData(const FXWindow* window,FXDragType type,FXuchar*& data,FXuint& size);
  void dragdropGetTypes(const FXWindow* window,FXDragType*& types,FXuint& numtypes);
#ifndef WIN32
  void addRepaint(FXID win,FXint x,FXint y,FXint w,FXint h,FXbool synth=0);
  void removeRepaints(FXID win,FXint x,FXint y,FXint w,FXint h);
  void scrollRepaints(FXID win,FXint dx,FXint dy);
#else
  static long CALLBACK wndproc(FXID hwnd,unsigned int iMsg,unsigned int wParam,long lParam);
protected:
  virtual long dispatchEvent(FXID hwnd,unsigned int iMsg,unsigned int wParam,long lParam);
#endif
private:
  FXbool doIdleProcessing();
  void doTimers();
  void doAsyncMsgs();

protected:

  FXEventLoop(FXApp* app=NULL);

  virtual bool getNextEvent(FXRawEvent& ev,bool blocking=true);

  virtual bool dispatchEvent(FXRawEvent& ev);

  virtual void latchLoop();

  virtual void resetLoopLatch();

  virtual bool getNextEventI(FXRawEvent& ev,bool blocking);

  virtual bool peekEventI();

  virtual void* makeStaticPtr(void* val);

  virtual void deleteStaticPtr(void* ref);

  virtual void* getStaticPtr(const void* ref) const;

  virtual void setStaticPtr(void* ref,void* val);

public:
  enum {
    ID_ASYNCRECALC=1,
    ID_LAST
    };
public:
  FXApp* getApp() const { return app; }

  FXRootWindow* getRootWindow() const { return root; }

  void setRootWindow(FXRootWindow* rt);

  FXWindow *getFocusWindow() const;

  FXWindow *getCursorWindow() const { return cursorWindow; }

  FXWindow *getActiveWindow() const { return activeWindow; }

  FXPopup* getPopupWindow() const { return popupWindow; }

  FXWindow* findWindowWithId(FXID xid) const;

  FXWindow* findWindowAt(FXint rx,FXint ry,FXID window=0) const;

  void addTimeout(FXObject* tgt,FXSelector sel,FXuint ms=1000,void* ptr=NULL);

  void removeTimeout(FXObject* tgt,FXSelector sel);

  bool hasTimeout(FXObject *tgt,FXSelector sel) const;

  FXuint remainingTimeout(FXObject *tgt,FXSelector sel);

  void handleTimeouts();

  void addChore(FXObject* tgt,FXSelector sel,void *ptr=NULL);

  void removeChore(FXObject* tgt,FXSelector sel);

  bool hasChore(FXObject *tgt,FXSelector sel) const;

  void addSignal(FXint sig,FXObject* tgt,FXSelector sel,FXbool immediate=FALSE,FXuint flags=0);

  void removeSignal(FXint sig);

  bool addInput(FXInputHandle fd,FXuint mode,FXObject *tgt,FXSelector sel);

  bool removeInput(FXInputHandle fd,FXuint mode);

  bool getKeyState(FXuint keysym) const;

  bool peekEvent();

  bool runOneEvent(bool blocking=true);

  FXint run();

  FXint runUntil(FXuint& condition);

  FXint runWhileEvents();

  FXint runModalWhileEvents(FXWindow* window=NULL);

  FXint runModal();

  FXint runModalFor(FXWindow* window);

  FXint runModalWhileShown(FXWindow* window);

  FXint runPopup(FXWindow* window);

  bool isModal(FXWindow* window) const;

  FXWindow* getModalWindow() const;

  FXModality getModality() const;

  void stop(FXint value=0);

  void stopModal(FXWindow* window,FXint value=0);

  void stopModal(FXint value=0);

  void forceRefresh();

  void refresh();

  void flush(bool sync=false);

  void repaint();

  FXWindow* getDragWindow() const { return dragWindow; }

  virtual ~FXEventLoop();

public:
  long onCmdAsyncRecalc(FXObject*,FXSelector,void*);

  void postAsyncMessage(FXObject* tgt,FXuint message,void *ptr=NULL,FXObject* src=NULL);

  static void postAsyncMessage(FXId* tgt,FXuint message,void *ptr=NULL,FXObject* src=NULL);

  virtual FXulong getThreadId() const { return 0; }

  static void requestAsyncRecalc(FXWindow *what);

};

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4251)
#endif

class FXAPI FXApp : public FXLockable, public FXObject {
  FXDECLARE(FXApp)

  // We've got many friends
  friend class FXEventLoop;
  friend class FXId;
  friend class FXBitmap;
  friend class FXImage;
  friend class FXIcon;
  friend class FXCursor;
  friend class FXDrawable;
  friend class FXWindow;
  friend class FXShell;
  friend class FXRootWindow;
  friend class FXTopWindow;
  friend class FXMainWindow;
  friend class FXPopup;
  friend class FXFont;
  friend class FXVisual;
  friend class FXGLVisual;
  friend class FXGLContext;
  friend class FXDC;
  friend class FXDCWindow;
  friend class FXEmbedderWindow;
  friend class FXDragCorner;
  friend class FXComposeContext;
protected:
  mutable FXEventLoop *eventLoop;       // Event loop

private:

  // Platform independent private data
  void            *display;             // Display we're talking to
  const FXchar    *dpy;                 // Initial display guess
  FXRegistry       registry;            // Application setting registry
  FXVisual        *monoVisual;          // Monochrome visual
  FXVisual        *defaultVisual;       // Default [color] visual
  FXFont          *normalFont;          // Normal font
  FXFont          *stockFont;           // Stock font
  FXuint           stickyMods;          // Sticky modifier state
  FXuchar         *ddeData;             // DDE array
  FXuint           ddeSize;             // DDE array size
  FXuint           maxcolors;           // Maximum number of colors to allocate
  FXuint           typingSpeed;         // Typing speed
  FXuint           clickSpeed;          // Double click speed
  FXuint           scrollSpeed;         // Scroll speed
  FXuint           scrollDelay;         // Scroll delay
  FXuint           blinkSpeed;          // Cursor blink speed
  FXuint           animSpeed;           // Animation speed
  FXuint           menuPause;           // Menu popup delay
  FXuint           tooltipPause;        // Tooltip popup delay
  FXuint           tooltipTime;         // Tooltip display time
  FXint            dragDelta;           // Minimum distance considered a move
  FXint            wheelLines;          // Scroll by this many lines
  FXint            scrollBarSize;       // Scrollbar size
  FXColor          borderColor;         // Border color
  FXColor          baseColor;           // Background color of GUI controls
  FXColor          hiliteColor;         // Highlight color of GUI controls
  FXColor          shadowColor;         // Shadow color of GUI controls
  FXColor          backColor;           // Background color
  FXColor          foreColor;           // Foreground color
  FXColor          selforeColor;        // Select foreground color
  FXColor          selbackColor;        // Select background color
  FXColor          tipforeColor;        // Tooltip foreground color
  FXColor          tipbackColor;        // Tooltip background color
  FXColor          selMenuTextColor;    // Select foreground color in menus
  FXColor          selMenuBackColor;    // Select background color in menus
  FXCursor        *waitCursor;          // Current wait cursor
  FXuint           waitCount;           // Number of times wait cursor was called
  FXuint           windowCount;         // Number of windows
  FXCursor        *cursor[DEF_WAIT_CURSOR+1];
  //FXTranslator    *translator;          // Message translator
  FXint            appArgc;             // Argument count
  const FXchar *const *appArgv;         // Argument vector
  const FXchar    *inputmethod;         // Input method name
  const FXchar    *inputstyle;          // Input method style
  bool             initialized;         // Has been initialized
  FXAppDestructUpcall *destructUpcalls; // Destruction upcalls

private:
  static FXApp    *app;                 // Application pointer

  // Platform dependent private stuff
#ifndef WIN32
private:
  FXID             wmDeleteWindow;      // Catch delete window
  FXID             wmQuitApp;           // Catch quit application
  FXID             wmProtocols;         // Window manager protocols
  FXID             wmMotifHints;        // Motif hints
  FXID             wmTakeFocus;         // Focus explicitly set by app
  FXID             wmState;             // Window state
  FXID             wmNetState;          // Extended Window Manager window state
  FXID             wmNetIconName;       // Extended Window Manager icon name
  FXID             wmNetWindowName;     // Extended Window Manager window name
  FXID             wmNetSupported;      // Extended Window Manager states list
  FXID             wmNetWindowType;     // Extended Window Manager types
  FXID             wmNetHMaximized;     // Extended Window Manager horizontally maximized
  FXID             wmNetVMaximized;     // Extended Window Manager vertically maximized
  FXID             wmNetMoveResize;     // Extended Window Manager drag corner
  FXID             wmNetPing;           // Extended Window Manager ping
  FXID             wmNetTypes[8];       // Extended Window Manager window types
  FXID             wmNetStates[12];     // Extended Window Manager state
  FXID             wmWindowRole;        // Window Role
  FXID             wmClientLeader;      // Client leader
  FXID             wmClientId;          // Client id
  FXID             embedAtom;           // XEMBED support
  FXID             embedInfoAtom;       // XEMBED info support
  FXID             timestampAtom;       // Server time
  FXID             ddeTargets;          // DDE targets atom
  FXID             ddeAtom;             // DDE exchange atom
  FXID             ddeDelete;           // DDE delete target atom
  FXID             ddeIncr;             // DDE incremental data exchange atom
  FXDragType      *ddeTypeList;         // DDE drop type list
  FXuint           ddeNumTypes;         // DDE number of drop types
  FXDragAction     ddeAction;           // DDE action
  FXDragAction     ansAction;           // Reply action
  FXID             xcbSelection;        // Clipboard selection
  FXDragType      *xcbTypeList;         // Clipboard type list
  FXuint           xcbNumTypes;         // Clipboard number of types on list
  FXDragType      *xselTypeList;        // Selection type list
  FXuint           xselNumTypes;        // Selection number of types on list
  FXDragType      *xdndTypeList;        // XDND type list
  FXuint           xdndNumTypes;        // XDND number of types
  FXID             xdndProxy;           // XDND proxy atom
  FXID             xdndAware;           // XDND awareness atom
  FXID             xdndEnter;           // XDND enter window message
  FXID             xdndLeave;           // XDND leave window message
  FXID             xdndPosition;        // XDND position update message
  FXID             xdndStatus;          // XDND status feedback message
  FXID             xdndDrop;            // XDND drop message
  FXID             xdndFinished;        // XDND finished message
  FXID             xdndSelection;       // XDND selection atom
  FXID             xdndActionMove;      // XDND Move action
  FXID             xdndActionCopy;      // XDND Copy action
  FXID             xdndActionLink;      // XDND Link action
  FXID             xdndActionPrivate;   // XDND Private action
  FXID             xdndTypes;           // XDND types list atom
  FXID             xdndSource;          // XDND drag source window
  FXID             xdndTarget;          // XDND drop target window
  FXID             xdndProxyTarget;     // XDND window to set messages to
  FXbool           xdndStatusPending;   // XDND waiting for status feedback
  FXbool           xdndStatusReceived;  // XDND received at least one status
  FXbool           xdndWantUpdates;     // XDND target wants new positions while in rect
  FXbool           xdndFinishSent;      // XDND finish sent
  FXRectangle      xdndRect;            // XDND rectangle bounding target
  FXint            xrreventbase;        // XRR event base
  FXID             stipples[23];        // Standard stipple patterns
  void            *xim;                 // Input method
  FXbool           shmi;                // Use XSHM Image possible
  FXbool           shmp;                // Use XSHM Pixmap possible
  FXbool           synchronize;         // Synchronized

#else

  FXushort         ddeTargets;          // DDE targets atom
  FXushort         ddeAtom;             // DDE Exchange Atom
  FXDragType       ddeDelete;           // DDE Delete Target Atom
  FXDragType      *ddeTypeList;         // DDE drop type list
  FXuint           ddeNumTypes;         // DDE number of drop types
  FXDragAction     ddeAction;           // DDE action
  FXDragAction     ansAction;           // Reply action
  FXDragType      *xselTypeList;        // Selection type list
  FXuint           xselNumTypes;        // Selection number of types on list
  void*            xdndTypes;           // Handle to file mapping object for types list
  FXushort         xdndAware;           // XDND awareness atom
  FXID             xdndSource;          // XDND drag source window
  FXID             xdndTarget;          // XDND drop target window
  FXbool           xdndStatusPending;   // XDND waiting for status feedback
  FXbool           xdndFinishPending;   // XDND waiting for drop-confirmation
  FXbool           xdndStatusReceived;  // XDND received at least one status
  FXbool           xdndFinishSent;      // XDND finish sent
  FXRectangle      xdndRect;            // XDND rectangle bounding target
  FXID             stipples[17];        // Standard stipple bitmaps

#endif

private:

  // Internal helper functions
  FXApp(const FXApp&);
  FXApp &operator=(const FXApp&);
#ifndef WIN32
  static void imcreatecallback(void*,FXApp*,void*);
  static void imdestroycallback(void*,FXApp*,void*);
#else
protected:
  virtual long dispatchEvent(FXID hwnd,unsigned int iMsg,unsigned int wParam,long lParam);
#endif

protected:

  virtual bool getNextEvent(FXRawEvent& ev,bool blocking=true);

  virtual bool dispatchEvent(FXRawEvent& ev);

public:
  long onCmdQuit(FXObject*,FXSelector,void*);
  long onCmdDump(FXObject*,FXSelector,void*);
  long onCmdHover(FXObject*,FXSelector,void*);

public:

  enum {
    ID_QUIT=1,    
    ID_DUMP,      
    ID_HOVER,
    ID_LAST
    };

public:

  static const FXuchar *copyright;     

public:

  FXApp(const FXString& name="Application",const FXString& vendor="FoxDefault");

  const FXString& getAppName() const { return registry.getAppKey(); }

  const FXString& getVendorName() const { return registry.getVendorKey(); }

  bool openDisplay(const FXchar* dpyname=NULL);

  bool closeDisplay();

  void* getDisplay() const { return display; }

  bool isInitialized() const { return initialized; }

  FXint getArgc() const { return appArgc; }

  const FXchar *const *getArgv() const { return appArgv; }

  virtual FXEventLoop* getEventLoop() const;

  static FXEventLoop* getPrimaryEventLoop();

  bool hasInputMethod() const;

  FXVisual* getDefaultVisual() const { return defaultVisual; }

  void setDefaultVisual(FXVisual* vis);

  FXVisual* getMonoVisual() const { return monoVisual; }

  FXRootWindow* getRootWindow() const { return getEventLoop()->getRootWindow(); }

  void setRootWindow(FXRootWindow* rt) { return getEventLoop()->setRootWindow(rt); }

  FXWindow *getFocusWindow() const { return getEventLoop()->getFocusWindow(); }

  FXWindow *getCursorWindow() const { return getEventLoop()->getCursorWindow(); }

  FXWindow *getActiveWindow() const { return getEventLoop()->getActiveWindow(); }

  FXPopup* getPopupWindow() const { return getEventLoop()->getPopupWindow(); }

  FXWindow* findWindowWithId(FXID xid) const { return getEventLoop()->findWindowWithId(xid); }

  FXWindow* findWindowAt(FXint rx,FXint ry,FXID window=0) const { return getEventLoop()->findWindowAt(rx,ry,window); }

  virtual void create();

  virtual void destroy();

  virtual void detach();

  void addTimeout(FXObject* tgt,FXSelector sel,FXuint ms=1000,void* ptr=NULL) { return getEventLoop()->addTimeout(tgt,sel,ms,ptr); }

  void removeTimeout(FXObject* tgt,FXSelector sel) { return getEventLoop()->removeTimeout(tgt,sel); }

  bool hasTimeout(FXObject *tgt,FXSelector sel) const { return getEventLoop()->hasTimeout(tgt,sel); }

  FXuint remainingTimeout(FXObject *tgt,FXSelector sel) const { return getEventLoop()->remainingTimeout(tgt,sel); }

  void handleTimeouts() { return getEventLoop()->handleTimeouts(); }

  void addChore(FXObject* tgt,FXSelector sel,void *ptr=NULL) { return getEventLoop()->addChore(tgt,sel,ptr); }

  void removeChore(FXObject* tgt,FXSelector sel) { return getEventLoop()->removeChore(tgt,sel); }

  FXbool hasChore(FXObject *tgt,FXSelector sel) const { return getEventLoop()->hasChore(tgt,sel); }

  void addSignal(FXint sig,FXObject* tgt,FXSelector sel,FXbool immediate=FALSE,FXuint flags=0) { getEventLoop()->addSignal(sig,tgt,sel,immediate,flags); }

  void removeSignal(FXint sig) { getEventLoop()->removeSignal(sig); }

  bool addInput(FXInputHandle fd,FXuint mode,FXObject *tgt,FXSelector sel) { return getEventLoop()->addInput(fd,mode,tgt,sel); }

  bool removeInput(FXInputHandle fd,FXuint mode) { return getEventLoop()->removeInput(fd,mode); }

  bool getKeyState(FXuint keysym) const;

  bool peekEvent() { return getEventLoop()->peekEvent(); }

  bool runOneEvent(bool blocking=true) { return getEventLoop()->runOneEvent(blocking); }

  FXint run() { return getEventLoop()->run(); }

  FXint runUntil(FXuint& condition) { return getEventLoop()->runUntil(condition); }

  FXint runWhileEvents() { return getEventLoop()->runWhileEvents(); }

  FXint runModalWhileEvents(FXWindow* window=NULL) { return getEventLoop()->runModalWhileEvents(window); }

  FXint runModal() { return getEventLoop()->runModal(); }

  FXint runModalFor(FXWindow* window) { return getEventLoop()->runModalFor(window); }

  FXint runModalWhileShown(FXWindow* window) { return getEventLoop()->runModalWhileShown(window); }

  FXint runPopup(FXWindow* window) { return getEventLoop()->runPopup(window); }

  FXbool isModal(FXWindow* window) const { return getEventLoop()->isModal(window); }

  FXWindow* getModalWindow() const { return getEventLoop()->getModalWindow(); }

  FXModality getModality() const { return getEventLoop()->getModality(); }

  void stop(FXint value=0) { getEventLoop()->stop(value); }

  void stopModal(FXWindow* window,FXint value=0) { getEventLoop()->stopModal(window, value); }

  void stopModal(FXint value=0) { getEventLoop()->stopModal(value); }

  void forceRefresh() { getEventLoop()->forceRefresh(); }

  void refresh() { getEventLoop()->refresh(); }

  void flush(bool sync=false) { getEventLoop()->flush(sync); }

  void repaint() { getEventLoop()->repaint(); }

  virtual void init(int& argc,char** argv,bool connect=true);

  virtual void exit(FXint code=0);

  FXRegistry& reg(){ return registry; }

  FXDragType registerDragType(const FXString& name) const;

  FXString getDragTypeName(FXDragType type) const;

  FXWindow* getDragWindow() const { return getEventLoop()->getDragWindow(); }

  void beep();

  void errorBeep();

  static FXlong time();

  static inline FXApp* instance(){ return app; }

  void setNormalFont(FXFont* font);

  FXFont* getNormalFont() const { return normalFont; }

  void beginWaitCursor();

  void endWaitCursor();

  void setWaitCursor(FXCursor *cur);

  FXCursor* getWaitCursor() const { return waitCursor; }

  FXCursor* getDefaultCursor(FXDefaultCursor which) const { return cursor[which]; }

  void setDefaultCursor(FXDefaultCursor which,FXCursor* cur);

  FXbool writeWindow(FXStream& store,FXWindow *window);

  FXbool readWindow(FXStream& store,FXWindow*& window,FXWindow* father,FXWindow* owner);


  //void setTranslator(FXTranslator* trans);

  //FXTranslator* getTranslator() const { return translator; }

  FXuint getTypingSpeed() const { return typingSpeed; }
  FXuint getClickSpeed() const { return clickSpeed; }
  FXuint getScrollSpeed() const { return scrollSpeed; }
  FXuint getScrollDelay() const { return scrollDelay; }
  FXuint getBlinkSpeed() const { return blinkSpeed; }
  FXuint getAnimSpeed() const { return animSpeed; }
  FXuint getMenuPause() const { return menuPause; }
  FXuint getTooltipPause() const { return tooltipPause; }
  FXuint getTooltipTime() const { return tooltipTime; }
  FXint getDragDelta() const { return dragDelta; }
  FXint getWheelLines() const { return wheelLines; }
  FXint getScrollBarSize() const { return scrollBarSize; }

  void setTypingSpeed(FXuint speed);
  void setClickSpeed(FXuint speed);
  void setScrollSpeed(FXuint speed);
  void setScrollDelay(FXuint delay);
  void setBlinkSpeed(FXuint speed);
  void setAnimSpeed(FXuint speed);
  void setMenuPause(FXuint pause);
  void setTooltipPause(FXuint pause);
  void setTooltipTime(FXuint time);
  void setDragDelta(FXint delta);
  void setWheelLines(FXint lines);
  void setScrollBarSize(FXint size);

  FXColor getBorderColor() const { return borderColor; }
  FXColor getBaseColor() const { return baseColor; }
  FXColor getHiliteColor() const { return hiliteColor; }
  FXColor getShadowColor() const { return shadowColor; }
  FXColor getBackColor() const { return backColor; }
  FXColor getForeColor() const { return foreColor; }
  FXColor getSelforeColor() const { return selforeColor; }
  FXColor getSelbackColor() const { return selbackColor; }
  FXColor getTipforeColor() const { return tipforeColor; }
  FXColor getTipbackColor() const { return tipbackColor; }
  FXColor getSelMenuTextColor() const { return selMenuTextColor; }
  FXColor getSelMenuBackColor() const { return selMenuBackColor; }

  void setBorderColor(FXColor color);
  void setBaseColor(FXColor color);
  void setHiliteColor(FXColor color);
  void setShadowColor(FXColor color);
  void setBackColor(FXColor color);
  void setForeColor(FXColor color);
  void setSelforeColor(FXColor color);
  void setSelbackColor(FXColor color);
  void setTipforeColor(FXColor color);
  void setTipbackColor(FXColor color);
  void setSelMenuTextColor(FXColor color);
  void setSelMenuBackColor(FXColor color);

  FXuint getWindowCount() const { return windowCount; }

  virtual void save(FXStream& store) const;

  virtual void load(FXStream& store);

  void dumpWidgets() const;

  void addDestructionUpcall(void (*func)(void *), void *data);

  void removeDestructionUpcall(void (*func)(void *), void *data);

  virtual ~FXApp();
  };

#ifdef _MSC_VER
#pragma warning(pop)
#endif

class FXAPI FXLockHold
{
  FXbool locked;
  FXLockable *item;
public:
  FXLockHold(FXLockable *obj) : locked(FALSE), item(obj) { relock(); }

  FXLockHold(FXLockable &obj) : locked(FALSE), item(&obj) { relock(); }

  ~FXLockHold() { unlock(); }

  void relock(){
    if(!locked && item){
        item->lock();
        locked=TRUE;
      }
    }

  // Unlocks the item if locked
  void unlock(){
    if(locked && item){
      item->unlock();
      locked=FALSE;
      }
    }

  };

template<typename type> class FXEventLoop_Static
{
  void *ref;
public:
  FXEventLoop_Static(type *v=NULL) : ref(FXApp::instance()->getEventLoop()->makeStaticPtr(static_cast<void *>(v))) { }
  ~FXEventLoop_Static() { FXApp::instance()->getEventLoop()->deleteStaticPtr(ref); }
  type *operator=(type *v){
    FXApp::instance()->getEventLoop()->setStaticPtr(ref, static_cast<void *>(v));
    return v;
    }
  operator type *() const {
    return static_cast<type *>(FXApp::instance()->getEventLoop()->getStaticPtr(ref));
    }
  type *operator->() const {
    return static_cast<type *>(FXApp::instance()->getEventLoop()->getStaticPtr(ref));
    }
};

}

#endif
#endif

---

(C) 2002-2009 Niall Douglas. Some parts (C) to assorted authors.