Make layer switching more robust

[gpl/argeo-suite.git] / org.argeo.app.ui / src / org / argeo / app / ui / SuiteApp.java

diff --git a/org.argeo.app.ui/src/org/argeo/app/ui/SuiteApp.java b/org.argeo.app.ui/src/org/argeo/app/ui/SuiteApp.java
index 50a7f80a82f90bc14fe622aadfbe1f8769fd027f..9ad2673fc1216d79746a5de580c2a6b7f56dc359 100644 (file)
--- a/org.argeo.app.ui/src/org/argeo/app/ui/SuiteApp.java
+++ b/org.argeo.app.ui/src/org/argeo/app/ui/SuiteApp.java
@@ -2,6 +2,7 @@ package org.argeo.app.ui;
 
 import static org.argeo.api.cms.ux.CmsView.CMS_VIEW_UID_PROPERTY;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -40,8 +41,8 @@ import org.argeo.cms.acr.ContentUtils;
 import org.argeo.cms.jcr.CmsJcrUtils;
 import org.argeo.cms.jcr.acr.JcrContent;
 import org.argeo.cms.swt.CmsSwtUtils;
+import org.argeo.cms.swt.acr.SwtUiProvider;
 import org.argeo.cms.swt.dialogs.CmsFeedback;
-import org.argeo.cms.ui.CmsUiProvider;
 import org.argeo.cms.ux.CmsUxUtils;
 import org.argeo.eclipse.ui.specific.UiContext;
 import org.argeo.jcr.JcrException;
@@ -80,8 +81,9 @@ public class SuiteApp extends AbstractCmsApp implements CmsEventSubscriber {
        @Deprecated
        private String defaultThemeId = "org.argeo.app.theme.default";
 
-       private Map<String, RankedObject<CmsUiProvider>> uiProvidersByPid = Collections.synchronizedMap(new HashMap<>());
-       private Map<String, RankedObject<CmsUiProvider>> uiProvidersByType = Collections.synchronizedMap(new HashMap<>());
+       // TODO use QName as key for byType
+       private Map<String, RankedObject<SwtUiProvider>> uiProvidersByPid = Collections.synchronizedMap(new HashMap<>());
+       private Map<String, RankedObject<SwtUiProvider>> uiProvidersByType = Collections.synchronizedMap(new HashMap<>());
        private Map<String, RankedObject<SuiteLayer>> layersByPid = Collections.synchronizedSortedMap(new TreeMap<>());
        private Map<String, RankedObject<SuiteLayer>> layersByType = Collections.synchronizedSortedMap(new TreeMap<>());
 
@@ -191,9 +193,9 @@ public class SuiteApp extends AbstractCmsApp implements CmsEventSubscriber {
 
                        ProvidedSession contentSession = (ProvidedSession) CmsUxUtils.getContentSession(contentRepository, cmsView);
 
-                       CmsUiProvider headerUiProvider = findUiProvider(headerPid);
-                       CmsUiProvider footerUiProvider = findUiProvider(footerPid);
-                       CmsUiProvider leadPaneUiProvider;
+                       SwtUiProvider headerUiProvider = findUiProvider(headerPid);
+                       SwtUiProvider footerUiProvider = findUiProvider(footerPid);
+                       SwtUiProvider leadPaneUiProvider;
                        if (adminUiName.equals(uiName)) {
                                leadPaneUiProvider = findUiProvider(adminLeadPanePid);
                        } else {
@@ -224,7 +226,8 @@ public class SuiteApp extends AbstractCmsApp implements CmsEventSubscriber {
                                        // FIXME NPE on CMSSession when logging in from anonymous
                                        if (cmsSession == null || cmsView.isAnonymous()) {
                                                assert publicBasePath != null;
-                                               Content userDir = contentSession.get(CmsConstants.SYS_WORKSPACE + publicBasePath);
+                                               Content userDir = contentSession
+                                                               .get(ContentUtils.SLASH + CmsConstants.SYS_WORKSPACE + publicBasePath);
                                                ui.setUserDir(userDir);
 //                                             ui.initSessions(getRepository(), publicBasePath);
                                        } else {
@@ -263,7 +266,7 @@ public class SuiteApp extends AbstractCmsApp implements CmsEventSubscriber {
                                setState(ui, state != null ? state : defaultLayerPid);
                        }
                } catch (Exception e) {
-                       CmsFeedback.show("Unexpected exception", e);
+                       CmsFeedback.error("Unexpected exception", e);
                }
        }
 
@@ -276,12 +279,12 @@ public class SuiteApp extends AbstractCmsApp implements CmsEventSubscriber {
 
        }
 
-       private void refreshPart(CmsUiProvider uiProvider, Composite part, Content context) {
+       private void refreshPart(SwtUiProvider uiProvider, Composite part, Content context) {
                CmsSwtUtils.clear(part);
                uiProvider.createUiPart(part, context);
        }
 
-       private CmsUiProvider findUiProvider(String pid) {
+       private SwtUiProvider findUiProvider(String pid) {
                if (!uiProvidersByPid.containsKey(pid))
                        return null;
                return uiProvidersByPid.get(pid).get();
@@ -361,8 +364,9 @@ public class SuiteApp extends AbstractCmsApp implements CmsEventSubscriber {
                                if (byType.containsKey(type))
                                        types.add(type);
                        }
-                       if (types.size() == 0)
+                       if (types.size() == 0) {
                                throw new IllegalArgumentException("No type found for " + content + " (" + objectClasses + ")");
+                       }
                        String type = types.iterator().next();
                        if (!byType.containsKey(type))
                                throw new IllegalArgumentException("No component found for " + content + " with type " + type);
@@ -495,7 +499,7 @@ public class SuiteApp extends AbstractCmsApp implements CmsEventSubscriber {
                                        Content node = getNode(ui, event);
                                        if (node == null)
                                                return;
-                                       CmsUiProvider uiProvider = findByType(uiProvidersByType, node);
+                                       SwtUiProvider uiProvider = findByType(uiProvidersByType, node);
                                        SuiteLayer layer = findByType(layersByType, node);
                                        ui.switchToLayer(layer, node);
                                        layer.view(uiProvider, ui.getCurrentWorkArea(), node);
@@ -504,7 +508,7 @@ public class SuiteApp extends AbstractCmsApp implements CmsEventSubscriber {
                                        Content node = getNode(ui, event);
                                        if (node == null)
                                                return;
-                                       CmsUiProvider uiProvider = findByType(uiProvidersByType, node);
+                                       SwtUiProvider uiProvider = findByType(uiProvidersByType, node);
                                        SuiteLayer layer = findByType(layersByType, node);
                                        ui.switchToLayer(layer, node);
                                        layer.open(uiProvider, ui.getCurrentWorkArea(), node);
@@ -548,8 +552,8 @@ public class SuiteApp extends AbstractCmsApp implements CmsEventSubscriber {
                                        }
                                }
                        } catch (Exception e) {
-                               log.error("Cannot handle event " + event, e);
-//                     CmsView.getCmsView(ui).exception(e);
+                               CmsFeedback.error("Cannot handle event " + event, e);
+//                             log.error("Cannot handle event " + event, e);
                        }
                });
        }
@@ -621,23 +625,24 @@ public class SuiteApp extends AbstractCmsApp implements CmsEventSubscriber {
         * Dependency injection.
         */
 
-       public void addUiProvider(CmsUiProvider uiProvider, Map<String, Object> properties) {
+       public void addUiProvider(SwtUiProvider uiProvider, Map<String, Object> properties) {
                if (properties.containsKey(Constants.SERVICE_PID)) {
                        String pid = (String) properties.get(Constants.SERVICE_PID);
                        RankedObject.putIfHigherRank(uiProvidersByPid, pid, uiProvider, properties);
                }
                if (properties.containsKey(EntityConstants.TYPE)) {
                        List<String> types = LangUtils.toStringList(properties.get(EntityConstants.TYPE));
-                       for (String type : types)
+                       for (String type : types) {
                                RankedObject.putIfHigherRank(uiProvidersByType, type, uiProvider, properties);
+                       }
                }
        }
 
-       public void removeUiProvider(CmsUiProvider uiProvider, Map<String, Object> properties) {
+       public void removeUiProvider(SwtUiProvider uiProvider, Map<String, Object> properties) {
                if (properties.containsKey(Constants.SERVICE_PID)) {
                        String pid = (String) properties.get(Constants.SERVICE_PID);
                        if (uiProvidersByPid.containsKey(pid)) {
-                               if (uiProvidersByPid.get(pid).equals(new RankedObject<CmsUiProvider>(uiProvider, properties))) {
+                               if (uiProvidersByPid.get(pid).equals(new RankedObject<SwtUiProvider>(uiProvider, properties))) {
                                        uiProvidersByPid.remove(pid);
                                }
                        }
@@ -646,7 +651,7 @@ public class SuiteApp extends AbstractCmsApp implements CmsEventSubscriber {
                        List<String> types = LangUtils.toStringList(properties.get(EntityConstants.TYPE));
                        for (String type : types) {
                                if (uiProvidersByType.containsKey(type)) {
-                                       if (uiProvidersByType.get(type).equals(new RankedObject<CmsUiProvider>(uiProvider, properties))) {
+                                       if (uiProvidersByType.get(type).equals(new RankedObject<SwtUiProvider>(uiProvider, properties))) {
                                                uiProvidersByType.remove(type);
                                        }
                                }
@@ -655,12 +660,26 @@ public class SuiteApp extends AbstractCmsApp implements CmsEventSubscriber {
        }
 
        public void addLayer(SuiteLayer layer, Map<String, Object> properties) {
-               if (properties.containsKey(Constants.SERVICE_PID)) {
-                       String pid = (String) properties.get(Constants.SERVICE_PID);
+               if (!properties.containsKey(Constants.SERVICE_PID))
+                       throw new IllegalArgumentException("A layer must have an ID");
+               String pid = (String) properties.get(Constants.SERVICE_PID);
+               List<String> types = properties.containsKey(EntityConstants.TYPE)
+                               ? LangUtils.toStringList(properties.get(EntityConstants.TYPE))
+                               : new ArrayList<>();
+               if (types.isEmpty()) {
+                       RankedObject.putIfHigherRank(layersByPid, pid, layer, properties);
+               } else {
+                       if (layersByPid.containsKey(pid)) {
+                               RankedObject<SuiteLayer> current = layersByPid.get(pid);
+                               List<String> currentTypes = current.getProperties().containsKey(EntityConstants.TYPE)
+                                               ? LangUtils.toStringList(current.getProperties().get(EntityConstants.TYPE))
+                                               : new ArrayList<>();
+                               if (!types.containsAll(currentTypes)) {
+                                       throw new IllegalArgumentException("Higher-ranked layer " + pid + " contains only types " + types
+                                                       + ", while it must override all " + currentTypes);
+                               }
+                       }
                        RankedObject.putIfHigherRank(layersByPid, pid, layer, properties);
-               }
-               if (properties.containsKey(EntityConstants.TYPE)) {
-                       List<String> types = LangUtils.toStringList(properties.get(EntityConstants.TYPE));
                        for (String type : types)
                                RankedObject.putIfHigherRank(layersByType, type, layer, properties);
                }