[JBoss JIRA] (WFLY-11202) Default ResourceBundle fails to load
by Brian Stansberry (Jira)
[ https://issues.jboss.org/browse/WFLY-11202?page=com.atlassian.jira.plugin... ]
Brian Stansberry commented on WFLY-11202:
-----------------------------------------
Here's the failure details:
{code}
20:28:44,668 ERROR [org.jboss.msc.service.fail] (ServerService Thread Pool -- 75) MSC000001: Failed to start service jboss.deployment.unit."resourcebundle-0.0.1-SNAPSHOT.jar".component.Test.START: org.jboss.msc.service.StartException in service jboss.deployment.unit."resourcebundle-0.0.1-SNAPSHOT.jar".component.Test.START: java.lang.IllegalStateException: WFLYEE0042: Failed to construct component instance
at org.jboss.as.ee.component.ComponentStartService$1.run(ComponentStartService.java:57)
at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
at java.util.concurrent.FutureTask.run(FutureTask.java:266)
at org.jboss.threads.ContextClassLoaderSavingRunnable.run(ContextClassLoaderSavingRunnable.java:35)
at org.jboss.threads.EnhancedQueueExecutor.safeRun(EnhancedQueueExecutor.java:1985)
at org.jboss.threads.EnhancedQueueExecutor$ThreadBody.doRunTask(EnhancedQueueExecutor.java:1487)
at org.jboss.threads.EnhancedQueueExecutor$ThreadBody.run(EnhancedQueueExecutor.java:1349)
at java.lang.Thread.run(Thread.java:748)
at org.jboss.threads.JBossThread.run(JBossThread.java:485)
Caused by: java.lang.IllegalStateException: WFLYEE0042: Failed to construct component instance
at org.jboss.as.ee.component.BasicComponent.constructComponentInstance(BasicComponent.java:163)
at org.jboss.as.ee.component.BasicComponent.constructComponentInstance(BasicComponent.java:134)
at org.jboss.as.ee.component.BasicComponent.createInstance(BasicComponent.java:88)
at org.jboss.as.ejb3.component.singleton.SingletonComponent.getComponentInstance(SingletonComponent.java:127)
at org.jboss.as.ejb3.component.singleton.SingletonComponent.start(SingletonComponent.java:141)
at org.jboss.as.ee.component.ComponentStartService$1.run(ComponentStartService.java:54)
... 8 more
Caused by: javax.ejb.EJBException: java.util.MissingResourceException: Can't find resource for bundle java.util.PropertyResourceBundle, key Test
at org.jboss.as.ejb3.tx.CMTTxInterceptor.invokeInOurTx(CMTTxInterceptor.java:246)
at org.jboss.as.ejb3.tx.CMTTxInterceptor.requiresNew(CMTTxInterceptor.java:388)
at org.jboss.as.ejb3.tx.LifecycleCMTTxInterceptor.processInvocation(LifecycleCMTTxInterceptor.java:68)
at org.jboss.invocation.InterceptorContext.proceed(InterceptorContext.java:422)
at org.jboss.as.weld.injection.WeldInjectionContextInterceptor.processInvocation(WeldInjectionContextInterceptor.java:43)
at org.jboss.invocation.InterceptorContext.proceed(InterceptorContext.java:422)
at org.jboss.as.ejb3.component.interceptors.CurrentInvocationContextInterceptor.processInvocation(CurrentInvocationContextInterceptor.java:41)
at org.jboss.invocation.InterceptorContext.proceed(InterceptorContext.java:422)
at org.jboss.as.ee.concurrent.ConcurrentContextInterceptor.processInvocation(ConcurrentContextInterceptor.java:45)
at org.jboss.invocation.InterceptorContext.proceed(InterceptorContext.java:422)
at org.jboss.invocation.ContextClassLoaderInterceptor.processInvocation(ContextClassLoaderInterceptor.java:60)
at org.jboss.invocation.InterceptorContext.proceed(InterceptorContext.java:422)
at org.jboss.as.ejb3.component.singleton.StartupCountDownInterceptor.processInvocation(StartupCountDownInterceptor.java:25)
at org.jboss.invocation.InterceptorContext.proceed(InterceptorContext.java:422)
at org.jboss.invocation.ChainedInterceptor.processInvocation(ChainedInterceptor.java:53)
at org.jboss.as.ee.component.BasicComponent.constructComponentInstance(BasicComponent.java:161)
... 13 more
Caused by: java.util.MissingResourceException: Can't find resource for bundle java.util.PropertyResourceBundle, key Test
at java.util.ResourceBundle.getObject(ResourceBundle.java:450)
at java.util.ResourceBundle.getString(ResourceBundle.java:407)
at resourcebundle.Test.testResource(Test.java:22)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498)
at org.jboss.as.ee.component.ManagedReferenceLifecycleMethodInterceptor.processInvocation(ManagedReferenceLifecycleMethodInterceptor.java:96)
at org.jboss.invocation.InterceptorContext.proceed(InterceptorContext.java:422)
at org.jboss.as.weld.interceptors.Jsr299BindingsInterceptor.doLifecycleInterception(Jsr299BindingsInterceptor.java:122)
at org.jboss.as.weld.interceptors.Jsr299BindingsInterceptor.processInvocation(Jsr299BindingsInterceptor.java:111)
at org.jboss.invocation.InterceptorContext.proceed(InterceptorContext.java:422)
at org.jboss.invocation.InterceptorContext$Invocation.proceed(InterceptorContext.java:509)
at org.jboss.weld.module.ejb.AbstractEJBRequestScopeActivationInterceptor.aroundInvoke(AbstractEJBRequestScopeActivationInterceptor.java:81)
at org.jboss.as.weld.ejb.EjbRequestScopeActivationInterceptor.processInvocation(EjbRequestScopeActivationInterceptor.java:89)
at org.jboss.invocation.InterceptorContext.proceed(InterceptorContext.java:422)
at org.jboss.as.weld.injection.WeldInjectionInterceptor.processInvocation(WeldInjectionInterceptor.java:53)
at org.jboss.invocation.InterceptorContext.proceed(InterceptorContext.java:422)
at org.jboss.as.ee.component.AroundConstructInterceptorFactory$1.processInvocation(AroundConstructInterceptorFactory.java:28)
at org.jboss.invocation.InterceptorContext.proceed(InterceptorContext.java:422)
at org.jboss.as.weld.injection.WeldInterceptorInjectionInterceptor.processInvocation(WeldInterceptorInjectionInterceptor.java:56)
at org.jboss.invocation.InterceptorContext.proceed(InterceptorContext.java:422)
at org.jboss.as.weld.interceptors.Jsr299BindingsCreateInterceptor.processInvocation(Jsr299BindingsCreateInterceptor.java:105)
at org.jboss.invocation.InterceptorContext.proceed(InterceptorContext.java:422)
at org.jboss.as.ee.component.NamespaceContextInterceptor.processInvocation(NamespaceContextInterceptor.java:50)
at org.jboss.invocation.InterceptorContext.proceed(InterceptorContext.java:422)
at org.jboss.as.ejb3.tx.CMTTxInterceptor.invokeInOurTx(CMTTxInterceptor.java:237)
... 28 more
{code}
> Default ResourceBundle fails to load
> ------------------------------------
>
> Key: WFLY-11202
> URL: https://issues.jboss.org/browse/WFLY-11202
> Project: WildFly
> Issue Type: Bug
> Affects Versions: 14.0.1.Final
> Reporter: Andrew Schmidt
> Assignee: Jason Greene
> Priority: Major
> Attachments: resourcebundle.zip
>
>
> Wildfly 14 no longer loads the default message bundle when a locale is specified and the specific locale has no properties file.
> For example, in the attached project, I have a messages.properties file, Wildfly 13 and previous releases would simply load the messages.properties if there is no messages_en.properties. But in wildfly 14 this is no longer the case (it appears it provides a different resourcebundle)
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 9 months
[JBoss JIRA] (DROOLS-3146) [DMN Designer] Remove Context from Manage Data Type dialog
by Edson Tirelli (Jira)
[ https://issues.jboss.org/browse/DROOLS-3146?page=com.atlassian.jira.plugi... ]
Edson Tirelli commented on DROOLS-3146:
---------------------------------------
Sorry [~jomarko], discussing this further with [~karreiro], there are a couple corner situations where it might make sense to support this, so lets leave it as is right now.
Closing this ticket.
> [DMN Designer] Remove Context from Manage Data Type dialog
> ----------------------------------------------------------
>
> Key: DROOLS-3146
> URL: https://issues.jboss.org/browse/DROOLS-3146
> Project: Drools
> Issue Type: Task
> Components: DMN Editor
> Affects Versions: 7.13.0.Final
> Reporter: Jozef Marko
> Assignee: Guilherme Carreiro
> Priority: Major
> Labels: drools-tools
>
> We shouldn't offer *context* as an option in the *Manage Custom Data Types* dialog, however we should preserve this option for DRG nodes *Output data type* field.
> [~tirelli] could you please advise if we should keep *context* as an option for rows and columns in expression grid editor?
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 9 months
[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/17/18 7:45 PM:
------------------------------------------------------------------
Hey [~dadossan] [~jomarko] [~manstis] [~ibek]
Sharing the minutes from a call with [~dadossan]: Please feel free to add your feedback/comments as well, for now that's the way we're trying to move forward... thanks in advance!
*Iteration #1*
* Goals
** Build the layout API and the specific implementation required on DMN
** Perform the automatic layout once opening DMN a diagram, if it does not contains layout info - this operation CANNOT be undone/redone and it only affects the DMN editors
** As automatic layout operates on client side, it could make sense to notify the user about the need for saving the diagram on the server and so updating the source (xml) files, with some text like "The diagram has no layout information. It has been automatically layout, please save changes in order to keep this layout."
This iteration is actually on status [PR sent|https://github.com/kiegroup/kie-wb-common/pull/2174].
*Iteration #2*
* Goals
** Add a toolbar button to perform the automatic layout operation
** Allow to undo/redo the button's action - implies using the _commands API_ instead of applying the changes directly on the graph instance, as done in _Iteration #1_
** Show the notification to the user as in _Iteration #1_
No progress on the second iteration yet.
*Future iterations*
In future releases we can consider:
* Using the layout capabilities in other editors (like BPMN, CM)
* Adding more layout implementations (vertical, horizontal, grid)
* Consider resizing elements when applying layouts
* Support layout for just a set of elements in the graph (eg: all children for a given parent, selected elements) - could make sense to consider using incremental layout executions to avoid performance and memory issues
was (Author: roger600):
Hey [~dadossan] [~jomarko] [~manstis] [~ibek]
Sharing the minutes from a call with [~dadossan]: Please feel free to add your feedback/comments as well, for now that's the way we're trying to move forward... thanks in advance!
*Iteration #1*
* Goals
** Build the layout API and the specific implementation required on DMN
** Perform the automatic layout once opening DMN a diagram, if it does not contains layout info - this operation CANNOT be undone/redone and it only affects the DMN editors
** As automatic layout operates on client side, it could make sense to notify the user about the need for saving the diagram on the server and so updating the source (xml) files, with some text like "The diagram has no layout information. It has been automatically layout, please save changes in order to keep this layout."
This iteration is actually on status [PR sent|https://github.com/kiegroup/kie-wb-common/pull/2174].
*Iteration #2*
* Goals
** Add a toolbar button to perform the automatic layout operation
** Allow to undo/redo the button's action - implies using the _commands API_ instead of applying the changes directly on the graph instance, as done in _Iteration #1_
** Show the notification to the user as in _Iteration #1_
No progress on the second iteration yet.
*Future iterations*
In future releases we can consider:
* Using the layout capabilities in other editors (like BPMN, CM)
* Adding more layout implementations (vertical, horizontal, grid)
* Support layout for just a set of elements in the graph (eg: all children for a given parent, selected elements) - could make sense to consider using incremental layout executions to avoid performance and memory issues
> [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
[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/17/18 7:43 PM:
------------------------------------------------------------------
Hey [~dadossan] [~jomarko] [~manstis] [~ibek]
Sharing the minutes from a call with [~dadossan]: Please feel free to add your feedback/comments as well, for now that's the way we're trying to move forward... thanks in advance!
*Iteration #1*
* Goals
** Build the layout API and the specific implementation required on DMN
** Perform the automatic layout once opening DMN a diagram, if it does not contains layout info - this operation CANNOT be undone/redone and it only affects the DMN editors
** As automatic layout operates on client side, it could make sense to notify the user about the need for saving the diagram on the server and so updating the source (xml) files, with some text like "The diagram has no layout information. It has been automatically layout, please save changes in order to keep this layout."
This iteration is actually on status [PR sent|https://github.com/kiegroup/kie-wb-common/pull/2174].
*Iteration #2*
* Goals
** Add a toolbar button to perform the automatic layout operation
** Allow to undo/redo the button's action - implies using the _commands API_ instead of applying the changes directly on the graph instance, as done in _Iteration #1_
** Show the notification to the user as in _Iteration #1_
No progress on the second iteration yet.
*Future iterations*
In future releases we can consider:
* Using the layout capabilities in other editors (like BPMN, CM)
* Adding more layout implementations (vertical, horizontal, grid)
* Support layout for just a set of elements in the graph (eg: all children for a given parent, selected elements) - could make sense to consider using incremental layout executions to avoid performance and memory issues
was (Author: roger600):
Hey [~dadossan] [~jomarko] [~manstis] [~ibek]
Sharing the minutes from a call with [~dadossan]: Please feel free to add your feedback/comments as well, for now that's the way we're trying to move forward... thanks in advance!
*Iteration #1*
* Goals
** Build the layout API and the specific implementation required on DMN
** Perform the automatic layout once opening DMN a diagram, if it does not contains layout info - this operation CANNOT be undone/redone and it only affects the DMN editors
** As automatic layout operates on client side, it could make sense to notify the user about the need for saving the diagram on the server and so updating the source (xml) files, with some text like "The diagram has no layout information. It has been automatically layout, please save changes in order to keep this layout."
This iteration is actually on status [PR sent|https://github.com/kiegroup/kie-wb-common/pull/2174].
*Iteration #2*
* Goals
** Add a toolbar button to perform the automatic layout operation
** Allow to undo/redo the button's action
** Show the notification to the user as in _Iteration #1_
No progress on the second iteration yet.
*Future iterations*
In future releases we can consider:
* Using the layout capabilities in other editors (like BPMN, CM)
* Adding more layout implementations (vertical, horizontal, grid)
* Support layout for just a set of elements in the graph (eg: all children for a given parent, selected elements) - could make sense to consider using incremental layout executions to avoid performance and memory issues
> [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
[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/17/18 7:42 PM:
------------------------------------------------------------------
Hey [~dadossan] [~jomarko] [~manstis] [~ibek]
Sharing the minutes from a call with [~dadossan]: Please feel free to add your feedback/comments as well, for now that's the way we're trying to move forward... thanks in advance!
*Iteration #1*
* Goals
** Build the layout API and the specific implementation required on DMN
** Perform the automatic layout once opening DMN a diagram, if it does not contains layout info - this operation CANNOT be undone/redone and it only affects the DMN editors
** As automatic layout operates on client side, it could make sense to notify the user about the need for saving the diagram on the server and so updating the source (xml) files, with some text like "The diagram has no layout information. It has been automatically layout, please save changes in order to keep this layout."
This iteration is actually on status [PR sent|https://github.com/kiegroup/kie-wb-common/pull/2174].
*Iteration #2*
* Goals
** Add a toolbar button to perform the automatic layout operation
** Allow to undo/redo the button's action
** Show the notification to the user as in _Iteration #1_
No progress on the second iteration yet.
*Future iterations*
In future releases we can consider:
* Using the layout capabilities in other editors (like BPMN, CM)
* Adding more layout implementations (vertical, horizontal, grid)
* Support layout for just a set of elements in the graph (eg: all children for a given parent, selected elements) - could make sense to consider using incremental layout executions to avoid performance and memory issues
was (Author: roger600):
Hey [~dadossan] [~jomarko] [~manstis] [~ibek]
Sharing the minutes from a call with [~dadossan]: Please feel free to add your feedback/comments as well, for now that's the way we're trying to move forward... thanks in advance!
*Iteration #1*
* Goals
** Build the layout API and the specific implementation required on DMN
** Perform the automatic layout once opening DMN a diagram, if it does not contains layout info - this operation CANNOT be undone/redone and it only affects the DMN editors
** As automatic layout operates on client side, it could make sense to notify the user about the need for saving the diagram on the server and so updating the source (xml) files, with some test like "The diagram has no layout information. It has been automatically layout, please save changes in order to keep this layout."
This iteration is actually on status [PR sent|https://github.com/kiegroup/kie-wb-common/pull/2174].
*Iteration #2*
* Goals
** Add a toolbar button to perform the automatic layout operation
** Allow to undo/redo the button's action
** Show the notification to the user as in _Iteration #1_
No progress on the second iteration yet.
*Future iterations*
In future releases we can consider:
* Using the layout capabilities in other editors (like BPMN, CM)
* Adding more layout implementations (vertical, horizontal, grid)
* Support layout for just a set of elements in the graph (eg: all children for a given parent, selected elements) - could make sense to consider using incremental layout executions to avoid performance and memory issues
> [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
[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/17/18 7:41 PM:
------------------------------------------------------------------
Hey [~dadossan] [~jomarko] [~manstis] [~ibek]
Sharing the minutes from a call with [~dadossan]: Please feel free to add your feedback/comments as well, for now that's the way we're trying to move forward... thanks in advance!
*Iteration #1*
* Goals
** Build the layout API and the specific implementation required on DMN
** Perform the automatic layout once opening DMN a diagram, if it does not contains layout info - this operation CANNOT be undone/redone and it only affects the DMN editors
** As automatic layout operates on client side, it could make sense to notify the user about the need for saving the diagram on the server and so updating the source (xml) files, with some test like "The diagram has no layout information. It has been automatically layout, please save changes in order to keep this layout."
This iteration is actually on status [PR sent|https://github.com/kiegroup/kie-wb-common/pull/2174].
*Iteration #2*
* Goals
** Add a toolbar button to perform the automatic layout operation
** Allow to undo/redo the button's action
** Show the notification to the user as in _Iteration #1_
No progress on the second iteration yet.
*Future iterations*
In future releases we can consider:
* Using the layout capabilities in other editors (like BPMN, CM)
* Adding more layout implementations (vertical, horizontal, grid)
* Support layout for just a set of elements in the graph (eg: all children for a given parent, selected elements) - could make sense to consider using incremental layout executions to avoid performance and memory issues
was (Author: roger600):
Hey [~dadossan] [~jomarko] [~manstis] [~ibek]
Sharing the minutes from a call with [~dadossan]: Please feel free to add your feedback/comments as well, for now that's the way we're trying to move forward... thanks in advance!
*Iteration #1*
* Goals
** Build the layout API and the specific implementation required on DMN
** Perform the automatic layout once opening DMN a diagram, if it does not contains layout info - this operation CANNOT be undone/redone and it only affects the DMN editors
** If automatic layout performed, show a notification to the user "The diagram has no layout information. It has been automatically layout, please save changes in order to keep this layout."
This iteration is actually on status [PR sent|https://github.com/kiegroup/kie-wb-common/pull/2174].
*Iteration #2*
* Goals
** Add a toolbar button to perform the automatic layout operation
** Allow to undo/redo the button's action
** Show the notification to the user as in _Iteration #1_
No progress on the second iteration yet.
*Future iterations*
In future releases we can consider:
* Using the layout capabilities in other editors (like BPMN, CM)
* Adding more layout implementations (vertical, horizontal, grid)
* Support layout for just a set of elements in the graph (eg: all children for a given parent, selected elements) - could make sense to consider using incremental layout executions to avoid performance and memory issues
> [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
[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/17/18 7:39 PM:
------------------------------------------------------------------
Hey [~dadossan] [~jomarko] [~manstis] [~ibek]
Sharing the minutes from a call with [~dadossan]: Please feel free to add your feedback/comments as well, for now that's the way we're trying to move forward... thanks in advance!
*Iteration #1*
* Goals
** Build the layout API and the specific implementation required on DMN
** Perform the automatic layout once opening DMN a diagram, if it does not contains layout info - this operation CANNOT be undone/redone and it only affects the DMN editors
** If automatic layout performed, show a notification to the user "The diagram has no layout information. It has been automatically layout, please save changes in order to keep this layout."
This iteration is actually on status [PR sent|https://github.com/kiegroup/kie-wb-common/pull/2174].
*Iteration #2*
* Goals
** Add a toolbar button to perform the automatic layout operation
** Allow to undo/redo the button's action
** Show the notification to the user as in _Iteration #1_
No progress on the second iteration yet.
*Future iterations*
In future releases we can consider:
* Using the layout capabilities in other editors (like BPMN, CM)
* Adding more layout implementations (vertical, horizontal, grid)
* Support layout for just a set of elements in the graph (eg: all children for a given parent, selected elements) - could make sense to consider using incremental layout executions to avoid performance and memory issues
was (Author: roger600):
Hey [~dadossan] [~jomarko] [~manstis]
Sharing the minutes from a call with [~dadossan]: Please feel free to add your feedback/comments as well, for now that's the way we're trying to move forward... thanks in advance!
*Iteration #1*
* Goals
** Build the layout API and the specific implementation required on DMN
** Perform the automatic layout once opening DMN a diagram, if it does not contains layout info - this operation CANNOT be undone/redone and it only affects the DMN editors
** If automatic layout performed, show a notification to the user "The diagram has no layout information. It has been automatically layout, please save changes in order to keep this layout."
This iteration is actually on status [PR sent|https://github.com/kiegroup/kie-wb-common/pull/2174].
*Iteration #2*
* Goals
** Add a toolbar button to perform the automatic layout operation
** Allow to undo/redo the button's action
** Show the notification to the user as in _Iteration #1_
No progress on the second iteration yet.
*Future iterations*
In future releases we can consider:
* Using the layout capabilities in other editors (like BPMN, CM)
* Adding more layout implementations (vertical, horizontal, grid)
* Support layout for just a set of elements in the graph (eg: all children for a given parent, selected elements) - could make sense to consider using incremental layout executions to avoid performance and memory issues
> [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
[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/17/18 7:38 PM:
------------------------------------------------------------------
[~manstis] yeahh well it's really easy to show a notification to the user like we do in Stunner for other things, so I proposed this for closing the actual PR, but just my opinion, my proposal, so feel free guys to add yours :)
Also agree about CM... although at some point we could even reuse that same API in both lienzo/stunner(graph)... not sure, was just brainstorming also with [~dadossan], anyway that's looong term if so, no worries.
Thanks!
was (Author: roger600):
[~manstis] yeahh well it's really easy to show a notification to the user like we do in Stunner for other things, so I proposed this for closing the actual PR, but just my opinion, my proposal, so feel free guys to add yours :)
Also agree about CM... although at some point we could even reuse that same API in both lienzo/stunner(graph)... not sure, was just brainstorming also with [~dadossan], anyway that's looong term, no worries.
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 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