scilab/modules/gui/src/java/org/scilab/modules/gui/tabfactory/ScilabTabFactory.java

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2011 - Calixte DENIZET
   4  *
   5  * This file must be used under the terms of the CeCILL.
   6  * This source file is licensed as described in the file COPYING, which
   7  * you should have received as part of this distribution.  The terms
   8  * are also available at
   9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  10  *
  11  */
  12
  13 package org.scilab.modules.gui.tabfactory;
  14
  15 import java.awt.Component;
  16 import java.util.HashMap;
  17 import java.util.Map;
  18 import java.util.UUID;
  19
  20 import javax.swing.JTextArea;
  21
  22 import org.flexdock.docking.DockableFactory;
  23
  24 import org.scilab.modules.gui.bridge.tab.SwingScilabTab;
  25 import org.scilab.modules.gui.utils.WindowsConfigurationManager;
  26 import org.scilab.modules.jvm.LoadClassPath;
  27 import org.scilab.modules.localization.Messages;
  28
  29 /**
  30  * The main Tab factory.
  31  * A component which needs to restore a Tab with a given uuid must register its factory.
  32  *
  33  * @author Calixte DENIZET
  34  */
  35 public class ScilabTabFactory extends DockableFactory.Stub {
  36
  37     private static final ScilabTabFactory instance = new ScilabTabFactory();
  38     private static final String EMPTYTAB = Messages.gettext("Empty tab");
  39     private static final String NULLUUID = new UUID(0L, 0L).toString();
  40     private static final String ERROR = Messages.gettext("The tab with uuid %s cannot be restored.\nPlease report a bug with the previous message and in attaching the file %s.");
  41
  42     /*
  43       Certains components could depend an other Tab and this last one could be created before
  44       to be requested by the Tab restorator. So we cache it to be sure to have the same instance.
  45     */
  46     private Map<String, SwingScilabTab> cache = new HashMap<String, SwingScilabTab>();
  47     private Map<String, AbstractScilabTabFactory> factories = new HashMap<String, AbstractScilabTabFactory>();
  48
  49     /**
  50      * Default constructor
  51      */
  52     protected ScilabTabFactory() { }
  53
  54     /**
  55      * {@inheritDoc}
  56      */
  57     public Component getDockableComponent(String uuid) {
  58         return getTab(uuid);
  59     }
  60
  61     /**
  62      * Adds a new Tab factory
  63      * @param factory the factory to add
  64      */
  65     public void addTabFactory(AbstractScilabTabFactory factory) {
  66         if (!factories.containsKey(factory.getClassName())) {
  67             factories.put(factory.getClassName(), factory);
  68         }
  69     }
  70
  71     /**
  72      * Adds a new Tab factory
  73      * @param pack the package to load in using LoadClassPath
  74      * @param className the name of the factory
  75      * @return the newly added factory
  76      */
  77     public AbstractScilabTabFactory addTabFactory(String pack, String className) {
  78         AbstractScilabTabFactory factory = null;
  79         if (!factories.containsKey(className)) {
  80             if (pack != null && !pack.isEmpty()) {
  81                 LoadClassPath.loadOnUse(pack);
  82             }
  83             try {
  84                 Class clazz = Class.forName(className);
  85                 factory = (AbstractScilabTabFactory) clazz.newInstance();
  86                 addTabFactory(factory);
  87             } catch (ClassNotFoundException e) {
  88                 System.out.println(e);
  89             }
  90             catch (IllegalAccessException e) {
  91                 System.out.println(e);
  92             }
  93             catch (InstantiationException e) {
  94                 System.out.println(e);
  95             }
  96         }
  97
  98         return factory;
  99     }
 100
 101     /**
 102      * Removes a Tab factory
 103      * @param factory the factory to remove
 104      */
 105     public void removeTabFactory(AbstractScilabTabFactory factory) {
 106         factories.remove(factory);
 107     }
 108
 109     /**
 110      * Creates a tab given an uuid
 111      * @param uuid the uuid
 112      * @return the corresponding tab
 113      */
 114     public SwingScilabTab getTab(String uuid) {
 115         SwingScilabTab tab = cache.get(uuid);
 116         if (tab != null) {
 117             return tab;
 118         }
 119
 120         for (String name : factories.keySet()) {
 121             AbstractScilabTabFactory factory = factories.get(name);
 122             if (factory.isAValidUUID(uuid)) {
 123                 tab = factory.getTab(uuid);
 124                 if (tab != null) {
 125                     cache.put(uuid, tab);
 126                     return tab;
 127                 }
 128             }
 129         }
 130
 131         WindowsConfigurationManager.removeNode(uuid);
 132         return makeEmptyTab(uuid);
 133     }
 134
 135     /**
 136      * {@inheritDoc}
 137      */
 138     public String getPackage(String uuid) {
 139         for (String name : factories.keySet()) {
 140             if (factories.get(name).isAValidUUID(uuid)) {
 141                 return factories.get(name).getPackage();
 142             }
 143         }
 144         return "";
 145     }
 146
 147     /**
 148      * {@inheritDoc}
 149      */
 150     public String getClassName(String uuid) {
 151         for (String name : factories.keySet()) {
 152             if (factories.get(name).isAValidUUID(uuid)) {
 153                 return factories.get(name).getClassName();
 154             }
 155         }
 156         return "";
 157     }
 158
 159     /**
 160      * {@inheritDoc}
 161      */
 162     public String getApplication(String uuid) {
 163         for (String name : factories.keySet()) {
 164             if (factories.get(name).isAValidUUID(uuid)) {
 165                 return factories.get(name).getApplication();
 166             }
 167         }
 168         return "";
 169     }
 170
 171     /**
 172      * Clear the cache
 173      */
 174     public void clearCache() {
 175         cache.clear();
 176     }
 177
 178     public void removeFromCache(String uuid) {
 179         cache.remove(uuid);
 180     }
 181
 182     public SwingScilabTab getFromCache(String uuid) {
 183         return cache.get(uuid);
 184     }
 185
 186     public void addToCache(SwingScilabTab tab) {
 187         cache.put(tab.getPersistentId(), tab);
 188     }
 189
 190     /**
 191      * @return the instace (this class should be used as a singleton)
 192      */
 193     public static ScilabTabFactory getInstance() {
 194         return instance;
 195     }
 196
 197     /**
 198      * Make an empty tab
 199      * @return an empty tab
 200      */
 201     private static final SwingScilabTab makeEmptyTab(String uuid) {
 202         String u = uuid;
 203         if (uuid == null || uuid.isEmpty()) {
 204             u = NULLUUID;
 205         }
 206
 207         SwingScilabTab tab = new SwingScilabTab(EMPTYTAB, u);
 208         String text = String.format(ERROR, u, System.getProperty("user.home"));
 209         JTextArea textarea = new JTextArea(text);
 210         textarea.setEditable(false);
 211         tab.setContentPane(textarea);
 212
 213         return tab;
 214     }
 215 }