public static String CompareWithOther_clipboardSection;

	public static String CompareWithOther_fileName;

	public static String CompareWithOther_createTmpFile_title;

	public static String CompareWithOther_createTmpFile_message;

	public static String CompareWithOther_refreshButton;

	public static String CompareWithOther_clipboardInfo_1;

	public static String CompareWithOther_clipboardInfo_2;

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.runtime.CoreException;

import org.eclipse.core.runtime.IPath;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.text.Document;

import org.eclipse.jface.text.source.SourceViewer;

import org.eclipse.swt.dnd.Clipboard;

import org.eclipse.swt.widgets.Display;

	private int REFRESH_RETURN_CODE = 154;

	private int clipboardCounter = 0;

	public final static 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$

	private class ClipboardDropListener implements DropTargetListener {

		ClipboardAbstractSection clipboardSection;

		public ClipboardDropListener(ClipboardAbstractSection clipboardSection) {

			this.clipboardSection = clipboardSection;

		}

		public void dragEnter(DropTargetEvent event) {

			if (event.detail == DND.DROP_DEFAULT) {

				if ((event.operations & DND.DROP_COPY) != 0)

					event.detail = DND.DROP_COPY;

				else

					event.detail = DND.DROP_NONE;

			}

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

				if (TextTransfer.getInstance().isSupportedType(event.dataTypes[i])) {

					event.currentDataType = event.dataTypes[i];

					if (event.detail != DND.DROP_COPY)

						event.detail = DND.DROP_NONE;

					break;

				}

			}

		}

		public void dragLeave(DropTargetEvent event) {

			clipboardSection.clipboardExpandable.setExpanded(true);

			getShell().pack();

		}

		public void dragOperationChanged(DropTargetEvent event) {

			// intentionally empty

		}

		public void dragOver(DropTargetEvent event) {

			clipboardSection.clipboardExpandable.setExpanded(true);

			getShell().pack();

		}

		public void drop(DropTargetEvent event) {

			if (TextTransfer.getInstance().isSupportedType(event.currentDataType)) {

				String fileContent = (String) event.data;

				clipboardSection.setViewerContent(fileContent);

				IFile file = clipboardSection.createTmpFile(fileContent);

				// don't update a fileText's content

				clipboardSection.getPanel().setResourceFromClipboard(file);

				updateErrorInfo();

			}

		}

		public void dropAccept(DropTargetEvent event) {

			// intentionally empty

		}

	}

	private abstract class ClipboardAbstractSection {

		protected ExpandableComposite clipboardExpandable;

		protected SourceViewer viewer;

		protected Button refreshButton;

		private InternalSection section;

		public ClipboardAbstractSection(InternalSection section) {

			this.section = section;

		}

		protected void createClipboardSection(Composite parent) {

			final Composite p = parent;

			clipboardExpandable = new ExpandableComposite(parent, SWT.NONE,

					ExpandableComposite.TWISTIE);

			clipboardExpandable

					.setText(CompareMessages.CompareWithOther_clipboardSection);

			Composite content = createContentsForClipboardSection(clipboardExpandable);

			clipboardExpandable.setClient(content);

			clipboardExpandable.addExpansionListener(new ExpansionAdapter() {

				public void expansionStateChanged(ExpansionEvent e) {

					p.layout();

					getShell().pack();

					if (e.getState()) {

						section.fileText.setEnabled(false);

						// do not clear contents of the fileText

						section.clearResourceWithoutPath();

						setViewerAndCreateFile();

					} else {

						section.fileText.setEnabled(true);

						section.clearResourceWithoutPath();

						if (section.fileText.getText() != "") //$NON-NLS-1$

							section.setResource(section.fileText.getText());

					}

					updateErrorInfo();

				}

			});

			GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true);

			gd.horizontalSpan = 2;

			clipboardExpandable.setLayoutData(gd);

			initDropForClipboard();

		}

		private void setViewerAndCreateFile() {

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

			setViewerContent(newContent);

		}

		public void setViewerContent(String newContent) {

			viewer.setDocument(new Document(newContent));

			// don't update a fileText's content

			section.setResourceFromClipboard(createTmpFile(newContent));

		}

		private void initDropForClipboard() {

			DropTarget clipboardTarget = new DropTarget(clipboardExpandable, DND.DROP_COPY | DND.DROP_DEFAULT);

			Transfer[] types = new Transfer[] {TextTransfer.getInstance()};

			clipboardTarget.setTransfer(types);

			clipboardTarget.addDropListener(new ClipboardDropListener(this));

		}

		private Composite createContentsForClipboardSection(Composite parent) {

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

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

			Label infoLabel = new Label(contents, SWT.NONE);

			infoLabel.setText(clipboardInfo());

			GridData labelGd = new GridData(SWT.FILL, SWT.FILL, true, true);

			labelGd.horizontalSpan = 3;

			infoLabel.setLayoutData(labelGd);

			viewer = new SourceViewer(contents, null, SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL);

			viewer.setEditable(false);

			GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true);

			gd.horizontalSpan = 3;

			gd.widthHint = 200;

			gd.heightHint = 150;

			viewer.getTextWidget().setLayoutData(gd);

			// although viewer is not editable, we need ModifyListener to

			// set viewer's content and error message after dropping a portion of text

			viewer.getTextWidget().addModifyListener(new ModifyListener() {

				public void modifyText(ModifyEvent e) {

					setViewerAndCreateFile();

					updateErrorInfo();

				}

			});

			createRefreshButton(contents);

			parent.layout();

			return contents;

		}

		abstract protected String clipboardInfo();

		private void createRefreshButton(Composite parent) {

			refreshButton = createButton(parent, REFRESH_RETURN_CODE, CompareMessages.CompareWithOther_refreshButton, false);

			refreshButton.addSelectionListener(new SelectionListener() {

				public void widgetDefaultSelected(SelectionEvent e) {

					widgetSelected(e);

				}

				public void widgetSelected(SelectionEvent e) {

					setViewerAndCreateFile();

					updateErrorInfo();

				}

			});

		}

		private IFile createTmpFile(String fileContent) {

			IFile file = null;

			try {

				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

						+ clipboardCounter++);

				if (!file.exists()) {

					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 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;

		}

		private IProject getTmpProject() {

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

					TMP_PROJECT_NAME);

		}

		protected boolean clipboardSectionExpanded() {

			return clipboardExpandable.isExpanded();

		}

		protected boolean noResource() {

			return section.getResource() == null;

		}

		public InternalSection getPanel() {

			return section;

		}

	}

	private class ClipboardSection extends ClipboardAbstractSection {

		public ClipboardSection(InternalSection section) {

			super(section);

		}

		protected String clipboardInfo() {

			return CompareMessages.CompareWithOther_clipboardInfo_1 + "\n" + //$NON-NLS-1$

				CompareMessages.CompareWithOther_clipboardInfo_2;

		}

	}

	private class ClipboardAncestorSection extends ClipboardAbstractSection {

		public ClipboardAncestorSection(InternalSection section) {

			super(section);

		}

		protected String clipboardInfo() {

			return CompareMessages.CompareWithOther_clipboardInfo_1 +

				CompareMessages.CompareWithOther_clipboardInfo_2;

		}

	}

		}

		public void setResourceFromClipboard(IResource resource) {

			this.resource = resource;

		protected void clearResourceWithoutPath() {

			resource = null;

			updateErrorInfo();

		}

			createFileLabel(group);

			createFileCombo(group);

		private ClipboardSection clipboardSection;

			this.clipboardSection = new ClipboardSection(this);

		protected void createGroup(Composite parent) {

			super.createGroup(parent);

			clipboardSection.createClipboardSection(group);

		}

			this.clipboardAncestorSection = new ClipboardAncestorSection(this);

			createClearButton(group);

					getShell().pack();

			clipboardAncestorSection.createClipboardSection(group);

	Clipboard clipboard;

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

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.CoreException;

		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);

		}

	}