resizablewindow.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005-2013 by the FIFE team                              *
 *   http://www.fifengine.net                                              *
 *   This file is part of FIFE.                                            *
 *                                                                         *
 *   FIFE is free software; you can redistribute it and/or                 *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
 ***************************************************************************/

#ifndef FIFE_GUI_WIDGETS_RESIZABLEWINDOW_H
#define FIFE_GUI_WIDGETS_RESIZABLEWINDOW_H

// Standard C++ library includes

// 3rd party library includes
#include <fifechan.hpp>

// FIFE includes
// These includes are split up in two parts, separated by one empty line
// First block: files included from the FIFE root src directory
// Second block: files included from the same folder
#include "video/cursor.h"


namespace fcn {
    class ResizableWindow : public Window, public KeyListener, public FocusListener {
    public:
        enum CursorDirections {
            // left
            CURSOR_DIRECTION_L = 0,
            // right
            CURSOR_DIRECTION_R = 1,
            // top
            CURSOR_DIRECTION_T = 2,
            // bottom
            CURSOR_DIRECTION_B = 5,
            // left and top
            CURSOR_DIRECTION_LT = 3,
            // right and top
            CURSOR_DIRECTION_RT = 4,
            // left and bottom
            CURSOR_DIRECTION_LB = 6,
            // right and bottom
            CURSOR_DIRECTION_RB = 7
        };

        ResizableWindow();
        ResizableWindow(bool resizable);
        ResizableWindow(const std::string& caption, bool resizable=true);
        virtual ~ResizableWindow();
        
        void setResizableBorderDistance(int32_t border);

        int32_t getResizableBorderDistance() const;

        void setResizable(bool resizable);

        bool isResizable() const;

        void setTopResizable(bool resizable);

        bool isTopResizable() const;

        void setRightResizable(bool resizable);

        bool isRightResizable() const;

        void setBottomResizable(bool resizable);

        bool isBottomResizable() const;

        void setLeftResizable(bool resizable);

        bool isLeftResizable() const;

        void setShove(bool shove);

        bool getShove() const;

        void set(CursorDirections direction, uint32_t cursor_id=0);

        void set(CursorDirections direction, FIFE::ImagePtr image);

        void set(CursorDirections direction, FIFE::AnimationPtr anim);

        FIFE::MouseCursorType getType(CursorDirections direction) const;

        uint32_t getId(CursorDirections direction) const;

        FIFE::ImagePtr getImage(CursorDirections direction);

        FIFE::AnimationPtr getAnimation(CursorDirections direction);

        // Inherited from Window

        virtual void resizeToContent(bool recursiv=true);

        // Inherited from FocusListener
    
        virtual void focusLost(const Event& event);
    
    
        // Inherited from Window / MouseListener

        virtual void mouseEntered(MouseEvent& mouseEvent);

        virtual void mouseExited(MouseEvent& mouseEvent);

        virtual void mousePressed(MouseEvent& mouseEvent);

        virtual void mouseReleased(MouseEvent& mouseEvent);

        virtual void mouseMoved(MouseEvent& mouseEvent);
    
        virtual void mouseDragged(MouseEvent& mouseEvent);

    protected:
        // initialized the 8 cursors, see CursorDirections
        void initCursors();
        // restore cursor
        void restoreCursor();
        // save cursor so we can restore it later
        void saveCursor();

        // access to fifes cursor class
        FIFE::Cursor* m_cursor;
        // distance from the widgets edge that is active for resizing events
        int32_t m_borderDistance;
        // is resizable
        bool m_resizable;
        // allow resize on top
        bool m_resizableTop;
        // allow resize on right
        bool m_resizableRight;
        // allow resize on bottom
        bool m_resizableBottom;
        // allow resize on left
        bool m_resizableLeft;
        // is currently resizing
        bool m_resizing;

        // indicate the changed size per direction
        bool m_resizeTop;
        bool m_resizeRight;
        bool m_resizeBottom;
        bool m_resizeLeft;
        // is shove allowed
        bool m_shove;

        struct CursorState  {
            FIFE::MouseCursorType cursorType;
            uint32_t cursorId;
            FIFE::ImagePtr cursorImage;
            FIFE::AnimationPtr cursorAnimation;
        };
        // old saved cursor
        CursorState m_saved;
        // contains the 8 CursorStates, one per direction
        std::vector<CursorState> m_cursors;
    };
}

#endif