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:

  • 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.editMasks 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.editMasks 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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

      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:

    • 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:

    • 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:

    • 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:

    • 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

      public EditNode addNode(EditNode newNode, EditNode parentNode, Integer index)
      See Also:

    • addNode

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

    • addNode

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

    • 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 Also:

    • 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:

    • addPaletteNodesFromJSON

      public void addPaletteNodesFromJSON(String jsonString, EditNode parentNode)
      See Also:

    • addPaletteNodesFromJSON

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

    • 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:

    • 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:

    • addPaletteNodesFromXML

      public void addPaletteNodesFromXML(String xmlString, EditNode parentNode)
      See Also:

    • addPaletteNodesFromXML

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

    • 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:

    • 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:

    • 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:

    • 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

    • 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:

    • 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:

    • 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)
      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 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • setNodeProperties

      protected void setNodeProperties(EditNode editNode, JavaScriptObject properties)

    • setNodeProperties

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