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         return makeEmptyTab(uuid);
 132     }
 133
 134     /**
 135      * {@inheritDoc}
 136      */
 137     public String getPackage(String uuid) {
 138         for (String name : factories.keySet()) {
 139             if (factories.get(name).isAValidUUID(uuid)) {
 140                 return factories.get(name).getPackage();
 141             }
 142         }
 143         return "";
 144     }
 145
 146     /**
 147      * {@inheritDoc}
 148      */
 149     public String getClassName(String uuid) {
 150         for (String name : factories.keySet()) {
 151             if (factories.get(name).isAValidUUID(uuid)) {
 152                 return factories.get(name).getClassName();
 153             }
 154         }
 155         return "";
 156     }
 157
 158     /**
 159      * {@inheritDoc}
 160      */
 161     public String getApplication(String uuid) {
 162         for (String name : factories.keySet()) {
 163             if (factories.get(name).isAValidUUID(uuid)) {
 164                 return factories.get(name).getApplication();
 165             }
 166         }
 167         return "";
 168     }
 169
 170     /**
 171      * Clear the cache
 172      */
 173     public void clearCache() {
 174         cache.clear();
 175     }
 176
 177     public void removeFromCache(String uuid) {
 178         cache.remove(uuid);
 179     }
 180
 181     public SwingScilabTab getFromCache(String uuid) {
 182         return cache.get(uuid);
 183     }
 184
 185     public void addToCache(SwingScilabTab tab) {
 186         cache.put(tab.getPersistentId(), tab);
 187     }
 188
 189     /**
 190      * @return the instace (this class should be used as a singleton)
 191      */
 192     public static ScilabTabFactory getInstance() {
 193         return instance;
 194     }
 195
 196     /**
 197      * Make an empty tab
 198      * @return an empty tab
 199      */
 200     private static final SwingScilabTab makeEmptyTab(String uuid) {
 201         String u = uuid;
 202         if (uuid == null || uuid.isEmpty()) {
 203             u = NULLUUID;
 204         }
 205
 206         SwingScilabTab tab = new SwingScilabTab(EMPTYTAB, u);
 207         String text = String.format(ERROR, u, System.getProperty("user.home"));
 208         JTextArea textarea = new JTextArea(text);
 209         textarea.setEditable(false);
 210         tab.setContentPane(textarea);
 211
 212         return tab;
 213     }
 214 }