gesche
/
tibia-client
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

remake widgets's anchor layouts

Browse Source
master
Eduardo Bart 13 years ago
parent b410921e32
commit f266b9fbc6
23 changed files with 365 additions and 364 deletions
Show Stats Download Patch File Download Diff File

1
CMakeLists.txt
Unescape View File

@ -128,7 +128,6 @@ SET(SOURCES
src/framework/ui/uibutton.cpp
src/framework/ui/uilineedit.cpp
src/framework/ui/uiwindow.cpp
src/framework/ui/uianchorlayout.cpp
src/framework/ui/uianchor.cpp
src/framework/ui/uilist.cpp
)

2
modules/core/constants.lua
Unescape View File

@ -1,4 +1,4 @@
-- AnchorPoint
-- AnchorEdge
AnchorNone = 0
AnchorTop = 1
AnchorBottom = 2

2
src/framework/const.h
Unescape View File

@ -29,7 +29,7 @@ enum AlignmentFlag {
AlignCenter = AlignVerticalCenter | AlignHorizontalCenter
};
enum AnchorPoint {
enum AnchorEdge {
AnchorNone = 0,
AnchorTop,
AnchorBottom,

14
src/framework/ui/declarations.h
Unescape View File

@ -5,27 +5,23 @@
#include "const.h"
class UIManager;
class UILayout;
class UIAnchorLayout;
class UIStyle;
class UIAnchor;
class UIWidget;
class UILabel;
class UIButton;
class UILineEdit;
class UIWindow;
class UIConsole;
typedef std::shared_ptr<UIWidget> UIWidgetPtr;
typedef std::weak_ptr<UIWidget> UIWidgetWeakPtr;
typedef std::deque<UIWidgetPtr> UIWidgetList;
typedef std::shared_ptr<UILayout> UILayoutPtr;
typedef std::shared_ptr<UIAnchorLayout> UIAnchorLayoutPtr;
typedef std::shared_ptr<UIStyle> UIStylePtr;
typedef std::shared_ptr<UILabel> UILabelPtr;
typedef std::shared_ptr<UIButton> UIButtonPtr;
typedef std::shared_ptr<UILineEdit> UILineEditPtr;
typedef std::shared_ptr<UIWindow> UIWindowPtr;
typedef std::shared_ptr<UIConsole> UIConsolePtr;
typedef std::vector<UIAnchor> UIAnchorList;
typedef std::deque<UIWidgetPtr> UIWidgetList;
typedef std::deque<UIWidgetWeakPtr> UIWeakWidgetList;
#endif

1
src/framework/ui/ui.h
Unescape View File

@ -5,7 +5,6 @@
#include "uiwidget.h"
#include "uibutton.h"
#include "uilabel.h"
#include "uilayout.h"
#include "uilineedit.h"
#include "uiwindow.h"

44
src/framework/ui/uianchor.cpp
Unescape View File

@ -1,45 +1,31 @@
#include "uianchor.h"
#include "uiwidget.h"
UIAnchor::UIAnchor(const UIWidgetPtr& anchoredWidget, AnchorPoint anchoredEdge, const AnchorLine& anchorLine)
: m_anchoredWidget(anchoredWidget), m_anchoredEdge(anchoredEdge), m_anchorLine(anchorLine) {
UIAnchor::UIAnchor(AnchorEdge anchoredEdge, const std::string& hookedWidgetId, AnchorEdge hookedEdge) :
m_anchoredEdge(anchoredEdge), m_hookedWidgetId(hookedWidgetId), m_hookedEdge(hookedEdge) {
}
UIWidgetPtr UIAnchor::getAnchorLineWidget() const {
UIWidgetPtr anchoredWidget = m_anchoredWidget.lock();
if(anchoredWidget && !anchoredWidget->isDestroyed())
return anchoredWidget->backwardsGetWidgetById(m_anchorLine.widgetId);
return nullptr;
}
UIWidgetPtr UIAnchor::getAnchoredWidget() const {
return m_anchoredWidget.lock();
}
int UIAnchor::getHookedPoint() const {
UIWidgetPtr hookedWidget = getHookedWidget();
AnchorPoint UIAnchor::getAnchoredEdge() const {
return m_anchoredEdge;
}
int UIAnchor::getAnchorLinePoint() const {
UIWidgetPtr anchorLineWidget = getAnchorLineWidget();
if(anchorLineWidget) {
switch(m_anchorLine.edge) {
if(hookedWidget) {
switch(m_hookedEdge) {
case AnchorLeft:
return anchorLineWidget->getGeometry().left();
return hookedWidget->getRect().left();
case AnchorRight:
return anchorLineWidget->getGeometry().right();
return hookedWidget->getRect().right();
case AnchorTop:
return anchorLineWidget->getGeometry().top();
return hookedWidget->getRect().top();
case AnchorBottom:
return anchorLineWidget->getGeometry().bottom();
return hookedWidget->getRect().bottom();
case AnchorHorizontalCenter:
return anchorLineWidget->getGeometry().horizontalCenter();
return hookedWidget->getRect().horizontalCenter();
case AnchorVerticalCenter:
return anchorLineWidget->getGeometry().verticalCenter();
return hookedWidget->getRect().verticalCenter();
default:
break;
}
}
return -9999;
}
return INVALID_POINT;
}

30
src/framework/ui/uianchor.h
Unescape View File

@ -3,25 +3,27 @@
#include "declarations.h"
struct AnchorLine {
AnchorLine(std::string widgetId, AnchorPoint edge) : widgetId(widgetId), edge(edge) { }
std::string widgetId;
AnchorPoint edge;
};
class UIAnchor
{
public:
UIAnchor(const UIWidgetPtr& anchoredWidget, AnchorPoint anchoredEdge, const AnchorLine& anchorLine);
UIWidgetPtr getAnchorLineWidget() const;
UIWidgetPtr getAnchoredWidget() const;
AnchorPoint getAnchoredEdge() const;
int getAnchorLinePoint() const;
enum {
INVALID_POINT = -999999
};
UIAnchor(AnchorEdge anchoredEdge, const std::string& hookedWidgetId, AnchorEdge hookedEdge);
AnchorEdge getAnchoredEdge() const { return m_anchoredEdge; }
UIWidgetPtr getHookedWidget() const { return m_hookedWidget.lock(); }
std::string getHookedWidgetId() const { return m_hookedWidgetId; }
int getHookedPoint() const;
void setHookedWidget(const UIWidgetPtr hookedWidget) { m_hookedWidget = hookedWidget; }
private:
UIWidgetWeakPtr m_anchoredWidget;
AnchorPoint m_anchoredEdge;
AnchorLine m_anchorLine;
AnchorEdge m_anchoredEdge;
UIWidgetWeakPtr m_hookedWidget;
std::string m_hookedWidgetId;
AnchorEdge m_hookedEdge;
};
#endif

123
src/framework/ui/uianchorlayout.cpp
Unescape View File

@ -1,123 +0,0 @@
#include "uianchorlayout.h"
#include "uiwidget.h"
bool UIAnchorLayout::addAnchor(const UIWidgetPtr& anchoredWidget, AnchorPoint anchoredEdge, const AnchorLine& anchorLine)
{
UIAnchor anchor(anchoredWidget, anchoredEdge, anchorLine);
UIWidgetPtr anchorLineWidget = anchor.getAnchorLineWidget();
/*
if(!anchorLineWidget) {
logError("could not find the widget to anchor on, wrong id?");
return false;
}
*/
// we can never anchor with itself
if(anchoredWidget == anchorLineWidget) {
logError("anchoring with itself is not possible");
return false;
}
// we must never anchor to an anchor child
if(anchoredWidget && hasWidgetInAnchorTree(anchorLineWidget, anchoredWidget)) {
logError("anchors is miss configured, you must never make an anchor chains in loops");
return false;
}
// avoid duplicated anchors
for(auto it = m_anchors.begin(); it != m_anchors.end(); ++it) {
const UIAnchor& otherAnchor = *it;
if(otherAnchor.getAnchoredWidget() == anchoredWidget && otherAnchor.getAnchoredEdge() == anchoredEdge) {
m_anchors.erase(it);
break;
}
}
// setup the anchor
m_anchors.push_back(anchor);
// recalculate anchored widget layout
updateWidget(anchoredWidget);
return true;
}
void UIAnchorLayout::updateWidget(const UIWidgetPtr& widget)
{
Rect rect = widget->getGeometry();
bool verticalMoved = false;
bool horizontalMoved = false;
// FIXME: release expired anchors
for(const UIAnchor& anchor : m_anchors) {
if(anchor.getAnchoredWidget() == widget && anchor.getAnchorLineWidget()) {
int point = anchor.getAnchorLinePoint();
switch(anchor.getAnchoredEdge()) {
case AnchorHorizontalCenter:
rect.moveHorizontalCenter(point + widget->getMarginLeft() - widget->getMarginRight());
horizontalMoved = true;
break;
case AnchorLeft:
if(!horizontalMoved) {
rect.moveLeft(point + widget->getMarginLeft());
horizontalMoved = true;
} else
rect.setLeft(point + widget->getMarginLeft());
break;
case AnchorRight:
if(!horizontalMoved) {
rect.moveRight(point - widget->getMarginRight());
horizontalMoved = true;
} else
rect.setRight(point - widget->getMarginRight());
break;
case AnchorVerticalCenter:
rect.moveVerticalCenter(point + widget->getMarginTop() - widget->getMarginBottom());
verticalMoved = true;
break;
case AnchorTop:
if(!verticalMoved) {
rect.moveTop(point + widget->getMarginTop());
verticalMoved = true;
} else
rect.setTop(point + widget->getMarginTop());
break;
case AnchorBottom:
if(!verticalMoved) {
rect.moveBottom(point - widget->getMarginBottom());
verticalMoved = true;
} else
rect.setBottom(point - widget->getMarginBottom());
break;
default:
break;
}
}
}
if(rect != widget->getGeometry())
widget->setGeometry(rect);
}
void UIAnchorLayout::updateWidgetChildren(const UIWidgetPtr& parent)
{
for(const UIAnchor& anchor : m_anchors) {
if(anchor.getAnchorLineWidget() == parent) {
UIWidgetPtr child = anchor.getAnchoredWidget();
if(child)
updateWidget(child);
}
}
}
bool UIAnchorLayout::hasWidgetInAnchorTree(const UIWidgetPtr& widget, const UIWidgetPtr& treeAnchor)
{
for(const UIAnchor& anchor : m_anchors) {
if(anchor.getAnchorLineWidget() == treeAnchor) {
if(anchor.getAnchoredWidget() == widget || hasWidgetInAnchorTree(widget, anchor.getAnchoredWidget()))
return true;
}
}
return false;
}

20
src/framework/ui/uianchorlayout.h
Unescape View File

@ -1,20 +0,0 @@
#ifndef UIANCHORLAYOUT_H
#define UIANCHORLAYOUT_H
#include "uilayout.h"
#include "uianchor.h"
class UIAnchorLayout : public UILayout
{
public:
bool addAnchor(const UIWidgetPtr& anchoredWidget, AnchorPoint anchoredEdge, const AnchorLine& anchorLine);
void updateWidget(const UIWidgetPtr& widget);
void updateWidgetChildren(const UIWidgetPtr& parent);
bool hasWidgetInAnchorTree(const UIWidgetPtr& widget, const UIWidgetPtr& treeAnchor);
private:
std::list<UIAnchor> m_anchors;
};
#endif

4
src/framework/ui/uibutton.cpp
Unescape View File

@ -63,7 +63,7 @@ void UIButton::render()
UIWidget::render();
const ButtonStateStyle& currentStyle = m_statesStyle[m_state];
Rect textRect = getGeometry();
Rect textRect = getRect();
if(currentStyle.image) {
g_graphics.bindColor(currentStyle.color);
@ -93,7 +93,7 @@ void UIButton::onMousePress(UIMouseEvent& event)
void UIButton::onMouseRelease(UIMouseEvent& event)
{
if(m_state == ButtonDown) {
if(m_onClick && getGeometry().contains(event.pos()))
if(m_onClick && getRect().contains(event.pos()))
m_onClick();
m_state = (isHovered() && isEnabled()) ? ButtonHover : ButtonUp;
} else

4
src/framework/ui/uievent.h
Unescape View File

@ -88,10 +88,10 @@ private:
bool m_hovered;
};
class UIGeometryUpdateEvent : public UIEvent
class UIRectUpdateEvent : public UIEvent
{
public:
UIGeometryUpdateEvent(const Rect& oldRect, const Rect& rect)
UIRectUpdateEvent(const Rect& oldRect, const Rect& rect)
: m_oldRect(oldRect), m_rect(rect) { }
Point pos() const { return m_rect.topLeft(); }

2
src/framework/ui/uilayout.cpp
Unescape View File

@ -1,2 +0,0 @@
#include "uilayout.h"

13
src/framework/ui/uilayout.h
Unescape View File

@ -1,13 +0,0 @@
#ifndef UILAYOUT_H
#define UILAYOUT_H
#include "declarations.h"
class UILayout
{
public:
virtual void updateWidget(const UIWidgetPtr& widget) = 0;
virtual void updateWidgetChildren(const UIWidgetPtr& widget) = 0;
};
#endif

10
src/framework/ui/uilineedit.cpp
Unescape View File

@ -18,7 +18,6 @@ UILineEdit::UILineEdit() : UIWidget(UITypeLabel)
UILineEditPtr UILineEdit::create()
{
UILineEditPtr lineEdit(new UILineEdit);
lineEdit->setStyle("LineEdit");
return lineEdit;
}
@ -38,13 +37,16 @@ void UILineEdit::render()
{
UIWidget::render();
if(!m_rect.isValid())
return;
//TODO: text rendering could be much optimized by using vertex buffer or caching the render into a texture
int textLength = m_text.length();
const TexturePtr& texture = m_font->getTexture();
for(int i=0;i<textLength;++i) {
for(int i=0;i<textLength;++i)
g_graphics.drawTexturedRect(m_glyphsCoords[i], texture, m_glyphsTexCoords[i]);
}
// render cursor
if(isExplicitlyEnabled() && hasFocus() && m_cursorPos >= 0) {
@ -334,7 +336,7 @@ int UILineEdit::getTextPos(Point pos)
return candidatePos;
}
void UILineEdit::onGeometryUpdate(UIGeometryUpdateEvent& event)
void UILineEdit::onRectUpdate(UIRectUpdateEvent& event)
{
update();
}

2
src/framework/ui/uilineedit.h
Unescape View File

@ -30,7 +30,7 @@ public:
int getTextPos(Point pos);
protected:
virtual void onGeometryUpdate(UIGeometryUpdateEvent& event);
virtual void onRectUpdate(UIRectUpdateEvent& event);
virtual void onFocusChange(UIFocusEvent& event);
virtual void onKeyPress(UIKeyEvent& event);
virtual void onMousePress(UIMouseEvent& event);

6
src/framework/ui/uimanager.cpp
Unescape View File

@ -1,6 +1,5 @@
#include "uimanager.h"
#include "ui.h"
#include "uianchorlayout.h"
#include <framework/otml/otml.h>
#include <framework/graphics/graphics.h>
@ -13,9 +12,6 @@ void UIManager::init()
m_rootWidget = UIWidgetPtr(new UIWidget);
m_rootWidget->setId("root");
m_rootWidget->setHovered(true);
UIAnchorLayoutPtr anchorLayout(new UIAnchorLayout);
m_rootWidget->setLayout(anchorLayout);
m_rootWidget->resize(g_graphics.getScreenSize());
}
@ -187,7 +183,7 @@ UIWidgetPtr UIManager::loadWidgetFromOTML(const OTMLNodePtr& widgetNode)
throw OTMLException(styleNode, "cannot determine widget type");
widget->loadStyleFromOTML(styleNode);
widget->updateGeometry();
widget->updateLayout();
for(const OTMLNodePtr& childNode : widgetNode->children()) {
if(!childNode->isUnique())

368
src/framework/ui/uiwidget.cpp
Unescape View File

@ -1,7 +1,5 @@
#include "uiwidget.h"
#include "uimanager.h"
#include "uilayout.h"
#include "uianchorlayout.h"
#include <framework/core/eventdispatcher.h>
#include <framework/graphics/image.h>
@ -9,6 +7,7 @@
#include <framework/graphics/fontmanager.h>
#include <framework/otml/otmlnode.h>
#include <framework/graphics/graphics.h>
#include "uianchor.h"
UIWidget::UIWidget(UIWidgetType type)
{
@ -18,7 +17,10 @@ UIWidget::UIWidget(UIWidgetType type)
m_hovered = false;
m_focusable = true;
m_destroyed = false;
m_updateScheduled = false;
m_layoutUpdated = true;
m_updateEventScheduled = false;
m_layoutUpdateScheduled = false;
m_childrenLayoutUpdateScheduled = false;
m_opacity = 255;
m_marginLeft = m_marginRight = m_marginTop = m_marginBottom = 0;
m_backgroundColor = Color::white;
@ -158,7 +160,7 @@ void UIWidget::loadStyleFromOTML(const OTMLNodePtr& styleNode)
} else if(what == "centerIn") {
centerIn(node->value());
} else {
AnchorPoint myEdge = fw::translateAnchorPoint(what);
AnchorEdge myEdge = fw::translateAnchorEdge(what);
std::string anchorDescription = node->value();
std::vector<std::string> split;
@ -167,15 +169,15 @@ void UIWidget::loadStyleFromOTML(const OTMLNodePtr& styleNode)
throw OTMLException(node, "invalid anchor description");
std::string target = split[0];
AnchorPoint targetEdge = fw::translateAnchorPoint(split[1]);
AnchorEdge hookedEdge = fw::translateAnchorEdge(split[1]);
if(myEdge == AnchorNone)
throw OTMLException(node, "invalid anchor edge");
if(targetEdge == AnchorNone)
if(hookedEdge == AnchorNone)
throw OTMLException(node, "invalid anchor target edge");
addAnchor(myEdge, target, targetEdge);
addAnchor(myEdge, target, hookedEdge);
}
}
else if(node->tag() == "onLoad") {
@ -190,7 +192,7 @@ void UIWidget::render()
assert(!m_destroyed);
if(m_image)
m_image->draw(getGeometry());
m_image->draw(getRect());
for(const UIWidgetPtr& child : m_children) {
if(child->isExplicitlyVisible()) {
@ -203,23 +205,13 @@ void UIWidget::render()
// debug draw box
//g_graphics.bindColor(Color::green);
//g_graphics.drawBoundingRect(child->getGeometry());
//g_graphics.drawBoundingRect(child->getRect());
g_graphics.setOpacity(oldOpacity);
}
}
}
void UIWidget::updateGeometry()
{
assert(!m_destroyed);
if(UILayoutPtr layout = getLayout()) {
layout->updateWidget(asUIWidget());
layout->updateWidgetChildren(asUIWidget());
}
}
void UIWidget::setParent(const UIWidgetPtr& parent)
{
assert(!m_destroyed);
@ -247,32 +239,33 @@ void UIWidget::setStyle(const std::string& styleName)
loadStyleFromOTML(styleNode);
// forces layout recalculation
updateGeometry();
updateLayout();
} catch(std::exception& e) {
logError("couldn't change widget '", m_id, "' style: ", e.what());
}
}
void UIWidget::setGeometry(const Rect& rect)
void UIWidget::setRect(const Rect& rect)
{
assert(!m_destroyed);
Rect oldRect = m_rect;
m_rect = rect;
if(UILayoutPtr layout = getLayout())
layout->updateWidgetChildren(asUIWidget());
// avoid massive updates
if(!m_updateScheduled) {
// updates children geometry
updateChildrenLayout();
// avoid massive update events
if(!m_updateEventScheduled) {
UIWidgetPtr self = asUIWidget();
g_dispatcher.addEvent([self, oldRect]() {
self->m_updateScheduled = false;
UIGeometryUpdateEvent e(oldRect, self->getGeometry());
self->m_updateEventScheduled = false;
UIRectUpdateEvent e(oldRect, self->getRect());
// this widget could be destroyed before the event happens
if(!self->isDestroyed())
self->onGeometryUpdate(e);
self->onRectUpdate(e);
});
m_updateScheduled = true;
m_updateEventScheduled = true;
}
}
@ -310,16 +303,12 @@ bool UIWidget::hasChild(const UIWidgetPtr& child)
return false;
}
UILayoutPtr UIWidget::getLayout() const
UIWidgetPtr UIWidget::getRootParent()
{
assert(!m_destroyed);
if(m_layout)
return m_layout;
else if(getParent() && getParent()->getLayout())
return getParent()->getLayout();
// fallback to root layout
return g_ui.getRootWidget()->getLayout();
if(UIWidgetPtr parent = getParent())
return parent->getRootParent();
else
return asUIWidget();
}
UIWidgetPtr UIWidget::getChildAfter(const UIWidgetPtr& relativeChild)
@ -383,7 +372,7 @@ UIWidgetPtr UIWidget::getChildByPos(const Point& childPos)
for(auto it = m_children.rbegin(); it != m_children.rend(); ++it) {
const UIWidgetPtr& widget = (*it);
if(widget->isExplicitlyVisible() && widget->getGeometry().contains(childPos))
if(widget->isExplicitlyVisible() && widget->getRect().contains(childPos))
return widget;
}
@ -399,35 +388,19 @@ UIWidgetPtr UIWidget::getChildByIndex(int childIndex)
return nullptr;
}
UIWidgetPtr UIWidget::recursiveGetChildById(const std::string& childId)
UIWidgetPtr UIWidget::recursiveGetChildById(const std::string& id)
{
assert(!m_destroyed);
if(getId() == childId || childId == "self")
return asUIWidget();
else if(childId == "parent")
return getParent();
else if(childId == "root")
return g_ui.getRootWidget();
else if(childId == "prev") {
if(UIWidgetPtr parent = getParent())
return parent->getChildBefore(asUIWidget());
} else if(childId == "next") {
if(UIWidgetPtr parent = getParent())
return parent->getChildAfter(asUIWidget());
} else {
UIWidgetPtr widget = getChildById(id);
if(!widget) {
for(const UIWidgetPtr& child : m_children) {
if(child->getId() == childId)
return child;
}
for(const UIWidgetPtr& child : m_children) {
if(UIWidgetPtr subChild = child->recursiveGetChildById(childId)) {
if(subChild->getId() == childId)
return subChild;
}
widget = child->recursiveGetChildById(id);
if(widget)
break;
}
}
return nullptr;
return widget;
}
UIWidgetPtr UIWidget::recursiveGetChildByPos(const Point& childPos)
@ -435,7 +408,7 @@ UIWidgetPtr UIWidget::recursiveGetChildByPos(const Point& childPos)
assert(!m_destroyed);
for(const UIWidgetPtr& child : m_children) {
if(child->getGeometry().contains(childPos)) {
if(child->getRect().contains(childPos)) {
if(UIWidgetPtr subChild = child->recursiveGetChildByPos(childPos))
return subChild;
return child;
@ -449,27 +422,12 @@ UIWidgetPtr UIWidget::backwardsGetWidgetById(const std::string& id)
{
assert(!m_destroyed);
UIWidgetPtr widget;
if(getId() == id || id == "self")
widget = asUIWidget();
else if(id == "parent")
widget = getParent();
else if(id == "root")
widget = g_ui.getRootWidget();
else if(id == "prev") {
if(UIWidgetPtr parent = getParent())
widget = parent->getChildBefore(asUIWidget());
} else if(id == "next") {
if(UIWidgetPtr parent = getParent())
widget = parent->getChildAfter(asUIWidget());
} else {
widget = recursiveGetChildById(id);
if(widget)
return widget;
UIWidgetPtr widget = getChildById(id);
if(!widget) {
if(UIWidgetPtr parent = getParent())
widget = parent->backwardsGetWidgetById(id);
}
return widget;
}
@ -503,8 +461,11 @@ void UIWidget::addChild(const UIWidgetPtr& childToAdd)
m_children.push_back(childToAdd);
childToAdd->setParent(asUIWidget());
// updates geometry
updateGeometry();
// recalculate anchors
getRootParent()->recalculateAnchoredWidgets();
// may need to update children layout
updateChildrenLayout();
// always focus new children
if(childToAdd->isFocusable())
@ -529,8 +490,11 @@ void UIWidget::insertChild(const UIWidgetPtr& childToInsert, int index)
m_children.insert(it, childToInsert);
childToInsert->setParent(asUIWidget());
// updates geometry
updateGeometry();
// recalculate anchors
getRootParent()->recalculateAnchoredWidgets();
// may need to update children layout
updateChildrenLayout();
}
void UIWidget::removeChild(const UIWidgetPtr& childToRemove)
@ -555,6 +519,13 @@ void UIWidget::removeChild(const UIWidgetPtr& childToRemove)
// reset child parent
assert(childToRemove->getParent() == asUIWidget());
childToRemove->setParent(nullptr);
// recalculate anchors
UIWidgetPtr parent = getRootParent();
parent->recalculateAnchoredWidgets();
// may need to update children layout
updateChildrenLayout();
}
void UIWidget::focusNextChild(FocusReason reason)
@ -633,32 +604,227 @@ void UIWidget::unlockChild(const UIWidgetPtr& childToUnlock)
}
}
void UIWidget::addAnchor(AnchorPoint edge, const std::string& targetId, AnchorPoint targetEdge)
void UIWidget::updateLayout()
{
assert(!m_destroyed);
UIAnchorLayoutPtr layout = std::dynamic_pointer_cast<UIAnchorLayout>(getLayout());
assert(layout);
if(layout)
layout->addAnchor(asUIWidget(), edge, AnchorLine(targetId, targetEdge));
if(!m_layoutUpdateScheduled) {
m_layoutUpdateScheduled = true;
UIWidgetPtr self = asUIWidget();
g_dispatcher.addEvent([self] {
self->m_layoutUpdateScheduled = false;
if(!self->isDestroyed())
self->internalUpdateLayout();
});
}
}
void UIWidget::centerIn(const std::string& targetId)
void UIWidget::updateChildrenLayout()
{
assert(!m_destroyed);
addAnchor(AnchorHorizontalCenter, targetId, AnchorHorizontalCenter);
addAnchor(AnchorVerticalCenter, targetId, AnchorVerticalCenter);
if(!m_childrenLayoutUpdateScheduled) {
m_childrenLayoutUpdateScheduled = true;
UIWidgetPtr self = asUIWidget();
g_dispatcher.addEvent([self] {
self->m_childrenLayoutUpdateScheduled = false;
if(!self->isDestroyed())
self->internalUpdateChildrenLayout();
});
}
}
void UIWidget::fill(const std::string& targetId)
bool UIWidget::addAnchor(AnchorEdge edge, const std::string& hookedWidgetId, AnchorEdge hookedEdge)
{
assert(!m_destroyed);
addAnchor(AnchorLeft, targetId, AnchorLeft);
addAnchor(AnchorRight, targetId, AnchorRight);
addAnchor(AnchorTop, targetId, AnchorTop);
addAnchor(AnchorBottom, targetId, AnchorBottom);
UIAnchor anchor(edge, hookedWidgetId, hookedEdge);
UIWidgetPtr hookedWidget = backwardsGetWidgetById(hookedWidgetId);
anchor.setHookedWidget(hookedWidget);
// we can never anchor with itself
if(hookedWidget == asUIWidget()) {
logError("anchoring with itself is not possible");
return false;
}
// we must never anchor to an anchor child
//TODO: this check
// duplicated anchors must be replaced
for(auto it = m_anchors.begin(); it != m_anchors.end(); ++it) {
const UIAnchor& otherAnchor = *it;
if(otherAnchor.getAnchoredEdge() == edge) {
m_anchors.erase(it);
break;
}
}
m_anchors.push_back(anchor);
updateLayout();
return true;
}
void UIWidget::centerIn(const std::string& hookedWidgetId)
{
assert(!m_destroyed);
addAnchor(AnchorHorizontalCenter, hookedWidgetId, AnchorHorizontalCenter);
addAnchor(AnchorVerticalCenter, hookedWidgetId, AnchorVerticalCenter);
}
void UIWidget::fill(const std::string& hookedWidgetId)
{
assert(!m_destroyed);
addAnchor(AnchorLeft, hookedWidgetId, AnchorLeft);
addAnchor(AnchorRight, hookedWidgetId, AnchorRight);
addAnchor(AnchorTop, hookedWidgetId, AnchorTop);
addAnchor(AnchorBottom, hookedWidgetId, AnchorBottom);
}
void UIWidget::internalUpdateLayout()
{
assert(!m_destroyed);
for(const UIAnchor& anchor : m_anchors) {
// ignore invalid anchors
if(!anchor.getHookedWidget())
continue;
// the update should only happens if the hooked widget is already updated
if(!anchor.getHookedWidget()->m_layoutUpdated)
return;
}
Rect newRect = m_rect;
bool verticalMoved = false;
bool horizontalMoved = false;
// calculate new rect based on anchors
for(const UIAnchor& anchor : m_anchors) {
int point = anchor.getHookedPoint();
// ignore invalid anchors
if(point == UIAnchor::INVALID_POINT)
continue;
switch(anchor.getAnchoredEdge()) {
case AnchorHorizontalCenter:
newRect.moveHorizontalCenter(point + getMarginLeft() - getMarginRight());
horizontalMoved = true;
break;
case AnchorLeft:
if(!horizontalMoved) {
newRect.moveLeft(point + getMarginLeft());
horizontalMoved = true;
} else
newRect.setLeft(point + getMarginLeft());
break;
case AnchorRight:
if(!horizontalMoved) {
newRect.moveRight(point - getMarginRight());
horizontalMoved = true;
} else
newRect.setRight(point - getMarginRight());
break;
case AnchorVerticalCenter:
newRect.moveVerticalCenter(point + getMarginTop() - getMarginBottom());
verticalMoved = true;
break;
case AnchorTop:
if(!verticalMoved) {
newRect.moveTop(point + getMarginTop());
verticalMoved = true;
} else
newRect.setTop(point + getMarginTop());
break;
case AnchorBottom:
if(!verticalMoved) {
newRect.moveBottom(point - getMarginBottom());
verticalMoved = true;
} else
newRect.setBottom(point - getMarginBottom());
break;
default:
break;
}
}
m_layoutUpdated = true;
// changes the rect only if really needed
if(newRect != m_rect) {
// setRect will update children layout too
setRect(newRect);
} else {
// update children
internalUpdateChildrenLayout();
}
}
void UIWidget::internalUpdateChildrenLayout()
{
assert(!m_destroyed);
// reset all children anchors update state
resetLayoutUpdateState(false);
// update children layouts
for(const UIWidgetWeakPtr& anchoredWidgetWeak : m_anchoredWidgets) {
if(UIWidgetPtr anchoredWidget = anchoredWidgetWeak.lock())
anchoredWidget->updateLayout();
}
}
void UIWidget::resetLayoutUpdateState(bool resetOwn)
{
if(resetOwn)
m_layoutUpdated = false;
// resets children layout update state too
for(const UIWidgetWeakPtr& anchoredWidgetWeak : m_anchoredWidgets) {
if(UIWidgetPtr anchoredWidget = anchoredWidgetWeak.lock())
anchoredWidget->resetLayoutUpdateState(true);
}
}
void UIWidget::addAnchoredWidget(const UIWidgetPtr& widget)
{
// prevent duplicated anchored widgets
for(const UIWidgetWeakPtr& anchoredWidget : m_anchoredWidgets)
if(anchoredWidget.lock() == widget)
return;
m_anchoredWidgets.push_back(widget);
}
void UIWidget::recalculateAnchoredWidgets()
{
clearAnchoredWidgets();
computeAnchoredWidgets();
}
void UIWidget::clearAnchoredWidgets()
{
m_anchoredWidgets.clear();
for(const UIWidgetPtr& child : m_children)
child->clearAnchoredWidgets();
}
void UIWidget::computeAnchoredWidgets()
{
// update anchors's hooked widget
for(UIAnchor& anchor : m_anchors) {
UIWidgetPtr hookedWidget = backwardsGetWidgetById(anchor.getHookedWidgetId());
anchor.setHookedWidget(hookedWidget);
if(hookedWidget)
hookedWidget->addAnchoredWidget(asUIWidget());
}
for(const UIWidgetPtr& child : m_children)
child->computeAnchoredWidgets();
}
void UIWidget::onFocusChange(UIFocusEvent& event)
@ -726,7 +892,7 @@ void UIWidget::onMousePress(UIMouseEvent& event)
continue;
// mouse press events only go to children that contains the mouse position
if(child->getGeometry().contains(event.pos()) && child == getChildByPos(event.pos())) {
if(child->getRect().contains(event.pos()) && child == getChildByPos(event.pos())) {
// focus it
if(child->isFocusable())
focusChild(child, MouseFocusReason);
@ -775,7 +941,7 @@ void UIWidget::onMouseMove(UIMouseEvent& event)
// check if the mouse is relally over this child
bool overChild = (isHovered() &&
child->getGeometry().contains(event.pos()) &&
child->getRect().contains(event.pos()) &&
child == getChildByPos(event.pos()));
if(overChild != child->isHovered()) {
child->setHovered(overChild);
@ -806,7 +972,7 @@ void UIWidget::onMouseWheel(UIMouseEvent& event)
continue;
// mouse wheel events only go to children that contains the mouse position
if(child->getGeometry().contains(event.pos()) && child == getChildByPos(event.pos())) {
if(child->getRect().contains(event.pos()) && child == getChildByPos(event.pos())) {
event.accept();
child->onMouseWheel(event);
}

55
src/framework/ui/uiwidget.h
Unescape View File

@ -27,34 +27,30 @@ public:
/// Draw widget on screen
virtual void render();
/// Notifies the layout system that this widget has changed and may need to change geometry
void updateGeometry();
void setEnabled(bool enable) { m_enabled = enable; }
void setLayout(const UILayoutPtr& layout) { m_layout = layout; }
void setId(const std::string& id) { m_id = id; }
void setFocusable(bool focusable) { m_focusable = focusable; }
void setHovered(bool hovered) { m_hovered = hovered; }
void setVisible(bool visible) { m_visible = visible; }
void setParent(const UIWidgetPtr& parent);
void setStyle(const std::string& styleName);
void setGeometry(const Rect& rect);
void setRect(const Rect& rect);
void setX(int x) { move(Point(x, getY())); }
void setY(int y) { move(Point(getX(), y)); }
void setWidth(int width) { resize(Size(width, getHeight())); }
void setHeight(int height) { resize(Size(getWidth(), height)); }
void resize(const Size& size) { setGeometry(Rect(getPosition(), size)); updateGeometry(); }
void move(const Point& pos) { setGeometry(Rect(pos, getSize())); }
void resize(const Size& size) { setRect(Rect(getPosition(), size)); }
void move(const Point& pos) { setRect(Rect(pos, getSize())); }
void setImage(const ImagePtr& image) { m_image = image; }
virtual void setFont(const FontPtr& font) { m_font = font; }
void setOpacity(int opacity) { m_opacity = opacity; }
void setBackgroundColor(const Color& color) { m_backgroundColor = color; }
void setForegroundColor(const Color& color) { m_foregroundColor = color; }
void setMarginLeft(int margin) { m_marginLeft = margin; updateGeometry(); }
void setMarginRight(int margin) { m_marginRight = margin; updateGeometry(); }
void setMarginTop(int margin) { m_marginTop = margin; updateGeometry(); }
void setMarginBottom(int margin) { m_marginBottom = margin; updateGeometry(); }
void setMarginLeft(int margin) { m_marginLeft = margin; updateLayout(); }
void setMarginRight(int margin) { m_marginRight = margin; updateLayout(); }
void setMarginTop(int margin) { m_marginTop = margin; updateLayout(); }
void setMarginBottom(int margin) { m_marginBottom = margin; updateLayout(); }
void hide() { setVisible(false); }
void show() { setVisible(true); }
@ -72,13 +68,13 @@ public:
bool hasChild(const UIWidgetPtr& child);
UIWidgetType getWidgetType() const { return m_type; }
UILayoutPtr getLayout() const;
std::string getId() const { return m_id; }
int getChildCount() const { return m_children.size(); }
UIWidgetPtr getParent() const { return m_parent.lock(); }
UIWidgetPtr getRootParent();
Point getPosition() const { return m_rect.topLeft(); }
Size getSize() const { return m_rect.size(); }
Rect getGeometry() const { return m_rect; }
Rect getRect() const { return m_rect; }
int getX() const { return m_rect.x(); }
int getY() const { return m_rect.y(); }
int getWidth() const { return m_rect.width(); }
@ -101,7 +97,7 @@ public:
UIWidgetPtr getChildById(const std::string& childId);
UIWidgetPtr getChildByPos(const Point& childPos);
UIWidgetPtr getChildByIndex(int childIndex);
UIWidgetPtr recursiveGetChildById(const std::string& childId);
UIWidgetPtr recursiveGetChildById(const std::string& id);
UIWidgetPtr recursiveGetChildByPos(const Point& childPos);
UIWidgetPtr backwardsGetWidgetById(const std::string& id);
@ -114,16 +110,33 @@ public:
void lockChild(const UIWidgetPtr& childToLock);
void unlockChild(const UIWidgetPtr& childToUnlock);
// for using only with anchor layouts
void addAnchor(AnchorPoint edge, const std::string& targetId, AnchorPoint targetEdge);
void centerIn(const std::string& targetId);
void fill(const std::string& targetId);
void updateLayout();
void updateChildrenLayout();
bool addAnchor(AnchorEdge edge, const std::string& hookedWidgetId, AnchorEdge hookedEdge);
void centerIn(const std::string& hookedWidgetId);
void fill(const std::string& hookedWidgetId);
UIWidgetPtr asUIWidget() { return std::static_pointer_cast<UIWidget>(shared_from_this()); }
private:
void internalUpdateLayout();
void internalUpdateChildrenLayout();
void addAnchoredWidget(const UIWidgetPtr& widget);
void recalculateAnchoredWidgets();
void clearAnchoredWidgets();
void computeAnchoredWidgets();
void resetLayoutUpdateState(bool resetOwn);
bool m_layoutUpdated;
bool m_updateEventScheduled;
bool m_layoutUpdateScheduled;
bool m_childrenLayoutUpdateScheduled;
protected:
/// Triggered when widget is moved or resized
virtual void onGeometryUpdate(UIGeometryUpdateEvent& event) { }
virtual void onRectUpdate(UIRectUpdateEvent& event) { }
// Triggered when widget change visibility/enabled/style/children/parent/layout/...
//virtual void onChange(const UIEvent& event);
/// Triggered when widget gets or loses focus
@ -155,9 +168,9 @@ protected:
bool m_hovered;
bool m_focusable;
bool m_destroyed;
bool m_updateScheduled;
Rect m_rect;
UILayoutPtr m_layout;
UIAnchorList m_anchors;
UIWeakWidgetList m_anchoredWidgets;
UIWidgetWeakPtr m_parent;
UIWidgetList m_children;
UIWidgetList m_lockedWidgets;

14
src/framework/ui/uiwindow.cpp
Unescape View File

@ -42,7 +42,7 @@ void UIWindow::loadStyleFromOTML(const OTMLNodePtr& styleNode)
void UIWindow::render()
{
// draw window head
Rect headRect = getGeometry();
Rect headRect = getRect();
headRect.setHeight(m_headHeight);
if(m_headImage && m_headHeight > 0) {
@ -58,7 +58,7 @@ void UIWindow::render()
}
// draw window body
Rect bodyRect = getGeometry();
Rect bodyRect = getRect();
bodyRect.setTop(headRect.bottom() + 1);
if(m_bodyImage)
m_bodyImage->draw(bodyRect);
@ -67,13 +67,13 @@ void UIWindow::render()
UIWidget::render();
}
void UIWindow::onGeometryUpdate(UIGeometryUpdateEvent& event)
void UIWindow::onRectUpdate(UIRectUpdateEvent& event)
{
// bind window rect to parent rect
Rect boundRect = event.rect();
UIWidgetPtr parent = getParent();
if(parent) {
Rect parentRect = parent->getGeometry();
Rect parentRect = parent->getRect();
if(boundRect.left() < parentRect.left())
boundRect.moveLeft(parentRect.left());
if(boundRect.top() < parentRect.top())
@ -85,7 +85,7 @@ void UIWindow::onGeometryUpdate(UIGeometryUpdateEvent& event)
}
if(boundRect != event.rect())
setGeometry(boundRect);
setRect(boundRect);
}
void UIWindow::onFocusChange(UIFocusEvent& event)
@ -97,11 +97,11 @@ void UIWindow::onFocusChange(UIFocusEvent& event)
void UIWindow::onMousePress(UIMouseEvent& event)
{
Rect headRect = getGeometry();
Rect headRect = getRect();
headRect.setHeight(m_headHeight);
if(headRect.contains(event.pos())) {
m_moving = true;
m_movingReference = event.pos() - getGeometry().topLeft();
m_movingReference = event.pos() - getRect().topLeft();
} else
UIWidget::onMousePress(event);
}

2
src/framework/ui/uiwindow.h
Unescape View File

@ -17,7 +17,7 @@ public:
std::string getTitle() const { return m_title; }
protected:
virtual void onGeometryUpdate(UIGeometryUpdateEvent& event);
virtual void onRectUpdate(UIRectUpdateEvent& event);
virtual void onFocusChange(UIFocusEvent& event);
virtual void onMousePress(UIMouseEvent& event);
virtual void onMouseRelease(UIMouseEvent& event);

2
src/framework/util/translator.cpp
Unescape View File

@ -25,7 +25,7 @@ AlignmentFlag fw::translateAlignment(std::string aligment)
return AlignCenter;
}
AnchorPoint fw::translateAnchorPoint(const std::string& anchorPoint)
AnchorEdge fw::translateAnchorEdge(const std::string& anchorPoint)
{
if(anchorPoint == "left")
return AnchorLeft;

2
src/framework/util/translator.h
Unescape View File

@ -7,7 +7,7 @@
namespace fw {
AlignmentFlag translateAlignment(std::string aligment);
AnchorPoint translateAnchorPoint(const std::string& anchorPoint);
AnchorEdge translateAnchorEdge(const std::string& anchorPoint);
};

8
src/otclient/core/tile.cpp
Unescape View File

@ -34,7 +34,7 @@ void Tile::draw(int x, int y, int step)
if(thingAttributes.alwaysOnTopOrder == 1) {
thing->draw(x - m_drawNextOffset, y - m_drawNextOffset);
font->renderText("T1", Rect(x + 5, y+5, 100, 100));
//font->renderText("T1", Rect(x + 5, y+5, 100, 100));
m_drawNextOffset += thingAttributes.drawNextOffset;
}
@ -45,7 +45,7 @@ void Tile::draw(int x, int y, int step)
if(thingAttributes.alwaysOnTopOrder == 2) {
thing->draw(x - m_drawNextOffset, y - m_drawNextOffset);
font->renderText("T2", Rect(x + 5, y+5, 100, 100));
//font->renderText("T2", Rect(x + 5, y+5, 100, 100));
m_drawNextOffset += thingAttributes.drawNextOffset;
}
}
@ -53,7 +53,7 @@ void Tile::draw(int x, int y, int step)
for(const ThingPtr& thing : m_itemsBottom) {
const ThingAttributes& thingAttributes = thing->getAttributes();
thing->draw(x - m_drawNextOffset, y - m_drawNextOffset);
font->renderText("B0", Rect(x + 5, y+5, 100, 100));
//font->renderText("B0", Rect(x + 5, y+5, 100, 100));
m_drawNextOffset += thingAttributes.drawNextOffset;
}
@ -69,7 +69,7 @@ void Tile::draw(int x, int y, int step)
if(thingAttributes.alwaysOnTopOrder == 3) {
thing->draw(x - m_drawNextOffset, y - m_drawNextOffset);
font->renderText("T3", Rect(x + 5, y+5, 100, 100));
//font->renderText("T3", Rect(x + 5, y+5, 100, 100));
m_drawNextOffset += thingAttributes.drawNextOffset;
}
}

Write Preview
Loading…
Cancel
Save