tibia-client/src/framework/ui/uiwidget.cpp

1692 lines
45 KiB
C++
Raw Normal View History

2011-08-28 15:17:58 +02:00
/*
* Copyright (c) 2010-2013 OTClient <https://github.com/edubart/otclient>
2011-08-28 15:17:58 +02:00
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
2011-08-14 04:09:11 +02:00
#include "uiwidget.h"
#include "uimanager.h"
#include "uianchorlayout.h"
2011-11-16 00:47:32 +01:00
#include "uitranslator.h"
2011-08-14 04:09:11 +02:00
2011-08-15 16:06:15 +02:00
#include <framework/core/eventdispatcher.h>
#include <framework/otml/otmlnode.h>
#include <framework/graphics/graphics.h>
#include <framework/platform/platformwindow.h>
#include <framework/graphics/texturemanager.h>
#include <framework/core/application.h>
2011-08-14 04:09:11 +02:00
2011-08-22 14:44:26 +02:00
UIWidget::UIWidget()
2011-08-14 04:09:11 +02:00
{
2011-11-17 18:43:41 +01:00
m_lastFocusReason = Fw::ActiveFocusReason;
m_states = Fw::DefaultState;
m_clickTimer.stop();
m_autoRepeatDelay = 500;
2011-08-14 04:09:11 +02:00
initBaseStyle();
initText();
initImage();
2011-08-14 04:09:11 +02:00
}
UIWidget::~UIWidget()
2011-08-22 21:39:46 +02:00
{
2012-07-28 13:43:48 +02:00
#ifndef NDEBUG
assert(!g_app.isTerminated());
if(!m_destroyed)
2012-06-01 22:39:23 +02:00
g_logger.warning(stdext::format("widget '%s' was not explicitly destroyed", m_id));
#endif
}
2012-06-08 18:58:08 +02:00
void UIWidget::draw(const Rect& visibleRect, Fw::DrawPane drawPane)
{
Rect oldClipRect;
if(m_clipping) {
oldClipRect = g_painter->getClipRect();
g_painter->setClipRect(visibleRect);
}
2013-01-19 17:44:07 +01:00
if(m_rotation != 0.0f) {
g_painter->pushTransformMatrix();
g_painter->rotate(m_rect.center(), m_rotation * (Fw::pi / 180.0));
}
2012-06-08 18:58:08 +02:00
drawSelf(drawPane);
if(m_children.size() > 0) {
if(m_clipping)
2012-06-02 02:38:26 +02:00
g_painter->setClipRect(visibleRect.intersection(getPaddingRect()));
2012-06-08 18:58:08 +02:00
drawChildren(visibleRect, drawPane);
}
2013-01-19 17:44:07 +01:00
if(m_rotation != 0.0f)
g_painter->popTransformMatrix();
if(m_clipping) {
g_painter->setClipRect(oldClipRect);
}
}
2012-06-08 18:58:08 +02:00
void UIWidget::drawSelf(Fw::DrawPane drawPane)
2011-08-14 04:09:11 +02:00
{
2012-06-08 18:58:08 +02:00
if((drawPane & Fw::ForegroundPane) == 0)
return;
// draw style components in order
2012-04-05 21:08:46 +02:00
if(m_backgroundColor.aF() > Fw::MIN_ALPHA) {
Rect backgroundDestRect = m_rect;
backgroundDestRect.expand(-m_borderWidth.top, -m_borderWidth.right, -m_borderWidth.bottom, -m_borderWidth.left);
drawBackground(m_rect);
}
drawImage(m_rect);
drawBorder(m_rect);
drawIcon(m_rect);
drawText(m_rect);
}
2011-08-14 04:09:11 +02:00
2012-06-08 18:58:08 +02:00
void UIWidget::drawChildren(const Rect& visibleRect, Fw::DrawPane drawPane)
{
2011-08-22 21:13:52 +02:00
// draw children
2011-08-14 04:09:11 +02:00
for(const UIWidgetPtr& child : m_children) {
// render only visible children with a valid rect inside parent rect
2012-04-05 21:08:46 +02:00
if(!child->isExplicitlyVisible() || !child->getRect().isValid() || child->getOpacity() < Fw::MIN_ALPHA)
continue;
Rect childVisibleRect = visibleRect.intersection(child->getRect());
if(!childVisibleRect.isValid())
continue;
// store current graphics opacity
float oldOpacity = g_painter->getOpacity();
// decrease to self opacity
if(child->getOpacity() < oldOpacity)
g_painter->setOpacity(child->getOpacity());
2012-06-08 18:58:08 +02:00
child->draw(childVisibleRect, drawPane);
// debug draw box
2012-06-08 18:58:08 +02:00
if(g_ui.isDrawingDebugBoxes() && drawPane & Fw::ForegroundPane) {
g_painter->setColor(Color::green);
g_painter->drawBoundingRect(child->getRect());
}
//g_fonts.getDefaultFont()->renderText(child->getId(), child->getPosition() + Point(2, 0), Color::red);
g_painter->setOpacity(oldOpacity);
2011-08-14 04:09:11 +02:00
}
}
void UIWidget::addChild(const UIWidgetPtr& child)
{
if(!child) {
2013-01-08 21:01:47 +01:00
g_logger.traceWarning("attempt to add a null child into a UIWidget");
return;
}
if(child->isDestroyed()) {
2013-01-08 21:01:47 +01:00
g_logger.traceWarning("attemp to add a destroyed child into a UIWidget");
return;
}
if(hasChild(child)) {
2013-01-08 21:01:47 +01:00
g_logger.traceWarning("attempt to add a child again into a UIWidget");
return;
}
UIWidgetPtr oldLastChild = getLastChild();
m_children.push_back(child);
child->setParent(static_self_cast<UIWidget>());
// create default layout
if(!m_layout)
m_layout = UIAnchorLayoutPtr(new UIAnchorLayout(static_self_cast<UIWidget>()));
// add to layout and updates it
m_layout->addWidget(child);
// update new child states
child->updateStates();
// update old child index states
if(oldLastChild) {
oldLastChild->updateState(Fw::MiddleState);
oldLastChild->updateState(Fw::LastState);
}
g_ui.onWidgetAppear(child);
}
void UIWidget::insertChild(int index, const UIWidgetPtr& child)
{
if(!child) {
2013-01-08 21:01:47 +01:00
g_logger.traceWarning("attempt to insert a null child into a UIWidget");
return;
}
if(hasChild(child)) {
2013-01-08 21:01:47 +01:00
g_logger.traceWarning("attempt to insert a child again into a UIWidget");
return;
}
index = index <= 0 ? (m_children.size() + index) : index-1;
if(!(index >= 0 && (uint)index <= m_children.size())) {
2013-01-08 21:01:47 +01:00
//g_logger.traceWarning("attempt to insert a child UIWidget into an invalid index, using nearest index...");
index = std::min(std::max(index, 0), (int)m_children.size());
}
// retrieve child by index
auto it = m_children.begin() + index;
m_children.insert(it, child);
child->setParent(static_self_cast<UIWidget>());
// create default layout if needed
if(!m_layout)
m_layout = UIAnchorLayoutPtr(new UIAnchorLayout(static_self_cast<UIWidget>()));
// add to layout and updates it
m_layout->addWidget(child);
// update new child states
child->updateStates();
updateChildrenIndexStates();
g_ui.onWidgetAppear(child);
}
void UIWidget::removeChild(UIWidgetPtr child)
{
// remove from children list
if(hasChild(child)) {
// defocus if needed
bool focusAnother = false;
if(m_focusedChild == child) {
focusChild(nullptr, Fw::ActiveFocusReason);
focusAnother = true;
}
if(isChildLocked(child))
unlockChild(child);
auto it = std::find(m_children.begin(), m_children.end(), child);
m_children.erase(it);
// reset child parent
assert(child->getParent() == static_self_cast<UIWidget>());
child->setParent(nullptr);
m_layout->removeWidget(child);
// update child states
child->updateStates();
updateChildrenIndexStates();
if(focusAnother && !m_focusedChild)
focusPreviousChild(Fw::ActiveFocusReason);
g_ui.onWidgetDisappear(child);
} else
2013-01-08 21:01:47 +01:00
g_logger.traceError("attempt to remove an unknown child from a UIWidget");
}
void UIWidget::focusChild(const UIWidgetPtr& child, Fw::FocusReason reason)
2011-08-30 01:40:56 +02:00
{
if(m_destroyed)
return;
2012-01-19 05:12:53 +01:00
if(child == m_focusedChild)
return;
if(child && !hasChild(child)) {
2012-06-01 22:39:23 +02:00
g_logger.error("attempt to focus an unknown child in a UIWidget");
return;
}
2011-11-16 22:00:40 +01:00
2012-01-19 05:12:53 +01:00
UIWidgetPtr oldFocused = m_focusedChild;
m_focusedChild = child;
2012-01-19 05:12:53 +01:00
if(child) {
child->setLastFocusReason(reason);
child->updateState(Fw::FocusState);
child->updateState(Fw::ActiveState);
2012-03-26 15:34:43 +02:00
2012-03-30 09:39:46 +02:00
child->onFocusChange(true, reason);
2012-01-19 05:12:53 +01:00
}
2011-11-16 22:00:40 +01:00
2012-01-19 05:12:53 +01:00
if(oldFocused) {
oldFocused->setLastFocusReason(reason);
oldFocused->updateState(Fw::FocusState);
oldFocused->updateState(Fw::ActiveState);
2012-03-26 15:34:43 +02:00
2012-03-30 09:39:46 +02:00
oldFocused->onFocusChange(false, reason);
2011-11-16 22:00:40 +01:00
}
2012-02-06 02:44:47 +01:00
onChildFocusChange(child, oldFocused, reason);
2011-11-16 22:00:40 +01:00
}
void UIWidget::focusNextChild(Fw::FocusReason reason)
2012-01-05 03:42:17 +01:00
{
if(m_destroyed)
return;
UIWidgetPtr toFocus;
UIWidgetList rotatedChildren(m_children);
2012-01-05 03:42:17 +01:00
if(m_focusedChild) {
auto focusedIt = std::find(rotatedChildren.begin(), rotatedChildren.end(), m_focusedChild);
if(focusedIt != rotatedChildren.end()) {
std::rotate(rotatedChildren.begin(), focusedIt, rotatedChildren.end());
rotatedChildren.pop_front();
}
2012-01-05 03:42:17 +01:00
}
// finds next child to focus
for(const UIWidgetPtr& child : rotatedChildren) {
if(child->isFocusable() && child->isExplicitlyEnabled() && child->isVisible()) {
toFocus = child;
break;
}
2012-01-05 03:42:17 +01:00
}
if(toFocus)
focusChild(toFocus, reason);
2012-01-05 19:02:27 +01:00
}
void UIWidget::focusPreviousChild(Fw::FocusReason reason)
2012-01-05 19:02:27 +01:00
{
if(m_destroyed)
return;
UIWidgetPtr toFocus;
UIWidgetList rotatedChildren(m_children);
std::reverse(rotatedChildren.begin(), rotatedChildren.end());
2012-01-05 19:02:27 +01:00
if(m_focusedChild) {
auto focusedIt = std::find(rotatedChildren.begin(), rotatedChildren.end(), m_focusedChild);
if(focusedIt != rotatedChildren.end()) {
std::rotate(rotatedChildren.begin(), focusedIt, rotatedChildren.end());
rotatedChildren.pop_front();
}
}
2011-11-16 22:00:40 +01:00
// finds next child to focus
for(const UIWidgetPtr& child : rotatedChildren) {
if(child->isFocusable() && child->isExplicitlyEnabled() && child->isVisible()) {
toFocus = child;
break;
2011-11-16 22:00:40 +01:00
}
2011-08-30 01:40:56 +02:00
}
if(toFocus)
focusChild(toFocus, reason);
2011-08-30 01:40:56 +02:00
}
void UIWidget::lowerChild(UIWidgetPtr child)
{
if(m_destroyed)
return;
if(!child)
return;
// remove and push child again
auto it = std::find(m_children.begin(), m_children.end(), child);
if(it == m_children.end()) {
2012-06-01 22:39:23 +02:00
g_logger.traceError("cannot find child");
return;
}
m_children.erase(it);
m_children.push_front(child);
updateChildrenIndexStates();
}
void UIWidget::raiseChild(UIWidgetPtr child)
{
if(m_destroyed)
return;
if(!child)
return;
// remove and push child again
auto it = std::find(m_children.begin(), m_children.end(), child);
if(it == m_children.end()) {
2012-06-01 22:39:23 +02:00
g_logger.traceError("cannot find child");
return;
}
m_children.erase(it);
m_children.push_back(child);
updateChildrenIndexStates();
}
void UIWidget::moveChildToIndex(const UIWidgetPtr& child, int index)
2011-08-14 04:09:11 +02:00
{
if(m_destroyed)
return;
if(!child)
return;
2012-06-21 21:31:22 +02:00
if((uint)index - 1 > m_children.size()) {
2013-01-08 21:01:47 +01:00
g_logger.traceError(stdext::format("moving %s to index %d on %s", child->getId(), index, m_id));
2012-06-21 21:31:22 +02:00
return;
}
// remove and push child again
auto it = std::find(m_children.begin(), m_children.end(), child);
if(it == m_children.end()) {
2012-06-01 22:39:23 +02:00
g_logger.traceError("cannot find child");
return;
}
m_children.erase(it);
m_children.insert(m_children.begin() + index - 1, child);
updateChildrenIndexStates();
2012-06-21 21:31:22 +02:00
updateLayout();
}
2011-08-14 04:09:11 +02:00
void UIWidget::lockChild(const UIWidgetPtr& child)
{
if(m_destroyed)
return;
if(!child)
2011-11-17 21:40:31 +01:00
return;
if(!hasChild(child)) {
2012-06-01 22:39:23 +02:00
g_logger.traceError("cannot find child");
return;
}
2011-08-14 04:09:11 +02:00
// prevent double locks
if(isChildLocked(child))
unlockChild(child);
2011-08-22 21:13:52 +02:00
// disable all other children
for(const UIWidgetPtr& otherChild : m_children) {
if(otherChild == child)
child->setEnabled(true);
else
otherChild->setEnabled(false);
2011-08-14 04:09:11 +02:00
}
m_lockedChildren.push_front(child);
// lock child focus
if(child->isFocusable())
focusChild(child, Fw::ActiveFocusReason);
2011-08-14 04:09:11 +02:00
}
void UIWidget::unlockChild(const UIWidgetPtr& child)
2011-08-14 04:09:11 +02:00
{
if(m_destroyed)
return;
if(!child)
return;
if(!hasChild(child)) {
2012-06-01 22:39:23 +02:00
g_logger.traceError("cannot find child");
return;
}
2011-08-14 04:09:11 +02:00
auto it = std::find(m_lockedChildren.begin(), m_lockedChildren.end(), child);
if(it == m_lockedChildren.end())
return;
2011-08-21 21:43:05 +02:00
m_lockedChildren.erase(it);
// find new child to lock
UIWidgetPtr lockedChild;
if(m_lockedChildren.size() > 0) {
lockedChild = m_lockedChildren.front();
assert(hasChild(lockedChild));
2011-08-14 04:09:11 +02:00
}
for(const UIWidgetPtr& otherChild : m_children) {
// lock new child
if(lockedChild) {
if(otherChild == lockedChild)
lockedChild->setEnabled(true);
else
otherChild->setEnabled(false);
}
// else unlock all
else
otherChild->setEnabled(true);
}
if(lockedChild) {
if(lockedChild->isFocusable())
focusChild(lockedChild, Fw::ActiveFocusReason);
}
}
2012-04-30 18:40:12 +02:00
void UIWidget::mergeStyle(const OTMLNodePtr& styleNode)
{
applyStyle(styleNode);
2013-01-08 21:01:47 +01:00
std::string name = m_style->tag();
std::string source = m_style->source();
2012-04-30 18:40:12 +02:00
m_style->merge(styleNode);
2013-01-08 21:01:47 +01:00
m_style->setTag(name);
m_style->setSource(source);
2012-04-30 18:40:12 +02:00
updateStyle();
}
void UIWidget::applyStyle(const OTMLNodePtr& styleNode)
{
if(m_destroyed)
return;
if(styleNode->size() == 0)
return;
2012-01-12 20:20:18 +01:00
m_loadingStyle = true;
try {
// translate ! style tags
for(const OTMLNodePtr& node : styleNode->children()) {
if(node->tag()[0] == '!') {
std::string tag = node->tag().substr(1);
std::string code = stdext::format("tostring(%s)", node->value().c_str());
2013-01-08 21:01:47 +01:00
std::string origin = "@" + node->source() + ": [" + node->tag() + "]";
g_lua.evaluateExpression(code, origin);
std::string value = g_lua.popString();
node->setTag(tag);
node->setValue(value);
}
}
onStyleApply(styleNode->tag(), styleNode);
callLuaField("onStyleApply", styleNode->tag(), styleNode);
if(m_firstOnStyle) {
// always focus new child
if(isFocusable() && isExplicitlyVisible() && isExplicitlyEnabled())
focus();
}
m_firstOnStyle = false;
} catch(stdext::exception& e) {
2013-01-08 21:01:47 +01:00
g_logger.traceError(stdext::format("failed to apply style to widget '%s': %s", m_id, e.what()));
}
2012-01-12 20:20:18 +01:00
m_loadingStyle = false;
}
void UIWidget::addAnchor(Fw::AnchorEdge anchoredEdge, const std::string& hookedWidgetId, Fw::AnchorEdge hookedEdge)
{
if(m_destroyed)
return;
if(UIAnchorLayoutPtr anchorLayout = getAnchoredLayout())
anchorLayout->addAnchor(static_self_cast<UIWidget>(), anchoredEdge, hookedWidgetId, hookedEdge);
2012-01-19 05:12:53 +01:00
else
2013-01-08 21:01:47 +01:00
g_logger.traceError(stdext::format("cannot add anchors to widget '%s': the parent doesn't use anchors layout", m_id));
}
2012-04-06 00:46:53 +02:00
void UIWidget::removeAnchor(Fw::AnchorEdge anchoredEdge)
{
addAnchor(anchoredEdge, "none", Fw::AnchorNone);
}
void UIWidget::centerIn(const std::string& hookedWidgetId)
{
if(m_destroyed)
return;
if(UIAnchorLayoutPtr anchorLayout = getAnchoredLayout()) {
anchorLayout->addAnchor(static_self_cast<UIWidget>(), Fw::AnchorHorizontalCenter, hookedWidgetId, Fw::AnchorHorizontalCenter);
anchorLayout->addAnchor(static_self_cast<UIWidget>(), Fw::AnchorVerticalCenter, hookedWidgetId, Fw::AnchorVerticalCenter);
2012-01-19 05:12:53 +01:00
} else
2013-01-08 21:01:47 +01:00
g_logger.traceError(stdext::format("cannot add anchors to widget '%s': the parent doesn't use anchors layout", m_id));
}
void UIWidget::fill(const std::string& hookedWidgetId)
2012-01-02 23:09:49 +01:00
{
if(m_destroyed)
return;
if(UIAnchorLayoutPtr anchorLayout = getAnchoredLayout()) {
anchorLayout->addAnchor(static_self_cast<UIWidget>(), Fw::AnchorLeft, hookedWidgetId, Fw::AnchorLeft);
anchorLayout->addAnchor(static_self_cast<UIWidget>(), Fw::AnchorRight, hookedWidgetId, Fw::AnchorRight);
anchorLayout->addAnchor(static_self_cast<UIWidget>(), Fw::AnchorTop, hookedWidgetId, Fw::AnchorTop);
anchorLayout->addAnchor(static_self_cast<UIWidget>(), Fw::AnchorBottom, hookedWidgetId, Fw::AnchorBottom);
2012-01-19 05:12:53 +01:00
} else
2013-01-08 21:01:47 +01:00
g_logger.traceError(stdext::format("cannot add anchors to widget '%s': the parent doesn't use anchors layout", m_id));
}
2012-01-02 23:09:49 +01:00
void UIWidget::breakAnchors()
{
if(m_destroyed)
return;
if(UIAnchorLayoutPtr anchorLayout = getAnchoredLayout())
anchorLayout->removeAnchors(static_self_cast<UIWidget>());
}
void UIWidget::updateParentLayout()
{
if(m_destroyed)
return;
if(UIWidgetPtr parent = getParent())
parent->updateLayout();
else
updateLayout();
}
void UIWidget::updateLayout()
{
if(m_destroyed)
return;
if(m_layout)
m_layout->update();
// children can affect the parent layout
if(UIWidgetPtr parent = getParent())
if(UILayoutPtr parentLayout = parent->getLayout())
parentLayout->updateLater();
2012-01-02 23:09:49 +01:00
}
void UIWidget::lock()
{
if(m_destroyed)
return;
if(UIWidgetPtr parent = getParent())
parent->lockChild(static_self_cast<UIWidget>());
}
void UIWidget::unlock()
{
if(m_destroyed)
return;
if(UIWidgetPtr parent = getParent())
parent->unlockChild(static_self_cast<UIWidget>());
}
void UIWidget::focus()
{
if(m_destroyed)
return;
2011-11-16 22:00:40 +01:00
if(!m_focusable)
return;
if(UIWidgetPtr parent = getParent())
parent->focusChild(static_self_cast<UIWidget>(), Fw::ActiveFocusReason);
}
2012-03-30 00:46:44 +02:00
void UIWidget::recursiveFocus(Fw::FocusReason reason)
{
if(m_destroyed)
return;
if(UIWidgetPtr parent = getParent()) {
if(m_focusable)
parent->focusChild(static_self_cast<UIWidget>(), reason);
2012-03-30 00:46:44 +02:00
parent->recursiveFocus(reason);
}
}
void UIWidget::lower()
{
if(m_destroyed)
return;
UIWidgetPtr parent = getParent();
if(parent)
parent->lowerChild(static_self_cast<UIWidget>());
}
void UIWidget::raise()
{
if(m_destroyed)
return;
UIWidgetPtr parent = getParent();
if(parent)
parent->raiseChild(static_self_cast<UIWidget>());
}
2012-01-02 23:09:49 +01:00
void UIWidget::grabMouse()
{
if(m_destroyed)
return;
g_ui.setMouseReceiver(static_self_cast<UIWidget>());
2012-01-02 23:09:49 +01:00
}
void UIWidget::ungrabMouse()
{
if(g_ui.getMouseReceiver() == static_self_cast<UIWidget>())
2012-01-02 23:09:49 +01:00
g_ui.resetMouseReceiver();
}
void UIWidget::grabKeyboard()
{
if(m_destroyed)
return;
g_ui.setKeyboardReceiver(static_self_cast<UIWidget>());
2012-01-02 23:09:49 +01:00
}
void UIWidget::ungrabKeyboard()
{
if(g_ui.getKeyboardReceiver() == static_self_cast<UIWidget>())
2012-01-02 23:09:49 +01:00
g_ui.resetKeyboardReceiver();
}
void UIWidget::bindRectToParent()
2011-08-14 04:09:11 +02:00
{
if(m_destroyed)
return;
Rect boundRect = m_rect;
UIWidgetPtr parent = getParent();
if(parent) {
2012-06-02 02:38:26 +02:00
Rect parentRect = parent->getPaddingRect();
boundRect.bind(parentRect);
2011-08-14 04:09:11 +02:00
}
setRect(boundRect);
2011-08-14 04:09:11 +02:00
}
2012-04-09 22:52:39 +02:00
void UIWidget::internalDestroy()
2011-08-14 04:09:11 +02:00
{
m_destroyed = true;
2012-04-09 22:52:39 +02:00
m_visible = false;
m_enabled = false;
m_focusedChild = nullptr;
if(m_layout) {
m_layout->setParent(nullptr);
m_layout = nullptr;
}
m_parent = nullptr;
2012-04-09 22:52:39 +02:00
m_lockedChildren.clear();
for(const UIWidgetPtr& child : m_children)
child->internalDestroy();
m_children.clear();
callLuaField("onDestroy");
2011-08-22 21:13:52 +02:00
releaseLuaFieldsTable();
g_ui.onWidgetDestroy(static_self_cast<UIWidget>());
}
2012-04-09 22:52:39 +02:00
void UIWidget::destroy()
{
if(m_destroyed)
2012-06-01 22:39:23 +02:00
g_logger.warning(stdext::format("attempt to destroy widget '%s' two times", m_id));
2012-04-09 22:52:39 +02:00
// hold itself reference
UIWidgetPtr self = static_self_cast<UIWidget>();
2012-04-09 22:52:39 +02:00
m_destroyed = true;
// remove itself from parent
if(UIWidgetPtr parent = getParent())
parent->removeChild(self);
internalDestroy();
}
2012-02-06 02:44:47 +01:00
void UIWidget::destroyChildren()
{
2012-04-09 22:52:39 +02:00
UILayoutPtr layout = getLayout();
if(layout)
layout->disableUpdates();
m_focusedChild = nullptr;
m_lockedChildren.clear();
while(!m_children.empty()) {
UIWidgetPtr child = m_children.front();
m_children.pop_front();
child->setParent(nullptr);
m_layout->removeWidget(child);
child->destroy();
}
2012-04-09 22:52:39 +02:00
2013-01-08 21:01:47 +01:00
if(layout)
layout->enableUpdates();
2012-02-06 02:44:47 +01:00
}
void UIWidget::setId(const std::string& id)
2011-08-14 04:09:11 +02:00
{
2012-06-21 21:31:22 +02:00
if(id != m_id) {
m_id = id;
callLuaField("onIdChange", id);
}
2011-08-14 04:09:11 +02:00
}
void UIWidget::setParent(const UIWidgetPtr& parent)
2011-08-20 22:30:41 +02:00
{
// remove from old parent
UIWidgetPtr oldParent = getParent();
2011-08-20 22:30:41 +02:00
// the parent is already the same
if(oldParent == parent)
return;
2011-08-20 22:30:41 +02:00
UIWidgetPtr self = static_self_cast<UIWidget>();
if(oldParent && oldParent->hasChild(self))
oldParent->removeChild(self);
2011-08-20 22:30:41 +02:00
// reset parent
m_parent.reset();
// set new parent
if(parent) {
m_parent = parent;
// add to parent if needed
if(!parent->hasChild(self))
parent->addChild(self);
}
2011-08-20 22:30:41 +02:00
}
void UIWidget::setLayout(const UILayoutPtr& layout)
2011-08-14 04:09:11 +02:00
{
2013-01-08 21:01:47 +01:00
if(!layout)
stdext::throw_exception("attempt to set a nil layout to a widget");
if(m_layout)
m_layout->disableUpdates();
2011-08-14 04:09:11 +02:00
layout->setParent(static_self_cast<UIWidget>());
layout->disableUpdates();
2011-08-22 21:13:52 +02:00
for(const UIWidgetPtr& child : m_children) {
if(m_layout)
m_layout->removeWidget(child);
layout->addWidget(child);
2011-08-22 21:13:52 +02:00
}
if(m_layout) {
m_layout->enableUpdates();
m_layout->setParent(nullptr);
m_layout->update();
2011-08-22 21:13:52 +02:00
}
2011-08-14 04:09:11 +02:00
layout->enableUpdates();
m_layout = layout;
2011-08-14 04:09:11 +02:00
}
bool UIWidget::setRect(const Rect& rect)
2011-08-29 04:18:13 +02:00
{
2012-07-15 07:46:56 +02:00
/*
2012-03-23 04:06:00 +01:00
if(rect.width() > 8192 || rect.height() > 8192) {
2012-06-01 22:39:23 +02:00
g_logger.error(stdext::format("attempt to set huge rect size (%s) for %s", stdext::to_string(rect), m_id));
return false;
2012-03-23 04:06:00 +01:00
}
2012-07-15 07:46:56 +02:00
*/
// only update if the rect really changed
Rect oldRect = m_rect;
if(rect == oldRect)
return false;
2011-08-29 04:18:13 +02:00
m_rect = rect;
2011-08-29 04:18:13 +02:00
// updates own layout
updateLayout();
2011-08-29 04:18:13 +02:00
// avoid massive update events
if(!m_updateEventScheduled) {
UIWidgetPtr self = static_self_cast<UIWidget>();
2012-06-26 00:13:30 +02:00
g_dispatcher.addEvent([self, oldRect]() {
self->m_updateEventScheduled = false;
if(oldRect != self->getRect())
self->onGeometryChange(oldRect, self->getRect());
});
m_updateEventScheduled = true;
}
// update hovered widget when moved behind mouse area
if(containsPoint(g_window.getMousePosition()))
g_ui.updateHoveredWidget();
return true;
2011-08-29 04:18:13 +02:00
}
void UIWidget::setStyle(const std::string& styleName)
2011-08-14 04:09:11 +02:00
{
OTMLNodePtr styleNode = g_ui.getStyle(styleName);
if(!styleNode) {
2012-06-01 22:39:23 +02:00
g_logger.traceError(stdext::format("unable to retrieve style '%s': not a defined style", styleName));
2011-08-22 21:13:52 +02:00
return;
}
styleNode = styleNode->clone();
applyStyle(styleNode);
m_style = styleNode;
updateStyle();
2011-08-14 04:09:11 +02:00
}
void UIWidget::setStyleFromNode(const OTMLNodePtr& styleNode)
{
applyStyle(styleNode);
m_style = styleNode;
updateStyle();
}
void UIWidget::setEnabled(bool enabled)
{
if(enabled != m_enabled) {
m_enabled = enabled;
updateState(Fw::DisabledState);
updateState(Fw::ActiveState);
}
}
void UIWidget::setVisible(bool visible)
{
if(m_visible != visible) {
m_visible = visible;
2011-08-20 22:30:41 +02:00
// hiding a widget make it lose focus
if(!visible && isFocused()) {
if(UIWidgetPtr parent = getParent())
parent->focusPreviousChild(Fw::ActiveFocusReason);
}
// visibility can change change parent layout
2012-01-23 14:47:15 +01:00
updateParentLayout();
updateState(Fw::ActiveState);
2013-01-08 21:01:47 +01:00
updateState(Fw::HiddenState);
2012-02-09 19:38:50 +01:00
// visibility can change the current hovered widget
if(visible)
g_ui.onWidgetAppear(static_self_cast<UIWidget>());
2012-02-09 19:38:50 +01:00
else
g_ui.onWidgetDisappear(static_self_cast<UIWidget>());
}
}
void UIWidget::setOn(bool on)
{
setState(Fw::OnState, on);
}
void UIWidget::setChecked(bool checked)
{
if(setState(Fw::CheckedState, checked))
callLuaField("onCheckChange", checked);
}
2011-08-20 22:30:41 +02:00
void UIWidget::setFocusable(bool focusable)
{
if(m_focusable != focusable) {
m_focusable = focusable;
2011-08-22 21:13:52 +02:00
// make parent focus another child
if(!focusable && isFocused()) {
if(UIWidgetPtr parent = getParent())
parent->focusPreviousChild(Fw::ActiveFocusReason);
2011-08-22 21:13:52 +02:00
}
}
}
2011-08-29 20:38:01 +02:00
void UIWidget::setPhantom(bool phantom)
{
m_phantom = phantom;
}
2011-08-29 20:38:01 +02:00
2012-08-07 01:43:14 +02:00
void UIWidget::setDraggable(bool draggable)
2012-01-20 02:16:10 +01:00
{
2012-08-07 01:43:14 +02:00
m_draggable = draggable;
2012-01-20 02:16:10 +01:00
}
void UIWidget::setFixedSize(bool fixed)
{
m_fixedSize = fixed;
updateParentLayout();
}
void UIWidget::setLastFocusReason(Fw::FocusReason reason)
{
m_lastFocusReason = reason;
}
void UIWidget::setVirtualOffset(const Point& offset)
{
m_virtualOffset = offset;
if(m_layout)
m_layout->update();
}
bool UIWidget::isAnchored()
{
if(UIWidgetPtr parent = getParent())
if(UIAnchorLayoutPtr anchorLayout = parent->getAnchoredLayout())
return anchorLayout->hasAnchors(static_self_cast<UIWidget>());
return false;
}
2011-08-29 20:38:01 +02:00
bool UIWidget::isChildLocked(const UIWidgetPtr& child)
{
auto it = std::find(m_lockedChildren.begin(), m_lockedChildren.end(), child);
return it != m_lockedChildren.end();
}
bool UIWidget::hasChild(const UIWidgetPtr& child)
{
auto it = std::find(m_children.begin(), m_children.end(), child);
if(it != m_children.end())
return true;
return false;
}
int UIWidget::getChildIndex(const UIWidgetPtr& child)
{
int index = 1;
for(auto it = m_children.begin(); it != m_children.end(); ++it) {
if(*it == child)
return index;
++index;
}
return -1;
}
2012-06-02 02:38:26 +02:00
Rect UIWidget::getPaddingRect()
{
Rect rect = m_rect;
rect.expand(-m_padding.top, -m_padding.right, -m_padding.bottom, -m_padding.left);
return rect;
}
Rect UIWidget::getMarginRect()
{
Rect rect = m_rect;
rect.expand(m_margin.top, m_margin.right, m_margin.bottom, m_margin.left);
return rect;
}
Rect UIWidget::getChildrenRect()
{
Rect childrenRect;
for(const UIWidgetPtr& child : m_children) {
if(!child->isExplicitlyVisible() || !child->getRect().isValid())
continue;
Rect marginRect = child->getMarginRect();
if(!childrenRect.isValid())
childrenRect = marginRect;
else
childrenRect = childrenRect.united(marginRect);
}
2012-06-02 02:38:26 +02:00
Rect myClippingRect = getPaddingRect();
if(!childrenRect.isValid())
childrenRect = myClippingRect;
else {
if(childrenRect.width() < myClippingRect.width())
childrenRect.setWidth(myClippingRect.width());
if(childrenRect.height() < myClippingRect.height())
childrenRect.setHeight(myClippingRect.height());
}
return childrenRect;
}
UIAnchorLayoutPtr UIWidget::getAnchoredLayout()
{
UIWidgetPtr parent = getParent();
2012-01-19 05:12:53 +01:00
if(!parent)
return nullptr;
UILayoutPtr layout = parent->getLayout();
if(layout->isUIAnchorLayout())
return layout->static_self_cast<UIAnchorLayout>();
return nullptr;
}
UIWidgetPtr UIWidget::getRootParent()
2011-08-14 04:09:11 +02:00
{
if(UIWidgetPtr parent = getParent())
return parent->getRootParent();
else
return static_self_cast<UIWidget>();
2011-08-14 04:09:11 +02:00
}
UIWidgetPtr UIWidget::getChildAfter(const UIWidgetPtr& relativeChild)
2011-08-14 04:09:11 +02:00
{
auto it = std::find(m_children.begin(), m_children.end(), relativeChild);
if(it != m_children.end() && ++it != m_children.end())
return *it;
return nullptr;
}
UIWidgetPtr UIWidget::getChildBefore(const UIWidgetPtr& relativeChild)
{
auto it = std::find(m_children.rbegin(), m_children.rend(), relativeChild);
if(it != m_children.rend() && ++it != m_children.rend())
return *it;
return nullptr;
2011-08-14 04:09:11 +02:00
}
UIWidgetPtr UIWidget::getChildById(const std::string& childId)
{
for(const UIWidgetPtr& child : m_children) {
if(child->getId() == childId)
return child;
}
return nullptr;
}
2012-01-06 20:25:27 +01:00
UIWidgetPtr UIWidget::getChildByPos(const Point& childPos)
{
2012-06-11 16:10:03 +02:00
if(!containsPaddingPoint(childPos))
return nullptr;
for(auto it = m_children.rbegin(); it != m_children.rend(); ++it) {
2012-02-06 20:19:47 +01:00
const UIWidgetPtr& child = (*it);
if(child->isExplicitlyVisible() && child->containsPoint(childPos))
return child;
}
return nullptr;
}
UIWidgetPtr UIWidget::getChildByIndex(int index)
{
index = index <= 0 ? (m_children.size() + index) : index-1;
if(index >= 0 && (uint)index < m_children.size())
return m_children.at(index);
return nullptr;
}
UIWidgetPtr UIWidget::recursiveGetChildById(const std::string& id)
{
UIWidgetPtr widget = getChildById(id);
if(!widget) {
for(const UIWidgetPtr& child : m_children) {
widget = child->recursiveGetChildById(id);
if(widget)
break;
2012-01-06 20:25:27 +01:00
}
}
return widget;
}
2012-01-06 20:25:27 +01:00
UIWidgetPtr UIWidget::recursiveGetChildByPos(const Point& childPos, bool wantsPhantom)
{
2012-06-11 16:10:03 +02:00
if(!containsPaddingPoint(childPos))
return nullptr;
2012-02-06 20:19:47 +01:00
for(auto it = m_children.rbegin(); it != m_children.rend(); ++it) {
const UIWidgetPtr& child = (*it);
if(child->isExplicitlyVisible() && child->containsPoint(childPos)) {
UIWidgetPtr subChild = child->recursiveGetChildByPos(childPos, wantsPhantom);
if(subChild)
return subChild;
else if(wantsPhantom || !child->isPhantom())
return child;
}
}
return nullptr;
}
2012-07-26 08:10:28 +02:00
UIWidgetList UIWidget::recursiveGetChildren()
{
UIWidgetList children;
for(const UIWidgetPtr& child : m_children) {
UIWidgetList subChildren = child->recursiveGetChildren();
if(!subChildren.empty())
children.insert(children.end(), subChildren.begin(), subChildren.end());
children.push_back(child);
}
return children;
}
2012-02-07 01:41:53 +01:00
UIWidgetList UIWidget::recursiveGetChildrenByPos(const Point& childPos)
{
UIWidgetList children;
2012-06-11 16:10:03 +02:00
if(!containsPaddingPoint(childPos))
return children;
2012-02-07 01:41:53 +01:00
for(auto it = m_children.rbegin(); it != m_children.rend(); ++it) {
const UIWidgetPtr& child = (*it);
if(child->isExplicitlyVisible() && child->containsPoint(childPos)) {
UIWidgetList subChildren = child->recursiveGetChildrenByPos(childPos);
if(!subChildren.empty())
children.insert(children.end(), subChildren.begin(), subChildren.end());
children.push_back(child);
2012-02-07 01:41:53 +01:00
}
}
return children;
}
2012-06-11 16:10:03 +02:00
UIWidgetList UIWidget::recursiveGetChildrenByMarginPos(const Point& childPos)
{
UIWidgetList children;
if(!containsPaddingPoint(childPos))
return children;
for(auto it = m_children.rbegin(); it != m_children.rend(); ++it) {
const UIWidgetPtr& child = (*it);
if(child->isExplicitlyVisible() && child->containsMarginPoint(childPos)) {
UIWidgetList subChildren = child->recursiveGetChildrenByMarginPos(childPos);
if(!subChildren.empty())
children.insert(children.end(), subChildren.begin(), subChildren.end());
children.push_back(child);
}
}
return children;
}
UIWidgetPtr UIWidget::backwardsGetWidgetById(const std::string& id)
{
UIWidgetPtr widget = getChildById(id);
if(!widget) {
if(UIWidgetPtr parent = getParent())
widget = parent->backwardsGetWidgetById(id);
}
return widget;
}
bool UIWidget::setState(Fw::WidgetState state, bool on)
2011-11-16 00:47:32 +01:00
{
if(state == Fw::InvalidState)
return false;
2011-11-16 00:47:32 +01:00
int oldStates = m_states;
if(on)
m_states |= state;
else
m_states &= ~state;
if(oldStates != m_states) {
2011-11-16 00:47:32 +01:00
updateStyle();
return true;
}
return false;
2011-11-16 00:47:32 +01:00
}
bool UIWidget::hasState(Fw::WidgetState state)
{
if(state == Fw::InvalidState)
return false;
return (m_states & state);
}
void UIWidget::updateState(Fw::WidgetState state)
2011-08-14 04:09:11 +02:00
{
if(m_destroyed)
return;
bool newStatus = true;
bool oldStatus = hasState(state);
bool updateChildren = false;
2011-08-14 04:09:11 +02:00
switch(state) {
case Fw::ActiveState: {
UIWidgetPtr widget = static_self_cast<UIWidget>();
UIWidgetPtr parent;
do {
parent = widget->getParent();
if(!widget->isExplicitlyEnabled() ||
2012-01-06 09:48:59 +01:00
((parent && parent->getFocusedChild() != widget))) {
newStatus = false;
break;
}
} while((widget = parent));
2012-02-09 19:38:50 +01:00
updateChildren = newStatus != oldStatus;
break;
}
case Fw::FocusState: {
newStatus = (getParent() && getParent()->getFocusedChild() == static_self_cast<UIWidget>());
break;
}
case Fw::HoverState: {
newStatus = (g_ui.getHoveredWidget() == static_self_cast<UIWidget>() && isEnabled());
break;
}
case Fw::PressedState: {
newStatus = (g_ui.getPressedWidget() == static_self_cast<UIWidget>());
break;
}
case Fw::DraggingState: {
newStatus = (g_ui.getDraggingWidget() == static_self_cast<UIWidget>());
break;
}
case Fw::DisabledState: {
bool enabled = true;
UIWidgetPtr widget = static_self_cast<UIWidget>();
do {
if(!widget->isExplicitlyEnabled()) {
enabled = false;
break;
}
} while((widget = widget->getParent()));
newStatus = !enabled;
2012-02-09 19:38:50 +01:00
updateChildren = newStatus != oldStatus;
break;
}
case Fw::FirstState: {
newStatus = (getParent() && getParent()->getFirstChild() == static_self_cast<UIWidget>());
break;
}
case Fw::MiddleState: {
newStatus = (getParent() && getParent()->getFirstChild() != static_self_cast<UIWidget>() && getParent()->getLastChild() != static_self_cast<UIWidget>());
break;
}
case Fw::LastState: {
newStatus = (getParent() && getParent()->getLastChild() == static_self_cast<UIWidget>());
break;
}
case Fw::AlternateState: {
newStatus = (getParent() && (getParent()->getChildIndex(static_self_cast<UIWidget>()) % 2) == 1);
break;
}
2013-01-08 21:01:47 +01:00
case Fw::HiddenState: {
bool visible = true;
UIWidgetPtr widget = static_self_cast<UIWidget>();
do {
if(!widget->isExplicitlyVisible()) {
visible = false;
break;
}
} while((widget = widget->getParent()));
newStatus = !visible;
updateChildren = newStatus != oldStatus;
break;
}
default:
return;
2011-08-21 21:43:05 +02:00
}
2012-02-09 19:38:50 +01:00
if(updateChildren) {
// do a backup of children list, because it may change while looping it
UIWidgetList children = m_children;
for(const UIWidgetPtr& child : children)
child->updateState(state);
}
2012-02-09 19:38:50 +01:00
if(setState(state, newStatus)) {
2012-03-26 15:34:43 +02:00
// disabled widgets cannot have hover state
if(state == Fw::DisabledState && !newStatus && isHovered()) {
g_ui.updateHoveredWidget();
2013-01-08 21:01:47 +01:00
} else if(state == Fw::HiddenState) {
onVisibilityChange(!newStatus);
2012-03-26 15:34:43 +02:00
}
}
2011-08-21 21:43:05 +02:00
}
void UIWidget::updateStates()
2011-08-21 21:43:05 +02:00
{
if(m_destroyed)
return;
2012-01-05 19:02:27 +01:00
for(int state = 1; state != Fw::LastWidgetState; state <<= 1)
2011-11-16 00:47:32 +01:00
updateState((Fw::WidgetState)state);
2011-08-21 21:43:05 +02:00
}
void UIWidget::updateChildrenIndexStates()
{
if(m_destroyed)
return;
for(const UIWidgetPtr& child : m_children) {
child->updateState(Fw::FirstState);
child->updateState(Fw::MiddleState);
child->updateState(Fw::LastState);
child->updateState(Fw::AlternateState);
}
}
void UIWidget::updateStyle()
2011-08-21 21:43:05 +02:00
{
if(m_destroyed)
return;
2012-01-05 19:02:27 +01:00
if(m_loadingStyle && !m_updateStyleScheduled) {
UIWidgetPtr self = static_self_cast<UIWidget>();
2012-06-26 00:13:30 +02:00
g_dispatcher.addEvent([self] {
2012-01-05 19:02:27 +01:00
self->m_updateStyleScheduled = false;
self->updateStyle();
});
m_updateStyleScheduled = true;
return;
}
if(!m_style)
return;
2011-08-21 21:43:05 +02:00
OTMLNodePtr newStateStyle = OTMLNode::create();
2011-08-21 21:43:05 +02:00
// copy only the changed styles from default style
if(m_stateStyle) {
for(OTMLNodePtr node : m_stateStyle->children()) {
if(OTMLNodePtr otherNode = m_style->get(node->tag()))
newStateStyle->addChild(otherNode->clone());
2011-08-21 21:43:05 +02:00
}
}
2011-11-16 00:47:32 +01:00
// checks for states combination
for(const OTMLNodePtr& style : m_style->children()) {
if(stdext::starts_with(style->tag(), "$")) {
2011-11-16 00:47:32 +01:00
std::string statesStr = style->tag().substr(1);
std::vector<std::string> statesSplit = stdext::split(statesStr, " ");
2011-08-21 21:43:05 +02:00
2011-11-16 00:47:32 +01:00
bool match = true;
for(std::string stateStr : statesSplit) {
if(stateStr.length() == 0)
continue;
2011-08-21 21:43:05 +02:00
2011-11-16 00:47:32 +01:00
bool notstate = (stateStr[0] == '!');
if(notstate)
stateStr = stateStr.substr(1);
2011-08-21 21:43:05 +02:00
2011-11-16 00:47:32 +01:00
bool stateOn = hasState(Fw::translateState(stateStr));
if((!notstate && !stateOn) || (notstate && stateOn))
match = false;
}
2011-08-23 03:08:36 +02:00
2011-11-16 00:47:32 +01:00
// merge states styles
2011-11-16 06:23:16 +01:00
if(match) {
2011-11-16 00:47:32 +01:00
newStateStyle->merge(style);
2011-11-16 06:23:16 +01:00
}
2011-11-16 00:47:32 +01:00
}
}
2011-08-21 21:43:05 +02:00
2011-11-16 22:00:40 +01:00
//TODO: prevent setting already set proprieties
applyStyle(newStateStyle);
m_stateStyle = newStateStyle;
2011-08-21 21:43:05 +02:00
}
void UIWidget::onStyleApply(const std::string& styleName, const OTMLNodePtr& styleNode)
2011-08-22 21:13:52 +02:00
{
if(m_destroyed)
return;
// first set id
if(const OTMLNodePtr& node = styleNode->get("id"))
setId(node->value());
2011-08-22 21:13:52 +02:00
parseBaseStyle(styleNode);
parseImageStyle(styleNode);
parseTextStyle(styleNode);
2012-06-02 20:58:30 +02:00
g_app.repaint();
2011-08-22 21:13:52 +02:00
}
2012-01-05 03:42:17 +01:00
void UIWidget::onGeometryChange(const Rect& oldRect, const Rect& newRect)
2011-08-22 14:44:26 +02:00
{
if(m_textWrap && oldRect.size() != newRect.size())
updateText();
// move children that is outside the parent rect to inside again
2012-04-03 16:15:11 +02:00
for(const UIWidgetPtr& child : m_children) {
2013-01-08 21:01:47 +01:00
if(!child->isAnchored() && child->isVisible())
2012-04-03 16:15:11 +02:00
child->bindRectToParent();
}
2012-04-11 04:59:05 +02:00
callLuaField("onGeometryChange", oldRect, newRect);
2012-06-02 20:58:30 +02:00
g_app.repaint();
2011-08-22 14:44:26 +02:00
}
void UIWidget::onLayoutUpdate()
{
callLuaField("onLayoutUpdate");
}
void UIWidget::onFocusChange(bool focused, Fw::FocusReason reason)
2011-08-21 03:01:46 +02:00
{
callLuaField("onFocusChange", focused, reason);
2011-08-21 03:01:46 +02:00
}
2012-02-06 02:44:47 +01:00
void UIWidget::onChildFocusChange(const UIWidgetPtr& focusedChild, const UIWidgetPtr& unfocusedChild, Fw::FocusReason reason)
{
callLuaField("onChildFocusChange", focusedChild, unfocusedChild, reason);
}
2011-08-22 14:44:26 +02:00
void UIWidget::onHoverChange(bool hovered)
2011-08-14 04:09:11 +02:00
{
callLuaField("onHoverChange", hovered);
2011-08-22 14:44:26 +02:00
}
2013-01-08 21:01:47 +01:00
void UIWidget::onVisibilityChange(bool visible)
{
if(!isAnchored())
bindRectToParent();
callLuaField("onVisibilityChange", visible);
}
2012-02-09 19:38:50 +01:00
bool UIWidget::onDragEnter(const Point& mousePos)
2012-01-20 02:16:10 +01:00
{
2012-02-09 19:38:50 +01:00
return callLuaField<bool>("onDragEnter", mousePos);
2012-01-20 02:16:10 +01:00
}
2012-03-23 23:48:18 +01:00
bool UIWidget::onDragLeave(UIWidgetPtr droppedWidget, const Point& mousePos)
2012-01-20 02:16:10 +01:00
{
2012-03-23 23:48:18 +01:00
return callLuaField<bool>("onDragLeave", droppedWidget, mousePos);
2012-01-20 02:16:10 +01:00
}
2012-02-07 01:41:53 +01:00
bool UIWidget::onDragMove(const Point& mousePos, const Point& mouseMoved)
{
2012-03-26 15:34:43 +02:00
return callLuaField<bool>("onDragMove", mousePos, mouseMoved);
2012-02-07 01:41:53 +01:00
}
2012-02-07 03:06:48 +01:00
bool UIWidget::onDrop(UIWidgetPtr draggedWidget, const Point& mousePos)
2012-01-20 02:16:10 +01:00
{
2012-02-07 03:06:48 +01:00
return callLuaField<bool>("onDrop", draggedWidget, mousePos);
2012-01-20 02:16:10 +01:00
}
bool UIWidget::onKeyText(const std::string& keyText)
2011-08-22 14:44:26 +02:00
{
return callLuaField<bool>("onKeyText", keyText);
2012-01-05 03:42:17 +01:00
}
bool UIWidget::onKeyDown(uchar keyCode, int keyboardModifiers)
2012-01-05 03:42:17 +01:00
{
return callLuaField<bool>("onKeyDown", keyCode, keyboardModifiers);
}
bool UIWidget::onKeyPress(uchar keyCode, int keyboardModifiers, int autoRepeatTicks)
{
return callLuaField<bool>("onKeyPress", keyCode, keyboardModifiers, autoRepeatTicks);
}
2012-01-17 07:24:58 +01:00
bool UIWidget::onKeyUp(uchar keyCode, int keyboardModifiers)
{
2012-01-17 07:24:58 +01:00
return callLuaField<bool>("onKeyUp", keyCode, keyboardModifiers);
2012-01-05 03:42:17 +01:00
}
2012-01-05 03:42:17 +01:00
bool UIWidget::onMousePress(const Point& mousePos, Fw::MouseButton button)
{
if(button == Fw::MouseLeftButton) {
if(m_clickTimer.running() && m_clickTimer.ticksElapsed() <= 200) {
if(onDoubleClick(mousePos))
return true;
m_clickTimer.stop();
} else
m_clickTimer.restart();
2012-03-26 20:33:00 +02:00
m_lastClickPosition = mousePos;
}
2012-02-07 05:55:20 +01:00
2012-04-07 05:37:29 +02:00
if(hasLuaField("onMousePress"))
2012-02-07 05:55:20 +01:00
return callLuaField<bool>("onMousePress", mousePos, button);
2012-04-07 05:37:29 +02:00
return false;
2012-01-05 03:42:17 +01:00
}
bool UIWidget::onMouseRelease(const Point& mousePos, Fw::MouseButton button)
2012-01-05 03:42:17 +01:00
{
return callLuaField<bool>("onMouseRelease", mousePos, button);
2012-01-05 03:42:17 +01:00
}
bool UIWidget::onMouseMove(const Point& mousePos, const Point& mouseMoved)
{
return callLuaField<bool>("onMouseMove", mousePos, mouseMoved);
}
bool UIWidget::onMouseWheel(const Point& mousePos, Fw::MouseWheelDirection direction)
{
return callLuaField<bool>("onMouseWheel", mousePos, direction);
}
2012-02-06 02:44:47 +01:00
bool UIWidget::onClick(const Point& mousePos)
{
if(hasLuaField("onClick")) {
callLuaField("onClick", mousePos);
return true;
}
return false;
2012-02-06 02:44:47 +01:00
}
bool UIWidget::onDoubleClick(const Point& mousePos)
{
if(hasLuaField("onDoubleClick")) {
callLuaField("onDoubleClick", mousePos);
return true;
}
return false;
}
bool UIWidget::propagateOnKeyText(const std::string& keyText)
{
// do a backup of children list, because it may change while looping it
UIWidgetList children;
for(const UIWidgetPtr& child : m_children) {
// events on hidden or disabled widgets are discarded
if(!child->isExplicitlyEnabled() || !child->isExplicitlyVisible())
continue;
// key events go only to containers or focused child
if(child->isFocused())
children.push_back(child);
}
for(const UIWidgetPtr& child : children) {
if(child->propagateOnKeyText(keyText))
return true;
}
return onKeyText(keyText);
}
bool UIWidget::propagateOnKeyDown(uchar keyCode, int keyboardModifiers)
{
// do a backup of children list, because it may change while looping it
UIWidgetList children;
for(const UIWidgetPtr& child : m_children) {
// events on hidden or disabled widgets are discarded
if(!child->isExplicitlyEnabled() || !child->isExplicitlyVisible())
continue;
// key events go only to containers or focused child
if(child->isFocused())
children.push_back(child);
}
for(const UIWidgetPtr& child : children) {
if(child->propagateOnKeyDown(keyCode, keyboardModifiers))
return true;
}
return onKeyDown(keyCode, keyboardModifiers);
}
bool UIWidget::propagateOnKeyPress(uchar keyCode, int keyboardModifiers, int autoRepeatTicks)
2012-01-05 03:42:17 +01:00
{
2011-08-14 04:09:11 +02:00
// do a backup of children list, because it may change while looping it
UIWidgetList children;
for(const UIWidgetPtr& child : m_children) {
2011-08-22 21:13:52 +02:00
// events on hidden or disabled widgets are discarded
2011-08-21 03:01:46 +02:00
if(!child->isExplicitlyEnabled() || !child->isExplicitlyVisible())
2011-08-14 04:09:11 +02:00
continue;
2011-08-14 04:09:11 +02:00
// key events go only to containers or focused child
if(child->isFocused())
children.push_back(child);
}
for(const UIWidgetPtr& child : children) {
if(child->propagateOnKeyPress(keyCode, keyboardModifiers, autoRepeatTicks))
return true;
2011-08-14 04:09:11 +02:00
}
2011-08-22 14:44:26 +02:00
2012-02-06 20:19:47 +01:00
if(autoRepeatTicks == 0 || autoRepeatTicks >= m_autoRepeatDelay)
return onKeyPress(keyCode, keyboardModifiers, autoRepeatTicks);
2012-02-06 20:19:47 +01:00
else
return false;
2011-08-14 04:09:11 +02:00
}
2012-01-17 07:24:58 +01:00
bool UIWidget::propagateOnKeyUp(uchar keyCode, int keyboardModifiers)
2011-08-14 04:09:11 +02:00
{
// do a backup of children list, because it may change while looping it
UIWidgetList children;
for(const UIWidgetPtr& child : m_children) {
2011-08-22 21:13:52 +02:00
// events on hidden or disabled widgets are discarded
2011-08-21 03:01:46 +02:00
if(!child->isExplicitlyEnabled() || !child->isExplicitlyVisible())
2011-08-14 04:09:11 +02:00
continue;
// key events go only to focused child
if(child->isFocused())
children.push_back(child);
}
for(const UIWidgetPtr& child : children) {
2012-01-17 07:24:58 +01:00
if(child->propagateOnKeyUp(keyCode, keyboardModifiers))
return true;
2011-08-14 04:09:11 +02:00
}
2011-08-22 14:44:26 +02:00
2012-01-17 07:24:58 +01:00
return onKeyUp(keyCode, keyboardModifiers);
2011-08-14 04:09:11 +02:00
}
2012-03-28 13:46:15 +02:00
bool UIWidget::propagateOnMouseEvent(const Point& mousePos, UIWidgetList& widgetList)
{
bool ret = false;
2012-06-11 16:10:03 +02:00
if(containsPaddingPoint(mousePos)) {
2012-03-28 13:46:15 +02:00
for(auto it = m_children.rbegin(); it != m_children.rend(); ++it) {
const UIWidgetPtr& child = *it;
if(child->isExplicitlyEnabled() && child->isExplicitlyVisible() && child->containsPoint(mousePos)) {
if(child->propagateOnMouseEvent(mousePos, widgetList)) {
ret = true;
break;
}
}
2012-01-19 05:12:53 +01:00
}
}
widgetList.push_back(static_self_cast<UIWidget>());
if(!isPhantom())
2012-03-28 13:46:15 +02:00
ret = true;
return ret;
2011-08-14 04:09:11 +02:00
}
2012-03-28 13:46:15 +02:00
bool UIWidget::propagateOnMouseMove(const Point& mousePos, const Point& mouseMoved, UIWidgetList& widgetList)
2011-08-14 04:09:11 +02:00
{
2012-03-28 13:46:15 +02:00
for(auto it = m_children.begin(); it != m_children.end(); ++it) {
const UIWidgetPtr& child = *it;
if(child->isExplicitlyVisible() && child->isExplicitlyEnabled())
child->propagateOnMouseMove(mousePos, mouseMoved, widgetList);
}
widgetList.push_back(static_self_cast<UIWidget>());
2012-03-28 13:46:15 +02:00
return true;
2011-08-14 04:09:11 +02:00
}