Replace Old Widgets

Widgets/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();
+}

Widgets/private/widgets/DockWidget.cpp

@@ -0,0 +1,138 @@
+#include "DockWidget.hpp"
+#include "FloatingWidget.hpp"
+
+using namespace tp;
+
+DockWidget::DockWidget() : Widget() {
+	setDebug("dock", { 1, 1, 1, 1 });
+	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);
+}

Widgets/private/widgets/FloatingWidget.cpp

@@ -0,0 +1,76 @@
+#include "FloatingWidget.hpp"
+#include "ScrollableLayout.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();
+		lockFocus();
+	}
+
+	if (layout()->isFloating() && events.isReleased(InputID::MOUSE1)) {
+		layout()->endAction();
+		freeFocus();
+	}
+
+	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::processesEvents() const {
+	return true;
+}
+
+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());
+}
+
+FloatingMenu::FloatingMenu() : FloatingWidget() {
+	setDebug("float menu", { 0.0, 0.9, 0.1, 0.7 });
+
+	// addChild(&mMenuLayout);
+
+	addChild(&mHeader);
+	addChild(&mBodyLayout);
+
+	mHeader.setText("Menu");
+
+	mHeader.setSizePolicy(SizePolicy::Expanding, SizePolicy::Minimal);
+	mBodyLayout.setSizePolicy(SizePolicy::Expanding, SizePolicy::Expanding);
+
+	mBodyLayout.setLayout(new ScrollableLayout(&mBodyLayout));
+	mBodyLayout.addChild(&mScrollBar);
+	mBodyLayout.addChild(&mContentWidget);
+
+	mContentWidget.setSizePolicy(SizePolicy::Minimal, SizePolicy::Minimal);
+
+	// getLayout()->setLayoutPolicy(LayoutPolicy::Vertical);
+	// mBodyLayout.getLayout()->setLayoutPolicy(LayoutPolicy::Vertical);
+}
+
+void FloatingMenu::setText(const std::string& text) {
+	mHeader.setText(text);
+}

Widgets/private/widgets/ScrollableWidget.cpp

@@ -0,0 +1,87 @@
+#include "ScrollableWidget.hpp"
+
+using namespace tp;
+
+void ScrollableBarWidget::process(const EventHandler& events) {
+	// all content is visible no need to process anything
+	if (mSizeFactor >= 1) {
+		mScrolling = false;
+		mPosFactor = mSizeFactor / 2.f;
+		freeFocus();
+		return;
+	}
+
+	updateHandleRect();
+
+	auto pointer = events.getPointer();
+	auto size = getArea().size;
+
+	mHandleHovered = getHandleRect().isInside(pointer);
+
+	if (getRelativeAreaT().isInside(pointer) && events.isPressed(InputID::MOUSE1)) {
+		if (!mHandleHovered) {
+			jumpTo((pointer / size)[mVertical]);
+			mStartPos = { 0, 0 };
+		} else {
+			mStartPos = pointer - getHandleRect().center();
+		}
+		mScrolling = true;
+		lockFocus();
+	}
+
+	if (mScrolling && events.isReleased(InputID::MOUSE1)) {
+		mScrolling = false;
+		freeFocus();
+	}
+
+	if (mScrolling) {
+		updateHandleRect();
+		auto dragDelta = (pointer - getHandleRect().center()) - mStartPos;
+		moveBy((dragDelta / size)[mVertical]);
+	}
+}
+
+void ScrollableBarWidget::jumpTo(halnf pos) {
+	mPosFactor = pos;
+	clamp();
+}
+
+void ScrollableBarWidget::moveBy(halnf delta) {
+	mPosFactor += delta;
+	clamp();
+}
+
+void ScrollableBarWidget::updateSizeFactor(halnf factor) {
+	mSizeFactor = factor;
+	clamp();
+}
+
+void ScrollableBarWidget::clamp() {
+	mSizeFactor = ::clamp(mSizeFactor, 0.f, 1.f);
+	mPosFactor = ::clamp(mPosFactor, mSizeFactor / 2, 1.f - mSizeFactor / 2);
+}
+
+void ScrollableBarWidget::draw(Canvas& canvas) {
+	updateHandleRect();
+
+	canvas.rect(getArea().relative(), mBGColor, mRounding);
+
+	auto& handleColor = mScrolling ? mHandleSlideColor : (mHandleHovered ? mHandleHoverColor : mHandleColor);
+	canvas.rect(getHandleRect(), handleColor, mRounding);
+}
+
+void ScrollableBarWidget::updateHandleRect() {
+	auto area = getArea().relative();
+
+	mHandleRect = area;
+	mHandleRect.size[mVertical] = area.size[mVertical] * mSizeFactor;
+	mHandleRect.pos[mVertical] = area.size[mVertical] * mPosFactor;
+
+	mHandleRect.pos[mVertical] -= mHandleRect.size[mVertical] / 2;
+
+	mHandleRect.shrinkFromCenter(mHandlePadding, true);
+}
+
+const RectF& ScrollableBarWidget::getHandleRect() const {
+	return mHandleRect;
+}

Widgets/private/widgets/SimpleWidgets.cpp

@@ -0,0 +1,130 @@
+
+#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");
+}
+
+
+void SliderWidget::process(const EventHandler& events) {
+	const auto pointer = events.getPointer();
+
+	switch (mState) {
+		case SLIDING:
+			if (events.isReleased(InputID::MOUSE1)) {
+				mState = IDLE;
+				freeFocus();
+			}
+
+			mFactor = ((pointer - mHandleSize / 2) / (getArea().relative().size - mHandleSize)).x;
+			mFactor = clamp(mFactor, 0.f, 1.f);
+			break;
+
+		case IDLE:
+		case HOVER:
+			mState = getHandleArea().isInside(pointer) ? HOVER : IDLE;
+			if (getRelativeAreaT().isInside(pointer) && events.isPressed(InputID::MOUSE1)) {
+				mState = SLIDING;
+				lockFocus();
+			}
+			break;
+	}
+}
+
+void SliderWidget::draw(Canvas& canvas) {
+	canvas.rect(getArea().relative(), mColorBG, mRounding);
+
+	switch (mState) {
+		case IDLE: canvas.rect(getHandleArea(), mColorIdle, mRounding); break;
+		case HOVER: canvas.rect(getHandleArea(), mColorHovered, mRounding); break;
+		case SLIDING: canvas.rect(getHandleArea(), mColorActive, mRounding); break;
+	}
+}
+
+RectF SliderWidget::getHandleArea() const {
+	auto area = getArea().relative();
+
+	const auto& size = area.size;
+	auto center = area.center();
+	auto tilt = -(mFactor - 0.5f) * 2;
+
+	area.pos.x = center.x - (tilt * ((size.x - mHandleSize) / 2)) - mHandleSize / 2;
+	area.size.x = mHandleSize;
+
+	return area;
+}