public Map promptForAlternativeRepository(Map alternativeMap) {

		return null;

	}

    <context id="alternative_repository_dialog_context">

        <description>When the project set contains only partial repository information (not all locations are known) this dialog allows to choose a known repository location or create a new one or at last use a default.</description>

    </context>

	/**

	 * Checks whether a dialog prompting for an addition repository location is

	 * required.

	 * 

	 * @see org.eclipse.team.internal.ccvs.ui.AlternativeRepositoryDialog

	 * @see org.eclipse.team.internal.ccvs.ui.AlternativeRepositoryTable

	 * 

	 * @param projects

	 *            an array of project to check out

	 * @param infoMap

	 *            a mapping of project to project load information

	 * @param alternativeMap

	 * 

	 * Initially it's an empty map. When <code>true</code> is returned the map

	 * will contain a mapping of a repository location (<code>ICVSRepositoryLocation</code>)

	 * from the project set to a list of suggested, known repositories locations (<code>ICVSRepositoryLocation</code>)

	 * to use. The list contains at least one element - a default location (same

	 * as in the project set). It's always on the first position in the list.

	 * It's possible that the repository location is known, but even then we

	 * still allow user to select a different location. So, the default location

	 * is optionally followed by compatible locations found. Finally, the last

	 * positions are held by the rest of known locations.

	 * 

	 * <p>

	 * The order in which items are kept in a list also reflects the way a combo

	 * box from the Alternative Repository dialog will look like.

	 * </p>

	 * <p>

	 * Structure of the list:

	 * <ul>

	 * <li>default location form the project set</li>

	 * <li>compatible locations (if found) - no particular order here</li>

	 * <li>other known locations - no particular order here neither</li>

	 * </ul>

	 * </p>

	 * @return <code>false</code> when the project set file contains all

	 *         required information or <code>true</code> when Alternative

	 *         Repository dialog needs to be displayed.

	 * 

	 * 

	 */

	private static boolean isAdditionRepositoryInformationRequired(

			IProject[] projects, final Map infoMap, Map alternativeMap) {

		List confirmedProjectsList = Arrays.asList(projects);

		if (infoMap == null)

			return false;

		Set projectSetRepositoryLocations = new HashSet();

		for (Iterator iterator = infoMap.keySet().iterator(); iterator

				.hasNext();) {

			IProject project = (IProject) iterator.next();

			if (confirmedProjectsList.contains(project)) {

				LoadInfo loadInfo = (LoadInfo) infoMap.get(project);

				projectSetRepositoryLocations.add(loadInfo.repositoryLocation);

			}

		}

		// none of projects from project sets is confirmed to overwrite

		if (projectSetRepositoryLocations.isEmpty()) {

			return false;

		}

		List knownRepositories = Arrays.asList(KnownRepositories.getInstance()

				.getRepositories());

		if (knownRepositories.isEmpty()) {

			// there are no known repositories so use repository location from

			// the project set

			for (Iterator iterator = projectSetRepositoryLocations.iterator(); iterator

					.hasNext();) {

				ICVSRepositoryLocation projectSetRepositoryLocation = (ICVSRepositoryLocation) iterator

						.next();

				ArrayList alternativeList = new ArrayList(1);

				alternativeList.add(projectSetRepositoryLocation);

				alternativeMap.put(projectSetRepositoryLocation,

						alternativeList);

			}

		} else if (!knownRepositories.containsAll(projectSetRepositoryLocations)) {

			// not all repositories from the project set are known

			for (Iterator iterator = projectSetRepositoryLocations.iterator(); iterator

					.hasNext();) {

				ICVSRepositoryLocation projectSetRepositoryLocation = (ICVSRepositoryLocation) iterator

						.next();

				ArrayList alternativeList = new ArrayList();

				for (Iterator iterator2 = knownRepositories.iterator(); iterator2

						.hasNext();) {

					ICVSRepositoryLocation knownRepositoryLocation = (ICVSRepositoryLocation) iterator2

							.next();

					if (isCompatible(knownRepositoryLocation,

							projectSetRepositoryLocation)) {

						// compatible repositories first

						alternativeList.add(0, knownRepositoryLocation);

					} else {

						alternativeList.add(knownRepositoryLocation);

					}

				}

				// Always put the repository location from the project set

				// at the beginning (as default). There is a chance that this

				// repository is known.

				alternativeList.add(0, projectSetRepositoryLocation);

				alternativeMap.put(projectSetRepositoryLocation,

						alternativeList);

			}

		} // else { all repositories are known, we don't need to prompt for

			// additional information }

		return !alternativeMap.isEmpty();

	}

	/**

	 * Same test as in org.eclipse.team.internal.ccvs.ui.CVSProjectPropertiesPage

	 * 

	 * @see org.eclipse.team.internal.ccvs.ui.CVSProjectPropertiesPage#isCompatible

	 * 

	 * @param location A location from known repositories collection

	 * @param oldLocation A location to check c

	 * @return Are given locations compatible

	 */

	public static boolean isCompatible(ICVSRepositoryLocation location, ICVSRepositoryLocation oldLocation) {

		if (!location.getHost().equals(oldLocation.getHost())) return false;

		if (!location.getRootDirectory().equals(oldLocation.getRootDirectory())) return false;

		if (location.equals(oldLocation)) return false;

		return true;

	}

	private Map promptForAdditionRepositoryInformation(Map alternativeMap) {

		IUserAuthenticator authenticator = CVSRepositoryLocation.getAuthenticator();

		return authenticator.promptForAlternativeRepository(alternativeMap);

	}

import java.util.Map;

    /**

	 * If the project set contains only partial repository information (some of

	 * location are unknown) we will display a dialog to associate each project

	 * set repository with a known repository location or create a new one or at

	 * last use the default locations.

	 * 

	 * @param alternativeMap

	 *            a map of CVS repository locations form the project set (as

	 *            keys) and a list of suggested alternative CVS repository

	 *            locations (as values)

	 * @return a map of CVS repository locations from the project set (as keys)

	 *         and confirmed CVS repository locations to be used during checkout

	 *         (as values) or <code>null</code> if the operation is to be

	 *         canceled

	 */

	public abstract Map promptForAlternativeRepository(Map alternativeMap);

    public static final String ALTERNATIVE_REPOSITORY_DIALOG = PREFIX + "alternative_repository_dialog_context"; //$NON-NLS-1$

	public static String AlternativeRepositoryWizard_title;

	public static String AlternativeRepositoryWizard_message;

	public static String AlternativeRepositoryWizard_createLocation;

	public static String AlternativeRepositoryWizard_createLocationTooltip;

	public static String AlternativeRepositoryWizard_column0;

	public static String AlternativeRepositoryWizard_column1;

	public static String AlternativeRepositoryWizard_showConnection;

	public static String AlternativeRepositoryWizardDialog_finish;

	public static String AlternativeLocationWizard_title;

	public static String AlternativeLocationWizard_heading;

	public static String AlternativeLocationWizard_description;

	public static String AlternativeLocationWizard_validationFailedText;

	public static String AlternativeLocationWizard_validationFailedTitle;

	public static String AlternativeLocationWizard_exception;

	public static String AlternativeConfigurationWizardMainPage_0;

import java.util.Map;

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.team.internal.ccvs.core.IUserAuthenticator#promptForAlternativeRepository(java.util.Map)

	 */

	public Map promptForAlternativeRepository(final Map alternativeMap) {

		final Map[] result = new Map[1];

		Display display = Display.getCurrent();

		if (display != null) {

			result[0] = openAlternativeRepositoryDialog(alternativeMap);

		} else {

			// sync exec in default thread

			Display.getDefault().syncExec(new Runnable() {

				public void run() {

					result[0] = openAlternativeRepositoryDialog(alternativeMap);

				}

			});

		}

		return result[0];

	}

	/**

	 * Opens the Alternative Repository Selection dialog.

	 * 

	 * @param alternativeMap

	 * @return a map with selected repositories to use or <code>null</code>

	 *         when canceled.

	 */

	private Map openAlternativeRepositoryDialog(Map alternativeMap) {

		AlternativeRepositoryDialog dialog = new AlternativeRepositoryDialog(

				null, alternativeMap);

		int result = dialog.open();

		return result == IDialogConstants.CANCEL_ID ? null : dialog

				.getSelected();

	}

AlternativeRepositoryWizard_title=Select alternative repository

AlternativeRepositoryWizard_message=The project set only contains partial repository information. Please use the table below to associate each project set repository with a repository location or click OK to use the default locations.

AlternativeRepositoryWizard_createLocation=Create Location

AlternativeRepositoryWizard_createLocationTooltip=Creates Location from a selected alternative repository

AlternativeRepositoryWizard_column0=Project set repository information

AlternativeRepositoryWizard_column1=Repository Location

AlternativeRepositoryWizard_showConnection=Show connection method

AlternativeRepositoryWizardDialog_finish=Create

AlternativeLocationWizard_title=Configure CVS Repository

AlternativeLocationWizard_heading=Configure an alternative CVS Repository

AlternativeLocationWizard_description=Configure an alternative CVS Repository

AlternativeLocationWizard_validationFailedText=Error validating location: "{0}"\n\nUse location anyway?

AlternativeLocationWizard_validationFailedTitle=Unable to Validate

AlternativeLocationWizard_exception=Unable to create repository location

AlternativeConfigurationWizardMainPage_0=Location already exists. Close this dialog and select the location from a combo box.

/*******************************************************************************

 * Copyright (c) 2000, 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.team.internal.ccvs.ui;

import java.util.*;

import java.util.List;

import org.eclipse.jface.viewers.*;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.TableEditor;

import org.eclipse.swt.events.ControlAdapter;

import org.eclipse.swt.events.ControlEvent;

import org.eclipse.swt.graphics.*;

import org.eclipse.swt.widgets.*;

import org.eclipse.team.internal.ccvs.core.CVSProjectSetCapability;

import org.eclipse.team.internal.ccvs.core.ICVSRepositoryLocation;

import org.eclipse.team.internal.ccvs.core.connection.CVSRepositoryLocation;

public class AlternativeRepositoryTable implements ICellModifier,

		IStructuredContentProvider, ITableLabelProvider {

	private static final class AlternativeRepositoryComparator extends

			ViewerComparator {

		public AlternativeRepositoryComparator() {

		}

		private int getCategory(Object element) {

			if (element instanceof RepositoryLocationItem) {

				return 0;

			}

			return 2;

		}

		public int compare(Viewer viewer, Object e1, Object e2) {

			final int compare = getCategory(e1) - getCategory(e2);

			if (compare != 0)

				return compare;

			return super.compare(viewer, ((Item) e1).location,

					((Item) e2).location);

		}

	}

	public abstract static class Item implements Comparable {

		public final ICVSRepositoryLocation location;

		public List alternativeList;

		public int selected;

		public Item(ICVSRepositoryLocation name, List alternative) {

			this.location = name;

			this.alternativeList = alternative;

			this.selected = 0;

		}

		/*

		 * (non-Javadoc)

		 * 

		 * @see java.lang.Comparable#compareTo(java.lang.Object)

		 */

		public int compareTo(Object o) {

			return location.getLocation(false).compareTo(

					((Item) o).location.getLocation(false));

		}

	}

	public static class RepositoryLocationItem extends Item {

		public RepositoryLocationItem(

				ICVSRepositoryLocation projectSetRepositoryLocation,

				List suggestedRepositoryLocations) {

			super(projectSetRepositoryLocation, suggestedRepositoryLocations);

		}

	}

	protected static final String ITEM = "item"; //$NON-NLS-1$

	protected static final String PROPERTY_ALTERNATIVE_LIST = "alternativeList"; //$NON-NLS-1$

	private TableViewer fTableViewer;

	private CellEditor[] cellEditors;

	private TextCellEditor dummyAlternativeRepositoryEditor;

	private Table table;

	/**

	 * List of <code>AlternativeRepositoryTable.RepositoryLocationItem</code>

	 * used as an input to the table.

	 */

	private List fAlternatives;

	/**

	 * Indicates whether a connection method should be displayed in the first

	 * column - project set information.

	 */

	private boolean fShowConnectionMethod;

	private boolean fNoDuplicateRepositoryLocationFound;

	public AlternativeRepositoryTable(Map alternativesMap) {

		fAlternatives = new ArrayList();

		Set checkSet = new HashSet();

		for (Iterator iterator = alternativesMap.entrySet().iterator(); iterator

				.hasNext();) {

			Map.Entry entry = (Map.Entry) iterator.next();

			fAlternatives

					.add(new AlternativeRepositoryTable.RepositoryLocationItem(

							(ICVSRepositoryLocation) entry.getKey(),

							(List) entry.getValue()));

			fNoDuplicateRepositoryLocationFound = checkSet

					.add(excludeConnectionMethod((ICVSRepositoryLocation) entry

							.getKey()));

		}

		fShowConnectionMethod = !fNoDuplicateRepositoryLocationFound;

		// we won't need it anymore

		checkSet = null;

	}

	public Composite createControl(final Composite composite) {

		/**

		 * Create a table.

		 */

		table = new Table(composite, SWT.V_SCROLL | SWT.BORDER | SWT.MULTI

				| SWT.FULL_SELECTION);

		// table.setLayoutData(SWTUtils.createHVFillGridData());

		table.setLinesVisible(true);

		table.setHeaderVisible(true);

		table.addListener(SWT.MeasureItem, new Listener() {

			public void handleEvent(Event event) {

				// int clientWidth = table.getClientArea().width;

				event.height = event.gc.getFontMetrics().getHeight() + 5;

				// event.width = clientWidth * 2;

			}

		});

		/**

		 * The 'Project Set repository location' column

		 */

		final TableColumn projectSetRepositoryColumn = new TableColumn(table,

				SWT.NONE, 0);

		projectSetRepositoryColumn

				.setText(CVSUIMessages.AlternativeRepositoryWizard_column0);

		/**

		 * The 'Alternative repository locations' column

		 */

		final TableColumn alternativeRepositoryColums = new TableColumn(table,

				SWT.NONE, 1);

		alternativeRepositoryColums

				.setText(CVSUIMessages.AlternativeRepositoryWizard_column1);

		composite.addControlListener(new ControlAdapter() {

			public void controlResized(ControlEvent e) {

				Rectangle area = composite.getClientArea();

				Point size = table.computeSize(SWT.DEFAULT, SWT.DEFAULT);

				ScrollBar vBar = table.getVerticalBar();

				int width = area.width - table.computeTrim(0, 0, 0, 0).width

						- vBar.getSize().x;

				if (size.y > area.height + table.getHeaderHeight()) {

					// Subtract the scrollbar width from the total column width

					// if a vertical scrollbar will be required

					Point vBarSize = vBar.getSize();

					width -= vBarSize.x;

				}

				Point oldSize = table.getSize();

				if (oldSize.x > area.width) {

					// table is getting smaller so make the columns

					// smaller first and then resize the table to

					// match the client area width

					projectSetRepositoryColumn.setWidth(width / 2);

					alternativeRepositoryColums.setWidth(width

							- projectSetRepositoryColumn.getWidth());

					table.setSize(area.width, area.height);

				} else {

					// table is getting bigger so make the table

					// bigger first and then make the columns wider

					// to match the client area width

					table.setSize(area.width, area.height);

					projectSetRepositoryColumn.setWidth(width / 2);

					alternativeRepositoryColums.setWidth(width

							- projectSetRepositoryColumn.getWidth());

				}

			}

		});

		/**

		 * Create a viewer for the table.

		 */

		fTableViewer = new TableViewer(table);

		fTableViewer.setContentProvider(this);

		fTableViewer.setLabelProvider(this);

		fTableViewer.setComparator(new AlternativeRepositoryComparator());

		/**

		 * Add a cell editor in the 'Alternative repository locations' column

		 */

		new TableEditor(table);

		cellEditors = new CellEditor[2];

		cellEditors[0] = null;

		// to enable cell editing, create a dummy cell editor

		cellEditors[1] = dummyAlternativeRepositoryEditor = new TextCellEditor(

				table, SWT.READ_ONLY);

		fTableViewer.setCellEditors(cellEditors);

		fTableViewer.setColumnProperties(new String[] { ITEM,

				PROPERTY_ALTERNATIVE_LIST });

		fTableViewer.setCellModifier(this);

		fTableViewer.setInput(fAlternatives);

		return table;

	}

	public Object getValue(Object element, String property) {

		final Item item = (Item) element;

		if (PROPERTY_ALTERNATIVE_LIST.equals(property)) {

			return new Integer(item.selected);

		}

		return null;

	}

	public boolean canModify(Object element, String property) {

		// set the correct cell editor for this element

		cellEditors[1] = getCellEditor(element);

		// only allow modification for editable elements

		return PROPERTY_ALTERNATIVE_LIST.equals(property);

	}

	private CellEditor getCellEditor(Object element) {

		if (element instanceof RepositoryLocationItem) {

			// create combo-box list of alternative repositories

			List alternativeList = ((RepositoryLocationItem) element).alternativeList;

			String[] alternativeNames = new String[alternativeList.size()];

			int i = 0;

			for (Iterator iterator = alternativeList.iterator(); iterator

					.hasNext();) {

				CVSRepositoryLocation repo = (CVSRepositoryLocation) iterator

						.next();

				alternativeNames[i++] = repo.getLocation();

			}

			return new ComboBoxCellEditor(table, alternativeNames,

					SWT.READ_ONLY);

		}

		return dummyAlternativeRepositoryEditor;

	}

	public void modify(Object element, String property, Object value) {

		final IStructuredSelection selection = (IStructuredSelection) fTableViewer

				.getSelection();

		final Item item = (Item) selection.getFirstElement();

		if (item == null)

			return;

		final int comboIndex = ((Integer) value).intValue();

		if (PROPERTY_ALTERNATIVE_LIST.equals(property)) {

			item.selected = comboIndex;

		}

		fTableViewer.refresh(item);

	}

	public Image getColumnImage(Object element, int columnIndex) {

		return null;

	}

	public String getColumnText(Object element, int columnIndex) {

		final Item item = (Item) element;

		switch (columnIndex) {

		case 0:

			return fShowConnectionMethod ? item.location.getLocation(false)

					: excludeConnectionMethod(item.location);

		case 1:

			return ((CVSRepositoryLocation) item.alternativeList

					.get(item.selected)).getLocation();

		default:

			return null;

		}

	}

	public void addListener(ILabelProviderListener listener) {

	}

	public void dispose() {

	}

	public boolean isLabelProperty(Object element, String property) {

		return false;

	}

	public void removeListener(ILabelProviderListener listener) {

	}

	public Object[] getElements(Object inputElement) {

		return ((Collection) inputElement).toArray();

	}

	public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {

	}

	public IStructuredSelection getSelection() {

		return (IStructuredSelection) fTableViewer.getSelection();

	}

	public TableViewer getViewer() {

		return fTableViewer;

	}

	/**

	 * @return a selected (in a combo box) alternative repository location for

	 *         the first selected element

	 */

	public CVSRepositoryLocation getSelectedAlternativeRepository() {

		RepositoryLocationItem firstElement = (RepositoryLocationItem) getSelection()

				.getFirstElement();

		return (CVSRepositoryLocation) firstElement.alternativeList

				.get(firstElement.selected);

	}

	public void addAlternativeRepositoryToSelection(

			ICVSRepositoryLocation location) {

		// add newly created repository location to all selected elements

		for (Iterator iterator = getSelection().iterator(); iterator.hasNext();) {

			RepositoryLocationItem selectedItem = (RepositoryLocationItem) iterator

					.next();

			selectedItem.alternativeList.add(0, location);

			selectedItem.selected = 0;

			// fTableViewer.refresh(selectedItem);

		}

		// add newly created repository location to not-selected elements

		// new location must be compatible with the one from the project set

		for (int i = 0; i < fTableViewer.getTable().getItemCount(); i++) {

			Object element = fTableViewer.getElementAt(i);

			if (!getSelection().toList().contains(element)) {

				RepositoryLocationItem locationItem = (RepositoryLocationItem) element;

				if (CVSProjectSetCapability.isCompatible(location,

						locationItem.location)) {

					locationItem.alternativeList.add(location);

				}

			}

		}

		// update labels because of the first loop - first item changed

		fTableViewer.refresh(true);

	}

	/**

	 * @return A map with repository location from the project set as a key and

	 *         selected repository location from a combo box as value.

	 */

	public Map getSelected() {

		Map map = new HashMap();

		for (Iterator iterator = fAlternatives.iterator(); iterator.hasNext();) {

			AlternativeRepositoryTable.RepositoryLocationItem rli = (AlternativeRepositoryTable.RepositoryLocationItem) iterator

					.next();

			map.put(rli.location, rli.alternativeList.get(rli.selected));

		}

		return map;

	}

	public void setShowConnectionMethod(boolean show) {

		fShowConnectionMethod = show;

		fTableViewer.refresh(true);

	}

	private String excludeConnectionMethod(ICVSRepositoryLocation location) {

		String user = location.getUsername();

		String host = location.getHost();

		int port = location.getPort();

		String root = location.getRootDirectory();

		return (user != null && !user.equals("") ? (user + CVSRepositoryLocation.HOST_SEPARATOR) //$NON-NLS-1$

				: "") + //$NON-NLS-1$ 

				host

				+ CVSRepositoryLocation.COLON

				+ ((port == CVSRepositoryLocation.USE_DEFAULT_PORT) ? "" : (new Integer(port).toString())) + //$NON-NLS-1$ 

				root;

	}

	public boolean noDuplicateRepositoryLocationFound() {

		return fNoDuplicateRepositoryLocationFound;

	}

}

/*******************************************************************************

 * Copyright (c) 2007 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.team.internal.ccvs.ui;

import java.util.Map;

import java.util.Properties;

import org.eclipse.jface.dialogs.*;

import org.eclipse.jface.dialogs.Dialog;

import org.eclipse.jface.viewers.*;

import org.eclipse.jface.wizard.IWizard;

import org.eclipse.jface.wizard.WizardDialog;

import org.eclipse.swt.SWT;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.*;

import org.eclipse.team.internal.ccvs.core.ICVSRepositoryLocation;

import org.eclipse.team.internal.ccvs.core.connection.CVSRepositoryLocation;

import org.eclipse.team.internal.ccvs.ui.wizards.AlternativeLocationWizard;

import org.eclipse.ui.PlatformUI;

public class AlternativeRepositoryDialog extends TitleAreaDialog {

	private Image dlgTitleImage;

	private AlternativeRepositoryTable fAlternativeRepositoryTable;

	/**

	 * Creates a new AlternativeRepositoryDialog.

	 * 

	 * @param parentShell

	 *            the parent shell

	 * @param alternativesMap

	 *            Map with a repository location (ICVSRepositoryLocation) from

	 *            the Team Project Set as a key and list of alternatives found

	 *            (also ICVSRepositoryLocation) as a value.

	 * @param message

	 *            a message to display to the user

	 */

	public AlternativeRepositoryDialog(Shell parentShell, Map alternativesMap) {

		super(parentShell);

		setShellStyle(getShellStyle() | SWT.RESIZE);

		fAlternativeRepositoryTable = new AlternativeRepositoryTable(

				alternativesMap);

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.jface.dialogs.TitleAreaDialog#createContents(org.eclipse.swt.widgets.Composite)

	 */

	protected Control createContents(Composite parent) {

		Control contents = super.createContents(parent);

		setTitle(CVSUIMessages.AlternativeRepositoryWizard_title);

		setMessage(CVSUIMessages.AlternativeRepositoryWizard_message);

		dlgTitleImage = CVSUIPlugin.getPlugin().getImageDescriptor(

				ICVSUIConstants.IMG_WIZBAN_NEW_LOCATION).createImage();

		setTitleImage(dlgTitleImage);

		return contents;

	}

	public boolean close() {

		if (dlgTitleImage != null) {

			dlgTitleImage.dispose();

		}

		return super.close();

	}

	/*

	 * (non-Javadoc) Method declared in Window.

	 */

	protected void configureShell(Shell shell) {

		super.configureShell(shell);

		shell.setText(CVSUIMessages.AlternativeRepositoryWizard_title);

		// set F1 help

		PlatformUI.getWorkbench().getHelpSystem().setHelp(shell,

				IHelpContextIds.ALTERNATIVE_REPOSITORY_DIALOG);

	}

	/**

	 * @see Dialog#createDialogArea

	 */

	protected Control createDialogArea(Composite parent) {

		initializeDialogUnits(parent);

		final Composite composite = new Composite(parent, SWT.NONE);

		composite.setLayout(new GridLayout(2, false));

		// TODO: help

		GridData childData = new GridData(GridData.FILL_BOTH);

		composite.setLayoutData(childData);

		Composite table = fAlternativeRepositoryTable.createControl(composite);

		GridData gridData = new GridData(GridData.VERTICAL_ALIGN_FILL);

		gridData.horizontalSpan = 2;

		gridData.horizontalAlignment = GridData.FILL;

		gridData.grabExcessHorizontalSpace = true;

		gridData.grabExcessVerticalSpace = true;

		table.setLayoutData(gridData);

		final Button showMethodButton = new Button(composite, SWT.CHECK);

		showMethodButton

				.setText(CVSUIMessages.AlternativeRepositoryWizard_showConnection);

		showMethodButton.addListener(SWT.Selection, new Listener() {

			public void handleEvent(Event event) {

				fAlternativeRepositoryTable

						.setShowConnectionMethod(showMethodButton

								.getSelection());

			}

		});

		showMethodButton.setEnabled(fAlternativeRepositoryTable

				.noDuplicateRepositoryLocationFound());

		showMethodButton.setSelection(!fAlternativeRepositoryTable

				.noDuplicateRepositoryLocationFound());

		showMethodButton.setLayoutData(new GridData(

				GridData.HORIZONTAL_ALIGN_BEGINNING));

		final Button createLocationButton = new Button(composite, SWT.PUSH);

		createLocationButton

				.setText(CVSUIMessages.AlternativeRepositoryWizard_createLocation);

		createLocationButton

				.setToolTipText(CVSUIMessages.AlternativeRepositoryWizard_createLocationTooltip);

		createLocationButton.addListener(SWT.Selection, new Listener() {

			public void handleEvent(Event event) {

				CVSRepositoryLocation selectedAlternativeRepository = fAlternativeRepositoryTable

						.getSelectedAlternativeRepository();

				Properties properties = new Properties();

				properties

						.put(

								"connection", selectedAlternativeRepository.getMethod().getName()); //$NON-NLS-1$

				properties.put(

						"user", selectedAlternativeRepository.getUsername()); //$NON-NLS-1$

				// TODO: retrieve password (if available) and use it to prime

				// the field

				// properties.put("password", ""); //$NON-NLS-1$

				properties.put("host", selectedAlternativeRepository.getHost()); //$NON-NLS-1$

				int port = selectedAlternativeRepository.getPort();

				if (port != ICVSRepositoryLocation.USE_DEFAULT_PORT)

					properties.put("port", String.valueOf(port)); //$NON-NLS-1$

				properties

						.put(

								"root", selectedAlternativeRepository.getRootDirectory()); //$NON-NLS-1$

				AlternativeLocationWizard wizard = new AlternativeLocationWizard(

						properties);

				wizard.setSwitchPerspectives(false);

				WizardDialog dialog = new AlternativeRepositoryWizardDialog(

						getShell(), wizard);

				dialog.open();

				ICVSRepositoryLocation location = wizard.getLocation();

				if (location != null)

					fAlternativeRepositoryTable

							.addAlternativeRepositoryToSelection(location);

			}

		});

		createLocationButton.setEnabled(fAlternativeRepositoryTable

				.getSelection().getFirstElement() != null);

		createLocationButton.setLayoutData(new GridData(

				GridData.HORIZONTAL_ALIGN_END));

		fAlternativeRepositoryTable.getViewer().addSelectionChangedListener(

				new ISelectionChangedListener() {

					public void selectionChanged(SelectionChangedEvent event) {

						IStructuredSelection sel = (IStructuredSelection) event

								.getSelection();

						Object firstElement = sel.getFirstElement();

						createLocationButton.setEnabled(firstElement != null);

					}

				});

		return composite;

	}

	public Map getSelected() {

		return fAlternativeRepositoryTable.getSelected();

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.jface.dialogs.Dialog#getDialogBoundsSettings()

	 */

	protected IDialogSettings getDialogBoundsSettings() {

		String sectionName = getClass().getName() + "_dialogBounds"; //$NON-NLS-1$

		IDialogSettings settings = CVSUIPlugin.getPlugin().getDialogSettings();

		IDialogSettings section = settings.getSection(sectionName);

		if (section == null)

			section = settings.addNewSection(sectionName);

		return section;

	}

	/*

	 * @see org.eclipse.jface.dialogs.Dialog#getDialogBoundsStrategy()

	 * @since 3.2

	 */

	protected int getDialogBoundsStrategy() {

		return DIALOG_PERSISTLOCATION | DIALOG_PERSISTSIZE;

	}

	/**

	 * This class is made only to change Wizard's default "Finish" button label

	 * to "Create".

	 */

	private class AlternativeRepositoryWizardDialog extends WizardDialog {

		public AlternativeRepositoryWizardDialog(Shell parentShell,

				IWizard newWizard) {

			super(parentShell, newWizard);

		}

		protected Button createButton(Composite parent, int id, String label,

				boolean defaultButton) {

			if (id == IDialogConstants.FINISH_ID)

				label = CVSUIMessages.AlternativeRepositoryWizardDialog_finish;

			return super.createButton(parent, id, label, defaultButton);

		}

	}

}

/*******************************************************************************

 * Copyright (c) 2007 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.team.internal.ccvs.ui.wizards;

import java.lang.reflect.InvocationTargetException;

import java.util.Properties;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.operation.IRunnableWithProgress;

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.osgi.util.NLS;

import org.eclipse.team.core.TeamException;

import org.eclipse.team.internal.ccvs.core.CVSException;

import org.eclipse.team.internal.ccvs.core.ICVSRepositoryLocation;

import org.eclipse.team.internal.ccvs.core.util.KnownRepositories;

import org.eclipse.team.internal.ccvs.ui.*;

public class AlternativeLocationWizard extends NewLocationWizard {

	private ICVSRepositoryLocation location;

	public boolean performFinish() {

		final ICVSRepositoryLocation[] location = new ICVSRepositoryLocation[] { null };

		boolean useLocation = true;

		try {

			// Create a handle to a repository location

			location[0] = mainPage.getLocation();

			// Add the location quitely so we can validate

			location[0] = KnownRepositories.getInstance().addRepository(location[0], false /* don't tell anybody */);

			if (mainPage.getValidate()) {

				try {

					getContainer().run(true, true, new IRunnableWithProgress() {

						public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {

							try {

								location[0].validateConnection(monitor);

							} catch (TeamException e) {

								throw new InvocationTargetException(e);

							}

						}

					});

				} catch (InterruptedException e) {

					// Cancelled by user. Fall through to dispose of location

				} catch (InvocationTargetException e) {

					Throwable t = e.getTargetException();

					if (t instanceof TeamException) {

						throw (TeamException)t;

					} else if (t instanceof Exception) {

						throw CVSException.wrapException((Exception)t);

					} else {

						throw CVSException.wrapException(e);

					}

				}

			} 

		} catch (TeamException e) {

			if (location[0] == null) {

				// Exception creating the root, we cannot continue

				CVSUIPlugin.openError(getContainer().getShell(), CVSUIMessages.AlternativeLocationWizard_exception, null, e); 

				return false;

			} else {

				// Exception validating. We can continue if the user wishes.

				IStatus error = e.getStatus();

				if (error.isMultiStatus() && error.getChildren().length == 1) {

					error = error.getChildren()[0];

				}

				if (error.isMultiStatus()) {

					CVSUIPlugin.openError(getContainer().getShell(), CVSUIMessages.AlternativeLocationWizard_validationFailedTitle, null, e); 

				} else {

					useLocation = MessageDialog.openQuestion(getContainer().getShell(),

						CVSUIMessages.AlternativeLocationWizard_validationFailedTitle, 

						NLS.bind(CVSUIMessages.AlternativeLocationWizard_validationFailedText, (new Object[] {error.getMessage()}))); 

				}

			}

		}

		if (useLocation) {

			KnownRepositories.getInstance().addRepository(location[0], true /* let the world know */);

		} else {

			KnownRepositories.getInstance().disposeRepository(location[0]);

		}

		this.location = useLocation ? location[0] : null;

		return useLocation;

	}

	public AlternativeLocationWizard(Properties initialProperties) {

		super(initialProperties);

	}

	/**

	 * Creates the wizard pages

	 */

	public void addPages() {

		mainPage = new AlternativeConfigurationWizardMainPage("repositoryPage1", CVSUIMessages.AlternativeLocationWizard_heading, CVSUIPlugin.getPlugin().getImageDescriptor(ICVSUIConstants.IMG_WIZBAN_NEW_LOCATION)); //$NON-NLS-1$ 

		if (properties != null) {

			mainPage.setProperties(properties);

		}

		mainPage.setShowValidate(true);

		mainPage.setDescription(CVSUIMessages.AlternativeLocationWizard_description); 

		mainPage.setDialogSettings(getDialogSettings());

		addPage(mainPage);

	}

	public ICVSRepositoryLocation getLocation() {

		return location;

	}

	/**

	 * Wizard page for entering information about a CVS repository location used

	 * while working with Alternative Repository dialog.

	 * 

	 * <p>

	 * Validation works slightly different. When user wants to create a

	 * location, which already exists he/she will be informed that the location

	 * can be obtained from a combo-box.

	 * </p>

	 * 

	 * TODO: enable to create existing location, instead of displaying an error

	 * close the dialog and select the entry with that location in the combo box

	 */

	private class AlternativeConfigurationWizardMainPage extends

			ConfigurationWizardMainPage {

		public AlternativeConfigurationWizardMainPage(String pageName,

				String title, ImageDescriptor titleImage) {

			super(pageName, title, titleImage);

		}

		/*

		 * (non-Javadoc)

		 * 

		 * @see org.eclipse.team.internal.ccvs.ui.wizards.ConfigurationWizardMainPage#validateFields()

		 */

		protected void validateFields() {

			super.validateFields();

			if (!isPageComplete()

					&& getErrorMessage() != null

					&& getErrorMessage().equals(

							CVSUIMessages.ConfigurationWizardMainPage_0)) {

				// add an information that the location already exists and can

				// be selected from a combo box

				setErrorMessage(CVSUIMessages.AlternativeConfigurationWizardMainPage_0);

			}

		}

	}

}