"Composition rules"?

[PatrikN-work]

How do I specify which semantic "node" elements can be connected by which "edge" semantic elements?

Eg. how do i specify that nodes of Type A can only be connected by edge of type X but not an edge of type Y while nodes of type B only by edges of type Y?

[tortmayr]

Hi @PatrikN-work,
GLSP uses a server-side provides TypeHints to express such composition rules.
This types are defined in the DiagramConfiguration.

A DiagramConfiguration that expresses the rules you described could look like this (when using the node Server):

@injectable()
export class MyDiagramConfiguration implements DiagramConfiguration {
    // ...
    get shapeTypeHints(): ShapeTypeHint[] {
        return [
            { elementTypeId: 'A', deletable: true, reparentable: false, repositionable: true, resizable: true },
            { elementTypeId: 'B', deletable: true, reparentable: false, repositionable: true, resizable: true }
        ];
    }

    get edgeTypeHints(): EdgeTypeHint[] {
        return [
            {
                elementTypeId: 'X',
                deletable: true,
                repositionable: true,
                routable: true,
                sourceElementTypeIds: ['A'],
                targetElementTypeIds: ['A']
            },
            {
                elementTypeId: 'Y',
                deletable: true,
                repositionable: true,
                routable: true,
                sourceElementTypeIds: ['B'],
                targetElementTypeIds: ['B']
            }
        ];
    }
}

[tortmayr]

I see, at the moment this is not directly supported.
As connections are created on the client side. Here only the graphical model is available and the client does not have direct access to the semantic model. Currently there is an inherit assumption that each semantic type can be mapped to a distinct graphical model element. This way the restrictions of the semantic element can be applied accordingly on its graphical representation.

Note that we are currently working on an overhaul of the TypeHints system to provide a more flexible mechanism. Your request seems more than reasonable to me, so we will think about how to best integrate it in GLSP.

[PatrikN-work]

Just so I understand, the current "workaround" is to map each semantic element to exactly one graphical element?

Would it be possible to extend the GLSP som that the client could query the server if an edge can be connectd to a node according the semantic model? I guess howeve rthat would imply that the Gmodel is aware of any semanric model, or at least that there is a mapping, maybe in the index.

[tortmayr]

Hi, yes you are correct.

The current workaround is to map each semantic element type to exactly one graphical element type,
In theory it's also possible to extend the GLSP client so that the server can be queried directly and then can compute on demand whether an edge can be connected according the the semantic model. However, I would recommend for you to wait until the 2.0.0 Release is available as it will provide this feature out of the box.
Regarding the semantic to graphical element mapping: we typically do this by extending the GModelindex. For instance the gluecode for semantic models based on EMF provides a customized index that allows querying of the corresponding semantic model via the it of the GModelElement.

I'm on vacation for the next two weeks so If you have any follow up questions please ping @martin-fleck-at.

[PatrikN-work]

Any news on this now when GLSP 2.0 is released?

[planger]

Yes, it is actually already released: https://github.com/eclipse-glsp/glsp/releases/tag/v2.0.0
The project templates are already updated accordingly and the documentation is largely updated as well. We are still working on migration guide though.
But if you are starting from scratch, there is no need to wait!
Thanks for your interest!

[PatrikN-work]

To clariy even more:

I want to have two semantic elements, A and B. They are different semantic elements but both are visualized as a GNode of type Node

Elements of A should only be connected by a semantic realationship of type X while elements of B shall only be conneted by a semantic relationship of type Y. Both X and Y are visualized as an GEdge of type Edge

I see, at the moment this is not directly supported. As connections are created on the client side. Here only the graphical model is available and the client does not have direct access to the semantic model. Currently there is an inherit assumption that each semantic type can be mapped to a distinct graphical model element. This way the restrictions of the semantic element can be applied accordingly on its graphical representation.

Note that we are currently working on an overhaul of the TypeHints system to provide a more flexible mechanism. Your request seems more than reasonable to me, so we will think about how to best integrate it in GLSP.

I was thinking of this particular issue. is it addressed in GLSP 2.0?

[planger]

Yes, this is now supported with 2.0.
This is the bug which should reference all changes: #211
There now is a new property dynamic to indicate that the client should ask the server for validating the edge creation, see in particular eclipse-glsp/glsp-client#285.
Let us know if you have questions!

[PatrikN-work]

Sorry, still can't get it to work. I'm probaly missing something simple. I'm extending the tasklist example and my diagram config is as follows.

The issue is that I can still create edges betwene both NODEs and NODE_CIRCLES.

Edit:
I see this in the log when hovering over the nodes whne creating a edge.

warn - [RequestPopupModelActionHandler] Could not process RequestPopupModelAction. No PopupModelFactory is bound

export class TaskListDiagramConfiguration implements DiagramConfiguration { layoutKind = ServerLayoutKind.MANUAL; needsClientLayout = true; animatedUpdate = true; get typeMapping(): Map> { return getDefaultMapping(); } get shapeTypeHints(): ShapeTypeHint[] { return [ { elementTypeId: DefaultTypes.NODE, deletable: true, reparentable: false, repositionable: true, resizable: true }, { elementTypeId: DefaultTypes.NODE_CIRCLE, deletable: true, reparentable: false, repositionable: true, resizable: true } ]; } get edgeTypeHints(): EdgeTypeHint[] { return [ { elementTypeId: DefaultTypes.EDGE, deletable: true, repositionable: false, routable: false, dynamic: true, sourceElementTypeIds: [DefaultTypes.NODE], targetElementTypeIds: [DefaultTypes.NODE] } ]; } }

[patnan]

is there a working example I can look at?