[JBoss JIRA] (DROOLS-3061) [DMN Designer] Automatic Layout Feature
by Roger Martínez (Jira)
[ https://issues.jboss.org/browse/DROOLS-3061?page=com.atlassian.jira.plugi... ]
Roger Martínez updated DROOLS-3061:
-----------------------------------
Description:
DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
*Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
*Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
*Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
*Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
*Architecture*
>From the design of view the goals are:
* +Layout Public interface & DMN implementation+
** The goal for this API is to provide the layout declaration data for an input Graph (DMN, BPMN, etc) instance. It will NOT mutate the graph structure and/or data at all. This way it will provide methods for calculating the candidate locations for the graph elements. even could be the case the elements must be resized as well, and it returns on some result data object that specifies the necessary updates to be done on the elements. So the resulting layout data will be consumed by another component that will use the _command API_ in order to perform the necessary updates (location, size) for the graph' elements.
** Build a well defined layout API (shared) on some _api_ module
** Build the requested layout implementation specific for DMN inside some DMN shared module (considering the implementation is shared between client and server)
** Any other common or base classes can be placed inside the _commons_ module
* +Designer integration+
** Once having the layout API and implementations, next step is to consume this API in order to obtain the layout data and use it to mutate the graph structure. So we need some kind of component for this, for example we can name it as _LayoutExecutor_.
** Create some default layout executor which will consume the layout API and use the command API to perform the updates on the model (graph) via "commands", this way we can undo/redo all the operations on the designer
** [Optional] This designer integration can be done as generic, and so reuse it for other domains like BPMN, or just specific for DMN
was:
DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
*Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
*Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
*Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
*Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
*Architecture*
>From the technical point of view the goals are:
* +Layout Public interface & DMN implementation+
** The goal for this API is to provide the layout declaration data for an input Graph (DMN, BPMN, etc) instance. It will NOT mutate the graph structure and/or data at all. This way it will provide methods for calculating the candidate locations for the graph elements. even could be the case the elements must be resized as well, and it returns on some result data object that specifies the necessary updates to be done on the elements. So the resulting layout data will be consumed by another component that will use the _command API_ in order to perform the necessary updates (location, size) for the graph' elements.
** Build a well defined layout API (shared) on some _api_ module
** Build the requested layout implementation specific for DMN inside some DMN shared module (considering the implementation is shared between client and server)
** Any other common or base classes can be placed inside the _commons_ module
* +Designer integration+
** Once having the layout API and implementations, next step is to consume this API in order to obtain the layout data and use it to mutate the graph structure. So we need some kind of component for this, for example we can name it as _LayoutExecutor_.
** Create some default layout executor which will consume the layout API and use the command API to perform the updates on the model (graph) via "commands", this way we can undo/redo all the operations on the designer
** [Optional] This designer integration can be done as generic, and so reuse it for other domains like BPMN, or just specific for DMN
> [DMN Designer] Automatic Layout Feature
> ---------------------------------------
>
> Key: DROOLS-3061
> URL: https://issues.jboss.org/browse/DROOLS-3061
> Project: Drools
> Issue Type: Epic
> Components: DMN Editor
> Reporter: Jozef Marko
> Assignee: Daniel José dos Santos
> Priority: Major
> Labels: drools-tools
>
> DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
> User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
> The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
> *Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
> *Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
> This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
> *Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
> *Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
> *Architecture*
> From the design of view the goals are:
> * +Layout Public interface & DMN implementation+
> ** The goal for this API is to provide the layout declaration data for an input Graph (DMN, BPMN, etc) instance. It will NOT mutate the graph structure and/or data at all. This way it will provide methods for calculating the candidate locations for the graph elements. even could be the case the elements must be resized as well, and it returns on some result data object that specifies the necessary updates to be done on the elements. So the resulting layout data will be consumed by another component that will use the _command API_ in order to perform the necessary updates (location, size) for the graph' elements.
> ** Build a well defined layout API (shared) on some _api_ module
> ** Build the requested layout implementation specific for DMN inside some DMN shared module (considering the implementation is shared between client and server)
> ** Any other common or base classes can be placed inside the _commons_ module
> * +Designer integration+
> ** Once having the layout API and implementations, next step is to consume this API in order to obtain the layout data and use it to mutate the graph structure. So we need some kind of component for this, for example we can name it as _LayoutExecutor_.
> ** Create some default layout executor which will consume the layout API and use the command API to perform the updates on the model (graph) via "commands", this way we can undo/redo all the operations on the designer
> ** [Optional] This designer integration can be done as generic, and so reuse it for other domains like BPMN, or just specific for DMN
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 9 months
- 1
- 0
[JBoss JIRA] (DROOLS-3061) [DMN Designer] Automatic Layout Feature
by Roger Martínez (Jira)
[ https://issues.jboss.org/browse/DROOLS-3061?page=com.atlassian.jira.plugi... ]
Roger Martínez updated DROOLS-3061:
-----------------------------------
Description:
DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
*Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
*Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
*Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
*Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
*Architecture*
>From the technical point of view the goals are:
* +Layout Public interface & DMN implementation+
** The goal for this API is to provide the layout declaration data for an input Graph (DMN, BPMN, etc) instance. It will NOT mutate the graph structure and/or data at all. This way it will provide methods for calculating the candidate locations for the graph elements. even could be the case the elements must be resized as well, and it returns on some result data object that specifies the necessary updates to be done on the elements. So the resulting layout data will be consumed by another component that will use the _command API_ in order to perform the necessary updates (location, size) for the graph' elements.
** Build a well defined layout API (shared) on some _api_ module
** Build the requested layout implementation specific for DMN inside some DMN shared module (considering the implementation is shared between client and server)
** Any other common or base classes can be placed inside the _commons_ module
* +Designer integration+
** Once having the layout API and implementations, next step is to consume this API in order to obtain the layout data and use it to mutate the graph structure. So we need some kind of component for this, for example we can name it as _LayoutExecutor_.
** Create some default layout executor which will consume the layout API and use the command API to perform the updates on the model (graph) via "commands", this way we can undo/redo all the operations on the designer
** [Optional] This designer integration can be done as generic, and so reuse it for other domains like BPMN, or just specific for DMN
was:
DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
*Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
*Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
*Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
*Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
*Technical description*
>From the technical point of view the goals are:
* +Layout Public interface & DMN implementation+
** The goal for this API is to provide the layout declaration data for an input Graph (DMN, BPMN, etc) instance. It will NOT mutate the graph structure and/or data at all. This way it will provide methods for calculating the candidate locations for the graph elements. even could be the case the elements must be resized as well, and it returns on some result data object that specifies the necessary updates to be done on the elements. So the resulting layout data will be consumed by another component that will use the _command API_ in order to perform the necessary updates (location, size) for the graph' elements.
** Build a well defined layout API (shared) on some _api_ module
** Build the requested layout implementation specific for DMN inside some DMN shared module (considering the implementation is shared between client and server)
** Any other common or base classes can be placed inside the _commons_ module
* +Designer integration+
** Once having the layout API and implementations, next step is to consume this API in order to obtain the layout data and use it to mutate the graph structure. So we need some kind of component for this, for example we can name it as _LayoutExecutor_.
** Create some default layout executor which will consume the layout API and use the command API to perform the updates on the model (graph) via "commands", this way we can undo/redo all the operations on the designer
** [Optional] This designer integration can be done as generic, and so reuse it for other domains like BPMN, or just specific for DMN
> [DMN Designer] Automatic Layout Feature
> ---------------------------------------
>
> Key: DROOLS-3061
> URL: https://issues.jboss.org/browse/DROOLS-3061
> Project: Drools
> Issue Type: Epic
> Components: DMN Editor
> Reporter: Jozef Marko
> Assignee: Daniel José dos Santos
> Priority: Major
> Labels: drools-tools
>
> DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
> User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
> The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
> *Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
> *Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
> This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
> *Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
> *Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
> *Architecture*
> From the technical point of view the goals are:
> * +Layout Public interface & DMN implementation+
> ** The goal for this API is to provide the layout declaration data for an input Graph (DMN, BPMN, etc) instance. It will NOT mutate the graph structure and/or data at all. This way it will provide methods for calculating the candidate locations for the graph elements. even could be the case the elements must be resized as well, and it returns on some result data object that specifies the necessary updates to be done on the elements. So the resulting layout data will be consumed by another component that will use the _command API_ in order to perform the necessary updates (location, size) for the graph' elements.
> ** Build a well defined layout API (shared) on some _api_ module
> ** Build the requested layout implementation specific for DMN inside some DMN shared module (considering the implementation is shared between client and server)
> ** Any other common or base classes can be placed inside the _commons_ module
> * +Designer integration+
> ** Once having the layout API and implementations, next step is to consume this API in order to obtain the layout data and use it to mutate the graph structure. So we need some kind of component for this, for example we can name it as _LayoutExecutor_.
> ** Create some default layout executor which will consume the layout API and use the command API to perform the updates on the model (graph) via "commands", this way we can undo/redo all the operations on the designer
> ** [Optional] This designer integration can be done as generic, and so reuse it for other domains like BPMN, or just specific for DMN
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 9 months
- 1
- 0
[JBoss JIRA] (DROOLS-3061) [DMN Designer] Automatic Layout Feature
by Roger Martínez (Jira)
[ https://issues.jboss.org/browse/DROOLS-3061?page=com.atlassian.jira.plugi... ]
Roger Martínez edited comment on DROOLS-3061 at 10/16/18 7:33 PM:
------------------------------------------------------------------
Hey [~jomarko] [~dadossan]
Added an _Architecture_ section in the description as well with some comments and ideas about how to drive the design for this. Just giving my opinion.. so plz Reach me out for whatever you need.
[~dadossan] I guess that this technical description matches your current work, anyway no worries, let's see this in more detail tomorrow in a call.
Thanks!
was (Author: roger600):
Hey [~jomarko] [~dadossan]
Added a technical description section in the description as well with some comments and ideas about how to drive the design for this. Plz Reach me out for whatever you need.
[~dadossan] I guess that this technical description matches your current work, anyway no worries, let's see this in more detail tomorrow in a call.
Thanks!
> [DMN Designer] Automatic Layout Feature
> ---------------------------------------
>
> Key: DROOLS-3061
> URL: https://issues.jboss.org/browse/DROOLS-3061
> Project: Drools
> Issue Type: Epic
> Components: DMN Editor
> Reporter: Jozef Marko
> Assignee: Daniel José dos Santos
> Priority: Major
> Labels: drools-tools
>
> DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
> User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
> The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
> *Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
> *Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
> This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
> *Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
> *Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
> *Architecture*
> From the technical point of view the goals are:
> * +Layout Public interface & DMN implementation+
> ** The goal for this API is to provide the layout declaration data for an input Graph (DMN, BPMN, etc) instance. It will NOT mutate the graph structure and/or data at all. This way it will provide methods for calculating the candidate locations for the graph elements. even could be the case the elements must be resized as well, and it returns on some result data object that specifies the necessary updates to be done on the elements. So the resulting layout data will be consumed by another component that will use the _command API_ in order to perform the necessary updates (location, size) for the graph' elements.
> ** Build a well defined layout API (shared) on some _api_ module
> ** Build the requested layout implementation specific for DMN inside some DMN shared module (considering the implementation is shared between client and server)
> ** Any other common or base classes can be placed inside the _commons_ module
> * +Designer integration+
> ** Once having the layout API and implementations, next step is to consume this API in order to obtain the layout data and use it to mutate the graph structure. So we need some kind of component for this, for example we can name it as _LayoutExecutor_.
> ** Create some default layout executor which will consume the layout API and use the command API to perform the updates on the model (graph) via "commands", this way we can undo/redo all the operations on the designer
> ** [Optional] This designer integration can be done as generic, and so reuse it for other domains like BPMN, or just specific for DMN
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 9 months
- 1
- 0
[JBoss JIRA] (DROOLS-3061) [DMN Designer] Automatic Layout Feature
by Roger Martínez (Jira)
[ https://issues.jboss.org/browse/DROOLS-3061?page=com.atlassian.jira.plugi... ]
Roger Martínez updated DROOLS-3061:
-----------------------------------
Description:
DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
*Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
*Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
*Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
*Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
*Technical description*
>From the technical point of view the goals are:
* +Layout Public interface & DMN implementation+
** The goal for this API is to provide the layout declaration data for an input Graph (DMN, BPMN, etc) instance. It will NOT mutate the graph structure and/or data at all. This way it will provide methods for calculating the candidate locations for the graph elements. even could be the case the elements must be resized as well, and it returns on some result data object that specifies the necessary updates to be done on the elements. So the resulting layout data will be consumed by another component that will use the _command API_ in order to perform the necessary updates (location, size) for the graph' elements.
** Build a well defined layout API (shared) on some _api_ module
** Build the requested layout implementation specific for DMN inside some DMN shared module (considering the implementation is shared between client and server)
** Any other common or base classes can be placed inside the _commons_ module
* +Designer integration+
** Once having the layout API and implementations, next step is to consume this API in order to obtain the layout data and use it to mutate the graph structure. So we need some kind of component for this, for example we can name it as _LayoutExecutor_.
** Create some default layout executor which will consume the layout API and use the command API to perform the updates on the model (graph) via "commands", this way we can undo/redo all the operations on the designer
** [Optional] This designer integration can be done as generic, and so reuse it for other domains like BPMN, or just specific for DMN
was:
DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
*Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
*Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
*Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
*Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
*Technical description*
>From the technical point of view the goals are:
* +Layout Public interface & DMN implementation+
** The goal for this API is to provide the layout declaration data for an input Graph (DMN, BPMN, etc) instance. It will not mutate the graph structure and/or data at all. This way it will provide methods for calculating the candidate locations for the graph elements. even could be the case the elements must be resized as well, and it returns on some result data object that specifies the necessary updates to be done on the elements. So the resulting layout data will be consumed by another component that will use the _command API_ in order to perform the necessary updates (location, size) for the graph' elements.
** Build a well defined layout API (shared) on some _api_ module
** Build the requested layout implementation specific for DMN inside some DMN shared module (considering the implementation is shared between client and server)
** Any other common or base classes can be placed inside the _commons_ module
* +Designer integration+
** Once having the layout API and implementations, next step is to consume this API in order to obtain the layout data and use it to mutate the graph structure. So we need some kind of component for this, for example we can name it as _LayoutExecutor_.
** Create some default layout executor which will consume the layout API and use the command API to perform the updates on the model (graph) via "commands", this way we can undo/redo all the operations on the designer
** [Optional] This designer integration can be done as generic, and so reuse it for other domains like BPMN, or just specific for DMN
> [DMN Designer] Automatic Layout Feature
> ---------------------------------------
>
> Key: DROOLS-3061
> URL: https://issues.jboss.org/browse/DROOLS-3061
> Project: Drools
> Issue Type: Epic
> Components: DMN Editor
> Reporter: Jozef Marko
> Assignee: Daniel José dos Santos
> Priority: Major
> Labels: drools-tools
>
> DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
> User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
> The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
> *Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
> *Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
> This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
> *Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
> *Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
> *Technical description*
> From the technical point of view the goals are:
> * +Layout Public interface & DMN implementation+
> ** The goal for this API is to provide the layout declaration data for an input Graph (DMN, BPMN, etc) instance. It will NOT mutate the graph structure and/or data at all. This way it will provide methods for calculating the candidate locations for the graph elements. even could be the case the elements must be resized as well, and it returns on some result data object that specifies the necessary updates to be done on the elements. So the resulting layout data will be consumed by another component that will use the _command API_ in order to perform the necessary updates (location, size) for the graph' elements.
> ** Build a well defined layout API (shared) on some _api_ module
> ** Build the requested layout implementation specific for DMN inside some DMN shared module (considering the implementation is shared between client and server)
> ** Any other common or base classes can be placed inside the _commons_ module
> * +Designer integration+
> ** Once having the layout API and implementations, next step is to consume this API in order to obtain the layout data and use it to mutate the graph structure. So we need some kind of component for this, for example we can name it as _LayoutExecutor_.
> ** Create some default layout executor which will consume the layout API and use the command API to perform the updates on the model (graph) via "commands", this way we can undo/redo all the operations on the designer
> ** [Optional] This designer integration can be done as generic, and so reuse it for other domains like BPMN, or just specific for DMN
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 9 months
- 1
- 0
[JBoss JIRA] (DROOLS-3061) [DMN Designer] Automatic Layout Feature
by Roger Martínez (Jira)
[ https://issues.jboss.org/browse/DROOLS-3061?page=com.atlassian.jira.plugi... ]
Roger Martínez updated DROOLS-3061:
-----------------------------------
Description:
DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
*Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
*Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
*Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
*Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
*Technical description*
>From the technical point of view the goals are:
* +Layout Public interface & DMN implementation+
** The goal for this API is to provide the layout declaration data for an input Graph (DMN, BPMN, etc) instance. It will NOT mutate the graph structure and/or data at all. This way it will provide methods for calculating the candidate locations for the graph elements. even could be the case the elements must be resized as well, and it returns on some result data object that specifies the necessary updates to be done on the elements. So the resulting layout data will be consumed by another component that will use the _command API_ in order to perform the necessary updates (location, size) for the graph' elements.
** Build a well defined layout API (shared) on some _api_ module
** Build the requested layout implementation specific for DMN inside some DMN shared module (considering the implementation is shared between client and server)
** Any other common or base classes can be placed inside the _commons_ module
* +Designer integration+
** Once having the layout API and implementations, next step is to consume this API in order to obtain the layout data and use it to mutate the graph structure. So we need some kind of component for this, for example we can name it as _LayoutExecutor_.
** Create some default layout executor which will consume the layout API and use the command API to perform the updates on the model (graph) via "commands", this way we can undo/redo all the operations on the designer
** [Optional] This designer integration can be done as generic, and so reuse it for other domains like BPMN, or just specific for DMN
was:
DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
*Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
*Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
*Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
*Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
*Technical description*
>From the technical point of view the goals are:
* +Layout Public interface & DMN implementation+
** The goal for this API is to provide the layout declaration data for an input Graph (DMN, BPMN, etc) instance. It will NOT mutate the graph structure and/or data at all. This way it will provide methods for calculating the candidate locations for the graph elements. even could be the case the elements must be resized as well, and it returns on some result data object that specifies the necessary updates to be done on the elements. So the resulting layout data will be consumed by another component that will use the _command API_ in order to perform the necessary updates (location, size) for the graph' elements.
** Build a well defined layout API (shared) on some _api_ module
** Build the requested layout implementation specific for DMN inside some DMN shared module (considering the implementation is shared between client and server)
** Any other common or base classes can be placed inside the _commons_ module
* +Designer integration+
** Once having the layout API and implementations, next step is to consume this API in order to obtain the layout data and use it to mutate the graph structure. So we need some kind of component for this, for example we can name it as _LayoutExecutor_.
** Create some default layout executor which will consume the layout API and use the command API to perform the updates on the model (graph) via "commands", this way we can undo/redo all the operations on the designer
** [Optional] This designer integration can be done as generic, and so reuse it for other domains like BPMN, or just specific for DMN
> [DMN Designer] Automatic Layout Feature
> ---------------------------------------
>
> Key: DROOLS-3061
> URL: https://issues.jboss.org/browse/DROOLS-3061
> Project: Drools
> Issue Type: Epic
> Components: DMN Editor
> Reporter: Jozef Marko
> Assignee: Daniel José dos Santos
> Priority: Major
> Labels: drools-tools
>
> DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
> User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
> The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
> *Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
> *Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
> This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
> *Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
> *Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
> *Technical description*
> From the technical point of view the goals are:
> * +Layout Public interface & DMN implementation+
> ** The goal for this API is to provide the layout declaration data for an input Graph (DMN, BPMN, etc) instance. It will NOT mutate the graph structure and/or data at all. This way it will provide methods for calculating the candidate locations for the graph elements. even could be the case the elements must be resized as well, and it returns on some result data object that specifies the necessary updates to be done on the elements. So the resulting layout data will be consumed by another component that will use the _command API_ in order to perform the necessary updates (location, size) for the graph' elements.
> ** Build a well defined layout API (shared) on some _api_ module
> ** Build the requested layout implementation specific for DMN inside some DMN shared module (considering the implementation is shared between client and server)
> ** Any other common or base classes can be placed inside the _commons_ module
> * +Designer integration+
> ** Once having the layout API and implementations, next step is to consume this API in order to obtain the layout data and use it to mutate the graph structure. So we need some kind of component for this, for example we can name it as _LayoutExecutor_.
> ** Create some default layout executor which will consume the layout API and use the command API to perform the updates on the model (graph) via "commands", this way we can undo/redo all the operations on the designer
> ** [Optional] This designer integration can be done as generic, and so reuse it for other domains like BPMN, or just specific for DMN
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 9 months
- 1
- 0
[JBoss JIRA] (DROOLS-3061) [DMN Designer] Automatic Layout Feature
by Roger Martínez (Jira)
[ https://issues.jboss.org/browse/DROOLS-3061?page=com.atlassian.jira.plugi... ]
Roger Martínez commented on DROOLS-3061:
----------------------------------------
Hey [~jomarko] [~dadossan]
Added a technical description section in the description as well with some comments and ideas about how to drive the design for this. Plz Reach me out for whatever you need.
[~dadossan] I guess that this technical description matches your current work, anyway no worries, let's see this in more detail tomorrow in a call.
Thanks!
> [DMN Designer] Automatic Layout Feature
> ---------------------------------------
>
> Key: DROOLS-3061
> URL: https://issues.jboss.org/browse/DROOLS-3061
> Project: Drools
> Issue Type: Epic
> Components: DMN Editor
> Reporter: Jozef Marko
> Assignee: Daniel José dos Santos
> Priority: Major
> Labels: drools-tools
>
> DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
> User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
> The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
> *Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
> *Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
> This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
> *Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
> *Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
> *Technical description*
> From the technical point of view the goals are:
> * +Layout Public interface & DMN implementation+
> ** The goal for this API is to provide the layout declaration data for an input Graph (DMN, BPMN, etc) instance. It will not mutate the graph structure and/or data at all. This way it will provide methods for calculating the candidate locations for the graph elements. even could be the case the elements must be resized as well, and it returns on some result data object that specifies the necessary updates to be done on the elements. So the resulting layout data will be consumed by another component that will use the _command API_ in order to perform the necessary updates (location, size) for the graph' elements.
> ** Build a well defined layout API (shared) on some _api_ module
> ** Build the requested layout implementation specific for DMN inside some DMN shared module (considering the implementation is shared between client and server)
> ** Any other common or base classes can be placed inside the _commons_ module
> * +Designer integration+
> ** Once having the layout API and implementations, next step is to consume this API in order to obtain the layout data and use it to mutate the graph structure. So we need some kind of component for this, for example we can name it as _LayoutExecutor_.
> ** Create some default layout executor which will consume the layout API and use the command API to perform the updates on the model (graph) via "commands", this way we can undo/redo all the operations on the designer
> ** [Optional] This designer integration can be done as generic, and so reuse it for other domains like BPMN, or just specific for DMN
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 9 months
- 1
- 0
[JBoss JIRA] (DROOLS-3061) [DMN Designer] Automatic Layout Feature
by Roger Martínez (Jira)
[ https://issues.jboss.org/browse/DROOLS-3061?page=com.atlassian.jira.plugi... ]
Roger Martínez updated DROOLS-3061:
-----------------------------------
Description:
DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
*Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
*Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
*Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
*Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
*Technical description*
>From the technical point of view the goals are:
* +Layout Public interface & DMN implementation+
** The goal for this API is to provide the layout declaration data for an input Graph (DMN, BPMN, etc) instance. It will not mutate the graph structure and/or data at all. This way it will provide methods for calculating the candidate locations for the graph elements. even could be the case the elements must be resized as well, and it returns on some result data object that specifies the necessary updates to be done on the elements. So the resulting layout data will be consumed by another component that will use the _command API_ in order to perform the necessary updates (location, size) for the graph' elements.
** Build a well defined layout API (shared) on some _api_ module
** Build the requested layout implementation specific for DMN inside some DMN shared module (considering the implementation is shared between client and server)
** Any other common or base classes can be placed inside the _commons_ module
* +Designer integration+
** Once having the layout API and implementations, next step is to consume this API in order to obtain the layout data and use it to mutate the graph structure. So we need some kind of component for this, for example we can name it as _LayoutExecutor_.
** Create some default layout executor which will consume the layout API and use the command API to perform the updates on the model (graph) via "commands", this way we can undo/redo all the operations on the designer
** [Optional] This designer integration can be done as generic, and so reuse it for other domains like BPMN, or just specific for DMN
was:
DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
*Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
*Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
*Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
*Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
> [DMN Designer] Automatic Layout Feature
> ---------------------------------------
>
> Key: DROOLS-3061
> URL: https://issues.jboss.org/browse/DROOLS-3061
> Project: Drools
> Issue Type: Epic
> Components: DMN Editor
> Reporter: Jozef Marko
> Assignee: Daniel José dos Santos
> Priority: Major
> Labels: drools-tools
>
> DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
> User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
> The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
> *Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
> *Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
> This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
> *Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
> *Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
> *Technical description*
> From the technical point of view the goals are:
> * +Layout Public interface & DMN implementation+
> ** The goal for this API is to provide the layout declaration data for an input Graph (DMN, BPMN, etc) instance. It will not mutate the graph structure and/or data at all. This way it will provide methods for calculating the candidate locations for the graph elements. even could be the case the elements must be resized as well, and it returns on some result data object that specifies the necessary updates to be done on the elements. So the resulting layout data will be consumed by another component that will use the _command API_ in order to perform the necessary updates (location, size) for the graph' elements.
> ** Build a well defined layout API (shared) on some _api_ module
> ** Build the requested layout implementation specific for DMN inside some DMN shared module (considering the implementation is shared between client and server)
> ** Any other common or base classes can be placed inside the _commons_ module
> * +Designer integration+
> ** Once having the layout API and implementations, next step is to consume this API in order to obtain the layout data and use it to mutate the graph structure. So we need some kind of component for this, for example we can name it as _LayoutExecutor_.
> ** Create some default layout executor which will consume the layout API and use the command API to perform the updates on the model (graph) via "commands", this way we can undo/redo all the operations on the designer
> ** [Optional] This designer integration can be done as generic, and so reuse it for other domains like BPMN, or just specific for DMN
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 9 months
- 1
- 0
[JBoss JIRA] (WFLY-11195) Module dependency on org.jboss.as.xts from org.jboss.xts should be optional.
by Brian Stansberry (Jira)
[ https://issues.jboss.org/browse/WFLY-11195?page=com.atlassian.jira.plugin... ]
Brian Stansberry updated WFLY-11195:
------------------------------------
Description:
The org.jboss.xts module depends on org.jboss.as.xts. It does so to allow the WildflyTransactionClientTxBridgeIntegrationHandler class to be found after the XTS subsystem's XTSHandlerDeploymentProcessor wires its name into the deployment.
But if there is no xts subsystem, then there's no XTSHandlerDeploymentProcessor and thus there's no wiring of the class name nor any need to load the class.
So, this dependency is optional and should be marked as such.
The reason this is important is that we currently have this dependency chain:
org.jboss.as.transactions/org.jboss.narayana.compensations/org.jboss.xts/org.jboss.as.xts/org.jboss.as.webservices.server.integration
And org.jboss.as.transactions is used from quite a lot of places. And that means this org.jboss.xts dependency brings the whole WS stack into a lot of places. Making this link optional will allow Galleon to optimize that away.
was:
The org.jboss.xts module depends on org.jboss.as.xts. It does so to allow the WildflyTransactionClientTxBridgeIntegrationHandler class to be found after the XTS subsystem's XTSHandlerDeploymentProcessor wires it's name into the deployment.
But if there is no xts subsystem, then there's no XTSHandlerDeploymentProcessor and thus there's no wiring of the class name nor any need to load the class.
So, this dependency is optional and should be marked as such.
The reason this is important is that we currently have this dependency chain:
org.jboss.as.transactions/org.jboss.narayana.compensations/org.jboss.xts/org.jboss.as.xts/org.jboss.as.webservices.server.integration
And org.jboss.as.transactions is used from quite a lot of places. And that means this org.jboss.xts dependency brings the whole WS stack into a lot of places. Making this link optional will allow Galleon to optimize that away.
> Module dependency on org.jboss.as.xts from org.jboss.xts should be optional.
> ----------------------------------------------------------------------------
>
> Key: WFLY-11195
> URL: https://issues.jboss.org/browse/WFLY-11195
> Project: WildFly
> Issue Type: Enhancement
> Components: XTS
> Reporter: Brian Stansberry
> Assignee: Brian Stansberry
> Priority: Major
>
> The org.jboss.xts module depends on org.jboss.as.xts. It does so to allow the WildflyTransactionClientTxBridgeIntegrationHandler class to be found after the XTS subsystem's XTSHandlerDeploymentProcessor wires its name into the deployment.
> But if there is no xts subsystem, then there's no XTSHandlerDeploymentProcessor and thus there's no wiring of the class name nor any need to load the class.
> So, this dependency is optional and should be marked as such.
> The reason this is important is that we currently have this dependency chain:
> org.jboss.as.transactions/org.jboss.narayana.compensations/org.jboss.xts/org.jboss.as.xts/org.jboss.as.webservices.server.integration
> And org.jboss.as.transactions is used from quite a lot of places. And that means this org.jboss.xts dependency brings the whole WS stack into a lot of places. Making this link optional will allow Galleon to optimize that away.
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 9 months
- 1
- 0
[JBoss JIRA] (WFLY-11195) Module dependency on org.jboss.as.xts from org.jboss.xts should be optional.
by Brian Stansberry (Jira)
[ https://issues.jboss.org/browse/WFLY-11195?page=com.atlassian.jira.plugin... ]
Brian Stansberry updated WFLY-11195:
------------------------------------
Description:
The org.jboss.xts module depends on org.jboss.as.xts. It does so to allow the WildflyTransactionClientTxBridgeIntegrationHandler class to be found after the XTS subsystem's XTSHandlerDeploymentProcessor wires it's name into the deployment.
But if there is no xts subsystem, then there's no XTSHandlerDeploymentProcessor and thus there's no wiring of the class name nor any need to load the class.
So, this dependency is optional and should be marked as such.
The reason this is important is that we currently have this dependency chain:
org.jboss.as.transactions/org.jboss.narayana.compensations/org.jboss.xts/org.jboss.as.xts/org.jboss.as.webservices.server.integration
And org.jboss.as.transactions is used from quite a lot of places. And that means this org.jboss.xts dependency brings the whole WS stack into a lot of places. Making this link optional will allow Galleon to optimize that away.
was:
The org.jboss.xts module depends on org.jboss.as.xts. It does to allow the WildflyTransactionClientTxBridgeIntegrationHandler class to be found after the XTS subsystem's XTSHandlerDeploymentProcessor wires it's name into the deployment.
But if there is no xts subsystem, then there's no XTSHandlerDeploymentProcessor and thus there's no wiring of the class name nor any need to load the class.
So, this dependency is optional and should be marked as such.
The reason this is important is that we currently have this dependency chain:
org.jboss.as.transactions/org.jboss.narayana.compensations/org.jboss.xts/org.jboss.as.xts/org.jboss.as.webservices.server.integration
And org.jboss.as.transactions is used from quite a lot of places. And that means this org.jboss.xts dependency brings the whole WS stack into a lot of places. Making this link optional will allow Galleon to optimize that away.
> Module dependency on org.jboss.as.xts from org.jboss.xts should be optional.
> ----------------------------------------------------------------------------
>
> Key: WFLY-11195
> URL: https://issues.jboss.org/browse/WFLY-11195
> Project: WildFly
> Issue Type: Enhancement
> Components: XTS
> Reporter: Brian Stansberry
> Assignee: Brian Stansberry
> Priority: Major
>
> The org.jboss.xts module depends on org.jboss.as.xts. It does so to allow the WildflyTransactionClientTxBridgeIntegrationHandler class to be found after the XTS subsystem's XTSHandlerDeploymentProcessor wires it's name into the deployment.
> But if there is no xts subsystem, then there's no XTSHandlerDeploymentProcessor and thus there's no wiring of the class name nor any need to load the class.
> So, this dependency is optional and should be marked as such.
> The reason this is important is that we currently have this dependency chain:
> org.jboss.as.transactions/org.jboss.narayana.compensations/org.jboss.xts/org.jboss.as.xts/org.jboss.as.webservices.server.integration
> And org.jboss.as.transactions is used from quite a lot of places. And that means this org.jboss.xts dependency brings the whole WS stack into a lot of places. Making this link optional will allow Galleon to optimize that away.
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 9 months
- 1
- 0
[JBoss JIRA] (WFLY-11196) The javax.orb.api module's dependencies on the iiop-opendk and transaction subsystem modules should be optional
by Brian Stansberry (Jira)
Brian Stansberry created WFLY-11196:
---------------------------------------
Summary: The javax.orb.api module's dependencies on the iiop-opendk and transaction subsystem modules should be optional
Key: WFLY-11196
URL: https://issues.jboss.org/browse/WFLY-11196
Project: WildFly
Issue Type: Enhancement
Components: IIOP
Reporter: Brian Stansberry
Assignee: Brian Stansberry
The javax.orb.api module depends on org.wildfly.iiop-openjdk and org.jboss.as.transactions in order to allow the ORB to initialize using classes that the iiop-openjdk subsystem will configure.
But if there is no iiop-openjdk subsystem in the config, then no such configuration will occur. Which means the dependencies are optional.
This is meaningful because javax.orb.api is relatively widely used as an API module, both directly and via the org.omg.api and javax.rmi.api modules that 'wrap' it. When Galleon is trying to provision an optimized footprint server we don't want the mere fact that some required module has an API dependency on one of those to result in a big set of transitive dependencies. Marking the iiop-openjdk and transaction subsystem modules as optional dependencies as such will allow Galleon to decide not to provision them if the config doesn't specify them.
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 9 months
- 1
- 0