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