resizablewindow.cpp

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

// Standard C++ library includes
#include <cassert>

// 3rd party library includes

// 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 "gui/fifechan/base/gui_font.h"
#include "gui/fifechan/fifechanmanager.h"
#include "util/base/exception.h"

#include "resizablewindow.h"

namespace fcn {
    ResizableWindow::ResizableWindow():
        Window(),
        m_cursor(FIFE::FifechanManager::instance()->getCursor()),
        m_borderDistance(5),
        m_resizable(true),
        m_resizableTop(true),
        m_resizableRight(true),
        m_resizableBottom(true),
        m_resizableLeft(true),
        m_resizing(false),
        m_resizeTop(false),
        m_resizeRight(false),
        m_resizeBottom(false),
        m_resizeLeft(false),
        m_shove(false) {

        addKeyListener(this);
        addFocusListener(this);
        initCursors();
    }

    ResizableWindow::ResizableWindow(bool resizable):
        Window(),
        m_cursor(FIFE::FifechanManager::instance()->getCursor()),
        m_borderDistance(5),
        m_resizable(resizable),
        m_resizableTop(true),
        m_resizableRight(true),
        m_resizableBottom(true),
        m_resizableLeft(true),
        m_resizing(false),
        m_resizeTop(false),
        m_resizeRight(false),
        m_resizeBottom(false),
        m_resizeLeft(false),
        m_shove(false) {

        addKeyListener(this);
        addFocusListener(this);
        initCursors();
    }

    ResizableWindow::ResizableWindow(const std::string& caption, bool resizable):
        Window(),
        m_cursor(FIFE::FifechanManager::instance()->getCursor()),
        m_borderDistance(5),
        m_resizable(resizable),
        m_resizableTop(true),
        m_resizableRight(true),
        m_resizableBottom(true),
        m_resizableLeft(true),
        m_resizing(false),
        m_resizeTop(false),
        m_resizeRight(false),
        m_resizeBottom(false),
        m_resizeLeft(false),
        m_shove(false) {

        setCaption(caption);
        addKeyListener(this);
        addFocusListener(this);
        initCursors();
    }

    ResizableWindow::~ResizableWindow() {
    }
    
    void ResizableWindow::initCursors() {
        // defines default cursors
        // don't change the sequence!
        CursorState state;
        state.cursorId = FIFE::NC_ARROW;
        state.cursorType = FIFE::CURSOR_NONE;
        m_saved = state;
        state.cursorType = FIFE::CURSOR_NATIVE;
        // left
        state.cursorId = FIFE::NC_RESIZEWE;
        m_cursors.push_back(state);
        // right
        state.cursorId = FIFE::NC_RESIZEWE;
        m_cursors.push_back(state);
        // top
        state.cursorId = FIFE::NC_RESIZENS;
        m_cursors.push_back(state);
        // left and top
        state.cursorId = FIFE::NC_RESIZENWSE;
        m_cursors.push_back(state);
        // right and top
        state.cursorId = FIFE::NC_RESIZENESW;
        m_cursors.push_back(state);
        // bottom
        state.cursorId = FIFE::NC_RESIZENS;
        m_cursors.push_back(state);
        // left and bottom
        state.cursorId = FIFE::NC_RESIZENESW;
        m_cursors.push_back(state);
        // right and bottom
        state.cursorId = FIFE::NC_RESIZENWSE;
        m_cursors.push_back(state);
    }

    void ResizableWindow::restoreCursor() {
        FIFE::MouseCursorType type = m_saved.cursorType;
        switch (type) {
            case FIFE::CURSOR_NATIVE:
                m_cursor->set(m_saved.cursorId);
                break;
            case FIFE::CURSOR_IMAGE:
                m_cursor->set(m_saved.cursorImage);
                break;
            case FIFE::CURSOR_ANIMATION:
                m_cursor->set(m_saved.cursorAnimation);
                break;
            default:
                return;
        }
    }

    void ResizableWindow::saveCursor() {
        FIFE::MouseCursorType type = m_cursor->getType();
        switch (type) {
            case FIFE::CURSOR_NATIVE:
                m_saved.cursorType = type;
                m_saved.cursorId = m_cursor->getId();
                m_saved.cursorImage.reset();
                m_saved.cursorAnimation.reset();
                break;
            case FIFE::CURSOR_IMAGE:
                m_saved.cursorType = type;
                m_saved.cursorId = FIFE::NC_ARROW;;
                m_saved.cursorImage = m_cursor->getImage();
                m_saved.cursorAnimation.reset();
                break;
            case FIFE::CURSOR_ANIMATION:
                m_saved.cursorType = type;
                m_saved.cursorId = FIFE::NC_ARROW;;
                m_saved.cursorImage.reset();
                m_saved.cursorAnimation = m_cursor->getAnimation();
                break;
            default:
                m_saved.cursorType = FIFE::CURSOR_NONE;
        }
    }

    void ResizableWindow::setResizableBorderDistance(int32_t border) {
        m_borderDistance = border;
    }

    int32_t ResizableWindow::getResizableBorderDistance() const {
        return m_borderDistance;
    }

    void ResizableWindow::setResizable(bool resizable) {
        m_resizable = resizable;
    }

    bool ResizableWindow::isResizable() const {
        return m_resizable;
    }

    void ResizableWindow::setTopResizable(bool resizable) {
        m_resizableTop = resizable;
    }

    bool ResizableWindow::isTopResizable() const {
        return m_resizableTop;
    }

    void ResizableWindow::setRightResizable(bool resizable) {
        m_resizableRight = resizable;
    }

    bool ResizableWindow::isRightResizable() const {
        return m_resizableRight;
    }

    void ResizableWindow::setBottomResizable(bool resizable) {
        m_resizableBottom = resizable;
    }

    bool ResizableWindow::isBottomResizable() const {
        return m_resizableBottom;
    }

    void ResizableWindow::setLeftResizable(bool resizable) {
        m_resizableLeft = resizable;
    }

    bool ResizableWindow::isLeftResizable() const {
        return m_resizableLeft;
    }

    void ResizableWindow::setShove(bool shove) {
        m_shove = shove;
    }

    bool ResizableWindow::getShove() const {
        return m_shove;
    }

    void ResizableWindow::set(CursorDirections direction, uint32_t cursor_id) {
        CursorState& state = m_cursors[direction];
        state.cursorType = FIFE::CURSOR_NATIVE;
        state.cursorId = cursor_id;
        state.cursorImage.reset();
        state.cursorAnimation.reset();
    }

    void ResizableWindow::set(CursorDirections direction, FIFE::ImagePtr image) {
        CursorState& state = m_cursors[direction];
        state.cursorType = FIFE::CURSOR_IMAGE;
        state.cursorId = FIFE::NC_ARROW;
        state.cursorImage = image;
        state.cursorAnimation.reset();
    }

    void ResizableWindow::set(CursorDirections direction, FIFE::AnimationPtr anim) {
        CursorState& state = m_cursors[direction];
        state.cursorType = FIFE::CURSOR_ANIMATION;
        state.cursorId = FIFE::NC_ARROW;
        state.cursorImage.reset();
        state.cursorAnimation = anim;
    }

    FIFE::MouseCursorType ResizableWindow::getType(CursorDirections direction) const {
        return m_cursors[direction].cursorType;
    }
    
    uint32_t ResizableWindow::getId(CursorDirections direction) const {
        return m_cursors[direction].cursorId;
    }

    FIFE::ImagePtr ResizableWindow::getImage(CursorDirections direction) {
        return m_cursors[direction].cursorImage;
    }

    FIFE::AnimationPtr ResizableWindow::getAnimation(CursorDirections direction) {
        return m_cursors[direction].cursorAnimation;
    }

    void ResizableWindow::resizeToContent(bool recursiv) {
        // we keep the size in case we want it resizable
        if (m_resizable) {
            int w = getWidth();
            int h = getHeight();
            Window::resizeToContent(recursiv);
            setSize(w, h);
        } else {
            Window::resizeToContent(recursiv);
        }
    }

    void ResizableWindow::mouseEntered(MouseEvent& mouseEvent) {
        if (m_resizable && !m_resizing) {
            saveCursor();
        }
        Window::mouseEntered(mouseEvent);
    }

    void ResizableWindow::mouseExited(MouseEvent& mouseEvent) {
        if (m_resizable && !m_resizing && m_saved.cursorType != FIFE::CURSOR_NONE) {
            restoreCursor();
        } else if (m_resizable && m_resizing) {
            mouseEvent.consume();
        }
        Window::mouseExited(mouseEvent);
    }

    void ResizableWindow::mousePressed(MouseEvent& mouseEvent) {
        if (m_resizable && mouseEvent.getButton() == MouseEvent::Left) {
            m_resizeLeft = m_resizableLeft && mouseEvent.getX() < m_borderDistance;
            m_resizeRight = m_resizableRight && mouseEvent.getX() > getWidth() - m_borderDistance;
            m_resizeTop = m_resizableTop && mouseEvent.getY() < m_borderDistance;
            m_resizeBottom = m_resizableBottom && mouseEvent.getY() > getHeight() - m_borderDistance;
            if (m_resizeTop || m_resizeBottom || m_resizeLeft || m_resizeRight) {
                m_resizing = true;
                mouseEvent.consume();
            }
        }
        Window::mousePressed(mouseEvent);
    }

    void ResizableWindow::mouseReleased(MouseEvent& mouseEvent) {
        if (m_resizing) {
            adaptLayout();
            m_resizing = false;
            if (mouseEvent.getX() <= 0 || mouseEvent.getX() >= getWidth() ||
                mouseEvent.getY() <= 0 || mouseEvent.getY() >= getHeight()) {
                    mouseExited(mouseEvent);
            }
            mouseEvent.consume();
        } else {
            Window::mouseReleased(mouseEvent);
        }
    }

    void ResizableWindow::mouseMoved(MouseEvent& mouseEvent) {
        if (m_resizable && !m_resizing && m_saved.cursorType != FIFE::CURSOR_NONE) {
            // use the CursorDirections directly
            uint32_t index = 0;
            index += (m_resizableLeft && mouseEvent.getX() < m_borderDistance) ? 1 : 0;
            index += (m_resizableRight && mouseEvent.getX() > getWidth() - m_borderDistance) ? 2 : 0;
            index += (m_resizableTop && mouseEvent.getY() < m_borderDistance) ? 3 : 0;
            index += (m_resizableBottom && mouseEvent.getY() > getHeight() - m_borderDistance) ? 6 : 0;

            if (index > 0) {
                // to get the real index value
                index -= 1;
                CursorState state = m_cursors[index];
                FIFE::MouseCursorType type = state.cursorType;
                switch (type) {
                    case FIFE::CURSOR_NATIVE:
                        m_cursor->set(state.cursorId);
                        break;
                    case FIFE::CURSOR_IMAGE:
                        m_cursor->set(state.cursorImage);
                        break;
                    case FIFE::CURSOR_ANIMATION:
                        m_cursor->set(state.cursorAnimation);
                        break;
                    default:
                        break;
                }
                mouseEvent.consume();
            } else {
                restoreCursor();
            }
        }
        Window::mouseMoved(mouseEvent);
    }
    
    void ResizableWindow::mouseDragged(MouseEvent& mouseEvent) {
        if (m_resizable && m_resizing) {
            int x = mouseEvent.getX();
            int y = mouseEvent.getY();
            if (m_resizeLeft) {
                int oldW = getWidth();
                int newW = oldW - x;
                if (newW < 0) {
                    newW = 0;
                }
                setWidth(newW);
                if (m_shove) {
                    setX(getX() + x);
                } else {
                    newW = getWidth();
                    int newX = oldW - newW;
                    setX(getX() + newX);
                }
            } else if (m_resizeRight) {
                setWidth(x);
                if (x != getWidth() && m_shove) {
                    setX(getX() + (x-getWidth()));
                }
            }

            if (m_resizeTop) {
                int oldH = getHeight();
                int newH = oldH - y;
                if (newH < 0) {
                    newH = 0;
                }
                setHeight(newH);
                if (m_shove) {
                    setY(getY() + y);
                } else {
                    newH = getHeight();
                    int newY = oldH - newH;
                    setY(getY() + newY);
                }
            } else if (m_resizeBottom) {
                setHeight(y);
                if (y != getHeight() && m_shove) {
                    setY(getY() + (y-getHeight()));
                }
            }
            mouseEvent.consume();
        } else {
            Window::mouseDragged(mouseEvent);
        }
    }


    void ResizableWindow::focusLost(const Event& event) {
        m_resizing = false;
        restoreCursor();
    }
}