575 lines
20 KiB
C++
575 lines
20 KiB
C++
// Copyright 2019-Present LexLiu. All Rights Reserved.
|
|
|
|
#include "UIPanelLayoutFlexibleGridComponentVisualizer.h"
|
|
#include "Layout/UIPanelLayout_FlexibleGrid.h"
|
|
#include "LGUIComponentVisualizerModule.h"
|
|
#include "LGUI.h"
|
|
|
|
#if LGUI_CAN_DISABLE_OPTIMIZATION
|
|
PRAGMA_DISABLE_OPTIMIZATION
|
|
#endif
|
|
|
|
#define LOCTEXT_NAMESPACE "UIPanelLayoutFlexibleGridComponentVisualizer"
|
|
|
|
|
|
FUIPanelLayoutFlexibleGridComponentVisualizer::FUIPanelLayoutFlexibleGridComponentVisualizer()
|
|
: FComponentVisualizer()
|
|
{
|
|
SelectionState = NewObject<UUIPanelLayoutFlexibleGridVisualizerSelectionState>(GetTransientPackage(), TEXT("UIPanelLayoutFlexibleGrid_Visualizer_SelectionState"), RF_Transactional);
|
|
}
|
|
void FUIPanelLayoutFlexibleGridComponentVisualizer::DrawVisualization(const UActorComponent* Component, const FSceneView* View, FPrimitiveDrawInterface* PDI)
|
|
{
|
|
auto Layout = Cast<UUIPanelLayout_FlexibleGrid>(Component);
|
|
if (!Layout)return;
|
|
auto UIItem = Layout->GetRootUIComponent();
|
|
if (!UIItem)return;
|
|
|
|
TargetComp = (UUIPanelLayout_FlexibleGrid*)Layout;
|
|
if (TargetComp->GetWorld() != View->Family->Scene->GetWorld())return;
|
|
|
|
auto& Columns = Layout->GetColumns();
|
|
auto& Rows = Layout->GetRows();
|
|
|
|
FVector2D rectSize;
|
|
rectSize.X = UIItem->GetWidth();
|
|
rectSize.Y = UIItem->GetHeight();
|
|
|
|
float columnTotalRatio = 0, rowTotalRatio = 0;
|
|
float columnTotalContstantSize = 0, rowTotalConstantSize = 0;
|
|
for (auto& Item : Columns)
|
|
{
|
|
if (Item.SizeType == EUIPanelLayout_FlexibleGridSizeRule::Ratio)
|
|
{
|
|
columnTotalRatio += Item.Value;
|
|
}
|
|
else
|
|
{
|
|
columnTotalContstantSize += Item.Value;
|
|
}
|
|
}
|
|
for (auto& Item : Rows)
|
|
{
|
|
if (Item.SizeType == EUIPanelLayout_FlexibleGridSizeRule::Ratio)
|
|
{
|
|
rowTotalRatio += Item.Value;
|
|
}
|
|
else
|
|
{
|
|
rowTotalConstantSize += Item.Value;
|
|
}
|
|
}
|
|
float invColumnTotalRatio = 1.0f / columnTotalRatio;
|
|
float invRowTotalRatio = 1.0f / rowTotalRatio;
|
|
float thisFreeWidth = rectSize.X - columnTotalContstantSize;
|
|
float thisFreeHeight = rectSize.Y - rowTotalConstantSize;
|
|
|
|
//darw line at column's left
|
|
float offsetX = 0, offsetY = 0;
|
|
auto lineColor = FLinearColor(0, 1, 1, 1);
|
|
auto handleSize = 10;
|
|
for (int i = 0; i < Columns.Num(); i++)
|
|
{
|
|
auto& item = Columns[i];
|
|
float itemWidth =
|
|
item.SizeType == EUIPanelLayout_FlexibleGridSizeRule::Constant ?
|
|
item.Value :
|
|
item.Value * invColumnTotalRatio * thisFreeWidth
|
|
;
|
|
if (i != 0)
|
|
{
|
|
auto LineStart = FVector(0, UIItem->GetLocalSpaceLeft() + offsetX, UIItem->GetLocalSpaceTop());
|
|
auto LineEnd = FVector(0, LineStart.Y, UIItem->GetLocalSpaceBottom());
|
|
LineStart = UIItem->GetComponentTransform().TransformPosition(LineStart);
|
|
LineEnd = UIItem->GetComponentTransform().TransformPosition(LineEnd);
|
|
//draw split line
|
|
PDI->DrawLine(
|
|
LineStart,
|
|
LineEnd,
|
|
FLinearColor(0, 1, 1, 1),
|
|
SDPG_Foreground
|
|
);
|
|
|
|
PDI->SetHitProxy(new HUIPanelLayoutFlexibleGridSpliterVisProxy(Layout, true, true, i));
|
|
//draw click point
|
|
PDI->DrawPoint(
|
|
LineStart, lineColor, handleSize, SDPG_Foreground
|
|
);
|
|
PDI->SetHitProxy(NULL);
|
|
PDI->SetHitProxy(new HUIPanelLayoutFlexibleGridSpliterVisProxy(Layout, true, false, i));
|
|
PDI->DrawPoint(
|
|
LineEnd, lineColor, handleSize, SDPG_Foreground
|
|
);
|
|
PDI->SetHitProxy(NULL);
|
|
}
|
|
offsetX += itemWidth;
|
|
}
|
|
for (int i = 0; i < Rows.Num(); i++)
|
|
{
|
|
auto item = Rows[i];
|
|
float itemHeight =
|
|
item.SizeType == EUIPanelLayout_FlexibleGridSizeRule::Constant ?
|
|
item.Value :
|
|
item.Value * invRowTotalRatio * thisFreeHeight
|
|
;
|
|
if (i != 0)
|
|
{
|
|
auto LineStart = FVector(0, UIItem->GetLocalSpaceLeft(), UIItem->GetLocalSpaceTop() - offsetY);
|
|
auto LineEnd = FVector(0, UIItem->GetLocalSpaceRight(), LineStart.Z);
|
|
LineStart = UIItem->GetComponentTransform().TransformPosition(LineStart);
|
|
LineEnd = UIItem->GetComponentTransform().TransformPosition(LineEnd);
|
|
//draw split line
|
|
PDI->DrawLine(
|
|
LineStart,
|
|
LineEnd,
|
|
FLinearColor(0, 1, 1, 0.1),
|
|
SDPG_Foreground
|
|
);
|
|
//draw click point
|
|
PDI->SetHitProxy(new HUIPanelLayoutFlexibleGridSpliterVisProxy(Layout, false, true, i));
|
|
PDI->DrawPoint(
|
|
LineStart, lineColor, handleSize, SDPG_Foreground
|
|
);
|
|
PDI->SetHitProxy(NULL);
|
|
PDI->SetHitProxy(new HUIPanelLayoutFlexibleGridSpliterVisProxy(Layout, false, false, i));
|
|
PDI->DrawPoint(
|
|
LineEnd, lineColor, handleSize, SDPG_Foreground
|
|
);
|
|
PDI->SetHitProxy(NULL);
|
|
}
|
|
offsetY += itemHeight;
|
|
}
|
|
|
|
lineColor = FLinearColor(0, 1, 0, 1);
|
|
const float FrameLineThickness = 0.5f;
|
|
auto LeftTop = FVector(0, UIItem->GetLocalSpaceLeft(), UIItem->GetLocalSpaceTop());
|
|
auto RightTop = FVector(0, UIItem->GetLocalSpaceRight(), UIItem->GetLocalSpaceTop());
|
|
auto LeftBottom = FVector(0, UIItem->GetLocalSpaceLeft(), UIItem->GetLocalSpaceBottom());
|
|
auto RightBottom = FVector(0, UIItem->GetLocalSpaceRight(), UIItem->GetLocalSpaceBottom());
|
|
LeftTop = UIItem->GetComponentTransform().TransformPosition(LeftTop);
|
|
RightTop = UIItem->GetComponentTransform().TransformPosition(RightTop);
|
|
LeftBottom = UIItem->GetComponentTransform().TransformPosition(LeftBottom);
|
|
RightBottom = UIItem->GetComponentTransform().TransformPosition(RightBottom);
|
|
//left frame line
|
|
PDI->SetHitProxy(new HUIPanelLayoutFlexibleGridFrameLineVisProxy(Layout, HUIPanelLayoutFlexibleGridFrameLineVisProxy::EFrameType::Left));
|
|
PDI->DrawLine(LeftTop, LeftBottom, lineColor, SDPG_Foreground, FrameLineThickness);
|
|
PDI->SetHitProxy(NULL);
|
|
//top frame line
|
|
PDI->SetHitProxy(new HUIPanelLayoutFlexibleGridFrameLineVisProxy(Layout, HUIPanelLayoutFlexibleGridFrameLineVisProxy::EFrameType::Top));
|
|
PDI->DrawLine(LeftTop, RightTop, lineColor, SDPG_Foreground, FrameLineThickness);
|
|
PDI->SetHitProxy(NULL);
|
|
//right frame line
|
|
PDI->SetHitProxy(new HUIPanelLayoutFlexibleGridFrameLineVisProxy(Layout, HUIPanelLayoutFlexibleGridFrameLineVisProxy::EFrameType::Right));
|
|
PDI->DrawLine(RightBottom, RightTop, lineColor, SDPG_Foreground, FrameLineThickness);
|
|
PDI->SetHitProxy(NULL);
|
|
//bottom frame line
|
|
PDI->SetHitProxy(new HUIPanelLayoutFlexibleGridFrameLineVisProxy(Layout, HUIPanelLayoutFlexibleGridFrameLineVisProxy::EFrameType::Bottom));
|
|
PDI->DrawLine(RightBottom, LeftBottom, lineColor, SDPG_Foreground, FrameLineThickness);
|
|
PDI->SetHitProxy(NULL);
|
|
}
|
|
bool FUIPanelLayoutFlexibleGridComponentVisualizer::VisProxyHandleClick(FEditorViewportClient* InViewportClient, HComponentVisProxy* VisProxy, const FViewportClick& Click)
|
|
{
|
|
if (!TargetComp.IsValid())return false;
|
|
auto UIItem = TargetComp->GetRootUIComponent();
|
|
if (!UIItem)return false;
|
|
|
|
if (VisProxy->IsA(HUIPanelLayoutFlexibleGridSpliterVisProxy::StaticGetType()))
|
|
{
|
|
const HUIPanelLayoutFlexibleGridSpliterVisProxy* Proxy = (HUIPanelLayoutFlexibleGridSpliterVisProxy*)VisProxy;
|
|
SelectionState->ProxyType = UUIPanelLayoutFlexibleGridVisualizerSelectionState::EHitProxyType::Spliter;
|
|
SelectionState->SelectedSpliterIndex = Proxy->SpliterIndex;
|
|
SelectionState->bHorizontalOrVertical = Proxy->bHorizontalOrVertical;
|
|
SelectionState->bFirstOrSecond = Proxy->bFirstOrSecond;
|
|
if (SelectionState->bHorizontalOrVertical)
|
|
{
|
|
if (!TargetComp->GetColumns().IsValidIndex(SelectionState->SelectedSpliterIndex))
|
|
{
|
|
SelectionState->SelectedSpliterIndex = -1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!TargetComp->GetRows().IsValidIndex(SelectionState->SelectedSpliterIndex))
|
|
{
|
|
SelectionState->SelectedSpliterIndex = -1;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
else if (VisProxy->IsA(HUIPanelLayoutFlexibleGridFrameLineVisProxy::StaticGetType()))
|
|
{
|
|
const HUIPanelLayoutFlexibleGridFrameLineVisProxy* Proxy = (HUIPanelLayoutFlexibleGridFrameLineVisProxy*)VisProxy;
|
|
SelectionState->ProxyType = UUIPanelLayoutFlexibleGridVisualizerSelectionState::EHitProxyType::Frame;
|
|
SelectionState->FrameType = Proxy->FrameType;
|
|
auto Plane = FPlane(UIItem->GetComponentLocation(), UIItem->GetForwardVector());
|
|
SelectionState->CurrentClickPoint = FMath::RayPlaneIntersection(Click.GetOrigin(), Click.GetDirection(), Plane);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
bool FUIPanelLayoutFlexibleGridComponentVisualizer::HandleInputDelta(FEditorViewportClient* ViewportClient, FViewport* Viewport, FVector& DeltaTranslate, FRotator& DeltalRotate, FVector& DeltaScale)
|
|
{
|
|
if (!DeltaTranslate.IsZero())
|
|
{
|
|
if (!TargetComp.IsValid())return false;
|
|
|
|
auto UIItem = TargetComp->GetRootUIComponent();
|
|
if (!UIItem)return true;
|
|
if (SelectionState->SelectedSpliterIndex == -1)return true;
|
|
|
|
TargetComp->Modify();
|
|
|
|
auto LocalSpaceTranslate = UIItem->GetComponentTransform().InverseTransformVector(DeltaTranslate);
|
|
if (SelectionState->bHorizontalOrVertical)
|
|
{
|
|
if (LocalSpaceTranslate.Y != 0)
|
|
{
|
|
LayoutChangeSizeToPixelRelevant(true);
|
|
auto Columns = TargetComp->GetColumns();
|
|
auto& ColumnItem = Columns[SelectionState->SelectedSpliterIndex];
|
|
auto& PrevColumnItem = Columns[SelectionState->SelectedSpliterIndex - 1];
|
|
ColumnItem.Value -= LocalSpaceTranslate.Y;
|
|
PrevColumnItem.Value += LocalSpaceTranslate.Y;
|
|
if (ColumnItem.Value > 0 && PrevColumnItem.Value > 0)
|
|
{
|
|
TargetComp->SetColumns(Columns);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (LocalSpaceTranslate.Z != 0)
|
|
{
|
|
LayoutChangeSizeToPixelRelevant(false);
|
|
auto Rows = TargetComp->GetRows();
|
|
auto& RowItem = Rows[SelectionState->SelectedSpliterIndex];
|
|
auto& PrevRowItem = Rows[SelectionState->SelectedSpliterIndex - 1];
|
|
RowItem.Value += LocalSpaceTranslate.Z;
|
|
PrevRowItem.Value -= LocalSpaceTranslate.Z;
|
|
if (RowItem.Value > 0 && PrevRowItem.Value > 0)
|
|
{
|
|
TargetComp->SetRows(Rows);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
bool FUIPanelLayoutFlexibleGridComponentVisualizer::GetWidgetLocation(const FEditorViewportClient* ViewportClient, FVector& OutLocation) const
|
|
{
|
|
if (!TargetComp.IsValid())return false;
|
|
|
|
auto UIItem = TargetComp->GetRootUIComponent();
|
|
if (!UIItem)return false;
|
|
|
|
if (SelectionState->ProxyType == UUIPanelLayoutFlexibleGridVisualizerSelectionState::EHitProxyType::Frame)return false;
|
|
if (SelectionState->SelectedSpliterIndex == -1)return false;
|
|
|
|
auto& Columns = TargetComp->GetColumns();
|
|
auto& Rows = TargetComp->GetRows();
|
|
|
|
FVector2D rectSize;
|
|
rectSize.X = UIItem->GetWidth();
|
|
rectSize.Y = UIItem->GetHeight();
|
|
|
|
float columnTotalRatio = 0, rowTotalRatio = 0;
|
|
float columnTotalContstantSize = 0, rowTotalConstantSize = 0;
|
|
for (auto& Item : Columns)
|
|
{
|
|
if (Item.SizeType == EUIPanelLayout_FlexibleGridSizeRule::Ratio)
|
|
{
|
|
columnTotalRatio += Item.Value;
|
|
}
|
|
else
|
|
{
|
|
columnTotalContstantSize += Item.Value;
|
|
}
|
|
}
|
|
for (auto& Item : Rows)
|
|
{
|
|
if (Item.SizeType == EUIPanelLayout_FlexibleGridSizeRule::Ratio)
|
|
{
|
|
rowTotalRatio += Item.Value;
|
|
}
|
|
else
|
|
{
|
|
rowTotalConstantSize += Item.Value;
|
|
}
|
|
}
|
|
float invColumnTotalRatio = 1.0f / columnTotalRatio;
|
|
float invRowTotalRatio = 1.0f / rowTotalRatio;
|
|
float thisFreeWidth = rectSize.X - columnTotalContstantSize;
|
|
float thisFreeHeight = rectSize.Y - rowTotalConstantSize;
|
|
|
|
float offsetX = 0, offsetY = 0;
|
|
if (SelectionState->bHorizontalOrVertical)
|
|
{
|
|
for (int i = 0; i < Columns.Num(); i++)
|
|
{
|
|
auto& item = Columns[i];
|
|
float itemWidth =
|
|
item.SizeType == EUIPanelLayout_FlexibleGridSizeRule::Constant ?
|
|
item.Value :
|
|
item.Value * invColumnTotalRatio * thisFreeWidth
|
|
;
|
|
if (i == SelectionState->SelectedSpliterIndex)
|
|
{
|
|
auto LineStart = FVector(0, UIItem->GetLocalSpaceLeft() + offsetX, UIItem->GetLocalSpaceTop());
|
|
auto LineEnd = FVector(0, LineStart.Y, UIItem->GetLocalSpaceBottom());
|
|
LineStart = UIItem->GetComponentTransform().TransformPosition(LineStart);
|
|
LineEnd = UIItem->GetComponentTransform().TransformPosition(LineEnd);
|
|
OutLocation = SelectionState->bFirstOrSecond ? LineStart : LineEnd;
|
|
return true;
|
|
}
|
|
offsetX += itemWidth;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < Rows.Num(); i++)
|
|
{
|
|
auto item = Rows[i];
|
|
float itemHeight =
|
|
item.SizeType == EUIPanelLayout_FlexibleGridSizeRule::Constant ?
|
|
item.Value :
|
|
item.Value * invRowTotalRatio * thisFreeHeight
|
|
;
|
|
if (i == SelectionState->SelectedSpliterIndex)
|
|
{
|
|
auto LineStart = FVector(0, UIItem->GetLocalSpaceLeft(), UIItem->GetLocalSpaceTop() - offsetY);
|
|
auto LineEnd = FVector(0, UIItem->GetLocalSpaceRight(), LineStart.Z);
|
|
LineStart = UIItem->GetComponentTransform().TransformPosition(LineStart);
|
|
LineEnd = UIItem->GetComponentTransform().TransformPosition(LineEnd);
|
|
OutLocation = SelectionState->bFirstOrSecond ? LineStart : LineEnd;
|
|
return true;
|
|
}
|
|
offsetY += itemHeight;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
TSharedPtr<SWidget> FUIPanelLayoutFlexibleGridComponentVisualizer::GenerateContextMenu() const
|
|
{
|
|
FMenuBuilder MenuBuilder(true, nullptr);
|
|
|
|
MenuBuilder.BeginSection("EditUIPanelLayoutFlexibleGrid", LOCTEXT("EditUIPanelLayoutFlexibleGrid", "UI FlexibleGridLayout"));
|
|
{
|
|
if (SelectionState->ProxyType == UUIPanelLayoutFlexibleGridVisualizerSelectionState::EHitProxyType::Spliter)
|
|
{
|
|
//@todo
|
|
//MenuBuilder.AddMenuEntry(
|
|
// LOCTEXT("ChangeSpliterType", "Change Spliter Type"),
|
|
// LOCTEXT("ChangeSpliterType_Tooltip", "Change size type of this spliter"),
|
|
// FSlateIcon(),
|
|
// FUIAction(FExecuteAction::CreateSP((FUIPanelLayoutFlexibleGridComponentVisualizer*)this, &FUIPanelLayoutFlexibleGridComponentVisualizer::ChangeSpliterType))
|
|
//);
|
|
if (SelectionState->SelectedSpliterIndex != -1)
|
|
{
|
|
MenuBuilder.AddMenuEntry(
|
|
LOCTEXT("DeleteSpliter", "Delete Spliter"),
|
|
LOCTEXT("DeleteSpliter_Tooltip", "Delete this spliter"),
|
|
FSlateIcon(),
|
|
FUIAction(FExecuteAction::CreateSP((FUIPanelLayoutFlexibleGridComponentVisualizer*)this, &FUIPanelLayoutFlexibleGridComponentVisualizer::RemoveSpliter))
|
|
);
|
|
}
|
|
}
|
|
else if (SelectionState->ProxyType == UUIPanelLayoutFlexibleGridVisualizerSelectionState::EHitProxyType::Frame)
|
|
{
|
|
MenuBuilder.AddMenuEntry(
|
|
LOCTEXT("AddSpliterHere", "Add Spliter Here"),
|
|
LOCTEXT("AddSpliter_Tooltip", "Add a new spliter at click point"),
|
|
FSlateIcon(),
|
|
FUIAction(FExecuteAction::CreateSP((FUIPanelLayoutFlexibleGridComponentVisualizer*)this, &FUIPanelLayoutFlexibleGridComponentVisualizer::AddSpliter))
|
|
);
|
|
}
|
|
}
|
|
MenuBuilder.EndSection();
|
|
|
|
TSharedPtr<SWidget> MenuWidget = MenuBuilder.MakeWidget();
|
|
return MenuWidget;
|
|
}
|
|
void FUIPanelLayoutFlexibleGridComponentVisualizer::AddSpliter()
|
|
{
|
|
if (!TargetComp.IsValid())return;
|
|
auto UIItem = TargetComp->GetRootUIComponent();
|
|
if (!UIItem)return;
|
|
|
|
GEditor->BeginTransaction(LOCTEXT("AddSpliter_Transaction", "UIPanelLayoutFlexibleGrid AddSpliter"));
|
|
TargetComp->Modify();
|
|
auto LocalClickPoint = UIItem->GetComponentTransform().InverseTransformPosition(SelectionState->CurrentClickPoint);
|
|
switch (SelectionState->FrameType)
|
|
{
|
|
case HUIPanelLayoutFlexibleGridFrameLineVisProxy::EFrameType::Left:
|
|
case HUIPanelLayoutFlexibleGridFrameLineVisProxy::EFrameType::Right:
|
|
{
|
|
LayoutChangeSizeToPixelRelevant(false);
|
|
auto SplitPoint = LocalClickPoint.Z - UIItem->GetLocalSpaceTop();
|
|
SplitPoint = -SplitPoint;
|
|
auto Rows = TargetComp->GetRows();
|
|
float CumulativeSplitSize = 0;
|
|
for (int i = 0; i < Rows.Num(); i++)
|
|
{
|
|
auto PrevCumulativeSplitSize = CumulativeSplitSize;
|
|
CumulativeSplitSize += Rows[i].Value;
|
|
if (SplitPoint < CumulativeSplitSize)
|
|
{
|
|
Rows[i].Value = CumulativeSplitSize - SplitPoint;
|
|
Rows.Insert(FUIPanelLayout_FlexibleGridSize(SplitPoint - PrevCumulativeSplitSize), i);
|
|
break;
|
|
}
|
|
}
|
|
TargetComp->SetRows(Rows);
|
|
}
|
|
break;
|
|
case HUIPanelLayoutFlexibleGridFrameLineVisProxy::EFrameType::Top:
|
|
case HUIPanelLayoutFlexibleGridFrameLineVisProxy::EFrameType::Bottom:
|
|
{
|
|
LayoutChangeSizeToPixelRelevant(true);
|
|
auto SplitPoint = LocalClickPoint.Y - UIItem->GetLocalSpaceLeft();
|
|
auto Columns = TargetComp->GetColumns();
|
|
float CumulativeSplitSize = 0;
|
|
for (int i = 0; i < Columns.Num(); i++)
|
|
{
|
|
auto PrevCumulativeSplitSize = CumulativeSplitSize;
|
|
CumulativeSplitSize += Columns[i].Value;
|
|
if (SplitPoint < CumulativeSplitSize)
|
|
{
|
|
Columns[i].Value = CumulativeSplitSize - SplitPoint;
|
|
Columns.Insert(FUIPanelLayout_FlexibleGridSize(SplitPoint - PrevCumulativeSplitSize), i);
|
|
break;
|
|
}
|
|
}
|
|
TargetComp->SetColumns(Columns);
|
|
}
|
|
break;
|
|
}
|
|
GEditor->EndTransaction();
|
|
}
|
|
void FUIPanelLayoutFlexibleGridComponentVisualizer::RemoveSpliter()
|
|
{
|
|
if (!TargetComp.IsValid())return;
|
|
auto UIItem = TargetComp->GetRootUIComponent();
|
|
if (!UIItem)return;
|
|
if (SelectionState->ProxyType == UUIPanelLayoutFlexibleGridVisualizerSelectionState::EHitProxyType::Frame)return;
|
|
if (SelectionState->SelectedSpliterIndex == -1)return;
|
|
|
|
GEditor->BeginTransaction(LOCTEXT("RemoveSpliter_Transaction", "UIPanelLayoutFlexibleGrid RemoveSpliter"));
|
|
TargetComp->Modify();
|
|
|
|
if (SelectionState->bHorizontalOrVertical)
|
|
{
|
|
LayoutChangeSizeToPixelRelevant(true);
|
|
auto Columns = TargetComp->GetColumns();
|
|
Columns[SelectionState->SelectedSpliterIndex - 1].Value += Columns[SelectionState->SelectedSpliterIndex].Value;
|
|
Columns.RemoveAt(SelectionState->SelectedSpliterIndex);
|
|
TargetComp->SetColumns(Columns);
|
|
}
|
|
else
|
|
{
|
|
LayoutChangeSizeToPixelRelevant(false);
|
|
auto Rows = TargetComp->GetRows();
|
|
Rows[SelectionState->SelectedSpliterIndex - 1].Value += Rows[SelectionState->SelectedSpliterIndex].Value;
|
|
Rows.RemoveAt(SelectionState->SelectedSpliterIndex);
|
|
TargetComp->SetRows(Rows);
|
|
}
|
|
SelectionState->SelectedSpliterIndex = -1;
|
|
GEditor->EndTransaction();
|
|
}
|
|
void FUIPanelLayoutFlexibleGridComponentVisualizer::ChangeSpliterType()
|
|
{
|
|
if (!TargetComp.IsValid())return;
|
|
auto UIItem = TargetComp->GetRootUIComponent();
|
|
if (!UIItem)return;
|
|
|
|
|
|
}
|
|
void FUIPanelLayoutFlexibleGridComponentVisualizer::LayoutChangeSizeToPixelRelevant(bool InHorizontalOrVertical)
|
|
{
|
|
if (!TargetComp.IsValid())return;
|
|
auto UIItem = TargetComp->GetRootUIComponent();
|
|
if (!UIItem)return;
|
|
|
|
if (InHorizontalOrVertical)
|
|
{
|
|
auto Columns = TargetComp->GetColumns();
|
|
float columnTotalRatio = 0, columnTotalContstantSize = 0;
|
|
for (auto& Item : Columns)
|
|
{
|
|
if (Item.SizeType == EUIPanelLayout_FlexibleGridSizeRule::Ratio)
|
|
{
|
|
columnTotalRatio += Item.Value;
|
|
}
|
|
else
|
|
{
|
|
columnTotalContstantSize += Item.Value;
|
|
}
|
|
}
|
|
float invColumnTotalRatio = 1.0f / columnTotalRatio;
|
|
float thisWidth = UIItem->GetWidth();
|
|
float thisFreeWidth = thisWidth - columnTotalContstantSize;
|
|
for (int i = 0; i < Columns.Num(); i++)
|
|
{
|
|
auto& Column = Columns[i];
|
|
if (Column.SizeType == EUIPanelLayout_FlexibleGridSizeRule::Ratio)
|
|
{
|
|
Column.Value = thisFreeWidth * Column.Value * invColumnTotalRatio;
|
|
}
|
|
}
|
|
TargetComp->SetColumns(Columns);
|
|
}
|
|
else
|
|
{
|
|
auto Rows = TargetComp->GetRows();
|
|
float rowTotalRatio = 0, rowTotalConstantSize = 0;
|
|
for (auto& Item : Rows)
|
|
{
|
|
if (Item.SizeType == EUIPanelLayout_FlexibleGridSizeRule::Ratio)
|
|
{
|
|
rowTotalRatio += Item.Value;
|
|
}
|
|
else
|
|
{
|
|
rowTotalConstantSize += Item.Value;
|
|
}
|
|
}
|
|
float invRowTotalRatio = 1.0f / rowTotalRatio;
|
|
float thisHeight = UIItem->GetHeight();
|
|
float thisFreeHeight = thisHeight - rowTotalConstantSize;
|
|
for (int i = 0; i < Rows.Num(); i++)
|
|
{
|
|
auto& Row = Rows[i];
|
|
if (Row.SizeType == EUIPanelLayout_FlexibleGridSizeRule::Ratio)
|
|
{
|
|
Row.Value = thisFreeHeight * Row.Value * invRowTotalRatio;
|
|
}
|
|
}
|
|
TargetComp->SetRows(Rows);
|
|
}
|
|
}
|
|
|
|
|
|
IMPLEMENT_HIT_PROXY(HUIPanelLayoutFlexibleGridSpliterVisProxy, HComponentVisProxy);
|
|
HUIPanelLayoutFlexibleGridSpliterVisProxy::HUIPanelLayoutFlexibleGridSpliterVisProxy(const UUIPanelLayout_FlexibleGrid* InComponent, bool InHorizontalOrVertical, bool InFirstOrSecond, int32 InSelectingSpliterIndex
|
|
)
|
|
: HComponentVisProxy(InComponent, HPP_Foreground)
|
|
{
|
|
bHorizontalOrVertical = InHorizontalOrVertical;
|
|
bFirstOrSecond = InFirstOrSecond;
|
|
SpliterIndex = InSelectingSpliterIndex;
|
|
}
|
|
|
|
IMPLEMENT_HIT_PROXY(HUIPanelLayoutFlexibleGridFrameLineVisProxy, HComponentVisProxy);
|
|
HUIPanelLayoutFlexibleGridFrameLineVisProxy::HUIPanelLayoutFlexibleGridFrameLineVisProxy(const UUIPanelLayout_FlexibleGrid* InComponent, EFrameType InFrameType
|
|
)
|
|
: HComponentVisProxy(InComponent, HPP_Foreground)
|
|
{
|
|
FrameType = InFrameType;
|
|
}
|
|
|
|
#undef LOCTEXT_NAMESPACE
|
|
|
|
#if LGUI_CAN_DISABLE_OPTIMIZATION
|
|
PRAGMA_ENABLE_OPTIMIZATION
|
|
#endif
|