widgets/TabControl.h

/***********************************************************************
        created:        08/08/2004
        author:         Steve Streeting

        purpose:        Interface to base class for TabControl widget
*************************************************************************/
/***************************************************************************
 *   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 _CEGUITabControl_h_
#define _CEGUITabControl_h_

#include "../Base.h"
#include "../Window.h"
#include <vector>


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


// Start of CEGUI namespace section
namespace CEGUI
{

    // Forward declaration
    class TabButton;

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

    virtual TabButton*  createTabButton(const String& name) const       = 0;
};

class CEGUIEXPORT TabControl : public Window
{
public:
        static const String EventNamespace;                             
    static const String WidgetTypeName;             

        enum TabPanePosition
        {
                Top,
                Bottom
        };

        /*************************************************************************
                Constants
        *************************************************************************/
        // event names
        static const String EventSelectionChanged;

    /*************************************************************************
        Child Widget name constants
    *************************************************************************/
    static const String ContentPaneName;   
    static const String TabButtonName;     
    static const String TabButtonPaneName; 
    static const String ButtonScrollLeft;  
    static const String ButtonScrollRight; 


        /*************************************************************************
                Accessor Methods
        *************************************************************************/
        size_t  getTabCount(void) const;

        TabPanePosition getTabPanePosition(void) const
        { return d_tabPanePos; }

        void    setTabPanePosition(TabPanePosition pos);

    void    setSelectedTab(const String &name);

    void    setSelectedTab(uint ID);

    void    setSelectedTabAtIndex(size_t index);

    void    makeTabVisible(const String &name);

    void    makeTabVisible(uint ID);

    void    makeTabVisibleAtIndex(size_t index);

    Window*     getTabContentsAtIndex(size_t index) const;

    Window*     getTabContents(const String& name) const;

    Window*     getTabContents(uint ID) const;

    bool        isTabContentsSelected(Window* wnd) const;

    size_t      getSelectedTabIndex() const;

    const UDim& getTabHeight(void) const { return d_tabHeight; }

    const UDim& getTabTextPadding(void) const { return d_tabPadding; }


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

    void setTabHeight(const UDim& height);

    void setTabTextPadding(const UDim& padding);

    void addTab(Window* wnd);
    void removeTab(const String& name);
    void removeTab(uint ID);


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


        virtual ~TabControl(void);


protected:

        /*************************************************************************
                Implementation Functions
        *************************************************************************/
    virtual     void    drawSelf(const RenderingContext&) { /* do nothing; rendering handled by children */ }

    virtual void addButtonForTabContent(Window* wnd);
    virtual void removeButtonForTabContent(Window* wnd);
        TabButton* getButtonForTabContents(Window* wnd) const;
    String makeButtonName(Window* wnd);

    virtual void selectTab_impl(Window* wnd);


    virtual void makeTabVisible_impl(Window* wnd);

    Window* getTabButtonPane() const;

    Window* getTabPane() const;

    void performChildWindowLayout(bool nonclient_sized_hint = false,
                                  bool client_sized_hint = false);
    int writeChildWindowsXML(XMLSerializer& xml_stream) const;

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

    TabButton*  createTabButton(const String& name) const;

    void removeTab_impl(Window* window);

        /*************************************************************************
                New event handlers
        *************************************************************************/

        virtual void    onSelectionChanged(WindowEventArgs& e);

        virtual void    onFontChanged(WindowEventArgs& e);

        /*************************************************************************
                Implementation Data
        *************************************************************************/
    UDim        d_tabHeight;        
    UDim        d_tabPadding;       
    typedef std::vector<TabButton*
        CEGUI_VECTOR_ALLOC(TabButton*)> TabButtonVector;
    TabButtonVector d_tabButtonVector;  
    float       d_firstTabOffset;   
    TabPanePosition d_tabPanePos;   
    float       d_btGrabPos;        
    std::map<Window*, Event::ScopedConnection> d_eventConnections;
    /*************************************************************************
    Abstract Implementation Functions (must be provided by derived class)
    *************************************************************************/
    //virtual TabButton*        createTabButton_impl(const String& name) const          = 0;

    void calculateTabButtonSizePosition(size_t index);

protected:
    /*************************************************************************
                Private methods
        *************************************************************************/
        void    addTabControlProperties(void);

    void    addChild_impl(Element* element);
    void    removeChild_impl(Element* element);
    
    virtual NamedElement* getChildByNamePath_impl(const String& name_path) const;

    /*************************************************************************
    Event handlers
    *************************************************************************/
    bool handleContentWindowTextChanged(const EventArgs& args);
    bool handleTabButtonClicked(const EventArgs& args);
    bool handleScrollPane(const EventArgs& e);
    bool handleDraggedPane(const EventArgs& e);
    bool handleWheeledPane(const EventArgs& e);
};

template<>
class PropertyHelper<TabControl::TabPanePosition>
{
public:
    typedef TabControl::TabPanePosition return_type;
    typedef return_type safe_method_return_type;
    typedef TabControl::TabPanePosition pass_type;
    typedef String string_return_type;

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

        return type;
    }

    static return_type fromString(const String& str)
    {
        if (str == "Bottom")
        {
            return TabControl::Bottom;
        }
        else
        {
            return TabControl::Top;
        }
    }

    static string_return_type toString(pass_type val)
    {
        if (val == TabControl::Top)
        {
            return "Top";
        }
        else if (val == TabControl::Bottom)
        {
            return "Bottom";
        }
        else
        {
            assert(false && "Invalid Tab Pane Position");
            return "Top";
        }
    }
};
} // End of  CEGUI namespace section


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

#endif  // end of guard _CEGUITabControl_h_