Java tutorial
/******************************************************************************* * Copyright (c) 2005 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 *******************************************************************************/ package org.eclipse.bpel.common.ui.editmodel; import java.util.ArrayList; import java.util.Arrays; import java.util.EventObject; import java.util.HashSet; import java.util.List; import java.util.Set; import org.eclipse.bpel.common.ui.CommonUIPlugin; import org.eclipse.bpel.common.ui.Messages; import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.core.runtime.IStatus; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.gef.commands.Command; import org.eclipse.gef.commands.CommandStack; import org.eclipse.gef.commands.CommandStackListener; import org.eclipse.gef.commands.CompoundCommand; import org.eclipse.jface.dialogs.IDialogConstants; import org.eclipse.jface.dialogs.MessageDialog; import org.eclipse.osgi.util.NLS; import org.eclipse.swt.widgets.Shell; import org.eclipse.ui.IWorkbenchWindow; /** * Implements the CommandStack API, adds extra notifications, * supports validateEdit and update the resource's dirty state. * * WDG: TODO: the GEF CommandStack has been extended with extra notifications. * However, how are we supposed to use it since everything is still private? */ public class EditModelCommandStack extends CommandStack { protected int saveLocation = 0; protected int fCurrentLocation = 0; protected Set<Resource> dirtyUntilSave = new HashSet<Resource>(); protected List<Context> fContexts = new ArrayList<Context>(30); /** * Brand new shiny EditModelCommandStack. */ public EditModelCommandStack() { super(); } /** * @see org.eclipse.gef.commands.CommandStack#getUndoCommand() */ @Override public Command getUndoCommand() { if (fCurrentLocation < 1) { return null; } return fContexts.get(fCurrentLocation - 1).fCommand; } /** * @see org.eclipse.gef.commands.CommandStack#canUndo() */ @Override public boolean canUndo() { Command c = getUndoCommand(); return (c != null) && c.canUndo(); } /** * @see org.eclipse.gef.commands.CommandStack#getRedoCommand() */ @Override public Command getRedoCommand() { if (fCurrentLocation >= fContexts.size()) return null; return fContexts.get(fCurrentLocation).fCommand; } /** * @see org.eclipse.gef.commands.CommandStack#canRedo() */ @Override public boolean canRedo() { return (getRedoCommand() != null); } /** * @see org.eclipse.gef.commands.CommandStack#execute(org.eclipse.gef.commands.Command) */ @Override public void execute(Command command) { SharedCommandStackChangedEvent event = notifyListeners(SharedCommandStackListener.EVENT_START_EXECUTE); if (!event.doit) return; if (getUndoCommand() instanceof PlaceHolderCommand) { // This should never happen because the EditModelCommandFramework should // remove the placeholder during the notifyListeners() call above. throw new IllegalStateException(); } if (command == null) return; if (!validateEdit(command)) return; if (!command.canExecute()) return; drop(fCurrentLocation, fContexts.size()); // Paranoia check if (getUndoCommand() instanceof PlaceHolderCommand) { // This should never happen because the EditModelCommandFramework should // remove the placeholder during the notifyListeners() call above. throw new IllegalStateException(); } command.execute(); if (getUndoCommand() instanceof PlaceHolderCommand) { // This should never happen because the EditModelCommandFramework should // remove the placeholder during the notifyListeners() call above. throw new IllegalStateException(); } int limit = getUndoLimit(); if (limit > 0) while (fCurrentLocation >= limit) { if (saveLocation == 0) saveLocation = -1; drop(0); notifyListeners(SharedCommandStackListener.EVENT_DROP_LAST_UNDO_STACK_ENTRY); } if (getUndoCommand() instanceof PlaceHolderCommand) { // This should never happen because the EditModelCommandFramework should // remove the placeholder during the notifyListeners() call above. throw new IllegalStateException(); } Resource[] resources = getModifiedResources(command); if ((resources.length > 0) || (command instanceof PlaceHolderCommand)) { Context c = new Context(command, resources); fContexts.add(c); fCurrentLocation = fContexts.size(); // mark resources as dirty/clean as appropriate. c.setModifiedFlags(true); //System.out.println("execute - markModified. currentLocation="+currentLocation+", saveLocation="+saveLocation); } notifyListeners(SharedCommandStackListener.EVENT_FINISH_EXECUTE); } /* * call VCM validateEdit; * open the dialog to ask the user if he/she wants to procede * in case the file is readonly; * return true if the command should be executed otherwise returns false; */ protected boolean validateEdit(Command command) { Resource[] resources = getResources(command); if (resources.length == 0) return true; boolean disposeShell = false; Shell shell; IWorkbenchWindow win = CommonUIPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow(); if (win != null) { shell = win.getShell(); } else { disposeShell = true; shell = new Shell(); } try { IFile[] files = new IFile[resources.length]; StringBuffer filesString = new StringBuffer(); for (int i = 0; i < resources.length; i++) { Resource resource = resources[i]; files[i] = EditModel.getIFileForURI(resource.getURI()); filesString.append(files[i].getName()); if (i < resources.length - 1) filesString.append(", "); //$NON-NLS-1$ } IStatus stat = ResourcesPlugin.getWorkspace().validateEdit(files, shell); if (stat.getSeverity() == IStatus.CANCEL) { return false; } else if (!stat.isOK()) { String[] buttons = { IDialogConstants.OK_LABEL }; // String msg; if (files.length == 1) msg = NLS.bind(Messages.EditModelCommandStack_validateEdit_message0, (new String[] { filesString.toString(), stat.getMessage() })); else msg = NLS.bind(Messages.EditModelCommandStack_validateEdit_message1, (new String[] { filesString.toString(), stat.getMessage() })); MessageDialog dialog = new MessageDialog(shell, Messages.EditModelCommandStack_validateEdit_title, null, // accept the default windowing system icon msg, MessageDialog.WARNING, buttons, 0); dialog.open(); return false; } } finally { if (disposeShell) shell.dispose(); } return true; } /** * @see org.eclipse.gef.commands.CommandStack#dispose() */ @Override public void dispose() { drop(0, fContexts.size()); } /** * @see org.eclipse.gef.commands.CommandStack#flush() */ @Override public void flush() { SharedCommandStackChangedEvent event = notifyListeners(SharedCommandStackListener.EVENT_START_FLUSH); if (!event.doit) return; drop(0, fContexts.size()); fContexts.clear(); saveLocation = -1; fCurrentLocation = 0; // TODO: should we mark all resources as clean? notifyListeners(SharedCommandStackListener.EVENT_FINISH_FLUSH); } /** * @see org.eclipse.gef.commands.CommandStack#getCommands() */ @Override public Object[] getCommands() { Object[] commands = new Object[fContexts.size()]; for (int i = 0; i < fContexts.size(); i++) { commands[i] = fContexts.get(i).fCommand; } return commands; } /** * @see org.eclipse.gef.commands.CommandStack#isDirty() */ @Override public boolean isDirty() { //System.out.println("isDirty: C="+currentLocation+" S="+saveLocation+" dus="+dirtyUntilSave.size()); return (fCurrentLocation != saveLocation) || !dirtyUntilSave.isEmpty(); } /** * @see org.eclipse.gef.commands.CommandStack#markSaveLocation() */ @Override public void markSaveLocation() { // // mark all the resources we know about as clean! // for (int i = 0; i<contexts.size(); i++) { // Context c = (Context)contexts.get(i); // c.setModifiedFlags(false); // } // // that includes ones that fell off the bottom of the undo stack. // for (Iterator it = dirtyUntilSave.iterator(); it.hasNext(); ) { // setResourceModified((Resource)it.next(), false); // } dirtyUntilSave.clear(); saveLocation = fCurrentLocation; notifyListeners(SharedCommandStackListener.EVENT_MARK_SAVED); } /** * @see org.eclipse.gef.commands.CommandStack#undo() */ @Override public void undo() { SharedCommandStackChangedEvent event = notifyListeners(SharedCommandStackListener.EVENT_START_UNDO); if (!event.doit) return; if (!canUndo()) return; Context c = fContexts.get(fCurrentLocation - 1); c.fCommand.undo(); fCurrentLocation--; // mark resources as dirty/clean as appropriate. if (fCurrentLocation < saveLocation) { // moving away from save location --> resources can only become dirty c.setModifiedFlags(true); // System.out.println("undo - markModified. currentLocation="+currentLocation+", saveLocation="+saveLocation); } else { // moving towards save location --> resources can only become clean updateModifiedFlags(); } notifyListeners(); notifyListeners(SharedCommandStackListener.EVENT_FINISH_UNDO); } /** * @see org.eclipse.gef.commands.CommandStack#redo() */ @Override public void redo() { SharedCommandStackChangedEvent event = notifyListeners(SharedCommandStackListener.EVENT_START_REDO); if (!event.doit) return; if (!canRedo()) return; Context c = fContexts.get(fCurrentLocation); c.fCommand.redo(); fCurrentLocation++; // mark resources as dirty/clean as appropriate. if (fCurrentLocation > saveLocation) { // moving away from save location --> resources can only become dirty c.setModifiedFlags(true); //System.out.println("redo - markModified. currentLocation="+currentLocation+", saveLocation="+saveLocation); } else { // moving towards save location --> resources can only become clean updateModifiedFlags(); } if (getUndoCommand() instanceof PlaceHolderCommand) { // This should never happen throw new IllegalStateException(); } notifyListeners(); notifyListeners(SharedCommandStackListener.EVENT_FINISH_REDO); } /** * Sends notification to all {@link CommandStackListener}s. */ protected SharedCommandStackChangedEvent notifyListeners(int property) { SharedCommandStackChangedEvent event = new SharedCommandStackChangedEvent(this); event.property = property; for (Object next : listeners) { CommandStackListener csl = (CommandStackListener) next; csl.commandStackChanged(event); } return event; } /* * Helper to remove a command from any point in the stack. */ protected void drop(int pos) { //System.out.println(" (drop "+pos+") C="+currentLocation+" S="+saveLocation); if ((pos < 0) || pos >= fContexts.size()) { throw new IllegalArgumentException(); } Context c = fContexts.get(pos); int a = Math.min(saveLocation, fCurrentLocation); int b = Math.max(saveLocation, fCurrentLocation); if ((a <= pos) && (pos < b)) { // we're dropping something between current and save point. dirtyUntilSave.addAll(Arrays.asList(c.fResources)); //System.out.println("dus = "+dirtyUntilSave); } c.fCommand.dispose(); fContexts.remove(pos); if (fCurrentLocation > pos) { fCurrentLocation--; } if (saveLocation > pos) { saveLocation--; } } /* * Helper to remove a range of commands from anywhere in the stack. */ protected void drop(int from, int to) { if (to < from) { int a = to; to = from; from = a; } //System.out.println("drop: "+to+".."+from); while (to > from) { drop(from); to--; } } /* * Helper to mark a resource as clean or dirty (mostly for ease of debugging) */ protected static void setResourceModified(Resource r, boolean modified) { if (r.isModified() != modified) { //System.out.println("> "+modified+" : "+r); r.setModified(modified); } } /* * Helper to calculate which resources should be marked as dirty */ protected void updateModifiedFlags() { //System.out.println("calculateModifiedState()"); Set<Resource> cleanResources = new HashSet<Resource>(); // for starters, treat everything as clean for (Context c : fContexts) { cleanResources.addAll(Arrays.asList(c.fResources)); } // mark things that fell off the bottom of the undo stack as dirty for (Resource resource : dirtyUntilSave) { cleanResources.remove(resource); setResourceModified(resource, true); } // mark things modified between saveLocation and currentLocation as dirty int a = Math.min(fCurrentLocation, saveLocation); int b = Math.max(fCurrentLocation, saveLocation); for (int i = Math.max(a, 0); i < b; i++) { Context c = fContexts.get(i); cleanResources.removeAll(Arrays.asList(c.fResources)); c.setModifiedFlags(true); } // mark anything we still consider clean as clean for (Resource resource : cleanResources) { setResourceModified(resource, false); } } /** * SharedCommandStackListener * */ public static interface SharedCommandStackListener extends CommandStackListener { public static final int EVENT_START_EXECUTE = 1; public static final int EVENT_FINISH_EXECUTE = 2; public static final int EVENT_START_UNDO = 3; public static final int EVENT_FINISH_UNDO = 4; public static final int EVENT_START_REDO = 5; public static final int EVENT_FINISH_REDO = 6; public static final int EVENT_START_FLUSH = 7; public static final int EVENT_FINISH_FLUSH = 8; public static final int EVENT_START_MARK_SAVED = 9; public static final int EVENT_FINISH_MARK_SAVED = 10; public static final int EVENT_DROP_LAST_UNDO_STACK_ENTRY = 11; public static final int EVENT_MARK_SAVED = 12; } public static class SharedCommandStackChangedEvent extends EventObject { int property; public boolean doit = true; SharedCommandStackChangedEvent(Object source) { super(source); } public EditModelCommandStack getStack() { return (EditModelCommandStack) getSource(); } public int getProperty() { return property; } } protected static Resource[] EMPTY_RESOURCE_ARRAY = new Resource[0]; // TODO: should this be in a utility class? Can it be made extensible? public static Resource[] getResources(Command command) { if (command instanceof IEditModelCommand) { return ((IEditModelCommand) command).getResources(); } if (command instanceof CompoundCommand) { CompoundCommand ccmd = (CompoundCommand) command; Set<Resource> set = new HashSet<Resource>(); for (Object n : ccmd.getChildren()) { for (Resource r : getResources((Command) n)) { set.add(r); } } if (set.isEmpty()) { return EMPTY_RESOURCE_ARRAY; } return set.toArray(EMPTY_RESOURCE_ARRAY); } throw new IllegalArgumentException(); } // TODO: should this be in a utility class? Can it be made extensible? public static Resource[] getModifiedResources(Command command) { if (command instanceof IEditModelCommand) { return ((IEditModelCommand) command).getModifiedResources(); } if (command instanceof CompoundCommand) { CompoundCommand ccmd = (CompoundCommand) command; Set<Resource> set = new HashSet<Resource>(); for (Object n : ccmd.getChildren()) { for (Resource r : getModifiedResources((Command) n)) { set.add(r); } } if (set.isEmpty()) { return EMPTY_RESOURCE_ARRAY; } return set.toArray(EMPTY_RESOURCE_ARRAY); } throw new IllegalArgumentException(); } protected static class Context { public Command fCommand; public Resource[] fResources; public Context(Command command, Resource[] resources) { this.fCommand = command; this.fResources = resources; } public void setModifiedFlags(boolean value) { for (Resource r : fResources) { setResourceModified(r, value); } } } }