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; }