fxruby 1.6.27-x64-mingw32

data/swig-interfaces/FX7Segment.i

@@ -0,0 +1,141 @@
+/***********************************************************************
+ * FXRuby -- the Ruby language bindings for the FOX GUI toolkit.
+ * Copyright (c) 2001-2009 by Lyle Johnson. 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
+ *
+ * For further information please contact the author by e-mail
+ * at "lyle@lylejohnson.name".
+ ***********************************************************************/
+
+
+/// 7 Segment styles
+enum {
+  SEVENSEGMENT_NORMAL   = 0,            /// Draw segments normally
+  SEVENSEGMENT_SHADOW   = 0x00080000    /// Draw shadow under the segments
+  };
+
+%rename("text=")	FX7Segment::setText(const FXString&);
+%rename("text")		FX7Segment::getText() const;
+%rename("textColor=")	FX7Segment::setTextColor(FXColor);
+%rename("textColor")	FX7Segment::getTextColor() const;
+%rename("cellWidth=")	FX7Segment::setCellWidth(FXint);
+%rename("cellWidth")	FX7Segment::getCellWidth() const;
+%rename("cellHeight=")	FX7Segment::setCellHeight(FXint);
+%rename("cellHeight")	FX7Segment::getCellHeight() const;
+%rename("thickness=")	FX7Segment::setThickness(FXint);
+%rename("thickness")	FX7Segment::getThickness() const;
+%rename("justify=")	FX7Segment::setJustify(FXuint);
+%rename("justify")	FX7Segment::getJustify() const;
+%rename("helpText=")	FX7Segment::setHelpText(const FXString&);
+%rename("helpText")	FX7Segment::getHelpText() const;
+%rename("tipText=")	FX7Segment::setTipText(const FXString&);
+%rename("tipText")	FX7Segment::getTipText() const;
+
+/**
+* Seven-segment (eg LCD/watch style) widget, useful for making
+* indicators and timers.  Besides numbers, the seven-segment
+* display widget can also display some letters and punctuations.
+*/
+class FX7Segment : public FXFrame {
+protected:
+  FXString label;       // Text being shown
+  FXColor  textColor;   // Text color
+  FXint    thickness;   // Segment thickness
+  FXint    cellwidth;   // Width of cell
+  FXint    cellheight;  // height of cell
+protected:
+  FX7Segment();
+public:
+  long onPaint(FXObject*,FXSelector,void* PTR_EVENT);
+  long onCmdSetValue(FXObject*,FXSelector,void*); // FIXME
+  long onCmdSetIntValue(FXObject*,FXSelector,void*); // FIXME
+  long onCmdSetRealValue(FXObject*,FXSelector,void*); // FIXME
+  long onCmdSetStringValue(FXObject*,FXSelector,void*); // FIXME
+  long onCmdGetIntValue(FXObject*,FXSelector,void*); // FIXME
+  long onCmdGetRealValue(FXObject*,FXSelector,void*); // FIXME
+  long onCmdGetStringValue(FXObject*,FXSelector,void*); // FIXME
+  long onCmdSetHelp(FXObject*,FXSelector,void*); // FIXME
+  long onCmdGetHelp(FXObject*,FXSelector,void*); // FIXME
+  long onCmdSetTip(FXObject*,FXSelector,void*); // FIXME
+  long onCmdGetTip(FXObject*,FXSelector,void*); // FIXME
+  long onQueryHelp(FXObject*,FXSelector,void*); // FIXME
+  long onQueryTip(FXObject*,FXSelector,void*); // FIXME
+public:
+
+  %extend {
+    /// Create a seven segment display
+    FX7Segment(FXComposite* p,const FXString& text,FXuint opts=SEVENSEGMENT_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRb7Segment(p,text,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+  }
+
+  /// Set the text for this label
+  void setText(const FXString& text);
+
+  /// Get the text for this label
+  FXString getText() const;
+
+  /// Change text color
+  void setTextColor(FXColor clr);
+
+  /// Return text color
+  FXColor getTextColor() const;
+
+  /// Get/set cell width
+  void setCellWidth(FXint w);
+  FXint getCellWidth() const;
+
+  /// Get/set cell height
+  void setCellHeight(FXint h);
+  FXint getCellHeight() const;
+
+  /// Get/set segment thickness
+  void setThickness(FXint t);
+  FXint getThickness() const;
+
+  /// Change 7 segment style
+  void set7SegmentStyle(FXuint style);
+
+  /// Get current 7 segment style
+  FXuint get7SegmentStyle() const;
+
+  /// Set the current text-justification mode.
+  void setJustify(FXuint mode);
+
+  /// Get the current text-justification mode.
+  FXuint getJustify() const;
+
+  /// Set the status line help text
+  void setHelpText(const FXString& text);
+
+  /// Get the status line help text
+  const FXString& getHelpText() const;
+
+  /// Set the tool tip message
+  void setTipText(const FXString& text);
+
+  /// Get the tool tip message
+  const FXString& getTipText() const;
+
+  /// Destroy
+  virtual ~FX7Segment();
+  };
+
+DECLARE_FXOBJECT_VIRTUALS(FX7Segment)
+DECLARE_FXID_VIRTUALS(FX7Segment)
+DECLARE_FXDRAWABLE_VIRTUALS(FX7Segment)
+DECLARE_FXWINDOW_VIRTUALS(FX7Segment)
+

data/swig-interfaces/FXAccelTable.i

@@ -0,0 +1,100 @@
+/***********************************************************************
+ * FXRuby -- the Ruby language bindings for the FOX GUI toolkit.
+ * Copyright (c) 2001-2009 by Lyle Johnson. 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
+ *
+ * For further information please contact the author by e-mail
+ * at "lyle@lylejohnson.name".
+ ***********************************************************************/
+
+/**
+ * The accelerator table sends a message to a specific
+ * target object when the indicated key and modifier combination
+ * is pressed.
+ */
+
+class FXAccelTable : public FXObject {
+protected:
+  struct FXAccelKey {
+    FXObject    *target;    // Target object of message
+    FXSelector   messagedn; // Message being sent
+    FXSelector   messageup; // Message being sent
+    FXHotKey     code;      // Keysym and modifier mask to match
+    };
+public:
+  long onKeyPress(FXObject*,FXSelector,void* PTR_EVENT);
+  long onKeyRelease(FXObject*,FXSelector,void* PTR_EVENT);
+public:
+  %extend {
+    /// Construct empty accelerator table
+    FXAccelTable(){
+      return new FXRbAccelTable();
+      }
+    }
+
+  /// Add an accelerator into the table
+  void addAccel(FXHotKey hotkey,FXObject* target=NULL,FXSelector seldn=0,FXSelector selup=0);
+
+  /// Remove an accelerator from the table
+  void removeAccel(FXHotKey hotkey);
+
+  /// Return true if accelerator specified
+  bool hasAccel(FXHotKey hotkey) const;
+
+  /// Return target object of the given accelerator
+  FXObject* targetOfAccel(FXHotKey hotkey) const;
+
+  /// Destructor
+  virtual ~FXAccelTable();
+  };
+
+DECLARE_FXOBJECT_VIRTUALS(FXAccelTable)
+
+/**
+* Parse accelerator from string, yielding modifier and
+* key code.  For example, parseAccel("Ctl+Shift+X")
+* yields MKUINT(KEY_X,CONTROLMASK|SHIFTMASK).
+*/
+FXHotKey parseAccel(const FXString& string);
+
+/**
+* Unparse hot key comprising modifier and key code back
+* into a string suitable for parsing with fxparseHotKey.
+*/
+FXString unparseAccel(FXHotKey key);
+
+/**
+* Parse hot key from string, yielding modifier and
+* key code.  For example, parseHotKey(""Salt && &Pepper!"")
+* yields MKUINT(KEY_p,ALTMASK).
+*/
+FXHotKey parseHotKey(const FXString& string);
+
+/**
+* Obtain hot key offset in string, or -1 if not found.
+* For example, findHotKey("Salt && &Pepper!") yields 7.
+* Note that this is the byte-offset, not the character
+* index!
+*/
+FXint findHotKey(const FXString& string);
+
+/**
+* Strip hot key combination from the string.
+* For example, stripHotKey("Salt && &Pepper") should
+* yield "Salt & Pepper".
+*/
+FXString stripHotKey(const FXString& string);
+

data/swig-interfaces/FXApp.i

@@ -0,0 +1,735 @@
+/***********************************************************************
+ * FXRuby -- the Ruby language bindings for the FOX GUI toolkit.
+ * Copyright (c) 2001-2009 by Lyle Johnson. 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
+ *
+ * For further information please contact the author by e-mail
+ * at "lyle@lylejohnson.name".
+ ***********************************************************************/
+
+// Forward declarations
+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;
+
+
+/// File input modes for addInput
+enum FXInputMode {
+  INPUT_NONE   = 0,                 /// Inactive
+  INPUT_READ   = 1,                 /// Read input fd
+  INPUT_WRITE  = 2,                 /// Write input fd
+  INPUT_EXCEPT = 4                  /// Except input fd
+  };
+
+
+/// All ways of being modal
+enum FXModality {
+  MODAL_FOR_NONE,                 /// Non modal event loop (dispatch normally)
+  MODAL_FOR_WINDOW,               /// Modal dialog (beep if outside of modal dialog)
+  MODAL_FOR_POPUP                 /// Modal for popup (always dispatch to popup)
+  };
+
+
+/// Default cursors provided by the application
+enum FXDefaultCursor {
+  DEF_ARROW_CURSOR,                     /// Arrow cursor
+  DEF_RARROW_CURSOR,                    /// Reverse arrow cursor
+  DEF_TEXT_CURSOR,                      /// Text cursor
+  DEF_HSPLIT_CURSOR,                    /// Horizontal split cursor
+  DEF_VSPLIT_CURSOR,                    /// Vertical split cursor
+  DEF_XSPLIT_CURSOR,                    /// Cross split cursor
+  DEF_SWATCH_CURSOR,                    /// Color swatch drag cursor
+  DEF_MOVE_CURSOR,                      /// Move cursor
+  DEF_DRAGH_CURSOR,                     /// Resize horizontal edge
+  DEF_DRAGV_CURSOR,                     /// Resize vertical edge
+  DEF_DRAGTL_CURSOR,                    /// Resize upper-leftcorner
+  DEF_DRAGBR_CURSOR=DEF_DRAGTL_CURSOR,  /// Resize bottom-right corner
+  DEF_DRAGTR_CURSOR,                    /// Resize upper-right corner
+  DEF_DRAGBL_CURSOR=DEF_DRAGTR_CURSOR,  /// Resize bottom-left corner
+  DEF_DNDSTOP_CURSOR,                   /// Drag and drop stop
+  DEF_DNDCOPY_CURSOR,                   /// Drag and drop copy
+  DEF_DNDMOVE_CURSOR,                   /// Drag and drop move
+  DEF_DNDLINK_CURSOR,                   /// Drag and drop link
+  DEF_CROSSHAIR_CURSOR,                 /// Cross hair cursor
+  DEF_CORNERNE_CURSOR,                  /// North-east cursor
+  DEF_CORNERNW_CURSOR,                  /// North-west cursor
+  DEF_CORNERSE_CURSOR,                  /// South-east cursor
+  DEF_CORNERSW_CURSOR,                  /// South-west cursor
+  DEF_HELP_CURSOR,                      /// Help arrow cursor
+  DEF_HAND_CURSOR,                      /// Hand cursor
+  DEF_ROTATE_CURSOR,                    /// Rotate cursor
+  DEF_WAIT_CURSOR                       /// Wait cursor
+  };
+
+
+/// FOX Event
+struct FXEvent {
+  FXEvent();
+  FXuint      type;           /// Event type
+  FXuint      time;           /// Time of last event
+  FXint       win_x;          /// Window-relative x-coord
+  FXint       win_y;          /// Window-relative y-coord
+  FXint       root_x;         /// Root x-coord
+  FXint       root_y;         /// Root y-coord
+  FXint       state;          /// Keyboard/Modifier state
+  FXint       code;           /// Button, Keysym, or mode; DDE Source
+  FXString    text;           /// Text of keyboard event
+  FXint       last_x;         /// Window-relative x-coord of previous mouse location
+  FXint       last_y;         /// Window-relative y-coord of previous mouse location
+  FXint       click_x;        /// Window-relative x-coord of mouse press
+  FXint       click_y;        /// Window-relative y-coord of mouse press
+  FXint       rootclick_x;    /// Root-relative x-coord of mouse press
+  FXint       rootclick_y;    /// Root-relative y-coord of mouse press
+  FXuint      click_time;     /// Time of mouse button press
+  FXuint      click_button;   /// Mouse button pressed
+  FXint       click_count;    /// Click-count
+  FXbool      moved;          /// Moved cursor since press
+  FXRectangle rect;           /// Rectangle
+  FXbool      synthetic;      /// True if synthetic expose event
+  FXDragType  target;         /// Target drag type being requested
+  ~FXEvent();
+  };
+
+
+// FXChore is an opaque struct for FOX; this is just a declaration for SWIG
+struct FXChore {
+  };
+
+
+// FXTimer is an opaque struct for FOX; this is just a declaration for SWIG
+struct FXTimer {
+  };
+
+%rename("hasInputMethod?") FXApp::hasInputMethod() const;
+%rename("hasChore?") FXApp::hasChore(FXObject *tgt,FXSelector sel) const;
+%rename("hasTimeout?") FXApp::hasTimeout(FXObject *tgt,FXSelector sel) const;
+%rename("focusWindow") FXApp::getFocusWindow() const;
+%rename("activeWindow") FXApp::getActiveWindow() const;
+%rename("scrollBarSize") FXApp::getScrollBarSize() const;
+%rename("scrollBarSize=") FXApp::setScrollBarSize(FXint);
+
+/// Application Object
+class FXApp : public FXObject {
+protected:
+
+  /// Return TRUE when new raw event is available
+  virtual bool getNextEvent(FXRawEvent& ev,FXbool blocking=TRUE);
+
+  /// Dispatch raw event
+  virtual bool dispatchEvent(FXRawEvent& ev);
+
+public:
+  long onCmdQuit(FXObject*,FXSelector,void* PTR_IGNORE);
+  long onCmdDump(FXObject*,FXSelector,void* PTR_IGNORE);
+  long onCmdHover(FXObject*,FXSelector,void* PTR_IGNORE);
+
+public:
+
+  // Messages applications understand
+  enum {
+    ID_QUIT=1,    /// Terminate the application normally
+    ID_DUMP,      /// Dump the current widget tree
+    ID_HOVER,
+    ID_LAST
+    };
+
+public:
+
+  %extend {
+    // Copyright notice for library
+    static VALUE copyright() {
+      return to_ruby(FXApp::copyright);
+    }
+  }
+
+public:
+
+  %extend {
+    /**
+    * Construct application object; the name and vendor strings are used
+    * as keys into the registry database for this application's settings
+    */
+    FXApp(const FXchar* name="Application",const FXchar* vendor="FoxDefault"){
+      if(FXApp::instance()){
+        rb_raise(rb_eRuntimeError,"attempted to create more than one FXApp instance");
+        return 0;
+        }
+      else{
+	      return FXRbApp::constructAndInit(name,vendor);
+        }
+      }
+  }
+
+  /// Get application name
+  const FXString& getAppName() const;
+
+  /// Get vendor name
+  const FXString& getVendorName() const;
+
+  /// Connection to display; this is called by init()
+  bool openDisplay(const FXchar* dpyname=NULL);
+
+  /// Close connection to the display
+  bool closeDisplay();
+
+  %extend {
+    /// Return pointer to display
+    FXuval getDisplay() const {
+      return reinterpret_cast<FXuval>(self->getDisplay());
+      }
+    }
+
+  /// Is application initialized
+  bool isInitialized() const;
+
+  /// Get argument count
+  FXint getArgc() const;
+
+  /// Get argument vector
+  const FXchar *const *getArgv() const; // FIXME
+
+  /// Return true if input method support
+  bool hasInputMethod() const;
+
+  /// Get default visual
+  FXVisual* getDefaultVisual() const;
+
+  %extend {
+    /// Change default visual
+    void setDefaultVisual(FXVisual* vis){
+      FXASSERT(vis);
+      if(vis->isMemberOf(FXMETACLASS(FXRbVisual))){
+        dynamic_cast<FXRbVisual*>(vis)->ownedByApp=TRUE;
+        }
+      else if(vis->isMemberOf(FXMETACLASS(FXRbGLVisual))){
+        dynamic_cast<FXRbGLVisual*>(vis)->ownedByApp=TRUE;
+        }
+      self->setDefaultVisual(vis);
+      }
+  }
+
+  /// Get monochrome visual
+  FXVisual* getMonoVisual() const;
+
+  /// Get root Window
+  FXRootWindow* getRootWindow() const;
+
+  /// Set root Window
+  void setRootWindow(FXRootWindow* rt);
+
+  /// Return window at the end of the focus chain
+  FXWindow *getFocusWindow() const;
+
+  /// Get the window under the cursor, if any
+  FXWindow *getCursorWindow() const;
+
+  /// Get the active toplevel window, if any
+  FXWindow *getActiveWindow() const;
+
+  /// Get current popup window, if any
+  FXPopup* getPopupWindow() const;
+
+  /// Find window from id
+  FXWindow* findWindowWithId(FXID xid) const;
+
+  /// Find window from root x,y, starting from given window
+  FXWindow* findWindowAt(FXint rx,FXint ry,FXID window=0) const;
+
+  /**
+  * Add timeout message to be sent to target object in ms milliseconds;
+  * the timer fires only once after the interval expires.  The void* ptr
+  * is user data which will be passed into the void* ptr of the message
+  * handler.  If a timer with the same target and message already exists,
+  * it will be rescheduled.
+  */
+  void addTimeout(FXObject* tgt,FXSelector sel,FXuint ms=1000,void* ptr=NULL);
+
+  /**
+  * Remove timeout identified by tgt and sel.
+  */
+  void removeTimeout(FXObject* tgt,FXSelector sel);
+
+   /**
+   * Return TRUE if given timeout has been set
+   */
+  bool hasTimeout(FXObject *tgt,FXSelector sel) const;
+
+   /**
+  * Return, in ms, the time remaining until the given timer fires.
+  * If the timer is past due, 0 is returned.  If there is no such
+  * timer, infinity (UINT_MAX) is returned.
+  */
+  FXuint remainingTimeout(FXObject *tgt,FXSelector sel);
+
+  /**
+   * Process any timeouts due at this time.
+   */
+  void handleTimeouts();
+
+  /**
+  * Add a idle processing message to be sent to target object when
+  * the system becomes idle, i.e. there are no events to be processed.
+  * The void* ptr is user data which will be passed into the void* ptr
+  * of the message handler. If a chore with the same target and message
+  * already exists, it will be rescheduled.
+  */
+  void addChore(FXObject* tgt,FXSelector sel,void *ptr=NULL);
+
+  /**
+  * Remove idle processing message(s) identified by tgt and sel.
+  */
+  void removeChore(FXObject* tgt,FXSelector sel);
+
+   /**
+  * Return TRUE if given chore has been set
+  */
+  bool hasChore(FXObject *tgt,FXSelector sel) const;
+
+  %extend {
+    /**
+    * Add signal processing message to be sent to target object when
+    * the signal sig is raised; flags are to be set as per POSIX definitions.
+    * When immediate is TRUE, the message will be sent to the target right away;
+    * this should be used with extreme care as the application is interrupted
+    * at an unknown point in its execution.
+    */
+    void addSignal(VALUE sigObj,FXObject* tgt,FXSelector sel,FXbool immediate=FALSE,FXuint flags=0){
+      const char *s;
+      FXint sig;
+      switch(TYPE(sigObj)){
+        case T_STRING:
+          s=StringValuePtr(sigObj);
+          sig=FXRbSignalNameToNumber(s);
+          if(sig==0) rb_raise(rb_eArgError,"unrecognized signal name `%s'",s);
+          break;
+        case T_FIXNUM:
+          sig=(FXint)NUM2INT(sigObj);
+          break;
+        default:
+          rb_raise(rb_eArgError,"bad signal type %s",rb_class2name(CLASS_OF(sigObj)));
+          break;
+        }
+      self->addSignal(sig,tgt,sel,immediate,flags);
+      }
+
+    /// Remove signal message for signal sig
+    void removeSignal(VALUE sigObj){
+      const char *s;
+      FXint sig;
+      switch(TYPE(sigObj)){
+        case T_STRING:
+          s=StringValuePtr(sigObj);
+          sig=FXRbSignalNameToNumber(s);
+          if(sig==0) rb_raise(rb_eArgError,"unrecognized signal name `%s'",s);
+          break;
+        case T_FIXNUM:
+          sig=(FXint)NUM2INT(sigObj);
+          break;
+        default:
+          rb_raise(rb_eArgError,"bad signal type %s",rb_class2name(CLASS_OF(sigObj)));
+          break;
+        }
+      self->removeSignal(sig);
+      }
+  }
+
+  %extend {
+    /**
+    * Add a file descriptor fd to be watched for activity as determined
+    * by mode, where mode is a bitwise OR (INPUT_READ, INPUT_WRITE, INPUT_EXCEPT).
+    * A message of type SEL_IO_READ, SEL_IO_WRITE, or SEL_IO_EXCEPT will be sent
+    * to the target when the specified activity is detected on the file descriptor.
+    */
+    bool addInput(VALUE obj,FXuint mode,FXObject *tgt,FXSelector sel){
+      FXInputHandle fd;
+      FXuint m;
+      if(mode&INPUT_READ){
+        m=INPUT_READ;
+	if(mode&INPUT_EXCEPT) m|=INPUT_EXCEPT;
+        fd=FXRbGetReadFileHandle(obj);
+	self->addInput(fd,m,tgt,sel);
+        }
+      if(mode&INPUT_WRITE){
+        m=INPUT_WRITE;
+	if(mode&INPUT_EXCEPT) m|=INPUT_EXCEPT;
+        fd=FXRbGetWriteFileHandle(obj);
+	self->addInput(fd,m,tgt,sel);
+        }
+      return true;
+      }
+
+    /**
+    * Remove input message and target object for the specified file descriptor
+    * and mode, which is a bitwise OR of (INPUT_READ, INPUT_WRITE, INPUT_EXCEPT).
+    */
+    bool removeInput(VALUE obj,FXuint mode){
+      FXInputHandle fd;
+      FXuint m;
+      if(mode&INPUT_READ){
+        m=INPUT_READ;
+	if(mode&INPUT_EXCEPT) m|=INPUT_EXCEPT;
+        fd=FXRbGetReadFileHandle(obj);
+	self->removeInput(fd,m);
+        }
+      if(mode&INPUT_WRITE){
+        m=INPUT_WRITE;
+	if(mode&INPUT_EXCEPT) m|=INPUT_EXCEPT;
+        fd=FXRbGetWriteFileHandle(obj);
+	self->removeInput(fd,m);
+        }
+      return true;
+      }
+  }
+
+  /// Return key state
+  bool getKeyState(FXuint keysym) const;
+
+  /// Peek to determine if there's an event
+  bool peekEvent();
+
+  /// Perform one event dispatch; return true if event was dispatched
+  bool runOneEvent(bool blocking=true);
+
+  /**
+  * Run the main application event loop until stop() is called,
+  * and return the exit code passed as argument to stop().
+  */
+  FXint run();
+
+  /**
+  * Run an event loop till some flag becomes non-zero, and
+  * then return.
+  */
+  FXint runUntil(FXuint& condition); // FIXME
+
+  /**
+  * Run event loop while events are available, non-modally.
+  * Return when no more events, timers, or chores are outstanding.
+  */
+  FXint runWhileEvents();
+
+  /**
+  * Run event loop while there are events are available in the queue.
+  * Returns 1 when all events in the queue have been handled, and 0 when
+  * the event loop was terminated due to stop() or stopModal().
+  * Except for the modal window and its children, user input to all windows
+  * is blocked; if the modal window is NULL, all user input is blocked.
+  */
+  FXint runModalWhileEvents(FXWindow* window=NULL);
+
+  /**
+  * Run modal event loop, blocking keyboard and mouse events to all windows
+  * until stopModal is called.
+  */
+  FXint runModal();
+
+  /**
+  * Run a modal event loop for the given window, until stop() or stopModal() is
+  * called. Except for the modal window and its children, user input to all
+  * windows is blocked; if the modal window is NULL all user input is blocked.
+  */
+  FXint runModalFor(FXWindow* window);
+
+  /**
+  * Run modal while window is shown, or until stop() or stopModal() is called.
+  * Except for the modal window and its children, user input to all windows
+  * is blocked; if the modal window is NULL all user input is blocked.
+  */
+  FXint runModalWhileShown(FXWindow* window);
+
+  /**
+  * Run popup menu while shown, until stop() or stopModal() is called.
+  * Also returns when entering previous cascading popup menu.
+  */
+  FXint runPopup(FXWindow* owner);
+
+  /// True if the window is modal
+  bool isModal(FXWindow* window) const;
+
+  /// Return window of current modal loop
+  FXWindow* getModalWindow() const;
+
+  /// Return mode of current modal loop
+  FXModality getModality() const;
+
+  /**
+  * Terminate the outermost event loop, and all inner modal loops;
+  * All more deeper nested event loops will be terminated with code equal
+  * to 0, while the outermost event loop will return code equal to value.
+  */
+  void stop(FXint value=0);
+
+  /**
+  * Break out of the matching modal loop, returning code equal to value.
+  * All deeper nested event loops are terminated with code equal to 0.
+  */
+  void stopModal(FXWindow* window,FXint value=0);
+
+  /**
+  * Break out of the innermost modal loop, returning code equal to value.
+  */
+  void stopModal(FXint value=0);
+
+  /// Force GUI refresh
+  void forceRefresh();
+
+  /// Schedule a refresh
+  void refresh();
+
+  /// Flush pending repaints
+  void flush(bool sync=false);
+
+  /**
+  * Paint all windows marked for repainting.
+  * On return all the applications windows have been painted.
+  */
+  void repaint();
+
+  /**
+   * Return a reference to the registry.  The registry keeps
+   * settings and configuration information for an application,
+   * which are automatically loaded when the application starts
+   * up, and saved when the application terminates.
+   */
+  FXRegistry& reg();
+
+  /// Register new DND type
+  FXDragType registerDragType(const FXString& name) const;
+
+  /// Get drag type name
+  FXString getDragTypeName(FXDragType type) const;
+
+  /// Return drag window if a drag operation is in progress
+  FXWindow* getDragWindow() const;
+
+  /// Beep
+  void beep();
+
+  /// Return application instance
+  static inline FXApp* instance();
+
+  %extend {
+    /// Change default font
+    void setNormalFont(FXFont* font){
+      FXASSERT(font);
+      if(font->isMemberOf(FXMETACLASS(FXRbFont))){
+        dynamic_cast<FXRbFont*>(font)->ownedByApp=TRUE;
+	}
+      self->setNormalFont(font);
+      }
+  }
+
+  /// Return default font
+  FXFont* getNormalFont() const;
+
+  /// Begin of wait-cursor block; wait-cursor blocks may be nested.
+  void beginWaitCursor();
+
+  /// End of wait-cursor block
+  void endWaitCursor();
+
+  %extend {
+    /// Change to a new wait cursor
+    void setWaitCursor(FXCursor *cur){
+      FXASSERT(cur);
+      if(cur->isMemberOf(FXMETACLASS(FXRbCursor))){
+        dynamic_cast<FXRbCursor*>(cur)->ownedByApp=TRUE;
+	}
+      else if(cur->isMemberOf(FXMETACLASS(FXRbCURCursor))){
+        dynamic_cast<FXRbCURCursor*>(cur)->ownedByApp=TRUE;
+	}
+      else if(cur->isMemberOf(FXMETACLASS(FXRbGIFCursor))){
+        dynamic_cast<FXRbGIFCursor*>(cur)->ownedByApp=TRUE;
+	}
+      self->setWaitCursor(cur);
+      }
+  }
+
+  /// Return current wait cursor
+  FXCursor* getWaitCursor() const;
+
+  /// Obtain a default cursor
+  FXCursor* getDefaultCursor(FXDefaultCursor which) const;
+
+  %extend {
+    /// Change default cursor
+    void setDefaultCursor(FXDefaultCursor which,FXCursor* cur){
+      FXASSERT(cur);
+      if(cur->isMemberOf(FXMETACLASS(FXRbCursor))){
+        dynamic_cast<FXRbCursor*>(cur)->ownedByApp=TRUE;
+	}
+      else if(cur->isMemberOf(FXMETACLASS(FXRbCURCursor))){
+        dynamic_cast<FXRbCURCursor*>(cur)->ownedByApp=TRUE;
+	}
+      else if(cur->isMemberOf(FXMETACLASS(FXRbGIFCursor))){
+        dynamic_cast<FXRbGIFCursor*>(cur)->ownedByApp=TRUE;
+	}
+      self->setDefaultCursor(which,cur);
+      }
+  }
+
+  /**
+   * Write a window and its children, and all resources reachable from this
+   * window, into the stream store.
+   */
+  FXbool writeWindow(FXStream& store,FXWindow *window);
+
+  %extend {
+    /**
+     * Read a window and its children from the stream store, and append
+     * it under father; note it is initially not created yet.
+     */
+    FXWindow* readWindow(FXStream& store,FXWindow*& window,FXWindow* father,FXWindow* owner){
+      window=0;
+      self->readWindow(store,window,father,owner);
+      return window;
+      }
+  }
+
+  /**
+  * Return a reference to the application-wide mutex.
+  * Normally, the main user interface thread holds this mutex,
+  * insuring that no other threads are modifying data during the
+  * processing of user interface messages. However, whenever the
+  * main user interface thread blocks for messages, it releases
+  * this mutex, to allow other threads to modify the same data.
+  * When a new message becomes available, the main user interface
+  * thread regains the mutex prior to dispatching the message.
+  * Other threads should hold this mutex only for short durations,
+  * so as to not starve the main user interface thread.
+  */
+  FXMutex& mutex();
+
+  /**
+  * Change message translator.
+  * The new translator will be owned by FXApp.
+  */
+  void setTranslator(FXTranslator* trans);
+
+  /// Return message translator
+  FXTranslator* getTranslator() const;
+
+  /// Obtain application-wide settings
+  FXuint getTypingSpeed() const;
+  FXuint getClickSpeed() const;
+  FXuint getScrollSpeed() const;
+  FXuint getScrollDelay() const;
+  FXuint getBlinkSpeed() const;
+  FXuint getAnimSpeed() const;
+  FXuint getMenuPause() const;
+  FXuint getTooltipPause() const;
+  FXuint getTooltipTime() const;
+  FXint getDragDelta() const;
+  FXint getWheelLines() const;
+  FXint getScrollBarSize() const;
+
+  /// Change application-wide settings
+  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);
+
+  /// Obtain default colors
+  FXColor getBorderColor() const;
+  FXColor getBaseColor() const;
+  FXColor getHiliteColor() const;
+  FXColor getShadowColor() const;
+  FXColor getBackColor() const;
+  FXColor getForeColor() const;
+  FXColor getSelforeColor() const;
+  FXColor getSelbackColor() const;
+  FXColor getTipforeColor() const;
+  FXColor getTipbackColor() const;
+  FXColor getSelMenuTextColor() const;
+  FXColor getSelMenuBackColor() const;
+
+  /// Change default colors
+  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);
+
+  /// Dump widget information
+  void dumpWidgets() const;
+
+  /// Get number of existing windows
+  FXuint getWindowCount() const;
+
+  /// Destroy the application and all reachable resources
+  virtual ~FXApp();
+  };
+
+DECLARE_FXOBJECT_VIRTUALS(FXApp)
+DECLARE_FXAPP_VIRTUALS(FXApp)
+
+#ifdef SWIGRUBY
+
+%rename("threadsEnabled=") FXApp::setThreadsEnabled(FXbool);
+%rename("threadsEnabled?") FXApp::threadsEnabled() const;
+
+%extend FXApp {
+  // Enable (or disable) support for multithreaded applications
+  void setThreadsEnabled(FXbool enabled){
+    FXASSERT(self->isMemberOf(FXMETACLASS(FXRbApp)));
+    dynamic_cast<FXRbApp*>(self)->setThreadsEnabled(enabled);
+    }
+
+  // Are threads enabled?
+  FXbool threadsEnabled() const {
+    FXASSERT(self->isMemberOf(FXMETACLASS(FXRbApp)));
+    return dynamic_cast<const FXRbApp*>(self)->threadsEnabled();
+    }
+
+  // Set the amount of time to sleep
+  void setSleepTime(FXuint sleepTime){
+    FXASSERT(self->isMemberOf(FXMETACLASS(FXRbApp)));
+    dynamic_cast<FXRbApp*>(self)->setSleepTime(sleepTime);
+    }
+
+  // Get the amount of time to sleep
+  FXuint getSleepTime() const {
+    FXASSERT(self->isMemberOf(FXMETACLASS(FXRbApp)));
+    return dynamic_cast<const FXRbApp*>(self)->getSleepTime();
+    }
+  }
+
+#endif