public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
TreeViewTest.TestDragging.FooDragData fooDragData = DragAndDrop.GetGenericData("FooDragging") as TreeViewTest.TestDragging.FooDragData;
TreeViewTest.FooTreeViewItem fooTreeViewItem = targetItem as TreeViewTest.FooTreeViewItem;
TreeViewTest.FooTreeViewItem fooTreeViewItem2 = parentItem as TreeViewTest.FooTreeViewItem;
if (fooTreeViewItem2 != null && fooDragData != null)
{
bool flag = this.ValidDrag(parentItem, fooDragData.m_DraggedItems);
if (perform && flag)
{
List <TreeViewTest.BackendData.Foo> draggedItems = (
from x in fooDragData.m_DraggedItems
where x is TreeViewTest.FooTreeViewItem
select((TreeViewTest.FooTreeViewItem)x).foo).ToList <TreeViewTest.BackendData.Foo>();
this.m_BackendData.ReparentSelection(fooTreeViewItem2.foo, fooTreeViewItem.foo, draggedItems);
this.m_TreeView.ReloadData();
}
return((!flag) ? DragAndDropVisualMode.None : DragAndDropVisualMode.Move);
}
return(DragAndDropVisualMode.None);
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
DragAndDropVisualMode result;
if (targetItem == null)
{
result = DragAndDropVisualMode.None;
}
else
{
object genericData = DragAndDrop.GetGenericData(ProjectWindowUtil.k_DraggingFavoriteGenericData);
if (genericData != null)
{
int num = (int)genericData;
if (targetItem is SearchFilterTreeItem && parentItem is SearchFilterTreeItem)
{
bool flag = SavedSearchFilters.CanMoveSavedFilter(num, parentItem.id, targetItem.id, dropPos == TreeViewDragging.DropPosition.Below);
if (flag && perform)
{
SavedSearchFilters.MoveSavedFilter(num, parentItem.id, targetItem.id, dropPos == TreeViewDragging.DropPosition.Below);
this.m_TreeView.SetSelection(new int[]
{
num
}, false);
this.m_TreeView.NotifyListenersThatSelectionChanged();
}
result = ((!flag) ? DragAndDropVisualMode.None : DragAndDropVisualMode.Copy);
}
else
{
result = DragAndDropVisualMode.None;
}
}
else if (targetItem is SearchFilterTreeItem && parentItem is SearchFilterTreeItem)
{
string a = DragAndDrop.GetGenericData(ProjectWindowUtil.k_IsFolderGenericData) as string;
if (a == "isFolder")
{
if (perform)
{
UnityEngine.Object[] objectReferences = DragAndDrop.objectReferences;
if (objectReferences.Length > 0)
{
string assetPath = AssetDatabase.GetAssetPath(objectReferences[0].GetInstanceID());
if (!string.IsNullOrEmpty(assetPath))
{
string name = new DirectoryInfo(assetPath).Name;
SearchFilter searchFilter = new SearchFilter();
searchFilter.folders = new string[]
{
assetPath
};
bool addAsChild = targetItem == parentItem;
float listAreaGridSize = ProjectBrowserColumnOneTreeViewGUI.GetListAreaGridSize();
int num2 = SavedSearchFilters.AddSavedFilterAfterInstanceID(name, searchFilter, listAreaGridSize, targetItem.id, addAsChild);
this.m_TreeView.SetSelection(new int[]
{
num2
}, false);
this.m_TreeView.NotifyListenersThatSelectionChanged();
}
else
{
Debug.Log("Could not get asset path from id " + objectReferences[0].GetInstanceID());
}
}
}
result = DragAndDropVisualMode.Copy;
}
else
{
result = DragAndDropVisualMode.None;
}
}
else
{
result = base.DoDrag(parentItem, targetItem, perform, dropPos);
}
}
return(result);
}
private DragAndDropVisualMode DoDragScenes(GameObjectTreeViewItem parentItem, GameObjectTreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
List <Scene> list = DragAndDrop.GetGenericData("SceneHeaderList") as List <Scene>;
bool flag = list != null;
bool flag2 = false;
if (!flag && DragAndDrop.objectReferences.Length > 0)
{
int num = 0;
UnityEngine.Object[] objectReferences = DragAndDrop.objectReferences;
for (int i = 0; i < objectReferences.Length; i++)
{
UnityEngine.Object @object = objectReferences[i];
if (@object is SceneAsset)
{
num++;
}
}
flag2 = (num == DragAndDrop.objectReferences.Length);
}
if (!flag && !flag2)
{
return(DragAndDropVisualMode.None);
}
if (perform)
{
List <Scene> list2 = null;
if (flag2)
{
List <Scene> list3 = new List <Scene>();
UnityEngine.Object[] objectReferences2 = DragAndDrop.objectReferences;
for (int j = 0; j < objectReferences2.Length; j++)
{
UnityEngine.Object assetObject = objectReferences2[j];
string assetPath = AssetDatabase.GetAssetPath(assetObject);
Scene scene = SceneManager.GetSceneByPath(assetPath);
if (SceneHierarchyWindow.IsSceneHeaderInHierarchyWindow(scene))
{
this.m_TreeView.Frame(scene.handle, true, true);
}
else
{
bool alt = Event.current.alt;
if (alt)
{
scene = EditorSceneManager.OpenScene(assetPath, OpenSceneMode.AdditiveWithoutLoading);
}
else
{
scene = EditorSceneManager.OpenScene(assetPath, OpenSceneMode.Additive);
}
if (SceneHierarchyWindow.IsSceneHeaderInHierarchyWindow(scene))
{
list3.Add(scene);
}
}
}
if (targetItem != null)
{
list2 = list3;
}
if (list3.Count > 0)
{
Selection.instanceIDs = (from x in list3
select x.handle).ToArray <int>();
this.m_TreeView.Frame(list3.Last <Scene>().handle, true, false);
}
}
else
{
list2 = list;
}
if (list2 != null)
{
if (targetItem != null)
{
Scene scene2 = targetItem.scene;
if (SceneHierarchyWindow.IsSceneHeaderInHierarchyWindow(scene2))
{
if (!targetItem.isSceneHeader || dropPos == TreeViewDragging.DropPosition.Upon)
{
dropPos = TreeViewDragging.DropPosition.Below;
}
if (dropPos == TreeViewDragging.DropPosition.Above)
{
for (int k = 0; k < list2.Count; k++)
{
EditorSceneManager.MoveSceneBefore(list2[k], scene2);
}
}
else if (dropPos == TreeViewDragging.DropPosition.Below)
{
for (int l = list2.Count - 1; l >= 0; l--)
{
EditorSceneManager.MoveSceneAfter(list2[l], scene2);
}
}
}
}
else
{
Scene sceneAt = SceneManager.GetSceneAt(SceneManager.sceneCount - 1);
for (int m = list2.Count - 1; m >= 0; m--)
{
EditorSceneManager.MoveSceneAfter(list2[m], sceneAt);
}
}
}
}
return(DragAndDropVisualMode.Move);
}
public DragAndDropVisualMode HandleAudioSourceDrop(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
DragAndDropVisualMode result;
if (parentItem != null || targetItem != null)
{
result = 0;
}
else
{
IEnumerable <AudioSource> enumerable = DragAndDrop.get_objectReferences().OfType <AudioSource>();
if (!enumerable.Any <AudioSource>())
{
result = 0;
}
else if (this.m_Window.state.currentDirector == null)
{
result = 32;
}
else
{
if (perform)
{
foreach (AudioSource current in enumerable)
{
AudioTrack audioTrack = this.m_Window.AddTrack <AudioTrack>(null, string.Empty);
this.m_Window.state.currentDirector.SetGenericBinding(audioTrack, current);
}
this.m_Window.state.Refresh();
}
result = 1;
}
}
return(result);
}
public DragAndDropVisualMode HandleObjectDrop(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
DragAndDropVisualMode result;
if (!perform)
{
List <Object> list = new List <Object>();
if (DragAndDrop.get_objectReferences().Any <Object>())
{
list.AddRange(DragAndDrop.get_objectReferences());
using (List <Object> .Enumerator enumerator = list.GetEnumerator())
{
while (enumerator.MoveNext())
{
Object o = enumerator.Current;
TrackType[] trackTypeHandle = TimelineHelpers.GetTrackTypeHandle(o.GetType());
if (!trackTypeHandle.Any <TrackType>() || trackTypeHandle.Any((TrackType t) => !TimelineDragging.ValidateObjectDrop(o)))
{
result = 0;
return(result);
}
}
}
result = 1;
}
else if (DragAndDrop.get_paths().Any <string>())
{
TimelineGroupGUI timelineGroupGUI = targetItem as TimelineGroupGUI;
if (timelineGroupGUI == null)
{
result = 1;
}
else if (timelineGroupGUI.track == null)
{
result = 0;
}
else
{
TrackType tt = TimelineHelpers.TrackTypeFromType(timelineGroupGUI.track.GetType());
string[] paths = DragAndDrop.get_paths();
for (int i = 0; i < paths.Length; i++)
{
string text = paths[i];
list.AddRange(AssetDatabase.LoadAllAssetsAtPath(text));
}
bool flag = (from o in list
where o != null
select o).Any((Object o) => TimelineHelpers.IsTypeSupportedByTrack(tt, o.GetType()));
result = ((!flag) ? 0 : 1);
}
}
else
{
result = 0;
}
}
else
{
List <Object> list2 = new List <Object>();
list2.AddRange(DragAndDrop.get_objectReferences());
TrackAsset trackAsset = null;
TimelineGroupGUI timelineGroupGUI2 = (TimelineGroupGUI)targetItem;
if (targetItem != null && timelineGroupGUI2.track != null)
{
trackAsset = timelineGroupGUI2.track;
}
Vector2 mousePosition = Event.get_current().get_mousePosition();
foreach (Object current in list2)
{
if (!(current == null))
{
if (current is TimelineAsset)
{
if (TimelineHelpers.IsCircularRef(this.m_Timeline, current as TimelineAsset))
{
Debug.LogError("Cannot add " + current.get_name() + " to the sequence because it would cause a circular reference");
continue;
}
TimelineAsset timelineAsset = current as TimelineAsset;
foreach (TrackAsset current2 in timelineAsset.tracks)
{
if (current2.mediaType == TimelineAsset.MediaType.Group)
{
this.m_Timeline.AddTrackInternal(current2);
}
}
this.m_Window.state.Refresh();
EditorUtility.SetDirty(this.m_Timeline);
}
else if (current is TrackAsset)
{
this.m_Timeline.AddTrackInternal((TrackAsset)current);
}
else
{
TrackType trackType = null;
TrackAsset trackAsset2 = null;
TrackType[] trackTypeHandle2 = TimelineHelpers.GetTrackTypeHandle(current.GetType());
if (trackAsset != null)
{
TrackType[] array = trackTypeHandle2;
for (int j = 0; j < array.Length; j++)
{
TrackType trackType2 = array[j];
if (trackAsset.GetType() == trackType2.trackType)
{
trackType = trackType2;
break;
}
}
}
if (trackType == null)
{
if (trackTypeHandle2.Length == 1)
{
trackType = trackTypeHandle2[0];
}
else if (trackTypeHandle2.Length > 1)
{
trackType = this.ResolveTypeAmbiguity(trackTypeHandle2);
}
}
if (trackType == null)
{
continue;
}
if (!TimelineDragging.ValidateObjectDrop(current))
{
continue;
}
if (trackAsset != null && trackAsset.GetType() == trackType.trackType)
{
trackAsset2 = trackAsset;
}
if (trackAsset2 == null)
{
trackAsset2 = this.m_Window.AddTrack(trackType.trackType, null, string.Empty);
}
if (trackAsset2 == null)
{
result = 0;
return(result);
}
Object @object = TimelineDragging.TransformObjectBeingDroppedAccordingToTrackRules(trackAsset2, current);
if (@object == null)
{
continue;
}
TimelineUndo.PushUndo(trackAsset2, "Create Clip");
AnimationTrack animationTrack = trackAsset2 as AnimationTrack;
if (animationTrack != null)
{
animationTrack.ConvertToClipMode();
}
TimelineClip timelineClip = TimelineHelpers.CreateClipOnTrack(@object, trackAsset2, this.m_Window.state, mousePosition);
if (timelineClip != null)
{
float num = this.m_Window.state.TimeToPixel(1.0) - this.m_Window.state.TimeToPixel(0.0);
mousePosition.x += (float)timelineClip.duration * num;
if (timelineClip.asset is ScriptableObject)
{
string assetPath = AssetDatabase.GetAssetPath(timelineClip.asset);
if (assetPath.Length == 0)
{
TimelineCreateUtilities.SaveAssetIntoObject(timelineClip.asset, trackAsset2);
}
}
TimelineDragging.FrameClips(this.m_Window.state);
trackAsset2.SetCollapsed(false);
}
}
this.m_Window.state.Refresh();
EditorUtility.SetDirty(this.m_Timeline);
}
}
result = 1;
}
return(result);
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentNode, TreeViewItem targetNode, bool perform, TreeViewDragging.DropPosition dragPos)
{
AudioMixerTreeViewNode mixerTreeViewNode1 = targetNode as AudioMixerTreeViewNode;
AudioMixerTreeViewNode mixerTreeViewNode2 = parentNode as AudioMixerTreeViewNode;
List <AudioMixerGroupController> list1 = new List <UnityEngine.Object>((IEnumerable <UnityEngine.Object>)DragAndDrop.objectReferences).OfType <AudioMixerGroupController>().ToList <AudioMixerGroupController>();
if (mixerTreeViewNode2 == null || list1.Count <= 0)
{
return(DragAndDropVisualMode.None);
}
List <int> list2 = list1.Select <AudioMixerGroupController, int>((Func <AudioMixerGroupController, int>)(i => i.GetInstanceID())).ToList <int>();
bool flag = this.ValidDrag(parentNode, list2) && !AudioMixerController.WillModificationOfTopologyCauseFeedback(this.m_owner.Controller.GetAllAudioGroupsSlow(), list1, mixerTreeViewNode2.group, (List <AudioMixerController.ConnectionNode>)null);
if (perform && flag)
{
this.m_owner.Controller.ReparentSelection(mixerTreeViewNode2.group, mixerTreeViewNode1.group, list1);
this.m_owner.ReloadTree();
this.m_TreeView.SetSelection(list2.ToArray(), true);
}
return(flag ? DragAndDropVisualMode.Move : DragAndDropVisualMode.Rejected);
}
static DragAndDropVisualMode PrefabModeDraggingHandler(GameObjectTreeViewItem parentItem, GameObjectTreeViewItem targetItem, TreeViewDragging.DropPosition dropPos, bool perform)
{
var stage = StageNavigationManager.instance.currentItem;
if (!stage.isPrefabStage)
{
throw new InvalidOperationException("PrefabModeDraggingHandler should only be called in Prefab Mode");
}
// Disallow dropping as sibling to the prefab instance root (In Prefab Mode we only want to show one root).
if (parentItem != null && parentItem.parent == null && dropPos != TreeViewDragging.DropPosition.Upon)
{
return(DragAndDropVisualMode.Rejected);
}
// Disallow dragging scenes into the hierarchy when it is in Prefab Mode (we do not support multi-scenes for prefabs yet)
foreach (var dragged in DragAndDrop.objectReferences)
{
if (dragged is SceneAsset)
{
return(DragAndDropVisualMode.Rejected);
}
}
// Check for cyclic nesting (only on perform since it is an expensive operation)
if (perform)
{
var prefabAssetThatIsAddedTo = AssetDatabase.LoadMainAssetAtPath(stage.prefabAssetPath);
foreach (var dragged in DragAndDrop.objectReferences)
{
if (dragged is GameObject && EditorUtility.IsPersistent(dragged))
{
var prefabAssetThatWillBeAdded = dragged;
if (PrefabUtility.CheckIfAddingPrefabWouldResultInCyclicNesting(prefabAssetThatIsAddedTo, prefabAssetThatWillBeAdded))
{
PrefabUtility.ShowCyclicNestingWarningDialog();
return(DragAndDropVisualMode.Rejected);
}
}
}
}
return(DragAndDropVisualMode.None);
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentNode, TreeViewItem targetNode, bool perform, TreeViewDragging.DropPosition dragPos)
{
AudioMixerTreeViewNode node = targetNode as AudioMixerTreeViewNode;
AudioMixerTreeViewNode node2 = parentNode as AudioMixerTreeViewNode;
List <AudioMixerGroupController> source = new List <Object>(DragAndDrop.objectReferences).OfType <AudioMixerGroupController>().ToList <AudioMixerGroupController>();
if ((node2 == null) || (source.Count <= 0))
{
return(DragAndDropVisualMode.None);
}
if (< > f__am$cache1 == null)
{
public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
DragAndDropVisualMode dragAndDropVisualMode = this.DoDragScenes(parentItem as GameObjectTreeViewItem, targetItem as GameObjectTreeViewItem, perform, dropPos);
DragAndDropVisualMode result;
if (dragAndDropVisualMode != DragAndDropVisualMode.None)
{
result = dragAndDropVisualMode;
}
else
{
InternalEditorUtility.HierarchyDropMode hierarchyDropMode = InternalEditorUtility.HierarchyDropMode.kHierarchyDragNormal;
bool flag = !string.IsNullOrEmpty(((GameObjectTreeViewDataSource)this.m_TreeView.data).searchString);
if (flag)
{
hierarchyDropMode |= InternalEditorUtility.HierarchyDropMode.kHierarchySearchActive;
}
if (parentItem == null || targetItem == null)
{
hierarchyDropMode |= InternalEditorUtility.HierarchyDropMode.kHierarchyDropUpon;
result = InternalEditorUtility.HierarchyWindowDrag(null, perform, hierarchyDropMode);
}
else
{
HierarchyProperty hierarchyProperty = new HierarchyProperty(HierarchyType.GameObjects);
if (!hierarchyProperty.Find(targetItem.id, null))
{
hierarchyProperty = null;
}
bool flag2 = dropPos == TreeViewDragging.DropPosition.Upon;
if (flag && !flag2)
{
result = DragAndDropVisualMode.None;
}
else
{
hierarchyDropMode |= ((!flag2) ? InternalEditorUtility.HierarchyDropMode.kHierarchyDropBetween : InternalEditorUtility.HierarchyDropMode.kHierarchyDropUpon);
bool flag3 = parentItem != null && targetItem != parentItem && dropPos == TreeViewDragging.DropPosition.Above && parentItem.children[0] == targetItem;
if (flag3)
{
hierarchyDropMode |= InternalEditorUtility.HierarchyDropMode.kHierarchyDropAfterParent;
}
result = InternalEditorUtility.HierarchyWindowDrag(hierarchyProperty, perform, hierarchyDropMode);
}
}
}
return(result);
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentNode, TreeViewItem targetNode, bool perform, TreeViewDragging.DropPosition dragPos)
{
DragData genericData = DragAndDrop.GetGenericData("AudioMixerDragging") as DragData;
if (genericData == null)
{
return(DragAndDropVisualMode.None);
}
List <AudioMixerItem> draggedItems = genericData.m_DraggedItems;
AudioMixerItem item = parentNode as AudioMixerItem;
if ((item == null) || (genericData == null))
{
return(DragAndDropVisualMode.None);
}
if (< > f__am$cache1 == null)
{
private DragAndDropVisualMode DoDragScenes(GameObjectTreeViewItem parentItem, GameObjectTreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
List <Scene> genericData = DragAndDrop.GetGenericData("SceneHeaderList") as List <Scene>;
bool flag1 = genericData != null;
bool flag2 = false;
if (!flag1 && DragAndDrop.objectReferences.Length > 0)
{
int num = 0;
foreach (UnityEngine.Object objectReference in DragAndDrop.objectReferences)
{
if (objectReference is SceneAsset)
{
++num;
}
}
flag2 = num == DragAndDrop.objectReferences.Length;
}
if (!flag1 && !flag2)
{
return(DragAndDropVisualMode.None);
}
if (perform)
{
List <Scene> sceneList = (List <Scene>)null;
if (flag2)
{
List <Scene> source = new List <Scene>();
foreach (UnityEngine.Object objectReference in DragAndDrop.objectReferences)
{
string assetPath = AssetDatabase.GetAssetPath(objectReference);
Scene sceneByPath = SceneManager.GetSceneByPath(assetPath);
if (SceneHierarchyWindow.IsSceneHeaderInHierarchyWindow(sceneByPath))
{
this.m_TreeView.Frame(sceneByPath.handle, true, true);
}
else
{
Scene scene = !Event.current.alt ? EditorSceneManager.OpenScene(assetPath, OpenSceneMode.Additive) : EditorSceneManager.OpenScene(assetPath, OpenSceneMode.AdditiveWithoutLoading);
if (SceneHierarchyWindow.IsSceneHeaderInHierarchyWindow(scene))
{
source.Add(scene);
}
}
}
if (targetItem != null)
{
sceneList = source;
}
if (SceneManager.sceneCount - source.Count == 1)
{
((TreeViewDataSource)this.m_TreeView.data).SetExpanded(SceneManager.GetSceneAt(0).handle, true);
}
if (source.Count > 0)
{
Selection.instanceIDs = source.Select <Scene, int>((Func <Scene, int>)(x => x.handle)).ToArray <int>();
this.m_TreeView.Frame(source.Last <Scene>().handle, true, false);
}
}
else
{
sceneList = genericData;
}
if (sceneList != null)
{
if (targetItem != null)
{
Scene scene = targetItem.scene;
if (SceneHierarchyWindow.IsSceneHeaderInHierarchyWindow(scene))
{
if (!targetItem.isSceneHeader || dropPos == TreeViewDragging.DropPosition.Upon)
{
dropPos = TreeViewDragging.DropPosition.Below;
}
if (dropPos == TreeViewDragging.DropPosition.Above)
{
for (int index = 0; index < sceneList.Count; ++index)
{
EditorSceneManager.MoveSceneBefore(sceneList[index], scene);
}
}
else if (dropPos == TreeViewDragging.DropPosition.Below)
{
for (int index = sceneList.Count - 1; index >= 0; --index)
{
EditorSceneManager.MoveSceneAfter(sceneList[index], scene);
}
}
}
}
else
{
Scene sceneAt = SceneManager.GetSceneAt(SceneManager.sceneCount - 1);
for (int index = sceneList.Count - 1; index >= 0; --index)
{
EditorSceneManager.MoveSceneAfter(sceneList[index], sceneAt);
}
}
}
}
return(DragAndDropVisualMode.Move);
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
FooDragData genericData = DragAndDrop.GetGenericData("FooDragging") as FooDragData;
TreeViewTest.FooTreeViewItem item = targetItem as TreeViewTest.FooTreeViewItem;
TreeViewTest.FooTreeViewItem item2 = parentItem as TreeViewTest.FooTreeViewItem;
if ((item2 == null) || (genericData == null))
{
return(DragAndDropVisualMode.None);
}
bool flag = this.ValidDrag(parentItem, genericData.m_DraggedItems);
if (perform && flag)
{
if (< > f__am$cache1 == null)
{
public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
HierarchyProperty property = new HierarchyProperty(HierarchyType.GameObjects);
if ((parentItem == null) || (targetItem == null))
{
return(InternalEditorUtility.HierarchyWindowDrag(null, perform, InternalEditorUtility.HierarchyDropMode.kHierarchyDropUpon));
}
if (this.allowDragBetween)
{
if (((dropPos == TreeViewDragging.DropPosition.Above) || (targetItem == null)) || !property.Find(targetItem.id, null))
{
property = null;
}
}
else if (((dropPos == TreeViewDragging.DropPosition.Above) || (parentItem == null)) || !property.Find(parentItem.id, null))
{
property = null;
}
InternalEditorUtility.HierarchyDropMode kHierarchyDragNormal = InternalEditorUtility.HierarchyDropMode.kHierarchyDragNormal;
if (this.allowDragBetween)
{
kHierarchyDragNormal = (dropPos != TreeViewDragging.DropPosition.Upon) ? InternalEditorUtility.HierarchyDropMode.kHierarchyDropBetween : InternalEditorUtility.HierarchyDropMode.kHierarchyDropUpon;
}
if (((parentItem != null) && (parentItem == targetItem)) && (dropPos != TreeViewDragging.DropPosition.Above))
{
kHierarchyDragNormal |= InternalEditorUtility.HierarchyDropMode.kHierarchyDropAfterParent;
}
return(InternalEditorUtility.HierarchyWindowDrag(property, perform, kHierarchyDragNormal));
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentNode, TreeViewItem targetNode, bool perform, TreeViewDragging.DropPosition dragPos)
{
AudioMixerTreeViewDragging.DragData genericData = DragAndDrop.GetGenericData("AudioMixerDragging") as AudioMixerTreeViewDragging.DragData;
if (genericData == null)
{
return(DragAndDropVisualMode.None);
}
List <AudioMixerItem> draggedItems = genericData.m_DraggedItems;
AudioMixerItem audioMixerItem = parentNode as AudioMixerItem;
if (audioMixerItem == null || genericData == null)
{
return(DragAndDropVisualMode.None);
}
List <AudioMixerGroupController> list = draggedItems.Select <AudioMixerItem, AudioMixerGroupController>((Func <AudioMixerItem, AudioMixerGroupController>)(i => i.mixer.masterGroup)).ToList <AudioMixerGroupController>();
bool flag1 = AudioMixerController.WillModificationOfTopologyCauseFeedback(audioMixerItem.mixer.GetAllAudioGroupsSlow(), list, audioMixerItem.mixer.masterGroup, (List <AudioMixerController.ConnectionNode>)null);
bool flag2 = this.ValidDrag(parentNode, draggedItems) && !flag1;
if (perform && flag2 && this.m_MixersDroppedOnMixerCallback != null)
{
this.m_MixersDroppedOnMixerCallback(this.GetAudioMixersFromItems(draggedItems), audioMixerItem.mixer);
}
return(flag2 ? DragAndDropVisualMode.Move : DragAndDropVisualMode.Rejected);
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentNode, TreeViewItem targetNode, bool perform, TreeViewDragging.DropPosition dragPos)
{
AudioMixerTreeViewDragging.DragData dragData = DragAndDrop.GetGenericData("AudioMixerDragging") as AudioMixerTreeViewDragging.DragData;
DragAndDropVisualMode result;
if (dragData == null)
{
result = DragAndDropVisualMode.None;
}
else
{
List <AudioMixerItem> draggedItems = dragData.m_DraggedItems;
AudioMixerItem audioMixerItem = parentNode as AudioMixerItem;
if (audioMixerItem != null && dragData != null)
{
List <AudioMixerGroupController> groupsToBeMoved = (from i in draggedItems
select i.mixer.masterGroup).ToList <AudioMixerGroupController>();
List <AudioMixerGroupController> allAudioGroupsSlow = audioMixerItem.mixer.GetAllAudioGroupsSlow();
bool flag = AudioMixerController.WillModificationOfTopologyCauseFeedback(allAudioGroupsSlow, groupsToBeMoved, audioMixerItem.mixer.masterGroup, null);
bool flag2 = this.ValidDrag(parentNode, draggedItems) && !flag;
if (perform && flag2)
{
if (this.m_MixersDroppedOnMixerCallback != null)
{
this.m_MixersDroppedOnMixerCallback(this.GetAudioMixersFromItems(draggedItems), audioMixerItem.mixer);
}
}
result = ((!flag2) ? DragAndDropVisualMode.Rejected : DragAndDropVisualMode.Move);
}
else
{
result = DragAndDropVisualMode.None;
}
}
return(result);
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentNode, TreeViewItem targetNode, bool perform, TreeViewDragging.DropPosition dragPos)
{
AudioMixerTreeViewNode audioMixerTreeViewNode = targetNode as AudioMixerTreeViewNode;
AudioMixerTreeViewNode audioMixerTreeViewNode2 = parentNode as AudioMixerTreeViewNode;
List <AudioMixerGroupController> list = new List <UnityEngine.Object>(DragAndDrop.objectReferences).OfType <AudioMixerGroupController>().ToList <AudioMixerGroupController>();
if (audioMixerTreeViewNode2 != null && list.Count > 0)
{
List <int> list2 = (from i in list
select i.GetInstanceID()).ToList <int>();
bool flag = this.ValidDrag(parentNode, list2) && !AudioMixerController.WillModificationOfTopologyCauseFeedback(this.m_owner.Controller.GetAllAudioGroupsSlow(), list, audioMixerTreeViewNode2.group, null);
if (perform && flag)
{
AudioMixerGroupController group = audioMixerTreeViewNode2.group;
this.m_owner.Controller.ReparentSelection(group, audioMixerTreeViewNode.group, list);
this.m_owner.ReloadTree();
this.m_TreeView.SetSelection(list2.ToArray(), true);
}
return((!flag) ? DragAndDropVisualMode.Rejected : DragAndDropVisualMode.Move);
}
return(DragAndDropVisualMode.None);
}
public abstract DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPosition);
internal static int GetInsertionIndex(TreeViewItem parentItem, TreeViewItem targetItem, TreeViewDragging.DropPosition dropPosition)
{
int result;
if (parentItem == null)
{
result = -1;
}
else
{
int num;
if (parentItem == targetItem)
{
num = -1;
}
else
{
int num2 = parentItem.children.IndexOf(targetItem);
if (num2 >= 0)
{
if (dropPosition == TreeViewDragging.DropPosition.Below)
{
num = num2 + 1;
}
else
{
num = num2;
}
}
else
{
Debug.LogError("Did not find targetItem,; should be a child of parentItem");
num = -1;
}
}
result = num;
}
return(result);
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPosition)
{
DragAndDropVisualMode result;
if (this.m_Owner.m_OverriddenMethods.hasHandleDragAndDrop)
{
TreeView.DragAndDropArgs args = new TreeView.DragAndDropArgs
{
insertAtIndex = -1,
parentItem = parentItem,
performDrop = perform
};
if (parentItem != null && targetItem != null)
{
args.insertAtIndex = TreeViewDragging.GetInsertionIndex(parentItem, targetItem, dropPosition);
}
result = this.m_Owner.HandleDragAndDrop(args);
}
else
{
result = DragAndDropVisualMode.None;
}
return(result);
}
protected bool TryGetDropPosition(TreeViewItem item, Rect itemRect, int row, out TreeViewDragging.DropPosition dropPosition)
{
Vector2 mousePosition = Event.current.mousePosition;
bool result;
if (itemRect.Contains(mousePosition))
{
float dropBetweenHalfHeight = this.GetDropBetweenHalfHeight(item, itemRect);
if (mousePosition.y >= itemRect.yMax - dropBetweenHalfHeight)
{
dropPosition = TreeViewDragging.DropPosition.Below;
}
else if (mousePosition.y <= itemRect.yMin + dropBetweenHalfHeight)
{
dropPosition = TreeViewDragging.DropPosition.Above;
}
else
{
dropPosition = TreeViewDragging.DropPosition.Upon;
}
result = true;
}
else
{
float height = this.m_TreeView.gui.halfDropBetweenHeight;
int num = row + 1;
if (num < this.m_TreeView.data.rowCount)
{
Rect rowRect = this.m_TreeView.gui.GetRowRect(num, itemRect.width);
bool flag = this.m_TreeView.data.CanBeParent(this.m_TreeView.data.GetItem(num));
if (flag)
{
height = this.m_TreeView.gui.halfDropBetweenHeight;
}
else
{
height = rowRect.height * 0.5f;
}
}
Rect rect = itemRect;
rect.y = itemRect.yMax;
rect.height = height;
if (rect.Contains(mousePosition))
{
dropPosition = TreeViewDragging.DropPosition.Below;
result = true;
}
else
{
if (row == 0)
{
Rect rect2 = itemRect;
rect2.yMin -= this.m_TreeView.gui.halfDropBetweenHeight;
rect2.height = this.m_TreeView.gui.halfDropBetweenHeight;
if (rect2.Contains(mousePosition))
{
dropPosition = TreeViewDragging.DropPosition.Above;
result = true;
return(result);
}
}
dropPosition = TreeViewDragging.DropPosition.Below;
result = false;
}
}
return(result);
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
this.m_Window.isDragging = false;
DragAndDropVisualMode dragAndDropVisualMode = 0;
TimelineDragging.TimelineDragData timelineDragData = DragAndDrop.GetGenericData("TimelineDragging") as TimelineDragging.TimelineDragData;
if (timelineDragData != null)
{
dragAndDropVisualMode = this.HandleTrackDrop(parentItem, targetItem, perform, dropPos);
}
else if (DragAndDrop.get_objectReferences().Any <Object>() || DragAndDrop.get_paths().Any <string>())
{
dragAndDropVisualMode = this.HandleGameObjectDrop(parentItem, targetItem, perform, dropPos);
if (dragAndDropVisualMode == null)
{
dragAndDropVisualMode = this.HandleAudioSourceDrop(parentItem, targetItem, perform, dropPos);
}
if (dragAndDropVisualMode == null)
{
dragAndDropVisualMode = this.HandleObjectDrop(parentItem, targetItem, perform, dropPos);
}
}
this.m_Window.isDragging = false;
if (dragAndDropVisualMode == 1 && targetItem != null)
{
TimelineGroupGUI timelineGroupGUI = targetItem as TimelineGroupGUI;
if (timelineGroupGUI != null)
{
timelineGroupGUI.isDropTarget = true;
}
}
return(dragAndDropVisualMode);
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
FooDragData genericData = DragAndDrop.GetGenericData("FooDragging") as FooDragData;
FooTreeViewItem item = parentItem as FooTreeViewItem;
if ((item != null) && (genericData != null))
{
bool flag = this.ValidDrag(parentItem, genericData.m_DraggedItems);
if (perform && flag)
{
if (< > f__am$cache0 == null)
{
public DragAndDropVisualMode HandleGameObjectDrop(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
DragAndDropVisualMode result;
if (parentItem != null || targetItem != null)
{
result = 0;
}
else if (!DragAndDrop.get_objectReferences().Any((Object x) => x is GameObject))
{
result = 0;
}
else if (this.m_Window.state.currentDirector == null)
{
result = 32;
}
else
{
if (perform)
{
Object[] objectReferences = DragAndDrop.get_objectReferences();
for (int i = 0; i < objectReferences.Length; i++)
{
Object @object = objectReferences[i];
GameObject go = @object as GameObject;
if (!(go == null))
{
PrefabType prefabType = PrefabUtility.GetPrefabType(go);
if (prefabType != 1 && prefabType != 2)
{
IEnumerable <TrackType> enumerable = from x in TimelineHelpers.GetMixableTypes()
where x.requiresGameObjectBinding
select x;
GenericMenu genericMenu = new GenericMenu();
foreach (TrackType current in enumerable)
{
genericMenu.AddItem(new GUIContent(TimelineHelpers.GetTrackMenuName(current)), false, delegate(object e)
{
TrackAsset trackAsset = this.m_Window.AddTrack(((TrackType)e).trackType, null, string.Empty);
if (trackAsset.GetType() == typeof(ActivationTrack))
{
TimelineClip timelineClip = trackAsset.CreateClip(0.0);
timelineClip.displayName = ActivationTrackDrawer.Styles.ClipText.get_text();
}
this.m_Window.state.previewMode = false;
TimelineUtility.SetSceneGameObject(this.m_Window.state.currentDirector, trackAsset, go);
}, current);
}
genericMenu.ShowAsContext();
}
this.m_Window.state.Refresh();
}
}
}
result = 1;
}
return(result);
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
TestDragging.FooDragData fooDragData = DragAndDrop.GetGenericData("FooDragging") as TestDragging.FooDragData;
FooTreeViewItem fooTreeViewItem = parentItem as FooTreeViewItem;
DragAndDropVisualMode result;
if (fooTreeViewItem != null && fooDragData != null)
{
bool flag = this.ValidDrag(parentItem, fooDragData.m_DraggedItems);
if (perform && flag)
{
List <BackendData.Foo> draggedItems = (from x in fooDragData.m_DraggedItems
where x is FooTreeViewItem
select((FooTreeViewItem)x).foo).ToList <BackendData.Foo>();
int[] selectedIDs = (from x in fooDragData.m_DraggedItems
where x is FooTreeViewItem
select((FooTreeViewItem)x).id).ToArray <int>();
int insertionIndex = TreeViewDragging.GetInsertionIndex(parentItem, targetItem, dropPos);
this.m_BackendData.ReparentSelection(fooTreeViewItem.foo, insertionIndex, draggedItems);
this.m_TreeView.ReloadData();
this.m_TreeView.SetSelection(selectedIDs, true);
}
result = ((!flag) ? DragAndDropVisualMode.None : DragAndDropVisualMode.Move);
}
else
{
result = DragAndDropVisualMode.None;
}
return(result);
}
public DragAndDropVisualMode HandleTrackDrop(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
((TimelineTreeView)this.m_Window.treeView.gui).showInsertionMarker = false;
TimelineDragging.TimelineDragData timelineDragData = (TimelineDragging.TimelineDragData)DragAndDrop.GetGenericData("TimelineDragging");
DragAndDropVisualMode result;
if (!TimelineDragging.ValidDrag(targetItem, timelineDragData.draggedItems))
{
result = 0;
}
else
{
TimelineGroupGUI timelineGroupGUI = targetItem as TimelineGroupGUI;
if (timelineGroupGUI != null && timelineGroupGUI.track != null)
{
((TimelineTreeView)this.m_Window.treeView.gui).showInsertionMarker = true;
}
if (dropPos == null)
{
TimelineGroupGUI timelineGroupGUI2 = targetItem as TimelineGroupGUI;
if (timelineGroupGUI2 != null)
{
timelineGroupGUI2.isDropTarget = true;
}
}
if (perform)
{
List <TrackAsset> draggedActors = (from x in timelineDragData.draggedItems.OfType <TimelineGroupGUI>()
select x.track).ToList <TrackAsset>();
if (draggedActors.Count == 0)
{
result = 0;
return(result);
}
PlayableAsset playableAsset = this.m_Timeline;
TimelineGroupGUI timelineGroupGUI3 = parentItem as TimelineGroupGUI;
if (timelineGroupGUI3 != null && timelineGroupGUI3.track != null)
{
playableAsset = timelineGroupGUI3.track;
}
TrackAsset trackAsset = (timelineGroupGUI == null) ? null : timelineGroupGUI.track;
if (playableAsset == this.m_Timeline && dropPos == 1 && trackAsset == null)
{
trackAsset = this.m_Timeline.tracks.LastOrDefault((TrackAsset x) => !draggedActors.Contains(x));
}
if (TrackExtensions.ReparentTracks(draggedActors, playableAsset, trackAsset, dropPos == 2))
{
this.m_Window.state.Refresh(true);
}
}
result = 16;
}
return(result);
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
HierarchyProperty property = new HierarchyProperty(HierarchyType.Assets);
if ((parentItem == null) || !property.Find(parentItem.id, null))
{
property = null;
}
return(InternalEditorUtility.ProjectWindowDrag(property, perform));
}
public override bool DragElement(TreeViewItem targetItem, Rect targetItemRect, bool firstItem)
{
if (targetItem == null)
{
if (m_DropData != null)
{
m_DropData.dropTargetControlID = 0;
m_DropData.rowMarkerControlID = 0;
}
bool perform = Event.current.type == EventType.DragPerform;
DragAndDrop.visualMode = DoDrag(null, null, perform, TreeViewDragging.DropPosition.Below);
if (DragAndDrop.visualMode != DragAndDropVisualMode.None && perform)
{
FinalizeDragPerformed(true);
}
return(false);
}
Vector2 mousePosition = Event.current.mousePosition;
bool flag = m_TreeView.data.CanBeParent(targetItem);
Rect rect = targetItemRect;
float betweenHalfHeight = !flag ? targetItemRect.height * 0.5f : m_TreeView.gui.halfDropBetweenHeight;
if (firstItem)
{
rect.yMin -= betweenHalfHeight;
}
rect.yMax += betweenHalfHeight;
if (!rect.Contains(mousePosition))
{
return(false);
}
TreeViewDragging.DropPosition dropPosition = mousePosition.y < targetItemRect.yMax - betweenHalfHeight ? (!firstItem || mousePosition.y > targetItemRect.yMin + betweenHalfHeight ? (!flag ? TreeViewDragging.DropPosition.Above : TreeViewDragging.DropPosition.Upon) : TreeViewDragging.DropPosition.Above) : TreeViewDragging.DropPosition.Below;
TreeViewItem parentItem = !m_TreeView.data.IsExpanded(targetItem) || !targetItem.hasChildren ? targetItem.parent : targetItem;
DragAndDropVisualMode andDropVisualMode1 = DragAndDropVisualMode.None;
if (Event.current.type == EventType.DragPerform)
{
if (dropPosition == TreeViewDragging.DropPosition.Upon)
{
andDropVisualMode1 = DoDrag(targetItem, targetItem, true, dropPosition);
}
if (andDropVisualMode1 == DragAndDropVisualMode.None && parentItem != null)
{
andDropVisualMode1 = DoDrag(parentItem, targetItem, true, dropPosition);
}
if (andDropVisualMode1 != DragAndDropVisualMode.None)
{
FinalizeDragPerformed(false);
}
else
{
DragCleanup(true);
m_TreeView.NotifyListenersThatDragEnded(null, false);
}
}
else
{
if (m_DropData == null)
{
m_DropData = new TreeViewDragging.DropData();
}
m_DropData.dropTargetControlID = 0;
m_DropData.rowMarkerControlID = 0;
int itemControlId = TreeView.GetItemControlID(targetItem, m_TreeView);
HandleAutoExpansion(itemControlId, targetItem, targetItemRect, betweenHalfHeight, mousePosition);
if (dropPosition == TreeViewDragging.DropPosition.Upon)
{
andDropVisualMode1 = DoDrag(targetItem, targetItem, false, dropPosition);
}
if (andDropVisualMode1 != DragAndDropVisualMode.None)
{
m_DropData.dropTargetControlID = itemControlId;
DragAndDrop.visualMode = andDropVisualMode1;
}
else if (parentItem != null)
{
DragAndDropVisualMode andDropVisualMode2 = DoDrag(parentItem, targetItem, false, dropPosition);
if (andDropVisualMode2 != DragAndDropVisualMode.None)
{
drawRowMarkerAbove = dropPosition == TreeViewDragging.DropPosition.Above;
m_DropData.rowMarkerControlID = itemControlId;
//m_DropData.dropTargetControlID = !drawRowMarkerAbove ? TreeView.GetItemControlID(parentItem) : 0;
DragAndDrop.visualMode = andDropVisualMode2;
}
}
}
Event.current.Use();
return(true);
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
if (targetItem == null)
{
return(DragAndDropVisualMode.None);
}
object genericData = DragAndDrop.GetGenericData(ProjectWindowUtil.k_DraggingFavoriteGenericData);
if (genericData != null)
{
int instanceID = (int)genericData;
if (!(targetItem is SearchFilterTreeItem) || !(parentItem is SearchFilterTreeItem))
{
return(DragAndDropVisualMode.None);
}
bool flag = SavedSearchFilters.CanMoveSavedFilter(instanceID, parentItem.id, targetItem.id, true);
if (flag && perform)
{
SavedSearchFilters.MoveSavedFilter(instanceID, parentItem.id, targetItem.id, true);
}
return(!flag ? DragAndDropVisualMode.None : DragAndDropVisualMode.Copy);
}
if (!(targetItem is SearchFilterTreeItem) || !(parentItem is SearchFilterTreeItem))
{
return(base.DoDrag(parentItem, targetItem, perform, dropPos));
}
string str = DragAndDrop.GetGenericData(ProjectWindowUtil.k_IsFolderGenericData) as string;
if (!(str == "isFolder"))
{
return(DragAndDropVisualMode.None);
}
if (perform)
{
UnityEngine.Object[] objectReferences = DragAndDrop.objectReferences;
if (objectReferences.Length > 0)
{
HierarchyProperty property = new HierarchyProperty(HierarchyType.Assets);
if (property.Find(objectReferences[0].GetInstanceID(), null))
{
SearchFilter filter = new SearchFilter();
string assetPath = AssetDatabase.GetAssetPath(property.instanceID);
if (!string.IsNullOrEmpty(assetPath))
{
filter.folders = new string[] { assetPath };
bool addAsChild = targetItem == parentItem;
float listAreaGridSize = ProjectBrowserColumnOneTreeViewGUI.GetListAreaGridSize();
Selection.activeInstanceID = SavedSearchFilters.AddSavedFilterAfterInstanceID(property.name, filter, listAreaGridSize, targetItem.id, addAsChild);
}
else
{
Debug.Log("Could not get asset path from id " + property.name);
}
}
}
}
return(DragAndDropVisualMode.Copy);
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
DragAndDropVisualMode dragAndDropVisualMode = this.DoDragScenes(parentItem as GameObjectTreeViewItem, targetItem as GameObjectTreeViewItem, perform, dropPos);
if (dragAndDropVisualMode != DragAndDropVisualMode.None)
{
return(dragAndDropVisualMode);
}
if (parentItem == null || targetItem == null)
{
return(InternalEditorUtility.HierarchyWindowDrag(null, perform, InternalEditorUtility.HierarchyDropMode.kHierarchyDropUpon));
}
HierarchyProperty hierarchyProperty = new HierarchyProperty(HierarchyType.GameObjects);
if (this.allowDragBetween)
{
if (dropPos == TreeViewDragging.DropPosition.Above || !hierarchyProperty.Find(targetItem.id, null))
{
hierarchyProperty = null;
}
}
else if (dropPos == TreeViewDragging.DropPosition.Above || !hierarchyProperty.Find(parentItem.id, null))
{
hierarchyProperty = null;
}
InternalEditorUtility.HierarchyDropMode hierarchyDropMode = InternalEditorUtility.HierarchyDropMode.kHierarchyDragNormal;
if (this.allowDragBetween)
{
hierarchyDropMode = ((dropPos != TreeViewDragging.DropPosition.Upon) ? InternalEditorUtility.HierarchyDropMode.kHierarchyDropBetween : InternalEditorUtility.HierarchyDropMode.kHierarchyDropUpon);
}
if (parentItem != null && parentItem == targetItem && dropPos != TreeViewDragging.DropPosition.Above)
{
hierarchyDropMode |= InternalEditorUtility.HierarchyDropMode.kHierarchyDropAfterParent;
}
return(InternalEditorUtility.HierarchyWindowDrag(hierarchyProperty, perform, hierarchyDropMode));
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
TestDragging.FooDragData genericData = DragAndDrop.GetGenericData("FooDragging") as TestDragging.FooDragData;
FooTreeViewItem fooTreeViewItem1 = targetItem as FooTreeViewItem;
FooTreeViewItem fooTreeViewItem2 = parentItem as FooTreeViewItem;
if (fooTreeViewItem2 == null || genericData == null)
{
return(DragAndDropVisualMode.None);
}
bool flag = this.ValidDrag(parentItem, genericData.m_DraggedItems);
if (perform && flag)
{
List <BackendData.Foo> list = genericData.m_DraggedItems.Where <TreeViewItem>((Func <TreeViewItem, bool>)(x => x is FooTreeViewItem)).Select <TreeViewItem, BackendData.Foo>((Func <TreeViewItem, BackendData.Foo>)(x => ((FooTreeViewItem)x).foo)).ToList <BackendData.Foo>();
int[] array = genericData.m_DraggedItems.Where <TreeViewItem>((Func <TreeViewItem, bool>)(x => x is FooTreeViewItem)).Select <TreeViewItem, int>((Func <TreeViewItem, int>)(x => x.id)).ToArray <int>();
this.m_BackendData.ReparentSelection(fooTreeViewItem2.foo, fooTreeViewItem1.foo, list);
this.m_TreeView.ReloadData();
this.m_TreeView.SetSelection(array, true);
}
return(flag ? DragAndDropVisualMode.Move : DragAndDropVisualMode.None);
}
