dc9b2889a86f662ebf2e4a4e0c7f4a2ec86a6cc3
[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  * 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 }