fxruby 1.6.14-universal-darwin-9

data/rdoc-sources/FXMDIChild.rb

@@ -0,0 +1,155 @@
+module Fox
+  #
+  # The MDI child window contains the application work area in a Multiple Document
+  # Interface application.  GUI Controls are connected to the MDI child via delegation
+  # through the MDI client, which forwards messages it receives to the active MDI child.
+  # The MDI child itself tries to further delegate messages to its single content window,
+  # and if not handled there, to its target object.
+  # When the MDI child is maximized, it sends a SEL_MAXIMIZE message; when the MDI
+  # child is minimized, it sends a SEL_MINIMIZE message.  When it is restored, it
+  # sends a SEL_RESTORE message to its target.  The MDI child also notifies its
+  # target when it becomes the active MDI child, via the SEL_SELECTED message.
+  # The void* in the SEL_SELECTED message refers to the previously active MDI child,
+  # if any.  When an MDI child ceases to be the active one, a SEL_DESELECTED message
+  # is sent.  The void* in the SEL_DESELECTED message refers to the newly activated
+  # MDI child, if any.  Thus, interception of SEL_SELECTED and SEL_DESELECTED allows
+  # the target object to determine whether the user switched between MDI windows of
+  # the same document (target) or between MDI windows belonging to the same document.
+  # When the MDI child is closed, it sends a SEL_CLOSE message to its target.
+  # The target has an opportunity to object to the closing; if the MDI child should
+  # not be closed, it should return 1 (objection). If the MDI child should be closed,
+  # the target can either just return 0 or simply not handle the SEL_CLOSE message.
+  # The SEL_UPDATE message can be used to modify the MDI child's title (via
+  # ID_SETSTRINGVALUE), and window icon (via ID_SETICONVALUE).
+  #
+  # === Events
+  #
+  # The following messages are sent by FXMDIChild 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_MIDDLEBUTTONPRESS+::	sent when the middle mouse button goes down; the message data is an FXEvent instance.
+  # +SEL_MIDDLEBUTTONRELEASE+::	sent when the middle mouse button goes up; the message data is an FXEvent instance.
+  # +SEL_RIGHTBUTTONPRESS+::	sent when the right mouse button goes down; the message data is an FXEvent instance.
+  # +SEL_RIGHTBUTTONRELEASE+::	sent when the right mouse button goes up; the message data is an FXEvent instance.
+  # +SEL_SELECTED+::
+  #   sent when the window is selected; the message data is a reference to the MDI client's previous active
+  #   child window, or +nil+ if there was no active child window.
+  # +SEL_DESELECTED+::
+  #   sent when the window is deselected; the message data is a reference to the MDI client's new active child window,
+  #   or +nil+ if there is no active child window.
+  # +SEL_MAXIMIZE+::		sent when the window is maximized
+  # +SEL_MINIMIZE+::		sent when the window is minimized
+  # +SEL_RESTORE+::		sent when the window is restored to its normal size and position
+  # +SEL_CLOSE+::
+  #   sent when the user is trying to close this window. The message handler for this message should
+  #   return 1 (or true) if the target objects to closing the window; otherwise it should just return false (or zero).
+  # +SEL_DELETE+::		sent immediately before this window is destroyed
+  #
+  # === MDI Child Window styles
+  #
+  # +MDI_NORMAL+::	Normal display mode
+  # +MDI_MAXIMIZED+::	Window appears maximized
+  # +MDI_MINIMIZED+::	Window is iconified or minimized
+  # +MDI_TRACKING+::	Track continuously during dragging
+  #
+  class FXMDIChild < FXComposite
+
+    # Normal (restored) position x-coordinate [Integer]
+    attr_accessor :normalX
+
+    # Normal (restored) position y-coordinate [Integer]
+    attr_accessor :normalY
+
+    # Normal (restored) width [Integer]
+    attr_accessor :normalWidth
+
+    # Normal (restored) height [Integer]
+    attr_accessor :normalHeight
+
+    # Iconified position x-coordinate [Integer]
+    attr_accessor :iconX
+
+    # Iconified position y-coordinate [Integer]
+    attr_accessor :iconY
+
+    # Iconified width [Integer]
+    attr_accessor :iconWidth
+
+    # Iconified height [Integer]
+    attr_accessor :iconHeight
+    
+    # Content window [FXWindow]
+    attr_reader :contentWindow
+    
+    # Window title [String]
+    attr_accessor :title
+
+    # Highlight color [FXColor]
+    attr_accessor :hiliteColor
+
+    # Shadow color [FXColor]
+    attr_accessor :shadowColor
+
+    # Base color [FXColor]
+    attr_accessor :baseColor
+
+    # Border color [FXColor]
+    attr_accessor :borderColor
+
+    # Title color [FXColor]
+    attr_accessor :titleColor
+
+    # Title background color [FXColor]
+    attr_accessor :titleBackColor
+    
+    # Window icon [FXIcon]
+    attr_accessor :icon
+    
+    # Window menu [FXPopup]
+    attr_accessor :menu
+    
+    # Title font [FXFont]
+    attr_accessor :font
+
+    # Construct MDI Child window with given name and icon
+    def initialize(p, name, ic=nil, pup=nil, opts=0, x=0, y=0, width=0, height=0) # :yields: theMDIChild
+    end
+  
+    #
+    # Minimize this window.
+    # If _notify_ is +true+, ...
+    #
+    def minimize(notify=false); end
+
+    #
+    # Maximize this window.
+    # If _notify_ is +true+, ...
+    #
+    def maximize(notify=false); end
+
+    #
+    # Restore this window to its normal position and size.
+    # If _notify_ is +true+, ...
+    #
+    def restore(notify=false); end
+
+    # Return +true+ if maximized
+    def maximized? ; end
+    
+    # Return +true+ if minimized
+    def minimized? ; end
+    
+    # Set tracking instead of just outline
+    def setTracking(tracking); end
+    
+    alias tracking= setTracking
+    
+    # Return +true+ if tracking, +false+ otherwise.
+    def getTracking(); end
+    
+    alias isTracking? getTracking
+    alias tracking    getTracking
+
+  end
+end

data/rdoc-sources/FXMDIClient.rb

@@ -0,0 +1,65 @@
+module Fox
+  #
+  # The MDI client window manages a number of MDI child windows in a multiple-document
+  # interface (MDI) application. MDI child windows usually receive messages from the GUI controls
+  # by delegation via the MDI client.  This is accomplished by making the MDI client window
+  # the target for most GUI controls.  The MDI client filters out messages intented for itself,
+  # and delegates the remaining messages to its currently active MDI child, if any.
+  # If you use the auto-gray or auto-hide feature available in some GUI controls, these
+  # controls can be automatically grayed out or hidden when there is no active MDI child.
+  # When delegating messages via MDI client to MDI child windows of different types, care
+  # should be taken that message ID's do not overlap, so that all message ID's only map to
+  # the intented handlers no matter which MDI child window type is active.
+  # The MDI client sends a SEL_CHANGED message to its target when the active MDI child is
+  # switched, with the void  # pointer refering to the new MDI child.
+  # A MDI Window selection dialog can be brought up through the ID_MDI_OVER_X messages;
+  # a menu button connected to the MDI client with the ID_MDI_OVER_X message will be
+  # automatically grayed out if there are less than X MDI child windows.
+  #
+  # === Events
+  #
+  # The following messages are sent by FXMDIClient to its target:
+  #
+  # +SEL_CHANGED+::
+  #   sent when the active child changes; the message data is a reference to the new active child window (or +nil+ if there is none)
+  #
+  class FXMDIClient < FXComposite
+  
+    # Active MDI child window, or +nil+ if none [FXMDIChild].
+    attr_accessor :activeChild
+  
+    # Cascade offset X [Integer]
+    attr_accessor :cascadeX
+  
+    # Cascade offset Y [Integer]
+    attr_accessor :cascadeY
+
+    # Construct MDI Client window
+    def initialize(p, opts=0, x=0, y=0, width=0, height=0) # :yields: theMDIClient
+    end
+
+    #
+    # Pass message to all MDI windows, stopping when one of
+    # the MDI windows fails to handle the message.
+    #
+    def forallWindows(sender, sel, ptr); end
+  
+    #
+    # Pass message once to all MDI windows with the same document,
+    # stopping when one of the MDI windows fails to handle the message.
+    #
+    def forallDocuments(sender, sel, ptr); end
+
+    #
+    # Pass message to all MDI Child windows whose target is _document_,
+    # stopping when one of the MDI windows fails to handle the message.
+    #
+    def forallDocWindows(document, sender, sel, ptr); end
+  
+    #
+    # Set active MDI child window for this MDI client to _child_.
+    #
+    def setActiveChild(child=nil, notify=true); end
+  end
+end
+

data/rdoc-sources/FXMainWindow.rb

@@ -0,0 +1,26 @@
+module Fox
+  #
+  # The Main Window is usually the central window of an application.  Applications
+  # may have any number of main windows.
+  # When a MainWindow is closed, it sends a SEL_CLOSE message to its target; the target
+  # should return 0 if there is no objection against proceeding with the close, and
+  # return 1 otherwise.
+  # After the SEL_CLOSE message has been sent and no objection was raised, the main
+  # window will delete itself.
+  #
+  # === Events
+  #
+  # The following messages are sent by FXMainWindow to its target:
+  #
+  # +SEL_CLOSE+::
+  #   sent when the user clicks the close button in the upper right-hand
+  #   corner of the main window.
+  #
+  class FXMainWindow < FXTopWindow
+    #
+    # Construct a main window
+    #
+    def initialize(app, title, icon=nil, miniIcon=nil, opts=DECOR_ALL, x=0, y=0, width=0, height=0, padLeft=0, padRight=0, padTop=0, padBottom=0, hSpacing=4, vSpacing=4) # :yields: theMainWindow
+    end
+  end
+end

data/rdoc-sources/FXMatrix.rb

@@ -0,0 +1,57 @@
+module Fox
+  #
+  # The FXMatrix layout manager automatically arranges its child windows
+  # in rows and columns. If the matrix style is +MATRIX_BY_ROWS+, then
+  # the matrix will have the given number of rows and the number of columns
+  # grows as more child windows are added; if the matrix style is +MATRIX_BY_COLUMNS+,
+  # then the number of columns is fixed and the number of rows grows as more children
+  # are added.  
+  # If all children in a row (column) have the +LAYOUT_FILL_ROW+ (+LAYOUT_FILL_COLUMN+)
+  # hint set, then the row (column) will be stretchable as the matrix layout manager
+  # itself is resized.  If more than one row (column) is stretchable, the space is
+  # apportioned to each stretchable row (column) proportionally.
+  # Within each cell of the matrix, all other layout hints are observed.  
+  # For example, a child having +LAYOUT_CENTER_Y+ and +LAYOUT_FILL_X+ hints will
+  # be centered in the Y-direction, while being stretched in the X-direction.
+  # Empty cells can be obtained by simply placing a borderless FXFrame widget
+  # as a space-holder.
+  #
+  # === Matrix packing options
+  #
+  # +MATRIX_BY_ROWS+::		Fixed number of rows, add columns as needed
+  # +MATRIX_BY_COLUMNS+::	Fixed number of columns, adding rows as needed
+  #
+  class FXMatrix < FXPacker
+
+    # Matrix style [Integer]
+    attr_accessor :matrixStyle
+    
+    # Number of rows [Integer]
+    attr_accessor :numRows
+    
+    # Number of columns [Integer]
+    attr_accessor :numColumns
+
+    #
+    # Construct a matrix layout manager with _n_ rows or columns
+    #
+    def initialize(parent, n=1, opts=MATRIX_BY_ROWS, x=0, y=0, width=0, height=0, padLeft=DEFAULT_SPACING, padRight=DEFAULT_SPACING, padTop=DEFAULT_SPACING, padBottom=DEFAULT_SPACING, hSpacing=DEFAULT_SPACING, vSpacing=DEFAULT_SPACING) # :yields: theMatrix
+    end
+
+    #
+    # Obtain the child placed at a certain _row_ and _column_.
+    #
+    def childAtRowCol(row, column); end
+    
+    #
+    # Return the row in which the given _child_ is placed.
+    #
+    def rowOfChild(child); end
+    
+    #
+    # Return the column in which the given _child_ is placed.
+    #
+    def colOfChild(child); end
+  end
+end
+

data/rdoc-sources/FXMemoryBuffer.rb

@@ -0,0 +1,28 @@
+module Fox
+  class FXMemoryBuffer
+
+    #
+    # Return a new FXMemoryBuffer instance, initialized with the
+    # provided array of FXColor values.
+    #
+    # ==== Parameters:
+    #
+    # +data+::	the initial array of FXColor values.
+    #
+    def initialize(data); end
+
+    # Return a copy of the pixel buffer, as an array of FXColor values [Array]
+    def data; end
+    alias to_a data
+
+    # Return the size of the pixel buffer
+    def size; end
+
+    # Return the specified element (an FXColor value)
+    def [](index); end
+    
+    # Set the specified element to _clr_.
+    def []=(index, clr); end
+  end
+end
+

data/rdoc-sources/FXMemoryStream.rb

@@ -0,0 +1,50 @@
+module Fox
+  #
+  # A FXMemoryStream is a stream that reads from (or writes to) a buffer of bytes in memory.
+  # That buffer may "owned" by either the application code or by the stream object itself.
+  # In the latter case, the stream object will dispose of the buffer contents when the stream
+  # is closed.
+  #
+  class FXMemoryStream < FXStream
+
+    attr_reader :position
+
+    #
+    # Construct a new memory stream with given container object.
+    # The container object is an object that will itself not be
+    # saved to or loaded from the stream, but which may be referenced
+    # by other objects. These references will be properly saved and restored.
+    #
+    # ==== Parameters:
+    #
+    # +cont+::	the container object, or +nil+ if there is none [FXObject].
+    #
+    def initialize(cont=nil) # :yields: theMemoryStream
+    end
+  
+    #
+    # Open memory stream for reading or writing.
+    # Returns +true+ if successful, +false+ otherwise.
+    #
+    # ==== Parameters:
+    #
+    # +save_or_load+:: access mode, either +FXStreamSave+ or +FXStreamLoad+ [Integer]
+    # +data+::         memory buffer to be used for the stream, or +nil+ if the stream object should allocate its own buffer [String]
+    #
+    def open(save_or_load, data); end
+    
+    #
+    # Take buffer away from stream, thus transferring ownership of the buffer
+    # from the stream object to the caller.
+    # Returns a string containing the buffer contents.
+    #
+    def takeBuffer; end
+    
+    #
+    # Give buffer (a string) to this stream, thus transferring ownership of
+    # the buffer from the caller to the stream object.
+    #
+    def giveBuffer(buffer); end
+  end
+end
+

data/rdoc-sources/FXMenuBar.rb

@@ -0,0 +1,23 @@
+module Fox
+  #
+  # Menu bar
+  #
+  class FXMenuBar < FXToolBar
+    #
+    # Construct a floatable menubar.
+    # Normally, the menubar is docked under window _p_.
+    # When floated, the menubar can be docked under window _q_, which is
+    # typically an FXToolBarShell window.
+    #
+    def initialize(p, q, opts=LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X, x=0, y=0, width=0, height=0, padLeft=3, padRight=3, padTop=2, padBottom=2, hSpacing=DEFAULT_SPACING, vSpacing=DEFAULT_SPACING) # :yields: theMenuBar
+    end
+  
+    #
+    # Construct a non-floatable menubar.
+    # The menubar can not be undocked.
+    #
+    def initialize(p, opts, x=0, y=0, width=0, height=0, padLeft=3, padRight=3, padTop=2, padBottom=2, hSpacing=DEFAULT_SPACING, vSpacing=DEFAULT_SPACING) # :yields: theMenuBar
+    end
+  end
+end
+

data/rdoc-sources/FXMenuButton.rb

@@ -0,0 +1,84 @@
+module Fox
+  #
+  # An FXMenuButton posts a popup menu when clicked.
+  # There are many ways to control the placement where the popup will appear;
+  # first, the popup may be placed on either of the four sides relative to the
+  # menu button; this is controlled by the flags +MENUBUTTON_DOWN+, etc.
+  # Next, there are several attachment modes; the popup's left/bottom edge may
+  # attach to the menu button's left/top edge, or the popup's right/top edge may
+  # attach to the menu button's right/bottom edge, or both. 
+  # Also, the popup may appear centered relative to the menu button.
+  # Finally, a small offset may be specified to displace the location of the
+  # popup by a few pixels so as to account for borders and so on. 
+  # Normally, the menu button shows an arrow pointing to the direction where
+  # the popup is set to appear; this can be turned off by passing the option
+  # +MENUBUTTON_NOARROWS+.
+  #
+  # === Events
+  #
+  # The following messages are sent by FXMenuButton to its target:
+  #
+  # +SEL_KEYPRESS+::		sent when a key goes down; the message data is an FXEvent instance.
+  # +SEL_KEYRELEASE+::		sent when a key goes up; the message data is an FXEvent instance.
+  # +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.
+  #
+  # === Menu Button Style Flags
+  #
+  # Any combination of the following flags can be assigned as the menu
+  # button style flags.
+  #
+  # +MENUBUTTON_AUTOGRAY+::		Automatically gray out when no target
+  # +MENUBUTTON_AUTOHIDE+::		Automatically hide when no target
+  # +MENUBUTTON_TOOLBAR+::		Toolbar style
+  # +MENUBUTTON_NOARROWS+::		Do not show arrows
+  #
+  # === Menu Button Popup Style
+  #
+  # Any one of the following options can be assigned as the menu
+  # button's popup style.
+  #
+  # +MENUBUTTON_DOWN+::			Popup window appears below menu button
+  # +MENUBUTTON_UP+::			Popup window appears above menu button
+  # +MENUBUTTON_LEFT+::			Popup window to the left of the menu button
+  # +MENUBUTTON_RIGHT+::		Popup window to the right of the menu button
+  #
+  # === Menu Button Attachment
+  #
+  # Any combination of the following flags can be assigned as the menu
+  # button's attachment flags.
+  #
+  # +MENUBUTTON_ATTACH_LEFT+::		Popup attaches to the left side of the menu button
+  # +MENUBUTTON_ATTACH_TOP+::		Popup attaches to the top of the menu button
+  # +MENUBUTTON_ATTACH_RIGHT+::		Popup attaches to the right side of the menu button
+  # +MENUBUTTON_ATTACH_BOTTOM+::	Popup attaches to the bottom of the menu button
+  # +MENUBUTTON_ATTACH_CENTER+::	Popup attaches to the center of the menu button
+  # +MENUBUTTON_ATTACH_BOTH+::		Popup attaches to both sides of the menu button
+  #
+  class FXMenuButton < FXLabel
+
+    # The popup menu [FXPopup]
+    attr_accessor :menu
+    
+    # X-offset where menu pops up relative to button [Integer]
+    attr_accessor :xOffset
+    
+    # Y-offset where menu pops up relative to button [Integer]
+    attr_accessor :yOffset
+    
+    # Menu button style [Integer]
+    attr_accessor :buttonStyle
+    
+    # Popup style [Integer]
+    attr_accessor :popupStyle
+    
+    # Attachment [Integer]
+    attr_accessor :attachment
+
+    #
+    # Constructor
+    #
+    def initialize(parent, text, icon=nil, popupMenu=nil, opts=JUSTIFY_NORMAL|ICON_BEFORE_TEXT|MENUBUTTON_DOWN, x=0, y=0, width=0, height=0, padLeft=DEFAULT_SPACING, padRight=DEFAULT_SPACING, padTop=DEFAULT_SPACING, padBottom=DEFAULT_SPACING) # :yields: theMenuButton
+  end
+end
+

data/rdoc-sources/FXMenuCaption.rb

@@ -0,0 +1,50 @@
+module Fox
+  #
+  # The menu caption is a widget which can be used as a caption
+  # above a number of menu commands in a menu.
+  #
+  # === Menu caption options
+  #
+  # +MENU_AUTOGRAY+::	Automatically gray out when not updated
+  # +MENU_AUTOHIDE+::	Automatically hide button when not updated
+  #
+  class FXMenuCaption < FXWindow
+
+    # The text for this menu [String]
+    attr_accessor :text
+    
+    # The icon for this menu [FXIcon]
+    attr_accessor :icon
+    
+    # The text font [FXFont]
+    attr_accessor :font
+    
+    # Text color [FXColor]
+    attr_accessor :textColor
+    
+    # Selection background color [FXColor]
+    attr_accessor :selBackColor
+    
+    # Selection text color [FXColor]
+    attr_accessor :selTextColor
+    
+    # Highlight color [FXColor]
+    attr_accessor :hiliteColor
+    
+    # Shadow color [FXColor]
+    attr_accessor :shadowColor
+    
+    # Status line help text for this menu [String]
+    attr_accessor :helpText
+    
+    # Tool tip message for this menu [String]
+    attr_accessor :tipText
+
+    #
+    # Construct a new menu caption
+    #
+    def initialize(parent, text, icon=nil, opts=0) # :yields: theMenuCaption
+    end
+  end
+end
+

data/rdoc-sources/FXMenuCascade.rb

@@ -0,0 +1,18 @@
+module Fox
+  #
+  # The cascade menu widget is used to bring up a sub menu from a
+  # pull down menu.
+  #
+  class FXMenuCascade < FXMenuCaption
+
+    # The popup menu [FXPopup]
+    attr_accessor :menu
+
+    #
+    # Construct a menu cascade responsible for the given popup menu
+    #
+    def initialize(parent, text, icon=nil, popupMenu=nil, opts=0) # :yields: theMenuCascade
+    end
+  end
+end
+

data/rdoc-sources/FXMenuCheck.rb

@@ -0,0 +1,30 @@
+module Fox
+  #
+  # The FXMenuCheck widget is used to change a state in the application from a menu.
+  # Menu checks may reflect the state of the application by graying out, becoming
+  # hidden, or by a check mark.
+  # When activated, a menu check sends a +SEL_COMMAND+ message to its target;
+  # the message data contains the new state (one of +TRUE+, +FALSE+ or +MAYBE+).
+  #
+  # === Events
+  #
+  # The following messages are sent by FXMenuCheck to its target:
+  #
+  # +SEL_COMMAND+::		sent when the command is activated
+  #
+  class FXMenuCheck < FXMenuCommand
+
+    # Check state, one of +TRUE+, +FALSE+ or +MAYBE+
+    attr_accessor :check
+    
+    # Box background color [FXColor]
+    attr_accessor :boxColor
+
+    #
+    # Construct a menu check
+    #
+    def initialize(p, text, target=nil, selector=0, opts=0) # :yields: theMenuCheck
+    end
+  end
+end
+

data/rdoc-sources/FXMenuCommand.rb

@@ -0,0 +1,26 @@
+module Fox
+  #
+  # The FXMenuCommand widget is used to invoke a command in the
+  # application from a menu.  Menu commands may reflect
+  # the state of the application by graying out or becoming hidden.
+  # When activated, a menu command sends a +SEL_COMMAND+ to its target.
+  #
+  # === Events
+  #
+  # The following messages are sent by FXMenuCommand to its target:
+  #
+  # +SEL_COMMAND+::		sent when the command is activated
+  #
+  class FXMenuCommand < FXMenuCaption
+
+    # Accelerator text [String]
+    attr_accessor :accelText
+
+    #
+    # Construct a menu command
+    #
+    def initialize(p, text, ic=nil, target=nil, selector=0, opts=0) # :yields: theMenuCommand
+    end
+  end
+end
+

data/rdoc-sources/FXMenuPane.rb

@@ -0,0 +1,13 @@
+module Fox
+  #
+  # Popup menu pane
+  #
+  class FXMenuPane < FXPopup
+    #
+    # Construct menu pane
+    #
+    def initialize(owner, opts=0) # :yields: theMenuPane
+    end
+  end
+end
+

data/rdoc-sources/FXMenuRadio.rb

@@ -0,0 +1,33 @@
+module Fox
+  #
+  # The FXMenuRadio widget is used to change a state in the application from a menu.
+  # Menu radio commands may reflect the state of the application by graying out, becoming
+  # hidden, or by displaying a bullet.
+  # When activated, a menu radio sends a +SEL_COMMAND+ to its target;
+  # the message data contains the new state.
+  # A collection of menu radio widgets which belong to each other
+  # is supposed to be updated by a common +SEL_UPDATE+ handler to
+  # properly maintain the state between them.
+  #
+  # === Events
+  #
+  # The following messages are sent by FXMenuRadio to its target:
+  #
+  # +SEL_COMMAND+::		sent when the command is activated
+  #
+  class FXMenuRadio < FXMenuCommand
+
+    # Radio button state, one of +TRUE+, +FALSE+ or +MAYBE+
+    attr_accessor :check
+    
+    # Radio background color [FXColor]
+    attr_accessor :radioColor
+
+    #
+    # Construct a menu radio
+    #
+    def initialize(p, text, target=nil, selector=0, opts=0) # :yields: theMenuRadio
+    end
+  end
+end
+

data/rdoc-sources/FXMenuSeparator.rb

@@ -0,0 +1,21 @@
+module Fox
+  #
+  # The menu separator is a simple decorative groove
+  # used to delineate items in a popup menu.
+  #
+  class FXMenuSeparator < FXWindow
+
+    # Highlight color [FXColor]
+    attr_accessor :hiliteColor
+    
+    # Shadow color [FXColor]
+    attr_accessor :shadowColor
+
+    #
+    # Construct a menu separator
+    #
+    def initialize(parent, opts=0) # :yields: theMenuSeparator
+    end
+  end
+end
+