org.eclipse.gmf.runtime.diagram.ui/src/org/eclipse/gmf/runtime/diagram/ui/commands/DeferredLayoutCommand.java - gmf-runtime/org.eclipse.gmf-runtime - Git at Google

 /******************************************************************************
  * Copyright (c) 2002, 2010 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
  *    Nicolas Rouquette (NASA) - Fix for Bug 260812.
  ****************************************************************************/

 package org.eclipse.gmf.runtime.diagram.ui.commands;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import org.eclipse.core.commands.ExecutionException;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.draw2d.IFigure;
 import org.eclipse.emf.transaction.RunnableWithResult;
 import org.eclipse.emf.transaction.TransactionalEditingDomain;
 import org.eclipse.emf.workspace.util.WorkspaceSynchronizer;
 import org.eclipse.gef.commands.Command;
 import org.eclipse.gef.commands.CompoundCommand;
 import org.eclipse.gmf.runtime.common.core.command.CommandResult;
 import org.eclipse.gmf.runtime.common.core.command.ICommand;
 import org.eclipse.gmf.runtime.diagram.ui.actions.ActionIds;
 import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart;
 import org.eclipse.gmf.runtime.diagram.ui.l10n.DiagramUIMessages;
 import org.eclipse.gmf.runtime.diagram.ui.requests.ArrangeRequest;
 import org.eclipse.gmf.runtime.diagram.ui.services.layout.LayoutType;
 import org.eclipse.gmf.runtime.diagram.ui.util.EditPartUtil;
 import org.eclipse.gmf.runtime.emf.commands.core.command.AbstractTransactionalCommand;
 import org.eclipse.gmf.runtime.emf.commands.core.command.CompositeTransactionalCommand;
 import org.eclipse.gmf.runtime.notation.View;

 /**
  * This command is used to arrange editparts on a diagram, when only the view
  * adapters are available at the time of creating the command. It is necessary
  * to have the editparts when creating a layout command so this command defers
  * the creation of the layout command until execution time at which point it can
  * get the editparts from the editpart registry using the view adapters.
  *
  * @author cmahoney
  */
 public class DeferredLayoutCommand
 	extends AbstractTransactionalCommand {

 	/** the type of layout to be performed */
 	protected String layoutType;

 	/** the IAdaptables from which an View can be retrieved */
 	protected List viewAdapters;

 	/** the diagram editpart used to get the editpart registry */
 	protected IGraphicalEditPart containerEP;

 	/**
 	 * Constructor for <code>DeferredLayoutCommand</code>.
 	 *
      * @param editingDomain
      *            the editing domain through which model changes are made
 	 * @param viewAdapters
 	 *            the IAdaptables from which an IView can be retrieved
 	 * @param containerEP
 	 *            the container editpart used to get the editpart registry
 	 */
 	public DeferredLayoutCommand(TransactionalEditingDomain editingDomain, List viewAdapters,
 		IGraphicalEditPart containerEP) {
 		this(editingDomain, viewAdapters, containerEP, LayoutType.DEFAULT);
 	}

 	/**
 	 * Constructor for <code>DeferredLayoutCommand</code>.
 	 *
      * @param editingDomain
      *            the editing domain through which model changes are made
 	 * @param viewAdapters
 	 *            the IAdaptables from which an IView can be retrieved
 	 * @param containerEP
 	 *            the container editpart used to get the editpart registry
 	 * @param commandLayoutType
 	 *            the type of layout to be performed
 	 */
 	public DeferredLayoutCommand(TransactionalEditingDomain editingDomain, List viewAdapters,
 		IGraphicalEditPart containerEP, String commandLayoutType) {

 		super(editingDomain,
             DiagramUIMessages.Command_Deferred_Layout, null);
 		if (commandLayoutType != null) {
 			this.layoutType = commandLayoutType;
 		} else {
 			this.layoutType = LayoutType.DEFAULT;
 		}
 		this.viewAdapters = viewAdapters;
 		this.containerEP = containerEP;
 	}

 	public List getAffectedFiles() {
 		if (containerEP != null) {
 			View view = (View)containerEP.getModel();
 			if (view != null) {
 				IFile f = WorkspaceSynchronizer.getFile(view.eResource());
 				return f != null ? Collections.singletonList(f)
 					: Collections.EMPTY_LIST;
 			}
 		}
 		return super.getAffectedFiles();
 	}

 	/**
 	 * Executes a layout command with all the editparts for the view adapters.
 	 *
 	 */
 	protected CommandResult doExecuteWithResult(
             IProgressMonitor progressMonitor, IAdaptable info)
         throws ExecutionException {

 		RunnableWithResult refreshRunnable = new RunnableWithResult() {

 			private IStatus status;
             private Object result;

             public Object getResult() {
                 return result;
             }

             public void setStatus(IStatus status) {
                 this.status = status;
             }

             public IStatus getStatus() {
                 return status;
             }

 			public void run() {
 				containerEP.refresh();

 				// The layout command requires that the figure world is updated.
 				getContainerFigure().invalidate();
 				getContainerFigure().validate();

 				List editParts = new ArrayList(viewAdapters.size());
 				Map epRegistry = containerEP.getRoot().getViewer()
 					.getEditPartRegistry();
 				for (Iterator iter = viewAdapters.iterator(); iter.hasNext();) {
 					IAdaptable ad = (IAdaptable) iter.next();
 					View view = (View) ad.getAdapter(View.class);
 					Object ep = epRegistry.get(view);
 					if (ep != null) {
 						editParts.add(ep);
 					}
 				}

 				if (editParts.isEmpty()) {
 					result = editParts;
 					return;
 				}

 				Set layoutSet = new HashSet(editParts.size());
 				layoutSet.addAll(editParts);

 				// refresh source and target connections of any shapes in the container not being considered for layout
 				Iterator iter = containerEP.getChildren().iterator();
 				while (iter.hasNext()) {
 					Object obj = iter.next();
 					if (!layoutSet.contains(obj) && obj instanceof IGraphicalEditPart) {
 						IGraphicalEditPart ep = (IGraphicalEditPart)obj;
 						ep.refresh();
 					}
 				}

 				result = editParts;
 			}
 		};

 		EditPartUtil.synchronizeRunnableToMainThread(containerEP, refreshRunnable);
 		List editParts = (List)refreshRunnable.getResult();
 		if (editParts == null || editParts.isEmpty()) {
 			return CommandResult.newOKCommandResult();
 		}

 		//	add an arrange command, to layout the related shapes
 		ArrangeRequest request = new ArrangeRequest(
 			ActionIds.ACTION_ARRANGE_SELECTION, layoutType);
 		request.setPartsToArrange(editParts);
 		Command layoutCmd = containerEP.getCommand(request);

 		if (layoutCmd != null && layoutCmd.canExecute()) {
             ICommand optimizedCommand = optimizeCommand(layoutCmd);
 			optimizedCommand.execute(progressMonitor, info);
             optimizedCommand = null;
 		}
 		return CommandResult.newOKCommandResult();
 	}

     private ICommand optimizeCommand(Command command) {
         if (command instanceof ICommandProxy) {
             ICommand icmd = ((ICommandProxy)command).getICommand();
             return icmd;
         } else {
             if(command instanceof CompoundCommand) {
                 CompositeTransactionalCommand transactionalCommand = new CompositeTransactionalCommand(getEditingDomain(), command.getLabel());
                 transactionalCommand.setTransactionNestingEnabled(false);

                 CompoundCommand compound = (CompoundCommand)command;
                 Iterator commandIter = compound.getCommands().iterator();
                 while(commandIter.hasNext()) {
                     Command iteredCommand = (Command)commandIter.next();
                     ICommand iteredICommand = optimizeCommand(iteredCommand);
                     transactionalCommand.compose(iteredICommand);
                 }
                 return transactionalCommand;
             }
             if (null != command)
             	return new CommandProxy(command);
             else
             	return null;
         }
     }
 	protected void cleanup() {
 		containerEP = null;//for garbage collection
 		viewAdapters = null;
 		super.cleanup();
 	}

 	/**
 	 * gets the container edit part's figure
 	 * @return the container figure
 	 */
 	protected IFigure getContainerFigure() {
 		return containerEP.getFigure();
 	}

 	/**
 	 * gets the container edit part
 	 * @return the container edit part
 	 */
 	protected IGraphicalEditPart getContainerEP() {
 		return containerEP;
 	}

 	/**
 	 * gets a list of <code>IAdaptable</code> that can adapt to <code>
 	 * View</code>
 	 * @return view adapters
 	 */
 	protected List getViewAdapters() {
 		return viewAdapters;
 	}

 	@Override
 	public boolean canExecute() {
 		return super.canExecute() && containerEP != null;
 	}
 }
	/******************************************************************************
	* Copyright (c) 2002, 2010 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
	* Nicolas Rouquette (NASA) - Fix for Bug 260812.
	****************************************************************************/

	package org.eclipse.gmf.runtime.diagram.ui.commands;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	import org.eclipse.core.commands.ExecutionException;
	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.runtime.IAdaptable;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.draw2d.IFigure;
	import org.eclipse.emf.transaction.RunnableWithResult;
	import org.eclipse.emf.transaction.TransactionalEditingDomain;
	import org.eclipse.emf.workspace.util.WorkspaceSynchronizer;
	import org.eclipse.gef.commands.Command;
	import org.eclipse.gef.commands.CompoundCommand;
	import org.eclipse.gmf.runtime.common.core.command.CommandResult;
	import org.eclipse.gmf.runtime.common.core.command.ICommand;
	import org.eclipse.gmf.runtime.diagram.ui.actions.ActionIds;
	import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart;
	import org.eclipse.gmf.runtime.diagram.ui.l10n.DiagramUIMessages;
	import org.eclipse.gmf.runtime.diagram.ui.requests.ArrangeRequest;
	import org.eclipse.gmf.runtime.diagram.ui.services.layout.LayoutType;
	import org.eclipse.gmf.runtime.diagram.ui.util.EditPartUtil;
	import org.eclipse.gmf.runtime.emf.commands.core.command.AbstractTransactionalCommand;
	import org.eclipse.gmf.runtime.emf.commands.core.command.CompositeTransactionalCommand;
	import org.eclipse.gmf.runtime.notation.View;

	/**
	* This command is used to arrange editparts on a diagram, when only the view
	* adapters are available at the time of creating the command. It is necessary
	* to have the editparts when creating a layout command so this command defers
	* the creation of the layout command until execution time at which point it can
	* get the editparts from the editpart registry using the view adapters.
	*
	* @author cmahoney
	*/
	public class DeferredLayoutCommand
	extends AbstractTransactionalCommand {

	/** the type of layout to be performed */
	protected String layoutType;

	/** the IAdaptables from which an View can be retrieved */
	protected List viewAdapters;

	/** the diagram editpart used to get the editpart registry */
	protected IGraphicalEditPart containerEP;

	/**
	* Constructor for <code>DeferredLayoutCommand</code>.
	*
	* @param editingDomain
	* the editing domain through which model changes are made
	* @param viewAdapters
	* the IAdaptables from which an IView can be retrieved
	* @param containerEP
	* the container editpart used to get the editpart registry
	*/
	public DeferredLayoutCommand(TransactionalEditingDomain editingDomain, List viewAdapters,
	IGraphicalEditPart containerEP) {
	this(editingDomain, viewAdapters, containerEP, LayoutType.DEFAULT);
	}

	/**
	* Constructor for <code>DeferredLayoutCommand</code>.
	*
	* @param editingDomain
	* the editing domain through which model changes are made
	* @param viewAdapters
	* the IAdaptables from which an IView can be retrieved
	* @param containerEP
	* the container editpart used to get the editpart registry
	* @param commandLayoutType
	* the type of layout to be performed
	*/
	public DeferredLayoutCommand(TransactionalEditingDomain editingDomain, List viewAdapters,
	IGraphicalEditPart containerEP, String commandLayoutType) {

	super(editingDomain,
	DiagramUIMessages.Command_Deferred_Layout, null);
	if (commandLayoutType != null) {
	this.layoutType = commandLayoutType;
	} else {
	this.layoutType = LayoutType.DEFAULT;
	}
	this.viewAdapters = viewAdapters;
	this.containerEP = containerEP;
	}

	public List getAffectedFiles() {
	if (containerEP != null) {
	View view = (View)containerEP.getModel();
	if (view != null) {
	IFile f = WorkspaceSynchronizer.getFile(view.eResource());
	return f != null ? Collections.singletonList(f)
	: Collections.EMPTY_LIST;
	}
	}
	return super.getAffectedFiles();
	}

	/**
	* Executes a layout command with all the editparts for the view adapters.
	*
	*/
	protected CommandResult doExecuteWithResult(
	IProgressMonitor progressMonitor, IAdaptable info)
	throws ExecutionException {

	RunnableWithResult refreshRunnable = new RunnableWithResult() {

	private IStatus status;
	private Object result;

	public Object getResult() {
	return result;
	}

	public void setStatus(IStatus status) {
	this.status = status;
	}

	public IStatus getStatus() {
	return status;
	}

	public void run() {
	containerEP.refresh();

	// The layout command requires that the figure world is updated.
	getContainerFigure().invalidate();
	getContainerFigure().validate();

	List editParts = new ArrayList(viewAdapters.size());
	Map epRegistry = containerEP.getRoot().getViewer()
	.getEditPartRegistry();
	for (Iterator iter = viewAdapters.iterator(); iter.hasNext();) {
	IAdaptable ad = (IAdaptable) iter.next();
	View view = (View) ad.getAdapter(View.class);
	Object ep = epRegistry.get(view);
	if (ep != null) {
	editParts.add(ep);
	}
	}

	if (editParts.isEmpty()) {
	result = editParts;
	return;
	}

	Set layoutSet = new HashSet(editParts.size());
	layoutSet.addAll(editParts);

	// refresh source and target connections of any shapes in the container not being considered for layout
	Iterator iter = containerEP.getChildren().iterator();
	while (iter.hasNext()) {
	Object obj = iter.next();
	if (!layoutSet.contains(obj) && obj instanceof IGraphicalEditPart) {
	IGraphicalEditPart ep = (IGraphicalEditPart)obj;
	ep.refresh();
	}
	}

	result = editParts;
	}
	};

	EditPartUtil.synchronizeRunnableToMainThread(containerEP, refreshRunnable);
	List editParts = (List)refreshRunnable.getResult();
	if (editParts == null \|\| editParts.isEmpty()) {
	return CommandResult.newOKCommandResult();
	}

	// add an arrange command, to layout the related shapes
	ArrangeRequest request = new ArrangeRequest(
	ActionIds.ACTION_ARRANGE_SELECTION, layoutType);
	request.setPartsToArrange(editParts);
	Command layoutCmd = containerEP.getCommand(request);

	if (layoutCmd != null && layoutCmd.canExecute()) {
	ICommand optimizedCommand = optimizeCommand(layoutCmd);
	optimizedCommand.execute(progressMonitor, info);
	optimizedCommand = null;
	}
	return CommandResult.newOKCommandResult();
	}

	private ICommand optimizeCommand(Command command) {
	if (command instanceof ICommandProxy) {
	ICommand icmd = ((ICommandProxy)command).getICommand();
	return icmd;
	} else {
	if(command instanceof CompoundCommand) {
	CompositeTransactionalCommand transactionalCommand = new CompositeTransactionalCommand(getEditingDomain(), command.getLabel());
	transactionalCommand.setTransactionNestingEnabled(false);

	CompoundCommand compound = (CompoundCommand)command;
	Iterator commandIter = compound.getCommands().iterator();
	while(commandIter.hasNext()) {
	Command iteredCommand = (Command)commandIter.next();
	ICommand iteredICommand = optimizeCommand(iteredCommand);
	transactionalCommand.compose(iteredICommand);
	}
	return transactionalCommand;
	}
	if (null != command)
	return new CommandProxy(command);
	else
	return null;
	}
	}
	protected void cleanup() {
	containerEP = null;//for garbage collection
	viewAdapters = null;
	super.cleanup();
	}

	/**
	* gets the container edit part's figure
	* @return the container figure
	*/
	protected IFigure getContainerFigure() {
	return containerEP.getFigure();
	}

	/**
	* gets the container edit part
	* @return the container edit part
	*/
	protected IGraphicalEditPart getContainerEP() {
	return containerEP;
	}

	/**
	* gets a list of <code>IAdaptable</code> that can adapt to <code>
	* View</code>
	* @return view adapters
	*/
	protected List getViewAdapters() {
	return viewAdapters;
	}

	@Override
	public boolean canExecute() {
	return super.canExecute() && containerEP != null;
	}
	}