Package com.smartgwt.client.tools

# Class EditContext

java.lang.Object
com.smartgwt.client.core.BaseClass
com.smartgwt.client.tools.EditContext

All Implemented Interfaces:
  `HasHandlers`, `HasEditMaskClickedHandlers`, `HasEditNodeUpdatedHandlers`, `HasNodeAddedHandlers`, `HasSelectedEditNodesUpdatedHandlers`

public class EditContext extends BaseClass implements HasEditMaskClickedHandlers, HasEditNodeUpdatedHandlers, HasNodeAddedHandlers, HasSelectedEditNodesUpdatedHandlers
An EditContext provides an editing environment for a set of components.

An EditContext is typically populated by adding a series of `EditNodes` created via a `Palette`, either via drag and drop creation, or when loading from a saved version, via `addFromPaletteNode()` or `addPaletteNodesFromXML()`.

An EditContext then provides interfaces for further editing of the components represented by EditNodes.

Developers may explicitly define an edit context and initialize it with a `rootComponent` - the root of the user interface being created. The EditContext itself is not visible to the user, but the root component's `liveObject` may be.
As child editNodes are added to the rootComponent node or its descendants, liveObjects in the user will update to reflect these changes. The live objects for the edit nodes will be nested using the appropriate parent-child relationships, for the types of node in question. For example Canvases will be added as `members` of layouts and FormItems will be added as `fields` of DynamicForms.

To enable drag and drop creation of widgets from a `Palette`, a developer can use `Canvas.setEditMode()` to enable editing behaviors on the live object of the desired drop target (typically the root component).
To enable editNode creation via double-click on a `Palette`, developers can set the `Palette.defaultEditContext`.

Developers can also make use of `EditPane` or `EditTree` classes which provide a visual interface for managing an EditContext.

See Also:
  - `Dashboards & Tools Framework Overview`

- ## Field Summary

  ### Fields inherited from class com.smartgwt.client.core.BaseClass

  `config, configOnly, factoryCreated, factoryProperties, id, scClassName`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `EditContext()`
  `EditContext(JavaScriptObject jsObj)`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `HandlerRegistration`
  `addEditMaskClickedHandler(EditMaskClickedHandler handler)`
  Add a editMaskClicked handler.
  `HandlerRegistration`
  `addEditNodeUpdatedHandler(EditNodeUpdatedHandler handler)`
  Add a editNodeUpdated handler.
  `EditNode`
  `addFromPaletteNode(PaletteNode paletteNode)`
  Creates a new EditNode from a PaletteNode, using the `defaultPalette`.
  `EditNode`
  `addFromPaletteNode(PaletteNode paletteNode, EditNode parentNode)`
  Creates a new EditNode from a PaletteNode, using the `defaultPalette`.
  `EditNode[]`
  `addFromPaletteNodes(PaletteNode[] paletteNodes)`
  Add the supplied `PaletteNodes` to the parentNode, preserving internal references from one supplied PaletteNode to another.
  `EditNode[]`
  `addFromPaletteNodes(PaletteNode[] paletteNodes, EditNode parentNode)`
  Add the supplied `PaletteNodes` to the parentNode, preserving internal references from one supplied PaletteNode to another.
  `EditNode[]`
  `addFromPaletteNodeTree(Tree paletteNodeTree)`
  Add the supplied `PaletteNode` tree to the parentNode, preserving internal references from one supplied PaletteNode to another.
  `EditNode[]`
  `addFromPaletteNodeTree(Tree paletteNodeTree, EditNode parentNode)`
  Add the supplied `PaletteNode` tree to the parentNode, preserving internal references from one supplied PaletteNode to another.
  `EditNode`
  `addNode(EditNode newNode)`
  Add a new `EditNode` to the EditContext, under the specified parent.
  `EditNode`
  `addNode(EditNode newNode, EditNode parentNode)`
  See `addNode()`
  `EditNode`
  `addNode(EditNode newNode, EditNode parentNode, Integer index)`
  See `addNode()`
  `EditNode`
  `addNode(EditNode newNode, EditNode parentNode, Integer index, String parentProperty)`
  See `addNode()`
  `EditNode`
  `addNode(EditNode newNode, EditNode parentNode, Integer index, String parentProperty, Boolean skipParentComponentAdd)`
  See `addNode()`
  `EditNode`
  `addNode(EditNode newNode, EditNode parentNode, Integer index, String parentProperty, Boolean skipParentComponentAdd, Boolean forceSingularFieldReplace)`
  Add a new `EditNode` to the EditContext, under the specified parent.
  `HandlerRegistration`
  `addNodeAddedHandler(NodeAddedHandler handler)`
  Add a nodeAdded handler.
  `void`
  `addPaletteNodeFormItemConstructors(Tree nodeTree)`
  Add `PaletteNode` constructors for the specific type of `FormItem` that will be created to the paletteNodes in the specified tree created by `createPaletteNodeTree()`.
  `void`
  `addPaletteNodesFromJS(String jsCode)`
  Add `PaletteNodes` from a JavaScript source representation.
  `void`
  `addPaletteNodesFromJS(String jsCode, EditNode parentNode)`
  See `addPaletteNodesFromJS()`
  `void`
  `addPaletteNodesFromJS(String jsCode, EditNode parentNode, String[] globals)`
  Add `PaletteNodes` from a JavaScript source representation.
  `void`
  `addPaletteNodesFromJSON(String jsonString)`
  Recreate `EditNodes` from a JSON representation of `PaletteNodes` (possibly created by calling `serializeAllEditNodesAsJSON()` or `serializeEditNodesAsJSON()`.
  `void`
  `addPaletteNodesFromJSON(String jsonString, EditNode parentNode)`
  See `addPaletteNodesFromJSON()`
  `void`
  `addPaletteNodesFromJSON(String jsonString, EditNode parentNode, String[] globals)`
  See `addPaletteNodesFromJSON()`
  `void`
  `addPaletteNodesFromJSON(String jsonString, EditNode parentNode, String[] globals, Function callback)`
  Recreate `EditNodes` from a JSON representation of `PaletteNodes` (possibly created by calling `serializeAllEditNodesAsJSON()` or `serializeEditNodesAsJSON()`.
  `void`
  `addPaletteNodesFromXML(String xmlString)`
  Recreate `EditNodes` from an XML representation of `PaletteNodes` (possibly created by calling `serializeAllEditNodes()` or `serializeEditNodes()`.
  `void`
  `addPaletteNodesFromXML(String xmlString, EditNode parentNode)`
  See `addPaletteNodesFromXML()`
  `void`
  `addPaletteNodesFromXML(String xmlString, EditNode parentNode, String[] globals)`
  See `addPaletteNodesFromXML()`
  `void`
  `addPaletteNodesFromXML(String xmlString, EditNode parentNode, String[] globals, Function callback)`
  Recreate `EditNodes` from an XML representation of `PaletteNodes` (possibly created by calling `serializeAllEditNodes()` or `serializeEditNodes()`.
  `HandlerRegistration`
  `addSelectedEditNodesUpdatedHandler(SelectedEditNodesUpdatedHandler handler)`
  Add a selectedEditNodesUpdated handler.
  `void`
  `convertedNode(EditNode origNode, EditNode newNode, EditNode parentNode)`
  Notification fired when an `EditNode` is converted to a different type when moved from one container to another.
  `void`
  `copyEditNodes(EditNode editNode)`
  Copies the passed editNode or editNodes to an internal "clipboard" space, for later application via `pasteEditNodes()`.
  `void`
  `copyEditNodes(EditNode... editNode)`
  Copies the passed editNode or editNodes to an internal "clipboard" space, for later application via `pasteEditNodes()`.
  `JavaScriptObject`
  `create()`
  `Tree`
  `createPaletteNodeTree(PaletteNode... paletteNodes)`
  Creates a `Tree` from the supplied `PaletteNodes` preserving internal references from one supplied PaletteNode to another.
  `void`
  `deselectAllEditNodes()`
  Deselect all EditNodes.
  `void`
  `deselectEditNodes(List editNodes)`
  Deselect a list of EditNodes.
  `void`
  `destroyAll()`
  Removes all `EditNodes` from the EditContext, and calls `destroy()` on the `liveObjects`.
  `Boolean`
  `editNodeHasDataSource(EditNode editNode)`
  Does the `editNode` have a DataSource assigned?
  `Boolean`
  `editNodeHasFields(EditNode editNode)`
  Does the `editNode` have at least one field assigned?
  `void`
  `enableEditing(EditNode editNode)`
  Enable edit mode for an `EditNode`.
  `Map`
  `getAllEditNodeGlobals()`
  Returns all global component IDs as a map of ID to `EditNode`.
  `Boolean`
  `getAllowDropThrough()`
  Dropping a component near the edge of another component allows the component to be dropped through an ancestor component.
  `Boolean`
  `getAllowNestedDrops()`
  Controls whether components can be dropped into other components which support child components.
  `Boolean`
  `getAutoEditNewNodes()`
  New nodes added to the editContext are automatically placed into edit mode if the new node's parent is in edit mode.
  `Boolean`
  `getCanDragGroup()`
  Should the group selection box shown when `canGroupSelect` is true allow dragging the group as a whole?
  `Boolean`
  `getCanGroupSelect()`
  Should a group selection outline covering the outermost bounding boxes of all selected components be shown in this container?
  `Boolean`
  `getCanSelectEditNodes()`
  Should editNodes added to this EditContext be selectable? When `true`, each `EditProxy.canSelectChildren` property is enabled unless explicitly set to `false`.
  `Palette`
  `getDefaultPalette()`
  `Palette` to use when an `EditNode` is being created directly by this EditContext, instead of being created due to a user interaction with a palette (eg dragging from a `TreePalette`, or clicking on `MenuPalette`).
  `EditNode`
  `getDefaultParent()`
  The default parent `EditNode` to be used when a new EditNode is added to the EditContext without a specified parent.
  `Map`
  `getEditMaskProperties()`
  Properties to apply to all `EditProxy.editMask`s created for components in edit mode.
  `EditNode[]`
  `getEditNodesByType(String types)`
  Returns `EditNodes` as an array that match the specified type or types.
  `EditNode[]`
  `getEditNodesByType(String... types)`
  Returns `EditNodes` as an array that match the specified type or types.
  `EditNode[]`
  `getEditNodesByType(String[] types, boolean strict)`
  Returns `EditNodes` as an array that match the specified type or types.
  `EditNode[]`
  `getEditNodesByType(String types, boolean strict)`
  Returns `EditNodes` as an array that match the specified type or types.
  `Tree`
  `getEditNodeTree()`
  Gets the tree of editNodes being edited by this editContext.
  `Boolean`
  `getEnableInlineEdit()`
  Whether inline editing should be enabled for any components that are added and are placed into editMode.
  `Palette[]`
  `getExtraPalettes()`
  Additional `Palettes` to consult for metadata when deserializing `Edit Nodes`.
  `Boolean`
  `getHideGroupBorderOnDrag()`
  Should the group selection box shown when `canGroupSelect` is true be hidden during drag?
  `HoopSelectionStyle`
  `getHoopSelectionMode()`
  Defines the mode of inclusion for components encountered during hoop selection which is enabled when `selectionType` is `multiple`.
  `Map`
  `getHoopSelectorProperties()`
  Properties to apply to `EditProxy.hoopSelector`.
  `JavaScriptObject`
  `getJsObj()`
  `void`
  `getNodeProperty(EditNode editNode, String name)`
  Returns the specified property from the editNode's serializable "defaults".
  `JavaScriptObject`
  `getOrCreateJsObj()`
  `static EditContext`
  `getOrCreateRef(JavaScriptObject jsObj)`
  `void`
  `getPaletteNodesFromJS(String jsCode, PaletteNodeCallback callback)`
  Obtain `PaletteNodes` from a JavaScript source representation.
  `void`
  `getPaletteNodesFromJS(String jsCode, PaletteNodeCallback callback, String[] globals)`
  Obtain `PaletteNodes` from a JavaScript source representation.
  `void`
  `getPaletteNodesFromXML(String xmlString, PaletteNodeCallback callback)`
  Obtain `PaletteNodes` from an XML representation, but do not add them to the EditContext.
  `Boolean`
  `getPersistCoordinates()`
  When enabled, changes to a `liveObject`'s position and size will be persisted to their `EditNodes` by default.
  `PaletteNode`
  `getRootComponent()`
  Root of data to edit.
  `EditNode`
  `getRootEditNode()`
  Returns the root `EditNode` of the EditContext typically created from `rootComponent`.
  `SelectedAppearance`
  `getSelectedAppearance()`
  Appearance that is applied to selected component.
  `String`
  `getSelectedBorder()`
  Set the CSS border to be applied to the selection outline of the selected components.
  `EditNode`
  `getSelectedEditNode()`
  Returns selected EditNode or first selected EditNode if multiple nodes are selected.
  `EditNode[]`
  `getSelectedEditNodes()`
  Returns all selected EditNodes as an Array.
  `String`
  `getSelectedLabelBackgroundColor()`
  The background color for the selection outline label.
  `String`
  `getSelectedTintColor()`
  Mask color applied to `editMask` of selected component when `EditProxy.selectedAppearance` is "tintMask".
  `int`
  `getSelectedTintOpacity()`
  Opacity applied to `editMask` of selected component when `EditProxy.selectedAppearance` is "tintMask".
  `SelectionStyle`
  `getSelectionType()`
  Defines selection behavior when in edit mode.
  `Boolean`
  `getShowSelectedLabel()`
  Should the selection outline show a label for selected components? A component may also be highlighted with the selection outline and label to indicate the target of a drop.
  `Boolean`
  `getShowSelectedLabelOnSelect()`
  Should the selection outline show a label when the component is selected? This property is similar to `showSelectedLabel`.
  `Boolean`
  `getUseCopyPasteShortcuts()`
  If set, auto-enables `EditProxy.useCopyPasteShortcuts` on the `EditProxy` for the `root editNode`.
  `void`
  `inlineEditorShowing(FormItem field, String type)`
  Notification method fired when an inline title or value editor is shown or closed for a component in the designer pane.
  `boolean`
  `isCreated()`
  `boolean`
  `isEditNodeSelected()`
  Returns true if the editNode is selected.
  `boolean`
  `isNodeEditingOn(EditNode editNode)`
  Returns true if `editNode` is in edit mode.
  `EditNode`
  `makeEditNode(PaletteNode paletteNode)`
  Creates and returns an EditNode using the `defaultPalette`.
  `PaletteNode`
  `makePaletteNode(EditNode editNode)`
  Creates a `PaletteNode` from an `EditNode` in this context's `editNodeTree`.
  `Tree`
  `makePaletteNodeTree(EditNode editNode, Boolean removeAutoIDs)`
  Creates a `Tree` of `PaletteNodes` from an `EditNode` in this context's `editNodeTree`, by using `makePaletteNode()` on the passed `EditNode` and its descendents within the `editNodeTree`.
  `void`
  `nodeMoved(EditNode oldNode, EditNode oldParentNode, EditNode newNode, EditNode newParentNode, EditNode rootNode)`
  Notification fired when an `EditNode` has been moved to a new position in the component tree.
  `void`
  `nodeRemoved(EditNode removedNode, EditNode parentNode, EditNode rootNode)`
  Notification fired when an `EditNode` has been removed from the EditContext
  `void`
  `pasteEditNodes()`
  "Pastes" `editNodes` previously captured via `copyEditNodes()`.
  `void`
  `pasteEditNodes(EditNode targetEditNode)`
  "Pastes" `editNodes` previously captured via `copyEditNodes()`.
  `void`
  `removeAll()`
  Removes all `EditNodes` from the EditContext, but does not destroy the `liveObjects`.
  `void`
  `removeNode(EditNode editNode)`
  Removes `EditNode` from the EditContext.
  `void`
  `removeNodeProperties(EditNode editNode, String[] properties)`
  Removes the specified properties from an editNode's serializable "defaults".
  `void`
  `reorderNode(EditNode parentNode, Integer index, Integer moveToIndex)`
  Moves an `EditNode` from one child index to another in the EditContext under the specified parent.
  `void`
  `selectAllEditNodes()`
  Select all EditNodes.
  `void`
  `selectEditNode(EditNode editNode)`
  Select an EditNode.
  `void`
  `selectSingleEditNode(EditNode editNode)`
  Select a single EditNode and deselect everything else.
  `String`
  `serializeAllEditNodes()`
  Serialize the tree of `EditNodes` to an XML representation of `PaletteNodes`.
  `String`
  `serializeAllEditNodes(SerializationSettings settings)`
  Serialize the tree of `EditNodes` to an XML representation of `PaletteNodes`.
  `String`
  `serializeAllEditNodesAsJSON()`
  Encode the tree of `EditNodes` to a JSON representation of `PaletteNodes`.
  `String`
  `serializeAllEditNodesAsJSON(SerializationSettings settings)`
  Encode the tree of `EditNodes` to a JSON representation of `PaletteNodes`.
  `String`
  `serializeEditNodes(EditNode[] nodes)`
  Serialize the provided `EditNodes` to an XML representation of `PaletteNodes`.
  `String`
  `serializeEditNodes(EditNode[] nodes, SerializationSettings settings)`
  Serialize the provided `EditNodes` to an XML representation of `PaletteNodes`.
  `String`
  `serializeEditNodesAsJSON(EditNode[] nodes)`
  Serialize the provided `EditNodes` to a JSON representation of `PaletteNodes`.
  `String`
  `serializeEditNodesAsJSON(EditNode[] nodes, SerializationSettings settings)`
  Serialize the provided `EditNodes` to a JSON representation of `PaletteNodes`.
  `EditContext`
  `setAllowDropThrough(Boolean allowDropThrough)`
  Dropping a component near the edge of another component allows the component to be dropped through an ancestor component.
  `EditContext`
  `setAllowNestedDrops(Boolean allowNestedDrops)`
  Controls whether components can be dropped into other components which support child components.
  `EditContext`
  `setAutoEditNewNodes(Boolean autoEditNewNodes)`
  New nodes added to the editContext are automatically placed into edit mode if the new node's parent is in edit mode.
  `EditContext`
  `setCanDragGroup(Boolean canDragGroup)`
  Should the group selection box shown when `canGroupSelect` is true allow dragging the group as a whole?
  `EditContext`
  `setCanGroupSelect(Boolean canGroupSelect)`
  Should a group selection outline covering the outermost bounding boxes of all selected components be shown in this container?
  `EditContext`
  `setCanSelectEditNodes(Boolean canSelectEditNodes)`
  Should editNodes added to this EditContext be selectable? When `true`, each `EditProxy.canSelectChildren` property is enabled unless explicitly set to `false`.
  `EditContext`
  `setDefaultPalette(Palette defaultPalette)`
  `Palette` to use when an `EditNode` is being created directly by this EditContext, instead of being created due to a user interaction with a palette (eg dragging from a `TreePalette`, or clicking on `MenuPalette`).
  `EditContext`
  `setDefaultParent(EditNode defaultParent)`
  The default parent `EditNode` to be used when a new EditNode is added to the EditContext without a specified parent.
  `EditContext`
  `setEditMaskProperties(Map editMaskProperties)`
  Properties to apply to all `EditProxy.editMask`s created for components in edit mode.
  `void`
  `setEditProxyProperties(EditNode editNode, EditProxy properties)`
  Update an editNode's `EditProxy` properties.
  `EditContext`
  `setEnableInlineEdit(Boolean enableInlineEdit)`
  Whether inline editing should be enabled for any components that are added and are placed into editMode.
  `EditContext`
  `setExtraPalettes(Palette... extraPalettes)`
  Additional `Palettes` to consult for metadata when deserializing `Edit Nodes`.
  `EditContext`
  `setHideGroupBorderOnDrag(Boolean hideGroupBorderOnDrag)`
  Should the group selection box shown when `canGroupSelect` is true be hidden during drag?
  `EditContext`
  `setHoopSelectionMode(HoopSelectionStyle hoopSelectionMode)`
  Defines the mode of inclusion for components encountered during hoop selection which is enabled when `selectionType` is `multiple`.
  `EditContext`
  `setHoopSelectorProperties(Map hoopSelectorProperties)`
  Properties to apply to `EditProxy.hoopSelector`.
  `void`
  `setJavaScriptObject(JavaScriptObject jsObj)`
  `protected void`
  `setNodeProperties(EditNode editNode, JavaScriptObject properties)`
  `protected void`
  `setNodeProperties(EditNode editNode, JavaScriptObject properties, Boolean skipLiveObjectUpdate)`
  `void`
  `setNodeProperties(EditNode editNode, Canvas properties)`
  Update an editNode's serializable "defaults" with the supplied properties.
  `void`
  `setNodeProperties(EditNode editNode, Canvas properties, Boolean skipLiveObjectUpdate)`
  Update an editNode's serializable "defaults" with the supplied properties.
  `void`
  `setNodeProperties(EditNode editNode, DrawItem properties)`
  Update an editNode's serializable "defaults" with the supplied properties.
  `void`
  `setNodeProperties(EditNode editNode, DrawItem properties, Boolean skipLiveObjectUpdate)`
  Update an editNode's serializable "defaults" with the supplied properties.
  `EditContext`
  `setPersistCoordinates(Boolean persistCoordinates)`
  When enabled, changes to a `liveObject`'s position and size will be persisted to their `EditNodes` by default.
  `EditContext`
  `setRootComponent(PaletteNode rootComponent)`
  Root of data to edit.
  `EditContext`
  `setSelectedAppearance(SelectedAppearance selectedAppearance)`
  Appearance that is applied to selected component.
  `EditContext`
  `setSelectedBorder(String selectedBorder)`
  Set the CSS border to be applied to the selection outline of the selected components.
  `EditContext`
  `setSelectedLabelBackgroundColor(String selectedLabelBackgroundColor)`
  The background color for the selection outline label.
  `EditContext`
  `setSelectedTintColor(String selectedTintColor)`
  Mask color applied to `editMask` of selected component when `EditProxy.selectedAppearance` is "tintMask".
  `EditContext`
  `setSelectedTintOpacity(int selectedTintOpacity)`
  Opacity applied to `editMask` of selected component when `EditProxy.selectedAppearance` is "tintMask".
  `EditContext`
  `setSelectionType(SelectionStyle selectionType)`
  Defines selection behavior when in edit mode.
  `EditContext`
  `setShowSelectedLabel(Boolean showSelectedLabel)`
  Should the selection outline show a label for selected components? A component may also be highlighted with the selection outline and label to indicate the target of a drop.
  `EditContext`
  `setShowSelectedLabelOnSelect(Boolean showSelectedLabelOnSelect)`
  Should the selection outline show a label when the component is selected? This property is similar to `showSelectedLabel`.
  `EditContext`
  `setUseCopyPasteShortcuts(Boolean useCopyPasteShortcuts)`
  If set, auto-enables `EditProxy.useCopyPasteShortcuts` on the `EditProxy` for the `root editNode`.
  `void`
  `substitutedNode(PaletteNode origNode, PaletteNode newNode, EditNode parentNode)`
  Notification fired when a different `PaletteNode` is substituted for one being dropped into a container.

  ### Methods inherited from class com.smartgwt.client.core.BaseClass

  `addDynamicProperty, addDynamicProperty, addDynamicProperty, addDynamicProperty, applyFactoryProperties, asSGWTComponent, clearDynamicProperty, createJsObj, destroy, doAddHandler, doInit, error, error, errorIfNotCreated, fireEvent, getAttribute, getAttributeAsBoolean, getAttributeAsDate, getAttributeAsDouble, getAttributeAsElement, getAttributeAsFloat, getAttributeAsInt, getAttributeAsJavaScriptObject, getAttributeAsMap, getAttributeAsString, getAttributeAsStringArray, getClassName, getConfig, getHandlerCount, getID, getRef, getRuleScope, getScClassName, getTestInstance, hasAutoAssignedID, hasDynamicProperty, internalSetID, internalSetID, isConfigOnly, isFactoryCreated, onBind, onInit, registerID, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setAttribute, setConfig, setConfigOnly, setFactoryCreated, setID, setProperty, setProperty, setProperty, setProperty, setRuleScope, setScClassName`

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

  ### Methods inherited from interface com.google.gwt.event.shared.HasHandlers

  `fireEvent`

- ## Constructor Details

  - ### EditContext

    public EditContext()

  - ### EditContext

    public EditContext(JavaScriptObject jsObj)

- ## Method Details

  - ### getOrCreateRef

    public static EditContext getOrCreateRef(JavaScriptObject jsObj)

  - ### setJavaScriptObject

    public void setJavaScriptObject(JavaScriptObject jsObj)
    Overrides:
      `setJavaScriptObject` in class `BaseClass`

  - ### create

    public JavaScriptObject create()
    Specified by:
      `create` in class `BaseClass`

  - ### isCreated

    public boolean isCreated()
    Overrides:
      `isCreated` in class `BaseClass`

  - ### getJsObj

    public JavaScriptObject getJsObj()
    Overrides:
      `getJsObj` in class `BaseClass`

  - ### getOrCreateJsObj

    public JavaScriptObject getOrCreateJsObj()
    Overrides:
      `getOrCreateJsObj` in class `BaseClass`

  - ### setAllowDropThrough

    public EditContext setAllowDropThrough(Boolean allowDropThrough)
    Dropping a component near the edge of another component allows the component to be dropped through an ancestor component. To suppress this action set `allowDropThrough` to false.
    Parameters:
      `allowDropThrough` - New allowDropThrough value. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls

  - ### getAllowDropThrough

    public Boolean getAllowDropThrough()
    Dropping a component near the edge of another component allows the component to be dropped through an ancestor component. To suppress this action set `allowDropThrough` to false.
    Returns:
      Current allowDropThrough value. Default value is null

  - ### setAllowNestedDrops

    public EditContext setAllowNestedDrops(Boolean allowNestedDrops) throws IllegalStateException
    Controls whether components can be dropped into other components which support child components.

    When enabled, during a drop interaction in which a `PaletteNode` or `EditNode` is the drop data, the `Component Schema` of the current candidate drop target is inspected to see whether that parent allows children of the type being dropped. If it does, the drop will result in a call to `addNode()` for a paletteNode or for an existing `EditNode` in the same tree.

    Specific components can disable nested drops by explicitly setting `EditProxy.allowNestedDrops` to false.

    This mode is enabled by default unless explicitly disabled by setting this property to false.

    Parameters:
      `allowNestedDrops` - New allowNestedDrops value. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls
    Throws:
      `IllegalStateException` - this property cannot be changed after the underlying component has been created

  - ### getAllowNestedDrops

    public Boolean getAllowNestedDrops()
    Controls whether components can be dropped into other components which support child components.

    When enabled, during a drop interaction in which a `PaletteNode` or `EditNode` is the drop data, the `Component Schema` of the current candidate drop target is inspected to see whether that parent allows children of the type being dropped. If it does, the drop will result in a call to `addNode()` for a paletteNode or for an existing `EditNode` in the same tree.

    Specific components can disable nested drops by explicitly setting `EditProxy.allowNestedDrops` to false.

    This mode is enabled by default unless explicitly disabled by setting this property to false.

    Returns:
      Current allowNestedDrops value. Default value is null

  - ### setAutoEditNewNodes

    public EditContext setAutoEditNewNodes(Boolean autoEditNewNodes)
    New nodes added to the editContext are automatically placed into edit mode if the new node's parent is in edit mode. To suppress this action set `autoEditNewNodes` to false.
    Parameters:
      `autoEditNewNodes` - New autoEditNewNodes value. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls

  - ### getAutoEditNewNodes

    public Boolean getAutoEditNewNodes()
    New nodes added to the editContext are automatically placed into edit mode if the new node's parent is in edit mode. To suppress this action set `autoEditNewNodes` to false.
    Returns:
      Current autoEditNewNodes value. Default value is null

  - ### setCanDragGroup

    public EditContext setCanDragGroup(Boolean canDragGroup) throws IllegalStateException
    Should the group selection box shown when `canGroupSelect` is true allow dragging the group as a whole?

    Treated as `true` if not set and `canGroupSelect` is true.

    Parameters:
      `canDragGroup` - New canDragGroup value. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls
    Throws:
      `IllegalStateException` - this property cannot be changed after the underlying component has been created

  - ### getCanDragGroup

    public Boolean getCanDragGroup()
    Should the group selection box shown when `canGroupSelect` is true allow dragging the group as a whole?

    Treated as `true` if not set and `canGroupSelect` is true.

    Returns:
      Current canDragGroup value. Default value is null

  - ### setCanGroupSelect

    public EditContext setCanGroupSelect(Boolean canGroupSelect) throws IllegalStateException
    Should a group selection outline covering the outermost bounding boxes of all selected components be shown in this container?

    Treated as `true` if not set and hoop selection is enabled (see `EditProxy.canSelectChildren` and `selectionType`.

    Parameters:
      `canGroupSelect` - New canGroupSelect value. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls
    Throws:
      `IllegalStateException` - this property cannot be changed after the underlying component has been created

  - ### getCanGroupSelect

    public Boolean getCanGroupSelect()
    Should a group selection outline covering the outermost bounding boxes of all selected components be shown in this container?

    Treated as `true` if not set and hoop selection is enabled (see `EditProxy.canSelectChildren` and `selectionType`.

    Returns:
      Current canGroupSelect value. Default value is null

  - ### setCanSelectEditNodes

    public EditContext setCanSelectEditNodes(Boolean canSelectEditNodes) throws IllegalStateException
    Should editNodes added to this EditContext be selectable? When `true`, each `EditProxy.canSelectChildren` property is enabled unless explicitly set to `false`. This allows an individual component to override this setting.
    Parameters:
      `canSelectEditNodes` - New canSelectEditNodes value. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls
    Throws:
      `IllegalStateException` - this property cannot be changed after the underlying component has been created

  - ### getCanSelectEditNodes

    public Boolean getCanSelectEditNodes()
    Should editNodes added to this EditContext be selectable? When `true`, each `EditProxy.canSelectChildren` property is enabled unless explicitly set to `false`. This allows an individual component to override this setting.
    Returns:
      Current canSelectEditNodes value. Default value is null

  - ### setDefaultPalette

    public EditContext setDefaultPalette(Palette defaultPalette)
    `Palette` to use when an `EditNode` is being created directly by this EditContext, instead of being created due to a user interaction with a palette (eg dragging from a `TreePalette`, or clicking on `MenuPalette`).

    If no defaultPalette is provided, the EditContext uses an automatically created `HiddenPalette`.
    If this method is called after the component has been drawn/initialized: `Palette` to use when an `EditNode` is being created directly by this EditContext, instead of being created due to a user interaction with a palette (eg dragging from a `TreePalette`, or clicking on `MenuPalette`).

    If no defaultPalette is provided, the EditContext uses an automatically created `HiddenPalette`.

    Parameters:
      `defaultPalette` - the default Palette. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls

  - ### getDefaultPalette

    public Palette getDefaultPalette()
    `Palette` to use when an `EditNode` is being created directly by this EditContext, instead of being created due to a user interaction with a palette (eg dragging from a `TreePalette`, or clicking on `MenuPalette`).

    If no defaultPalette is provided, the EditContext uses an automatically created `HiddenPalette`.

    Returns:
      `Palette` to use when an `EditNode` is being created directly by this EditContext, instead of being created due to a user interaction with a palette (eg dragging from a `TreePalette`, or clicking on `MenuPalette`).

      If no defaultPalette is provided, the EditContext uses an automatically created `HiddenPalette`. Default value is null

  - ### setDefaultParent

    public EditContext setDefaultParent(EditNode defaultParent)
    The default parent `EditNode` to be used when a new EditNode is added to the EditContext without a specified parent. This commonly occurs when a paletteNode is double-clicked in a palette.

    If not specified, the root editNode (see `getRootEditNode()`) is used.

    Note: this property is automatically cleared if node is removed from the editTree such as on calls to `destroyAll()` or `removeNode()`.

    Parameters:
      `defaultParent` - New defaultParent value. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls

  - ### getDefaultParent

    public EditNode getDefaultParent()
    The default parent `EditNode` to be used when a new EditNode is added to the EditContext without a specified parent. This commonly occurs when a paletteNode is double-clicked in a palette.

    If not specified, the root editNode (see `getRootEditNode()`) is used.

    Note: this property is automatically cleared if node is removed from the editTree such as on calls to `destroyAll()` or `removeNode()`.

    Returns:
      Current defaultParent value. Default value is null

  - ### setEditMaskProperties

    public EditContext setEditMaskProperties(Map editMaskProperties) throws IllegalStateException
    Properties to apply to all `EditProxy.editMask`s created for components in edit mode. This mask can be modified when the node is selected by `selectedBorder`, `selectedTintColor` and `selectedTintOpacity` depending on the `selectedAppearance` setting.
    Parameters:
      `editMaskProperties` - New editMaskProperties value. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls
    Throws:
      `IllegalStateException` - this property cannot be changed after the underlying component has been created

  - ### getEditMaskProperties

    public Map getEditMaskProperties()
    Properties to apply to all `EditProxy.editMask`s created for components in edit mode. This mask can be modified when the node is selected by `selectedBorder`, `selectedTintColor` and `selectedTintOpacity` depending on the `selectedAppearance` setting.
    Returns:
      Current editMaskProperties value. Default value is null

  - ### setEnableInlineEdit

    public EditContext setEnableInlineEdit(Boolean enableInlineEdit) throws IllegalStateException
    Whether inline editing should be enabled for any components that are added and are placed into editMode. Enabling this will turn on inline edit for any EditProxy where `EditProxy.supportsInlineEdit` is true.
    Parameters:
      `enableInlineEdit` - New enableInlineEdit value. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls
    Throws:
      `IllegalStateException` - this property cannot be changed after the underlying component has been created

  - ### getEnableInlineEdit

    public Boolean getEnableInlineEdit()
    Whether inline editing should be enabled for any components that are added and are placed into editMode. Enabling this will turn on inline edit for any EditProxy where `EditProxy.supportsInlineEdit` is true.
    Returns:
      Current enableInlineEdit value. Default value is null

  - ### setExtraPalettes

    public EditContext setExtraPalettes(Palette... extraPalettes)
    Additional `Palettes` to consult for metadata when deserializing `Edit Nodes`. Note that the `defaultPalette` is always consulted and need not be provided again here.
    Parameters:
      `extraPalettes` - New extraPalettes value. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls

  - ### getExtraPalettes

    public Palette[] getExtraPalettes()
    Additional `Palettes` to consult for metadata when deserializing `Edit Nodes`. Note that the `defaultPalette` is always consulted and need not be provided again here.
    Returns:
      Current extraPalettes value. Default value is null

  - ### setHideGroupBorderOnDrag

    public EditContext setHideGroupBorderOnDrag(Boolean hideGroupBorderOnDrag) throws IllegalStateException
    Should the group selection box shown when `canGroupSelect` is true be hidden during drag?

    Treated as `true` if not explicitly set to false.

    Parameters:
      `hideGroupBorderOnDrag` - New hideGroupBorderOnDrag value. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls
    Throws:
      `IllegalStateException` - this property cannot be changed after the underlying component has been created

  - ### getHideGroupBorderOnDrag

    public Boolean getHideGroupBorderOnDrag()
    Should the group selection box shown when `canGroupSelect` is true be hidden during drag?

    Treated as `true` if not explicitly set to false.

    Returns:
      Current hideGroupBorderOnDrag value. Default value is null

  - ### setHoopSelectionMode

    public EditContext setHoopSelectionMode(HoopSelectionStyle hoopSelectionMode) throws IllegalStateException
    Defines the mode of inclusion for components encountered during hoop selection which is enabled when `selectionType` is `multiple`. `encloses` mode causes selection of components that are completely enclosed by the hoop. `intersects` mode selects components that come into contact with the hoop.
    Parameters:
      `hoopSelectionMode` - New hoopSelectionMode value. Default value is "encloses"
    Returns:
      `EditContext` instance, for chaining setter calls
    Throws:
      `IllegalStateException` - this property cannot be changed after the underlying component has been created
    See Also:
      - `HoopSelectionStyle`

  - ### getHoopSelectionMode

    public HoopSelectionStyle getHoopSelectionMode()
    Defines the mode of inclusion for components encountered during hoop selection which is enabled when `selectionType` is `multiple`. `encloses` mode causes selection of components that are completely enclosed by the hoop. `intersects` mode selects components that come into contact with the hoop.
    Returns:
      Current hoopSelectionMode value. Default value is "encloses"
    See Also:
      - `HoopSelectionStyle`

  - ### setHoopSelectorProperties

    public EditContext setHoopSelectorProperties(Map hoopSelectorProperties) throws IllegalStateException
    Properties to apply to `EditProxy.hoopSelector`.
    Parameters:
      `hoopSelectorProperties` - New hoopSelectorProperties value. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls
    Throws:
      `IllegalStateException` - this property cannot be changed after the underlying component has been created

  - ### getHoopSelectorProperties

    public Map getHoopSelectorProperties()
    Properties to apply to `EditProxy.hoopSelector`.
    Returns:
      Current hoopSelectorProperties value. Default value is null

  - ### setPersistCoordinates

    public EditContext setPersistCoordinates(Boolean persistCoordinates)
    When enabled, changes to a `liveObject`'s position and size will be persisted to their `EditNodes` by default. This applies to both programmatic calls and user interaction (drag reposition or drag resize).

    This feature can be disabled by either setting this property or `EditProxy.persistCoordinates` to `false`. This property affects all nodes within the EditContext whereas the latter property affects children of a single node.

    In some use-cases, like Reify, coordinates should not be persisted except when a component explicitly enables this feature. By setting this property to `null` no component will persist coordinates of children unless `EditProxy.persistCoordinates` is explicitly set to `true`.

    Parameters:
      `persistCoordinates` - New persistCoordinates value. Default value is true
    Returns:
      `EditContext` instance, for chaining setter calls

  - ### getPersistCoordinates

    public Boolean getPersistCoordinates()
    When enabled, changes to a `liveObject`'s position and size will be persisted to their `EditNodes` by default. This applies to both programmatic calls and user interaction (drag reposition or drag resize).

    This feature can be disabled by either setting this property or `EditProxy.persistCoordinates` to `false`. This property affects all nodes within the EditContext whereas the latter property affects children of a single node.

    In some use-cases, like Reify, coordinates should not be persisted except when a component explicitly enables this feature. By setting this property to `null` no component will persist coordinates of children unless `EditProxy.persistCoordinates` is explicitly set to `true`.

    Returns:
      Current persistCoordinates value. Default value is true

  - ### setRootComponent

    public EditContext setRootComponent(PaletteNode rootComponent) throws IllegalStateException
    Root of data to edit. Must contain the "type" property, with the name of a valid `schema` or nothing will be able to be dropped on this EditContext. A "liveObject" property representing the rootComponent is also suggested. Otherwise, a live object will be created from the palette node.

    Can be retrieved at any time. Use `getRootEditNode()` to retrieve the `EditNode` created from the rootComponent.

    Parameters:
      `rootComponent` - New rootComponent value. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls
    Throws:
      `IllegalStateException` - this property cannot be changed after the underlying component has been created
    See Also:
      - `Dashboards & Tools Framework Overview`

  - ### getRootComponent

    public PaletteNode getRootComponent()
    Root of data to edit. Must contain the "type" property, with the name of a valid `schema` or nothing will be able to be dropped on this EditContext. A "liveObject" property representing the rootComponent is also suggested. Otherwise, a live object will be created from the palette node.

    Can be retrieved at any time. Use `getRootEditNode()` to retrieve the `EditNode` created from the rootComponent.

    Returns:
      Current rootComponent value. Default value is null
    See Also:
      - `Dashboards & Tools Framework Overview`

  - ### setSelectedAppearance

    public EditContext setSelectedAppearance(SelectedAppearance selectedAppearance) throws IllegalStateException
    Appearance that is applied to selected component.

    This value is applied as a default to `EditProxy.selectedAppearance`.

    Parameters:
      `selectedAppearance` - New selectedAppearance value. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls
    Throws:
      `IllegalStateException` - this property cannot be changed after the underlying component has been created
    See Also:
      - `setSelectedBorder(java.lang.String)`
      - `setSelectedTintColor(java.lang.String)`
      - `setSelectedTintOpacity(int)`

  - ### getSelectedAppearance

    public SelectedAppearance getSelectedAppearance()
    Appearance that is applied to selected component.

    This value is applied as a default to `EditProxy.selectedAppearance`.

    Returns:
      Current selectedAppearance value. Default value is null
    See Also:
      - `getSelectedBorder()`
      - `getSelectedTintColor()`
      - `getSelectedTintOpacity()`

  - ### setSelectedBorder

    public EditContext setSelectedBorder(String selectedBorder) throws IllegalStateException
    Set the CSS border to be applied to the selection outline of the selected components. This property is used when `EditProxy.selectedAppearance` is `outlineMask` or `outlineEdges`.

    This value is applied as a default to `EditProxy.selectedBorder`.

    Parameters:
      `selectedBorder` - New selectedBorder value. Default value is "1px dashed #44ff44"
    Returns:
      `EditContext` instance, for chaining setter calls
    Throws:
      `IllegalStateException` - this property cannot be changed after the underlying component has been created

  - ### getSelectedBorder

    public String getSelectedBorder()
    Set the CSS border to be applied to the selection outline of the selected components. This property is used when `EditProxy.selectedAppearance` is `outlineMask` or `outlineEdges`.

    This value is applied as a default to `EditProxy.selectedBorder`.

    Returns:
      Current selectedBorder value. Default value is "1px dashed #44ff44"

  - ### setSelectedLabelBackgroundColor

    public EditContext setSelectedLabelBackgroundColor(String selectedLabelBackgroundColor) throws IllegalStateException
    The background color for the selection outline label. The default is defined on `SelectionOutline`.

    This value is applied as a default to `EditProxy.selectedLabelBackgroundColor`.

    NOTE: A selected component label is only supported when `EditProxy.selectedAppearance` is "outlineEdges".

    Parameters:
      `selectedLabelBackgroundColor` - New selectedLabelBackgroundColor value. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls
    Throws:
      `IllegalStateException` - this property cannot be changed after the underlying component has been created
    See Also:
      - `setShowSelectedLabel(java.lang.Boolean)`

  - ### getSelectedLabelBackgroundColor

    public String getSelectedLabelBackgroundColor()
    The background color for the selection outline label. The default is defined on `SelectionOutline`.

    This value is applied as a default to `EditProxy.selectedLabelBackgroundColor`.

    NOTE: A selected component label is only supported when `EditProxy.selectedAppearance` is "outlineEdges".

    Returns:
      Current selectedLabelBackgroundColor value. Default value is null
    See Also:
      - `getShowSelectedLabel()`

  - ### setSelectedTintColor

    public EditContext setSelectedTintColor(String selectedTintColor) throws IllegalStateException
    Mask color applied to `editMask` of selected component when `EditProxy.selectedAppearance` is "tintMask".

    This value is applied as a default to `EditProxy.selectedTintColor`.

    Parameters:
      `selectedTintColor` - New selectedTintColor value. Default value is "#cccccc"
    Returns:
      `EditContext` instance, for chaining setter calls
    Throws:
      `IllegalStateException` - this property cannot be changed after the underlying component has been created
    See Also:
      - `setSelectedTintOpacity(int)`
      - `CSSColor`

  - ### getSelectedTintColor

    public String getSelectedTintColor()
    Mask color applied to `editMask` of selected component when `EditProxy.selectedAppearance` is "tintMask".

    This value is applied as a default to `EditProxy.selectedTintColor`.

    Returns:
      Current selectedTintColor value. Default value is "#cccccc"
    See Also:
      - `getSelectedTintOpacity()`
      - `CSSColor`

  - ### setSelectedTintOpacity

    public EditContext setSelectedTintOpacity(int selectedTintOpacity) throws IllegalStateException
    Opacity applied to `editMask` of selected component when `EditProxy.selectedAppearance` is "tintMask".

    This value is applied as a default to `EditProxy.selectedTintOpacity`.

    Parameters:
      `selectedTintOpacity` - New selectedTintOpacity value. Default value is 25
    Returns:
      `EditContext` instance, for chaining setter calls
    Throws:
      `IllegalStateException` - this property cannot be changed after the underlying component has been created
    See Also:
      - `setSelectedTintColor(java.lang.String)`

  - ### getSelectedTintOpacity

    public int getSelectedTintOpacity()
    Opacity applied to `editMask` of selected component when `EditProxy.selectedAppearance` is "tintMask".

    This value is applied as a default to `EditProxy.selectedTintOpacity`.

    Returns:
      Current selectedTintOpacity value. Default value is 25
    See Also:
      - `getSelectedTintColor()`

  - ### setSelectionType

    public EditContext setSelectionType(SelectionStyle selectionType)
    Defines selection behavior when in edit mode. Only two styles are supported: "single" and "multiple". Multiple enables hoop selection.
    Parameters:
      `selectionType` - New selectionType value. Default value is "multiple"
    Returns:
      `EditContext` instance, for chaining setter calls
    See Also:
      - `SelectionStyle`

  - ### getSelectionType

    public SelectionStyle getSelectionType()
    Defines selection behavior when in edit mode. Only two styles are supported: "single" and "multiple". Multiple enables hoop selection.
    Returns:
      Current selectionType value. Default value is "multiple"
    See Also:
      - `SelectionStyle`

  - ### setShowSelectedLabel

    public EditContext setShowSelectedLabel(Boolean showSelectedLabel) throws IllegalStateException
    Should the selection outline show a label for selected components? A component may also be highlighted with the selection outline and label to indicate the target of a drop. To suppress showing a label at any time set this property to `false`.

    To suppress labels during selection but still show them when targeted for a drop, see `showSelectedLabelOnSelect`.

    NOTE: A selected component label is only supported when `EditProxy.selectedAppearance` is "outlineEdges".

    Parameters:
      `showSelectedLabel` - New showSelectedLabel value. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls
    Throws:
      `IllegalStateException` - this property cannot be changed after the underlying component has been created

  - ### getShowSelectedLabel

    public Boolean getShowSelectedLabel()
    Should the selection outline show a label for selected components? A component may also be highlighted with the selection outline and label to indicate the target of a drop. To suppress showing a label at any time set this property to `false`.

    To suppress labels during selection but still show them when targeted for a drop, see `showSelectedLabelOnSelect`.

    NOTE: A selected component label is only supported when `EditProxy.selectedAppearance` is "outlineEdges".

    Returns:
      Current showSelectedLabel value. Default value is null

  - ### setShowSelectedLabelOnSelect

    public EditContext setShowSelectedLabelOnSelect(Boolean showSelectedLabelOnSelect) throws IllegalStateException
    Should the selection outline show a label when the component is selected? This property is similar to `showSelectedLabel`. Whereas `showSelectedLabel` controls whether a label is shown at any time, this property allows normal selection to suppress the label but still show a label during the drop process on the target. Leave `showSelectedLabel` unset and set this property to `false`.

    NOTE: A selected component label is only supported when `EditProxy.selectedAppearance` is "outlineEdges".

    Parameters:
      `showSelectedLabelOnSelect` - New showSelectedLabelOnSelect value. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls
    Throws:
      `IllegalStateException` - this property cannot be changed after the underlying component has been created

  - ### getShowSelectedLabelOnSelect

    public Boolean getShowSelectedLabelOnSelect()
    Should the selection outline show a label when the component is selected? This property is similar to `showSelectedLabel`. Whereas `showSelectedLabel` controls whether a label is shown at any time, this property allows normal selection to suppress the label but still show a label during the drop process on the target. Leave `showSelectedLabel` unset and set this property to `false`.

    NOTE: A selected component label is only supported when `EditProxy.selectedAppearance` is "outlineEdges".

    Returns:
      Current showSelectedLabelOnSelect value. Default value is null

  - ### setUseCopyPasteShortcuts

    public EditContext setUseCopyPasteShortcuts(Boolean useCopyPasteShortcuts) throws IllegalStateException
    If set, auto-enables `EditProxy.useCopyPasteShortcuts` on the `EditProxy` for the `root editNode`. This works whether there is currently a root editNode or one is added later.
    Parameters:
      `useCopyPasteShortcuts` - New useCopyPasteShortcuts value. Default value is null
    Returns:
      `EditContext` instance, for chaining setter calls
    Throws:
      `IllegalStateException` - this property cannot be changed after the underlying component has been created

  - ### getUseCopyPasteShortcuts

    public Boolean getUseCopyPasteShortcuts()
    If set, auto-enables `EditProxy.useCopyPasteShortcuts` on the `EditProxy` for the `root editNode`. This works whether there is currently a root editNode or one is added later.
    Returns:
      Current useCopyPasteShortcuts value. Default value is null

  - ### addFromPaletteNode

    public EditNode addFromPaletteNode(PaletteNode paletteNode)
    Creates a new EditNode from a PaletteNode, using the `defaultPalette`. If you have an array of possibly inter-related PaletteNodes, then you should use `addFromPaletteNodes()` on the array instead, in order to preserve the relationships.
    Parameters:
      `paletteNode` - the palette node to use to create the new node
    Returns:
      the EditNode created from the paletteNode
    See Also:
      - `addFromPaletteNodes(com.smartgwt.client.tools.PaletteNode[])`

  - ### addFromPaletteNode

    public EditNode addFromPaletteNode(PaletteNode paletteNode, EditNode parentNode)
    Creates a new EditNode from a PaletteNode, using the `defaultPalette`. If you have an array of possibly inter-related PaletteNodes, then you should use `addFromPaletteNodes()` on the array instead, in order to preserve the relationships.
    Parameters:
      `paletteNode` - the palette node to use to create the new node
      `parentNode` - optional the parent node if the new node should appear under a specific parent
    Returns:
      the EditNode created from the paletteNode
    See Also:
      - `addFromPaletteNodes(com.smartgwt.client.tools.PaletteNode[])`

  - ### addFromPaletteNodes

    public EditNode[] addFromPaletteNodes(PaletteNode[] paletteNodes)
    Add the supplied `PaletteNodes` to the parentNode, preserving internal references from one supplied PaletteNode to another. This method should be used with an array of possibly inter-related PaletteNodes (for instance, those produced as a result of serialization via `serializeAllEditNodes()`) rather than calling `addFromPaletteNode()` on each individual PaletteNode.
    Parameters:
      `paletteNodes` - array of PaletteNodes
    Returns:
      an array of the EditNodes added to the parentNode
    See Also:
      - `addFromPaletteNode(com.smartgwt.client.tools.PaletteNode)`

  - ### addFromPaletteNodes

    public EditNode[] addFromPaletteNodes(PaletteNode[] paletteNodes, EditNode parentNode)
    Add the supplied `PaletteNodes` to the parentNode, preserving internal references from one supplied PaletteNode to another. This method should be used with an array of possibly inter-related PaletteNodes (for instance, those produced as a result of serialization via `serializeAllEditNodes()`) rather than calling `addFromPaletteNode()` on each individual PaletteNode.
    Parameters:
      `paletteNodes` - array of PaletteNodes
      `parentNode` - parent to add to (defaults to the root)
    Returns:
      an array of the EditNodes added to the parentNode
    See Also:
      - `addFromPaletteNode(com.smartgwt.client.tools.PaletteNode)`

  - ### addFromPaletteNodeTree

    public EditNode[] addFromPaletteNodeTree(Tree paletteNodeTree)
    Add the supplied `PaletteNode` tree to the parentNode, preserving internal references from one supplied PaletteNode to another.
    Parameters:
      `paletteNodeTree` - tree of PaletteNodes
    Returns:
      an array of the EditNodes added to the parentNode
    See Also:
      - `addFromPaletteNode(com.smartgwt.client.tools.PaletteNode)`

  - ### addFromPaletteNodeTree

    public EditNode[] addFromPaletteNodeTree(Tree paletteNodeTree, EditNode parentNode)
    Add the supplied `PaletteNode` tree to the parentNode, preserving internal references from one supplied PaletteNode to another.
    Parameters:
      `paletteNodeTree` - tree of PaletteNodes
      `parentNode` - parent to add to (defaults to the root)
    Returns:
      an array of the EditNodes added to the parentNode
    See Also:
      - `addFromPaletteNode(com.smartgwt.client.tools.PaletteNode)`

  - ### addNode

    public EditNode addNode(EditNode newNode)
    Add a new `EditNode` to the EditContext, under the specified parent. If the parentNode is not provided it will be determined from `defaultParent`.

    The EditContext will interrogate the parent and new nodes to determine what field within the parent allows a child of this type, and to find a method to add the newNode's liveObject to the parentNode's liveObject. The new relationship will then be stored in the tree of EditNodes.

    For example, when a Tab is dropped on a TabSet, the field TabSet.tabs is discovered as the correct target field via naming conventions, and the method TabSet.addTab() is likewise discovered as the correct method to add a Tab to a TabSet.

    Parameters:
      `newNode` - new node to be added
    Returns:
      newNodenode added

  - ### addNode

    public EditNode addNode(EditNode newNode, EditNode parentNode)
    See `addNode()`

  - ### addNode

    public EditNode addNode(EditNode newNode, EditNode parentNode, Integer index)
    See `addNode()`

  - ### addNode

    public EditNode addNode(EditNode newNode, EditNode parentNode, Integer index, String parentProperty)
    See `addNode()`

  - ### addNode

    public EditNode addNode(EditNode newNode, EditNode parentNode, Integer index, String parentProperty, Boolean skipParentComponentAdd)
    See `addNode()`

  - ### addNode

    public EditNode addNode(EditNode newNode, EditNode parentNode, Integer index, String parentProperty, Boolean skipParentComponentAdd, Boolean forceSingularFieldReplace)
    Add a new `EditNode` to the EditContext, under the specified parent. If the parentNode is not provided it will be determined from `defaultParent`.

    The EditContext will interrogate the parent and new nodes to determine what field within the parent allows a child of this type, and to find a method to add the newNode's liveObject to the parentNode's liveObject. The new relationship will then be stored in the tree of EditNodes.

    For example, when a Tab is dropped on a TabSet, the field TabSet.tabs is discovered as the correct target field via naming conventions, and the method TabSet.addTab() is likewise discovered as the correct method to add a Tab to a TabSet.

    Parameters:
      `newNode` - new node to be added
      `parentNode` - parent to add the new node under.
      `index` - index within the parent's children array
      `parentProperty` - the property of the liveParent to which the new node should be added, if not auto-discoverable from the schema
      `skipParentComponentAdd` - whether to skip adding the liveObject to the liveParent (default false)
      `forceSingularFieldReplace` - whether to replace existing single field node if newNode liveObject is the same (default false)
    Returns:
      newNodenode added

  - ### addPaletteNodeFormItemConstructors

    public void addPaletteNodeFormItemConstructors(Tree nodeTree)
    Add `PaletteNode` constructors for the specific type of `FormItem` that will be created to the paletteNodes in the specified tree created by `createPaletteNodeTree()`.

    Normally, the specific FormItem is applied from the DataSource and DataBoundComponent at time of use but there are times when having the explicit constructor on the paletteNodes is helpful such as for validation or serialization.

    Note that the paletteNodes are updated in place.

    Parameters:
      `nodeTree` - tree of PaletteNodes

  - ### addPaletteNodesFromJS

    public void addPaletteNodesFromJS(String jsCode)
    Add `PaletteNodes` from a JavaScript source representation.

    By default, components that have `global IDs` will not actually be allowed to take those global IDs - instead, only widgets that have one of the global IDs passed as the `globals` parameter will actually receive their global IDs. To override this behavior, pass the special value `ALL_GLOBALS` for the `globals` parameter.

    Parameters:
      `jsCode` - JavaScript code to eval.

  - ### addPaletteNodesFromJS

    public void addPaletteNodesFromJS(String jsCode, EditNode parentNode)
    See `addPaletteNodesFromJS()`

  - ### addPaletteNodesFromJS

    public void addPaletteNodesFromJS(String jsCode, EditNode parentNode, String[] globals)
    Add `PaletteNodes` from a JavaScript source representation.

    By default, components that have `global IDs` will not actually be allowed to take those global IDs - instead, only widgets that have one of the global IDs passed as the `globals` parameter will actually receive their global IDs. To override this behavior, pass the special value `ALL_GLOBALS` for the `globals` parameter.

    Parameters:
      `jsCode` - JavaScript code to eval.
      `parentNode` - parent node (defaults to the root)
      `globals` - widgets to allow to take their global IDs

  - ### addPaletteNodesFromJSON

    public void addPaletteNodesFromJSON(String jsonString)
    Recreate `EditNodes` from a JSON representation of `PaletteNodes` (possibly created by calling `serializeAllEditNodesAsJSON()` or `serializeEditNodesAsJSON()`.

    By default, components that have `global IDs` will not actually be allowed to take those global IDs - instead, only widgets that have one of the global IDs passed as the `globals` parameter will actually receive their global IDs. To override this behavior, pass the special value `ALL_GLOBALS` for the `globals` parameter.

    Parameters:
      `jsonString` - JSON string representing an array of PaletteNodes
    See Also:
      - `addFromPaletteNodes(com.smartgwt.client.tools.PaletteNode[])`
      - `serializeAllEditNodesAsJSON()`
      - `serializeEditNodesAsJSON(com.smartgwt.client.tools.EditNode[])`

  - ### addPaletteNodesFromJSON

    public void addPaletteNodesFromJSON(String jsonString, EditNode parentNode)
    See `addPaletteNodesFromJSON()`

  - ### addPaletteNodesFromJSON

    public void addPaletteNodesFromJSON(String jsonString, EditNode parentNode, String[] globals)
    See `addPaletteNodesFromJSON()`

  - ### addPaletteNodesFromJSON

    public void addPaletteNodesFromJSON(String jsonString, EditNode parentNode, String[] globals, Function callback)
    Recreate `EditNodes` from a JSON representation of `PaletteNodes` (possibly created by calling `serializeAllEditNodesAsJSON()` or `serializeEditNodesAsJSON()`.

    By default, components that have `global IDs` will not actually be allowed to take those global IDs - instead, only widgets that have one of the global IDs passed as the `globals` parameter will actually receive their global IDs. To override this behavior, pass the special value `ALL_GLOBALS` for the `globals` parameter.

    Parameters:
      `jsonString` - JSON string representing an array of PaletteNodes
      `parentNode` - parent to add to (defaults to the root)
      `globals` - widgets to allow to take their global IDs
      `callback` - Callback to fire after nodes have been added
    See Also:
      - `addFromPaletteNodes(com.smartgwt.client.tools.PaletteNode[])`
      - `serializeAllEditNodesAsJSON()`
      - `serializeEditNodesAsJSON(com.smartgwt.client.tools.EditNode[])`

  - ### addPaletteNodesFromXML

    public void addPaletteNodesFromXML(String xmlString)
    Recreate `EditNodes` from an XML representation of `PaletteNodes` (possibly created by calling `serializeAllEditNodes()` or `serializeEditNodes()`.

    By default, components that have `global IDs` will not actually be allowed to take those global IDs - instead, only widgets that have one of the global IDs passed as the `globals` parameter will actually receive their global IDs. To override this behavior, pass the special value `ALL_GLOBALS` for the `globals` parameter.

    Parameters:
      `xmlString` - XML string
    See Also:
      - `serializeAllEditNodes()`
      - `serializeEditNodes(com.smartgwt.client.tools.EditNode[])`

  - ### addPaletteNodesFromXML

    public void addPaletteNodesFromXML(String xmlString, EditNode parentNode)
    See `addPaletteNodesFromXML()`

  - ### addPaletteNodesFromXML

    public void addPaletteNodesFromXML(String xmlString, EditNode parentNode, String[] globals)
    See `addPaletteNodesFromXML()`

  - ### addPaletteNodesFromXML

    public void addPaletteNodesFromXML(String xmlString, EditNode parentNode, String[] globals, Function callback)
    Recreate `EditNodes` from an XML representation of `PaletteNodes` (possibly created by calling `serializeAllEditNodes()` or `serializeEditNodes()`.

    By default, components that have `global IDs` will not actually be allowed to take those global IDs - instead, only widgets that have one of the global IDs passed as the `globals` parameter will actually receive their global IDs. To override this behavior, pass the special value `ALL_GLOBALS` for the `globals` parameter.

    Parameters:
      `xmlString` - XML string
      `parentNode` - parent node (defaults to the root)
      `globals` - widgets to allow to take their global IDs
      `callback` - Callback to fire after nodes have been added
    See Also:
      - `serializeAllEditNodes()`
      - `serializeEditNodes(com.smartgwt.client.tools.EditNode[])`

  - ### convertedNode

    public void convertedNode(EditNode origNode, EditNode newNode, EditNode parentNode)
    Notification fired when an `EditNode` is converted to a different type when moved from one container to another.
    Parameters:
      `origNode` - node that was being moved
      `newNode` - node that was placed into new container
      `parentNode` - parent node of the drop

  - ### copyEditNodes

    public void copyEditNodes(EditNode editNode)
    Copies the passed editNode or editNodes to an internal "clipboard" space, for later application via `pasteEditNodes()`.
    Parameters:
      `editNode` -

  - ### copyEditNodes

    public void copyEditNodes(EditNode... editNode)
    Copies the passed editNode or editNodes to an internal "clipboard" space, for later application via `pasteEditNodes()`.
    Parameters:
      `editNode` -

  - ### createPaletteNodeTree

    public Tree createPaletteNodeTree(PaletteNode... paletteNodes)
    Creates a `Tree` from the supplied `PaletteNodes` preserving internal references from one supplied PaletteNode to another. This method should be used with an array of possibly inter-related PaletteNodes (for instance, those produced as a result of serialization via `serializeAllEditNodes()`) rather than calling `addFromPaletteNode()` on each individual PaletteNode.
    Parameters:
      `paletteNodes` - array of PaletteNodes
    Returns:
      a tree of the PaletteNodes
    See Also:
      - `addFromPaletteNode(com.smartgwt.client.tools.PaletteNode)`

  - ### deselectAllEditNodes

    public void deselectAllEditNodes()
    Deselect all EditNodes.

  - ### deselectEditNodes

    public void deselectEditNodes(List editNodes)
    Deselect a list of EditNodes.
    Parameters:
      `editNodes` - editNodes to deselect

  - ### destroyAll

    public void destroyAll()
    Removes all `EditNodes` from the EditContext, and calls `destroy()` on the `liveObjects`.

  - ### addEditMaskClickedHandler

    public HandlerRegistration addEditMaskClickedHandler(EditMaskClickedHandler handler)
    Add a editMaskClicked handler.

    Executed when the left mouse is clicked (pressed and then released) on any selectable component with `EditProxy.editMask` enabled. implementation.

    Specified by:
      `addEditMaskClickedHandler` in interface `HasEditMaskClickedHandlers`
    Parameters:
      `handler` - the editMaskClicked handler
    Returns:
      `HandlerRegistration` used to remove this handler

  - ### editNodeHasDataSource

    public Boolean editNodeHasDataSource(EditNode editNode)
    Does the `editNode` have a DataSource assigned?
    Parameters:
      `editNode` - editNode to check for a DataSource
    Returns:
      true if the editNode has a DataSource assigned

  - ### editNodeHasFields

    public Boolean editNodeHasFields(EditNode editNode)
    Does the `editNode` have at least one field assigned?

    Note that if this method is called for a component editNode that could have child components rather than fields, it will return `true` if there are any child nodes other than a DataSource.

    Parameters:
      `editNode` - editNode to check for fields
    Returns:
      true if the editNode has fields or child nodes other than a DataSource

  - ### addEditNodeUpdatedHandler

    public HandlerRegistration addEditNodeUpdatedHandler(EditNodeUpdatedHandler handler)
    Add a editNodeUpdated handler.

    Fires whenever editNode.defaults are modified by setNodeProperties() and/or editProxy features

    Specified by:
      `addEditNodeUpdatedHandler` in interface `HasEditNodeUpdatedHandlers`
    Parameters:
      `handler` - the editNodeUpdated handler
    Returns:
      `HandlerRegistration` used to remove this handler

  - ### enableEditing

    public void enableEditing(EditNode editNode)
    Enable edit mode for an `EditNode`. This is a shortcut for calling `Canvas.setEditMode()`.
    Parameters:
      `editNode` - the EditNode on which to enable editing
    See Also:
      - `Canvas.setEditMode(boolean)`
      - `isNodeEditingOn(com.smartgwt.client.tools.EditNode)`

  - ### getAllEditNodeGlobals

    public Map getAllEditNodeGlobals()
    Returns all global component IDs as a map of ID to `EditNode`.
    Returns:
      Map of global ID to EditNode for all components in the edit tree

  - ### getEditNodesByType

    public EditNode[] getEditNodesByType(String... types)
    Returns `EditNodes` as an array that match the specified type or types. By default the `types` are matched against the `EditNode.type` or the general type of the component. By setting `strict` to `true` the match is made against the editNode type exactly.

    For example, searching for "Canvas" nodes will return nodes for any component that derives from Canvas unless `strict` is set. In the strict case, the search will only return nodes for explict Canvas nodes.

    Parameters:
      `types` - type or types of nodes to find
    Returns:
      the filtered list of EditNodes

  - ### getEditNodesByType

    public EditNode[] getEditNodesByType(String types)
    Returns `EditNodes` as an array that match the specified type or types. By default the `types` are matched against the `EditNode.type` or the general type of the component. By setting `strict` to `true` the match is made against the editNode type exactly.

    For example, searching for "Canvas" nodes will return nodes for any component that derives from Canvas unless `strict` is set. In the strict case, the search will only return nodes for explict Canvas nodes.

    Parameters:
      `types` - type or types of nodes to find
    Returns:
      the filtered list of EditNodes

  - ### getEditNodesByType

    public EditNode[] getEditNodesByType(String[] types, boolean strict)
    Returns `EditNodes` as an array that match the specified type or types. By default the `types` are matched against the `EditNode.type` or the general type of the component. By setting `strict` to `true` the match is made against the editNode type exactly.

    For example, searching for "Canvas" nodes will return nodes for any component that derives from Canvas unless `strict` is set. In the strict case, the search will only return nodes for explict Canvas nodes.

    Parameters:
      `types` - type or types of nodes to find
      `strict` - true to match the `EditNode.type` exactly
    Returns:
      the filtered list of EditNodes

  - ### getEditNodesByType

    public EditNode[] getEditNodesByType(String types, boolean strict)
    Returns `EditNodes` as an array that match the specified type or types. By default the `types` are matched against the `EditNode.type` or the general type of the component. By setting `strict` to `true` the match is made against the editNode type exactly.

    For example, searching for "Canvas" nodes will return nodes for any component that derives from Canvas unless `strict` is set. In the strict case, the search will only return nodes for explict Canvas nodes.

    Parameters:
      `types` - type or types of nodes to find
      `strict` - true to match the `EditNode.type` exactly
    Returns:
      the filtered list of EditNodes

  - ### getEditNodeTree

    public Tree getEditNodeTree()
    Gets the tree of editNodes being edited by this editContext. Standard tree traversal methods can then be used to locate desired editNodes for interaction.

    Note: the returned tree is read-only and must only be modified by calling methods on EditContext like `addNode()` or `setNodeProperties()`.

    Returns:
      the tree of EditNodes

  - ### getNodeProperty

    public void getNodeProperty(EditNode editNode, String name)
    Returns the specified property from the editNode's serializable "defaults".
    Parameters:
      `editNode` - the editNode to query
      `name` - the property name to query
    See Also:
      - `setNodeProperties(com.smartgwt.client.tools.EditNode, com.smartgwt.client.widgets.Canvas)`

  - ### getPaletteNodesFromJS

    public void getPaletteNodesFromJS(String jsCode, PaletteNodeCallback callback)
    Obtain `PaletteNodes` from a JavaScript source representation.

    By default, components that have `global IDs` will not actually be allowed to take those global IDs - instead, only widgets that have one of the global IDs passed as the `globals` parameter will actually receive their global IDs. To override this behavior, pass the special value `ALL_GLOBALS` for the `globals` parameter.

    Parameters:
      `jsCode` - JavaScript code to eval.
      `callback` - Callback used to return the PaletteNodes

  - ### getPaletteNodesFromJS

    public void getPaletteNodesFromJS(String jsCode, PaletteNodeCallback callback, String[] globals)
    Obtain `PaletteNodes` from a JavaScript source representation.

    By default, components that have `global IDs` will not actually be allowed to take those global IDs - instead, only widgets that have one of the global IDs passed as the `globals` parameter will actually receive their global IDs. To override this behavior, pass the special value `ALL_GLOBALS` for the `globals` parameter.

    Parameters:
      `jsCode` - JavaScript code to eval.
      `callback` - Callback used to return the PaletteNodes
      `globals` - widgets to allow to take their global IDs

  - ### getPaletteNodesFromXML

    public void getPaletteNodesFromXML(String xmlString, PaletteNodeCallback callback)
    Obtain `PaletteNodes` from an XML representation, but do not add them to the EditContext.
    Parameters:
      `xmlString` - XML string
      `callback` - Callback used to return the PaletteNodes
    See Also:
      - `serializeAllEditNodes()`
      - `serializeEditNodes(com.smartgwt.client.tools.EditNode[])`

  - ### getRootEditNode

    public EditNode getRootEditNode()
    Returns the root `EditNode` of the EditContext typically created from `rootComponent`.
    Returns:
      the root EditNode

  - ### getSelectedEditNode

    public EditNode getSelectedEditNode()
    Returns selected EditNode or first selected EditNode if multiple nodes are selected.
    Returns:
      the selected or first edit node

  - ### getSelectedEditNodes

    public EditNode[] getSelectedEditNodes()
    Returns all selected EditNodes as an Array.
    Returns:
      the selected edit nodes

  - ### inlineEditorShowing

    public void inlineEditorShowing(FormItem field, String type)
    Notification method fired when an inline title or value editor is shown or closed for a component in the designer pane.
    Parameters:
      `field` - the field within the inline editor when showing. null if the editor is closed.
      `type` - the type of editor showing: "title" or "value"

  - ### isEditNodeSelected

    public boolean isEditNodeSelected()
    Returns true if the editNode is selected.
    Returns:
      true if editNode is selected; false otherwise

  - ### isNodeEditingOn

    public boolean isNodeEditingOn(EditNode editNode)
    Returns true if `editNode` is in edit mode.
    Parameters:
      `editNode` - the EditNode
    Returns:
      true if node is in edit mode

  - ### makeEditNode

    public EditNode makeEditNode(PaletteNode paletteNode)
    Creates and returns an EditNode using the `defaultPalette`. Does not add the newly created EditNode to an EditContext.
    Parameters:
      `paletteNode` - the palette node to use to create the new node
    Returns:
      the EditNode created from the paletteNode

  - ### makePaletteNode

    public PaletteNode makePaletteNode(EditNode editNode)
    Creates a `PaletteNode` from an `EditNode` in this context's `editNodeTree`.

    This essentially creates a new `PaletteNode` with the `EditNode.defaults` from the passed `editNode`. The returned `paletteNode` could then be used with `addFromPaletteNode()` to effectively create a copy of the original editNode - specifically a new editNode with a new `EditNode.liveObject` created from the same defaults.

    However note that `makePaletteNode()` does not copy descendant nodes - use `makePaletteNodeTree()` for that.

    May return null if the passed editNode cannot validly by transformed into a paletteNode, for example if `EditNode.canDuplicate` was set false.

    Parameters:
      `editNode` - the editNode to use to make a paletteNode
    Returns:
      paletteNode derived from the editNode or null

  - ### makePaletteNodeTree

    public Tree makePaletteNodeTree(EditNode editNode, Boolean removeAutoIDs)
    Creates a `Tree` of `PaletteNodes` from an `EditNode` in this context's `editNodeTree`, by using `makePaletteNode()` on the passed `EditNode` and its descendents within the `editNodeTree`.

    The root node of the returned `Tree` will be a PaletteNode derived from the passed `EditNode`.

    Parameters:
      `editNode` - root editNode to make Tree of PaletteNodes from
      `removeAutoIDs` - should ID and autoID defaults be removed?
    Returns:
      a Tree of paletteNodes or null

  - ### addNodeAddedHandler

    public HandlerRegistration addNodeAddedHandler(NodeAddedHandler handler)
    Add a nodeAdded handler.

    Notification fired when an `EditNode` has been added to the EditContext

    Specified by:
      `addNodeAddedHandler` in interface `HasNodeAddedHandlers`
    Parameters:
      `handler` - the nodeAdded handler
    Returns:
      `HandlerRegistration` used to remove this handler

  - ### nodeMoved

    public void nodeMoved(EditNode oldNode, EditNode oldParentNode, EditNode newNode, EditNode newParentNode, EditNode rootNode)
    Notification fired when an `EditNode` has been moved to a new position in the component tree.
    Parameters:
      `oldNode` - node that was removed
      `oldParentNode` - parent node of the node that was removed
      `newNode` - node that was added
      `newParentNode` - parent node of the node that was added
      `rootNode` - root node of the edit context

  - ### nodeRemoved

    public void nodeRemoved(EditNode removedNode, EditNode parentNode, EditNode rootNode)
    Notification fired when an `EditNode` has been removed from the EditContext
    Parameters:
      `removedNode` - node that was removed
      `parentNode` - parent node of the node that was removed
      `rootNode` - root node of the edit context

  - ### pasteEditNodes

    public void pasteEditNodes()
    "Pastes" `editNodes` previously captured via `copyEditNodes()`.

    New editNodes will be added as root-level nodes of the `editNodeTree` unless a `targetEditNode` is passed.

  - ### pasteEditNodes

    public void pasteEditNodes(EditNode targetEditNode)
    "Pastes" `editNodes` previously captured via `copyEditNodes()`.

    New editNodes will be added as root-level nodes of the `editNodeTree` unless a `targetEditNode` is passed.

    Parameters:
      `targetEditNode` -

  - ### removeAll

    public void removeAll()
    Removes all `EditNodes` from the EditContext, but does not destroy the `liveObjects`.

  - ### removeNode

    public void removeNode(EditNode editNode)
    Removes `EditNode` from the EditContext. The editNode liveObject is not destroyed.
    Parameters:
      `editNode` - node to be removed

  - ### removeNodeProperties

    public void removeNodeProperties(EditNode editNode, String[] properties)
    Removes the specified properties from an editNode's serializable "defaults". Note that the `liveObject` is not updated by this method. To set a property to null (rather than removing it), use `setNodeProperties()` instead.
    Parameters:
      `editNode` - the editNode to update
      `properties` - an array of property names to remove
    See Also:
      - `setNodeProperties(com.smartgwt.client.tools.EditNode, com.smartgwt.client.widgets.Canvas)`

  - ### reorderNode

    public void reorderNode(EditNode parentNode, Integer index, Integer moveToIndex)
    Moves an `EditNode` from one child index to another in the EditContext under the specified parent.

    No changes are made to the live objects.

    Parameters:
      `parentNode` - parent to reorder child nodes
      `index` - index within the parent's children array to be moved
      `moveToIndex` - index within the parent's children array at which to place moved node

  - ### selectAllEditNodes

    public void selectAllEditNodes()
    Select all EditNodes.

  - ### addSelectedEditNodesUpdatedHandler

    public HandlerRegistration addSelectedEditNodesUpdatedHandler(SelectedEditNodesUpdatedHandler handler)
    Add a selectedEditNodesUpdated handler.

    Called when editMode selection changes. Note this method fires exactly once for any given change.

    This event is fired once after selection/deselection has completed. The result is one event per mouse-down event. For a drag selection there will be one event fired when the range is completed.

    Specified by:
      `addSelectedEditNodesUpdatedHandler` in interface `HasSelectedEditNodesUpdatedHandlers`
    Parameters:
      `handler` - the selectedEditNodesUpdated handler
    Returns:
      `HandlerRegistration` used to remove this handler

  - ### selectEditNode

    public void selectEditNode(EditNode editNode)
    Select an EditNode.
    Parameters:
      `editNode` - editNode to select

  - ### selectSingleEditNode

    public void selectSingleEditNode(EditNode editNode)
    Select a single EditNode and deselect everything else.
    Parameters:
      `editNode` - editNode to select

  - ### serializeAllEditNodes

    public String serializeAllEditNodes()
    Serialize the tree of `EditNodes` to an XML representation of `PaletteNodes`. The result can be supplied to `addPaletteNodesFromXML()` to recreate the EditNodes.
    Returns:
      an XML representation of PaletteNodes which can be used to recreate the tree of EditNodes.
    See Also:
      - `addPaletteNodesFromXML(java.lang.String)`

  - ### serializeAllEditNodes

    public String serializeAllEditNodes(SerializationSettings settings)
    Serialize the tree of `EditNodes` to an XML representation of `PaletteNodes`. The result can be supplied to `addPaletteNodesFromXML()` to recreate the EditNodes.
    Parameters:
      `settings` - Additional serialization settings
    Returns:
      an XML representation of PaletteNodes which can be used to recreate the tree of EditNodes.
    See Also:
      - `addPaletteNodesFromXML(java.lang.String)`

  - ### serializeAllEditNodesAsJSON

    public String serializeAllEditNodesAsJSON()
    Encode the tree of `EditNodes` to a JSON representation of `PaletteNodes`. The result can be supplied to `addPaletteNodesFromJSON()` to recreate the EditNodes.
    Returns:
      a JSON representation of PaletteNodes which can be used to recreate the tree of EditNodes.
    See Also:
      - `addPaletteNodesFromJSON(java.lang.String)`

  - ### serializeAllEditNodesAsJSON

    public String serializeAllEditNodesAsJSON(SerializationSettings settings)
    Encode the tree of `EditNodes` to a JSON representation of `PaletteNodes`. The result can be supplied to `addPaletteNodesFromJSON()` to recreate the EditNodes.
    Parameters:
      `settings` - Additional serialization settings
    Returns:
      a JSON representation of PaletteNodes which can be used to recreate the tree of EditNodes.
    See Also:
      - `addPaletteNodesFromJSON(java.lang.String)`

  - ### serializeEditNodes

    public String serializeEditNodes(EditNode[] nodes)
    Serialize the provided `EditNodes` to an XML representation of `PaletteNodes`. Note that the EditNodes must have been added to this EditContext. The result can be supplied to `addPaletteNodesFromXML()` to recreate the EditNodes.
    Parameters:
      `nodes` - EditNodes to be serialized
    Returns:
      an XML representtion of the provided EditNodes

  - ### serializeEditNodes

    public String serializeEditNodes(EditNode[] nodes, SerializationSettings settings)
    Serialize the provided `EditNodes` to an XML representation of `PaletteNodes`. Note that the EditNodes must have been added to this EditContext. The result can be supplied to `addPaletteNodesFromXML()` to recreate the EditNodes.
    Parameters:
      `nodes` - EditNodes to be serialized
      `settings` - Additional serialization settings
    Returns:
      an XML representtion of the provided EditNodes

  - ### serializeEditNodesAsJSON

    public String serializeEditNodesAsJSON(EditNode[] nodes)
    Serialize the provided `EditNodes` to a JSON representation of `PaletteNodes`. Note that the EditNodes must have been added to this EditContext. The result can be supplied to `addPaletteNodesFromJSON()` to recreate the EditNodes.
    Parameters:
      `nodes` - EditNodes to be serialized
    Returns:
      a JSON representtion of the provided EditNodes

  - ### serializeEditNodesAsJSON

    public String serializeEditNodesAsJSON(EditNode[] nodes, SerializationSettings settings)
    Serialize the provided `EditNodes` to a JSON representation of `PaletteNodes`. Note that the EditNodes must have been added to this EditContext. The result can be supplied to `addPaletteNodesFromJSON()` to recreate the EditNodes.
    Parameters:
      `nodes` - EditNodes to be serialized
      `settings` - Additional serialization settings
    Returns:
      a JSON representtion of the provided EditNodes

  - ### setEditProxyProperties

    public void setEditProxyProperties(EditNode editNode, EditProxy properties)
    Update an editNode's `EditProxy` properties. If editProxy has not yet been created, `editProxyProperties` is updated or created instead.
    Parameters:
      `editNode` - the editNode to update
      `properties` - the properties to apply

  - ### setNodeProperties

    public void setNodeProperties(EditNode editNode, Canvas properties)
    Update an editNode's serializable "defaults" with the supplied properties. If you wish to remove a property from the defaults (rather than setting it to null), then use `removeNodeProperties()` instead.
    Parameters:
      `editNode` - the editNode to update
      `properties` - the properties to apply
    See Also:
      - `removeNodeProperties(com.smartgwt.client.tools.EditNode, java.lang.String[])`
      - `getNodeProperty(com.smartgwt.client.tools.EditNode, java.lang.String)`

  - ### setNodeProperties

    public void setNodeProperties(EditNode editNode, Canvas properties, Boolean skipLiveObjectUpdate)
    Update an editNode's serializable "defaults" with the supplied properties. If you wish to remove a property from the defaults (rather than setting it to null), then use `removeNodeProperties()` instead.
    Parameters:
      `editNode` - the editNode to update
      `properties` - the properties to apply
      `skipLiveObjectUpdate` - whether to skip updating the `liveObject`, e.g. if you have already updated the liveObject
    See Also:
      - `removeNodeProperties(com.smartgwt.client.tools.EditNode, java.lang.String[])`
      - `getNodeProperty(com.smartgwt.client.tools.EditNode, java.lang.String)`

  - ### substitutedNode

    public void substitutedNode(PaletteNode origNode, PaletteNode newNode, EditNode parentNode)
    Notification fired when a different `PaletteNode` is substituted for one being dropped into a container.
    Parameters:
      `origNode` - node that was originally dropped
      `newNode` - node that was substituted
      `parentNode` - parent node of the drop

  - ### setNodeProperties

    public void setNodeProperties(EditNode editNode, DrawItem properties) throws IllegalStateException
    Update an editNode's serializable "defaults" with the supplied properties. If you wish to remove a property from the defaults (rather than setting it to null), then use `removeNodeProperties()` instead.
    Parameters:
      `editNode` - the editNode to update
      `properties` - the properties to apply
    Throws:
      `IllegalStateException`
    See Also:
      - `removeNodeProperties(com.smartgwt.client.tools.EditNode, java.lang.String[])`

  - ### setNodeProperties

    public void setNodeProperties(EditNode editNode, DrawItem properties, Boolean skipLiveObjectUpdate) throws IllegalStateException
    Update an editNode's serializable "defaults" with the supplied properties. If you wish to remove a property from the defaults (rather than setting it to null), then use `removeNodeProperties()` instead.
    Parameters:
      `editNode` - the editNode to update
      `properties` - the properties to apply
      `skipLiveObjectUpdate` - whether to skip updating the `liveObject`, e.g. if you have already updated the liveObject
    Throws:
      `IllegalStateException`
    See Also:
      - `removeNodeProperties(com.smartgwt.client.tools.EditNode, java.lang.String[])`

  - ### setNodeProperties

    protected void setNodeProperties(EditNode editNode, JavaScriptObject properties)

  - ### setNodeProperties

    protected void setNodeProperties(EditNode editNode, JavaScriptObject properties, Boolean skipLiveObjectUpdate)