Reorganize code in widgets

WidgetsNew/private/widgets/AnimationTestWidget.cpp

@@ -0,0 +1,28 @@
+#include "AnimationTestWidget.hpp"
+
+using namespace tp;
+
+void AnimationTestWidget::process(const EventHandler& events) {
+	if (events.isDown(tp::InputID::MOUSE1)) {
+		mTestSpring.getStart().setTargetPosition(events.getPointer());
+	}
+
+	if (events.isDown(tp::InputID::MOUSE2)) {
+		mTestSpring.getEnd().setTargetPosition(events.getPointer());
+	}
+
+	mTestSpring.updateCurrentRect();
+
+	if (mTestSpring.shouldEndTransition()) {
+		mTestSpring.endAnimation();
+	}
+}
+
+void AnimationTestWidget::draw(Canvas& canvas) {
+	canvas.rect(getRelativeArea(), { 0, 0, 0, 1 }, 10);
+	canvas.rect(mTestSpring.getCurrentRect(), RGBA(1.f), 10);
+}
+
+bool AnimationTestWidget::needsNextFrame() const {
+	return Widget::needsNextFrame() || !mTestSpring.shouldEndTransition();
+}

WidgetsNew/private/widgets/DockWidget.cpp

@@ -0,0 +1,138 @@
+#include "DockWidget.hpp"
+#include "FloatingWidget.hpp"
+
+using namespace tp;
+
+DockWidget::DockWidget() : Widget() {
+	setDebug("dock", {});
+	setLayout(new DockLayout(this));
+}
+
+void DockWidget::dockWidget(Widget* widget, DockLayout::Side side) {
+	if (layout()->dockWidget(widget, side)) {
+		addChild(widget);
+
+		for (auto child : layout()->getDockedWidgets()) {
+      if (child) child->bringToBack();
+		}
+	}
+}
+
+void DockWidget::undockWidget(DockLayout::Side side, bool restoreArea) {
+	if (layout()->sideExists(side) && side != DockLayout::NONE) {
+		auto widget = layout()->getSideWidget(side);
+
+		widget->bringToFront();
+		if (restoreArea) {
+			widget->setArea(layout()->getRectBeforeDocked(side));
+		} else {
+			// FIXME : widget->endAnimations();
+		}
+
+		layout()->undockWidget(side);
+	}
+}
+
+void DockWidget::setCenterWidget(Widget* widget) {
+	if (layout()->setCenterWidget(widget)) {
+		addChild(widget);
+	}
+}
+
+void DockWidget::toggleWidgetVisibility(DockLayout::Side side) {
+	if (layout()->sideExists(side)) {
+		auto widget = layout()->getSideWidget(side);
+		widget->setEnabled(!layout()->isSideVisible(side));
+		widget->bringToBack();
+
+		layout()->toggleWidgetVisibility(side);
+	}
+}
+
+void DockWidget::process(const EventHandler& events) {
+	// calculateHeaderAreas();
+
+	Widget* floater = nullptr;
+	for (auto child : mChildren) {
+		if (auto iter = dynamic_cast<FloatingWidget*>(child)) {
+			if (iter->isFloating()) {
+				floater = iter;
+				break;
+			}
+		}
+	}
+
+	if (floater) undockWidget(layout()->getSideFromWidget(floater), false);
+
+	if (floater) {
+		layout()->updatePreviewSide(events.getPointer());
+	}
+
+	if (mPreviewWidget && !floater) {
+		dockWidget(mPreviewWidget, layout()->getPreviewSide());
+	}
+
+	mPreviewWidget = floater;
+
+	if (!mPreviewWidget) {
+		layout()->updateResizeHover(events.getPointer());
+
+		if (events.isPressed(InputID::MOUSE1)) {
+			if (layout()->startResize(events.getPointer())) {
+				triggerWidgetUpdate("dock layout resizing");
+			}
+		} else if (events.isReleased(InputID::MOUSE1)) {
+			layout()->endResize();
+		}
+
+		if (layout()->isResizing()) {
+			layout()->updateResize(events.getPointerDelta());
+		}
+	}
+}
+
+bool DockWidget::propagateEventsToChildren() const {
+	return !layout()->isResizing();
+}
+
+bool DockWidget::needsNextFrame() const {
+	return Widget::needsNextFrame() || layout()->isResizing();
+}
+
+void DockWidget::draw(Canvas& canvas) {
+	canvas.rect(getRelativeArea(), mBackgroundColor, 0);
+}
+
+void DockWidget::drawSide(DockLayout::Side side, tp::Canvas& canvas) {
+	auto lay = layout();
+
+	if (lay->isSideVisible(side)) {
+		// header
+		canvas.rect(lay->getHeaderArea(side), mResizeHandleColorActive, 0);
+
+		// resize
+		if (lay->isResizing(side)) {
+			canvas.rect(lay->getResizeHandleArea(side).shrink(mPadding / 1.5f), mResizeHandleColorActive, 0);
+		} else if (lay->isResizeHandleHover(side)) {
+			canvas.rect(lay->getResizeHandleArea(side).shrink(mPadding / 1.5f), mResizeHandleColorHovered, 0);
+		}
+
+	} else {
+		// preview handles
+		if (mPreviewWidget) {
+			// preview active
+			if (lay->getPreviewSide() == side) {
+				canvas.rect(lay->getPreviewArea().shrink(mPadding * 2), mPreviewColor, mRounding);
+			} else {
+				canvas.rect(lay->getPreviewHandleArea(side), mPreviewColor, mRounding);
+			}
+		}
+	}
+}
+
+void DockWidget::drawOverlay(Canvas& canvas) {
+	drawSide(DockLayout::Side::LEFT, canvas);
+	drawSide(DockLayout::Side::RIGHT, canvas);
+	drawSide(DockLayout::Side::TOP, canvas);
+	drawSide(DockLayout::Side::BOTTOM, canvas);
+}

WidgetsNew/private/widgets/FloatingWidget.cpp

@@ -0,0 +1,41 @@
+#include "FloatingWidget.hpp"
+
+using namespace tp;
+
+void FloatingWidget::process(const EventHandler& events) {
+	const auto pointer = events.getPointer();
+
+	if (getRelativeAreaT().isInside(pointer) && events.isPressed(InputID::MOUSE1)) {
+		layout()->startAction(pointer);
+		bringToFront();
+	}
+
+	if (layout()->isFloating() && events.isReleased(InputID::MOUSE1)) {
+		layout()->endAction();
+	}
+
+	layout()->updateAction(pointer);
+}
+
+void FloatingWidget::draw(Canvas& canvas) {
+	canvas.rect(layout()->resizeHandleRect(), RGBA(0.7f), 2);
+	canvas.rect(getRelativeArea(), RGBA(0.5f), 10);
+}
+
+bool FloatingWidget::propagateEventsToChildren() const {
+	return !layout()->isFloating();
+}
+
+bool FloatingWidget::isFloating() const {
+	return layout()->isFloating();
+}
+
+bool FloatingWidget::needsNextFrame() const {
+	return Widget::needsNextFrame() || isFloating();
+}
+
+FloatingLayout* FloatingWidget::layout() { return dynamic_cast<FloatingLayout*>(Widget::getLayout()); }
+
+const FloatingLayout* FloatingWidget::layout() const {
+	return dynamic_cast<const FloatingLayout*>(Widget::getLayout());
+}

WidgetsNew/private/widgets/SimpleWidgets.cpp

@@ -0,0 +1,81 @@
+
+#include "SimpleWidgets.hpp"
+
+using namespace tp;
+
+void LabelWidget::setText(const std::string& text) {
+	mText = text;
+}
+
+const std::string& LabelWidget::getText() const {
+	return mText;
+}
+
+void LabelWidget::draw(Canvas& canvas) {
+	canvas.text(mText.c_str(), getRelativeArea(), mSize, Canvas::LC, mPadding, mColor);
+}
+
+ButtonWidget::ButtonWidget() {
+	mAction = []() {
+		printf("Button Pressed!\n");
+	};
+
+	setDebug("button", { 0.1, 0.1, 0.7, 0.7 });
+
+	mColorAnimated.setTargetColor(mColor);
+	mColorAnimated.endAnimation();
+}
+
+void ButtonWidget::setAction(const std::function<void()>& action) {
+	mAction = action;
+}
+
+void ButtonWidget::setColor(const RGBA& in) {
+	mColor = in;
+	mColorAnimated.setTargetColor(mColor);
+	triggerWidgetUpdate("color changed");
+}
+
+void ButtonWidget::process(const EventHandler& eventHandler) {
+	if (getRelativeArea().isInside(eventHandler.getPointer())) {
+		if (eventHandler.isPressed(InputID::MOUSE1)) {
+			mAction();
+		}
+	}
+}
+
+void ButtonWidget::draw(Canvas& canvas) {
+	canvas.rect(getRelativeArea(), mColorAnimated.getCurrentColor(), mRounding);
+	LabelWidget::draw(canvas);
+}
+
+bool ButtonWidget::needsNextFrame() const {
+	return LabelWidget::needsNextFrame() || !mColorAnimated.shouldEndTransition();
+}
+
+void ButtonWidget::endAnimations() {
+	mColorAnimated.endAnimation();
+	LabelWidget::endAnimations();
+}
+
+void ButtonWidget::updateAnimations() {
+	mColorAnimated.updateCurrentRect();
+	LabelWidget::updateAnimations();
+}
+
+void ButtonWidget::mouseEnter() {
+	mColorAnimated.setTargetColor(mColor);
+	mColorAnimated.endAnimation();
+
+	mColorAnimated.setTargetColor(mColorHovered);
+
+	// mColorAnimated.updateCurrentRect();
+	triggerWidgetUpdate("button hovered");
+}
+
+void ButtonWidget::mouseLeave() {
+	mColorAnimated.setTargetColor(mColor);
+	//mColorAnimated.updateCurrentRect();
+
+	triggerWidgetUpdate("button out of focus");
+}