Attachment 186907 Details for Bug 327891 – Modified ShapesEditor.java to demonstrate problem.

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Modified ShapesEditor.java to demonstrate problem.

ShapesEditor.java (text/plain), 14.43 KB, created by Marcel Romijn

on 2011-01-17 10:23:21 EST

(hide)

Description:

Filename:

MIME Type:

Creator: Marcel Romijn

Created: 2011-01-17 10:23:21 EST

Size: 14.43 KB

patch

obsolete

>/*******************************************************************************
> * Copyright (c) 2004, 2005 Elias Volanakis 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:
> * Elias Volanakis - initial API and implementation
> *******************************************************************************/
>package org.eclipse.gef.examples.shapes;
>
>import java.io.ByteArrayInputStream;
>import java.io.ByteArrayOutputStream;
>import java.io.IOException;
>import java.io.ObjectInputStream;
>import java.io.ObjectOutputStream;
>import java.io.OutputStream;
>import java.lang.reflect.InvocationTargetException;
>import java.util.ArrayList;
>import java.util.EventObject;
>import java.util.List;
>
>import org.eclipse.swt.widgets.Composite;
>import org.eclipse.swt.widgets.Control;
>import org.eclipse.swt.widgets.Shell;
>
>import org.eclipse.core.resources.IFile;
>import org.eclipse.core.resources.ResourcesPlugin;
>import org.eclipse.core.runtime.CoreException;
>import org.eclipse.core.runtime.IPath;
>import org.eclipse.core.runtime.IProgressMonitor;
>import org.eclipse.jface.action.IAction;
>import org.eclipse.jface.dialogs.ProgressMonitorDialog;
>import org.eclipse.jface.util.TransferDropTargetListener;
>import org.eclipse.ui.IActionBars;
>import org.eclipse.ui.IEditorInput;
>import org.eclipse.ui.IEditorPart;
>import org.eclipse.ui.IFileEditorInput;
>import org.eclipse.ui.actions.ActionFactory;
>import org.eclipse.ui.actions.WorkspaceModifyOperation;
>import org.eclipse.ui.dialogs.SaveAsDialog;
>import org.eclipse.ui.part.FileEditorInput;
>import org.eclipse.ui.part.IPageSite;
>import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
>
>import org.eclipse.gef.ContextMenuProvider;
>import org.eclipse.gef.DefaultEditDomain;
>import org.eclipse.gef.EditPartViewer;
>import org.eclipse.gef.GraphicalViewer;
>import org.eclipse.gef.dnd.TemplateTransferDragSourceListener;
>import org.eclipse.gef.dnd.TemplateTransferDropTargetListener;
>import org.eclipse.gef.editparts.ScalableFreeformRootEditPart;
>import org.eclipse.gef.editparts.ZoomManager;
>import org.eclipse.gef.palette.PaletteRoot;
>import org.eclipse.gef.requests.CreationFactory;
>import org.eclipse.gef.requests.SimpleFactory;
>import org.eclipse.gef.ui.actions.ActionRegistry;
>import org.eclipse.gef.ui.actions.ZoomInAction;
>import org.eclipse.gef.ui.actions.ZoomOutAction;
>import org.eclipse.gef.ui.palette.PaletteViewer;
>import org.eclipse.gef.ui.palette.PaletteViewerProvider;
>import org.eclipse.gef.ui.parts.ContentOutlinePage;
>import org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette;
>import org.eclipse.gef.ui.parts.GraphicalViewerKeyHandler;
>import org.eclipse.gef.ui.parts.ScrollingGraphicalViewer;
>import org.eclipse.gef.ui.parts.TreeViewer;
>
>import org.eclipse.gef.examples.shapes.model.ShapesDiagram;
>import org.eclipse.gef.examples.shapes.parts.ShapesEditPartFactory;
>import org.eclipse.gef.examples.shapes.parts.ShapesTreeEditPartFactory;
>
>/**
> * A graphical editor with flyout palette that can edit .shapes files. The
> * binding between the .shapes file extension and this editor is done in
> * plugin.xml
> * 
> * @author Elias Volanakis
> */
>public class ShapesEditor extends GraphicalEditorWithFlyoutPalette {
>
>	/** This is the root of the editor's model. */
>	private ShapesDiagram diagram;
>	/** Palette component, holding the tools and shapes. */
>	private static PaletteRoot PALETTE_MODEL;
>
>	/** Create a new ShapesEditor instance. This is called by the Workspace. */
>	public ShapesEditor() {
>		setEditDomain(new DefaultEditDomain(this));
>	}
>
>	/**
>	 * Configure the graphical viewer before it receives contents.
>	 * <p>
>	 * This is the place to choose an appropriate RootEditPart and
>	 * EditPartFactory for your editor. The RootEditPart determines the behavior
>	 * of the editor's "work-area". For example, GEF includes zoomable and
>	 * scrollable root edit parts. The EditPartFactory maps model elements to
>	 * edit parts (controllers).
>	 * </p>
>	 * 
>	 * @see org.eclipse.gef.ui.parts.GraphicalEditor#configureGraphicalViewer()
>	 */
>	protected void configureGraphicalViewer() {
>		super.configureGraphicalViewer();
>		ScrollingGraphicalViewer viewer = (ScrollingGraphicalViewer) getGraphicalViewer();
>
>		ScalableFreeformRootEditPart root = new ScalableFreeformRootEditPart();
>
>		List zoomLevels = new ArrayList(3);
>		zoomLevels.add(ZoomManager.FIT_ALL);
>		zoomLevels.add(ZoomManager.FIT_WIDTH);
>		zoomLevels.add(ZoomManager.FIT_HEIGHT);
>		root.getZoomManager().setZoomLevelContributions(zoomLevels);
>
>		IAction zoomIn = new ZoomInAction(root.getZoomManager());
>		IAction zoomOut = new ZoomOutAction(root.getZoomManager());
>		getActionRegistry().registerAction(zoomIn);
>		getActionRegistry().registerAction(zoomOut);
>		getSite().getKeyBindingService().registerAction(zoomIn);
>		getSite().getKeyBindingService().registerAction(zoomOut);
>
>		viewer.setRootEditPart(root);
>
>		viewer.setEditPartFactory(new ShapesEditPartFactory());
>		viewer.setRootEditPart(new ScalableFreeformRootEditPart());
>		viewer.setKeyHandler(new GraphicalViewerKeyHandler(viewer));
>
>		// configure the context menu provider
>		ContextMenuProvider cmProvider = new ShapesEditorContextMenuProvider(
>				viewer, getActionRegistry());
>		viewer.setContextMenu(cmProvider);
>		getSite().registerContextMenu(cmProvider, viewer);
>	}
>
>	/*
>	 * (non-Javadoc)
>	 * 
>	 * @see
>	 * org.eclipse.gef.ui.parts.GraphicalEditor#commandStackChanged(java.util
>	 * .EventObject)
>	 */
>	public void commandStackChanged(EventObject event) {
>		firePropertyChange(IEditorPart.PROP_DIRTY);
>		super.commandStackChanged(event);
>	}
>
>	private void createOutputStream(OutputStream os) throws IOException {
>		ObjectOutputStream oos = new ObjectOutputStream(os);
>		oos.writeObject(getModel());
>		oos.close();
>	}
>
>	/*
>	 * (non-Javadoc)
>	 * 
>	 * @see org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette#
>	 * createPaletteViewerProvider()
>	 */
>	protected PaletteViewerProvider createPaletteViewerProvider() {
>		return new PaletteViewerProvider(getEditDomain()) {
>			protected void configurePaletteViewer(PaletteViewer viewer) {
>				super.configurePaletteViewer(viewer);
>				// create a drag source listener for this palette viewer
>				// together with an appropriate transfer drop target listener,
>				// this will enable
>				// model element creation by dragging a
>				// CombinatedTemplateCreationEntries
>				// from the palette into the editor
>				// @see ShapesEditor#createTransferDropTargetListener()
>				viewer.addDragSourceListener(new TemplateTransferDragSourceListener(
>						viewer));
>			}
>		};
>	}
>
>	/**
>	 * Create a transfer drop target listener. When using a
>	 * CombinedTemplateCreationEntry tool in the palette, this will enable model
>	 * element creation by dragging from the palette.
>	 * 
>	 * @see #createPaletteViewerProvider()
>	 */
>	private TransferDropTargetListener createTransferDropTargetListener() {
>		return new TemplateTransferDropTargetListener(getGraphicalViewer()) {
>			protected CreationFactory getFactory(Object template) {
>				return new SimpleFactory((Class) template);
>			}
>		};
>	}
>
>	/*
>	 * (non-Javadoc)
>	 * 
>	 * @see
>	 * org.eclipse.ui.ISaveablePart#doSave(org.eclipse.core.runtime.IProgressMonitor
>	 * )
>	 */
>	public void doSave(IProgressMonitor monitor) {
>		ByteArrayOutputStream out = new ByteArrayOutputStream();
>		try {
>			createOutputStream(out);
>			IFile file = ((IFileEditorInput) getEditorInput()).getFile();
>			file.setContents(new ByteArrayInputStream(out.toByteArray()), true, // keep
>																				// saving,
>																				// even
>																				// if
>																				// IFile
>																				// is
>																				// out
>																				// of
>																				// sync
>																				// with
>																				// the
>																				// Workspace
>					false, // dont keep history
>					monitor); // progress monitor
>			getCommandStack().markSaveLocation();
>		} catch (CoreException ce) {
>			ce.printStackTrace();
>		} catch (IOException ioe) {
>			ioe.printStackTrace();
>		}
>	}
>
>	/*
>	 * (non-Javadoc)
>	 * 
>	 * @see org.eclipse.ui.ISaveablePart#doSaveAs()
>	 */
>	public void doSaveAs() {
>		// Show a SaveAs dialog
>		Shell shell = getSite().getWorkbenchWindow().getShell();
>		SaveAsDialog dialog = new SaveAsDialog(shell);
>		dialog.setOriginalFile(((IFileEditorInput) getEditorInput()).getFile());
>		dialog.open();
>
>		IPath path = dialog.getResult();
>		if (path != null) {
>			// try to save the editor's contents under a different file name
>			final IFile file = ResourcesPlugin.getWorkspace().getRoot()
>					.getFile(path);
>			try {
>				new ProgressMonitorDialog(shell).run(false, // don't fork
>						false, // not cancelable
>						new WorkspaceModifyOperation() { // run this operation
>							public void execute(final IProgressMonitor monitor) {
>								try {
>									ByteArrayOutputStream out = new ByteArrayOutputStream();
>									createOutputStream(out);
>									file.create(
>											new ByteArrayInputStream(out
>													.toByteArray()), // contents
>											true, // keep saving, even if IFile
>													// is out of sync with the
>													// Workspace
>											monitor); // progress monitor
>								} catch (CoreException ce) {
>									ce.printStackTrace();
>								} catch (IOException ioe) {
>									ioe.printStackTrace();
>								}
>							}
>						});
>				// set input to the new file
>				setInput(new FileEditorInput(file));
>				getCommandStack().markSaveLocation();
>			} catch (InterruptedException ie) {
>				// should not happen, since the monitor dialog is not cancelable
>				ie.printStackTrace();
>			} catch (InvocationTargetException ite) {
>				ite.printStackTrace();
>			}
>		}
>	}
>
>	public Object getAdapter(Class type) {
>		if (type == IContentOutlinePage.class)
>			return new ShapesOutlinePage(new TreeViewer());
>		if (type == ZoomManager.class)
>			return getGraphicalViewer().getProperty(
>					ZoomManager.class.toString());
>
>		return super.getAdapter(type);
>	}
>
>	ShapesDiagram getModel() {
>		return diagram;
>	}
>
>	/*
>	 * (non-Javadoc)
>	 * 
>	 * @see
>	 * org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette#getPaletteRoot
>	 * ()
>	 */
>	protected PaletteRoot getPaletteRoot() {
>		if (PALETTE_MODEL == null)
>			PALETTE_MODEL = ShapesEditorPaletteFactory.createPalette();
>		return PALETTE_MODEL;
>	}
>
>	private void handleLoadException(Exception e) {
>		System.err.println("** Load failed. Using default model. **");
>		e.printStackTrace();
>		diagram = new ShapesDiagram();
>	}
>
>	/**
>	 * Set up the editor's inital content (after creation).
>	 * 
>	 * @see org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette#initializeGraphicalViewer()
>	 */
>	protected void initializeGraphicalViewer() {
>		super.initializeGraphicalViewer();
>		GraphicalViewer viewer = getGraphicalViewer();
>		viewer.setContents(getModel()); // set the contents of this editor
>
>		// listen for dropped parts
>		viewer.addDropTargetListener(createTransferDropTargetListener());
>	}
>
>	/*
>	 * (non-Javadoc)
>	 * 
>	 * @see org.eclipse.ui.ISaveablePart#isSaveAsAllowed()
>	 */
>	public boolean isSaveAsAllowed() {
>		return true;
>	}
>
>	/*
>	 * (non-Javadoc)
>	 * 
>	 * @see org.eclipse.ui.part.EditorPart#setInput(org.eclipse.ui.IEditorInput)
>	 */
>	protected void setInput(IEditorInput input) {
>		super.setInput(input);
>		try {
>			IFile file = ((IFileEditorInput) input).getFile();
>			ObjectInputStream in = new ObjectInputStream(file.getContents());
>			diagram = (ShapesDiagram) in.readObject();
>			in.close();
>			setPartName(file.getName());
>		} catch (IOException e) {
>			handleLoadException(e);
>		} catch (CoreException e) {
>			handleLoadException(e);
>		} catch (ClassNotFoundException e) {
>			handleLoadException(e);
>		}
>	}
>
>	/**
>	 * Creates an outline pagebook for this editor.
>	 */
>	public class ShapesOutlinePage extends ContentOutlinePage {
>		/**
>		 * Create a new outline page for the shapes editor.
>		 * 
>		 * @param viewer
>		 *            a viewer (TreeViewer instance) used for this outline page
>		 * @throws IllegalArgumentException
>		 *             if editor is null
>		 */
>		public ShapesOutlinePage(EditPartViewer viewer) {
>			super(viewer);
>		}
>
>		/*
>		 * (non-Javadoc)
>		 * 
>		 * @see
>		 * org.eclipse.ui.part.IPage#createControl(org.eclipse.swt.widgets.Composite
>		 * )
>		 */
>		public void createControl(Composite parent) {
>			// create outline viewer page
>			getViewer().createControl(parent);
>			// configure outline viewer
>			getViewer().setEditDomain(getEditDomain());
>			getViewer().setEditPartFactory(new ShapesTreeEditPartFactory());
>			// configure & add context menu to viewer
>			ContextMenuProvider cmProvider = new ShapesEditorContextMenuProvider(
>					getViewer(), getActionRegistry());
>			getViewer().setContextMenu(cmProvider);
>			getSite().registerContextMenu(
>					"org.eclipse.gef.examples.shapes.outline.contextmenu",
>					cmProvider, getSite().getSelectionProvider());
>			// hook outline viewer
>			getSelectionSynchronizer().addViewer(getViewer());
>			// initialize outline viewer with model
>			getViewer().setContents(getModel());
>			// show outline viewer
>		}
>
>		/*
>		 * (non-Javadoc)
>		 * 
>		 * @see org.eclipse.ui.part.IPage#dispose()
>		 */
>		public void dispose() {
>			// unhook outline viewer
>			getSelectionSynchronizer().removeViewer(getViewer());
>			// dispose
>			super.dispose();
>		}
>
>		public Object getAdapter(Class type) {
>			if (type == ZoomManager.class)
>				return getGraphicalViewer().getProperty(
>						ZoomManager.class.toString());
>			return null;
>		}
>
>		/*
>		 * (non-Javadoc)
>		 * 
>		 * @see org.eclipse.ui.part.IPage#getControl()
>		 */
>		public Control getControl() {
>			return getViewer().getControl();
>		}
>
>		/**
>		 * @see org.eclipse.ui.part.IPageBookViewPage#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));
>		}
>	}
>
>}

Actions: View

Attachments on bug 327891: 186907 | 186908 | 186909 | 186910 | 186939