public bool MoveUp(IReorderable reorderable) { if (reorderable.CanMoveUp == false) { return(false); } T item = (T)reorderable; int oldIndex = Items.IndexOf(item); if (oldIndex < 1) { return(false); } IsReordering = true; try { Remove(item); int newIndex = oldIndex - 1; Insert(newIndex, item); ChildReordered?.Invoke(this, new ReorderingEventArgs(this, reorderable, oldIndex, newIndex)); } finally { IsReordering = false; } return(true); }
/// <summary> /// Searches the IParentDrawer for valid IReorderableParent options for the IReorderable and saves them in the "results" list. /// </summary> /// <param name="reorderable"> The reorderable for which to find valid parents. </param> /// <param name="searchInChildren"> Parent whose children we search for valid reorderable parents for the reorderable. </param> /// <param name="results"> [in,out] The results. </param> private static void GetReorderableParentOptionsForReorderable([NotNull] IReorderable reorderable, [NotNull] IParentDrawer searchInChildren, ref List <IReorderableParent> results) { var reorderableParent = searchInChildren as IReorderableParent; if (reorderableParent != null && reorderableParent.Unfolded && reorderableParent.MemberIsReorderable(reorderable)) { results.Add(reorderableParent); /* * //is nestedness of IReorderableParents possible? Can't figure out how that could be possible, * //so won't search deeper after finding a valid target. * return; * UPDATE: It is possible! Can for example drag a Component into an array of Objects! */ } var members = searchInChildren.VisibleMembers; for (int n = members.Length - 1; n >= 0; n--) { var parent = members[n] as IParentDrawer; if (parent != null) { GetReorderableParentOptionsForReorderable(reorderable, parent, ref results); } } }
public ReorderingEventArgs(IReorderer reorderer, IReorderable reorderable, int oldIndex, int newIndex) { Reorderer = reorderer; Reorderable = reorderable; OldIndex = oldIndex; NewIndex = newIndex; }
/// <summary> /// Finds the valid IReorderableParent drop targets in the currently mouseovered inspector /// that can receive the IReorderable and saves them in the dropTargetParentOptions list. /// </summary> /// <param name="reordering"> The IReorderable currently being dragged. </param> private void UpdateReorderingOptions([NotNull] IReorderable reordering) { dropTargetParentOptions.Clear(); if (inspector != null) { GetReorderableParentOptionsForReorderable(reordering, inspector.State.drawers, ref dropTargetParentOptions); } }
public void Clear() { if (drawer != null) { parent.OnMemberReorderingEnded(drawer); drawer = null; parent = null; controlIndexInParent = -1; mouseoveredDropTarget.Clear(); isUnityObjectHeaderDrag = false; } }
public void OnReorderableDragStarted([NotNull] IReorderable reorderedControl, [NotNull] IReorderableParent reorderedControlParent, [NotNull] IInspector inspector) { #if DEV_MODE && DEBUG_DRAG_STARTED Debug.Log("OnReorderableDragStarted(control=" + StringUtils.ToString(reorderedControl) + ", parent=" + StringUtils.ToString(reorderedControlParent) + ")"); #endif drawer = reorderedControl; parent = reorderedControlParent; controlIndexInParent = Array.IndexOf(parent.Members, drawer); mouseoveredDropTarget.OnReorderableDragStarted(inspector, drawer); reorderedControlParent.OnMemberReorderingStarted(reorderedControl); isUnityObjectHeaderDrag = reorderedControl is IUnityObjectDrawer || reorderedControl is IAssetDrawer; }
protected override void PrepareContainerForItemOverride(DependencyObject element, object item) { base.PrepareContainerForItemOverride(element, item); ReorderListBoxItem reorderListBoxItem = item as ReorderListBoxItem; if (reorderListBoxItem == null) { return; } IReorderable reorderable = item as IReorderable; if (reorderable == null || !reorderable.CanReorder) { return; } reorderListBoxItem.IsReorderEnabled = true; }
/// <summary> /// Called when the inspector whose viewport is under the cursor is changed while an IReorderable or Objects are being dragged /// </summary> /// <param name="newlyMouseoveredInspector"> /// The inspector whose viewport is now being mouseovered</param> /// <param name="reordering"> /// The IReorderable currently being dragged. </param> /// <param name="draggedObjects"> /// The Object references currently being dragged. </param> public void OnDropTargetInspectorChanged(IInspector newlyMouseoveredInspector, IReorderable reordering, Object[] draggedObjects) { inspector = newlyMouseoveredInspector; if (inspector == null) { Clear(); return; } if (reordering != null) { UpdateReorderingOptions(reordering); } else { UpdateReorderingOptions(draggedObjects); } UpdateDropTarget(); #if DEV_MODE //Debug.Log("OnDropTargetInspectorChanged(" + StringUtils.ToString(newlyMouseoveredInspector) + "): " + StringUtils.ToString(inspector) + " parentOptions: " + StringUtils.ToString(dropTargetParentOptions)); #endif }
public void OnReorderableDragStarted([NotNull] IInspector containingInspector, [NotNull] IReorderable reordering) { #if DEV_MODE Debug.Assert(containingInspector != null); Debug.Assert(reordering != null); #endif inspector = containingInspector; UpdateReorderingOptions(reordering); UpdateDropTarget(); #if DEV_MODE && DEBUG_DRAG_STARTED Debug.Log("OnReorderableDragStarted(" + reordering + "): inspector=" + StringUtils.ToString(inspector) + ", parentOptions=" + StringUtils.ToString(dropTargetParentOptions)); #endif }
/// <inheritdoc/> public override bool MemberIsReorderable(IReorderable member) { return(false); }
/// <inheritdoc/> public void OnMemberReorderingEnded(IReorderable reordering) { }
/// <inheritdoc/> public void OnMemberReorderingStarted(IReorderable reordering) { }
/// <inheritdoc/> public bool MemberIsReorderable(IReorderable member) { var values = member.GetValues(); return(values.Length > 0 && (values[0] as GameObject) != null); }