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