widgets/ListHeaderSegment.h

/***********************************************************************
        filename:       CEGUIListHeaderSegment.h
        created:        15/6/2004
        author:         Paul D Turner
        
        purpose:        Interface to list header segment class.
*************************************************************************/
/***************************************************************************
 *   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 _CEGUIListHeaderSegment_h_
#define _CEGUIListHeaderSegment_h_

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


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


// Start of CEGUI namespace section
namespace CEGUI
{
class CEGUIEXPORT ListHeaderSegment : public Window
{
public:
        static const String EventNamespace;                             
    static const String WidgetTypeName;             


        /*************************************************************************
                Constants
        *************************************************************************/
        // Event names
        static const String EventSegmentClicked;
        static const String EventSplitterDoubleClicked;
        static const String EventSizingSettingChanged;
        static const String EventSortDirectionChanged;
        static const String EventMovableSettingChanged;
        static const String EventSegmentDragStart;
        static const String EventSegmentDragStop;
        static const String EventSegmentDragPositionChanged;
        static const String EventSegmentSized;
        static const String EventClickableSettingChanged;

        // Defaults
        static const float      DefaultSizingArea;              
        static const float      SegmentMoveThreshold;   


        /*************************************************************************
                Enumerated types
        *************************************************************************/
        enum SortDirection
        {
                None,           
                Ascending,      
                Descending      
        };


        /*************************************************************************
                Accessor Methods
        *************************************************************************/
        bool    isSizingEnabled(void) const                     {return d_sizingEnabled;}


        SortDirection   getSortDirection(void) const    {return d_sortDir;}


        bool    isDragMovingEnabled(void) const         {return d_movingEnabled;}


        const Vector2f& getDragMoveOffset(void) const   {return d_dragPosition;}


        bool    isClickable(void) const         {return d_allowClicks;}


    bool    isSegmentHovering(void) const  {return d_segmentHover;}


    bool    isSegmentPushed(void) const  {return d_segmentPushed;}


    bool    isSplitterHovering(void) const  {return d_splitterHover;}


    bool    isBeingDragMoved(void) const  {return d_dragMoving;}


    bool    isBeingDragSized(void) const  {return d_dragSizing;}


    const Image* getSizingCursorImage() const;
    const Image* getMovingCursorImage() const;


        /*************************************************************************
                Manipulator Methods
        *************************************************************************/
        void    setSizingEnabled(bool setting);


        void    setSortDirection(SortDirection sort_dir);


        void    setDragMovingEnabled(bool setting);


        void setClickable(bool setting);


    void setSizingCursorImage(const Image* image);
    void setSizingCursorImage(const String& name);
    void setMovingCursorImage(const Image* image);
    void setMovingCursorImage(const String& name);


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


        virtual ~ListHeaderSegment(void);


protected:
        /*************************************************************************
                Implementation Methods
        *************************************************************************/
        void    doDragSizing(const Vector2f& local_mouse);


        void    doDragMoving(const Vector2f& local_mouse);


        void    initDragMoving(void);


        void    initSizingHoverState(void);


        void    initSegmentHoverState(void);


        bool    isDragMoveThresholdExceeded(const Vector2f& local_mouse);

        /*************************************************************************
                New Event Handlers
        *************************************************************************/
        virtual void    onSegmentClicked(WindowEventArgs& e);


        virtual void    onSplitterDoubleClicked(WindowEventArgs& e);


        virtual void    onSizingSettingChanged(WindowEventArgs& e);


        virtual void    onSortDirectionChanged(WindowEventArgs& e);


        virtual void    onMovableSettingChanged(WindowEventArgs& e);


        virtual void    onSegmentDragStart(WindowEventArgs& e);


        virtual void    onSegmentDragStop(WindowEventArgs& e);


        virtual void    onSegmentDragPositionChanged(WindowEventArgs& e);


        virtual void    onSegmentSized(WindowEventArgs& e);


        virtual void    onClickableSettingChanged(WindowEventArgs& e);


        /*************************************************************************
                Overridden Event Handlers
        *************************************************************************/
        virtual void    onMouseMove(MouseEventArgs& e);
        virtual void    onMouseButtonDown(MouseEventArgs& e);
        virtual void    onMouseButtonUp(MouseEventArgs& e);
        virtual void    onMouseDoubleClicked(MouseEventArgs& e);
        virtual void    onMouseLeaves(MouseEventArgs& e);
        virtual void    onCaptureLost(WindowEventArgs& e);


        /*************************************************************************
                Implementation Data
        *************************************************************************/
        const Image*    d_sizingMouseCursor;    
        const Image*    d_movingMouseCursor;    

        float   d_splitterSize;         
        bool    d_splitterHover;        

        bool    d_dragSizing;           
        Vector2f d_dragPoint;           

        SortDirection   d_sortDir;      

        bool    d_segmentHover;         
        bool    d_segmentPushed;        
        bool    d_sizingEnabled;        
        bool    d_movingEnabled;        
        bool    d_dragMoving;           
        Vector2f d_dragPosition;                
        bool    d_allowClicks;          

private:
        /*************************************************************************
                Private methods
        *************************************************************************/
        void    addHeaderSegmentProperties(void);
};


template<>
class PropertyHelper<ListHeaderSegment::SortDirection>
{
public:
    typedef ListHeaderSegment::SortDirection return_type;
    typedef return_type safe_method_return_type;
    typedef ListHeaderSegment::SortDirection pass_type;
    typedef String string_return_type;

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

        return type;
    }

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

    static string_return_type toString(pass_type val)
    {
        if (val == ListHeaderSegment::None)
        {
            return "None";
        }
        else if (val == ListHeaderSegment::Ascending)
        {
            return "Ascending";
        }
        else if (val == ListHeaderSegment::Descending)
        {
            return "Descending";
        }
        else
        {
            assert(false && "Invalid Sort Direction");
            return "Ascending";
        }
    }
};

} // End of  CEGUI namespace section

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

#endif  // end of guard _CEGUIListHeaderSegment_h_