383 lines
9.7 KiB
C++
383 lines
9.7 KiB
C++
|
|
#include <algorithm>
|
|
#include "RootWidget.hpp"
|
|
|
|
#include "imgui.h"
|
|
|
|
using namespace tp;
|
|
|
|
void RootWidget::setRootWidget(Widget* widget) {
|
|
mRoot = widget;
|
|
widget->mParent = this;
|
|
}
|
|
|
|
void RootWidget::processFrame(EventHandler* events, const RectF& screenArea) {
|
|
mScreenArea = screenArea;
|
|
|
|
if (mDebug) {
|
|
mScreenArea.size -= { 400, 0 };
|
|
events->setEnableKeyEvents(true);
|
|
if (events->isPressed(InputID::K)) mDebugStopProcessing = !mDebugStopProcessing;
|
|
if (mDebugStopProcessing) return;
|
|
}
|
|
|
|
mRoot->setArea(mScreenArea);
|
|
|
|
// construct hierarchy tree of widgets to process
|
|
updateTreeToProcess();
|
|
|
|
updateAnimations();
|
|
updateAreaCache(mRoot, true);
|
|
|
|
// update all events and call all event processing callbacks
|
|
events->setEnableKeyEvents(true);
|
|
events->setCursorOrigin({ 0, 0 });
|
|
processFocusItems(*events);
|
|
|
|
events->setEnableKeyEvents(false);
|
|
events->setCursorOrigin({ 0, 0 });
|
|
processActiveTree(mRoot, *events, { 0, 0 });
|
|
|
|
updateAreaCache(mRoot, true);
|
|
|
|
// update widget sizes base on individual size policies
|
|
processLayout();
|
|
|
|
updateAreaCache(mRoot, false);
|
|
|
|
// trigger some widgets by moise pointer
|
|
handleFocusChanges(*events);
|
|
|
|
// check triggered widgets for removal
|
|
erase_if(mTriggeredWidgets, [](auto iter) {
|
|
auto widget = iter.first;
|
|
auto flag = iter.second;
|
|
|
|
if (!flag) return false;
|
|
|
|
// if (mWidgetsToProcess.find(widget) == mWidgetsToProcess.end()) return false;
|
|
widget->updateAnimations();
|
|
auto end = !widget->needsNextFrame();
|
|
if (end) {
|
|
widget->endAnimations();
|
|
widget->mDebug.triggerReason = "del";
|
|
}
|
|
return end;
|
|
});
|
|
}
|
|
|
|
bool RootWidget::needsUpdate() const { return !mTriggeredWidgets.empty() || mDebugRedrawAlways; }
|
|
|
|
void RootWidget::debugDrawWidget(Widget* widget) {
|
|
|
|
ImGui::PushID(widget);
|
|
if (ImGui::CollapsingHeader(widget->mDebug.id.c_str())) {
|
|
|
|
ImGui::Text("trigger reason: %s", widget->mDebug.triggerReason.c_str());
|
|
|
|
auto area = widget->getAreaT();
|
|
if (ImGui::InputFloat4("rect", &area.x)) {
|
|
widget->setArea(area);
|
|
}
|
|
|
|
// ImGui::InputFloat2("min size", &widget->mMinSize.x);
|
|
// ImGui::InputFloat2("max size", &widget->mMaxSize.x);
|
|
|
|
// int sizePolicyX = int(widget->mSizePolicy.x);
|
|
// int sizePolicyY = int(widget->mSizePolicy.y);
|
|
// int layout = int(widget->mLayoutPolicy);
|
|
|
|
// if (ImGui::Combo("Size Policy X", &sizePolicyX, "Fixed\0Expanding\0Minimal\0")) {
|
|
// widget->setSizePolicy(SizePolicy(sizePolicyX), SizePolicy(sizePolicyY));
|
|
// }
|
|
|
|
// if (ImGui::Combo("Size Policy Y", &sizePolicyY, "Fixed\0Expanding\0Minimal\0")) {
|
|
// widget->setSizePolicy(SizePolicy(sizePolicyX), SizePolicy(sizePolicyY));
|
|
// }
|
|
|
|
// if (ImGui::Combo("Layout", &layout, "Passive\0Vertical\0Horizontal\0")) {
|
|
// widget->setLayoutPolicy(LayoutPolicy(layout));
|
|
// }
|
|
}
|
|
ImGui::PopID();
|
|
}
|
|
|
|
void RootWidget::drawFrame(Canvas& canvas) {
|
|
// draw from top to bottom
|
|
canvas.rect(mScreenArea, RGBA(0, 0, 0, 1));
|
|
|
|
// draw all tree from top to bottom
|
|
drawRecursion(canvas, mRoot, { 0, 0 });
|
|
|
|
ImGui::Checkbox("Draw debug", &mDebug);
|
|
|
|
if (mDebug) {
|
|
drawDebug(canvas, mRoot, { 0, 0 }, 0);
|
|
|
|
ImGui::Text("Triggered Widgets: %i", (int) mTriggeredWidgets.size());
|
|
ImGui::Text("Widgets To Process: %i", mDebugWidgetsToProcess);
|
|
|
|
ImGui::Text("To Toggle processing press k");
|
|
ImGui::Checkbox("Stop processing", &mDebugStopProcessing);
|
|
ImGui::Checkbox("Force new frames", &mDebugRedrawAlways);
|
|
|
|
if (ImGui::CollapsingHeader("Triggered")) {
|
|
if (ImGui::BeginListBox("##triggered", { -FLT_MIN, 300 })) {
|
|
for (auto widget : mTriggeredWidgets) {
|
|
debugDrawWidget(widget.first);
|
|
}
|
|
ImGui::EndListBox();
|
|
}
|
|
}
|
|
|
|
if (mInFocusWidget) {
|
|
if (ImGui::CollapsingHeader("Under cursor")) {
|
|
if (ImGui::BeginListBox("##under_cursor", { -FLT_MIN, 300 })) {
|
|
for (auto widget = mInFocusWidget; widget && widget != this; widget = widget->mParent) {
|
|
debugDrawWidget(widget);
|
|
}
|
|
ImGui::EndListBox();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void RootWidget::updateTreeToProcess() {
|
|
dfs(mRoot, [](Widget* widget) {
|
|
widget->mNeedsProcessing = false;
|
|
});
|
|
|
|
for (auto& [widget, flag] : mTriggeredWidgets) {
|
|
flag = true;
|
|
|
|
for (auto iter = widget; iter && iter != this; iter = iter->mParent) {
|
|
iter->mNeedsProcessing = true;
|
|
}
|
|
}
|
|
|
|
mDebugWidgetsToProcess = 0;
|
|
dfs(mRoot, [this](Widget*) {
|
|
mDebugWidgetsToProcess++;
|
|
});
|
|
}
|
|
|
|
void RootWidget::drawRecursion(Canvas& canvas, Widget* active, const Vec2F& pos) {
|
|
canvas.setOrigin(pos);
|
|
canvas.pushClamp({ pos, active->getArea().size });
|
|
|
|
active->draw(canvas);
|
|
|
|
for (auto child = active->mDepthOrder.lastNode(); child; child = child->prev) {
|
|
drawRecursion(canvas, child->data, pos + child->data->getArea().pos);
|
|
}
|
|
|
|
canvas.setOrigin(pos);
|
|
canvas.popClamp();
|
|
|
|
active->drawOverlay(canvas);
|
|
}
|
|
|
|
void RootWidget::drawDebug(Canvas& canvas, Widget* active, const Vec2F& pos, int depthOrder) {
|
|
auto area = RectF{ pos, active->getAreaT().size };
|
|
|
|
if (active->mNeedsProcessing) {
|
|
RGBA color = { 1, 0, 0, 1};
|
|
canvas.frame(area, color);
|
|
canvas.text((active->mDebug.id + ":" + std::to_string(depthOrder)).c_str(), area, 22, Canvas::Align::LC, 2, color);
|
|
}
|
|
|
|
if (active->mNeedsProcessing || active->mInFocus) {
|
|
canvas.circle(pos + active->mDebug.pLocal, 5, active->mDebug.col);
|
|
canvas.circle(active->mDebug.pGlobal, 15, active->mDebug.col);
|
|
}
|
|
|
|
if (active->mInFocus) {
|
|
RGBA color = { 1, 0, 0, 0.3f};
|
|
canvas.debugCross(area, color);
|
|
}
|
|
|
|
int orderIdx = 0;
|
|
for (auto child = active->mDepthOrder.lastNode(); child; child = child->prev) {
|
|
drawDebug(canvas, child->data, pos + child->data->getAreaT().pos, orderIdx++);
|
|
}
|
|
}
|
|
|
|
void RootWidget::setWidgetArea(Widget& widget, const RectF& rect) {
|
|
widget.mArea.setTargetRect(rect);
|
|
widget.mArea.endAnimation();
|
|
}
|
|
|
|
void RootWidget::updateAnimations() {
|
|
dfs(mRoot, [](Widget* widget) {
|
|
widget->updateAnimations();
|
|
});
|
|
}
|
|
|
|
void RootWidget::getWidgetPath(Widget* widget, std::vector<Widget*>& out) {
|
|
if (!widget) return;
|
|
|
|
for (auto iter = widget; iter && iter != this; iter = iter->mParent) {
|
|
out.push_back(iter);
|
|
}
|
|
|
|
for (auto i = 0; i < out.size() / 2; i++) {
|
|
swap(out[i], out[out.size() - i - 1]);
|
|
}
|
|
}
|
|
|
|
void RootWidget::handleFocusChanges(EventHandler& events) {
|
|
auto prevFocus = mInFocusWidget;
|
|
|
|
events.setCursorOrigin({ 0, 0 });
|
|
|
|
findFocusWidget(mRoot, &mInFocusWidget, events.getPointer());
|
|
|
|
// if (mInFocusWidget == prevFocus) return;
|
|
if (mInFocusWidget) updateWidget(mInFocusWidget, "focus entered");
|
|
|
|
std::vector<Widget*> path2;
|
|
getWidgetPath(mInFocusWidget, path2);
|
|
size_t propLen2 = path2.size();
|
|
for (auto i = 0; i < path2.size(); i++) {
|
|
if (!path2[i]->propagateEventsToChildren()) {
|
|
propLen2 = i + 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
std::vector<Widget*> path1;
|
|
getWidgetPath(prevFocus, path1);
|
|
size_t propLen1 = path1.size();
|
|
for (auto i = 0; i < path1.size(); i++) {
|
|
if (!path1[i]->propagateEventsToChildren()) {
|
|
propLen1 = i + 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
size_t mostCommonIdx = 0;
|
|
if (!(path1.empty() || path2.empty())) {
|
|
while (path1[mostCommonIdx] == path2[mostCommonIdx] && mostCommonIdx < min(path1.size(), path2.size())) {
|
|
mostCommonIdx++;
|
|
}
|
|
}
|
|
mostCommonIdx--;
|
|
|
|
for (auto i = 0; i < path1.size(); i++) {
|
|
path1[i]->mInFocus = false;
|
|
if (i > mostCommonIdx && i < propLen1) path1[i]->mouseLeave();
|
|
}
|
|
|
|
for (auto i = 0; i < path2.size(); i++) {
|
|
path2[i]->mInFocus = true;
|
|
if (i > mostCommonIdx && i < propLen2) path2[i]->mouseEnter();
|
|
}
|
|
}
|
|
|
|
void RootWidget::findFocusWidget(Widget* iter, Widget** focus, const Vec2F& pointer) {
|
|
if (!iter->mArea.getTargetRect().isInside(pointer)) return;
|
|
|
|
*focus = iter;
|
|
|
|
for (auto child = iter->mDepthOrder.lastNode(); child; child = child->prev) {
|
|
findFocusWidget(child->data, focus, pointer - iter->mArea.getTargetRect().pos);
|
|
}
|
|
}
|
|
|
|
void RootWidget::updateWidget(Widget* widget, const char* reason) {
|
|
DEBUG_ASSERT(reason)
|
|
widget->mDebug.triggerReason = reason;
|
|
mTriggeredWidgets.insert({ widget, false });
|
|
}
|
|
|
|
void RootWidget::updateAreaCache(Widget* iter, bool read) {
|
|
if (!iter || !iter->mNeedsProcessing) return;
|
|
|
|
if (read) {
|
|
iter->mAreaCache = iter->getAreaT();
|
|
} else {
|
|
iter->setArea(iter->mAreaCache);
|
|
iter->mArea.updateCurrentRect();
|
|
}
|
|
|
|
for (auto child : iter->mChildren) {
|
|
if (read) {
|
|
child->mAreaCache = child->getAreaT();
|
|
} else {
|
|
child->setArea(child->mAreaCache);
|
|
child->mArea.updateCurrentRect();
|
|
}
|
|
}
|
|
|
|
for (auto child : iter->mDepthOrder) {
|
|
updateAreaCache(child.data(), read);
|
|
}
|
|
}
|
|
|
|
void RootWidget::processLayout() {
|
|
mLayoutManager.adjust(mRoot);
|
|
}
|
|
|
|
void RootWidget::processActiveTree(Widget* iter, EventHandler& events, Vec2F parent) {
|
|
if (!iter || !iter->mNeedsProcessing) return;
|
|
|
|
auto current = parent + iter->getAreaT().pos;
|
|
|
|
if (!iter->mInFocus) {
|
|
iter->mDebug.pGlobal = current;
|
|
|
|
events.setCursorOrigin(current);
|
|
iter->process(events);
|
|
}
|
|
|
|
for (auto child : iter->mDepthOrder) {
|
|
processActiveTree(child.data(), events, current);
|
|
}
|
|
}
|
|
|
|
void RootWidget::processFocusItems(EventHandler& events) {
|
|
if (!mInFocusWidget) return;
|
|
|
|
// FIXME : cringe
|
|
|
|
std::vector<Widget*> path;
|
|
getWidgetPath(mInFocusWidget, path);
|
|
|
|
size_t len = path.size();
|
|
for (auto i = 0; i < len; i++) {
|
|
if (!path[i]->propagateEventsToChildren()) {
|
|
len = i + 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
std::vector<Vec2F> widgetGlobalPos(path.size());
|
|
|
|
widgetGlobalPos[0] = 0;
|
|
for (auto widget = 0; widget < path.size() - 1; widget++) {
|
|
widgetGlobalPos[widget + 1] = widgetGlobalPos[widget] + path[widget + 1]->getAreaT().pos;
|
|
// path[widget]->mGlobalPoint = widgetGlobalPos[widget];
|
|
}
|
|
|
|
bool eventsProcessed = false;
|
|
|
|
for (int iter = (int) len - 1; iter >= 0; iter--) {
|
|
auto widget = path[iter];
|
|
|
|
events.setCursorOrigin(widgetGlobalPos[iter]);
|
|
|
|
widget->mDebug.pGlobal = widgetGlobalPos[iter];
|
|
|
|
if (!eventsProcessed && widget->processesEvents()) {
|
|
events.setEnableKeyEvents(true);
|
|
widget->process(events);
|
|
|
|
events.setEnableKeyEvents(false);
|
|
eventsProcessed = true;
|
|
} else {
|
|
widget->process(events);
|
|
}
|
|
}
|
|
}
|