public UVSize(FlexDirection direction, Size size)
{
U = V = 0d;
FlexDirection = direction;
Width = size.Width;
Height = size.Height;
}
public static void SetFlexDirection(this VisualElement self, FlexDirection v)
{
var c = self.style.flexDirection;
c.value = v;
self.style.flexDirection = c;
}
// StyleSetFlexDirection sets flex directions
public void StyleSetFlexDirection(FlexDirection flexDirection)
{
if (this.nodeStyle.FlexDirection != flexDirection)
{
this.nodeStyle.FlexDirection = flexDirection;
Flex.nodeMarkDirtyInternal(this);
}
}
/// <summary>
/// Applies the direction rule to the current flex definition.
/// </summary>
/// <param name="direction">Direction to be apply.</param>
/// <returns>Next rule reference.</returns>
public IFluentFlexAll WithDirection(FlexDirection direction)
{
currentFlexDefinition = CreateDefinition();
currentFlexDefinition.Direction = direction;
Dirty();
return(this);
}
public static VisualElement SetFlexDirection(this VisualElement self, FlexDirection v)
{
var c = self.style.flexDirection;
c.value = v;
self.style.flexDirection = c;
return(self);
}
public VisualSplitter(VisualElement fixedPane, VisualElement flexedPane, FlexDirection direction, float size = 0f)
{
this.fixedPane = fixedPane;
this.flexedPane = flexedPane;
m_Resizer = new Resizer(this, 1, direction);
flexedPane.style.flexGrow = 1;
m_Dragger = new VisualElement();
m_Dragger.style.position = Position.Absolute;
m_Dragger.AddManipulator(m_Resizer);
var splitter = new VisualElement()
{
name = "Splitter"
};
if (direction == FlexDirection.Column)
{
m_Dragger.style.height = k_SplitterSize;
m_Dragger.style.top = -Mathf.RoundToInt(k_SplitterSize / 2f);
m_Dragger.style.left = 0f;
m_Dragger.style.right = 0f;
m_Dragger.style.cursor = LoadCursor(MouseCursor.ResizeVertical);
//m_Dragger.style.backgroundColor = Color.green;
if (size != 0)
{
splitter.style.height = size;
}
}
else if (direction == FlexDirection.Row)
{
m_Dragger.style.width = k_SplitterSize;
m_Dragger.style.left = -Mathf.RoundToInt(k_SplitterSize / 2f);
m_Dragger.style.top = 0f;
m_Dragger.style.bottom = 0f;
m_Dragger.style.cursor = LoadCursor(MouseCursor.ResizeHorizontal);
//m_Dragger.style.backgroundColor = Color.red;
if (size != 0)
{
splitter.style.width = size;
}
}
Add(fixedPane);
Add(splitter);
Add(flexedPane);
Add(m_Dragger);
RegisterCallback <GeometryChangedEvent>(OnSizeChange);
fixedPane.RegisterCallback <GeometryChangedEvent>(OnSizeChange);
style.flexGrow = 1;
style.flexDirection = direction;
}
public Resizer(VisualSplitter splitView, int dir, FlexDirection orientation)
{
m_Orientation = orientation;
m_Splitter = splitView;
m_Direction = dir;
activators.Add(new ManipulatorActivationFilter {
button = MouseButton.LeftMouse
});
m_Active = false;
}
public void AreConditions(string expected, FlexDirection flexDirection, bool condition)
{
var flex = new FluentFlex();
flex.WithDirection(flexDirection);
flex.If(condition);
var classname = flex.Class(classProvider);
Assert.Equal(expected, classname);
}
public void AreDirection(string expected, FlexDirection direction)
{
var flex = new FluentFlex();
flex.WithFlexType(FlexType.Flex);
flex.WithDirection(direction);
var classname = flex.Class(classProvider);
Assert.Equal(expected, classname);
}
// FlexDirectionToString returns string version of FlexDirection enum
public static bool StringToFlexDirection(string value, out FlexDirection result)
{
switch (value)
{
case "column": result = FlexDirection.Column; return(true);
case "column-reverse": result = FlexDirection.ColumnReverse; return(true);
case "row": result = FlexDirection.Row; return(true);
case "row-reverse": result = FlexDirection.RowReverse; return(true);
}
result = FlexDirection.Column;
return(false);
}
public FluentElement <Group> NewIndentedGroup(int left = 15, int right = 1, int top = 0, int bottom = 0,
bool useMargin = false, FlexDirection direction = UnityEngine.UIElements.FlexDirection.Column)
{
var group = new Group(direction).Fluent();
if (useMargin)
{
group.Margin(top, left, right, bottom);
}
else
{
group.Padding(top, left, right, bottom);
}
return(group);
}
public static FlexLayout Configure(this FlexLayout layout,
FlexAlignContent alignContent = FlexAlignContent.Center,
FlexAlignItems alignItems = FlexAlignItems.Center,
FlexDirection direction = FlexDirection.Column,
FlexJustify justify = FlexJustify.Center,
FlexPosition position = FlexPosition.Absolute,
FlexWrap wrap = FlexWrap.NoWrap)
{
layout.AlignContent = alignContent;
layout.AlignItems = alignItems;
layout.Direction = direction;
layout.JustifyContent = justify;
layout.Position = position;
layout.Wrap = wrap;
return(layout);
}
public static FlexDirection Resolve(this FlexDirection flexDirection, Direction direction)
{
if (direction == Direction.RTL)
{
if (flexDirection == FlexDirection.Row)
{
return(FlexDirection.RowReverse);
}
if (flexDirection == FlexDirection.RowReverse)
{
return(FlexDirection.Row);
}
}
return(flexDirection);
}
protected void OnMouseDown(MouseDownEvent e)
{
if (CanStartManipulation(e))
{
VisualSplitter visualSplitter = target as VisualSplitter;
FlexDirection flexDirection = visualSplitter.resolvedStyle.flexDirection;
if (m_AffectedElements != null)
{
VisualElementListPool.Release(m_AffectedElements);
}
m_AffectedElements = visualSplitter.GetAffectedVisualElements();
var shouldUseEvent = false;
for (int i = 0; i < m_AffectedElements.Count - 1; ++i)
{
VisualElement visualElement = m_AffectedElements[i];
Rect splitterRect = visualSplitter.GetSplitterRect(visualElement);
if (splitterRect.Contains(e.localMousePosition))
{
bool isReverse = flexDirection == FlexDirection.RowReverse || flexDirection == FlexDirection.ColumnReverse;
if (isReverse)
{
m_ActiveVisualElementIndex = i + 1;
m_NextVisualElementIndex = i;
}
else
{
m_ActiveVisualElementIndex = i;
m_NextVisualElementIndex = i + 1;
}
shouldUseEvent = true;
}
}
if (shouldUseEvent)
{
m_Active = true;
target.CaptureMouse();
e.StopPropagation();
e.PreventDefault();
}
}
}
// FlexDirectionToString returns string version of FlexDirection enum
public static string FlexDirectionToString(FlexDirection value)
{
switch (value)
{
case FlexDirection.Column:
return("column");
case FlexDirection.ColumnReverse:
return("column-reverse");
case FlexDirection.Row:
return("row");
case FlexDirection.RowReverse:
return("row-reverse");
}
return("unknown");
}
protected void OnMouseMove(MouseMoveEvent e)
{
if (m_Active)
{
// These calculations should only work if flex-basis is auto.
// However, Yoga implementation of flex-basis 0 is broken and behaves much like
// flex-basis auto, so it currently works with flex-basis 0 too.
VisualSplitter visualSplitter = target as VisualSplitter;
VisualElement visualElement = m_AffectedElements[m_ActiveVisualElementIndex];
VisualElement nextVisualElement = m_AffectedElements[m_NextVisualElementIndex];
FlexDirection flexDirection = visualSplitter.resolvedStyle.flexDirection;
bool isVertical = flexDirection == FlexDirection.Column || flexDirection == FlexDirection.ColumnReverse;
float relativeMousePosition;
if (isVertical)
{
float minHeight = visualElement.resolvedStyle.minHeight == StyleKeyword.Auto ? 0 : visualElement.resolvedStyle.minHeight.value;
float nextMinHeight = nextVisualElement.resolvedStyle.minHeight == StyleKeyword.Auto ? 0 : nextVisualElement.resolvedStyle.minHeight.value;
float availableHeight = visualElement.layout.height + nextVisualElement.layout.height - minHeight - nextMinHeight;
float maxHeight = visualElement.resolvedStyle.maxHeight.value <= 0 ? availableHeight : visualElement.resolvedStyle.maxHeight.value;
relativeMousePosition = (Math.Min(e.localMousePosition.y, visualElement.layout.yMin + maxHeight) - visualElement.layout.yMin - minHeight) / availableHeight;
}
else
{
float minWidth = visualElement.resolvedStyle.minWidth == StyleKeyword.Auto ? 0 : visualElement.resolvedStyle.minWidth.value;
float nextMinWidth = nextVisualElement.resolvedStyle.minWidth == StyleKeyword.Auto ? 0 : nextVisualElement.resolvedStyle.minWidth.value;
float availableWidth = visualElement.layout.width + nextVisualElement.layout.width - minWidth - nextMinWidth;
float maxWidth = visualElement.resolvedStyle.maxWidth.value <= 0 ? availableWidth : visualElement.resolvedStyle.maxWidth.value;
relativeMousePosition = (Math.Min(e.localMousePosition.x, visualElement.layout.xMin + maxWidth) - visualElement.layout.xMin - minWidth) / availableWidth;
}
relativeMousePosition = Math.Max(0.0f, Math.Min(0.999f, relativeMousePosition));
float totalFlex = visualElement.resolvedStyle.flexGrow + nextVisualElement.resolvedStyle.flexGrow;
visualElement.style.flexGrow = relativeMousePosition * totalFlex;
nextVisualElement.style.flexGrow = (1.0f - relativeMousePosition) * totalFlex;
e.StopPropagation();
}
}
void FlexDirectionUpdateToggleIcon(FlexDirection resolvedStyle)
{
foreach (var button in m_FlexAlignButtons)
{
button.RemoveFromClassList("flex-column");
button.RemoveFromClassList("flex-column-reverse");
button.RemoveFromClassList("flex-row");
button.RemoveFromClassList("flex-row-reverse");
switch (resolvedStyle)
{
case FlexDirection.Column: button.AddToClassList("flex-column"); break;
case FlexDirection.ColumnReverse: button.AddToClassList("flex-column-reverse"); break;
case FlexDirection.Row: button.AddToClassList("flex-row"); break;
case FlexDirection.RowReverse: button.AddToClassList("flex-row-reverse"); break;
}
}
}
private static void OnDirectionChanged(FrameButton instance, FlexDirection direction)
{
switch (direction)
{
case FlexDirection.Row:
AlignContent(instance, new Thickness(0, 0, 10, 0), LayoutOptions.StartAndExpand);
break;
case FlexDirection.RowReverse:
AlignContent(instance, new Thickness(10, 0, 0, 0), LayoutOptions.StartAndExpand);
break;
case FlexDirection.Column:
AlignContent(instance, new Thickness(0, 0, 0, 10), LayoutOptions.CenterAndExpand);
break;
case FlexDirection.ColumnReverse:
AlignContent(instance, new Thickness(0, 10, 0, 0), LayoutOptions.CenterAndExpand);
break;
}
}
protected void OnMouseMove(MouseMoveEvent e)
{
if (m_Active)
{
// These calculations should only work if flex-basis is auto.
// However, Yoga implementation of flex-basis 0 is broken and behaves much like
// flex-basis auto, so it currently works with flex-basis 0 too.
VisualSplitter visualSplitter = target as VisualSplitter;
VisualElement visualElement = m_AffectedElements[m_ActiveVisualElementIndex];
VisualElement nextVisualElement = m_AffectedElements[m_NextVisualElementIndex];
FlexDirection flexDirection = visualSplitter.style.flexDirection;
bool isVertical = flexDirection == FlexDirection.Column || flexDirection == FlexDirection.ColumnReverse;
float relativeMousePosition;
if (isVertical)
{
relativeMousePosition = (e.localMousePosition.y - visualElement.layout.yMin - visualElement.style.minHeight) /
(visualElement.layout.height + nextVisualElement.layout.height -
visualElement.style.minHeight - nextVisualElement.style.minHeight);
}
else
{
relativeMousePosition = (e.localMousePosition.x - visualElement.layout.xMin - visualElement.style.minWidth) /
(visualElement.layout.width + nextVisualElement.layout.width -
visualElement.style.minWidth - nextVisualElement.style.minWidth);
}
relativeMousePosition = Math.Max(0.0f, Math.Min(1.0f, relativeMousePosition));
float totalFlex = visualElement.style.flexGrow + nextVisualElement.style.flexGrow;
visualElement.style.flexGrow = relativeMousePosition * totalFlex;
nextVisualElement.style.flexGrow = (1.0f - relativeMousePosition) * totalFlex;
e.StopPropagation();
}
}
// Set defaults values for attributes
// clear_text_values = false used for animation(see Sync())
public virtual void SetDefault(bool clear_text_values = true)
{
if (clear_text_values)
{
layoutAttributeChanged.Clear();
layoutAttribute.Clear();
}
Direction = Direction.Inherit;
FlexDirection = FlexDirection.Row;
JustifyContent = Justify.FlexStart;
AlignContent = Align.Stretch;
AlignItems = Align.Stretch;
AlignSelf = Align.Auto;
PositionType = PositionType.Relative;
FlexWrap = Wrap.NoWrap;
Overflow = Overflow.Visible;
Display = Display.Flex;
FlexGrow = 0f;
FlexShrink = 1f;
FlexBasis = CreateAutoValue();
Margin = CreateDefaultEdgeValuesUnit();
Position = CreateDefaultEdgeValuesUnit();
Padding = CreateDefaultEdgeValuesUnit();
Border = CreateDefaultEdgeValuesUnit();
Dimensions = new Value[2] {
CreateAutoValue(), CreateAutoValue()
};
MinDimensions = new Value[2] {
Value.UndefinedValue, Value.UndefinedValue
};
MaxDimensions = new Value[2] {
Value.UndefinedValue, Value.UndefinedValue
};
// Yoga specific properties, not compatible with flexbox specification
AspectRatio = float.NaN;
}
public static float YGNodePaddingAndBorderForAxis(YogaNode node, FlexDirection axis, float widthSize) => node.PaddingAndBorderForAxis(axis, widthSize);
public static void YGConstrainMaxSizeForMode(YogaNode node, FlexDirection axis, float ownerAxisSize, float ownerWidth, ref MeasureMode mode, ref float size) => node.ConstrainMaxSizeForMode(axis, ownerAxisSize, ownerWidth, ref mode, ref size);
public static void YGNodeSetChildTrailingPosition(YogaNode node, YogaNode child, FlexDirection axis) => node.SetChildTrailingPosition(child, axis);
public static float YGNodeBoundAxis(YogaNode node, FlexDirection axis, float value, float axisSize, float widthSize) => node.BoundAxis(axis, value, axisSize, widthSize);
public static float YGNodeBoundAxisWithinMinAndMax(YogaNode node, FlexDirection axis, float value, float axisSize) => node.BoundAxisWithinMinAndMax(axis, value, axisSize);
public static bool YGNodeIsLayoutDimDefined(YogaNode node, FlexDirection axis) => node.IsLayoutDimDefined(axis);
public static bool YGNodeIsStyleDimDefined(YogaNode node, FlexDirection axis, float ownerSize) => node.IsStyleDimDefined(axis, ownerSize);
public static float YGNodeDimWithMargin(YogaNode node, FlexDirection axis, float widthSize) => node.DimWithMargin(axis, widthSize);
public static void YGNodeStyleSetFlexDirection(YogaNode node, FlexDirection flexDirection) => node.Style.FlexDirection = flexDirection;
public UVSize(FlexDirection direction)
{
U = V = 0d;
FlexDirection = direction;
}
