Update widgets

3DEditor/applications/Entry.cpp

@@ -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); }

3DEditor/public/EditorWidget.hpp

@@ -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");
 		}

Graphics/private/EventHandler.cpp

@@ -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::PRESSED, InputState::State::HOLD, InputState::State::HOLD, InputState::State::HOLD },
-	{ InputState::State::HOLD, InputState::State::RELEASED, InputState::State::RELEASED, InputState::State::HOLD },
+	{ InputState::State::HOLD, InputState::State::HOLD, InputState::State::HOLD, InputState::State::RELEASED },
-	{ InputState::State::RELEASED, InputState::State::NONE, InputState::State::NONE, 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();
 				}

Graphics/public/EventHandler.hpp

@@ -20,6 +20,7 @@ namespace tp {
 		enum class ButtonAction {
 			NONE = 0,
 			PRESS,
+			HOLD,
 			RELEASE,
 			REPEAT,
 		} buttonAction = ButtonAction::NONE;
@@ -61,7 +62,6 @@ namespace tp {
 		~EventHandler();
 
 	public: // Event Poster Interface
-
 		// Record event
 		void postEvent(InputID inputID, InputEvent inputEvent);
 

LibraryViewer/applications/Entry.cpp

@@ -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); }

LibraryViewer/public/GUI.hpp

@@ -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;

Sketch3D/applications/Entry.cpp

@@ -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); }

Sketch3D/public/Sketch3DWidget.hpp

@@ -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");

Widgets/examples/ChatGUI.cpp

@@ -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); }

Widgets/examples/ChatGUI.hpp

@@ -9,19 +9,14 @@ namespace tp {
 	public:
 		UserWidget() = default;
 
-		void procCallback(const Events& events) override {
+		void eventDraw(Canvas& canvas) override {
-			this->mArea.w = 30;
+			if (this->isFocus()) canvas.rect(this->mArea, mAccentColor, mRounding);
-			mIsHover = this->mArea.isInside(events.getPointer());
-		}
-
-		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 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 eventDraw(Canvas& canvas) override {
-
+			if (this->isFocus()) canvas.rect(this->mArea, mBaseColor, mRounding);
-		void drawCallback(Canvas& canvas) override {
-			if (mIsHover) 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) {
+			if (mButton.isFired()) {
-				mButton.mIsReleased = false;
 				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");
 		}

Widgets/examples/SimpleGUI.cpp

@@ -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 {

Widgets/public/ButtonWidget.hpp

@@ -18,27 +18,14 @@ namespace tp {
 			this->mChildWidgets.pushBack(&mLabel);
 		}
 
-		void procCallback(const Events& events) override {
+		bool isFired() { return this->isReleased(); }
-			mLabel.setArea(this->mArea);
 
-			mIsHover = this->mArea.isInside(events.getPointer());
+		void eventProcess(const Events&) override { mLabel.setArea(this->mArea); }
 
-			if (events.isPressed(InputID::MOUSE1) && mIsHover) {
+		void eventDraw(Canvas& canvas) override {
-				mIsPressed = true;
+			if (this->isHolding()) {
-			}
-
-			if (mIsPressed && mIsHover && events.isReleased(InputID::MOUSE1)) {
-				mIsReleased = true;
-				mIsPressed = false;
-			}
-
-			if (!mIsHover) mIsPressed = false;
-		}
-
-		void drawCallback(Canvas& canvas) override {
-			if (mIsPressed) {
 				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;
 	};
 }

Widgets/public/LabelWidget.hpp

@@ -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");

Widgets/public/ScrollableWidget.hpp

@@ -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");
 		}

Widgets/public/SliderWidget.hpp

@@ -9,8 +9,8 @@ namespace tp {
 	public:
 		SliderWidget() = default;
 
-		void procCallback(const Events& events) override {
+		void eventProcess(const Events& events) override {
-			if (events.isPressed(InputID::MOUSE1) && this->mArea.isInside(events.getPointer())) {
+			if (this->isPressed()) {
 				mIsSliding = true;
 			} else if (events.isReleased(InputID::MOUSE1)) {
 				mIsSliding = false;
@@ -23,7 +23,7 @@ namespace tp {
 			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);
 

Widgets/public/SplitViewWidget.hpp

@@ -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");

Widgets/public/TextInputWidget.hpp

@@ -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");

Widgets/public/WidgetBase.hpp

@@ -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->procWrapper(events, getArea());
-				child->setVisible(isChildVisible);
-				child->procWrapper(events);
 			}
 		}
 
 		virtual void drawWrapper(Canvas& canvas) {
-			if (!mEnable) return;
+			if (!mEnable || !mVisible) return;
-			if (!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 eventProcess(const Events& events) {}
-		virtual void drawCallback(Canvas& canvas) {}
+		virtual void eventDraw(Canvas& canvas) {}
-		virtual void updateConfigCallback(WidgetManager& wm) {}
+		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;
 	};
 }