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-07 12:04:36 +03:00 • committed by Ilya Shurupov
parent 35cb553ecb
commit 0f8fb5c580
18 changed files with 171 additions and 124 deletions
Download patch file Download diff file Expand all files Collapse all files

2
3DEditor/applications/Entry.cpp
View file

@ -27,7 +27,7 @@ public:
mGui->setArea(rec);
mGui->setVisible(true);
mGui->updateConfigWrapper(mWidgetManager);
mGui->procWrapper(*eventHandler);
mGui->procWrapper(*eventHandler, rec);
}
void drawFrame(Canvas* canvas) override { mGui->drawWrapper(*canvas); }

10
3DEditor/public/EditorWidget.hpp
View file

@ -16,9 +16,9 @@ namespace tp {
~ViewportWidget() { mCanvas->deleteImageHandle(mImage); }
void procCallback(const Events& events) override { mGeometry->mCamera.rotate(0.01f, 0.0); }
void eventProcess(const Events& events) override { mGeometry->mCamera.rotate(0.01f, 0.0); }
void drawCallback(Canvas& canvas) override {
void eventDraw(Canvas& canvas) override {
mRender.render(*mGeometry, this->mArea.size);
canvas.drawImage(this->mArea, &mImage, PI);
}
@ -40,14 +40,14 @@ namespace tp {
this->mChildWidgets.pushBack(&mSplitView);
}
void procCallback(const Events& events) override {
void eventProcess(const Events& events) override {
mSplitView.setArea(this->mArea);
mViewport.setArea(mSplitView.getFirst());
}
void drawCallback(Canvas& canvas) override { canvas.rect(this->mArea, mBaseColor); }
void eventDraw(Canvas& canvas) override { canvas.rect(this->mArea, mBaseColor); }
void updateConfigCallback(WidgetManager& wm) override {
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("3DEditor");
mBaseColor = wm.getColor("Base", "Base");
}

14
Graphics/private/EventHandler.cpp
View file

@ -21,16 +21,16 @@ bool EventHandler::isEvents() {
InputState::State transitions[4][4] = {
{ InputState::State::NONE, InputState::State::PRESSED, InputState::State::PRESSED, InputState::State::NONE },
{ InputState::State::PRESSED, InputState::State::PRESSED, InputState::State::HOLD, InputState::State::PRESSED },
{ InputState::State::HOLD, InputState::State::RELEASED, InputState::State::RELEASED, InputState::State::HOLD },
{ InputState::State::RELEASED, InputState::State::NONE, InputState::State::NONE, InputState::State::RELEASED },
{ InputState::State::PRESSED, InputState::State::HOLD, InputState::State::HOLD, InputState::State::HOLD },
{ InputState::State::HOLD, InputState::State::HOLD, InputState::State::HOLD, InputState::State::RELEASED },
{ InputState::State::NONE, InputState::State::NONE, InputState::State::NONE, InputState::State::NONE },
};
bool transitionsReduce[4][4] = {
{ true, true, false, true },
{ true, true, false, true },
{ true, false, false, true },
{ true, false, true, true },
{ true, true, true, false },
{ true, true, true, false },
{ true, true, true, true },
};
void EventHandler::processEvent() {
@ -55,6 +55,8 @@ void EventHandler::processEvent() {
mInputStates[(int) inputId].mCurrentState = transitions[currentState][reportedEvent];
// printf("%i - %i \n", reportedEvent, mInputStates[(int) InputID::A].mCurrentState);
if (transitionsReduce[currentState][reportedEvent]) {
mEventQueue.popFront();
}

4
Graphics/public/EventHandler.hpp
View file

@ -20,6 +20,7 @@ namespace tp {
enum class ButtonAction {
NONE = 0,
PRESS,
HOLD,
RELEASE,
REPEAT,
} buttonAction = ButtonAction::NONE;
@ -42,7 +43,7 @@ namespace tp {
// Transitions from state to state is strict and defined by state order in the enum
// If posted event conflicts with that automata, we need to emulate intermediate states
enum State {
NONE = 0, // Button is inactive
NONE = 0, // Button is inactive
PRESSED, // Button is pressed
HOLD, // Button is still pressed
RELEASED, // Button is released
@ -61,7 +62,6 @@ namespace tp {
~EventHandler();
public: // Event Poster Interface
// Record event
void postEvent(InputID inputID, InputEvent inputEvent);

2
LibraryViewer/applications/Entry.cpp
View file

@ -20,7 +20,7 @@ public:
gui.setVisible(true);
gui.setArea(rec);
gui.updateConfigWrapper(mWidgetManager);
gui.procWrapper(*eventHandler);
gui.procWrapper(*eventHandler, rec);
}
void drawFrame(Canvas* canvas) override { gui.drawWrapper(*canvas); }

10
LibraryViewer/public/GUI.hpp
View file

@ -18,7 +18,7 @@ namespace tp {
col.mColor.setNoTransition({ 0.15f, 0.15f, 0.15f, 0.f });
};
void procCallback(const Events& events) override {
void eventProcess(const Events& events) override {
mSelected = false;
if (!mTrack) return;
if (this->mArea.isInside(events.getPointer())) {
@ -29,7 +29,7 @@ namespace tp {
}
}
void drawCallback(Canvas& canvas) override {
void eventDraw(Canvas& canvas) override {
if (!mTrack) return;
canvas.rect(this->mArea, col.get(), 4.f);
@ -76,7 +76,7 @@ namespace tp {
items.append({ "Date Last Played" });
}
void drawCallback(Canvas&) override {
void eventDraw(Canvas&) override {
if (!mTrack) return;
// canvas.rect(this->mArea, { 0.13f, 0.13f, 0.13f, 1.f }, 4.f);
renderUI();
@ -210,7 +210,7 @@ namespace tp {
}
}
void procCallback(const Events& events) override {
void eventProcess(const Events& events) override {
filter();
mSplitView.setArea(this->mArea);
@ -228,7 +228,7 @@ namespace tp {
// mCurrentTrack.proc(events, this->mArea, mSplitView.getFirst());
}
void drawCallback(Canvas& canvas) override { canvas.rect(this->mArea, { 0.1f, 0.1f, 0.1f, 1.f }); }
void eventDraw(Canvas& canvas) override { canvas.rect(this->mArea, { 0.1f, 0.1f, 0.1f, 1.f }); }
void filter() {
if (!mCurrentTrackInfo.isSongFilterChanged) return;

2
Sketch3D/applications/Entry.cpp
View file

@ -17,7 +17,7 @@ public:
mGui.setVisible(true);
mGui.setArea(rec);
mGui.updateConfigWrapper(mWidgetManager);
mGui.procWrapper(*eventHandler);
mGui.procWrapper(*eventHandler, rec);
}
void drawFrame(Canvas* canvas) override { mGui.drawWrapper(*canvas); }

18
Sketch3D/public/Sketch3DWidget.hpp
View file

@ -18,7 +18,7 @@ namespace tp {
~Sketch3DWidget() { mCanvas->deleteImageHandle(mImage); }
void procCallback(const Events& events) override {
void eventProcess(const Events& events) override {
if (!this->mArea.isInside(events.getPointer())) {
return;
}
@ -71,7 +71,7 @@ namespace tp {
mActionPosAbsolutePrev = absolutePos;
}
void drawCallback(Canvas& canvas) override {
void eventDraw(Canvas& canvas) override {
mRenderer.renderToTexture(&mProject, this->mArea.size);
canvas.drawImage(this->mArea, &mImage, 0, 1, 12);
}
@ -126,27 +126,27 @@ namespace tp {
}
}
void procCallback(const Events& events) override {
void eventProcess(const Events& events) override {
mSplitView.setArea(this->mArea);
mViewport.setArea(mSplitView.getFirst());
mOptions.setArea(mSplitView.getSecond());
if (mDrawButton->mIsPressed) {
if (mDrawButton->isFired()) {
mViewport.mMode = Sketch3DWidget<Events, Canvas>::Mode::DRAW;
} else if (mMoveButton->mIsPressed) {
} else if (mMoveButton->isFired()) {
mViewport.mMode = Sketch3DWidget<Events, Canvas>::Mode::MOVE;
} else if (mRotateButton->mIsPressed) {
} else if (mRotateButton->isFired()) {
mViewport.mMode = Sketch3DWidget<Events, Canvas>::Mode::ROTATE;
} else if (mZoomButton->mIsPressed) {
} else if (mZoomButton->isFired()) {
mViewport.mMode = Sketch3DWidget<Events, Canvas>::Mode::ZOOM;
}
mViewport.setColor(RGBA(mRed->mSlider.mFactor, mGreen->mSlider.mFactor, mBlue->mSlider.mFactor, 1.f));
}
void drawCallback(Canvas& canvas) override { canvas.rect(this->mArea, mBackgroundColor, mRounding); }
void eventDraw(Canvas& canvas) override { canvas.rect(this->mArea, mBackgroundColor, mRounding); }
void updateConfigCallback(WidgetManager& wm) override {
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("Sketch3DGui");
mBackgroundColor = wm.getColor("Background", "Background");

2
Widgets/examples/ChatGUI.cpp
View file

@ -16,7 +16,7 @@ public:
mGui.setArea(rec);
mGui.setVisible(true);
mGui.procWrapper(*eventHandler);
mGui.procWrapper(*eventHandler, rec);
}
void drawFrame(Canvas* canvas) override { mGui.drawWrapper(*canvas); }

50
Widgets/examples/ChatGUI.hpp
View file

@ -9,19 +9,14 @@ namespace tp {
public:
UserWidget() = default;
void procCallback(const Events& events) override {
this->mArea.w = 30;
mIsHover = this->mArea.isInside(events.getPointer());
}
void drawCallback(Canvas& canvas) override {
if (mIsHover) canvas.rect(this->mArea, mAccentColor, mRounding);
void eventDraw(Canvas& canvas) override {
if (this->isFocus()) 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 updateConfigCallback(WidgetManager& wm) override {
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("UserWidget");
mBaseColor = wm.getColor("Base", "Base");
@ -49,10 +44,8 @@ namespace tp {
public:
MessageWidget() = default;
void procCallback(const Events& events) override { mIsHover = this->mArea.isInside(events.getPointer()); }
void drawCallback(Canvas& canvas) override {
if (mIsHover) canvas.rect(this->mArea, mBaseColor, mRounding);
void eventDraw(Canvas& canvas) override {
if (this->isFocus()) canvas.rect(this->mArea, mBaseColor, mRounding);
auto userName = this->mArea;
userName.w = 25;
@ -65,7 +58,7 @@ namespace tp {
canvas.text(mUser.c_str(), userName, mFontSizeDim, Canvas::LC, mPadding, mUserColor);
}
void updateConfigCallback(WidgetManager& wm) override {
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("MessageWidget");
mBaseColor = wm.getColor("Base", "Base");
@ -104,7 +97,7 @@ namespace tp {
this->mChildWidgets.pushBack(&mButton);
}
void procCallback(const Events& events) override {
void eventProcess(const Events& events) override {
mLogged = false;
const auto xval = this->mArea.z / 2 - 100;
@ -113,16 +106,15 @@ namespace tp {
mPass.setArea({ xval, 50, 200, 30 });
mButton.setArea({ xval, 90, 200, 30 });
if (mButton.mIsReleased) {
mButton.mIsReleased = false;
if (mButton.isFired()) {
mLogged = true;
}
}
void drawCallback(Canvas& canvas) override { canvas.rect(this->mArea, mBGColor); }
void eventDraw(Canvas& canvas) override { canvas.rect(this->mArea, mBGColor); }
public:
void updateConfigCallback(WidgetManager& wm) override {
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("LoginWidget");
mBGColor = wm.getColor("Back", "Base");
}
@ -148,7 +140,7 @@ namespace tp {
this->mChildWidgets.pushBack(&mSend);
}
void procCallback(const Events& events) override {
void eventProcess(const Events& events) override {
auto history = this->mArea;
history.w -= 50;
@ -168,16 +160,12 @@ namespace tp {
mSend.setArea(inputSend);
mMessage.setArea(inputMessage);
if (mSend.mIsReleased) {
mSend.mIsReleased = false;
}
mHistoryView.setArea(history);
}
void drawCallback(Canvas& canvas) override { canvas.rect(this->mArea, mBGColor); }
void eventDraw(Canvas& canvas) override { canvas.rect(this->mArea, mBGColor); }
void updateConfigCallback(WidgetManager& wm) override {
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("ActiveChat");
mBGColor = wm.getColor("Back", "Background");
mPadding = wm.getNumber("Padding", "Padding");
@ -227,15 +215,15 @@ namespace tp {
this->mChildWidgets.pushBack(&mSplitView);
}
void procCallback(const Events& events) override {
void eventProcess(const Events& events) override {
mSplitView.setArea(this->mArea);
mSideView.setArea(mSplitView.getSecond());
mActive.setArea(mSplitView.getFirst());
}
void drawCallback(Canvas& canvas) override { canvas.rect(this->mArea, mBGColor); }
void eventDraw(Canvas& canvas) override { canvas.rect(this->mArea, mBGColor); }
void updateConfigCallback(WidgetManager& wm) override {
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("ChattingWidget");
mBGColor = wm.getColor("Back", "Background");
}
@ -257,7 +245,7 @@ namespace tp {
this->mChildWidgets.pushBack(&mChatting);
}
void procCallback(const Events& events) override {
void eventProcess(const Events& events) override {
mLogged = mLogin.mLogged;
mLogin.setEnable(!mLogged);
@ -267,9 +255,9 @@ namespace tp {
mChatting.setArea(this->mArea);
}
void drawCallback(Canvas& canvas) override { canvas.rect(this->mArea, mBGColor); }
void eventDraw(Canvas& canvas) override { canvas.rect(this->mArea, mBGColor); }
void updateConfigCallback(WidgetManager& wm) override {
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("ChatGui");
mBGColor = wm.getColor("Back", "Background");
}

3
Widgets/examples/SimpleGUI.cpp
View file

@ -17,9 +17,8 @@ public:
const auto rec = RectF({ 0, 0 }, mWindow->getSize());
mGui.setArea(rec);
mGui.setVisible(true);
mGui.updateConfigWrapper(mWidgetManager);
mGui.procWrapper(*eventHandler);
mGui.procWrapper(*eventHandler, rec);
}
void drawFrame(Canvas* canvas) override {

33
Widgets/public/ButtonWidget.hpp
View file

@ -18,27 +18,14 @@ namespace tp {
this->mChildWidgets.pushBack(&mLabel);
}
void procCallback(const Events& events) override {
mLabel.setArea(this->mArea);
bool isFired() { return this->isReleased(); }
mIsHover = this->mArea.isInside(events.getPointer());
void eventProcess(const Events&) override { mLabel.setArea(this->mArea); }
if (events.isPressed(InputID::MOUSE1) && mIsHover) {
mIsPressed = true;
}
if (mIsPressed && mIsHover && events.isReleased(InputID::MOUSE1)) {
mIsReleased = true;
mIsPressed = false;
}
if (!mIsHover) mIsPressed = false;
}
void drawCallback(Canvas& canvas) override {
if (mIsPressed) {
void eventDraw(Canvas& canvas) override {
if (this->isHolding()) {
canvas.rect(this->mArea, pressedColor, rounding);
} else if (mIsHover) {
} else if (this->isFocus()) {
canvas.rect(this->mArea, hoveredColor, rounding);
} else {
canvas.rect(this->mArea, accentColor, rounding);
@ -46,29 +33,21 @@ namespace tp {
}
public:
void updateConfigCallback(WidgetManager& wm) override {
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("Button");
pressedColor = wm.getColor("Pressed", "Action");
hoveredColor = wm.getColor("Hovered", "Interaction");
accentColor = wm.getColor("Default", "Accent");
rounding = wm.getNumber("Rounding", "Rounding");
// mPressEvent = wm.getEventState("Activate", { { InputID::MOUSE1, InputState::PRESSED } });
}
public:
LabelWidget<Events, Canvas> mLabel;
bool mIsHover = false;
bool mIsPressed = false;
bool mIsReleased = false;
RGBA pressedColor;
RGBA hoveredColor;
RGBA accentColor;
halnf rounding = 0;
// InputState mPressEvent;
};
}

4
Widgets/public/LabelWidget.hpp
View file

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

10
Widgets/public/ScrollableWidget.hpp
View file

@ -11,7 +11,7 @@ namespace tp {
ScrollBarWidget() = default;
// takes whole area
void procCallback(const Events& events) override {
void eventProcess(const Events& events) override {
auto area = getHandle();
mHovered = getHandleHandle().isInside(events.getPointer());
@ -52,7 +52,7 @@ namespace tp {
mPositionFraction = tp::clamp(mPositionFraction, 0.f, 1.f - mSizeFraction);
}
void drawCallback(Canvas& canvas) override {
void eventDraw(Canvas& canvas) override {
auto area = getHandle();
if (mSizeFraction > 1.f) return;
@ -92,7 +92,7 @@ namespace tp {
}
public:
void updateConfigCallback(WidgetManager& wm) override {
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("Scrollbar");
mDefaultColor = wm.getColor("Default", "Base");
@ -134,7 +134,7 @@ namespace tp {
~ScrollableWindow() = default;
// takes whole area
void procCallback(const Events& events) override {
void eventProcess(const Events& events) override {
List<Widget<Events, Canvas>*>& content = mContentWidget.mChildWidgets;
updateContents(content);
@ -164,7 +164,7 @@ namespace tp {
void clearContent() { mContentWidget.mChildWidgets.removeAll(); }
List<Widget<Events, Canvas>*>& getContent() { return mContentWidget.mChildWidgets; }
void updateConfigCallback(WidgetManager& wm) override {
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("ScrollableWidget");
mPadding = wm.getNumber("Padding", "Padding");
}

12
Widgets/public/SliderWidget.hpp
View file

@ -9,8 +9,8 @@ namespace tp {
public:
SliderWidget() = default;
void procCallback(const Events& events) override {
if (events.isPressed(InputID::MOUSE1) && this->mArea.isInside(events.getPointer())) {
void eventProcess(const Events& events) override {
if (this->isPressed()) {
mIsSliding = true;
} else if (events.isReleased(InputID::MOUSE1)) {
mIsSliding = false;
@ -19,11 +19,11 @@ namespace tp {
if (mIsSliding) {
mFactor = (events.getPointer().x - this->mArea.x - handleSize / 2.f) / (this->mArea.z - handleSize);
}
mFactor = tp::clamp(mFactor, 0.f, 1.f);
}
void drawCallback(Canvas& canvas) override {
void eventDraw(Canvas& canvas) override {
canvas.rect(this->mArea, defaultColor, rounding);
canvas.rect(getHandle(), handleColor, rounding);
}
@ -34,7 +34,7 @@ namespace tp {
}
public:
void updateConfigCallback(WidgetManager& wm) override {
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("Slider");
defaultColor = wm.getColor("Default", "Base");
handleColor = wm.getColor("Handle", "Accent");
@ -63,7 +63,7 @@ namespace tp {
this->mChildWidgets.pushBack(&mLabel);
}
void procCallback(const Events& events) override {
void eventProcess(const Events& events) override {
const auto widthFirst = this->mArea.z * mFactor;
const auto widthSecond = this->mArea.z * (1.f - mFactor);

6
Widgets/public/SplitViewWidget.hpp
View file

@ -9,7 +9,7 @@ namespace tp {
SplitView() = default;
// takes whole area
void procCallback(const Events& events) override {
void eventProcess(const Events& events) override {
mIsHover = getHandle().isInside(events.getPointer());
if (events.isPressed(InputID::MOUSE1) && mIsHover) {
@ -31,7 +31,7 @@ namespace tp {
}
}
void drawCallback(Canvas& canvas) override {
void eventDraw(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 updateConfigCallback(WidgetManager& wm) override {
void eventUpdateConfiguration(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 drawCallback(Canvas&) override {
void eventDraw(Canvas&) override {
nChanged = false;
const auto col = mAccentColor;
@ -51,7 +51,7 @@ namespace tp {
}
public:
void updateConfigCallback(WidgetManager& wm) override {
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("TextInput");
mAccentColor = wm.getColor("Accent", "Accent");

109
Widgets/public/WidgetBase.hpp
View file

@ -13,58 +13,137 @@ namespace tp {
virtual ~Widget() = default;
virtual void procWrapper(const Events& events) {
virtual void procWrapper(const Events& events, const RectF& parentArea) {
if (!mEnable) return;
checkVisibility(events, parentArea);
if (!mVisible) return;
procCallback(events);
checkFocus(events);
checkClicked(events);
eventProcess(events);
for (auto child : mChildWidgets) {
const bool isChildVisible = getArea().isOverlap(child->getArea());
child->setVisible(isChildVisible);
child->procWrapper(events);
child->procWrapper(events, getArea());
}
}
virtual void drawWrapper(Canvas& canvas) {
if (!mEnable) return;
if (!mVisible) return;
if (!mEnable || !mVisible) return;
drawCallback(canvas);
eventDraw(canvas);
// draw child widgets
canvas.pushClamp(this->mArea);
for (auto child : mChildWidgets) {
child->drawWrapper(canvas);
}
canvas.popClamp();
}
virtual void updateConfigWrapper(WidgetManager& wm) {
wm.setActiveId("Global");
updateConfigCallback(wm);
eventUpdateConfiguration(wm);
for (auto child : mChildWidgets) {
child->updateConfigWrapper(wm);
}
}
virtual void procCallback(const Events& events) {}
virtual void drawCallback(Canvas& canvas) {}
virtual void updateConfigCallback(WidgetManager& wm) {}
virtual void eventProcess(const Events& events) {}
virtual void eventDraw(Canvas& canvas) {}
virtual void eventUpdateConfiguration(WidgetManager& wm) {}
virtual void eventVisible(const Events& events) {}
virtual void eventNotVisible(const Events& events) {}
virtual void eventFocusEnter(const Events& events) {}
virtual void eventFocusLeave(const Events& events) {}
virtual void eventPressed(const Events& events) {}
virtual void eventReleased(const Events& events) {}
public:
void checkVisibility(const Events& events, const RectF& parentArea) {
const bool currentVisibility = parentArea.isOverlap(getArea());
if (currentVisibility != mVisible) {
if (currentVisibility) eventVisible(events);
else eventNotVisible(events);
}
mVisible = currentVisibility;
if (!mVisible) {
mHolding = false;
mPressed = false;
mReleased = false;
}
}
void checkFocus(const Events& events) {
const bool currentFocus = getArea().isInside(events.getPointer());
if (currentFocus != mInFocus) {
if (currentFocus) eventFocusEnter(events);
else eventFocusLeave(events);
}
mInFocus = currentFocus;
if (!mInFocus) {
mHolding = false;
mPressed = false;
mReleased = false;
}
}
void checkClicked(const Events& events) {
mPressed = false;
mReleased = false;
if (!mInFocus) return;
if (mHolding) {
if (events.isReleased(InputID::MOUSE1)) {
eventReleased(events);
mReleased = true;
mHolding = false;
}
} else {
if (events.isPressed(InputID::MOUSE1)) {
eventPressed(events);
mHolding = true;
mPressed = true;
}
}
}
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; }
const RectF& getArea() const { return mArea; }
bool isFocus() const { return mInFocus; }
bool isPressed() const { return mPressed; }
bool isReleased() const { return mReleased; }
bool isHolding() const { return mHolding; }
public:
RectF mArea;
List<Widget<Events, Canvas>*> mChildWidgets;
bool mVisible = false;
bool mEnable = true;
bool mInFocus = false;
bool mHolding = false;
bool mPressed = false;
bool mReleased = false;
};
}