/*******************************************************************************
* Copyright (c) 2000, 2017 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* IBM Corporation - initial API and implementation
* Sebastian Davids <sdavids@gmx.de> - layout tweaks
* Matt McCutchen <hashproduct+eclipse@gmail.com> - Bug 180358 [Apply Patch] Cursor jumps to beginning of filename field on keystroke
*******************************************************************************/
package org.eclipse.compare.internal.patch;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import org.eclipse.compare.internal.ICompareContextIds;
import org.eclipse.compare.internal.Utilities;
import org.eclipse.compare.patch.IFilePatch2;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.Clipboard;
import org.eclipse.swt.dnd.TextTransfer;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.ShellAdapter;
import org.eclipse.swt.events.ShellEvent;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.model.WorkbenchContentProvider;
import org.eclipse.ui.model.WorkbenchLabelProvider;
import org.eclipse.ui.views.navigator.ResourceComparator;
import com.ibm.icu.text.MessageFormat;
public class InputPatchPage extends WizardPage {
// constants
protected static final int SIZING_TEXT_FIELD_WIDTH= 250;
protected static final int COMBO_HISTORY_LENGTH= 5;
// dialog store id constants
private final static String PAGE_NAME= "PatchWizardPage1"; //$NON-NLS-1$
private final static String STORE_PATCH_FILES_ID= PAGE_NAME+".PATCH_FILES"; //$NON-NLS-1$
private final static String STORE_PATCH_URLS_ID= PAGE_NAME+".PATCH_URLS"; //$NON-NLS-1$
private final static String STORE_INPUT_METHOD_ID= PAGE_NAME+".INPUT_METHOD"; //$NON-NLS-1$
private final static String STORE_WORKSPACE_PATH_ID= PAGE_NAME+".WORKSPACE_PATH"; //$NON-NLS-1$
//patch input constants
protected final static int CLIPBOARD= 1;
protected final static int FILE= 2;
protected final static int WORKSPACE= 3;
protected final static int URL= 4;
protected final static String INPUTPATCHPAGE_NAME= "InputPatchPage"; //$NON-NLS-1$
private boolean fShowError= false;
private String fPatchSource;
private boolean fPatchRead= false;
private PatchWizard fPatchWizard;
private ActivationListener fActivationListener= new ActivationListener();
// SWT widgets
private Button fUseClipboardButton;
private Combo fPatchFileNameField;
private Button fPatchFileBrowseButton;
private Button fUsePatchFileButton;
private Button fUseWorkspaceButton;
private Button fUseURLButton;
private Combo fPatchURLField;
private Label fWorkspaceSelectLabel;
private TreeViewer fTreeViewer;
class ActivationListener extends ShellAdapter {
@Override
public void shellActivated(ShellEvent e) {
// allow error messages if the selected input actually has something selected in it
fShowError=true;
switch(getInputMethod()) {
case FILE:
fShowError= (fPatchFileNameField.getText() != ""); //$NON-NLS-1$
break;
case URL:
fShowError = (fPatchURLField.getText() != ""); //$NON-NLS-1$
break;
case WORKSPACE:
fShowError= (!fTreeViewer.getSelection().isEmpty());
break;
}
updateWidgetEnablements();
}
}
public InputPatchPage(PatchWizard pw) {
super(INPUTPATCHPAGE_NAME, PatchMessages.InputPatchPage_title, null);
fPatchWizard= pw;
setMessage(PatchMessages.InputPatchPage_message);
}
/*
* Get a path from the supplied text widget.
* @return org.eclipse.core.runtime.IPath
*/
protected IPath getPathFromText(Text textField) {
return (new Path(textField.getText())).makeAbsolute();
}
/* package */ String getPatchName() {
if (getInputMethod() == CLIPBOARD)
return PatchMessages.InputPatchPage_Clipboard;
return getPatchFilePath();
}
@Override
public void createControl(Composite parent) {
Composite composite= new Composite(parent, SWT.NULL);
composite.setLayout(new GridLayout());
composite.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_FILL | GridData.HORIZONTAL_ALIGN_FILL));
setControl(composite);
initializeDialogUnits(parent);
buildPatchFileGroup(composite);
// by default, whatever was used last was selected or
// default to File if nothing has been selected
restoreWidgetValues();
// see if there are any better options presently selected (i.e workspace
// or clipboard or URL from clipboard)
adjustToCurrentTarget();
// No error for dialog opening
fShowError= false;
clearErrorMessage();
updateWidgetEnablements();
Shell shell= getShell();
shell.addShellListener(fActivationListener);
Dialog.applyDialogFont(composite);
PlatformUI.getWorkbench().getHelpSystem().setHelp(composite, ICompareContextIds.PATCH_INPUT_WIZARD_PAGE);
}
/**
* Returns the next page depending on what type of patch is being applied:
* i) If the patch is a Workspace patch then it will proceed right to the PreviewPatchPage
* ii) If the patch is a single project patch then it will proceed to the PatchTargetPage, which
* allows the user to specify where to root the patch
* @return PreviewPatchPage if multi-project patch, PatchTargetPage if single project patch
*/
@Override
public IWizardPage getNextPage() {
if (!checkPageComplete())
return this;
WorkspacePatcher patcher= ((PatchWizard) getWizard()).getPatcher();
// guess prefix count
int guess= 0; // guessPrefix(diffs);
patcher.setStripPrefixSegments(guess);
// If this is a workspace patch we don't need to set a target as the targets will be figured out from
// all of the projects that make up the patch and continue on to final preview page
if (patcher.isWorkspacePatch()) {
// skip 'Patch Target' page
IWizardPage page = super.getNextPage();
if (page.getName().equals(PatchTargetPage.PATCHTARGETPAGE_NAME))
return page.getNextPage();
}
// If this is a git patch set the workspace root as the target and skip the target selection page
if (patcher.isGitPatch()) {
// skip 'Patch Target' page
IWizardPage page = super.getNextPage();
if (page.getName().equals(PatchTargetPage.PATCHTARGETPAGE_NAME)) {
// set the workspace root as the target
patcher.setTarget(ResourcesPlugin.getWorkspace().getRoot());
return page.getNextPage();
}
}
// else go on to target selection page
return super.getNextPage();
}
boolean checkPageComplete() {
WorkspacePatcher patcher= ((PatchWizard)getWizard()).getPatcher();
// Read in the patch
readInPatch();
IFilePatch2[] diffs= patcher.getDiffs();
if (diffs == null || diffs.length == 0) {
String format= PatchMessages.InputPatchPage_NoDiffsFound_format;
String message= MessageFormat.format(format, fPatchSource);
MessageDialog.openInformation(null, PatchMessages.InputPatchPage_PatchErrorDialog_title, message);
return false;
}
return true;
}
/*
* Reads in the patch contents
*/
public void readInPatch(){
if (fPatchRead)
return;
WorkspacePatcher patcher= ((PatchWizard) getWizard()).getPatcher();
// Create a reader for the input
Reader reader= null;
try {
int inputMethod= getInputMethod();
if (inputMethod == CLIPBOARD) {
Control c= getControl();
if (c != null) {
Clipboard clipboard= new Clipboard(c.getDisplay());
Object o= clipboard.getContents(TextTransfer.getInstance());
clipboard.dispose();
if (o instanceof String)
reader= new StringReader((String)o);
}
fPatchSource= PatchMessages.InputPatchPage_Clipboard_title;
} else if (inputMethod==FILE) {
String patchFilePath= getPatchFilePath();
if (patchFilePath != null) {
try {
reader= new FileReader(patchFilePath);
} catch (FileNotFoundException ex) {
MessageDialog.openError(null,
PatchMessages.InputPatchPage_PatchErrorDialog_title,
PatchMessages.InputPatchPage_PatchFileNotFound_message);
}
}
fPatchSource= PatchMessages.InputPatchPage_PatchFile_title;
} else if (inputMethod==URL) {
String patchFileURL = fPatchURLField.getText();
if (patchFileURL != null) {
try {
String contents = Utilities.getURLContents(new URL(
patchFileURL), getContainer());
if (contents != null)
reader = new StringReader(contents);
} catch (MalformedURLException e) {
// ignore as we tested it with modify listener on combo
} catch (InvocationTargetException e) { // ignore
} catch (OperationCanceledException e) { // ignore
} catch (InterruptedException e) { // ignore
}
}
fPatchSource= PatchMessages.InputPatchPage_URL_title;
} else if (inputMethod==WORKSPACE) {
// Get the selected patch file (tree will only allow for one selection)
IResource[] resources= Utilities.getResources(fTreeViewer.getSelection());
IResource patchFile= resources[0];
if (patchFile != null) {
try {
reader= new FileReader(patchFile.getLocation().toFile());
} catch (FileNotFoundException ex) {
MessageDialog.openError(null, PatchMessages.InputPatchPage_PatchErrorDialog_title, PatchMessages.InputPatchPage_PatchFileNotFound_message);
} catch (NullPointerException nex) {
//in case the path doesn't exist (eg. getLocation() returned null)
MessageDialog.openError(null, PatchMessages.InputPatchPage_PatchErrorDialog_title, PatchMessages.InputPatchPage_PatchFileNotFound_message);
}
}
fPatchSource= PatchMessages.InputPatchPage_WorkspacePatch_title;
}
// parse the input
if (reader != null) {
try {
patcher.parse(new BufferedReader(reader));
//report back to the patch wizard that the patch has been read in
fPatchWizard.patchReadIn();
fPatchRead=true;
} catch (Exception ex) {
// Ignore. User will be informed of error since patcher contains no diffs
setPageComplete(false);
}
}
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException x) {
// silently ignored
}
}
}
}
@Override
public boolean canFlipToNextPage() {
// we can't call getNextPage to determine if flipping is allowed since computing
// the next page is quite expensive. So we say yes if the page is complete.
return isPageComplete();
}
private void setEnablePatchFile(boolean enable) {
fPatchFileNameField.setEnabled(enable);
fPatchFileBrowseButton.setEnabled(enable);
}
private void setEnableWorkspacePatch(boolean enable) {
fWorkspaceSelectLabel.setEnabled(enable);
fTreeViewer.getTree().setEnabled(enable);
}
private void setEnableURLPatch(boolean enable) {
fPatchURLField.setEnabled(enable);
}
/*
* Create the group for selecting the patch file
*/
private void buildPatchFileGroup(Composite parent) {
final Composite composite= new Composite(parent, SWT.NULL);
GridLayout gridLayout= new GridLayout();
gridLayout.numColumns= 3;
composite.setLayout(gridLayout);
composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
// 1st row
GridData gd= new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
gd.horizontalSpan= 3;
fUseClipboardButton= new Button(composite, SWT.RADIO);
fUseClipboardButton.setText(PatchMessages.InputPatchPage_UseClipboardButton_text);
fUseClipboardButton.setLayoutData(gd);
// 2nd row
fUsePatchFileButton= new Button(composite, SWT.RADIO);
fUsePatchFileButton.setText(PatchMessages.InputPatchPage_FileButton_text);
fPatchFileNameField= new Combo(composite, SWT.BORDER);
gd= new GridData(GridData.FILL_HORIZONTAL);
gd.widthHint= SIZING_TEXT_FIELD_WIDTH;
fPatchFileNameField.setLayoutData(gd);
fPatchFileBrowseButton= new Button(composite, SWT.PUSH);
fPatchFileBrowseButton.setText(PatchMessages.InputPatchPage_ChooseFileButton_text);
GridData data= new GridData(GridData.HORIZONTAL_ALIGN_FILL);
int widthHint= convertHorizontalDLUsToPixels(IDialogConstants.BUTTON_WIDTH);
Point minSize= fPatchFileBrowseButton.computeSize(SWT.DEFAULT, SWT.DEFAULT, true);
data.widthHint= Math.max(widthHint, minSize.x);
fPatchFileBrowseButton.setLayoutData(data);
//3rd row
fUseURLButton = new Button(composite, SWT.RADIO);
fUseURLButton.setText(PatchMessages.InputPatchPage_URLButton_text);
fPatchURLField = new Combo(composite, SWT.BORDER);
gd = new GridData(GridData.FILL_HORIZONTAL);
gd.horizontalSpan = 2;
fPatchURLField.setLayoutData(gd);
//4th row
fUseWorkspaceButton= new Button(composite, SWT.RADIO);
fUseWorkspaceButton.setText(PatchMessages.InputPatchPage_UseWorkspaceButton_text);
gd= new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING);
fUseWorkspaceButton.setLayoutData(gd);
addWorkspaceControls(parent);
// Add listeners
fUseClipboardButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
if (!fUseClipboardButton.getSelection())
return;
clearErrorMessage();
fShowError= true;
int state= getInputMethod();
setEnablePatchFile(state == FILE);
setEnableURLPatch(state == URL);
setEnableWorkspacePatch(state == WORKSPACE);
updateWidgetEnablements();
fPatchRead = false;
}
});
fUsePatchFileButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
if (!fUsePatchFileButton.getSelection())
return;
//If there is anything typed in at all
clearErrorMessage();
fShowError= (fPatchFileNameField.getText() != ""); //$NON-NLS-1$
int state= getInputMethod();
setEnablePatchFile(state == FILE);
setEnableURLPatch(state == URL);
setEnableWorkspacePatch(state == WORKSPACE);
updateWidgetEnablements();
fPatchRead = false;
}
});
fPatchFileNameField.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
updateWidgetEnablements();
}
});
fPatchFileNameField.addModifyListener(e -> {
clearErrorMessage();
fShowError= true;
fPatchRead = false;
updateWidgetEnablements();
});
fPatchFileBrowseButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
clearErrorMessage();
fShowError= true;
handlePatchFileBrowseButtonPressed();
updateWidgetEnablements();
}
});
fUseURLButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
clearErrorMessage();
fShowError= (fPatchURLField.getText() != ""); //$NON-NLS-1$
int state= getInputMethod();
setEnablePatchFile(state == FILE);
setEnableURLPatch(state == URL);
setEnableWorkspacePatch(state == WORKSPACE);
updateWidgetEnablements();
}
});
fPatchURLField.addModifyListener(e -> {
clearErrorMessage();
fShowError = true;
fPatchRead = false;
updateWidgetEnablements();
});
fUseWorkspaceButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
if (!fUseWorkspaceButton.getSelection())
return;
clearErrorMessage();
// If there is anything typed in at all
fShowError= (!fTreeViewer.getSelection().isEmpty());
int state= getInputMethod();
setEnablePatchFile(state == FILE);
setEnableURLPatch(state == URL);
setEnableWorkspacePatch(state == WORKSPACE);
updateWidgetEnablements();
fPatchRead = false;
}
});
fTreeViewer.addSelectionChangedListener(event -> {
clearErrorMessage();
updateWidgetEnablements();
});
fTreeViewer.addDoubleClickListener(event -> {
ISelection selection= event.getSelection();
if (selection instanceof TreeSelection) {
TreeSelection treeSel= (TreeSelection) selection;
Object res= treeSel.getFirstElement();
if (res != null) {
if (res instanceof IProject || res instanceof IFolder) {
if (fTreeViewer.getExpandedState(res))
fTreeViewer.collapseToLevel(res, 1);
else
fTreeViewer.expandToLevel(res, 1);
} else if (res instanceof IFile)
fPatchWizard.showPage(getNextPage());
}
}
});
}
private void addWorkspaceControls(Composite composite) {
Composite newComp= new Composite(composite, SWT.NONE);
GridLayout layout= new GridLayout(1, false);
layout.marginLeft= 16; // align w/ lable of check button
newComp.setLayout(layout);
newComp.setLayoutData(new GridData(GridData.FILL_BOTH));
fWorkspaceSelectLabel= new Label(newComp, SWT.LEFT);
fWorkspaceSelectLabel.setText(PatchMessages.InputPatchPage_WorkspaceSelectPatch_text);
fTreeViewer= new TreeViewer(newComp, SWT.BORDER);
GridData layoutData = new GridData(SWT.FILL, SWT.FILL, true, true);
layoutData.heightHint = 300;
fTreeViewer.getTree().setLayoutData(layoutData);
fTreeViewer.setLabelProvider(new WorkbenchLabelProvider());
fTreeViewer.setContentProvider(new WorkbenchContentProvider());
fTreeViewer.setComparator(new ResourceComparator(ResourceComparator.NAME));
fTreeViewer.setInput(ResourcesPlugin.getWorkspace().getRoot());
}
/**
* Updates the enable state of this page's controls.
*/
private void updateWidgetEnablements() {
String error= null;
boolean gotPatch= false;
int inputMethod= getInputMethod();
if (inputMethod==CLIPBOARD) {
Control c= getControl();
if (c != null) {
Clipboard clipboard= new Clipboard(c.getDisplay());
Object o= clipboard.getContents(TextTransfer.getInstance());
clipboard.dispose();
if (o instanceof String) {
String s= ((String) o).trim();
if (s.length() > 0)
gotPatch= true;
else
error= PatchMessages.InputPatchPage_ClipboardIsEmpty_message;
} else
error= PatchMessages.InputPatchPage_NoTextInClipboard_message;
} else
error= PatchMessages.InputPatchPage_CouldNotReadClipboard_message;
} else if (inputMethod==FILE) {
String path= fPatchFileNameField.getText();
if (path != null && path.length() > 0) {
File file= new File(path);
gotPatch= file.exists() && file.isFile() && file.length() > 0;
if (!gotPatch)
error= PatchMessages.InputPatchPage_CannotLocatePatch_message + path;
} else {
error= PatchMessages.InputPatchPage_NoFileName_message;
}
} else if (inputMethod == URL) {
String urlText = fPatchURLField.getText();
if(urlText != null) {
try {
new URL(urlText);
// Checking the URL is a bit too heavy for each keystroke.
// Let's assume it contains a valid patch.
gotPatch = true;
} catch (MalformedURLException e) {
error= PatchMessages.InputPatchPage_MalformedURL;
}
} else {
error= PatchMessages.InputPatchPage_NoURL;
}
} else if (inputMethod == WORKSPACE) {
//Get the selected patch file (tree will only allow for one selection)
IResource[] resources= Utilities.getResources(fTreeViewer.getSelection());
if (resources != null && resources.length > 0) {
IResource patchFile= resources[0];
if (patchFile != null && patchFile.getType() == IResource.FILE) {
IPath location = patchFile.getLocation();
if (location == null) {
error = PatchMessages.InputPatchPage_PatchFileNotFound_message;
} else {
File actualFile= location.toFile();
gotPatch= actualFile.exists()&&actualFile.isFile()&&actualFile.length() > 0;
if (!gotPatch)
error= PatchMessages.InputPatchPage_FileSelectedNotPatch_message;
}
}
} else {
error= PatchMessages.InputPatchPage_NoFileName_message;
}
}
setPageComplete(gotPatch);
if (fShowError)
setErrorMessage(error);
}
protected void handlePatchFileBrowseButtonPressed() {
FileDialog dialog= new FileDialog(getShell(), SWT.NONE);
dialog.setText(PatchMessages.InputPatchPage_SelectPatchFileDialog_title);
String patchFilePath= getPatchFilePath();
if (patchFilePath != null) {
int lastSegment= patchFilePath.lastIndexOf(File.separatorChar);
if (lastSegment > 0) {
patchFilePath= patchFilePath.substring(0, lastSegment);
}
}
dialog.setFilterPath(patchFilePath);
String res= dialog.open();
if (res == null)
return;
patchFilePath= dialog.getFileName();
IPath filterPath= new Path(dialog.getFilterPath());
IPath path= filterPath.append(patchFilePath).makeAbsolute();
patchFilePath= path.toOSString();
//fDialogSettings.put(IUIConstants.DIALOGSTORE_LASTEXTJAR, filterPath.toOSString());
fPatchFileNameField.setText(patchFilePath);
//setSourceName(patchFilePath);
}
/**
* Sets the source name of the import to be the supplied path.
* Adds the name of the path to the list of items in the
* source combo and selects it.
*
* @param path the path to be added
*/
protected void setSourceName(String path) {
if (path.length() > 0) {
String[] currentItems= fPatchFileNameField.getItems();
int selectionIndex= -1;
for (int i= 0; i < currentItems.length; i++)
if (currentItems[i].equals(path))
selectionIndex= i;
if (selectionIndex < 0) { // not found in history
int oldLength= currentItems.length;
String[] newItems= new String[oldLength + 1];
System.arraycopy(currentItems, 0, newItems, 0, oldLength);
newItems[oldLength]= path;
fPatchFileNameField.setItems(newItems);
selectionIndex= oldLength;
}
fPatchFileNameField.select(selectionIndex);
//resetSelection();
}
}
/**
* The Finish button was pressed. Try to do the required work now and answer
* a boolean indicating success. If false is returned then the wizard will
* not close.
*
* @return boolean
*/
public boolean finish() {
// if (!ensureSourceIsValid())
// return false;
saveWidgetValues();
// Iterator resourcesEnum= getSelectedResources().iterator();
// List fileSystemObjects= new ArrayList();
// while (resourcesEnum.hasNext()) {
// fileSystemObjects.add(
// ((FileSystemElement) resourcesEnum.next()).getFileSystemObject());
// }
//
// if (fileSystemObjects.size() > 0)
// return importResources(fileSystemObjects);
//
// MessageDialog
// .openInformation(
// getContainer().getShell(),
// DataTransferMessages.getString("DataTransfer.information"), //$NON-NLS-1$
// DataTransferMessages.getString("FileImport.noneSelected")); //$NON-NLS-1$
//
// return false;
return true;
}
/**
* Use the dialog store to restore widget values to the values that they held
* last time this wizard was used to completion
*/
private void restoreWidgetValues() {
int inputMethod= FILE;
IDialogSettings settings= getDialogSettings();
if (settings != null) {
try {
inputMethod= settings.getInt(STORE_INPUT_METHOD_ID);
} catch (NumberFormatException ex) {
//OK - no value stored in settings; just use CLIPBOARD
}
// set filenames history
String[] sourceNames= settings.getArray(STORE_PATCH_FILES_ID);
if (sourceNames != null)
for (int i= 0; i < sourceNames.length; i++)
if (sourceNames[i] != null && sourceNames[i].length() > 0)
fPatchFileNameField.add(sourceNames[i]);
// set patch file path
String patchFilePath= settings.get(STORE_PATCH_FILES_ID);
if (patchFilePath != null)
setSourceName(patchFilePath);
// set URLs history
String[] sourceURLs= settings.getArray(STORE_PATCH_URLS_ID);
if (sourceURLs != null)
for (int i= 0; i < sourceURLs.length; i++)
if (sourceURLs[i] != null && sourceURLs[i].length() > 0)
fPatchURLField.add(sourceURLs[i]);
// If the previous apply patch was used with a clipboard, we need to check
// if there is a valid patch on the clipboard. This will be done in adjustToCurrentTarget()
// so just set it to FILE now and, if there exists a patch on the clipboard, then clipboard
// will be selected automatically
if (inputMethod == CLIPBOARD){
inputMethod= FILE;
fPatchFileNameField.deselectAll();
}
//set the workspace patch selection
String workspaceSetting= settings.get(STORE_WORKSPACE_PATH_ID);
if (workspaceSetting != null && workspaceSetting.length() > 0) {
// See if this resource still exists in the workspace
try {
IPath path= new Path(workspaceSetting);
IFile targetFile= ResourcesPlugin.getWorkspace().getRoot().getFile(path);
if (fTreeViewer != null && targetFile.exists()){
fTreeViewer.expandToLevel(targetFile, 0);
fTreeViewer.setSelection(new StructuredSelection(targetFile));
}
} catch (RuntimeException e) {
// Ignore. The setting was invalid
}
} else {
//check to see if the current input is set to workspace - if it is switch it
//back to clipboard since there is no corresponding element to go along with
//the tree viewer
if (inputMethod == WORKSPACE)
inputMethod= FILE;
}
}
// set radio buttons state
setInputButtonState(inputMethod);
}
/**
* Since Finish was pressed, write widget values to the dialog store so that they
* will persist into the next invocation of this wizard page
*/
void saveWidgetValues() {
IDialogSettings settings= getDialogSettings();
if (settings != null) {
settings.put(STORE_INPUT_METHOD_ID, getInputMethod());
settings.put(STORE_PATCH_FILES_ID, getPatchFilePath());
// update source names history
String[] sourceNames= settings.getArray(STORE_PATCH_FILES_ID);
if (sourceNames == null)
sourceNames= new String[0];
sourceNames= addToHistory(sourceNames, getPatchFilePath());
settings.put(STORE_PATCH_FILES_ID, sourceNames);
// update source URLs history
String[] sourceURLs= settings.getArray(STORE_PATCH_URLS_ID);
if (sourceURLs == null)
sourceURLs= new String[0];
sourceURLs= addToHistory(sourceURLs, fPatchURLField.getText());
settings.put(STORE_PATCH_URLS_ID, sourceURLs);
// save the workspace selection
settings.put(STORE_WORKSPACE_PATH_ID, getWorkspacePath());
}
}
private String getWorkspacePath() {
if (fTreeViewer != null){
IResource[] resources= Utilities.getResources(fTreeViewer.getSelection());
if (resources.length > 0) {
IResource patchFile= resources[0];
return patchFile.getFullPath().toString();
}
}
return ""; //$NON-NLS-1$
}
// static helpers
/**
* Checks to see if the file that has been selected for Apply Patch is
* actually a patch
*
* @return true if the file selected to run Apply Patch on in the workspace
* is a patch file or if the clipboard contains a patch or if the
* clipboard contains an URL (we assume it points to a patch )
*/
private boolean adjustToCurrentTarget() {
// readjust selection if there is a patch selected in the workspace or on the clipboard
// check workspace first
IResource patchTarget= fPatchWizard.getTarget();
if (patchTarget instanceof IFile) {
Reader reader= null;
try {
try {
reader= new FileReader(patchTarget.getLocation().toFile());
if (isPatchFile(reader)) {
// set choice to workspace
setInputButtonState(WORKSPACE);
if (fTreeViewer != null && patchTarget.exists()) {
fTreeViewer.expandToLevel(patchTarget, 0);
fTreeViewer.setSelection(new StructuredSelection(patchTarget));
}
return true;
}
} catch (FileNotFoundException ex) {
// silently ignored
} catch (NullPointerException nex) {
// silently ignored
}
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException x) {
// silently ignored
}
}
}
}
// check out clipboard contents
Reader reader = null;
Control c = getControl();
if (c != null) {
Clipboard clipboard= new Clipboard(c.getDisplay());
Object o= clipboard.getContents(TextTransfer.getInstance());
clipboard.dispose();
try {
if (o instanceof String) {
reader= new StringReader((String) o);
if (isPatchFile(reader)) {
setInputButtonState(CLIPBOARD);
return true;
}
// maybe it's an URL
try {
new URL((String)o);
setInputButtonState(URL);
fPatchURLField.setText((String)o);
return true;
} catch (MalformedURLException e) {
// ignore
}
}
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException x) {
// silently ignored
}
}
}
}
return false;
}
private boolean isPatchFile(Reader reader) {
WorkspacePatcher patcher= ((PatchWizard) getWizard()).getPatcher();
try {
patcher.parse(new BufferedReader(reader));
} catch (Exception ex) {
return false;
}
IFilePatch2[] diffs= patcher.getDiffs();
if (diffs == null || diffs.length == 0)
return false;
return true;
}
/*
* Clears the dialog message box
*/
private void clearErrorMessage(){
setErrorMessage(null);
}
private void setInputButtonState(int state) {
switch (state) {
case CLIPBOARD:
fUseClipboardButton.setSelection(true);
fUsePatchFileButton.setSelection(false);
fUseURLButton.setSelection(false);
fUseWorkspaceButton.setSelection(false);
break;
case FILE:
fUseClipboardButton.setSelection(false);
fUsePatchFileButton.setSelection(true);
fUseURLButton.setSelection(false);
fUseWorkspaceButton.setSelection(false);
break;
case URL:
fUseClipboardButton.setSelection(false);
fUsePatchFileButton.setSelection(false);
fUseURLButton.setSelection(true);
fUseWorkspaceButton.setSelection(false);
break;
case WORKSPACE:
fUseClipboardButton.setSelection(false);
fUsePatchFileButton.setSelection(false);
fUseURLButton.setSelection(false);
fUseWorkspaceButton.setSelection(true);
break;
}
setEnablePatchFile(state == FILE);
setEnableWorkspacePatch(state == WORKSPACE);
setEnableURLPatch(state == URL);
}
protected int getInputMethod() {
if (fUseClipboardButton.getSelection())
return CLIPBOARD;
if (fUsePatchFileButton.getSelection())
return FILE;
if(fUseURLButton.getSelection())
return URL;
return WORKSPACE;
}
private String getPatchFilePath() {
if (fPatchFileNameField != null)
return fPatchFileNameField.getText();
return ""; //$NON-NLS-1$
}
/*
* Adds an entry to a history, while taking care of duplicate history items
* and excessively long histories. The assumption is made that all histories
* should be of length <code>COMBO_HISTORY_LENGTH</code>.
*
* @param history the current history
* @param newEntry the entry to add to the history
*/
protected static String[] addToHistory(String[] history, String newEntry) {
ArrayList<String> l= new ArrayList<>(Arrays.asList(history));
l.remove(newEntry);
l.add(0,newEntry);
// since only one new item was added, we can be over the limit
// by at most one item
if (l.size() > COMBO_HISTORY_LENGTH)
l.remove(COMBO_HISTORY_LENGTH);
return l.toArray(new String[l.size()]);
}
public boolean isPatchRead() {
return fPatchRead;
}
}
