Focus locking and popups

WidgetsNew/private/RootWidget.cpp

@@ -1,7 +1,8 @@
 
 #include "RootWidget.hpp"
-#include "BasicLayout.hpp"
 
+#include "BasicLayout.hpp"
+#include "OverlayLayout.hpp"
 
 #include <algorithm>
 
@@ -13,36 +14,47 @@ WidgetLayout* WidgetManagerInterface::defaultLayout(Widget* widget) {
 
 RootWidget::RootWidget() {
 	setDebug("root", RGBA(1));
+
+	addChild(&mRoot);
+
+	mRoot.addChild(&mPopups);
+	mRoot.setLayout(new OverlayLayout(&mRoot));
+
+	dynamic_cast<BasicLayout*>(mPopups.getLayout())->setLayoutPolicy(LayoutPolicy::Passive);
 }
 
 void RootWidget::setRootWidget(Widget* widget) {
-	mRoot = widget;
-	widget->mParent = this;
+	mRoot.removeChild(mUserRoot);
+	mRoot.addChild(widget);
+
+	widget->bringToBack();
+
+	mUserRoot = widget;
 }
 
 void RootWidget::processFrame(EventHandler* events, const RectF& screenArea) {
-	mRoot->setArea(screenArea);
+	mRoot.setArea(screenArea);
 
 	if (!gDebugWidget.update(this, *events)) return;
 
 	// construct hierarchy tree of widgets to process
-	mUpdateManager.updateTreeToProcess(mRoot);
+	mUpdateManager.updateTreeToProcess(&mRoot);
 
 	updateAnimations();
-	updateAreaCache(mRoot, true);
+	updateAreaCache(&mRoot, true);
 
 	// update all events and call all event processing callbacks
-	mUpdateManager.processWidgets(mRoot, *events);
+	mUpdateManager.processWidgets(&mRoot, *events);
 
-	updateAreaCache(mRoot, true);
+	updateAreaCache(&mRoot, true);
 
 	// update widget sizes base on individual size policies
-	mLayoutManager.adjust(mRoot);
+	mLayoutManager.adjust(&mRoot);
 
-	updateAreaCache(mRoot, false);
+	updateAreaCache(&mRoot, false);
 
 	// trigger some widgets by moise pointer
-  mUpdateManager.handleFocusChanges(mRoot, *events);
+  mUpdateManager.handleFocusChanges(&mRoot, *events);
 
 	// check triggered widgets for removal
 	mUpdateManager.clean();
@@ -54,9 +66,9 @@ bool RootWidget::needsUpdate() const {
 }
 
 void RootWidget::drawFrame(Canvas& canvas) {
-	canvas.rect(mRoot->getAreaT(), RGBA(0, 0, 0, 1));
+	canvas.rect(mRoot.getAreaT(), RGBA(0, 0, 0, 1));
 
-	drawRecursion(canvas, mRoot, { 0, 0 });
+	drawRecursion(canvas, &mRoot, { 0, 0 });
 
 	gDebugWidget.drawDebug(this, canvas);
 }
@@ -86,17 +98,11 @@ void RootWidget::setWidgetArea(Widget& widget, const RectF& rect) {
 }
 
 void RootWidget::updateAnimations() {
-	dfs(mRoot, [](Widget* widget) {
+	dfs(&mRoot, [](Widget* widget) {
 		widget->updateAnimations();
 	});
 }
 
-
-void RootWidget::updateWidget(Widget* widget, const char* reason) {
-	DEBUG_ASSERT(reason)
-	mUpdateManager.scheduleUpdate(widget, reason);
-}
-
 void RootWidget::updateAreaCache(Widget* iter, bool read) {
 	if (!iter || !iter->isUpdate()) return;
 
@@ -119,4 +125,28 @@ void RootWidget::updateAreaCache(Widget* iter, bool read) {
 	for (auto child : iter->mDepthOrder) {
 		updateAreaCache(child.data(), read);
 	}
-}
+}
+
+void RootWidget::updateWidget(Widget* widget, const char* reason) {
+	DEBUG_ASSERT(reason)
+	mUpdateManager.scheduleUpdate(widget, reason);
+}
+
+void RootWidget::openPopup(Widget* widget) {
+	auto relativeArea = widget->getAreaT();
+	for (auto iter = widget->mParent; iter && iter->mParent; iter = iter->mParent) {
+		relativeArea.pos += iter->getAreaT().pos;
+	}
+	setWidgetArea(*widget, relativeArea);
+
+	mPopups.addChild(widget);
+	mUpdateManager.lockFocus(widget);
+}
+
+void RootWidget::closePopup(Widget* widget) {
+	mPopups.removeChild(widget);
+	mUpdateManager.freeFocus(widget);
+}
+
+void RootWidget::lockFocus(Widget* widget) { mUpdateManager.lockFocus(widget); }
+void RootWidget::freeFocus(Widget* widget) { mUpdateManager.freeFocus(widget); }

WidgetsNew/private/Widget.cpp

@@ -97,12 +97,6 @@ WidgetManagerInterface* Widget::getRoot() {
 	return dynamic_cast<WidgetManagerInterface*>(iter);
 }
 
-void Widget::triggerWidgetUpdate(const char* reason) {
-	if (auto root = getRoot()) {
-		root->updateWidget(this, reason);
-	}
-}
-
 void Widget::setAreaCache(const tp::RectF& area) { mAreaCache = area; }
 
 void Widget::setArea(const RectF& area) {
@@ -128,3 +122,26 @@ void Widget::setDebug(const char* name, RGBA col) {
 void Widget::setSizePolicy(SizePolicy x, SizePolicy y) {
 	getLayout()->setSizePolicy(x, y);
 }
+
+void Widget::triggerWidgetUpdate(const char* reason) {
+	if (auto root = getRoot()) {
+		root->updateWidget(this, reason);
+	}
+}
+
+void Widget::openPopup(Widget* widget) {
+	addChild(widget);
+	getRoot()->openPopup(widget);
+}
+
+void Widget::closePopup(Widget* widget) {
+	getRoot()->closePopup(widget);
+}
+
+void Widget::lockFocus() {
+	getRoot()->lockFocus(this);
+}
+
+void Widget::freeFocus() {
+	getRoot()->freeFocus(this);
+}

WidgetsNew/private/layouts/OverlayLayout.cpp

@@ -0,0 +1,29 @@
+
+#include "OverlayLayout.hpp"
+#include "Widget.hpp"
+
+
+using namespace tp;
+
+void OverlayLayout::updateLayout(bool vertical) {
+	if (vertical) return;
+
+	if (children().empty()) return;
+
+	for (auto child : children()) {
+		child->getLayout()->setArea(getArea().relative());
+	}
+
+	/*
+if (children().empty()) return;
+
+auto first = children().front();
+
+first->getLayout()->setArea(getArea().relative());
+
+for (auto child : children()) {
+	if (child == first) continue;
+	child->getLayout()->setArea(getArea().relative());
+}
+	 */
+}

WidgetsNew/private/managers/DebugManager.cpp

@@ -15,9 +15,9 @@ bool DebugManager::update(RootWidget* rootWidget, EventHandler& events) {
 	mRootWidget = rootWidget;
 
 	if (mDebug) {
-		auto area = rootWidget->mRoot->getAreaT();
+		auto area = rootWidget->mRoot.getAreaT();
 		area.size -= { 400, 0 };
-		rootWidget->mRoot->setArea(area);
+		rootWidget->mRoot.setArea(area);
 
 		events.setEnableKeyEvents(true);
 		if (events.isPressed(InputID::K)) mDebugStopProcessing = !mDebugStopProcessing;
@@ -63,7 +63,7 @@ void DebugManager::drawDebug(RootWidget* rootWidget, Canvas& canvas) {
 
 	auto& upd = rootWidget->mUpdateManager;
 
-	recursiveDraw(canvas, rootWidget->mRoot, { 0, 0 }, 0);
+	recursiveDraw(canvas, &rootWidget->mRoot, { 0, 0 }, 0);
 
 	ImGui::Text("Triggered: %i", (int) upd.mTriggeredWidgets.size());
 	ImGui::SameLine(); ImGui::Text("Processing: %i", upd.mDebugWidgetsToProcess);
@@ -140,10 +140,9 @@ void DebugManager::widgetMenu(Widget* widget) {
 		ImGui::InputFloat2("min size", &layout->mMinSize.x);
 		ImGui::InputFloat2("max size", &layout->mMaxSize.x);
 
-		if (auto pBasicLayout = dynamic_cast<BasicLayout*>(widget->getLayout())) {
-			int sizePolicyX = int(pBasicLayout->mSizePolicy.x);
-			int sizePolicyY = int(pBasicLayout->mSizePolicy.y);
-			int policy = int(pBasicLayout->mLayoutPolicy);
+		{
+			int sizePolicyX = int(widget->getLayout()->getSizePolicy().x);
+			int sizePolicyY = int(widget->getLayout()->getSizePolicy().y);
 
 			if (ImGui::Combo("Size Policy X", &sizePolicyX, "Fixed\0Expanding\0Minimal\0")) {
 				widget->setSizePolicy(SizePolicy(sizePolicyX), SizePolicy(sizePolicyY));
@@ -152,7 +151,10 @@ void DebugManager::widgetMenu(Widget* widget) {
 			if (ImGui::Combo("Size Policy Y", &sizePolicyY, "Fixed\0Expanding\0Minimal\0")) {
 				widget->setSizePolicy(SizePolicy(sizePolicyX), SizePolicy(sizePolicyY));
 			}
+		}
 
+		if (auto pBasicLayout = dynamic_cast<BasicLayout*>(widget->getLayout())) {
+			int policy = int(pBasicLayout->mLayoutPolicy);
 			if (ImGui::Combo("Layout", &policy, "Passive\0Vertical\0Horizontal\0")) {
 				pBasicLayout->mLayoutPolicy = LayoutPolicy(policy);
 			}

WidgetsNew/private/managers/UpdateManager.cpp

@@ -74,11 +74,19 @@ void UpdateManager::handleFocusChanges(Widget* root, EventHandler& events) {
 
 	events.setCursorOrigin({ 0, 0 });
 
-	findFocusWidget(root, &mInFocusWidget, events.getPointer());
+	mInFocusWidget = nullptr;
+
+	if (!mFocusLockWidget) {
+		findFocusWidget(root, &mInFocusWidget, events.getPointer());
+	} else {
+		mInFocusWidget = mFocusLockWidget;
+	}
 
 	// if (mInFocusWidget == prevFocus) return;
 	if (mInFocusWidget) scheduleUpdate(mInFocusWidget, "focus entered");
 
+	if (!mInFocusWidget && !prevFocus) return;
+
 	std::vector<Widget*> path2;
 	getWidgetPath(mInFocusWidget, path2);
 	size_t propLen2 = path2.size();
@@ -99,7 +107,7 @@ void UpdateManager::handleFocusChanges(Widget* root, EventHandler& events) {
 		}
 	}
 
-	size_t mostCommonIdx = 0;
+	int mostCommonIdx = 0;
 	if (!(path1.empty() || path2.empty())) {
 		while (path1[mostCommonIdx] == path2[mostCommonIdx] && mostCommonIdx < min(path1.size(), path2.size())) {
 			mostCommonIdx++;
@@ -121,7 +129,9 @@ void UpdateManager::handleFocusChanges(Widget* root, EventHandler& events) {
 void UpdateManager::findFocusWidget(Widget* iter, Widget** focus, const Vec2F& pointer) {
 	if (!iter->mArea.getTargetRect().isInside(pointer) || !iter->mFlags.get(Widget::ENABLED)) return;
 
-	*focus = iter;
+	if (iter->processesEvents()) {
+		*focus = iter;
+	}
 
 	for (auto child = iter->mDepthOrder.lastNode(); child; child = child->prev) {
 		findFocusWidget(child->data, focus, pointer - iter->mArea.getTargetRect().pos);
@@ -148,8 +158,6 @@ void UpdateManager::processActiveTree(Widget* iter, EventHandler& events, Vec2F
 void UpdateManager::processFocusItems(EventHandler& events) {
 	if (!mInFocusWidget) return;
 
-	// FIXME : cringe
-
 	std::vector<Widget*> path;
 	getWidgetPath(mInFocusWidget, path);
 
@@ -191,4 +199,13 @@ void UpdateManager::procWidget(Widget* widget, EventHandler& events, bool withEv
 	events.setEnableKeyEvents(withEvents);
 	gDebugWidget.checkProcBreakPoints(widget);
 	widget->process(events);
+}
+
+void UpdateManager::lockFocus(tp::Widget* widget) {
+	mFocusLockWidget = widget;
+}
+
+void UpdateManager::freeFocus(tp::Widget* widget) {
+	DEBUG_ASSERT(mFocusLockWidget == widget)
+	mFocusLockWidget = nullptr;
 }

WidgetsNew/private/widgets/DockWidget.cpp

@@ -4,7 +4,7 @@
 using namespace tp;
 
 DockWidget::DockWidget() : Widget() {
-	setDebug("dock", {});
+	setDebug("dock", { 1, 1, 1, 1 });
 	setLayout(new DockLayout(this));
 }
 

WidgetsNew/private/widgets/FloatingWidget.cpp

@@ -7,11 +7,14 @@ void FloatingWidget::process(const EventHandler& events) {
 
 	if (getRelativeAreaT().isInside(pointer) && events.isPressed(InputID::MOUSE1)) {
 		layout()->startAction(pointer);
+
 		bringToFront();
+		lockFocus();
 	}
 
 	if (layout()->isFloating() && events.isReleased(InputID::MOUSE1)) {
 		layout()->endAction();
+		freeFocus();
 	}
 
 	layout()->updateAction(pointer);
@@ -22,6 +25,10 @@ void FloatingWidget::draw(Canvas& canvas) {
 	canvas.rect(getRelativeArea(), RGBA(0.5f), 10);
 }
 
+bool FloatingWidget::processesEvents() const {
+	return true;
+}
+
 bool FloatingWidget::propagateEventsToChildren() const {
 	return !layout()->isFloating();
 }
@@ -39,3 +46,4 @@ FloatingLayout* FloatingWidget::layout() { return dynamic_cast<FloatingLayout*>(
 const FloatingLayout* FloatingWidget::layout() const {
 	return dynamic_cast<const FloatingLayout*>(Widget::getLayout());
 }
+