com.smartgwt.client.tools

## Class EditContext

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

- All Implemented Interfaces:
    com.google.gwt.event.shared.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:
    `DevTools overview and related methods`

- - ### Field Summary

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

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

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `EditContext()`
    `EditContext(com.google.gwt.core.client.JavaScriptObject jsObj)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `com.google.gwt.event.shared.HandlerRegistration` | `addEditMaskClickedHandler(EditMaskClickedHandler handler)` Add a editMaskClicked handler.
    `com.google.gwt.event.shared.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` | `addNode(EditNode newNode)` Add a new `EditNode` to the EditContext, under the specified parent.
    `EditNode` | `addNode(EditNode newNode, EditNode parentNode)`
    `EditNode` | `addNode(EditNode newNode, EditNode parentNode, java.lang.Integer index)`
    `EditNode` | `addNode(EditNode newNode, EditNode parentNode, java.lang.Integer index, java.lang.String parentProperty)`
    `EditNode` | `addNode(EditNode newNode, EditNode parentNode, java.lang.Integer index, java.lang.String parentProperty, java.lang.Boolean skipParentComponentAdd)`
    `EditNode` | `addNode(EditNode newNode, EditNode parentNode, java.lang.Integer index, java.lang.String parentProperty, java.lang.Boolean skipParentComponentAdd, java.lang.Boolean forceSingularFieldReplace)` Add a new `EditNode` to the EditContext, under the specified parent.
    `com.google.gwt.event.shared.HandlerRegistration` | `addNodeAddedHandler(NodeAddedHandler handler)` Add a nodeAdded handler.
    `void` | `addPaletteNodesFromJS(java.lang.String jsCode)` Add `PaletteNodes` from a JavaScript source representation.
    `void` | `addPaletteNodesFromJS(java.lang.String jsCode, EditNode parentNode)`
    `void` | `addPaletteNodesFromJS(java.lang.String jsCode, EditNode parentNode, java.lang.String[] globals)` Add `PaletteNodes` from a JavaScript source representation.
    `void` | `addPaletteNodesFromJSON(java.lang.String jsonString)` Recreate `EditNodes` from a JSON representation of `PaletteNodes` (possibly created by calling `serializeAllEditNodesAsJSON()` or `serializeEditNodesAsJSON()`.
    `void` | `addPaletteNodesFromJSON(java.lang.String jsonString, EditNode parentNode)`
    `void` | `addPaletteNodesFromJSON(java.lang.String jsonString, EditNode parentNode, java.lang.String[] globals)`
    `void` | `addPaletteNodesFromJSON(java.lang.String jsonString, EditNode parentNode, java.lang.String[] globals, Function callback)` Recreate `EditNodes` from a JSON representation of `PaletteNodes` (possibly created by calling `serializeAllEditNodesAsJSON()` or `serializeEditNodesAsJSON()`.
    `void` | `addPaletteNodesFromXML(java.lang.String xmlString)` Recreate `EditNodes` from an XML representation of `PaletteNodes` (possibly created by calling `serializeAllEditNodes()` or `serializeEditNodes()`.
    `void` | `addPaletteNodesFromXML(java.lang.String xmlString, EditNode parentNode)`
    `void` | `addPaletteNodesFromXML(java.lang.String xmlString, EditNode parentNode, java.lang.String[] globals)`
    `void` | `addPaletteNodesFromXML(java.lang.String xmlString, EditNode parentNode, java.lang.String[] globals, Function callback)` Recreate `EditNodes` from an XML representation of `PaletteNodes` (possibly created by calling `serializeAllEditNodes()` or `serializeEditNodes()`.
    `com.google.gwt.event.shared.HandlerRegistration` | `addSelectedEditNodesUpdatedHandler(SelectedEditNodesUpdatedHandler handler)` Add a selectedEditNodesUpdated handler.
    `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()`.
    `com.google.gwt.core.client.JavaScriptObject` | `create()`
    `void` | `deselectAllEditNodes()` Deselect all EditNodes.
    `void` | `deselectEditNodes(java.util.List editNodes)` Deselect a list of EditNodes.
    `void` | `destroyAll()` Removes all `EditNodes` from the EditContext, and calls `destroy()` on the `liveObjects`.
    `void` | `enableEditing(EditNode editNode)` Enable edit mode for an `EditNode`.
    `java.lang.Boolean` | `getAllowNestedDrops()` Controls whether components can be dropped into other components which support child components.
    `java.lang.Boolean` | `getAutoEditNewNodes()` New nodes added to the editContext are automatically placed into edit mode if the new node's parent is in edit mode.
    `java.lang.Boolean` | `getCanDragGroup()` Should the group selection box shown when `canGroupSelect` is true allow dragging the group as a whole?
    `java.lang.Boolean` | `getCanGroupSelect()` Should a group selection outline covering the outermost bounding boxes of all selected components be shown in this container?
    `java.lang.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.
    `java.util.Map` | `getEditMaskProperties()` Properties to apply to all `EditProxy.editMask`s created for components in edit mode.
    `Tree` | `getEditNodeTree()` Gets the tree of editNodes being edited by this editContext.
    `java.lang.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`.
    `java.lang.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`.
    `java.util.Map` | `getHoopSelectorProperties()` Properties to apply to `EditProxy.hoopSelector`.
    `com.google.gwt.core.client.JavaScriptObject` | `getJsObj()`
    `com.google.gwt.core.client.JavaScriptObject` | `getOrCreateJsObj()`
    `static EditContext` | `getOrCreateRef(com.google.gwt.core.client.JavaScriptObject jsObj)`
    `void` | `getPaletteNodesFromJS(java.lang.String jsCode, PaletteNodeCallback callback)` Obtain `PaletteNodes` from a JavaScript source representation.
    `void` | `getPaletteNodesFromJS(java.lang.String jsCode, PaletteNodeCallback callback, java.lang.String[] globals)` Obtain `PaletteNodes` from a JavaScript source representation.
    `void` | `getPaletteNodesFromXML(java.lang.String xmlString, PaletteNodeCallback callback)` Obtain `PaletteNodes` from an XML representation, but do not add them to the EditContext.
    `java.lang.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.
    `java.lang.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.
    `java.lang.String` | `getSelectedLabelBackgroundColor()` The background color for the selection outline label.
    `java.lang.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.
    `java.lang.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.
    `java.lang.Boolean` | `getShowSelectedLabelOnSelect()` Should the selection outline show a label when the component is selected? This property is similar to `showSelectedLabel`.
    `java.lang.Boolean` | `getUseCopyPasteShortcuts()` If set, auto-enables `EditProxy.useCopyPasteShortcuts` on the `EditProxy` for the `root editNode`.
    `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)` 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, java.lang.String[] properties)` Removes the specified properties from an editNode's serializable "defaults".
    `void` | `selectAllEditNodes()` Select all EditNodes.
    `void` | `selectEditNode(EditNode editNode)` Select an EditNode.
    `void` | `selectSingleEditNode(EditNode editNode)` Select a single EditNode and deselect everything else.
    `java.lang.String` | `serializeAllEditNodes()` Serialize the tree of `EditNodes` to an XML representation of `PaletteNodes`.
    `java.lang.String` | `serializeAllEditNodes(SerializationSettings settings)` Serialize the tree of `EditNodes` to an XML representation of `PaletteNodes`.
    `java.lang.String` | `serializeAllEditNodesAsJSON()` Encode the tree of `EditNodes` to a JSON representation of `PaletteNodes`.
    `java.lang.String` | `serializeAllEditNodesAsJSON(SerializationSettings settings)` Encode the tree of `EditNodes` to a JSON representation of `PaletteNodes`.
    `java.lang.String` | `serializeEditNodes(EditNode[] nodes)` Serialize the provided `EditNodes` to an XML representation of `PaletteNodes`.
    `java.lang.String` | `serializeEditNodes(EditNode[] nodes, SerializationSettings settings)` Serialize the provided `EditNodes` to an XML representation of `PaletteNodes`.
    `java.lang.String` | `serializeEditNodesAsJSON(EditNode[] nodes)` Serialize the provided `EditNodes` to a JSON representation of `PaletteNodes`.
    `java.lang.String` | `serializeEditNodesAsJSON(EditNode[] nodes, SerializationSettings settings)` Serialize the provided `EditNodes` to a JSON representation of `PaletteNodes`.
    `EditContext` | `setAllowNestedDrops(java.lang.Boolean allowNestedDrops)` Controls whether components can be dropped into other components which support child components.
    `EditContext` | `setAutoEditNewNodes(java.lang.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(java.lang.Boolean canDragGroup)` Should the group selection box shown when `canGroupSelect` is true allow dragging the group as a whole?
    `EditContext` | `setCanGroupSelect(java.lang.Boolean canGroupSelect)` Should a group selection outline covering the outermost bounding boxes of all selected components be shown in this container?
    `EditContext` | `setCanSelectEditNodes(java.lang.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(java.util.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(java.lang.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(java.lang.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(java.util.Map hoopSelectorProperties)` Properties to apply to `EditProxy.hoopSelector`.
    `void` | `setJavaScriptObject(com.google.gwt.core.client.JavaScriptObject jsObj)`
    `void` | `setNodeProperties(EditNode editNode, Canvas properties)` Update an editNode's serializable "defaults" with the supplied properties.
    `void` | `setNodeProperties(EditNode editNode, Canvas properties, java.lang.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, java.lang.Boolean skipLiveObjectUpdate)` Update an editNode's serializable "defaults" with the supplied properties.
    `protected void` | `setNodeProperties(EditNode editNode, com.google.gwt.core.client.JavaScriptObject properties)`
    `protected void` | `setNodeProperties(EditNode editNode, com.google.gwt.core.client.JavaScriptObject properties, java.lang.Boolean skipLiveObjectUpdate)`
    `EditContext` | `setPersistCoordinates(java.lang.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(java.lang.String selectedBorder)` Set the CSS border to be applied to the selection outline of the selected components.
    `EditContext` | `setSelectedLabelBackgroundColor(java.lang.String selectedLabelBackgroundColor)` The background color for the selection outline label.
    `EditContext` | `setSelectedTintColor(java.lang.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(java.lang.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(java.lang.Boolean showSelectedLabelOnSelect)` Should the selection outline show a label when the component is selected? This property is similar to `showSelectedLabel`.
    `EditContext` | `setUseCopyPasteShortcuts(java.lang.Boolean useCopyPasteShortcuts)` If set, auto-enables `EditProxy.useCopyPasteShortcuts` on the `EditProxy` for the `root editNode`.

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

      `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 Detail

    - #### EditContext

          public EditContext()

    - #### EditContext

          public EditContext(com.google.gwt.core.client.JavaScriptObject jsObj)

  - ### Method Detail

    - #### getOrCreateRef

          public static EditContext getOrCreateRef(com.google.gwt.core.client.JavaScriptObject jsObj)

    - #### setJavaScriptObject

          public void setJavaScriptObject(com.google.gwt.core.client.JavaScriptObject jsObj)

      Overrides:
        `setJavaScriptObject` in class `BaseClass`

    - #### create

          public com.google.gwt.core.client.JavaScriptObject create()

      Specified by:
        `create` in class `BaseClass`

    - #### isCreated

          public boolean isCreated()

      Overrides:
        `isCreated` in class `BaseClass`

    - #### getJsObj

          public com.google.gwt.core.client.JavaScriptObject getJsObj()

      Overrides:
        `getJsObj` in class `BaseClass`

    - #### getOrCreateJsObj

          public com.google.gwt.core.client.JavaScriptObject getOrCreateJsObj()

      Overrides:
        `getOrCreateJsObj` in class `BaseClass`

    - #### setAllowNestedDrops

          public EditContext setAllowNestedDrops(java.lang.Boolean allowNestedDrops)
                                          throws java.lang.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:
        `java.lang.IllegalStateException` - this property cannot be changed after the underlying component has been created

    - #### getAllowNestedDrops

          public java.lang.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(java.lang.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 java.lang.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(java.lang.Boolean canDragGroup)
                                      throws java.lang.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:
        `java.lang.IllegalStateException` - this property cannot be changed after the underlying component has been created

    - #### getCanDragGroup

          public java.lang.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(java.lang.Boolean canGroupSelect)
                                        throws java.lang.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:
        `java.lang.IllegalStateException` - this property cannot be changed after the underlying component has been created

    - #### getCanGroupSelect

          public java.lang.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(java.lang.Boolean canSelectEditNodes)
                                            throws java.lang.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:
        `java.lang.IllegalStateException` - this property cannot be changed after the underlying component has been created

    - #### getCanSelectEditNodes

          public java.lang.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(java.util.Map editMaskProperties)
                                            throws java.lang.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:
        `java.lang.IllegalStateException` - this property cannot be changed after the underlying component has been created

    - #### getEditMaskProperties

          public java.util.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(java.lang.Boolean enableInlineEdit)
                                          throws java.lang.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:
        `java.lang.IllegalStateException` - this property cannot be changed after the underlying component has been created

    - #### getEnableInlineEdit

          public java.lang.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(java.lang.Boolean hideGroupBorderOnDrag)
                                               throws java.lang.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:
        `java.lang.IllegalStateException` - this property cannot be changed after the underlying component has been created

    - #### getHideGroupBorderOnDrag

          public java.lang.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 java.lang.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:
        `java.lang.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(java.util.Map hoopSelectorProperties)
                                                throws java.lang.IllegalStateException

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

    - #### getHoopSelectorProperties

          public java.util.Map getHoopSelectorProperties()

      Properties to apply to `EditProxy.hoopSelector`.
      Returns:
        Current hoopSelectorProperties value. Default value is null

    - #### setPersistCoordinates

          public EditContext setPersistCoordinates(java.lang.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 VisualBuilder, 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 java.lang.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 VisualBuilder, 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 java.lang.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:
        `java.lang.IllegalStateException` - this property cannot be changed after the underlying component has been created
      See Also:
        `DevTools overview and related methods`

    - #### 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:
        `DevTools overview and related methods`

    - #### setSelectedAppearance

          public EditContext setSelectedAppearance(SelectedAppearance selectedAppearance)
                                            throws java.lang.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:
        `java.lang.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(java.lang.String selectedBorder)
                                        throws java.lang.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:
        `java.lang.IllegalStateException` - this property cannot be changed after the underlying component has been created

    - #### getSelectedBorder

          public java.lang.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(java.lang.String selectedLabelBackgroundColor)
                                                      throws java.lang.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:
        `java.lang.IllegalStateException` - this property cannot be changed after the underlying component has been created
      See Also:
        `setShowSelectedLabel(java.lang.Boolean)`

    - #### getSelectedLabelBackgroundColor

          public java.lang.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(java.lang.String selectedTintColor)
                                           throws java.lang.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:
        `java.lang.IllegalStateException` - this property cannot be changed after the underlying component has been created
      See Also:
        `setSelectedTintOpacity(int)`, `CSSColor`

    - #### getSelectedTintColor

          public java.lang.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 java.lang.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:
        `java.lang.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(java.lang.Boolean showSelectedLabel)
                                           throws java.lang.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:
        `java.lang.IllegalStateException` - this property cannot be changed after the underlying component has been created

    - #### getShowSelectedLabel

          public java.lang.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(java.lang.Boolean showSelectedLabelOnSelect)
                                                   throws java.lang.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:
        `java.lang.IllegalStateException` - this property cannot be changed after the underlying component has been created

    - #### getShowSelectedLabelOnSelect

          public java.lang.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(java.lang.Boolean useCopyPasteShortcuts)
                                               throws java.lang.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:
        `java.lang.IllegalStateException` - this property cannot be changed after the underlying component has been created

    - #### getUseCopyPasteShortcuts

          public java.lang.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)`

    - #### 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 Also:
        `addNode(com.smartgwt.client.tools.EditNode)`

    - #### addNode

          public EditNode addNode(EditNode newNode,
                                  EditNode parentNode,
                                  java.lang.Integer index)

      See Also:
        `addNode(com.smartgwt.client.tools.EditNode)`

    - #### addNode

          public EditNode addNode(EditNode newNode,
                                  EditNode parentNode,
                                  java.lang.Integer index,
                                  java.lang.String parentProperty)

      See Also:
        `addNode(com.smartgwt.client.tools.EditNode)`

    - #### addNode

          public EditNode addNode(EditNode newNode,
                                  EditNode parentNode,
                                  java.lang.Integer index,
                                  java.lang.String parentProperty,
                                  java.lang.Boolean skipParentComponentAdd)

      See Also:
        `addNode(com.smartgwt.client.tools.EditNode)`

    - #### addNode

          public EditNode addNode(EditNode newNode,
                                  EditNode parentNode,
                                  java.lang.Integer index,
                                  java.lang.String parentProperty,
                                  java.lang.Boolean skipParentComponentAdd,
                                  java.lang.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

    - #### addPaletteNodesFromJS

          public void addPaletteNodesFromJS(java.lang.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(java.lang.String jsCode,
                                            EditNode parentNode)

      See Also:
        `addPaletteNodesFromJS(java.lang.String)`

    - #### addPaletteNodesFromJS

          public void addPaletteNodesFromJS(java.lang.String jsCode,
                                            EditNode parentNode,
                                            java.lang.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(java.lang.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(java.lang.String jsonString,
                                              EditNode parentNode)

      See Also:
        `addPaletteNodesFromJSON(java.lang.String)`

    - #### addPaletteNodesFromJSON

          public void addPaletteNodesFromJSON(java.lang.String jsonString,
                                              EditNode parentNode,
                                              java.lang.String[] globals)

      See Also:
        `addPaletteNodesFromJSON(java.lang.String)`

    - #### addPaletteNodesFromJSON

          public void addPaletteNodesFromJSON(java.lang.String jsonString,
                                              EditNode parentNode,
                                              java.lang.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(java.lang.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(java.lang.String xmlString,
                                             EditNode parentNode)

      See Also:
        `addPaletteNodesFromXML(java.lang.String)`

    - #### addPaletteNodesFromXML

          public void addPaletteNodesFromXML(java.lang.String xmlString,
                                             EditNode parentNode,
                                             java.lang.String[] globals)

      See Also:
        `addPaletteNodesFromXML(java.lang.String)`

    - #### addPaletteNodesFromXML

          public void addPaletteNodesFromXML(java.lang.String xmlString,
                                             EditNode parentNode,
                                             java.lang.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[])`

    - #### 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` -

    - #### deselectAllEditNodes

          public void deselectAllEditNodes()

      Deselect all EditNodes.

    - #### deselectEditNodes

          public void deselectEditNodes(java.util.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 com.google.gwt.event.shared.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

    - #### addEditNodeUpdatedHandler

          public com.google.gwt.event.shared.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)`

    - #### 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

    - #### getPaletteNodesFromJS

          public void getPaletteNodesFromJS(java.lang.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(java.lang.String jsCode,
                                            PaletteNodeCallback callback,
                                            java.lang.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(java.lang.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

    - #### 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)

      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
      Returns:
        a Tree of paletteNodes or null

    - #### addNodeAddedHandler

          public com.google.gwt.event.shared.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,
                                           java.lang.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)`

    - #### selectAllEditNodes

          public void selectAllEditNodes()

      Select all EditNodes.

    - #### addSelectedEditNodesUpdatedHandler

          public com.google.gwt.event.shared.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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 java.lang.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[])`

    - #### setNodeProperties

          public void setNodeProperties(EditNode editNode,
                                        Canvas properties,
                                        java.lang.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[])`

    - #### setNodeProperties

          public void setNodeProperties(EditNode editNode,
                                        DrawItem properties)
                                 throws java.lang.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:
        `java.lang.IllegalStateException`
      See Also:
        `removeNodeProperties(com.smartgwt.client.tools.EditNode, java.lang.String[])`

    - #### setNodeProperties

          public void setNodeProperties(EditNode editNode,
                                        DrawItem properties,
                                        java.lang.Boolean skipLiveObjectUpdate)
                                 throws java.lang.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:
        `java.lang.IllegalStateException`
      See Also:
        `removeNodeProperties(com.smartgwt.client.tools.EditNode, java.lang.String[])`

    - #### setNodeProperties

          protected void setNodeProperties(EditNode editNode,
                                           com.google.gwt.core.client.JavaScriptObject properties)

    - #### setNodeProperties

          protected void setNodeProperties(EditNode editNode,
                                           com.google.gwt.core.client.JavaScriptObject properties,
                                           java.lang.Boolean skipLiveObjectUpdate)