How to Copy&Paste between models?

[rsoika]

I whant to copy/paste elements from one editor window into another.

Currently this works only in one opened Editor window. I have implemented a RequestClipboardDataAction to react on a 'Copy' command from the UI

public class BPMNClipboardDataActionHandler extends AbstractActionHandler<RequestClipboardDataAction> {

    private static Logger logger = LogManager.getLogger(BPMNClipboardDataActionHandler.class);

    @Inject
    protected BPMNGModelState modelState;

    @Override
    protected List<Action> executeAction(final RequestClipboardDataAction actualAction) {
        EditorContext ctx = actualAction.getEditorContext();
        List<String> selectedElements = ctx.getSelectedElementIds();
        logger.debug("... copy " + selectedElements.size() + " elements...");

        // return a data action with the selected ids
        Map<String, String> data = new HashMap<String, String>();
        data.put("bpmn", String.join(",", selectedElements));
        SetClipboardDataAction clipboardDataAction = new SetClipboardDataAction(data);
        return this.listOf(clipboardDataAction);
    }

}

I understand that in this way I have the data only in my current ModelState and I can only 'paste' the data into the same model.
I have currently already implemented a PasteOperation:

public class BPMNPasteOperationHandler extends GModelOperationHandler<PasteOperation> {

    private static Logger logger = LogManager.getLogger(BPMNPasteOperationHandler.class);

    @Inject
    protected BPMNGModelState modelState;

    @Inject
    protected ActionDispatcher actionDispatcher;

    @Override
    public Optional<Command> createCommand(PasteOperation operation) {
        return commandOf(() -> executeOperation(operation));
    }

    private void executeOperation(PasteOperation operation) {
        BPMNPoint refPoint = null;
        double xOffset = 0;
        double yOffset = 0;
        Map<String, String> clonedIDs = new HashMap<String, String>();
        List<String> newElementIDList = new ArrayList<String>();

        // get copy data
        Map<String, String> data = operation.getClipboardData();
        // get list of ids...
       .....

    }
....

My plan was to store the data into a general memory or a temp file to allow Paste Actions between two different model files.

But I now regonized, that the PasteOperation in a second opened Model File will never be triggered.

I register my OpeationHandler in my DiagramModule:

    @Override
    protected void configureOperationHandlers(final MultiBinding<OperationHandler<?>> binding) {
        super.configureOperationHandlers(binding);

	.....
        // Clipboard
        binding.add(BPMNPasteOperationHandler.class);

What is the correct way to handel the Paste Action when I whant to copy elements from one editor into another?

Thanks for help

===
Ralph

[martin-fleck-at]

Yes, you are right, currently GLSP writes only a UUID into the real system clipboard and keeps the payload in LocalClipboardService that is bound per diagram and if the UUIDs do not match we do not execute the paste operation. Improving upon this and other clipboard support features has been tracked in #148.

But I believe even if that were to work, the selected element ids put into the clipboard may not work as they will not match the proper element ids anyways. So ideally, what we need for that to work is:

• a storage that is shared across diagrams (this may also be different between Theia where we have a single module and VS Code where we have iframes).
• a self-contained payload that works across diagrams (e.g., a BPMN fragment)

For the payload part, the default GModel-based handlers may be a good reference: GModelRequestClipboardDataActionHandler serializes the selected elements themselves under application/json, and GModelPasteOperationHandler deserializes them, reassigns fresh ids and rewires the edges. So I'd put a self-contained BPMN fragment into the clipboard data instead of the id list and make BPMNPasteOperationHandler a pure import of that fragment so that it no longer matters which model the copy came from.

For the shared storage part, you have two options today:

a) Share the clipboard on the client. Rebind TYPES.IAsyncClipboardService to your own implementation that is shared across diagram containers. The UUID handshake already works across editors, it's only the store that is per-diagram, so ServerCopyPasteHandler can stay as it is. In Theia a module-scoped singleton is enough; in VS Code every diagram is its own webview iframe, so you'd need localStorage or a round-trip to the extension host.

b) Let the server own the clipboard. This is what the Eclipse integration does: EclipseCopyPasteActionHandler.handlePaste always dispatches the PasteOperation with empty clipboard data and lets the server keep the payload. That matches your idea of a shared memory/temp file. Important detail: the holder has to be a singleton outside the session-scoped injector (bound in the server module, not in your DiagramModule), otherwise you just move the same per-model problem to the server. The trade-off is that you lose the "user copied something else in the meantime" detection and can't paste into other applications.

If you only care about editor-to-editor within the same application, (b) is the least amount of fighting with browser clipboard restrictions. (a) is closer to where we'd want to take #148. So if you build something there, feedback or a contribution on that issue would be very welcome.

Of course, this is just theory and I have not actively tested this so I'm happy to see what you report ;-)

[rsoika]

@martin-fleck-at thanks for your feedback. I will look into this and give you more feedback when I have made some progress ;-)

[rsoika]

Hi @martin-fleck-at once again I need your help. I am still struggeling with the over all concept you are talking about.

To me it looks like my server side ClipboardDataActionHandler is fine :

public class BPMNClipboardDataActionHandler extends AbstractActionHandler<RequestClipboardDataAction> {

    @Override
    protected List<Action> executeAction(final RequestClipboardDataAction actualAction) {
        EditorContext ctx = actualAction.getEditorContext();
        List<String> selectedElements = ctx.getSelectedElementIds();
        logger.debug("... copy " + selectedElements.size() + " elements...");
        ..........

    }
}

It simply copy somehow the diagram information on store it somehow in my server.

The problem seems to be only the client side Clipboard-Paste-Handler. As you pointed out the LocalClipboardService is not sending each paste event to the server. So my shared server side clipboard is not working.
What I need is to get notifications about each Paste-Action.

As far as I understand GLSP I need to implement my own IAsyncClipboardService class which is a Client Part - right?
So I implemente a copy of the LocalClipboardService in my GLSP Client module - right? But how do I register this service? This is the part I will never understand.
I expect that I need to bind my own ClipboardService somewhere in my ContainerModule - maybe something like this:

  bind(TYPES.IAsyncClipboardService).to(BPMNClipboardService);

Is this approach correct? Or do I oversee something?

[rsoika]

Ok, I think I found the correct way to solve the problem based on solution b) server side clipboard:

Client: A custom BPMNCopyPasteHandler (extends ServerCopyPasteHandler) overrides handlePaste() to always dispatch the PasteOperation to the server, regardless of whether the client-side IAsyncClipboardService has matching data.

@injectable()
export class BPMNCopyPasteHandler extends ServerCopyPasteHandler {

    override handlePaste(event: ClipboardEvent): void {
        if (event.clipboardData && this.shouldPaste(event)) {
            // Always dispatch the PasteOperation - the server holds the actual
            // clipboard data itself and knows what to paste.
            this.actionDispatcher.dispatch(
                PasteOperation.create({ clipboardData: {}, editorContext: this.editorContext.get() })
            );
            event.preventDefault();
        }
    }
}

The default handler otherwise aborts if no local data is found for the clipboard id - which is always the case across two independently opened diagram editors, since that service is scoped per diagram injector.

I rebind the handler in my BPMNDiagramModule:

rebind(TYPES.ICopyPasteHandler).to(BPMNCopyPasteHandler);

Server: A new BPMNClipboardService holds the copied element ids. The key point is that it's not bound in the DiagramModule (per-diagram injector), but in a dedicated BPMNServerModule (extending ServerModule) as a Singleton. This way it's shared across all diagrams opened within the same client connection.

So in my java server I have a new class:

public class BPMNClipboardService {

    private Map<String, String> data;

    public void put(final Map<String, String> data) {
        this.data = data;
    }

    public Map<String, String> get() {
        return data;
    }

    public void clear() {
        data = null;
    }
}

and I overwrite the default server module

public class BPMNServerModule extends ServerModule {

    @Override
    protected void configure() {
        super.configure();
        // Bind the clipboard service as a session-wide singleton so it is shared
        // across all diagram editors within the same client connection.
        bind(BPMNClipboardService.class).in(Singleton.class);
    }
}

...which I call in my ServerLauncher instead of the GLSP Default server

public final class BPMNServerLauncher {
   private BPMNServerLauncher() {
   }

   public static void main(final String[] args) {
      // setup custom logging format
      LoggingHelper.setupLogging();
      String processName = "OpenBPMNServer";
      try {
         DefaultCLIParser parser = new DefaultCLIParser(args, processName);
         LaunchUtil.configure(parser);
         int port = parser.parsePort();
         String host = parser.parseHostname();

         ServerModule bpmnServerModule = new BPMNServerModule()
               .configureDiagramModule(new BPMNDiagramModule());

         GLSPServerLauncher launcher = new SocketGLSPServerLauncher(bpmnServerModule);
         launcher.start(host, port, parser);
      } catch (ParseException ex) {
         ex.printStackTrace();
         LaunchUtil.printHelp(processName, DefaultCLIParser.getDefaultOptions());
      }
   }
}

The Handler: Finally my BPMNClipboardDataActionHandler writes to this singleton service on copy, and my BPMNPasteOperationHandler reads from it on paste - instead of relying on operation.getClipboardData().

As a result copy in editor A → paste in editor B now works :-)

[martin-fleck-at]

Overall, the solution looks quite nice to me and if you say it works, there is not much for me to add. I'm just curious about one thing: What is it you actually store in the clipboard service? Because if it is just selected element IDs, I wonder how you resolve them from the other diagram where those element IDs have no proper meaning. Or are you storing BPMN fragments? Are you cleaning the clipboard if a diagram gets closed or is that not necessary?

Two other things you may want to be aware of:

• By always dispatching the PasteOperation you lose the check whether the user copied something else in the meantime. So a Ctrl+V after copying text elsewhere will still paste the last BPMN selection. This might be the desired behavior but it is good to highlight.
• Since SocketGLSPServerLauncher creates one injector per client connection, your clipboard is shared across all diagrams of a single connection, but not across two separate VS Code/Theia windows. That is expected, just want to note it here for anyone else reading this.

[rsoika]

Yes, your assumption is right. I do not deal with the element IDs like in the core concept of the LocalClipboardService. On the server side I always operate on a Meta Model of my BPMN XML Model. This means, I do copy a clone of the corresponding XML element from my source model and I share this object in a server-instance wide memory. So on the past operation I simply add the cloned element into my current model - simmilar like if I would drag an element form the toolPalette into the model. So I concentrate not so much on the GNodes in this szeanrio. The trasnlation from my XML source object into the GNode is already solved by the existing builder code.
And yes this only works inside one instance - but this is what I whant to do and the restriction makes the paste operation also save. Simmilar like the core concept in the LocalClipboardService which operates inside one model instance.

[martin-fleck-at]

Fantastic! I just was curious but that is a good way and I'm glad it works for you now!