/// <summary> /// Init this instance. /// </summary> protected virtual void Init() { if (isInited) { return; } isInited = true; //ScrollRect.horizontal = false; //ScrollRect.vertical = false; var resizeListener = Utilites.GetOrAddComponent <ResizeListener>(ScrollRect); resizeListener.OnResize.AddListener(RecalculatePages); var contentResizeListener = Utilites.GetOrAddComponent <ResizeListener>(ScrollRect.content); contentResizeListener.OnResize.AddListener(RecalculatePages); var dragListener = Utilites.GetOrAddComponent <OnDragListener>(ScrollRect); dragListener.OnDragStartEvent.AddListener(OnScrollRectDragStart); dragListener.OnDragEvent.AddListener(OnScrollRectDrag); dragListener.OnDragEndEvent.AddListener(OnScrollRectDragEnd); ScrollRect.onValueChanged.AddListener(OnScrollRectValueChanged); var scroll_listener = Utilites.GetOrAddComponent <ScrollListener>(ScrollRect); scroll_listener.ScrollEvent.AddListener(ContainerScroll); if (DefaultPage != null) { SRDefaultPage = Utilites.GetOrAddComponent <ScrollRectPage>(DefaultPage); SRDefaultPage.gameObject.SetActive(false); } if (ActivePage != null) { SRActivePage = Utilites.GetOrAddComponent <ScrollRectPage>(ActivePage); } if (PrevPage != null) { SRPrevPage = Utilites.GetOrAddComponent <ScrollRectPage>(PrevPage); SRPrevPage.SetPage(0); SRPrevPage.OnPageSelect.AddListener(Prev); } if (NextPage != null) { SRNextPage = Utilites.GetOrAddComponent <ScrollRectPage>(NextPage); SRNextPage.OnPageSelect.AddListener(Next); } RecalculatePages(); var page = currentPage; currentPage = -1; GoToPage(page); }
/// <summary> /// Adds the callback. /// </summary> /// <param name="item">Item.</param> protected virtual void AddCallback(AccordionItem item) { if (item.Open) { Open(item, false); } else { Close(item, false); } UnityAction callback = () => ToggleItem(item); var component = Utilites.GetOrAddComponent <AccordionItemComponent>(item.ToggleObject); component.OnClick.AddListener(callback); item.ContentObjectRect = item.ContentObject.transform as RectTransform; item.ContentLayoutElement = Utilites.GetOrAddComponent <LayoutElement>(item.ContentObject); item.ContentObjectHeight = item.ContentObjectRect.rect.height; if (item.ContentObjectHeight == 0f) { item.ContentObjectHeight = LayoutUtility.GetPreferredHeight(item.ContentObjectRect); } item.ContentObjectWidth = item.ContentObjectRect.rect.width; if (item.ContentObjectWidth == 0f) { item.ContentObjectWidth = LayoutUtility.GetPreferredWidth(item.ContentObjectRect); } Components.Add(component); Callbacks.Add(callback); }
/// <summary> /// Adds the callback. /// </summary> /// <param name="item">Item.</param> protected virtual void AddCallback(AccordionItem item) { if (item.Open) { Open(item, false); } else { Close(item, false); } UnityAction callback = () => ToggleItem(item); var component = Utilites.GetOrAddComponent <AccordionItemComponent>(item.ToggleObject); component.OnClick.AddListener(callback); item.ContentObjectRect = item.ContentObject.transform as RectTransform; item.ContentLayoutElement = Utilites.GetOrAddComponent <LayoutElement>(item.ContentObject); if (IsHorizontal()) { item.ContentLayoutElement.minWidth = 0f; } else { item.ContentLayoutElement.minHeight = 0f; } UpdateItemSize(item); Components.Add(component); Callbacks.Add(callback); }
/// <summary> /// Init this instance. /// </summary> public void Init() { canvasRect = Utilites.FindTopmostCanvas(transform) as RectTransform; canvas = canvasRect.GetComponent <Canvas>(); foreach (Transform child in transform) { var cell = Utilites.GetOrAddComponent <ResizableHeaderDragCell>(child); if (cell.Position == -1) { cell.Position = CellsInfo.Count; cell.ResizableHeader = this; cell.AllowDropCursor = AllowDropCursor; cell.AllowDropCursorHotSpot = AllowDropCursorHotSpot; cell.DeniedDropCursor = DeniedDropCursor; cell.DeniedDropCursorHotSpot = DeniedDropCursorHotSpot; var events = Utilites.GetOrAddComponent <ResizableHeaderCell>(child); events.OnInitializePotentialDragEvent.AddListener(OnInitializePotentialDrag); events.OnBeginDragEvent.AddListener(OnBeginDrag); events.OnDragEvent.AddListener(OnDrag); events.OnEndDragEvent.AddListener(OnEndDrag); CellsInfo.Add(new ResizableHeaderCellInfo() { Rect = child as RectTransform, LayoutElement = Utilites.GetOrAddComponent <LayoutElement>(child), Position = CellsInfo.Count }); } } }
/// <summary> /// Sets the palette. /// </summary> /// <param name="value">Value.</param> protected virtual void SetPalette(Image value) { if (dragListener != null) { dragListener.OnDragEvent.RemoveListener(OnDrag); } palette = value; if (palette != null) { paletteRect = palette.transform as RectTransform; dragListener = Utilites.GetOrAddComponent <DragListener>(palette); dragListener.OnDragEvent.AddListener(OnDrag); clickListener = Utilites.GetOrAddComponent <ClickListener>(palette); clickListener.ClickEvent.AddListener(OnDrag); UpdateMaterial(); } else { paletteRect = null; } }
/// <summary> /// Change container. /// </summary> /// <param name="value">New container.</param> protected virtual void ChangeContainer(RectTransform value) { if (value == null) { value = transform as RectTransform; } if (container != null) { var resize_listener = container.GetComponent <ResizeListener>(); if (resize_listener != null) { resize_listener.OnResize.RemoveListener(SizeChanged); } } container = value; if (container != null) { var resize_listener = Utilites.GetOrAddComponent <ResizeListener>(container); resize_listener.OnResize.AddListener(SizeChanged); ContainerLayoutElement = Utilites.GetOrAddComponent <LayoutElement>(container); } }
/// <summary> /// Adds the listener. /// </summary> protected virtual void AddListener() { if ((Line != null) && (Line.Target != null)) { listener = Utilites.GetOrAddComponent <TransformListener>(Line.Target); listener.OnTransformChanged.AddListener(SetVerticesDirty); } }
/// <summary> /// Closes the options. /// </summary> protected virtual void HideOptions() { if (CanvasTransform != null) { Utilites.GetOrAddComponent <HierarchyToggle>(DisplayListView).Restore(); } DisplayListView.gameObject.SetActive(false); }
/// <summary> /// Sets the handle. /// </summary> /// <param name="value">Value.</param> protected virtual void SetHandle(GameObject value) { if (handle != null) { Destroy(handleScript); } handle = value; handleScript = Utilites.GetOrAddComponent <DraggableHandle>(handle); handleScript.Drag(gameObject.transform as RectTransform); }
/// <summary> /// Shows the options. /// </summary> protected virtual void ShowOptions() { CanvasTransform = Utilites.FindTopmostCanvas(DisplayListView.transform); if (CanvasTransform != null) { Utilites.GetOrAddComponent <HierarchyToggle>(DisplayListView).SetParent(CanvasTransform); } DisplayListView.gameObject.SetActive(true); }
/// <summary> /// Base slide animation. /// </summary> /// <param name="notify">Notify.</param> /// <param name="isHorizontal">Is horizontal slide?</param> /// <param name="direction">Slide direction.</param> /// <param name="speed">Speed.</param> /// <param name="animateOthers">Animate other notifications.</param> /// <returns>Animation.</returns> public static IEnumerator AnimationSlideBase(Notify notify, bool isHorizontal, float direction, float speed, bool animateOthers = true) { var replacement = GetReplacement(notify); var layout_element = Utilites.GetOrAddComponent <LayoutElement>(notify); layout_element.ignoreLayout = true; var layout = notify.GetComponentInParent <EasyLayout>(); var rect = notify.transform as RectTransform; var base_size = isHorizontal ? rect.rect.width : rect.rect.height; var base_pos = rect.anchoredPosition; var time = base_size / speed; var end_time = Utilites.GetTime(notify.unscaledTime) + time; var axis = isHorizontal ? RectTransform.Axis.Horizontal : RectTransform.Axis.Vertical; while (Utilites.GetTime(notify.unscaledTime) <= end_time) { if (!animateOthers) { base_pos = replacement.anchoredPosition; } var t = 1 - ((end_time - Utilites.GetTime(notify.unscaledTime)) / time); var size = Mathf.Lerp(0, base_size, t); rect.anchoredPosition = isHorizontal ? new Vector2(base_pos.x + (size * direction), base_pos.y) : new Vector2(base_pos.x, base_pos.y + (size * direction)); if (animateOthers) { replacement.SetSizeWithCurrentAnchors(axis, base_size - size); if (layout != null) { layout.NeedUpdateLayout(); } } yield return(null); } layout_element.ignoreLayout = false; Replacements.Push(replacement); replacement.gameObject.SetActive(false); replacement.SetSizeWithCurrentAnchors(axis, base_size); if (layout != null) { layout.NeedUpdateLayout(); } }
/// <summary> /// Adds the listeners. /// </summary> protected virtual void AddListeners() { Lines.ForEach(x => { if (x.Target != null) { var listener = Utilites.GetOrAddComponent <TransformListener>(x.Target); listener.OnTransformChanged.AddListener(SetVerticesDirty); listeners.Add(listener); } }); }
/// <summary> /// Init this instance. /// </summary> public virtual void Init() { if (isInited) { return; } isInited = true; var click = Utilites.GetOrAddComponent <ClickListener>(this); click.DoubleClickEvent.AddListener(OnDoubleClick); }
/// <summary> /// Start this instance. /// </summary> protected virtual void Start() { var layout = GetComponent <EasyLayoutNS.EasyLayout>(); if (layout != null) { layout.ChildrenWidth = EasyLayoutNS.ChildrenSize.SetPreferred; } var mask = Utilites.GetOrAddComponent <Mask>(this); mask.showMaskGraphic = true; }
/// <summary> /// Change settings of DefaultItem.Resizable component. /// </summary> protected override void ChangeDefaultItemResizable() { var width = GetItemMinWidth(); Action <TDataView> action = (x) => { var resizable = Utilites.GetOrAddComponent <Resizable>(x); resizable.MinSize = new Vector2(width, DefaultItemSize.y); }; action(DefaultItem); DataViews.ForEachAll(action); }
/// <summary> /// Init input field proxy. /// </summary> protected virtual void InitInputField() { if (!isInited) { return; } InputFieldProxy.onValueChanged.AddListener(ApplyFilter); var inputListener = Utilites.GetOrAddComponent <InputFieldListener>(InputFieldProxy.gameObject); inputListener.OnMoveEvent.AddListener(SelectResult); inputListener.OnSubmitEvent.AddListener(SubmitResult); inputListener.onDeselect.AddListener(InputDeselected); }
/// <summary> /// Reset position. /// </summary> public override void ResetPosition() { if (Owner.scrollRect != null) { Owner.scrollRect.horizontal = false; Owner.scrollRect.vertical = false; Owner.scrollRect.StopMovement(); Owner.scrollRect.content.anchoredPosition = Vector2.zero; scrollListener = Utilites.GetOrAddComponent <ScrollListener>(Owner.ScrollRect); } if (Owner.Layout != null) { Owner.Layout.EllipseSettings.AngleScroll = -Owner.Layout.EllipseSettings.ArcLength / 2f; } }
/// <summary> /// Collapse animation. /// </summary> /// <returns>Animation.</returns> /// <param name="rectTransform">RectTransform.</param> /// <param name="time">Time.</param> /// <param name="isHorizontal">Is Horizontal animated width changes; otherwise height.</param> /// <param name="unscaledTime">Use unscaled time.</param> /// <param name="actionAfter">Action to run after animation.</param> static public IEnumerator Collapse(RectTransform rectTransform, float time = 0.5f, bool isHorizontal = false, bool unscaledTime = false, Action actionAfter = null) { var size = rectTransform.rect.size; var layoutElement = Utilites.GetOrAddComponent <LayoutElement>(rectTransform); if (size.x == 0 || size.y == 0) { size = new Vector2(layoutElement.preferredWidth, layoutElement.preferredHeight); } var end_time = (unscaledTime ? Time.unscaledTime : Time.time) + time; while ((unscaledTime ? Time.unscaledTime : Time.time) <= end_time) { if (isHorizontal) { var width = Mathf.Lerp(size.x, 0, 1 - (end_time - (unscaledTime ? Time.unscaledTime : Time.time)) / time); rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, width); layoutElement.preferredWidth = width; } else { var height = Mathf.Lerp(size.y, 0, 1 - (end_time - (unscaledTime ? Time.unscaledTime : Time.time)) / time); rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, height); layoutElement.preferredHeight = height; } yield return(null); } //return size back for future use if (isHorizontal) { rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, size.x); layoutElement.preferredWidth = size.x; } else { rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, size.y); layoutElement.preferredHeight = size.y; } if (actionAfter != null) { actionAfter(); } }
/// <summary> /// Hide notification. /// </summary> public void Hide() { if (SlideUpOnHide) { var replacement = GetReplacement(this); var slide = Utilites.GetOrAddComponent <SlideUp>(replacement); slide.UnscaledTime = UnscaledTime; slide.Run(); } if (OnHideCallback != null) { OnHideCallback(); } Return(); }
/// <summary> /// Open animation. /// </summary> /// <returns>Animation.</returns> /// <param name="rectTransform">RectTransform.</param> /// <param name="time">Time.</param> /// <param name="isHorizontal">Is Horizontal animated width changes; otherwise height.</param> /// <param name="unscaledTime">Use unscaled time.</param> /// <param name="actionAfter">Action to run after animation.</param> public static IEnumerator OpenFlexible(RectTransform rectTransform, float time = 0.5f, bool isHorizontal = false, bool unscaledTime = false, Action actionAfter = null) { var layoutElement = Utilites.GetOrAddComponent <LayoutElement>(rectTransform); if (isHorizontal) { layoutElement.preferredWidth = -1f; } else { layoutElement.preferredHeight = -1f; } var end_time = Utilites.GetTime(unscaledTime) + time; while (Utilites.GetTime(unscaledTime) <= end_time) { var t = 1 - ((end_time - Utilites.GetTime(unscaledTime)) / time); var size = Mathf.Lerp(0f, 1f, t); if (isHorizontal) { layoutElement.flexibleWidth = size; } else { layoutElement.flexibleHeight = size; } yield return(null); } // return size back for future use if (isHorizontal) { layoutElement.flexibleWidth = 1f; } else { layoutElement.flexibleHeight = 1f; } if (actionAfter != null) { actionAfter(); } }
/// <summary> /// Add listeners. /// </summary> protected virtual void AddListeners() { var click = Utilites.GetOrAddComponent <ClickListener>(this); click.DoubleClickEvent.AddListener(OnDoubleClick); Resizable = GetComponent <Resizable>(); if (Resizable != null) { Resizable.ResizeDirections.Top = false; Resizable.ResizeDirections.TopLeft = false; Resizable.ResizeDirections.TopRight = false; Resizable.ResizeDirections.Bottom = false; Resizable.ResizeDirections.BottomLeft = false; Resizable.ResizeDirections.BottomRight = false; Resizable.OnEndResize.AddListener(OnEndResize); } }
/// <summary> /// Sets the scroll button. /// </summary> /// <param name="oldButton">Old button.</param> /// <param name="newButton">New button.</param> /// <param name="downAction">Action on pointer down.</param> /// <param name="clickAction">Action on pointer click.</param> protected virtual RectTransform SetScrollButton(RectTransform oldButton, RectTransform newButton, UnityAction downAction, UnityAction clickAction) { if (oldButton != null) { Utilites.GetOrAddComponent <ScrollButton>(oldButton).OnDown.RemoveListener(downAction); Utilites.GetOrAddComponent <ScrollButton>(oldButton).OnUp.RemoveListener(AnimationStop); Utilites.GetOrAddComponent <ScrollButton>(oldButton).OnClick.RemoveListener(clickAction); } if (newButton != null) { Utilites.GetOrAddComponent <ScrollButton>(newButton).OnDown.AddListener(downAction); Utilites.GetOrAddComponent <ScrollButton>(newButton).OnUp.AddListener(AnimationStop); Utilites.GetOrAddComponent <ScrollButton>(newButton).OnClick.AddListener(clickAction); } return(newButton); }
/// <summary> /// Collapse animation. /// </summary> /// <returns>Animation.</returns> /// <param name="rectTransform">RectTransform.</param> /// <param name="time">Time.</param> /// <param name="isHorizontal">Is Horizontal animated width changes; otherwise height.</param> /// <param name="unscaledTime">Use unscaled time.</param> /// <param name="actionAfter">Action to run after animation.</param> static public IEnumerator CollapseFlexible(RectTransform rectTransform, float time = 0.5f, bool isHorizontal = false, bool unscaledTime = false, Action actionAfter = null) { var layoutElement = Utilites.GetOrAddComponent <LayoutElement>(rectTransform); if (isHorizontal) { layoutElement.preferredWidth = -1f; } else { layoutElement.preferredHeight = -1f; } var end_time = (unscaledTime ? Time.unscaledTime : Time.time) + time; while ((unscaledTime ? Time.unscaledTime : Time.time) <= end_time) { var size = Mathf.Lerp(1f, 0f, 1 - (end_time - (unscaledTime ? Time.unscaledTime : Time.time)) / time); if (isHorizontal) { layoutElement.flexibleWidth = size; } else { layoutElement.flexibleHeight = size; } yield return(null); } if (isHorizontal) { layoutElement.flexibleWidth = 0f; } else { layoutElement.flexibleHeight = 0f; } if (actionAfter != null) { actionAfter(); } }
/// <summary> /// Collapse animation. /// </summary> /// <returns>Animation.</returns> /// <param name="rectTransform">RectTransform.</param> /// <param name="time">Time.</param> /// <param name="isHorizontal">Is Horizontal animated width changes; otherwise height.</param> /// <param name="unscaledTime">Use unscaled time.</param> /// <param name="actionAfter">Action to run after animation.</param> public static IEnumerator Collapse(RectTransform rectTransform, float time = 0.5f, bool isHorizontal = false, bool unscaledTime = false, Action actionAfter = null) { var layoutElement = Utilites.GetOrAddComponent <LayoutElement>(rectTransform); var size = isHorizontal ? (LayoutUtilites.IsWidthControlled(rectTransform) ? LayoutUtility.GetPreferredWidth(rectTransform) : rectTransform.rect.width) : (LayoutUtilites.IsHeightControlled(rectTransform) ? LayoutUtility.GetPreferredHeight(rectTransform) : rectTransform.rect.height); var end_time = Utilites.GetTime(unscaledTime) + time; while (Utilites.GetTime(unscaledTime) <= end_time) { var t = 1 - ((end_time - Utilites.GetTime(unscaledTime)) / time); var new_size = Mathf.Lerp(size, 0, t); if (isHorizontal) { rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, new_size); layoutElement.preferredWidth = new_size; } else { rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, new_size); layoutElement.preferredHeight = new_size; } yield return(null); } // return size back for future use if (isHorizontal) { rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, size); layoutElement.preferredWidth = size; } else { rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, size); layoutElement.preferredHeight = size; } if (actionAfter != null) { actionAfter(); } }
/// <summary> /// Init this instance. /// </summary> public virtual void Init() { if (isInited) { return; } isInited = true; var scrollRect = TileView.GetScrollRect(); if (scrollRect != null) { ResizeListener = Utilites.GetOrAddComponent <ResizeListener>(scrollRect); BaseSizeDelta = (scrollRect.transform as RectTransform).sizeDelta; ApplyFitter(); } }
/// <summary> /// Init this instance. /// </summary> public void Init() { if (isInited) { return; } isInited = true; UpdateLayout(); var resizer = Utilites.GetOrAddComponent <ResizeListener>(this); resizer.OnResize.AddListener(Resize); Resize(); AlignComponents(); }
/// <summary> /// Set the specified style. /// </summary> /// <returns><c>true</c>, if style was set for children gameobjects, <c>false</c> otherwise.</returns> /// <param name="style">Style data.</param> public virtual bool SetStyle(Style style) { if (DefaultPage != null) { style.Paginator.DefaultBackground.ApplyTo(DefaultPage.GetComponent <Image>()); Utilites.GetOrAddComponent <ScrollRectPage>(DefaultPage).SetStyle(style.Paginator.DefaultText, style); } if (ActivePage != null) { style.Paginator.ActiveBackground.ApplyTo(ActivePage.GetComponent <Image>()); Utilites.GetOrAddComponent <ScrollRectPage>(ActivePage).SetStyle(style.Paginator.ActiveText, style); } DefaultPages.ForEach(x => { style.Paginator.DefaultBackground.ApplyTo(x.GetComponent <Image>()); Utilites.GetOrAddComponent <ScrollRectPage>(x).SetStyle(style.Paginator.DefaultText, style); }); DefaultPagesCache.ForEach(x => { style.Paginator.DefaultBackground.ApplyTo(x.GetComponent <Image>()); Utilites.GetOrAddComponent <ScrollRectPage>(x).SetStyle(style.Paginator.DefaultText, style); }); if (PrevPage != null) { style.Paginator.DefaultBackground.ApplyTo(PrevPage.GetComponent <Image>()); style.Paginator.DefaultText.ApplyTo(PrevPage.transform.Find("Text")); } if (NextPage != null) { style.Paginator.DefaultBackground.ApplyTo(NextPage.GetComponent <Image>()); style.Paginator.DefaultText.ApplyTo(NextPage.transform.Find("Text")); } return(true); }
/// <summary> /// Remove header cell. /// </summary> /// <param name="cell">Cell.</param> /// <param name="parent">Parent.</param> public void RemoveCell(GameObject cell, RectTransform parent = null) { var index = CellsInfo.FindIndex(x => x.Rect.gameObject == cell); var cell_info = CellsInfo[index]; if (index == -1) { Debug.LogWarning("Cell not in header", cell); return; } cell.SetActive(false); cell.transform.SetParent(parent, false); if (parent == null) { Destroy(cell); } // remove from cells CellsInfo.RemoveAt(index); // remove events var events = Utilites.GetOrAddComponent <TableHeaderCell>(cell); events.OnInitializePotentialDragEvent.RemoveListener(OnInitializePotentialDrag); events.OnBeginDragEvent.RemoveListener(OnBeginDrag); events.OnDragEvent.RemoveListener(OnDrag); events.OnEndDragEvent.RemoveListener(OnEndDrag); // decrease position for cells where >cell_position CellsInfo.ForEach(x => { if (x.Position > cell_info.Position) { x.Position -= 1; } }); // update list widths LayoutUtilites.UpdateLayout(layout); Resize(); }
/// <summary> /// Enable tracks view. /// </summary> /// <param name="tracksView">Tracks view.</param> protected virtual void EnableTracksView(ScrollRect tracksView) { if (tracksView == null) { return; } tracksView.content.pivot = new Vector2(0.5f, 1f); tracksView.inertia = false; tracksView.horizontal = true; tracksView.vertical = true; var tracks_drag = Utilites.GetOrAddComponent <DragListener>(tracksView); tracks_drag.OnInitializePotentialDragEvent.AddListener(OnTracksDragInit); tracks_drag.OnDragStartEvent.AddListener(OnTracksDragBegin); tracks_drag.OnDragEvent.AddListener(OnTracksDrag); tracks_drag.OnDragEndEvent.AddListener(OnTracksDragEnd); tracks_drag.OnScrollEvent.AddListener(OnTracksScroll); }
/// <summary> /// Initializes a new instance of the <see cref="UIWidgets.StandardLayoutBridge"/> class. /// </summary> /// <param name="layout">Layout.</param> /// <param name="defaultItem">Default item.</param> /// <param name="updateContentSizeFitter">Update ContentSizeFitter on direction change.</param> public StandardLayoutBridge(HorizontalOrVerticalLayoutGroup layout, RectTransform defaultItem, bool updateContentSizeFitter = true) { LayoutUtilites.UpdateLayout(layout); Layout = layout; DefaultItem = defaultItem; UpdateContentSizeFitter = updateContentSizeFitter; isHorizontal = layout is HorizontalLayoutGroup; var firstFillerGO = new GameObject("FirstFiller"); var firstFillerTransform = Utilites.GetOrAddComponent <RectTransform>(firstFillerGO); firstFillerTransform.SetParent(Layout.transform, false); firstFillerTransform.localScale = Vector3.one; FirstFiller = firstFillerGO.AddComponent <LayoutElement>(); var lastFillerGO = new GameObject("LastFiller"); var lastFillerTransform = Utilites.GetOrAddComponent <RectTransform>(lastFillerGO); lastFillerTransform.SetParent(Layout.transform, false); lastFillerTransform.localScale = Vector3.one; LastFiller = lastFillerGO.AddComponent <LayoutElement>(); var size = GetItemSize(); if (IsHorizontal) { firstFillerTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, size.y); lastFillerTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, size.y); } else { firstFillerTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, size.x); lastFillerTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, size.x); } fitter = Layout.GetComponent <ContentSizeFitter>(); }