MyGUI_Window.cpp

Go to the documentation of this file.

/*
 * This source file is part of MyGUI. For the latest info, see http://mygui.info/
 * Distributed under the MIT License
 * (See accompanying file COPYING.MIT or copy at http://opensource.org/licenses/MIT)
 */
 
#include "MyGUI_Precompiled.h"
#include "MyGUI_Window.h"
#include "MyGUI_Macros.h"
#include "MyGUI_Gui.h"
#include "MyGUI_ControllerManager.h"
#include "MyGUI_InputManager.h"
#include "MyGUI_WidgetManager.h"
#include "MyGUI_ResourceSkin.h"
 
namespace MyGUI
{
    const float WINDOW_ALPHA_ACTIVE = ALPHA_MAX;
    const float WINDOW_ALPHA_FOCUS = 0.7f;
    const float WINDOW_ALPHA_DEACTIVE = 0.3f;
    const float WINDOW_SPEED_COEF = 3.0f;
 
    const int WINDOW_SNAP_DISTANSE = 10;
 
    Window::Window() :
        mWidgetCaption(nullptr),
        mMouseRootFocus(false),
        mKeyRootFocus(false),
        mIsAutoAlpha(false),
        mSnap(false),
        mAnimateSmooth(false),
        mMovable(true)
    {
    }
 
    void Window::initialiseOverride()
    {
        Base::initialiseOverride();
 
        // FIXME нам нужен фокус клавы
        setNeedKeyFocus(true);
 
        // дефолтные размеры
        mMinmax.set(
            (std::numeric_limits<int>::min)(),
            (std::numeric_limits<int>::min)(),
            (std::numeric_limits<int>::max)(),
            (std::numeric_limits<int>::max)());
 
        bool main_move = false;
        if (isUserString("MainMove"))
        {
            setUserString("Scale", "1 1 0 0");
            main_move = true;
        }
 
        if (getClientWidget() != nullptr)
        {
            if (main_move)
            {
                getClientWidget()->setUserString("Scale", "1 1 0 0");
                getClientWidget()->eventMouseButtonPressed += newDelegate(this, &Window::notifyMousePressed);
                getClientWidget()->eventMouseButtonReleased += newDelegate(this, &Window::notifyMouseReleased);
                getClientWidget()->eventMouseDrag += newDelegate(this, &Window::notifyMouseDrag);
            }
        }
 
        assignWidget(mWidgetCaption, "Caption");
        if (mWidgetCaption != nullptr)
        {
            mWidgetCaption->setUserString("Scale", "1 1 0 0");
            mWidgetCaption->eventMouseButtonPressed += newDelegate(this, &Window::notifyMousePressed);
            mWidgetCaption->eventMouseButtonReleased += newDelegate(this, &Window::notifyMouseReleased);
            mWidgetCaption->eventMouseDrag += newDelegate(this, &Window::notifyMouseDrag);
        }
 
        VectorWidgetPtr buttons = getSkinWidgetsByName("Button");
        for (VectorWidgetPtr::iterator iter = buttons.begin(); iter != buttons.end(); ++iter)
        {
            (*iter)->eventMouseButtonClick += newDelegate(this, &Window::notifyPressedButtonEvent);
        }
 
        VectorWidgetPtr actions = getSkinWidgetsByName("Action");
        for (VectorWidgetPtr::iterator iter = actions.begin(); iter != actions.end(); ++iter)
        {
            (*iter)->eventMouseButtonPressed += newDelegate(this, &Window::notifyMousePressed);
            (*iter)->eventMouseButtonReleased += newDelegate(this, &Window::notifyMouseReleased);
            (*iter)->eventMouseDrag += newDelegate(this, &Window::notifyMouseDrag);
            (*iter)->eventMouseWheel += newDelegate(this, &Window::notifyMouseWheel);
        }
 
        const size_t countNames = 8;
        const char* resizers[2][countNames] =
        {
            {"ResizeLeftTop", "ResizeTop", "ResizeRightTop", "ResizeRight", "ResizeRightBottom", "ResizeBottom", "ResizeLeftBottom", "ResizeLeft"},
            {"Left Top", "Top", "Right Top", "Right", "Right Bottom", "Bottom", "Left Bottom", "Left"}
        };
 
        for (size_t index = 0; index < countNames; ++ index)
        {
            Widget* widget = nullptr;
            assignWidget(widget, resizers[0][index]);
            if (widget != nullptr)
            {
                widget->eventMouseButtonPressed += newDelegate(this, &Window::notifyMousePressed);
                widget->eventMouseButtonReleased += newDelegate(this, &Window::notifyMouseReleased);
                widget->eventMouseDrag += newDelegate(this, &Window::notifyMouseDrag);
                widget->eventMouseWheel += newDelegate(this, &Window::notifyMouseWheel);
                widget->setUserString("Action", resizers[1][index]);
            }
        }
    }
 
    void Window::shutdownOverride()
    {
        mWidgetCaption = nullptr;
 
        Base::shutdownOverride();
    }
 
    void Window::onMouseChangeRootFocus(bool _focus)
    {
        mMouseRootFocus = _focus;
        updateAlpha();
 
        Base::onMouseChangeRootFocus(_focus);
    }
 
    void Window::onKeyChangeRootFocus(bool _focus)
    {
        mKeyRootFocus = _focus;
        updateAlpha();
 
        Base::onKeyChangeRootFocus(_focus);
    }
 
    void Window::onMouseDrag(int _left, int _top, MouseButton _id)
    {
        // на тот случай, если двигать окно, можно за любое место виджета
        notifyMouseDrag(this, _left, _top, _id);
 
        Base::onMouseDrag(_left, _top, _id);
    }
 
    void Window::onMouseButtonPressed(int _left, int _top, MouseButton _id)
    {
        notifyMousePressed(this, _left, _top, _id);
 
        Base::onMouseButtonPressed(_left, _top, _id);
    }
 
    void Window::onMouseButtonReleased(int _left, int _top, MouseButton _id)
    {
        notifyMouseReleased(this, _left, _top, _id);
 
        Base::onMouseButtonReleased(_left, _top, _id);
    }
 
    void Window::notifyMousePressed(MyGUI::Widget* _sender, int _left, int _top, MouseButton _id)
    {
        if (MouseButton::Left == _id)
        {
            mPreActionCoord = mCoord;
            mCurrentActionScale = _getActionScale(_sender);
        }
    }
 
    void Window::notifyPressedButtonEvent(MyGUI::Widget* _sender)
    {
        eventWindowButtonPressed(this, _sender->getUserString("Event"));
    }
 
    void Window::notifyMouseDrag(MyGUI::Widget* _sender, int _left, int _top, MouseButton _id)
    {
        if (_id != MouseButton::Left)
            return;
 
        const IntPoint& point = InputManager::getInstance().getLastPressedPosition(MouseButton::Left);
 
        IntCoord coord = mCurrentActionScale;
        coord.left *= (_left - point.left);
        coord.top *= (_top - point.top);
        coord.width *= (_left - point.left);
        coord.height *= (_top - point.top);
 
        if (coord.empty())
            return;
 
        if (coord.left == 0 && coord.top == 0)
            setSize((mPreActionCoord + coord).size());
        else if (coord.width == 0 && coord.height == 0)
            setPosition((mPreActionCoord + coord).point());
        else
            setCoord(mPreActionCoord + coord);
 
        // посылаем событие о изменении позиции и размере
        eventWindowChangeCoord(this);
    }
 
    void Window::updateAlpha()
    {
        if (!mIsAutoAlpha)
            return;
 
        float alpha;
        if (mKeyRootFocus)
            alpha = WINDOW_ALPHA_ACTIVE;
        else if (mMouseRootFocus)
            alpha = WINDOW_ALPHA_FOCUS;
        else
            alpha = WINDOW_ALPHA_DEACTIVE;
 
        ControllerFadeAlpha* controller = createControllerFadeAlpha(alpha, WINDOW_SPEED_COEF, true);
        ControllerManager::getInstance().addItem(this, controller);
    }
 
    void Window::setAutoAlpha(bool _auto)
    {
        mIsAutoAlpha = _auto;
        if (!_auto)
            setAlpha(ALPHA_MAX);
        else
        {
            if (mKeyRootFocus)
                setAlpha(WINDOW_ALPHA_ACTIVE);
            else if (mMouseRootFocus)
                setAlpha(WINDOW_ALPHA_FOCUS);
            else
                setAlpha(WINDOW_ALPHA_DEACTIVE);
        }
    }
 
    void Window::setPosition(const IntPoint& _point)
    {
        IntPoint point = _point;
        // прилепляем к краям
        if (mSnap)
        {
            IntCoord coord(point, mCoord.size());
            getSnappedCoord(coord, Snap::Position);
            point = coord.point();
        }
 
        Base::setPosition(point);
    }
 
    void Window::setSize(const IntSize& _size)
    {
        IntSize size = _size;
        // прилепляем к краям
 
        if (size.width < mMinmax.left)
            size.width = mMinmax.left;
        else if (size.width > mMinmax.right)
            size.width = mMinmax.right;
        if (size.height < mMinmax.top)
            size.height = mMinmax.top;
        else if (size.height > mMinmax.bottom)
            size.height = mMinmax.bottom;
        if ((size.width == mCoord.width) && (size.height == mCoord.height))
            return;
 
        if (mSnap)
        {
            IntCoord coord(mCoord.point(), size);
            getSnappedCoord(coord, Snap::Size);
            size = coord.size();
        }
 
        Base::setSize(size);
    }
 
    void Window::setCoord(const IntCoord& _coord)
    {
        IntPoint pos = _coord.point();
        IntSize size = _coord.size();
 
        if (size.width < mMinmax.left)
        {
            int offset = mMinmax.left - size.width;
            size.width = mMinmax.left;
            if ((pos.left - mCoord.left) > offset)
                pos.left -= offset;
            else
                pos.left = mCoord.left;
        }
        else if (size.width > mMinmax.right)
        {
            int offset = mMinmax.right - size.width;
            size.width = mMinmax.right;
            if ((pos.left - mCoord.left) < offset)
                pos.left -= offset;
            else
                pos.left = mCoord.left;
        }
        if (size.height < mMinmax.top)
        {
            int offset = mMinmax.top - size.height;
            size.height = mMinmax.top;
            if ((pos.top - mCoord.top) > offset)
                pos.top -= offset;
            else
                pos.top = mCoord.top;
        }
        else if (size.height > mMinmax.bottom)
        {
            int offset = mMinmax.bottom - size.height;
            size.height = mMinmax.bottom;
            if ((pos.top - mCoord.top) < offset)
                pos.top -= offset;
            else
                pos.top = mCoord.top;
        }
 
        IntCoord coord(pos, size);
        if (mSnap)
        {
            // prefer size change over position change
            getSnappedCoord(coord, Snap::Size);
        }
 
        if (coord == mCoord)
            return;
 
        Base::setCoord(coord);
    }
 
    void Window::setCaption(const UString& _caption)
    {
        if (mWidgetCaption != nullptr)
            mWidgetCaption->setCaption(_caption);
        else
            Base::setCaption(_caption);
    }
 
    const UString& Window::getCaption() const
    {
        if (mWidgetCaption != nullptr)
            return mWidgetCaption->getCaption();
        return Base::getCaption();
    }
 
    void Window::destroySmooth()
    {
        ControllerFadeAlpha* controller = createControllerFadeAlpha(ALPHA_MIN, WINDOW_SPEED_COEF, false);
        controller->eventPostAction += newDelegate(action::actionWidgetDestroy);
        ControllerManager::getInstance().addItem(this, controller);
    }
 
    void Window::animateStop(Widget* _widget, ControllerItem* _controller)
    {
        if (mAnimateSmooth)
        {
            ControllerManager::getInstance().removeItem(this);
            mAnimateSmooth = false;
        }
    }
 
    void Window::setVisible(bool _visible)
    {
        if (mAnimateSmooth)
        {
            ControllerManager::getInstance().removeItem(this);
            setAlpha(getAlphaVisible());
            setEnabledSilent(true);
            mAnimateSmooth = false;
        }
 
        Base::setVisible(_visible);
    }
 
    float Window::getAlphaVisible() const
    {
        return (mIsAutoAlpha && !mKeyRootFocus) ? WINDOW_ALPHA_DEACTIVE : ALPHA_MAX;
    }
 
    void Window::getSnappedCoord(IntCoord& _coord, Snap snapMode) const
    {
        const IntSize view_size = getParentSize();
        bool nearLeftSide = abs(_coord.left) <= WINDOW_SNAP_DISTANSE;
        bool nearTopSide = abs(_coord.top) <= WINDOW_SNAP_DISTANSE;
        bool nearRightSide = abs(_coord.left + _coord.width - view_size.width) <= WINDOW_SNAP_DISTANSE;
        bool nearBottomSide = abs(_coord.top + _coord.height - view_size.height) <= WINDOW_SNAP_DISTANSE;
 
        switch (snapMode)
        {
        case Snap::Position:
            if (nearLeftSide)
                _coord.left = 0;
            if (nearTopSide)
                _coord.top = 0;
 
            if (nearRightSide)
                _coord.left = view_size.width - _coord.width;
            if (nearBottomSide)
                _coord.top = view_size.height - _coord.height;
            break;
        case Snap::Size:
            if (nearLeftSide)
            {
                _coord.width = _coord.right();
                _coord.left = 0;
            }
            if (nearTopSide)
            {
                _coord.height = _coord.bottom();
                _coord.top = 0;
            }
 
            if (nearRightSide)
                _coord.width = view_size.width - _coord.left;
            if (nearBottomSide)
                _coord.height = view_size.height - _coord.top;
            break;
        }
    }
 
    void Window::setVisibleSmooth(bool _visible)
    {
        mAnimateSmooth = true;
        ControllerManager::getInstance().removeItem(this);
 
        if (_visible)
        {
            setEnabledSilent(true);
            if (!getVisible())
            {
                setAlpha(ALPHA_MIN);
                Base::setVisible(true);
            }
            ControllerFadeAlpha* controller = createControllerFadeAlpha(getAlphaVisible(), WINDOW_SPEED_COEF, true);
            controller->eventPostAction += newDelegate(this, &Window::animateStop);
            ControllerManager::getInstance().addItem(this, controller);
        }
        else
        {
            setEnabledSilent(false);
            ControllerFadeAlpha* controller = createControllerFadeAlpha(ALPHA_MIN, WINDOW_SPEED_COEF, false);
            controller->eventPostAction += newDelegate(action::actionWidgetHide);
            ControllerManager::getInstance().addItem(this, controller);
        }
    }
 
    ControllerFadeAlpha* Window::createControllerFadeAlpha(float _alpha, float _coef, bool _enable)
    {
        ControllerItem* item = ControllerManager::getInstance().createItem(ControllerFadeAlpha::getClassTypeName());
        ControllerFadeAlpha* controller = item->castType<ControllerFadeAlpha>();
 
        controller->setAlpha(_alpha);
        controller->setCoef(_coef);
        controller->setEnabled(_enable);
 
        return controller;
    }
 
    void Window::setMinSize(const IntSize& _value)
    {
        mMinmax.left = _value.width;
        mMinmax.top = _value.height;
    }
 
    IntSize Window::getMinSize() const
    {
        return IntSize(mMinmax.left, mMinmax.top);
    }
 
    void Window::setMaxSize(const IntSize& _value)
    {
        mMinmax.right = _value.width;
        mMinmax.bottom = _value.height;
    }
 
    IntSize Window::getMaxSize() const
    {
        return IntSize(mMinmax.right, mMinmax.bottom);
    }
 
    void Window::setPropertyOverride(const std::string& _key, const std::string& _value)
    {
        if (_key == "AutoAlpha")
            setAutoAlpha(utility::parseValue<bool>(_value));
 
        else if (_key == "Snap")
            setSnap(utility::parseValue<bool>(_value));
 
        else if (_key == "MinSize")
            setMinSize(utility::parseValue<IntSize>(_value));
 
        else if (_key == "MaxSize")
            setMaxSize(utility::parseValue<IntSize>(_value));
 
        else if (_key == "Movable")
            setMovable(utility::parseValue<bool>(_value));
 
        else
        {
            Base::setPropertyOverride(_key, _value);
            return;
        }
 
        eventChangeProperty(this, _key, _value);
    }
 
    const IntCoord& Window::getActionScale() const
    {
        return mCurrentActionScale;
    }
 
    bool Window::getAutoAlpha() const
    {
        return mIsAutoAlpha;
    }
 
    TextBox* Window::getCaptionWidget() const
    {
        return mWidgetCaption;
    }
 
    void Window::setMinSize(int _width, int _height)
    {
        setMinSize(IntSize(_width, _height));
    }
 
    void Window::setMaxSize(int _width, int _height)
    {
        setMaxSize(IntSize(_width, _height));
    }
 
    bool Window::getSnap() const
    {
        return mSnap;
    }
 
    void Window::setSnap(bool _value)
    {
        mSnap = _value;
    }
 
    void Window::notifyMouseReleased(MyGUI::Widget* _sender, int _left, int _top, MouseButton _id)
    {
        if (MouseButton::Left == _id)
        {
            mCurrentActionScale.clear();
        }
    }
 
    IntCoord Window::_getActionScale(Widget* _widget) const
    {
        if (_widget->isUserString("Scale"))
        {
            IntCoord result = IntCoord::parse(_widget->getUserString("Scale"));
 
            if (result == IntCoord(1, 1, 0, 0) && !mMovable)
                result.clear();
 
            return result;
        }
        else if (_widget->isUserString("Action"))
        {
            const std::string& action = _widget->getUserString("Action");
            if (action == "Move")
            {
                if (mMovable)
                    return IntCoord(1, 1, 0, 0);
                else
                    return IntCoord();
            }
 
            IntCoord coord;
            Align align = Align::parse(action);
 
            if (align.isLeft())
            {
                coord.left = 1;
                coord.width = -1;
            }
            else if (align.isRight())
            {
                coord.width = 1;
            }
 
            if (align.isTop())
            {
                coord.top = 1;
                coord.height = -1;
            }
            else if (align.isBottom())
            {
                coord.height = 1;
            }
 
            return coord;
        }
 
        return IntCoord();
    }
 
    void Window::setMovable(bool _value)
    {
        mMovable = _value;
    }
 
    bool Window::getMovable() const
    {
        return mMovable;
    }
 
    void Window::notifyMouseWheel(MyGUI::Widget* _sender, int _rel)
    {
        onMouseWheel(_rel);
        eventMouseWheel(_sender, _rel);
    }
 
} // namespace MyGUI