internal static Object DoDropField(Rect position, int id, System.Type objType, ObjectFieldValidator validator, bool allowSceneObjects, GUIStyle style)
{
if (validator == null)
{
validator = ValidateObjectFieldAssignment;
}
Event evt = Event.current;
EventType eventType = evt.type;
// special case test, so we continue to ping/select objects with the object field disabled
if (!GUI.enabled && GUIClip.enabled && (Event.current.rawType == EventType.MouseDown))
{
eventType = Event.current.rawType;
}
switch (eventType)
{
case EventType.DragExited:
if (GUI.enabled)
{
HandleUtility.Repaint();
}
break;
case EventType.DragUpdated:
case EventType.DragPerform:
if (position.Contains(Event.current.mousePosition) && GUI.enabled)
{
Object[] references = DragAndDrop.objectReferences;
Object validatedObject = validator(references, objType, null, ObjectFieldValidatorOptions.None);
if (validatedObject != null)
{
// If scene objects are not allowed and object is a scene object then clear
if (!allowSceneObjects && !EditorUtility.IsPersistent(validatedObject))
{
validatedObject = null;
}
}
if (validatedObject != null)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Generic;
if (eventType == EventType.DragPerform)
{
GUI.changed = true;
DragAndDrop.AcceptDrag();
DragAndDrop.activeControlID = 0;
Event.current.Use();
return(validatedObject);
}
else
{
DragAndDrop.activeControlID = id;
Event.current.Use();
}
}
}
break;
case EventType.Repaint:
style.Draw(position, GUIContent.none, id, DragAndDrop.activeControlID == id);
break;
}
return(null);
}
void ListArea(Rect rect, PresetLibrary lib, object newPresetObject)
{
if (lib == null)
{
return;
}
Event evt = Event.current;
if (m_PresetLibraryFileLocation == PresetFileLocation.ProjectFolder && evt.type == EventType.Repaint)
{
m_IsOpenForEdit = AssetDatabase.IsOpenForEdit(pathWithExtension, StatusQueryOptions.UseCachedIfPossible);
}
else if (m_PresetLibraryFileLocation == PresetFileLocation.PreferencesFolder)
{
m_IsOpenForEdit = true;
}
if (!m_IsOpenForEdit)
{
Rect versionControlRect = new Rect(rect.x, rect.yMax - versionControlAreaHeight, rect.width, versionControlAreaHeight);
VersionControlArea(versionControlRect);
rect.height -= versionControlAreaHeight;
}
// To ensure we setup grid to visible rect we need to run once to check if scrollbar is taking up screen estate.
// To optimize the first width is based on the last frame and we therefore most likely will only run once.
for (int i = 0; i < 2; i++)
{
gridWidth = m_ShowedScrollBarLastFrame ? rect.width - 17 : rect.width;
SetupGrid(gridWidth, lib.Count());
bool isShowingScrollBar = m_Grid.height > rect.height;
if (isShowingScrollBar == m_ShowedScrollBarLastFrame)
{
break;
}
else
{
m_ShowedScrollBarLastFrame = isShowingScrollBar;
}
}
// Draw horizontal lines for scrollview content to clip against
if ((m_ShowedScrollBarLastFrame || alwaysShowScrollAreaHorizontalLines) && Event.current.type == EventType.Repaint)
{
Rect scrollEdgeRect = new RectOffset(1, 1, 1, 1).Add(rect);
scrollEdgeRect.height = 1;
EditorGUI.DrawRect(scrollEdgeRect, new Color(0, 0, 0, 0.3f));
scrollEdgeRect.y += rect.height + 1;
EditorGUI.DrawRect(scrollEdgeRect, new Color(0, 0, 0, 0.3f));
}
Rect contentRect = new Rect(0, 0, 1, m_Grid.height);
m_State.m_ScrollPosition = GUI.BeginScrollView(rect, m_State.m_ScrollPosition, contentRect);
{
int startIndex, endIndex;
float yOffset = 0f;
int maxIndex = m_ShowAddNewPresetItem ? lib.Count() : lib.Count() - 1;
bool isGridVisible = m_Grid.IsVisibleInScrollView(rect.height, m_State.m_ScrollPosition.y, yOffset, maxIndex, out startIndex, out endIndex);
bool drawDragInsertionMarker = false;
if (isGridVisible)
{
// Handle renaming overlay before item handling because its needs mouse input first to end renaming if clicked outside
if (GetRenameOverlay().IsRenaming() && !GetRenameOverlay().isWaitingForDelay)
{
if (!m_State.m_RenameOverlay.OnGUI())
{
EndRename();
evt.Use();
}
Repaint();
}
for (int i = startIndex; i <= endIndex; ++i)
{
int itemControlID = i + 1000000;
Rect itemRect = m_Grid.CalcRect(i, yOffset);
Rect previewRect = itemRect;
Rect labelRect = itemRect;
switch (m_State.itemViewMode)
{
case PresetLibraryEditorState.ItemViewMode.List:
previewRect.width = m_State.m_PreviewHeight * m_PreviewAspect;
labelRect.x += previewRect.width + 8f;
labelRect.width -= previewRect.width + 10f;
labelRect.height = kGridLabelHeight;
labelRect.y = itemRect.yMin + (itemRect.height - kGridLabelHeight) * 0.5f;
break;
case PresetLibraryEditorState.ItemViewMode.Grid:
// only preview is shown: no label
break;
}
// Add new preset button
if (m_ShowAddNewPresetItem && i == lib.Count())
{
CreateNewPresetButton(previewRect, newPresetObject, lib, m_IsOpenForEdit);
continue;
}
// Rename overlay
bool isRenamingThisItem = IsRenaming(i);
if (isRenamingThisItem)
{
Rect renameRect = labelRect;
renameRect.y -= 1f; renameRect.x -= 1f; // adjustment to fit perfectly
m_State.m_RenameOverlay.editFieldRect = renameRect;
}
// Handle event
switch (evt.type)
{
case EventType.Repaint:
if (m_State.m_HoverIndex == i)
{
if (itemRect.Contains(evt.mousePosition))
{
// TODO: We need a better hover effect so disabling for now...
//if (!GetRenameOverlay().IsRenaming ())
// DrawHoverEffect (itemRect, false);
}
else
{
m_State.m_HoverIndex = -1;
}
}
if (m_DragState.draggingIndex == i || GUIUtility.hotControl == itemControlID)
{
DrawHoverEffect(itemRect, false);
}
lib.Draw(previewRect, i);
if (!isRenamingThisItem && drawLabels)
{
GUI.Label(labelRect, GUIContent.Temp(lib.GetName(i)));
}
if (m_DragState.dragUponIndex == i && m_DragState.draggingIndex != m_DragState.dragUponIndex)
{
drawDragInsertionMarker = true;
}
// We delete presets on alt-click
if (GUIUtility.hotControl == 0 && Event.current.alt && m_IsOpenForEdit)
{
EditorGUIUtility.AddCursorRect(itemRect, MouseCursor.ArrowMinus);
}
break;
case EventType.MouseDown:
if (evt.button == 0 && itemRect.Contains(evt.mousePosition))
{
GUIUtility.hotControl = itemControlID;
if (evt.clickCount == 1)
{
m_ItemClickedCallback(evt.clickCount, lib.GetPreset(i));
evt.Use();
}
}
break;
case EventType.MouseDrag:
if (GUIUtility.hotControl == itemControlID && m_IsOpenForEdit)
{
DragAndDropDelay delay = (DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), itemControlID);
if (delay.CanStartDrag())
{
// Start drag
DragAndDrop.PrepareStartDrag();
DragAndDrop.SetGenericData("DraggingPreset", i);
DragAndDrop.StartDrag("");
m_DragState.draggingIndex = i;
m_DragState.dragUponIndex = i;
GUIUtility.hotControl = 0;
}
evt.Use();
}
break;
case EventType.DragUpdated:
case EventType.DragPerform:
{
Rect dragRect = GetDragRect(itemRect);
if (dragRect.Contains(evt.mousePosition))
{
m_DragState.dragUponIndex = i;
m_DragState.dragUponRect = itemRect;
if (m_State.itemViewMode == PresetLibraryEditorState.ItemViewMode.List)
{
m_DragState.insertAfterIndex = ((evt.mousePosition.y - dragRect.y) / dragRect.height) > 0.5f;
}
else
{
m_DragState.insertAfterIndex = ((evt.mousePosition.x - dragRect.x) / dragRect.width) > 0.5f;
}
bool perform = evt.type == EventType.DragPerform;
if (perform)
{
if (m_DragState.draggingIndex >= 0)
{
MovePreset(m_DragState.draggingIndex, m_DragState.dragUponIndex, m_DragState.insertAfterIndex);
DragAndDrop.AcceptDrag();
}
ClearDragState();
}
DragAndDrop.visualMode = DragAndDropVisualMode.Move;
evt.Use();
}
}
break;
case EventType.DragExited:
if (m_DragState.IsDragging())
{
ClearDragState();
evt.Use();
}
break;
case EventType.MouseUp:
if (GUIUtility.hotControl == itemControlID)
{
GUIUtility.hotControl = 0;
if (evt.button == 0 && itemRect.Contains(evt.mousePosition))
{
if (Event.current.alt && m_IsOpenForEdit)
{
DeletePreset(i);
evt.Use();
}
}
}
break;
case EventType.ContextClick:
if (itemRect.Contains(evt.mousePosition))
{
PresetContextMenu.Show(m_IsOpenForEdit, i, newPresetObject, this);
evt.Use();
}
break;
case EventType.MouseMove:
if (itemRect.Contains(evt.mousePosition))
{
if (m_State.m_HoverIndex != i)
{
m_State.m_HoverIndex = i;
Repaint();
}
}
else if (m_State.m_HoverIndex == i)
{
m_State.m_HoverIndex = -1;
Repaint();
}
break;
}
} // end foreach item
// Draw above all items
if (drawDragInsertionMarker)
{
DrawDragInsertionMarker();
}
}
} GUI.EndScrollView();
}
private DragAndDropVisualMode DoDragScenes(GameObjectTreeViewItem parentItem, GameObjectTreeViewItem targetItem, bool perform, TreeViewDragging.DropPosition dropPos)
{
List <Scene> genericData = DragAndDrop.GetGenericData("SceneHeaderList") as List <Scene>;
bool flag = genericData != null;
bool flag2 = false;
if (!flag && (DragAndDrop.objectReferences.Length > 0))
{
int num = 0;
foreach (Object obj2 in DragAndDrop.objectReferences)
{
if (obj2 is SceneAsset)
{
num++;
}
}
flag2 = num == DragAndDrop.objectReferences.Length;
}
if (!flag && !flag2)
{
return(DragAndDropVisualMode.None);
}
if (perform)
{
List <Scene> list2 = null;
if (flag2)
{
List <Scene> source = new List <Scene>();
foreach (Object obj3 in DragAndDrop.objectReferences)
{
string assetPath = AssetDatabase.GetAssetPath(obj3);
Scene sceneByPath = SceneManager.GetSceneByPath(assetPath);
if (SceneHierarchyWindow.IsSceneHeaderInHierarchyWindow(sceneByPath))
{
base.m_TreeView.Frame(sceneByPath.handle, true, true);
}
else
{
if (Event.current.alt)
{
sceneByPath = EditorSceneManager.OpenScene(assetPath, OpenSceneMode.AdditiveWithoutLoading);
}
else
{
sceneByPath = EditorSceneManager.OpenScene(assetPath, OpenSceneMode.Additive);
}
if (SceneHierarchyWindow.IsSceneHeaderInHierarchyWindow(sceneByPath))
{
source.Add(sceneByPath);
}
}
}
if (targetItem != null)
{
list2 = source;
}
if ((SceneManager.sceneCount - source.Count) == 1)
{
Scene sceneAt = SceneManager.GetSceneAt(0);
((TreeViewDataSource)base.m_TreeView.data).SetExpanded(sceneAt.handle, true);
}
if (source.Count > 0)
{
if (< > f__am$cache1 == null)
{
static Object DoObjectField(Rect position, Rect dropRect, int id, Object obj, Object objBeingEdited, System.Type objType, System.Type additionalType, SerializedProperty property, ObjectFieldValidator validator, bool allowSceneObjects, GUIStyle style, GUIStyle buttonStyle)
{
if (validator == null)
{
validator = ValidateObjectFieldAssignment;
}
if (property != null)
{
obj = property.objectReferenceValue;
}
Event evt = Event.current;
EventType eventType = evt.type;
// special case test, so we continue to ping/select objects with the object field disabled
if (!GUI.enabled && GUIClip.enabled && (Event.current.rawType == EventType.MouseDown))
{
eventType = Event.current.rawType;
}
bool hasThumbnail = EditorGUIUtility.HasObjectThumbnail(objType);
// Determine visual type
ObjectFieldVisualType visualType = ObjectFieldVisualType.IconAndText;
if (hasThumbnail && position.height <= kObjectFieldMiniThumbnailHeight && position.width <= kObjectFieldMiniThumbnailWidth)
{
visualType = ObjectFieldVisualType.MiniPreview;
}
else if (hasThumbnail && position.height > kSingleLineHeight)
{
visualType = ObjectFieldVisualType.LargePreview;
}
Vector2 oldIconSize = EditorGUIUtility.GetIconSize();
if (visualType == ObjectFieldVisualType.IconAndText)
{
EditorGUIUtility.SetIconSize(new Vector2(12, 12)); // Have to be this small to fit inside a single line height ObjectField
}
else if (visualType == ObjectFieldVisualType.LargePreview)
{
EditorGUIUtility.SetIconSize(new Vector2(64, 64));
}
if ((eventType == EventType.MouseDown && Event.current.button == 1 ||
(eventType == EventType.ContextClick && visualType == ObjectFieldVisualType.IconAndText)) &&
position.Contains(Event.current.mousePosition))
{
var actualObject = property != null ? property.objectReferenceValue : obj;
var contextMenu = new GenericMenu();
if (FillPropertyContextMenu(property, null, contextMenu) != null)
{
contextMenu.AddSeparator("");
}
contextMenu.AddItem(GUIContent.Temp("Properties..."), false, () => PropertyEditor.OpenPropertyEditor(actualObject));
contextMenu.DropDown(position);
Event.current.Use();
}
switch (eventType)
{
case EventType.DragExited:
if (GUI.enabled)
{
HandleUtility.Repaint();
}
break;
case EventType.DragUpdated:
case EventType.DragPerform:
if (eventType == EventType.DragPerform)
{
string errorString;
if (!ValidDroppedObject(DragAndDrop.objectReferences, objType, out errorString))
{
Object reference = DragAndDrop.objectReferences[0];
EditorUtility.DisplayDialog("Can't assign script", errorString, "OK");
break;
}
}
if (dropRect.Contains(Event.current.mousePosition) && GUI.enabled)
{
Object[] references = DragAndDrop.objectReferences;
Object validatedObject = validator(references, objType, property, ObjectFieldValidatorOptions.None);
if (validatedObject != null)
{
// If scene objects are not allowed and object is a scene object then clear
if (!allowSceneObjects && !EditorUtility.IsPersistent(validatedObject))
{
validatedObject = null;
}
}
if (validatedObject != null)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Generic;
if (eventType == EventType.DragPerform)
{
if (property != null)
{
property.objectReferenceValue = validatedObject;
}
else
{
obj = validatedObject;
}
GUI.changed = true;
DragAndDrop.AcceptDrag();
DragAndDrop.activeControlID = 0;
}
else
{
DragAndDrop.activeControlID = id;
}
Event.current.Use();
}
}
break;
case EventType.MouseDown:
if (position.Contains(Event.current.mousePosition) && Event.current.button == 0)
{
// Get button rect for Object Selector
Rect buttonRect = GetButtonRect(visualType, position);
EditorGUIUtility.editingTextField = false;
if (buttonRect.Contains(Event.current.mousePosition))
{
if (GUI.enabled)
{
GUIUtility.keyboardControl = id;
var types = additionalType == null ? new Type[] { objType } : new Type[] { objType, additionalType };
if (property != null)
{
ObjectSelector.get.Show(types, property, allowSceneObjects);
}
else
{
ObjectSelector.get.Show(obj, types, objBeingEdited, allowSceneObjects);
}
ObjectSelector.get.objectSelectorID = id;
evt.Use();
GUIUtility.ExitGUI();
}
}
else
{
Object actualTargetObject = property != null ? property.objectReferenceValue : obj;
Component com = actualTargetObject as Component;
if (com)
{
actualTargetObject = com.gameObject;
}
if (showMixedValue)
{
actualTargetObject = null;
}
// One click shows where the referenced object is, or pops up a preview
if (Event.current.clickCount == 1)
{
GUIUtility.keyboardControl = id;
PingObjectOrShowPreviewOnClick(actualTargetObject, position);
var selectedMaterial = actualTargetObject as Material;
if (selectedMaterial != null)
{
PingObjectInSceneViewOnClick(selectedMaterial);
}
evt.Use();
}
// Double click opens the asset in external app or changes selection to referenced object
else if (Event.current.clickCount == 2)
{
if (actualTargetObject)
{
AssetDatabase.OpenAsset(actualTargetObject);
evt.Use();
GUIUtility.ExitGUI();
}
}
}
}
break;
case EventType.ExecuteCommand:
string commandName = evt.commandName;
if (commandName == ObjectSelector.ObjectSelectorUpdatedCommand && ObjectSelector.get.objectSelectorID == id && GUIUtility.keyboardControl == id && (property == null || !property.isScript))
{
return(AssignSelectedObject(property, validator, objType, evt));
}
else if (commandName == ObjectSelector.ObjectSelectorClosedCommand && ObjectSelector.get.objectSelectorID == id && GUIUtility.keyboardControl == id && property != null && property.isScript)
{
if (ObjectSelector.get.GetInstanceID() == 0)
{
// User canceled object selection; don't apply
evt.Use();
break;
}
return(AssignSelectedObject(property, validator, objType, evt));
}
else if ((evt.commandName == EventCommandNames.Delete || evt.commandName == EventCommandNames.SoftDelete) && GUIUtility.keyboardControl == id)
{
if (property != null)
{
property.objectReferenceValue = null;
}
else
{
obj = null;
}
GUI.changed = true;
evt.Use();
}
break;
case EventType.ValidateCommand:
if ((evt.commandName == EventCommandNames.Delete || evt.commandName == EventCommandNames.SoftDelete) && GUIUtility.keyboardControl == id)
{
evt.Use();
}
break;
case EventType.KeyDown:
if (GUIUtility.keyboardControl == id)
{
if (evt.keyCode == KeyCode.Backspace || (evt.keyCode == KeyCode.Delete && (evt.modifiers & EventModifiers.Shift) == 0))
{
if (property != null)
{
if (property.propertyPath.EndsWith("]"))
{
var parentArrayPropertyPath = property.propertyPath.Substring(0, property.propertyPath.LastIndexOf(".Array.data[", StringComparison.Ordinal));
var parentArrayProperty = property.serializedObject.FindProperty(parentArrayPropertyPath);
bool isReorderableList = PropertyHandler.s_reorderableLists.ContainsKey(ReorderableListWrapper.GetPropertyIdentifier(parentArrayProperty));
// If it's an element of an non-orderable array and it is displayed inside a list, remove that element from the array (cases 1379541 & 1335322)
if (!isReorderableList && GUI.isInsideList && GetInsideListDepth() == parentArrayProperty.depth)
{
TargetChoiceHandler.DeleteArrayElement(property);
}
else
{
property.objectReferenceValue = null;
}
}
else
{
property.objectReferenceValue = null;
}
}
else
{
obj = null;
}
GUI.changed = true;
evt.Use();
}
// Apparently we have to check for the character being space instead of the keyCode,
// otherwise the Inspector will maximize upon pressing space.
if (evt.MainActionKeyForControl(id))
{
var types = additionalType == null ? new Type[] { objType } : new Type[] { objType, additionalType };
if (property != null)
{
ObjectSelector.get.Show(types, property, allowSceneObjects);
}
else
{
ObjectSelector.get.Show(obj, types, objBeingEdited, allowSceneObjects);
}
ObjectSelector.get.objectSelectorID = id;
evt.Use();
GUIUtility.ExitGUI();
}
}
break;
case EventType.Repaint:
GUIContent temp;
if (showMixedValue)
{
temp = s_MixedValueContent;
}
else
{
// If obj or objType are both null, we have to rely on
// property.objectReferenceStringValue to display None/Missing and the
// correct type. But if not, EditorGUIUtility.ObjectContent is more reliable.
// It can take a more specific object type specified as argument into account,
// and it gets the icon at the same time.
if (obj == null && objType == null && property != null)
{
temp = EditorGUIUtility.TempContent(property.objectReferenceStringValue);
}
else
{
// In order for ObjectContext to be able to distinguish between None/Missing,
// we need to supply an instanceID. For some reason, getting the instanceID
// from property.objectReferenceValue is not reliable, so we have to
// explicitly check property.objectReferenceInstanceIDValue if a property exists.
if (property != null)
{
temp = EditorGUIUtility.ObjectContent(obj, objType, property.objectReferenceInstanceIDValue);
}
else
{
temp = EditorGUIUtility.ObjectContent(obj, objType);
}
}
if (property != null)
{
if (obj != null)
{
Object[] references = { obj };
if (EditorSceneManager.preventCrossSceneReferences && CheckForCrossSceneReferencing(obj, property.serializedObject.targetObject))
{
if (!EditorApplication.isPlaying)
{
temp = s_SceneMismatch;
}
else
{
temp.text = temp.text + string.Format(" ({0})", GetGameObjectFromObject(obj).scene.name);
}
}
else if (validator(references, objType, property, ObjectFieldValidatorOptions.ExactObjectTypeValidation) == null)
{
temp = s_TypeMismatch;
}
}
}
}
switch (visualType)
{
case ObjectFieldVisualType.IconAndText:
BeginHandleMixedValueContentColor();
style.Draw(position, temp, id, DragAndDrop.activeControlID == id, position.Contains(Event.current.mousePosition));
Rect buttonRect = buttonStyle.margin.Remove(GetButtonRect(visualType, position));
buttonStyle.Draw(buttonRect, GUIContent.none, id, DragAndDrop.activeControlID == id, buttonRect.Contains(Event.current.mousePosition));
EndHandleMixedValueContentColor();
break;
case ObjectFieldVisualType.LargePreview:
DrawObjectFieldLargeThumb(position, id, obj, temp);
break;
case ObjectFieldVisualType.MiniPreview:
DrawObjectFieldMiniThumb(position, id, obj, temp);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
}
EditorGUIUtility.SetIconSize(oldIconSize);
return(obj);
}
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);
}
DragAndDropVisualMode result;
if (!flag && !flag2)
{
result = DragAndDropVisualMode.None;
}
else
{
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);
}
}
}
}
result = DragAndDropVisualMode.Move;
}
return(result);
}
private static void OnProjectWindowItemOnGUI(string guid, Rect selectionRect)
{
// Break - key modifier doen't pressed
var activated = Event.current.alt;
if (activated == false)
{
return;
}
// Break - OnGUI() call not for mouse target
var within = selectionRect.Contains(Event.current.mousePosition);
if (within == false)
{
return;
}
// Break - destination match one of sources
var target = AssetDatabase.GUIDToAssetPath(guid);
var targetInSources = Array.IndexOf(DragAndDrop.paths, target) != -1;
if (targetInSources)
{
return;
}
// Break - unity default moving
var targetIsFolder = AssetDatabase.IsValidFolder(target);
if (targetIsFolder)
{
foreach (var asset in DragAndDrop.objectReferences)
{
if (AssetDatabase.IsMainAsset(asset))
{
return;
}
}
}
// Break - there is Unity restriction to use GameObjects as SubAssets
foreach (var obj in DragAndDrop.objectReferences)
{
if (obj is GameObject)
{
return;
}
}
if (Event.current.type == EventType.DragUpdated)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Move;
Event.current.Use();
}
else if (Event.current.type == EventType.DragPerform)
{
Move(DragAndDrop.objectReferences, target);
DragAndDrop.AcceptDrag();
Event.current.Use();
}
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, DropPosition dropPos)
{
if (targetItem == null)
{
return(DragAndDropVisualMode.None);
}
object savedFilterData = DragAndDrop.GetGenericData(ProjectWindowUtil.k_DraggingFavoriteGenericData);
// Dragging saved filter
if (savedFilterData != null)
{
int instanceID = (int)savedFilterData;
if (targetItem is SearchFilterTreeItem && parentItem is SearchFilterTreeItem)// && targetItem.id != draggedInstanceID && parentItem.id != draggedInstanceID)
{
bool validMove = SavedSearchFilters.CanMoveSavedFilter(instanceID, parentItem.id, targetItem.id, dropPos == DropPosition.Below);
if (validMove && perform)
{
SavedSearchFilters.MoveSavedFilter(instanceID, parentItem.id, targetItem.id, dropPos == DropPosition.Below);
m_TreeView.SetSelection(new[] { instanceID }, false);
m_TreeView.NotifyListenersThatSelectionChanged();
}
return(validMove ? DragAndDropVisualMode.Copy : DragAndDropVisualMode.None);
}
return(DragAndDropVisualMode.None);
}
// Dragging of folders into filters
else
{
// Check if we are dragging a single folder
if (targetItem is SearchFilterTreeItem && parentItem is SearchFilterTreeItem)
{
string genericData = DragAndDrop.GetGenericData(ProjectWindowUtil.k_IsFolderGenericData) as string;
if (genericData == "isFolder")
{
if (perform)
{
Object[] objs = DragAndDrop.objectReferences;
if (objs.Length > 0)
{
string path = AssetDatabase.GetAssetPath(objs[0].GetInstanceID());
if (!string.IsNullOrEmpty(path))
{
// TODO: Fix with new AssetDatabase API when it is ready (GetName)
string folderName = new DirectoryInfo(path).Name;
SearchFilter searchFilter = new SearchFilter();
searchFilter.folders = new[] { path };
bool addAsChild = targetItem == parentItem;
float previewSize = ProjectBrowserColumnOneTreeViewGUI.GetListAreaGridSize();
int instanceID = SavedSearchFilters.AddSavedFilterAfterInstanceID(folderName, searchFilter, previewSize, targetItem.id, addAsChild);
m_TreeView.SetSelection(new[] { instanceID }, false);
m_TreeView.NotifyListenersThatSelectionChanged();
}
else
{
Debug.Log("Could not get asset path from id " + objs[0].GetInstanceID());
}
}
}
return(DragAndDropVisualMode.Copy); // Allow dragging folders to filters
}
return(DragAndDropVisualMode.None); // Assets that are not folders are not allowed to be dragged to filters
}
}
// Assets are handled by base
return(base.DoDrag(parentItem, targetItem, perform, dropPos));
}
public DragAndDropVisualMode HandleTrackDrop(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, DropPosition dropPos)
{
((TimelineTreeView)m_Window.treeView.gui).showInsertionMarker = false;
var trackDragData = (TimelineDragData)DragAndDrop.GetGenericData(k_GenericDragId);
bool validDrag = ValidDrag(targetItem, trackDragData.draggedItems);
if (!validDrag)
{
return(DragAndDropVisualMode.None);
}
var draggedTracks = trackDragData.draggedItems.OfType <TimelineGroupGUI>().Select(x => x.track).ToList();
if (draggedTracks.Count == 0)
{
return(DragAndDropVisualMode.None);
}
if (parentItem != null)
{
var parentActor = parentItem as TimelineGroupGUI;
if (parentActor != null && parentActor.track != null)
{
if (parentActor.track.lockedInHierarchy)
{
return(DragAndDropVisualMode.Rejected);
}
if (draggedTracks.Any(x => !TimelineCreateUtilities.ValidateParentTrack(parentActor.track, x.GetType())))
{
return(DragAndDropVisualMode.Rejected);
}
}
}
var insertAfterItem = targetItem as TimelineGroupGUI;
if (insertAfterItem != null && insertAfterItem.track != null)
{
((TimelineTreeView)m_Window.treeView.gui).showInsertionMarker = true;
}
if (dropPos == DropPosition.Upon)
{
var groupGUI = targetItem as TimelineGroupGUI;
if (groupGUI != null)
{
groupGUI.isDropTarget = true;
}
}
if (perform)
{
PlayableAsset targetParent = m_Timeline;
var parentActor = parentItem as TimelineGroupGUI;
if (parentActor != null && parentActor.track != null)
{
targetParent = parentActor.track;
}
TrackAsset siblingTrack = insertAfterItem != null ? insertAfterItem.track : null;
// where the user drops after the last track, make sure to place it after all the tracks
if (targetParent == m_Timeline && dropPos == DropPosition.Below && siblingTrack == null)
{
siblingTrack = m_Timeline.GetRootTracks().LastOrDefault(x => !draggedTracks.Contains(x));
}
if (TrackExtensions.ReparentTracks(TrackExtensions.FilterTracks(draggedTracks).ToList(), targetParent, siblingTrack, dropPos == DropPosition.Above))
{
m_Window.state.Refresh();
}
}
return(DragAndDropVisualMode.Move);
}
internal static Object DoObjectField(Rect position, Rect dropRect, int id, Object obj, System.Type objType, SerializedProperty property, ObjectFieldValidator validator, bool allowSceneObjects, GUIStyle style)
{
if (validator == null)
{
validator = ValidateObjectFieldAssignment;
}
Event evt = Event.current;
EventType eventType = evt.type;
// special case test, so we continue to ping/select objects with the object field disabled
if (!GUI.enabled && GUIClip.enabled && (Event.current.rawType == EventType.MouseDown))
{
eventType = Event.current.rawType;
}
bool hasThumbnail = EditorGUIUtility.HasObjectThumbnail(objType);
// Determine visual type
ObjectFieldVisualType visualType = ObjectFieldVisualType.IconAndText;
if (hasThumbnail && position.height <= kObjectFieldMiniThumbnailHeight && position.width <= kObjectFieldMiniThumbnailWidth)
{
visualType = ObjectFieldVisualType.MiniPreview;
}
else if (hasThumbnail && position.height > kSingleLineHeight)
{
visualType = ObjectFieldVisualType.LargePreview;
}
Vector2 oldIconSize = EditorGUIUtility.GetIconSize();
if (visualType == ObjectFieldVisualType.IconAndText)
{
EditorGUIUtility.SetIconSize(new Vector2(12, 12)); // Have to be this small to fit inside a single line height ObjectField
}
else if (visualType == ObjectFieldVisualType.LargePreview)
{
EditorGUIUtility.SetIconSize(new Vector2(64, 64));
}
switch (eventType)
{
case EventType.DragExited:
if (GUI.enabled)
{
HandleUtility.Repaint();
}
break;
case EventType.DragUpdated:
case EventType.DragPerform:
if (dropRect.Contains(Event.current.mousePosition) && GUI.enabled)
{
Object[] references = DragAndDrop.objectReferences;
Object validatedObject = validator(references, objType, property, ObjectFieldValidatorOptions.None);
if (validatedObject != null)
{
// If scene objects are not allowed and object is a scene object then clear
if (!allowSceneObjects && !EditorUtility.IsPersistent(validatedObject))
{
validatedObject = null;
}
}
if (validatedObject != null)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Generic;
if (eventType == EventType.DragPerform)
{
if (property != null)
{
property.objectReferenceValue = validatedObject;
}
else
{
obj = validatedObject;
}
GUI.changed = true;
DragAndDrop.AcceptDrag();
DragAndDrop.activeControlID = 0;
}
else
{
DragAndDrop.activeControlID = id;
}
Event.current.Use();
}
}
break;
case EventType.MouseDown:
// Ignore right clicks
if (Event.current.button != 0)
{
break;
}
if (position.Contains(Event.current.mousePosition))
{
// Get button rect for Object Selector
Rect buttonRect;
switch (visualType)
{
case ObjectFieldVisualType.IconAndText:
case ObjectFieldVisualType.MiniPreview:
buttonRect = new Rect(position.xMax - 15, position.y, 15, position.height);
break;
case ObjectFieldVisualType.LargePreview:
buttonRect = new Rect(position.xMax - 36, position.yMax - 14, 36, 14);
break;
default:
throw new ArgumentOutOfRangeException();
}
EditorGUIUtility.editingTextField = false;
if (buttonRect.Contains(Event.current.mousePosition))
{
if (GUI.enabled)
{
GUIUtility.keyboardControl = id;
ObjectSelector.get.Show(obj, objType, property, allowSceneObjects);
ObjectSelector.get.objectSelectorID = id;
evt.Use();
GUIUtility.ExitGUI();
}
}
else
{
Object actualTargetObject = property != null ? property.objectReferenceValue : obj;
Component com = actualTargetObject as Component;
if (com)
{
actualTargetObject = com.gameObject;
}
if (showMixedValue)
{
actualTargetObject = null;
}
// One click shows where the referenced object is, or pops up a preview
if (Event.current.clickCount == 1)
{
GUIUtility.keyboardControl = id;
PingObjectOrShowPreviewOnClick(actualTargetObject, position);
evt.Use();
}
// Double click opens the asset in external app or changes selection to referenced object
else if (Event.current.clickCount == 2)
{
if (actualTargetObject)
{
AssetDatabase.OpenAsset(actualTargetObject);
GUIUtility.ExitGUI();
}
evt.Use();
}
}
}
break;
case EventType.ExecuteCommand:
string commandName = evt.commandName;
if (commandName == ObjectSelector.ObjectSelectorUpdatedCommand && ObjectSelector.get.objectSelectorID == id && GUIUtility.keyboardControl == id && (property == null || !property.isScript))
{
return(AssignSelectedObject(property, validator, objType, evt));
}
else if (commandName == ObjectSelector.ObjectSelectorClosedCommand && ObjectSelector.get.objectSelectorID == id && GUIUtility.keyboardControl == id && property != null && property.isScript)
{
if (ObjectSelector.get.GetInstanceID() == 0)
{
// User canceled object selection; don't apply
evt.Use();
break;
}
return(AssignSelectedObject(property, validator, objType, evt));
}
break;
case EventType.KeyDown:
if (GUIUtility.keyboardControl == id)
{
if (evt.keyCode == KeyCode.Backspace || evt.keyCode == KeyCode.Delete)
{
if (property != null)
{
property.objectReferenceValue = null;
}
else
{
obj = null;
}
GUI.changed = true;
evt.Use();
}
// Apparently we have to check for the character being space instead of the keyCode,
// otherwise the Inspector will maximize upon pressing space.
if (evt.MainActionKeyForControl(id))
{
ObjectSelector.get.Show(obj, objType, property, allowSceneObjects);
ObjectSelector.get.objectSelectorID = id;
evt.Use();
GUIUtility.ExitGUI();
}
}
break;
case EventType.Repaint:
GUIContent temp;
if (showMixedValue)
{
temp = s_MixedValueContent;
}
else if (property != null)
{
temp = EditorGUIUtility.TempContent(property.objectReferenceStringValue, AssetPreview.GetMiniThumbnail(property.objectReferenceValue));
obj = property.objectReferenceValue;
if (obj != null)
{
Object[] references = { obj };
if (EditorSceneManager.preventCrossSceneReferences && CheckForCrossSceneReferencing(obj, property.serializedObject.targetObject))
{
if (!EditorApplication.isPlaying)
{
temp = s_SceneMismatch;
}
else
{
temp.text = temp.text + string.Format(" ({0})", GetGameObjectFromObject(obj).scene.name);
}
}
else if (validator(references, objType, property, ObjectFieldValidatorOptions.ExactObjectTypeValidation) == null)
{
temp = s_TypeMismatch;
}
}
}
else
{
temp = EditorGUIUtility.ObjectContent(obj, objType);
}
switch (visualType)
{
case ObjectFieldVisualType.IconAndText:
BeginHandleMixedValueContentColor();
style.Draw(position, temp, id, DragAndDrop.activeControlID == id, position.Contains(Event.current.mousePosition));
EndHandleMixedValueContentColor();
break;
case ObjectFieldVisualType.LargePreview:
DrawObjectFieldLargeThumb(position, id, obj, temp);
break;
case ObjectFieldVisualType.MiniPreview:
DrawObjectFieldMiniThumb(position, id, obj, temp);
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
}
EditorGUIUtility.SetIconSize(oldIconSize);
return(obj);
}
private void HandleMouseInput()
{
List <CubemapInfo> hdriList = this.m_LookDevView.envLibrary.hdriList;
Vector2 pos = new Vector2(Event.current.mousePosition.x, Event.current.mousePosition.y + this.m_ScrollPosition.y);
Event current = Event.current;
EventType typeForControl = current.GetTypeForControl(this.m_LookDevView.hotControl);
switch (typeForControl)
{
case EventType.MouseUp:
if (this.m_SelectedCubemap != null)
{
Rect gUIRect = this.m_GUIRect;
gUIRect.yMax += 16f;
if (!gUIRect.Contains(Event.current.mousePosition))
{
break;
}
int insertionIndex = this.IsPositionInInsertionArea(pos);
if (insertionIndex == -1)
{
int num2 = this.IsPositionInThumbnailArea(pos);
if ((num2 != -1) && this.m_LookDevView.config.enableShadowCubemap)
{
Undo.RecordObject(this.m_LookDevView.envLibrary, "Update shadow cubemap");
CubemapInfo info2 = this.m_LookDevView.envLibrary.hdriList[num2];
if (info2 != this.m_SelectedCubemapInfo)
{
info2.SetCubemapShadowInfo(this.m_SelectedCubemapInfo);
}
this.m_LookDevView.envLibrary.dirty = true;
}
}
else
{
this.ResetShadowCubemap();
this.m_LookDevView.envLibrary.InsertHDRI(this.m_SelectedCubemap, insertionIndex);
}
this.CancelSelection();
}
break;
case EventType.MouseDrag:
if (this.m_SelectedCubeMapOffsetIndex != -1)
{
Undo.RecordObject(this.m_LookDevView.envLibrary, "");
CubemapInfo info = hdriList[this.m_SelectedCubeMapOffsetIndex];
info.angleOffset = this.ComputeAngleOffsetFromMouseCoord(pos) + this.m_SelectedCubeMapOffsetValue;
this.m_LookDevView.envLibrary.dirty = true;
Event.current.Use();
}
if (this.m_SelectedCubemapInfo != null)
{
if (this.IsPositionInInsertionArea(pos) == -1)
{
this.m_HoveringCubeMapIndex = this.IsPositionInThumbnailArea(pos);
}
else
{
this.m_HoveringCubeMapIndex = -1;
}
}
this.m_LookDevView.Repaint();
return;
case EventType.KeyDown:
if (Event.current.keyCode == KeyCode.Escape)
{
this.CancelSelection();
this.m_LookDevView.Repaint();
}
return;
case EventType.Repaint:
if (this.m_SelectedCubeMapOffsetIndex != -1)
{
EditorGUIUtility.AddCursorRect(this.m_displayRect, MouseCursor.SlideArrow);
}
return;
case EventType.DragUpdated:
{
bool flag = false;
foreach (UnityEngine.Object obj3 in DragAndDrop.objectReferences)
{
Cubemap cubemap2 = obj3 as Cubemap;
if (cubemap2 != null)
{
flag = true;
}
}
DragAndDrop.visualMode = !flag ? DragAndDropVisualMode.Rejected : DragAndDropVisualMode.Link;
if (flag)
{
this.m_DragBeingPerformed = true;
}
current.Use();
return;
}
case EventType.DragPerform:
{
int num3 = this.IsPositionInInsertionArea(pos);
foreach (UnityEngine.Object obj2 in DragAndDrop.objectReferences)
{
Cubemap cubemap = obj2 as Cubemap;
if (cubemap != null)
{
this.m_LookDevView.envLibrary.InsertHDRI(cubemap, num3);
}
}
DragAndDrop.AcceptDrag();
this.m_DragBeingPerformed = false;
current.Use();
return;
}
default:
if (typeForControl == EventType.DragExited)
{
}
return;
}
this.m_LookDevView.Repaint();
if ((this.m_SelectedCubeMapOffsetIndex != -1) && (Mathf.Abs(hdriList[this.m_SelectedCubeMapOffsetIndex].angleOffset) <= 10f))
{
Undo.RecordObject(this.m_LookDevView.envLibrary, "");
hdriList[this.m_SelectedCubeMapOffsetIndex].angleOffset = 0f;
this.m_LookDevView.envLibrary.dirty = true;
}
this.m_SelectedCubemapInfo = null;
this.m_SelectedShadowCubemapOwnerInfo = null;
this.m_SelectedLightIconIndex = -1;
this.m_SelectedShadowInfo = null;
this.m_SelectedCubeMapOffsetIndex = -1;
this.m_HoveringCubeMapIndex = -1;
this.m_SelectedCubeMapOffsetValue = 0f;
GUIUtility.hotControl = 0;
}
public bool MoveNext()
{
if (this.xPos > -1)
{
if (ListViewShared.HasMouseDown(this.ilvState, this.rect))
{
this.ilvState.state.selectionChanged = true;
this.ilvState.state.row = this.yPos;
this.ilvState.state.column = this.xPos;
this.ilvState.state.scrollPos = ListViewShared.ListViewScrollToRow(this.ilvState, this.yPos);
if ((this.ilvState.wantsReordering || this.ilvState.wantsToStartCustomDrag) && GUIUtility.hotControl == this.ilvState.state.ID)
{
DragAndDropDelay dragAndDropDelay = (DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), this.ilvState.state.ID);
dragAndDropDelay.mouseDownPosition = Event.current.mousePosition;
this.ilvState.dragItem = this.yPos;
ListViewShared.dragControlID = this.ilvState.state.ID;
}
}
if (!ListViewShared.isDragging && (this.ilvState.wantsReordering || this.ilvState.wantsToStartCustomDrag) && GUIUtility.hotControl == this.ilvState.state.ID && Event.current.type == EventType.MouseDrag && GUIClip.visibleRect.Contains(Event.current.mousePosition))
{
DragAndDropDelay dragAndDropDelay2 = (DragAndDropDelay)GUIUtility.GetStateObject(typeof(DragAndDropDelay), this.ilvState.state.ID);
if (dragAndDropDelay2.CanStartDrag())
{
DragAndDrop.PrepareStartDrag();
DragAndDrop.objectReferences = new UnityEngine.Object[0];
DragAndDrop.paths = null;
if (this.ilvState.wantsReordering)
{
this.ilvState.state.dropHereRect = new Rect(this.ilvState.rect.x, 0f, this.ilvState.rect.width, (float)(this.ilvState.state.rowHeight * 2));
DragAndDrop.StartDrag(this.dragTitle);
}
else if (this.ilvState.wantsToStartCustomDrag)
{
DragAndDrop.SetGenericData("CustomDragID", this.ilvState.state.ID);
DragAndDrop.StartDrag(this.dragTitle);
}
ListViewShared.isDragging = true;
}
Event.current.Use();
}
}
this.xPos++;
if (this.xPos > this.xTo)
{
this.xPos = 0;
this.yPos++;
this.rect.x = this.firstRect.x;
this.rect.width = (float)this.colWidths[0];
if (this.yPos > this.yTo)
{
this.quiting = true;
}
else
{
this.rect.y = this.rect.y + this.rect.height;
}
}
else
{
if (this.xPos >= 1)
{
this.rect.x = this.rect.x + (float)this.colWidths[this.xPos - 1];
}
this.rect.width = (float)this.colWidths[this.xPos];
}
this.element.row = this.yPos;
this.element.column = this.xPos;
this.element.position = this.rect;
if (this.element.row >= this.ilvState.state.totalRows)
{
this.quiting = true;
}
if (this.isLayouted && Event.current.type == EventType.Layout)
{
if (this.yFrom + 1 == this.yPos)
{
this.quiting = true;
}
}
if (this.isLayouted && this.yPos != this.yFrom)
{
GUILayout.EndHorizontal();
}
if (this.quiting)
{
if (this.ilvState.state.drawDropHere && Event.current.GetTypeForControl(this.ilvState.state.ID) == EventType.Repaint)
{
GUIStyle gUIStyle = ListViewShared.Constants.insertion;
gUIStyle.Draw(gUIStyle.margin.Remove(this.ilvState.state.dropHereRect), false, false, false, false);
}
if (ListViewShared.ListViewKeyboard(this.ilvState, this.colWidths.Length))
{
this.ilvState.state.selectionChanged = true;
}
if (Event.current.GetTypeForControl(this.ilvState.state.ID) == EventType.MouseUp)
{
GUIUtility.hotControl = 0;
}
if (this.ilvState.wantsReordering && GUIUtility.hotControl == this.ilvState.state.ID)
{
ListViewState state = this.ilvState.state;
EventType type = Event.current.type;
if (type != EventType.DragUpdated)
{
if (type != EventType.DragPerform)
{
if (type == EventType.DragExited)
{
this.ilvState.wantsReordering = false;
this.ilvState.state.drawDropHere = false;
GUIUtility.hotControl = 0;
}
}
else
{
if (GUIClip.visibleRect.Contains(Event.current.mousePosition))
{
this.ilvState.state.draggedFrom = this.ilvState.dragItem;
this.ilvState.state.draggedTo = Mathf.RoundToInt(Event.current.mousePosition.y / (float)state.rowHeight);
if (this.ilvState.state.draggedTo > this.ilvState.state.totalRows)
{
this.ilvState.state.draggedTo = this.ilvState.state.totalRows;
}
if (this.ilvState.state.draggedTo > this.ilvState.state.draggedFrom)
{
this.ilvState.state.row = this.ilvState.state.draggedTo - 1;
}
else
{
this.ilvState.state.row = this.ilvState.state.draggedTo;
}
this.ilvState.state.selectionChanged = true;
DragAndDrop.AcceptDrag();
Event.current.Use();
this.ilvState.wantsReordering = false;
this.ilvState.state.drawDropHere = false;
}
GUIUtility.hotControl = 0;
}
}
else
{
DragAndDrop.visualMode = ((!this.ilvState.rect.Contains(Event.current.mousePosition)) ? DragAndDropVisualMode.None : DragAndDropVisualMode.Move);
Event.current.Use();
if (DragAndDrop.visualMode != DragAndDropVisualMode.None)
{
state.dropHereRect.y = (float)((Mathf.RoundToInt(Event.current.mousePosition.y / (float)state.rowHeight) - 1) * state.rowHeight);
if (state.dropHereRect.y >= (float)(state.rowHeight * state.totalRows))
{
state.dropHereRect.y = (float)(state.rowHeight * (state.totalRows - 1));
}
state.drawDropHere = true;
}
}
}
else if (this.ilvState.wantsExternalFiles)
{
EventType type2 = Event.current.type;
if (type2 != EventType.DragUpdated)
{
if (type2 != EventType.DragPerform)
{
if (type2 == EventType.DragExited)
{
this.ilvState.wantsExternalFiles = false;
this.ilvState.state.drawDropHere = false;
GUIUtility.hotControl = 0;
}
}
else
{
if (GUIClip.visibleRect.Contains(Event.current.mousePosition))
{
this.ilvState.state.fileNames = DragAndDrop.paths;
DragAndDrop.AcceptDrag();
Event.current.Use();
this.ilvState.wantsExternalFiles = false;
this.ilvState.state.drawDropHere = false;
this.ilvState.state.draggedTo = Mathf.RoundToInt(Event.current.mousePosition.y / (float)this.ilvState.state.rowHeight);
if (this.ilvState.state.draggedTo > this.ilvState.state.totalRows)
{
this.ilvState.state.draggedTo = this.ilvState.state.totalRows;
}
this.ilvState.state.row = this.ilvState.state.draggedTo;
}
GUIUtility.hotControl = 0;
}
}
else if (GUIClip.visibleRect.Contains(Event.current.mousePosition) && DragAndDrop.paths != null && DragAndDrop.paths.Length != 0)
{
DragAndDrop.visualMode = ((!this.ilvState.rect.Contains(Event.current.mousePosition)) ? DragAndDropVisualMode.None : DragAndDropVisualMode.Copy);
Event.current.Use();
if (DragAndDrop.visualMode != DragAndDropVisualMode.None)
{
this.ilvState.state.dropHereRect = new Rect(this.ilvState.rect.x, (float)((Mathf.RoundToInt(Event.current.mousePosition.y / (float)this.ilvState.state.rowHeight) - 1) * this.ilvState.state.rowHeight), this.ilvState.rect.width, (float)this.ilvState.state.rowHeight);
if (this.ilvState.state.dropHereRect.y >= (float)(this.ilvState.state.rowHeight * this.ilvState.state.totalRows))
{
this.ilvState.state.dropHereRect.y = (float)(this.ilvState.state.rowHeight * (this.ilvState.state.totalRows - 1));
}
this.ilvState.state.drawDropHere = true;
}
}
}
else if (this.ilvState.wantsToAcceptCustomDrag && ListViewShared.dragControlID != this.ilvState.state.ID)
{
EventType type3 = Event.current.type;
if (type3 != EventType.DragUpdated)
{
if (type3 != EventType.DragPerform)
{
if (type3 == EventType.DragExited)
{
GUIUtility.hotControl = 0;
}
}
else
{
object genericData = DragAndDrop.GetGenericData("CustomDragID");
if (GUIClip.visibleRect.Contains(Event.current.mousePosition) && genericData != null)
{
this.ilvState.state.customDraggedFromID = (int)genericData;
DragAndDrop.AcceptDrag();
Event.current.Use();
}
GUIUtility.hotControl = 0;
}
}
else
{
object genericData2 = DragAndDrop.GetGenericData("CustomDragID");
if (GUIClip.visibleRect.Contains(Event.current.mousePosition) && genericData2 != null)
{
DragAndDrop.visualMode = ((!this.ilvState.rect.Contains(Event.current.mousePosition)) ? DragAndDropVisualMode.None : DragAndDropVisualMode.Move);
Event.current.Use();
}
}
}
if (this.ilvState.beganHorizontal)
{
EditorGUILayout.EndScrollView();
GUILayout.EndHorizontal();
this.ilvState.beganHorizontal = false;
}
if (this.isLayouted)
{
GUILayoutUtility.EndLayoutGroup();
EditorGUILayout.EndScrollView();
}
this.ilvState.wantsReordering = false;
this.ilvState.wantsExternalFiles = false;
}
else if (this.isLayouted)
{
if (this.yPos != this.yFrom)
{
this.ilvStateL.group.ResetCursor();
this.ilvStateL.group.AddY();
}
else
{
this.ilvStateL.group.AddY((float)(this.ilvState.invisibleRows * this.ilvState.state.rowHeight));
}
}
if (this.isLayouted)
{
if (!this.quiting)
{
GUILayout.BeginHorizontal(GUIStyle.none, new GUILayoutOption[0]);
}
else
{
GUILayout.EndHorizontal();
}
}
return(!this.quiting);
}
public void OnSceneDrag(SceneView sceneView)
{
GameObject target = this.target as GameObject;
switch (PrefabUtility.GetPrefabType(target))
{
case PrefabType.Prefab:
case PrefabType.ModelPrefab:
{
Event current = Event.current;
EventType type = current.type;
if (type != EventType.DragUpdated)
{
if (type == EventType.DragPerform)
{
string uniqueNameForSibling = GameObjectUtility.GetUniqueNameForSibling(null, dragObject.name);
dragObject.hideFlags = HideFlags.None;
Undo.RegisterCreatedObjectUndo(dragObject, "Place " + dragObject.name);
EditorUtility.SetDirty(dragObject);
DragAndDrop.AcceptDrag();
Selection.activeObject = dragObject;
HandleUtility.ignoreRaySnapObjects = null;
EditorWindow.mouseOverWindow.Focus();
dragObject.name = uniqueNameForSibling;
dragObject = null;
current.Use();
return;
}
if ((type == EventType.DragExited) && (dragObject != null))
{
Object.DestroyImmediate(dragObject, false);
HandleUtility.ignoreRaySnapObjects = null;
dragObject = null;
current.Use();
}
}
else
{
if (dragObject == null)
{
dragObject = (GameObject)PrefabUtility.InstantiatePrefab(PrefabUtility.FindPrefabRoot(target));
HandleUtility.ignoreRaySnapObjects = dragObject.GetComponentsInChildren <Transform>();
dragObject.hideFlags = HideFlags.HideInHierarchy;
dragObject.name = target.name;
}
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
object obj3 = HandleUtility.RaySnap(HandleUtility.GUIPointToWorldRay(current.mousePosition));
if (obj3 != null)
{
RaycastHit hit = (RaycastHit)obj3;
float num = 0f;
if (Tools.pivotMode == PivotMode.Center)
{
float num2 = HandleUtility.CalcRayPlaceOffset(HandleUtility.ignoreRaySnapObjects, hit.normal);
if (num2 != float.PositiveInfinity)
{
num = Vector3.Dot(dragObject.transform.position, hit.normal) - num2;
}
}
dragObject.transform.position = Matrix4x4.identity.MultiplyPoint(hit.point + ((Vector3)(hit.normal * num)));
}
else
{
dragObject.transform.position = HandleUtility.GUIPointToWorldRay(current.mousePosition).GetPoint(10f);
}
if (sceneView.in2DMode)
{
Vector3 position = dragObject.transform.position;
position.z = PrefabUtility.FindPrefabRoot(target).transform.position.z;
dragObject.transform.position = position;
}
current.Use();
}
break;
}
}
}
private void HandleMouseInput()
{
List <CubemapInfo> cubemapList = m_LookDevView.envLibrary.hdriList;
Vector2 scrollFixedPosition = new Vector2(Event.current.mousePosition.x, Event.current.mousePosition.y + m_ScrollPosition.y);
Event evt = Event.current;
switch (evt.GetTypeForControl(m_LookDevView.hotControl))
{
// Update overlay position for next repaint event
case EventType.MouseDrag:
{
if (m_SelectedCubeMapOffsetIndex != -1)
{
Undo.RecordObject(m_LookDevView.envLibrary, "");
CubemapInfo info = cubemapList[m_SelectedCubeMapOffsetIndex];
info.angleOffset = ComputeAngleOffsetFromMouseCoord(scrollFixedPosition) + m_SelectedCubeMapOffsetValue;
m_LookDevView.envLibrary.dirty = true;
Event.current.Use();
}
if (m_SelectedCubemapInfo != null)
{
if (IsPositionInInsertionArea(scrollFixedPosition) == -1)
{
m_HoveringCubeMapIndex = IsPositionInThumbnailArea(scrollFixedPosition);
}
else
{
m_HoveringCubeMapIndex = -1;
}
}
m_LookDevView.Repaint();
break;
}
// Handles environment drop
case EventType.MouseUp:
{
if (m_SelectedCubemap != null)
{
// The rect needs to include an extra slot when moving to last position
Rect extendedGUIRect = m_GUIRect;
extendedGUIRect.yMax += EditorGUI.kSingleLineHeight;
if (extendedGUIRect.Contains(Event.current.mousePosition))
{
int insertionRectIndex = IsPositionInInsertionArea(scrollFixedPosition);
if (insertionRectIndex != -1)
{
// Must be called before we do any modification to HDRI list
ResetShadowCubemap();
m_LookDevView.envLibrary.InsertHDRI(m_SelectedCubemap, insertionRectIndex);
}
else
{
int thumbnailRectIndex = IsPositionInThumbnailArea(scrollFixedPosition);
if (thumbnailRectIndex != -1 && m_LookDevView.config.enableShadowCubemap)
{
Undo.RecordObject(m_LookDevView.envLibrary, "Update shadow cubemap");
CubemapInfo cubemapInfo = m_LookDevView.envLibrary.hdriList[thumbnailRectIndex];
// We don't want the user to drop a cubemap on itself and reset the shadows (it would happen all the time by mistake)
if (cubemapInfo != m_SelectedCubemapInfo)
{
cubemapInfo.SetCubemapShadowInfo(m_SelectedCubemapInfo);
}
m_LookDevView.envLibrary.dirty = true;
}
}
CancelSelection();
}
}
m_LookDevView.Repaint();
if (m_SelectedCubeMapOffsetIndex != -1)
{
// Fall back to zero when near the center
if (Mathf.Abs(cubemapList[m_SelectedCubeMapOffsetIndex].angleOffset) <= 10.0f)
{
Undo.RecordObject(m_LookDevView.envLibrary, "");
cubemapList[m_SelectedCubeMapOffsetIndex].angleOffset = 0.0f;
m_LookDevView.envLibrary.dirty = true;
}
}
m_SelectedCubemapInfo = null;
m_SelectedShadowCubemapOwnerInfo = null;
m_SelectedLightIconIndex = -1;
m_SelectedShadowInfo = null;
m_SelectedCubeMapOffsetIndex = -1;
m_HoveringCubeMapIndex = -1;
m_SelectedCubeMapOffsetValue = 0.0f;
GUIUtility.hotControl = 0;
break;
}
// Escape closes the window
case EventType.KeyDown:
{
if (Event.current.keyCode == KeyCode.Escape)
{
CancelSelection();
m_LookDevView.Repaint();
}
break;
}
case EventType.DragPerform:
{
int insertionIndex = IsPositionInInsertionArea(scrollFixedPosition);
foreach (UnityEngine.Object o in DragAndDrop.objectReferences)
{
Cubemap cubemap = o as Cubemap;
if (cubemap)
{
// When insertion outside the list the index is -1 which mean in InsertHDRI that it will be add at the end
m_LookDevView.envLibrary.InsertHDRI(cubemap, insertionIndex);
}
}
DragAndDrop.AcceptDrag();
m_DragBeingPerformed = false;
evt.Use();
break;
}
case EventType.DragUpdated:
{
bool hasCubemap = false;
foreach (UnityEngine.Object o in DragAndDrop.objectReferences)
{
Cubemap cubemap = o as Cubemap;
if (cubemap)
{
hasCubemap = true;
}
}
DragAndDrop.visualMode = hasCubemap ? DragAndDropVisualMode.Link : DragAndDropVisualMode.Rejected;
if (hasCubemap)
{
m_DragBeingPerformed = true;
}
evt.Use();
}
break;
case EventType.DragExited:
break;
case EventType.Repaint:
if (m_SelectedCubeMapOffsetIndex != -1)
{
EditorGUIUtility.AddCursorRect(m_displayRect, MouseCursor.SlideArrow);
}
break;
}
}
protected override DragAndDropVisualMode HandleDragAndDrop(DragAndDropArgs args)
{
// Check if we can handle the current drag data (could be dragged in from other areas/windows in the editor)
var draggedRows = DragAndDrop.GetGenericData(k_DragId) as List <int>;
if (draggedRows == null || args.dragAndDropPosition != DragAndDropPosition.BetweenItems)
{
return(DragAndDropVisualMode.None);
}
if (args.performDrop)
{
if (m_Positions.hasMultipleDifferentValues)
{
if (!EditorUtility.DisplayDialog(L10n.Tr("Moving an array element will copy the complete array to all other selected objects."),
L10n.Tr("Unique values in the different selected objects will be lost"),
L10n.Tr("OK"),
L10n.Tr("Cancel")))
{
return(DragAndDropVisualMode.Rejected);
}
}
int arraySize = GetArraySize();
var newList = new List <Vector3>(arraySize);
draggedRows.Sort();
int nextDragItem = 0;
for (int i = 0; i < arraySize; ++i)
{
if (i == args.insertAtIndex)
{
// Insert the items here
foreach (var viewItem in draggedRows)
{
newList.Add(m_Positions.GetArrayElementAtIndex(viewItem).vector3Value);
}
}
if (i == draggedRows[nextDragItem])
{
// Ignore this item, it is being moved
nextDragItem++;
if (nextDragItem >= draggedRows.Count)
{
nextDragItem = 0;
}
}
else
{
newList.Add(m_Positions.GetArrayElementAtIndex(i).vector3Value);
}
}
// Add to the end?
if (args.insertAtIndex == arraySize)
{
foreach (var viewItem in draggedRows)
{
newList.Add(m_Positions.GetArrayElementAtIndex(viewItem).vector3Value);
}
}
// Copy the list back
for (int i = 0; i < arraySize; ++i)
{
m_Positions.GetArrayElementAtIndex(i).vector3Value = newList[i];
}
SetSelection(Enumerable.Range(args.insertAtIndex - draggedRows.Count(o => o < args.insertAtIndex), draggedRows.Count).ToList());
}
return(DragAndDropVisualMode.Move);
}
void HandleEditorDragging(Editor[] editors, int editorIndex, Rect targetRect, float markerY, bool bottomTarget)
{
var evt = Event.current;
switch (evt.type)
{
case EventType.DragUpdated:
if (targetRect.Contains(evt.mousePosition))
{
var draggingMode = DragAndDrop.GetGenericData(k_DraggingModeKey) as DraggingMode ? ;
if (!draggingMode.HasValue)
{
var draggedObjects = DragAndDrop.objectReferences;
if (draggedObjects.Length == 0)
{
draggingMode = DraggingMode.NotApplicable;
}
else if (draggedObjects.All(o => o is Component && !(o is Transform)))
{
draggingMode = DraggingMode.Component;
}
else if (draggedObjects.All(o => o is MonoScript))
{
draggingMode = DraggingMode.Script;
}
else
{
draggingMode = DraggingMode.NotApplicable;
}
DragAndDrop.SetGenericData(k_DraggingModeKey, draggingMode);
}
if (draggingMode.Value != DraggingMode.NotApplicable)
{
if (bottomTarget)
{
m_TargetAbove = false;
m_TargetIndex = m_LastIndex;
}
else
{
m_TargetAbove = evt.mousePosition.y < targetRect.y + targetRect.height / 2f;
m_TargetIndex = editorIndex;
if (m_TargetAbove)
{
m_TargetIndex++;
while (m_TargetIndex < editors.Length && m_InspectorWindow.ShouldCullEditor(editors, m_TargetIndex))
{
m_TargetIndex++;
}
if (m_TargetIndex == editors.Length)
{
m_TargetIndex = -1;
return;
}
}
}
if (m_TargetAbove && InspectorWindow.EditorHasLargeHeader(m_TargetIndex, editors))
{
m_TargetIndex--;
while (m_TargetIndex >= 0 && m_InspectorWindow.ShouldCullEditor(editors, m_TargetIndex))
{
m_TargetIndex--;
}
if (m_TargetIndex == -1)
{
return;
}
m_TargetAbove = false;
}
if (draggingMode.Value == DraggingMode.Script)
{
// Validate dragging scripts
// Always allow script dragging, instead fail during DragPerform with a dialog box
DragAndDrop.visualMode = DragAndDropVisualMode.Link;
}
else
{
// Validate dragging components
var valid = false;
if (editors[m_TargetIndex].targets.All(t => t is Component))
{
var targetComponents = editors[m_TargetIndex].targets.Cast <Component>().ToArray();
var sourceComponents = DragAndDrop.objectReferences.Cast <Component>().ToArray();
valid = MoveOrCopyComponents(sourceComponents, targetComponents, EditorUtility.EventHasDragCopyModifierPressed(evt), true);
}
if (valid)
{
DragAndDrop.visualMode = EditorUtility.EventHasDragCopyModifierPressed(evt) ? DragAndDropVisualMode.Copy : DragAndDropVisualMode.Move;
}
else
{
DragAndDrop.visualMode = DragAndDropVisualMode.None;
m_TargetIndex = -1;
return;
}
}
evt.Use();
}
}
else
{
m_TargetIndex = -1;
}
break;
case EventType.DragPerform:
if (m_TargetIndex != -1)
{
HandleDragPerformEvent(editors, evt, ref m_TargetIndex);
}
break;
case EventType.DragExited:
m_TargetIndex = -1;
break;
case EventType.Repaint:
if (m_TargetIndex != -1 && editorIndex == m_TargetIndex &&
(targetRect.Contains(evt.mousePosition) ||
m_BottomArea.Contains(GUIClip.UnclipToWindow(evt.mousePosition)) &&
m_BottomAreaDropIndex == editors.Length - 1))
{
Styles.insertionMarker.Draw(GetMarkerRect(targetRect, markerY, m_TargetAbove), false, false, false, false);
}
break;
}
}
public override DragAndDropVisualMode DoDrag(TreeViewItem parentItem, TreeViewItem targetItem, bool perform, DropPosition dropPos)
{
m_Window.isDragging = false;
var retMode = DragAndDropVisualMode.None;
var trackDragData = DragAndDrop.GetGenericData(k_GenericDragId) as TimelineDragData;
if (trackDragData != null)
{
retMode = HandleTrackDrop(parentItem, targetItem, perform, dropPos);
if (retMode == DragAndDropVisualMode.Copy && targetItem != null && Event.current.type == EventType.DragUpdated)
{
var targetActor = targetItem as TimelineGroupGUI;
if (targetActor != null)
{
targetActor.isDropTarget = true;
}
}
}
else if (DragAndDrop.objectReferences.Any())
{
var objectsBeingDropped = DragAndDrop.objectReferences.OfType <UnityObject>();
var director = m_Window.state.editSequence.director;
if (ShouldUseHierarchyDragAndDrop())
{
// for object drawing
var originalTarget = targetItem;
TreeViewItem insertBeforeItem = null;
HandleNestedItemGUI(ref parentItem, ref targetItem, ref insertBeforeItem);
var track = GetTrack(targetItem);
var parent = GetTrack(parentItem);
var insertBefore = GetTrack(insertBeforeItem);
retMode = HandleHierarchyPaneDragAndDrop(objectsBeingDropped, track, perform, m_Timeline, director, ResolveType, insertBefore);
// fallback to old clip behaviour
if (retMode == DragAndDropVisualMode.None)
{
retMode = HandleClipPaneObjectDragAndDrop(objectsBeingDropped, track, perform, m_Timeline, parent, director, m_Window.state.timeAreaShownRange.x, ResolveType, insertBefore);
}
// if we are rejected, clear any drop markers
if (retMode == DragAndDropVisualMode.Rejected && targetItem != null)
{
ClearInsertionMarkers(originalTarget);
ClearInsertionMarkers(targetItem);
ClearInsertionMarkers(parentItem);
ClearInsertionMarkers(insertBeforeItem);
}
}
else
{
var candidateTime = TimelineHelpers.GetCandidateTime(Event.current.mousePosition);
retMode = HandleClipPaneObjectDragAndDrop(objectsBeingDropped, GetTrack(targetItem), perform, m_Timeline, GetTrack(parentItem), director, candidateTime, ResolveType);
}
}
m_Window.isDragging = false;
return(retMode);
}
void HandleDragPerformEvent(Editor[] editors, Event evt, ref int targetIndex)
{
if (targetIndex != -1)
{
var draggingMode = DragAndDrop.GetGenericData(k_DraggingModeKey) as DraggingMode ? ;
if (!draggingMode.HasValue || draggingMode.Value == DraggingMode.NotApplicable)
{
targetIndex = -1;
return;
}
if (!editors[targetIndex].targets.All(t => t is Component))
{
return;
}
var targetComponents = editors[targetIndex].targets.Cast <Component>().ToArray();
if (draggingMode.Value == DraggingMode.Script)
{
var scripts = DragAndDrop.objectReferences.Cast <MonoScript>();
// Ensure all script components can be added
var valid = true;
foreach (var targetComponent in targetComponents)
{
var gameObject = targetComponent.gameObject;
if (scripts.Any(s => !ComponentUtility.WarnCanAddScriptComponent(gameObject, s)))
{
valid = false;
break;
}
}
if (valid)
{
Undo.IncrementCurrentGroup();
var undoGroup = Undo.GetCurrentGroup();
// Add script components
var index = 0;
var addedComponents = new Component[targetComponents.Length * scripts.Count()];
for (int i = 0; i < targetComponents.Length; i++)
{
var targetComponent = targetComponents[i];
var gameObject = targetComponent.gameObject;
bool targetIsTransform = targetComponent is Transform;
foreach (var script in scripts)
{
addedComponents[index++] = ObjectFactory.AddComponent(gameObject, script.GetClass());
}
// If the target is a Transform, the AddComponent might have replaced it with a RectTransform.
// Handle this possibility by updating the target component.
if (targetIsTransform)
{
targetComponents[i] = gameObject.transform;
}
}
// Move added components relative to target components
if (!ComponentUtility.MoveComponentsRelativeToComponents(addedComponents, targetComponents, m_TargetAbove))
{
// Ensure we have the same selection after calling RevertAllDownToGroup below (MoveComponentsRelativeToComponents can have opened a Prefab in Prefab Mode and changed selection to that root)
var wantedSelectedGameObject = Selection.activeGameObject;
// Revert added components if move operation fails (e.g. user has been shown the dialog with 'prefab instance restructuring is not posssible' or object is not editable)
Undo.RevertAllDownToGroup(undoGroup);
if (wantedSelectedGameObject != Selection.activeGameObject)
{
Selection.activeGameObject = wantedSelectedGameObject;
}
}
}
}
else
{
// Handle dragging components
var sourceComponents = DragAndDrop.objectReferences.Cast <Component>().ToArray();
if (sourceComponents.Length == 0 || targetComponents.Length == 0)
{
return;
}
MoveOrCopyComponents(sourceComponents, targetComponents, EditorUtility.EventHasDragCopyModifierPressed(evt), false);
}
targetIndex = -1;
DragAndDrop.AcceptDrag();
evt.Use();
EditorGUIUtility.ExitGUI();
}
}
public static void HandleBindingDragAndDrop(TrackAsset dropTarget, Type requiredBindingType)
{
var objectBeingDragged = DragAndDrop.objectReferences[0];
var action = BindingUtility.GetBindingAction(requiredBindingType, objectBeingDragged);
DragAndDrop.visualMode = action == BindingAction.DoNotBind
? DragAndDropVisualMode.Rejected
: DragAndDropVisualMode.Link;
if (action == BindingAction.DoNotBind || Event.current.type != EventType.DragPerform)
{
return;
}
var director = TimelineEditor.inspectedDirector;
switch (action)
{
case BindingAction.BindDirectly:
{
BindingUtility.Bind(director, dropTarget, objectBeingDragged);
break;
}
case BindingAction.BindToExistingComponent:
{
var gameObjectBeingDragged = objectBeingDragged as GameObject;
Debug.Assert(gameObjectBeingDragged != null, "The object being dragged was detected as being a GameObject");
BindingUtility.Bind(director, dropTarget, gameObjectBeingDragged.GetComponent(requiredBindingType));
break;
}
case BindingAction.BindToMissingComponent:
{
var gameObjectBeingDragged = objectBeingDragged as GameObject;
Debug.Assert(gameObjectBeingDragged != null, "The object being dragged was detected as being a GameObject");
var typeNameOfComponent = requiredBindingType.ToString().Split(".".ToCharArray()).Last();
var bindMenu = new GenericMenu();
bindMenu.AddItem(
EditorGUIUtility.TextContent("Create " + typeNameOfComponent + " on " + gameObjectBeingDragged.name),
false,
nullParam => BindingUtility.Bind(director, dropTarget, Undo.AddComponent(gameObjectBeingDragged, requiredBindingType)),
null);
bindMenu.AddSeparator("");
bindMenu.AddItem(EditorGUIUtility.TrTextContent("Cancel"), false, userData => {}, null);
bindMenu.ShowAsContext();
break;
}
default:
{
//no-op
return;
}
}
DragAndDrop.AcceptDrag();
}
public override void DragCleanup(bool revertExpanded)
{
DragAndDrop.SetGenericData("SceneHeaderList", null);
base.DragCleanup(revertExpanded);
}