import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.CoreException;

		// prevent reusing old temporary files

		cleanup();

	private void cleanup() {

		try {

			String projectName = CompareWithOtherResourceDialog.TMP_PROJECT_NAME;

			IProject project = ResourcesPlugin.getWorkspace().getRoot()

					.getProject(projectName);

			project.delete(true, true, null);

		} catch (CoreException e) {

			CompareUIPlugin.log(e);

		}

	}

	public static String CompareWithOther_externalFileButton;

	public static String CompareWithOther_externalFile_errorTitle;

	public static String CompareWithOther_externalFile_errorMessage;

	public static String CompareWithOther_pathLabel;

	public static String CompareWithOther_externalFolderBUtton;

	public static String CompareWithOther_fileName;

	public static String CompareWithOther_createTmpFile_title;

	public static String CompareWithOther_createTmpFile_message;

	public static String CompareWithOther_showInEditorButton;

	public static String CompareWithOther_refreshButton;

	public static String CompareWithOther_clipboardCheckBox;

	public static String CompareWithOther_clipboardRadioAncestor;

	public static String CompareWithOther_clipboardRadioLeft;

	public static String CompareWithOther_clipboardRadioRight;

import java.io.ByteArrayInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import org.eclipse.compare.CompareUI;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IFolder;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IProjectDescription;

import org.eclipse.core.resources.IWorkspace;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.Path;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.swt.dnd.Clipboard;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.widgets.DirectoryDialog;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Event;

import org.eclipse.swt.widgets.FileDialog;

import org.eclipse.swt.widgets.Listener;

import org.eclipse.ui.IEditorDescriptor;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IEditorReference;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.part.FileEditorInput;

	private int OPEN_EXTERNAL_RETURN_CODE = 153;

	public static final String TMP_PROJECT_NAME = ".org.eclipse.compare.tmp"; //$NON-NLS-1$

	private final static String TMP_PROJECT_FILE = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" //$NON-NLS-1$

			+ "<projectDescription>\n" //$NON-NLS-1$

			+ "\t<name>" + TMP_PROJECT_NAME + "\t</name>\n" //$NON-NLS-1$ //$NON-NLS-2$

			+ "\t<comment></comment>\n" //$NON-NLS-1$

			+ "\t<projects>\n" //$NON-NLS-1$

			+ "\t</projects>\n" //$NON-NLS-1$

			+ "\t<buildSpec>\n" //$NON-NLS-1$

			+ "\t</buildSpec>\n" //$NON-NLS-1$

			+ "\t<natures>\n" + "\t</natures>\n" //$NON-NLS-1$//$NON-NLS-2$

			+ "</projectDescription>"; //$NON-NLS-1$

	public final static String EXTERNAL_FILES_FOLDER_NAME = "ExternalFilesFolder"; //$NON-NLS-1$

				section.updateAllSectionInfo();

		private Button openExternalFileButton, openExternalFolderButton;

		private String path = ""; //$NON-NLS-1$

		private Text pathLabel;

		protected Label pLabel, fileLabel;

		public void setEnabled(boolean enabled) {

			fileText.setEnabled(enabled);

			pLabel.setEnabled(enabled);

			openExternalFileButton.setEnabled(enabled);

			openExternalFolderButton.setEnabled(enabled);

			pathLabel.setEnabled(enabled);

			fileLabel.setEnabled(enabled);

			group.setEnabled(enabled);

			if (enabled)

				setResource(fileText.getText());

		}

			path = resource.getLocation().toOSString();

			pathLabel.setText(dividePath(path));

				path = resource.getLocation().toOSString();

				pathLabel.setText(dividePath(path));

			}

		}

		public void setResourceFromClipboard(IFile file) {

			resource = file;

			updateErrorInfo();

					if (getResource() != null) {

						path = resource.getLocation().toOSString();

						pathLabel.setText(dividePath(path));

					} else {

						pathLabel.setText(""); //$NON-NLS-1$

					}

			});

		}

		protected void createOpenExternalFileButton(Composite parent) {

			openExternalFileButton = createButton(parent,

					OPEN_EXTERNAL_RETURN_CODE,

					CompareMessages.CompareWithOther_externalFileButton, false);

			openExternalFileButton.addSelectionListener(new SelectionListener() {

				public void widgetDefaultSelected(SelectionEvent e) {

					widgetSelected(e);

				}

				public void widgetSelected(SelectionEvent e) {

					resource = getExtenalFile();

					updateAllSectionInfo();

				}

			});

		}

		protected void createOpenExternalFolderButton(Composite parent) {

			openExternalFolderButton = createButton(parent,

					OPEN_EXTERNAL_RETURN_CODE,

					CompareMessages.CompareWithOther_externalFolderBUtton, false);

			openExternalFolderButton.addSelectionListener(new SelectionListener() {

				public void widgetDefaultSelected(SelectionEvent e) {

					widgetSelected(e);

				}

				public void widgetSelected(SelectionEvent e) {

					resource = getExternalDirectory();

					updateAllSectionInfo();

				}

		protected void createPathLabel(Composite parent) {

			pLabel = new Label(parent, SWT.NONE);

			pLabel.setText(CompareMessages.CompareWithOther_pathLabel);

			pLabel.setLayoutData(new GridData(SWT.BEGINNING, SWT.BEGINNING, false, true));

			pathLabel = new Text(parent, SWT.MULTI);

			pathLabel.setBackground(PlatformUI.getWorkbench().getDisplay().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));

			pathLabel.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

		}

		private String dividePath(String text) {

			String[] parts;

			int lineLengthLimit = computeLineLengthLimit(this);

			int lineLength = 0;

			String s = new String();

			String separator = new String(System.getProperty("file.separator")); //$NON-NLS-1$

			if (separator.equals("\\")) //$NON-NLS-1$

				parts = text.split("\\" + separator); //$NON-NLS-1$

			else

				parts = text.split(separator);

			for (int i = 0; i < parts.length; i++) {

				lineLength += parts[i].length();

				if (lineLength >= lineLengthLimit) {

					s += "\n"; //$NON-NLS-1$

					lineLength = 0;

				}

				s += parts[i];

				s += separator;

			}

			return s;

		}

					getShell().pack();

	private class ClipboardSection {

		private Composite contents;

		protected Button check;

		protected Text preview;

		protected Button showInEditorButton, refreshButton;

		protected Button[] panels;

		private IFile clipboardFile;

		private Clipboard clipboard;

		private InternalSection selectedSection;

		public ClipboardSection(Composite parent) {

			createContents(parent);

			clipboard = new Clipboard(Display.getDefault());

			String fileContent = (String) clipboard.getContents(TextTransfer.getInstance());

			clipboardFile = createClipboardFile(fileContent);

		}

		private void createContents(Composite parent) {

			contents = new Composite(parent, SWT.NONE);

			contents.setLayout(new GridLayout(3, false));

			createCheckRadioComposite(contents);

			preview = new Text(contents, SWT.BORDER | SWT.MULTI | SWT.V_SCROLL);

			preview.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));

			preview.setEnabled(false);

			createButtonComposite(contents);

		}

		private void createButtonComposite(Composite parent) {

			Composite buttonComposite = new Composite(parent, SWT.NONE);

			buttonComposite.setLayout(new GridLayout(1, false));

			createShowInEditorButton(buttonComposite);

			createRefreshButton(buttonComposite);

		}

		private void createShowInEditorButton(Composite parent) {

			showInEditorButton = new Button(parent, SWT.PUSH);

			showInEditorButton.setText(CompareMessages.CompareWithOther_showInEditorButton);

			showInEditorButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));

			showInEditorButton.setEnabled(false);

			showInEditorButton.addSelectionListener(new SelectionListener() {

				public void widgetDefaultSelected(SelectionEvent e) {

					widgetSelected(e);

				}

				public void widgetSelected(SelectionEvent e) {

					IWorkbenchPage page = getWorkbenchPage();

					String id = getEditorId(page);

					try {

						FileEditorInput input = new FileEditorInput(clipboardFile);

						closeEditorWithClipboard(page, id, input);

						page.openEditor(input, id);

					} catch (PartInitException e1) {

						CompareUIPlugin.log(e1);

					}

				}

			});

		}

		private void createRefreshButton(Composite parent) {

			refreshButton = new Button(parent, SWT.PUSH);

			refreshButton.setText(CompareMessages.CompareWithOther_refreshButton);

			refreshButton.setEnabled(false);

			refreshButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));

			refreshButton.addSelectionListener(new SelectionListener() {

				public void widgetDefaultSelected(SelectionEvent e) {

					widgetSelected(e);

				}

				public void widgetSelected(SelectionEvent e) {

					setPreviewContent();

					clipboardFile = createClipboardFile(preview.getText());

					selectedSection.setResourceFromClipboard(clipboardFile);

				}

			});

		}

		private String getEditorId(IWorkbenchPage page) {

			IEditorDescriptor descriptor = CompareUI.getPlugin().getWorkbench().getEditorRegistry().getDefaultEditor(clipboardFile.getName());

			return descriptor.getId();

		}

		private void closeEditorWithClipboard(IWorkbenchPage page, String id, IEditorInput input) throws PartInitException {

			IEditorReference[] editors = page.getEditorReferences();

			for (int i = 0; i < editors.length; i++)

				if (editors[i].getId().equals(id) && editors[i].getEditorInput().equals(input))

					page.closeEditor(editors[i].getEditor(false), false);

		}

		public void closeEditorWithClipboard(IWorkbenchPage page) {

			String id = getEditorId(page);

			IEditorInput input = new FileEditorInput(clipboardFile);

			try {

				closeEditorWithClipboard(page, id, input);

			} catch (PartInitException e) {

				CompareUIPlugin.log(e);

			}

		}

		private void createCheckRadioComposite(Composite parent) {

			Composite checkAndRadioComposite = new Composite(parent, SWT.NONE);

			checkAndRadioComposite.setLayout(new GridLayout(1, false));

			check = new Button(checkAndRadioComposite, SWT.CHECK);

			check.setText(CompareMessages.CompareWithOther_clipboardCheckBox);

			createRadioComposite(checkAndRadioComposite);

			check.addSelectionListener(new SelectionAdapter() {

				public void widgetSelected(SelectionEvent e) {

					if (check.getSelection() == true) {

						setEnableForWidgets(true);

						setPreviewContent();

					}

					else {

						setEnableForWidgets(false);

						setEnableForPanels(true);

					}

				}

			});

		}

		private void createRadioComposite(Composite parent) {

			Composite radioComposite = new Composite(parent, SWT.NONE);

			radioComposite.setLayout(new GridLayout(3, false));

			panels = new Button[3];

			panels[0] = new Button(radioComposite, SWT.RADIO);

			panels[0].setText(CompareMessages.CompareWithOther_clipboardRadioAncestor);

			panels[1] = new Button(radioComposite, SWT.RADIO);

			panels[1].setText(CompareMessages.CompareWithOther_clipboardRadioLeft);

			panels[2] = new Button(radioComposite, SWT.RADIO);

			panels[2].setText(CompareMessages.CompareWithOther_clipboardRadioRight);

			for (int i = 0; i < panels.length; i++)

				panels[i].setEnabled(false);

			Listener listener = new Listener() {

				public void handleEvent(Event event) {

					for (int i = 0; i < panels.length; i++)

						if (event.widget != panels[i])

							panels[i].setSelection(false);

					if (event.widget instanceof Button) {

						((Button)event.widget).setSelection(true);

						if (panels[0].getSelection())

							setEnableForPanels(ancestorPanel);

						else if (panels[1].getSelection())

							setEnableForPanels(leftPanel);

						else if (panels[2].getSelection())

							setEnableForPanels(rightPanel);

					}

				}

			};

			for (int i = 0; i < panels.length; i++)

				panels[i].addListener(SWT.Selection, listener);

		}

		private void setPreviewContent() {

			String clipboardContent = (String) clipboard.getContents(TextTransfer.getInstance());

			preview.setText(clipboardContent);

		}

		private IFile createClipboardFile(String fileContent) {

			IFile file = null;

			try {

				file = getClipboardFile();

				if (file.exists())

					file.delete(false, null);

				InputStream source = new ByteArrayInputStream(fileContent.getBytes());

				file.create(source, IResource.NONE, null);

			} catch (CoreException e) {

				CompareUIPlugin.log(e);

				MessageDialog.openError(getShell(),

						CompareMessages.CompareWithOther_createTmpFile_title,

						CompareMessages.CompareWithOther_createTmpFile_message);

				return file;

			}

			return file;

		}

		private IFile getClipboardFile() throws CoreException {

			IFile file = null;

			IProject project = createTmpProject();

			if (!project.isOpen())

				project.open(null);

			IFolder folder = project.getFolder("ClipboardFolder"); //$NON-NLS-1$

			if (!folder.exists())

				folder.create(IResource.NONE, true, null);

			file = folder.getFile(CompareMessages.CompareWithOther_fileName);

			return file;

		}

		private void setEnableForPanels(InternalSection selectedSection) {

			this.selectedSection = selectedSection;

			InternalSection[] sections = {ancestorPanel, leftPanel, rightPanel};

			for (int i = 0; i < sections.length; i++)

				if (sections[i] == selectedSection) {

					sections[i].setEnabled(false);

					sections[i].setResourceFromClipboard(clipboardFile);

				} else

					sections[i].setEnabled(true);

		}

		private void setEnableForPanels(boolean enabled) {

			InternalSection[] sections = {ancestorPanel, leftPanel, rightPanel};

			for (int i = 0; i < sections.length; i++)

				sections[i].setEnabled(enabled);

		}

		private void setEnableForWidgets(boolean enabled) {

			for (int i = 0; i < panels.length; i++)

				panels[i].setEnabled(enabled);

			showInEditorButton.setEnabled(enabled);

			refreshButton.setEnabled(enabled);

			preview.setEnabled(enabled);

		}

		public void setLayoutData(GridData data) {

			contents.setLayoutData(data);

		}

	}

	private int lineLimit = 0;

		clipboardSection = new ClipboardSection(mainPanel);

		GridData data = new GridData(SWT.FILL, SWT.FILL, false, true);

		data.horizontalSpan = 2;

		clipboardSection.setLayoutData(data);

	public int computeLineLengthLimit(InternalSection section) {

		int leftLenght = leftPanel.fileText.getCharCount();

		int rightLength = rightPanel.fileText.getCharCount();

		int maxLenght = (leftLenght > rightLength ? leftLenght : rightLength);

		if (maxLenght > lineLimit)

			lineLimit = maxLenght;

		if (section instanceof InternalExpandable)

			return Math.max(lineLimit * 2 + 20, 90);

		return maxLenght;

	}

	/*

	 * (non-javadoc)

	 *

	 * Implementation based on org.eclipse.jdt.internakl.core.ExternalFoldersManager#createExternalFoldersProject

	 */

	private IProject createTmpProject() throws CoreException {

		IProject tmpProject = getTmpProject();

		if (!tmpProject.isAccessible()) {

			try {

				if (!tmpProject.exists()) {

					IProjectDescription desc = tmpProject.getWorkspace()

							.newProjectDescription(tmpProject.getName());

					IPath location = CompareUI.getPlugin()

							.getStateLocation();

					desc.setLocation(location.append(TMP_PROJECT_NAME));

					tmpProject.create(desc, null);

				}

				try {

					tmpProject.open(null);

				} catch (CoreException e1) { // in case .project file or folder has been deleted

					IPath location1 = CompareUI.getPlugin()

							.getStateLocation();

					IPath projectPath1 = location1.append(TMP_PROJECT_NAME);

					projectPath1.toFile().mkdirs();

					FileOutputStream output = new FileOutputStream(

							projectPath1.append(".project").toOSString()); //$NON-NLS-1$

					try {

						output.write(TMP_PROJECT_FILE.getBytes());

					} finally {

						output.close();

					}

					tmpProject.open(null);

				}

			} catch (IOException ioe) {

				return tmpProject;

			} catch (CoreException ce) {

				throw new CoreException(ce.getStatus());

			}

		}

		return tmpProject;

	}

	/*

	 * (non-javadoc)

	 *

	 * Following method is analogical to org.eclipse.jdt.internal

	 */

	private IProject getTmpProject() {

		return ResourcesPlugin.getWorkspace().getRoot().getProject(

				TMP_PROJECT_NAME);

	}

	private IWorkbenchPage getWorkbenchPage() {

		return CompareUI.getPlugin().getWorkbench().getActiveWorkbenchWindow().getActivePage();

	}

	public void okPressed() {

		IWorkbenchPage page = getWorkbenchPage();

		clipboardSection.closeEditorWithClipboard(page);

		super.okPressed();

	}

CompareWithOther_externalFileButton=External file...

CompareWithOther_externalFolderBUtton=External folder...

CompareWithOther_externalFile_errorTitle=Compare With Other Resource Error

CompareWithOther_externalFile_errorMessage=I cannot create a link to external file.

CompareWithOther_pathLabel=Path:

CompareWithOther_fileName=clipboard.txt

CompareWithOther_createTmpFile_title= Unable to create file

CompareWithOther_createTmpFile_message= A file cannot be created from clipboard content.

CompareWithOther_showInEditorButton=Show in editor

CompareWithOther_refreshButton=Refresh

CompareWithOther_clipboardCheckBox=Use clipboard's content

CompareWithOther_clipboardRadioAncestor=Ancestor

CompareWithOther_clipboardRadioLeft=Left

CompareWithOther_clipboardRadioRight=Right