fxruby 1.6.14-universal-darwin-9

data/rdoc-sources/FXBMPIcon.rb

@@ -0,0 +1,67 @@
+module Fox
+  #
+  # The BMP Icon class is a convenience class for working with icons in the
+  # Microsoft Bitmap (.bmp) graphics file format.  This makes it possible to
+  # use resources created with Windows development tools inside FOX without
+  # need for graphics file format translators.  The bitmap loaded handles
+  # 1, 4, and 8 bit paletted bitmaps, 16 and 24 bit RGB bitmaps, and
+  # 32 bit RGBA bitmaps.
+  #
+  class FXBMPIcon < FXIcon
+    #
+    # Return the suggested file extension for this image type ("bmp").
+    #
+    def FXBMPIcon.fileExt; end
+    
+    #
+    # Return the MIME type for this image type
+    #
+    def FXBMPIcon.mimeType; end
+    
+    #
+    # Return an initialized FXBMPIcon instance.
+    #
+    # ==== Parameters:
+    #
+    # +a+::	an application instance [FXApp]
+    # +pix+::	a memory buffer formatted in BMP file format [String]
+    # +clr+::	transparency color [FXColor]
+    # +opts+::	options [Integer]
+    # +width+::	width [Integer]
+    # +height+::	height [Integer]
+    #
+    def initialize(a, pix=nil, clr=FXRGB(192,192,192), opts=0, width=1, height=1) # :yields: theBMPIcon
+    end
+  end
+
+  #
+  # Load a BMP file from a stream.
+  # If successful, returns an array containing the image pixel data (as a
+  # String), the transparency color, the image width and the image height.
+  # If it fails, the function returns +nil+.
+  #
+  # ==== Parameters:
+  #
+  # +store+::	stream from which to read the file data [FXStream]
+  #
+  def Fox.fxloadBMP(store); end
+
+  #
+  # Save a BMP image to a stream.
+  # Returns +true+ on success, +false+ on failure.
+  #
+  # ==== Parameters:
+  #
+  # +store+::	stream to which to write the image data [FXStream]
+  # +data+::	the image pixel data [String]
+  # +transp+::	transparency color [FXColor]
+  # +width+::	width [Integer]
+  # +height+::	height [Integer]
+  #
+  def Fox.fxsaveBMP(store, data, transp, width, height); end
+  
+  #
+  # Return +true+ if _store_ (an FXStream instance) contains a BMP image.
+  #
+  def Fox.fxcheckBMP(store); end
+end

data/rdoc-sources/FXBMPImage.rb

@@ -0,0 +1,30 @@
+module Fox
+  #
+  # Microsoft Bitmap image.
+  #
+  class FXBMPImage < FXImage
+    #
+    # Return the suggested file extension for this image type ("bmp").
+    #
+    def FXBMPImage.fileExt; end
+    
+    #
+    # Return the MIME type for this image type
+    #
+    def FXBMPImage.mimeType; end
+    
+    #
+    # Return an initialized FXBMPImage instance.
+    #
+    # ==== Parameters:
+    #
+    # +a+::	an application instance [FXApp]
+    # +pix+::	a memory buffer formatted in BMP file format [String]
+    # +opts+::	options [Integer]
+    # +width+::	width [Integer]
+    # +height+::	height [Integer]
+    #
+    def initialize(a, pix=nil, opts=0, width=1, height=1)	# :yields: theBMPImage
+    end
+  end
+end

data/rdoc-sources/FXBitmap.rb

@@ -0,0 +1,115 @@
+module Fox
+  #
+  # A bitmap is a rectangular array of pixels.
+  # It supports two representations of these pixels: a client-side pixel buffer,
+  # and a server-side pixmap which is stored in an organization directly compatible
+  # with the screen, for fast drawing onto the device. The server-side representation
+  # is not directly accessible from the current process at it lives in the process
+  # of the X server or GDI (on Microsoft Windows).
+  # The client-side pixel array is of size height x (width+7)/8 bytes; in other
+  # words, 8 pixels packed into a single byte, starting with bit zero on the left.
+  # 
+  # === Image rendering hints
+  #
+  # +BITMAP_KEEP+::	Keep pixel data in client
+  # +BITMAP_OWNED+::	Pixel data is owned by image
+  # +BITMAP_SHMI+::	Using shared memory image
+  # +BITMAP_SHMP+::	Using shared memory pixmap
+  #
+  class FXBitmap < FXDrawable
+  
+    alias data getData
+
+    #
+    # Return an initialized FXBitmap instance.
+    # If a client-side pixel buffer (the _pixels_ argument) has been specified,
+    # the bitmap does not own that pixel buffer unless the +BITMAP_OWNED+ flag
+    # is set. If the +BITMAP_OWNED+ flag _is_ set, but a +nil+ value for _pixels_
+    # is passed in, a pixel buffer will be automatically created and will be
+    # owned by the bitmap. The flags +BITMAP_SHMI+ and +BITMAP_SHMP+ may be
+    # specified for large bitmaps to instruct FXBitmap#render to use shared
+    # memory to communicate with the server.
+    #
+    def initialize(app, pixels=nil, opts=0, width=1, height=1) # :yields: theBitmap
+    end
+
+    #
+    # Populate the bitmap with new pixel data of the same size; it will assume
+    # ownership of the pixel data if the +BITMAP_OWNED+ option is passed in the _opts_.
+    # The server-side representation of the image, if it exists, is not updated;
+    # to update ther server-side representation, call #render.
+    #
+    def setData(pix, opts=0); end
+
+    #
+    # Populate the bitmap with new pixel data of a new size; it will assume ownership
+    # of the pixel data if the +BITMAP_OWNED+ option is passed in the _opts_. The size of the server-
+    # side representation of the image, if it exists, is adjusted but the contents are
+    # not updated; to update the server-side representation, call #render.
+    #
+    def setData(pix, opts, w, h); end
+
+    # Return the pixel data.
+    def getData(); end
+    
+    # Return the option flags.
+    def options; end
+    
+    # Set the options.
+    def options=(opts); end
+
+    # Retrieve pixels from the server-side bitmap.
+    def restore; end
+
+    # Render the server-side representation of the bitmap from the client-side pixels.
+    def render() ; end
+    
+    #
+    # Release the client-side pixels buffer and free it if it was owned.
+    # If it is not owned, the image just forgets about the buffer.
+    #
+    def release(); end
+
+    #
+    # Resize both client-side and server-side representations (if any) to the
+    # given width and height.  The new representations typically contain garbage
+    # after this operation and need to be re-filled.
+    #
+    def resize(w, h); end
+
+    # Save pixel data only
+    def savePixels(stream); end
+    
+    # Load pixel data from a stream
+    def loadPixels(stream); end
+
+    # Get pixel state (either +true+ or +false+) at (_x_, _y_)
+    def getPixel(x, y) ; end
+
+    # Change pixel at (_x_, _y_), where _color_ is either +true+ or +false+.
+    def setPixel(x, y, color) ; end
+    
+    #
+    # Rescale pixels image to the specified width and height; this calls
+    # #resize to adjust the client and server side representations.
+    #
+    def scale(w, h); end
+    
+    # Mirror the bitmap horizontally and/or vertically
+    def mirror(horizontal, vertical); end
+    
+    # Rotate bitmap by _degrees_ degrees (counter-clockwise)
+    def rotate(degrees); end
+    
+    #
+    # Crop bitmap to given rectangle; this calls #resize to adjust the client
+    # and server side representations.  The new bitmap may be smaller or larger
+    # than the old one; blank areas are filled with _color_. There must be at
+    # least one pixel of overlap between the old and the new bitmap.
+    #
+    def crop(x, y, w, h, color=false); end
+    
+    # Fill bitmap with uniform value
+    def fill(color); end
+  end
+end

data/rdoc-sources/FXBitmapFrame.rb

@@ -0,0 +1,31 @@
+module Fox
+  #
+  # The bitmap frame is a simple frame widget displaying an monochrome bitmap
+  # image; the bitmap is not owned by the bitmap frame so it must be explicitly
+  # deleted elsewhere.
+  #
+  class FXBitmapFrame < FXFrame
+  
+    # The current image being displayed [FXBitmap]
+    attr_accessor :bitmap
+    
+    # The color used for the "on" bits in the bitmap [FXColor]
+    attr_accessor :onColor
+    
+    # The color used for the "off" bits in the bitmap [FXColor]
+    attr_accessor :offColor
+    
+    #
+    # The current justification mode, some combination of the flags
+    # +JUSTIFY_LEFT+, +JUSTIFY_RIGHT+, +JUSTIFY_TOP+ and +JUSTIFY_BOTTOM+
+    # [Integer]
+    #
+    attr_accessor :justify
+    
+    #
+    # Return an initialized FXBitmapFrame instance.
+    #
+    def initialize(p, bmp, opts=FRAME_SUNKEN|FRAME_THICK, x=0, y=0, width=0, height=0, padLeft=0, padRight=0, padTop=0, padBottom=0) # :yields: theBitmapFrame
+    end
+  end
+end

data/rdoc-sources/FXBitmapView.rb

@@ -0,0 +1,44 @@
+module Fox
+  #
+  # The Bitmap View widget display a scrollable view of a monochrome bitmap image;
+  # the bitmap is not owned by the bitmap frame so it must be explicitly deleted
+  # elsewhere.  Thus, a single bitmap image can be displayed inside multiple bitmap
+  # view widgets.
+  #
+  # === Bitmap alignment styles
+  #
+  # +BITMAPVIEW_NORMAL+::	Normal mode is centered
+  # +BITMAPVIEW_CENTER_X+::	Centered horizontally
+  # +BITMAPVIEW_LEFT+::		Left-aligned
+  # +BITMAPVIEW_RIGHT+::	Right-aligned
+  # +BITMAPVIEW_CENTER_Y+::	Centered vertically
+  # +BITMAPVIEW_TOP+::		Top-aligned
+  # +BITMAPVIEW_BOTTOM+::	Bottom-aligned
+  #
+  # === Events
+  #
+  # +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.
+  #
+  class FXBitmapView < FXScrollArea
+  
+    # The bitmap [FXBitmap]
+    attr_accessor :bitmap
+    
+    # The color used for the "on" bits in the bitmap [FXColor]
+    attr_accessor :onColor
+
+    # The color used for the "off" bits in the bitmap [FXColor]
+    attr_accessor :offColor
+
+    # Current alignment [Integer]
+    attr_accessor :alignment
+
+    #
+    # Return an initialized FXBitmapView instance.
+    #
+    def initialize(p, bmp=nil, target=nil, selector=0, opts=0, x=0, y=0, width=0, height=0) # :yields: theBitmapView
+    end
+  end
+end
+

data/rdoc-sources/FXButton.rb

@@ -0,0 +1,59 @@
+module Fox
+  #
+  # A button provides a push button, with optional icon and/or text label.
+  # When pressed, the button widget sends a <tt>SEL_COMMAND</tt> to its target.
+  # Passing the <tt>BUTTON_TOOLBAR</tt> style option gives buttons a "flat" look, and
+  # causes the edge of the button to be raised when the cursor moves over it.
+  # Passing <tt>BUTTON_DEFAULT</tt> allows the button to become the default button in
+  # a dialog, when the focus moves to it.  The default widget in a dialog
+  # is the widget which will accept the _Return_ key when it is pressed.
+  # The <tt>BUTTON_INITIAL</tt> flag makes the button the default widget when the
+  # focus moves to a widget which can not itself be a default widget.
+  # There should be only a single button in the dialog which is the
+  # initial default; typically this is the _OK_ or _Close_ button.
+  # The option <tt>BUTTON_AUTOGRAY</tt> (<tt>BUTTON_AUTOHIDE</tt>) causes the button to be grayed
+  # out (hidden) if its handler does not respond to the <tt>SEL_UPDATE</tt> message.
+  # This is useful when messages are delegated, for example when using a
+  # multiple document interface, where the ultimate destination of a message
+  # can be changed.
+  #
+  # === Events
+  #
+  # The following messages are sent by FXButton 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.
+  # +SEL_COMMAND+::		sent when the button is clicked.
+  #
+  # === Button state bits
+  #
+  # +STATE_UP+::        Button is up
+  # +STATE_DOWN+::      Button is down
+  # +STATE_ENGAGED+::   Button is engaged
+  # +STATE_UNCHECKED+:: Same as +STATE_UP+ (used for check buttons or radio buttons)
+  # +STATE_CHECKED+::   Same as +STATE_ENGAGED+ (used for check buttons or radio buttons)
+  #
+  # === Button flags
+  #
+  # +BUTTON_AUTOGRAY+:: Automatically gray out when not updated
+  # +BUTTON_AUTOHIDE+:: Automatically hide button when not updated
+  # +BUTTON_TOOLBAR+::  Toolbar style button [flat look]
+  # +BUTTON_DEFAULT+::  May become default button when receiving focus
+  # +BUTTON_INITIAL+::  This button is the initial default button
+  # +BUTTON_NORMAL+::   Default button flags (<tt>FRAME_RAISED|FRAME_THICK|JUSTIFY_NORMAL|ICON_BEFORE_TEXT</tt>)
+  #
+  class FXButton < FXLabel
+  
+    # Button state (one of +STATE_UP+, +STATE_DOWN+, etc.) [Integer]
+    attr_accessor :state
+    
+    # Button style flags (some combination of +BUTTON_AUTOGRAY+, +BUTTON_AUTOHIDE+, etc.) [Integer]
+    attr_accessor :buttonStyle
+
+    # Construct button with specified _text_ and _icon_.
+    def initialize(parent, text, icon=nil, target=nil, selector=0, opts=BUTTON_NORMAL, x=0, y=0, width=0, height=0, padLeft=DEFAULT_PAD, padRight=DEFAULT_PAD, padTop=DEFAULT_PAD, padBottom=DEFAULT_PAD) # :yields: theButton
+    end
+  end
+end

data/rdoc-sources/FXCURCursor.rb

@@ -0,0 +1,13 @@
+module Fox
+  #
+  # CUR Cursor class
+  #
+  class FXCURCursor < FXCursor
+    #
+    # Construct a cursor from memory stream in Microsoft CUR format.
+    # The image is limited to 32x32 pixels.
+    #
+    def initialize(app, pixels) # :yields: theCursor
+    end
+  end
+end

data/rdoc-sources/FXCanvas.rb

@@ -0,0 +1,18 @@
+module Fox
+  # Canvas, an area drawn by another object
+  #
+  # === Events
+  #
+  # The following messages are sent by FXCanvas 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_MOTION+::	sent when the mouse moves; the message data is an FXEvent instance.
+  # +SEL_PAINT+::	sent when the canvas needs to be redrawn; the message data is an FXEvent instance.
+
+  class FXCanvas < FXWindow
+    # Construct new drawing canvas widget
+    def initialize(parent, target=nil, selector=0, opts=FRAME_NORMAL, x=0, y=0, width=0, height=0) # :yields: theCanvas
+    end
+  end
+end

data/rdoc-sources/FXCheckButton.rb

@@ -0,0 +1,58 @@
+module Fox
+  #
+  # A Check button is a tri-state button.  Normally, it is either
+  # +TRUE+ or +FALSE+, and toggles between +TRUE+ or +FALSE+ whenever it is pressed.
+  # A third state +MAYBE+ may be set to indicate that no selection has been made yet
+  # by the user, or that the state is ambiguous.
+  # When pressed, the Check Button sends a <tt>SEL_COMMAND</tt> to its target, and the
+  # message data represents the state of the check button.
+  # The option <tt>CHECKBUTTON_AUTOGRAY</tt> (<tt>CHECKBUTTON_AUTOHIDE</tt>) causes the button to be
+  # grayed out (hidden) if its handler does not respond to the <tt>SEL_UPDATE</tt> message.
+  # With the <tt>CHECKBUTTON_PLUS</tt> option, the Check Button will draw a + or - sign instead
+  # of a check. You can use this to make collapsible panels, by hooking up a Check
+  # Button to a layout manager via the <tt>ID_TOGGLE_SHOWN</tt> message. This will give a
+  # similar visual element as collapsing folders in a Tree List.
+  #
+  # === Events
+  #
+  # The following messages are sent by FXCheckButton 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.
+  # +SEL_COMMAND+::		sent when the button is clicked.
+  #
+  # === CheckButton styles
+  #
+  # +CHECKBUTTON_AUTOGRAY+::  Automatically gray out when not updated
+  # +CHECKBUTTON_AUTOHIDE+::  Automatically hide when not updated
+  # +CHECKBUTTON_PLUS+::      Draw a plus sign for unchecked and minus sign for checked
+  # +CHECKBUTTON_NORMAL+::    <tt>JUSTIFY_NORMAL|ICON_BEFORE_TEXT</tt>
+  
+  class FXCheckButton < FXLabel
+
+    # Check button state (+TRUE+, +FALSE+ or +MAYBE+) [Integer]
+    attr_accessor :checkState
+    
+    # Check button style [Integer]
+    attr_accessor :checkButtonStyle
+    
+    # Box background color [FXColor]
+    attr_accessor :boxColor
+    
+    # Box check color [FXColor]
+    attr_accessor :checkColor
+
+    # Construct new check button
+    def initialize(parent, text, target=nil, selector=0, opts=CHECKBUTTON_NORMAL, x=0, y=0, width=0, height=0, padLeft=DEFAULT_PAD, padRight=DEFAULT_PAD, padTop=DEFAULT_PAD, padBottom=DEFAULT_PAD) # :yields: theCheckButton
+    end
+    
+    #
+    # Set the check button state to one of +TRUE+, +FALSE+ or +MAYBE+.
+    # If _notify_ is +true+, send a +SEL_COMMAND+ message to the message target
+    # after the state has been updated.
+    #
+    def setCheck(state, notify=false); end
+  end
+end

data/rdoc-sources/FXChoiceBox.rb

@@ -0,0 +1,49 @@
+module Fox
+  #
+  # The Choice Box provides a dialog panel to select one item out of a list
+  # of choices.  The choices are provided as a list of text strings.
+  # When the dialog closes, the index of the selected choice is returned,
+  # while a -1 is returned if the dialog was canceled,
+  #
+  class FXChoiceBox < FXDialogBox
+    #
+    # Construct choice box with given caption, icon, message text, and with choices from array of strings.
+    # If _owner_ is another FXWindow, the dialog box is created as a child of that window. If _owner_
+    # is an FXApp instance, it's created as a free-floating dialog box.
+    #
+    # ==== Parameters:
+    #
+    # +owner+::		Owner for this dialog box [FXWindow or FXApp]
+    # +caption+::	Caption for this dialog box [String]
+    # +text+::		Message text for this dialog box [String]
+    # +icon+::		Icon for this dialog box [FXIcon]
+    # +choices+::	Array of strings containing choices [Array]
+    # +opts+::		Dialog box options [Integer]
+    # +x+::		x-coordinate
+    # +y+::		y-coordinate
+    # +width+::		width
+    # +height+::		height
+    #
+    def initialize(owner, caption, text, icon, choices, opts=0, x=0, y=0, width=0, height=0) # :yields: theChoiceBox
+    end
+
+    #
+    # Show a modal choice dialog.
+    # Prompt the user using a dialog with given caption, icon,
+    # message text, and choices from array of strings.
+    # Returns -1 if the dialog box is cancelled, otherwise returns the index of the selected choice
+    #
+    # ==== Parameters:
+    #
+    # +owner+::		Owner for this dialog box [FXWindow or FXApp]
+    # +opts+::		Dialog box options [Integer]
+    # +caption+::	Caption for this dialog box [String]
+    # +text+::		Message text for this dialog box [String]
+    # +icon+::		Icon for this dialog box [FXIcon]
+    # +choices+::	Array of strings containing choices [Array]
+    #
+    def FXChoiceBox.ask(owner, opts, caption, text, icon, choices); end
+
+  end
+end
+

data/rdoc-sources/FXColorBar.rb

@@ -0,0 +1,48 @@
+module Fox
+  #
+  # A Color Bar is a widget which controls the brightness (value) of a
+  # color by means of the hue, saturation, value specification system.
+  # It is most useful when used together with the Color Wheel which controls
+  # the hue and saturation.
+  # The options <tt>COLORBAR_HORIZONTAL</tt> and <tt>COLORBAR_VERTICAL</tt> control the orientation
+  # of the bar.
+  #
+  # === Events
+  #
+  # The following messages are sent by FXColorBar to its target:
+  #
+  # +SEL_CHANGED+::		sent continuously while the user is dragging the spot around; the message data is a three-element array containing the hue, saturation and value values.
+  # +SEL_COMMAND+::		sent when the user releases the mouse button and "drops" the spot at its new location; the message data is a three-element array containing the hue, saturation and value values.
+  # +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.
+  #
+  # === Color bar orientation
+  #
+  # +COLORBAR_HORIZONTAL+::	Color bar shown horizontally
+  # +COLORBAR_VERTICAL+::	Color bar shown vertically
+
+  class FXColorBar < FXFrame
+
+    # Hue [Float]
+    attr_accessor :hue
+    
+    # Saturation [Float]
+    attr_accessor :sat
+    
+    # Value [Float]
+    attr_accessor :val
+    
+    # Color bar style (one of +COLORBAR_HORIZONTAL+ or +COLORBAR_VERTICAL+) [Integer]
+    attr_accessor	:barStyle
+    
+    # Status line help text [String]
+    attr_accessor	:helpText
+    
+    # Tool tip message [String]
+    attr_accessor	:tipText
+
+    # Construct color bar
+    def initialize(parent, target=nil, selector=0, opts=FRAME_NORMAL, x=0, y=0, width=0, height=0, padLeft=DEFAULT_PAD, padRight=DEFAULT_PAD, padTop=DEFAULT_PAD, padBottom=DEFAULT_PAD) # :yields: theColorBar
+    end
+  end
+end

data/rdoc-sources/FXColorDialog.rb

@@ -0,0 +1,37 @@
+module Fox
+  #
+  # FXColorDialog is a standard dialog panel used to edit colors.
+  # Colors can be edited via RGB (Red, Green, Blue additive color model),
+  # via HSV (Hue, Saturation, Value color modal), via CMY (Cyan, Magenta,
+  # Yellow subtractive color model), or by name.
+  # Commonly used colors can be dragged into a number of small color wells
+  # to be used repeatedly; colors dropped into the small color wells are
+  # automatically saved into the registry for future use.
+  #
+  # === Events
+  #
+  # The following messages are sent by FXColorDialog to its target:
+  #
+  # +SEL_CHANGED+::	sent continuously, while the color selector's color is changing
+  # +SEL_COMMAND+::	sent when the new color is set
+  #
+  # === Message identifiers
+  #
+  # +ID_COLORSELECTOR+::	used internally to identify messages from the FXColorSelector
+
+  class FXColorDialog < FXDialogBox
+
+    # The color [FXColor]
+    attr_accessor :rgba
+   
+    # Only opaque colors allowed [Boolean]
+    attr_writer :opaqueOnly
+
+    # Construct color dialog
+    def initialize(owner, title, opts=0, x=0, y=0, width=0, height=0) # :yields: theColorDialog
+    end
+  
+    # Return +true+ if only opaque colors allowed
+    def opaqueOnly?() ; end
+  end
+end

data/rdoc-sources/FXColorList.rb

@@ -0,0 +1,55 @@
+module Fox
+  # Color item
+  class FXColorItem < FXListItem
+    # Item color [FXColor]
+    attr_accessor :color
+    
+    # Return a new color item, initialized with the given text, color and
+    # user data.
+    def initialize(text, clr, data=nil) # :yields: theColorItem
+    end
+  end
+  
+  # Displays a list of colors
+  class FXColorList < FXList
+
+    #
+    # Return an initially empty list of colors.
+    #
+    def initialize(p, target=nil, selector=0, opts=LIST_BROWSESELECT, x=0, y=0, width=0, height=0) # :yields: theColorList
+    end
+
+    #
+    # Fill list by appending color items from array of strings and array of colors.
+    #
+    def fillItems(strings, colors=nil, ptr=nil, notify=false); end
+
+    #
+    # Insert item at index with given text, color, and user-data pointer
+    #
+    def insertItem(index, text, color=0, ptr=nil, notify=false); end
+
+    #
+    # Append new item with given text, color, and user-data pointer
+    #
+    def appendItem(text, color=0, ptr=nil, notify=false); end
+
+    #
+    # Prepend new item with given text, color, and user-data pointer
+    #
+    def prependItem(text, color=0, ptr=nil, notify=false); end
+
+    #
+    # Change item color for the item at _index_.
+    # Raises IndexError if _index_ is out of bounds.
+    #
+    def setItemColor(index, color); end
+
+    #
+    # Return item color for the item at _index_.
+    # Raises IndexError if _index_ is out of bounds.
+    #
+    def getItemColor(index); end
+  end
+end
+

data/rdoc-sources/FXColorRing.rb

@@ -0,0 +1,49 @@
+module Fox
+  #
+  # A Color Ring widget provides an intuitive way to specify a color.
+  # The outer ring of the widget is rotated to control the hue of the color
+  # being specified, while the inner triangle varies the color saturation
+  # and the brightness of the color.  The color saturation axis of the
+  # triangle goes from a fully saturated "pure" color to "pastel" color;
+  # the brightness goes from black to a bright color.
+  #
+  # === Events
+  #
+  # The following messages are sent by FXColorRing to its target:
+  #
+  # +SEL_CHANGED+::		sent continuously while the user is dragging the spot around; the message data is a three-element array containing the hue, saturation and value values.
+  # +SEL_COMMAND+::		sent when the user releases the mouse button and "drops" the spot at its new location; the message data is a three-element array containing the hue, saturation and value values.
+  # +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.
+  #
+  class FXColorRing < FXFrame
+  
+    # Hue [Float]
+    attr_accessor :hue
+    
+    # Saturation [Float]
+    attr_accessor :sat
+    
+    # Value [Float]
+    attr_accessor :val
+    
+    # Width of hue ring in pixels [Integer]
+    attr_accessor :ringWidth
+    
+    # Status line help text [String]
+    attr_accessor :helpText
+    
+    # Tool tip message [String]
+    attr_accessor :tipText
+    
+    #
+    # Return an initialized FXColorRing instance.
+    #
+    def initialize(p, target=nil, selector=0, opts=FRAME_NORMAL, x=0, y=0, width=0, height=0, padLeft=DEFAULT_PAD, padRight=DEFAULT_PAD, padTop=DEFAULT_PAD, padBottom=DEFAULT_PAD) # :yields: theColorRing
+    end
+    
+    # Set the hue, saturation and value (all floating point values)
+    def setHueSatVal(h, s, v); end
+  end
+end
+