org.eclipse.compare.internal.CompareWithOtherResourceDialog Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of org.eclipse.compare Show documentation
Show all versions of org.eclipse.compare Show documentation
This is org.eclipse.compare jar used by Scout SDK
The newest version!
/*******************************************************************************
* Copyright (c) 2008, 2011 Aleksandra Wozniak 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:
* Aleksandra Wozniak ([email protected]) - initial implementation
* IBM Corporation - Bug 73923 (major refactoring and adjustments)
* IBM Corporation - Bug 241649 - [Dialogs] Resizing of the "compare with other" dialog
*******************************************************************************/
package org.eclipse.compare.internal;
import java.io.FileOutputStream;
import java.io.IOException;
import org.eclipse.compare.CompareConfiguration;
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.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.IMessageProvider;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.TitleAreaDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DragSource;
import org.eclipse.swt.dnd.DragSourceEvent;
import org.eclipse.swt.dnd.DragSourceListener;
import org.eclipse.swt.dnd.DropTarget;
import org.eclipse.swt.dnd.DropTargetEvent;
import org.eclipse.swt.dnd.DropTargetListener;
import org.eclipse.swt.dnd.TextTransfer;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
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.DirectoryDialog;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.forms.events.ExpansionAdapter;
import org.eclipse.ui.forms.events.ExpansionEvent;
import org.eclipse.ui.forms.widgets.ExpandableComposite;
import org.eclipse.ui.part.ResourceTransfer;
/**
* This is a dialog that can invoke the compare editor on chosen files.
*/
public class CompareWithOtherResourceDialog extends TitleAreaDialog {
private int MIN_WIDTH = 320;
private int MIN_HEIGHT_WITH_ANCESTOR = 320;
private int MIN_HEIGHT_WITHOUT_ANCESTOR = 238;
private class FileTextDragListener implements DragSourceListener {
private ContentTypeElement element;
public FileTextDragListener(ContentTypeElement element) {
this.element = element;
}
public void dragFinished(DragSourceEvent event) {
element.setText(""); //$NON-NLS-1$
}
public void dragSetData(DragSourceEvent event) {
event.data = element.getText();
}
public void dragStart(DragSourceEvent event) {
if (element.getText() == null)
event.doit = false;
}
}
private class FileTextDropListener implements DropTargetListener {
private ContentTypeElement element;
private ResourceTransfer resourceTransfer;
private TextTransfer textTransfer;
public FileTextDropListener(ContentTypeElement element) {
this.element = element;
resourceTransfer = ResourceTransfer.getInstance();
textTransfer = TextTransfer.getInstance();
}
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 (resourceTransfer.isSupportedType(event.dataTypes[i])
|| textTransfer.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) {
// intentionally empty
}
public void dragOperationChanged(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;
} else if (resourceTransfer.isSupportedType(event.currentDataType)) {
if (event.detail != DND.DROP_COPY)
event.detail = DND.DROP_NONE;
}
}
public void dragOver(DropTargetEvent event) {
// intentionally empty
}
public void drop(DropTargetEvent event) {
if (textTransfer.isSupportedType(event.currentDataType)) {
String txt = (String) event.data;
IResource r = ResourcesPlugin.getWorkspace().getRoot().findMember(txt);
if (r != null)
element.setResource(r);
} else if (resourceTransfer.isSupportedType(event.currentDataType)) {
IResource[] files = (IResource[]) event.data;
if (files.length > 0)
element.setResource(files[0]);
}
}
public void dropAccept(DropTargetEvent event) {
// intentionally empty
}
}
private abstract class ContentTypeElement {
private Button radioButton;
protected Button mainButton;
protected Text text;
private String type;
protected InternalSection section;
private IResource resource;
public ContentTypeElement(Composite parent, String type, InternalSection section) {
this.type = type;
this.section = section;
createContents(parent);
}
private void createContents(Composite parent) {
createRadioButton(parent);
createText(parent);
createMainButton(parent);
}
private void createRadioButton(Composite parent) {
radioButton = new Button(parent, SWT.RADIO);
radioButton.setText(type);
}
protected void createText(Composite parent) {
text = new Text(parent, SWT.BORDER);
text.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
text.setEditable(false);
}
protected void createMainButton(Composite parent) {
mainButton = new Button(parent, SWT.PUSH);
mainButton.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
}
protected Button getRadioButton() {
return radioButton;
}
protected String getText() {
return text.getText();
}
protected void setText(String string) {
text.setText(string);
}
protected void setEnabled(boolean enabled) {
radioButton.setSelection(enabled);
mainButton.setEnabled(enabled);
text.setEnabled(enabled);
}
protected void setResource(IResource resource) {
this.resource = resource;
section.setResource(resource);
}
public IResource getResource() {
return resource;
}
void clearResource() {
resource = null;
text.setText(""); //$NON-NLS-1$
}
}
private class WorkspaceContent extends ContentTypeElement {
public WorkspaceContent(Composite parent, InternalSection section) {
super(parent, CompareMessages.CompareWithOtherResourceDialog_workspaceRadioButton, section);
}
protected void createMainButton(Composite parent) {
super.createMainButton(parent);
mainButton.setText(CompareMessages.CompareWithOtherResourceDialog_workspaceMainButton);
// temporarily hide this button. For more information about supporting for browsing workspace see bug 243744.
mainButton.setVisible(false);
}
protected void createText(Composite parent) {
super.createText(parent);
text.setEditable(true);
text.addModifyListener(new ModifyListener() {
public void modifyText(ModifyEvent e) {
section.setResource(text.getText());
updateErrorInfo();
}
});
text.addSelectionListener(new SelectionListener() {
public void widgetDefaultSelected(SelectionEvent e) {
widgetSelected(e);
}
public void widgetSelected(SelectionEvent e) {
section.setResource(text.getText());
updateErrorInfo();
}
});
initDrag();
initDrop();
}
protected void setResource(IResource resource) {
super.setResource(resource);
text.setText(resource.getFullPath().toOSString());
}
protected void initDrag() {
DragSource source = new DragSource(text, DND.DROP_MOVE
| DND.DROP_COPY | DND.DROP_DEFAULT);
Transfer[] types = new Transfer[] { TextTransfer.getInstance(),
ResourceTransfer.getInstance() };
source.setTransfer(types);
source.addDragListener(new FileTextDragListener(this));
}
protected void initDrop() {
DropTarget target = new DropTarget(text, DND.DROP_MOVE
| DND.DROP_COPY | DND.DROP_DEFAULT);
Transfer[] types = new Transfer[] { TextTransfer.getInstance(),
ResourceTransfer.getInstance() };
target.setTransfer(types);
target.addDropListener(new FileTextDropListener(this));
}
}
private class ExternalFileContent extends ContentTypeElement {
public ExternalFileContent(Composite parent, InternalSection section) {
super(parent, CompareMessages.CompareWithOtherResourceDialog_externalFileRadioButton, section);
}
protected void createMainButton(Composite parent) {
super.createMainButton(parent);
mainButton.setText(CompareMessages.CompareWithOtherResourceDialog_externalFileMainButton);
mainButton.addSelectionListener(new SelectionListener() {
public void widgetDefaultSelected(SelectionEvent e) {
widgetSelected(e);
}
public void widgetSelected(SelectionEvent e) {
IResource r = tmpProject.getExternalFile();
if (r == null)
return;
setResource(r);
}
});
}
protected void setResource(IResource resource) {
super.setResource(resource);
text.setText(resource.getLocation().toOSString());
}
}
private class ExternalFolderContent extends ContentTypeElement {
public ExternalFolderContent(Composite parent, InternalSection section) {
super(parent, CompareMessages.CompareWithOtherResourceDialog_externalFolderRadioButton, section);
}
protected void createMainButton(Composite parent) {
super.createMainButton(parent);
mainButton.setText(CompareMessages.CompareWithOtherResourceDialog_externalFolderMainButton);
mainButton.addSelectionListener(new SelectionListener() {
public void widgetDefaultSelected(SelectionEvent e) {
widgetSelected(e);
}
public void widgetSelected(SelectionEvent e) {
IResource r = tmpProject.getExternalFolder();
if (r == null)
return;
setResource(r);
}
});
}
protected void setResource(IResource resource) {
super.setResource(resource);
text.setText(resource.getLocation().toOSString());
}
}
private abstract class InternalSection {
// there is no "enum" support in Java 1.4. Sigh...
public static final int WORKSPACE = 0;
public static final int EXTERNAL_FILE = 1;
public static final int EXTERNAL_FOLDER = 2;
protected Group group;
private IResource resource;
ExternalFileContent externalFileContent;
ExternalFolderContent externalFolderContent;
WorkspaceContent workspaceContent;
private InternalSection() {
// not to instantiate
}
protected void createContents(Composite parent) {
group = new Group(parent, SWT.NONE);
group.setLayout(new GridLayout(3, false));
group.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
workspaceContent = new WorkspaceContent(group, this);
externalFileContent = new ExternalFileContent(group, this);
externalFolderContent = new ExternalFolderContent(group, this);
addListenersToRadioButtons();
}
private void addListenersToRadioButtons() {
final ContentTypeElement[] elements = new ContentTypeElement[] { workspaceContent,
externalFileContent, externalFolderContent };
for (int i = 0; i < elements.length; i++) {
elements[i].getRadioButton().addListener(SWT.Selection, new Listener() {
public void handleEvent(Event event) {
for (int j = 0; j < elements.length; j++) {
if (event.widget != elements[j].getRadioButton())
elements[j].setEnabled(false);
else {
elements[j].setEnabled(true);
setResource(elements[j].getResource());
}
}
}
});
}
}
protected IResource getResource() {
return resource;
}
protected void setResource(IResource resource) {
this.resource = resource;
updateErrorInfo();
}
protected void setResource(String s) {
IResource tmp = ResourcesPlugin.getWorkspace().getRoot()
.findMember(s);
if (tmp instanceof IWorkspaceRoot)
resource = null;
else
resource = tmp;
updateErrorInfo();
}
protected void clearResource() {
resource = null;
workspaceContent.clearResource();
externalFileContent.clearResource();
externalFolderContent.clearResource();
updateErrorInfo();
}
protected void setContentType(int type) {
switch(type) {
case WORKSPACE:
workspaceContent.setEnabled(true);
externalFileContent.setEnabled(false);
externalFolderContent.setEnabled(false);
break;
case EXTERNAL_FILE:
workspaceContent.setEnabled(false);
externalFileContent.setEnabled(true);
externalFolderContent.setEnabled(false);
break;
case EXTERNAL_FOLDER:
workspaceContent.setEnabled(false);
externalFileContent.setEnabled(false);
externalFolderContent.setEnabled(true);
}
}
}
private class InternalGroup extends InternalSection {
public InternalGroup(Composite parent) {
createContents(parent);
}
public void setText(String text) {
group.setText(text);
}
public void setLayoutData(GridData layoutData) {
group.setLayoutData(layoutData);
}
}
private class InternalExpandable extends InternalSection {
private ExpandableComposite expandable;
private Button clearButton;
public InternalExpandable(Composite parent) {
createContents(parent);
}
protected void createContents(Composite parent) {
final Composite p = parent;
expandable = new ExpandableComposite(parent, SWT.NONE,
ExpandableComposite.TREE_NODE | ExpandableComposite.TWISTIE);
super.createContents(expandable);
createClearButton(group);
expandable.setClient(group);
expandable.addExpansionListener(new ExpansionAdapter() {
public void expansionStateChanged(ExpansionEvent e) {
p.layout();
adjustSize(e.getState());
}
});
}
private void createClearButton(Composite parent) {
clearButton = new Button(parent, SWT.PUSH);
clearButton.setText(CompareMessages.CompareWithOtherResourceDialog_clear);
clearButton.addSelectionListener(new SelectionListener() {
public void widgetDefaultSelected(SelectionEvent e) {
widgetSelected(e);
}
public void widgetSelected(SelectionEvent e) {
clearResource();
}
});
}
public void setText(String text) {
expandable.setText(text);
group.setText(text);
}
public void setLayoutData(GridData layoutData) {
expandable.setLayoutData(layoutData);
}
}
private class ExternalResourcesProject {
// Implementation based on org.eclipse.jdt.internal.core.ExternalFoldersManager
private int counter = 0;
private static final String TMP_PROJECT_NAME = ".org.eclipse.compare.tmp"; //$NON-NLS-1$
private final static String TMP_PROJECT_FILE = "\n" //$NON-NLS-1$
+ "\n" //$NON-NLS-1$
+ "\t" + TMP_PROJECT_NAME + "\t \n" //$NON-NLS-1$ //$NON-NLS-2$
+ "\t\n" //$NON-NLS-1$
+ "\t \n" //$NON-NLS-1$
+ "\t\n" //$NON-NLS-1$
+ "\t \n" //$NON-NLS-1$
+ "\t\n" + "\t \n" //$NON-NLS-1$//$NON-NLS-2$
+ " "; //$NON-NLS-1$
private final static String TMP_FOLDER_NAME = "tmpFolder"; //$NON-NLS-1$
private ExternalResourcesProject() {
// nothing to do here
}
private IProject createTmpProject() throws CoreException {
IProject project = getTmpProject();
if (!project.isAccessible()) {
try {
IPath stateLocation = CompareUI.getPlugin().getStateLocation();
if (!project.exists()) {
IProjectDescription desc = project.getWorkspace()
.newProjectDescription(project.getName());
desc.setLocation(stateLocation.append(TMP_PROJECT_NAME));
project.create(desc, null);
}
try {
project.open(null);
} catch (CoreException e) { // in case .project file or folder has been deleted
IPath projectPath = stateLocation.append(TMP_PROJECT_NAME);
projectPath.toFile().mkdirs();
FileOutputStream output = new FileOutputStream(
projectPath.append(".project").toOSString()); //$NON-NLS-1$
try {
output.write(TMP_PROJECT_FILE.getBytes());
} finally {
output.close();
}
project.open(null);
}
getTmpFolder(project);
} catch (IOException ioe) {
return project;
} catch (CoreException ce) {
throw new CoreException(ce.getStatus());
}
}
project.setHidden(true);
return project;
}
private IFolder getTmpFolder(IProject project) throws CoreException {
IFolder folder = project.getFolder(TMP_FOLDER_NAME);
if (!folder.exists())
folder.create(IResource.NONE, true, null);
return folder;
}
private IFile getExternalFile() {
FileDialog dialog = new FileDialog(getShell());
String path = dialog.open();
if (path != null)
return (IFile) linkResource(new Path(path));
return null;
}
private IFolder getExternalFolder() {
DirectoryDialog dialog = new DirectoryDialog(getShell());
String path = dialog.open();
if (path != null)
return (IFolder) linkResource(new Path(path));
return null;
}
private IResource linkResource(IPath path) {
IResource r = null;
String resourceName = path.lastSegment();
try {
IProject project = createTmpProject();
if (!project.isOpen())
project.open(null);
if (path.toFile().isFile()) {
r = getTmpFolder(project).getFile(resourceName);
if (r.exists()) { // add a number to file's name when there already is a file with that name in a folder
String extension = path.getFileExtension();
String fileName = path.removeFileExtension().lastSegment();
r = getTmpFolder(project).getFile(getName(fileName, extension));
}
((IFile)r).createLink(path, IResource.REPLACE, null);
} else { // isDirectory
r = getTmpFolder(project).getFolder(resourceName);
if (r.exists()) {
r = getTmpFolder(project).getFolder(getName(resourceName, null));
}
((IFolder)r).createLink(path, IResource.REPLACE, null);
}
} catch (CoreException e) {
CompareUIPlugin.log(e);
MessageDialog.openError(getShell(),
CompareMessages.CompareWithOtherResourceDialog_externalFile_errorTitle,
CompareMessages.CompareWithOtherResourceDialog_externalFile_errorMessage);
}
return r;
}
/**
* This method is used to prevent duplicating names of linked resources.
* It adds a suffix based on the counter value.
*
* @param name
* @param extension optional
* @return
*/
private String getName(String name, String extension) {
if (counter != 0) {
name = name + "-" + counter; //$NON-NLS-1$
}
// at most 3 resources at the same time with the same name:
// left, right, ancestor
counter = (counter + 1) % 3;
if (extension != null) {
name += "." + extension; //$NON-NLS-1$
}
// don't change the name if counter equals 0
return name;
}
private IProject getTmpProject() {
return ResourcesPlugin.getWorkspace().getRoot().getProject(
TMP_PROJECT_NAME);
}
}
private Button okButton;
private InternalGroup rightPanel, leftPanel;
private InternalExpandable ancestorPanel;
private ISelection selection;
private ExternalResourcesProject tmpProject = new ExternalResourcesProject();
/**
* Creates the dialog.
*
* @param shell
* a shell
* @param selection
* if the selection is not null, it will be set as initial files
* for comparison
* @since 3.4
*/
protected CompareWithOtherResourceDialog(Shell shell, ISelection selection) {
super(shell);
setShellStyle(SWT.MODELESS | SWT.RESIZE | SWT.MAX);
this.selection = selection;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets
* .Composite)
*/
protected Control createDialogArea(Composite parent) {
Composite mainPanel = new Composite(parent, SWT.NULL);
mainPanel.setLayout(new GridLayout(1, true));
mainPanel.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
ancestorPanel = new InternalExpandable(mainPanel);
ancestorPanel.setText(CompareMessages.CompareWithOtherResourceDialog_ancestor);
GridData ancestorGD = new GridData(SWT.FILL, SWT.FILL, true, false);
ancestorPanel.setLayoutData(ancestorGD);
leftPanel = new InternalGroup(mainPanel);
leftPanel.setText(CompareMessages.CompareWithOtherResourceDialog_leftPanel);
leftPanel.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
rightPanel = new InternalGroup(mainPanel);
rightPanel.setText(CompareMessages.CompareWithOtherResourceDialog_rightPanel);
rightPanel.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
setSelection(selection);
getShell().setText(CompareMessages.CompareWithOtherResourceDialog_dialogTitle);
setTitle(CompareMessages.CompareWithOtherResourceDialog_dialogMessage);
adjustSize(ancestorPanel.expandable.isExpanded());
return mainPanel;
}
private void adjustSize(boolean expanded) {
int minWidth = convertHorizontalDLUsToPixels(MIN_WIDTH);
int minHeight = convertVerticalDLUsToPixels(expanded ? MIN_HEIGHT_WITH_ANCESTOR
: MIN_HEIGHT_WITHOUT_ANCESTOR);
getShell().setMinimumSize(minWidth, minHeight);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.jface.dialogs.Dialog#createButtonsForButtonBar(org.eclipse
* .swt.widgets.Composite)
*/
protected void createButtonsForButtonBar(Composite parent) {
super.createButtonsForButtonBar(parent);
okButton = getButton(IDialogConstants.OK_ID);
updateErrorInfo();
setMessage(CompareMessages.CompareWithOtherResourceDialog_info);
}
private void setSelection(ISelection selection) {
IResource[] selectedResources = Utilities.getResources(selection);
switch (selectedResources.length) {
case 1:
leftPanel.workspaceContent.setResource(selectedResources[0]);
break;
case 2:
leftPanel.workspaceContent.setResource(selectedResources[0]);
rightPanel.workspaceContent.setResource(selectedResources[1]);
break;
case 3:
ancestorPanel.workspaceContent.setResource(selectedResources[0]);
ancestorPanel.expandable.setExpanded(true);
leftPanel.workspaceContent.setResource(selectedResources[1]);
rightPanel.workspaceContent.setResource(selectedResources[2]);
break;
}
setInitialContentTypes();
}
private void setInitialContentTypes() {
ancestorPanel.setContentType(InternalSection.WORKSPACE);
leftPanel.setContentType(InternalSection.WORKSPACE);
rightPanel.setContentType(InternalSection.WORKSPACE);
}
private boolean isComparePossible() {
IResource[] resources;
if (ancestorPanel.getResource() == null)
resources = new IResource[] { leftPanel.getResource(),
rightPanel.getResource() };
else
resources = new IResource[] { ancestorPanel.getResource(),
leftPanel.getResource(), rightPanel.getResource() };
ResourceCompareInput r = new ResourceCompareInput(
new CompareConfiguration());
return r.isEnabled(new StructuredSelection(resources));
}
private void updateErrorInfo() {
if (okButton != null) {
if (leftPanel.getResource() == null
|| rightPanel.getResource() == null) {
setMessage(CompareMessages.CompareWithOtherResourceDialog_error_empty,
IMessageProvider.ERROR);
okButton.setEnabled(false);
} else if (!isComparePossible()) {
setMessage(
CompareMessages.CompareWithOtherResourceDialog_error_not_comparable,
IMessageProvider.ERROR);
okButton.setEnabled(false);
} else {
setMessage(CompareMessages.CompareWithOtherResourceDialog_info);
okButton.setEnabled(true);
}
}
}
/**
* Returns table with selected resources. If any resource wasn't chosen in
* the ancestor panel, table has only two elements -- resources chosen in
* left and right panel. In the other case table contains all three
* resources.
*
* @return table with selected resources
*/
public IResource[] getResult() {
IResource[] resources;
IResource rightResource = rightPanel.getResource();
IResource leftResource = leftPanel.getResource();
IResource ancestorResource = ancestorPanel.getResource();
if (ancestorResource == null)
resources = new IResource[] { leftResource, rightResource };
else
resources = new IResource[] { ancestorResource, leftResource,
rightResource };
return resources;
}
/*
* @see org.eclipse.jface.dialogs.Dialog#getDialogBoundsSettings()
*/
protected IDialogSettings getDialogBoundsSettings() {
String sectionName = getClass().getName() + "_dialogBounds"; //$NON-NLS-1$
IDialogSettings settings = CompareUIPlugin.getDefault()
.getDialogSettings();
IDialogSettings section = settings.getSection(sectionName);
if (section == null)
section = settings.addNewSection(sectionName);
return section;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy