widgets/Tree.h

/***********************************************************************
    created:    5-13-07
    author:             Jonathan Welch (Based on Code by David Durant)
 *************************************************************************/
/***************************************************************************
 *   Copyright (C) 2004 - 2006 Paul D Turner & The CEGUI Development Team
 *
 *   Permission is hereby granted, free of charge, to any person obtaining
 *   a copy of this software and associated documentation files (the
 *   "Software"), to deal in the Software without restriction, including
 *   without limitation the rights to use, copy, modify, merge, publish,
 *   distribute, sublicense, and/or sell copies of the Software, and to
 *   permit persons to whom the Software is furnished to do so, subject to
 *   the following conditions:
 *
 *   The above copyright notice and this permission notice shall be
 *   included in all copies or substantial portions of the Software.
 *
 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 *   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 *   OTHER DEALINGS IN THE SOFTWARE.
 ***************************************************************************/
#ifndef _CEGUITree_h_
#define _CEGUITree_h_

#include "../Base.h"
#include "../Window.h"
#include "../WindowManager.h"
#include "./TreeItem.h"
#include "./Scrollbar.h"
#include <vector>

#if defined(_MSC_VER)
#       pragma warning(push)
#       pragma warning(disable : 4251)
#endif

// Start of CEGUI namespace section
namespace CEGUI
{
class CEGUIEXPORT TreeEventArgs : public WindowEventArgs
{
public:
    TreeEventArgs(Window* wnd) : WindowEventArgs(wnd)
        { treeItem = 0; }

    TreeItem *treeItem;
};


class CEGUIEXPORT Tree : public Window
{
    friend class TreeItem;

    typedef     std::vector<TreeItem*
        CEGUI_VECTOR_ALLOC(TreeItem*)> LBItemList;
    
public:
    static const String EventNamespace;
    static const String WidgetTypeName;
    
    /*************************************************************************
        Constants
     *************************************************************************/
    // event names
    static const String EventListContentsChanged;
    static const String EventSelectionChanged;
    static const String EventSortModeChanged;
    static const String EventMultiselectModeChanged;
    static const String EventVertScrollbarModeChanged;
    static const String EventHorzScrollbarModeChanged;
    static const String EventBranchOpened;
    static const String EventBranchClosed;

    //Render the actual tree
    void doTreeRender()
        { populateGeometryBuffer(); }

    //UpdateScrollbars
    void doScrollbars()
        { configureScrollbars(); }

    /*************************************************************************
        Accessor Methods
     *************************************************************************/
    size_t getItemCount(void) const
        { return d_listItems.size(); }

    size_t getSelectedCount(void) const;

    TreeItem* getFirstSelectedItem(void) const;
        
    TreeItem* getLastSelectedItem(void) const
        { return d_lastSelected; }

    TreeItem* getNextSelected(const TreeItem* start_item) const;
    
    TreeItem* getNextSelectedItemFromList(const LBItemList &itemList,
                                          const TreeItem* start_item,
                                          bool& foundStartItem) const;

    bool isSortEnabled(void) const
        { return d_sorted; }
    
    void setItemRenderArea(Rectf& r)
        { d_itemArea = r; }
    
    Scrollbar* getVertScrollbar()
        { return d_vertScrollbar; }

    Scrollbar* getHorzScrollbar()
        { return d_horzScrollbar; }

    bool isMultiselectEnabled(void) const
        { return d_multiselect; }
    
    bool isItemTooltipsEnabled(void) const
        { return d_itemTooltips; }

    TreeItem* findFirstItemWithText(const String& text);

    TreeItem* findNextItemWithText(const String& text,
                                   const TreeItem* start_item);

    TreeItem* findItemWithTextFromList(const LBItemList &itemList,
                                       const String& text,
                                       const TreeItem* start_item,
                                       bool foundStartItem);

    TreeItem* findFirstItemWithID(uint searchID);
    TreeItem* findNextItemWithID(uint searchID, const TreeItem* start_item);
    TreeItem* findItemWithIDFromList(const LBItemList &itemList, uint searchID,
                                     const TreeItem* start_item,
                                     bool foundStartItem);

    bool isTreeItemInList(const TreeItem* item) const;

    bool isVertScrollbarAlwaysShown(void) const;

    bool isHorzScrollbarAlwaysShown(void) const;

    /*************************************************************************
        Manipulator Methods
     *************************************************************************/
    virtual void initialise(void);

    void resetList(void);

    void addItem(TreeItem* item);

    void insertItem(TreeItem* item, const TreeItem* position);

    void removeItem(const TreeItem* item);

    void clearAllSelections(void);
    bool clearAllSelectionsFromList(const LBItemList &itemList);

    void setSortingEnabled(bool setting);

    void setMultiselectEnabled(bool setting);

    void setShowVertScrollbar(bool setting);

    void setShowHorzScrollbar(bool setting);
    
    void setItemTooltipsEnabled(bool setting);

    void setItemSelectState(TreeItem* item, bool state);

    void setItemSelectState(size_t item_index, bool state);
    
    virtual void setLookNFeel(const String& look);
    
    void handleUpdatedItemData(void);

    void ensureItemIsVisible(const TreeItem* item);
    
    
    /*************************************************************************
     Construction and Destruction
     *************************************************************************/
    Tree(const String& type, const String& name);

    virtual ~Tree(void);

protected:
    /*************************************************************************
        Abstract Implementation Functions (must be provided by derived class)
     *************************************************************************/
    virtual     Rectf getTreeRenderArea(void) const
        { return d_itemArea; }
    
    virtual Scrollbar* createVertScrollbar(const String& name) const
        { return static_cast<Scrollbar*>(getChild(name)); }

    virtual Scrollbar* createHorzScrollbar(const String& name) const
        { return static_cast<Scrollbar*>(getChild(name)); }

    virtual     void cacheTreeBaseImagery()
    {}
    
    /*************************************************************************
        Implementation Functions
     *************************************************************************/
    bool containsOpenItemRecursive(const LBItemList& itemList, TreeItem* item);

    void addTreeEvents(void);
    
    
    void configureScrollbars(void);
    
    void selectRange(size_t start, size_t end);
    
    float getTotalItemsHeight(void) const;
    void getTotalItemsInListHeight(const LBItemList &itemList,
                                    float *heightSum) const;

    float getWidestItemWidth(void) const;
    void getWidestItemWidthInList(const LBItemList &itemList, int itemDepth,
                                  float *widest) const;
    
    bool getHeightToItemInList(const LBItemList &itemList,
                               const TreeItem *treeItem,
                               int itemDepth,
                               float *height) const;

    bool clearAllSelections_impl(void);

    TreeItem* getItemAtPoint(const Vector2f& pt) const;
    TreeItem* getItemFromListAtPoint(const LBItemList &itemList, float *bottomY,
                                     const Vector2f& pt) const;

    bool resetList_impl(void);
    
    bool handle_scrollChange(const EventArgs& args);
    
    // overridden from Window base class.
    virtual void populateGeometryBuffer();
    bool handleFontRenderSizeChange(const EventArgs& args);
 
     void drawItemList(LBItemList& itemList, Rectf& itemsArea, float widest,
                       Vector2f& itemPos, GeometryBuffer& geometry, float alpha);
    
    /*************************************************************************
        New event handlers
     *************************************************************************/
    virtual     void onListContentsChanged(WindowEventArgs& e);

    virtual     void onSelectionChanged(TreeEventArgs& e);

    virtual     void onSortModeChanged(WindowEventArgs& e);

    virtual     void onMultiselectModeChanged(WindowEventArgs& e);

    virtual     void onVertScrollbarModeChanged(WindowEventArgs& e);

    virtual     void onHorzScrollbarModeChanged(WindowEventArgs& e);
    
    virtual     void onBranchOpened(TreeEventArgs& e);
    
    virtual     void onBranchClosed(TreeEventArgs& e);
    
    /*************************************************************************
        Overridden Event handlers
     *************************************************************************/
    virtual void onSized(ElementEventArgs& e);
    virtual void onMouseButtonDown(MouseEventArgs& e);
    virtual     void onMouseWheel(MouseEventArgs& e);
    virtual void onMouseMove(MouseEventArgs& e);

    /*************************************************************************
        Implementation Data
     *************************************************************************/
    bool d_sorted;
    bool d_multiselect;
    bool d_forceVertScroll;
    bool d_forceHorzScroll;
    bool d_itemTooltips;
    Scrollbar* d_vertScrollbar;
    Scrollbar* d_horzScrollbar;
    LBItemList d_listItems;
    TreeItem* d_lastSelected;
    const ImagerySection* d_openButtonImagery;
    const ImagerySection* d_closeButtonImagery;

private:
    /*************************************************************************
        Private methods
     *************************************************************************/
    void addTreeProperties(void);
    Rectf d_itemArea;
};

bool lbi_less(const TreeItem* a, const TreeItem* b);


bool lbi_greater(const TreeItem* a, const TreeItem* b);

} // End of  CEGUI namespace section


#if defined(_MSC_VER)
#       pragma warning(pop)
#endif

#endif  // end of guard _CEGUITree_h_