update/org.eclipse.update.ui/src/org/eclipse/update/internal/ui/wizards/TargetPage.java

/*******************************************************************************
 * Copyright (c) 2000, 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.update.internal.ui.wizards;

import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ControlAdapter;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.ui.PlatformUI;
import org.eclipse.update.configuration.IConfiguredSite;
import org.eclipse.update.configuration.IInstallConfiguration;
import org.eclipse.update.configuration.IInstallConfigurationChangedListener;
import org.eclipse.update.configuration.LocalSystemInfo;
import org.eclipse.update.core.IFeature;
import org.eclipse.update.core.ISite;
import org.eclipse.update.internal.core.ConfiguredSite;
import org.eclipse.update.internal.core.UpdateCore;
import org.eclipse.update.internal.operations.UpdateUtils;
import org.eclipse.update.internal.ui.UpdateLabelProvider;
import org.eclipse.update.internal.ui.UpdateUI;
import org.eclipse.update.internal.ui.UpdateUIImages;
import org.eclipse.update.internal.ui.UpdateUIMessages;
import org.eclipse.update.internal.ui.parts.DefaultContentProvider;
import org.eclipse.update.internal.ui.parts.SWTUtil;
import org.eclipse.update.operations.IInstallFeatureOperation;

public class TargetPage extends BannerPage implements IDynamicPage {
	
	private static final int FEATURE_NAME_COLUMN = 0;
	private static final int FEATURE_VERSION_COLUMN = 1;
	private static final int FEATURE_SIZE_COLUMN = 2;
	private static final int INSTALLATION_DIRECTORY_COLUMN = 3;
	
	private float featureNameColumnProcetange = 0.25f;
	private float featureVersionColumnProcetange = 0.25f;
	private float featureSizeColumnProcetange = 0.15f;
	
	private TableViewer jobViewer;
	private IInstallConfiguration config;
	private Label requiredSpaceLabel;
	private Label availableSpaceLabel;
	private IInstallFeatureOperation[] jobs;
    //private IInstallFeatureOperation currentJob;
    private Label installLocation;
    private Button changeLocation;
    private IConfiguredSite [] addedSites;
    
    private boolean isUpdate; // whether the wizard is updating a feature or installing a new one

	class JobsContentProvider
		extends DefaultContentProvider
		implements IStructuredContentProvider {
		public Object[] getElements(Object parent) {
			return jobs;
		}
	}

	class JobsLabelProvider
		extends LabelProvider
		implements ITableLabelProvider {
			
		public Image getColumnImage(Object obj, int col) {
			
			if (col > 0) {
				return null;
			}
			
			UpdateLabelProvider provider = UpdateUI.getDefault().getLabelProvider();

			IInstallFeatureOperation job = (IInstallFeatureOperation) obj;
			ImageDescriptor base =
				job.getFeature().isPatch()
					? UpdateUIImages.DESC_EFIX_OBJ
					: UpdateUIImages.DESC_FEATURE_OBJ;
			int flags = 0;
			if (job.getTargetSite() == null)
				flags = UpdateLabelProvider.F_ERROR;
			return provider.get(base, flags);
		}

		public String getColumnText(Object obj, int col) {
			
			IFeature feature = ((IInstallFeatureOperation) obj).getFeature();
			IConfiguredSite csite =((IInstallFeatureOperation)obj).getTargetSite(); 
			ISite site = csite!=null?csite.getSite():null;
			if (col == FEATURE_NAME_COLUMN) {				
				return feature.getLabel();
			} else if (col == FEATURE_VERSION_COLUMN) {
				return feature.getVersionedIdentifier().getVersion().toString();
			} else if (col == FEATURE_SIZE_COLUMN) {
				if (site==null)
					return ""; //$NON-NLS-1$
				long requiredSpace = site.getDownloadSizeFor(feature) + site.getInstallSizeFor(feature);
				return getSizeString(requiredSpace);
			} else if (col == INSTALLATION_DIRECTORY_COLUMN) {
				if (site==null)
					return ""; //$NON-NLS-1$
				return site.getURL().getFile().toString();
			}
			return ""; //$NON-NLS-1$
		}
	}
	
	class JobViewerSorter extends ViewerSorter {
		
		
		private static final int ASCENDING = 0;

		private static final int DESCENDING = 1;

		private int column;

		private int direction;

		public void doSort(int column) {

			if (column == this.column) {
				direction = 1 - direction;
			} else {
				this.column = column;
				direction = ASCENDING;
			}
		}

		/**
		 * Compares the object for sorting
		 */
		public int compare(Viewer viewer, Object o1, Object o2) {

			int rc = 0;
			
			IFeature feature1 = ((IInstallFeatureOperation) o1).getFeature();
			IFeature feature2 = ((IInstallFeatureOperation) o2).getFeature();

			String featureName1 = feature1.getLabel();
			String featureName2 = feature2.getLabel();
			
			String featureId1 = feature1.getVersionedIdentifier().getVersion().toString();
			String featureId2 = feature2.getVersionedIdentifier().getVersion().toString();

			String installationDirectory1 = ((IInstallFeatureOperation)o1).getTargetSite().getSite().getURL().getFile().toString();
			String installationDirectory2 = ((IInstallFeatureOperation)o2).getTargetSite().getSite().getURL().getFile().toString();

			switch (column) {
			case FEATURE_NAME_COLUMN:
				rc = collator.compare(featureName1, featureName2);
				break;
			case FEATURE_VERSION_COLUMN:
				rc = collator.compare(featureId1, featureId2);
				break;
			case INSTALLATION_DIRECTORY_COLUMN:
				rc = collator.compare(installationDirectory1, installationDirectory2);
				break;
			}

			// If descending order, flip the direction
			if (direction == DESCENDING)
				rc = -rc;

			return rc;
		}
	}
	
	class ConfigListener implements IInstallConfigurationChangedListener {
		public void installSiteAdded(IConfiguredSite csite) {
			
			// set the site as target for all jobs without a target
			for (int i=0; jobs != null && i<jobs.length; i++)
				if (jobs[i].getTargetSite() == null && getSiteVisibility(csite, jobs[i])) {
					jobs[i].setTargetSite(csite);
				}

			jobViewer.refresh();
		}

		public void installSiteRemoved(IConfiguredSite csite) {
			// remove the target site for all jobs that use it
			// set the site as target for all jobs without a target
			boolean refreshJobs = false;
			for (int i=0; jobs != null && i<jobs.length; i++)
				if (jobs[i].getTargetSite() == csite) {
					jobs[i].setTargetSite(null);
					refreshJobs = true;
				}
				
			pageChanged();
			
			jobViewer.refresh();
			if (refreshJobs) {
				jobViewer.getControl().setFocus();
			}
		}
	}

	/**
	 * Constructor for ReviewPage2
	 */
	public TargetPage(IInstallConfiguration config, boolean isUpdate) {
		super("Target"); //$NON-NLS-1$
		setTitle(UpdateUIMessages.InstallWizard_TargetPage_title); 
		setDescription(UpdateUIMessages.InstallWizard_TargetPage_desc); 
		this.config = config;
		UpdateUI.getDefault().getLabelProvider().connect(this);
		this.isUpdate = isUpdate;
	}

	public void setJobs(IInstallFeatureOperation[] jobs) {
		//we need only unique features
		//using Set here allows us to get rid of a duplicate elements
		Set jobsSet = new HashSet();
		for (int i = 0; i < jobs.length; i++) {
			jobsSet.add(jobs[i]);
		}
		
		this.jobs = (IInstallFeatureOperation[]) jobsSet.toArray(new IInstallFeatureOperation[jobsSet.size()]);
	}

	public void dispose() {
		UpdateUI.getDefault().getLabelProvider().disconnect(this);
//		config.removeInstallConfigurationChangedListener(configListener);
		super.dispose();
	}

	public Control createContents(Composite parent) {
		Composite client = new Composite(parent, SWT.NULL);
		GridLayout layout = new GridLayout();
		layout.numColumns = 3;
		layout.marginWidth = layout.marginHeight = 0;
		client.setLayout(layout);
		client.setLayoutData(new GridData(GridData.FILL_BOTH));
		
		Label label = new Label(client, SWT.NULL);
		label.setText(UpdateUIMessages.InstallWizard_TargetPage_jobsLabel); 
		createJobViewer(client);

		label = new Label(client, SWT.NULL);
		label.setText(UpdateUIMessages.InstallWizard_TargetPage_location); 
        GridData gd = new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
        label.setLayoutData(gd);

		installLocation = new Label(client, SWT.NULL);
        installLocation.setText(""); //$NON-NLS-1$
        gd = new GridData(GridData.FILL_HORIZONTAL);
        installLocation.setLayoutData(gd);
        
        changeLocation = new Button(client, SWT.PUSH);
        changeLocation.setText(UpdateUIMessages.InstallWizard_TargetPage_location_change); 
        changeLocation.addSelectionListener(new SelectionAdapter() {
            public void widgetSelected(SelectionEvent e) {
                changeLocationOfFeatures();
            }

			
        });
			
		Composite status = new Composite(client, SWT.NULL);
		gd = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
		gd.horizontalSpan = 3;
		status.setLayoutData(gd);
		layout = new GridLayout();
		layout.numColumns = 2;
		status.setLayout(layout);
		label = new Label(status, SWT.NULL);
		label.setText(UpdateUIMessages.InstallWizard_TargetPage_requiredSpace); 
		requiredSpaceLabel = new Label(status, SWT.NULL);
		requiredSpaceLabel.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		label = new Label(status, SWT.NULL);
		label.setText(UpdateUIMessages.InstallWizard_TargetPage_availableSpace); 
		availableSpaceLabel = new Label(status, SWT.NULL);
		availableSpaceLabel.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

        PlatformUI.getWorkbench().getHelpSystem().setHelp(client, "org.eclipse.update.ui.MultiTargetPage2"); //$NON-NLS-1$
		
		Dialog.applyDialogFont(parent);
		
		return client;
	}

	private void createJobViewer(Composite parent) {
		
		final Table table = new Table(parent, SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER | SWT.MULTI | SWT.RESIZE | SWT.FULL_SELECTION);
		
		TableColumn featureNameColumn = new TableColumn(table, SWT.LEFT, FEATURE_NAME_COLUMN);
		featureNameColumn.setText(UpdateUIMessages.TargetPage_FeatureNameColumn); 
		featureNameColumn.setWidth(75);
		
		TableColumn featureVersionColumn = new TableColumn(table, SWT.LEFT, FEATURE_VERSION_COLUMN);
		featureVersionColumn.setText(UpdateUIMessages.TargetPage_Feature_Version); 
		featureVersionColumn.setWidth(75);
		
		TableColumn featureSizeColumn = new TableColumn(table, SWT.LEFT, FEATURE_SIZE_COLUMN);
		featureSizeColumn.setText(UpdateUIMessages.TargetPage_Feature_Size); 
		featureSizeColumn.setWidth(75);
		
		TableColumn featureLocationColumn = new TableColumn(table, SWT.LEFT, INSTALLATION_DIRECTORY_COLUMN);
		featureLocationColumn.setText(UpdateUIMessages.TargetPage_InstallationDirectoryColumn); 
		featureLocationColumn.setWidth(75);
		jobViewer = new TableViewer(table);
		
		//jobViewer = new TableViewer(parent, SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER | SWT.MULTI);
		GridData gd = new GridData(GridData.FILL_BOTH);
        gd.horizontalSpan = 3;
		gd.widthHint = 150;
		gd.heightHint = 200;
		jobViewer.getTable().setLayoutData(gd);
		jobViewer.setContentProvider(new JobsContentProvider());
		jobViewer.setLabelProvider(new JobsLabelProvider());
		jobViewer.setSorter(new JobViewerSorter());
		
		jobViewer.addDoubleClickListener(new IDoubleClickListener() {
				public void doubleClick(DoubleClickEvent event) {
					changeLocationOfFeatures();				
				}
			}
		);
		
		table.addListener(SWT.MenuDetect, new Listener() {
		      public void handleEvent(Event event) {
		    	  Menu menu = new Menu (getShell(), SWT.POP_UP);
					MenuItem item = new MenuItem (menu, SWT.PUSH);
					item.setText(UpdateUIMessages.InstallWizard_TargetPage_location_change);
					item.addListener(SWT.Selection, new Listener () {
							public void handleEvent (Event e) {
								changeLocationOfFeatures();
							}
						}
					);
					menu.setLocation (event.x, event.y);
					menu.setVisible (true);
		      }
			}
		);
		featureNameColumn.addSelectionListener(new SelectionAdapter() {
				public void widgetSelected(SelectionEvent event) {
					((JobViewerSorter) jobViewer.getSorter()).doSort(FEATURE_NAME_COLUMN);
					jobViewer.refresh();
				}
		    }
		);
		
		featureVersionColumn.addSelectionListener(new SelectionAdapter() {
		      	public void widgetSelected(SelectionEvent event) {
		      		((JobViewerSorter) jobViewer.getSorter()).doSort(FEATURE_VERSION_COLUMN);
		      		jobViewer.refresh();
		      	}
		    }
		);
		
		featureSizeColumn.addSelectionListener(new SelectionAdapter() {
		      	public void widgetSelected(SelectionEvent event) {
		      		((JobViewerSorter) jobViewer.getSorter()).doSort(FEATURE_SIZE_COLUMN);
		      		jobViewer.refresh();
		      	}
		    }
		);
		
		featureLocationColumn.addSelectionListener(new SelectionAdapter() {
		      	public void widgetSelected(SelectionEvent event) {
		      		((JobViewerSorter) jobViewer.getSorter()).doSort(INSTALLATION_DIRECTORY_COLUMN);
		      		jobViewer.refresh();
		      	}
		    }
		);
		
		table.addControlListener(new ControlAdapter() {
			public void controlResized(ControlEvent e) {


				Rectangle area = table.getClientArea();
				Point preferredSize = table.computeSize(SWT.DEFAULT, SWT.DEFAULT);

				int tableWidth = area.width - 3 * table.getBorderWidth();
				if (preferredSize.y > area.height + table.getHeaderHeight()){
					Point vBarSize = table.getVerticalBar().getSize();
					tableWidth -= vBarSize.x;
				}		
				
				TableColumn featureNameColumn = table.getColumn(FEATURE_NAME_COLUMN);
				TableColumn featureVersionColumn = table.getColumn(FEATURE_VERSION_COLUMN);
				TableColumn featureSizeColumn = table.getColumn(FEATURE_SIZE_COLUMN);
				TableColumn featureLocationColumn = table.getColumn(INSTALLATION_DIRECTORY_COLUMN);

				featureNameColumn.setWidth((int)(tableWidth * featureNameColumnProcetange));
				featureVersionColumn.setWidth((int)(tableWidth * featureVersionColumnProcetange));
				featureSizeColumn.setWidth((int)(tableWidth * featureSizeColumnProcetange));
				featureLocationColumn.setWidth(tableWidth - featureNameColumn.getWidth() - featureVersionColumn.getWidth() - featureSizeColumn.getWidth());		    	

				
				featureNameColumnProcetange = featureNameColumn.getWidth() / (float)tableWidth;
				featureVersionColumnProcetange = featureVersionColumn.getWidth() / (float)tableWidth;
				featureSizeColumnProcetange = featureSizeColumn.getWidth() / (float)tableWidth;
			}
		});


		jobViewer.addSelectionChangedListener(new ISelectionChangedListener() {
			public void selectionChanged(SelectionChangedEvent event) {
				updateStatus();

			}
		});
		
		table.setHeaderVisible(true);
	    table.setLinesVisible(true);
	}

	public void setVisible(boolean visible) {
		if (visible) {
			initializeDefaultTargetSites();
			jobViewer.setInput(jobs);
			if (jobViewer.getSelection().isEmpty() && jobs.length > 0)
				jobViewer.setSelection(new StructuredSelection(jobs[0]));
		}
		
		super.setVisible(visible);
	}

	private void verifyNotEmpty(boolean empty) {
		String errorMessage = null;
		if (empty)
			errorMessage = UpdateUIMessages.InstallWizard_TargetPage_location_empty; 
		setErrorMessage(errorMessage);
		setPageComplete(!empty);
	}


	private void updateStatus() {
		
		IStructuredSelection selectedJobs = (IStructuredSelection)jobViewer.getSelection();
		IInstallFeatureOperation selectedJob = (IInstallFeatureOperation)selectedJobs.getFirstElement();
	
		requiredSpaceLabel.setText(""); //$NON-NLS-1$
		availableSpaceLabel.setText(""); //$NON-NLS-1$
		installLocation.setText(""); //$NON-NLS-1$
		
		if (selectedJob == null) {
			return;
		}
		
		IConfiguredSite site = selectedJob.getTargetSite(); /*(IConfiguredSite) element;*/
		File file = new File(site.getSite().getURL().getFile());
		long available = -1;
		long required = -1;
		if (areAllTargetSitesSame()) {
			available = LocalSystemInfo.getFreeSpace(file);
			required = computeRequiredSizeFor(site);
			//add the download size to space required to do operation since all plugins and nonplugin data will be downloaded first
			required += computeDownloadSizeFor(site); 
			installLocation.setText(new File(selectedJob.getTargetSite().getSite().getURL().getFile()).toString());
		}		
		
		if (available == LocalSystemInfo.SIZE_UNKNOWN)
			available = -1;
		
		requiredSpaceLabel.setText(getSizeString(required));
		availableSpaceLabel.setText(getSizeString(available));
		
		
		//if the available space was retireved from the OS and the required space is greater that the available space, do not let the user continue
		if(available != LocalSystemInfo.SIZE_UNKNOWN && required > available){
			this.setPageComplete(false);
			//TODO: set error message: "...not enough space..."
		}else
			this.setPageComplete(true);
	}
	
	private boolean areAllTargetSitesSame() {
		IStructuredSelection selectedJobs = (IStructuredSelection)jobViewer.getSelection();
		Iterator iterator = selectedJobs.iterator();
		URL site = null;
		if (iterator != null) {
			while(iterator.hasNext()) {
				IInstallFeatureOperation current = (IInstallFeatureOperation) iterator.next();				
				if (site != null) {
					if (!site.equals(current.getTargetSite().getSite().getURL())) {
						return false;
					}
				} else {
					site = current.getTargetSite().getSite().getURL();
				}
			}
			return true;
		}
		return false;
	}

	private String getSizeString(long size) {
		if (size <= 0) {
			return UpdateUIMessages.InstallWizard_TargetPage_unknownSize;
		} else {
			double order = 1024.0;
			double sizeInMB = size / order;
			double sizeInGB = size / order / order;
			if ( sizeInMB < 1) {
				return NLS.bind(UpdateUIMessages.InstallWizard_TargetPage_size_KB, "" + size); //$NON-NLS-1$
			} else {
				String pattern = "#.##"; //$NON-NLS-1$
				DecimalFormat formatter = new DecimalFormat(pattern);
				if (sizeInGB < 1) {					
					return NLS.bind(UpdateUIMessages.InstallWizard_TargetPage_size_MB, formatter.format(sizeInMB));
				} else {
					return NLS.bind(UpdateUIMessages.InstallWizard_TargetPage_size_GB, formatter.format(sizeInGB));
				}
			}
		}
	}

	private long computeRequiredSizeFor(IConfiguredSite site) {
		long totalSize = 0;
		for (int i = 0; i < jobs.length; i++) {
			if (site.equals(jobs[i].getTargetSite())) {
				long jobSize = site.getSite().getInstallSizeFor(jobs[i].getFeature());
				if (jobSize == -1)
					return -1;
				totalSize += jobSize;
			}
		}
		return totalSize;
	}
	
	private long computeDownloadSizeFor(IConfiguredSite site) {
		long totalSize = 0;
		for (int i = 0; i < jobs.length; i++) {
			if (site.equals(jobs[i].getTargetSite())) {
				long jobSize = site.getSite().getDownloadSizeFor(jobs[i].getFeature());
				if (jobSize == -1)
					return -1;
				totalSize += jobSize;
			}
		}
		return totalSize;
	}

	private void pageChanged() {
		boolean empty = false;
		for (int i=0; jobs!=null && i<jobs.length; i++) {
			if (jobs[i].getTargetSite() == null) {
				empty = true;
				break;
			}
		
			IFeature feature = jobs[i].getFeature();
			if (feature.isPatch()) {
				// Patches must go together with the features
				// they are patching.
				
				// Check current jobs
				IInstallFeatureOperation patchedFeatureJob = findPatchedFeature(feature);
				if (patchedFeatureJob != null
					&& patchedFeatureJob.getTargetSite() != null
					&& !jobs[i].getTargetSite().equals(patchedFeatureJob.getTargetSite())) {
					String msg = NLS.bind(UpdateUIMessages.InstallWizard_TargetPage_patchError, (new String[] {
                    feature.getLabel(),
                    patchedFeatureJob.getFeature().getLabel()}));
					setErrorMessage(msg);
					setPageComplete(false);
					return;
				}
				// Check installed features
				IFeature patchedFeature = UpdateUtils.getPatchedFeature(feature);
				if (patchedFeature != null  
					&& !jobs[i].getTargetSite().equals(patchedFeature.getSite().getCurrentConfiguredSite())) {
					String msg = NLS.bind(UpdateUIMessages.InstallWizard_TargetPage_patchError2, (new String[] {
                    feature.getLabel(),
                    patchedFeature.getLabel(),
                    patchedFeature.getSite().getCurrentConfiguredSite().getSite().getURL().getFile()}));
					setErrorMessage(msg);
					setPageComplete(false);
					return;
				}
			}
		}
		verifyNotEmpty(empty);
	}
	
	
	private  boolean getSiteVisibility(IConfiguredSite site, IInstallFeatureOperation job) {
		// Do not allow installing into a non-updateable site
		if (!site.isUpdatable())
			return false;
		
		// If affinity site is known, only it should be shown
		IConfiguredSite affinitySite = UpdateUtils.getAffinitySite(config, job.getFeature());
		if (affinitySite != null) {
			// Must compare referenced sites because
			// configured sites themselves may come from 
			// different configurations
			return site.getSite().equals(affinitySite.getSite());
		}
		
		// Co-locate updates with the old feature
		if (job.getOldFeature() != null) {
			IConfiguredSite oldSite = UpdateUtils.getSiteWithFeature(config, job.getOldFeature().getVersionedIdentifier().getIdentifier());
			return (site == oldSite);
		}

		// Allow installing into any site that is updateable and there is no affinity specified
		return true;
	}
	
	private void initializeDefaultTargetSites() {
		
		
		IConfiguredSite mostReceantlyUsedSite = getMostReceantlyUsedSite();
		for (int i = 0; i < jobs.length; i++) {
			if (jobs[i].getTargetSite() != null)
				continue;
			
			IConfiguredSite affinitySite =	UpdateUtils.getAffinitySite(config, jobs[i].getFeature());
			if (affinitySite != null) {
				jobs[i].setTargetSite(affinitySite);
				continue;
			}

			IConfiguredSite defaultSite = UpdateUtils.getDefaultTargetSite(config, jobs[i], false);
			if (defaultSite != null) {
				jobs[i].setTargetSite(defaultSite);
				continue;
			}
			
			if (mostReceantlyUsedSite != null) {
				jobs[i].setTargetSite(mostReceantlyUsedSite);
				continue;
			}
			
			IConfiguredSite csite = getFirstTargetSite(jobs[i]);
			if (csite == null && Platform.getInstallLocation().isReadOnly() && isUpdate == false) {
				// there are no updateable sites, the installation location is read-only and we are installing a new feature
				// make an update site in the configuration area
				String configurationLocation = Platform.getConfigurationLocation().getURL().getFile();
				File site = new File(configurationLocation);
				if (!ConfiguredSite.canWrite(site)) {
					// if we cannot write to the configuration area then make an update site in the user's home directory
					site = new File(System.getProperty("user.home") + File.separator + ".eclipse" + File.separator + //$NON-NLS-1$ //$NON-NLS-2$
							Platform.getProduct().getId() + File.separator + "updates"); //$NON-NLS-1$
				}
				try {
					csite = config.createConfiguredSite(site);
					config.addConfiguredSite(csite);
					IStatus status = csite.verifyUpdatableStatus();
					if (!status.isOK())
						throw new CoreException(status);
				} catch (CoreException e) {
					// there was a problem, the user must choose an installation site
					csite = null;
					// no need to check if the directory exists because File.delete() returns false if it's not there
					deleteDir(site);
				}
			}

			jobs[i].setTargetSite(csite);
		}
	}
	
		private boolean deleteDir(File dir) {
		if (dir.isDirectory()) {
			String[] files = dir.list();
			for (int i = 0; i < files.length; i++) {
				if (!deleteDir(new File(dir, files[i]))) {
					return false;
				}
			}
		}
		return dir.delete();
	}
	
	private IConfiguredSite getMostReceantlyUsedSite() {
		IDialogSettings master = UpdateUI.getDefault().getDialogSettings();
		IDialogSettings section = master.getSection(TargetSiteDialog.MOST_RECEANTLY_USED_SITE_URL);
		if (section == null) {
			return null;
		}
		String mostReceantlyUsedSiteURLString = section.get(TargetSiteDialog.MOST_RECEANTLY_USED_SITE_URL); 
		if (mostReceantlyUsedSiteURLString == null) {
			return null;
		}
		
		URL mostReceantlyUsedSiteURL = null;
		try {
			mostReceantlyUsedSiteURL = new URL(mostReceantlyUsedSiteURLString);
		} catch (MalformedURLException mue) {
			UpdateCore.log("Url format is wrong for the mostReceantlyUsedSiteURL in preferences", mue); //$NON-NLS-1$
			mue.printStackTrace();
			return null;
		}
		IConfiguredSite[] sites = config.getConfiguredSites();
		for (int i = 0; i < sites.length; i++) {
			IConfiguredSite configuredSite = sites[i];
			if (mostReceantlyUsedSiteURL.equals(configuredSite.getSite().getURL())) {
				return configuredSite;
			}
		}
		return null;
	}
	

	private IConfiguredSite getFirstTargetSite(IInstallFeatureOperation job) {
		IConfiguredSite[] sites = config.getConfiguredSites();
		for (int i = 0; i < sites.length; i++) {
			IConfiguredSite csite = sites[i];
			if (getSiteVisibility(csite, job) && csite.getSite().getCurrentConfiguredSite().verifyUpdatableStatus().isOK())
				return csite;
		}
		return null;
	}
	
	public IInstallFeatureOperation findPatchedFeature(IFeature patch) {
		for (int i=0; i<jobs.length; i++) {
			IFeature target = jobs[i].getFeature();
			if (!target.equals(patch) && UpdateUtils.isPatch(target, patch))
				return jobs[i];
		}
		return null;
            }
    
    /* (non-Javadoc)
     * @see org.eclipse.jface.wizard.IWizardPage#isPageComplete()
     */
    public boolean isPageComplete() {
        // check if all jobs have a target site set
        for (int i = 0; jobs != null && i < jobs.length; i++) {
            if (jobs[i].getTargetSite() == null)
                return false;
        }
        return super.isPageComplete();
    }

    /**
     * @param job
     */
/*    private void setTargetLocation(IInstallFeatureOperation job) {
        if (job != null && job.getTargetSite() != null) {
            installLocation.setText(new File(job.getTargetSite().getSite().getURL().getFile()).toString());
            updateStatus(job.getTargetSite());
        }
    }*/
    
    private IInstallFeatureOperation[] toJobArray(Iterator selectedJobs) {
		
    	if (selectedJobs == null) 
    		return new IInstallFeatureOperation[0];
    	
    	ArrayList result = new ArrayList();
    	
    	while (selectedJobs.hasNext()) {
    		result.add(selectedJobs.next());
    	}
    	
    	return (IInstallFeatureOperation[])result.toArray(new IInstallFeatureOperation[result.size()]);
	}

	private void changeLocationOfFeatures() {
		IStructuredSelection selection = (IStructuredSelection) jobViewer.getSelection();
		if (selection == null)
		    return;
		Iterator selectedJob = selection.iterator();
		if (selectedJob == null) 
		    return;
		
		TargetSiteDialog dialog = new TargetSiteDialog(getShell(), config, toJobArray(selection.iterator()));
		dialog.create();

		SWTUtil.setDialogSize(dialog, 400, 300);
		
		dialog.getShell().setText(UpdateUIMessages.SitePage_new); 
		if ( dialog.open() == Dialog.OK) {
			pageChanged();
			jobViewer.refresh();
			updateStatus();
			addedSites = dialog.getAddedSites();
		}
	}
	
	void removeAddedSites() {
		if (addedSites!=null) {
			for (int i=0; i<addedSites.length; i++) {
				config.removeConfiguredSite(addedSites[i]);
			}
		}
	}
}