/*
* The ManaPlus Client
* Copyright (C) 2004-2009 The Mana World Development Team
* Copyright (C) 2009-2010 The Mana Developers
* Copyright (C) 2011-2012 The ManaPlus Developers
*
* 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 .
*/
#include "gui/widgets/window.h"
#include "client.h"
#include "configuration.h"
#include "graphicsvertexes.h"
#include "sound.h"
#include "gui/gui.h"
#include "gui/viewport.h"
#include "gui/widgets/layout.h"
#include "resources/image.h"
#include
#include
#include "debug.h"
const int resizeMask = 8 + 4 + 2 + 1;
int Window::instances = 0;
int Window::mouseResize = 0;
Window::Window(const std::string &caption, const bool modal,
Window *const parent, std::string skin) :
gcn::Window(caption),
Widget2(),
gcn::WidgetListener(),
mSkin(nullptr),
mDefaultX(0),
mDefaultY(0),
mDefaultWidth(0),
mDefaultHeight(0),
mGrip(nullptr),
mParent(parent),
mLayout(nullptr),
mWindowName("window"),
mShowTitle(true),
mModal(modal),
mCloseButton(false),
mDefaultVisible(false),
mSaveVisible(false),
mStickyButton(false),
mSticky(false),
mStickyButtonLock(false),
mMinWinWidth(100),
mMinWinHeight(40),
mMaxWinWidth(mainGraphics->mWidth),
mMaxWinHeight(mainGraphics->mHeight),
mVertexes(new GraphicsVertexes()),
mCaptionOffsetX(7),
mCaptionOffsetY(5),
mCaptionAlign(gcn::Graphics::LEFT),
mTitlePadding(4),
mGripPadding(2),
mResizeHandles(-1),
mRedraw(true),
mPlayVisibleSound(false),
mCaptionFont(getFont())
{
logger->log("Window::Window(\"%s\")", caption.c_str());
if (!windowContainer)
throw GCN_EXCEPTION("Window::Window(): no windowContainer set");
instances++;
setFrameSize(0);
setPadding(3);
setTitleBarHeight(20);
if (skin == "")
skin = "window.xml";
int childPalette = 1;
// Loads the skin
if (Theme::instance())
{
mSkin = Theme::instance()->load(skin, "window.xml");
if (mSkin)
{
setPadding(mSkin->getPadding());
if (getOptionBool("titlebarBold"))
mCaptionFont = reinterpret_cast(boldFont);
setTitlePadding(mSkin->getTitlePadding());
setTitleBarHeight(getOption("titlebarHeight"));
mGripPadding = getOption("resizePadding");
mCaptionOffsetX = getOption("captionoffsetx");
if (!mCaptionOffsetX)
mCaptionOffsetX = 7;
mCaptionOffsetY = getOption("captionoffsety");
if (!mCaptionOffsetY)
mCaptionOffsetY = 5;
mCaptionAlign = getOption("captionalign");
if (mCaptionAlign < gcn::Graphics::LEFT
|| mCaptionAlign > gcn::Graphics::RIGHT)
{
mCaptionAlign = gcn::Graphics::LEFT;
}
setPalette(getOption("palette"));
childPalette = getOption("childPalette");
}
}
// Add this window to the window container
windowContainer->add(this);
if (mModal)
{
gui->setCursorType(Gui::CURSOR_POINTER);
requestModalFocus();
}
// Windows are invisible by default
setVisible(false);
addWidgetListener(this);
mForegroundColor = getThemeColor(Theme::WINDOW);
setPalette(childPalette);
}
Window::~Window()
{
logger->log("Window::~Window(\"%s\")", getCaption().c_str());
saveWindowState();
delete mLayout;
mLayout = nullptr;
while (!mWidgets.empty())
delete mWidgets.front();
mWidgets.clear();
removeWidgetListener(this);
delete mVertexes;
mVertexes = nullptr;
instances--;
if (mSkin)
{
if (Theme::instance())
Theme::instance()->unload(mSkin);
mSkin = nullptr;
}
if (mGrip)
{
mGrip->decRef();
mGrip = nullptr;
}
}
void Window::setWindowContainer(WindowContainer *wc)
{
windowContainer = wc;
}
void Window::draw(gcn::Graphics *graphics)
{
if (!mSkin)
return;
Graphics *const g = static_cast(graphics);
bool update = false;
if (mRedraw)
{
mRedraw = false;
update = true;
g->calcWindow(mVertexes, 0, 0, mDimension.width,
mDimension.height, mSkin->getBorder());
}
g->drawImageRect2(mVertexes, mSkin->getBorder());
// Draw title
if (mShowTitle)
{
g->setColor(mForegroundColor);
g->setFont(mCaptionFont);
g->drawText(getCaption(), mCaptionOffsetX, mCaptionOffsetY,
static_cast(mCaptionAlign));
}
// Draw Close Button
if (mCloseButton)
{
const Image *const button = mSkin->getCloseImage(
mResizeHandles == CLOSE);
if (button)
g->drawImage(button, mCloseRect.x, mCloseRect.y);
}
// Draw Sticky Button
if (mStickyButton)
{
const Image *const button = mSkin->getStickyImage(mSticky);
if (button)
g->drawImage(button, mStickyRect.x, mStickyRect.y);
}
if (mGrip)
g->drawImage(mGrip, mGripRect.x, mGripRect.y);
if (update)
{
g->setRedraw(update);
drawChildren(graphics);
g->setRedraw(false);
}
else
{
drawChildren(graphics);
}
}
void Window::setContentSize(int width, int height)
{
width = width + 2 * mPadding;
height = height + mPadding + getTitleBarHeight();
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);
}
void Window::setLocationRelativeTo(const gcn::Widget *const widget)
{
if (!widget)
return;
int wx, wy;
int x, 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 gcn::Widget *const widget)
{
if (!widget)
return;
int wx, wy;
int x, y;
widget->getAbsolutePosition(wx, wy);
getAbsolutePosition(x, y);
setPosition(mDimension.x + (wx + (widget->getWidth()
- mDimension.width) / 2 - x), 0);
}
void Window::setLocationRelativeTo(const ImageRect::ImagePosition position,
int offsetX, int offsetY)
{
if (position == ImageRect::UPPER_LEFT)
{
}
else if (position == ImageRect::UPPER_CENTER)
{
offsetX += (mainGraphics->mWidth - mDimension.width) / 2;
}
else if (position == ImageRect::UPPER_RIGHT)
{
offsetX += mainGraphics->mWidth - mDimension.width;
}
else if (position == ImageRect::LEFT)
{
offsetY += (mainGraphics->mHeight - mDimension.height) / 2;
}
else if (position == ImageRect::CENTER)
{
offsetX += (mainGraphics->mWidth - mDimension.width) / 2;
offsetY += (mainGraphics->mHeight - mDimension.height) / 2;
}
else if (position == ImageRect::RIGHT)
{
offsetX += mainGraphics->mWidth - mDimension.width;
offsetY += (mainGraphics->mHeight - mDimension.height) / 2;
}
else if (position == ImageRect::LOWER_LEFT)
{
offsetY += mainGraphics->mHeight - mDimension.height;
}
else if (position == ImageRect::LOWER_CENTER)
{
offsetX += (mainGraphics->mWidth - mDimension.width) / 2;
offsetY += mainGraphics->mHeight - mDimension.height;
}
else if (position == ImageRect::LOWER_RIGHT)
{
offsetX += mainGraphics->mWidth - mDimension.width;
offsetY += mainGraphics->mHeight - mDimension.height;
}
setPosition(offsetX, offsetY);
}
void Window::setMinWidth(int width)
{
if (mSkin)
{
mMinWinWidth = width > mSkin->getMinWidth()
? width : mSkin->getMinWidth();
}
else
{
mMinWinWidth = width;
}
}
void Window::setMinHeight(int height)
{
if (mSkin)
{
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)
mGrip->decRef();
if (r)
{
mGrip = Theme::getImageFromThemeXml("resize.xml", "");
mGripRect.x = mDimension.width - mGrip->getWidth() - mGripPadding;
mGripRect.y = mDimension.height - mGrip->getHeight() - mGripPadding;
}
else
{
mGrip = nullptr;
}
}
void Window::widgetResized(const gcn::Event &event A_UNUSED)
{
const gcn::Rectangle area = getChildrenArea();
if (mGrip)
{
mGripRect.x = mDimension.width - mGrip->getWidth() - mGripPadding;
mGripRect.y = mDimension.height - mGrip->getHeight() - mGripPadding;
}
if (mLayout)
{
int w = area.width;
int h = area.height;
mLayout->reflow(w, h);
}
const bool showClose = mCloseButton && mSkin->getCloseImage(false);
const int closePadding = getOption("closePadding");
if (showClose)
{
const Image *const button = mSkin->getCloseImage(false);
const int x = mDimension.width - button->getWidth() - closePadding;
mCloseRect.x = x;
mCloseRect.y = closePadding;
mCloseRect.width = button->getWidth();
mCloseRect.height = button->getHeight();
}
if (mStickyButton)
{
const Image *const button = mSkin->getStickyImage(mSticky);
if (button)
{
int x = mDimension.width - button->getWidth() - closePadding;
if (showClose)
x -= mSkin->getCloseImage(false)->getWidth() + closePadding;
mStickyRect.x = x;
mStickyRect.y = closePadding;
mStickyRect.width = button->getWidth();
mStickyRect.height = button->getHeight();
}
}
mRedraw = true;
}
void Window::widgetMoved(const gcn::Event& event A_UNUSED)
{
mRedraw = true;
}
void Window::widgetHidden(const gcn::Event &event A_UNUSED)
{
if (gui)
gui->setCursorType(Gui::CURSOR_POINTER);
if (!mFocusHandler)
return;
for (WidgetListConstIterator it = mWidgets.begin();
it != mWidgets.end(); ++ it)
{
if (mFocusHandler->isFocused(*it))
mFocusHandler->focusNone();
}
}
void Window::setCloseButton(const bool flag)
{
mCloseButton = flag;
}
bool Window::isResizable() const
{
return mGrip;
}
void Window::setStickyButton(const bool flag)
{
mStickyButton = flag;
}
void Window::setSticky(const bool sticky)
{
mSticky = sticky;
}
void Window::setStickyButtonLock(const bool lock)
{
mStickyButtonLock = lock;
mStickyButton = lock;
}
void Window::setVisible(bool visible)
{
setVisible(visible, false);
}
void Window::setVisible(bool visible, bool forceSticky)
{
if (visible == isVisible())
return; // Nothing to do
// Check if the window is off screen...
if (visible)
{
ensureOnScreen();
}
else
{
mResizeHandles = 0;
}
if (isStickyButtonLock())
gcn::Window::setVisible(visible);
else
gcn::Window::setVisible((!forceSticky && isSticky()) || visible);
if (visible)
{
if (mPlayVisibleSound)
sound.playGuiSound(SOUND_SHOW_WINDOW);
if (gui)
{
gcn::MouseEvent *event = reinterpret_cast(
gui->createMouseEvent(this));
if (event)
{
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)
sound.playGuiSound(SOUND_HIDE_WINDOW);
}
}
void Window::scheduleDelete()
{
windowContainer->scheduleDelete(this);
}
void Window::mousePressed(gcn::MouseEvent &event)
{
// Let Guichan move window to top and figure out title bar drag
gcn::Window::mousePressed(event);
if (event.getButton() == gcn::MouseEvent::LEFT)
{
const int x = event.getX();
const int y = event.getY();
// Handle close button
if (mCloseButton && mSkin && mCloseRect.isPointInRect(x, y))
{
mouseResize = 0;
mMoved = 0;
close();
return;
}
// Handle sticky button
if (mStickyButton && mSkin && mStickyRect.isPointInRect(x, y))
{
setSticky(!isSticky());
mouseResize = 0;
mMoved = 0;
return;
}
// Handle window resizing
mouseResize = getResizeHandles(event) & resizeMask;
if (canMove())
mMoved = !mouseResize;
else
mMoved = false;
}
}
void Window::close()
{
setVisible(false);
}
void Window::mouseReleased(gcn::MouseEvent &event A_UNUSED)
{
if (mGrip && mouseResize)
{
mouseResize = 0;
if (gui)
gui->setCursorType(Gui::CURSOR_POINTER);
}
// This should be the responsibility of Guichan (and is from 0.8.0 on)
mMoved = false;
}
void Window::mouseEntered(gcn::MouseEvent &event)
{
updateResizeHandler(event);
}
void Window::mouseExited(gcn::MouseEvent &event A_UNUSED)
{
if (mGrip && !mouseResize && gui)
gui->setCursorType(Gui::CURSOR_POINTER);
}
void Window::updateResizeHandler(gcn::MouseEvent &event)
{
if (!gui)
return;
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(Gui::CURSOR_RESIZE_DOWN_RIGHT);
break;
case TOP | RIGHT:
case BOTTOM | LEFT:
gui->setCursorType(Gui::CURSOR_RESIZE_DOWN_LEFT);
break;
case BOTTOM:
case TOP:
gui->setCursorType(Gui::CURSOR_RESIZE_DOWN);
break;
case RIGHT:
case LEFT:
gui->setCursorType(Gui::CURSOR_RESIZE_ACROSS);
break;
default:
gui->setCursorType(Gui::CURSOR_POINTER);
}
}
void Window::mouseMoved(gcn::MouseEvent &event)
{
updateResizeHandler(event);
if (viewport)
viewport->hideBeingPopup();
}
bool Window::canMove() const
{
return !mStickyButtonLock || !mSticky;
}
void Window::mouseDragged(gcn::MouseEvent &event)
{
if (canMove())
{
// Let Guichan handle title bar drag
gcn::Window::mouseDragged(event);
}
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 && !mMoved)
{
const int dx = event.getX() - mDragOffsetX;
const int dy = event.getY() - mDragOffsetY;
gcn::Rectangle newDim = getDimension();
if (mouseResize & (TOP | BOTTOM))
{
const int newHeight = newDim.height
+ ((mouseResize & TOP) ? -dy : dy);
newDim.height = std::min(mMaxWinHeight,
std::max(mMinWinHeight, newHeight));
if (mouseResize & TOP)
newDim.y -= newDim.height - getHeight();
}
if (mouseResize & (LEFT | RIGHT))
{
const int newWidth = newDim.width
+ ((mouseResize & LEFT) ? -dx : dx);
newDim.width = std::min(mMaxWinWidth,
std::max(mMinWinWidth, newWidth));
if (mouseResize & LEFT)
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)
mDragOffsetY += newDim.height - mDimension.height;
if (mouseResize & RIGHT)
mDragOffsetX += newDim.width - mDimension.width;
// Set the new window and content dimensions
setDimension(newDim);
}
}
void Window::setModal(bool modal)
{
if (mModal != modal)
{
mModal = modal;
if (mModal)
{
if (gui)
gui->setCursorType(Gui::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(config.getValueBool(name
+ "Visible", mDefaultVisible));
}
if (mStickyButton)
{
setSticky(config.getValueBool(name
+ "Sticky", isSticky()));
}
if (mGrip)
{
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)
{
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", isVisible());
if (mStickyButton)
config.setValue(mWindowName + "Sticky", isSticky());
if (mGrip)
{
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(int defaultX, int defaultY,
int defaultWidth, int defaultHeight)
{
if (getMinWidth() > defaultWidth)
defaultWidth = getMinWidth();
else if (getMaxWidth() < defaultWidth)
defaultWidth = getMaxWidth();
if (getMinHeight() > defaultHeight)
defaultHeight = getMinHeight();
else if (getMaxHeight() < defaultHeight)
defaultHeight = getMaxHeight();
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(int defaultWidth, int defaultHeight,
const ImageRect::ImagePosition position,
const int offsetX, const int offsetY)
{
int x = 0, y = 0;
if (position == ImageRect::UPPER_LEFT)
{
}
else if (position == ImageRect::UPPER_CENTER)
{
x = (mainGraphics->mWidth - defaultWidth) / 2;
}
else if (position == ImageRect::UPPER_RIGHT)
{
x = mainGraphics->mWidth - defaultWidth;
}
else if (position == ImageRect::LEFT)
{
y = (mainGraphics->mHeight - defaultHeight) / 2;
}
else if (position == ImageRect::CENTER)
{
x = (mainGraphics->mWidth - defaultWidth) / 2;
y = (mainGraphics->mHeight - defaultHeight) / 2;
}
else if (position == ImageRect::RIGHT)
{
x = mainGraphics->mWidth - defaultWidth;
y = (mainGraphics->mHeight - defaultHeight) / 2;
}
else if (position == ImageRect::LOWER_LEFT)
{
y = mainGraphics->mHeight - defaultHeight;
}
else if (position == ImageRect::LOWER_CENTER)
{
x = (mainGraphics->mWidth - defaultWidth) / 2;
y = mainGraphics->mHeight - defaultHeight;
}
else if (position == ImageRect::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)
{
gcn::Rectangle dimension = getDimension();
// 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)
dimension.x = mainGraphics->mWidth - rightMargin - mDimension.width;
if (mDimension.y > 0 && mDimension.y > bottomMargin)
dimension.y = mainGraphics->mHeight - bottomMargin - mDimension.height;
setDimension(dimension);
ensureOnScreen();
}
int Window::getResizeHandles(const gcn::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 && (y > mTitleBarHeight || (y < mPadding
&& 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 >= static_cast(mGripRect.x)
&& y >= static_cast(mGripRect.y))
{
mDragOffsetX = x;
mDragOffsetY = y;
resizeHandles |= BOTTOM | RIGHT;
}
}
}
return resizeHandles;
}
bool Window::isResizeAllowed(const gcn::MouseEvent &event) const
{
const int y = event.getY();
if (mGrip && (y > static_cast(mTitleBarHeight)
|| y < static_cast(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;
}
int Window::getGuiAlpha()
{
const float alpha = std::max(Client::getGuiAlpha(),
Theme::instance()->getMinimumOpacity());
return static_cast(alpha * 255.0f);
}
Layout &Window::getLayout()
{
if (!mLayout)
mLayout = new Layout;
return *mLayout;
}
void Window::clearLayout()
{
clear();
// Recreate layout instance when one is present
if (mLayout)
{
delete mLayout;
mLayout = new Layout;
}
}
LayoutCell &Window::place(const int x, const int y, gcn::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)
return;
mLayout->reflow(w, h);
delete mLayout;
mLayout = nullptr;
setContentSize(w, h);
}
void Window::redraw()
{
if (mLayout)
{
const gcn::Rectangle 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;
gcn::Rectangle dimension = getDimension();
// Check the left and bottom screen boundaries
if (dimension.x + dimension.width > mainGraphics->mWidth)
dimension.x = mainGraphics->mWidth - dimension.width;
if (dimension.y + dimension.height > mainGraphics->mHeight)
dimension.y = mainGraphics->mHeight - dimension.height;
// But never allow the windows to disappear in to the right and top
if (dimension.x < 0)
dimension.x = 0;
if (dimension.y < 0)
dimension.y = 0;
setDimension(dimension);
}
gcn::Rectangle Window::getWindowArea() const
{
return gcn::Rectangle(mPadding,
mPadding,
mDimension.width - mPadding * 2,
mDimension.height - mPadding * 2);
}
int Window::getOption(const std::string &name, const int def) const
{
if (mSkin)
{
const int val = mSkin->getOption(name);
if (val)
return val;
return def;
}
return def;
}
bool Window::getOptionBool(std::string name)
{
if (mSkin)
return mSkin->getOption(name) != 0;
return 0;
}