/*******************************************************************************
* <copyright>
*
* Copyright (c) 2013 SRC
* 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:
* pjpaulin - initial API, implementation and documentation
*
* </copyright>
*
*******************************************************************************/
package org.eclipse.graphiti.ui.editor;
import java.util.ArrayList;
import java.util.EventObject;
import java.util.Iterator;
import java.util.List;
import org.eclipse.draw2d.ColorConstants;
import org.eclipse.draw2d.IFigure;
import org.eclipse.gef.ContextMenuProvider;
import org.eclipse.gef.DefaultEditDomain;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.GraphicalEditPart;
import org.eclipse.gef.GraphicalViewer;
import org.eclipse.gef.commands.CommandStack;
import org.eclipse.gef.commands.CommandStackListener;
import org.eclipse.gef.ui.actions.ActionBarContributor;
import org.eclipse.gef.ui.actions.ActionRegistry;
import org.eclipse.gef.ui.actions.DeleteAction;
import org.eclipse.gef.ui.actions.PrintAction;
import org.eclipse.gef.ui.actions.RedoAction;
import org.eclipse.gef.ui.actions.SelectAllAction;
import org.eclipse.gef.ui.actions.UndoAction;
import org.eclipse.gef.ui.actions.UpdateAction;
import org.eclipse.gef.ui.parts.ScrollingGraphicalViewer;
import org.eclipse.gef.ui.parts.SelectionSynchronizer;
import org.eclipse.gef.ui.properties.UndoablePropertySheetPage;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.ISelectionListener;
import org.eclipse.ui.ISelectionService;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.actions.ActionFactory;
/**
* Based on the original GEF GraphicalEditor class, this is a composite that
* supports graphical editing.
*
* @since 0.10
* @experimental This API is in an experimental state and should be used by
* clients only with care, as it not final and can be removed or
* changed without prior notice!
*/
@SuppressWarnings("rawtypes")
public abstract class GraphicalComposite extends Composite implements CommandStackListener,
ISelectionListener {
@SuppressWarnings("serial")
private static class ActionIDList extends ArrayList {
@SuppressWarnings("unchecked")
public boolean add(Object o) {
if (o instanceof IAction) {
try {
IAction action = (IAction) o;
o = action.getId();
throw new IllegalArgumentException(
"Action IDs should be added to lists, not the action: " + action); //$NON-NLS-1$
}
catch(IllegalArgumentException exc) {
exc.printStackTrace();
}
}
return super.add(o);
}
}
private DefaultEditDomain editDomain;
private GraphicalViewer graphicalViewer;
private ActionRegistry actionRegistry;
private SelectionSynchronizer synchronizer;
private List selectionActions = new ActionIDList();
private List stackActions = new ActionIDList();
private List propertyActions = new ActionIDList();
/**
* Constructs the editor part
*/
public GraphicalComposite(Composite parent, int style) {
super(parent, style);
setLayout(new FillLayout());
}
/**
* When the command stack changes, the actions interested in the command stack are updated.
*
* @param event
* the change event
*/
public void commandStackChanged(EventObject event) {
updateActions(stackActions);
}
/**
* Called to configure the graphical viewer before it receives its contents. This is where the
* root editpart should be configured. Subclasses should extend or override this method as
* needed.
*/
protected void configureGraphicalViewer() {
getGraphicalViewer().getControl().setBackground(ColorConstants.listBackground);
}
/**
* Creates actions for this editor. Subclasses should override this method to create and
* register actions with the {@link ActionRegistry}.
*/
@SuppressWarnings("unchecked")
protected void createActions() {
if (getWorkbenchPart() != null) {
ActionRegistry registry = getActionRegistry();
IAction action;
action = new UndoAction(this.getWorkbenchPart());
registry.registerAction(action);
getStackActions().add(action.getId());
action = new RedoAction(this.getWorkbenchPart());
registry.registerAction(action);
getStackActions().add(action.getId());
action = new SelectAllAction(this.getWorkbenchPart());
registry.registerAction(action);
action = new DeleteAction(this.getWorkbenchPart());
registry.registerAction(action);
getSelectionActions().add(action.getId());
registry.registerAction(new PrintAction(this.getWorkbenchPart()));
}
}
/**
* Creates the GraphicalViewer on the specified <code>Composite</code>.
*
* @param parent
* the parent composite
*/
protected void createGraphicalViewer() {
GraphicalViewer viewer = new ScrollingGraphicalViewer();
viewer.createControl(this);
setGraphicalViewer(viewer);
configureGraphicalViewer();
hookGraphicalViewer();
initializeGraphicalViewer();
}
/**
* Realizes the Editor by creating it's Control.
* <P>
* WARNING: This method may or may not be called by the workbench prior to {@link #dispose()}.
*
* @param parent
* the parent composite
*/
public void createControl() {
createGraphicalViewer();
}
/**
* @see org.eclipse.ui.IWorkbenchPart#dispose()
*/
public void dispose() {
getCommandStack().removeCommandStackListener(this);
if (getWorkbenchPart() != null)
this.getWorkbenchPart().getSite().getWorkbenchWindow().getSelectionService()
.removeSelectionListener(this);
getEditDomain().setActiveTool(null);
getActionRegistry().dispose();
super.dispose();
}
/**
* @see org.eclipse.ui.part.WorkbenchPart#firePropertyChange(int)
*/
protected void firePropertyChange(int property) {
/* TODO Need to communicate this to part somehow */
// super.firePropertyChange(property);
updateActions(propertyActions);
}
/**
* Lazily creates and returns the action registry.
*
* @return the action registry
*/
public ActionRegistry getActionRegistry() {
if (actionRegistry == null)
actionRegistry = new ActionRegistry();
return actionRegistry;
}
/**
* Returns the adapter for the specified key.
*
* <P>
* <EM>IMPORTANT</EM> certain requests, such as the property sheet, may be made before or after
* {@link #createPartControl(Composite)} is called. The order is unspecified by the Workbench.
*
* @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
*/
public Object getAdapter(Class type) {
if (type == org.eclipse.ui.views.properties.IPropertySheetPage.class) {
return new UndoablePropertySheetPage(getCommandStack(), getActionRegistry().getAction(
ActionFactory.UNDO.getId()), getActionRegistry().getAction(
ActionFactory.REDO.getId()));
}
if (type == GraphicalViewer.class)
return getGraphicalViewer();
if (type == CommandStack.class)
return getCommandStack();
if (type == ActionRegistry.class)
return getActionRegistry();
if (type == EditPart.class && getGraphicalViewer() != null)
return getGraphicalViewer().getRootEditPart();
if (type == IFigure.class && getGraphicalViewer() != null)
return ((GraphicalEditPart) getGraphicalViewer().getRootEditPart()).getFigure();
return null;
}
/**
* Returns the command stack.
*
* @return the command stack
*/
protected CommandStack getCommandStack() {
return getEditDomain().getCommandStack();
}
/**
* Returns the edit domain.
*
* @return the edit domain
*/
public DefaultEditDomain getEditDomain() {
return editDomain;
}
/**
* Returns the graphical viewer.
*
* @return the graphical viewer
*/
public GraphicalViewer getGraphicalViewer() {
return graphicalViewer;
}
/**
* Returns the list of {@link IAction IActions} dependant on property changes in the Editor.
* These actions should implement the {@link UpdateAction} interface so that they can be updated
* in response to property changes. An example is the "Save" action.
*
* @return the list of property-dependant actions
*/
protected List getPropertyActions() {
return propertyActions;
}
/**
* Returns the list of <em>IDs</em> of Actions that are dependant on changes in the workbench's
* {@link ISelectionService}. The associated Actions can be found in the action registry. Such
* actions should implement the {@link UpdateAction} interface so that they can be updated in
* response to selection changes.
*
* @see #updateActions(List)
* @return the list of selection-dependant action IDs
*/
public List getSelectionActions() {
return selectionActions;
}
/**
* Returns the selection syncronizer object. The synchronizer can be used to sync the selection
* of 2 or more EditPartViewers.
*
* @return the syncrhonizer
*/
protected SelectionSynchronizer getSelectionSynchronizer() {
if (synchronizer == null)
synchronizer = new SelectionSynchronizer();
return synchronizer;
}
/**
* Returns the list of <em>IDs</em> of Actions that are dependant on the CommmandStack's state.
* The associated Actions can be found in the action registry. These actions should implement
* the {@link UpdateAction} interface so that they can be updated in response to command stack
* changes. An example is the "undo" action.
*
* @return the list of stack-dependant action IDs
*/
protected List getStackActions() {
return stackActions;
}
/**
* Hooks the GraphicalViewer to the rest of the Editor. By default, the viewer is added to the
* SelectionSynchronizer, which can be used to keep 2 or more EditPartViewers in sync. The
* viewer is also registered as the ISelectionProvider for the Editor's PartSite.
*/
public void hookGraphicalViewer() {
getSelectionSynchronizer().addViewer(getGraphicalViewer());
if (getWorkbenchPart() != null) {
this.getWorkbenchPart().getSite().setSelectionProvider(getGraphicalViewer());
}
}
protected void init() {
getCommandStack().addCommandStackListener(this);
if (getWorkbenchPart() != null) {
this.getWorkbenchPart().getSite().getWorkbenchWindow().getSelectionService().addSelectionListener(this);
initializeActionRegistry();
}
this.createControl();
}
/**
* Initializes the ActionRegistry. This registry may be used by {@link ActionBarContributor
* ActionBarContributors} and/or {@link ContextMenuProvider ContextMenuProviders}.
* <P>
* This method may be called on Editor creation, or lazily the first time
* {@link #getActionRegistry()} is called.
*/
protected void initializeActionRegistry() {
createActions();
updateActions(propertyActions);
updateActions(stackActions);
}
/**
* Override to set the contents of the GraphicalViewer after it has been created.
*
* @see #createGraphicalViewer(Composite)
*/
protected void initializeGraphicalViewer() {
/* may be overridden */
}
/**
* Returns <code>true</code> if the command stack is dirty
*
* @see org.eclipse.ui.ISaveablePart#isDirty()
*/
public boolean isDirty() {
return getCommandStack().isDirty();
}
/**
* @see org.eclipse.ui.ISelectionListener#selectionChanged(IWorkbenchPart, ISelection)
*/
public void selectionChanged(IWorkbenchPart part, ISelection selection) {
// If not the active part, ignore selection changed.
if (getWorkbenchPart() != null
&& getWorkbenchPart().equals(getWorkbenchPart().getSite().getPage().getActivePart()))
updateActions(selectionActions);
}
/**
* Sets the ActionRegistry for this EditorPart.
*
* @param registry
* the registry
*/
protected void setActionRegistry(ActionRegistry registry) {
actionRegistry = registry;
}
/**
* Sets the EditDomain for this EditorPart.
*
* @param ed
* the domain
*/
public void setEditDomain(DefaultEditDomain editDomain) {
this.editDomain = editDomain;
}
public boolean setFocus() {
return getGraphicalViewer().getControl().setFocus();
}
/**
* Sets the graphicalViewer for this EditorPart.
*
* @param viewer
* the graphical viewer
*/
public void setGraphicalViewer(GraphicalViewer viewer) {
getEditDomain().addViewer(viewer);
this.graphicalViewer = viewer;
}
/**
* A convenience method for updating a set of actions defined by the given List of action IDs.
* The actions are found by looking up the ID in the {@link #getActionRegistry() action
* registry}. If the corresponding action is an {@link UpdateAction}, it will have its
* <code>update()</code> method called.
*
* @param actionIds
* the list of IDs to update
*/
protected void updateActions(List actionIds) {
ActionRegistry registry = getActionRegistry();
Iterator iter = actionIds.iterator();
while (iter.hasNext()) {
IAction action = registry.getAction(iter.next());
if (action instanceof UpdateAction)
((UpdateAction) action).update();
}
}
protected abstract IWorkbenchPart getWorkbenchPart();
}