ItemListBase.h

/***********************************************************************
        created:        31/3/2005
        author:         Tomas Lindquist Olsen (based on original Listbox code by Paul D Turner)
        
        purpose:        Interface to base class for ItemListBase widgets
*************************************************************************/
/***************************************************************************
 *   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 _CEGUIItemListBase_h_
#define _CEGUIItemListBase_h_

#include "../Base.h"
#include "../Window.h"
#include "./ItemEntry.h"

#include <vector>


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


// Start of CEGUI namespace section
namespace CEGUI
{

class CEGUIEXPORT ItemListBaseWindowRenderer : public WindowRenderer
{
public:
    ItemListBaseWindowRenderer(const String& name);

    virtual Rectf getItemRenderArea(void) const = 0;
};

class CEGUIEXPORT ItemListBase : public Window
{
public:
        static const String EventNamespace;                             

    enum SortMode
    {
        Ascending,
        Descending,
        UserSort
    };

    typedef bool (*SortCallback)(const ItemEntry* a, const ItemEntry* b);

        /*************************************************************************
                Constants
        *************************************************************************/
        // event names
        static const String EventListContentsChanged;
    static const String EventSortEnabledChanged;
    static const String EventSortModeChanged;

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


        ItemEntry*      getItemFromIndex(size_t index) const;


        size_t  getItemIndex(const ItemEntry* item) const;


        ItemEntry*      findItemWithText(const String& text, const ItemEntry* start_item);


        bool    isItemInList(const ItemEntry* item) const;


        bool isAutoResizeEnabled() const                {return d_autoResize;}


    bool isSortEnabled(void) const          {return d_sortEnabled;}


    SortMode getSortMode(void) const        {return d_sortMode;}


    SortCallback getSortCallback(void) const {return d_sortCallback;}

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


        void    resetList(void);


        void    addItem(ItemEntry* item);


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


        void    removeItem(ItemEntry* item);


        void    handleUpdatedItemData(bool resort=false);


        void setAutoResizeEnabled(bool setting);


        virtual void    sizeToContent(void)             {sizeToContent_impl();}


    virtual void endInitialisation(void);


    void performChildWindowLayout(bool nonclient_sized_hint = false,
                                  bool client_sized_hint = false);


    Rectf getItemRenderArea(void) const;

    Window* getContentPane(void) const  {return d_pane;}

    virtual void notifyItemClicked(ItemEntry*) {}

    virtual void notifyItemSelectState(ItemEntry*, bool) {}

    void setSortEnabled(bool setting);

    void setSortMode(SortMode mode);

    void setSortCallback(SortCallback cb);

    void sortList(bool relayout=true);

        /*************************************************************************
                Construction and Destruction
        *************************************************************************/
        ItemListBase(const String& type, const String& name);


        virtual ~ItemListBase(void);


protected:
        /*************************************************************************
                Abstract Implementation Functions (must be provided by derived class)
        *************************************************************************/
        virtual void    sizeToContent_impl(void);


        virtual Sizef getContentSize() const = 0;


        //virtual       Rect    getItemRenderArea_impl(void) const              = 0;


        virtual void    layoutItemWidgets()     = 0;


        /*************************************************************************
                Implementation Functions
        *************************************************************************/
        bool    resetList_impl(void);

    // validate window renderer
    virtual bool validateWindowRenderer(const WindowRenderer* renderer) const;

    SortCallback getRealSortCallback(void) const;

        /*************************************************************************
                New event handlers
        *************************************************************************/
        virtual void    onListContentsChanged(WindowEventArgs& e);

    virtual void onSortEnabledChanged(WindowEventArgs& e);

    virtual void onSortModeChanged(WindowEventArgs& e);

        /*************************************************************************
                Overridden Event handlers
        *************************************************************************/
    virtual void onParentSized(ElementEventArgs& e);
        //virtual void    onChildRemoved(WindowEventArgs& e);
    //virtual void    onDestructionStarted(WindowEventArgs& e);


    virtual bool handle_PaneChildRemoved(const EventArgs& e);

        /*************************************************************************
                Implementation Data
        *************************************************************************/
        typedef std::vector<ItemEntry*
        CEGUI_VECTOR_ALLOC(ItemEntry*)> ItemEntryList;
        ItemEntryList   d_listItems;            

        bool d_autoResize;

    Window* d_pane;

    bool d_sortEnabled;
    SortMode d_sortMode;
    SortCallback d_sortCallback;
    bool d_resort;

private:
        /*************************************************************************
                Private methods
        *************************************************************************/
        void    addItemListBaseProperties(void);


        virtual void addChild_impl(Element* element);
};


template<>
class PropertyHelper<ItemListBase::SortMode>
{
public:
    typedef ItemListBase::SortMode return_type;
    typedef return_type safe_method_return_type;
    typedef ItemListBase::SortMode pass_type;
    typedef String string_return_type;

    static const String& getDataTypeName()
    {
        static String type("SortMode");

        return type;
    }

    static return_type fromString(const String& str)
    {
        if (str == "Ascending")
        {
            return ItemListBase::Ascending;
        }
        else if (str == "Descending")
        {
            return ItemListBase::Descending;
        }
        else
        {
            return ItemListBase::UserSort;
        }
    }

    static string_return_type toString(pass_type val)
    {
        if (val == ItemListBase::UserSort)
        {
            return "UserSort";
        }
        else if (val == ItemListBase::Ascending)
        {
            return "Ascending";
        }
        else if (val == ItemListBase::Descending)
        {
            return "Descending";
        }
        else
        {
            assert(false && "Invalid sort mode");
            return "Ascending";
        }
    }
};


} // End of  CEGUI namespace section


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

#endif  // end of guard _CEGUIItemListBase_h_