issue_id
int64 2.04k
425k
| title
stringlengths 9
251
| body
stringlengths 4
32.8k
⌀ | status
stringclasses 6
values | after_fix_sha
stringlengths 7
7
| project_name
stringclasses 6
values | repo_url
stringclasses 6
values | repo_name
stringclasses 6
values | language
stringclasses 1
value | issue_url
null | before_fix_sha
null | pull_url
null | commit_datetime
timestamp[us, tz=UTC] | report_datetime
timestamp[us, tz=UTC] | updated_file
stringlengths 23
187
| chunk_content
stringlengths 1
22k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
14,525 |
Bug 14525 Visual confirmation should be given when adding interfaces
|
BUILD: 20020412 When using the Interface Selection dialog, the user should be given some sort of visual confirmation that the interfaces they select have actually been added after hitting the Add button. Perhaps placing a check mark next to interfaces that have already been added, or keeping a separate list inside the dialog of previously added interfaces. The latter sugegstion opens up the possibility of removing interfaces from the list of currently selected ones.
|
resolved fixed
|
ec79c7f
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T12:40:48Z | 2002-04-24T14:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/SuperInterfaceSelectionDialog.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.wizards;
import java.util.List;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.operation.IRunnableContext;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.search.IJavaSearchConstants;
import org.eclipse.jdt.core.search.IJavaSearchScope;
import org.eclipse.jdt.core.search.SearchEngine;
import org.eclipse.jdt.internal.corext.util.TypeInfo;
import org.eclipse.jdt.internal.ui.dialogs.TypeSelectionDialog;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.ListDialogField;
public class SuperInterfaceSelectionDialog extends TypeSelectionDialog {
private static final int ADD_ID= IDialogConstants.CLIENT_ID + 1;
|
14,525 |
Bug 14525 Visual confirmation should be given when adding interfaces
|
BUILD: 20020412 When using the Interface Selection dialog, the user should be given some sort of visual confirmation that the interfaces they select have actually been added after hitting the Add button. Perhaps placing a check mark next to interfaces that have already been added, or keeping a separate list inside the dialog of previously added interfaces. The latter sugegstion opens up the possibility of removing interfaces from the list of currently selected ones.
|
resolved fixed
|
ec79c7f
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T12:40:48Z | 2002-04-24T14:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/SuperInterfaceSelectionDialog.java
|
private ListDialogField fList;
private List fOldContent;
public SuperInterfaceSelectionDialog(Shell parent, IRunnableContext context, ListDialogField list, IJavaProject p) {
super(parent, context, IJavaSearchConstants.INTERFACE, createSearchScope(p));
fList= list;
fOldContent= fList.getElements();
}
/*
* @see Dialog#createButtonsForButtonBar
*/
protected void createButtonsForButtonBar(Composite parent) {
createButton(parent, ADD_ID, NewWizardMessages.getString("SuperInterfaceSelectionDialog.addButton.label"), true);
super.createButtonsForButtonBar(parent);
}
/*
* @see Dialog#cancelPressed
*/
protected void cancelPressed() {
fList.setElements(fOldContent);
super.cancelPressed();
}
/*
* @see Dialog#buttonPressed
*/
protected void buttonPressed(int buttonId) {
if (buttonId == ADD_ID){
addSelectedInterface();
|
14,525 |
Bug 14525 Visual confirmation should be given when adding interfaces
|
BUILD: 20020412 When using the Interface Selection dialog, the user should be given some sort of visual confirmation that the interfaces they select have actually been added after hitting the Add button. Perhaps placing a check mark next to interfaces that have already been added, or keeping a separate list inside the dialog of previously added interfaces. The latter sugegstion opens up the possibility of removing interfaces from the list of currently selected ones.
|
resolved fixed
|
ec79c7f
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T12:40:48Z | 2002-04-24T14:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/SuperInterfaceSelectionDialog.java
|
}
super.buttonPressed(buttonId);
}
/*
* @see Dialog#okPressed
*/
protected void okPressed() {
addSelectedInterface();
super.okPressed();
}
private void addSelectedInterface(){
Object ref= getLowerSelectedElement();
if (ref instanceof TypeInfo)
fList.addElement(((TypeInfo)ref).getFullyQualifiedName());
}
private static IJavaSearchScope createSearchScope(IJavaProject p) {
return SearchEngine.createJavaSearchScope(new IJavaProject[] { p });
}
/*
* @see AbstractElementListSelectionDialog#handleDefaultSelected()
*/
protected void handleDefaultSelected() {
if (validateCurrentSelection())
buttonPressed(ADD_ID);
}
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/BuildPathsPropertyPage.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.preferences;
import java.lang.reflect.InvocationTargetException;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.ui.actions.WorkspaceModifyDelegatingOperation;
import org.eclipse.ui.dialogs.PropertyPage;
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/BuildPathsPropertyPage.java
|
import org.eclipse.ui.help.DialogPageContextComputer;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.JavaUIMessages;
import org.eclipse.jdt.internal.ui.dialogs.StatusUtil;
import org.eclipse.jdt.internal.ui.util.ExceptionHandler;
import org.eclipse.jdt.internal.ui.wizards.IStatusChangeListener;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.BuildPathsBlock;
/**
* Property page for configuring the Java build path
*/
public class BuildPathsPropertyPage extends PropertyPage implements IStatusChangeListener {
private BuildPathsBlock fBuildPathsBlock;
/*
* @see PreferencePage#createControl(Composite)
*/
protected Control createContents(Composite parent) {
WorkbenchHelp.setHelp(parent, IJavaHelpContextIds.BUILD_PATH_PROPERTY_PAGE);
noDefaultAndApplyButton();
IProject project= getProject();
if (project == null || !isJavaProject(project)) {
return createWithoutJava(parent);
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/BuildPathsPropertyPage.java
|
} else if (!project.isOpen()) {
return createForClosedProject(parent);
} else {
return createWithJava(parent, project);
}
}
/**
* Content for valid projects.
*/
private Control createWithJava(Composite parent, IProject project) {
IWorkspaceRoot root= JavaPlugin.getWorkspace().getRoot();
fBuildPathsBlock= new BuildPathsBlock(root, this, false);
fBuildPathsBlock.init(JavaCore.create(project), null, null);
return fBuildPathsBlock.createControl(parent);
}
/**
* Content for non-Java projects.
*/
private Control createWithoutJava(Composite parent) {
Label label= new Label(parent, SWT.LEFT);
label.setText(JavaUIMessages.getString("BuildPathsPropertyPage.no_java_project.message"));
fBuildPathsBlock= null;
setValid(true);
return label;
}
/**
* Content for closed projects.
*/
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/BuildPathsPropertyPage.java
|
private Control createForClosedProject(Composite parent) {
Label label= new Label(parent, SWT.LEFT);
label.setText(JavaUIMessages.getString("BuildPathsPropertyPage.closed_project.message"));
fBuildPathsBlock= null;
setValid(true);
return label;
}
private IProject getProject() {
IAdaptable adaptable= getElement();
if (adaptable != null) {
IJavaElement elem= (IJavaElement) adaptable.getAdapter(IJavaElement.class);
if (elem instanceof IJavaProject) {
return ((IJavaProject) elem).getProject();
}
}
return null;
}
private boolean isJavaProject(IProject proj) {
try {
return proj.hasNature(JavaCore.NATURE_ID);
} catch (CoreException e) {
JavaPlugin.log(e);
}
return false;
}
/*
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/BuildPathsPropertyPage.java
|
* @see IPreferencePage#performOk
*/
public boolean performOk() {
if (fBuildPathsBlock != null) {
IRunnableWithProgress runnable= fBuildPathsBlock.getRunnable();
IRunnableWithProgress op= new WorkspaceModifyDelegatingOperation(runnable);
Shell shell= getControl().getShell();
try {
new ProgressMonitorDialog(shell).run(true, true, op);
} catch (InvocationTargetException e) {
String title= JavaUIMessages.getString("BuildPathsPropertyPage.error.title");
String message= JavaUIMessages.getString("BuildPathsPropertyPage.error.message");
ExceptionHandler.handle(e, shell, title, message);
return false;
} catch (InterruptedException e) {
return false;
}
}
return true;
}
/**
* @see IStatusChangeListener#statusChanged
*/
public void statusChanged(IStatus status) {
setValid(!status.matches(IStatus.ERROR));
StatusUtil.applyToStatusLine(this, status);
}
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.wizards;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
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.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.ui.actions.WorkspaceModifyDelegatingOperation;
import org.eclipse.ui.dialogs.ElementListSelectionDialog;
import org.eclipse.ui.dialogs.ElementTreeSelectionDialog;
import org.eclipse.ui.dialogs.ISelectionStatusValidator;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.ui.model.WorkbenchContentProvider;
import org.eclipse.ui.model.WorkbenchLabelProvider;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.ui.JavaElementLabelProvider;
import org.eclipse.jdt.ui.wizards.NewElementWizardPage;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.dialogs.StatusDialog;
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
import org.eclipse.jdt.internal.ui.util.CoreUtility;
import org.eclipse.jdt.internal.ui.util.ExceptionHandler;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.BuildPathsBlock;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.DialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IDialogFieldListener;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IStringButtonAdapter;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.LayoutUtil;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.SelectionButtonDialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.Separator;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.StringButtonDialogField;
public class NewSourceFolderWizardPage extends NewElementWizardPage {
private static final String PAGE_NAME= "NewSourceFolderWizardPage";
private StringButtonDialogField fProjectField;
private StatusInfo fProjectStatus;
private StringButtonDialogField fRootDialogField;
private StatusInfo fRootStatus;
private SelectionButtonDialogField fEditClassPathField;
private IWorkspaceRoot fWorkspaceRoot;
private IJavaProject fCurrJProject;
private IClasspathEntry[] fEntries;
private IPath fOutputLocation;
private IPackageFragmentRoot fCreatedRoot;
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
public NewSourceFolderWizardPage() {
super(PAGE_NAME);
setTitle(NewWizardMessages.getString("NewSourceFolderWizardPage.title"));
setDescription(NewWizardMessages.getString("NewSourceFolderWizardPage.description"));
fWorkspaceRoot= ResourcesPlugin.getWorkspace().getRoot();
RootFieldAdapter adapter= new RootFieldAdapter();
fProjectField= new StringButtonDialogField(adapter);
fProjectField.setDialogFieldListener(adapter);
fProjectField.setLabelText(NewWizardMessages.getString("NewSourceFolderWizardPage.project.label"));
fProjectField.setButtonLabel(NewWizardMessages.getString("NewSourceFolderWizardPage.project.button"));
fRootDialogField= new StringButtonDialogField(adapter);
fRootDialogField.setDialogFieldListener(adapter);
fRootDialogField.setLabelText(NewWizardMessages.getString("NewSourceFolderWizardPage.root.label"));
fRootDialogField.setButtonLabel(NewWizardMessages.getString("NewSourceFolderWizardPage.root.button"));
fEditClassPathField= new SelectionButtonDialogField(SWT.PUSH);
fEditClassPathField.setDialogFieldListener(adapter);
fEditClassPathField.setLabelText(NewWizardMessages.getString("NewSourceFolderWizardPage.editclasspath.button"));
fRootStatus= new StatusInfo();
fProjectStatus= new StatusInfo();
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
public void init(IStructuredSelection selection) {
if (selection == null || selection.isEmpty()) {
setDefaultAttributes();
return;
}
Object selectedElement= selection.getFirstElement();
if (selectedElement == null) {
selectedElement= EditorUtility.getActiveEditorJavaInput();
}
String projPath= null;
if (selectedElement instanceof IResource) {
IProject proj= ((IResource)selectedElement).getProject();
if (proj != null) {
projPath= proj.getFullPath().makeRelative().toString();
}
} else if (selectedElement instanceof IJavaElement) {
IJavaProject jproject= ((IJavaElement)selectedElement).getJavaProject();
if (jproject != null) {
projPath= jproject.getProject().getFullPath().makeRelative().toString();
}
}
if (projPath != null) {
fProjectField.setText(projPath);
fRootDialogField.setText("");
} else {
setDefaultAttributes();
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
}
}
private void setDefaultAttributes() {
String projPath= "";
try {
IProject[] projects= fWorkspaceRoot.getProjects();
for (int i= 0; i < projects.length; i++) {
IProject proj= projects[i];
if (proj.hasNature(JavaCore.NATURE_ID)) {
projPath= proj.getFullPath().makeRelative().toString();
break;
}
}
} catch (CoreException e) {
}
fProjectField.setText(projPath);
fRootDialogField.setText("");
}
/**
* @see WizardPage#createControl
*/
public void createControl(Composite parent) {
initializeDialogUnits(parent);
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
Composite composite= new Composite(parent, SWT.NONE);
GridLayout layout= new GridLayout();
layout.marginWidth= 0;
layout.marginHeight= 0;
layout.numColumns= 3;
composite.setLayout(layout);
fProjectField.doFillIntoGrid(composite, 3);
fRootDialogField.doFillIntoGrid(composite, 3);
fRootDialogField.setFocus();
int maxFieldWidth= convertWidthInCharsToPixels(40);
LayoutUtil.setWidthHint(fProjectField.getTextControl(null), maxFieldWidth);
LayoutUtil.setHorizontalGrabbing(fProjectField.getTextControl(null));
LayoutUtil.setWidthHint(fRootDialogField.getTextControl(null), maxFieldWidth);
(new Separator()).doFillIntoGrid(composite, 3);
fEditClassPathField.doFillIntoGrid(composite, 3);
Control control= fEditClassPathField.getSelectionButton(null);
GridData gd= (GridData) control.getLayoutData();
gd.verticalAlignment= GridData.END;
gd.horizontalAlignment= GridData.BEGINNING;
setControl(composite);
WorkbenchHelp.setHelp(composite, IJavaHelpContextIds.NEW_PACKAGEROOT_WIZARD_PAGE);
}
private class RootFieldAdapter implements IStringButtonAdapter, IDialogFieldListener {
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
public void changeControlPressed(DialogField field) {
packRootChangeControlPressed(field);
}
public void dialogFieldChanged(DialogField field) {
packRootDialogFieldChanged(field);
}
}
private void packRootChangeControlPressed(DialogField field) {
if (field == fRootDialogField) {
IFolder folder= chooseFolder();
if (folder != null) {
IPath path= folder.getFullPath().removeFirstSegments(1);
fRootDialogField.setText(path.toString());
}
} else if (field == fProjectField) {
IJavaProject jproject= chooseProject();
if (jproject != null) {
IPath path= jproject.getProject().getFullPath().makeRelative();
fProjectField.setText(path.toString());
}
}
}
private void packRootDialogFieldChanged(DialogField field) {
if (field == fRootDialogField) {
updateRootStatus();
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
} else if (field == fProjectField) {
updateProjectStatus();
updateRootStatus();
} else if (field == fEditClassPathField) {
if (showClassPathPropertyPage()) {
updateProjectStatus();
updateRootStatus();
}
}
updateStatus(new IStatus[] { fProjectStatus, fRootStatus });
}
private void updateProjectStatus() {
fCurrJProject= null;
String str= fProjectField.getText();
if (str.length() == 0) {
fProjectStatus.setError(NewWizardMessages.getString("NewSourceFolderWizardPage.error.EnterProjectName"));
return;
}
IPath path= new Path(str);
if (path.segmentCount() != 1) {
fProjectStatus.setError(NewWizardMessages.getString("NewSourceFolderWizardPage.error.InvalidProjectPath"));
return;
}
IProject project= fWorkspaceRoot.getProject(path.toString());
if (!project.exists()) {
fProjectStatus.setError(NewWizardMessages.getString("NewSourceFolderWizardPage.error.ProjectNotExists"));
return;
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
}
try {
if (project.hasNature(JavaCore.NATURE_ID)) {
fCurrJProject= JavaCore.create(project);
fEntries= fCurrJProject.getRawClasspath();
fOutputLocation= fCurrJProject.getOutputLocation();
fProjectStatus.setOK();
return;
}
} catch (CoreException e) {
JavaPlugin.log(e);
fCurrJProject= null;
}
fProjectStatus.setError(NewWizardMessages.getString("NewSourceFolderWizardPage.error.NotAJavaProject"));
}
private void updateRootStatus() {
fRootDialogField.enableButton(fCurrJProject != null);
if (fCurrJProject == null) {
return;
}
String str= fRootDialogField.getText();
if (str.length() == 0) {
fRootStatus.setError(NewWizardMessages.getFormattedString("NewSourceFolderWizardPage.error.EnterRootName", fCurrJProject.getProject().getFullPath().toString()));
} else {
IPath path= fCurrJProject.getProject().getFullPath().append(str);
if (!fWorkspaceRoot.getWorkspace().validatePath(path.toString(), IResource.FOLDER).isOK()) {
fRootStatus.setError(NewWizardMessages.getString("NewSourceFolderWizardPage.error.InvalidRootName"));
} else {
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
IResource res= fWorkspaceRoot.findMember(path);
if (res != null) {
if (res.getType() != IResource.FOLDER) {
fRootStatus.setError(NewWizardMessages.getString("NewSourceFolderWizardPage.error.NotAFolder"));
return;
}
}
IClasspathEntry[] newEntries= new IClasspathEntry[fEntries.length + 1];
for (int i= 0; i < fEntries.length; i++) {
IClasspathEntry curr= fEntries[i];
if (curr.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
if (path.equals(curr.getPath())) {
fRootStatus.setError(NewWizardMessages.getString("NewSourceFolderWizardPage.error.AlreadyExisting"));
return;
}
}
newEntries[i]= curr;
}
newEntries[fEntries.length]= JavaCore.newSourceEntry(path);
IStatus status= JavaConventions.validateClasspath(fCurrJProject, newEntries, fOutputLocation);
if (!status.isOK()) {
fRootStatus.setError(status.getMessage());
return;
}
fRootStatus.setOK();
}
}
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
/**
* @see NewElementWizardPage#getRunnable
*/
public IRunnableWithProgress getRunnable() {
return new IRunnableWithProgress() {
public void run(IProgressMonitor monitor) throws InvocationTargetException {
try {
fCreatedRoot= createPackageFragmentRoot(monitor, getShell());
} catch (CoreException e) {
throw new InvocationTargetException(e);
}
}
};
}
protected IPackageFragmentRoot getNewPackageFragmentRoot() {
return fCreatedRoot;
}
protected IPackageFragmentRoot createPackageFragmentRoot(IProgressMonitor monitor, Shell shell) throws CoreException {
String relPath= fRootDialogField.getText();
IFolder folder= fCurrJProject.getProject().getFolder(relPath);
IPath path= folder.getFullPath();
if (!folder.exists()) {
CoreUtility.createFolder(folder, true, true, monitor);
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
IClasspathEntry[] entries= fCurrJProject.getRawClasspath();
IClasspathEntry[] newEntries= new IClasspathEntry[entries.length + 1];
for (int i= entries.length - 1, k= entries.length; i >= 0; i--) {
IClasspathEntry curr= entries[i];
if (k > i && curr.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
newEntries[k--]= JavaCore.newSourceEntry(path);
}
newEntries[k--]= curr;
}
fCurrJProject.setRawClasspath(newEntries, monitor);
return fCurrJProject.getPackageFragmentRoot(folder);
}
private IFolder chooseFolder() {
Class[] acceptedClasses= new Class[] { IFolder.class };
ISelectionStatusValidator validator= new TypedElementSelectionValidator(acceptedClasses, false);
Object[] notWanted= getFilteredExistingContainerEntries();
ViewerFilter filter= new TypedViewerFilter(acceptedClasses, notWanted);
ILabelProvider lp= new WorkbenchLabelProvider();
ITreeContentProvider cp= new WorkbenchContentProvider();
ElementTreeSelectionDialog dialog= new ElementTreeSelectionDialog(getShell(), lp, cp);
dialog.setValidator(validator);
dialog.setTitle(NewWizardMessages.getString("NewSourceFolderWizardPage.ChooseExistingRootDialog.title"));
dialog.setMessage(NewWizardMessages.getString("NewSourceFolderWizardPage.ChooseExistingRootDialog.description"));
dialog.addFilter(filter);
dialog.setInput(fCurrJProject.getProject());
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
IResource res= fWorkspaceRoot.findMember(new Path(fRootDialogField.getText()));
if (res != null) {
dialog.setInitialSelection(res);
}
if (dialog.open() == dialog.OK) {
return (IFolder) dialog.getFirstResult();
}
return null;
}
private IJavaProject chooseProject() {
IJavaProject[] projects;
try {
projects= JavaCore.create(fWorkspaceRoot).getJavaProjects();
} catch (JavaModelException e) {
JavaPlugin.log(e);
projects= new IJavaProject[0];
}
ILabelProvider labelProvider= new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);
ElementListSelectionDialog dialog= new ElementListSelectionDialog(getShell(), labelProvider);
dialog.setTitle(NewWizardMessages.getString("NewSourceFolderWizardPage.ChooseProjectDialog.title"));
dialog.setMessage(NewWizardMessages.getString("NewSourceFolderWizardPage.ChooseProjectDialog.description"));
dialog.setElements(projects);
dialog.setInitialSelections(new Object[] { fCurrJProject });
if (dialog.open() == dialog.OK) {
return (IJavaProject) dialog.getFirstResult();
}
return null;
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
private class EditClassPathDialog extends StatusDialog implements IStatusChangeListener {
private BuildPathsBlock fBuildPathsBlock;
public EditClassPathDialog(Shell parent) {
super(parent);
fBuildPathsBlock= new BuildPathsBlock(fWorkspaceRoot, this, false);
}
public void create() {
super.create();
fBuildPathsBlock.init(fCurrJProject, null, null);
}
protected Control createDialogArea(Composite parent) {
Composite composite= (Composite)super.createDialogArea(parent);
Control inner= fBuildPathsBlock.createControl(composite);
inner.setLayoutData(new org.eclipse.swt.layout.GridData(org.eclipse.swt.layout.GridData.FILL_BOTH));
return composite;
}
public void statusChanged(IStatus status) {
updateStatus(status);
}
protected void buttonPressed(int buttonId) {
if (buttonId == IDialogConstants.OK_ID) {
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
IRunnableWithProgress runnable= fBuildPathsBlock.getRunnable();
if (invokeRunnable(runnable)) {
setReturnCode(OK);
} else {
setReturnCode(CANCEL);
}
}
close();
}
private boolean invokeRunnable(IRunnableWithProgress runnable) {
IRunnableWithProgress op= new WorkspaceModifyDelegatingOperation(runnable);
try {
getWizard().getContainer().run(false, true, op);
} catch (InvocationTargetException e) {
Shell shell= getShell();
String title= NewWizardMessages.getString("NewSourceFolderWizardPage.op_error.title");
String message= NewWizardMessages.getString("NewSourceFolderWizardPage.op_error.message");
ExceptionHandler.handle(e, shell, title, message);
return false;
} catch (InterruptedException e) {
return false;
}
return true;
}
}
private boolean showClassPathPropertyPage() {
EditClassPathDialog dialog= new EditClassPathDialog(getShell());
dialog.setTitle(NewWizardMessages.getString("NewSourceFolderWizardPage.EditClassPathDialog.title"));
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
return (dialog.open() == EditClassPathDialog.OK);
}
private IContainer[] getFilteredExistingContainerEntries() {
if (fCurrJProject == null) {
return new IContainer[0];
}
List res= new ArrayList();
try {
IResource container= fWorkspaceRoot.findMember(fCurrJProject.getOutputLocation());
if (container != null) {
res.add(container);
}
} catch (JavaModelException e) {
JavaPlugin.log(e);
}
for (int i= 0; i < fEntries.length; i++) {
IClasspathEntry elem= fEntries[i];
if (elem.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
IResource container= fWorkspaceRoot.findMember(elem.getPath());
if (container != null) {
res.add(container);
}
}
}
return (IContainer[]) res.toArray(new IContainer[res.size()]);
}
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.wizards.buildpaths;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Image;
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.TabFolder;
import org.eclipse.swt.widgets.TabItem;
import org.eclipse.swt.widgets.Widget;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.dialogs.ElementTreeSelectionDialog;
import org.eclipse.ui.dialogs.ISelectionStatusValidator;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.ui.model.WorkbenchContentProvider;
import org.eclipse.ui.model.WorkbenchLabelProvider;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.launching.JavaRuntime;
import org.eclipse.jdt.internal.corext.javadoc.JavaDocLocations;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.JavaPluginImages;
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
import org.eclipse.jdt.internal.ui.dialogs.StatusUtil;
import org.eclipse.jdt.internal.ui.preferences.JavaBasePreferencePage;
import org.eclipse.jdt.internal.ui.util.CoreUtility;
import org.eclipse.jdt.internal.ui.util.PixelConverter;
import org.eclipse.jdt.internal.ui.util.TabFolderLayout;
import org.eclipse.jdt.internal.ui.viewsupport.ImageDisposer;
import org.eclipse.jdt.internal.ui.wizards.IStatusChangeListener;
import org.eclipse.jdt.internal.ui.wizards.NewWizardMessages;
import org.eclipse.jdt.internal.ui.wizards.TypedElementSelectionValidator;
import org.eclipse.jdt.internal.ui.wizards.TypedViewerFilter;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.CheckedListDialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.DialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IDialogFieldListener;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IStringButtonAdapter;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.LayoutUtil;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.StringButtonDialogField;
public class BuildPathsBlock {
private IWorkspaceRoot fWorkspaceRoot;
private CheckedListDialogField fClassPathList;
private StringButtonDialogField fBuildPathDialogField;
private StatusInfo fClassPathStatus;
private StatusInfo fBuildPathStatus;
private IJavaProject fCurrJProject;
private IPath fOutputLocationPath;
private IStatusChangeListener fContext;
private Control fSWTWidget;
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
private boolean fShowSourceFolderPage;
private SourceContainerWorkbookPage fSourceContainerPage;
private ProjectsWorkbookPage fProjectsPage;
private LibrariesWorkbookPage fLibrariesPage;
private BuildPathBasePage fCurrPage;
public BuildPathsBlock(IWorkspaceRoot root, IStatusChangeListener context, boolean showSourceFolders) {
fWorkspaceRoot= root;
fContext= context;
fShowSourceFolderPage= showSourceFolders;
fSourceContainerPage= null;
fLibrariesPage= null;
fProjectsPage= null;
fCurrPage= null;
BuildPathAdapter adapter= new BuildPathAdapter();
String[] buttonLabels= new String[] {
NewWizardMessages.getString("BuildPathsBlock.classpath.up.button"),
NewWizardMessages.getString("BuildPathsBlock.classpath.down.button"),
null,
NewWizardMessages.getString("BuildPathsBlock.classpath.checkall.button"),
NewWizardMessages.getString("BuildPathsBlock.classpath.uncheckall.button")
};
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
fClassPathList= new CheckedListDialogField(null, buttonLabels, new CPListLabelProvider());
fClassPathList.setDialogFieldListener(adapter);
fClassPathList.setLabelText(NewWizardMessages.getString("BuildPathsBlock.classpath.label"));
fClassPathList.setUpButtonIndex(0);
fClassPathList.setDownButtonIndex(1);
fClassPathList.setCheckAllButtonIndex(3);
fClassPathList.setUncheckAllButtonIndex(4);
fBuildPathDialogField= new StringButtonDialogField(adapter);
fBuildPathDialogField.setButtonLabel(NewWizardMessages.getString("BuildPathsBlock.buildpath.button"));
fBuildPathDialogField.setDialogFieldListener(adapter);
fBuildPathDialogField.setLabelText(NewWizardMessages.getString("BuildPathsBlock.buildpath.label"));
fBuildPathStatus= new StatusInfo();
fClassPathStatus= new StatusInfo();
fCurrJProject= null;
}
public Control createControl(Composite parent) {
fSWTWidget= parent;
PixelConverter converter= new PixelConverter(parent);
Composite composite= new Composite(parent, SWT.NONE);
GridLayout layout= new GridLayout();
layout.marginWidth= 0;
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
layout.numColumns= 1;
composite.setLayout(layout);
TabFolder folder= new TabFolder(composite, SWT.NONE);
folder.setLayout(new TabFolderLayout());
folder.setLayoutData(new GridData(GridData.FILL_BOTH));
folder.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
tabChanged(e.item);
}
});
ImageRegistry imageRegistry= JavaPlugin.getDefault().getImageRegistry();
TabItem item;
fSourceContainerPage= new SourceContainerWorkbookPage(fWorkspaceRoot, fClassPathList, fBuildPathDialogField);
item= new TabItem(folder, SWT.NONE);
item.setText(NewWizardMessages.getString("BuildPathsBlock.tab.source"));
item.setImage(imageRegistry.get(JavaPluginImages.IMG_OBJS_PACKFRAG_ROOT));
item.setData(fSourceContainerPage);
item.setControl(fSourceContainerPage.getControl(folder));
IWorkbench workbench= JavaPlugin.getDefault().getWorkbench();
Image projectImage= workbench.getSharedImages().getImage(ISharedImages.IMG_OBJ_PROJECT);
fProjectsPage= new ProjectsWorkbookPage(fClassPathList);
item= new TabItem(folder, SWT.NONE);
item.setText(NewWizardMessages.getString("BuildPathsBlock.tab.projects"));
item.setImage(projectImage);
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
item.setData(fProjectsPage);
item.setControl(fProjectsPage.getControl(folder));
fLibrariesPage= new LibrariesWorkbookPage(fWorkspaceRoot, fClassPathList);
item= new TabItem(folder, SWT.NONE);
item.setText(NewWizardMessages.getString("BuildPathsBlock.tab.libraries"));
item.setImage(imageRegistry.get(JavaPluginImages.IMG_OBJS_LIBRARY));
item.setData(fLibrariesPage);
item.setControl(fLibrariesPage.getControl(folder));
Image cpoImage= JavaPluginImages.DESC_TOOL_CLASSPATH_ORDER.createImage();
composite.addDisposeListener(new ImageDisposer(cpoImage));
ClasspathOrderingWorkbookPage ordpage= new ClasspathOrderingWorkbookPage(fClassPathList);
item= new TabItem(folder, SWT.NONE);
item.setText(NewWizardMessages.getString("BuildPathsBlock.tab.order"));
item.setImage(cpoImage);
item.setData(ordpage);
item.setControl(ordpage.getControl(folder));
if (fCurrJProject != null) {
fSourceContainerPage.init(fCurrJProject);
fLibrariesPage.init(fCurrJProject);
fProjectsPage.init(fCurrJProject);
}
Composite editorcomp= new Composite(composite, SWT.NONE);
DialogField[] editors= new DialogField[] { fBuildPathDialogField };
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
LayoutUtil.doDefaultLayout(editorcomp, editors, true, 0, 0);
int maxFieldWidth= converter.convertWidthInCharsToPixels(40);
LayoutUtil.setWidthHint(fBuildPathDialogField.getTextControl(null), maxFieldWidth);
LayoutUtil.setHorizontalGrabbing(fBuildPathDialogField.getTextControl(null));
editorcomp.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
if (fShowSourceFolderPage) {
folder.setSelection(0);
fCurrPage= fSourceContainerPage;
} else {
folder.setSelection(3);
fCurrPage= ordpage;
fClassPathList.selectFirstElement();
}
WorkbenchHelp.setHelp(composite, IJavaHelpContextIds.BUILD_PATH_BLOCK);
return composite;
}
private Shell getShell() {
if (fSWTWidget != null) {
return fSWTWidget.getShell();
}
return JavaPlugin.getActiveWorkbenchShell();
}
/**
* Initializes the classpath for the given project. Multiple calls to init are allowed,
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
* but all existing settings will be cleared and replace by the given or default paths.
* @param project The java project to configure. Does not have to exist.
* @param outputLocation The output location to be set in the page. If <code>null</code>
* is passed, jdt default settings are used, or - if the project is an existing Java project- the
* output location of the existing project
* @param classpathEntries The classpath entries to be set in the page. If <code>null</code>
* is passed, jdt default settings are used, or - if the project is an existing Java project - the
* classpath entries of the existing project
*/
public void init(IJavaProject jproject, IPath outputLocation, IClasspathEntry[] classpathEntries) {
fCurrJProject= jproject;
boolean projExists= false;
try {
IProject project= fCurrJProject.getProject();
projExists= (project.exists() && project.getFile(".classpath").exists());
if (projExists) {
if (outputLocation == null) {
outputLocation= fCurrJProject.getOutputLocation();
}
if (classpathEntries == null) {
classpathEntries= fCurrJProject.getRawClasspath();
}
}
} catch (CoreException e) {
JavaPlugin.log(e.getStatus());
}
if (outputLocation == null) {
outputLocation= getDefaultBuildPath(jproject);
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
List newClassPath;
if (classpathEntries == null) {
newClassPath= getDefaultClassPath(jproject);
} else {
newClassPath= new ArrayList();
for (int i= 0; i < classpathEntries.length; i++) {
IClasspathEntry curr= classpathEntries[i];
int entryKind= curr.getEntryKind();
IPath path= curr.getPath();
boolean isExported= curr.isExported();
IResource res= null;
boolean isMissing= false;
if (entryKind != IClasspathEntry.CPE_VARIABLE) {
res= fWorkspaceRoot.findMember(path);
if (res == null) {
isMissing= (entryKind != IClasspathEntry.CPE_LIBRARY || !path.toFile().isFile());
}
} else {
IPath resolvedPath= JavaCore.getResolvedVariablePath(path);
isMissing= (resolvedPath == null) || !resolvedPath.toFile().isFile();
}
CPListElement elem= new CPListElement(entryKind, path, res, curr.getSourceAttachmentPath(), curr.getSourceAttachmentRootPath(), isExported);
if (projExists) {
elem.setIsMissing(isMissing);
}
newClassPath.add(elem);
}
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
List exportedEntries = new ArrayList();
for (int i= 0; i < newClassPath.size(); i++) {
CPListElement curr= (CPListElement) newClassPath.get(i);
if (curr.isExported() || curr.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
exportedEntries.add(curr);
}
}
fBuildPathDialogField.setText(outputLocation.makeRelative().toString());
fClassPathList.setElements(newClassPath);
fClassPathList.setCheckedElements(exportedEntries);
if (fSourceContainerPage != null) {
fSourceContainerPage.init(fCurrJProject);
fProjectsPage.init(fCurrJProject);
fLibrariesPage.init(fCurrJProject);
}
doStatusLineUpdate();
}
/**
* Returns the Java project. Can return <code>null<code> if the page has not
* been initialized.
*/
public IJavaProject getJavaProject() {
return fCurrJProject;
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
/**
* Returns the current output location. Note that the path returned must not be valid.
*/
public IPath getOutputLocation() {
return new Path(fBuildPathDialogField.getText()).makeAbsolute();
}
/**
* Returns the current class path (raw). Note that the entries returned must not be valid.
*/
public IClasspathEntry[] getRawClassPath() {
List elements= fClassPathList.getElements();
int nElements= elements.size();
IClasspathEntry[] entries= new IClasspathEntry[elements.size()];
for (int i= 0; i < nElements; i++) {
CPListElement currElement= (CPListElement) elements.get(i);
entries[i]= currElement.getClasspathEntry();
}
return entries;
}
private List getDefaultClassPath(IJavaProject jproj) {
List list= new ArrayList();
IResource srcFolder;
if (JavaBasePreferencePage.useSrcAndBinFolders()) {
String sourceFolderName= JavaBasePreferencePage.getSourceFolderName();
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
srcFolder= jproj.getProject().getFolder(sourceFolderName);
} else {
srcFolder= jproj.getProject();
}
list.add(new CPListElement(IClasspathEntry.CPE_SOURCE, srcFolder.getFullPath(), srcFolder));
IPath libPath= new Path(JavaRuntime.JRELIB_VARIABLE);
IPath attachPath= new Path(JavaRuntime.JRESRC_VARIABLE);
IPath attachRoot= new Path(JavaRuntime.JRESRCROOT_VARIABLE);
CPListElement elem= new CPListElement(IClasspathEntry.CPE_VARIABLE, libPath, null, attachPath, attachRoot, false);
list.add(elem);
return list;
}
private IPath getDefaultBuildPath(IJavaProject jproj) {
if (JavaBasePreferencePage.useSrcAndBinFolders()) {
String outputLocationName= JavaBasePreferencePage.getOutputLocationName();
return jproj.getProject().getFullPath().append(outputLocationName);
} else {
return jproj.getProject().getFullPath();
}
}
private class BuildPathAdapter implements IStringButtonAdapter, IDialogFieldListener {
public void changeControlPressed(DialogField field) {
buildPathChangeControlPressed(field);
}
public void dialogFieldChanged(DialogField field) {
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
buildPathDialogFieldChanged(field);
}
}
private void buildPathChangeControlPressed(DialogField field) {
if (field == fBuildPathDialogField) {
IContainer container= chooseContainer();
if (container != null) {
fBuildPathDialogField.setText(container.getFullPath().toString());
}
}
}
private void buildPathDialogFieldChanged(DialogField field) {
if (field == fClassPathList) {
updateClassPathStatus();
updateBuildPathStatus();
} else if (field == fBuildPathDialogField) {
updateBuildPathStatus();
}
doStatusLineUpdate();
}
private void doStatusLineUpdate() {
IStatus res= findMostSevereStatus();
fContext.statusChanged(res);
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
private IStatus findMostSevereStatus() {
return StatusUtil.getMoreSevere(fClassPathStatus, fBuildPathStatus);
}
/**
* Validates the build path.
*/
private void updateClassPathStatus() {
fClassPathStatus.setOK();
List elements= fClassPathList.getElements();
boolean entryMissing= false;
IClasspathEntry[] entries= new IClasspathEntry[elements.size()];
for (int i= elements.size()-1 ; i >= 0 ; i--) {
CPListElement currElement= (CPListElement)elements.get(i);
boolean isChecked= fClassPathList.isChecked(currElement);
if (currElement.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
if (!isChecked) {
fClassPathList.setCheckedWithoutUpdate(currElement, true);
}
} else {
currElement.setExported(isChecked);
}
entries[i]= currElement.getClasspathEntry();
entryMissing= entryMissing || currElement.isMissing();
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
if (entryMissing) {
fClassPathStatus.setWarning(NewWizardMessages.getString("BuildPathsBlock.warning.EntryMissing"));
}
if (fCurrJProject.hasClasspathCycle(entries)) {
fClassPathStatus.setWarning(NewWizardMessages.getString("BuildPathsBlock.warning.CycleInClassPath"));
}
}
/**
* Validates output location & build path.
*/
private void updateBuildPathStatus() {
fOutputLocationPath= null;
String text= fBuildPathDialogField.getText();
if ("".equals(text)) {
fBuildPathStatus.setError(NewWizardMessages.getString("BuildPathsBlock.error.EnterBuildPath"));
return;
}
IPath path= getOutputLocation();
IResource res= fWorkspaceRoot.findMember(path);
if (res != null) {
if (res.getType() == IResource.FILE) {
fBuildPathStatus.setError(NewWizardMessages.getString("BuildPathsBlock.error.InvalidBuildPath"));
return;
}
}
fOutputLocationPath= path;
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
List elements= fClassPathList.getElements();
IClasspathEntry[] entries= new IClasspathEntry[elements.size()];
for (int i= elements.size()-1 ; i >= 0 ; i--) {
CPListElement currElement= (CPListElement)elements.get(i);
entries[i]= currElement.getClasspathEntry();
}
IStatus status= JavaConventions.validateClasspath(fCurrJProject, entries, path);
if (!status.isOK()) {
fBuildPathStatus.setError(status.getMessage());
return;
}
if (res != null && res.exists() && fCurrJProject.exists()) {
try {
IPath oldOutputLocation= fCurrJProject.getOutputLocation();
if (!oldOutputLocation.equals(fOutputLocationPath)) {
if (((IContainer)res).members().length > 0) {
fBuildPathStatus.setWarning(NewWizardMessages.getString("BuildPathsBlock.warning.OutputFolderNotEmpty"));
return;
}
}
} catch (CoreException e) {
JavaPlugin.log(e);
}
}
fBuildPathStatus.setOK();
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
/**
* Creates a runnable that sets the configured build paths.
*/
public IRunnableWithProgress getRunnable() {
final List classPathEntries= fClassPathList.getElements();
final IPath path= getOutputLocation();
return new IRunnableWithProgress() {
public void run(IProgressMonitor monitor) throws InvocationTargetException {
if (monitor == null) {
monitor= new NullProgressMonitor();
}
monitor.beginTask(NewWizardMessages.getString("BuildPathsBlock.operationdesc"), 10);
try {
createJavaProject(classPathEntries, path, monitor);
} catch (CoreException e) {
throw new InvocationTargetException(e);
} finally {
monitor.done();
}
}
};
}
/**
* Creates the Java project and sets the configured build path and output location.
* If the project already exists only build paths are updated.
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
*/
private void createJavaProject(List classPathEntries, IPath buildPath, IProgressMonitor monitor) throws CoreException {
if (!fWorkspaceRoot.exists(buildPath)) {
IFolder folder= fWorkspaceRoot.getFolder(buildPath);
CoreUtility.createFolder(folder, true, true, null);
}
monitor.worked(2);
int nEntries= classPathEntries.size();
IClasspathEntry[] classpath= new IClasspathEntry[nEntries];
for (int i= 0; i < nEntries; i++) {
CPListElement entry= ((CPListElement)classPathEntries.get(i));
IResource res= entry.getResource();
if ((res instanceof IFolder) && !res.exists()) {
CoreUtility.createFolder((IFolder)res, true, true, null);
}
classpath[i]= entry.getClasspathEntry();
URL javadocLocation= entry.getJavadocLocation();
if (javadocLocation != null) {
IPath path= entry.getPath();
if (entry.getEntryKind() == IClasspathEntry.CPE_VARIABLE) {
path= JavaCore.getResolvedVariablePath(path);
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
if (path != null) {
JavaDocLocations.setLibraryJavadocLocation(path, javadocLocation);
}
}
}
monitor.worked(1);
fCurrJProject.setRawClasspath(classpath, buildPath, new SubProgressMonitor(monitor, 7));
}
private IContainer chooseContainer() {
Class[] acceptedClasses= new Class[] { IProject.class, IFolder.class };
ISelectionStatusValidator validator= new TypedElementSelectionValidator(acceptedClasses, false);
IProject[] allProjects= fWorkspaceRoot.getProjects();
ArrayList rejectedElements= new ArrayList(allProjects.length);
IProject currProject= fCurrJProject.getProject();
for (int i= 0; i < allProjects.length; i++) {
if (!allProjects[i].equals(currProject)) {
rejectedElements.add(allProjects[i]);
}
}
ViewerFilter filter= new TypedViewerFilter(acceptedClasses, rejectedElements.toArray());
ILabelProvider lp= new WorkbenchLabelProvider();
ITreeContentProvider cp= new WorkbenchContentProvider();
IResource initSelection= null;
if (fOutputLocationPath != null) {
initSelection= fWorkspaceRoot.findMember(fOutputLocationPath);
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
ElementTreeSelectionDialog dialog= new ElementTreeSelectionDialog(getShell(), lp, cp);
dialog.setTitle(NewWizardMessages.getString("BuildPathsBlock.ChooseOutputFolderDialog.title"));
dialog.setValidator(validator);
dialog.setMessage(NewWizardMessages.getString("BuildPathsBlock.ChooseOutputFolderDialog.description"));
dialog.addFilter(filter);
dialog.setInput(fWorkspaceRoot);
dialog.setInitialSelection(initSelection);
if (dialog.open() == dialog.OK) {
return (IContainer)dialog.getFirstResult();
}
return null;
}
private void tabChanged(Widget widget) {
if (widget instanceof TabItem) {
BuildPathBasePage newPage= (BuildPathBasePage) ((TabItem) widget).getData();
if (fCurrPage != null) {
List selection= fCurrPage.getSelection();
if (!selection.isEmpty()) {
newPage.setSelection(selection);
}
}
fCurrPage= newPage;
}
}
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/wizards/JavaCapabilityConfigurationPage.java
|
package org.eclipse.jdt.ui.wizards;
import java.lang.reflect.InvocationTargetException;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.wizards.IStatusChangeListener;
import org.eclipse.jdt.internal.ui.wizards.NewWizardMessages;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.BuildPathsBlock;
/**
*/
public class JavaCapabilityConfigurationPage extends NewElementWizardPage {
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/wizards/JavaCapabilityConfigurationPage.java
|
private static final String PAGE_NAME= "JavaCapabilityConfigurationPage";
private IJavaProject fJavaProject;
private BuildPathsBlock fBuildPathsBlock;
/**
* Creates a wizard page that can be used in a Java project creation wizard.
* It contains controls to configure a the classpath and the output folder.
*
* <p>
* After constructing, a call to <code>init</code> is required
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/wizards/JavaCapabilityConfigurationPage.java
|
* </p>
*/
public JavaCapabilityConfigurationPage() {
super(PAGE_NAME);
fJavaProject= null;
setTitle(NewWizardMessages.getString("JavaCapabilityConfigurationPage.title"));
setDescription(NewWizardMessages.getString("JavaCapabilityConfigurationPage.description"));
IStatusChangeListener listener= new IStatusChangeListener() {
public void statusChanged(IStatus status) {
updateStatus(status);
}
};
fBuildPathsBlock= new BuildPathsBlock(ResourcesPlugin.getWorkspace().getRoot(), listener, true);
}
/**
* Initializes the page with the project and default classpaths.
* <p>
* The default classpath entries must correspond the the given project.
* </p>
* <p>
* The caller of this method is responsible for creating the underlying project and any new
* folders that might be mentioned on the default classpath. The wizard will create the output folder if required.
* </p>
* <p>
* The project does not have to exist at the time of initialization, but must exist when executing the runnable
* obtained by <code>getRunnable()</code>.
* </p>
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/wizards/JavaCapabilityConfigurationPage.java
|
* @param project The java project.
* @param entries The default classpath entries or <code>null</code> to take the default
* @param path The folder to be taken as the default output path or <code>null</code> to take the default
* @return overrideExistingClasspath If set to true, an existing '.classpath' file is ignored. If set to <code>false</code>
* the default classpath is only used if no '.classpath' exists.
*/
public void init(IJavaProject jproject, IPath defaultOutputLocation, IClasspathEntry[] defaultEntries, boolean defaultsOverrideExistingClasspath) {
if (!defaultsOverrideExistingClasspath && jproject.exists() && jproject.getProject().getFile(".classpath").exists()) {
defaultOutputLocation= null;
defaultOutputLocation= null;
}
fBuildPathsBlock.init(jproject, defaultOutputLocation, defaultEntries);
fJavaProject= jproject;
}
/* (non-Javadoc)
* @see WizardPage#createControl
*/
public void createControl(Composite parent) {
Control control= fBuildPathsBlock.createControl(parent);
setControl(control);
WorkbenchHelp.setHelp(control, IJavaHelpContextIds.NEW_JAVAPROJECT_WIZARD_PAGE);
}
/**
* Returns the currently configured output location. Note that the returned path must not be valid.
*/
public IPath getOutputLocation() {
return fBuildPathsBlock.getOutputLocation();
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/wizards/JavaCapabilityConfigurationPage.java
|
}
/**
* Returns the currently configured class path. Note that the class path must not be valid.
*/
public IClasspathEntry[] getRawClassPath() {
return fBuildPathsBlock.getRawClassPath();
}
/**
* Returns the runnable that will create the Java project or <code>null</code> if the page has not been initialized.
* The runnable sets the project's classpath and output location to the values configured in the page.
*
* @return the runnable
*/
public IRunnableWithProgress getRunnable() {
if (fJavaProject != null) {
return new IRunnableWithProgress() {
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
if (monitor == null) {
monitor= new NullProgressMonitor();
}
int nSteps= 10;
monitor.beginTask(NewWizardMessages.getString("JavaCapabilityConfigurationPage.op_desc"), nSteps);
try {
IProject project= fJavaProject.getProject();
if (!project.hasNature(JavaCore.NATURE_ID)) {
addNatureToProject(project, JavaCore.NATURE_ID, new SubProgressMonitor(monitor, 1));
nSteps--;
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/wizards/JavaCapabilityConfigurationPage.java
|
IRunnableWithProgress jrunnable= fBuildPathsBlock.getRunnable();
jrunnable.run(new SubProgressMonitor(monitor, nSteps));
} catch (CoreException e) {
throw new InvocationTargetException(e);
} finally {
monitor.done();
}
}
};
}
return null;
}
/**
* Adds a nature to a project
*/
private static void addNatureToProject(IProject proj, String natureId, IProgressMonitor monitor) throws CoreException {
IProjectDescription description = proj.getDescription();
String[] prevNatures= description.getNatureIds();
String[] newNatures= new String[prevNatures.length + 1];
System.arraycopy(prevNatures, 0, newNatures, 0, prevNatures.length);
newNatures[prevNatures.length]= natureId;
description.setNatureIds(newNatures);
proj.setDescription(description, monitor);
}
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/wizards/NewJavaProjectWizardPage.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.ui.wizards;
import java.lang.reflect.InvocationTargetException;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IWorkspace;
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.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.swt.widgets.Composite;
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/wizards/NewJavaProjectWizardPage.java
|
import org.eclipse.swt.widgets.Control;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.util.Assert;
import org.eclipse.ui.dialogs.WizardNewProjectCreationPage;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.launching.JavaRuntime;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.wizards.IStatusChangeListener;
import org.eclipse.jdt.internal.ui.wizards.NewWizardMessages;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.BuildPathsBlock;
/**
* Standard wizard page for creating new Java projects. This page can be used in
* project creation wizards for projects and will configure the project with the
* Java nature. This page also allows the user to configure the Java project's
* output location for class files generated by the Java builder.
* <p>
*/
public class NewJavaProjectWizardPage extends NewElementWizardPage {
private static final String PAGE_NAME= "NewJavaProjectWizardPage";
private WizardNewProjectCreationPage fMainPage;
private IPath fOutputLocation;
private IClasspathEntry[] fClasspathEntries;
private boolean fAddJRE;
private BuildPathsBlock fBuildPathsBlock;
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/wizards/NewJavaProjectWizardPage.java
|
private boolean fProjectModified;
/**
* Creates a Java project wizard creation page.
* <p>
* The Java project wizard reads project name and location from the main page.
* </p>
*
* @param root the workspace root
* @param mainpage the main page of the wizard
*/
public NewJavaProjectWizardPage(IWorkspaceRoot root, WizardNewProjectCreationPage mainpage) {
super(PAGE_NAME);
setTitle(NewWizardMessages.getString("NewJavaProjectWizardPage.title"));
setDescription(NewWizardMessages.getString("NewJavaProjectWizardPage.description"));
fMainPage= mainpage;
IStatusChangeListener listener= new IStatusChangeListener() {
public void statusChanged(IStatus status) {
updateStatus(status);
}
};
fBuildPathsBlock= new BuildPathsBlock(root, listener, true);
fProjectModified= true;
fOutputLocation= null;
fClasspathEntries= null;
fAddJRE= false;
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/wizards/NewJavaProjectWizardPage.java
|
/**
* Sets the default output location to be used for the new Java project.
* This is the path of the folder (with the project) into which the Java builder
* will generate binary class files corresponding to the project's Java source
* files.
* <p>
* The wizard will create this folder if required.
* </p>
* <p>
* The default class path will be applied when <code>initBuildPaths</code> is
* called. This is done automatically when the page becomes visible and
* the project or the default paths have changed.
* </p>
*
* @param path the folder to be taken as the default output path
*/
public void setDefaultOutputFolder(IPath path) {
fOutputLocation= path;
setProjectModified();
}
/**
* Sets the default classpath to be used for the new Java project.
* <p>
* The caller of this method is responsible for creating the classpath entries
* for the <code>IJavaProject</code> that corresponds to the created project.
* The caller is responsible for creating any new folders that might be mentioned
* on the classpath.
* </p>
* <p>
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/wizards/NewJavaProjectWizardPage.java
|
* The default output location will be applied when <code>initBuildPaths</code> is
* called. This is done automatically when the page becomes visible and
* the project or the default paths have changed.
* </p>
*
* @param entries the default classpath entries
* @param appendDefaultJRE <code>true</code> a variable entry for the
* default JRE (specified in the preferences) will be added to the classpath.
*/
public void setDefaultClassPath(IClasspathEntry[] entries, boolean appendDefaultJRE) {
if (entries != null && appendDefaultJRE) {
IClasspathEntry[] newEntries= new IClasspathEntry[entries.length + 1];
System.arraycopy(entries, 0, newEntries, 0, entries.length);
newEntries[entries.length]= JavaRuntime.getJREVariableEntry();
entries= newEntries;
}
fClasspathEntries= entries;
fAddJRE= appendDefaultJRE;
setProjectModified();
}
/**
* Sets the project to modified. This will initialize the page when becomes visible.
*/
public void setProjectModified() {
fProjectModified= true;
}
/**
* Gets the project handle from the main page.
* Overwrite this method if you do not have a main page
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/wizards/NewJavaProjectWizardPage.java
|
*/
protected IProject getProjectHandle() {
Assert.isNotNull(fMainPage);
return fMainPage.getProjectHandle();
}
/**
* Gets the project location path from the main page
* Overwrite this method if you do not have a main page
*/
protected IPath getLocationPath() {
Assert.isNotNull(fMainPage);
return fMainPage.getLocationPath();
}
/**
* Returns the Java project handle corresponding to the project defined in
* in the main page.
*
* @returns the Java project
*/
public IJavaProject getNewJavaProject() {
return JavaCore.create(getProjectHandle());
}
/* (non-Javadoc)
* @see WizardPage#createControl
*/
public void createControl(Composite parent) {
Control control= fBuildPathsBlock.createControl(parent);
setControl(control);
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/wizards/NewJavaProjectWizardPage.java
|
WorkbenchHelp.setHelp(control, IJavaHelpContextIds.NEW_JAVAPROJECT_WIZARD_PAGE);
}
/**
* Forces the initialization of the Java project page. Default classpath or buildpath
* will be used if set. The initialization should only be performed when the project
* changed or default paths have changed. Toggeling back and forward the
* pages without changes should not re-initialize the page, as changes
* from the user will be overwritten.
*/
protected void initBuildPaths() {
fBuildPathsBlock.init(getNewJavaProject(), fOutputLocation, fClasspathEntries);
}
/**
* Extend this method to set a user defined default class path or output location.
* <code>initBuildPaths</code> is called when the page becomes visible the first time
* or the project or the default paths have changed.
*/
public void setVisible(boolean visible) {
if (visible) {
if (fProjectModified || isNewProjectHandle()) {
initBuildPaths();
fProjectModified= false;
}
}
super.setVisible(visible);
}
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/wizards/NewJavaProjectWizardPage.java
|
private boolean isNewProjectHandle() {
IProject oldProject= fBuildPathsBlock.getJavaProject().getProject();
return !oldProject.equals(getProjectHandle());
}
/**
* Returns the currently configured output location. Note that the returned path must not be valid.
*/
public IPath getOutputLocation() {
return fBuildPathsBlock.getOutputLocation();
}
/**
* Returns the currently configured class path. Note that the class path must not be valid.
*/
public IClasspathEntry[] getRawClassPath() {
return fBuildPathsBlock.getRawClassPath();
}
/**
* Returns the runnable that will create the Java project.
* The runnable will create and open the project if needed. The runnable will
* add the Java nature to the project, and set the project's classpath and
* output location.
* <p>
* To create the new java project, execute this runnable
* </p>
*
* @return the runnable
*/
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/wizards/NewJavaProjectWizardPage.java
|
public IRunnableWithProgress getRunnable() {
return new IRunnableWithProgress() {
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
if (monitor == null) {
monitor= new NullProgressMonitor();
}
monitor.beginTask(NewWizardMessages.getString("NewJavaProjectWizardPage.op_desc"), 10);
int workLeft= 10;
if (fProjectModified || isNewProjectHandle()) {
initBuildPaths();
}
IWorkspace workspace= ResourcesPlugin.getWorkspace();
IProject project= getProjectHandle();
try {
if (!project.exists()) {
IProjectDescription desc= workspace.newProjectDescription(project.getName());
IPath locationPath= getLocationPath();
if (Platform.getLocation().equals(locationPath)) {
locationPath= null;
}
desc.setLocation(locationPath);
project.create(desc, new SubProgressMonitor(monitor, 1));
workLeft--;
}
if (!project.isOpen()) {
project.open(new SubProgressMonitor(monitor, 1));
workLeft--;
|
14,421 |
Bug 14421 Old .CLASS Files Are Not Deleted
|
When creating a project that does NOT use source folders (and does not use a bin directory for .class files) the .java and .class files are stored together in the Java package structure. When converting a project to use source folders (and the required bin directory for .class files), the old .class files stored in the Java package structure are NEVER DELETED by Eclipse. This is a bug for Eclipse 1.0 and 2.0. Since I use WSDD 4.0 (which is built on Eclipse 1.0), I've seen compilation errors due to the fact that the compiler/JDT is using old .class files rather than the new ones in the project's bin directory. I have not managed to reproduce the compile errors in build 20020416. But since the old .class files should have been deleted this is still a bug for the latest build.
|
resolved fixed
|
1b8c60b
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T17:19:31Z | 2002-04-23T16:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/wizards/NewJavaProjectWizardPage.java
|
}
if (!project.hasNature(JavaCore.NATURE_ID)) {
addNatureToProject(project, JavaCore.NATURE_ID, new SubProgressMonitor(monitor, 1));
workLeft--;
}
IRunnableWithProgress jrunnable= fBuildPathsBlock.getRunnable();
jrunnable.run(new SubProgressMonitor(monitor, workLeft));
} catch (CoreException e) {
throw new InvocationTargetException(e);
} finally {
monitor.done();
}
}
};
}
/**
* Adds a nature to a project
*/
private static void addNatureToProject(IProject proj, String natureId, IProgressMonitor monitor) throws CoreException {
IProjectDescription description = proj.getDescription();
String[] prevNatures= description.getNatureIds();
String[] newNatures= new String[prevNatures.length + 1];
System.arraycopy(prevNatures, 0, newNatures, 0, prevNatures.length);
newNatures[prevNatures.length]= natureId;
description.setNatureIds(newNatures);
proj.setDescription(description, monitor);
}
}
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.wizards.buildpaths;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.runtime.CoreException;
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.TabFolder;
import org.eclipse.swt.widgets.TabItem;
import org.eclipse.swt.widgets.Widget;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.dialogs.ElementTreeSelectionDialog;
import org.eclipse.ui.dialogs.ISelectionStatusValidator;
import org.eclipse.ui.dialogs.ListSelectionDialog;
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.ui.model.WorkbenchContentProvider;
import org.eclipse.ui.model.WorkbenchLabelProvider;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.launching.JavaRuntime;
import org.eclipse.jdt.internal.corext.javadoc.JavaDocLocations;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.JavaPluginImages;
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.jdt.internal.ui.dialogs.StatusUtil;
import org.eclipse.jdt.internal.ui.preferences.JavaBasePreferencePage;
import org.eclipse.jdt.internal.ui.util.CoreUtility;
import org.eclipse.jdt.internal.ui.util.PixelConverter;
import org.eclipse.jdt.internal.ui.util.TabFolderLayout;
import org.eclipse.jdt.internal.ui.viewsupport.ImageDisposer;
import org.eclipse.jdt.internal.ui.wizards.IStatusChangeListener;
import org.eclipse.jdt.internal.ui.wizards.NewWizardMessages;
import org.eclipse.jdt.internal.ui.wizards.TypedElementSelectionValidator;
import org.eclipse.jdt.internal.ui.wizards.TypedViewerFilter;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.CheckedListDialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.DialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IDialogFieldListener;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IStringButtonAdapter;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.LayoutUtil;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.StringButtonDialogField;
public class BuildPathsBlock {
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
public static interface IRemoveOldBinariesQuery {
public static int YES= 0;
public static int NO= 1;
public static int CANCEL= 2;
/**
* Do the callback. Returns YES, NO, CANCEL to decide if .class files should be removed from the
* old output location.
*/
int doQuery(IPath oldOutputLocation);
}
private IWorkspaceRoot fWorkspaceRoot;
private CheckedListDialogField fClassPathList;
private StringButtonDialogField fBuildPathDialogField;
private StatusInfo fClassPathStatus;
private StatusInfo fBuildPathStatus;
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
private IJavaProject fCurrJProject;
private IPath fOutputLocationPath;
private IStatusChangeListener fContext;
private Control fSWTWidget;
private boolean fShowSourceFolderPage;
private SourceContainerWorkbookPage fSourceContainerPage;
private ProjectsWorkbookPage fProjectsPage;
private LibrariesWorkbookPage fLibrariesPage;
private BuildPathBasePage fCurrPage;
public BuildPathsBlock(IWorkspaceRoot root, IStatusChangeListener context, boolean showSourceFolders) {
fWorkspaceRoot= root;
fContext= context;
fShowSourceFolderPage= showSourceFolders;
fSourceContainerPage= null;
fLibrariesPage= null;
fProjectsPage= null;
fCurrPage= null;
BuildPathAdapter adapter= new BuildPathAdapter();
String[] buttonLabels= new String[] {
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
NewWizardMessages.getString("BuildPathsBlock.classpath.up.button"),
NewWizardMessages.getString("BuildPathsBlock.classpath.down.button"),
null,
NewWizardMessages.getString("BuildPathsBlock.classpath.checkall.button"),
NewWizardMessages.getString("BuildPathsBlock.classpath.uncheckall.button")
};
fClassPathList= new CheckedListDialogField(null, buttonLabels, new CPListLabelProvider());
fClassPathList.setDialogFieldListener(adapter);
fClassPathList.setLabelText(NewWizardMessages.getString("BuildPathsBlock.classpath.label"));
fClassPathList.setUpButtonIndex(0);
fClassPathList.setDownButtonIndex(1);
fClassPathList.setCheckAllButtonIndex(3);
fClassPathList.setUncheckAllButtonIndex(4);
fBuildPathDialogField= new StringButtonDialogField(adapter);
fBuildPathDialogField.setButtonLabel(NewWizardMessages.getString("BuildPathsBlock.buildpath.button"));
fBuildPathDialogField.setDialogFieldListener(adapter);
fBuildPathDialogField.setLabelText(NewWizardMessages.getString("BuildPathsBlock.buildpath.label"));
fBuildPathStatus= new StatusInfo();
fClassPathStatus= new StatusInfo();
fCurrJProject= null;
}
public Control createControl(Composite parent) {
fSWTWidget= parent;
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
PixelConverter converter= new PixelConverter(parent);
Composite composite= new Composite(parent, SWT.NONE);
GridLayout layout= new GridLayout();
layout.marginWidth= 0;
layout.numColumns= 1;
composite.setLayout(layout);
TabFolder folder= new TabFolder(composite, SWT.NONE);
folder.setLayout(new TabFolderLayout());
folder.setLayoutData(new GridData(GridData.FILL_BOTH));
folder.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
tabChanged(e.item);
}
});
ImageRegistry imageRegistry= JavaPlugin.getDefault().getImageRegistry();
TabItem item;
fSourceContainerPage= new SourceContainerWorkbookPage(fWorkspaceRoot, fClassPathList, fBuildPathDialogField);
item= new TabItem(folder, SWT.NONE);
item.setText(NewWizardMessages.getString("BuildPathsBlock.tab.source"));
item.setImage(imageRegistry.get(JavaPluginImages.IMG_OBJS_PACKFRAG_ROOT));
item.setData(fSourceContainerPage);
item.setControl(fSourceContainerPage.getControl(folder));
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
IWorkbench workbench= JavaPlugin.getDefault().getWorkbench();
Image projectImage= workbench.getSharedImages().getImage(ISharedImages.IMG_OBJ_PROJECT);
fProjectsPage= new ProjectsWorkbookPage(fClassPathList);
item= new TabItem(folder, SWT.NONE);
item.setText(NewWizardMessages.getString("BuildPathsBlock.tab.projects"));
item.setImage(projectImage);
item.setData(fProjectsPage);
item.setControl(fProjectsPage.getControl(folder));
fLibrariesPage= new LibrariesWorkbookPage(fWorkspaceRoot, fClassPathList);
item= new TabItem(folder, SWT.NONE);
item.setText(NewWizardMessages.getString("BuildPathsBlock.tab.libraries"));
item.setImage(imageRegistry.get(JavaPluginImages.IMG_OBJS_LIBRARY));
item.setData(fLibrariesPage);
item.setControl(fLibrariesPage.getControl(folder));
Image cpoImage= JavaPluginImages.DESC_TOOL_CLASSPATH_ORDER.createImage();
composite.addDisposeListener(new ImageDisposer(cpoImage));
ClasspathOrderingWorkbookPage ordpage= new ClasspathOrderingWorkbookPage(fClassPathList);
item= new TabItem(folder, SWT.NONE);
item.setText(NewWizardMessages.getString("BuildPathsBlock.tab.order"));
item.setImage(cpoImage);
item.setData(ordpage);
item.setControl(ordpage.getControl(folder));
if (fCurrJProject != null) {
fSourceContainerPage.init(fCurrJProject);
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
fLibrariesPage.init(fCurrJProject);
fProjectsPage.init(fCurrJProject);
}
Composite editorcomp= new Composite(composite, SWT.NONE);
DialogField[] editors= new DialogField[] { fBuildPathDialogField };
LayoutUtil.doDefaultLayout(editorcomp, editors, true, 0, 0);
int maxFieldWidth= converter.convertWidthInCharsToPixels(40);
LayoutUtil.setWidthHint(fBuildPathDialogField.getTextControl(null), maxFieldWidth);
LayoutUtil.setHorizontalGrabbing(fBuildPathDialogField.getTextControl(null));
editorcomp.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
if (fShowSourceFolderPage) {
folder.setSelection(0);
fCurrPage= fSourceContainerPage;
} else {
folder.setSelection(3);
fCurrPage= ordpage;
fClassPathList.selectFirstElement();
}
WorkbenchHelp.setHelp(composite, IJavaHelpContextIds.BUILD_PATH_BLOCK);
return composite;
}
private Shell getShell() {
if (fSWTWidget != null) {
return fSWTWidget.getShell();
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
}
return JavaPlugin.getActiveWorkbenchShell();
}
/**
* Initializes the classpath for the given project. Multiple calls to init are allowed,
* but all existing settings will be cleared and replace by the given or default paths.
* @param project The java project to configure. Does not have to exist.
* @param outputLocation The output location to be set in the page. If <code>null</code>
* is passed, jdt default settings are used, or - if the project is an existing Java project- the
* output location of the existing project
* @param classpathEntries The classpath entries to be set in the page. If <code>null</code>
* is passed, jdt default settings are used, or - if the project is an existing Java project - the
* classpath entries of the existing project
*/
public void init(IJavaProject jproject, IPath outputLocation, IClasspathEntry[] classpathEntries) {
fCurrJProject= jproject;
boolean projectExists= false;
try {
IProject project= fCurrJProject.getProject();
projectExists= (project.exists() && project.getFile(".classpath").exists());
if (projectExists) {
if (outputLocation == null) {
outputLocation= fCurrJProject.getOutputLocation();
}
if (classpathEntries == null) {
classpathEntries= fCurrJProject.getRawClasspath();
}
}
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
} catch (CoreException e) {
JavaPlugin.log(e.getStatus());
}
if (outputLocation == null) {
outputLocation= getDefaultBuildPath(jproject);
}
List newClassPath;
if (classpathEntries == null) {
newClassPath= getDefaultClassPath(jproject);
} else {
newClassPath= new ArrayList();
for (int i= 0; i < classpathEntries.length; i++) {
IClasspathEntry curr= classpathEntries[i];
int entryKind= curr.getEntryKind();
IPath path= curr.getPath();
boolean isExported= curr.isExported();
IResource res= null;
boolean isMissing= false;
if (entryKind != IClasspathEntry.CPE_VARIABLE) {
res= fWorkspaceRoot.findMember(path);
if (res == null) {
isMissing= (entryKind != IClasspathEntry.CPE_LIBRARY || !path.toFile().isFile());
}
} else {
IPath resolvedPath= JavaCore.getResolvedVariablePath(path);
isMissing= (resolvedPath == null) || !resolvedPath.toFile().isFile();
}
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
CPListElement elem= new CPListElement(entryKind, path, res, curr.getSourceAttachmentPath(), curr.getSourceAttachmentRootPath(), isExported);
if (projectExists) {
elem.setIsMissing(isMissing);
}
newClassPath.add(elem);
}
}
List exportedEntries = new ArrayList();
for (int i= 0; i < newClassPath.size(); i++) {
CPListElement curr= (CPListElement) newClassPath.get(i);
if (curr.isExported() || curr.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
exportedEntries.add(curr);
}
}
fBuildPathDialogField.setText(outputLocation.makeRelative().toString());
fClassPathList.setElements(newClassPath);
fClassPathList.setCheckedElements(exportedEntries);
if (fSourceContainerPage != null) {
fSourceContainerPage.init(fCurrJProject);
fProjectsPage.init(fCurrJProject);
fLibrariesPage.init(fCurrJProject);
}
doStatusLineUpdate();
}
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
/**
* Returns the Java project. Can return <code>null<code> if the page has not
* been initialized.
*/
public IJavaProject getJavaProject() {
return fCurrJProject;
}
/**
* Returns the current output location. Note that the path returned must not be valid.
*/
public IPath getOutputLocation() {
return new Path(fBuildPathDialogField.getText()).makeAbsolute();
}
/**
* Returns the current class path (raw). Note that the entries returned must not be valid.
*/
public IClasspathEntry[] getRawClassPath() {
List elements= fClassPathList.getElements();
int nElements= elements.size();
IClasspathEntry[] entries= new IClasspathEntry[elements.size()];
for (int i= 0; i < nElements; i++) {
CPListElement currElement= (CPListElement) elements.get(i);
entries[i]= currElement.getClasspathEntry();
}
return entries;
}
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
private List getDefaultClassPath(IJavaProject jproj) {
List list= new ArrayList();
IResource srcFolder;
if (JavaBasePreferencePage.useSrcAndBinFolders()) {
String sourceFolderName= JavaBasePreferencePage.getSourceFolderName();
srcFolder= jproj.getProject().getFolder(sourceFolderName);
} else {
srcFolder= jproj.getProject();
}
list.add(new CPListElement(IClasspathEntry.CPE_SOURCE, srcFolder.getFullPath(), srcFolder));
IPath libPath= new Path(JavaRuntime.JRELIB_VARIABLE);
IPath attachPath= new Path(JavaRuntime.JRESRC_VARIABLE);
IPath attachRoot= new Path(JavaRuntime.JRESRCROOT_VARIABLE);
CPListElement elem= new CPListElement(IClasspathEntry.CPE_VARIABLE, libPath, null, attachPath, attachRoot, false);
list.add(elem);
return list;
}
private IPath getDefaultBuildPath(IJavaProject jproj) {
if (JavaBasePreferencePage.useSrcAndBinFolders()) {
String outputLocationName= JavaBasePreferencePage.getOutputLocationName();
return jproj.getProject().getFullPath().append(outputLocationName);
} else {
return jproj.getProject().getFullPath();
}
}
private class BuildPathAdapter implements IStringButtonAdapter, IDialogFieldListener {
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
public void changeControlPressed(DialogField field) {
buildPathChangeControlPressed(field);
}
public void dialogFieldChanged(DialogField field) {
buildPathDialogFieldChanged(field);
}
}
private void buildPathChangeControlPressed(DialogField field) {
if (field == fBuildPathDialogField) {
IContainer container= chooseContainer();
if (container != null) {
fBuildPathDialogField.setText(container.getFullPath().toString());
}
}
}
private void buildPathDialogFieldChanged(DialogField field) {
if (field == fClassPathList) {
updateClassPathStatus();
updateBuildPathStatus();
} else if (field == fBuildPathDialogField) {
updateBuildPathStatus();
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
}
doStatusLineUpdate();
}
private void doStatusLineUpdate() {
IStatus res= findMostSevereStatus();
fContext.statusChanged(res);
}
private IStatus findMostSevereStatus() {
return StatusUtil.getMoreSevere(fClassPathStatus, fBuildPathStatus);
}
/**
* Validates the build path.
*/
private void updateClassPathStatus() {
fClassPathStatus.setOK();
List elements= fClassPathList.getElements();
boolean entryMissing= false;
IClasspathEntry[] entries= new IClasspathEntry[elements.size()];
for (int i= elements.size()-1 ; i >= 0 ; i--) {
CPListElement currElement= (CPListElement)elements.get(i);
boolean isChecked= fClassPathList.isChecked(currElement);
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
if (currElement.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
if (!isChecked) {
fClassPathList.setCheckedWithoutUpdate(currElement, true);
}
} else {
currElement.setExported(isChecked);
}
entries[i]= currElement.getClasspathEntry();
entryMissing= entryMissing || currElement.isMissing();
}
if (entryMissing) {
fClassPathStatus.setWarning(NewWizardMessages.getString("BuildPathsBlock.warning.EntryMissing"));
}
if (fCurrJProject.hasClasspathCycle(entries)) {
fClassPathStatus.setWarning(NewWizardMessages.getString("BuildPathsBlock.warning.CycleInClassPath"));
}
}
/**
* Validates output location & build path.
*/
private void updateBuildPathStatus() {
fOutputLocationPath= null;
String text= fBuildPathDialogField.getText();
if ("".equals(text)) {
fBuildPathStatus.setError(NewWizardMessages.getString("BuildPathsBlock.error.EnterBuildPath"));
return;
}
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
IPath path= getOutputLocation();
IResource res= fWorkspaceRoot.findMember(path);
if (res != null) {
if (res.getType() == IResource.FILE) {
fBuildPathStatus.setError(NewWizardMessages.getString("BuildPathsBlock.error.InvalidBuildPath"));
return;
}
}
fOutputLocationPath= path;
List elements= fClassPathList.getElements();
IClasspathEntry[] entries= new IClasspathEntry[elements.size()];
for (int i= elements.size()-1 ; i >= 0 ; i--) {
CPListElement currElement= (CPListElement)elements.get(i);
entries[i]= currElement.getClasspathEntry();
}
IStatus status= JavaConventions.validateClasspath(fCurrJProject, entries, path);
if (!status.isOK()) {
fBuildPathStatus.setError(status.getMessage());
return;
}
if (res != null && res.exists() && fCurrJProject.exists()) {
try {
IPath oldOutputLocation= fCurrJProject.getOutputLocation();
if (!oldOutputLocation.equals(fOutputLocationPath)) {
if (((IContainer)res).members().length > 0) {
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
fBuildPathStatus.setWarning(NewWizardMessages.getString("BuildPathsBlock.warning.OutputFolderNotEmpty"));
return;
}
}
} catch (CoreException e) {
JavaPlugin.log(e);
}
}
fBuildPathStatus.setOK();
}
/**
* Creates a runnable that sets the configured build paths.
*/
public IRunnableWithProgress getRunnable(final IRemoveOldBinariesQuery reorgQuery) {
final List classPathEntries= fClassPathList.getElements();
final IPath path= getOutputLocation();
return new IRunnableWithProgress() {
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
if (monitor == null) {
monitor= new NullProgressMonitor();
}
monitor.beginTask(NewWizardMessages.getString("BuildPathsBlock.operationdesc"), 10);
try {
createJavaProject(classPathEntries, path, reorgQuery, monitor);
} catch (CoreException e) {
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
throw new InvocationTargetException(e);
} finally {
monitor.done();
}
}
};
}
public IRemoveOldBinariesQuery getRemoveOldBinariesQuery(final Shell shell) {
return new IRemoveOldBinariesQuery() {
public int doQuery(final IPath oldOutputLocation) {
final int[] res= new int[] { IRemoveOldBinariesQuery.NO };
shell.getDisplay().syncExec(new Runnable() {
public void run() {
String title= NewWizardMessages.getString("BuildPathsBlock.RemoveBinariesDialog.title");
String message= NewWizardMessages.getFormattedString("BuildPathsBlock.RemoveBinariesDialog.description", oldOutputLocation.toString());
MessageDialog dialog= new MessageDialog(getShell(), title, null, message, MessageDialog.QUESTION, new String[] { IDialogConstants.YES_LABEL, IDialogConstants.NO_LABEL, IDialogConstants.CANCEL_LABEL }, 2);
int returnVal= dialog.open();
if (returnVal == 0) {
res[0]= IRemoveOldBinariesQuery.YES;
} else if (returnVal == 1) {
res[0]= IRemoveOldBinariesQuery.NO;
} else {
res[0]= IRemoveOldBinariesQuery.CANCEL;
}
}
});
return res[0];
}
};
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
}
/**
* Creates the Java project and sets the configured build path and output location.
* If the project already exists only build paths are updated.
*/
private void createJavaProject(List classPathEntries, IPath outputLocation, IRemoveOldBinariesQuery reorgQuery, IProgressMonitor monitor) throws CoreException, InterruptedException {
if (reorgQuery != null) {
IPath oldOutputLocation= fCurrJProject.getOutputLocation();
if (fWorkspaceRoot.exists(oldOutputLocation)) {
int result= reorgQuery.doQuery(oldOutputLocation);
if (result == reorgQuery.CANCEL) {
throw new InterruptedException();
} else if (result == reorgQuery.YES) {
removeOldClassfiles(fWorkspaceRoot.findMember(oldOutputLocation));
}
}
}
if (!fWorkspaceRoot.exists(outputLocation)) {
IFolder folder= fWorkspaceRoot.getFolder(outputLocation);
CoreUtility.createFolder(folder, true, true, null);
}
monitor.worked(2);
int nEntries= classPathEntries.size();
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
IClasspathEntry[] classpath= new IClasspathEntry[nEntries];
for (int i= 0; i < nEntries; i++) {
CPListElement entry= ((CPListElement)classPathEntries.get(i));
IResource res= entry.getResource();
if ((res instanceof IFolder) && !res.exists()) {
CoreUtility.createFolder((IFolder)res, true, true, null);
}
classpath[i]= entry.getClasspathEntry();
URL javadocLocation= entry.getJavadocLocation();
if (javadocLocation != null) {
IPath path= entry.getPath();
if (entry.getEntryKind() == IClasspathEntry.CPE_VARIABLE) {
path= JavaCore.getResolvedVariablePath(path);
}
if (path != null) {
JavaDocLocations.setLibraryJavadocLocation(path, javadocLocation);
}
}
}
monitor.worked(1);
fCurrJProject.setRawClasspath(classpath, outputLocation, new SubProgressMonitor(monitor, 7));
}
private void removeOldClassfiles(IResource resource) throws CoreException {
if (resource.isDerived() && "class".equals(resource.getFileExtension())) {
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
resource.delete(false, null);
}
if (resource instanceof IContainer) {
IResource[] members= ((IContainer) resource).members();
for (int i= 0; i < members.length; i++) {
removeOldClassfiles(members[i]);
}
}
}
private IContainer chooseContainer() {
Class[] acceptedClasses= new Class[] { IProject.class, IFolder.class };
ISelectionStatusValidator validator= new TypedElementSelectionValidator(acceptedClasses, false);
IProject[] allProjects= fWorkspaceRoot.getProjects();
ArrayList rejectedElements= new ArrayList(allProjects.length);
IProject currProject= fCurrJProject.getProject();
for (int i= 0; i < allProjects.length; i++) {
if (!allProjects[i].equals(currProject)) {
rejectedElements.add(allProjects[i]);
}
}
ViewerFilter filter= new TypedViewerFilter(acceptedClasses, rejectedElements.toArray());
ILabelProvider lp= new WorkbenchLabelProvider();
ITreeContentProvider cp= new WorkbenchContentProvider();
IResource initSelection= null;
if (fOutputLocationPath != null) {
initSelection= fWorkspaceRoot.findMember(fOutputLocationPath);
}
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/BuildPathsBlock.java
|
ElementTreeSelectionDialog dialog= new ElementTreeSelectionDialog(getShell(), lp, cp);
dialog.setTitle(NewWizardMessages.getString("BuildPathsBlock.ChooseOutputFolderDialog.title"));
dialog.setValidator(validator);
dialog.setMessage(NewWizardMessages.getString("BuildPathsBlock.ChooseOutputFolderDialog.description"));
dialog.addFilter(filter);
dialog.setInput(fWorkspaceRoot);
dialog.setInitialSelection(initSelection);
if (dialog.open() == dialog.OK) {
return (IContainer)dialog.getFirstResult();
}
return null;
}
private void tabChanged(Widget widget) {
if (widget instanceof TabItem) {
BuildPathBasePage newPage= (BuildPathBasePage) ((TabItem) widget).getData();
if (fCurrPage != null) {
List selection= fCurrPage.getSelection();
if (!selection.isEmpty()) {
newPage.setSelection(selection);
}
}
fCurrPage= newPage;
}
}
}
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/CPListLabelProvider.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.wizards.buildpaths;
import org.eclipse.swt.graphics.Image;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IPath;
import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.jface.util.Assert;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.IWorkbench;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.JavaPluginImages;
import org.eclipse.jdt.internal.ui.wizards.NewWizardMessages;
class CPListLabelProvider extends LabelProvider {
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/CPListLabelProvider.java
|
private String fNewLabel, fClassLabel;
private Image fJarIcon, fExtJarIcon, fJarWSrcIcon, fExtJarWSrcIcon;
private Image fFolderImage, fProjectImage, fVariableImage;
private Image fMissingLibaryImage, fMissingVariableImage;
private Image fMissingFolderImage, fMissingProjectImage;
public CPListLabelProvider() {
fNewLabel= NewWizardMessages.getString("CPListLabelProvider.new");
fClassLabel= NewWizardMessages.getString("CPListLabelProvider.classcontainer");
ImageRegistry reg= JavaPlugin.getDefault().getImageRegistry();
fJarIcon= reg.get(JavaPluginImages.IMG_OBJS_JAR);
fExtJarIcon= reg.get(JavaPluginImages.IMG_OBJS_EXTJAR);
fJarWSrcIcon= reg.get(JavaPluginImages.IMG_OBJS_JAR_WSRC);
fExtJarWSrcIcon= reg.get(JavaPluginImages.IMG_OBJS_EXTJAR_WSRC);
fFolderImage= reg.get(JavaPluginImages.IMG_OBJS_PACKFRAG_ROOT);
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/CPListLabelProvider.java
|
fVariableImage= reg.get(JavaPluginImages.IMG_OBJS_ENV_VAR);
IWorkbench workbench= JavaPlugin.getDefault().getWorkbench();
fProjectImage= workbench.getSharedImages().getImage(ISharedImages.IMG_OBJ_PROJECT);
fMissingLibaryImage= reg.get(JavaPluginImages.IMG_OBJS_MISSING_JAR);
fMissingVariableImage= reg.get(JavaPluginImages.IMG_OBJS_MISSING_ENV_VAR);
fMissingFolderImage= reg.get(JavaPluginImages.IMG_OBJS_MISSING_PACKFRAG_ROOT);
fMissingProjectImage= workbench.getSharedImages().getImage(ISharedImages.IMG_OBJ_PROJECT_CLOSED);
}
public String getText(Object element) {
if (element instanceof CPListElement) {
CPListElement cpentry= (CPListElement)element;
IPath path= cpentry.getPath();
switch (cpentry.getEntryKind()) {
case IClasspathEntry.CPE_LIBRARY: {
IResource resource= cpentry.getResource();
if (resource instanceof IFolder) {
StringBuffer buf= new StringBuffer(path.makeRelative().toString());
buf.append(' ');
buf.append(fClassLabel);
if (!resource.exists()) {
buf.append(' ');
buf.append(fNewLabel);
}
return buf.toString();
} else if (resource instanceof IFile) {
if (ArchiveFileFilter.isArchivePath(path)) {
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/CPListLabelProvider.java
|
String[] args= new String[] { path.lastSegment(), path.removeLastSegments(1).makeRelative().toString() };
return NewWizardMessages.getFormattedString("CPListLabelProvider.twopart", args);
}
} else {
if (ArchiveFileFilter.isArchivePath(path)) {
String[] args= new String[] { path.lastSegment(), path.removeLastSegments(1).toOSString() };
return NewWizardMessages.getFormattedString("CPListLabelProvider.twopart", args);
}
}
return path.makeRelative().toString();
}
case IClasspathEntry.CPE_VARIABLE: {
String name= path.makeRelative().toString();
StringBuffer buf= new StringBuffer(name);
IPath entryPath= JavaCore.getClasspathVariable(path.segment(0));
if (entryPath != null) {
buf.append(" - ");
buf.append(entryPath.append(path.removeFirstSegments(1)).toOSString());
}
return buf.toString();
}
case IClasspathEntry.CPE_PROJECT:
return path.lastSegment();
case IClasspathEntry.CPE_SOURCE: {
StringBuffer buf= new StringBuffer(path.makeRelative().toString());
IResource resource= cpentry.getResource();
if (resource != null && !resource.exists()) {
buf.append(' ');
buf.append(fNewLabel);
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/CPListLabelProvider.java
|
}
return buf.toString();
}
default:
}
}
return super.getText(element);
}
public Image getImage(Object element) {
if (element instanceof CPListElement) {
CPListElement cpentry= (CPListElement)element;
switch (cpentry.getEntryKind()) {
case IClasspathEntry.CPE_SOURCE:
if (!cpentry.isMissing()) {
return fFolderImage;
} else {
return fMissingFolderImage;
}
case IClasspathEntry.CPE_LIBRARY:
if (!cpentry.isMissing()) {
IResource res= cpentry.getResource();
if (res == null) {
if (cpentry.getSourceAttachmentPath() == null) {
return fExtJarIcon;
} else {
return fExtJarWSrcIcon;
}
} else if (res instanceof IFile) {
|
9,159 |
Bug 9159 Classpath wizard should not complain when adding missing source folder
|
Build 20020125 - Define a project A with source folder 'src1'. - Go to the .classpath file and edit it to insert one extra line: <classpathentry kind="src" path="src2"/> below the line referring to first source folder: <classpathentry kind="src" path="src1"/>. - Now, try to add this missing source folder 'src2', it isn't allowed by the wizard, one has to add a basic folder instead. Note: It is not such an uncommon scenario, the classpath modification could simply occur by catching up with a shared classpath having one more source folder on it, and which is locally missing.
|
resolved fixed
|
52b834c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-01T18:04:03Z | 2002-02-06T12:53:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/CPListLabelProvider.java
|
if (cpentry.getSourceAttachmentPath() == null) {
return fJarIcon;
} else {
return fJarWSrcIcon;
}
} else {
return fFolderImage;
}
} else {
return fMissingLibaryImage;
}
case IClasspathEntry.CPE_PROJECT:
if (!cpentry.isMissing()) {
return fProjectImage;
} else {
return fMissingProjectImage;
}
case IClasspathEntry.CPE_VARIABLE:
if (!cpentry.isMissing()) {
return fVariableImage;
} else {
return fMissingVariableImage;
}
default:
}
}
return null;
}
}
|
13,034 |
Bug 13034 Cannot create a Source Folder in a new Java Project
|
build 20020404 If you try and create a Source Folder in a Java Project you have just created you get an error preventing you from hitting finish. STEPS 1) Create Java Project Foo 2) Open New->Source Folder 3) Enter Bar as the name - you will get "Cannot nest entry Bar inside entry Foo/Bar" 4) Create a folder Bar. 5) Add it as a source folder in the Properties Dialog for Foo. No problem.
|
resolved fixed
|
1986114
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-02T16:39:00Z | 2002-04-08T21:06:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/StatusUtil.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.dialogs;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.dialogs.DialogPage;
/**
* A utility class to work with IStatus.
*/
public class StatusUtil {
|
13,034 |
Bug 13034 Cannot create a Source Folder in a new Java Project
|
build 20020404 If you try and create a Source Folder in a Java Project you have just created you get an error preventing you from hitting finish. STEPS 1) Create Java Project Foo 2) Open New->Source Folder 3) Enter Bar as the name - you will get "Cannot nest entry Bar inside entry Foo/Bar" 4) Create a folder Bar. 5) Add it as a source folder in the Properties Dialog for Foo. No problem.
|
resolved fixed
|
1986114
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-02T16:39:00Z | 2002-04-08T21:06:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/StatusUtil.java
|
/**
* Compares two instances of <code>IStatus</code>. The more severe is returned:
* An error is more severe than a warning, and a warning is more severe
* than ok. If the two stati have the same severity, the second is returned.
*/
public static IStatus getMoreSevere(IStatus s1, IStatus s2) {
if (s1.getSeverity() > s2.getSeverity()) {
return s1;
} else {
return s2;
}
}
/**
* Finds the most severe status from a array of stati.
* An error is more severe than a warning, and a warning is more severe
* than ok.
*/
public static IStatus getMostSevere(IStatus[] status) {
IStatus max= null;
for (int i= 0; i < status.length; i++) {
IStatus curr= status[i];
if (curr.matches(IStatus.ERROR)) {
return curr;
}
if (max == null || curr.getSeverity() > max.getSeverity()) {
max= curr;
}
}
return max;
}
|
13,034 |
Bug 13034 Cannot create a Source Folder in a new Java Project
|
build 20020404 If you try and create a Source Folder in a Java Project you have just created you get an error preventing you from hitting finish. STEPS 1) Create Java Project Foo 2) Open New->Source Folder 3) Enter Bar as the name - you will get "Cannot nest entry Bar inside entry Foo/Bar" 4) Create a folder Bar. 5) Add it as a source folder in the Properties Dialog for Foo. No problem.
|
resolved fixed
|
1986114
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-02T16:39:00Z | 2002-04-08T21:06:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/StatusUtil.java
|
/**
* Applies the status to the status line of a dialog page.
*/
public static void applyToStatusLine(DialogPage page, IStatus status) {
String message= status.getMessage();
switch (status.getSeverity()) {
case IStatus.OK:
page.setErrorMessage(null);
page.setMessage(message, DialogPage.NONE);
break;
case IStatus.WARNING:
page.setErrorMessage(null);
page.setMessage(message, DialogPage.WARNING);
break;
case IStatus.INFO:
page.setErrorMessage(null);
page.setMessage(message, DialogPage.INFORMATION);
break;
default:
if (message.length() == 0) {
message= null;
}
page.setErrorMessage(message);
page.setMessage(null);
break;
}
}
}
|
13,034 |
Bug 13034 Cannot create a Source Folder in a new Java Project
|
build 20020404 If you try and create a Source Folder in a Java Project you have just created you get an error preventing you from hitting finish. STEPS 1) Create Java Project Foo 2) Open New->Source Folder 3) Enter Bar as the name - you will get "Cannot nest entry Bar inside entry Foo/Bar" 4) Create a folder Bar. 5) Add it as a source folder in the Properties Dialog for Foo. No problem.
|
resolved fixed
|
1986114
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-02T16:39:00Z | 2002-04-08T21:06:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.wizards;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
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.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
|
13,034 |
Bug 13034 Cannot create a Source Folder in a new Java Project
|
build 20020404 If you try and create a Source Folder in a Java Project you have just created you get an error preventing you from hitting finish. STEPS 1) Create Java Project Foo 2) Open New->Source Folder 3) Enter Bar as the name - you will get "Cannot nest entry Bar inside entry Foo/Bar" 4) Create a folder Bar. 5) Add it as a source folder in the Properties Dialog for Foo. No problem.
|
resolved fixed
|
1986114
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-02T16:39:00Z | 2002-04-08T21:06:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.ui.actions.WorkspaceModifyDelegatingOperation;
import org.eclipse.ui.dialogs.ElementListSelectionDialog;
import org.eclipse.ui.dialogs.ElementTreeSelectionDialog;
import org.eclipse.ui.dialogs.ISelectionStatusValidator;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.ui.model.WorkbenchContentProvider;
import org.eclipse.ui.model.WorkbenchLabelProvider;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.ui.JavaElementLabelProvider;
import org.eclipse.jdt.ui.wizards.NewElementWizardPage;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.dialogs.StatusDialog;
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
|
13,034 |
Bug 13034 Cannot create a Source Folder in a new Java Project
|
build 20020404 If you try and create a Source Folder in a Java Project you have just created you get an error preventing you from hitting finish. STEPS 1) Create Java Project Foo 2) Open New->Source Folder 3) Enter Bar as the name - you will get "Cannot nest entry Bar inside entry Foo/Bar" 4) Create a folder Bar. 5) Add it as a source folder in the Properties Dialog for Foo. No problem.
|
resolved fixed
|
1986114
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-02T16:39:00Z | 2002-04-08T21:06:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
import org.eclipse.jdt.internal.ui.util.CoreUtility;
import org.eclipse.jdt.internal.ui.util.ExceptionHandler;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.BuildPathsBlock;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.DialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IDialogFieldListener;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IStringButtonAdapter;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.LayoutUtil;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.SelectionButtonDialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.Separator;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.StringButtonDialogField;
public class NewSourceFolderWizardPage extends NewElementWizardPage {
private static final String PAGE_NAME= "NewSourceFolderWizardPage";
private StringButtonDialogField fProjectField;
private StatusInfo fProjectStatus;
private StringButtonDialogField fRootDialogField;
private StatusInfo fRootStatus;
private SelectionButtonDialogField fEditClassPathField;
private IWorkspaceRoot fWorkspaceRoot;
private IJavaProject fCurrJProject;
private IClasspathEntry[] fEntries;
private IPath fOutputLocation;
private IPackageFragmentRoot fCreatedRoot;
|
13,034 |
Bug 13034 Cannot create a Source Folder in a new Java Project
|
build 20020404 If you try and create a Source Folder in a Java Project you have just created you get an error preventing you from hitting finish. STEPS 1) Create Java Project Foo 2) Open New->Source Folder 3) Enter Bar as the name - you will get "Cannot nest entry Bar inside entry Foo/Bar" 4) Create a folder Bar. 5) Add it as a source folder in the Properties Dialog for Foo. No problem.
|
resolved fixed
|
1986114
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-02T16:39:00Z | 2002-04-08T21:06:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
public NewSourceFolderWizardPage() {
super(PAGE_NAME);
setTitle(NewWizardMessages.getString("NewSourceFolderWizardPage.title"));
setDescription(NewWizardMessages.getString("NewSourceFolderWizardPage.description"));
fWorkspaceRoot= ResourcesPlugin.getWorkspace().getRoot();
RootFieldAdapter adapter= new RootFieldAdapter();
fProjectField= new StringButtonDialogField(adapter);
fProjectField.setDialogFieldListener(adapter);
fProjectField.setLabelText(NewWizardMessages.getString("NewSourceFolderWizardPage.project.label"));
fProjectField.setButtonLabel(NewWizardMessages.getString("NewSourceFolderWizardPage.project.button"));
fRootDialogField= new StringButtonDialogField(adapter);
fRootDialogField.setDialogFieldListener(adapter);
fRootDialogField.setLabelText(NewWizardMessages.getString("NewSourceFolderWizardPage.root.label"));
fRootDialogField.setButtonLabel(NewWizardMessages.getString("NewSourceFolderWizardPage.root.button"));
fEditClassPathField= new SelectionButtonDialogField(SWT.PUSH);
fEditClassPathField.setDialogFieldListener(adapter);
fEditClassPathField.setLabelText(NewWizardMessages.getString("NewSourceFolderWizardPage.editclasspath.button"));
fRootStatus= new StatusInfo();
fProjectStatus= new StatusInfo();
}
|
13,034 |
Bug 13034 Cannot create a Source Folder in a new Java Project
|
build 20020404 If you try and create a Source Folder in a Java Project you have just created you get an error preventing you from hitting finish. STEPS 1) Create Java Project Foo 2) Open New->Source Folder 3) Enter Bar as the name - you will get "Cannot nest entry Bar inside entry Foo/Bar" 4) Create a folder Bar. 5) Add it as a source folder in the Properties Dialog for Foo. No problem.
|
resolved fixed
|
1986114
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-02T16:39:00Z | 2002-04-08T21:06:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderWizardPage.java
|
public void init(IStructuredSelection selection) {
if (selection == null || selection.isEmpty()) {
setDefaultAttributes();
return;
}
Object selectedElement= selection.getFirstElement();
if (selectedElement == null) {
selectedElement= EditorUtility.getActiveEditorJavaInput();
}
String projPath= null;
if (selectedElement instanceof IResource) {
IProject proj= ((IResource)selectedElement).getProject();
if (proj != null) {
projPath= proj.getFullPath().makeRelative().toString();
}
} else if (selectedElement instanceof IJavaElement) {
IJavaProject jproject= ((IJavaElement)selectedElement).getJavaProject();
if (jproject != null) {
projPath= jproject.getProject().getFullPath().makeRelative().toString();
}
}
if (projPath != null) {
fProjectField.setText(projPath);
fRootDialogField.setText("");
} else {
setDefaultAttributes();
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.