/// <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>();
}
