FullInspector-Editor
A list of all types that have a CustomBehaviorEditorAttribute attribute.
Cached property editors.
If there are multiple user-defined property editors that report that they can edit a
specific type, we sort the applicability of the property editor based on how close it's
reported edited type is to the actual property type. This allows for, say, the
IListPropertyEditor to override the ICollectionPropertyEditor.
Returns a set of property editors that can be used to edit the given property type.
Returns a behavior editor that can be used to edit the given behavior type.
The type of behavior to edit. This should derive from
BaseBehavior.
Returns true if the given dataType matches the given behaviorType. If the dataType is
generic and the behaviorType is a generic definition, then the behaviorType will be
instantiated with the same generic arguments as dataType.
Creates a new instance of the given editorType. It is assumed that editorType extends
IBehaviorEditor.
Attempt to create a new IBehaviorEditor instance.
The data type that is used for comparison with the behavior
editor.
The actual data type that that usedEditedType was derived
from.
The type of editor we are trying to create.
Attempts to create a behavior editor for the given edited data type from the given
editor type.
The type that is being edited.
The editor type.
A behavior editor that can edit the given edited type.
Allows an IPropertyEditor to be used as an attribute property editor.
The attribute type that activates this property editor.
If true, then this attribute property editor will replace other property editors beneath
it.
Construct a new attribute instance.
The attribute type that activates this property
editor.
Construct a new attribute instance.
The attribute type that activates this property
editor.
If true, then this attribute property editor will replace
other property editors beneath it.
Mark a type as a custom behavior editor. That editor needs to derive from
BehaviorEditor{TBehavior} and will be used as the editor for that behavior type.
The behavior type to edit.
True if this should editor should apply to derived types. Defaults to true.
An annotation that signals that a class is a property editor for a given property type.
If the property editor is editing a generic type, then PropertyType should just be an open
generic type reflecting the edited type. For example, for a List property editor,
PropertyType should be typeof(List{}) (where {} are angle brackets).
The type of property that this class is a property editor for. This can be either a
non-generic type or an open generic type (List{} is an open generic type, but List[int]
is not).
Should this editor type be used for inherited PropertyTypes? If Inherit is true, then
the first generic parameter of your property editor type will be automatically populated
with the derived type that the property editor is being used to edit.
Internal bool to prevent a warning emission if this property editor targets UnityObject
types.
Mark this type as an IPropertyEditor. It will be instantiated automatically.
The type of property that this PropertyEditor is
editing.
Mark this type as an IPropertyEditor. It will be instantiated automatically.
The type of property that this PropertyEditor is
editing.
If true, then this PropertyEditor will also be used for types that
derive from propertyType. If true, then this also has implications on the generic
parameter list. See the documentation on the member variable for more
information.
The default behavior editor is used whenever there is not a user-defined one that should be
used instead.
If you wish to just extend the default behavior editor by adding a section before/after it, you
can just extend this class and override the appropriate methods.
An editor that provides a good inspector experience for types which derive from
ISerializedObject.
This is accessed by the BaseBehaviorEditor (using reflection) to determine if the editor
should show the value for _serializedState.
Draws an open script button for the given object.
An IAttributePropertyEditor is identical to an IPropertyEditor, except that it also
contains an Attribute parameter.
The attribute that was used to create this editor.
A property editor is the core editing abstraction used within FI. This allows for
overriding of the default inspector logic for elements of a custom type. PropertyEditors
are extremely similar to Unity's PropertyDrawers, except that they support generics and
are fully type-safe. The AttributePropertyEditor is identical to the PropertyEditor, except
that it is activated when a user adds an attribute to a type.
Recall that to get FI to actually use the property editor, you need to add the
[CustomAttributePropertyEditor] attribute to the type with appropriate parameters.
The element type that the editor will edit
Notification that the inspector/editor is now active.
Notification that the inspector/editor is no longer active.
This method makes it easy to use a typical behavior editor as a GUILayout style method,
where the rect is taken care of.
The editor that is being used.
The element that is being edited.
Marks an object as a property editor.
This interface is split up into two parts, the core one that user's typically access,
IPropertyEditor, and one that implements the actual editing API, IPropertyEditorEditAPI.
You almost certainly want to extend PropertyEditor{T} instead of this
interface. It provides an automatic implementation for all methods and gives type-safety to
your editor.
The editing chain that this editor is within. This can be used to fetch the next editor
to use and the like.
Can the editor edit the given type?
An optional annotation for a property editor to specify its default foldout state.
The default foldout state for the property editor. If set to false, then the editor
will be collapsed immediately.
A property editor is the core editing abstraction used within FI. This allows for overriding
of the default inspector logic for elements of a custom type. PropertyEditors are extremely
similar to Unity's PropertyDrawers, except that they support generics and are fully
type-safe.
Recall that to get FI to actually use the property editor, you need to add the
[CustomPropertyEditor] attribute to the type with appropriate parameters.
The element type that the editor will edit
This is the core editing API that property editors use. We split the editing API and the
IPropertyEditor interfaces into two as we define extension methods on IPropertyEditor that
allows FI to run arbitrary code before/after the actual edit method executes.
Display a Unity inspector GUI that provides an editing interface for the given object.
The rect on the screen to draw the GUI controls.
The label to label the controls with.
The element itself to edit. This can be mutated directly. For
values which cannot be mutated, such as structs, the return value is used to update the
stored value.
An updated instance of the element.
Returns the height of the region that needs editing.
The label that will be used when editing.
The element that will be edited.
The height of the region that needs editing.
Returns a header that should be used for the foldout. An item is displayed within a
foldout when this property editor reaches a certain height.
The current foldout label.
The current object element.
An updated label.
Draw an optional scene GUI.
The object instance to edit using the scene GUI.
An updated object instance.
Does this editor display a standard label that can instead be rendered with EditorGUI.Foldout?
The cached height metadata is used to optimize CPU/execution time for some memory so that
we don't have to recompute heights multiple times over. In essence, if we call
GetElementHeight from Edit, then GetElementHeight will short-circuit and just return a
cached height.
We store the current
The current method that we are invoking.
Helper method to fetch the editing API for an IPropertyEditor.
Display a Unity inspector GUI that provides an editing interface for the given object.
The rect on the screen to draw the GUI controls.
The label to label the controls with.
The element itself to edit. This can be mutated directly. For
values which cannot be mutated, such as structs, the return value is used to update the
stored value.
An updated instance of the element.
Fetches the dropdown metadata instance that should be used. This performs any necessary initialization.
Returns the height of the region that needs editing.
The label that will be used when editing.
The element that will be edited.
The height of the region that needs editing.
Returns a header that should be used for the foldout. An item is displayed within a
foldout when this property editor reaches a certain height.
The current foldout label.
The current object element.
An updated label.
Draw an optional scene GUI.
The object instance to edit using the scene GUI.
An updated object instance.
This method makes it easy to use a typical property editor as a GUILayout style method,
where the rect is taken care of.
The editor that is being used.
The label to edit the region with.
The element that is being edited.
Detects when Unity is recompiling code. Before a recompile happens, all state is saved and
after the recompilation is finished all state is restored.
True if we have detected a compile but have already saved. This is set to false by Unity
after a compilation has finished.
True if everything has been restored. This is set to false by Unity after a compilation
/ reload has occurred.
Detects when the editor has entered or left play mode or has paused.
This class is currently disabled / not used, but it remains here because the code is tricky
to get right and may be useful in the future.
A transition that the editor can go through.
The editor is about to enter play mode but has yet to go through Unity
serialization.
The editor is about to enter play mode and has just gone through Unity
serialization.
The editor is leaving play mode and has just gone through Unity serialization.
The editor is about to enter pause mode
The editor is about to leave pause mode
The last playing state
The last paused state
This function is called when the editor is undergoing a play mode related transition.
This processor saves the state of any unsaved BaseBehavior instances when the scene has been
saved. This type isn't necessary as the BaseBehaviorEditor manages saving everything, but it
provides some extra data protection.
Manages the discovery of PropertyEditor class instances.
The type of the edited object.
The attributes associated with the edited type.
A list of all types that have a CustomPropertyEditorAttribute attribute.
Cached property editors.
If there are multiple user-defined property editors that report that they can edit a
specific type, we sort the applicability of the property editor based on how close it's
reported edited type is to the actual property type. This allows for, say, the
IListPropertyEditor to override the ICollectionPropertyEditor.
Returns a set of property editors that can be used to edit the given property type.
Returns a PropertyEditorChain that can edit the given type. The PropertyEditorChain will
contain all of the IPropertyEditor instances which reported that they could edit the
given type (with the associated set of attributes). To get an actual property editor,
use chain.FirstEditor or a similar method.
The type of property/field that is being edited.
Provides attributes that may override the default
property editor. This parameter can safely be set to null.
A property editor chain composed of property editors which can edit the given
property type.
In Full Inspector, there are typically a large number of property editors that can be used
for each type, for example, a user defined editor, then the abstract editor, then the
reflected editor. PropertyEditorChain encapsulates this idea and makes it easy to retrieve
the next editor that will be used.
The editing chain. The most applicable editor is at index 0 (followed by the next most
applicable at index 1, ...).
Adds an editor to the end of this chain.
Returns true if there is another editor after the given one.
Returns the next editor that will be used, or null if the given editor is either the
last one or was not found in the chain.
The editor that is currently being used.
The next editor, or null if there is no next one.
Returns the first property editor in this chain that is not an instance of any of the
given types.
Returns the first property editor in this chain.
Returns true if the given dataType matches the given propertyType. If the dataType is
generic and the propertyType is a generic definition, then the propertyType will be
instantiated with the same generic arguments as dataType.
Creates a new instance of the given editorType. It is assumed that editorType extends
IPropertyEditor.
Attempt to create a new IPropertyEditor instance.
The data type that is used for comparison with the property
editor.
The actual data type that that usedEditedType was derived
from.
The type of editor we are trying to create.
Attempts to create a property editor for the given edited data type from the given
editor type.
The type that is being edited.
The editor type.
The attributes that were specified for the type.
Should inheritance behavior be forced? The expected value is false.
A property editor that can edit the given edited type.
We only animate the abstract type height when we have changed types ourselves. If we
always animate when a height change occurs and the inside is also animating, then we
will create an "animation lag" which looks awful.
Provides a property editor for types which cannot be instantiated directly and require the
user to select a specific instance to instantiate.
A map of attribute type to the IPropertyEditor type that is associated with that
attribute (via the CustomAttributePropertyEditorAttribute annotation).
A map of attribute type to if that property editor should replace all other editors
after it.
Provides a property editor for enums.
A property editor for nullable types.
The general property editor that takes over when there is no specific override. This uses
reflection to discover what values to edit.
The maximum depth that the reflected editor will go to for automatic object reference
instantiation. Beyond this depth, the user will have the manually instantiate
references. We have a depth limit so that we don't end up in an infinite object
construction cycle.
This returns true if automatic instantiation should be enabled. Automatic instantiation
gets disabled after the reflected editor has gone a x calls deep into itself in an
attempt to prevent infinite recursion.
How tall buttons should be.
How tall the label element should be.
How much space is between each element.
The height of the category toolbar.
Returns true if the given GUIContent element contains any content.
Draws a label at the given region. Returns an indented rectangle that can be used for
drawing properties directly under the label.
A helper method that draws the inspector for a field/property at the given location.
A helper method that draws a button at the given region.
Draws the actual property editors.
Manages the options that are displayed to the user in the instance selection drop-down.
Setup the instance option manager for the given type.
Returns an array of options that should be displayed.
Remove any options from the set of display options that are not permanently visible.
Returns the index of the option that should be displayed (from GetDisplayOptions())
based on the current object instance.
Changes the instance of the given object, if necessary.
This class assists with cycle detection in an object graph.
Factory we use for allocation HashSets (to minimize GC pressure).
Cycle detectors that we are depending on / derived from.
The objects we have encountered so far.
The recursion depth level that we're at.
The current recursion / nesting depth.
Increase the recursion / nesting depth.
Decrease the recursion / nesting depth.
Tries to mark an object. Returns false if the object is already in the cycle detector,
ie, it has already been encountered (which implies that it's part of a cycle).
Returns true if the object is in the cycle detector, ie, the object is part of a cycle.
An editor that is displayed while we are generating the PropertyDrawer bindings.
The current version string.
Full Inspector will effectively force the user to do a clean import if any of the following types are found in
the assembly.
A wrapper around AnimFloat that makes it easier to use.
Update the height of the editor.
The new height.
Should animation be allowed? Sometimes animation is not
desired if a sub-item is animation. If this item animations when a sub-item is
animating, then there will be visible UX jerk.
If true, then a transition is occurring and the animation is rendering.
Returns true if animation is occurring.
The current height of the animation.
Draws a normal EditorGUI.ObjectField, except it includes the component type.
Draws a button with a label in front of the button.
Draws a button with a label in front of the button.
Draws an editor for the given control at the given rect.
The rect to draw the editor within.
The label for the edited control.
The element to edit.
The metadata to use when editing.
The actual control that will be used for the editor.
The updated element instance.
Draws an editor for the given control at the given rect.
The element to edit.
The label for the edited control.
The metadata to use when editing.
The actual control that will be used for the editor.
The height that is needed to fully display this control.
Draws a GUI for editing the given property and returns the updated value. This does
*not* write the updated value to a container.
Draws a GUI for editing the given property and returns the updated value. This does
*not* write the updated value to a container.
An optional context that the property value came from. If this is not given, then a prefab context menu will not be displayable.
This class is used to cache results for some expensive fiEditorUtility method calls.
Returns the paths of all .scene files in the Unity project.
Find all prefabs of a given type, regardless of location.
The type of object to fetch
Please note that this method can return UnityObject instances that have been deleted.
Find all assets of a given type, regardless of location.
The (ScriptableObject derived) type of object to fetch
Please note that this method can return UnityObject instances that have been deleted.
This will sent a repaint request to every active editor.
Add to this list if the editor should be repainted upon a general repaint request.
If enabled, then the inspector should be constantly redrawn. This is used to work around
some rendering issues within Unity.
Attempts to fetch a MonoScript that is associated with the given obj.
The object to fetch the script for.
The script, if found.
True if there was a script, false otherwise.
Returns true if the given obj has a MonoScript associated with it.
Returns an associated object for another object.
A mapping from the objects that contain metadata to their metadata.
Returns true if there is metadata for the given item.
Sets the metadata instance for the given item and type.
Fetch a metadata instance for the given item.
Utility functions for working with prefab overrides.
Returns true if the period separate property path contains the given property name.
Attempts to extract the name of serialized key for the given property modification.
The object that that modification is applied to.
The modification.
An output parameter containing the name of the key that the
modification maps to.
True if the key was found, false otherwise.
Reverts the given property on the instance to the prefab value.
The prefab instance to revert the value on.
The property to revert.
Returns true if the given property on the given object instance has a prefab override.
The object instance.
The property to check.
True if the property is prefab override, false otherwise.
Currently, this method only works for MonoBehavior targets.
A cache of all types that derive the key type in the AppDomain. The cache is
automatically destroyed upon assembly loads.
Returns all types that derive from the base type. This includes generic type
definitions, which when returned will have appropriate constructor values injected.
The base parent type.
A candidate type that can potentially be used as a generic parameter argument.
The actual type that will be the generic parameter.
The name of the generic parameter that this type came from.
Helper method to return the index of the Type in the array that has the given Name (or
- 1 if the item is not in the array).
Orders the given types parameter array so that the order most closely matches the given
genericArguments array
The types that have been collected as potential candidates
for generic parameter arguments
The type that we are going to use the candidateTypes for
constructing a closed generic type on
An array of types that can (hopefully) be used to construct a closed generic
type from the given openGenericType.
Attempts to create an instance of openGenericType such that it is can be assigned to
baseType.
An open generic type that derives baseType
A generic type with fully populated type parameters.
Just baseType.GetGenericTypeDefinition()
Just baseType.GetGenericArguments()
If this function returns true, then this value is set to
the created type that is assignable to baseType and an instance of
openGenericType.
True if a type was constructed, false otherwise.
Searches for a particular implementation of the given parent type inside of the type.
This is particularly useful if the interface type is an open type, ie, typeof(IFace{}),
because this method will then return IFace{} but with appropriate type parameters
inserted.
The base type to search for interface
The parent type to search for. Can be an open generic
type.
The actual interface type that the type contains, or null if there is no
implementation of the given interfaceType on type.
Tries to fetch the given CSharpName of the given object type, or null if the object is
null.
Returns the value of a boolean, field, or property.
A few APIs to forcibly call SaveState and RestoreState on every type
that implements ISerializedObject.
Forcibly save the state of all objects which derive from ISerializedObject.
ISerializedObject saving is managed automatically when you use the editor (and can be
customized in fiSettings).
Forcibly restore the state of all objects which derive from ISerializedObject.
This will clean all of the FI data from the scene.
Returns the object that this serialized property is currently storing.
This class contains methods that do not use public Unity API. These are subject to
break/change per update.
Attempts to enable/disable the bold font that is used by Unity when an object has a
value different from its prefab.
True if the bold font is set, false if it is not.
Helper to write the C# file containing the selected serializer information.
Contains editing logic common to the backup window and the inline backup viewer.
The backup editor window.
The central API that end-users might be interested in. Provides key functions such as
creating a new backup and restoring an old one.
Returns all backups for the given object.
Creates a new backup of the given component. Only guaranteed to work for types that
derive from CommonBaseBehavior, but there is a good chance it'll work for most/all
types derived from Component.
Helper function that just ignores a few FI internal types for serialization since the
backup solution serializes all inspected properties, not just those that are serialized
Restores a backup that was previously created.
Creates a serialized object from the given component.
Manages backups stored in prefab storage container. The prefab container stores backups
when Unity is in play-mode and when the backup target does not live in the scene (an
example would be a backup targeting another prefab).
Manages the backup storage that lives in the scene.
This class provides a unified API for accessing backups across scene and prefab storage.
Returns the storage component that is currently best suited for use.
Removes the given backup instance.
Removes backups that are no longer valid (their target got destroyed, etc).
Attempts to migrate prefab storage into scene storage.
Returns true if there is a backup for the given behavior.
Returns every serialized object.
Reorderable list adapter for arrays.
Reorderable list adapter for ICollection types
Returns the height of the given element.
Provides an editor for the given element.
Metadata we use for the callbacks.
Stores all of the elements
A cached version of the collection optimized for item lookup.
For performance reasons, the CollectionAdaptor stores an array version of the
collection. If the adapted collection has been structurally modified, for example, an
item has been added, then the local cache is invalid. Calling this method updates the
cache, which will restore proper adapter semantics.
Reorderable list adapter for generic list.
This adapter can be subclassed to add special logic to item height calculation. You
may want to implement a custom adapter class where specialized functionality is
needed.
The list which can be reordered.
Callback to draw list item.
Height of list item in pixels.
This is the base collection property editor with a set of extension points for the other
property editors. All Rotorz-style collection editors use this as the base editor. It
provides automatic support for paging.
The actual type of the collection, ie, List{T}. This is used for instance creation.
The collection interface, ie, IList{T}, or List{T}. The property editor
selection logic will choose the most associated editor using this type.
The type of items stored inside of the collection, ie, {T} in List{T}.
The type of item that is added to a collection, ie,
TAddItem = {K} in TActual = Dictionary{K, V} where TItem = KeyValuePair{K, V}
Fetch an adaptor for the collection.
Called after an edit cycle is done if the collection needs to be updated from the adaptor.
An item has been added to the collection.
Should the item added to the collection be customized *before* adding it?
Can we reorder elements inside of the collection?
Provides a relatively simple editor for IList{T} types that only views one element at a
time. This is useful if the list is massive, or perhaps to just reduce information overload
when editing.
Returns true if there is currently an item that is being edited.
Attempts to ensure that the current editing index is not out of range. However, if the
edited list is empty, then the index will always be out of range.
The metadata we store on each item that we edit so that we know what the active editing
item is.
Adaptor allowing reorderable list control to interface with list data.
Gets count of elements in list.
Determines whether an item can be reordered by dragging mouse.
This should be a light-weight method since it will be used to determine whether
grab handle should be included for each item in a reorderable list. Please
note that returning a value of false does not prevent movement on list item since
other draggable items can be moved around it.
Zero-based index for list element.
A value of true if item can be dragged; otherwise /c>.
Determines whether an item can be removed from list.
This should be a light-weight method since it will be used to determine whether
remove button should be included for each item in list. This is redundant
when is specified.
Zero-based index for list element.
A value of true if item can be removed; otherwise /c>.
Add new element at end of list.
Insert new element at specified index.
Zero-based index for list element.
Duplicate existing element.
Zero-based index of list element.
Remove element at specified index.
Zero-based index of list element.
Move element from source index to destination index.
Zero-based index of source element.
Zero-based index of destination element.
Clear all elements from list.
Draw interface for list element.
Position in GUI.
Zero-based index of array element.
Gets height of list item in pixels.
Zero-based index of array element.
Measurement in pixels.
Resources to assist with reorderable list control.
Resource assets for light skin.
Resource assets are PNG images which have been encoded using a base-64 string so
that actual asset files are not necessary.
Resource assets for dark skin.
Resource assets are PNG images which have been encoded using a base-64 string so
that actual asset files are not necessary.
Gets light or dark texture "add_button.png".
Gets light or dark texture "add_button_active.png".
Gets light or dark texture "container_background.png".
Gets light or dark texture "grab_handle.png".
Gets light or dark texture "remove_button.png".
Gets light or dark texture "remove_button_active.png".
Gets light or dark texture "title_background.png".
Generate special textures.
Create 1x1 pixel texture of specified color.
Name for texture object.
Pixel color.
The new Texture2D instance.
Read textures from base-64 encoded strings. Automatically selects assets based upon
whether the light or dark (pro) skin is active.
Read width and height if PNG file in pixels.
PNG image data.
Width of image in pixels.
Height of image in pixels.
Utility functions to assist with GUIs.
Gets visible rectangle within GUI.
VisibleRect = TopmostRect + scrollViewOffsets
Focus control and text editor where applicable.
Arguments which are passed to .
Gets adaptor to reorderable list container which contains element.
Gets zero-based index of item which was inserted.
Indicates if inserted item was duplicated from another item.
Initializes a new instance of .
Reorderable list adaptor.
Zero-based index of item.
Indicates if inserted item was duplicated from another
item.
An event handler which is invoked after new list item is inserted.
Object which raised event.
Event arguments.
Arguments which are passed to .
Gets adaptor to reorderable list container which contains element.
Gets zero-based index of item which was inserted.
Initializes a new instance of .
Reorderable list adaptor.
Zero-based index of item.
An event handler which is invoked before a list item is removed.
Item removal can be cancelled by setting to
true.
Object which raised event.
Event arguments.
Base class for custom reorderable list control.
Invoked to draw list item.
GUI controls must be positioned absolutely within the given rectangle since list
items must be sized consistently.
The following listing presents a text field for each list item:
wishlist = new
List();
private void OnGUI() { ReorderableListGUI.ListField(wishlist, DrawListItem); }
private string DrawListItem(Rect position, string value) { // Text fields do not like
`null` values! if (value == null) value = ""; return EditorGUI.TextField(position,
value) ; } } ]]> ;
function OnGUI() { ReorderableListGUI.ListField(wishlist, DrawListItem); }
function DrawListItem(position:Rect, value:String):String { // Text fields do not like
`null` values! if (value == null) value = ''; return EditorGUI.TextField(position,
value) ; } } ]]>
Type of item list.
Position of list item.
The list item.
The modified value.
Invoked to draw content for empty list.
Callback should make use of GUILayout to present controls.
The following listing displays a label for empty list control:
_list;
private void OnEnable() { _list = new List(); } private void OnGUI() {
ReorderableListGUI.ListField(_list, ReorderableListGUI.TextFieldItemDrawer,
DrawEmptyMessage) ; }
private string DrawEmptyMessage() { GUILayout.Label("List is empty!",
EditorStyles.miniLabel); } } ]]> ;
function OnEnable() { _list = new List.(); } function OnGUI() {
ReorderableListGUI.ListField(_list, ReorderableListGUI.TextFieldItemDrawer,
DrawEmptyMessage) ; }
function DrawEmptyMessage() { GUILayout.Label('List is empty!', EditorStyles.miniLabel);
} } ]]>
Invoked to draw content for empty list with absolute positioning.
Position of empty content.
Background color of anchor list item.
Background color of target slot when dragging list item.
Style for right-aligned label for element number prefix.
Generate and draw control from state object.
Reorderable list adaptor.
Delegate for drawing empty list.
Optional flags to pass into list field.
Generate and draw control from state object.
Position of control.
Reorderable list adaptor.
Delegate for drawing empty list.
Optional flags to pass into list field.
Position of mouse upon anchoring item for drag.
Zero-based index of anchored list item.
Zero-based index of target list item for reordering.
Unique ID of list control which should be automatically focused. A value of zero
indicates that no control is to be focused.
Zero-based index of item which should be focused.
Zero-based index of list item which is currently being drawn.
Gets zero-based index of list item which is currently being drawn; or a value of -1 if
no item is currently being drawn.
Use instead.
Gets or sets flags which affect behavior of control.
Gets a value indicating whether add button is shown.
Gets a value indicating whether remove buttons are shown.
Occurs after list item is inserted or duplicated.
Raises event after list item is inserted or duplicated.
Event arguments.
Occurs before list item is removed and allows removal to be cancelled.
Raises event before list item is removed and provides oppertunity to cancel.
Event arguments.
Initializes a new instance of .
Initializes a new instance of .
Optional flags which affect behavior of control.
Unique Id of control.
Visible rectangle of control.
Width of index label in pixels (zero indicates no label).
Indicates whether item is currently being dragged within control.
Indicates if reordering is allowed.
Prepare initial state for list control.
Unique ID of list control.
Reorderable list adaptor.
Indicate that first control of list item should be automatically focused if possible.
Unique ID of list control.
Zero-based index of list item.
Draw add item button.
Position of button.
Unique ID of list control.
Reorderable list adaptor.
Draw remove button.
Position of button.
Indicates if control is visible within GUI.
A value of true if clicked; otherwise /c>.
Begin tracking drag and drop within list.
Unique ID of list control.
Zero-based index of item which is going to be dragged.
Stop tracking drag and drop.
Gets a value indicating whether item in current list is currently being tracked.
Unique ID of list control.
A value of true if item is being tracked; otherwise /c>.
Accept reordering.
Reorderable list adaptor.
Draw list container and items.
Position of list control in GUI.
Unique ID of list control.
Reorderable list adaptor.
Checks to see if list control needs to be automatically focused.
Unique ID of list control.
Draw additional controls below list control and highlight drop target.
Position of list control in GUI.
Unique ID of list control.
Reorderable list adaptor.
Cache of container heights mapped by control ID.
Do layout version of list field.
Unique ID of list control.
Reorderable list adaptor.
Position of list container area in GUI (excludes footer area).
Draw content for empty list (layout version).
Callback to draw empty content.
Position of list container area in GUI (excludes footer area).
Draw content for empty list (layout version).
Position of list control in GUI.
Callback to draw empty content.
Correct if for some reason one or more styles are missing!
Draw layout version of list control.
Unique ID of list control.
Reorderable list adaptor.
Delegate for drawing empty list.
Draw list control with absolute positioning.
Position of list control in GUI.
Unique ID of list control.
Reorderable list adaptor.
Delegate for drawing empty list.
Draw list control with absolute positioning.
Position of list control in GUI.
Reorderable list adaptor.
Delegate for drawing empty list.
Content for "Move to Top" command.
Content for "Move to Bottom" command.
Content for "Insert Above" command.
Content for "Insert Below" command.
Content for "Duplicate" command.
Content for "Remove" command.
Content for "Clear All" command.
Default functionality to handle context command.
Can be used when adding custom items to the context menu: