fxruby 1.2.2

data/rdoc-sources/FXTreeListBox.rb

@@ -0,0 +1,182 @@
+module Fox
+  #
+  # Tree list box.
+  #
+  # === Tree list box styles
+  #
+  # +TREELISTBOX_NORMAL+::	Normal style
+  #
+  # === Message identifiers
+  #
+  # +ID_TREE+::		x
+  # +ID_FIELD+::	x
+  #
+  class FXTreeListBox < FXPacker
+
+    # Number of items [Integer]
+    attr_reader :numItems
+
+    # Number of visible items [Integer]
+    attr_accessor :numVisible
+
+    # First root-level item [FXTreeItem]
+    attr_reader :firstItem
+
+    # Last root-level item [FXTreeItem]
+    attr_reader :lastItem
+
+    # Current item, if any [FXTreeItem]
+    attr_accessor :currentItem
+
+    # Text font [FXFont]
+    attr_accessor :font
+    
+    # Tree list box style
+    attr_accessor :listStyle
+
+    # Status line help text for this tree list box [String]
+    attr_accessor :helpText
+
+    # Tool tip text for this tree list box [String]
+    attr_accessor :tipText
+
+    #
+    # Return an initially empty FXTreeListBox.
+    #
+    # ==== Parameters:
+    #
+    # +p+::	the parent window for this tree list box [FXComposite]
+    # +tgt+::	the message target, if any, for this tree list box [FXObject]
+    # +sel+::	the message identifier for this tree list box [Integer]
+    # +opts+::	tree list options [Integer]
+    # +x+::	initial x-position [Integer]
+    # +y+::	initial y-position [Integer]
+    # +w+::	initial width [Integer]
+    # +h+::	initial height [Integer]
+    # +pl+::	internal padding on the left side, in pixels [Integer]
+    # +pr+::	internal padding on the right side, in pixels [Integer]
+    # +pt+::	internal padding on the top side, in pixels [Integer]
+    # +pb+::	internal padding on the bottom side, in pixels [Integer]
+    #
+    def initialize(p, tgt=nil, sel=0, opts=FRAME_SUNKEN|FRAME_THICK|TREELISTBOX_NORMAL, x=0, y=0, w=0, h=0, pl=DEFAULT_PAD, pr=DEFAULT_PAD, pt=DEFAULT_PAD, pb=DEFAULT_PAD) # :yields: theTreeListBox
+    end
+
+    # Prepend a new (possibly subclassed) _item_ as first child of _parentItem_.
+    # Returns a reference to the newly added item (an FXTreeItem instance).
+    # If _notify_ is +true+, a +SEL_INSERTED+ message is sent to the list's message
+    # target after the item is added.
+    def addItemFirst(parentItem, item, notify=false); end
+  
+    # Prepend a new item with given _text_ and optional _openIcon_, _closedIcon_ and user _data_, as first child of _parentItem_.
+    # Returns a reference to the newly added item (an FXTreeItem instance).
+    # If _notify_ is +true+, a +SEL_INSERTED+ message is sent to the list's message
+    # target after the item is added.
+    def addItemFirst(parentItem, text, openIcon=nil, closedIcon=nil, data=nil, notify=false); end
+  
+    # Append a new (possibly subclassed) _item_ as last child of _parentItem_.
+    # Returns a reference to the newly added item (an FXTreeItem instance).
+    # If _notify_ is +true+, a +SEL_INSERTED+ message is sent to the list's message
+    # target after the item is added.
+    def addItemLast(parentItem, item, notify=false); end
+  
+    # Append a new item with given _text_ and optional _openIcon_, _closedIcon_ and user _data_, as last child of _parentItem_.
+    # Returns a reference to the newly added item (an FXTreeItem instance).
+    # If _notify_ is +true+, a +SEL_INSERTED+ message is sent to the list's message
+    # target after the item is added.
+    def addItemLast(parentItem, text, openIcon=nil, closedIcon=nil, data=nil, notify=false); end
+  
+    # Append a new (possibly subclassed) _item_ after _otherItem_. 
+    # Returns a reference to the newly added item (an FXTreeItem instance).
+    # If _notify_ is +true+, a +SEL_INSERTED+ message is sent to the list's message
+    # target after the item is added.
+    def addItemAfter(otherItem, item, notify=false); end
+  
+    # Append a new item with given _text_ and optional _openIcon_, _closedIcon_ and user _data_ after _otherItem_. 
+    # Returns a reference to the newly added item (an FXTreeItem instance).
+    # If _notify_ is +true+, a +SEL_INSERTED+ message is sent to the list's message
+    # target after the item is added.
+    def addItemAfter(otherItem, text, openIcon=nil, closedIcon=nil, data=nil, notify=false); end
+  
+    # Prepend a new (possibly subclassed) _item_ prior to _otherItem_. 
+    # Returns a reference to the newly added item (an FXTreeItem instance).
+    # If _notify_ is +true+, a +SEL_INSERTED+ message is sent to the list's message
+    # target after the item is added.
+    def addItemBefore(otherItem, item, notify=false); end
+  
+    # Prepend a new item with given _text_ and optional _openIcon_, _closedIcon_ and user _data_ prior to _otherItem_. 
+    # Returns a reference to the newly added item (an FXTreeItem instance).
+    # If _notify_ is +true+, a +SEL_INSERTED+ message is sent to the list's message
+    # target after the item is added.
+    def addItemBefore(otherItem, text, openIcon=nil, closedIcon=nil, data=nil, notify=false); end
+
+    # Remove item.
+    # If _notify_ is +true+, a +SEL_DELETED+ message is sent to the list's message
+    # target before the item is removed.
+    def removeItem(item, notify=false);
+
+    # Remove items in range [_fromItem_, _toItem_] inclusively.
+    # If _notify_ is +true+, a +SEL_DELETED+ message is sent to the list's message
+    # target before each item is removed.
+    def removeItems(fromItem, toItem, notify=false); end
+
+    # Remove all items from the list.
+    # If _notify_ is +true+, a +SEL_DELETED+ message is sent to the list's message
+    # target before each item is removed.
+    def clearItems(notify=false); end
+
+    # Search items for item by _text_, starting from _startItem_; the
+    # _flags_ argument controls the search direction, and case sensitivity.
+    # Returns a reference to the matching item, or +nil+ if no match is found.
+    def findItem(text, startItem=nil, flags=SEARCH_FORWARD|SEARCH_WRAP); end
+
+    # Return +true+ if item is current
+    def itemCurrent?(item); end
+
+    # Return +true+ if item is a leaf-item, i.e. has no children
+    def itemLeaf?(item); end
+
+    # Sort root items
+    def sortRootItems(); end
+
+    # Sort all items recursively.
+    def sortItems(); end
+
+    # Sort children of _item_
+    def sortChildItems(item); end
+
+    #
+    # Change current item.
+    # If _notify_ is +true+, a SEL_CHANGED message is sent to the tree list box's
+    # message target.
+    #
+    def setCurrentItem(item, notify=false); end
+    
+    # Change item's text
+    def setItemText(item, text); end
+    
+    # Return item's text
+    def getItemText(item); end
+  
+    # Change item's open icon
+    def setItemOpenIcon(item, openIcon); end
+    
+    # Return item's open icon
+    def getItemOpenIcon(item); end
+    
+    # Change item's closed icon
+    def setItemClosedIcon(item, closedIcon); end
+    
+    # Return item's closed icon
+    def getItemClosedIcon(item); end
+  
+    # Change item's user data
+    def setItemData(item, data); end
+  
+    # Return item's user data
+    def getItemData(item); end
+  
+    # Return +true+ if the pane is shown.
+    def paneShown?; end
+  end
+end
+

data/rdoc-sources/FXTriStateButton.rb

@@ -0,0 +1,49 @@
+module Fox
+  #
+  # The tri-state button provides a three-state button, which toggles between the
+  # on and the off state each time it is pressed. Programmatically, it may also be
+  # switched into the +MAYBE+ state. The +MAYBE+ state is useful to signify an
+  # "unknown" or "indeterminate" state in the application data.
+  #
+  class FXTriStateButton < FXToggleButton
+
+    # Maybe text, shown when toggled [String]
+    attr_accessor	:maybeText
+
+    # Maybe icon, shown when toggled [FXIcon]
+    attr_accessor	:maybeIcon
+
+    # Maybe status line help text, shown when toggled [String]
+    attr_accessor	:maybeHelpText
+
+    # Maybe tool tip message, shown when toggled [String]
+    attr_accessor	:maybeTipText
+
+    #
+    # Return an initialized FXTriStateButton instance.
+    #
+    # ==== Parameters:
+    #
+    # +p+::		the parent window for this tri-state button [FXComposite]
+    # <tt>text1</tt>::	the text for this tri-state button's first state [String]
+    # <tt>text2</tt>::	the text for this tri-state button's second state [String]
+    # <tt>text3</tt>::	the text for this tri-state button's third state [String]
+    # <tt>icon1</tt>::	the icon, if any, for this tri-state button's first state [FXIcon]
+    # <tt>icon2</tt>::	the icon, if any, for this tri-state button's second state [FXIcon]
+    # <tt>icon3</tt>::	the icon, if any, for this tri-state button's second state [FXIcon]
+    # +tgt+::		the message target, if any, for this tri-state button [FXObject]
+    # +sel+::		the message identifier for this tri-state button [Integer]
+    # +opts+::		tri-state button options [Integer]
+    # +x+::		initial x-position [Integer]
+    # +y+::		initial y-position [Integer]
+    # +w+::		initial width [Integer]
+    # +h+::		initial height [Integer]
+    # +pl+::		internal padding on the left side, in pixels [Integer]
+    # +pr+::		internal padding on the right side, in pixels [Integer]
+    # +pt+::		internal padding on the top side, in pixels [Integer]
+    # +pb+::		internal padding on the bottom side, in pixels [Integer]
+    #
+    def initialize(p, text1, text2, text3, icon1=nil, icon2=nil, icon3=nil, tgt=nil, sel=0, opts=TOGGLEBUTTON_NORMAL, x=0, y=0, w=0, h=0, pl=DEFAULT_PAD, pr=DEFAULT_PAD, pt=DEFAULT_PAD, pb=DEFAULT_PAD) # :yields: theTriStateButton
+    end
+  end
+end

data/rdoc-sources/FXVec.rb

@@ -0,0 +1,97 @@
+module Fox
+  class FXVec
+    #
+    # Return an initialized FXVec instance.
+    #
+    def initialize(x=0.0, y=0.0, z=0.0); end
+  
+    #
+    # Returns the element at _index_, where _index_ is 0, 1 or 2.
+    # Raises IndexError if _index_ is out of range.
+    #
+    def [](index); end
+
+    #
+    # Set the element at _index_ to _value_ and return _value_.
+    # Raises IndexError if _index_ is out of range.
+    #
+    def []=(index, value); end
+
+    # Return +true+ if this vector is equal to _other_.
+    def ==(other); end
+
+    # Returns a new FXVec instance which is the negation of this one.
+    def @-(); end
+
+    #
+    # Returns a new FXVec instance obtained by memberwise
+    # addition of the _other_ FXVec instance with this
+    # one.
+    #
+    def +(other); end
+
+    #
+    # Returns a new FXVec instance obtained by memberwise
+    # subtraction of the _other_ FXVec instance from this
+    # one.
+    #
+    def -(other); end
+
+    #
+    # Returns a new FXVec instance obtained by memberwise
+    # multiplication of this vector's elements by the scalar
+    # _n_.
+    #
+    def *(n); end
+
+    #
+    # Returns a new FXVec instance obtained by memberwise
+    # division of this vector's elements by the scalar
+    # _n_.
+    # Raises ZeroDivisionError if _n_ is identically zero.
+    #
+    def /(n); end
+
+    #
+    # Returns the dot (scalar) product of this vector and _other_.
+    #
+    def dot(other); end
+
+    #
+    # Return the cross product of this vector and _other_.
+    #
+    def cross(other); end
+
+    #
+    # Return the length (magnitude) of this vector.
+    #
+    def len; end
+
+    #
+    # Return a new FXVec instance which is a normalized version
+    # of this one.
+    #
+    def normalize; end
+
+    #
+    # Normalize this vector and return a reference to it.
+    #
+    def normalize!; end
+
+    #
+    # Return a new FXVec instance which is the lesser of this
+    # vector and _other_.
+    #
+    def lo(other); end
+
+    #
+    # Return a new FXVec instance which is the greater of this
+    # vector and _other_.
+    #
+    def hi(other); end
+
+    # Return a new Array instance with this vector's elements as its members.
+    def to_a; end
+  end
+end
+

data/rdoc-sources/FXVec4.rb

@@ -0,0 +1,91 @@
+module Fox
+  #
+  # FXHVec is a 3-D homogenous vector.
+  #
+  class FXHVec
+    #
+    # Returns a new, uninitialized FXHVec instance.
+    #
+    def initialize; end
+
+    #
+    # Returns a new FXHVec instance with contents initialized from _other_,
+    # where _other_ is either an FXVec or FXHVec instance.
+    #
+    def initialize(other); end
+  
+    #
+    # Returns a new FXHVec instance with initial components (_x_, _y_, _z_ and _w_).
+    #
+    def initialize(x, y, z, w=1.0); end
+  
+    #
+    # Initialize with color
+    #
+    def initialize(color); end
+  
+    # Returns +true+ if this vector is equal to _other_.
+    def ==(other); end
+    
+    # Returns the negation of this
+    def -@(); end
+    
+    # Returns the <em>i</em>th element of this vector.
+    def [](i); end
+    
+    # Set the <em>i</em>th element of this vector to _x_.
+    def []=(i, x); end
+    
+    # Returns the sum of this vector and another vector
+    def +(other); end
+    
+    # Returns the difference, this vector minus another vector
+    def -(other); end
+    
+    # Returns the product of this vector and the scalar _x_.
+    def *(x); end
+    
+    # Returns the quotient, this vector divided by the scalar _x_.
+    def /(x); end
+
+    # Returns the dot product of this vector and _other_.
+    def dot(other); end
+    
+    # Returns the cross product of this vector and _other_.
+    def cross(other); end
+    
+    # Returns the length of this vector
+    def len; end
+
+    # Returns the normalized version of this vector.
+    def normalize; end
+
+    #
+    # Returns a new FXHVec, each of whose components is equal to the smaller
+    # of this vector's and other's components, i.e.
+    #
+    #   self.lo(other) === FXHVec.new( [self[0], other[0]].min,
+    #                                  [self[1], other[1]].min,
+    #                                  [self[2], other[2]].min,
+    #                                  [self[3], other[3]].min )
+    #
+    def lo(other); end
+
+    #
+    # Returns a new FXHVec, each of whose components is equal to the greater
+    # of this vector's and other's components, i.e.
+    #
+    #   self.lo(other) === FXHVec.new( [self[0], other[0]].max,
+    #                                  [self[1], other[1]].max,
+    #                                  [self[2], other[2]].max,
+    #                                  [self[3], other[3]].max )
+    #
+    def hi(other); end
+    
+    # Returns a stringified version of this vector
+    def to_s; end
+
+    # Convert to an array
+    def to_a; end    
+  end
+end

data/rdoc-sources/FXVerticalFrame.rb

@@ -0,0 +1,29 @@
+module Fox
+  #
+  # Vertical frame layout manager widget is used to automatically
+  # place child-windows vertically from top-to-bottom, or bottom-to-top,
+  # depending on the child window's layout hints.
+  #
+  class FXVerticalFrame < FXPacker
+    #
+    # Return an initialized FXVerticalFrame instance.
+    #
+    # ==== Parameters:
+    #
+    # +p+::	the parent window for this vertical frame [FXComposite]
+    # +opts+::	frame options [Integer]
+    # +x+::	initial x-position [Integer]
+    # +y+::	initial y-position [Integer]
+    # +w+::	initial width [Integer]
+    # +h+::	initial height [Integer]
+    # +pl+::	internal padding on the left side, in pixels [Integer]
+    # +pr+::	internal padding on the right side, in pixels [Integer]
+    # +pt+::	internal padding on the top side, in pixels [Integer]
+    # +pb+::	internal padding on the bottom side, in pixels [Integer]
+    # +hs+::	horizontal spacing between widgets, in pixels [Integer]
+    # +vs+::	vertical spacing between widgets, in pixels [Integer]
+    #
+    def initialize(p, opts=0, x=0, y=0, w=0, h=0, pl=DEFAULT_SPACING, pr=DEFAULT_SPACING, pt=DEFAULT_SPACING, pb=DEFAULT_SPACING, hs=DEFAULT_SPACING, vs=DEFAULT_SPACING) # :yields: theVerticalFrame
+    end
+  end
+end