GraphClipboard (yFiles-for-JavaFX-Complete-3.0 API)

java.lang.Object
- com.yworks.yfiles.graph.GraphClipboard

```
public class GraphClipboard
extends Object
```
Clipboard implementation for IGraph instances.
This implementation copies a given graph to an internally held clipboard graph. The clipboard graph can then be pasted to a target graph instance.

The clipboard can be configured to copy and paste items that depend on other items without copying the items it depends on, e.g. labels, ports, edges, and bends.

Also depending on the selection in the target graph, items can be pasted at multiple locations at once, e.g. a single label can be copied to the clipboard independently and pasted onto several selected target items.

See Also:

IClipboardHelper, cut(IGraph, Predicate), copy(IGraph, Predicate, IGraph, INode, IElementCopiedCallback), paste(IGraph, Predicate, IElementCopiedCallback), getClipboardGraph()

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class GraphClipboard.ParentNodeDetectionModes
Defines the rules for pasting nodes into group nodes.

Nested Classes
Modifier and Type	Class and Description
`static class`	`GraphClipboard.ParentNodeDetectionModes` Defines the rules for pasting nodes into group nodes.

Constructor Summary

Constructors
Constructor and Description

GraphClipboard()
Creates a new initially empty clipboard.

Constructors
Constructor and Description
`GraphClipboard()` Creates a new initially empty clipboard.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addElementsCopiedListener(IEventHandler<IEventArgs> elementsCopiedEvent)` Adds the given listener for the `ElementsCopied` event that occurs when the `copy(IGraph, Predicate)` operation finished successfully.
`void`	`addElementsCutListener(IEventHandler<IEventArgs> elementsCutEvent)` Adds the given listener for the `ElementsCut` event that occurs when the `cut(IGraph, Predicate)` operation finished successfully.
`void`	`addElementsPastedListener(IEventHandler<IEventArgs> elementsPastedEvent)` Adds the given listener for the `ElementsPasted` event that occurs when the `paste(IInputModeContext, IGraph, Predicate, IElementCopiedCallback, Predicate)` operation finished successfully.
`void`	`clear()` Clears the clipboard's contents.
`void`	`copy(IGraph sourceGraph, Predicate<IModelItem> filter)` Copies the elements indicated by the filter to the clipboard graph.
`protected void`	`copy(IGraph sourceGraph, Predicate<IModelItem> filter, IGraph targetGraph, INode targetRootNode, IElementCopiedCallback elementCopiedCallback)` Calls `GraphCopier.copy(IGraph, Predicate, IGraph, INode, PointD, IElementCopiedCallback)` on the current `ToClipboardCopier` instance or `FromClipboardCopier` instance, depending on whether the `targetGraph` is the `ClipboardGraph` instance.
`protected IGraph`	`createClipboardGraph()` Creates the graph used for the clipboard.
`Predicate<IModelItem>`	`createClipBoardHelperCopyFilter()` Convenience method that creates a `Predicate` that is based upon the outcome of the `IClipboardHelper.shouldCopy(IGraphClipboardContext, IModelItem)` method that can be found in the `ILookup.lookup(Class)` of the provided `IModelItem`.
`Predicate<IModelItem>`	`createClipBoardHelperCutFilter()` Convenience method that creates a `Predicate` that is based upon the outcome of the `IClipboardHelper.shouldCut(IGraphClipboardContext, IModelItem)` method that can be found in the `ILookup.lookup(Class)` of the provided `IModelItem`.
`Predicate<IModelItem>`	`createClipBoardHelperPasteFilter()` Convenience method that creates a `Predicate` that is based upon the outcome of the `IClipboardHelper.shouldPaste(IGraphClipboardContext, IModelItem, Object)` method that can be found in the `ILookup.lookup(Class)` of the provided `IModelItem`.
`protected IGraphClipboardContext`	`createContext(IGraph sourceGraph, IGraph targetGraph)` Factory method that creates the context for the upcoming calls to the `IClipboardHelper` methods.
`protected IClipboardIdProvider`	`createDefaultClipboardIdProvider()` Creates the default `IClipboardIdProvider` used by this instance to provide IDs for copied items.
`Predicate<IModelItem>`	`createDefaultCopyFilter(IGraphSelection selection, IGraph graph)` Creates a `Predicate` for use in the `copy(IGraph, Predicate, IGraph, INode, IElementCopiedCallback)` method.
`Predicate<IModelItem>`	`createDefaultCutFilter(IGraphSelection selection, IGraph graph)` Creates a `Predicate` for use in the `cut(IGraph, Predicate)` method.
`Predicate<IModelItem>`	`createDefaultDuplicateFilter(IGraphSelection selection, IGraph graph)` Creates a `Predicate` for use in the `duplicate(IInputModeContext, IGraph, Predicate, IElementCopiedCallback)` method.
`protected GraphCopier`	`createDuplicateCopier()` Factory method that creates the `DuplicateCopier`.
`protected GraphCopier`	`createFromClipboardCopier()` Factory method that creates the `FromClipboardCopier`.
`Predicate<IModelItem>`	`createSelectionFilter(IGraphSelection selection, IGraph graph)` Creates a `Predicate` for use in the `cut(IGraph, Predicate)` and `copy(IGraph, Predicate, IGraph, INode, IElementCopiedCallback)` methods.
`protected GraphCopier`	`createToClipboardCopier()` Factory method that creates the `ToClipboardCopier`.
`static Predicate<IModelItem>`	`createWrappedFilter(Predicate<IModelItem> coreFilter, IGraph graph, boolean restrictive)` Creates an induced `Predicate` from `coreFilter` for use in the `cut(IGraph, Predicate)` and `copy(IGraph, Predicate, IGraph, INode, IElementCopiedCallback)` methods that takes dependent items into account.
`void`	`cut(IGraph sourceGraph, Predicate<IModelItem> filter)` Cuts the items indicated by `filter` to the clipboard and removes them from the graph.
`void`	`duplicate(IInputModeContext context, IGraph sourceGraph, Predicate<IModelItem> filter, IElementCopiedCallback elementDuplicated)` Duplicates the elements indicated by the filter.
`IGraph`	`getClipboardGraph()` Gets the graph that contains the clipboard's contents.
`protected IClipboardHelper`	`getClipboardHelper(IModelItem item)` Retrieves the `IClipboardHelper` instance associated with the given item.
`GraphItemTypes`	`getCopyItems()` Gets the type of items that can be copied and pasted at all using the clipboard.
`GraphItemTypes`	`getDependentCopyItems()` Gets the type of items that depend on other elements but should automatically be copied implicitly to the clipboard if all elements that it depends on are explicitly selected for copying.
`GraphCopier`	`getDuplicateCopier()` Gets the `GraphCopier` instance that will be used to duplicate elements inside the graph.
`protected IEdge`	`getFoldingEdgeState(IEdge edge, FoldingEdgeStateId id)` Gets a folding state of an edge for a given `FoldingEdgeStateId`.
`GraphCopier`	`getFromClipboardCopier()` Gets the `GraphCopier` instance that will be used to copy the graph from the clipboard to the target graph.
`IClipboardIdProvider`	`getIdProvider()` Gets the `IClipboardIdProvider` used by this instance to provide IDs for copied items.
`GraphItemTypes`	`getIndependentCopyItems()` Gets the type of items that can be copied and pasted independently of their owning element.
`protected ILabelModelParameter`	`getLabelLayoutParameter(GraphCopier copier, IGraph graph, ILabel label, ILabelOwner newOwner)` Gets a `ILabelModelParameter` for the given `label` to be placed at the given `newOwner`.
`Object`	`getMemento(IModelItem clipboardItem)` Retrieves the memento associated with an item in the clipboard graph that has been stored with the item during `onElementCopied(IModelItem, IModelItem)` and `onElementCut(IModelItem, IModelItem)`.
`GraphClipboard.ParentNodeDetectionModes`	`getParentNodeDetection()` Gets whether or not nodes should be automatically put into a group node and if so how this group will be determined.
`PointD`	`getPasteDelta()` Gets a vector that will be used to move nodes and bends by after they have been pasted to the target graph.
`protected IPortLocationModelParameter`	`getPortLocationParameter(GraphCopier copier, IGraph graph, IPort originalPort, IPortOwner newOwner)` Gets a `IPortLocationModelParameter` for the given `originalPort` to be placed at the given `newOwner`.
`protected IEdge`	`getTarget(IBend originalBend)` Provides an `IEdge` where the given `originalBend` can be added to.
`protected IPort`	`getTarget(IEdge originalEdge, boolean atSource)` Provides an `IPort` where the given `originalEdge` can be added to.
`protected ILabelOwner`	`getTarget(ILabel originalLabel)` Provides an `ILabelOwner` where the given `originalLabel` can be added to.
`protected INode`	`getTarget(INode originalNode)` Provides a parent group node for the given `originalNode`.
`protected IPortOwner`	`getTarget(IPort originalPort)` Provides an `IPortOwner` where the given `originalPort` can be added to.
`GraphCopier`	`getToClipboardCopier()` Gets the `GraphCopier` instance that will be used to copy the graph to the clipboard.
`boolean`	`isDummy(IModelItem item)` Whether the given `item` is a "dummy" item which should not be pasted.
`boolean`	`isEmpty()` Determines whether the clipboard graph is empty.
`protected static boolean`	`isFoldingStateElement(IModelItem owner, IModelItem item)` Whether the given `item` exists in a folding state of its `owner`.
`boolean`	`isIgnoringEdgesWithOneNodeEnabled()` Whether to paste edges whose source or target node was selected when copying to the clipboard while the other node was not.
`protected void`	`onElementCopied(IModelItem original, IModelItem copy)` `IElementCopiedCallback` that will be invoked for each item that has been copied into the clipboard graph in response to a `copy(IGraph, Predicate, IGraph, INode, IElementCopiedCallback)` operation.
`protected void`	`onElementCut(IModelItem original, IModelItem copy)` `IElementCopiedCallback` that will be invoked for each item that has been copied into the clipboard graph in response to a `cut(IGraph, Predicate)` operation.
`protected void`	`onElementPasted(IModelItem original, IModelItem copy)` `IElementCopiedCallback` that will be invoked for each item that has been pasted into the target graph in response to a `paste(IGraph, Predicate, IGraph, INode, IElementCopiedCallback, Predicate)` operation.
`void`	`paste(IGraph targetGraph)` Pastes the contents from the `ClipboardGraph` to the `targetGraph` after applying a `filter`.
`void`	`paste(IGraph targetGraph, IGraphSelection selection)` Pastes the `ClipboardGraph`'s contents into the `targetGraph`, selecting all pasted elements.
`void`	`paste(IGraph targetGraph, Predicate<IModelItem> filter)` Pastes the contents from the `ClipboardGraph` to the `targetGraph` after applying a `filter`.
`void`	`paste(IGraph targetGraph, Predicate<IModelItem> filter, IElementCopiedCallback elementPasted)` Pastes the contents from the `ClipboardGraph` to the `targetGraph` after applying a `filter`.
`protected void`	`paste(IGraph sourceGraph, Predicate<IModelItem> filter, IGraph targetGraph, INode targetRootNode, IElementCopiedCallback elementCopiedCallback, Predicate<IModelItem> targetFilter)` Calls `GraphCopier.copy(IGraph, Predicate, IGraph, INode, PointD, IElementCopiedCallback)` on the current `FromClipboardCopier` instance, depending on whether the `targetGraph` is the `ClipboardGraph` instance.
`void`	`paste(IInputModeContext context, IGraph targetGraph, Predicate<IModelItem> filter, IElementCopiedCallback elementPasted, Predicate<IModelItem> targetFilter)` Pastes the contents from the `ClipboardGraph` to the `targetGraph` after applying a `filter`.
`protected void`	`removeElements(IGraph sourceGraph, Predicate<IModelItem> predicate)` Removes elements from the graph based on a `Predicate`.
`void`	`removeElementsCopiedListener(IEventHandler<IEventArgs> elementsCopiedEvent)` Removes the given listener for the `ElementsCopied` event that occurs when the `copy(IGraph, Predicate)` operation finished successfully.
`void`	`removeElementsCutListener(IEventHandler<IEventArgs> elementsCutEvent)` Removes the given listener for the `ElementsCut` event that occurs when the `cut(IGraph, Predicate)` operation finished successfully.
`void`	`removeElementsPastedListener(IEventHandler<IEventArgs> elementsPastedEvent)` Removes the given listener for the `ElementsPasted` event that occurs when the `paste(IInputModeContext, IGraph, Predicate, IElementCopiedCallback, Predicate)` operation finished successfully.
`void`	`setClipboardGraph(IGraph value)` Sets the graph that contains the clipboard's contents.
`void`	`setCopyItems(GraphItemTypes value)` Sets the type of items that can be copied and pasted at all using the clipboard.
`void`	`setDependentCopyItems(GraphItemTypes value)` Sets the type of items that depend on other elements but should automatically be copied implicitly to the clipboard if all elements that it depends on are explicitly selected for copying.
`void`	`setDuplicateCopier(GraphCopier value)` Sets the `GraphCopier` instance that will be used to duplicate elements inside the graph.
`void`	`setFromClipboardCopier(GraphCopier value)` Sets the `GraphCopier` instance that will be used to copy the graph from the clipboard to the target graph.
`void`	`setIdProvider(IClipboardIdProvider value)` Sets the `IClipboardIdProvider` used by this instance to provide IDs for copied items.
`void`	`setIgnoringEdgesWithOneNodeEnabled(boolean value)` Whether to paste edges whose source or target node was selected when copying to the clipboard while the other node was not.
`void`	`setIndependentCopyItems(GraphItemTypes value)` Sets the type of items that can be copied and pasted independently of their owning element.
`void`	`setParentNodeDetection(GraphClipboard.ParentNodeDetectionModes value)` Sets whether or not nodes should be automatically put into a group node and if so how this group will be determined.
`void`	`setPasteDelta(PointD value)` Sets a vector that will be used to move nodes and bends by after they have been pasted to the target graph.
`void`	`setToClipboardCopier(GraphCopier value)` Sets the `GraphCopier` instance that will be used to copy the graph to the clipboard.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - GraphClipboard
```
public GraphClipboard()
```
    Creates a new initially empty clipboard.
- Method Detail
  - addElementsCopiedListener
```
public final void addElementsCopiedListener(IEventHandler<IEventArgs> elementsCopiedEvent)
```
    Adds the given listener for the ElementsCopied event that occurs when the copy(IGraph, Predicate) operation finished successfully.
    
    Parameters:
    
    elementsCopiedEvent - The listener to add.
    
    See Also:
    
    removeElementsCopiedListener(IEventHandler)
  - addElementsCutListener
```
public final void addElementsCutListener(IEventHandler<IEventArgs> elementsCutEvent)
```
    Adds the given listener for the ElementsCut event that occurs when the cut(IGraph, Predicate) operation finished successfully.
    
    Parameters:
    
    elementsCutEvent - The listener to add.
    
    See Also:
    
    removeElementsCutListener(IEventHandler)
  - addElementsPastedListener
```
public final void addElementsPastedListener(IEventHandler<IEventArgs> elementsPastedEvent)
```
    Adds the given listener for the ElementsPasted event that occurs when the paste(IInputModeContext, IGraph, Predicate, IElementCopiedCallback, Predicate) operation finished successfully.
    
    Parameters:
    
    elementsPastedEvent - The listener to add.
    
    See Also:
    
    removeElementsPastedListener(IEventHandler)
  - clear
```
public void clear()
```
    Clears the clipboard's contents.
  - copy
```
public void copy(IGraph sourceGraph,
                 Predicate<IModelItem> filter)
```
    Copies the elements indicated by the filter to the clipboard graph.
    For each element copied to the clipboard graph the onElementCopied(IModelItem, IModelItem) delegate will be called. The actual work of this method is delegated to the ToClipboardCopier's GraphCopier.copy(IGraph, Predicate, IGraph, INode, PointD, IElementCopiedCallback) method.
    
    Parameters:
    
    sourceGraph - The graph to copy the contents from.
    
    filter - The filter to apply to the source graph's elements.
  - copy
```
protected void copy(IGraph sourceGraph,
                    Predicate<IModelItem> filter,
                    IGraph targetGraph,
                    INode targetRootNode,
                    IElementCopiedCallback elementCopiedCallback)
```
    Calls GraphCopier.copy(IGraph, Predicate, IGraph, INode, PointD, IElementCopiedCallback) on the current ToClipboardCopier instance or FromClipboardCopier instance, depending on whether the targetGraph is the ClipboardGraph instance.
    
    Parameters:
    
    sourceGraph - The source graph to pass to GraphCopier.copy(IGraph, Predicate, IGraph, INode, PointD, IElementCopiedCallback)
    
    filter - The predicate to pass on.
    
    targetGraph - The target graph to pass on.
    
    targetRootNode - The node to use as the root node in the grouped targetGraph.
    
    elementCopiedCallback - The delegate to pass on. For each element that is copied during the operation to the clipboard, this callback will be passed the original and the copy of the item. In case the sourceGraph is a folding view graph both elements are passed as master elements or folding state elements if a master element does not exist.
  - createClipboardGraph
```
protected IGraph createClipboardGraph()
```
    Creates the graph used for the clipboard.
    
    Returns:
    
    A new readily configured DefaultGraph instance.
  - createClipBoardHelperCopyFilter
```
public Predicate<IModelItem> createClipBoardHelperCopyFilter()
```
    Convenience method that creates a Predicate that is based upon the outcome of the IClipboardHelper.shouldCopy(IGraphClipboardContext, IModelItem) method that can be found in the ILookup.lookup(Class) of the provided IModelItem.
    
    Returns:
    
    A predicate that uses IClipboardHelper.shouldCopy(IGraphClipboardContext, IModelItem).
    
    See Also:
    
    copy(IGraph, Predicate, IGraph, INode, IElementCopiedCallback)
  - createClipBoardHelperCutFilter
```
public Predicate<IModelItem> createClipBoardHelperCutFilter()
```
    Convenience method that creates a Predicate that is based upon the outcome of the IClipboardHelper.shouldCut(IGraphClipboardContext, IModelItem) method that can be found in the ILookup.lookup(Class) of the provided IModelItem.
    
    Returns:
    
    A predicate that uses IClipboardHelper.shouldCut(IGraphClipboardContext, IModelItem).
    
    See Also:
    
    cut(IGraph, Predicate)
  - createClipBoardHelperPasteFilter
```
public Predicate<IModelItem> createClipBoardHelperPasteFilter()
```
    Convenience method that creates a Predicate that is based upon the outcome of the IClipboardHelper.shouldPaste(IGraphClipboardContext, IModelItem, Object) method that can be found in the ILookup.lookup(Class) of the provided IModelItem.
    
    Returns:
    
    A predicate that uses IClipboardHelper.shouldPaste(IGraphClipboardContext, IModelItem, Object).
    
    See Also:
    
    cut(IGraph, Predicate)
  - createContext
```
protected IGraphClipboardContext createContext(IGraph sourceGraph,
                                               IGraph targetGraph)
```
    Factory method that creates the context for the upcoming calls to the IClipboardHelper methods.
    
    Parameters:
    
    sourceGraph - The source graph of the operation.
    
    targetGraph - The target graph of the operation.
    
    Returns:
    
    A context that has the properties configured according to the parameters.
  - createDefaultClipboardIdProvider
```
protected IClipboardIdProvider createDefaultClipboardIdProvider()
```
    Creates the default IClipboardIdProvider used by this instance to provide IDs for copied items.
    The default implementation simply uses a reference to the original item as ID.
    
    Custom ID can be used to map between elements in different graphs.
  - createDefaultCopyFilter
```
public Predicate<IModelItem> createDefaultCopyFilter(IGraphSelection selection,
                                                     IGraph graph)
```
    Creates a Predicate for use in the copy(IGraph, Predicate, IGraph, INode, IElementCopiedCallback) method.
    This filter uses two predicates to decide whether a graph item can be copied. The base set of items specified by this filter is induced by the createSelectionFilter(IGraphSelection, IGraph). Optionally, this set can be restricted further by an IClipboardHelper.shouldCopy(IGraphClipboardContext, IModelItem) predicate. If such a predicate returns false for the item itself or any item this item depends on, then the item will not be copied. Items without such a predicate are handled solely according to their selection state.
    
    Parameters:
    
    selection - The selection model to base the filter on.
    
    graph - The graph to use for determining adjacency.
    
    Returns:
    
    A predicate that filters subgraph induced by the selection of nodes and restricted by an optional IClipboardHelper.shouldCopy(IGraphClipboardContext, IModelItem) predicate.
  - createDefaultCutFilter
```
public Predicate<IModelItem> createDefaultCutFilter(IGraphSelection selection,
                                                    IGraph graph)
```
    Creates a Predicate for use in the cut(IGraph, Predicate) method.
    This filter uses two predicates to decide whether a graph item can be cut. The base set of items specified by this filter is induced by the createSelectionFilter(IGraphSelection, IGraph). Optionally, this set can be restricted further by an IClipboardHelper.shouldCut(IGraphClipboardContext, IModelItem) predicate. If such a predicate returns false for the item itself or any item this item depends on, then the item will not be cut. Items without such a predicate are handled solely according to their selection state.
    
    Parameters:
    
    selection - The selection model to base the filter on.
    
    graph - The graph to use for determining adjacency.
    
    Returns:
    
    A predicate that filters subgraph induced by the selection of nodes and restricted by an optional IClipboardHelper.shouldCut(IGraphClipboardContext, IModelItem) predicate.
  - createDefaultDuplicateFilter
```
public Predicate<IModelItem> createDefaultDuplicateFilter(IGraphSelection selection,
                                                          IGraph graph)
```
    Creates a Predicate for use in the duplicate(IInputModeContext, IGraph, Predicate, IElementCopiedCallback) method.
    By default this method uses the same filter implementation as createDefaultCopyFilter(IGraphSelection, IGraph): This filter uses two predicates to decide whether a graph item will be duplicated. The base set of items specified by this filter is induced by the createSelectionFilter(IGraphSelection, IGraph). Optionally, this set can be restricted further by an IClipboardHelper.shouldCopy(IGraphClipboardContext, IModelItem) predicate. If such a predicate returns false for the item itself or any item this item depends on, then the item will not be copied. Items without such a predicate are handled solely according to their selection state.
    
    Parameters:
    
    selection - The selection model to base the filter on.
    
    graph - The graph to use for determining adjacency.
    
    Returns:
    
    A predicate that filters subgraph induced by the selection of nodes and restricted by an optional IClipboardHelper.shouldCopy(IGraphClipboardContext, IModelItem) predicate.
  - createDuplicateCopier
```
protected GraphCopier createDuplicateCopier()
```
    Factory method that creates the DuplicateCopier.
    
    Returns:
    
    A new GraphCopier instance.
  - createFromClipboardCopier
```
protected GraphCopier createFromClipboardCopier()
```
    Factory method that creates the FromClipboardCopier.
    
    Returns:
    
    A new GraphCopier instance.
  - createSelectionFilter
```
public Predicate<IModelItem> createSelectionFilter(IGraphSelection selection,
                                                   IGraph graph)
```
    Creates a Predicate for use in the cut(IGraph, Predicate) and copy(IGraph, Predicate, IGraph, INode, IElementCopiedCallback) methods.
    This predicate is based on the element induced by the set of selected nodes, e.g. each edge that has both of its adjacent port owners selected will be included as well as each label and port whose owner is included. Also ports where no adjacent edge is included (but edges exist), will not be included, unless the AutoCleanupEnabled is set to false.
    
    Parameters:
    
    selection - The selection model to base the filter on.
    
    graph - The graph to use for determining adjacency.
    
    Returns:
    
    A predicate that filters subgraph induced by the selection of nodes.
  - createToClipboardCopier
```
protected GraphCopier createToClipboardCopier()
```
    Factory method that creates the ToClipboardCopier.
    
    Returns:
    
    A new GraphCopier instance.
  - createWrappedFilter
```
public static final Predicate<IModelItem> createWrappedFilter(Predicate<IModelItem> coreFilter,
                                                              IGraph graph,
                                                              boolean restrictive)
```
    Creates an induced Predicate from coreFilter for use in the cut(IGraph, Predicate) and copy(IGraph, Predicate, IGraph, INode, IElementCopiedCallback) methods that takes dependent items into account.
    This method can create a predicate for only a core set of items which is then extended or restricted depending on the predicate values of graph item dependencies.
    
    The restrictive parameter determines whether the result restricts or extends the set of elements handled by coreFilter:
    - If restrictive is false, an item is allowed if either coreFilter returns true for itself or if all items it depends on (e.g. label/port owner, source/target port etc.) are allowed by coreFilter.
    - If restrictive is true, an item is forbidden if either coreFilter returns false for itself or if any item it depends on (e.g. label/port owner, source/target port etc.) is forbidden by coreFilter.
    Parameters:
    
    coreFilter - The core predicate for the base set of elements.
    
    graph - The graph to use for determining adjacency.
    
    restrictive - Whether to create a restriction or extension for the coreFilter predicate
  - cut
```
public void cut(IGraph sourceGraph,
                Predicate<IModelItem> filter)
```
    Cuts the items indicated by filter to the clipboard and removes them from the graph.
    This method delegates the core work to copy(IGraph, Predicate, IGraph, INode, IElementCopiedCallback) which will use the ToClipboardCopier to copy the cut elements to the clipboard.
    
    Parameters:
    
    sourceGraph - The graph to cut the items from.
    
    filter - The filter to use.
    
    See Also:
    
    createSelectionFilter(IGraphSelection, IGraph)
  - duplicate
```
public void duplicate(IInputModeContext context,
                      IGraph sourceGraph,
                      Predicate<IModelItem> filter,
                      IElementCopiedCallback elementDuplicated)
```
    Duplicates the elements indicated by the filter.
    The ClipboardGraph is not altered by this operation.
    
    Parameters:
    
    context - The current IInputModeContext.
    
    sourceGraph - The graph whose elements should be duplicated.
    
    filter - A Predicate which returns true for elements which should be duplicated.
    
    elementDuplicated - An IElementCopiedCallback which gets invoked for each element which has been duplicated. The two parameters passed into the callback are guaranteed to be part of the sourceGraph.
  - getClipboardGraph
```
public final IGraph getClipboardGraph()
```
    Gets the graph that contains the clipboard's contents.
    
    Throws:
    
    NullPointerException - If value is null.
    
    Returns:
    
    The ClipboardGraph.
    
    See Also:
    
    setClipboardGraph(IGraph)
  - getClipboardHelper
```
protected IClipboardHelper getClipboardHelper(IModelItem item)
```
    Retrieves the IClipboardHelper instance associated with the given item.
    This implementation uses the item's ILookup.lookup(Class) method to retrieve the helper instance.
    
    Parameters:
    
    item - The item to find the clipboard helper for.
    
    Returns:
    
    An instance or null.
  - getCopyItems
```
public final GraphItemTypes getCopyItems()
```
    Gets the type of items that can be copied and pasted at all using the clipboard.
    If the corresponding element type is set in this property, items can be effectively copied.
    
    If the corresponding element type is not set in this property, items will not be pasted, even if they have been explicitly selected. They may copied to the clipboard and become part of the ClipboardGraph, nevertheless though, if they are required as dummy elements. But these elements will not be pasted to the target during paste or duplicate operations.
    
    The default is GraphItemTypes.ALL.
    
    Returns:
    
    The CopyItems.
    
    See Also:
    
    setCopyItems(GraphItemTypes)
  - getDependentCopyItems
```
public final GraphItemTypes getDependentCopyItems()
```
    Gets the type of items that depend on other elements but should automatically be copied implicitly to the clipboard if all elements that it depends on are explicitly selected for copying.
    Labels depend on their owner, like ports depend on their owner. Also bends of course depend on their owning edge.
    
    If the corresponding element type is set in this property, items that depend on other items are implicitly included in the copy operation, if all of the items that they depend on are included recursively, even if they are not included explicitly themselves.
    
    The default is GraphItemTypes.ALL minus GraphItemTypes.NODE, which means that selecting a number of nodes will automatically select all elements that directly and indirectly depend on the existence of this set of nodes will be copied to the clipboard, too.
    
    Technically nodes do not depend on anything. Setting this property to a value that includes GraphItemTypes.NODE will include all child nodes for every selected group node.
    
    Returns:
    
    The DependentCopyItems.
    
    See Also:
    
    setDependentCopyItems(GraphItemTypes)
  - getDuplicateCopier
```
public final GraphCopier getDuplicateCopier()
```
    Gets the GraphCopier instance that will be used to duplicate elements inside the graph.
    This instance is lazily created using createDuplicateCopier().
    
    Returns:
    
    The DuplicateCopier.
    
    See Also:
    
    setDuplicateCopier(GraphCopier)
  - getFoldingEdgeState
```
protected IEdge getFoldingEdgeState(IEdge edge,
                                    FoldingEdgeStateId id)
```
    Gets a folding state of an edge for a given FoldingEdgeStateId.
    This method might be overridden to map folding states for edges whose source or target node's hierarchy might have changed during a paste operation.
    
    Parameters:
    
    edge - The edge to get the folding state for.
    
    id - The original FoldingEdgeStateId to get the folding state for. Passing null will return the folding state which was visible when the edge was copied into the clipboard.
    
    Returns:
    
    The folding state which is mapped to the given id. May be null.
  - getFromClipboardCopier
```
public final GraphCopier getFromClipboardCopier()
```
    Gets the GraphCopier instance that will be used to copy the graph from the clipboard to the target graph.
    This instance is lazily created using createFromClipboardCopier().
    
    Returns:
    
    The FromClipboardCopier.
    
    See Also:
    
    setFromClipboardCopier(GraphCopier)
  - getIdProvider
```
public final IClipboardIdProvider getIdProvider()
```
    Gets the IClipboardIdProvider used by this instance to provide IDs for copied items.
    The default implementation simply uses a reference to the original item as ID.
    Custom ID can be used to map between elements in different graphs.
    
    Returns:
    
    The IdProvider.
    
    See Also:
    
    setIdProvider(IClipboardIdProvider)
  - getIndependentCopyItems
```
public final GraphItemTypes getIndependentCopyItems()
```
    Gets the type of items that can be copied and pasted independently of their owning element.
    Labels depend on their owner, like ports depend on their owner. Also bends of course depend on their owning edge.
    
    If the corresponding element type is set in this property, items can be copied alone to the clipboard and be pasted onto different owning elements.
    
    This enables copying of a label to one or more owners, without having to copy the owner of the label. Also ports can be copied to other IPortOwners and bends to other edges.
    
    The default is GraphItemTypes.ALL which means that all elements can be copied to the clipboard even if the items that they depend on are not copied to the clipboard.
    
    Technically owning elements are still part of the clipboard as dummy elements, but these elements will not be pasted to the target during paste or duplicate operations.
    
    Returns:
    
    The IndependentCopyItems.
    
    See Also:
    
    setIndependentCopyItems(GraphItemTypes)
  - getLabelLayoutParameter
```
protected ILabelModelParameter getLabelLayoutParameter(GraphCopier copier,
                                                       IGraph graph,
                                                       ILabel label,
                                                       ILabelOwner newOwner)
```
    Gets a ILabelModelParameter for the given label to be placed at the given newOwner.
    Implementations might delegate to GraphCopier.copyLabelLayoutParameter(IGraph, ILabel) to copy the existing parameter or use the NodeDefaults or EdgeDefaults to create a new one. Note that the type of the owner might have changed during the copy operation.
    
    Parameters:
    
    copier - The GraphCopier whose GraphCopier.copyLabelLayoutParameter(IGraph, ILabel) method can be used to copy the existing parameter.
    
    graph - The IGraph whose NodeDefaults or EdgeDefaults can be used to create a new parameter.
    
    label - The label to be copied.
    
    newOwner - The new owner for the label.
    
    Returns:
    
    An ILabelModelParameter for the copied label.
  - getMemento
```
public final Object getMemento(IModelItem clipboardItem)
```
    Retrieves the memento associated with an item in the clipboard graph that has been stored with the item during onElementCopied(IModelItem, IModelItem) and onElementCut(IModelItem, IModelItem).
    
    Parameters:
    
    clipboardItem - The item in the clipboard graph.
    
    Returns:
    
    The object returned by the IClipboardHelper methods or null.
  - getParentNodeDetection
```
public final GraphClipboard.ParentNodeDetectionModes getParentNodeDetection()
```
    Gets whether or not nodes should be automatically put into a group node and if so how this group will be determined.
    This property is used by getTarget(INode) to decide what node to yield as the target group node for the newly pasted node.
    
    The default is GraphClipboard.ParentNodeDetectionModes.SELECTION|GraphClipboard.ParentNodeDetectionModes.PREVIOUS_PARENT.
    
    Returns:
    
    The ParentNodeDetection.
    
    See Also:
    
    setParentNodeDetection(ParentNodeDetectionModes)
  - getPasteDelta
```
public final PointD getPasteDelta()
```
    Gets a vector that will be used to move nodes and bends by after they have been pasted to the target graph.
    
    Returns:
    
    The PasteDelta.
    
    See Also:
    
    setPasteDelta(PointD)
  - getPortLocationParameter
```
protected IPortLocationModelParameter getPortLocationParameter(GraphCopier copier,
                                                               IGraph graph,
                                                               IPort originalPort,
                                                               IPortOwner newOwner)
```
    Gets a IPortLocationModelParameter for the given originalPort to be placed at the given newOwner.
    Implementations might delegate to GraphCopier.copyPortLocationParameter(IGraph, IPort) to copy the existing parameter or use the NodeDefaults or EdgeDefaults to create a new one. Note that the type of the owner might have changed during the copy operation.
    
    Parameters:
    
    copier - The GraphCopier whose GraphCopier.copyPortLocationParameter(IGraph, IPort) method can be used to copy the existing parameter.
    
    graph - The IGraph whose NodeDefaults or EdgeDefaults can be used to create a new parameter.
    
    originalPort - The port to be copied.
    
    newOwner - The new owner for the port.
    
    Returns:
    
    An IPortLocationModelParameter for the copied port.
  - getTarget
```
protected IEdge getTarget(IBend originalBend)
```
    Provides an IEdge where the given originalBend can be added to.
    Called for IBends whose edge is not copied to provide a new owner. Might return null if no target for the given originalBend is found. In this case the bend will not be copied.
    
    Parameters:
    
    originalBend - The bend to be copied.
    
    Returns:
    
    An IEdge for the bend to be added to or null if the bend should not be copied.
  - getTarget
```
protected IPort getTarget(IEdge originalEdge,
                          boolean atSource)
```
    Provides an IPort where the given originalEdge can be added to.
    Called for IEdges whose source or target ports are not copied to provide a new port. Might return null if no target for the given originalEdge is found. In this case the edge will not be copied.
    
    Parameters:
    
    originalEdge - The edge to be copied.
    
    atSource - Whether to look for a source port.
    
    Returns:
    
    An IPort for the edge to be added to or null if the edge should not be copied.
  - getTarget
```
protected ILabelOwner getTarget(ILabel originalLabel)
```
    Provides an ILabelOwner where the given originalLabel can be added to.
    Called for ILabels whose owners are not copied to provide a new owner. Might return null if no target for the given originalLabel is found. In this case the label will not be copied.
    
    Parameters:
    
    originalLabel - The label to be copied.
    
    Returns:
    
    An ILabelOwner for the label to be added to or null if the label should not be copied.
  - getTarget
```
protected INode getTarget(INode originalNode)
```
    Provides a parent group node for the given originalNode.
    Called for INodes to place them inside a group node. Might return null if the given node should be placed at the root or if the graph is not grouped.
    
    Parameters:
    
    originalNode - The node to be copied.
    
    Returns:
    
    The new parent group of the node or null if the node should be placed at the root of the hierarchy or if the graph is not grouped.
    
    See Also:
    
    getParentNodeDetection()
  - getTarget
```
protected IPortOwner getTarget(IPort originalPort)
```
    Provides an IPortOwner where the given originalPort can be added to.
    Called for IPorts whose owners are not copied to provide a new owner. Might return null if no target for the given originalPort is found. In this case the port will not be copied.
    
    Parameters:
    
    originalPort - The port to be copied.
    
    Returns:
    
    An IPortOwner for the port to be added to or null if the port should not be copied.
  - getToClipboardCopier
```
public final GraphCopier getToClipboardCopier()
```
    Gets the GraphCopier instance that will be used to copy the graph to the clipboard.
    This instance is lazily created using createToClipboardCopier().
    
    Returns:
    
    The ToClipboardCopier.
    
    See Also:
    
    setToClipboardCopier(GraphCopier)
  - isDummy
```
public final boolean isDummy(IModelItem item)
```
    Whether the given item is a "dummy" item which should not be pasted.
    A dummy item is used to keep IModelItems which cannot exist without an owner in the ClipboardGraph (e.g. ILabels).
    
    Parameters:
    
    item - The item to test.
    
    Returns:
    
    true if the item is a "dummy" item.
  - isEmpty
```
public boolean isEmpty()
```
    Determines whether the clipboard graph is empty.
    
    Returns:
    
    The Empty.
  - isFoldingStateElement
```
protected static final boolean isFoldingStateElement(IModelItem owner,
                                                     IModelItem item)
```
    Whether the given item exists in a folding state of its owner.
    
    Parameters:
    
    owner - The owner of the given item.
    
    item - An ILabel, IPort, or IBend.
    
    Returns:
    
    true if the given item exists in a folding state.
  - isIgnoringEdgesWithOneNodeEnabled
```
public final boolean isIgnoringEdgesWithOneNodeEnabled()
```
    Whether to paste edges whose source or target node was selected when copying to the clipboard while the other node was not.
    The default is false.
    
    Returns:
    
    The IgnoringEdgesWithOneNodeEnabled.
    
    See Also:
    
    setIgnoringEdgesWithOneNodeEnabled(boolean)
  - onElementCopied
```
protected void onElementCopied(IModelItem original,
                               IModelItem copy)
```
    IElementCopiedCallback that will be invoked for each item that has been copied into the clipboard graph in response to a copy(IGraph, Predicate, IGraph, INode, IElementCopiedCallback) operation.
    This implementation will ILookup.lookup(Class) a IClipboardHelper for each item in the original graph and remember the memento retrieved by the IClipboardHelper.copy(IGraphClipboardContext, IModelItem) method for later use during the onElementPasted(IModelItem, IModelItem) operation.
    
    Parameters:
    
    original - The original element from the source graph instance. If the source graph is a managed folding view, this is always a master item.
    
    copy - The copy from the clipboard graph.
  - onElementCut
```
protected void onElementCut(IModelItem original,
                            IModelItem copy)
```
    IElementCopiedCallback that will be invoked for each item that has been copied into the clipboard graph in response to a cut(IGraph, Predicate) operation.
    This implementation will ILookup.lookup(Class) a IClipboardHelper for each item in the original graph and remember the memento retrieved by the IClipboardHelper.cut(IGraphClipboardContext, IModelItem) method for later use during the onElementPasted(IModelItem, IModelItem) operation.
    
    Parameters:
    
    original - The original element from the source graph instance. If the source graph is a managed folding view, this is always a master item.
    
    copy - The copy from the clipboard graph.
  - onElementPasted
```
protected void onElementPasted(IModelItem original,
                               IModelItem copy)
```
    IElementCopiedCallback that will be invoked for each item that has been pasted into the target graph in response to a paste(IGraph, Predicate, IGraph, INode, IElementCopiedCallback, Predicate) operation.
    This method will use a previously stored IClipboardHelper to let it finish its work.
    
    Parameters:
    
    original - The original element from the clipboard graph instance. If the target graph is a managed folding view, this is always a master item.
    
    copy - The copy from the target graph.
  - paste
```
public final void paste(IGraph targetGraph)
```
    Pastes the contents from the ClipboardGraph to the targetGraph after applying a filter.
    For each element pasted into the graph the elementPasted delegate will be invoked and the onElementPasted(IModelItem, IModelItem) method will be called. The actual work of this method is delegated to the FromClipboardCopier's GraphCopier.copy(IGraph, Predicate, IGraph, INode, PointD, IElementCopiedCallback) method.
    
    Parameters:
    
    targetGraph - The graph to paste the contents in.
  - paste
```
public void paste(IGraph targetGraph,
                  IGraphSelection selection)
```
    Pastes the ClipboardGraph's contents into the targetGraph, selecting all pasted elements.
    The actual work of this method is delegated to the FromClipboardCopier's GraphCopier.copy(IGraph, Predicate, IGraph, INode, PointD, IElementCopiedCallback) method.
    
    Parameters:
    
    targetGraph - The graph to paste into.
    
    selection - The selection model to set the selection on.
  - paste
```
public final void paste(IGraph targetGraph,
                        Predicate<IModelItem> filter)
```
    Pastes the contents from the ClipboardGraph to the targetGraph after applying a filter.
    For each element pasted into the graph the elementPasted delegate will be invoked and the onElementPasted(IModelItem, IModelItem) method will be called. The actual work of this method is delegated to the FromClipboardCopier's GraphCopier.copy(IGraph, Predicate, IGraph, INode, PointD, IElementCopiedCallback) method.
    
    Parameters:
    
    targetGraph - The graph to paste the contents in.
    
    filter - The filter to apply to the clipboard graph.
  - paste
```
public void paste(IGraph targetGraph,
                  Predicate<IModelItem> filter,
                  IElementCopiedCallback elementPasted)
```
    Pastes the contents from the ClipboardGraph to the targetGraph after applying a filter.
    For each element pasted into the graph the elementPasted delegate will be invoked and the onElementPasted(IModelItem, IModelItem) method will be called. The actual work of this method is delegated to the FromClipboardCopier's GraphCopier.copy(IGraph, Predicate, IGraph, INode, PointD, IElementCopiedCallback) method.
    
    Parameters:
    
    targetGraph - The graph to paste the contents in.
    
    filter - The filter to apply to the clipboard graph.
    
    elementPasted - The callback to use for each element that has been pasted. For each element that is copied during the operation to the clipboard, this callback will be passed the original and the copy of the item. In case the targetGraph is a folding view graph the original element is passed as master elements or folding state elements if a master element does not exist. The copied element is always part of the targetGraph.
  - paste
```
protected void paste(IGraph sourceGraph,
                     Predicate<IModelItem> filter,
                     IGraph targetGraph,
                     INode targetRootNode,
                     IElementCopiedCallback elementCopiedCallback,
                     Predicate<IModelItem> targetFilter)
```
    Calls GraphCopier.copy(IGraph, Predicate, IGraph, INode, PointD, IElementCopiedCallback) on the current FromClipboardCopier instance, depending on whether the targetGraph is the ClipboardGraph instance.
    
    Parameters:
    
    sourceGraph - The source graph to pass to GraphCopier.copy(IGraph, Predicate, IGraph, INode, PointD, IElementCopiedCallback)
    
    filter - The predicate to pass on.
    
    targetGraph - The target graph to pass on.
    
    targetRootNode - The node to use as the root node in the grouped targetGraph.
    
    elementCopiedCallback - The delegate to pass on. For each element that is copied during the operation to the clipboard, this callback will be passed the original and the copy of the item. In case the targetGraph is a folding view graph the original element is passed as master elements or folding state elements if a master element does not exist. The copied element is always part of the targetGraph.
    
    targetFilter - This predicate is used to determine which INodes and IEdges can be used as targets for paste operations, e.g. if a labels or ports are copied without their owners. If null all model items can be used as targets.
  - paste
```
public void paste(IInputModeContext context,
                  IGraph targetGraph,
                  Predicate<IModelItem> filter,
                  IElementCopiedCallback elementPasted,
                  Predicate<IModelItem> targetFilter)
```
    Pastes the contents from the ClipboardGraph to the targetGraph after applying a filter.
    For each element pasted into the graph the elementPasted delegate will be invoked and the onElementPasted(IModelItem, IModelItem) method will be called. The actual work of this method is delegated to the FromClipboardCopier's GraphCopier.copy(IGraph, Predicate, IGraph, INode, PointD, IElementCopiedCallback) method.
    Providing a valid targetFilter allows for pasting ILabels, IPorts, and IEdges without valid owners.
    
    Parameters:
    
    context - A valid input mode context. Passing a valid input mode context is required for keeping orthogonal edges at group nodes whose size might be adjusted after the paste operation.
    
    targetGraph - The graph to paste the contents in.
    
    filter - The filter to apply to the clipboard graph.
    
    elementPasted - The callback to use for each element that has been pasted. For each element that is copied during the operation to the clipboard, this callback will be passed the original and the copy of the item. In case the targetGraph is a folding view graph the original element is passed as master elements or folding state elements if a master element does not exist. The copied element is always part of the targetGraph.
    
    targetFilter - A filter which returns true for model items which can be used as target for clipboard items which need an owner (e.g. ILabels which were copied without their owner). If null all model items can be used as targets.
  - removeElements
```
protected void removeElements(IGraph sourceGraph,
                              Predicate<IModelItem> predicate)
```
    Removes elements from the graph based on a Predicate.
    
    Parameters:
    
    sourceGraph - The graph to remove elements from.
    
    predicate - The predicate that decides which elements to remove.
    
    See Also:
    
    cut(IGraph, Predicate)
  - removeElementsCopiedListener
```
public final void removeElementsCopiedListener(IEventHandler<IEventArgs> elementsCopiedEvent)
```
    Removes the given listener for the ElementsCopied event that occurs when the copy(IGraph, Predicate) operation finished successfully.
    
    Parameters:
    
    elementsCopiedEvent - The listener to remove.
    
    See Also:
    
    addElementsCopiedListener(IEventHandler)
  - removeElementsCutListener
```
public final void removeElementsCutListener(IEventHandler<IEventArgs> elementsCutEvent)
```
    Removes the given listener for the ElementsCut event that occurs when the cut(IGraph, Predicate) operation finished successfully.
    
    Parameters:
    
    elementsCutEvent - The listener to remove.
    
    See Also:
    
    addElementsCutListener(IEventHandler)
  - removeElementsPastedListener
```
public final void removeElementsPastedListener(IEventHandler<IEventArgs> elementsPastedEvent)
```
    Removes the given listener for the ElementsPasted event that occurs when the paste(IInputModeContext, IGraph, Predicate, IElementCopiedCallback, Predicate) operation finished successfully.
    
    Parameters:
    
    elementsPastedEvent - The listener to remove.
    
    See Also:
    
    addElementsPastedListener(IEventHandler)
  - setClipboardGraph
```
public final void setClipboardGraph(IGraph value)
```
    Sets the graph that contains the clipboard's contents.
    
    Throws:
    
    NullPointerException - If value is null.
    
    Parameters:
    
    value - The ClipboardGraph to set.
    
    See Also:
    
    getClipboardGraph()
  - setCopyItems
```
public final void setCopyItems(GraphItemTypes value)
```
    Sets the type of items that can be copied and pasted at all using the clipboard.
    If the corresponding element type is set in this property, items can be effectively copied.
    
    If the corresponding element type is not set in this property, items will not be pasted, even if they have been explicitly selected. They may copied to the clipboard and become part of the ClipboardGraph, nevertheless though, if they are required as dummy elements. But these elements will not be pasted to the target during paste or duplicate operations.
    
    The default is GraphItemTypes.ALL.
    
    Parameters:
    
    value - The CopyItems to set.
    
    See Also:
    
    getCopyItems()
  - setDependentCopyItems
```
public final void setDependentCopyItems(GraphItemTypes value)
```
    Sets the type of items that depend on other elements but should automatically be copied implicitly to the clipboard if all elements that it depends on are explicitly selected for copying.
    Labels depend on their owner, like ports depend on their owner. Also bends of course depend on their owning edge.
    
    If the corresponding element type is set in this property, items that depend on other items are implicitly included in the copy operation, if all of the items that they depend on are included recursively, even if they are not included explicitly themselves.
    
    The default is GraphItemTypes.ALL minus GraphItemTypes.NODE, which means that selecting a number of nodes will automatically select all elements that directly and indirectly depend on the existence of this set of nodes will be copied to the clipboard, too.
    
    Technically nodes do not depend on anything. Setting this property to a value that includes GraphItemTypes.NODE will include all child nodes for every selected group node.
    
    Parameters:
    
    value - The DependentCopyItems to set.
    
    See Also:
    
    getDependentCopyItems()
  - setDuplicateCopier
```
public final void setDuplicateCopier(GraphCopier value)
```
    Sets the GraphCopier instance that will be used to duplicate elements inside the graph.
    This instance is lazily created using createDuplicateCopier().
    
    Parameters:
    
    value - The DuplicateCopier to set.
    
    See Also:
    
    getDuplicateCopier()
  - setFromClipboardCopier
```
public final void setFromClipboardCopier(GraphCopier value)
```
    Sets the GraphCopier instance that will be used to copy the graph from the clipboard to the target graph.
    This instance is lazily created using createFromClipboardCopier().
    
    Parameters:
    
    value - The FromClipboardCopier to set.
    
    See Also:
    
    getFromClipboardCopier()
  - setIdProvider
```
public final void setIdProvider(IClipboardIdProvider value)
```
    Sets the IClipboardIdProvider used by this instance to provide IDs for copied items.
    The default implementation simply uses a reference to the original item as ID.
    Custom ID can be used to map between elements in different graphs.
    
    Parameters:
    
    value - The IdProvider to set.
    
    See Also:
    
    getIdProvider()
  - setIgnoringEdgesWithOneNodeEnabled
```
public final void setIgnoringEdgesWithOneNodeEnabled(boolean value)
```
    Whether to paste edges whose source or target node was selected when copying to the clipboard while the other node was not.
    The default is false.
    
    Parameters:
    
    value - The IgnoringEdgesWithOneNodeEnabled to set.
    
    See Also:
    
    isIgnoringEdgesWithOneNodeEnabled()
  - setIndependentCopyItems
```
public final void setIndependentCopyItems(GraphItemTypes value)
```
    Sets the type of items that can be copied and pasted independently of their owning element.
    Labels depend on their owner, like ports depend on their owner. Also bends of course depend on their owning edge.
    
    If the corresponding element type is set in this property, items can be copied alone to the clipboard and be pasted onto different owning elements.
    
    This enables copying of a label to one or more owners, without having to copy the owner of the label. Also ports can be copied to other IPortOwners and bends to other edges.
    
    The default is GraphItemTypes.ALL which means that all elements can be copied to the clipboard even if the items that they depend on are not copied to the clipboard.
    
    Technically owning elements are still part of the clipboard as dummy elements, but these elements will not be pasted to the target during paste or duplicate operations.
    
    Parameters:
    
    value - The IndependentCopyItems to set.
    
    See Also:
    
    getIndependentCopyItems()
  - setParentNodeDetection
```
public final void setParentNodeDetection(GraphClipboard.ParentNodeDetectionModes value)
```
    Sets whether or not nodes should be automatically put into a group node and if so how this group will be determined.
    This property is used by getTarget(INode) to decide what node to yield as the target group node for the newly pasted node.
    
    The default is GraphClipboard.ParentNodeDetectionModes.SELECTION|GraphClipboard.ParentNodeDetectionModes.PREVIOUS_PARENT.
    
    Parameters:
    
    value - The ParentNodeDetection to set.
    
    See Also:
    
    getParentNodeDetection()
  - setPasteDelta
```
public final void setPasteDelta(PointD value)
```
    Sets a vector that will be used to move nodes and bends by after they have been pasted to the target graph.
    
    Parameters:
    
    value - The PasteDelta to set.
    
    See Also:
    
    getPasteDelta()
  - setToClipboardCopier
```
public final void setToClipboardCopier(GraphCopier value)
```
    Sets the GraphCopier instance that will be used to copy the graph to the clipboard.
    This instance is lazily created using createToClipboardCopier().
    
    Parameters:
    
    value - The ToClipboardCopier to set.
    
    See Also:
    
    getToClipboardCopier()

Class GraphClipboard

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

GraphClipboard

Method Detail

addElementsCopiedListener

addElementsCutListener

addElementsPastedListener

clear

copy

copy

createClipboardGraph

createClipBoardHelperCopyFilter

createClipBoardHelperCutFilter

createClipBoardHelperPasteFilter

createContext

createDefaultClipboardIdProvider

createDefaultCopyFilter

createDefaultCutFilter

createDefaultDuplicateFilter

createDuplicateCopier

createFromClipboardCopier

createSelectionFilter

createToClipboardCopier

createWrappedFilter

cut

duplicate

getClipboardGraph

getClipboardHelper

getCopyItems

getDependentCopyItems

getDuplicateCopier

getFoldingEdgeState

getFromClipboardCopier

getIdProvider

getIndependentCopyItems

getLabelLayoutParameter

getMemento

getParentNodeDetection

getPasteDelta

getPortLocationParameter

getTarget

getTarget

getTarget

getTarget

getTarget

getToClipboardCopier

isDummy

isEmpty

isFoldingStateElement

isIgnoringEdgesWithOneNodeEnabled

onElementCopied

onElementCut

onElementPasted

paste

paste

paste

paste

paste

paste

removeElements

removeElementsCopiedListener

removeElementsCutListener

removeElementsPastedListener

setClipboardGraph

setCopyItems

setDependentCopyItems

setDuplicateCopier

setFromClipboardCopier

setIdProvider

setIgnoringEdgesWithOneNodeEnabled

setIndependentCopyItems

setParentNodeDetection

setPasteDelta

setToClipboardCopier