ilusha/Modules
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

update widgets

Browse source
This commit is contained in:
IlyaShurupov 2024-05-06 16:33:35 +03:00
parent c41dcf9efa
commit eb079e1386
24 changed files with 284 additions and 370 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Widgets/examples/ChatGUI.cpp
View file

@ -12,12 +12,14 @@ public:
void processFrame(EventHandler* eventHandler) override {
auto rec = RectF({ 0, 0 }, mWindow->getSize());
mGui.updateConfigCache(mWidgetManager);
mGui.updateConfigWrapper(mWidgetManager);
mGui.setArea(rec);
mGui.setVisible(true);
mGui.proc(*eventHandler, rec, rec);
mGui.procWrapper(*eventHandler);
}
void drawFrame(Canvas* canvas) override { mGui.draw(*canvas); }
void drawFrame(Canvas* canvas) override { mGui.drawWrapper(*canvas); }
private:
WidgetManager mWidgetManager;

167
Widgets/examples/ChatGUI.hpp
View file

@ -9,25 +9,19 @@ namespace tp {
public:
UserWidget() = default;
void proc(const Events& events, const RectF& areaParent, const RectF& aArea) override {
this->mArea = aArea;
void procCallback(const Events& events) override {
this->mArea.w = 30;
this->mVisible = areaParent.isOverlap(aArea);
if (!this->mVisible) return;
mIsHover = aArea.isInside(events.getPointer());
mIsHover = this->mArea.isInside(events.getPointer());
}
void draw(Canvas& canvas) override {
if (!this->mVisible) return;
void drawCallback(Canvas& canvas) override {
if (mIsHover) canvas.rect(this->mArea, mAccentColor, mRounding);
else canvas.rect(this->mArea, mBaseColor, mRounding);
canvas.text(mUser.c_str(), this->mArea, mFontSize, Canvas::CC, mPadding, mUserColor);
}
public:
void updateConfigCache(WidgetManager& wm) override {
void updateConfigCallback(WidgetManager& wm) override {
wm.setActiveId("UserWidget");
mBaseColor = wm.getColor("Base", "Base");
@ -55,16 +49,9 @@ namespace tp {
public:
MessageWidget() = default;
void proc(const Events& events, const RectF& areaParent, const RectF& aArea) override {
this->mArea = aArea;
this->mArea.w = 50;
this->mVisible = areaParent.isOverlap(aArea);
if (!this->mVisible) return;
mIsHover = aArea.isInside(events.getPointer());
}
void procCallback(const Events& events) override { mIsHover = this->mArea.isInside(events.getPointer()); }
void draw(Canvas& canvas) override {
if (!this->mVisible) return;
void drawCallback(Canvas& canvas) override {
if (mIsHover) canvas.rect(this->mArea, mBaseColor, mRounding);
auto userName = this->mArea;
@ -78,7 +65,7 @@ namespace tp {
canvas.text(mUser.c_str(), userName, mFontSizeDim, Canvas::LC, mPadding, mUserColor);
}
void updateConfigCache(WidgetManager& wm) override {
void updateConfigCallback(WidgetManager& wm) override {
wm.setActiveId("MessageWidget");
mBaseColor = wm.getColor("Base", "Base");
@ -111,16 +98,20 @@ namespace tp {
mPass.mId = "pass";
mUser.mId = "user";
mButton.mLabel.mLabel = "Login";
this->mChildWidgets.pushBack(&mPass);
this->mChildWidgets.pushBack(&mUser);
this->mChildWidgets.pushBack(&mButton);
}
void proc(const Events& events, const RectF& areaParent, const RectF& aArea) override {
this->mArea = aArea;
void procCallback(const Events& events) override {
mLogged = false;
const auto xval = aArea.z / 2 - 100;
mUser.proc(events, aArea, { xval, 10, 200, 30 });
mPass.proc(events, aArea, { xval, 50, 200, 30 });
mButton.proc(events, aArea, { xval, 90, 200, 30 });
const auto xval = this->mArea.z / 2 - 100;
mUser.setArea({ xval, 10, 200, 30 });
mPass.setArea({ xval, 50, 200, 30 });
mButton.setArea({ xval, 90, 200, 30 });
if (mButton.mIsReleased) {
mButton.mIsReleased = false;
@ -128,22 +119,12 @@ namespace tp {
}
}
void draw(Canvas& canvas) override {
canvas.rect(this->mArea, mBGColor);
mButton.draw(canvas);
mUser.draw(canvas);
mPass.draw(canvas);
}
void drawCallback(Canvas& canvas) override { canvas.rect(this->mArea, mBGColor); }
public:
void updateConfigCache(WidgetManager& wm) override {
void updateConfigCallback(WidgetManager& wm) override {
wm.setActiveId("LoginWidget");
mBGColor = wm.getColor("Back", "Base");
mUser.updateConfigCache(wm);
mPass.updateConfigCache(wm);
mButton.updateConfigCache(wm);
}
public:
@ -161,11 +142,13 @@ namespace tp {
ActiveChatWidget() {
mSend.mLabel.mLabel = "Send";
mMessage.mId = "Message";
this->mChildWidgets.pushBack(&mHistoryView);
this->mChildWidgets.pushBack(&mMessage);
this->mChildWidgets.pushBack(&mSend);
}
void proc(const Events& events, const RectF& areaParent, const RectF& aArea) override {
this->mArea = aArea;
void procCallback(const Events& events) override {
auto history = this->mArea;
history.w -= 50;
@ -182,36 +165,22 @@ namespace tp {
inputSend.x = inputMessage.x + inputMessage.z + mPadding;
inputSend.z = 100 - mPadding * 2;
mSend.proc(events, this->mArea, inputSend);
mMessage.proc(events, this->mArea, inputMessage);
mSend.setArea(inputSend);
mMessage.setArea(inputMessage);
if (mSend.mIsReleased) {
mSend.mIsReleased = false;
}
mHistoryView.proc(events, this->mArea, history);
mHistoryView.setArea(history);
}
void draw(Canvas& canvas) override {
canvas.rect(this->mArea, mBGColor);
mHistoryView.draw(canvas);
mMessage.draw(canvas);
mSend.draw(canvas);
}
void drawCallback(Canvas& canvas) override { canvas.rect(this->mArea, mBGColor); }
void updateConfigCache(WidgetManager& wm) override {
void updateConfigCallback(WidgetManager& wm) override {
wm.setActiveId("ActiveChat");
mBGColor = wm.getColor("Back", "Background");
mPadding = wm.getNumber("Padding", "Padding");
mHistoryView.updateConfigCache(wm);
mMessage.updateConfigCache(wm);
mSend.updateConfigCache(wm);
for (auto message : mMessages) {
message->updateConfigCache(wm);
}
}
public:
@ -238,49 +207,37 @@ namespace tp {
mUsers[2].mArea = { 0, 0, 100, 100 };
for (auto message : mUsers) {
mSideView.mContents.append(&message.data());
mSideView.addWidget(&message.data());
}
mActive.mMessages.append(MessageWidget<Events, Canvas>());
mActive.mMessages.append(MessageWidget<Events, Canvas>());
mActive.mMessages.append(MessageWidget<Events, Canvas>());
mActive.mMessages[0].mArea = { 0, 0, 100, 100 };
mActive.mMessages[1].mArea = { 0, 0, 100, 100 };
mActive.mMessages[2].mArea = { 0, 0, 100, 100 };
mActive.mMessages[0].mArea = { 0, 0, 100, 50 };
mActive.mMessages[1].mArea = { 0, 0, 100, 50 };
mActive.mMessages[2].mArea = { 0, 0, 100, 50 };
for (auto message : mActive.mMessages) {
mActive.mHistoryView.mContents.append(&message.data());
mActive.mHistoryView.addWidget(&message.data());
}
this->mChildWidgets.pushBack(&mSideView);
this->mChildWidgets.pushBack(&mActive);
this->mChildWidgets.pushBack(&mSplitView);
}
void proc(const Events& events, const RectF& areaParent, const RectF& aArea) override {
this->mArea = aArea;
mSplitView.proc(events, aArea, aArea);
mSideView.proc(events, this->mArea, mSplitView.getSecond());
mActive.proc(events, aArea, mSplitView.getFirst());
void procCallback(const Events& events) override {
mSplitView.setArea(this->mArea);
mSideView.setArea(mSplitView.getSecond());
mActive.setArea(mSplitView.getFirst());
}
void draw(Canvas& canvas) override {
canvas.rect(this->mArea, mBGColor);
mSplitView.draw(canvas);
mSideView.draw(canvas);
mActive.draw(canvas);
}
void drawCallback(Canvas& canvas) override { canvas.rect(this->mArea, mBGColor); }
void updateConfigCache(WidgetManager& wm) override {
void updateConfigCallback(WidgetManager& wm) override {
wm.setActiveId("ChattingWidget");
mBGColor = wm.getColor("Back", "Background");
mSideView.updateConfigCache(wm);
mActive.updateConfigCache(wm);
mSplitView.updateConfigCache(wm);
for (auto user : mUsers) {
user->updateConfigCache(wm);
}
}
public:
@ -295,34 +252,26 @@ namespace tp {
template <typename Events, typename Canvas>
class ComplexWidget : public Widget<Events, Canvas> {
public:
ComplexWidget() = default;
void proc(const Events& events, const RectF& areaParent, const RectF& aArea) override {
this->mArea = aArea;
if (mLogged) {
mChatting.proc(events, aArea, aArea);
} else {
mLogin.proc(events, aArea, aArea);
mLogged = mLogin.mLogged;
if (mLogged) {
mChatting.proc(events, aArea, aArea);
}
}
ComplexWidget() {
this->mChildWidgets.pushBack(&mLogin);
this->mChildWidgets.pushBack(&mChatting);
}
void draw(Canvas& canvas) override {
canvas.rect(this->mArea, mBGColor);
if (mLogged) mChatting.draw(canvas);
else mLogin.draw(canvas);
void procCallback(const Events& events) override {
mLogged = mLogin.mLogged;
mLogin.setEnable(!mLogged);
mChatting.setEnable(mLogged);
mLogin.setArea(this->mArea);
mChatting.setArea(this->mArea);
}
void updateConfigCache(WidgetManager& wm) override {
void drawCallback(Canvas& canvas) override { canvas.rect(this->mArea, mBGColor); }
void updateConfigCallback(WidgetManager& wm) override {
wm.setActiveId("ChatGui");
mBGColor = wm.getColor("Back", "Background");
mLogin.updateConfigCache(wm);
mChatting.updateConfigCache(wm);
}
private:

26
Widgets/examples/SimpleGUI.cpp
View file

@ -8,24 +8,24 @@ using namespace tp;
class SimpleGUI : public Application {
public:
SimpleGUI() {
mGui.mContents.append(&mButton);
mGui.mContents.append(&mSlider);
mGui.mContents.append(&mLabel);
mGui.addWidget(&mButton);
mGui.addWidget(&mLabel);
mGui.addWidget(&mSlider);
}
void processFrame(EventHandler* eventHandler) override {
mGui.updateConfigCache(mWidgetManager);
mSlider.updateConfigCache(mWidgetManager);
mLabel.updateConfigCache(mWidgetManager);
mButton.updateConfigCache(mWidgetManager);
const auto rec = RectF({ 0, 0 }, mWindow->getSize());
mGui.proc(*eventHandler, rec, rec);
mGui.setArea(rec);
mGui.setVisible(true);
mGui.updateConfigWrapper(mWidgetManager);
mGui.procWrapper(*eventHandler);
}
void drawFrame(Canvas* canvas) override { mGui.draw(*canvas); }
void drawFrame(Canvas* canvas) override {
canvas->rect(mGui.mArea, { 0, 0, 0, 1 });
mGui.drawWrapper(*canvas);
}
private:
WidgetManager mWidgetManager;
@ -33,7 +33,7 @@ private:
ButtonWidget<EventHandler, Canvas> mButton;
LabelWidget<EventHandler, Canvas> mLabel;
SliderWidget<EventHandler, Canvas> mSlider;
NamedSliderWidget<EventHandler, Canvas> mSlider;
};
int main() {

6
Widgets/private/WidgetConfig.cpp
View file

@ -1,6 +0,0 @@
#include "WidgetBase.hpp"
#include "Graphics.hpp"
namespace tp {}

29
Widgets/public/ButtonWidget.hpp
View file

@ -7,14 +7,20 @@ namespace tp {
template <typename Events, typename Canvas>
class ButtonWidget : public Widget<Events, Canvas> {
public:
ButtonWidget() { this->mArea = { 0, 0, 100, 100 }; }
ButtonWidget(const std::string& label, const tp::RectF& aArea) {
this->mArea = aArea;
this->mLabel.mLabel = label;
ButtonWidget() {
this->setArea({ 0, 0, 100, 100 });
this->mChildWidgets.pushBack(&mLabel);
}
void procBody(const Events& events) {
ButtonWidget(const std::string& label, const tp::RectF& aArea) {
this->setArea(aArea);
mLabel.mLabel = label;
this->mChildWidgets.pushBack(&mLabel);
}
void procCallback(const Events& events) override {
mLabel.setArea(this->mArea);
mIsHover = this->mArea.isInside(events.getPointer());
if (events.isPressed(InputID::MOUSE1) && mIsHover) {
@ -27,11 +33,9 @@ namespace tp {
}
if (!mIsHover) mIsPressed = false;
mLabel.proc(events, this->mArea, this->mArea);
}
void drawBody(Canvas& canvas) override {
void drawCallback(Canvas& canvas) override {
if (mIsPressed) {
canvas.rect(this->mArea, pressedColor, rounding);
} else if (mIsHover) {
@ -39,11 +43,10 @@ namespace tp {
} else {
canvas.rect(this->mArea, accentColor, rounding);
}
mLabel.draw(canvas);
}
public:
void updateConfigCache(WidgetManager& wm) override {
void updateConfigCallback(WidgetManager& wm) override {
wm.setActiveId("Button");
pressedColor = wm.getColor("Pressed", "Action");
@ -52,8 +55,6 @@ namespace tp {
rounding = wm.getNumber("Rounding", "Rounding");
// mPressEvent = wm.getEventState("Activate", { { InputID::MOUSE1, InputState::PRESSED } });
mLabel.updateConfigCache(wm);
}
public:
@ -68,6 +69,6 @@ namespace tp {
RGBA accentColor;
halnf rounding = 0;
InputState mPressEvent;
// InputState mPressEvent;
};
}

4
Widgets/public/LabelWidget.hpp
View file

@ -8,12 +8,12 @@ namespace tp {
public:
LabelWidget() = default;
void drawBody(Canvas& canvas) override {
void drawCallback(Canvas& canvas) override {
canvas.text(mLabel.c_str(), this->mArea, fontSize, Canvas::CC, padding, fontColor);
}
public:
void updateConfigCache(WidgetManager& wm) override {
void updateConfigCallback(WidgetManager& wm) override {
wm.setActiveId("Label");
fontSize = wm.getNumber("Size", "FontSize");

112
Widgets/public/ScrollableWidget.hpp
View file

@ -11,11 +11,7 @@ namespace tp {
ScrollBarWidget() = default;
// takes whole area
void proc(const Events& events, const tp::RectF& areaParent, const tp::RectF& aArea) override {
this->mArea = aArea;
this->mVisible = areaParent.isOverlap(aArea);
if (!this->mVisible) return;
void procCallback(const Events& events) override {
auto area = getHandle();
mHovered = getHandleHandle().isInside(events.getPointer());
@ -24,12 +20,7 @@ namespace tp {
return;
}
if (!areaParent.isOverlap(area)) {
mIsScrolling = false;
return;
}
if (events.getScrollY() != 0 && areaParent.isInside(events.getPointer())) {
if (events.getScrollY() != 0) {
auto offset = events.getScrollY() < 0 ? 1.0f : -1.0f;
if (scrollInertia * offset > 0) {
scrollInertia += offset;
@ -61,9 +52,7 @@ namespace tp {
mPositionFraction = tp::clamp(mPositionFraction, 0.f, 1.f - mSizeFraction);
}
void draw(Canvas& canvas) override {
if (!this->mVisible) return;
void drawCallback(Canvas& canvas) override {
auto area = getHandle();
if (mSizeFraction > 1.f) return;
@ -78,7 +67,6 @@ namespace tp {
}
canvas.rect(area, mDefaultColor, mRounding);
canvas.rect(getHandleHandle(), col, mRounding);
}
@ -104,7 +92,7 @@ namespace tp {
}
public:
void updateConfigCache(WidgetManager& wm) override {
void updateConfigCallback(WidgetManager& wm) override {
wm.setActiveId("Scrollbar");
mDefaultColor = wm.getColor("Default", "Base");
@ -138,99 +126,89 @@ namespace tp {
template <typename Events, typename Canvas>
class ScrollableWindow : public Widget<Events, Canvas> {
public:
ScrollableWindow() = default;
ScrollableWindow() {
this->mChildWidgets.pushBack(&mScroller);
this->mChildWidgets.pushBack(&mContentWidget);
}
~ScrollableWindow() = default;
// takes whole area
void procBody(const Events& events) override {
updateContents();
updateContentSize();
void procCallback(const Events& events) override {
List<Widget<Events, Canvas>*>& content = mContentWidget.mChildWidgets;
updateContents(content);
updateContentSize(content);
const auto padding = mPadding;
mScroller.mSizeFraction = this->mArea.w / mContentSize;
mScroller.proc(events, this->mArea, this->mArea);
mScroller.mSizeFraction = mContentWidget.mArea.w / mContentSize;
mScroller.setArea(this->mArea);
mContentWidget.setArea(mScroller.getViewport());
if (mScroller.mSizeFraction > 1.f) {
setOffset(0);
setOffset(content, 0);
} else {
setOffset((-mScroller.mPositionFraction) * mContentSize);
setOffset(content, (-mScroller.mPositionFraction) * mContentSize);
}
for (auto widget : mContents) {
widget->proc(
events,
this->mArea,
{ this->mArea.x + padding, widget->mArea.y, mScroller.getViewport().z - padding * 2, widget->mArea.w }
);
for (auto widget : content) {
widget->setArea({ mContentWidget.mArea.x + padding,
widget->mArea.y,
mScroller.getViewport().z - padding * 2,
widget->mArea.w });
}
}
void drawBody(Canvas& canvas) override {
mScroller.draw(canvas);
void addWidget(Widget<Events, Canvas>* widget) { mContentWidget.mChildWidgets.pushBack(widget); }
void clearContent() { mContentWidget.mChildWidgets.removeAll(); }
List<Widget<Events, Canvas>*>& getContent() { return mContentWidget.mChildWidgets; }
canvas.pushClamp(this->mArea);
for (auto widget : mContents) {
widget->draw(canvas);
}
canvas.popClamp();
}
public:
void updateConfigCache(WidgetManager& wm) override {
void updateConfigCallback(WidgetManager& wm) override {
wm.setActiveId("ScrollableWidget");
mDefaultColor = wm.getColor("Default", "Base");
mPadding = wm.getNumber("Padding", "Padding");
mScroller.updateConfigCache(wm);
for (auto item : mContents) {
item->updateConfigCache(wm);
}
}
private:
void updateContents() {
if (mContents.size()) {
const halnf offset = mContents.first()->mArea.y + mPadding;
void updateContents(List<Widget<Events, Canvas>*>& contentWidgets) {
if (contentWidgets.size()) {
const halnf offset = contentWidgets.first()->mArea.y + mPadding;
halnf start = 0;
for (auto widget : mContents) {
for (auto widget : contentWidgets) {
widget->mArea.y = start;
start += widget->mArea.w + mPadding;
}
for (auto widget : mContents) {
for (auto widget : contentWidgets) {
widget->mArea.y += offset;
}
}
}
void updateContentSize() {
void updateContentSize(List<Widget<Events, Canvas>*>& contentWidgets) {
mContentSize = 0;
if (mContents.size()) {
mContentSize = mContents.last()->mArea.y - mContents.first()->mArea.y;
mContentSize += mContents.last()->mArea.w;
if (contentWidgets.size()) {
mContentSize = contentWidgets.last()->mArea.y - contentWidgets.first()->mArea.y;
mContentSize += contentWidgets.last()->mArea.w;
mContentSize += 2 * mPadding;
}
}
void setOffset(const halnf offset) {
if (!mContents.size()) return;
auto newOffset = offset - mContents.first()->mArea.y + mPadding;
for (auto widget : mContents) {
void setOffset(List<Widget<Events, Canvas>*>& contentWidgets, const halnf offset) {
if (!contentWidgets.size()) return;
auto newOffset = offset - contentWidgets.first()->mArea.y + mPadding;
for (auto widget : contentWidgets) {
widget->mArea.y += newOffset;
}
}
public:
halnf mContentSize = 0;
Buffer<Widget<Events, Canvas>*> mContents;
private:
Widget<Events, Canvas> mContentWidget;
ScrollBarWidget<Events, Canvas> mScroller;
RGBA mDefaultColor;
halnf mContentSize = 0;
halnf mPadding = 0;
};
}

26
Widgets/public/SliderWidget.hpp
View file

@ -9,7 +9,7 @@ namespace tp {
public:
SliderWidget() = default;
void procBody(const Events& events) override {
void procCallback(const Events& events) override {
if (events.isPressed(InputID::MOUSE1) && this->mArea.isInside(events.getPointer())) {
mIsSliding = true;
} else if (events.isReleased(InputID::MOUSE1)) {
@ -23,7 +23,7 @@ namespace tp {
mFactor = tp::clamp(mFactor, 0.f, 1.f);
}
void drawBody(Canvas& canvas) override {
void drawCallback(Canvas& canvas) override {
canvas.rect(this->mArea, defaultColor, rounding);
canvas.rect(getHandle(), handleColor, rounding);
}
@ -34,7 +34,7 @@ namespace tp {
}
public:
void updateConfigCache(WidgetManager& wm) override {
void updateConfigCallback(WidgetManager& wm) override {
wm.setActiveId("Slider");
defaultColor = wm.getColor("Default", "Base");
handleColor = wm.getColor("Handle", "Accent");
@ -58,32 +58,24 @@ namespace tp {
explicit NamedSliderWidget(const char* name = "Value") {
mLabel.mLabel = name;
this->mArea = { 0, 0, 100, 30 };
this->mChildWidgets.pushBack(&mSlider);
this->mChildWidgets.pushBack(&mLabel);
}
void procBody(const Events& events) override {
void procCallback(const Events& events) override {
const auto widthFirst = this->mArea.z * mFactor;
const auto widthSecond = this->mArea.z * (1.f - mFactor);
RectF rec = this->mArea;
rec.size.x = widthFirst;
mLabel.proc(events, this->mArea, rec);
mLabel.setArea(rec);
rec.pos.x += widthFirst;
rec.size.x = widthSecond;
mSlider.proc(events, this->mArea, rec);
}
void drawBody(Canvas& canvas) override {
mSlider.draw(canvas);
mLabel.draw(canvas);
}
virtual void updateConfigCache(WidgetManager& wm) {
wm.setActiveId("NamedSlider");
mSlider.updateConfigCache(wm);
mLabel.updateConfigCache(wm);
mSlider.setArea(rec);
}
public:

8
Widgets/public/SplitViewWidget.hpp
View file

@ -8,7 +8,8 @@ namespace tp {
public:
SplitView() = default;
void procBody(const Events& events) override {
// takes whole area
void procCallback(const Events& events) override {
mIsHover = getHandle().isInside(events.getPointer());
if (events.isPressed(InputID::MOUSE1) && mIsHover) {
@ -30,8 +31,7 @@ namespace tp {
}
}
// takes whole area
void drawBody(Canvas& canvas) override {
void drawCallback(Canvas& canvas) override {
if (mResizeInProcess) canvas.rect(getHandle(), mResizingColor);
else if (mIsHover) canvas.rect(getHandle(), mHoveredColor);
else canvas.rect(getHandle(), mHandleColor);
@ -53,7 +53,7 @@ namespace tp {
}
public:
void updateConfigCache(WidgetManager& wm) override {
void updateConfigCallback(WidgetManager& wm) override {
wm.setActiveId("SplitView");
mHandleColor = wm.getColor("Handle", "Accent");

4
Widgets/public/TextInputWidget.hpp
View file

@ -11,7 +11,7 @@ namespace tp {
public:
TextInputWidget() = default;
void drawBody(Canvas& canvas) override {
void drawCallback(Canvas&) override {
nChanged = false;
const auto col = mAccentColor;
@ -51,7 +51,7 @@ namespace tp {
}
public:
void updateConfigCache(WidgetManager& wm) override {
void updateConfigCallback(WidgetManager& wm) override {
wm.setActiveId("TextInput");
mAccentColor = wm.getColor("Accent", "Accent");

63
Widgets/public/WidgetBase.hpp
View file

@ -2,42 +2,69 @@
#include "EventHandler.hpp"
#include "WidgetManager.hpp"
#include "List.hpp"
namespace tp {
template <typename Events, typename Canvas>
class Widget {
public:
Widget() { this->mArea = { 0, 0, 100, 100 }; }
Widget() { mArea = { 0, 0, 100, 100 }; }
virtual void proc(const Events& events, const tp::RectF& areaParent, const tp::RectF& aArea) {
mVisible = areaParent.isOverlap(aArea);
if (!mVisible) {
return;
virtual ~Widget() = default;
virtual void procWrapper(const Events& events) {
if (!mEnable) return;
if (!mVisible) return;
procCallback(events);
for (auto child : mChildWidgets) {
const bool isChildVisible = getArea().isOverlap(child->getArea());
child->setVisible(isChildVisible);
child->procWrapper(events);
}
this->mArea = aArea;
this->mAreaParent = areaParent;
procBody(events);
}
virtual void draw(Canvas& canvas) {
if (!mVisible) {
return;
virtual void drawWrapper(Canvas& canvas) {
if (!mEnable) return;
if (!mVisible) return;
drawCallback(canvas);
canvas.pushClamp(this->mArea);
for (auto child : mChildWidgets) {
child->drawWrapper(canvas);
}
drawBody(canvas);
canvas.popClamp();
}
virtual void procBody(const Events& events) {}
virtual void drawBody(Canvas& canvas) {}
virtual void updateConfigWrapper(WidgetManager& wm) {
wm.setActiveId("Global");
virtual void updateConfigCache(WidgetManager& wm) {}
updateConfigCallback(wm);
for (auto child : mChildWidgets) {
child->updateConfigWrapper(wm);
}
}
virtual void procCallback(const Events& events) {}
virtual void drawCallback(Canvas& canvas) {}
virtual void updateConfigCallback(WidgetManager& wm) {}
public:
void setEnable(bool enable) { mEnable = enable; }
void setVisible(bool visible) { mVisible = visible; }
const RectF& getArea() const { return mArea; }
void setArea(const RectF& area) { mArea = area; }
public:
RectF mArea;
RectF mAreaParent;
List<Widget<Events, Canvas>*> mChildWidgets;
bool mVisible = false;
bool mEnable = true;
};
}