/****************************************************************************** | |
* 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)); | |
((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) { | |
TransactionalEditingDomain domain = getEditingDomain(); | |
if (domain != null) { | |
undoContext = new EditingDomainUndoContext(domain); | |
} else { | |
undoContext = new ObjectUndoContext(this); | |
} | |
} | |
return undoContext; | |
} | |
/** | |
* 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; | |
} | |
} |