AbstractEditor


1   /* *****************************************************************************
2    * NightLabs Editor2D - Graphical editor framework                             *
3    * Copyright (C) 2004-2005 NightLabs - http://NightLabs.org                    *
4    * Project author: Daniel Mazurek <Daniel.Mazurek [at] nightlabs [dot] org>    *
5    *                                                                             *
6    * This library is free software; you can redistribute it and/or               *
7    * modify it under the terms of the GNU Lesser General Public                  *
8    * License as published by the Free Software Foundation; either                *
9    * version 2.1 of the License, or (at your option) any later version.          *
10   *                                                                             *
11   * This library is distributed in the hope that it will be useful,             *
12   * but WITHOUT ANY WARRANTY; without even the implied warranty of              *
13   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU           *
14   * Lesser General Public License for more details.                             *
15   *                                                                             *
16   * You should have received a copy of the GNU Lesser General Public            *
17   * License along with this library; if not, write to the                       *
18   *     Free Software Foundation, Inc.,                                         *
19   *     51 Franklin St, Fifth Floor,                                            *
20   *     Boston, MA  02110-1301  USA                                             *
21   *                                                                             *
22   * Or get it online :                                                          *
23   *     http://www.gnu.org/copyleft/lesser.html                                 *
24   *                                                                             *
25   *                                                                             *
26   ******************************************************************************/
27  
28  package org.nightlabs.editor2d;
29  
30  import java.beans.PropertyChangeEvent  ;
31  import java.beans.PropertyChangeListener  ;
32  import java.io.File  ;
33  import java.io.FileInputStream  ;
34  import java.io.FileNotFoundException  ;
35  import java.io.FileOutputStream  ;
36  import java.io.InputStream  ;
37  import java.lang.reflect.InvocationTargetException  ;
38  import java.util.ArrayList  ;
39  import java.util.EventObject  ;
40  import java.util.HashMap  ;
41  import java.util.Iterator  ;
42  import java.util.List  ;
43  import java.util.Map  ;
44  
45  import org.apache.log4j.Logger;
46  import org.eclipse.core.runtime.IProgressMonitor;
47  import org.eclipse.core.runtime.NullProgressMonitor;
48  import org.eclipse.draw2d.FigureCanvas;
49  import org.eclipse.draw2d.J2DGraphics;
50  import org.eclipse.draw2d.PositionConstants;
51  import org.eclipse.gef.ContextMenuProvider;
52  import org.eclipse.gef.DefaultEditDomain;
53  import org.eclipse.gef.EditPart;
54  import org.eclipse.gef.EditPartFactory;
55  import org.eclipse.gef.EditPartViewer;
56  import org.eclipse.gef.GraphicalViewer;
57  import org.eclipse.gef.KeyHandler;
58  import org.eclipse.gef.KeyStroke;
59  import org.eclipse.gef.SnapToGeometry;
60  import org.eclipse.gef.SnapToGrid;
61  import org.eclipse.gef.commands.CommandStackEvent;
62  import org.eclipse.gef.commands.CommandStackEventListener;
63  import org.eclipse.gef.dnd.TemplateTransferDragSourceListener;
64  import org.eclipse.gef.editparts.J2DScalableFreeformRootEditPart;
65  import org.eclipse.gef.editparts.ScalableFreeformRootEditPart;
66  import org.eclipse.gef.editparts.ZoomManager;
67  import org.eclipse.gef.palette.PaletteRoot;
68  import org.eclipse.gef.rulers.RulerProvider;
69  import org.eclipse.gef.ui.actions.ActionRegistry;
70  import org.eclipse.gef.ui.actions.AlignmentAction;
71  import org.eclipse.gef.ui.actions.CopyTemplateAction;
72  import org.eclipse.gef.ui.actions.DirectEditAction;
73  import org.eclipse.gef.ui.actions.GEFActionConstants;
74  import org.eclipse.gef.ui.actions.MatchHeightAction;
75  import org.eclipse.gef.ui.actions.MatchWidthAction;
76  import org.eclipse.gef.ui.actions.ToggleGridAction;
77  import org.eclipse.gef.ui.actions.ToggleRulerVisibilityAction;
78  import org.eclipse.gef.ui.actions.ToggleSnapToGeometryAction;
79  import org.eclipse.gef.ui.actions.ZoomInAction;
80  import org.eclipse.gef.ui.actions.ZoomOutAction;
81  import org.eclipse.gef.ui.palette.PaletteViewer;
82  import org.eclipse.gef.ui.palette.PaletteViewerProvider;
83  import org.eclipse.gef.ui.palette.FlyoutPaletteComposite.FlyoutPreferences;
84  import org.eclipse.gef.ui.parts.J2DGraphicalEditorWithFlyoutPalette;
85  import org.eclipse.gef.ui.parts.ScrollingGraphicalViewer;
86  import org.eclipse.gef.ui.parts.SelectionSynchronizer;
87  import org.eclipse.gef.ui.parts.TreeViewer;
88  import org.eclipse.gef.ui.properties.UndoablePropertySheetEntry;
89  import org.eclipse.gef.ui.rulers.RulerComposite;
90  import org.eclipse.jface.action.IAction;
91  import org.eclipse.jface.dialogs.ProgressMonitorDialog;
92  import org.eclipse.jface.operation.IRunnableWithProgress;
93  import org.eclipse.swt.SWT;
94  import org.eclipse.swt.events.ControlAdapter;
95  import org.eclipse.swt.events.ControlEvent;
96  import org.eclipse.swt.events.ControlListener;
97  import org.eclipse.swt.widgets.Composite;
98  import org.eclipse.swt.widgets.Control;
99  import org.eclipse.swt.widgets.Event;
100 import org.eclipse.swt.widgets.FileDialog;
101 import org.eclipse.swt.widgets.Listener;
102 import org.eclipse.ui.IEditorInput;
103 import org.eclipse.ui.IEditorPart;
104 import org.eclipse.ui.IWorkbenchPart;
105 import org.eclipse.ui.actions.ActionFactory;
106 import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
107 import org.eclipse.ui.views.properties.PropertySheetPage;
108 import org.holongate.j2d.J2DRegistry;
109 import org.nightlabs.base.io.FileEditorInput;
110 import org.nightlabs.base.io.IOFilterRegistry;
111 import org.nightlabs.base.language.LanguageManager;
112 import org.nightlabs.base.util.RCPUtil;
113 import org.nightlabs.editor2d.actions.CloneAction;
114 import org.nightlabs.editor2d.actions.CopyAction;
115 import org.nightlabs.editor2d.actions.CutAction;
116 import org.nightlabs.editor2d.actions.EditShapeAction;
117 import org.nightlabs.editor2d.actions.NormalSelectionAction;
118 import org.nightlabs.editor2d.actions.PasteAction;
119 import org.nightlabs.editor2d.actions.ResetRotationCenterAction;
120 import org.nightlabs.editor2d.actions.RotateAction;
121 import org.nightlabs.editor2d.actions.SelectAllWithSameName;
122 import org.nightlabs.editor2d.actions.ShowDefaultRenderAction;
123 import org.nightlabs.editor2d.actions.order.ChangeOrderOneDown;
124 import org.nightlabs.editor2d.actions.order.ChangeOrderOneUp;
125 import org.nightlabs.editor2d.actions.order.ChangeOrderToLocalBack;
126 import org.nightlabs.editor2d.actions.order.ChangeOrderToLocalFront;
127 import org.nightlabs.editor2d.actions.preferences.ShowFigureToolTipAction;
128 import org.nightlabs.editor2d.actions.preferences.ShowStatusLineAction;
129 import org.nightlabs.editor2d.actions.zoom.ZoomAllAction;
130 import org.nightlabs.editor2d.actions.zoom.ZoomSelectionAction;
131 import org.nightlabs.editor2d.edit.MultiLayerDrawComponentEditPart;
132 import org.nightlabs.editor2d.figures.BufferedFreeformLayer;
133 import org.nightlabs.editor2d.impl.LayerImpl;
134 import org.nightlabs.editor2d.outline.EditorOutlinePage;
135 import org.nightlabs.editor2d.outline.filter.FilterManager;
136 import org.nightlabs.editor2d.outline.filter.FilterNameProvider;
137 import org.nightlabs.editor2d.properties.EditorPropertyPage;
138 import org.nightlabs.editor2d.render.RenderModeManager;
139 import org.nightlabs.editor2d.rulers.EditorRulerProvider;
140 import org.nightlabs.editor2d.viewer.descriptor.DescriptorManager;
141 import org.nightlabs.editor2d.viewer.render.RendererRegistry;
142 import org.nightlabs.io.AbstractIOFilterWithProgress;
143 import org.nightlabs.io.IOFilter;
144 import org.nightlabs.io.IOFilterMan;
145 import org.nightlabs.io.IOFilterWithProgress;
146 import org.nightlabs.io.WriteException;
147 import org.nightlabs.util.FontUtil;
148 
149 
150 public abstract class AbstractEditor 
151 extends J2DGraphicalEditorWithFlyoutPalette 
152 {
153     public static final Logger LOGGER = Logger.getLogger(Editor.class);
154 
155     protected boolean savePreviouslyNeeded = false;
156     protected RulerComposite rulerComp;
157     
158     protected TreeViewer treeViewer;    
159     protected EditorOutlinePage outlinePage;
160     protected boolean editorSaving = false;
161     
162     protected static final String   PALETTE_DOCK_LOCATION = "Dock location"; //$NON-NLS-1$
163     protected static final String   PALETTE_SIZE = "Palette Size"; //$NON-NLS-1$
164     protected static final String   PALETTE_STATE = "Palette state"; //$NON-NLS-1$
165     protected static final int DEFAULT_PALETTE_SIZE = 130;
166     
167     static {
168       EditorPlugin.getDefault().getPreferenceStore().setDefault(
169           PALETTE_SIZE, DEFAULT_PALETTE_SIZE);
170     }
171     
172     protected void closeEditor(boolean save) 
173     {
174       getSite().getPage().closeEditor(AbstractEditor.this, save);      
175       System.gc();
176     }
177     
178     public Object   getModel() {
179       return getMultiLayerDrawComponent();
180     }
181     
182     protected MultiLayerDrawComponent mldc = null;  
183     public MultiLayerDrawComponent getMultiLayerDrawComponent() 
184     {
185       if (mldc == null) {
186         mldc = createMultiLayerDrawComponent();
187       }      
188       return mldc;
189     }
190   
191     public abstract MultiLayerDrawComponent createMultiLayerDrawComponent(); 
192         
193     public abstract EditPartFactory getEditPartFactory();
194         
195     public abstract EditPartFactory getOutlineEditPartFactory();
196     
197     /* (non-Javadoc)
198      * @see org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette#getPaletteRoot()
199      */
200     public abstract PaletteRoot getPaletteRoot(); 
201     
202     public abstract ContextMenuProvider getContextMenuProvider();
203     
204 //    /**
205 //     * SubClasses of this Editor should register here IOFilters for Input/Outputs
206 //     * which they want to support
207 //     * @see EditorIOFilterMan.addIOFIlter(Class IOFilterClass)
208 //     */
209 //    public abstract void registerIOFilters(); 
210     
211     /** Cache save-request status. */
212     protected boolean saveAlreadyRequested;
213     /** KeyHandler with common bindings for both the Outline View and the Editor. */
214     protected KeyHandler sharedKeyHandler;
215 
216     protected RenderModeManager renderMan;
217     public RenderModeManager getRenderModeManager() {
218       return renderMan;
219     }     
220 //    public RenderModeManager getRenderModeManager() {
221 //      return getMultiLayerDrawComponent().getRenderModeManager();
222 //    } 
223     
224     protected FilterManager filterMan;
225     public FilterManager getFilterManager() {
226       return filterMan;
227     }
228      
229     protected abstract FilterNameProvider getFilterNameProvider();
230     
231 //    protected IOFilterMan ioFilterMan;
232 //    public IOFilterMan getIOFilterMan() {
233 //      return ioFilterMan;
234 //    }
235    
236     protected IOFilterMan ioFilterMan;
237     public IOFilterMan getIOFilterMan() 
238     {
239         if (ioFilterMan == null)
240             ioFilterMan = IOFilterRegistry.sharedInstance().getIOFilterMan();
241             
242         return ioFilterMan;
243     }
244         
245     protected LanguageManager langMan;
246     public LanguageManager getLanguageManager() 
247     {
248         if (langMan == null)
249             langMan = new LanguageManager();
250         
251         return langMan;
252     }
253     
254     /** Create a new Editor instance. This is called by the Workspace. */
255     public AbstractEditor() 
256     {
257       setEditDomain(new DefaultEditDomain(this));
258       FontUtil.initSystemFonts();
259       
260 //      renderMan = new RenderModeManager();
261 //      registerRenderer();
262       
263 //      ioFilterMan = new IOFilterMan();      
264 //      registerIOFilters();
265       
266       filterMan = new FilterManager(getFilterNameProvider());     
267       
268       // WORKAROUND: Holongate Draw2D-PreferencePage does not store values 
269       Map   hints = new HashMap  ();
270       hints.put(J2DGraphics.KEY_USE_JAVA2D, Boolean.TRUE);
271       J2DRegistry.setHints(hints);      
272     }
273 
274 //    /**
275 //     * Subclasses should register in this Method custom renderers
276 //     * in the RenderModeManager
277 //     */
278 //    public abstract void registerRenderer();
279                       
280     protected MultiLayerDrawComponent load(IOFilter ioFilter, InputStream   input) 
281     {      
282       if (ioFilter != null) 
283       {
284         try {
285             MultiLayerDrawComponent mldc = (MultiLayerDrawComponent) ioFilter.read(input);
286             mldc.setRenderModeManager(getRenderModeManager());
287           return mldc;          
288         } 
289         catch (Exception   e) {
290             throw new RuntimeException  ("There occured an Error while reading with IOFilter "+ioFilter+" from InpuStream "+input, e);
291         }          
292       }
293       return null;
294     }
295     
296     protected void load(FileEditorInput fileInput, IProgressMonitor monitor) 
297     {
298         IOFilter ioFilter = getIOFilterMan().getIOFilter(fileInput.getFile());
299         if (ioFilter != null) 
300         {
301             try {           
302                 if (ioFilter instanceof IOFilterWithProgress) 
303                 {                   
304                     IOFilterWithProgress progressFilter = (IOFilterWithProgress) ioFilter;
305                     progressFilter.addPropertyChangeListener(progressListener);                 
306                     monitor.beginTask(EditorPlugin.getResourceString("resource.load") +" "+ fileInput.getName(), progressFilter.getTotalWork());
307                     mldc = load(ioFilter, new FileInputStream  (fileInput.getFile()));
308                     progressFilter.removePropertyChangeListener(progressListener);
309                     return;
310                 }
311                 else
312                     monitor.beginTask(EditorPlugin.getResourceString("resource.load") +" "+ fileInput.getName(), 2);                    
313                     mldc = load(ioFilter, new FileInputStream  (fileInput.getFile()));
314                     return;
315                 } catch (FileNotFoundException   e) {
316                     throw new RuntimeException  (e);
317                 } finally {
318                 monitor.done();
319                 }
320         }
321     }
322         
323     protected void load(FileEditorInput fileInput) 
324     {       
325         final FileEditorInput input = fileInput;
326         IRunnableWithProgress runnable = new IRunnableWithProgress()
327         {           
328                 public void run(IProgressMonitor monitor) 
329                 throws InvocationTargetException  , InterruptedException   
330                 {
331           try {
332             load(input, monitor);      
333           } 
334           catch (Exception   e) {
335             throw new RuntimeException  (e);
336           }                 
337                 }           
338             };
339             
340       try {
341         getProgressMonitor().run(false, false, runnable);
342         setPartName(input.getName());
343       }
344       catch (Exception   e) {
345         throw new RuntimeException  (e);
346       }             
347     }
348     
349     protected ScalableFreeformRootEditPart rootEditPart;
350     public ScalableFreeformRootEditPart getRootEditPart() 
351     {
352       if (rootEditPart == null)
353         rootEditPart = new J2DScalableFreeformRootEditPart();
354       
355       return rootEditPart;
356     }
357     
358     protected ViewerManager viewerManager;
359     public ViewerManager getViewerManager() {
360         return viewerManager;
361     }
362     
363     protected DescriptorManager descriptorManager;
364     public DescriptorManager getDescriptorManager() {
365         return descriptorManager;
366     }
367     
368     protected void configureGraphicalViewer() 
369     {
370       super.configureGraphicalViewer();
371       ScrollingGraphicalViewer viewer = (ScrollingGraphicalViewer)getGraphicalViewer();
372             
373       List   zoomLevels = new ArrayList  (3);
374       zoomLevels.add(ZoomManager.FIT_ALL);
375       zoomLevels.add(ZoomManager.FIT_WIDTH);
376       zoomLevels.add(ZoomManager.FIT_HEIGHT);
377       getRootEditPart().getZoomManager().setZoomLevelContributions(zoomLevels);
378 
379       viewer.setRootEditPart(getRootEditPart());
380 
381       viewer.setEditPartFactory(getEditPartFactory());
382       ContextMenuProvider provider = getContextMenuProvider();
383       viewer.setContextMenu(provider);
384       // TODO: ContextMenu ID Problem
385       getSite().registerContextMenu("org.nightlabs.editor2d.contextmenu", //$NON-NLS-1$
386           provider, viewer);
387 //      viewer.setKeyHandler(new GraphicalViewerKeyHandler(viewer)
388 //          .setParent(getCommonKeyHandler()));
389       viewer.setKeyHandler(new EditorViewerKeyHandler(viewer)
390           .setParent(getCommonKeyHandler()));
391             
392       loadProperties();
393 
394       // Actions
395       IAction showRulers = new ToggleRulerVisibilityAction(getGraphicalViewer());
396       getActionRegistry().registerAction(showRulers);
397       
398       IAction snapAction = new ToggleSnapToGeometryAction(getGraphicalViewer());
399       getActionRegistry().registerAction(snapAction);
400 
401       IAction showGrid = new ToggleGridAction(getGraphicalViewer());
402       getActionRegistry().registerAction(showGrid);
403       
404       Listener   listener = new Listener  () {
405         public void handleEvent(Event   event) {
406           handleActivationChanged(event);
407         }
408       };
409       getGraphicalControl().addListener(SWT.Activate, listener);
410       getGraphicalControl().addListener(SWT.Deactivate, listener);  
411             
412       // ViewerManager
413       viewerManager = new ViewerManager(viewer, getEditorSite().getActionBars().getStatusLineManager());
414       configureViewerManager();  
415             
416       getGraphicalControl().addControlListener(resizeListener);
417       getCommandStack().addCommandStackEventListener(commandStackListener);
418     }
419      
420     // should solve redraw problems when resizing the viewer
421     protected ControlListener resizeListener = new ControlAdapter(){        
422             public void controlResized(ControlEvent e) {
423 //              if (e.getSource().equals(getGraphicalViewer().getControl())) {
424                     updateViewer();
425 //              }
426             }       
427         };
428             
429     // should solve redraw problems when undoing things
430     protected CommandStackEventListener commandStackListener = new CommandStackEventListener(){     
431             public void stackChanged(CommandStackEvent event) {
432                 updateViewer();
433             }       
434         };              
435     
436     /* (non-Javadoc)
437      * @see org.eclipse.gef.ui.parts.GraphicalEditor#commandStackChanged(java.util.EventObject)
438      */    
439     public void commandStackChanged(EventObject   event) 
440     {
441       if (isDirty()){
442         if (!savePreviouslyNeeded()) {
443           setSavePreviouslyNeeded(true);
444           firePropertyChange(IEditorPart.PROP_DIRTY);
445         }
446       }
447       else {
448         setSavePreviouslyNeeded(false);
449         firePropertyChange(IEditorPart.PROP_DIRTY);
450       }
451       super.commandStackChanged(event);
452     }  
453 
454     /* (non-Javadoc)
455      * @see org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette#createPaletteViewerProvider()
456      */
457     protected PaletteViewerProvider createPaletteViewerProvider() {
458       return new PaletteViewerProvider(getEditDomain()) {
459         protected void configurePaletteViewer(PaletteViewer viewer) {
460           super.configurePaletteViewer(viewer);
461           // create a drag source listener for this palette viewer
462           // together with an appropriate transfer drop target listener, this will enable
463           // model element creation by dragging a CombinatedTemplateCreationEntries 
464           // from the palette into the editor
465           // @see ShapesEditor#createTransferDropTargetListener()
466           viewer.addDragSourceListener(new TemplateTransferDragSourceListener(viewer));
467         }
468       };
469     }
470 
471     public Object   getAdapter(Class   type)
472     {
473       if (type == IContentOutlinePage.class) {
474           treeViewer = new TreeViewer();
475         outlinePage = new EditorOutlinePage(this, treeViewer);        
476         return outlinePage;
477       }
478       if (type == ZoomManager.class)
479         return getGraphicalViewer().getProperty(ZoomManager.class.toString());
480         
481         if (type == org.eclipse.ui.views.properties.IPropertySheetPage.class) {
482 //          PropertySheetPage page = new EditorPropertyPage(getLanguageManager());
483             PropertySheetPage page = new EditorPropertyPage();          
484             page.setRootEntry(new UndoablePropertySheetEntry(getCommandStack()));
485             return page;
486         }
487         
488         if (type == RenderModeManager.class)
489             return getRenderModeManager();
490         
491       return super.getAdapter(type);
492     }
493     
494     protected Control getGraphicalControl() {
495       return rulerComp;
496     }
497       
498 //    /**
499 //     * Create a transfer drop target listener. When using a CombinedTemplateCreationEntry
500 //     * tool in the palette, this will enable model element creation by dragging from the palette.
501 //     * @see #createPaletteViewerProvider()
502 //     */
503 //    protected TransferDropTargetListener createTransferDropTargetListener() {
504 //      return new TemplateTransferDropTargetListener(getGraphicalViewer()) {
505 //        protected CreationFactory getFactory(Object template) {
506 //          return new SimpleFactory((Class) template);
507 //        }
508 //      };
509 //    }
510 
511     public void doSave(IProgressMonitor monitor) 
512     {
513       try {         
514         FileEditorInput input = (FileEditorInput) getEditorInput();
515         if (!input.isSaved()) {
516             doSaveAs();
517             return;
518         }
519         
520         File   file = input.getFile();
521         String   inputName = input.getName();
522         LOGGER.debug("inputName = "+inputName);
523         
524         if (file.exists() 
525             || org.eclipse.jface.dialogs.MessageDialogWithToggle.openConfirm(getSite().getShell(),
526                 EditorPlugin.getResourceString("resource.create.file"),
527                 EditorPlugin.getResourceString("resource.fileNotExists.1")
528                 + " "
529                 + file.getName() 
530                 + " "
531                 + EditorPlugin.getResourceString("resource.fileNotExists.2")))
532         {
533           editorSaving = true;
534           saveProperties();
535           save(file, monitor);
536           getCommandStack().markSaveLocation();
537         }
538       }
539       catch (WriteException e)
540       {
541         throw new RuntimeException  (e);
542         
543 //          RCPUtil.showErrorDialog(EditorPlugin.getResourceString("error.during.save"));
544         
545 //        ErrorDialog.openError(
546 //          getSite().getShell(),
547 //          EditorPlugin.getResourceString("error.during.save"),
548 //          EditorPlugin.getResourceString("error.during.save.message"),
549 //          e.getStatus());
550       }   
551     }
552 
553     /* (non-Javadoc)
554      * @see org.eclipse.ui.ISaveablePart#doSaveAs()
555      */
556     public void doSaveAs() 
557     {
558       performSaveAs();      
559     }
560 
561     /**
562      * Returns the KeyHandler with common bindings for both the Outline and Graphical Views.
563      * For example, delete is a common action.
564      */
565     public KeyHandler getCommonKeyHandler() 
566     {
567       if (sharedKeyHandler == null) {
568         sharedKeyHandler = new KeyHandler();
569 
570         // Add key and action pairs to sharedKeyHandler
571         sharedKeyHandler.put(
572             KeyStroke.getPressed(SWT.DEL, 127, 0),
573             getActionRegistry().getAction(ActionFactory.DELETE.getId()));
574         sharedKeyHandler.put(
575             KeyStroke.getPressed(SWT.F2, 0),
576             getActionRegistry().getAction(GEFActionConstants.DIRECT_EDIT));     
577       }
578       return sharedKeyHandler;
579     }
580 
581     /* (non-Javadoc)
582      * @see org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette#getPalettePreferences()
583      */
584     protected FlyoutPreferences getPalettePreferences() {
585       return EditorPaletteFactory.createPalettePreferences();
586     }
587     
588     protected void handleActivationChanged(Event   event) 
589     {
590       IAction copy = null;
591       if (event.type == SWT.Deactivate)
592         copy = getActionRegistry().getAction(ActionFactory.COPY.getId());
593       if (getEditorSite().getActionBars().getGlobalActionHandler(ActionFactory.COPY.getId()) 
594           != copy) {
595         getEditorSite().getActionBars().setGlobalActionHandler(
596             ActionFactory.COPY.getId(), copy);
597         getEditorSite().getActionBars().updateActionBars();
598       }
599     }  
600     
601     /**
602      * Set up the editor's inital content (after creation).
603      * @see org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette#initializeGraphicalViewer()
604      */
605     protected void initializeGraphicalViewer() 
606     {
607       GraphicalViewer graphicalViewer = getGraphicalViewer();
608       graphicalViewer.setContents(getModel()); // set the contents of this editor
609       
610 //      // listen for dropped parts
611 //      graphicalViewer.addDropTargetListener(createTransferDropTargetListener());   
612       
613       // DescriptorManager
614       descriptorManager = new DescriptorManager();
615       configureDescriptorManager();      
616       if (getModelRootEditPart() != null) {
617         getModelRootEditPart().setDescriptorManager(getDescriptorManager());
618       } else {
619         LOGGER.debug("DescriptorManager for MultiLayerDrawComponentEditPart not set, because it is null!");
620       }
621       viewerManager.setDescriptorManager(getDescriptorManager());      
622       
623       configureFilterManager();      
624     }
625 
626     protected void configureFilterManager() 
627     {
628         Map   class2DrawComponents = getMultiLayerDrawComponent().getClass2DrawComponents();
629         for (Iterator   it = class2DrawComponents.keySet().iterator(); it.hasNext(); ) {
630             Class   c = (Class  ) it.next();
631             getFilterManager().addFilter(c);
632         }
633         getMultiLayerDrawComponent().addPropertyChangeListener(getFilterManager().getTypeListener());           
634         getFilterManager().ignoreClass(LayerImpl.class);        
635     }
636 
637     /**
638      * By Default this Method does nothing, but Inheritans can override this Method to define 
639      * excluded EditParts, ignored classes or an exclusive class
640      * 
641      * @see org.nightlabs.editor2d.ViewerManager
642      */
643     protected void configureViewerManager()
644     {
645         
646     }
647     
648     /**
649      * By Default this Method does nothing, but Inheritans can override this Method to add 
650      * Descriptors for special classes to the DescriptorManager
651      * 
652      * @see DescriptorManager#addDescriptor(org.nightlabs.editor2d.viewer.descriptor.IDrawComponentDescriptor, Class) 
653      */
654     protected void configureDescriptorManager() 
655     {
656         
657     }
658     
659     protected void createActions() 
660     {
661       super.createActions();
662       ActionRegistry registry = getActionRegistry();
663       IAction action;
664       
665 //      action = new CopyTemplateAction(this);
666 //      registry.registerAction(action);
667 
668       // Match Actions
669       action = new MatchWidthAction(this);
670       registry.registerAction(action);
671       getSelectionActions().add(action.getId());
672       
673       action = new MatchHeightAction(this);
674       registry.registerAction(action);
675       getSelectionActions().add(action.getId());
676       
677 //      action = new EditorPasteTemplateAction(this);
678 //      registry.registerAction(action);
679 //      getSelectionActions().add(action.getId());
680 
681       action = new DirectEditAction((IWorkbenchPart)this);
682       registry.registerAction(action);
683       getSelectionActions().add(action.getId());
684 
685       // Alignment Actions
686       action = new AlignmentAction((IWorkbenchPart)this, PositionConstants.LEFT);
687       registry.registerAction(action);
688       getSelectionActions().add(action.getId());
689 
690       action = new AlignmentAction((IWorkbenchPart)this, PositionConstants.RIGHT);
691       registry.registerAction(action);
692       getSelectionActions().add(action.getId());
693 
694       action = new AlignmentAction((IWorkbenchPart)this, PositionConstants.TOP);
695       registry.registerAction(action);
696       getSelectionActions().add(action.getId());
697 
698       action = new AlignmentAction((IWorkbenchPart)this, PositionConstants.BOTTOM);
699       registry.registerAction(action);
700       getSelectionActions().add(action.getId());
701 
702       action = new AlignmentAction((IWorkbenchPart)this, PositionConstants.CENTER);
703       registry.registerAction(action);
704       getSelectionActions().add(action.getId());
705 
706       action = new AlignmentAction((IWorkbenchPart)this, PositionConstants.MIDDLE);
707       registry.registerAction(action);
708       getSelectionActions().add(action.getId());
709       
710       // ZoomIn
711       action = new ZoomInAction(getRootEditPart().getZoomManager());
712       registry.registerAction(action);      
713       getSite().getKeyBindingService().registerAction(action);
714 
715       // ZoomOut
716       action = new ZoomOutAction(getRootEditPart().getZoomManager());
717       registry.registerAction(action);      
718       getSite().getKeyBindingService().registerAction(action);
719 
720       // Zoom All
721       action = new ZoomAllAction(getRootEditPart().getZoomManager());
722       registry.registerAction(action);      
723       
724       // Zoom Selection
725       action = new ZoomSelectionAction(this);      
726       registry.registerAction(action);
727       getSelectionActions().add(action.getId());
728             
729       // Edit Shape Action
730       action = new EditShapeAction(this);
731       registry.registerAction(action);
732       getSelectionActions().add(action.getId());
733       
734       // Rotate Action
735       action = new RotateAction(this);
736       registry.registerAction(action);
737       getSelectionActions().add(action.getId());
738       
739       // Normal Selection Action
740       action = new NormalSelectionAction(this);
741       registry.registerAction(action);
742       getSelectionActions().add(action.getId());   
743       
744       // Reset Rotation Center Action
745       action = new ResetRotationCenterAction(this);
746       registry.registerAction(action);
747       getSelectionActions().add(action.getId());
748       
749       // Show Default View (Renderer) Action
750       action = new ShowDefaultRenderAction(this);
751       registry.registerAction(action);
752 
753       // Select all with same name
754       action = new SelectAllWithSameName(this);
755       registry.registerAction(action);
756       getSelectionActions().add(action.getId());    
757       
758       // Clone (Duplicate) Action
759       action = new CloneAction(this);
760       registry.registerAction(action);
761       getSelectionActions().add(action.getId());   
762             
763       // Order Actions
764       action = new ChangeOrderToLocalFront(this);
765       registry.registerAction(action);
766       getSelectionActions().add(action.getId());    
767 
768       action = new ChangeOrderToLocalBack(this);
769       registry.registerAction(action);
770       getSelectionActions().add(action.getId());    
771       
772       action = new ChangeOrderOneDown(this);
773       registry.registerAction(action);
774       getSelectionActions().add(action.getId());    
775 
776       action = new ChangeOrderOneUp(this);
777       registry.registerAction(action);
778       getSelectionActions().add(action.getId());    
779       
780       // Paste Action
781       PasteAction pasteAction = new PasteAction(this);
782       registry.registerAction(pasteAction);
783       getPropertyActions().add(pasteAction.getId());
784       getSite().getKeyBindingService().registerAction(pasteAction);
785            
786       // Cut Action
787       CutAction cutAction = new CutAction(this);
788       registry.registerAction(cutAction);
789       getSelectionActions().add(cutAction.getId());
790       cutAction.addPropertyChangeListener(pasteAction.cutListener);
791       getSite().getKeyBindingService().registerAction(cutAction);      
792             
793       // Copy Action
794       CopyAction copyAction = new CopyAction(this);
795       registry.registerAction(copyAction);
796       getSelectionActions().add(copyAction.getId());  
797       copyAction.addPropertyChangeListener(pasteAction.copyListener);
798       getSite().getKeyBindingService().registerAction(copyAction);      
799             
800       action = new ShowFigureToolTipAction(this);
801       registry.registerAction(action);
802       getPropertyActions().add(action);
803 
804       action = new ShowStatusLineAction(this);
805       registry.registerAction(action);
806       getPropertyActions().add(action);
807       
808 //      // Test Viewer Action
809 //      action = new ViewerAction(this);
810 //      registry.registerAction(action);
811     }
812     
813     /* (non-Javadoc)
814      * @see org.eclipse.gef.ui.parts.GraphicalEditor#createGraphicalViewer(org.eclipse.swt.widgets.Composite)
815      */
816     protected void createGraphicalViewer(Composite parent) 
817     {
818       rulerComp = new RulerComposite(parent, SWT.NONE);
819       super.createGraphicalViewer(rulerComp);
820       rulerComp.setGraphicalViewer((ScrollingGraphicalViewer) getGraphicalViewer());      
821     }  
822     
823     public FigureCanvas getEditor(){
824       return (FigureCanvas)getGraphicalViewer().getControl();
825     }
826     
827     public boolean isDirty() {
828       return isSaveOnCloseNeeded();
829     }
830 
831     public boolean isSaveOnCloseNeeded() {
832       return getCommandStack().isDirty();
833     }
834     
835     protected void loadProperties() 
836     {
837       // Ruler properties
838       EditorRuler ruler = getMultiLayerDrawComponent().getLeftRuler();
839       RulerProvider provider = null;
840       if (ruler != null) {
841         provider = new EditorRulerProvider(ruler);
842       }
843       getGraphicalViewer().setProperty(RulerProvider.PROPERTY_VERTICAL_RULER, provider);
844       ruler = getMultiLayerDrawComponent().getTopRuler();
845       provider = null;
846       if (ruler != null) {
847         provider = new EditorRulerProvider(ruler);
848       }
849       getGraphicalViewer().setProperty(RulerProvider.PROPERTY_HORIZONTAL_RULER, provider);
850       getGraphicalViewer().setProperty(RulerProvider.PROPERTY_RULER_VISIBILITY, 
851           new Boolean  (getMultiLayerDrawComponent().isRulersEnabled()));
852       
853       // Snap to Geometry property
854       getGraphicalViewer().setProperty(SnapToGeometry.PROPERTY_SNAP_ENABLED, 
855           new Boolean  (getMultiLayerDrawComponent().isSnapToGeometry()));
856       
857       // Grid properties
858       getGraphicalViewer().setProperty(SnapToGrid.PROPERTY_GRID_ENABLED, 
859           new Boolean  (getMultiLayerDrawComponent().isGridEnabled()));
860       // We keep grid visibility and enablement in sync
861       getGraphicalViewer().setProperty(SnapToGrid.PROPERTY_GRID_VISIBLE, 
862           new Boolean  (getMultiLayerDrawComponent().isGridEnabled()));
863       
864       // Zoom
865       ZoomManager manager = (ZoomManager)getGraphicalViewer()
866           .getProperty(ZoomManager.class.toString());
867       if (manager != null)
868         manager.setZoom(getMultiLayerDrawComponent().getZoom());
869 //        manager.setZoomAsText(ZoomManager.FIT_ALL);                   
870     }
871     
872     /* (non-Javadoc)
873      * @see org.eclipse.ui.ISaveablePart#isSaveAsAllowed()
874      */
875     public boolean isSaveAsAllowed() {
876       return true;
877     }
878 
879     protected boolean savePreviouslyNeeded() {
880       return savePreviouslyNeeded;
881     }
882     
883     protected void saveProperties() 
884     {
885       getMultiLayerDrawComponent().setRulersEnabled(((Boolean  )getGraphicalViewer()
886           .getProperty(RulerProvider.PROPERTY_RULER_VISIBILITY)).booleanValue());
887       getMultiLayerDrawComponent().setGridEnabled(((Boolean  )getGraphicalViewer()
888           .getProperty(SnapToGrid.PROPERTY_GRID_ENABLED)).booleanValue());
889       getMultiLayerDrawComponent().setSnapToGeometry(((Boolean  )getGraphicalViewer()
890           .getProperty(SnapToGeometry.PROPERTY_SNAP_ENABLED)).booleanValue());
891       ZoomManager manager = (ZoomManager)getGraphicalViewer()
892           .getProperty(ZoomManager.class.toString());
893       if (manager != null)
894         getMultiLayerDrawComponent().setZoom(manager.getZoom());
895     }
896     
897     protected void setSavePreviouslyNeeded(boolean value) {
898       savePreviouslyNeeded = value;
899     }  
900     
901 //    protected void superSetInput(IEditorInput input) 
902 //    {
903 //      // The workspace never changes for an editor.  So, removing and re-adding the 
904 //      // resourceListener is not necessary.  But it is being done here for the sake
905 //      // of proper implementation.  Plus, the resourceListener needs to be added 
906 //      // to the workspace the first time around.
907 //      if(getEditorInput() != null) {
908 //        IFile file = ((FileEditorInput)getEditorInput()).getFile();
909 //        file.getWorkspace().removeResourceChangeListener(resourceListener);
910 //      }
911 //      
912 //      super.setInput(input);
913 //      
914 //      if(getEditorInput() != null && getEditorInput() instanceof FileEditorInput) {
915 //        IFile file = ((FileEditorInput)getEditorInput()).getFile();
916 //        file.getWorkspace().addResourceChangeListener(resourceListener);
917 //        setTitle(file.getName());
918 //      }
919 //    }
920     
921     protected boolean performSaveAs() 
922     {
923       FileDialog dialog = new FileDialog(getSite().getWorkbenchWindow().getShell(), SWT.SAVE);
924       String   inputFileName = getEditorInput().getName();
925       dialog.setFileName(inputFileName);      
926       String  [] fileExtensions = getIOFilterMan().getAvailableFileExtensionsAsStrings();      
927       if (fileExtensions != null)
928         dialog.setFilterExtensions(fileExtensions);
929       
930       String   fullPath = dialog.open();
931       // Cancel pressed
932       if (fullPath == null)
933         return false;
934             
935       final File   file = new File  (fullPath);  
936       
937       if (!file.exists()) 
938       {
939         save(file);
940       }
941       else 
942       {
943         int returnVal = RCPUtil.showConfirmOverwriteDialog(file.getName());
944         if (returnVal == SWT.OK)
945             save(file);
946         else 
947             return false;
948       }
949       try {
950         getCommandStack().markSaveLocation();
951       } 
952       catch (Exception   e) {
953         e.printStackTrace();
954       }
955       
956       return true;
957     }
958     
959     protected PropertyChangeListener   progressListener = new PropertyChangeListener  ()
960     {
961         public void propertyChange(PropertyChangeEvent   evt) 
962         {
963             Object   newValue = evt.getNewValue();
964             String   propertyName = evt.getPropertyName();
965             if (propertyName.equals(AbstractIOFilterWithProgress.PROGRESS_CHANGED)) {
966                 int work = ((Integer  )newValue).intValue();
967                 getProgressMonitor().getProgressMonitor().internalWorked(work); 
968 //                  getProgressMonitor().getProgressMonitor().worked(work); 
969 //                  LOGGER.debug("Progress changes to "+work);
970             }
971             else if (propertyName.equals(AbstractIOFilterWithProgress.SUBTASK_FINISHED)) {
972                 String   subTaskName = (String  ) newValue;
973                 getProgressMonitor().getProgressMonitor().subTask(subTaskName);
974 //                  LOGGER.debug("subTask "+subTaskName+" finished!");                  
975             }
976         }           
977     };
978     
979     protected ProgressMonitorDialog progressMonitor; 
980     protected ProgressMonitorDialog getProgressMonitor() 
981     {
982         if (progressMonitor == null) {
983             progressMonitor = new ProgressMonitorDialog(getSite().getWorkbenchWindow().getShell());         
984         }
985         return progressMonitor;
986     }
987     
988     protected void save(File   f) 
989     {
990         final File   file = f;        
991         IRunnableWithProgress runnable = new IRunnableWithProgress()
992         {           
993                 public void run(IProgressMonitor monitor) 
994                 throws InvocationTargetException  , InterruptedException   
995                 {
996           saveProperties();
997           try {
998             save(file, monitor);      
999           } 
1000          catch (Exception   e) {
1001            throw new RuntimeException  (e);
1002          }                 
1003                }           
1004            };
1005            
1006      try {
1007        getProgressMonitor().run(false, false, runnable);
1008        setPartName(file.getName());
1009      }
1010      catch (Exception   e) {
1011        throw new RuntimeException  (e);
1012      }     
1013    }    
1014                  
1015    /**
1016     * Saves the Model under the specified path.
1017     * 
1018     * @param file the file to save
1019     * @param progressMonitor The ProgressMonitor to show the save Progress
1020     */
1021    protected void save(File   file, IProgressMonitor progressMonitor)
1022    throws WriteException
1023    {
1024      if (null == progressMonitor)
1025          progressMonitor = new NullProgressMonitor();
1026            
1027      // use IOFilterMan
1028      IOFilter ioFilter = getIOFilterMan().getIOFilter(file);      
1029      if (ioFilter != null) 
1030      {
1031        try {
1032            if (ioFilter instanceof IOFilterWithProgress) {             
1033                IOFilterWithProgress progressFilter = (IOFilterWithProgress) ioFilter;
1034                progressMonitor.beginTask(EditorPlugin.getResourceString("resource.save") +" "+ file.getName(), progressFilter.getTotalWork());             
1035                progressFilter.addPropertyChangeListener(progressListener);             
1036                saveFile(file, progressFilter, progressMonitor);
1037                progressFilter.removePropertyChangeListener(progressListener); 
1038            }
1039            else {
1040                progressMonitor.beginTask(EditorPlugin.getResourceString("resource.save") +" "+ file.getName(), 2);             
1041                saveFile(file, ioFilter, progressMonitor);              
1042            }           
1043        } finally {
1044            progressMonitor.done();
1045        }
1046      }
1047    }     
1048    
1049    protected void saveFile(File   file, IOFilter ioFilter, IProgressMonitor monitor) 
1050    throws WriteException
1051    {
1052        try {           
1053        String   fileName = file.getCanonicalPath();
1054        LOGGER.info("Save File "+fileName);
1055        FileOutputStream   fos = new FileOutputStream  (fileName);          
1056        ioFilter.write(getMultiLayerDrawComponent(), fos);              
1057        } catch (Exception   e) {
1058            throw new WriteException(file, "an error occured while writing", e);
1059        }       
1060    }
1061                                
1062    protected void setInput(IEditorInput input)
1063    {
1064      super.setInput(input);
1065      renderMan = RendererRegistry.sharedInstance().getRenderModeManager();  
1066      
1067      if (input instanceof FileEditorInput) {
1068        FileEditorInput fileInput = (FileEditorInput) input; 
1069        mldc = getMultiLayerDrawComponent();        
1070        if (!fileInput.isSaved()) {
1071            createNewMultiLayerDrawComponent();
1072        } else {            
1073          load(fileInput);          
1074        }        
1075//        System.gc();                  
1076      } 
1077      else
1078        createNewMultiLayerDrawComponent();
1079        
1080      mldc.setRenderModeManager(getRenderModeManager());      
1081      getMultiLayerDrawComponent().setLanguageId(getLanguageManager().getCurrentLanguageID());
1082    }
1083        
1084    protected void createNewMultiLayerDrawComponent() 
1085    {
1086        mldc = getMultiLayerDrawComponent();
1087        loadAdditional();       
1088    }
1089        
1090    protected void loadAdditional() {
1091      if (!editorSaving) {
1092        if (getGraphicalViewer() != null) {
1093          getGraphicalViewer().setContents(getMultiLayerDrawComponent());
1094          loadProperties();
1095        }        
1096      }     
1097    }
1098                
1099    public EditPartViewer getEditPartViewer() 
1100    {
1101      return (EditPartViewer) getGraphicalViewer();
1102    }
1103    
1104//    public void updateViewer() 
1105//    {
1106//      getGraphicalViewer().getControl().redraw();
1107////        getRootEditPart().getFigure().repaint();
1108////        refreshBuffer();
1109//      LOGGER.debug("updateViewer!");
1110//    }
1111
1112    public void updateViewer() 
1113    {
1114        refreshBuffer();        
1115      getGraphicalViewer().getControl().redraw();
1116      LOGGER.debug("updateViewer!");
1117    }
1118        
1119    protected void refreshBuffer() 
1120    {
1121        MultiLayerDrawComponentEditPart mldcEditPart = getModelRootEditPart();
1122        if (mldcEditPart != null) {
1123            BufferedFreeformLayer buffer = mldcEditPart.getBufferedFreeformLayer();
1124            if (buffer != null) {
1125                buffer.refresh();
1126            }                       
1127        }
1128    }
1129    
1130    protected MultiLayerDrawComponentEditPart mldcEditPart = null;
1131//    protected MultiLayerDrawComponentEditPart getModelRootEditPart() 
1132//    {
1133//      if (mldcEditPart == null) {
1134//          if (getRootEditPart().getChildren().size() == 1) {
1135//              EditPart editPart = (EditPart) getRootEditPart().getChildren().get(0);
1136//          if (editPart != null) {
1137//              if (editPart instanceof MultiLayerDrawComponentEditPart) {
1138//                  mldcEditPart = (MultiLayerDrawComponentEditPart) editPart;
1139//              }
1140//          }
1141//          }           
1142//      }
1143//      return mldcEditPart;
1144//    }
1145    protected MultiLayerDrawComponentEditPart getModelRootEditPart() 
1146    {
1147        if (getRootEditPart().getChildren().size() == 1) {
1148            EditPart editPart = (EditPart) getRootEditPart().getChildren().get(0);
1149        if (editPart != null) {
1150            if (editPart instanceof MultiLayerDrawComponentEditPart) {
1151                return mldcEditPart = (MultiLayerDrawComponentEditPart) editPart;
1152            }
1153        }
1154        }           
1155        return mldcEditPart;
1156    }
1157    
1158//   **************** BEGIN public Methods for EditorOutlinePage ******************** 
1159    public GraphicalViewer getOutlineGraphicalViewer() {
1160      return getGraphicalViewer();
1161    }
1162    
1163    public SelectionSynchronizer getOutlineSelectionSynchronizer() {
1164      return getSelectionSynchronizer();
1165    }
1166    
1167    public DefaultEditDomain getOutlineEditDomain() {
1168      return getEditDomain();
1169    }
1170    
1171    public ActionRegistry getOutlineActionRegistry() {
1172      return getActionRegistry();
1173    }
1174//  **************** END public Methods for EditorOutlinePage **********************  
1175        
1176  public void dispose() 
1177  {
1178    super.dispose();
1179    mldc = null;
1180    if (outlinePage != null)
1181      outlinePage.dispose();
1182    outlinePage = null; 
1183    rootEditPart = null;
1184    if (rulerComp != null)
1185      rulerComp.dispose();
1186    rulerComp = null;
1187    treeViewer = null;
1188    viewerManager = null;
1189  }
1190  
1191}
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags