window.cpp

Go to the documentation of this file.

/*
 *  The ManaPlus Client
 *  Copyright (C) 2004-2009  The Mana World Development Team
 *  Copyright (C) 2009-2010  The Mana Developers
 *  Copyright (C) 2011-2019  The ManaPlus Developers
 *  Copyright (C) 2019-2021  Andrei Karas
 *
 *  This file is part of The ManaPlus Client.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
/*      _______   __   __   __   ______   __   __   _______   __   __
 *     / _____/\ / /\ / /\ / /\ / ____/\ / /\ / /\ / ___  /\ /  |\/ /\
 *    / /\____\// / // / // / // /\___\// /_// / // /\_/ / // , |/ / /
 *   / / /__   / / // / // / // / /    / ___  / // ___  / // /| ' / /
 *  / /_// /\ / /_// / // / // /_/_   / / // / // /\_/ / // / |  / /
 * /______/ //______/ //_/ //_____/\ /_/ //_/ //_/ //_/ //_/ /|_/ /
 * \______\/ \______\/ \_\/ \_____\/ \_\/ \_\/ \_\/ \_\/ \_\/ \_\/
 *
 * Copyright (c) 2004 - 2008 Olof Naessén and Per Larsson
 *
 *
 * Per Larsson a.k.a finalman
 * Olof Naessén a.k.a jansem/yakslem
 *
 * Visit: http://guichan.sourceforge.net
 *
 * License: (BSD)
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name of Guichan nor the names of its contributors may
 *    be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#include "gui/widgets/window.h"
 
#include "client.h"
#include "configuration.h"
#ifndef DYECMD
#include "dragdrop.h"
#else  // DYECMD
#include "resources/image/image.h"
#endif  // DYECMD
#include "soundmanager.h"
 
#include "const/sound.h"
 
#include "gui/focushandler.h"
#include "gui/gui.h"
#include "gui/popupmanager.h"
#include "gui/skin.h"
#include "gui/viewport.h"
 
#include "gui/fonts/font.h"
 
#include "gui/popups/popupmenu.h"
 
#include "gui/windows/setupwindow.h"
 
#include "gui/widgets/containerplacer.h"
#include "gui/widgets/layout.h"
 
#include "render/renderers.h"
 
#include "render/vertexes/imagecollection.h"
 
#include "utils/checkutils.h"
#include "utils/delete2.h"
 
#include "debug.h"
 
const int resizeMask = 8 + 4 + 2 + 1;
 
int Window::windowInstances = 0;
int Window::mouseResize = 0;
 
Window::Window(const std::string &caption,
               const Modal modal,
               Window *const parent,
               std::string skin) :
    BasicContainer2(nullptr),
    MouseListener(),
    WidgetListener(),
    mCaption(caption),
    mAlignment(Graphics::CENTER),
    mPadding(2),
    mTitleBarHeight(16),
    mMovable(Move_true),
    mDragOffsetX(0),
    mDragOffsetY(0),
    mMoved(false),
    mSkin(nullptr),
    mDefaultX(0),
    mDefaultY(0),
    mDefaultWidth(0),
    mDefaultHeight(0),
    mCaptionOffsetX(7),
    mCaptionOffsetY(5),
    mShowTitle(true),
    mLastRedraw(true),
    mGrip(nullptr),
    mParentWindow(parent),
    mLayout(nullptr),
    mCloseRect(),
    mStickyRect(),
    mGripRect(),
    mTextChunk(),
    mWindowName("window"),
    mMinWinWidth(100),
    mMinWinHeight(40),
    mMaxWinWidth(mainGraphics->mWidth),
    mMaxWinHeight(mainGraphics->mHeight),
    mVertexes(new ImageCollection),
    mCaptionAlign(Graphics::LEFT),
    mTitlePadding(4),
    mGripPadding(2),
    mResizeHandles(-1),
    mOldResizeHandles(-1),
    mClosePadding(0),
    mStickySpacing(0),
    mStickyPadding(0),
    mCaptionFont(getFont()),
    mModal(modal),
    mCloseWindowButton(false),
    mDefaultVisible(false),
    mSaveVisible(false),
    mStickyButton(false),
    mSticky(false),
    mStickyButtonLock(false),
    mPlayVisibleSound(false),
    mInit(false),
    mTextChanged(true),
    mAllowClose(false)
{
    logger->log("Window::Window(\"%s\")", caption.c_str());
 
    mWindow = this;
 
    windowInstances++;
 
//    mFrameSize = 1;
    addMouseListener(this);
 
    setFrameSize(0);
    setPadding(3);
    setTitleBarHeight(20);
 
    if (skin.empty())
    {
        reportAlways("Default skin was used for window: %s",
            caption.c_str())
        skin = "window.xml";
    }
 
    int childPalette = 1;
    // Loads the skin
    if (theme != nullptr)
    {
        mSkin = theme->load(skin,
            "window.xml",
            true,
            Theme::getThemePath());
        if (mSkin != nullptr)
        {
            setPadding(mSkin->getPadding());
            if (getOptionBool("titlebarBold", false))
                mCaptionFont = boldFont;
            mTitlePadding = mSkin->getTitlePadding();
            mGripPadding = getOption("resizePadding", 0);
            mCaptionOffsetX = getOption("captionoffsetx", 0);
            if (mCaptionOffsetX == 0)
                mCaptionOffsetX = 7;
            mCaptionOffsetY = getOption("captionoffsety", 0);
            if (mCaptionOffsetY == 0)
                mCaptionOffsetY = 5;
            mCaptionAlign = static_cast<Graphics::Alignment>(
                getOption("captionalign", 0));
            if (mCaptionAlign < Graphics::LEFT
                || mCaptionAlign > Graphics::RIGHT)
            {
                mCaptionAlign = Graphics::LEFT;
            }
            setTitleBarHeight(CAST_U32(
                getOption("titlebarHeight", 0)));
            if (mTitleBarHeight == 0U)
                mTitleBarHeight = mCaptionFont->getHeight() + mPadding;
 
            mTitleBarHeight += getOption("titlebarHeightRelative", 0);
            setPalette(getOption("palette", 0));
            childPalette = getOption("childPalette", 0);
            mShowTitle = getOptionBool("showTitle", true);
            mClosePadding = getOption("closePadding", 0);
            mStickySpacing = getOption("stickySpacing", 0);
            mStickyPadding = getOption("stickyPadding", 0);
        }
    }
 
    // Add this window to the window container
    if (windowContainer != nullptr)
        windowContainer->add(this);
 
    if (mModal == Modal_true)
    {
        gui->setCursorType(Cursor::CURSOR_POINTER);
        requestModalFocus();
    }
 
    // Windows are invisible by default
    setVisible(Visible_false, false);
 
    addWidgetListener(this);
    mForegroundColor = getThemeColor(ThemeColorId::WINDOW, 255U);
    mForegroundColor2 = getThemeColor(ThemeColorId::WINDOW_OUTLINE, 255U);
    setPalette(childPalette);
}
 
void Window::postInit()
{
    if (mInit)
    {
        reportAlways("error: Window created with calling postInit() "
            "more than once: %s",
            mWindowName.c_str())
    }
    mInit = true;
}
 
Window::~Window()
{
    logger->log("Window::~Window(\"%s\")", getCaption().c_str());
 
    if (gui != nullptr)
        gui->removeDragged(this);
 
#ifndef DYECMD
    if (setupWindow != nullptr)
        setupWindow->unregisterWindowForReset(this);
#endif  // DYECMD
 
    client->windowRemoved(this);
 
    saveWindowState();
 
    delete2(mLayout)
 
    while (!mWidgets.empty())
        delete mWidgets.front();
 
    mWidgets.clear();
 
    removeWidgetListener(this);
    delete2(mVertexes)
 
    windowInstances--;
 
    if (mSkin != nullptr)
    {
        if (theme != nullptr)
            theme->unload(mSkin);
        mSkin = nullptr;
    }
    if (mGrip != nullptr)
    {
        mGrip->decRef();
        mGrip = nullptr;
    }
    if (!mInit)
    {
        reportAlways("error: Window created without calling postInit(): %s",
            mWindowName.c_str())
    }
}
 
void Window::setWindowContainer(WindowContainer *const wc)
{
    windowContainer = wc;
}
 
void Window::draw(Graphics *const graphics)
{
    if (mSkin == nullptr)
        return;
 
    BLOCK_START("Window::draw")
    bool update = false;
 
    if (mResizeHandles != mOldResizeHandles)
    {
        mRedraw = true;
        mOldResizeHandles = mResizeHandles;
    }
    if (mRedraw)
    {
        mLastRedraw = true;
        mRedraw = false;
        update = true;
        mVertexes->clear();
        graphics->calcWindow(mVertexes,
            0, 0,
            mDimension.width,
            mDimension.height,
            mSkin->getBorder());
 
        // Draw Close Button
        if (mCloseWindowButton)
        {
            const Image *const button = mSkin->getCloseImage(
                mResizeHandles == CLOSE);
            if (button != nullptr)
            {
                graphics->calcTileCollection(mVertexes,
                    button,
                    mCloseRect.x,
                    mCloseRect.y);
            }
        }
        // Draw Sticky Button
        if (mStickyButton)
        {
            const Image *const button = mSkin->getStickyImage(mSticky);
            if (button != nullptr)
            {
                graphics->calcTileCollection(mVertexes,
                    button,
                    mStickyRect.x,
                    mStickyRect.y);
            }
        }
 
        if (mGrip != nullptr)
        {
            graphics->calcTileCollection(mVertexes,
                mGrip,
                mGripRect.x,
                mGripRect.y);
        }
        graphics->finalize(mVertexes);
    }
    else
    {
        mLastRedraw = false;
    }
    graphics->drawTileCollection(mVertexes);
 
    // Draw title
    if (mShowTitle)
    {
        int x;
        switch (mCaptionAlign)
        {
            case Graphics::LEFT:
            default:
                x = mCaptionOffsetX;
                break;
            case Graphics::CENTER:
                x = mCaptionOffsetX - mCaptionFont->getWidth(mCaption) / 2;
                break;
            case Graphics::RIGHT:
                x = mCaptionOffsetX - mCaptionFont->getWidth(mCaption);
                break;
        }
        if (mTextChanged)
        {
            mTextChunk.textFont = mCaptionFont;
            mTextChunk.deleteImage();
            mTextChunk.text = mCaption;
            mTextChunk.color = mForegroundColor;
            mTextChunk.color2 = mForegroundColor2;
            mCaptionFont->generate(mTextChunk);
            mTextChanged = false;
        }
 
        const Image *const image = mTextChunk.img;
        if (image != nullptr)
            graphics->drawImage(image, x, mCaptionOffsetY);
    }
 
    if (update)
    {
        graphics->setRedraw(update);
        drawChildren(graphics);
        graphics->setRedraw(false);
    }
    else
    {
        drawChildren(graphics);
    }
    BLOCK_END("Window::draw")
}
 
void Window::safeDraw(Graphics *const graphics)
{
    if (mSkin == nullptr)
        return;
 
    BLOCK_START("Window::safeDraw")
 
    graphics->drawImageRect(0, 0,
        mDimension.width,
        mDimension.height,
        mSkin->getBorder());
 
    // Draw Close Button
    if (mCloseWindowButton)
    {
        const Image *const button = mSkin->getCloseImage(
            mResizeHandles == CLOSE);
        if (button != nullptr)
            graphics->drawImage(button, mCloseRect.x, mCloseRect.y);
    }
    // Draw Sticky Button
    if (mStickyButton)
    {
        const Image *const button = mSkin->getStickyImage(mSticky);
        if (button != nullptr)
            graphics->drawImage(button, mStickyRect.x, mStickyRect.y);
    }
 
    if (mGrip != nullptr)
        graphics->drawImage(mGrip, mGripRect.x, mGripRect.y);
 
    // Draw title
    if (mShowTitle)
    {
        int x;
        switch (mCaptionAlign)
        {
            case Graphics::LEFT:
            default:
                x = mCaptionOffsetX;
                break;
            case Graphics::CENTER:
                x = mCaptionOffsetX - mCaptionFont->getWidth(mCaption) / 2;
                break;
            case Graphics::RIGHT:
                x = mCaptionOffsetX - mCaptionFont->getWidth(mCaption);
                break;
        }
        if (mTextChanged)
        {
            mTextChunk.textFont = mCaptionFont;
            mTextChunk.deleteImage();
            mTextChunk.text = mCaption;
            mTextChunk.color = mForegroundColor;
            mTextChunk.color2 = mForegroundColor2;
            mCaptionFont->generate(mTextChunk);
            mTextChanged = false;
        }
 
        const Image *const image = mTextChunk.img;
        if (image != nullptr)
            graphics->drawImage(image, x, mCaptionOffsetY);
    }
 
    safeDrawChildren(graphics);
 
    BLOCK_END("Window::safeDraw")
}
 
void Window::setContentSize(int width, int height)
{
    width = width + 2 * mPadding;
    height = height + mPadding + mTitleBarHeight;
 
    if (mMinWinWidth > width)
        width = mMinWinWidth;
    else if (mMaxWinWidth < width)
        width = mMaxWinWidth;
    if (mMinWinHeight > height)
        height = mMinWinHeight;
    else if (mMaxWinHeight < height)
        height = mMaxWinHeight;
 
    setSize(width, height);
}
 
void Window::setLocationRelativeTo(const Widget *const widget)
{
    if (widget == nullptr)
        return;
 
    int wx;
    int wy;
    int x;
    int y;
 
    widget->getAbsolutePosition(wx, wy);
    getAbsolutePosition(x, y);
 
    setPosition(mDimension.x + (wx + (widget->getWidth()
        - mDimension.width) / 2 - x),
        mDimension.y + (wy + (widget->getHeight()
        - mDimension.height) / 2 - y));
}
 
void Window::setLocationHorisontallyRelativeTo(const Widget *const widget)
{
    if (widget == nullptr)
        return;
 
    int wx;
    int wy;
    int x;
    int y;
 
    widget->getAbsolutePosition(wx, wy);
    getAbsolutePosition(x, y);
 
    setPosition(mDimension.x + (wx + (widget->getWidth()
        - mDimension.width) / 2 - x), 0);
}
 
void Window::setLocationRelativeTo(const ImagePosition::Type &position,
                                   int offsetX, int offsetY)
{
    if (position == ImagePosition::UPPER_LEFT)
    {
    }
    else if (position == ImagePosition::UPPER_CENTER)
    {
        offsetX += (mainGraphics->mWidth - mDimension.width) / 2;
    }
    else if (position == ImagePosition::UPPER_RIGHT)
    {
        offsetX += mainGraphics->mWidth - mDimension.width;
    }
    else if (position == ImagePosition::LEFT)
    {
        offsetY += (mainGraphics->mHeight - mDimension.height) / 2;
    }
    else if (position == ImagePosition::CENTER)
    {
        offsetX += (mainGraphics->mWidth - mDimension.width) / 2;
        offsetY += (mainGraphics->mHeight - mDimension.height) / 2;
    }
    else if (position == ImagePosition::RIGHT)
    {
        offsetX += mainGraphics->mWidth - mDimension.width;
        offsetY += (mainGraphics->mHeight - mDimension.height) / 2;
    }
    else if (position == ImagePosition::LOWER_LEFT)
    {
        offsetY += mainGraphics->mHeight - mDimension.height;
    }
    else if (position == ImagePosition::LOWER_CENTER)
    {
        offsetX += (mainGraphics->mWidth - mDimension.width) / 2;
        offsetY += mainGraphics->mHeight - mDimension.height;
    }
    else if (position == ImagePosition::LOWER_RIGHT)
    {
        offsetX += mainGraphics->mWidth - mDimension.width;
        offsetY += mainGraphics->mHeight - mDimension.height;
    }
 
    setPosition(offsetX, offsetY);
}
 
void Window::setMinWidth(const int width)
{
    if (mSkin != nullptr)
    {
        mMinWinWidth = width > mSkin->getMinWidth()
            ? width : mSkin->getMinWidth();
    }
    else
    {
        mMinWinWidth = width;
    }
}
 
void Window::setMinHeight(const int height)
{
    if (mSkin != nullptr)
    {
        mMinWinHeight = height > mSkin->getMinHeight()
            ? height : mSkin->getMinHeight();
    }
    else
    {
        mMinWinHeight = height;
    }
}
 
void Window::setMaxWidth(const int width)
{
    mMaxWinWidth = width;
}
 
void Window::setMaxHeight(const int height)
{
    mMaxWinHeight = height;
}
 
void Window::setResizable(const bool r)
{
    if ((mGrip != nullptr) == r)
        return;
 
    if (mGrip != nullptr)
        mGrip->decRef();
    if (r)
    {
        mGrip = Theme::getImageFromThemeXml("resize.xml", "");
        if (mGrip != nullptr)
        {
            mGripRect.x = mDimension.width - mGrip->getWidth() - mGripPadding;
            mGripRect.y = mDimension.height - mGrip->getHeight()
                - mGripPadding;
        }
        else
        {
            mGripRect.x = 0;
            mGripRect.y = 0;
        }
    }
    else
    {
        mGrip = nullptr;
    }
}
 
void Window::widgetResized(const Event &event A_UNUSED)
{
    if (mGrip != nullptr)
    {
        mGripRect.x = mDimension.width - mGrip->getWidth() - mGripPadding;
        mGripRect.y = mDimension.height - mGrip->getHeight() - mGripPadding;
    }
 
    if (mLayout != nullptr)
    {
        const Rect area = getChildrenArea();
        int w = area.width;
        int h = area.height;
        mLayout->reflow(w, h);
    }
    if (mSkin != nullptr)
    {
        const bool showClose = mCloseWindowButton
            && (mSkin->getCloseImage(false) != nullptr);
        if (showClose)
        {
            const Image *const button = mSkin->getCloseImage(false);
            if (button != nullptr)
            {
                const int buttonWidth = button->getWidth();
                mCloseRect.x = mDimension.width - buttonWidth - mClosePadding;
                mCloseRect.y = mClosePadding;
                mCloseRect.width = buttonWidth;
                mCloseRect.height = button->getHeight();
            }
        }
        if (mStickyButton)
        {
            const Image *const button = mSkin->getStickyImage(mSticky);
            if (button != nullptr)
            {
                const int buttonWidth = button->getWidth();
                int x = mDimension.width - buttonWidth
                    - mStickySpacing - mClosePadding;
 
                if (showClose)
                    x -= mSkin->getCloseImage(false)->getWidth();
 
                mStickyRect.x = x;
                mStickyRect.y = mStickyPadding;
                mStickyRect.width = buttonWidth;
                mStickyRect.height = button->getHeight();
            }
        }
    }
    else
    {
        mCloseRect.x = 0;
        mCloseRect.y = 0;
        mCloseRect.width = 0;
        mCloseRect.height = 0;
        mStickyRect.x = 0;
        mStickyRect.y = 0;
        mStickyRect.width = 0;
        mStickyRect.height = 0;
    }
 
    mRedraw = true;
}
 
void Window::widgetMoved(const Event& event A_UNUSED)
{
    mRedraw = true;
}
 
void Window::widgetHidden(const Event &event A_UNUSED)
{
    if (isBatchDrawRenders(openGLMode))
        mVertexes->clear();
 
    mTextChunk.deleteImage();
 
    mTextChanged = true;
    mRedraw = true;
 
    if (gui != nullptr)
        gui->setCursorType(Cursor::CURSOR_POINTER);
 
    if (mFocusHandler == nullptr)
        return;
 
    for (WidgetListConstIterator it = mWidgets.begin();
         it != mWidgets.end(); ++ it)
    {
        if (mFocusHandler->isFocused(*it))
            mFocusHandler->focusNone();
    }
}
 
void Window::setCloseButton(const bool flag)
{
    mCloseWindowButton = flag;
    if (flag)
        mAllowClose = true;
}
 
bool Window::isResizable() const
{
    return mGrip != nullptr;
}
 
void Window::setStickyButton(const bool flag)
{
    mStickyButton = flag;
}
 
void Window::setSticky(const bool sticky)
{
    mSticky = sticky;
    mRedraw = true;
}
 
void Window::setStickyButtonLock(const bool lock)
{
    mStickyButtonLock = lock;
    mStickyButton = lock;
}
 
void Window::setVisible(Visible visible)
{
    setVisible(visible, false);
}
 
void Window::setVisible(const Visible visible, const bool forceSticky)
{
    if (visible == mVisible)
        return;
 
    // Check if the window is off screen...
    if (visible == Visible_true)
        ensureOnScreen();
    else
        mResizeHandles = 0;
 
    if (mStickyButtonLock)
    {
        BasicContainer2::setVisible(visible);
    }
    else
    {
        BasicContainer2::setVisible(fromBool((!forceSticky && mSticky) ||
            visible == Visible_true, Visible));
    }
    if (visible == Visible_true)
    {
        if (mPlayVisibleSound)
            soundManager.playGuiSound(SOUND_SHOW_WINDOW);
        if (gui != nullptr)
        {
            MouseEvent *const event = reinterpret_cast<MouseEvent*>(
                gui->createMouseEvent(this));
            if (event != nullptr)
            {
                const int x = event->getX();
                const int y = event->getY();
                if (x >= 0 && x <= mDimension.width
                    && y >= 0 && y <= mDimension.height)
                {
                    mouseMoved(*event);
                }
                delete event;
            }
        }
    }
    else
    {
        if (mPlayVisibleSound)
            soundManager.playGuiSound(SOUND_HIDE_WINDOW);
    }
}
 
void Window::scheduleDelete()
{
    windowContainer->scheduleDelete(this);
}
 
void Window::mousePressed(MouseEvent &event)
{
    if (event.isConsumed())
        return;
 
    if (event.getSource() == this)
    {
        if (getParent() != nullptr)
            getParent()->moveToTop(this);
 
        mDragOffsetX = event.getX();
        mDragOffsetY = event.getY();
        mMoved = event.getY() <= CAST_S32(mTitleBarHeight);
    }
 
    const MouseButtonT button = event.getButton();
    if (button == MouseButton::LEFT)
    {
        const int x = event.getX();
        const int y = event.getY();
 
        // Handle close button
        if (mCloseWindowButton &&
            mSkin != nullptr &&
            mCloseRect.isPointInRect(x, y))
        {
            mouseResize = 0;
            mMoved = false;
            event.consume();
            close();
            return;
        }
 
        // Handle sticky button
        if (mStickyButton &&
            mSkin != nullptr &&
            mStickyRect.isPointInRect(x, y))
        {
            setSticky(!isSticky());
            mouseResize = 0;
            mMoved = false;
            event.consume();
            return;
        }
 
        // Handle window resizing
        mouseResize = getResizeHandles(event) & resizeMask;
        if (mouseResize != 0)
            event.consume();
        if (canMove())
            mMoved = (mouseResize == 0);
        else
            mMoved = false;
    }
#ifndef DYECMD
    else if (button == MouseButton::RIGHT)
    {
        if (popupMenu != nullptr)
        {
            event.consume();
            popupMenu->showWindowPopup(this);
        }
    }
#endif  // DYECMD
}
 
void Window::close()
{
    setVisible(Visible_false);
}
 
void Window::mouseReleased(MouseEvent &event A_UNUSED)
{
    if ((mGrip != nullptr) && (mouseResize != 0))
    {
        mouseResize = 0;
        if (gui != nullptr)
            gui->setCursorType(Cursor::CURSOR_POINTER);
    }
 
    mMoved = false;
}
 
void Window::mouseEntered(MouseEvent &event)
{
    updateResizeHandler(event);
}
 
void Window::mouseExited(MouseEvent &event A_UNUSED)
{
    if ((mGrip != nullptr) && (mouseResize == 0) && (gui != nullptr))
        gui->setCursorType(Cursor::CURSOR_POINTER);
}
 
void Window::updateResizeHandler(MouseEvent &event)
{
    if (gui == nullptr)
        return;
 
#ifndef DYECMD
    if (!dragDrop.isEmpty())
        return;
#endif  // DYECMD
 
    mResizeHandles = getResizeHandles(event);
 
    // Changes the custom mouse cursor based on it's current position.
    switch (mResizeHandles & resizeMask)
    {
        case BOTTOM | RIGHT:
        case TOP | LEFT:
            gui->setCursorType(Cursor::CURSOR_RESIZE_DOWN_RIGHT);
            break;
        case TOP | RIGHT:
        case BOTTOM | LEFT:
            gui->setCursorType(Cursor::CURSOR_RESIZE_DOWN_LEFT);
            break;
        case BOTTOM:
        case TOP:
            gui->setCursorType(Cursor::CURSOR_RESIZE_DOWN);
            break;
        case RIGHT:
        case LEFT:
            gui->setCursorType(Cursor::CURSOR_RESIZE_ACROSS);
            break;
        default:
            gui->setCursorType(Cursor::CURSOR_POINTER);
            break;
    }
}
 
void Window::mouseMoved(MouseEvent &event)
{
    updateResizeHandler(event);
    if ((popupManager != nullptr) && !event.isConsumed())
    {
        PopupManager::hideBeingPopup();
        PopupManager::hideTextPopup();
    }
}
 
bool Window::canMove() const
{
    return !mStickyButtonLock || !mSticky;
}
 
void Window::mouseDragged(MouseEvent &event)
{
    if (canMove())
    {
        if (!event.isConsumed() && event.getSource() == this)
        {
            if (isMovable() && mMoved)
            {
                setPosition(event.getX() - mDragOffsetX + getX(),
                    event.getY() - mDragOffsetY + getY());
            }
 
            event.consume();
        }
    }
    else
    {
        if (!event.isConsumed() && event.getSource() == this)
            event.consume();
        return;
    }
 
    // Keep guichan window inside screen when it may be moved
    if (isMovable() && mMoved)
    {
        setPosition(std::min(mainGraphics->mWidth - mDimension.width,
            std::max(0, mDimension.x)),
            std::min(mainGraphics->mHeight - mDimension.height,
            std::max(0, mDimension.y)));
    }
 
    if ((mouseResize != 0) && !mMoved)
    {
        const int dy = event.getY() - mDragOffsetY;
        Rect newDim = getDimension();
 
        if ((mouseResize & (TOP | BOTTOM)) != 0)
        {
            const int newHeight = newDim.height
                + ((mouseResize & TOP) != 0 ? -dy : dy);
            newDim.height = std::min(mMaxWinHeight,
                std::max(mMinWinHeight, newHeight));
 
            if ((mouseResize & TOP) != 0)
                newDim.y -= newDim.height - getHeight();
        }
 
        if ((mouseResize & (LEFT | RIGHT)) != 0)
        {
            const int dx = event.getX() - mDragOffsetX;
            const int newWidth = newDim.width
                + ((mouseResize & LEFT) != 0 ? -dx : dx);
            newDim.width = std::min(mMaxWinWidth,
                std::max(mMinWinWidth, newWidth));
 
            if ((mouseResize & LEFT) != 0)
                newDim.x -= newDim.width - mDimension.width;
        }
 
        // Keep guichan window inside screen (supports resizing any side)
        if (newDim.x < 0)
        {
            newDim.width += newDim.x;
            newDim.x = 0;
        }
        if (newDim.y < 0)
        {
            newDim.height += newDim.y;
            newDim.y = 0;
        }
        if (newDim.x + newDim.width > mainGraphics->mWidth)
            newDim.width = mainGraphics->mWidth - newDim.x;
        if (newDim.y + newDim.height > mainGraphics->mHeight)
            newDim.height = mainGraphics->mHeight - newDim.y;
 
        // Update mouse offset when dragging bottom or right border
        if ((mouseResize & BOTTOM) != 0)
            mDragOffsetY += newDim.height - mDimension.height;
 
        if ((mouseResize & RIGHT) != 0)
            mDragOffsetX += newDim.width - mDimension.width;
 
        // Set the new window and content dimensions
        setDimension(newDim);
    }
}
 
void Window::setModal(const Modal modal)
{
    if (mModal != modal)
    {
        mModal = modal;
        if (mModal == Modal_true)
        {
            if (gui != nullptr)
                gui->setCursorType(Cursor::CURSOR_POINTER);
            requestModalFocus();
        }
        else
        {
            releaseModalFocus();
        }
    }
}
 
void Window::loadWindowState()
{
    const std::string &name = mWindowName;
    if (name.empty())
        return;
 
    setPosition(config.getValueInt(name + "WinX", mDefaultX),
        config.getValueInt(name + "WinY", mDefaultY));
 
    if (mSaveVisible)
    {
        setVisible(fromBool(config.getValueBool(name
            + "Visible", mDefaultVisible), Visible));
    }
 
    if (mStickyButton)
    {
        setSticky(config.getValueBool(name
            + "Sticky", isSticky()));
    }
 
    if (mGrip != nullptr)
    {
        int width = config.getValueInt(name + "WinWidth", mDefaultWidth);
        int height = config.getValueInt(name + "WinHeight", mDefaultHeight);
 
        if (getMinWidth() > width)
            width = getMinWidth();
        else if (getMaxWidth() < width)
            width = getMaxWidth();
        if (getMinHeight() > height)
            height = getMinHeight();
        else if (getMaxHeight() < height)
            height = getMaxHeight();
 
        setSize(width, height);
    }
    else
    {
        setSize(mDefaultWidth, mDefaultHeight);
    }
 
    // Check if the window is off screen...
    ensureOnScreen();
 
    if (viewport != nullptr)
    {
        int width = mDimension.width;
        int height = mDimension.height;
 
        if (mDimension.x + width > viewport->getWidth())
            width = viewport->getWidth() - mDimension.x;
        if (mDimension.y + height > viewport->getHeight())
            height = viewport->getHeight() - mDimension.y;
        if (width < 0)
            width = 0;
        if (height < 0)
            height = 0;
        setSize(width, height);
    }
}
 
void Window::saveWindowState()
{
    // Saving X, Y and Width and Height for resizables in the config
    if (!mWindowName.empty() && mWindowName != "window")
    {
        config.setValue(mWindowName + "WinX", mDimension.x);
        config.setValue(mWindowName + "WinY", mDimension.y);
 
        if (mSaveVisible)
            config.setValue(mWindowName + "Visible", isWindowVisible());
 
        if (mStickyButton)
            config.setValue(mWindowName + "Sticky", isSticky());
 
        if (mGrip != nullptr)
        {
            if (getMinWidth() > mDimension.width)
                setWidth(getMinWidth());
            else if (getMaxWidth() < mDimension.width)
                setWidth(getMaxWidth());
            if (getMinHeight() > mDimension.height)
                setHeight(getMinHeight());
            else if (getMaxHeight() < mDimension.height)
                setHeight(getMaxHeight());
 
            config.setValue(mWindowName + "WinWidth", mDimension.width);
            config.setValue(mWindowName + "WinHeight", mDimension.height);
        }
    }
}
 
void Window::setDefaultSize(const int defaultX, const int defaultY,
                            int defaultWidth, int defaultHeight)
{
    if (mMinWinWidth > defaultWidth)
        defaultWidth = mMinWinWidth;
    else if (mMaxWinWidth < defaultWidth)
        defaultWidth = mMaxWinWidth;
    if (mMinWinHeight > defaultHeight)
        defaultHeight = mMinWinHeight;
    else if (mMaxWinHeight < defaultHeight)
        defaultHeight = mMaxWinHeight;
 
    mDefaultX = defaultX;
    mDefaultY = defaultY;
    mDefaultWidth = defaultWidth;
    mDefaultHeight = defaultHeight;
}
 
void Window::setDefaultSize()
{
    mDefaultX = mDimension.x;
    mDefaultY = mDimension.y;
    mDefaultWidth = mDimension.width;
    mDefaultHeight = mDimension.height;
}
 
void Window::setDefaultSize(const int defaultWidth, const int defaultHeight,
                            const ImagePosition::Type &position,
                            const int offsetX, const int offsetY)
{
    int x = 0;
    int y = 0;
 
    if (position == ImagePosition::UPPER_LEFT)
    {
    }
    else if (position == ImagePosition::UPPER_CENTER)
    {
        x = (mainGraphics->mWidth - defaultWidth) / 2;
    }
    else if (position == ImagePosition::UPPER_RIGHT)
    {
        x = mainGraphics->mWidth - defaultWidth;
    }
    else if (position == ImagePosition::LEFT)
    {
        y = (mainGraphics->mHeight - defaultHeight) / 2;
    }
    else if (position == ImagePosition::CENTER)
    {
        x = (mainGraphics->mWidth - defaultWidth) / 2;
        y = (mainGraphics->mHeight - defaultHeight) / 2;
    }
    else if (position == ImagePosition::RIGHT)
    {
        x = mainGraphics->mWidth - defaultWidth;
        y = (mainGraphics->mHeight - defaultHeight) / 2;
    }
    else if (position == ImagePosition::LOWER_LEFT)
    {
        y = mainGraphics->mHeight - defaultHeight;
    }
    else if (position == ImagePosition::LOWER_CENTER)
    {
        x = (mainGraphics->mWidth - defaultWidth) / 2;
        y = mainGraphics->mHeight - defaultHeight;
    }
    else if (position == ImagePosition::LOWER_RIGHT)
    {
        x = mainGraphics->mWidth - defaultWidth;
        y = mainGraphics->mHeight - defaultHeight;
    }
 
    mDefaultX = x - offsetX;
    mDefaultY = y - offsetY;
    mDefaultWidth = defaultWidth;
    mDefaultHeight = defaultHeight;
}
 
void Window::resetToDefaultSize()
{
    setPosition(mDefaultX, mDefaultY);
    setSize(mDefaultWidth, mDefaultHeight);
    saveWindowState();
}
 
void Window::adjustPositionAfterResize(const int oldScreenWidth,
                                       const int oldScreenHeight)
{
    // If window was aligned to the right or bottom, keep it there
    const int rightMargin = oldScreenWidth - (mDimension.x + mDimension.width);
    const int bottomMargin = oldScreenHeight
        - (mDimension.y + mDimension.height);
    if (mDimension.x > 0 && mDimension.x > rightMargin)
        mDimension.x = mainGraphics->mWidth - rightMargin - mDimension.width;
    if (mDimension.y > 0 && mDimension.y > bottomMargin)
    {
        mDimension.y = mainGraphics->mHeight
            - bottomMargin - mDimension.height;
    }
 
    ensureOnScreen();
    adjustSizeToScreen();
}
 
void Window::adjustSizeToScreen()
{
    if (mGrip == nullptr)
        return;
 
    const int screenWidth = mainGraphics->mWidth;
    const int screenHeight = mainGraphics->mHeight;
    const int oldWidth = mDimension.width;
    const int oldHeight = mDimension.height;
    if (oldWidth + mDimension.x > screenWidth)
        mDimension.x = 0;
    if (oldHeight + mDimension.y > screenHeight)
        mDimension.x = 0;
    if (mDimension.width > screenWidth)
        mDimension.width = screenWidth;
    if (mDimension.height > screenHeight)
        mDimension.height = screenHeight;
    if (oldWidth != mDimension.width || oldHeight != mDimension.height)
        widgetResized(Event(this));
}
 
int Window::getResizeHandles(const MouseEvent &event)
{
    if (event.getX() < 0 || event.getY() < 0)
        return 0;
 
    int resizeHandles = 0;
    const unsigned y = event.getY();
    const unsigned x = event.getX();
    if (mCloseRect.isPointInRect(x, y))
        return CLOSE;
 
    if (!mStickyButtonLock || !mSticky)
    {
        if ((mGrip != nullptr) &&
            (y > mTitleBarHeight ||
            (CAST_S32(y) < mPadding &&
            CAST_S32(mTitleBarHeight) > mPadding)))
        {
            if (!getWindowArea().isPointInRect(x, y)
                && event.getSource() == this)
            {
                resizeHandles |= (x > mDimension.width - resizeBorderWidth)
                    ? RIGHT : (x < resizeBorderWidth) ? LEFT : 0;
                resizeHandles |= (y > mDimension.height - resizeBorderWidth)
                    ? BOTTOM : (y < resizeBorderWidth) ? TOP : 0;
            }
            if (x >= CAST_U32(mGripRect.x)
                && y >= CAST_U32(mGripRect.y))
            {
                mDragOffsetX = x;
                mDragOffsetY = y;
                resizeHandles |= BOTTOM | RIGHT;
            }
        }
    }
 
    return resizeHandles;
}
 
bool Window::isResizeAllowed(const MouseEvent &event) const
{
    const int y = event.getY();
 
    if ((mGrip != nullptr) &&
        (y > CAST_S32(mTitleBarHeight) ||
        y < mPadding))
    {
        const int x = event.getX();
 
        if (!getWindowArea().isPointInRect(x, y) && event.getSource() == this)
            return true;
 
        if (x >= mGripRect.x && y >= mGripRect.y)
            return true;
    }
 
    return false;
}
 
Layout &Window::getLayout()
{
    if (mLayout == nullptr)
        mLayout = new Layout;
    return *mLayout;
}
 
void Window::clearLayout()
{
    clear();
 
    // Recreate layout instance when one is present
    if (mLayout != nullptr)
    {
        delete mLayout;
        mLayout = new Layout;
    }
}
 
LayoutCell &Window::place(const int x, const int y, Widget *const wg,
                          const int w, const int h)
{
    add(wg);
    return getLayout().place(wg, x, y, w, h);
}
 
ContainerPlacer Window::getPlacer(const int x, const int y)
{
    return ContainerPlacer(this, &getLayout().at(x, y));
}
 
void Window::reflowLayout(int w, int h)
{
    if (mLayout == nullptr)
        return;
 
    mLayout->reflow(w, h);
    delete2(mLayout)
    setContentSize(w, h);
}
 
void Window::redraw()
{
    if (mLayout != nullptr)
    {
        const Rect area = getChildrenArea();
        int w = area.width;
        int h = area.height;
        mLayout->reflow(w, h);
    }
}
 
void Window::center()
{
    setLocationRelativeTo(getParent());
}
 
void Window::centerHorisontally()
{
    setLocationHorisontallyRelativeTo(getParent());
}
 
void Window::ensureOnScreen()
{
    // Skip when a window hasn't got any size initialized yet
    if (mDimension.width == 0 && mDimension.height == 0)
        return;
 
    // Check the left and bottom screen boundaries
    if (mDimension.x + mDimension.width > mainGraphics->mWidth)
        mDimension.x = mainGraphics->mWidth - mDimension.width;
    if (mDimension.y + mDimension.height > mainGraphics->mHeight)
        mDimension.y = mainGraphics->mHeight - mDimension.height;
 
    // But never allow the windows to disappear in to the right and top
    if (mDimension.x < 0)
        mDimension.x = 0;
    if (mDimension.y < 0)
        mDimension.y = 0;
}
 
Rect Window::getWindowArea() const
{
    return Rect(mPadding,
        mPadding,
        mDimension.width - mPadding * 2,
        mDimension.height - mPadding * 2);
}
 
int Window::getOption(const std::string &name, const int def) const
{
    if (mSkin != nullptr)
    {
        const int val = mSkin->getOption(name);
        if (val != 0)
            return val;
        return def;
    }
    return def;
}
 
bool Window::getOptionBool(const std::string &name, const bool def) const
{
    if (mSkin != nullptr)
        return mSkin->getOption(name, static_cast<int>(def)) != 0;
    return def;
}
 
Rect Window::getChildrenArea()
{
    return Rect(mPadding,
        mTitleBarHeight,
        mDimension.width - mPadding * 2,
        mDimension.height - mPadding - mTitleBarHeight);
}
 
void Window::resizeToContent()
{
    int w = 0;
    int h = 0;
    for (WidgetListConstIterator it = mWidgets.begin();
          it != mWidgets.end(); ++ it)
    {
        const Widget *const widget = *it;
        const int x = widget->getX();
        const int y = widget->getY();
        const int width = widget->getWidth();
        const int height = widget->getHeight();
        if (x + width > w)
            w = x + width;
 
        if (y + height > h)
            h = y + height;
    }
 
    setSize(w + 2 * mPadding,
        h + mPadding + mTitleBarHeight);
}
 
#ifdef USE_PROFILER
void Window::logic()
{
    BLOCK_START("Window::logic")
    logicChildren();
    BLOCK_END("Window::logic")
}
#endif  // USE_PROFILER