Java tutorial
/****************************************************************************** * Copyright (c) 2002, 2009 IBM Corporation and others. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * IBM Corporation - initial API and implementation * Dmitry Stadnik (Borland) - contribution for bugzilla 136582 ****************************************************************************/ package org.eclipse.gmf.runtime.diagram.ui.parts; import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.Iterator; import java.util.List; import java.util.Set; import org.eclipse.core.commands.operations.IOperationHistory; import org.eclipse.core.commands.operations.IOperationHistoryListener; import org.eclipse.core.commands.operations.IUndoContext; import org.eclipse.core.commands.operations.IUndoableOperation; import org.eclipse.core.commands.operations.ObjectUndoContext; import org.eclipse.core.commands.operations.OperationHistoryEvent; import org.eclipse.core.commands.operations.OperationHistoryFactory; import org.eclipse.core.runtime.Assert; import org.eclipse.core.runtime.IAdaptable; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.IStatus; import org.eclipse.draw2d.FigureCanvas; import org.eclipse.draw2d.LightweightSystem; import org.eclipse.draw2d.Viewport; import org.eclipse.draw2d.geometry.Point; import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.emf.ecore.resource.ResourceSet; import org.eclipse.emf.edit.domain.EditingDomain; import org.eclipse.emf.edit.domain.IEditingDomainProvider; import org.eclipse.emf.transaction.RunnableWithResult; import org.eclipse.emf.transaction.TransactionalEditingDomain; import org.eclipse.emf.transaction.util.TransactionUtil; import org.eclipse.emf.workspace.ResourceUndoContext; import org.eclipse.gef.ContextMenuProvider; import org.eclipse.gef.DefaultEditDomain; import org.eclipse.gef.EditPart; import org.eclipse.gef.EditPartFactory; import org.eclipse.gef.EditPartViewer; import org.eclipse.gef.KeyHandler; import org.eclipse.gef.KeyStroke; import org.eclipse.gef.LayerConstants; import org.eclipse.gef.MouseWheelHandler; import org.eclipse.gef.MouseWheelZoomHandler; import org.eclipse.gef.RootEditPart; import org.eclipse.gef.SnapToGeometry; import org.eclipse.gef.SnapToGrid; import org.eclipse.gef.commands.CommandStack; import org.eclipse.gef.editparts.ZoomManager; import org.eclipse.gef.rulers.RulerProvider; import org.eclipse.gef.ui.actions.ActionRegistry; import org.eclipse.gef.ui.actions.DirectEditAction; import org.eclipse.gef.ui.actions.GEFActionConstants; import org.eclipse.gef.ui.actions.ZoomInAction; import org.eclipse.gef.ui.actions.ZoomOutAction; import org.eclipse.gef.ui.parts.ContentOutlinePage; import org.eclipse.gef.ui.parts.GraphicalEditor; import org.eclipse.gef.ui.parts.ScrollingGraphicalViewer; import org.eclipse.gef.ui.parts.TreeViewer; import org.eclipse.gef.ui.rulers.RulerComposite; import org.eclipse.gmf.runtime.common.core.util.Log; import org.eclipse.gmf.runtime.common.core.util.Trace; import org.eclipse.gmf.runtime.common.ui.action.ActionManager; import org.eclipse.gmf.runtime.common.ui.services.editor.EditorService; import org.eclipse.gmf.runtime.common.ui.util.IPartSelector; import org.eclipse.gmf.runtime.diagram.core.listener.DiagramEventBroker; import org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint; import org.eclipse.gmf.runtime.diagram.core.util.ViewType; import org.eclipse.gmf.runtime.diagram.core.util.ViewUtil; import org.eclipse.gmf.runtime.diagram.ui.actions.ActionIds; import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart; import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramRootEditPart; import org.eclipse.gmf.runtime.diagram.ui.editparts.IDiagramPreferenceSupport; import org.eclipse.gmf.runtime.diagram.ui.editparts.TreeContainerEditPart; import org.eclipse.gmf.runtime.diagram.ui.editparts.TreeDiagramEditPart; import org.eclipse.gmf.runtime.diagram.ui.editparts.TreeEditPart; import org.eclipse.gmf.runtime.diagram.ui.internal.DiagramUIDebugOptions; import org.eclipse.gmf.runtime.diagram.ui.internal.DiagramUIPlugin; import org.eclipse.gmf.runtime.diagram.ui.internal.DiagramUIStatusCodes; import org.eclipse.gmf.runtime.diagram.ui.internal.actions.InsertAction; import org.eclipse.gmf.runtime.diagram.ui.internal.actions.PromptingDeleteAction; import org.eclipse.gmf.runtime.diagram.ui.internal.actions.PromptingDeleteFromModelAction; import org.eclipse.gmf.runtime.diagram.ui.internal.actions.ToggleRouterAction; import org.eclipse.gmf.runtime.diagram.ui.internal.editparts.DiagramRootTreeEditPart; import org.eclipse.gmf.runtime.diagram.ui.internal.l10n.DiagramUIPluginImages; import org.eclipse.gmf.runtime.diagram.ui.internal.pagesetup.PageInfoHelper; import org.eclipse.gmf.runtime.diagram.ui.internal.parts.DiagramGraphicalViewerKeyHandler; import org.eclipse.gmf.runtime.diagram.ui.internal.parts.DirectEditKeyHandler; import org.eclipse.gmf.runtime.diagram.ui.internal.properties.WorkspaceViewerProperties; import org.eclipse.gmf.runtime.diagram.ui.internal.ruler.DiagramRuler; import org.eclipse.gmf.runtime.diagram.ui.internal.ruler.DiagramRulerProvider; import org.eclipse.gmf.runtime.diagram.ui.l10n.DiagramUIMessages; import org.eclipse.gmf.runtime.diagram.ui.preferences.IPreferenceConstants; import org.eclipse.gmf.runtime.diagram.ui.providers.DiagramContextMenuProvider; import org.eclipse.gmf.runtime.diagram.ui.services.editpart.EditPartService; import org.eclipse.gmf.runtime.draw2d.ui.internal.parts.ScrollableThumbnailEx; import org.eclipse.gmf.runtime.draw2d.ui.internal.parts.ThumbnailEx; import org.eclipse.gmf.runtime.emf.commands.core.command.EditingDomainUndoContext; import org.eclipse.gmf.runtime.notation.Diagram; import org.eclipse.gmf.runtime.notation.GuideStyle; import org.eclipse.gmf.runtime.notation.NotationPackage; import org.eclipse.gmf.runtime.notation.View; import org.eclipse.jface.action.Action; import org.eclipse.jface.action.IAction; import org.eclipse.jface.action.IToolBarManager; import org.eclipse.jface.action.MenuManager; import org.eclipse.jface.preference.IPreferenceStore; import org.eclipse.jface.preference.PreferenceStore; import org.eclipse.jface.viewers.ISelection; import org.eclipse.jface.viewers.IStructuredSelection; import org.eclipse.swt.SWT; import org.eclipse.swt.SWTException; import org.eclipse.swt.events.DisposeEvent; import org.eclipse.swt.events.DisposeListener; import org.eclipse.swt.widgets.Canvas; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.Display; import org.eclipse.ui.IActionBars; import org.eclipse.ui.IEditorInput; import org.eclipse.ui.IEditorSite; import org.eclipse.ui.IWorkbenchPart; import org.eclipse.ui.IWorkbenchPartSite; import org.eclipse.ui.PartInitException; import org.eclipse.ui.actions.ActionFactory; import org.eclipse.ui.contexts.IContextService; import org.eclipse.ui.part.IPageSite; import org.eclipse.ui.part.IShowInSource; import org.eclipse.ui.part.PageBook; import org.eclipse.ui.part.ShowInContext; import org.eclipse.ui.views.contentoutline.IContentOutlinePage; import org.eclipse.ui.views.properties.tabbed.ITabbedPropertySheetPageContributor; /** * @author melaasar * * A generic diagram editor with no palette. DiagramEditorWithPalette will * provide a palette. */ public abstract class DiagramEditor extends GraphicalEditor implements IDiagramWorkbenchPart, ITabbedPropertySheetPageContributor, IShowInSource { public static String DIAGRAM_CONTEXT_ID = "org.eclipse.gmf.runtime.diagram.ui.diagramContext"; //$NON-NLS-1$ /** * teh ID of the outline */ protected static final int ID_OUTLINE = 0; /** * the id of the over view */ protected static final int ID_OVERVIEW = 1; /** * the work space viewer preference store */ protected PreferenceStore workspaceViewerPreferenceStore = null; /** * A diagram outline page */ class DiagramOutlinePage extends ContentOutlinePage implements IAdaptable { private PageBook pageBook; private Control outline; private Canvas overview; private IAction showOutlineAction, showOverviewAction; private boolean overviewInitialized; private ThumbnailEx thumbnail; private DisposeListener disposeListener; /** * @param viewer */ public DiagramOutlinePage(EditPartViewer viewer) { super(viewer); } /* * (non-Javadoc) * * @see org.eclipse.ui.part.Page#init(org.eclipse.ui.part.IPageSite) */ public void init(IPageSite pageSite) { super.init(pageSite); ActionRegistry registry = getActionRegistry(); IActionBars bars = pageSite.getActionBars(); String id = ActionFactory.UNDO.getId(); bars.setGlobalActionHandler(id, registry.getAction(id)); id = ActionFactory.REDO.getId(); bars.setGlobalActionHandler(id, registry.getAction(id)); id = ActionFactory.DELETE.getId(); bars.setGlobalActionHandler(id, registry.getAction(id)); bars.updateActionBars(); // Toolbar refresh to solve linux defect RATLC525198 bars.getToolBarManager().markDirty(); } /** * configures the outline viewer */ protected void configureOutlineViewer() { getViewer().setEditDomain(getEditDomain()); getViewer().setEditPartFactory(getOutlineViewEditPartFactory()); MenuManager outlineContextMenuProvider = getOutlineContextMenuProvider(getViewer()); if (outlineContextMenuProvider != null) { getViewer().setContextMenu(outlineContextMenuProvider); } getViewer().setKeyHandler(getKeyHandler()); // getViewer().addDropTargetListener( // new LogicTemplateTransferDropTargetListener(getViewer())); IToolBarManager tbm = this.getSite().getActionBars().getToolBarManager(); showOutlineAction = new Action() { public void run() { showPage(ID_OUTLINE); } }; showOutlineAction.setImageDescriptor(DiagramUIPluginImages.DESC_OUTLINE); showOutlineAction.setToolTipText(DiagramUIMessages.OutlineView_OutlineTipText); tbm.add(showOutlineAction); showOverviewAction = new Action() { public void run() { showPage(ID_OVERVIEW); } }; showOverviewAction.setImageDescriptor(DiagramUIPluginImages.DESC_OVERVIEW); showOverviewAction.setToolTipText(DiagramUIMessages.OutlineView_OverviewTipText); tbm.add(showOverviewAction); showPage(getDefaultOutlineViewMode()); } public void createControl(Composite parent) { pageBook = new PageBook(parent, SWT.NONE); outline = getViewer().createControl(pageBook); overview = new Canvas(pageBook, SWT.NONE); pageBook.showPage(outline); configureOutlineViewer(); hookOutlineViewer(); initializeOutlineViewer(); } public void dispose() { unhookOutlineViewer(); if (thumbnail != null) { thumbnail.deactivate(); } this.overviewInitialized = false; super.dispose(); } public Object getAdapter(Class type) { // if (type == ZoomManager.class) // return getZoomManager(); return null; } public Control getControl() { return pageBook; } /** * hook the outline viewer */ protected void hookOutlineViewer() { getSelectionSynchronizer().addViewer(getViewer()); } /** * initialize the outline viewer */ protected void initializeOutlineViewer() { try { TransactionUtil.getEditingDomain(getDiagram()).runExclusive(new Runnable() { public void run() { getViewer().setContents(getDiagram()); } }); } catch (InterruptedException e) { Trace.catching(DiagramUIPlugin.getInstance(), DiagramUIDebugOptions.EXCEPTIONS_CATCHING, getClass(), "initializeOutlineViewer", e); //$NON-NLS-1$ Log.error(DiagramUIPlugin.getInstance(), DiagramUIStatusCodes.IGNORED_EXCEPTION_WARNING, "initializeOutlineViewer", e); //$NON-NLS-1$ } } /** * initialize the overview */ protected void initializeOverview() { LightweightSystem lws = new LightweightSystem(overview); RootEditPart rep = getGraphicalViewer().getRootEditPart(); DiagramRootEditPart root = (DiagramRootEditPart) rep; thumbnail = new ScrollableThumbnailEx((Viewport) root.getFigure()); // thumbnail.setSource(root.getLayer(LayerConstants.PRINTABLE_LAYERS)); thumbnail.setSource(root.getLayer(LayerConstants.SCALABLE_LAYERS)); lws.setContents(thumbnail); disposeListener = new DisposeListener() { public void widgetDisposed(DisposeEvent e) { if (thumbnail != null) { thumbnail.deactivate(); thumbnail = null; } } }; getEditor().addDisposeListener(disposeListener); this.overviewInitialized = true; } /** * show page with a specific ID, possibel values are ID_OUTLINE and * ID_OVERVIEW * * @param id */ protected void showPage(int id) { if (id == ID_OUTLINE) { showOutlineAction.setChecked(true); showOverviewAction.setChecked(false); pageBook.showPage(outline); if (thumbnail != null) thumbnail.setVisible(false); } else if (id == ID_OVERVIEW) { if (!overviewInitialized) initializeOverview(); showOutlineAction.setChecked(false); showOverviewAction.setChecked(true); pageBook.showPage(overview); thumbnail.setVisible(true); } } /** * unhook the outline viewer */ protected void unhookOutlineViewer() { getSelectionSynchronizer().removeViewer(getViewer()); if (disposeListener != null && getEditor() != null && !getEditor().isDisposed()) getEditor().removeDisposeListener(disposeListener); } /** * getter for the editor conrolo * * @return <code>Control</code> */ protected Control getEditor() { return getGraphicalViewer().getControl(); } } /** * My editing domain provider. */ private IEditingDomainProvider domainProvider = new IEditingDomainProvider() { public EditingDomain getEditingDomain() { return DiagramEditor.this.getEditingDomain(); } }; /** The key handler */ private KeyHandler keyHandler; /** * The workbench site This variable overrides another one defined in * <code>org.eclipse.ui.part<code> * This is needed to override <code>setSite</code> to simply set the site, rather than also * initializing the actions like <code>setSite</code> override in <code>org.eclipse.gef.ui.parts</code> */ private IWorkbenchPartSite partSite; /** * The RulerComposite used to enhance the graphical viewer to display rulers */ private RulerComposite rulerComposite; /** * My undo context. */ private IUndoContext undoContext; /** * My operation history listener. By default it adds my undo context to * operations that have affected my editing domain. Subclasses may override * {@link #createHistoryListener()} to do something different. */ private IOperationHistoryListener historyListener; /** * Alternative operation history listener. By default it adds it disables * updates when command is executing on a separate thread and then reables * afterwards. */ private IOperationHistoryListener disableUpdateHistoryListener; /** * Returns this editor's outline-page default display mode. * * @return int the integer value indicating the content-outline-page dispaly * mode */ protected int getDefaultOutlineViewMode() { return ID_OVERVIEW; } /** * Returns the context menu provider for the outline view. * * @param viewer The outline viewer for which this context menu provider * will be added. * * @return A menu manager that can be used in the provided outline viewer * or null if no context menu should be shown. * */ protected MenuManager getOutlineContextMenuProvider(EditPartViewer viewer) { return null; } /** * @return Returns the rulerComp. */ protected RulerComposite getRulerComposite() { return rulerComposite; } /** * @param rulerComp * The rulerComp to set. */ protected void setRulerComposite(RulerComposite rulerComp) { this.rulerComposite = rulerComp; } /** * Creates a new DiagramEditor instance */ public DiagramEditor() { createDiagramEditDomain(); // add my operation history listener, if I have one historyListener = createHistoryListener(); disableUpdateHistoryListener = createDisableUpdateHistoryListener(); } /** * Creates a listener on the <code>IOperationHistory</code> that allows * us to turn off updates when execution is performed on a separate * thread. * * @return */ private IOperationHistoryListener createDisableUpdateHistoryListener() { return new IOperationHistoryListener() { public void historyNotification(final OperationHistoryEvent event) { if (event.getEventType() == OperationHistoryEvent.ABOUT_TO_EXECUTE || event.getEventType() == OperationHistoryEvent.ABOUT_TO_UNDO || event.getEventType() == OperationHistoryEvent.ABOUT_TO_REDO) { DiagramGraphicalViewer viewer = (DiagramGraphicalViewer) getDiagramGraphicalViewer(); if (viewer != null && Display.getCurrent() == null) viewer.enableUpdates(false); } else if (event.getEventType() == OperationHistoryEvent.OPERATION_NOT_OK || event.getEventType() == OperationHistoryEvent.DONE || event.getEventType() == OperationHistoryEvent.UNDONE || event.getEventType() == OperationHistoryEvent.REDONE) { DiagramGraphicalViewer viewer = (DiagramGraphicalViewer) getDiagramGraphicalViewer(); if (viewer != null) viewer.enableUpdates(true); } } }; } /** * Gets my operation history listener. By default it adds my undo context to * operations that have affected my editing domain. * <P> * Subclasses may override this method to return a different history * listener, or to return <code>null</code> if they do not want to listen * to the operation history. * * @return my operation history listener */ protected IOperationHistoryListener createHistoryListener() { return new IOperationHistoryListener() { public void historyNotification(final OperationHistoryEvent event) { if (event.getEventType() == OperationHistoryEvent.DONE) { IUndoableOperation operation = event.getOperation(); if (shouldAddUndoContext(operation)) { // add my undo context to populate my undo // menu operation.addContext(getUndoContext()); } } } }; } /** * Answers whether or not I should add my undo context to the undoable * <code>operation</code>, thereby making the operation available from my * undo menu. * <P> * The default implementation adds my context to any operation that affected * the same editing domain that has loaded the resource that contains my * diagram element. Subclasses can override this method if they wish to add * their context to operations for different reasons. * * @param operation * the operation * @return <code>true</code> if the operation should appear on my undo * menu, <code>false</code> otherwise. */ protected boolean shouldAddUndoContext(IUndoableOperation operation) { EditingDomain domain = getEditingDomain(); if (domain != null) { Set affectedResources = ResourceUndoContext.getAffectedResources(operation); for (Iterator i = affectedResources.iterator(); i.hasNext();) { Resource nextResource = (Resource) i.next(); ResourceSet resourceSet = nextResource.getResourceSet(); if (resourceSet != null) { TransactionalEditingDomain resourceSetEditingDomain = TransactionalEditingDomain.Factory.INSTANCE .getEditingDomain(resourceSet); if (domain.equals(resourceSetEditingDomain)) { return true; } } } } return false; } /** * @see org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramWorkbenchPart#getDiagramEditDomain() */ public IDiagramEditDomain getDiagramEditDomain() { return (IDiagramEditDomain) getEditDomain(); } /** * @see org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramWorkbenchPart#getDiagramGraphicalViewer() */ public IDiagramGraphicalViewer getDiagramGraphicalViewer() { return (IDiagramGraphicalViewer) getGraphicalViewer(); } /** * @see org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramWorkbenchPart#getDiagram() */ public Diagram getDiagram() { if (getEditorInput() != null) return ((IDiagramEditorInput) getEditorInput()).getDiagram(); return null; } /** * @see org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramWorkbenchPart#getDiagramEditPart() */ public DiagramEditPart getDiagramEditPart() { return (DiagramEditPart) getDiagramGraphicalViewer().getContents(); } /** * @see org.eclipse.core.runtime.IAdaptable#getAdapter(Class) */ public Object getAdapter(Class type) { if (type == IContentOutlinePage.class) { TreeViewer viewer = new TreeViewer(); viewer.setRootEditPart(new DiagramRootTreeEditPart()); return new DiagramOutlinePage(viewer); } if (ActionManager.class == type) return getActionManager(); if (IDiagramEditDomain.class == type) return getDiagramEditDomain(); if (type == ZoomManager.class) return getZoomManager(); if (type == IUndoContext.class) { return getUndoContext(); } if (type == IOperationHistory.class) { return getOperationHistory(); } if (type == IEditingDomainProvider.class) { return domainProvider; } return super.getAdapter(type); } /** * @see org.eclipse.ui.IEditorPart#init(IEditorSite, IEditorInput) */ public void init(IEditorSite site, IEditorInput input) throws PartInitException { super.init(site, input); try { EditorService.getInstance().registerEditor(this); } catch (Exception e) { Trace.catching(DiagramUIPlugin.getInstance(), DiagramUIDebugOptions.EXCEPTIONS_CATCHING, getClass(), "init", e); //$NON-NLS-1$ if (e.getMessage() != null) throw new PartInitException(e.getMessage(), e); else throw new PartInitException("DiagramEditor failed to initialize", e);//$NON-NLS-1$ } } /** * Disposes this editor by: <br> * 3. Stops all registered listeners * * @see org.eclipse.ui.IWorkbenchPart#dispose() */ public void dispose() { persistViewerSettings(); EditorService.getInstance().unregisterEditor(DiagramEditor.this); stopListening(); /* * RATLC00527385 DiagramRulerProvider wasn't uninitialized on dispose of * the editor. */ DiagramRulerProvider vertProvider = (DiagramRulerProvider) getDiagramGraphicalViewer() .getProperty(RulerProvider.PROPERTY_VERTICAL_RULER); if (vertProvider != null) vertProvider.uninit(); // Set the Horizontal Ruler properties DiagramRulerProvider horzProvider = (DiagramRulerProvider) getDiagramGraphicalViewer() .getProperty(RulerProvider.PROPERTY_HORIZONTAL_RULER); if (horzProvider != null) horzProvider.uninit(); // Dispose my GEF command stack getEditDomain().getCommandStack().dispose(); // stop listening to the history if (historyListener != null) { getOperationHistory().removeOperationHistoryListener(historyListener); // dispose my undo context getOperationHistory().dispose(getUndoContext(), true, true, true); } if (disableUpdateHistoryListener != null) { getOperationHistory().removeOperationHistoryListener(disableUpdateHistoryListener); } super.dispose(); } /** * Returns the KeyHandler with common bindings for both the Outline and * Graphical Views. For example, delete is a common action. * * @return KeyHandler */ protected KeyHandler getKeyHandler() { if (keyHandler == null) { keyHandler = new KeyHandler(); ActionRegistry registry = getActionRegistry(); IAction action; action = new PromptingDeleteAction(this); action.setText(DiagramUIMessages.DiagramEditor_Delete_from_Diagram); registry.registerAction(action); getSelectionActions().add(action.getId()); action = new InsertAction(this); action.setText(""); //$NON-NLS-1$ // no text necessary since this is not a visible action registry.registerAction(action); getSelectionActions().add(action.getId()); PromptingDeleteFromModelAction deleteModelAction = new PromptingDeleteFromModelAction(this); deleteModelAction.init(); registry.registerAction(deleteModelAction); action = new DirectEditAction((IWorkbenchPart) this); registry.registerAction(action); getSelectionActions().add(action.getId()); action = new ZoomInAction(getZoomManager()); action.setText(""); //$NON-NLS-1$ // no text necessary since this is not a visible action registry.registerAction(action); getSelectionActions().add(action.getId()); action = new ZoomOutAction(getZoomManager()); action.setText(""); //$NON-NLS-1$ // no text necessary since this is not a visible action registry.registerAction(action); getSelectionActions().add(action.getId()); action = new ToggleRouterAction(((IWorkbenchPart) this).getSite().getPage()); ((ToggleRouterAction) action).setPartSelector(new IPartSelector() { public boolean selects(IWorkbenchPart part) { return part == DiagramEditor.this; } }); action.setText(""); //$NON-NLS-1$ // no text necessary since this is not a visible action registry.registerAction(action); getSelectionActions().add(action.getId()); keyHandler.put(KeyStroke.getPressed(SWT.INSERT, 0), getActionRegistry().getAction(InsertAction.ID)); keyHandler.put(KeyStroke.getPressed(SWT.DEL, 127, 0), getActionRegistry().getAction(ActionFactory.DELETE.getId())); keyHandler.put(KeyStroke.getPressed(SWT.BS, 8, 0), getActionRegistry().getAction(ActionFactory.DELETE.getId())); keyHandler.put(/* CTRL + D */ KeyStroke.getPressed((char) 0x4, 100, SWT.CTRL), getActionRegistry().getAction(ActionIds.ACTION_DELETE_FROM_MODEL)); keyHandler.put(/* CTRL + '=' */ KeyStroke.getPressed('=', 0x3d, SWT.CTRL), getActionRegistry().getAction(GEFActionConstants.ZOOM_IN)); keyHandler.put(/* CTRL + '-' */ KeyStroke.getPressed('-', 0x2d, SWT.CTRL), getActionRegistry().getAction(GEFActionConstants.ZOOM_OUT)); keyHandler.put(/* CTRL + L */ KeyStroke.getPressed((char) 0xC, 108, SWT.CTRL), getActionRegistry().getAction(ActionIds.ACTION_TOGGLE_ROUTER)); keyHandler.put(KeyStroke.getPressed(SWT.F2, 0), getActionRegistry().getAction(GEFActionConstants.DIRECT_EDIT)); } return keyHandler; } /** * @see org.eclipse.gef.ui.parts.GraphicalEditor#createGraphicalViewer(Composite) */ protected void createGraphicalViewer(Composite parent) { setRulerComposite(new RulerComposite(parent, SWT.NONE)); ScrollingGraphicalViewer sGViewer = createScrollingGraphicalViewer(); sGViewer.createControl(getRulerComposite()); setGraphicalViewer(sGViewer); hookGraphicalViewer(); configureGraphicalViewer(); initializeGraphicalViewer(); getRulerComposite().setGraphicalViewer((ScrollingGraphicalViewer) getGraphicalViewer()); } /** * Creates a ScrollingGraphicalViewer without the drop adapter which * excludes drag and drop functionality from other defined views (XML) * Subclasses must override this method to include the DnD functionality * * @return ScrollingGraphicalViewer */ protected ScrollingGraphicalViewer createScrollingGraphicalViewer() { return new DiagramGraphicalViewer(); } /** * Configures the graphical viewer (the primary viewer of the editor) */ protected void configureGraphicalViewer() { super.configureGraphicalViewer(); IDiagramGraphicalViewer viewer = getDiagramGraphicalViewer(); RootEditPart rootEP = EditPartService.getInstance().createRootEditPart(getDiagram()); if (rootEP instanceof IDiagramPreferenceSupport) { ((IDiagramPreferenceSupport) rootEP).setPreferencesHint(getPreferencesHint()); } if (getDiagramGraphicalViewer() instanceof DiagramGraphicalViewer) { ((DiagramGraphicalViewer) getDiagramGraphicalViewer()) .hookWorkspacePreferenceStore(getWorkspaceViewerPreferenceStore()); } viewer.setRootEditPart(rootEP); viewer.setEditPartFactory(EditPartService.getInstance()); ContextMenuProvider provider = new DiagramContextMenuProvider(this, viewer); viewer.setContextMenu(provider); getSite().registerContextMenu(ActionIds.DIAGRAM_EDITOR_CONTEXT_MENU, provider, viewer); KeyHandler viewerKeyHandler = new DiagramGraphicalViewerKeyHandler(viewer).setParent(getKeyHandler()); viewer.setKeyHandler(new DirectEditKeyHandler(viewer).setParent(viewerKeyHandler)); if (viewer.getControl() instanceof FigureCanvas) { ((FigureCanvas) viewer.getControl()).setScrollBarVisibility(FigureCanvas.ALWAYS); } } /** * @see org.eclipse.gef.ui.parts.GraphicalEditor#initializeGraphicalViewer() */ protected void initializeGraphicalViewer() { initializeGraphicalViewerContents(); } /** * @see org.eclipse.gef.ui.parts.GraphicalEditor#initializeGraphicalViewer() */ protected void initializeGraphicalViewerContents() { getDiagramGraphicalViewer().setContents(getDiagram()); initializeContents(getDiagramEditPart()); } /** * Creates a diagram edit domain */ protected void createDiagramEditDomain() { DiagramEditDomain editDomain = new DiagramEditDomain(this); editDomain.setActionManager(createActionManager()); setEditDomain(editDomain); } /** * Configures my diagram edit domain with its command stack. */ protected void configureDiagramEditDomain() { DefaultEditDomain editDomain = getEditDomain(); if (editDomain != null) { CommandStack stack = editDomain.getCommandStack(); if (stack != null) { // dispose the old stack stack.dispose(); } // create and assign the new stack DiagramCommandStack diagramStack = new DiagramCommandStack(getDiagramEditDomain()); diagramStack.setOperationHistory(getOperationHistory()); // changes made on the stack can be undone from this editor diagramStack.setUndoContext(getUndoContext()); editDomain.setCommandStack(diagramStack); } } /** * @overridable */ protected ActionManager createActionManager() { return new ActionManager(createOperationHistory()); } /** * Create my operation history. * * @return my operation history */ protected IOperationHistory createOperationHistory() { return OperationHistoryFactory.getOperationHistory(); } /** * @see org.eclipse.ui.part.EditorPart#setInput(IEditorInput) */ protected void setInput(IEditorInput input) { stopListening(); if (input != null) { super.setInput(input); } if (input != null) { Assert.isNotNull(getDiagram(), "Couldn't load/create diagram view"); //$NON-NLS-1$ } // dispose the old command stack and create a new one configureDiagramEditDomain(); startListening(); } /** * Do nothing * * @see org.eclipse.gef.ui.parts.GraphicalEditor#initializeActionRegistry() */ protected void createActions() { // null impl. } /** * A utility to close the editor * * @param save */ protected void closeEditor(final boolean save) { // Make this call synchronously to avoid the following sequence: // Select me, select the model editor, close the model editor, // closes the model, fires events causing me to close, // if actual close is delayed using an async call then eclipse // tries to set the selection back to me when the model editor // finishes being disposed, but model has been closed so I // am no longer connected to the model, NullPointerExceptions occur. try { getSite().getPage().closeEditor(DiagramEditor.this, save); } catch (SWTException e) { // TODO remove when "Widget is disposed" exceptions are fixed. // Temporarily catch SWT exceptions here to allow model server event // processing to continue. Trace.catching(DiagramUIPlugin.getInstance(), DiagramUIDebugOptions.EXCEPTIONS_CATCHING, this.getClass(), "closeEditor", e); //$NON-NLS-1$ Log.error(DiagramUIPlugin.getInstance(), IStatus.ERROR, e.getMessage(), e); } } /** * Installs all the listeners needed by the editor */ protected void startListening() { // Create a diagram event broker if there isn't already one for this // editing domain. TransactionalEditingDomain domain = getEditingDomain(); if (domain != null) { if (historyListener != null) { getOperationHistory().addOperationHistoryListener(historyListener); } if (disableUpdateHistoryListener != null) { getOperationHistory().addOperationHistoryListener(disableUpdateHistoryListener); } DiagramEventBroker eventBroker = DiagramEventBroker.getInstance(domain); if (eventBroker == null) { DiagramEventBroker.startListening(domain); } } } /** * Removes all the listeners used by the editor */ protected void stopListening() { if (historyListener != null) { if (undoContext != null) { // dispose my undo context getOperationHistory().dispose(getUndoContext(), true, true, true); } getOperationHistory().removeOperationHistoryListener(historyListener); } if (disableUpdateHistoryListener != null) { getOperationHistory().removeOperationHistoryListener(disableUpdateHistoryListener); } } /** * Clears the contents of the graphical viewer */ protected void clearGraphicalViewerContents() { if (getDiagramGraphicalViewer().getContents() != null) { getDiagramGraphicalViewer().getContents().deactivate(); getDiagramGraphicalViewer().getContents().removeNotify(); } /* * DiagramRulerProvider needs to be uninitialized in case the input has * been changed during editor life cycle. * * https://bugs.eclipse.org/bugs/show_bug.cgi?id=167523 */ DiagramRulerProvider vertProvider = (DiagramRulerProvider) getDiagramGraphicalViewer() .getProperty(RulerProvider.PROPERTY_VERTICAL_RULER); if (vertProvider != null) vertProvider.uninit(); DiagramRulerProvider horzProvider = (DiagramRulerProvider) getDiagramGraphicalViewer() .getProperty(RulerProvider.PROPERTY_HORIZONTAL_RULER); if (horzProvider != null) horzProvider.uninit(); getDiagramGraphicalViewer().setContents(null); } /** * Gets the action manager for this diagram editor. The action manager's * command manager is used by my edit domain's command stack when executing * commands. This is the action manager that is returned when I am asked to * adapt to an <code>ActionManager</code>. * * @return the action manager */ protected ActionManager getActionManager() { return getDiagramEditDomain().getActionManager(); } /** * A utility method to return the zoom manager from the graphical viewer's * root * * @return the zoom manager */ protected ZoomManager getZoomManager() { return ((DiagramRootEditPart) getRootEditPart()).getZoomManager(); } private RootEditPart getRootEditPart() { return getGraphicalViewer().getRootEditPart(); } /** * Returns the operation history from my action manager. * * @return the operation history */ protected IOperationHistory getOperationHistory() { return getActionManager().getOperationHistory(); } /** * Gets my editing domain derived from my diagram editor input. * <P> * If subclasses have a known editing domain, they should override this * method to return that editing domain as that will be more efficient that * the generic implementation provided here. * * @return my editing domain */ public TransactionalEditingDomain getEditingDomain() { if (getDiagram() != null) { return TransactionUtil.getEditingDomain(getDiagram()); } return null; } /** * Gets my undo context. Lazily initializes my undo context if it has not * been set. * * @return my undo context */ protected IUndoContext getUndoContext() { if (undoContext == null) { undoContext = createUndoContext(); } return undoContext; } /** * Create the undo context. Subclasses may override to provide custom undo context. * @return the created undo context * @since 1.4 */ protected IUndoContext createUndoContext() { IUndoContext context; TransactionalEditingDomain domain = getEditingDomain(); if (domain != null) { context = new EditingDomainUndoContext(domain, createUndoContextLabel()); } else { context = new ObjectUndoContext(this); } return context; } /** * Determine the label to be used by my undo context. The default implementation * returns null which provides the built-in default label. * * @return label for undo context * @since 1.4 */ protected String createUndoContextLabel() { return null; } /** * Sets my undo context * * @param context * the undo context */ protected void setUndoContext(IUndoContext context) { this.undoContext = context; } /** * * @return The getRulerComposite(), which is the graphical control */ protected Control getGraphicalControl() { return getRulerComposite(); } /** * @see org.eclipse.ui.IWorkbenchPart#getSite() */ public IWorkbenchPartSite getSite() { return partSite; } /** * @see org.eclipse.ui.part.WorkbenchPart#setSite(IWorkbenchPartSite) */ protected void setSite(IWorkbenchPartSite site) { this.partSite = site; } /* * (non-Javadoc) * * @see org.eclipse.gmf.runtime.common.ui.properties.ITabbedPropertySheetPageContributor#getContributorId() */ public String getContributorId() { return "org.eclipse.gmf.runtime.diagram.ui.properties"; //$NON-NLS-1$ } /** * Adds the default preferences to the specified preference store. * * @param store * store to use * @param preferencesHint * The preference hint that is to be used to find the appropriate * preference store from which to retrieve diagram preference * values. The preference hint is mapped to a preference store in * the preference registry <@link DiagramPreferencesRegistry>. */ public static void addDefaultPreferences(PreferenceStore store, PreferencesHint preferencesHint) { store.setValue(WorkspaceViewerProperties.ZOOM, 1.0); store.setValue(WorkspaceViewerProperties.VIEWPAGEBREAKS, false); IPreferenceStore globalPreferenceStore = (IPreferenceStore) preferencesHint.getPreferenceStore(); // Initialize with the global settings boolean viewGrid = globalPreferenceStore.getBoolean(IPreferenceConstants.PREF_SHOW_GRID); boolean snapToGrid = globalPreferenceStore.getBoolean(IPreferenceConstants.PREF_SNAP_TO_GRID); boolean snapToGeometry = globalPreferenceStore.getBoolean(IPreferenceConstants.PREF_SNAP_TO_GEOMETRY); boolean viewRulers = globalPreferenceStore.getBoolean(IPreferenceConstants.PREF_SHOW_RULERS); // Set defaults for Grid store.setValue(WorkspaceViewerProperties.VIEWGRID, viewGrid); store.setValue(WorkspaceViewerProperties.SNAPTOGRID, snapToGrid); store.setValue(WorkspaceViewerProperties.SNAPTOGEOMETRY, snapToGeometry); // Set defaults for Rulers store.setValue(WorkspaceViewerProperties.VIEWRULERS, viewRulers); // Initialize printing defaults from the workspace preferences IPreferenceStore workspacePreferences = (IPreferenceStore) preferencesHint.getPreferenceStore(); store.setValue(WorkspaceViewerProperties.PREF_USE_WORKSPACE_SETTINGS, workspacePreferences.getBoolean(WorkspaceViewerProperties.PREF_USE_WORKSPACE_SETTINGS)); store.setValue(WorkspaceViewerProperties.PREF_USE_DIAGRAM_SETTINGS, workspacePreferences.getBoolean(WorkspaceViewerProperties.PREF_USE_WORKSPACE_SETTINGS)); store.setValue(WorkspaceViewerProperties.PREF_USE_INCHES, workspacePreferences.getBoolean(WorkspaceViewerProperties.PREF_USE_INCHES)); store.setValue(WorkspaceViewerProperties.PREF_USE_MILLIM, workspacePreferences.getBoolean(WorkspaceViewerProperties.PREF_USE_MILLIM)); store.setValue(WorkspaceViewerProperties.PREF_USE_PORTRAIT, workspacePreferences.getBoolean(WorkspaceViewerProperties.PREF_USE_PORTRAIT)); store.setValue(WorkspaceViewerProperties.PREF_USE_LANDSCAPE, workspacePreferences.getBoolean(WorkspaceViewerProperties.PREF_USE_LANDSCAPE)); store.setValue(WorkspaceViewerProperties.PREF_PAGE_SIZE, workspacePreferences.getString(WorkspaceViewerProperties.PREF_PAGE_SIZE)); store.setValue(WorkspaceViewerProperties.PREF_PAGE_WIDTH, workspacePreferences.getDouble(WorkspaceViewerProperties.PREF_PAGE_WIDTH)); store.setValue(WorkspaceViewerProperties.PREF_PAGE_HEIGHT, workspacePreferences.getDouble(WorkspaceViewerProperties.PREF_PAGE_HEIGHT)); store.setValue(WorkspaceViewerProperties.PREF_MARGIN_TOP, workspacePreferences.getDouble(WorkspaceViewerProperties.PREF_MARGIN_TOP)); store.setValue(WorkspaceViewerProperties.PREF_MARGIN_BOTTOM, workspacePreferences.getDouble(WorkspaceViewerProperties.PREF_MARGIN_BOTTOM)); store.setValue(WorkspaceViewerProperties.PREF_MARGIN_LEFT, workspacePreferences.getDouble(WorkspaceViewerProperties.PREF_MARGIN_LEFT)); store.setValue(WorkspaceViewerProperties.PREF_MARGIN_RIGHT, workspacePreferences.getDouble(WorkspaceViewerProperties.PREF_MARGIN_RIGHT)); } /** * Returns the workspace viewer <code>PreferenceStore</code> * * @return the workspace viewer <code>PreferenceStore</code> */ public PreferenceStore getWorkspaceViewerPreferenceStore() { if (workspaceViewerPreferenceStore != null) { return workspaceViewerPreferenceStore; } else { // Try to load it IPath path = DiagramUIPlugin.getInstance().getStateLocation(); String id = ViewUtil.getIdStr(getDiagram()); String fileName = path.toString() + "/" + id;//$NON-NLS-1$ java.io.File file = new File(fileName); workspaceViewerPreferenceStore = new PreferenceStore(fileName); if (file.exists()) { // Load it try { workspaceViewerPreferenceStore.load(); } catch (Exception e) { // Create the default addDefaultPreferences(); } } else { // Create it addDefaultPreferences(); } return workspaceViewerPreferenceStore; } } /** * Adds the default preferences to the workspace viewer preference store. */ protected void addDefaultPreferences() { addDefaultPreferences(workspaceViewerPreferenceStore, getPreferencesHint()); } /** * Persists the viewer settings to which this RootEditPart belongs. This * method should be called when the diagram is being disposed. */ public void persistViewerSettings() { Viewport viewport = getDiagramEditPart().getViewport(); if (viewport != null) { int x = viewport.getHorizontalRangeModel().getValue(); int y = viewport.getVerticalRangeModel().getValue(); getWorkspaceViewerPreferenceStore().setValue(WorkspaceViewerProperties.VIEWPORTX, x); getWorkspaceViewerPreferenceStore().setValue(WorkspaceViewerProperties.VIEWPORTY, y); } getWorkspaceViewerPreferenceStore().setValue(WorkspaceViewerProperties.ZOOM, getZoomManager().getZoom()); // Write the settings, if necessary try { if (getWorkspaceViewerPreferenceStore().needsSaving()) getWorkspaceViewerPreferenceStore().save(); } catch (IOException ioe) { Trace.catching(DiagramUIPlugin.getInstance(), DiagramUIDebugOptions.EXCEPTIONS_CATCHING, PageInfoHelper.class, "persistViewerSettings", //$NON-NLS-1$ ioe); } } /** * Initializes the viewer's state from the workspace preference store. * * @param editpart */ private void initializeContents(EditPart editpart) { getZoomManager().setZoom(getWorkspaceViewerPreferenceStore().getDouble(WorkspaceViewerProperties.ZOOM)); if (getWorkspaceViewerPreferenceStore().getBoolean(WorkspaceViewerProperties.VIEWPAGEBREAKS)) { getDiagramEditPart().getFigure().invalidate(); getDiagramEditPart().getFigure().validate(); } getDiagramEditPart().refreshPageBreaks(); // Update the range model of the viewport ((DiagramEditPart) editpart).getViewport().validate(); if (editpart instanceof DiagramEditPart) { int x = getWorkspaceViewerPreferenceStore().getInt(WorkspaceViewerProperties.VIEWPORTX); int y = getWorkspaceViewerPreferenceStore().getInt(WorkspaceViewerProperties.VIEWPORTY); ((DiagramEditPart) editpart).getViewport().getHorizontalRangeModel().setValue(x); ((DiagramEditPart) editpart).getViewport().getVerticalRangeModel().setValue(y); } // Get the Ruler Units properties int rulerUnits = getWorkspaceViewerPreferenceStore().getInt(WorkspaceViewerProperties.RULERUNIT); // Get the Guide Style GuideStyle guideStyle = (GuideStyle) getDiagram().getStyle(NotationPackage.eINSTANCE.getGuideStyle()); if (guideStyle != null) { RootEditPart rep = getGraphicalViewer().getRootEditPart(); DiagramRootEditPart root = (DiagramRootEditPart) rep; // Set the Vertical Ruler properties DiagramRuler verticalRuler = ((DiagramRootEditPart) getRootEditPart()).getVerticalRuler(); verticalRuler.setGuideStyle(guideStyle); verticalRuler.setUnit(rulerUnits); DiagramRulerProvider vertProvider = new DiagramRulerProvider(getEditingDomain(), verticalRuler, root.getMapMode()); vertProvider.init(); getDiagramGraphicalViewer().setProperty(RulerProvider.PROPERTY_VERTICAL_RULER, vertProvider); // Set the Horizontal Ruler properties DiagramRuler horizontalRuler = ((DiagramRootEditPart) getRootEditPart()).getHorizontalRuler(); horizontalRuler.setGuideStyle(guideStyle); horizontalRuler.setUnit(rulerUnits); DiagramRulerProvider horzProvider = new DiagramRulerProvider(getEditingDomain(), horizontalRuler, root.getMapMode()); horzProvider.init(); getDiagramGraphicalViewer().setProperty(RulerProvider.PROPERTY_HORIZONTAL_RULER, horzProvider); // Show/Hide Rulers getDiagramGraphicalViewer().setProperty(RulerProvider.PROPERTY_RULER_VISIBILITY, Boolean .valueOf(getWorkspaceViewerPreferenceStore().getBoolean(WorkspaceViewerProperties.VIEWRULERS))); } // Snap to Geometry getDiagramGraphicalViewer().setProperty(SnapToGeometry.PROPERTY_SNAP_ENABLED, Boolean .valueOf(getWorkspaceViewerPreferenceStore().getBoolean(WorkspaceViewerProperties.SNAPTOGEOMETRY))); // Snap to Grid getDiagramGraphicalViewer().setProperty(SnapToGrid.PROPERTY_GRID_ENABLED, Boolean .valueOf(getWorkspaceViewerPreferenceStore().getBoolean(WorkspaceViewerProperties.SNAPTOGRID))); // Hide/Show Grid getDiagramGraphicalViewer().setProperty(SnapToGrid.PROPERTY_GRID_VISIBLE, Boolean .valueOf(getWorkspaceViewerPreferenceStore().getBoolean(WorkspaceViewerProperties.VIEWGRID))); // Grid Origin (always 0, 0) Point origin = new Point(); getDiagramGraphicalViewer().setProperty(SnapToGrid.PROPERTY_GRID_ORIGIN, origin); // Grid Spacing double dSpacing = ((DiagramRootEditPart) getDiagramEditPart().getRoot()).getGridSpacing(); ((DiagramRootEditPart) getDiagramEditPart().getRoot()).setGridSpacing(dSpacing); // Scroll-wheel Zoom getGraphicalViewer().setProperty(MouseWheelHandler.KeyGenerator.getKey(SWT.CTRL), MouseWheelZoomHandler.SINGLETON); } /** * Returns the elements in the given selection. * * @param selection * the selection * @return a list of <code>EObject</code> */ protected List getElements(final ISelection selection) { if (selection instanceof IStructuredSelection && !selection.isEmpty()) { try { return (List) TransactionUtil.getEditingDomain( ((IAdaptable) ((IStructuredSelection) selection).toList().get(0)).getAdapter(View.class)) .runExclusive(new RunnableWithResult.Impl() { public void run() { List retval = new ArrayList(); if (selection instanceof IStructuredSelection) { IStructuredSelection structuredSelection = (IStructuredSelection) selection; for (Iterator i = structuredSelection.iterator(); i.hasNext();) { Object next = i.next(); View view = (View) ((IAdaptable) next).getAdapter(View.class); if (view != null) { EObject eObject = ViewUtil.resolveSemanticElement(view); if (eObject != null) { retval.add(eObject); } else { retval.add(view); } } } } setResult(retval); } }); } catch (InterruptedException e) { Trace.catching(DiagramUIPlugin.getInstance(), DiagramUIDebugOptions.EXCEPTIONS_CATCHING, getClass(), "createEditPart", e); //$NON-NLS-1$ return Collections.EMPTY_LIST; } } return Collections.EMPTY_LIST; } /* * (non-Javadoc) * * @see org.eclipse.ui.part.IShowInSource#getShowInContext() */ public ShowInContext getShowInContext() { ISelection selection = getGraphicalViewer().getSelection(); return new ShowInContext(null, selection); } /** * Gets the preferences hint that will be used to determine which preference * store to use when retrieving diagram preferences for this diagram editor. * The preference hint is mapped to a preference store in the preference * registry <@link DiagramPreferencesRegistry>. By default, this method * returns a preference hint configured with the id of the editor. If a * preference store has not been registered against this editor id in the * diagram preferences registry, then the default values will be used. * * @return the preferences hint to be used to configure the * <code>RootEditPart</code> */ protected PreferencesHint getPreferencesHint() { return new PreferencesHint(getEditorSite().getId()); }; /** * Returns false if the editor is read only and returns true if the editor * is writable. * * By default, edit parts have their edit mode enabled and this method * returns true. * * Subclasses may override and disable the edit mode on parts. * * @see org.eclipse.gmf.runtime.diagram.ui.internal.editparts.IEditableEditPart. * * @return false if the editor is read only and returns true if the editor * is writable. */ public boolean isWritable() { return (getDiagramEditPart() != null && getDiagramEditPart().isEditModeEnabled()); } /** * Creates edit part factory that will be creating tree edit parts in * the tree viewer * @return <code>EditPartFactory</code> factory for the tree viewer */ protected EditPartFactory getOutlineViewEditPartFactory() { return new EditPartFactory() { public EditPart createEditPart(EditPart context, Object model) { if (model instanceof Diagram) { return new TreeDiagramEditPart(model); } else if (model instanceof View && ViewType.GROUP.equals(((View) model).getType())) { return new TreeContainerEditPart(model); } else { return new TreeEditPart(model); } } }; } /* (non-Javadoc) * @see org.eclipse.gef.ui.parts.GraphicalEditor#createPartControl(org.eclipse.swt.widgets.Composite) */ public void createPartControl(Composite parent) { super.createPartControl(parent); IContextService contextService = (IContextService) getSite().getService(IContextService.class); if (contextService != null) contextService.activateContext(getContextID()); } /** * Get the context identifier for this diagram editor. * * @return the context identifier. */ protected String getContextID() { return DIAGRAM_CONTEXT_ID; } }