ilusha/Modules
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

gui updates

Browse source
This commit is contained in:
IlyaShurupov 2024-06-24 22:21:10 +03:00
parent 05ac11b24c
commit b8f125b472
42 changed files with 1179 additions and 962 deletions
Download patch file Download diff file Expand all files Collapse all files

48
Widgets/public/ButtonWidget.hpp
View file

@ -4,50 +4,20 @@
namespace tp {
template <typename Events, typename Canvas>
class ButtonWidget : public Widget<Events, Canvas> {
class ButtonWidget : public Widget {
public:
ButtonWidget() {
this->setArea({ 0, 0, 100, 30 });
this->mChildWidgets.pushBack(&mLabel);
}
ButtonWidget(const std::string& label, const tp::RectF& aArea) {
this->setArea(aArea);
mLabel.mLabel = label;
this->mChildWidgets.pushBack(&mLabel);
}
bool isFired() { return this->isReleased(); }
void eventProcess(const Events&) override { mLabel.setArea(this->mArea); }
void eventDraw(Canvas& canvas) override {
if (this->isHolding()) {
canvas.rect(this->mArea, pressedColor, rounding);
} else if (this->isFocus()) {
canvas.rect(this->mArea, hoveredColor, rounding);
} else {
canvas.rect(this->mArea, accentColor, rounding);
}
}
void setLabel(const std::string& string) {
mLabel.mLabel = string;
}
ButtonWidget();
ButtonWidget(const std::string& label, const tp::RectF& aArea);
bool isFired();
void eventProcess(const Events&) override;
void eventDraw(Canvas& canvas) override;
void setLabel(const std::string& string);
public:
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");
}
void eventUpdateConfiguration(WidgetManager& wm) override;
public:
LabelWidget<Events, Canvas> mLabel;
LabelWidget mLabel;
RGBA pressedColor;
RGBA hoveredColor;

103
Widgets/public/CollapsableMenu.hpp
View file

@ -5,104 +5,31 @@
namespace tp {
template <typename Events, typename Canvas>
class CollapsableMenu : public Widget<Events, Canvas> {
class CollapsableMenu : public Widget {
public:
CollapsableMenu() {
this->mChildWidgets.pushBack(&mHeader);
this->mChildWidgets.pushBack(&mBody);
}
void eventProcess(const Events&) override {
if (mHeader.isReleased()) {
toggleCollapsed();
}
updateGeometry();
}
void eventDraw(Canvas& canvas) override {
canvas.rect(this->mArea, mBorderColor, rounding);
canvas.rect(this->mArea.shrink(mBorderSize), mMenuColor, rounding);
}
CollapsableMenu();
void eventProcess(const Events&) override;
void eventDraw(Canvas& canvas) override;
public:
void addWidgetToMenu(Widget<Events, Canvas>* widget) {
mBody.addWidget(widget);
}
void addWidgetToMenu(Widget* widget);
void setLabel(const std::string& string);
void setLabel(const std::string& string) {
mHeader.mLabel = string;
}
void toggleCollapsed() {
setCollapsed(!getCollapsed());
}
void setCollapsed(bool collapsed) {
if (mLocked) return;
if (collapsed && !mCollapsed) mPrevHeight = this->mArea.size.y;
if (!collapsed && mCollapsed) this->mArea.size.y = mPrevHeight;
mCollapsed = collapsed;
}
[[nodiscard]] bool getCollapsed() const{
return mCollapsed;
}
void updateGeometry() {
mHeader.setArea(getHeaderRect());
mBody.mEnable = !mCollapsed;
if (mCollapsed) {
this->mArea.size.y = headerHeight;
} else {
if (mAdjustHeight) {
this->mArea.size.y = headerHeight + getBodyRect().size.y + mPadding * 2;
}
mBody.setArea(getBodyRect());
}
}
void toggleCollapsed();
void setCollapsed(bool collapsed);
[[nodiscard]] bool getCollapsed() const;
void updateGeometry();
private:
RectF getHeaderRect() {
RectF out = { this->mArea.pos, { this->mArea.size.x, headerHeight } };
return out.shrink(mPadding);
}
RectF getBodyRect() {
RectF out = { { this->mArea.pos.x, this->mArea.pos.y + headerHeight },
{ this->mArea.size.x, this->mArea.size.y - headerHeight - mPadding }
};
out.size.y -= mBorderSize * 2;
if (mAdjustHeight) out.size.y = mBody.getContentSize();
if (mBody.getContentSize()) {
out = out.shrink(mPadding);
out.size.y += mPadding * 2 + 1;
}
return out;
}
RectF getHeaderRect();
RectF getBodyRect();
public:
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("CollapsableMenu");
headerHeight = wm.getNumber("HeaderHeight", 35);
mMenuColor = wm.getColor("MenuColor", RGBA(0, 0, 0, 1.f));
rounding = wm.getNumber("Rounding", "Rounding");
mBorderColor = wm.getColor("BorderColor", RGBA(0.16, 0.16, 0.16, 1.f));
mBorderSize = wm.getNumber("BorderSize", 2.f);
mPadding = wm.getNumber("Padding", "Padding");
}
void eventUpdateConfiguration(WidgetManager& wm) override;
protected:
ScrollableWindow<Events, Canvas> mBody;
LabelWidget<Events, Canvas> mHeader;
ScrollableWindow mBody;
LabelWidget mHeader;
RGBA mMenuColor;
RGBA mBorderColor;

83
Widgets/public/FloatingWidget.hpp
View file

@ -3,85 +3,18 @@
#include "CollapsableMenu.hpp"
namespace tp {
template <typename Events, typename Canvas>
class FloatingWidget : public CollapsableMenu<Events, Canvas> {
class FloatingWidget : public CollapsableMenu {
public:
FloatingWidget() {
this->mArea = { 0, 0, 300, 300 };
this->mAdjustHeight = false;
}
FloatingWidget();
void eventProcess(const Events& events) override {
checkFloating(events);
checkResizing(events);
mActionStartRelativePos = events.getPointer() - this->mArea.pos;
CollapsableMenu<Events, Canvas>::eventProcess(events);
}
void eventDraw(Canvas& canvas) override {
CollapsableMenu<Events, Canvas>::eventDraw(canvas);
if (!this->getCollapsed()) {
auto rect = getResizeHandle();
canvas.rect(rect, mResizeHandleColor, 0);
canvas.circle(rect.pos - this->mBorderSize, rect.w, this->mMenuColor);
}
}
void eventUpdateConfiguration(WidgetManager& wm) override {
CollapsableMenu<Events, Canvas>::eventUpdateConfiguration(wm);
wm.setActiveId("FloatingWidget");
mResizeHandleSize = wm.getNumber("ResizeHandleSize", 15);
mResizeHandleColor = wm.getColor("ResizeHandleColor", RGBA(0.16, 0.16, 0.16, 1.f));
}
void eventProcess(const Events& events) override;
void eventDraw(Canvas& canvas) override;
void eventUpdateConfiguration(WidgetManager& wm) override;
private:
void checkFloating(const Events& events) {
if (this->mHeader.isHolding() && events.getPointerDelta().length2() > 4 ) {
mFloating = true;
}
if (mFloating && this->mHeader.isReleased()) {
mFloating = false;
this->mHeader.clearEvents();
}
if (mFloating) {
auto relativePos = events.getPointer() - this->mArea.pos;
this->mArea.pos += relativePos - mActionStartRelativePos;
}
}
void checkResizing(const Events& events) {
if (this->getCollapsed()) return;
if (events.isPressed(InputID::MOUSE1) && getResizeHandle().isInside(events.getPointer())) {
mResizing = true;
}
if (events.isReleased(InputID::MOUSE1)) {
mResizing = false;
}
if (mResizing) {
auto relativePos = events.getPointer() - this->mArea.pos;
this->mArea.size += relativePos - mActionStartRelativePos;
}
if (!this->mCollapsed) {
this->mArea.size.clamp(mMinSize, { FLT_MAX, FLT_MAX });
}
}
RectF getResizeHandle() {
auto size = Vec2F(mResizeHandleSize);
auto pos = this->mArea.pos + this->mArea.size - size;
return { pos, size };
}
void checkFloating(const Events& events);
void checkResizing(const Events& events);
RectF getResizeHandle();
private:
Vec2F mMinSize = { 70, 70 };

22
Widgets/public/LabelWidget.hpp
View file

@ -3,25 +3,15 @@
#include "WidgetBase.hpp"
namespace tp {
template <typename Events, typename Canvas>
class LabelWidget : public Widget<Events, Canvas> {
public:
LabelWidget() {
this->mArea = { 0, 0, 100, 30 };
}
void eventDraw(Canvas& canvas) override {
canvas.text(mLabel.c_str(), this->mArea, fontSize, Canvas::LC, padding, fontColor);
}
class LabelWidget : public Widget {
public:
LabelWidget();
void eventDraw(Canvas& canvas) override;
public:
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("Label");
fontSize = wm.getNumber("Size", "FontSize");
padding = wm.getNumber("Padding", "Padding");
fontColor = wm.getColor("Default", "Front");
}
void eventUpdateConfiguration(WidgetManager& wm) override;
public:
std::string mLabel = "Label";

194
Widgets/public/ScrollableWidget.hpp
View file

@ -5,109 +5,22 @@
namespace tp {
template <typename Events, typename Canvas>
class ScrollBarWidget : public Widget<Events, Canvas> {
class ScrollBarWidget : public Widget {
public:
ScrollBarWidget() = default;
ScrollBarWidget();
// takes whole area
void eventProcess(const Events& events) override {
auto area = getHandle();
mHovered = getHandleHandle().isInside(events.getPointer());
void eventProcess(const Events& events) override;
void eventDraw(Canvas& canvas) override;
if (mSizeFraction > 1.f) {
mPositionFraction = 0;
return;
}
if (events.getScrollY() != 0) {
auto offset = events.getScrollY() < 0 ? 1.0f : -1.0f;
if (scrollInertia * offset > 0) {
scrollInertia += offset;
} else {
scrollInertia = -scrollInertia + offset;
}
}
if (tp::abs(scrollInertia) > 0.1f) {
auto offset = scrollInertia * mScrollFactor;
mPositionFraction += offset;
mPositionFraction = tp::clamp(mPositionFraction, 0.f, 1.f - mSizeFraction);
scrollInertia *= 0.f;
return;
}
if (events.isPressed(InputID::MOUSE1) && area.isInside(events.getPointer())) {
mIsScrolling = true;
} else if (events.isReleased(InputID::MOUSE1)) {
mIsScrolling = false;
}
if (mIsScrolling) {
tp::halnf pos = events.getPointer().y;
pos = (pos - area.y - mSizeFraction * area.w / 2.f) / area.w;
mPositionFraction = tp::clamp(pos, 0.f, 1.f - mSizeFraction);
}
mPositionFraction = tp::clamp(mPositionFraction, 0.f, 1.f - mSizeFraction);
}
void eventDraw(Canvas& canvas) override {
auto area = getHandle();
if (mSizeFraction > 1.f) return;
// if (!areaParent.isOverlap(getHandle())) return;
tp::RGBA col = mHandleColor;
if (mIsScrolling) {
col = mScrollingColor;
} else if (mHovered) {
col = mHoveredColor;
}
canvas.rect(area, mDefaultColor, mRounding);
canvas.rect(getHandleHandle(), col, mRounding);
}
RectF getHandleHandle() const {
auto area = getHandle();
auto sliderSize = tp::clamp(area.w * mSizeFraction, mMinSize * 2, area.w);
auto diffSize = sliderSize - area.w * mSizeFraction;
return { area.x, area.y + (area.w - diffSize) * mPositionFraction, area.z, sliderSize };
}
RectF getViewport() const {
if (mSizeFraction > 1.f) {
return this->mArea;
}
return { this->mArea.x, this->mArea.y, this->mArea.z - mHandleSize, this->mArea.w };
}
RectF getHandle() const {
return { this->mArea.x + this->mArea.z - mHandleSize + mPadding,
this->mArea.y + mPadding,
mHandleSize - mPadding * 2,
this->mArea.w - mPadding * 2 };
}
RectF getHandleHandle() const;
RectF getViewport() const;
RectF getHandle() const;
public:
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("Scrollbar");
mDefaultColor = wm.getColor("Default", "Base");
mHandleColor = wm.getColor("Handle", "Accent");
mHoveredColor = wm.getColor("Hovered", "Interaction");
mScrollingColor = wm.getColor("Scrolling", "Action");
mPadding = wm.getNumber("Padding", "Padding");
mHandleSize = wm.getNumber("HandleSize", 20.f);
mMinSize = wm.getNumber("MinSize", 20.f);
mRounding = wm.getNumber("Rounding", "Rounding");
}
void eventUpdateConfiguration(WidgetManager& wm) override;
public:
halnf mScrollFactor = 0.f;
halnf scrollInertia = 0.f;
bool mIsScrolling = false;
halnf mSizeFraction = 1.f;
halnf mPositionFraction = 0.f;
@ -123,96 +36,33 @@ namespace tp {
halnf mRounding = 10;
};
template <typename Events, typename Canvas>
class ScrollableWindow : public Widget<Events, Canvas> {
class ScrollableWindow : public Widget {
public:
ScrollableWindow() {
this->mChildWidgets.pushBack(&mScroller);
this->mChildWidgets.pushBack(&mContentWidget);
}
ScrollableWindow();
virtual ~ScrollableWindow() = default;
virtual ~ScrollableWindow();
// takes whole area
void eventProcess(const Events& events) override {
List<Widget<Events, Canvas>*>& content = mContentWidget.mChildWidgets;
void eventProcess(const Events& events) override;
updateContents(content);
updateContentSize(content);
void addWidget(Widget* widget);
void clearContent();
List<Widget*>& getContent();
const auto padding = mPadding;
void eventUpdateConfiguration(WidgetManager& wm) override;
mScroller.mSizeFraction = mContentWidget.mArea.w / mContentSize;
mScroller.setArea(this->mArea);
mContentWidget.setArea(mScroller.getViewport());
if (mScroller.mSizeFraction > 1.f) {
setOffset(content, 0);
} else {
setOffset(content, (-mScroller.mPositionFraction) * mContentSize);
}
for (auto widget : content) {
widget->setArea({ mContentWidget.mArea.x + padding,
mContentWidget.mArea.y + widget->mArea.y,
mScroller.getViewport().z - padding * 2,
widget->mArea.w });
}
}
void addWidget(Widget<Events, Canvas>* widget) { mContentWidget.mChildWidgets.pushBack(widget); }
void clearContent() { mContentWidget.mChildWidgets.removeAll(); }
List<Widget<Events, Canvas>*>& getContent() { return mContentWidget.mChildWidgets; }
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("ScrollableWidget");
mPadding = wm.getNumber("Padding", "Padding");
}
[[nodiscard]] halnf getContentSize() const {
return mContentSize;
}
[[nodiscard]] halnf getContentSize() const;
private:
void updateContents(List<Widget<Events, Canvas>*>& contentWidgets) {
if (!contentWidgets.size()) {
return;
}
const halnf offset = contentWidgets.first()->mArea.y + mPadding;
halnf start = 0;
for (auto widget : contentWidgets) {
widget->mArea.y = start;
start += widget->mArea.w + mPadding;
}
for (auto widget : contentWidgets) {
widget->mArea.y += offset;
}
}
void updateContents(List<Widget*>& contentWidgets);
// ready content size
void updateContentSize(List<Widget<Events, Canvas>*>& contentWidgets) {
mContentSize = 0;
if (contentWidgets.size()) {
mContentSize = contentWidgets.last()->mArea.y - contentWidgets.first()->mArea.y;
mContentSize += contentWidgets.last()->mArea.w;
mContentSize += 2 * mPadding;
}
}
void setOffset(List<Widget<Events, Canvas>*>& contentWidgets, const halnf offset) {
if (!contentWidgets.size()) return;
auto newOffset = offset - contentWidgets.first()->mArea.y + mPadding;
for (auto widget : contentWidgets) {
widget->mArea.y += newOffset;
}
}
void updateContentSize(List<Widget*>& contentWidgets);
void setOffset(List<Widget*>& contentWidgets, const halnf offset);
private:
Widget<Events, Canvas> mContentWidget;
ScrollBarWidget<Events, Canvas> mScroller;
Widget mContentWidget;
ScrollBarWidget mScroller;
halnf mContentSize = 0;

69
Widgets/public/SliderWidget.hpp
View file

@ -4,43 +4,17 @@
namespace tp {
template <typename Events, typename Canvas>
class SliderWidget : public Widget<Events, Canvas> {
class SliderWidget : public Widget {
public:
SliderWidget() = default;
SliderWidget();
void eventProcess(const Events& events) override {
if (this->isPressed()) {
mIsSliding = true;
} else if (events.isReleased(InputID::MOUSE1)) {
mIsSliding = false;
}
void eventProcess(const Events& events) override;
void eventDraw(Canvas& canvas) override;
if (mIsSliding) {
mFactor = (events.getPointer().x - this->mArea.x - handleSize / 2.f) / (this->mArea.z - handleSize);
}
mFactor = tp::clamp(mFactor, 0.f, 1.f);
}
void eventDraw(Canvas& canvas) override {
canvas.rect(this->mArea, defaultColor, rounding);
canvas.rect(getHandle(), handleColor, rounding);
}
RectF getHandle() const {
const auto left = this->mArea.x + (this->mArea.z - handleSize) * mFactor;
return { left, this->mArea.y, handleSize, this->mArea.w };
}
RectF getHandle() const;
public:
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("Slider");
defaultColor = wm.getColor("Default", "Base");
handleColor = wm.getColor("Handle", "Accent");
handleSize = wm.getNumber("HandleSize", 20.f);
rounding = wm.getNumber("Rounding", "Rounding");
}
void eventUpdateConfiguration(WidgetManager& wm) override;
public:
halnf mFactor = 0.f;
@ -52,35 +26,14 @@ namespace tp {
halnf rounding = 0;
};
template <typename Events, typename Canvas>
class NamedSliderWidget : public Widget<Events, Canvas> {
class NamedSliderWidget : public Widget {
public:
explicit NamedSliderWidget(const char* name = "Value") {
mLabel.mLabel = name;
this->mArea = { 0, 0, 100, 30 };
this->mChildWidgets.pushBack(&mSlider);
this->mChildWidgets.pushBack(&mLabel);
}
void eventProcess(const Events& events) override {
const auto widthFirst = this->mArea.z * mFactor;
const auto widthSecond = this->mArea.z * (1.f - mFactor);
RectF rec = this->mArea;
rec.size.x = widthFirst;
mLabel.setArea(rec);
rec.pos.x += widthFirst;
rec.size.x = widthSecond;
mSlider.setArea(rec);
}
explicit NamedSliderWidget(const char* name = "Value");
void eventProcess(const Events& events) override;
public:
SliderWidget<Events, Canvas> mSlider;
LabelWidget<Events, Canvas> mLabel;
SliderWidget mSlider;
LabelWidget mLabel;
halnf mFactor = 0.5f;
};

151
Widgets/public/SplitViewWidget.hpp
View file

@ -6,145 +6,24 @@ namespace tp {
//TODO : clean up this mess
// takes the whole parent area
template <typename Events, typename Canvas>
class SplitView : public Widget<Events, Canvas> {
class SplitView : public Widget {
public:
SplitView() {
mLeftLabel.mLabel = "Left";
mRightLabel.mLabel = "Right";
SplitView();
this->mChildWidgets.pushBack(&mLeftLabel);
this->mChildWidgets.pushBack(&mRightLabel);
}
void eventProcess(const Events& events) override;
void eventDraw(Canvas& canvas) override;
void eventProcess(const Events& events) override {
mIsHover = getHandle().isInside(events.getPointer());
[[nodiscard]] bool getFirstEnabled() const;
[[nodiscard]] bool getSecondEnabled() const;
if (events.isPressed(InputID::MOUSE1) && mIsHover) {
mResizeInProcess = true;
} else if (events.isReleased(InputID::MOUSE1)) {
mResizeInProcess = false;
}
if (mResizeInProcess) {
halnf pos = events.getPointer().x;
auto diff = pos - (this->mArea.x + mFactor * this->mArea.z);
mFactor += diff / this->mArea.z;
}
mFactor = tp::clamp(mFactor, mMinSize / this->mArea.z, 1 - mMinSize / this->mArea.z);
if (mMinSize * 2.f > this->mArea.z) {
mFactor = 0.5f;
}
mLeftLabel.mEnable = mHeaders && mCollapsedSide != LEFT;
mRightLabel.mEnable = mHeaders && mCollapsedSide != RIGHT;
if (mHeaders) {
mLeftLabel.setArea(getFirstHeader());
mRightLabel.setArea(getSecondHeader());
}
if (mLeftLabel.isReleased()) {
mCollapsedSide = (mCollapsedSide == NONE) ? RIGHT : NONE;
}
if (mRightLabel.isReleased()) {
mCollapsedSide = (mCollapsedSide == NONE) ? LEFT : NONE;
}
}
void eventDraw(Canvas& canvas) override {
if (mResizeInProcess) canvas.rect(getHandle(), mResizingColor);
else if (mIsHover) canvas.rect(getHandle(), mHoveredColor);
else canvas.rect(getHandle(), mHandleColor);
}
[[nodiscard]] bool getFirstEnabled() const {
return mCollapsedSide != CollapsedSize::LEFT;
}
[[nodiscard]] bool getSecondEnabled() const {
return mCollapsedSide != CollapsedSize::RIGHT;
}
RectF getFirst() const {
Rect out = { this->mArea.x, this->mArea.y, mFactor * this->mArea.z - mHandleSize / 2.f, this->mArea.w };
if (mCollapsedSide == RIGHT) {
out.pos.x = this->mArea.pos.x;
out.size.x = this->mArea.size.x;
}
if (mHeaders) {
out.pos.y += mHeaderSize;
out.size.y -= mHeaderSize;
}
return out;
}
RectF getFirstHeader() const {
Rect out = { this->mArea.x, this->mArea.y, mFactor * this->mArea.z - mHandleSize / 2.f, mHeaderSize };
if (mCollapsedSide == RIGHT) {
out.pos.x = this->mArea.pos.x;
out.size.x = this->mArea.size.x;
}
return out;
}
RectF getSecondHeader() const {
RectF out = { this->mArea.x + mFactor * this->mArea.z + mHandleSize / 2.f,
this->mArea.y,
(1.f - mFactor) * this->mArea.z - mHandleSize / 2.f,
mHeaderSize };
if (mCollapsedSide == LEFT) {
out.pos.x = this->mArea.pos.x;
out.size.x = this->mArea.size.x;
}
return out;
}
RectF getSecond() const {
RectF out = { this->mArea.x + mFactor * this->mArea.z + mHandleSize / 2.f,
this->mArea.y,
(1.f - mFactor) * this->mArea.z - mHandleSize / 2.f,
this->mArea.w };
if (mCollapsedSide == LEFT) {
out.pos.x = this->mArea.pos.x;
out.size.x = this->mArea.size.x;
}
if (mHeaders) {
out.pos.y += mHeaderSize;
out.size.y -= mHeaderSize;
}
return out;
}
RectF getHandle() const {
if (mCollapsedSide != NONE) return {};
return { this->mArea.x + mFactor * this->mArea.z - mHandleSize / 2.f, this->mArea.y, mHandleSize, this->mArea.w };
}
RectF getFirst() const;
RectF getFirstHeader() const;
RectF getSecondHeader() const;
RectF getSecond() const ;
RectF getHandle() const;
public:
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("SplitView");
mHandleColor = wm.getColor("Handle", "Accent");
mHoveredColor = wm.getColor("Hovered", "Interaction");
mResizingColor = wm.getColor("Resizing", "Action");
mMinSize = wm.getNumber("Min", 200.f);
mHandleSize = wm.getNumber("HandleSize", 7.f);
mHeaderSize = wm.getNumber("HeaderSize", 30.f);
}
void eventUpdateConfiguration(WidgetManager& wm) override;
public:
halnf mFactor = 0.7f;
@ -159,10 +38,10 @@ namespace tp {
// Headers
halnf mHeaderSize = 0;
bool mHeaders = true;
bool mHeaders = false;
enum CollapsedSize { NONE, LEFT, RIGHT } mCollapsedSide = NONE;
LabelWidget<Events, Canvas> mLeftLabel;
LabelWidget<Events, Canvas> mRightLabel;
LabelWidget mLeftLabel;
LabelWidget mRightLabel;
};
}

57
Widgets/public/TextInputWidget.hpp
View file

@ -2,64 +2,15 @@
#include "WidgetBase.hpp"
#include "imgui.h"
#include "imgui_internal.h"
namespace tp {
template <typename Events, typename Canvas>
class TextInputWidget : public Widget<Events, Canvas> {
class TextInputWidget : public Widget {
public:
TextInputWidget() = default;
TextInputWidget();
void eventDraw(Canvas&) override {
nChanged = false;
const auto col = mAccentColor;
const auto colSel = mHoveredColor;
ImGui::GetStyle().Colors[ImGuiCol_FrameBg] = { col.r, col.g, col.b, col.a };
ImGui::GetStyle().Colors[ImGuiCol_TextSelectedBg] = { colSel.r, colSel.g, colSel.b, colSel.a };
ImGui::SetNextWindowPos({ this->mArea.x, this->mArea.y });
ImGui::SetNextWindowSize({ this->mArea.z, this->mArea.w });
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, { 0, 0 });
ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, mRounding * 1.5f);
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, { mPadding, mPadding });
// ImGui::PushID((int) alni(this));
ImGui::Begin(
mId.c_str(),
0,
ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoBackground |
ImGuiWindowFlags_NoResize
);
if (mMultiline) {
if (ImGui::InputTextMultiline("input", mBuff, mMaxBufferSize, { this->mArea.z, this->mArea.w })) {
mValue = mBuff;
nChanged = true;
}
} else {
if (ImGui::InputTextEx("input", mId.c_str(), mBuff, mMaxBufferSize, { this->mArea.z, this->mArea.w }, 0)) {
mValue = mBuff;
nChanged = true;
}
}
ImGui::End();
ImGui::PopStyleVar(3);
}
void eventDraw(Canvas&) override;
public:
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("TextInput");
mAccentColor = wm.getColor("Accent", "Accent");
mBaseColor = wm.getColor("Base", "Base");
mRounding = wm.getNumber("Rounding", "Rounding");
mHoveredColor = wm.getColor("Hovered", "Accent");
mPadding = wm.getNumber("Padding", "Padding");
}
void eventUpdateConfiguration(WidgetManager& wm) override;
public:
enum { mMaxBufferSize = 512 };

156
Widgets/public/WidgetBase.hpp
View file

@ -1,149 +1,59 @@
#pragma once
#include "Graphics.hpp"
#include "EventHandler.hpp"
#include "WidgetManager.hpp"
#include "List.hpp"
namespace tp {
template <typename Events, typename Canvas>
using Events = EventHandler;
class Widget {
public:
Widget() { mArea = { 0, 0, 100, 100 }; }
Widget();
virtual ~Widget();
virtual ~Widget() = default;
void procWrapper(const Events& events, const RectF& parentArea);
void drawWrapper(Canvas& canvas);
void updateConfigWrapper(WidgetManager& wm);
virtual void procWrapper(const Events& events, const RectF& parentArea) {
if (!mEnable) return;
virtual void eventProcess(const Events& events);
virtual void eventDraw(Canvas& canvas);
virtual void eventUpdateConfiguration(WidgetManager& wm);
checkVisibility(events, parentArea);
virtual void eventVisible(const Events& events);
virtual void eventNotVisible(const Events& events);
if (!mVisible) return;
virtual void eventFocusEnter(const Events& events);
virtual void eventFocusLeave(const Events& events);
checkFocus(events);
checkClicked(events);
eventProcess(events);
for (auto child : mChildWidgets) {
child->procWrapper(events, getArea());
}
}
virtual void drawWrapper(Canvas& canvas) {
if (!mEnable || !mVisible) return;
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");
eventUpdateConfiguration(wm);
for (auto child : mChildWidgets) {
child->updateConfigWrapper(wm);
}
}
virtual void eventProcess(const Events& events) {}
virtual void eventDraw(Canvas& canvas) {}
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) {}
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());
void setEnable(bool enable);
void setVisible(bool visible);
void setArea(const RectF& area);
if (currentVisibility != mVisible) {
if (currentVisibility) eventVisible(events);
else eventNotVisible(events);
}
[[nodiscard]] const RectF& getArea() const;
[[nodiscard]] bool isFocus() const;
[[nodiscard]] bool isPressed() const;
[[nodiscard]] bool isReleased() const;
[[nodiscard]] bool isHolding() const;
mVisible = currentVisibility;
void clearEvents();
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; }
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; }
void clearEvents() {
mReleased = false;
mPressed = false;
mHolding = false;
}
private:
void checkVisibility(const Events& events, const RectF& parentArea);
void checkFocus(const Events& events);
void checkClicked(const Events& events);
public:
RectF mArea;
List<Widget<Events, Canvas>*> mChildWidgets;
List<Widget*> mChildWidgets;
bool mVisible = false;
bool mEnable = true;
@ -152,7 +62,5 @@ namespace tp {
bool mHolding = false;
bool mPressed = false;
bool mReleased = false;
// Vec2F mPressedRelativeLocation;
};
}

75
Widgets/public/WidgetManager.hpp
View file

@ -60,77 +60,22 @@ namespace tp {
using Parameter = WidgetConfig::Parameter;
public:
WidgetManager() { initGlobalParameters(); }
~WidgetManager() { mConfigurations.removeAll(); }
WidgetManager();
~WidgetManager();
const RGBA& getColor(const std::string& parameterId, const RGBA& defaultValue) {
WidgetConfig& config = getWidgetConfig(mActiveId);
Parameter& parameter = getParameter(config, parameterId, Parameter(defaultValue));
return parameter.color;
}
const RGBA& getColor(const std::string& parameterId, const RGBA& defaultValue);
const RGBA& getColor(const std::string& parameterId, const char* globalRef);
const RGBA& getColor(const std::string& parameterId, const char* globalRef) {
WidgetConfig& config = getWidgetConfig(mActiveId);
Parameter& parameter = getParameter(config, parameterId, Parameter(globalRef, Parameter::COL));
return parameter.color;
}
halnf getNumber(const std::string& parameterId, halnf defaultValue);
halnf getNumber(const std::string& parameterId, const char* globalRef);
halnf getNumber(const std::string& parameterId, halnf defaultValue) {
WidgetConfig& config = getWidgetConfig(mActiveId);
Parameter& parameter = getParameter(config, parameterId, Parameter(defaultValue));
return parameter.value;
}
halnf getNumber(const std::string& parameterId, const char* globalRef) {
WidgetConfig& config = getWidgetConfig(mActiveId);
Parameter& parameter = getParameter(config, parameterId, Parameter(globalRef, Parameter::VAL));
return parameter.value;
}
void setActiveId(const std::string& id) { mActiveId = id; }
void setActiveId(const std::string& id);
private:
WidgetConfig& getWidgetConfig(const std::string& id) {
auto idx = mConfigurations.presents(id);
if (idx) return mConfigurations.getSlotVal(idx);
mConfigurations.put(id, {});
return mConfigurations.get(id);
}
WidgetConfig& getWidgetConfig(const std::string& id);
Parameter& getParameter(WidgetConfig& config, const std::string& id, const Parameter& defaultValue);
Parameter& getParameter(WidgetConfig& config, const std::string& id, const Parameter& defaultValue) {
auto idx = config.mParameters.presents(id);
if (!idx) {
config.mParameters.put(id, defaultValue);
}
Parameter& parameter = config.mParameters.get(id);
if (parameter.globalReference) {
return mGlobalConfig.mParameters.get(parameter.globalId);
} else {
return parameter;
}
}
void initGlobalParameters() {
auto& params = mGlobalConfig.mParameters;
params.put("FontSize", Parameter(15.f));
params.put("FontSizeDim", Parameter(12.f));
params.put("Rounding", Parameter(5.f));
params.put("Padding", Parameter(5.f));
params.put("HandleSize", Parameter(5.f));
params.put("Background", Parameter(RGBA{ 0.03f, 0.03f, 0.03f, 1.f }));
params.put("Base", Parameter(RGBA{ 0.07f, 0.07f, 0.07f, 1.f }));
params.put("Accent", Parameter(RGBA{ 0.13f, 0.13f, 0.13f, 1.f }));
params.put("Interaction", Parameter(RGBA{ 0.33f, 0.33f, 0.3f, 1.f }));
params.put("Action", Parameter(RGBA{ 0.44f, 0.44f, 0.4f, 1.f }));
params.put("Front", Parameter(RGBA{ 1.f, 1.f, 1.f, 1.f }));
params.put("FrontDim", Parameter(RGBA{ 0.7f, 0.7f, 0.7f, 1.f }));
}
void initGlobalParameters();
private:
Map<std::string, WidgetConfig> mConfigurations;