KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > nightlabs > editor2d > viewer > action > RenderModeContributionItem


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.viewer.action;
28
29 import java.util.Collection JavaDoc;
30 import java.util.HashMap JavaDoc;
31 import java.util.Iterator JavaDoc;
32 import java.util.Map JavaDoc;
33
34 import org.eclipse.jface.util.Assert;
35 import org.eclipse.swt.SWT;
36 import org.eclipse.swt.events.DisposeEvent;
37 import org.eclipse.swt.events.DisposeListener;
38 import org.eclipse.swt.events.FocusEvent;
39 import org.eclipse.swt.events.FocusListener;
40 import org.eclipse.swt.events.SelectionEvent;
41 import org.eclipse.swt.events.SelectionListener;
42 import org.eclipse.swt.layout.GridData;
43 import org.eclipse.swt.layout.GridLayout;
44 import org.eclipse.swt.widgets.Button;
45 import org.eclipse.swt.widgets.Composite;
46 import org.eclipse.swt.widgets.Control;
47 import org.eclipse.swt.widgets.Menu;
48 import org.eclipse.swt.widgets.ToolBar;
49 import org.eclipse.swt.widgets.ToolItem;
50 import org.eclipse.ui.IPartListener;
51 import org.eclipse.ui.IWorkbenchPage;
52 import org.eclipse.ui.IWorkbenchPart;
53 import org.nightlabs.base.action.XContributionItem;
54 import org.nightlabs.base.composite.XComposite;
55 import org.nightlabs.base.composite.XComposite.LayoutMode;
56 import org.nightlabs.base.custom.ColorCombo;
57 import org.nightlabs.editor2d.render.RenderModeDescriptor;
58 import org.nightlabs.editor2d.render.RenderModeListener;
59 import org.nightlabs.editor2d.render.RenderModeManager;
60 import org.nightlabs.editor2d.render.Renderer;
61 import org.nightlabs.editor2d.render.ShapeRenderer;
62 import org.nightlabs.editor2d.render.StringRenderer;
63 import org.nightlabs.editor2d.viewer.ViewerPlugin;
64
65 public class RenderModeContributionItem
66 extends XContributionItem
67 {
68     public static final String JavaDoc ID = RenderModeContributionItem.class.getName();
69     protected String JavaDoc initString = "RenderMode TEST";
70     
71     public RenderModeContributionItem(IWorkbenchPage page)
72     {
73         super(ID);
74         this.page = page;
75         this.page.addPartListener(partListener);
76     }
77         
78     public RenderModeContributionItem(RenderModeManager renderModeMan)
79     {
80         super(ID);
81         setRenderModeMan(renderModeMan);
82     }
83     
84     protected IPartListener partListener = new IPartListener()
85     {
86         public void partActivated(IWorkbenchPart part)
87         {
88           Object JavaDoc adapter = part.getAdapter(RenderModeManager.class);
89           if (adapter != null && adapter instanceof RenderModeManager) {
90             setRenderModeMan((RenderModeManager)adapter);
91           }
92         }
93         public void partOpened(IWorkbenchPart part) {
94             
95         }
96         public void partDeactivated(IWorkbenchPart part) {
97             
98         }
99         public void partClosed(IWorkbenchPart part) {
100             
101         }
102         public void partBroughtToTop(IWorkbenchPart part) {
103             
104         }
105     };
106     
107     protected Button showString;
108     protected Button showFillColor;
109     
110     protected ColorCombo combo;
111     protected ToolItem toolitem;
112     protected IWorkbenchPage page;
113     
114     protected Map JavaDoc entry2Index = new HashMap JavaDoc();
115     protected Map JavaDoc index2RenderMode = new HashMap JavaDoc();
116         
117   protected void refresh(boolean repopulateCombo)
118   {
119     if (combo == null || combo.isDisposed())
120         return;
121     
122         if (renderModeMan == null) {
123             combo.setEnabled(false);
124             showString.setEnabled(false);
125             showFillColor.setEnabled(false);
126         }
127         
128         if (renderModeMan != null)
129         {
130             checkRenderers(getCurrentRenderers());
131             
132             if (repopulateCombo)
133             {
134                 combo.remove(0);
135                 populateMaps(renderModeMan);
136                 int counter = 0;
137                 for (Iterator JavaDoc it = string2RenderMode.keySet().iterator(); it.hasNext(); )
138                 {
139                     String JavaDoc entry = (String JavaDoc) it.next();
140                     combo.add(null, entry, counter);
141                     entry2Index.put(entry, new Integer JavaDoc(counter));
142                     index2RenderMode.put(new Integer JavaDoc(counter), new Integer JavaDoc(getRenderMode(entry)));
143                     counter++;
144                 }
145             }
146             int currentRenderMode = renderModeMan.getCurrentRenderMode();
147             String JavaDoc entry = getEntry(currentRenderMode);
148             combo.select(getIndex(entry));
149             combo.setEnabled(true);
150         }
151   }
152     
153   /**
154    * Computes the width required by control
155    * @param control The control to compute width
156    * @return int The width required
157    */

158   protected int computeWidth(Control control)
159   {
160     int width = control.computeSize(SWT.DEFAULT, SWT.DEFAULT, true).x;
161     return width;
162   }
163   
164 // /**
165
// * Creates and returns the control for this contribution item
166
// * under the given parent composite.
167
// *
168
// * @param parent the parent composite
169
// * @return the new control
170
// */
171
// protected Control createControl(Composite parent)
172
// {
173
// combo = new ColorCombo(parent, SWT.DROP_DOWN | SWT.BORDER);
174
// combo.addSelectionListener(selectionListener);
175
// combo.addFocusListener(focusListener);
176
// combo.addDisposeListener(disposeListener);
177
//
178
// // Initialize width of combo
179
// combo.add(null, initString, 0);
180
// toolitem.setWidth(computeWidth(combo));
181
// refresh(true);
182
// return combo;
183
// }
184

185   /**
186    * Creates and returns the control for this contribution item
187    * under the given parent composite.
188    *
189    * @param parent the parent composite
190    * @return the new control
191    */

192   protected Control createControl(Composite parent)
193   {
194 // Composite comp = new XComposite(parent, SWT.NONE, LayoutMode.TIGHT_WRAPPER);
195
Composite comp = new XComposite(parent, SWT.NONE);
196     comp.setLayout(new GridLayout(3, false));
197     
198     combo = new ColorCombo(comp, SWT.DROP_DOWN | SWT.BORDER);
199     combo.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
200     combo.addSelectionListener(comboSelectionListener);
201     combo.addFocusListener(comboFocusListener);
202     combo.addDisposeListener(comboDisposeListener);
203     
204     // Initialize width of combo
205
combo.add(null, initString, 0);
206     
207     showString = new Button(comp, SWT.CHECK);
208     showString.setText(ViewerPlugin.getResourceString("contribution.renderMode.showString.text"));
209     showString.setToolTipText(ViewerPlugin.getResourceString("contribution.renderMode.showString.tooltip"));
210     showString.addSelectionListener(showStringSelectionListener);
211     showString.addDisposeListener(showStringDisposeListener);
212     
213     showFillColor = new Button(comp, SWT.CHECK);
214     showFillColor.setText(ViewerPlugin.getResourceString("contribution.renderMode.showFillColor.text"));
215     showFillColor.setToolTipText(ViewerPlugin.getResourceString("contribution.renderMode.showFillColor.tooltip"));
216     showFillColor.addSelectionListener(showShapeSelectionListener);
217     showFillColor.addDisposeListener(showFillColorDisposeListener);
218         
219     toolitem.setWidth(computeWidth(comp));
220     refresh(true);
221         
222     return comp;
223   }
224   
225     protected RenderModeManager renderModeMan;
226     public RenderModeManager getRenderModeMan() {
227         return renderModeMan;
228     }
229     public void setRenderModeMan(RenderModeManager rm)
230     {
231     if (renderModeMan == rm)
232         return;
233     if (renderModeMan != null)
234         renderModeMan.removeRenderModeListener(renderModeListener);
235
236     renderModeMan = rm;
237     refresh(true);
238
239     if (renderModeMan != null)
240         renderModeMan.addRenderModeListener(renderModeListener);
241     }
242     
243      /**
244    * The control item implementation of this <code>IContributionItem</code>
245    * method calls the <code>createControl</code> framework method to
246    * create a control under the given parent, and then creates
247    * a new tool item to hold it.
248    * Subclasses must implement <code>createControl</code> rather than
249    * overriding this method.
250    *
251    * @param parent The ToolBar to add the new control to
252    * @param index Index
253    */

254   public void fill(ToolBar parent, int index)
255   {
256     toolitem = new ToolItem(parent, SWT.SEPARATOR, index);
257     Control control = createControl(parent);
258     toolitem.setControl(control);
259   }
260   
261   /**
262    * The control item implementation of this <code>IContributionItem</code>
263    * method calls the <code>createControl</code> framework method.
264    * Subclasses must implement <code>createControl</code> rather than
265    * overriding this method.
266    *
267    * @param parent The parent of the control to fill
268    */

269   public final void fill(Composite parent) {
270     createControl(parent);
271   }
272
273   /**
274    * The control item implementation of this <code>IContributionItem</code>
275    * method throws an exception since controls cannot be added to menus.
276    *
277    * @param parent The menu
278    * @param index Menu index
279    */

280   public final void fill(Menu parent, int index) {
281     Assert.isTrue(false, "Can't add a control to a menu");//$NON-NLS-1$
282
}
283   
284   /**
285    * @see org.eclipse.jface.action.ContributionItem#dispose()
286    */

287   public void dispose()
288   {
289     if (partListener != null && page != null)
290         page.removePartListener(partListener);
291     
292     if (renderModeMan != null) {
293         renderModeMan.removeRenderModeListener(renderModeListener);
294         renderModeMan = null;
295     }
296     if (combo != null) {
297         combo = null;
298     }
299     partListener = null;
300   }
301   
302   protected Map JavaDoc string2RenderMode = new HashMap JavaDoc();
303   protected Map JavaDoc renderMode2String = new HashMap JavaDoc();
304   
305   protected void populateMaps(RenderModeManager rmm)
306   {
307     for (Iterator JavaDoc it = rmm.getRenderModes().iterator(); it.hasNext(); )
308     {
309         int renderMode = ((Integer JavaDoc) it.next()).intValue();
310         RenderModeDescriptor desc = rmm.getRenderModeDescriptor(renderMode);
311         String JavaDoc s = null;
312         if (desc != null) {
313             s = desc.getLocalizedText();
314         } else {
315             s = "RenderMode "+renderMode;
316         }
317         string2RenderMode.put(s, new Integer JavaDoc(renderMode));
318 // string2RenderMode.put(new Integer(renderMode), s);
319
renderMode2String.put(new Integer JavaDoc(renderMode), s);
320     }
321   }
322   
323   protected int getRenderMode(String JavaDoc entry)
324   {
325     Integer JavaDoc i = (Integer JavaDoc) string2RenderMode.get(entry);
326     if (i != null)
327         return i.intValue();
328     else
329         return 0;
330   }
331   
332   protected String JavaDoc getEntry(int renderMode) {
333     return (String JavaDoc) renderMode2String.get(new Integer JavaDoc(renderMode));
334   }
335   
336   protected int getIndex(String JavaDoc entry)
337   {
338     Integer JavaDoc i = (Integer JavaDoc) entry2Index.get(entry);
339     if (i != null)
340         return i.intValue();
341     else
342         return 0;
343   }
344   
345   protected int getRenderMode(int index)
346   {
347     Integer JavaDoc i = (Integer JavaDoc)index2RenderMode.get(new Integer JavaDoc(index));
348     if (i != null)
349         return i.intValue();
350     else
351         return 1;
352   }
353   
354 // protected List getEntries() {
355
// return new ArrayList(getRenderModeMan().getRenderModes());
356
// }
357
//
358
// protected String getText(Object entry)
359
// {
360
// RenderModeDescriptor desc = getRenderModeMan().getRenderModeDescriptor(((Integer)entry).intValue());
361
// if (desc != null) {
362
// return desc.getLocalizedText();
363
// }
364
// return "RenderMode "+((Integer)entry).intValue();
365
// }
366
//
367
// protected Image getImage(Object entry)
368
// {
369
// RenderModeDescriptor desc = getRenderModeMan().getRenderModeDescriptor(((Integer)entry).intValue());
370
// if (desc != null) {
371
// if (desc.getImage() != null) {
372
// ImageData imgData = ImageUtil.convertToSWT(desc.getImage());
373
// return new Image(null, imgData);
374
// }
375
// }
376
// return null;
377
// }
378

379   protected Collection JavaDoc<Renderer> currentRenderers = null;
380   protected Collection JavaDoc<Renderer> getCurrentRenderers() {
381     return currentRenderers;
382   }
383   
384     protected RenderModeListener renderModeListener = new RenderModeListener()
385     {
386         public void renderModeChanges(int renderMode) {
387             refresh(false);
388             currentRenderers = renderModeMan.getRenderers(renderMode);
389         }
390     };
391     
392     protected SelectionListener comboSelectionListener = new SelectionListener()
393     {
394         public void widgetDefaultSelected(SelectionEvent e) {
395             widgetSelected(e);
396         }
397         public void widgetSelected(SelectionEvent e)
398         {
399             int index = combo.getSelectionIndex();
400             int renderMode = getRenderMode(index);
401             renderModeMan.setCurrentRenderMode(renderMode);
402         }
403     };
404     
405     protected FocusListener comboFocusListener = new FocusListener()
406     {
407         public void focusLost(FocusEvent e) {
408             refresh(false);
409         }
410         public void focusGained(FocusEvent e) {
411             // do nothing
412
}
413     };
414     
415     protected DisposeListener comboDisposeListener = new DisposeListener()
416     {
417         public void widgetDisposed(DisposeEvent e)
418         {
419         combo.removeSelectionListener(comboSelectionListener);
420         combo.removeFocusListener(comboFocusListener);
421         }
422     };
423
424     protected DisposeListener showStringDisposeListener = new DisposeListener()
425     {
426         public void widgetDisposed(DisposeEvent e) {
427             showString.removeSelectionListener(showStringSelectionListener);
428         }
429     };
430     
431     protected DisposeListener showFillColorDisposeListener = new DisposeListener()
432     {
433         public void widgetDisposed(DisposeEvent e) {
434             showFillColor.removeSelectionListener(showShapeSelectionListener);
435         }
436     };
437         
438     protected SelectionListener showStringSelectionListener = new SelectionListener()
439     {
440         public void widgetDefaultSelected(SelectionEvent e) {
441             widgetSelected(e);
442         }
443         public void widgetSelected(SelectionEvent e) {
444             Button b = (Button) e.getSource();
445             boolean selection = b.getSelection();
446             setStringRenderer(getCurrentRenderers(), selection);
447         }
448     };
449     
450     protected SelectionListener showShapeSelectionListener = new SelectionListener()
451     {
452         public void widgetDefaultSelected(SelectionEvent e) {
453             widgetSelected(e);
454         }
455         public void widgetSelected(SelectionEvent e) {
456             Button b = (Button) e.getSource();
457             boolean selection = b.getSelection();
458             setShapeRenderer(getCurrentRenderers(), selection);
459         }
460     };
461     
462     protected void setStringRenderer(Collection JavaDoc<Renderer> renderer, boolean showString)
463     {
464         if (renderer != null)
465         {
466             for (Iterator JavaDoc<Renderer> it = renderer.iterator(); it.hasNext(); ) {
467                 Renderer r = it.next();
468                 if (r instanceof StringRenderer) {
469                     StringRenderer stringRenderer = (StringRenderer) r;
470                     stringRenderer.setShowString(showString);
471                 }
472             }
473             updateViewer();
474         }
475     }
476
477     protected void setShapeRenderer(Collection JavaDoc<Renderer> renderer, boolean showFillColor)
478     {
479         if (renderer != null)
480         {
481             for (Iterator JavaDoc<Renderer> it = renderer.iterator(); it.hasNext(); ) {
482                 Renderer r = it.next();
483                 if (r instanceof ShapeRenderer) {
484                     ShapeRenderer shapeRenderer = (ShapeRenderer) r;
485                     shapeRenderer.setShowFillColor(showFillColor);
486                 }
487             }
488             updateViewer();
489         }
490     }
491         
492     protected void checkRenderers(Collection JavaDoc<Renderer> renderer)
493     {
494         if (renderer != null)
495         {
496             boolean stringRendererContained = false;
497             boolean shapeRendererContained = false;
498             boolean showStringActive = true;
499             boolean showFillColorActive = true;
500             for (Iterator JavaDoc<Renderer> it = renderer.iterator(); it.hasNext(); ) {
501                 Renderer r = it.next();
502                 if (r instanceof ShapeRenderer) {
503                     ShapeRenderer shapeRenderer = (ShapeRenderer) r;
504                     showFillColorActive = shapeRenderer.isShowFillColor();
505                     shapeRendererContained = true;
506                 }
507                 if (r instanceof StringRenderer) {
508                     StringRenderer stringRenderer = (StringRenderer) r;
509                     showStringActive = stringRenderer.isShowString();
510                     stringRendererContained = true;
511                 }
512             }
513             showFillColor.setEnabled(shapeRendererContained);
514             showString.setEnabled(stringRendererContained);
515             
516             // remove SelectionListener first to avoid repaint
517
showFillColor.removeSelectionListener(showShapeSelectionListener);
518             showString.removeSelectionListener(showStringSelectionListener);
519             
520             showFillColor.setSelection(showFillColorActive);
521             showString.setSelection(showStringActive);
522             
523             showFillColor.addSelectionListener(showShapeSelectionListener);
524             showString.addSelectionListener(showStringSelectionListener);
525         }
526     }
527     
528     protected void updateViewer()
529     {
530         renderModeMan.setCurrentRenderMode(renderModeMan.getCurrentRenderMode());
531     }
532 }
533
Popular Tags