Initial Release

5 files changed, 700 insertions, 0 deletions

diff --git a/bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/HistoryDropAdapter.java b/bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/HistoryDropAdapter.java
new file mode 100644
index 000000000..19f1121d9
--- /dev/null
+++ b/bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/HistoryDropAdapter.java
@@ -0,0 +1,94 @@
+package org.eclipse.team.internal.ccvs.ui;
+
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.jface.viewers.StructuredViewer;
+import org.eclipse.jface.viewers.ViewerDropAdapter;
+import org.eclipse.swt.dnd.DND;
+import org.eclipse.swt.dnd.DropTargetEvent;
+import org.eclipse.swt.dnd.TransferData;
+import org.eclipse.ui.part.ResourceTransfer;
+
+public class HistoryDropAdapter extends ViewerDropAdapter {
+	HistoryView view;
+	
+	public HistoryDropAdapter(StructuredViewer viewer, HistoryView view) {
+		super(viewer);
+		this.view = view;
+	}
+	/*
+	 * Override dragOver to slam the detail to DROP_LINK, as we do not
+	 * want to really execute a DROP_MOVE, although we want to respond
+	 * to it.
+	 */
+	public void dragOver(DropTargetEvent event) {
+		if ((event.operations & DND.DROP_LINK) == DND.DROP_LINK) {
+			event.detail = DND.DROP_LINK;
+		}
+		super.dragOver(event);
+	}
+	/*
+	 * Override drop to slam the detail to DROP_LINK, as we do not
+	 * want to really execute a DROP_MOVE, although we want to respond
+	 * to it.
+	 */
+	public void drop(DropTargetEvent event) {
+		super.drop(event);
+		event.detail = DND.DROP_LINK;
+	}
+	/**
+	 * Returns a resource history for the given resource, or null
+	 * if none available.
+	 */
+	/*private IVersionHistory getHistory(IResource resource) throws CoreException {
+		ISharingManager manager = VCMPlugin.getProvider().getSharingManager();
+		if (resource.getType() == IResource.PROJECT) {
+	        ITeamStream stream = manager.getSharing(resource);
+	        if (stream != null) {
+		        return stream.getRepository().fetchProjectHistory(resource.getName(), null);
+	        }
+		} else {
+			IResourceEdition base = manager.getBaseVersion(resource);
+			if (base != null) {
+				return base.fetchVersionHistory(null);
+			}
+			IResourceEdition remote = manager.getRemoteResource(resource);
+			if (remote != null) {
+				try {
+					return remote.fetchVersionHistory(null);
+				} catch (CoreException e) {
+					//this exception means there is no remote resource
+					//so return null for the version history.
+					return null;
+				}
+			}
+		}
+		return null;
+	}*/
+	public boolean performDrop(Object data) {
+		if (data == null) return false;
+		IResource[] sources = (IResource[])data;
+		if (sources.length == 0) return false;
+		IResource resource = sources[0];
+/*		try {
+			IVersionHistory history = getHistory(resource);
+			if (history == null) {
+				MessageDialog.openInformation(getViewer().getControl().getShell(), WorkbenchVCMPlugin.getResourceString("BrowseHistoryAction.noHistoryShort"), WorkbenchVCMPlugin.getResourceString("BrowseHistoryAction.noHistoryLong"));
+				return false;
+			}
+			view.showHistory(history);
+		} catch (CoreException e) {
+			// Log this error
+			return false;
+		}*/
+		return true;
+	}
+	public boolean validateDrop(Object target, int operation, TransferData transferType) {
+		if (transferType != null && ResourceTransfer.getInstance().isSupportedType(transferType)) {
+			return true;
+		}
+		return false;
+	}
+}
+
diff --git a/bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/HistorySorter.java b/bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/HistorySorter.java
new file mode 100644
index 000000000..b2d01decd
--- /dev/null
+++ b/bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/HistorySorter.java
@@ -0,0 +1,105 @@
+package org.eclipse.team.internal.ccvs.ui;
+
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved.
+ */
+
+import org.eclipse.jface.viewers.*;
+import org.eclipse.team.ccvs.core.ILogEntry;
+
+import java.text.Collator;
import java.util.Date;
+
+/**
+ * This sorter is used by the HistoryView
+ */
+class HistorySorter extends ViewerSorter {
+	private boolean reversed = false;
+	private int columnNumber;
+	
+	private VersionCollator versionCollator = new VersionCollator();
+	
+	// column headings:	"Revision" "Tags" "Date" "Author" "Comment"
+	private int[][] SORT_ORDERS_BY_COLUMN = {
+		{0, 4, 1, 2, 3},	/* version */ 
+		{1, 0, 2, 3, 4},	/* tags */
+		{1, 4, 0, 2, 3},	/* date */
+		{2, 4, 1, 3, 0},	/* author */
+		{3, 4, 1, 2, 0}	/* comment */
+	};
+	
+	/**
+	 * The constructor.
+	 */
+	public HistorySorter(int columnNumber) {
+		this.columnNumber = columnNumber;
+	}
+	/**
+	 * Compares two log entries, sorting first by the main column of this sorter,
+	 * then by subsequent columns, depending on the column sort order.
+	 */
+	public int compare(Viewer viewer, Object o1, Object o2) {
+		ILogEntry e1 = (ILogEntry)o1;
+		ILogEntry e2 = (ILogEntry)o2;
+		int[] columnSortOrder = SORT_ORDERS_BY_COLUMN[columnNumber];
+		int result = 0;
+		for (int i = 0; i < columnSortOrder.length; ++i) {
+			result = compareColumnValue(columnSortOrder[i], e1, e2);
+			if (result != 0)
+				break;
+		}
+		if (reversed)
+			result = -result;
+		return result;
+	}
+	/**
+	 * Compares two markers, based only on the value of the specified column.
+	 */
+	int compareColumnValue(int columnNumber, ILogEntry e1, ILogEntry e2) {
+		switch (columnNumber) {
+			case 0: /* version */
+				return versionCollator.compare(e1.getRevision(), e2.getRevision());
+			case 1: /* tags */
+				String[] tags1 = e1.getTags();
+				String[] tags2 = e2.getTags();
+				if (tags2.length == 0) {
+					return -1;
+				}
+				if (tags1.length == 0) {
+					return 1;
+				}
+				return getCollator().compare(tags1[0], tags2[0]);
+			case 2: /* date  */
+				// To do: use dates instead of strings
+				String date1 = e1.getDate();
+				String date2 = e2.getDate();
+				//return date1.compareTo(date2);
+				return getCollator().compare(date1, date2);
+			case 3: /* author */
+				return getCollator().compare(e1.getAuthor(), e2.getAuthor());
+			case 4: /* comment */
+				return getCollator().compare(e1.getComment(), e2.getComment());
+			default:
+				return 0;
+		}
+	}
+	/**
+	 * Returns the number of the column by which this is sorting.
+	 */
+	public int getColumnNumber() {
+		return columnNumber;
+	}
+	/**
+	 * Returns true for descending, or false
+	 * for ascending sorting order.
+	 */
+	public boolean isReversed() {
+		return reversed;
+	}
+	/**
+	 * Sets the sorting order.
+	 */
+	public void setReversed(boolean newReversed) {
+		reversed = newReversed;
+	}
+}
diff --git a/bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/HistoryView.java b/bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/HistoryView.java
new file mode 100644
index 000000000..8c84615cc
--- /dev/null
+++ b/bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/HistoryView.java
@@ -0,0 +1,345 @@
+package org.eclipse.team.internal.ccvs.ui;
+
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved.
+ */
+ 
+import java.text.DateFormat;
+import java.util.Date;
+import java.util.HashMap;
+
+import org.eclipse.core.resources.*;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.jface.action.*;
+import org.eclipse.jface.viewers.*;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.dnd.DND;
+import org.eclipse.swt.dnd.Transfer;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.events.SelectionListener;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.widgets.*;
+import org.eclipse.team.ccvs.core.ILogEntry;
+import org.eclipse.team.ccvs.core.IRemoteFile;
+import org.eclipse.team.core.TeamException;
+import org.eclipse.team.internal.ccvs.ui.actions.OpenRemoteFileAction;
+import org.eclipse.ui.ISelectionListener;
+import org.eclipse.ui.IWorkbenchActionConstants;
+import org.eclipse.ui.IWorkbenchPart;
+import org.eclipse.ui.PartInitException;
+import org.eclipse.ui.help.ViewContextComputer;
+import org.eclipse.ui.help.WorkbenchHelp;
+import org.eclipse.ui.internal.model.AdaptableList;
+import org.eclipse.ui.model.WorkbenchContentProvider;
+import org.eclipse.ui.part.ResourceTransfer;
+import org.eclipse.ui.part.ViewPart;
+
+/**
+ * The history view allows browsing of an array of versions of
+ * a resource.
+ */
+public class HistoryView extends ViewPart implements IMenuListener, ISelectionListener {
+	//private IVersionHistory history;
+	//private IResourceEdition currentEdition;
+	private IRemoteFile remoteFile;
+	
+	private HashMap infoMap = new HashMap(30);
+	private TableViewer viewer;
+	//private OpenRemoteFileAction openAction;
+
+	private static final int DIALOG_WIDTH = 600;
+	private static final int DIALOG_HEIGHT = 250;
+
+	//column constants
+	private static final int COL_REVISION = 0;
+	private static final int COL_TAGS = 1;
+	private static final int COL_DATE = 2;
+	private static final int COL_AUTHOR = 3;
+	private static final int COL_COMMENT = 4;
+
+	class HistoryLabelProvider extends LabelProvider implements ITableLabelProvider {
+		public Image getColumnImage(Object element, int columnIndex) {
+			return null;
+		}
+		public String getColumnText(Object element, int columnIndex) {
+			ILogEntry entry = (ILogEntry)element;
+			switch (columnIndex) {
+				case COL_REVISION:
+					return entry.getRevision();
+				case COL_TAGS:
+					String[] tags = entry.getTags();
+					StringBuffer result = new StringBuffer();
+					for (int i = 0; i < tags.length; i++) {
+						result.append(tags[i]);
+						if (i < tags.length - 1) {
+							result.append(", ");
+						}
+					}
+					return result.toString();
+				case COL_DATE:
+					return entry.getDate();
+				case COL_AUTHOR:
+					return entry.getAuthor();
+				case COL_COMMENT:
+					return entry.getComment();
+			}
+			return "";
+		}
+	}
+	
+	public static final String VIEW_ID = "org.eclipse.team.ccvs.ui.HistoryView";
+	
+	/**
+	 * Creates a new HistoryView.
+	 */
+	public HistoryView() {
+		super();
+	}
+	
+	/**
+	 * Adds the action contributions for this view.
+	 */
+	protected void contributeActions() {
+		//double click
+//		openAction = new OpenRemoteFileAction();
+//		viewer.getTable().addListener(SWT.MouseDoubleClick, new Listener() {
+//			public void handleEvent(Event e) {
+//				openAction.selectionChanged(null, viewer.getSelection());
+//				openAction.run(null);
+//			}
+//		});
+		
+		
+		//popup menu
+//		MenuManager menuMgr = new MenuManager();
+//		Menu menu = menuMgr.createContextMenu(viewer.getTable());
+//		menuMgr.addMenuListener(this);
+//		menuMgr.setRemoveAllWhenShown(true);
+//		viewer.getTable().setMenu(menu);
+//		getSite().registerContextMenu(menuMgr, viewer);
+	}
+	
+	/**
+	 * Creates the columns for the history table.
+	 */
+	private void createColumns(Table table, TableLayout layout) {
+		SelectionListener headerListener = getColumnListener();
+		// revision
+		TableColumn col = new TableColumn(table, SWT.NONE);
+		col.setResizable(true);
+		col.setText("Revision");
+		col.addSelectionListener(headerListener);
+		layout.addColumnData(new ColumnWeightData(10, true));
+	
+		// tags
+		col = new TableColumn(table, SWT.NONE);
+		col.setResizable(true);
+		col.setText("Tags");
+		col.addSelectionListener(headerListener);
+		layout.addColumnData(new ColumnWeightData(20, true));
+	
+		// creation date
+		col = new TableColumn(table, SWT.NONE);
+		col.setResizable(true);
+		col.setText("Date");
+		col.addSelectionListener(headerListener);
+		layout.addColumnData(new ColumnWeightData(20, true));
+	
+		// author
+		col = new TableColumn(table, SWT.NONE);
+		col.setResizable(true);
+		col.setText("Author");
+		col.addSelectionListener(headerListener);
+		layout.addColumnData(new ColumnWeightData(20, true));
+	
+		//comment
+		col = new TableColumn(table, SWT.NONE);
+		col.setResizable(true);
+		col.setText("Comment");
+		col.addSelectionListener(headerListener);
+		layout.addColumnData(new ColumnWeightData(50, true));
+	}
+	/** (Non-javadoc)
+	 * Method declared on IWorkbenchPart
+	 */
+	public void createPartControl(Composite parent) {
+		viewer = createTable(parent);
+		getSite().getPage().getWorkbenchWindow().getSelectionService().addSelectionListener(this);
+		contributeActions();
+		// set F1 help
+		//WorkbenchHelp.setHelp(viewer.getControl(), new ViewContextComputer (this, IVCMHelpContextIds.RESOURCE_HISTORY_VIEW));
+		initDragAndDrop();
+	}
+	/**
+	 * Creates the group that displays lists of the available repositories
+	 * and team streams.
+	 *
+	 * @param the parent composite to contain the group
+	 * @return the group control
+	 */
+	protected TableViewer createTable(Composite parent) {
+		Table table = new Table(parent, SWT.H_SCROLL | SWT.V_SCROLL | SWT.MULTI | SWT.FULL_SELECTION);
+		table.setHeaderVisible(true);
+		table.setLinesVisible(true);
+		GridData data = new GridData(GridData.FILL_BOTH);
+		table.setLayoutData(data);
+	
+		TableLayout layout = new TableLayout();
+		table.setLayout(layout);
+		
+		createColumns(table, layout);
+	
+		TableViewer viewer = new TableViewer(table);
+		viewer.setContentProvider(new WorkbenchContentProvider());
+		viewer.setLabelProvider(new HistoryLabelProvider());
+		return viewer;
+	}
+	public void dispose() {
+		getSite().getPage().getWorkbenchWindow().getSelectionService().removeSelectionListener(this);
+	}	
+	/**
+	 * Adds the listener that sets the sorter.
+	 */
+	private SelectionListener getColumnListener() {
+		/**
+	 	 * This class handles selections of the column headers.
+		 * Selection of the column header will cause resorting
+		 * of the shown tasks using that column's sorter.
+		 * Repeated selection of the header will toggle
+		 * sorting order (ascending versus descending).
+		 */
+		return new SelectionListener() {
+			/**
+			  * Unused - double-click on the table header will
+			  * not produce any result.
+			  */
+			public void widgetDefaultSelected(SelectionEvent e) {}
+			/**
+			 * Handles the case of user selecting the
+			 * header area.
+			 * <p>If the column has not been selected previously,
+			 * it will set the sorter of that column to be
+			 * the current tasklist sorter. Repeated
+			 * presses on the same column header will
+			 * toggle sorting order (ascending/descending).
+			 */
+			public void widgetSelected(SelectionEvent e) {
+				// column selected - need to sort
+				int column = viewer.getTable().indexOf((TableColumn) e.widget);
+				HistorySorter oldSorter = (HistorySorter) viewer.getSorter();
+				if (oldSorter != null && column == oldSorter.getColumnNumber()) {
+					oldSorter.setReversed(!oldSorter.isReversed());
+					viewer.refresh();
+				} else {
+					viewer.setSorter(new HistorySorter(column));
+				}
+			}
+		};
+	}
+	/**
+	 * Returns the table viewer contained in this view.
+	 */
+	protected TableViewer getViewer() {
+		return viewer;
+	}
+	/**
+	 * Adds drag and drop support to the history view.
+	 */
+	void initDragAndDrop() {
+		int ops = DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK;
+		Transfer[] transfers = new Transfer[] {ResourceTransfer.getInstance()};
+		viewer.addDropSupport(ops, transfers, new HistoryDropAdapter(viewer, this));
+	}
+	/**
+	 * @see IMenuListener#menuAboutToShow
+	 */
+	public void menuAboutToShow(IMenuManager manager) {
+		//file actions go first (view file)
+		manager.add(new Separator(IWorkbenchActionConstants.GROUP_FILE));
+	
+		manager.add(new Separator("additions"));
+		manager.add(new Separator("additions-end"));
+	}
+	/**
+	 * Makes the history view visible in the active perspective. If there
+	 * isn't a history view registered <code>null</code> is returned.
+	 * Otherwise the opened view part is returned.
+	 */
+	public static HistoryView openInActivePerspective() {
+		try {
+			return (HistoryView)CVSUIPlugin.getActivePage().showView(VIEW_ID);
+		} catch (PartInitException pe) {
+			return null;
+		}
+	}
+	public void selectionChanged(IWorkbenchPart part, ISelection selection) {
+		/*if (CVSUIPlugin.getDefault().getPreferenceStore().getBoolean(ICVSUIConstants.PREF_HISTORY_TRACKS_SELECTION)) {
+			if (selection == null) return;
+			if (!(selection instanceof IStructuredSelection)) return;
+			IStructuredSelection ss = (IStructuredSelection)selection;
+			if (ss.size() != 1) {
+				showHistory(null);
+				return;
+			}
+			Object first = ss.getFirstElement();
+			try {
+				IVersionHistory history = getHistory(first);
+				showHistory(history);
+			} catch (CoreException e) {
+				showHistory(null);
+			}
+		}*/
+	}
+	/** (Non-javadoc)
+	 * Method declared on IWorkbenchPart
+	 */
+	public void setFocus() {
+		if (viewer != null) {
+			Table control = viewer.getTable();
+			if (control != null && !control.isDisposed()) {
+				control.setFocus();
+			}
+		}
+	}
+	/**
+	 * Shows the given log entries in the view.
+	 */
+	public void showHistory(IRemoteFile file) {
+		this.remoteFile = file;
+		if (remoteFile == null) {
+			setTitle("Resource History");
+			viewer.setInput(new AdaptableList());
+			return;
+		}
+		ILogEntry[] entries = null;
+		try {
+			entries = file.getLogEntries(new NullProgressMonitor());
+		} catch (TeamException e) {
+			CVSUIPlugin.log(e.getStatus());
+			setTitle("Resource History");
+			viewer.setInput(new AdaptableList());
+			return;
+		}
+		if (entries.length > 0) {
+			/*if (editions[0].getType() == IResource.PROJECT) {
+				name = editions[0].getName();
+			} else {
+				name = "/" + editions[0].getProjectName() + "/" + editions[0].getProjectRelativePath().toString();
+			}*/
+			setTitle("Resource History - " + file.getName());
+		} else {
+			setTitle("Resource History");
+		}
+		viewer.setInput(new AdaptableList(entries));
+		if (viewer.getSorter() == null) {
+			// By default, reverse sort by creation date.
+			HistorySorter sorter = new HistorySorter(COL_DATE);
+			sorter.setReversed(true);
+			viewer.setSorter(sorter);
+		}
+	}
+}
diff --git a/bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/VersionCollator.java b/bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/VersionCollator.java
new file mode 100644
index 000000000..16fd627e9
--- /dev/null
+++ b/bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/VersionCollator.java
@@ -0,0 +1,62 @@
+package org.eclipse.team.internal.ccvs.ui;
+
+import java.text.Collator;
+import java.util.Vector;
+
+public class VersionCollator {
+	static final int WORD = 0;
+	static final int NUMBER = 1;
+	
+	public int compare(String version1, String version2) {
+		if (version1 == null && version2 == null) return 0;
+		if (version1 == null) return -1;
+		if (version2 == null) return 1;
+		String[] version1Segments = getStringSegments(version1);
+		String[] version2Segments = getStringSegments(version2);
+		Collator collator = Collator.getInstance();
+		for (int i = 0; i < version1Segments.length && i < version2Segments.length; i++) {
+			int oneType = isNumber(version1Segments[i]) ? NUMBER : WORD;
+			int twoType = isNumber(version2Segments[i]) ? NUMBER : WORD;
+			if (oneType != twoType) {
+				return collator.compare(version1, version2);
+			}
+			if (oneType == NUMBER) {
+				int intOne = Integer.parseInt(version1Segments[i]);
+				int intTwo = Integer.parseInt(version2Segments[i]);
+				if (intOne != intTwo) return (intOne < intTwo) ? -1 : 1;
+			} else {
+				int result = collator.compare(version1Segments[i], version2Segments[i]);
+				if (result != 0) return result;
+			}
+		}
+		if (version1Segments.length != version2Segments.length) {
+			return version1Segments.length < version2Segments.length ? -1 : 1;
+		}
+		return 0;
+	}
+	String[] getStringSegments(String string) {
+		int size = string.length();
+		if (size == 0) return new String[0];
+		StringBuffer buffer = new StringBuffer();
+		Vector vector = new Vector();
+		int current = Character.isDigit(string.charAt(0)) ? NUMBER : WORD;
+		for (int i = 0; i < size; i++) {
+			char ch = string.charAt(i);
+			int newCurrent = Character.isDigit(string.charAt(i)) ? NUMBER : WORD;
+			if (newCurrent != current) {
+				vector.addElement(buffer.toString());
+				buffer = new StringBuffer();
+				current = newCurrent;
+			}
+			buffer.append(ch);
+		}
+		vector.addElement(buffer.toString());
+		String[] result = new String[vector.size()];
+		vector.toArray(result);
+		return result;
+	}
+	boolean isNumber(String string) {
+		return Character.isDigit(string.charAt(0));
+	}
+}
+
diff --git a/bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/actions/ShowHistoryAction.java b/bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/actions/ShowHistoryAction.java
new file mode 100644
index 000000000..c138d8af8
--- /dev/null
+++ b/bundles/org.eclipse.team.cvs.ui/src/org/eclipse/team/internal/ccvs/ui/actions/ShowHistoryAction.java
@@ -0,0 +1,94 @@
+package org.eclipse.team.internal.ccvs.ui.actions;
+
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved.
+ */
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.jface.action.IAction;
+import org.eclipse.jface.operation.IRunnableWithProgress;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.team.ccvs.core.IRemoteFile;
+import org.eclipse.team.core.TeamException;
+import org.eclipse.team.internal.ccvs.ui.HistoryView;
+import org.eclipse.team.internal.ccvs.ui.Policy;
+import org.eclipse.team.ui.actions.TeamAction;
+
+public class ShowHistoryAction extends TeamAction {
+	/**
+	 * Returns the selected remote files
+	 */
+	protected IRemoteFile[] getSelectedRemoteFiles() {
+		ArrayList resources = null;
+		if (!selection.isEmpty()) {
+			resources = new ArrayList();
+			Iterator elements = ((IStructuredSelection) selection).iterator();
+			while (elements.hasNext()) {
+				Object next = elements.next();
+				if (next instanceof IRemoteFile) {
+					resources.add(next);
+					continue;
+				}
+				if (next instanceof IAdaptable) {
+					IAdaptable a = (IAdaptable) next;
+					Object adapter = a.getAdapter(IRemoteFile.class);
+					if (adapter instanceof IRemoteFile) {
+						resources.add(adapter);
+						continue;
+					}
+				}
+			}
+		}
+		if (resources != null && !resources.isEmpty()) {
+			IRemoteFile[] result = new IRemoteFile[resources.size()];
+			resources.toArray(result);
+			return result;
+		}
+		return new IRemoteFile[0];
+	}
+	/*
+	 * @see IActionDelegate#run(IAction)
+	 */
+	public void run(IAction action) {
+		run(new IRunnableWithProgress() {
+			public void run(IProgressMonitor monitor) throws InvocationTargetException {
+				IRemoteFile[] files = getSelectedRemoteFiles();
+				HistoryView view = HistoryView.openInActivePerspective();
+				if (view != null) {
+					view.showHistory(files[0]);
+				}
+			}
+		}, Policy.bind("ShowHistoryAction.showHistory"), this.PROGRESS_DIALOG);
+	}
+	/*
+	 * @see TeamAction#isEnabled()
+	 */
+	protected boolean isEnabled() throws TeamException {
+		IRemoteFile[] resources = getSelectedRemoteFiles();
+		return resources.length == 1;
+	}
+	/** (Non-javadoc)
+	 * Method declared on IActionDelegate.
+	 */
+	public void selectionChanged(IAction action, ISelection selection) {
+		if (selection instanceof IStructuredSelection) {
+			this.selection = (IStructuredSelection) selection;
+			//this action can be invoked by double-click, in which case
+			//there is no target action
+			if (action != null) {
+				try {
+					action.setEnabled(isEnabled());
+				} catch (TeamException e) {
+					action.setEnabled(false);
+				}
+			}
+		}
+	}
+}
\ No newline at end of file