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

New DockspaceWidget Stable

Browse source
This commit is contained in:
IlyaShurupov 2024-06-25 23:27:21 +03:00 • committed by Ilya Shurupov
parent 9cc4819524
commit 242cd93589
8 changed files with 339 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Widgets/private/ButtonWidget.cpp
View file

@ -16,7 +16,13 @@ ButtonWidget::ButtonWidget(const std::string& label, const tp::RectF& aArea) {
bool ButtonWidget::isFired() { return this->isReleased(); }
void ButtonWidget::eventProcess(const Events&) { mLabel.setArea(this->mArea); }
void ButtonWidget::eventProcess(const Events&) {
mLabel.setArea(this->mArea);
if (isFired()) {
mCallback();
}
}
void ButtonWidget::eventDraw(Canvas& canvas) {
if (this->isHolding()) {

223
Widgets/private/DockspaceWidget.cpp
View file

@ -2,14 +2,90 @@
using namespace tp;
void DockSpaceWidget::eventProcess(const tp::Events& events) {
DockSpaceWidget::DockSpaceWidget() = default;
void DockSpaceWidget::addSideWidget(Widget* widget, Side side) {
if (mSideWidgets[side]) return;
mSideWidgets[side] = widget;
for (auto& order : mSideSplitOrder) {
if (order == -1) {
order = side;
break;
}
}
mChildWidgets.pushBack(widget);
widget->mIsDocked = true;
mSideHidden[side] = false;
}
void DockSpaceWidget::removeSideWidget(Side side) {
if (!mSideWidgets[side]) return;
bool removed = false;
for (ualni i = 0; i < 3; i++) {
if (mSideSplitOrder[i] == side) {
removed = true;
}
if (removed) {
mSideSplitOrder[i] = mSideSplitOrder[i + 1];
}
}
mSideSplitOrder[3] = -1;
auto widget = mSideWidgets[side];
mSideWidgets[side] = nullptr;
widget->mIsDocked = false;
mChildWidgets.removeNode(mChildWidgets.find(widget));
}
void DockSpaceWidget::setCenterWidget(Widget* widget) {
mChildWidgets.removeNode(mChildWidgets.find(mCenterWidget));
mCenterWidget = widget;
mChildWidgets.pushBack(mCenterWidget);
}
void DockSpaceWidget::toggleHiddenState(DockSpaceWidget::Side side) {
if (!isSideExists(side)) return;
mSideHidden[side] = !mSideHidden[side];
}
void DockSpaceWidget::eventProcess(const tp::Events& events) {
updateActiveWindow(events);
calculateSideAreas();
calculateResizeHandles();
// calculateHeaderAreas();
handleResizeEvents(events);
updateChildSideWidgets();
}
void DockSpaceWidget::eventDraw(Canvas& canvas) {
canvas.rect(this->mArea, mBackgroundColor, 0);
for (auto sizeHandle : mResizeHandles) {
if (sizeHandle->active) {
canvas.rect(sizeHandle->area.shrink(mPadding / 1.5f), mResizeHandleColorActive, 0);
} else if (sizeHandle->hover) {
canvas.rect(sizeHandle->area.shrink(mPadding / 1.5f), mResizeHandleColorHovered, 0);
}
}
for (auto& header : mSideHeaderAreas) {
canvas.rect(header, mResizeHandleColorActive, 0);
}
}
void DockSpaceWidget::updateActiveWindow(const tp::Events& events) {
if (this->mChildWidgets.size() > 1 && events.isPressed(InputID::MOUSE1)) {
Widget* activeChild = nullptr;
for (auto childNode = this->mChildWidgets.firstNode(); childNode; childNode = childNode->next) {
auto child = childNode->data;
if (child->mIsDocked) continue;
if (child->mArea.isInside(events.getPointer())) {
mChildWidgets.detach(childNode);
@ -23,12 +99,151 @@ void DockSpaceWidget::eventProcess(const tp::Events& events) {
if (activeChild) {
for (auto child : this->mChildWidgets) {
if (activeChild != child.data()) child->mHandlesEvents = false;
if (activeChild != child.data() && !child->mIsDocked) child->mHandlesEvents = false;
}
}
}
}
void DockSpaceWidget::eventDraw(Canvas& canvas) {
canvas.rect(this->mArea, RGBA(0, 0, 0, 1), 0);
void DockSpaceWidget::calculateSideAreas() {
auto startArea = this->mArea;
for (ualni i = 0; i < 4; i++) {
const auto side = mSideSplitOrder[i];
if (side == -1) break;
if (mSideHidden[side]) continue;
bool vertical = side == TOP || side == BOTTOM;
bool opposite = side == BOTTOM || side == RIGHT;
const auto maxAbsoluteSize = startArea.size[vertical];
const auto paddingFactor = mSideSizePadding / maxAbsoluteSize;
mSideAbsoluteSize[side] =
clamp(mSideAbsoluteSize[side], maxAbsoluteSize * paddingFactor, maxAbsoluteSize * (1.f - paddingFactor));
auto factor = mSideAbsoluteSize[side] / startArea.size[vertical];
if (opposite) factor = factor * -1 + 1;
if (!vertical) {
const auto first = startArea.splitByFactorHL(factor);
const auto second = startArea.splitByFactorHR(factor);
mSideAreas[side] = side == LEFT ? first : second;
startArea = side == LEFT ? second : first;
} else {
const auto first = startArea.splitByFactorVT(factor);
const auto second = startArea.splitByFactorVB(factor);
mSideAreas[side] = side == TOP ? first : second;
startArea = side == TOP ? second : first;
}
mSideAreas[side] = mSideAreas[side].shrink(mPadding);
}
mCenterArea = startArea.shrink(mPadding);
}
void DockSpaceWidget::calculateResizeHandles() {
mResizeHandles.clear();
RectF rec;
if (isSideVisible(LEFT)) {
rec = { mSideAreas[LEFT].p4(), { mPadding * 2, mSideAreas[LEFT].size.y } };
mResizeHandles.append({ rec, LEFT, 0, mCenterArea.p3().x });
}
if (isSideVisible(RIGHT)) {
rec = { mSideAreas[RIGHT].p1(), { mPadding * 2, mSideAreas[RIGHT].size.y } };
rec.x -= mPadding * 2;
mResizeHandles.append({ rec, RIGHT, mCenterArea.p1().x, rec.p3().x });
}
if (isSideVisible(TOP)) {
rec = { mSideAreas[TOP].p2(), { mSideAreas[TOP].size.x, mPadding * 2 } };
mResizeHandles.append({ rec, TOP, 0, mCenterArea.p2().y });
}
if (isSideVisible(BOTTOM)) {
rec = { mSideAreas[BOTTOM].p1(), { mSideAreas[BOTTOM].size.x, mPadding * 2 } };
rec.y -= mPadding * 2;
mResizeHandles.append({ rec, BOTTOM, mCenterArea.p1().y, rec.p2().y });
}
}
void DockSpaceWidget::handleResizeEvents(const Events& events) {
for (auto resizeHandle : mResizeHandles) {
resizeHandle->hover = false;
if (resizeHandle->area.isInside(events.getPointerPrev())) {
resizeHandle->hover = true;
}
}
if (events.isDown(InputID::MOUSE1)) {
for (auto resizeHandle : mResizeHandles) {
resizeHandle->active = false;
if (resizeHandle->area.isInside(events.getPointerPrev())) {
auto factorDeltaVec = events.getPointerDelta();
halnf factorDelta = factorDeltaVec[(resizeHandle->side == TOP || resizeHandle->side == BOTTOM)];
if (resizeHandle->side == BOTTOM || resizeHandle->side == RIGHT) factorDelta *= -1;
mSideAbsoluteSize[resizeHandle->side] += factorDelta;
resizeHandle->active = true;
}
}
}
}
void DockSpaceWidget::updateChildSideWidgets() {
// Update Child Widgets
{
for (ualni i = 0; i < 4; i++) {
if (!isSideExists(Side(i))) continue;
if (!isSideVisible(Side(i))) {
mSideWidgets[i]->mEnable = false;
} else {
mSideWidgets[i]->setArea(mSideAreas[i]);
mSideWidgets[i]->mEnable = true;
}
}
if (mCenterWidget) mCenterWidget->setArea(mCenterArea);
}
// update depth order
/*
if (mChildWidgets.size() > 1) {
for (auto sideChild : mSideWidgets) {
if (!sideChild) continue;
for (auto childNode = mChildWidgets.firstNode(); childNode; childNode = childNode->next) {
if (childNode->data == sideChild) {
mChildWidgets.detach(childNode);
mChildWidgets.pushBack(childNode);
break;
}
}
}
}
*/
}
void DockSpaceWidget::calculateHeaderAreas() {
for (ualni i = 0; i < 4; i++) {
if (!isSideVisible(Side(i))) continue;
const auto factor = mHeaderSize / mSideAreas[i].size.y;
mSideHeaderAreas[i] = mSideAreas[i].splitByFactorVT(factor);
mSideAreas[i] = mSideAreas[i].splitByFactorVB(factor);
mSideHeaderAreas[i].size.y -= mPadding;
}
}
bool DockSpaceWidget::isSideVisible(DockSpaceWidget::Side side) { return mSideWidgets[side] && !mSideHidden[side]; }
bool DockSpaceWidget::isSideExists(DockSpaceWidget::Side side) { return mSideWidgets[side]; }
ualni DockSpaceWidget::getVisibleSidesSize() {
ualni out = 0;
for (ualni i = 0; i < 4; i++) {
if (isSideVisible(Side(i))) out++;
}
return out;
}