KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > nightlabs > editor2d > render > RenderModeManager


1 /* *****************************************************************************
2  * NightLabs Editor2D - Graphical editor framework *
3  * Copyright (C) 2004-2005 NightLabs - http://NightLabs.org *
4  * *
5  * This library is free software; you can redistribute it and/or *
6  * modify it under the terms of the GNU Lesser General Public *
7  * License as published by the Free Software Foundation; either *
8  * version 2.1 of the License, or (at your option) any later version. *
9  * *
10  * This library is distributed in the hope that it will be useful, *
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
13  * Lesser General Public License for more details. *
14  * *
15  * You should have received a copy of the GNU Lesser General Public *
16  * License along with this library; if not, write to the *
17  * Free Software Foundation, Inc., *
18  * 51 Franklin St, Fifth Floor, *
19  * Boston, MA 02110-1301 USA *
20  * *
21  * Or get it online : *
22  * http://www.gnu.org/copyleft/lesser.html *
23  * *
24  * *
25  ******************************************************************************/
26
27 package org.nightlabs.editor2d.render;
28
29 import java.util.ArrayList JavaDoc;
30 import java.util.Collection JavaDoc;
31 import java.util.HashMap JavaDoc;
32 import java.util.HashSet JavaDoc;
33 import java.util.Iterator JavaDoc;
34 import java.util.LinkedList JavaDoc;
35 import java.util.Map JavaDoc;
36 import java.util.Set JavaDoc;
37 import java.util.Map.Entry;
38
39 import org.apache.log4j.Logger;
40 import org.nightlabs.editor2d.DrawComponentContainer;
41 import org.nightlabs.editor2d.ImageDrawComponent;
42 import org.nightlabs.editor2d.ShapeDrawComponent;
43
44
45 public class RenderModeManager
46 {
47     public static final Logger LOGGER = Logger.getLogger(RenderModeManager.class);
48     
49   public static final int DEFAULT_MODE = 1;
50   public static final int ROLLOVER_MODE = 2;
51     
52   public RenderModeManager()
53   {
54     super();
55     initModes();
56   }
57
58   /**
59    *
60    * initiates the standard render modes, which are always available
61    */
62   protected void initModes()
63   {
64     if (mode2Class2Renderer == null)
65         mode2Class2Renderer = new HashMap JavaDoc();
66     
67     addRenderer(DEFAULT_MODE, ShapeDrawComponent.class, new ShapeDefaultRenderer());
68     addRenderer(DEFAULT_MODE, ImageDrawComponent.class, new ImageDefaultRenderer());
69     addRenderer(DEFAULT_MODE, DrawComponentContainer.class, new RendererImpl());
70 // addRenderer(ROLLOVER_MODE, ShapeDrawComponent.class, new ShapeRolloverRenderer());
71 // addRenderer(ROLLOVER_MODE, ImageDrawComponent.class, new ImageRolloverRenderer());
72 }
73   
74 // protected RenderModelManagerConfigModule config;
75 protected Map JavaDoc mode2Class2Renderer;
76   
77   /**
78    * adds / registers a new renderMode, for the given Class with the
79    * given Renderer
80    *
81    * @param mode the renderMode to add
82    * @param dcClass the DrawComponent Class to link the Renderer with
83    * @param r the Renderer for the given Mode
84    *
85    * @deprecated should use addRenderer(RenderModeDescriptor desc,
86    * Class dcClass, Renderer r) instead
87    */
88   public void addRenderer(int mode, Class JavaDoc dcClass, Renderer r)
89   {
90     if (dcClass == null)
91         throw new IllegalArgumentException JavaDoc("Param dcClass must not be null!");
92
93     if (r == null)
94         throw new IllegalArgumentException JavaDoc("Param Renderer must not be null!");
95     
96     if (mode2Class2Renderer.containsKey(new Integer JavaDoc(mode)))
97     {
98       Map JavaDoc class2Renderer = (Map JavaDoc) mode2Class2Renderer.get(new Integer JavaDoc(mode));
99       class2Renderer.put(dcClass, r);
100     }
101     else
102     {
103       Map JavaDoc class2Renderer = new HashMap JavaDoc();
104       class2Renderer.put(dcClass, r);
105       mode2Class2Renderer.put(new Integer JavaDoc(mode), class2Renderer);
106     }
107     renderClasses = null;
108   }
109   
110   /**
111    *
112    * @param mode the RenderMode
113    * @param dcClass the DrawComponent Class
114    * @return the Renderer for the given class and Render Mode
115    * if no special Renderer is registered for the given class, the
116    * defaultRenderer for this class is taken.
117    */
118   public Renderer getRenderer(int mode, Class JavaDoc dcClass)
119   {
120     if (mode2Class2Renderer.containsKey(new Integer JavaDoc(mode)))
121     {
122       Map JavaDoc class2Renderer = (Map JavaDoc) mode2Class2Renderer.get(new Integer JavaDoc(mode));
123       if (class2Renderer.containsKey(dcClass)) {
124         Renderer r = (Renderer) class2Renderer.get(dcClass);
125         return r;
126       }
127       else {
128         return getDefaultRenderer(dcClass);
129       }
130     }
131     else
132       return getDefaultRenderer(dcClass);
133   }
134   
135   /**
136    * @return the registered Renderer for the given Class with the
137    * RenderMode DEFAULT_MODE, which should be always available
138    */
139   public Renderer getDefaultRenderer(Class JavaDoc dcClass)
140   {
141     if (mode2Class2Renderer.containsKey(new Integer JavaDoc(DEFAULT_MODE)))
142     {
143       Map JavaDoc class2Renderer = (Map JavaDoc) mode2Class2Renderer.get(new Integer JavaDoc(DEFAULT_MODE));
144       if (class2Renderer.containsKey(dcClass)) {
145         Renderer r = (Renderer) class2Renderer.get(dcClass);
146         return r;
147       }
148       // Check if a registered Class is a maybe superclass of a the given class
149 else {
150         for (Iterator JavaDoc it = class2Renderer.keySet().iterator(); it.hasNext(); ) {
151             Class JavaDoc c = (Class JavaDoc) it.next();
152             if (c.isAssignableFrom(dcClass)) {
153                 Renderer r = (Renderer) class2Renderer.get(c);
154                 return r;
155             }
156         }
157       }
158     }
159     return null;
160   }
161   
162   protected int currentRenderMode = DEFAULT_MODE;
163
164   /**
165    *
166    * @return the current (last set) render Mode
167    */
168     public int getCurrentRenderMode() {
169         return currentRenderMode;
170     }
171  
172     /**
173      *
174      * @param currentRenderMode the RenderMode to set to currentRenderMode
175      */
176     public void setCurrentRenderMode(int currentRenderMode) {
177         this.currentRenderMode = currentRenderMode;
178         fireRenderModeChanged();
179     }
180     
181     protected Set JavaDoc renderModeListeners = null;
182     protected Set JavaDoc getRenderModeListeners()
183     {
184         if (renderModeListeners == null)
185             renderModeListeners = new HashSet JavaDoc();
186         
187         return renderModeListeners;
188     }
189
190     /**
191      *
192      * @param rml the RenderModeListener to add
193      * @see org.nightlabs.editor2d.render.RenderModeListener
194      */
195     public void addRenderModeListener(RenderModeListener rml)
196     {
197         getRenderModeListeners().add(rml);
198     }
199     
200     /**
201      *
202      * @param rml the RenderModeListener to remove
203      * @see org.nightlabs.editor2d.render.RenderModeListener
204      */
205     public void removeRenderModeListener(RenderModeListener rml)
206     {
207         getRenderModeListeners().remove(rml);
208     }
209     
210     protected void fireRenderModeChanged()
211     {
212         for (Iterator JavaDoc it = getRenderModeListeners().iterator(); it.hasNext(); ) {
213             RenderModeListener rml = (RenderModeListener) it.next();
214             rml.renderModeChanges(getCurrentRenderMode());
215         }
216     }
217     
218     /**
219      *
220      * @return all registered Render-Modes
221      */
222     public Set JavaDoc getRenderModes()
223     {
224         return mode2Class2Renderer.keySet();
225     }
226     
227     protected Map JavaDoc renderMode2Descriptor;
228     protected Map JavaDoc getRenderMode2Descriptor()
229     {
230         if (renderMode2Descriptor == null)
231             renderMode2Descriptor = new HashMap JavaDoc();
232         
233         return renderMode2Descriptor;
234     }
235     
236     /**
237      *
238      * @param desc The RenderModeDescriptor for the RenderMode to register
239      * @param c the DrawComponent Class to link the Renderer with
240      * @param r the Renderer for the given RenderMode
241      *
242      * @see org.nightlabs.editor2d.render.Renderer
243      */
244     public void addRenderer(RenderModeDescriptor desc, Class JavaDoc c, Renderer r)
245     {
246         if (desc == null)
247             throw new IllegalArgumentException JavaDoc("Param desc must not be null");
248         
249         addRenderer(desc.getRenderMode(), c, r);
250         getRenderMode2Descriptor().put(new Integer JavaDoc(desc.getRenderMode()), desc);
251     }
252     
253     /**
254      *
255      * @param renderMode the RenderMode
256      * @return the RenderModeDescriptor for the given renderMode if it was registered,
257      * return null if no RenderModeDescriptor is registered
258      */
259     public RenderModeDescriptor getRenderModeDescriptor(int renderMode)
260     {
261         return (RenderModeDescriptor) getRenderMode2Descriptor().get(new Integer JavaDoc(renderMode));
262     }
263     
264     public void logRegisteredRenderer(int renderMode)
265     {
266         Map JavaDoc class2Renderer = (Map JavaDoc) mode2Class2Renderer.get(new Integer JavaDoc(renderMode));
267         if (class2Renderer != null) {
268             for (Iterator JavaDoc it = class2Renderer.entrySet().iterator(); it.hasNext(); ) {
269                 Map.Entry JavaDoc entry = (Map.Entry JavaDoc) it.next();
270                 Class JavaDoc c = (Class JavaDoc) entry.getKey();
271                 Renderer r = (Renderer) entry.getValue();
272                 LOGGER.info("Class "+c.getName());
273                 LOGGER.info("Renderer "+r);
274                 LOGGER.info("");
275             }
276         }
277     }
278     
279     public Collection JavaDoc<Renderer> getRenderers(int renderMode)
280     {
281         Collection JavaDoc<Class JavaDoc> classes = getRenderClasses();
282         Collection JavaDoc<Renderer> renderer = new ArrayList JavaDoc<Renderer>(classes.size());
283         for (Iterator JavaDoc<Class JavaDoc> it = classes.iterator(); it.hasNext(); ) {
284             Class JavaDoc c = it.next();
285             Renderer r = getRenderer(renderMode, c);
286             renderer.add(r);
287         }
288         return renderer;
289     }
290     
291     protected Collection JavaDoc<Class JavaDoc> renderClasses = null;
292     public Collection JavaDoc<Class JavaDoc> getRenderClasses()
293     {
294         if (renderClasses == null) {
295             for (Iterator JavaDoc it = mode2Class2Renderer.entrySet().iterator(); it.hasNext(); ) {
296                 Map.Entry JavaDoc<Integer JavaDoc, Map JavaDoc<Class JavaDoc, Renderer>> entry = (Map.Entry JavaDoc<Integer JavaDoc, Map JavaDoc<Class JavaDoc, Renderer>>) it.next();
297                 Map JavaDoc<Class JavaDoc, Renderer> class2Renderer = entry.getValue();
298                 renderClasses = class2Renderer.keySet();
299             }
300         }
301         return renderClasses;
302     }
303 }
304
Popular Tags