CEGUITabControl.h

/***********************************************************************
        filename:       CEGUITabControl.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 "../CEGUIBase.h"
#include "../CEGUIWindow.h"
#include "CEGUITabControlProperties.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 suffix constants
    *************************************************************************/
    static const String ContentPaneNameSuffix; 
    static const String TabButtonNameSuffix;   
    static const String TabButtonPaneNameSuffix; 
    static const String ButtonScrollLeftSuffix;
    static const String ButtonScrollRightSuffix; 


        /*************************************************************************
                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);


        virtual bool    testClassName_impl(const String& class_name) const
        {
                if (class_name=="TabControl")   return true;
                return Window::testClassName_impl(class_name);
        }

    Window* getTabButtonPane() const;

    Window* getTabPane() const;

        void performChildWindowLayout();
    int writeChildWindowsXML(XMLSerializer& xml_stream) const;

    // validate window renderer
    virtual bool validateWindowRenderer(const String& name) const
    {
        return (name == "TabControl");
    }

    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*> 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:
        /*************************************************************************
                Static Properties for this class
        *************************************************************************/
    static TabControlProperties::TabHeight       d_tabHeightProperty;
    static TabControlProperties::TabTextPadding  d_tabTextPaddingProperty;
    static TabControlProperties::TabPanePosition d_tabPanePosition;

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

    void    addChild_impl(Window* wnd);
    void    removeChild_impl(Window* wnd);

    /*************************************************************************
    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);
};


} // End of  CEGUI namespace section


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

#endif  // end of guard _CEGUITabControl_h_