Java > Open Source Codes > org > eclipse > emf > mapping > presentation > MappingEditor


1 /**
2  * <copyright>
3  *
4  * Copyright (c) 2002-2005 IBM Corporation and others.
5  * All rights reserved. This program and the accompanying materials
6  * are made available under the terms of the Eclipse Public License v1.0
7  * which accompanies this distribution, and is available at
8  * http://www.eclipse.org/legal/epl-v10.html
9  *
10  * Contributors:
11  * IBM - Initial API and implementation
12  *
13  * </copyright>
14  *
15  * $Id: MappingEditor.java,v 1.7 2005/06/12 13:39:41 emerks Exp $
16  */
17 package org.eclipse.emf.mapping.presentation;
18
19
20 import java.net.URL ;
21 import java.text.MessageFormat ;
22 import java.util.ArrayList ;
23 import java.util.Arrays ;
24 import java.util.Collection ;
25 import java.util.Collections ;
26 import java.util.EventObject ;
27 import java.util.HashMap ;
28 import java.util.HashSet ;
29 import java.util.Iterator ;
30 import java.util.List ;
31
32 import org.eclipse.core.resources.IFile;
33 import org.eclipse.core.resources.IMarker;
34 import org.eclipse.core.resources.ResourcesPlugin;
35 import org.eclipse.core.runtime.CoreException;
36 import org.eclipse.core.runtime.IPath;
37 import org.eclipse.core.runtime.IProgressMonitor;
38 import org.eclipse.core.runtime.Path;
39 import org.eclipse.core.runtime.Platform;
40 import org.eclipse.jface.action.Action;
41 import org.eclipse.jface.action.IMenuListener;
42 import org.eclipse.jface.action.IMenuManager;
43 import org.eclipse.jface.action.IStatusLineManager;
44 import org.eclipse.jface.action.IToolBarManager;
45 import org.eclipse.jface.action.MenuManager;
46 import org.eclipse.jface.action.Separator;
47 import org.eclipse.jface.dialogs.ProgressMonitorDialog;
48 import org.eclipse.jface.viewers.ColumnWeightData;
49 import org.eclipse.jface.viewers.ILabelProvider;
50 import org.eclipse.jface.viewers.ISelection;
51 import org.eclipse.jface.viewers.ISelectionChangedListener;
52 import org.eclipse.jface.viewers.ISelectionProvider;
53 import org.eclipse.jface.viewers.IStructuredSelection;
54 import org.eclipse.jface.viewers.SelectionChangedEvent;
55 import org.eclipse.jface.viewers.StructuredSelection;
56 import org.eclipse.jface.viewers.StructuredViewer;
57 import org.eclipse.jface.viewers.TableLayout;
58 import org.eclipse.jface.viewers.TreeViewer;
59 import org.eclipse.jface.viewers.Viewer;
60 import org.eclipse.swt.SWT;
61 import org.eclipse.swt.custom.CTabFolder;
62 import org.eclipse.swt.custom.SashForm;
63 import org.eclipse.swt.custom.TableTree;
64 import org.eclipse.swt.custom.TableTreeItem;
65 import org.eclipse.swt.dnd.DND;
66 import org.eclipse.swt.dnd.DropTargetEvent;
67 import org.eclipse.swt.dnd.Transfer;
68 import org.eclipse.swt.events.ControlAdapter;
69 import org.eclipse.swt.events.ControlEvent;
70 import org.eclipse.swt.events.ControlListener;
71 import org.eclipse.swt.graphics.Image;
72 import org.eclipse.swt.graphics.Point;
73 import org.eclipse.swt.widgets.Composite;
74 import org.eclipse.swt.widgets.Control;
75 import org.eclipse.swt.widgets.Menu;
76 import org.eclipse.swt.widgets.Table;
77 import org.eclipse.swt.widgets.TableColumn;
78 import org.eclipse.swt.widgets.Tree;
79 import org.eclipse.swt.widgets.Widget;
80 import org.eclipse.ui.IActionBars;
81 import org.eclipse.ui.IEditorInput;
82 import org.eclipse.ui.IEditorPart;
83 import org.eclipse.ui.IEditorSite;
84 import org.eclipse.ui.IFileEditorInput;
85 import org.eclipse.ui.IPartListener;
86 import org.eclipse.ui.IWorkbenchPage;
87 import org.eclipse.ui.IWorkbenchPart;
88 import org.eclipse.ui.PartInitException;
89 import org.eclipse.ui.actions.WorkspaceModifyOperation;
90 import org.eclipse.ui.dialogs.SaveAsDialog;
91 import org.eclipse.ui.part.FileEditorInput;
92 import org.eclipse.ui.part.MultiPageEditorPart;
93 import org.eclipse.ui.views.contentoutline.ContentOutline;
94 import org.eclipse.ui.views.contentoutline.ContentOutlinePage;
95 import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
96 import org.eclipse.ui.views.properties.IPropertySheetPage;
97 import org.eclipse.ui.views.properties.PropertySheet;
98 import org.eclipse.ui.views.properties.PropertySheetPage;
99
100 import org.eclipse.emf.common.command.BasicCommandStack;
101 import org.eclipse.emf.common.command.Command;
102 import org.eclipse.emf.common.command.CommandStack;
103 import org.eclipse.emf.common.command.CommandStackListener;
104 import org.eclipse.emf.common.command.CommandWrapper;
105 import org.eclipse.emf.common.notify.AdapterFactory;
106 import org.eclipse.emf.common.notify.Notification;
107 import org.eclipse.emf.common.ui.ViewerPane;
108 import org.eclipse.emf.common.ui.viewer.ExtendedTableTreeViewer;
109 import org.eclipse.emf.common.util.TreeIterator;
110 import org.eclipse.emf.common.util.URI;
111 import org.eclipse.emf.ecore.EObject;
112 import org.eclipse.emf.ecore.InternalEObject;
113 import org.eclipse.emf.ecore.impl.ENotificationImpl;
114 import org.eclipse.emf.ecore.resource.Resource;
115 import org.eclipse.emf.edit.command.RemoveCommand;
116 import org.eclipse.emf.edit.domain.EditingDomain;
117 import org.eclipse.emf.edit.domain.IEditingDomainProvider;
118 import org.eclipse.emf.edit.provider.AdapterFactoryTreeIterator;
119 import org.eclipse.emf.edit.provider.DecoratorAdapterFactory;
120 import org.eclipse.emf.edit.provider.IChangeNotifier;
121 import org.eclipse.emf.edit.provider.IDisposable;
122 import org.eclipse.emf.edit.provider.IEditingDomainItemProvider;
123 import org.eclipse.emf.edit.provider.IItemLabelProvider;
124 import org.eclipse.emf.edit.provider.IItemPropertySource;
125 import org.eclipse.emf.edit.provider.IItemProviderDecorator;
126 import org.eclipse.emf.edit.provider.INotifyChangedListener;
127 import org.eclipse.emf.edit.provider.IStructuredItemContentProvider;
128 import org.eclipse.emf.edit.provider.ITableItemLabelProvider;
129 import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
130 import org.eclipse.emf.edit.provider.ItemProvider;
131 import org.eclipse.emf.edit.provider.ItemProviderDecorator;
132 import org.eclipse.emf.edit.ui.action.DelegatingCommandAction;
133 import org.eclipse.emf.edit.ui.action.EditingDomainActionBarContributor;
134 import org.eclipse.emf.edit.ui.celleditor.AdapterFactoryTableTreeEditor;
135 import org.eclipse.emf.edit.ui.dnd.EditingDomainViewerDropAdapter;
136 import org.eclipse.emf.edit.ui.dnd.LocalTransfer;
137 import org.eclipse.emf.edit.ui.dnd.ViewerDragAdapter;
138 import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
139 import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider;
140 import org.eclipse.emf.edit.ui.provider.ExtendedImageRegistry;
141 import org.eclipse.emf.mapping.MappedObjectState;
142 import org.eclipse.emf.mapping.Mapping;
143 import org.eclipse.emf.mapping.MappingFactory;
144 import org.eclipse.emf.mapping.MappingPackage;
145 import org.eclipse.emf.mapping.MappingPlugin;
146 import org.eclipse.emf.mapping.MappingRoot;
147 import org.eclipse.emf.mapping.action.CreateMappingAction;
148 import org.eclipse.emf.mapping.action.CreateOneSidedMappingAction;
149 import org.eclipse.emf.mapping.action.NameMatchMappingAction;
150 import org.eclipse.emf.mapping.action.RemoveMappingAction;
151 import org.eclipse.emf.mapping.action.TypeMatchMappingAction;
152 import org.eclipse.emf.mapping.command.CreateMappingCommand;
153 import org.eclipse.emf.mapping.command.PersistentCommandStack;
154 import org.eclipse.emf.mapping.command.RemoveMappingCommand;
155 import org.eclipse.emf.mapping.command.RestoreInitialStateCommand;
156 import org.eclipse.emf.mapping.domain.AdapterFactoryMappingDomain;
157 import org.eclipse.emf.mapping.domain.MappingDomain;
158 import org.eclipse.emf.mapping.provider.MappedObjectItemProvider;
159 import org.eclipse.emf.mapping.provider.MappingItemProvider;
160
161
162 /**
163  * This is an example of a model editor.
164  */
165 public abstract class MappingEditor
166   extends MultiPageEditorPart
167   implements IEditingDomainProvider, ISelectionProvider, IMenuListener
168 {
169   protected static final String DIVIDER = MappingPlugin.getPlugin().getString("_UI_Mapping_label_separator");
170   protected static final String SEPARATOR = MappingPlugin.getPlugin().getString("_UI_Mapping_label_separator") + " ";
171
172   protected String topLabel = MappingUIPlugin.getPlugin().getString("_UI_Top_label");
173
174   public String getTopLabel()
175   {
176     return topLabel;
177   }
178
179   protected String bottomLabel = MappingUIPlugin.getPlugin().getString("_UI_Bottom_label");
180
181   public String getBottomLabel()
182   {
183     return bottomLabel;
184   }
185
186   protected Image topImage = MappingUIPlugin.getPlugin().getImage("full/cview16/TopLogo");
187
188   public Image getTopImage()
189   {
190     return topImage;
191   }
192
193   protected Image bottomImage = MappingUIPlugin.getPlugin().getImage("full/cview16/BottomLogo");
194
195   public Image getBottomImage()
196   {
197     return bottomImage;
198   }
199
200   protected boolean isNotificationEnabled = true;
201
202   public boolean isNotificationEnabled()
203   {
204     return isNotificationEnabled;
205   }
206
207   public void setNotificationEnabled(boolean isNotificationEnabled)
208   {
209     this.isNotificationEnabled = isNotificationEnabled;
210     if (isNotificationEnabled)
211     {
212       if (leftSelectionViewer != null)
213       {
214         leftSelectionViewer.refresh();
215         rightSelectionViewer.refresh();
216         overviewViewer.refresh();
217       }
218       if (contentOutlineViewer != null)
219       {
220         contentOutlineViewer.refresh();
221       }
222       if (propertySheetPage != null)
223       {
224         propertySheetPage.refresh();
225       }
226     }
227   }
228
229   /**
230    * This keeps track of the file that stores the model.
231    */
232   protected IFileEditorInput modelFile;
233
234   /**
235    * This keeps track of the root object of the model.
236    */
237   protected MappingRoot mappingRoot;
238
239   /**
240    * This keeps track of the editing domain that is used to track all changes to the model.
241    */
242   protected AdapterFactoryMappingDomain mappingDomain;
243
244   /**
245    * This is the content outline page.
246    */
247   protected IContentOutlinePage contentOutlinePage;
248
249   /**
250    * This is a kludge...
251    */
252   protected IStatusLineManager contentOutlineStatusLineManager;
253
254   /**
255    * This is the content outline page's viewer.
256    */
257   protected TreeViewer contentOutlineViewer;
258
259   protected Action contentOutlineFilterAction;
260
261   /**
262    * This is the property sheet page.
263    */
264   protected PropertySheetPage propertySheetPage;
265
266   /**
267    * This is the viewer that shadows the selection in the content outline.
268    * The parent relation must be correctly defined for this to work.
269    */
270   protected SimpleMappedObjectViewer leftSelectionViewer;
271   protected MyDecoratorAdapterFactory leftSelectionFactory;
272   protected SimpleMappedObjectViewer rightSelectionViewer;
273   protected MyDecoratorAdapterFactory rightSelectionFactory;
274   protected ViewerPane overviewViewerPane;
275   protected OverviewViewer overviewViewer;
276   protected OverviewDecoratorAdapterFactory overviewFactory;
277
278   /**
279    * This keeps track of the current viewer pane of the page book.
280    */
281   protected ViewerPane currentViewerPane;
282
283   /**
284    * This keeps track of the active content viewer, which may be either one of the viewers in the pages or the content outline viewer.
285    */
286   protected Viewer currentViewer;
287
288   /**
289    * This keeps track of the content viewer, which had something dropped on it.
290    */
291   protected Viewer dropViewer;
292
293   /**
294    * This listens to which ever viewer is active.
295    */
296   protected ISelectionChangedListener selectionChangedListener;
297
298   /**
299    * This keeps track of all the {@link org.eclipse.jface.viewers.ISelectionChangedListener}s that are listening to this editor.
300    */
301   protected Collection selectionChangedListeners = new ArrayList ();
302
303   /**
304    * This keeps track of the selection of the editor as a whole.
305    */
306   protected ISelection editorSelection = StructuredSelection.EMPTY;
307
308   /**
309    * This listens for when the outline becomes active
310    */
311   protected IPartListener partListener =
312     new IPartListener()
313     {
314       public void partActivated(IWorkbenchPart p)
315       {
316         if (p instanceof ContentOutline)
317         {
318           if (((ContentOutline)p).getCurrentPage() == contentOutlinePage)
319           {
320             getActionBarContributor().setActiveEditor(MappingEditor.this);
321             setCurrentViewer(contentOutlineViewer);
322           }
323         }
324         else if (p instanceof PropertySheet)
325         {
326           if (((PropertySheet)p).getCurrentPage() == propertySheetPage)
327           {
328             getActionBarContributor().setActiveEditor(MappingEditor.this);
329           }
330         }
331       }
332       public void partBroughtToTop(IWorkbenchPart p)
333       {
334       }
335       public void partClosed(IWorkbenchPart p)
336       {
337       }
338       public void partDeactivated(IWorkbenchPart p)
339       {
340       }
341       public void partOpened(IWorkbenchPart p)
342       {
343       }
344     };
345
346   CommandStackListener commandStackListener =
347     new CommandStackListener()
348     {
349       public void commandStackChanged(final EventObject event)
350       {
351         getContainer().getDisplay().asyncExec
352           (new Runnable ()
353            {
354              public void run()
355              {
356                firePropertyChange(IEditorPart.PROP_DIRTY);
357
358                // Try to select the affected objects.
359 //
360 Command mostRecentCommand = ((CommandStack)event.getSource()).getMostRecentCommand();
361                if (mostRecentCommand != null)
362                {
363                  setSelectionToViewer(mostRecentCommand.getAffectedObjects());
364                }
365        
366                leftSelectionViewer.updateActions();
367                rightSelectionViewer.updateActions();
368        
369                if (propertySheetPage != null)
370                {
371                  propertySheetPage.refresh();
372                }
373              }
374            });
375       }
376     };
377
378   /**
379    * This simply calls super; it is here only so that inner classes can call it.
380    */
381   protected void firePropertyChange(int type)
382   {
383     // VAJ kludge
384 //
385 super.firePropertyChange(type);
386   }
387
388   /**
389    * This creates a model editor.
390    */
391   public MappingEditor()
392   {
393     super();
394   }
395
396   protected abstract AdapterFactoryMappingDomain createMappingDomain();
397
398   /**
399    * This sets the selection into whichever viewer is active.
400    */
401   public void setSelectionToViewer(final Collection collection)
402   {
403     // Make sure it's okay.
404 //
405 if (collection != null && !collection.isEmpty())
406     {
407       // I don't know if we should be run this deferred
408 // because we might have to give the editor a chance to process the viewer update events
409 // and hence to update the views first.
410 //
411 //
412 Runnable runnable =
413        new Runnable ()
414         {
415           public void run()
416           {
417             Collection indirectMappedObjects = new ArrayList ();
418             Collection mappedInputs = new ArrayList ();
419             Collection mappedOutputs = new ArrayList ();
420             Collection mappings = new ArrayList ();
421             for (Iterator objects = collection.iterator(); objects.hasNext(); )
422             {
423               Object object = objects.next();
424               if (object instanceof Mapping)
425               {
426                 mappings.add(object);
427               }
428               else if (mappingDomain.getMappingRoot().isInputObject(object))
429               {
430                 mappedInputs.add(object);
431                 indirectMappedObjects.add(object);
432               }
433               else if (mappingDomain.getMappingRoot().isOutputObject(object))
434               {
435                 mappedOutputs.add(object);
436                 indirectMappedObjects.add(object);
437               }
438             }
439
440             LOOP: for (Iterator i = mappings.iterator(); i.hasNext(); )
441             {
442               Mapping mapping = (Mapping)i.next();
443
444               indirectMappedObjects.addAll(mapping.getMappedObjects());
445
446               for (Mapping parent = mapping.getNestedIn(); parent != null; parent = parent.getNestedIn())
447               {
448                 if (mappings.contains(parent))
449                 {
450                   continue LOOP;
451                 }
452               }
453               
454               mappedOutputs.addAll(mapping.getOutputs());
455               mappedInputs.addAll(mapping.getInputs());
456             }
457
458             if (!indirectMappedObjects.isEmpty())
459             {
460               overviewViewer.setSelection(new StructuredSelection(indirectMappedObjects.toArray()), true);
461             }
462
463             if (!mappings.isEmpty() && contentOutlineViewer != null)
464             {
465               contentOutlineViewer.setSelection(new StructuredSelection(mappings.toArray()), true);
466             }
467
468             Viewer affectedViewer = dropViewer == null ? currentViewer : dropViewer;
469             dropViewer = null;
470
471             // Try to select the items in the current content viewer of the editor.
472 //
473 if (affectedViewer != null)
474             {
475               if (affectedViewer == leftSelectionViewer)
476               {
477                 Collection topMappedObjects = mappingRoot.isTopToBottom() ? mappedInputs : mappedOutputs;
478                 if (!topMappedObjects.isEmpty())
479                 {
480                   leftSelectionViewer.setSelection(new StructuredSelection(topMappedObjects.toArray()), true);
481                 }
482               }
483               else if (affectedViewer == rightSelectionViewer)
484               {
485                 Collection bottomMappedObjects = !mappingRoot.isTopToBottom() ? mappedInputs : mappedOutputs;
486                 if (!bottomMappedObjects.isEmpty())
487                 {
488                   rightSelectionViewer.setSelection(new StructuredSelection(bottomMappedObjects.toArray()), true);
489                 }
490               }
491               else if (!collection.isEmpty())
492               {
493                 affectedViewer.setSelection(new StructuredSelection(collection.toArray()), true);
494               }
495             }
496           }
497         };
498       runnable.run();
499     }
500     else
501     {
502       dropViewer = null;
503     }
504   }
505
506   /**
507    * This returns the editing domain as required by the {@link IEditingDomainProvider} interface.
508    * This is important for implementing the static methods of
509    * {@link org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain} and for supporting
510    * {@link org.eclipse.emf.edit.ui.action.CommandAction}.
511    */
512   public EditingDomain getEditingDomain()
513   {
514     return mappingDomain;
515   }
516
517   public void setCurrentViewerPane(ViewerPane viewerPane)
518   {
519     if (currentViewerPane != viewerPane)
520     {
521       if (currentViewerPane != null)
522       {
523         currentViewerPane.showFocus(false);
524       }
525       currentViewerPane = viewerPane;
526     }
527     setCurrentViewer(currentViewerPane.getViewer());
528   }
529
530   /**
531    * This makes sure that one content viewer, either for the current page or the outline view, if it has focus,
532    * is the current one.
533    */
534   public void setCurrentViewer(Viewer viewer)
535   {
536     // If it is changing...
537 //
538 if (currentViewer != viewer)
539     {
540       if (selectionChangedListener == null)
541       {
542         // Create the listener on demand.
543 //
544 selectionChangedListener =
545           new ISelectionChangedListener()
546           {
547             // This just notifies those things that are affected by the selection.
548 //
549 public void selectionChanged(SelectionChangedEvent event)
550             {
551               setSelection(event.getSelection());
552             }
553           };
554       }
555
556       // Stop listening to the old one.
557 //
558 if (currentViewer != null)
559       {
560         currentViewer.removeSelectionChangedListener(selectionChangedListener);
561       }
562
563       // Start listening to the new one.
564 //
565 if (viewer != null)
566       {
567         viewer.addSelectionChangedListener(selectionChangedListener);
568       }
569
570       // Remember it.
571 //
572 currentViewer = viewer;
573
574       // Set the editor's selection based on the current viewer's selection.
575 //
576 setSelection(currentViewer.getSelection());
577     }
578   }
579
580   /**
581    * This is the contributor for the mapping editor.
582    */
583   static public class ActionBarContributor extends EditingDomainActionBarContributor
584   {
585     protected DelegatingCommandAction removeMappingAction;
586     protected DelegatingCommandAction createMappingAction;
587     protected DelegatingCommandAction createOneSidedMappingAction;
588     protected DelegatingCommandAction nameMatchMappingAction;
589     protected DelegatingCommandAction typeMatchMappingAction;
590
591     /**
592      * This creates an instance the contributor.
593      */
594     public ActionBarContributor()
595     {
596       removeMappingAction = new DelegatingCommandAction(new RemoveMappingAction());
597       createMappingAction = new DelegatingCommandAction(new CreateMappingAction());
598       createOneSidedMappingAction = new DelegatingCommandAction(new CreateOneSidedMappingAction());
599       nameMatchMappingAction = new DelegatingCommandAction(new NameMatchMappingAction());
600       typeMatchMappingAction = new DelegatingCommandAction(new TypeMatchMappingAction());
601     }
602
603     public void setActiveEditor(IEditorPart part)
604     {
605       super.setActiveEditor(part);
606       removeMappingAction.setActiveWorkbenchPart(part);
607       createMappingAction.setActiveWorkbenchPart(part);
608       createOneSidedMappingAction.setActiveWorkbenchPart(part);
609       nameMatchMappingAction.setActiveWorkbenchPart(part);
610       typeMatchMappingAction.setActiveWorkbenchPart(part);
611     }
612
613 /*
614     public void contributeToMenu(IMenuManager menuManager)
615     {
616       super.contributeToMenu(menuManager);
617     }
618 */
619
620     public void contributeToToolBar(IToolBarManager toolBarManager)
621     {
622       toolBarManager.add(new Separator("mapping-settings"));
623       toolBarManager.add(new Separator("mapping-additions"));
624       toolBarManager.add(new Separator("mapping-global-actions"));
625
626       super.contributeToToolBar(toolBarManager);
627     }
628   }
629
630   /**
631    * This creates a context menu for the viewer and adds a listener as well registering the menu for extension.
632    */
633   protected void createContextMenuFor(final StructuredViewer structuredViewer)
634   {
635     MenuManager contextMenu = new MenuManager("#PopUp");
636     contextMenu.add(new Separator("additions"));
637     contextMenu.setRemoveAllWhenShown(true);
638     contextMenu.addMenuListener(this);
639     Menu menu= contextMenu.createContextMenu(structuredViewer.getControl());
640     structuredViewer.getControl().setMenu(menu);
641     getSite().registerContextMenu(contextMenu, structuredViewer);
642
643     int dndOperations = DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK;
644     Transfer[] transfers = new Transfer[] { LocalTransfer.getInstance() };
645     structuredViewer.addDragSupport(dndOperations, transfers, new ViewerDragAdapter(structuredViewer));
646     structuredViewer.addDropSupport
647       (dndOperations,
648        transfers,
649        new EditingDomainViewerDropAdapter(mappingDomain, structuredViewer)
650        {
651          public void drop(DropTargetEvent event)
652          {
653            dropViewer = structuredViewer;
654            super.drop(event);
655          }
656        });
657   }
658
659   protected class MyDecoratorAdapterFactory extends DecoratorAdapterFactory
660   {
661     protected Collection listeningItemProviderDecorators = new HashSet ();
662     protected Action action;
663     protected Action multipleColumnsAction;
664     protected boolean exclude;
665
666     public MyDecoratorAdapterFactory(AdapterFactory adapterFactory, Action action, boolean exclude, Action multipleColumnsAction)
667     {
668       this(adapterFactory, action, exclude);
669       this.multipleColumnsAction = multipleColumnsAction;
670     }
671
672     public MyDecoratorAdapterFactory(AdapterFactory adapterFactory, Action action, boolean exclude)
673     {
674       super(adapterFactory);
675       this.action = action;
676       this.exclude = exclude;
677     }
678
679     public boolean isFactoryForType(Object t)
680     {
681       return super.isFactoryForType(t) || t == ITableItemLabelProvider.class;
682
683     }
684
685     public Object adapt(Object o, Object t)
686     {
687       Object result = super.adapt(o, t == ITableItemLabelProvider.class ? IItemLabelProvider.class : t);
688
689       if (result != null)
690       {
691         MappedObjectState mappedObjectState = mappingDomain.getMappingRoot().getMappedObjectState(o);
692         if (mappedObjectState != null && listeningItemProviderDecorators.add(o))
693         {
694           ((MyItemProviderDecorator) result).setMappedObjectState(mappedObjectState);
695         }
696       }
697
698       return result;
699     }
700
701     protected boolean doMappingRefresh(Object object)
702     {
703       return false;
704     }
705
706     protected void doMappedObjectRefresh(Object object)
707     {
708     }
709
710     public List getPrimaryMappedObjects(Mapping mapping)
711     {
712       return Collections.EMPTY_LIST;
713     }
714   
715     public List getSecondaryMappedObjects(Mapping mapping)
716     {
717       return Collections.EMPTY_LIST;
718     }
719
720     class MyItemProviderDecorator
721       extends
722         ItemProviderDecorator
723       implements
724         IStructuredItemContentProvider,
725         ITreeItemContentProvider,
726         IItemPropertySource,
727         IEditingDomainItemProvider,
728         IItemLabelProvider,
729         ITableItemLabelProvider
730     {
731       protected Collection mappedObjectStates = new ArrayList ();
732
733       public MyItemProviderDecorator(AdapterFactory adapterFactory)
734       {
735         super(adapterFactory);
736       }
737
738       public Collection getChildren(Object o)
739       {
740         if (action.isChecked())
741         {
742           Collection result = new ArrayList (super.getChildren(o));
743           LOOP : for (Iterator results = result.iterator(); results.hasNext(); )
744           {
745             Object child = results.next();
746             for (Iterator tree = new AdapterFactoryTreeIterator(getDecoratedAdapterFactory(), child, true); tree.hasNext(); )
747             {
748               Object descendant = tree.next();
749               if (mappingDomain.getMappingRoot().getMappings(descendant).isEmpty() == exclude)
750               {
751                 continue LOOP;
752               }
753             }
754             results.remove();
755           }
756           return result;
757         }
758         else
759         {
760           return super.getChildren(o);
761         }
762       }
763
764       public boolean hasChildren(Object o)
765       {
766         if (action.isChecked())
767         {
768           for (Iterator tree = new AdapterFactoryTreeIterator(getDecoratedAdapterFactory(), o, false); tree.hasNext(); )
769           {
770             Object descendant = tree.next();
771             if (mappingDomain.getMappingRoot().getMappings(descendant).isEmpty() == exclude)
772             {
773               return true;
774             }
775           }
776           return false;
777         }
778         else
779         {
780           return super.hasChildren(o);
781         }
782       }
783
784       public Object getSummaryColumnImage(Object o)
785       {
786         return getOverviewSummaryColumnImage(o);
787       }
788
789       public Object getColumnImage(Object o, int columnIndex)
790       {
791         if (columnIndex == 0)
792         {
793           return super.getImage(o);
794         }
795         else if (multipleColumnsAction == null || !multipleColumnsAction.isEnabled() || !multipleColumnsAction.isChecked())
796         {
797           if (columnIndex == 2)
798           {
799             return getSummaryColumnImage(o);
800           }
801           else
802           {
803             Collection mappedObjects = new ArrayList ();
804             Collection mappings = mappingRoot.getMappings(o);
805             for (Iterator i = mappings.iterator(); i.hasNext(); )
806             {
807               Mapping mapping = (Mapping)i.next();
808               for (Iterator j = getSecondaryMappedObjects(mapping).iterator(); j.hasNext(); )
809               {
810                 Object mappedObject = j.next();
811         &nbs