widgets/FrameWindow.h

/***********************************************************************
        filename:       CEGUIFrameWindow.h
        created:        13/4/2004
        author:         Paul D Turner
        
        purpose:        Interface to base class for FrameWindow
*************************************************************************/
/***************************************************************************
 *   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 _CEGUIFrameWindow_h_
#define _CEGUIFrameWindow_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 FrameWindow : public Window
{
public:
        static const String EventNamespace;                             
    static const String WidgetTypeName;             

        /*************************************************************************
                Constants       
        *************************************************************************/
        // additional event names for this window
        static const String EventRollupToggled;
        static const String EventCloseClicked;
    static const String EventDragSizingStarted;
    static const String EventDragSizingEnded;

        // other bits
        static const float      DefaultSizingBorderSize;        

    /*************************************************************************
        Child Widget name constants
    *************************************************************************/
    static const String TitlebarName;      
    static const String CloseButtonName;   


        enum SizingLocation {
                SizingNone,                     
                SizingTopLeft,          
                SizingTopRight,         
                SizingBottomLeft,       
                SizingBottomRight,      
                SizingTop,                      
                SizingLeft,                     
                SizingBottom,           
                SizingRight         
        };

        virtual void    initialiseComponents(void);
        
        
        bool    isSizingEnabled(void) const                                     {return d_sizingEnabled && isFrameEnabled();}


        bool    isFrameEnabled(void) const                                      {return d_frameEnabled;}


        bool    isTitleBarEnabled(void) const;


        bool    isCloseButtonEnabled(void) const;


        bool    isRollupEnabled(void) const                                     {return d_rollupEnabled;}

    void    setRolledup(bool val);

        bool    isRolledup(void) const                                          {return d_rolledup;}


        float   getSizingBorderThickness(void) const            {return d_borderSize;}


        void    setSizingEnabled(bool setting);


        void    setFrameEnabled(bool setting);


        void    setTitleBarEnabled(bool setting);


        void    setCloseButtonEnabled(bool setting);


        void    setRollupEnabled(bool setting);


        void    toggleRollup(void);

        void    setSizingBorderThickness(float pixels)          {d_borderSize = pixels;}


        void    offsetPixelPosition(const Vector2f& offset);


        bool    isDragMovingEnabled(void) const         {return d_dragMovable;}


        void    setDragMovingEnabled(bool setting);


    const Image* getNSSizingCursorImage() const;

    const Image* getEWSizingCursorImage() const;

    const Image* getNWSESizingCursorImage() const;

    const Image* getNESWSizingCursorImage() const;

    void setNSSizingCursorImage(const Image* image);

    void setEWSizingCursorImage(const Image* image);

    void setNWSESizingCursorImage(const Image* image);

    void setNESWSizingCursorImage(const Image* image);

    void setNSSizingCursorImage(const String& name);

    void setEWSizingCursorImage(const String& name);

    void setNWSESizingCursorImage(const String& name);

    void setNESWSizingCursorImage(const String& name);

    // overridden from Window class
    bool isHit(const Vector2f& position, const bool /*allow_disabled*/) const
        { return Window::isHit(position) && !d_rolledup; }

    Titlebar* getTitlebar() const;

    PushButton* getCloseButton() const;

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

        virtual ~FrameWindow(void);


protected:
        /*************************************************************************
                Implementation Functions
        *************************************************************************/
        bool    moveLeftEdge(float delta, URect& out_area);


        bool    moveRightEdge(float delta, URect& out_area);


        bool    moveTopEdge(float delta, URect& out_area);


        bool    moveBottomEdge(float delta, URect& out_area);


        SizingLocation  getSizingBorderAtPoint(const Vector2f& pt) const;

 
        bool    isLeftSizingLocation(SizingLocation loc) const                  {return ((loc == SizingLeft) || (loc == SizingTopLeft) || (loc == SizingBottomLeft));}


        bool    isRightSizingLocation(SizingLocation loc) const                 {return ((loc == SizingRight) || (loc == SizingTopRight) || (loc == SizingBottomRight));}


        bool    isTopSizingLocation(SizingLocation loc) const                   {return ((loc == SizingTop) || (loc == SizingTopLeft) || (loc == SizingTopRight));}


        bool    isBottomSizingLocation(SizingLocation loc) const                {return ((loc == SizingBottom) || (loc == SizingBottomLeft) || (loc == SizingBottomRight));}


        bool    closeClickHandler(const EventArgs& e);


        void    setCursorForPoint(const Vector2f& pt) const;


        virtual Rectf   getSizingRect(void) const               {return Rectf(0, 0, d_pixelSize.d_width, d_pixelSize.d_height);}

        /*************************************************************************
                New events for Frame Windows
        *************************************************************************/
        virtual void    onRollupToggled(WindowEventArgs& e);


        virtual void    onCloseClicked(WindowEventArgs& e);

    virtual void onDragSizingStarted(WindowEventArgs& e);

    virtual void onDragSizingEnded(WindowEventArgs& e);

        /*************************************************************************
                Overridden event handlers
        *************************************************************************/
        virtual void    onMouseMove(MouseEventArgs& e);
        virtual void    onMouseButtonDown(MouseEventArgs& e);
        virtual void    onMouseButtonUp(MouseEventArgs& e);
        virtual void    onCaptureLost(WindowEventArgs& e);
        virtual void    onTextChanged(WindowEventArgs& e);
        virtual void    onActivated(ActivationEventArgs& e);
        virtual void    onDeactivated(ActivationEventArgs& e);


        /*************************************************************************
                Implementation Data
        *************************************************************************/
        // frame data
        bool    d_frameEnabled;         

        // window roll-up data
        bool    d_rollupEnabled;        
        bool    d_rolledup;                     

        // drag-sizing data
        bool    d_sizingEnabled;        
        bool    d_beingSized;           
        float   d_borderSize;           
        Vector2f d_dragPoint;           

        // images for cursor when on sizing border
        const Image*    d_nsSizingCursor;               
        const Image*    d_ewSizingCursor;               
        const Image*    d_nwseSizingCursor;             
        const Image*    d_neswSizingCursor;             

        bool    d_dragMovable;          


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

} // End of  CEGUI namespace section

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

#endif  // end of guard _CEGUIFrameWindow_h_