Unfortunately Unity 3.5’s serialization mechanism for Assets based on ScriptableObject does not support polymorphism. If you store an object of a derived type B in a field of type A, you lose the actual type when serializing.

For instance, in the following piece of code

[Serializable]
public class SerializableA : ScriptableObject
{
    [Serializable]
    public class A
    {
        public virtual string S()
        {
            return "A";
        }
    }

    [Serializable]
    public class B : A
    {
        public override string S()
        {
            return "B";
        }
    }

    public A a;

the variable assigned to a will always be of type A after serialization. So if you reference the ScriptableObject in a prefab a will always be an A, even if you assigned a B to it. Hence, a.S() will always return “A”.

If you render custom controls in an EditorWindow and you want to pick them with the mouse (maybe for drag and dropping), you can use

GUILayoutUtility.GetRect

to reserve a rectangle with automatic layout. You can then use the returned rectangle to draw the control later with the regular GUI methods that take rectangles as parameters.

When you put your controls inside a scroll view you need to account for the scroll offset by using the value returned by BeginScrollView.

For some reason the local coordinate system is also reset inside the ScrollView and the mouse position will be shifted by any controls rendered before the ScrollView. In the example below the mouse y coordinate will be off by the height of the Popup control and any additional controls. You can account for that by retrieving the yMax of the last control with

GUILayoutUtility.GetLastRect

as given in the example below.

// Some GUI controls before the ScrollView
selection = EditorGUILayout.Popup( selection , options, EditorStyles.toolbarPopup );

... more, maybe a label or two

// Retrieve the y offset for any previously rendered controls
var lastRectangle = GUILayoutUtility.GetLastRect();
float yOffset = lastRectangle.yMax;

scrollPosition = EditorGUILayout.BeginScrollView( scrollPosition );
{
    // Account for the scroll position
    var samplePosition = mousePosition + scrollPosition;

    // Account for the GUI controls before the ScrollView
    samplePosition.y -= yOffset;

    Rect rectangle = GUILayoutUtility.GetRect( new GUIContent( "foobar" ), normalStyle );

    if ( ( e.type == EventType.MouseDown ) && rectangle.Contains( samplePosition ) )
    {
        // Handle selection here

        // Draw item with selected style and rectangle
    }
    else
    {
        // Draw item with normal style and rectangle
    }
}
EditorGUILayout.EndScrollView();

Some Unity functions are badly documented. I just could not find any detailed information on how to use the DragAndDrop functionality provided by the Unity GUI. Here is what I found out:

The following Event types are useful for DragAndDrop functionality:

• DragUpdated
• DragPerform
• DragExited
• MouseDrag
• MouseDown
• MouseUp

DragUpdated seems to be raised whenever the mouse button is held down and the mouse moved after a DragAndDrop.StartDrag. DragPerform is called when the mouse button is released for the drop. Pressing the ESC key will raise the DragExited event, but so will leaving the current GUI area with the mouse cursor. This makes it unsuitable to detect whether the drag ended if you want to drag from one window to another. As soon as the mouse moves outside of the source window, Unity will fire DragExited. Because you have to press the mouse button down again to reinitiate a drag, you can reset your DragAndDrop logic on MouseDown. For instance I reset the object I want selected for the drag on the MouseDown event. MouseDrag is fired as long as the mouse is moved while a button is pressed. I use this event for initiating the drag.

Let’s look at what I am currently using. It’s basically what I am using to drag ‘Tasks’ around. Don’t worry about what the tasks are, they are just the objects that I am displaying with the GUI and dragging around.

void OnGUI()
{
    Event e = Event.current;

    if ( e.isMouse )
    {
        mousePosition = e.mousePosition;
    }

    // If mouse pressed or released

    if ( ( e.type == EventType.MouseUp ) || ( e.type == EventType.MouseDown ) )
    {
        // Clear our drag info in DragAndDrop so that we know that we are not dragging
        DragAndDrop.SetGenericData( DRAG_DATA_KEY, null );
    }

    FindAndListTasks( e, ref focusedTask );

    // If mouse is dragging, we have a focused task, and we are not already dragging a task

    if ( ( e.type == EventType.MouseDrag ) && ( focusedTask != null ) && !HasDraggedTask() )
    {
        StartDrag();

        // Use the event, else the drag won't start

        e.Use();
    }

    if ( e.type == EventType.DragUpdated )
    {
        // Indicate that we don't accept drags ourselves

        DragAndDrop.visualMode = DragAndDropVisualMode.Rejected;
    }
}

private void StartDrag()
{
    // Clear out drag data (doesn't seem to do much)
    DragAndDrop.PrepareStartDrag();

    //      Debug.Log( "dragging " + focusedTask );

    // Set up what we want to drag
    DragAndDrop.SetGenericData( DRAG_DATA_KEY, focusedTask );

    // Clear anything we don't use, else we might get weird behaviour when dropping on
    // some other control

    DragAndDrop.paths = null;
    DragAndDrop.objectReferences = new UnityEngine.Object[ 0 ];

    // Start the actual drag (don't know what the name is for yet)
    DragAndDrop.StartDrag( "Copy Task" );
}

Helper functions are

internal static void AcceptDraggedTask()
{
    DragAndDrop.AcceptDrag();
    ClearDraggedTask();
}

private static void ClearDraggedTask()
{
    DragAndDrop.SetGenericData( DRAG_DATA_KEY, null );
}

internal static bool HasDraggedTask()
{
    return ( DragAndDrop.GetGenericData( DRAG_DATA_KEY ) as Type ) != null;
}

internal static Type GetDraggedTask()
{
    return DragAndDrop.GetGenericData( DRAG_DATA_KEY ) as Type;
}

Then use something like

void OnGUI()
{
    var eventType = Event.current.type;

    if ( eventType == EventType.DragUpdated || eventType == EventType.DragPerform )
    {
        if ( TaskListWindow.HasDraggedTask() )
        {
            Type task = TaskListWindow.GetDraggedTask();

            // Indicate that we can accept the drag

            DragAndDrop.visualMode = DragAndDropVisualMode.Copy;

            if ( eventType == EventType.DragPerform )
            {
                Debug.Log( ( ( Type ) task ).Name );

                TaskListWindow.AcceptDraggedTask();
            }
        }
        else
        {
            DragAndDrop.visualMode = DragAndDropVisualMode.Rejected;
        }

        Event.current.Use();
    }
}

in the receiver.

You should clear all fields of DragAndDrop in order to cleanup any values set by a previous Unity DragAndDrop operation. Do something like the

DragAndDrop.paths = null;
DragAndDrop.objectReferences = new UnityEngine.Object[ 0 ];

I did above. Else you might get unexpected behaviour. Let me clarify this a bit. If you drag a file in the Project tab, Unity apparently sets the DragAndDrop.paths property. If later, you drag your own data onto the Project tab, and you don’t clear DragAndDrop.paths, then Unity will read the outdated DragAndDrop.paths value and move a file around in the Project tab. It is also a good idea to reset any generic data

DragAndDrop.SetGenericData( DRAG_DATA_KEY, focusedTask )

in your drag receiver, as it allows you to detect if your drag ended. You could even use a specific generic value (a boolean for instance) to track your drag state. Just use some naming convention that should not clash with other code, e.g. something like <NAMESPACE.VALUE>.

Actually I don’t know the intended usage of DragAndDrop.SetGenericData, DragAndDrop.objectReferences and DragAndDrop.paths, but I guess it is ok to use it for what you need. For instance, I currently store single objects I want to drag with a specific DRAG_DATA_KEY that should not interfer with other code. To detect if my drag operation finished, I set that key to null. Experiments showed that it is difficult to use the DragExited event to detect if a drag was aborted. Because it is also fired when the mouse cursor leaves the window as mentioned earlier. Thus, resetting your drag on the MouseDown event is easier.

I am totally aware that this is not a well structured tutorial, but it’s late and I wanted to get this info out as fast as possible. I hope its useful.

Happy coding!