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