fxruby 1.6.19-x86-mingw32

data/lib/fox16/version.rb

@@ -0,0 +1,9 @@
+module Fox
+  #
+  # Returns the FXRuby version number as a string, e.g. "1.0.19".
+  #
+  def Fox.fxrubyversion
+    "1.6.19"
+  end
+end
+

data/rdoc-sources/FX4Splitter.rb

@@ -0,0 +1,156 @@
+module Fox
+
+  #
+  # The four-way splitter is a layout manager which manages
+  # four children like four panes in a window.
+  # You can use a four-way splitter for example in a CAD program
+  # where you may want to maintain three orthographic views, and
+  # one oblique view of a model.
+  # The four-way splitter allows interactive repartitioning of the
+  # panes by means of moving the central splitter bars.
+  # When the four-way splitter is itself resized, each child is
+  # proportionally resized, maintaining the same split-percentage.
+  #
+  # === Events
+  #
+  # The following messages are sent by FX4Splitter to its target:
+  #
+  # +SEL_LEFTBUTTONPRESS+::	sent when the left mouse button goes down; the message data is an FXEvent instance.
+  # +SEL_LEFTBUTTONRELEASE+::	sent when the left mouse button goes up; the message data is an FXEvent instance.
+  # +SEL_COMMAND+::		sent at the end of a resize operation, to signal that the resize is complete
+  # +SEL_CHANGED+::		sent continuously while a resize operation is occurring
+  #
+  # === Splitter options
+  #
+  # +FOURSPLITTER_TRACKING+::   Track continuously during split
+  # +FOURSPLITTER_NORMAL+::     Normal mode (no continuous tracking)
+  #
+  # === Expansion options
+  #
+  # +ExpandNone+::		None expanded
+  # +ExpandTopLeft+::		Expand top left child
+  # +ExpandTopRight+::		Expand top right child
+  # +ExpandBottomLeft+::	Expand bottom left child
+  # +ExpandBottomRight+::	Expand bottom right child
+  # +ExpandTop+::		Expand top children
+  # +ExpandBottom+::		Expand bottom children
+  # +ExpandLeft+::		Expand left children
+  # +ExpandRight+::		Expand right children
+  # +ExpandAll+::		Expand all children
+  #
+  # === Message identifiers
+  #
+  # +ID_EXPAND_NONE+::		None expanded
+  # +ID_EXPAND_TOP+::		Expand top left and top right panes
+  # +ID_EXPAND_BOTTOM+::	Expand bottom left and bottom right panes
+  # +ID_EXPAND_LEFT+::		Expand leftmost panes
+  # +ID_EXPAND_RIGHT+::		Expand rightmost panes
+  # +ID_EXPAND_TOPLEFT+::	Expand top left pane
+  # +ID_EXPAND_TOPRIGHT+::	Expand top right pane
+  # +ID_EXPAND_BOTTOMLEFT+::	Expand bottom left pane
+  # +ID_EXPAND_BOTTOMRIGHT+::	Expand bottom right pane
+  # +ID_EXPAND_ALL+::		Expand all panes
+  #
+  class FX4Splitter < FXComposite
+
+    # Horizontal split fraction [Integer]
+    attr_accessor :hSplit
+    
+    # Vertical split fraction [Integer]
+    attr_accessor :vSplit
+    
+    # Current splitter style, either +FOURSPLITTER_TRACKING+ or +FOURSPLITTER_NORMAL+
+    attr_accessor :splitterStyle
+    
+    # Splitter bar width, in pixels [Integer]
+    attr_accessor :barSize
+    
+    # Currently expanded child (some combination of the expansion flags, or zero if no panes are expanded)
+    attr_accessor :expanded
+    
+    # Top left child window, if any [FXWindow]
+    attr_reader :topLeft
+    
+    # Top right child window, if any [FXWindow]
+    attr_reader :topRight
+    
+    # Bottom left child window, if any [FXWindow]
+    attr_reader :bottomLeft
+    
+    # Bottom right child window, if any [FXWindow]
+    attr_reader :bottomRight
+
+    #
+    # Return an initialized FX4Splitter instance, initially shown as four unexpanded panes
+    #
+    # ==== Parameters:
+    #
+    # +p+::	the parent widget for this splitter [FXComposite]
+    # +opts+::	the options [Integer]
+    # +x+::	initial x-position [Integer]
+    # +y+::	initial y-position [Integer]
+    # +width+::	initial width [Integer]
+    # +height+::	initial height [Integer]
+    #
+    def initialize(p, opts=FOURSPLITTER_NORMAL, x=0, y=0, width=0, height=0) # :yields: theSplitter
+    end
+    
+    #
+    # Return an initialized FX4Splitter instance, initially shown as four unexpanded panes;
+    # notifies _tgt_ about size changes.
+    #
+    # ==== Parameters:
+    #
+    # +p+::	the parent widget for this splitter [FXComposite]
+    # +target+::	message target [FXObject]
+    # +selector+::	message identifier [Integer]
+    # +opts+::	the options [Integer]
+    # +x+::	initial x-position [Integer]
+    # +y+::	initial y-position [Integer]
+    # +width+::	initial width [Integer]
+    # +height+::	initial height [Integer]
+    #
+    def initialize(p, tgt, sel, opts=FOURSPLITTER_NORMAL, x=0, y=0, width=0, height=0) # :yields: theSplitter
+    end
+
+    #
+    # Change horizontal split fraction. The split fraction _s_ is
+    # an integer value between 0 and 10000 (inclusive), indicating
+    # how much space to allocate to the leftmost panes. For example,
+    # to split the panes at 35 percent, use:
+    #
+    #   fourSplitter.setHSplit(3500)
+    #
+    # or just:
+    #
+    #   fourSplitter.hSplit = 3500
+    #
+    def setHSplit(s); end
+
+    #
+    # Return the horizontal split fraction, an integer between 0 and
+    # 10000 inclusive. See FX4Splitter#setHSplit for more information.
+    #
+    def getHSplit(); end
+
+    #
+    # Change vertical split fraction. The split fraction _s_ is
+    # an integer value between 0 and 10000 (inclusive), indicating
+    # how much space to allocate to the topmost panes. For example,
+    # to split the panes at 35 percent, use:
+    #
+    #   fourSplitter.setVSplit(3500)
+    #
+    # or just:
+    #
+    #   fourSplitter.vSplit = 3500
+    #
+    def setVSplit(s); end
+
+    #
+    # Return the vertical split fraction, an integer between 0 and
+    # 10000 inclusive. See FX4Splitter#setVSplit for more information.
+    #
+    def getVSplit(); end
+  end
+end

data/rdoc-sources/FX7Segment.rb

@@ -0,0 +1,54 @@
+module Fox
+  #
+  # 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.
+  #
+  # === 7 Segment styles
+  #
+  # +SEVENSEGMENT_NORMAL+::	Draw segments normally
+  # +SEVENSEGMENT_SHADOW+::	Draw shadow under the segments
+  #
+  class FX7Segment < FXFrame
+    # The text for this label [String]
+    attr_accessor :text
+    
+    # The text color [FXColor]
+    attr_accessor :textColor
+    
+    # Cell width, in pixels [Integer]
+    attr_accessor :cellWidth
+    
+    # Cell height, in pixels [Integer]
+    attr_accessor :cellHeight
+    
+    # Segment thickness, in pixels [Integer]
+    attr_accessor :thickness
+    
+    # Current text-justification mode [Integer]
+    attr_accessor :justify
+    
+    # Status line help text [String]
+    attr_accessor :helpText
+    
+    # Tool tip message [String]
+    attr_accessor :tipText
+    
+    # Create a seven segment display
+    def initialize(p, text, opts=SEVENSEGMENT_NORMAL, x=0, y=0, width=0, height=0, padLeft=DEFAULT_PAD, padRight=DEFAULT_PAD, padTop=DEFAULT_PAD, padBottom=DEFAULT_PAD) # :yields: the7Segment
+    end
+  
+    #
+    # Change 7 segment style, where _style_ is either +SEVENSEGMENT_NORMAL+ or
+    # +SEVENSEGMENT_SHADOW+.
+    #
+    def set7SegmentStyle(style); end
+
+    #
+    # Return the current 7 segment style, which is either +SEVENSEGMENT_NORMAL+
+    # or +SEVENSEGMENT_SHADOW+.
+    #
+    def get7SegmentStyle(); end
+  end
+end
+

data/rdoc-sources/FXAccelTable.rb

@@ -0,0 +1,84 @@
+module Fox
+  #
+  # The accelerator table sends a message to a specific
+  # target object when the indicated key and modifier combination
+  # is pressed.
+  #
+  class FXAccelTable < FXObject
+    #
+    # Construct empty accelerator table.
+    #
+    def initialize # :yields: acceleratorTable
+    end
+
+    #
+    # Remove an accelerator from the table.
+    #
+    def removeAccel(hotKey) ; end
+
+    #
+    # Return +true+ if accelerator specified.
+    # Here, _hotKey_ is a code representing an accelerator key as returned
+    # by the Fox.fxparseAccel method. For example,
+    #
+    #   if accelTable.hasAccel?(fxparseAccel("Ctrl+S"))
+    #     ...
+    #   end
+    #
+    def hasAccel?(hotKey) ; end
+
+    #
+    # Return the target object of the given accelerator, or +nil+ if
+    # the accelerator is not present in this accelerator table.
+    # Here, _hotKey_ is a code representing an accelerator key as returned
+    # by the Fox.fxparseAccel method. For example,
+    #
+    #   doc = accelTable.targetofAccel(fxparseAccel("Ctrl+S"))
+    #
+    def targetOfAccel(hotKey) ; end
+  
+    #
+    # Remove mapping for specified hot key.
+    # Here, _hotKey_ is a code representing an accelerator key as returned
+    # by the Fox.fxparseAccel method. For example,
+    #
+    #   accelTable.removeAccel(fxparseAccel("Ctrl+S"))
+    #
+    def removeAccel(hotKey) ; end
+  end
+
+  #
+  # Parse accelerator from string, yielding modifier and
+  # key code.  For example, parseAccel("Ctl+Shift+X")
+  # yields MKUINT(KEY_X,CONTROLMASK|SHIFTMASK).
+  #
+  def parseAccel(string); end
+
+  #
+  # Unparse hot key comprising modifier and key code back
+  # into a string suitable for parsing with #parseHotKey.
+  #
+  def unparseAccel(key); end
+
+  #
+  # Parse hot key from string, yielding modifier and
+  # key code.  For example, parseHotKey(""Salt && &Pepper!"")
+  # yields MKUINT(KEY_p,ALTMASK).
+  #
+  def parseHotKey(string); end
+
+  #
+  # 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!
+  #
+  def findHotKey(string); end
+
+  #
+  # Strip hot key combination from the string.
+  # For example, stripHotKey("Salt && &Pepper") should
+  # yield "Salt & Pepper".
+  #
+  def stripHotKey(string); end
+end

data/rdoc-sources/FXApp.rb

@@ -0,0 +1,545 @@
+module Fox
+  # FOX Event 
+  class FXEvent
+  
+    # Event type [Integer]
+    attr_reader :type
+    
+    # Time of last event [Integer]
+    attr_reader :time
+    
+    # Window-relative x-coordinate [Integer]
+    attr_reader :win_x
+    
+    # Window-relative y-coordinate [Integer]
+    attr_reader :win_y
+    
+    # Root window x-coordinate [Integer]
+    attr_reader :root_x
+    
+    # Root window y-coordinate [Integer]
+    attr_reader :root_y
+    
+    # Keyboard/modifier state [Integer]
+    attr_reader :state
+    
+    # Button, keysym or mode; DDE source [Integer]
+    attr_reader :code
+    
+    # Text of keyboard event [String]
+    attr_reader :text
+    
+    # Window-relative x-coordinate of previous mouse location [Integer]
+    attr_reader :last_x
+    
+    # Window-relative y-coordinate of previous mouse location [Integer]
+    attr_reader :last_y
+    
+    # Window-relative x-coordinate of mouse press [Integer]
+    attr_reader :click_x
+    
+    # Window-relative y-coordinate of mouse press [Integer]
+    attr_reader :click_y
+    
+    # Root window x-coordinate of mouse press [Integer]
+    attr_reader :rootclick_x
+    
+    # Root window y-coordinate of mouse press [Integer]
+    attr_reader :rootclick_y
+    
+    # Time of mouse button press [Integer]
+    attr_reader :click_time
+    
+    # Mouse button pressed [Integer]
+    attr_reader :click_button
+    
+    # Click count [Integer]
+    attr_reader :click_count
+    
+    # Target drag type being requested [Integer]
+    attr_reader :target
+
+    # Return true if cursor moved since last press
+    def moved? ; end
+
+    # Exposed rectangle for paint events
+    def rect ; end
+
+    # Return true if this is a synthetic expose event
+    def synthetic? ; end
+  end
+
+  #
+  # Application Object
+  #
+  # === Events
+  #
+  # The FXApp object itself doesn't have a designated message target like
+  # other FOX objects, but it can send messages to objects for a few
+  # special events.
+  #
+  # [*Timers*]
+  #   When a timeout event is registered with the application using the
+  #   addTimeout method, a +SEL_TIMEOUT+ message is sent to the message
+  #   target.
+  # [*Chores*]
+  #   When a chore event is registered with the application using the
+  #   addChore method, a +SEL_CHORE+ message is sent to the message target.
+  # [*Inputs*]
+  #   When an input event is registered with the application using the
+  #   addInput method, a +SEL_IO_READ+, +SEL_IO_WRITE+ or +SEL_IO_EXCEPT+
+  #   message may be sent to the message target.
+  # [*Signals*]
+  #   When a signal handler object is registered with the application using
+  #   the addSignal method, a +SEL_SIGNAL+ message may be sent to the message
+  #   target.
+  # 
+  # === File input modes for #addInput
+  #
+  # +INPUT_NONE+::		inactive
+  # +INPUT_READ+::		read input fd
+  # +INPUT_WRITE+::		write input fd
+  # +INPUT_EXCEPT+::		except input fd
+  #
+  # === All ways of being modal
+  #
+  # +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
+  #
+  # These constants symbolically represent the different cursor shapes used
+  # in FOX applications, and can be used as the _which_ arguments for
+  # #getDefaultCursor and #setDefaultCursor.
+  #
+  # +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+::     Resize bottom-right corner
+  # +DEF_DRAGTR_CURSOR+::     Resize upper-right corner
+  # +DEF_DRAGBL_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
+  #
+  # === Messages identifiers
+  #
+  # +ID_QUIT+::               Terminate the application normally
+  # +ID_DUMP+::               Dump the current widget tree
+
+  class FXApp < FXObject
+
+    # Application name [String]
+    attr_reader :appName
+
+    # Vendor name [String]
+    attr_reader :vendorName
+    
+    # Argument count [Integer]
+    attr_reader :argc
+    
+    # Argument vector [Array]
+    attr_reader :argv
+
+    # Display [Integer]
+    attr_reader :display
+
+    # Border color [FXColor]
+    attr_accessor :borderColor
+
+    # Background color of GUI controls [FXColor]
+    attr_accessor :baseColor
+
+    # Hilite color of GUI controls [FXColor]
+    attr_accessor :hiliteColor
+
+    # Shadow color of GUI controls [FXColor]
+    attr_accessor :shadowColor
+
+    # Default background color [FXColor]
+    attr_accessor :backColor
+
+    # Default foreground color [FXColor]
+    attr_accessor :foreColor
+
+    # Default foreground color for selected objects [FXColor]
+    attr_accessor :selforeColor
+
+    # Default background color for selected objects [FXColor]
+    attr_accessor :selbackColor
+
+    # Default foreground color for tooltips [FXColor]
+    attr_accessor :tipforeColor
+
+    # Default background color for tooltips [FXColor]
+    attr_accessor :tipbackColor
+    
+    # Default text color for selected menu items [FXColor]
+    attr_accessor :selMenuTextColor
+    
+    # Default background color for selected menu items [FXColor]
+    attr_accessor :selMenuBackColor
+
+    # Default visual [FXVisual]
+    attr_accessor :defaultVisual
+
+    # Default font [FXFont]
+    attr_accessor :normalFont
+
+    # Wait cursor [FXCursor]
+    attr_accessor :waitCursor
+
+    # Monochrome visual [FXVisual]
+    attr_reader :monoVisual
+
+    # Root window [FXRootWindow]
+    attr_reader :rootWindow
+
+    # The window under the cursor, if any [FXWindow]
+    attr_reader :cursorWindow
+
+    # The window at the end of the focus chain, if any [FXWindow]
+    attr_reader :focusWindow
+    
+    # The active top-level window, if any [FXWindow]
+    attr_reader :activeWindow
+
+    # The main window, if any [FXWindow]
+    attr_reader :mainWindow
+
+    # The window of the current modal loop [FXWindow]
+    attr_reader :modalWindow
+
+    # Mode of current modal loop [Integer]
+    attr_reader :modalModality
+
+    # Typing speed used for the FXIconList, FXList and FXTreeList widgets' lookup features,
+    # in milliseconds. Default value is 1000 milliseconds.
+    attr_accessor :typingSpeed
+
+    # Click speed, in milliseconds [Integer]
+    attr_accessor :clickSpeed
+
+    # Scroll speed, in milliseconds [Integer]
+    attr_accessor :scrollSpeed
+
+    # Scroll delay time, in milliseconds [Integer]
+    attr_accessor :scrollDelay
+
+    # Blink speed, in milliseconds [Integer]
+    attr_accessor :blinkSpeed
+
+    # Animation speed, in milliseconds [Integer]
+    attr_accessor :animSpeed
+
+    # Menu pause, in milliseconds [Integer]
+    attr_accessor :menuPause
+
+    # Tooltip pause, in milliseconds [Integer]
+    attr_accessor :tooltipPause
+
+    # Tooltip time, in milliseconds [Integer]
+    attr_accessor :tooltipTime
+
+    # Drag delta, in pixels [Integer]
+    attr_accessor :dragDelta
+
+    # Number of wheel lines [Integer]
+    attr_accessor :wheelLines
+    
+    # Scroll bar size [Integer]
+    attr_accessor :scrollBarSize
+
+    # Amount of time (in milliseconds) to yield to Ruby's thread scheduler [Integer]
+    attr_accessor :sleepTime
+    
+    # Message translator [FXTranslator]
+    attr_accessor :translator
+
+    # Copyright notice for library
+    def FXApp.copyright() ; end
+
+    #
+    # Construct application object; the _appName_ and _vendorName_ strings are used
+    # as keys into the registry database for this application's settings.
+    # Only one single application object can be constructed.
+    #
+    def initialize(appName="Application", vendorName="FoxDefault") # :yields: theApp
+    end
+
+    #
+    # Open connection to display; this is called by #init.
+    #
+    def openDisplay(dpyname=nil) ; end
+  
+    # Close connection to the display
+    def closeDisplay() ; end
+
+    # Return true if the application has been initialized.
+    def initialized?; end
+
+    # Return +true+ if input methods are supported.
+    def hasInputMethod?; end
+
+    #
+    # Process any timeouts due at this time.
+    #
+    def handleTimeouts(); end
+    
+    #
+    # 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.
+    #
+    def addSignal(sig, tgt, sel, immediate=false, flags=0) ; end
+
+    #
+    # Remove signal message for signal _sig_.
+    #
+    def removeSignal(sig) ; end
+
+    #
+    # 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+).
+    #
+    def removeInput(fd, mode) ; end
+
+    # Create application's windows
+    def create() ; end
+
+    # Destroy application's windows
+    def destroy() ; end
+
+    # Detach application's windows
+    def detach() ; end
+
+    #
+    # Return key state (either +true+ or +false+) for _keysym_.
+    #
+    def getKeyState(keysym); end
+
+    #
+    # Peek to determine if there's an event.
+    #
+    def peekEvent(); end
+
+    # Perform one event dispatch; return +true+ if event was dispatched.
+    def runOneEvent(blocking=true); end
+
+    # Run the main application event loop until #stop is called,
+    # and return the exit code passed as argument to #stop.
+    def run(); end
+
+    #
+    # Run an event loop till some flag becomes non-zero, and
+    # then return.
+    #
+    def runUntil(condition); end
+
+    #
+    # Run event loop while events are available, non-modally.
+    # Return when no more events, timers, or chores are outstanding.
+    #
+    def runWhileEvents(); end
+
+    #
+    # 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 +nil+, all user input is blocked.
+    #
+    def runModalWhileEvents(window=nil); end
+
+    # Run modal event loop, blocking keyboard and mouse events to all windows
+    # until #stopModal is called.
+    def runModal(); end
+
+    # 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 +nil+ all user input is blocked.
+    def runModalFor(window); end
+  
+    # 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 +nil+ all user input is blocked.
+    def runModalWhileShown(window); end
+  
+    # Run popup menu while shown, until #stop or #stopModal is called.
+    # Also returns when entering previous cascading popup menu.
+    def runPopup(window); end
+  
+    # Returns +true+ if the window is modal
+    def modal?(window) ; end
+
+    # 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_.
+    def stop(value=0); end
+  
+    #
+    # Break out of the matching modal loop, returning code equal to _value_.
+    # All deeper nested event loops are terminated with code equal to 0.
+    #
+    def stopModal(window, value=0); end
+  
+    #
+    # Break out of the innermost modal loop, returning code equal to _value_.
+    #
+    def stopModal(value=0); end
+
+    # Force GUI refresh
+    def forceRefresh(); end
+
+    # Schedule a refresh
+    def refresh(); end
+
+    # Flush pending repaints
+    def flush(sync=false); end
+
+    # Paint all windows marked for repainting.
+    # On return all the applications windows have been painted.
+    def repaint(); end
+  
+    #
+    # Return a reference to the registry (an FXRegistry instance).
+    # 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.
+    #
+    def reg; end
+
+    # Initialize application.
+    # Parses and removes common command line arguments, reads the registry.
+    # Finally, if _connect_ is +true+, it opens the display.
+    def init(argv, connect=true) ; end
+
+    # Exit application.
+    # Closes the display and writes the registry.
+    def exit(code=0); end
+  
+    #
+    # Register a drag type with the given name and return the drag
+    # drag type. If this drag type has already been registered, this
+    # method will return the previously returned drag type. For example,
+    #
+    #   yamlDragType = app.registerDragType("application/x-yaml")
+    #
+    # See also #getDragTypeName.
+    #
+    def registerDragType(name) ; end
+
+    #
+    # Return the name of a previously registered drag type, e.g.
+    #
+    #   dragTypeName = app.getDragTypeName(yamlDragType)
+    #
+    # See also #registerDragType.
+    #
+    def getDragTypeName(dragType) ; end
+
+    # Beep
+    def beep(); end
+  
+    # Return application instance
+    def FXApp.instance(); end
+  
+    # End the most deeply nested wait-cursor block.
+    # See also #beginWaitCursor.
+    def endWaitCursor(); end
+  
+    #
+    # Return a reference to one of the default application cursors (an
+    # FXCursor instance), where _which_ is one of the default cursor
+    # identifiers listed above, e.g.
+    #
+    #   rotateCursor = app.getDefaultCursor(DEF_ROTATE_CURSOR)
+    # 
+    # See also #setDefaultCursor.
+    #
+    def getDefaultCursor(which) ; end
+  
+    #
+    # Replace one of the default application cursors with _cursor_; e.g
+    #
+    #   app.setDefaultCursor(DEF_ROTATE_CURSOR, myRotateCursor)
+    #
+    # See also #getDefaultCursor.
+    #
+    def setDefaultCursor(which, cursor); end
+  
+    #
+    # Write a window and its children, and all resources reachable from this
+    # window, into the stream _store_ (an FXStream instance).
+    #
+    # ==== Parameters:
+    #
+    # +store+::		[FXStream]
+    # +window+::	[FXWindow]
+    #
+    def writeWindow(store, window); end
+
+    #
+    # Read a window and its children from the stream store, and append
+    # it under father; note it is initially not created yet.
+    # Return a reference to the new window.
+    #
+    # ==== Parameters:
+    #
+    # +store+::		[FXStream]
+    # +father+::	[FXWindow]
+    # +owner+::		[FXWindow]
+    #
+    def readWindow(store, father, owner); end
+
+    #
+    # Return a reference to the application-wide mutex (an FXMutex instance).
+    # 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.
+    #
+    def mutex(); end
+
+    # Dump widget information
+    def dumpWidgets() ; end
+    
+    # Return the number of existing windows.
+    def windowCount; end
+    
+    # Enable support for multithreaded applications
+    def enableThreads(); end
+  
+    # Disable support for multithreaded applications
+    def disableThreads(); end
+
+    # Check to see if multithreaded applications are supported
+    def threadsEnabled?(); end
+  end
+end