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 setOpenIcon(oi, owned=false); 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 setClosedIcon(ci, owned=false); 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

    # 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]
    # +target+::	the message target, if any, for this tree list [FXObject]
    # +selector+::	the message identifier for this tree list [Integer]
    # +opts+::	tree list options [Integer]
    # +x+::	initial x-position [Integer]
    # +y+::	initial y-position [Integer]
    # +width+::	initial width [Integer]
    # +height+::	initial height [Integer]
    #
    def initialize(p, target=nil, selector=0, opts=TREELIST_NORMAL, x=0, y=0, width=0, height=0) # :yields: theTreeList
    end

    #
    # Fill tree list by appending items from array of strings and return the
    # number of items added.
    # If _notify_ is +true+, a +SEL_INSERTED+ message is sent to the list's
    # message target after each item is added.
    #
    def fillItems(father, strings, oi=nil, ci=nil, ptr=nil, notify=false); end

    # Insert a new (possibly subclassed) _item_ under _father_ before _other_ item
    # 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 insertItem(other, father, item, notify=false); end

    # Insert item with given text and optional icons, and user-data pointer under _father_ before _other_ item.
    # 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 insertItem(other, father, text, oi=nil, ci=nil, ptr=nil, notify=false); end

    # Append a new (possibly subclassed) _item_ as last child of _father_.
    # 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 appendItem(father, item, notify=false); end

    # Append item with given text and optional icons, and user-data pointer as last child of _father_.
    # 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 appendItem(father, text, oi=nil, ci=nil, ptr=nil, notify=false); end

    # Prepend a new (possibly subclassed) _item_ as first child of _father_.
    # 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 prependItem(father, item, notify=false); end

    # Prepend item with given text and optional icons, and user-data pointer as first child of _father_.
    # 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 prependItem(father, text, oi=nil, ci=nil, ptr=nil, notify=false); end

    #
    # Move _item_ under _father_ before _other_ item and return a reference to
    # _item_.
    #
    def moveItem(other, father, item); end

    #
    # Extract item from list and return a reference to the item.
    # If _notify_ is  +true+ and the extraction causes the list's current item
    # to change, a +SEL_CHANGED+ message is sent to the list's message target
    # before the item is extracted from the list.
    #
    def extractItem(item, 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

    # Return item width
    def getItemWidth(item); end

    # Return item height
    def getItemHeight(item); end

    # Return a reference to the tree item at (_x_, _y_), if any.
    def getItemAt(x, y); end

    #
    # Search items by _text_, beginning from item _start_ (an FXTreeItem instance).
    # If the start item is +nil+, the search will start at the first, top-most
    # item in the list.
    # Flags may be +SEARCH_FORWARD+ or +SEARCH_BACKWARD+ to control the search
    # direction; this can be combined with +SEARCH_NOWRAP+ or +SEARCH_WRAP+
    # to control whether the search wraps at the start or end of the list.
    # The option +SEARCH_IGNORECASE+ causes a case-insensitive match. Finally,
    # passing +SEARCH_PREFIX+ causes searching for a prefix of the item name.
    # Return +nil+ if no matching item is found.
    #
    def findItem(text, start=nil, flags=SEARCH_FORWARD|SEARCH_WRAP); end

    #
    # Search items by associated user _data_, beginning from item _start_
    # (an FXTreeItem instance).
    # If the start item is +nil+ the search will start at the first, top-most item
    # in the list.
    # Flags may be +SEARCH_FORWARD+ or +SEARCH_BACKWARD+ to control the search
    # direction; this can be combined with +SEARCH_NOWRAP+ or +SEARCH_WRAP+
    # to control whether the search wraps at the start or end of the list.
    # Return +nil+ if no matching item is found.
    #
    def findItemByData(data, start=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, deleting the old icon if it's owned
    def setItemOpenIcon(item, openIcon, owned=false); end

    # Return item's open icon
    def getItemOpenIcon(item); end

    # Change item's closed icon, deleting the old icon if it's owned
    def setItemClosedIcon(item, closedIcon, owned=false); 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

    #
    # 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