fxruby 1.2.2

data/rdoc-sources/FXTopWindow.rb

@@ -0,0 +1,92 @@
+module Fox
+  #
+  # Abstract base class for all top-level windows
+  #
+  # === Events
+  #
+  # The following messages are sent by FXTopWindow to its target:
+  #
+  # +SEL_CLOSE+::
+  #   sent when the user clicks the close button in the upper right-hand
+  #   corner of the top-level window.
+  #
+  # === Title and border decorations
+  #
+  # +DECOR_NONE+::            Borderless window
+  # +DECOR_TITLE+::           Window title
+  # +DECOR_MINIMIZE+::        Minimize button
+  # +DECOR_MAXIMIZE+::        Maximize button
+  # +DECOR_CLOSE+::           Close button
+  # +DECOR_BORDER+::          Border
+  # +DECOR_RESIZE+::          Resize handles
+  # +DECOR_MENU+::            Window menu
+  # +DECOR_ALL+::             All of the above
+  #
+  # === Initial window placement
+  #
+  # +PLACEMENT_DEFAULT+::     Place it at the default size and location
+  # +PLACEMENT_VISIBLE+::     Place window to be fully visible
+  # +PLACEMENT_CURSOR+::      Place it under the cursor position
+  # +PLACEMENT_OWNER+::       Place it centered on its owner
+  # +PLACEMENT_SCREEN+::      Place it centered on the screen
+  # +PLACEMENT_MAXIMIZED+::   Place it maximized to the screen size
+  #
+  # === Message identifiers
+  #
+  # +ID_ICONIFY+::            Iconify the window
+  # +ID_DEICONIFY+::          Deiconify the window
+  # +ID_QUERY_DOCK+::         Toolbar asks to dock
+
+  class FXTopWindow < FXShell
+
+    # Window title [String]
+    attr_accessor	:title
+    
+    # Top padding, in pixels [Integer]
+    attr_accessor	:padTop
+    
+    # Bottom padding, in pixels [Integer]
+    attr_accessor	:padBottom
+    
+    # Left padding, in pixels [Integer]
+    attr_accessor	:padLeft
+    
+    # Right padding, in pixels [Integer]
+    attr_accessor	:padRight
+    
+    # Horizontal spacing between child widgets, in pixels [Integer]
+    attr_accessor	:hSpacing
+    
+    # Vertical spacing between child widgets, in pixels [Integer]
+    attr_accessor	:vSpacing
+    
+    # Packing hints for child widgets [Integer]
+    attr_accessor	:packingHints
+    
+    # Title and border decorations (see above) [Integer]
+    attr_accessor	:decorations
+    
+    # Window icon [FXIcon]
+    attr_accessor	:icon
+    
+    # Window mini (title) icon [FXIcon]
+    attr_accessor	:miniIcon
+
+    # Show this window with given _placement_
+    # (one of +PLACEMENT_DEFAULT+, +PLACEMENT_VISIBLE+, +PLACEMENT_CURSOR+, +PLACEMENT_OWNER+, +PLACEMENT_SCREEN+ or +PLACEMENT_MAXIMIZED+).
+    def show(placement) ; end
+  
+    # Position the window based on _placement_
+    # (one of +PLACEMENT_DEFAULT+, +PLACEMENT_VISIBLE+, +PLACEMENT_CURSOR+, +PLACEMENT_OWNER+, +PLACEMENT_SCREEN+ or +PLACEMENT_MAXIMIZED+).
+    def place(placement) ; end
+  
+    # Iconify window
+    def iconify() ; end
+  
+    # Deiconify window
+    def deiconify() ; end
+  
+    # Return +true+ if window has been iconified
+    def iconified?() ; end
+  end
+end

data/rdoc-sources/FXTreeList.rb

@@ -0,0 +1,503 @@
+module Fox
+  #
+  # Each item in an FXTreeList is an instance of FXTreeItem.
+  #
+  # A tree item can contain zero or more child items, and those items are arranged
+  # as a linked list. The FXTreeItem#first method returns the a reference to the
+  # first child item, if any, and the FXTreeItem#last method returns a reference to
+  # the last child item.
+  #
+  class FXTreeItem < FXObject
+  
+    #
+    # Return a new FXTreeItem instance, initialized with the specified text,
+    # open-state icon, closed-state icon and user data.
+    #
+    def initialize(text, openIcon=nil, closedIcon=nil, data=nil) # :yields: theItem
+    end
+    
+    # Return the number of child items for this tree item.
+    def numChildren; end
+
+    # Return the item text (a string) for this tree item.
+    def text; end
+    
+    # Set the item text for this tree item.
+    def text=(txt); end
+
+    # Return a reference to the opened-state icon (an FXIcon instance) for
+    # this tree item, or +nil+ if none was specified.
+    def openIcon; end
+    
+    # Set the opened-state icon (an FXIcon instance) for this tree item,
+    # or +nil+ if no icon should be used.
+    def openIcon=(oi); end
+
+    # Return a reference to the closed-state icon (an FXIcon instance) for
+    # this tree item, or +nil+ if none was specified.
+    def closedIcon; end
+    
+    # Set the closed-state icon (an FXIcon instance) for this tree item,
+    # or +nil+ if no icon should be used.
+    def closedIcon=(ci); end
+
+    # Return a reference to the user data for this tree item, or +nil+
+    # if no user data has been associated with this tree item.
+    def data; end
+
+    # Set the user data (a reference to any kind of object) for this tree item,
+    # or +nil+ if no user data needs to be associated with this item.
+    def data=(dt); end
+
+    # Set the focus on this tree item (_focus_ is either +true+ or +false+)
+    def setFocus(focus) ; end
+
+    # Returns +true+ if this item has the focus
+    def hasFocus? ; end
+    
+    # Set this item's selected state to +true+ or +false+.
+    def selected=(sel); end
+
+    # Returns +true+ if this item is selected
+    def selected? ; end
+    
+    # Set this item's "opened" state to +true+ or +false+.
+    def opened=(op); end
+
+    # Returns +true+ if this item is opened
+    def opened? ; end
+    
+    # Set this item's expanded state to +true+ or +false+.
+    def expanded=(ex); end
+    
+    # Returns +true+ if this item is expanded
+    def expanded? ; end
+
+    # Set this item's enabled state to +true+ or +false+.
+    def enabled=(en); end
+
+    # Returns +true+ if this item is enabled
+    def enabled? ; end
+
+    # Set this item's "draggable" state to +true+ or +false+.
+    def draggable=(dr); end
+    
+    # Returns +true+ if this item is draggable
+    def draggable? ; end
+    
+    # Returns +true+ if this item owns its icons
+    def iconOwned? ; end
+    
+    # Return +true+ if this items has subitems, real or imagined.
+    def hasItems?; end
+    
+    # Change has items flag to +true+ or +false+.
+    def hasItems=(flag); end
+        
+    # Return a reference to the parent item for this tree item, or +nil+
+    # if this is a root-level item.
+    def parent; end
+
+    # Return a reference to the first child item for this tree item,
+    # or +nil+ if this tree item has no child items.
+    def first; end
+
+    # Return a reference to the last child item for this tree item,
+    # or +nil+ if this tree item has no child items.
+    def last; end
+
+    # Return a reference to the next sibling item for this tree item,
+    # or +nil+ if this is the last item in the parent item's list of
+    # child items.
+    def next; end
+
+    # Return a reference to the previous sibling item for this tree item,
+    # or +nil+ if this is the first item in the parent item's list of
+    # child items.
+    def prev; end
+
+    # Return a reference to the item that is "logically" below this item.
+    def below; end
+
+    # Return a reference to the item that is "logically" above this item.
+    def above; end
+
+    #
+    # Return +true+ if this item is a descendant of _item_.
+    #
+    def childOf?(item); end
+
+    #
+    # Return +true+ if this item is an ancestor of _item_.
+    #
+    def parentOf?(item); end
+
+    # Returns the item's text
+    def to_s
+      text
+    end
+    
+    # Get the width of this item
+    def getWidth(treeList) ; end
+    
+    # Get the height of this item
+    def getHeight(treeList) ; end
+    
+    # Create this tree item
+    def create; end
+
+    # Detach this tree item
+    def detach; end
+
+    # Destroy this tree item
+    def destroy; end
+  end
+
+  # 
+  # A Tree List Widget organizes items in a hierarchical, tree-like fashion.
+  # Subtrees can be collapsed or expanded by double-clicking on an item
+  # or by clicking on the optional plus button in front of the item.
+  # Each item may have a text and optional open-icon as well as a closed-icon.
+  # The items may be connected by optional lines to show the hierarchical
+  # relationship.
+  # When an item's selected state changes, the treelist emits a SEL_SELECTED
+  # or SEL_DESELECTED message.  If an item is opened or closed, a message
+  # of type SEL_OPENED or SEL_CLOSED is sent.  When the subtree under an
+  # item is expanded, a SEL_EXPANDED or SEL_COLLAPSED message is issued.
+  # A change of the current item is signified by the SEL_CHANGED message.
+  # In addition, the tree list sends SEL_COMMAND messages when the user
+  # clicks on an item, and SEL_CLICKED, SEL_DOUBLECLICKED, and SEL_TRIPLECLICKED
+  # when the user clicks once, twice, or thrice, respectively.
+  # When items are added or removed, the tree list sends messages of the
+  # type SEL_INSERTED or SEL_DELETED.
+  # In each of these cases, a pointer to the item, if any, is passed in the
+  # 3rd argument of the message.
+  #
+  # === Events
+  #
+  # The following messages are sent by FXTreeList 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_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_COMMAND+::		sent when a list item is clicked on; the message data is a reference to the item (an FXTreeItem instance).
+  # +SEL_CLICKED+::		sent when the left mouse button is single-clicked in the list; the message data is a reference to the item clicked (an FXTreeItem instance) or +nil+ if no item was clicked.
+  # +SEL_DOUBLECLICKED+::	sent when the left mouse button is double-clicked in the list; the message data is a reference to the item clicked (an FXTreeItem instance) or +nil+ if no item was clicked.
+  # +SEL_TRIPLECLICKED+::	sent when the left mouse button is triple-clicked in the list; the message data is a reference to the item clicked (an FXTreeItem instance) or +nil+ if no item was clicked.
+  # +SEL_OPENED+::		sent when an item is opened; the message data is a reference to the item (an FXTreeItem instance).
+  # +SEL_CLOSED+::		sent when an item is closed; the message data is a reference to the item (an FXTreeItem instance).
+  # +SEL_EXPANDED+::		sent when a sub-tree is expanded; the message data is a reference to the root item for the sub-tree (an FXTreeItem instance).
+  # +SEL_COLLAPSED+::		sent when a sub-tree is collapsed; the message data is a reference to the root item for the sub-tree (an FXTreeItem instance).
+  # +SEL_SELECTED+::		sent when an item is selected; the message data is a reference to the item (an FXTreeItem instance).
+  # +SEL_DESELECTED+::		sent when an item is deselected; the message data is a reference to the item (an FXTreeItem instance).
+  # +SEL_CHANGED+::		sent when the current item changes; the message data is a reference to the current item (an FXTreeItem instance).
+  # +SEL_INSERTED+::		sent after an item is added to the list; the message data is a reference to the item (an FXTreeItem instance).
+  # +SEL_DELETED+::		sent before an item is removed from the list; the message data is a reference to the item (an FXTreeItem instance).
+  #
+  # === Tree list styles
+  #
+  # +TREELIST_EXTENDEDSELECT+::		Extended selection mode allows for drag-selection of ranges of items
+  # +TREELIST_SINGLESELECT+::		Single selection mode allows up to one item to be selected
+  # +TREELIST_BROWSESELECT+::		Browse selection mode enforces one single item to be selected at all times
+  # +TREELIST_MULTIPLESELECT+::		Multiple selection mode is used for selection of individual items
+  # +TREELIST_AUTOSELECT+::		Automatically select under cursor
+  # +TREELIST_SHOWS_LINES+::		Lines shown
+  # +TREELIST_SHOWS_BOXES+::		Boxes to expand shown
+  # +TREELIST_ROOT_BOXES+::		Display root boxes also
+  # +TREELIST_NORMAL+::			same as +TREELIST_EXTENDEDLIST+
+
+  class FXTreeList < FXScrollArea
+
+    # 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
+
+    # Anchor item, if any [FXTreeItem]
+    attr_accessor	:anchorItem
+
+    # Item under the cursor, if any [FXTreeItem]
+    attr_reader		:cursorItem
+
+    # Text font [FXFont]
+    attr_accessor	:font
+
+    # Parent-child indent amount, in pixels [Integer]
+    attr_accessor	:indent
+
+    # Normal text color [FXColor]
+    attr_accessor	:textColor
+
+    # Selected text background color [FXColor]
+    attr_accessor	:selBackColor
+
+    # Selected text color [FXColor]
+    attr_accessor	:selTextColor
+
+    # Line color [FXColor]
+    attr_accessor	:lineColor
+
+    # List style [Integer]
+    attr_accessor	:listStyle
+
+    # Status line help text for this list [String]
+    attr_accessor	:helpText
+
+    #
+    # Construct a new, initially empty tree list.
+    #
+    # ==== Parameters:
+    #
+    # +p+::	the parent window for this tree list [FXComposite]
+    # +nvis+::	number of visible items [Integer]
+    # +tgt+::	the message target, if any, for this tree list [FXObject]
+    # +sel+::	the message identifier for this tree list [Integer]
+    # +opts+::	tree list options [Integer]
+    # +x+::	initial x-position [Integer]
+    # +y+::	initial y-position [Integer]
+    # +w+::	initial width [Integer]
+    # +h+::	initial height [Integer]
+    #
+    def initialize(p, nvis, tgt=nil, sel=0, opts=TREELIST_NORMAL, x=0, y=0, w=0, h=0) # :yields: theTreeList
+    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
+
+    #
+    # Reparent _item_ under _parentItem_.
+    #
+    def reparentItem(item, parentItem); end
+  
+    #
+    # Move _item_ before _otherItem_ and return a reference to the moved _item_.
+    #
+    def moveItemBefore(otherItem, item); end
+  
+    #
+    # Move _item_ after _otherItem_ and return a reference to the moved _item_.
+    #
+    def moveItemAfter(otherItem, item); 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
+  
+    # Return item width
+    def getItemWidth(item); end
+  
+    # Return item height
+    def getItemHeight(item); 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
+
+    # Scroll the list to make _item_ visible
+    def makeItemVisible(item); 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 item is selected
+    def itemSelected?(item); end
+    
+    # Return +true+ if item is current
+    def itemCurrent?(item); end
+
+    # Return +true+ if item is visible
+    def itemVisible?(item); end
+
+    # Return +true+ if item opened
+    def itemOpened?(item); end
+
+    # Return +true+ if item expanded
+    def itemExpanded?(item); end
+  
+    # Return +true+ if item is a leaf-item, i.e. has no children
+    def itemLeaf?(item); end
+  
+    # Return +true+ if item is enabled
+    def itemEnabled?(item); end
+
+    # Return item hit code: 0 outside, 1 icon, 2 text, 3 box
+    def hitItem(item, x, y); end
+
+    # Repaint item
+    def updateItem(item); end
+  
+    # Enable item
+    def enableItem(item); end
+  
+    # Disable item
+    def disableItem(item); end
+  
+    # Select item.
+    # If _notify_ is +true+, a +SEL_SELECTED+ message is sent to the list's
+    # message target after the item is selected.
+    def selectItem(item, notify=false); end
+
+    # Deselect item.
+    # If _notify_ is +true+, a +SEL_DESELECTED+ message is sent to the list's
+    # message target after the item is deselected.
+    def deselectItem(item, notify=false); end
+  
+    # Toggle item selection.
+    # If _notify_ is +true+, a +SEL_SELECTED+ or +SEL_DESELECTED+ message is
+    # sent to the list's message target to indicate the change.
+    def toggleItem(item, notify=false); end
+  
+    #
+    # Set this item's state to opened. The primary result of this change is
+    # that the item's icon will change to its "open" icon.
+    # This is different from the #expandTree method, which actually
+    # collapses part of the tree list, making some items invisible.
+    # If _notify_ is +true+, a +SEL_OPENED+ message is sent to the list's
+    # message target after the item is opened.
+    #
+    def openItem(item, notify=false); end
+  
+    #
+    # Set this item's state to closed. The primary result of this change is
+    # that the item's icon will change to its "closed" icon.
+    # This is different from the #collapseTree method, which actually
+    # collapses part of the tree list, making some items invisible.
+    # If _notify_ is +true+, a +SEL_CLOSED+ message is sent to the list's
+    # message target after the item is closed.
+    #
+    def closeItem(item, notify=false); end
+  
+    # Collapse sub-tree rooted at _tree_.
+    # If _notify_ is +true+, a +SEL_COLLAPSED+ message is sent to the list's
+    # message target after the sub-tree is collapsed.
+    def collapseTree(tree, notify=false); end
+
+    # Expand sub-tree rooted at _tree_.
+    # If _notify_ is +true+, a +SEL_EXPANDED+ message is sent to the list's
+    # message target after the sub-tree is expanded.
+    def expandTree(tree, notify=false); end
+  
+    # Reparent _item_ under _parentItem_.
+    def reparentItem(item, parentItem); end
+  
+    #
+    # Change current item. If there is already a current item, that item
+    # is first closed. After _item_ is set as the tree list's current item,
+    # it is opened and selected.
+    # If _notify_ is +true+, a +SEL_CHANGED+ message is sent to the list's
+    # message target after the current item changes.
+    #
+    def setCurrentItem(item, notify=false); end
+  
+    # Extend selection from anchor item to _item_.
+    # If _notify_ is +true+, a series of +SEL_SELECTED+ and +SEL_DESELECTED+
+    # messages may be sent to the list's message target, indicating the changes.
+    def extendSelection(item, notify=false); end
+    
+    # Deselect all items.
+    # If _notify_ is +true+, +SEL_DESELECTED+ messages will be sent to the list's
+    # message target indicating the affected items.
+    def killSelection(notify=false); end
+    
+    # Sort root items.
+    def sortRootItems(); end
+
+    # Sort all items recursively.
+    def sortItems(); end
+
+    # Sort children of _item_
+    def sortChildItems(item); end
+  end
+end
+