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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
6,410 |
Bug 6410 File unchanged but dirtied by code assist
|
1122. Open a Java file. Place the cursor inside the left-most parenthesis of a method call. For example, consider "I" to be the cursor below: Object o = anotherObject.method(I); Press Ctrl-Space. The file is dirtied but not changed, and code assist does not appear. If code assist has nothing to suggest, it should not dirty the file.
|
verified fixed
|
588ffa6
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-11T17:07:14Z | 2001-11-29T02:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/java/JavaCompletionProposal.java
|
}
/**
* Sets the image.
* @param image The image to set
*/
public void setImage(Image image) {
fImage= image;
}
/*
* @see ICompletionProposalExtension#isValidFor(IDocument, int)
*/
public boolean isValidFor(IDocument document, int offset) {
if (offset < fReplacementOffset)
return false;
int replacementLength= fReplacementString == null ? 0 : fReplacementString.length();
if (offset >= fReplacementOffset + replacementLength)
return false;
try {
int length= offset - fReplacementOffset;
String start= document.get(fReplacementOffset, length);
return fReplacementString.substring(0, length).equalsIgnoreCase(start);
} catch (BadLocationException x) {
}
return false;
}
}
|
7,385 |
Bug 7385 Breakpoint no hit if on variable declaration with no initialization
|
Build 20011219 It seems that a breakpoint will not be considered if located on a variable declaration with no initialization (in my case, it was the first statement of the method): org.eclipse.jdt.internal.compiler.codegen.CodeStream public void generateSyntheticArgumentValues(BlockScope currentScope, ReferenceBinding targetType, Expression enclosingInstance, AstNode invocationSite) { // perform some emulation work in case there is some and we are inside a local type only * ReferenceBinding[] syntheticArgumentTypes;
|
verified fixed
|
2746f20
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-11T17:23:18Z | 2002-01-09T15:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javaeditor/BreakpointLocationVerifier.java
|
package org.eclipse.jdt.internal.ui.javaeditor;
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
import org.eclipse.jdt.internal.compiler.parser.InvalidInputException;
import org.eclipse.jdt.internal.compiler.parser.Scanner;
import org.eclipse.jdt.internal.compiler.parser.TerminalSymbols;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
public class BreakpointLocationVerifier {
/**
* Returns the line number closest to the given line number that represents a
* valid location for a breakpoint in the given document, or -1 if a valid location
* cannot be found.
*/
public int getValidBreakpointLocation(IDocument doc, int lineNumber) {
Scanner scanner= new Scanner();
boolean found= false;
int start= 0, length= 0, token= 0;
while (!found) {
try {
start= doc.getLineOffset(lineNumber);
length= doc.getLineLength(lineNumber);
|
7,385 |
Bug 7385 Breakpoint no hit if on variable declaration with no initialization
|
Build 20011219 It seems that a breakpoint will not be considered if located on a variable declaration with no initialization (in my case, it was the first statement of the method): org.eclipse.jdt.internal.compiler.codegen.CodeStream public void generateSyntheticArgumentValues(BlockScope currentScope, ReferenceBinding targetType, Expression enclosingInstance, AstNode invocationSite) { // perform some emulation work in case there is some and we are inside a local type only * ReferenceBinding[] syntheticArgumentTypes;
|
verified fixed
|
2746f20
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-11T17:23:18Z | 2002-01-09T15:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javaeditor/BreakpointLocationVerifier.java
|
char[] txt= doc.get(start, length).toCharArray();
scanner.setSourceBuffer(txt);
token= scanner.getNextToken();
while (token != TerminalSymbols.TokenNameEOF) {
if (token == TerminalSymbols.TokenNamebreak ||
token == TerminalSymbols.TokenNamecontinue ||
token == TerminalSymbols.TokenNameIdentifier ||
token == TerminalSymbols.TokenNamereturn ||
token == TerminalSymbols.TokenNamethis||
token == TerminalSymbols.TokenNamesuper) {
found= true;
break;
} else {
token= scanner.getNextToken();
}
}
if (!found) {
lineNumber++;
}
} catch (BadLocationException ble) {
return -1;
} catch (InvalidInputException ie) {
return -1;
}
}
return lineNumber + 1;
}
}
|
7,487 |
Bug 7487 Classpath variable edit error message wrong
|
Using build 2002-01-09 on Windows 2000 From the prefrerence dialog, I opened the page Java > Classpath Variables. I selected the ECLIPSE_HOME variable and pressed Edit. The content came up as ECLIPSE_HOME D:/eclipse-sdk/2001-12-04/eclipse I started editing the path by removing the 2001-12-04 section D:/eclipse-sdk//eclipse At that point I got the following red error message at the bottom of the dialog !VariableCreationDialogerror.invalidpath!
|
resolved fixed
|
c5a405e
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-11T18:33:05Z | 2002-01-11T14:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableCreationDialog.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.wizards.buildpaths;
import java.io.File;
import java.util.List;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.DirectoryDialog;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.IUIConstants;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.dialogs.StatusDialog;
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.jdt.internal.ui.dialogs.StatusUtil;
import org.eclipse.jdt.internal.ui.util.SWTUtil;
import org.eclipse.jdt.internal.ui.wizards.NewWizardMessages;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.DialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IDialogFieldListener;
|
7,487 |
Bug 7487 Classpath variable edit error message wrong
|
Using build 2002-01-09 on Windows 2000 From the prefrerence dialog, I opened the page Java > Classpath Variables. I selected the ECLIPSE_HOME variable and pressed Edit. The content came up as ECLIPSE_HOME D:/eclipse-sdk/2001-12-04/eclipse I started editing the path by removing the 2001-12-04 section D:/eclipse-sdk//eclipse At that point I got the following red error message at the bottom of the dialog !VariableCreationDialogerror.invalidpath!
|
resolved fixed
|
c5a405e
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-11T18:33:05Z | 2002-01-11T14:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableCreationDialog.java
|
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.StringButtonDialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.StringDialogField;
import org.eclipse.jdt.internal.ui.wizards.swt.MGridLayout;
public class VariableCreationDialog extends StatusDialog {
private IDialogSettings fDialogSettings;
private StringDialogField fNameField;
private StatusInfo fNameStatus;
private StringButtonDialogField fPathField;
private StatusInfo fPathStatus;
private SelectionButtonDialogField fDirButton;
private CPVariableElement fElement;
private List fExistingNames;
public VariableCreationDialog(Shell parent, CPVariableElement element, List existingNames) {
super(parent);
if (element == null) {
setTitle(NewWizardMessages.getString("VariableCreationDialog.titlenew"));
} else {
setTitle(NewWizardMessages.getString("VariableCreationDialog.titleedit"));
}
fDialogSettings= JavaPlugin.getDefault().getDialogSettings();
|
7,487 |
Bug 7487 Classpath variable edit error message wrong
|
Using build 2002-01-09 on Windows 2000 From the prefrerence dialog, I opened the page Java > Classpath Variables. I selected the ECLIPSE_HOME variable and pressed Edit. The content came up as ECLIPSE_HOME D:/eclipse-sdk/2001-12-04/eclipse I started editing the path by removing the 2001-12-04 section D:/eclipse-sdk//eclipse At that point I got the following red error message at the bottom of the dialog !VariableCreationDialogerror.invalidpath!
|
resolved fixed
|
c5a405e
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-11T18:33:05Z | 2002-01-11T14:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableCreationDialog.java
|
fElement= element;
fNameStatus= new StatusInfo();
fPathStatus= new StatusInfo();
NewVariableAdapter adapter= new NewVariableAdapter();
fNameField= new StringDialogField();
fNameField.setDialogFieldListener(adapter);
fNameField.setLabelText(NewWizardMessages.getString("VariableCreationDialog.name.label"));
fPathField= new StringButtonDialogField(adapter);
fPathField.setDialogFieldListener(adapter);
fPathField.setLabelText(NewWizardMessages.getString("VariableCreationDialog.path.label"));
fPathField.setButtonLabel(NewWizardMessages.getString("VariableCreationDialog.path.file.button"));
fDirButton= new SelectionButtonDialogField(SWT.PUSH);
fDirButton.setDialogFieldListener(adapter);
fDirButton.setLabelText(NewWizardMessages.getString("VariableCreationDialog.path.dir.button"));
fExistingNames= existingNames;
if (element != null) {
fNameField.setText(element.getName());
fPathField.setText(element.getPath().toString());
fExistingNames.remove(element.getName());
} else {
fNameField.setText("");
fPathField.setText("");
}
}
|
7,487 |
Bug 7487 Classpath variable edit error message wrong
|
Using build 2002-01-09 on Windows 2000 From the prefrerence dialog, I opened the page Java > Classpath Variables. I selected the ECLIPSE_HOME variable and pressed Edit. The content came up as ECLIPSE_HOME D:/eclipse-sdk/2001-12-04/eclipse I started editing the path by removing the 2001-12-04 section D:/eclipse-sdk//eclipse At that point I got the following red error message at the bottom of the dialog !VariableCreationDialogerror.invalidpath!
|
resolved fixed
|
c5a405e
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-11T18:33:05Z | 2002-01-11T14:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableCreationDialog.java
|
/*
* @see Windows#configureShell
*/
protected void configureShell(Shell newShell) {
super.configureShell(newShell);
WorkbenchHelp.setHelp(newShell, new Object[] { IJavaHelpContextIds.VARIABLE_CREATION_DIALOG });
}
public CPVariableElement getClasspathElement() {
return new CPVariableElement(fNameField.getText(), new Path(fPathField.getText()), false);
}
/*
* @see Dialog#createDialogArea(org.eclipse.swt.widgets.Composite)
*/
protected Control createDialogArea(Composite parent) {
Composite composite= (Composite)super.createDialogArea(parent);
Composite inner= new Composite(composite, SWT.NONE);
MGridLayout layout= new MGridLayout();
layout.minimumWidth= SWTUtil.convertWidthInCharsToPixels(80, parent);
layout.marginWidth= 0;
layout.numColumns= 3;
inner.setLayout(layout);
int fieldWidthHint= SWTUtil.convertWidthInCharsToPixels(50, parent);
fNameField.doFillIntoGrid(inner, 2);
LayoutUtil.setWidthHint(fNameField.getTextControl(null), fieldWidthHint);
|
7,487 |
Bug 7487 Classpath variable edit error message wrong
|
Using build 2002-01-09 on Windows 2000 From the prefrerence dialog, I opened the page Java > Classpath Variables. I selected the ECLIPSE_HOME variable and pressed Edit. The content came up as ECLIPSE_HOME D:/eclipse-sdk/2001-12-04/eclipse I started editing the path by removing the 2001-12-04 section D:/eclipse-sdk//eclipse At that point I got the following red error message at the bottom of the dialog !VariableCreationDialogerror.invalidpath!
|
resolved fixed
|
c5a405e
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-11T18:33:05Z | 2002-01-11T14:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableCreationDialog.java
|
DialogField.createEmptySpace(inner, 1);
fPathField.doFillIntoGrid(inner, 3);
LayoutUtil.setWidthHint(fPathField.getTextControl(null), fieldWidthHint);
DialogField.createEmptySpace(inner, 2);
fDirButton.doFillIntoGrid(inner, 1);
DialogField focusField= (fElement == null) ? fNameField : fPathField;
focusField.postSetFocusOnDialogField(parent.getDisplay());
return composite;
}
private class NewVariableAdapter implements IDialogFieldListener, IStringButtonAdapter {
public void dialogFieldChanged(DialogField field) {
doFieldUpdated(field);
}
public void changeControlPressed(DialogField field) {
doChangeControlPressed(field);
}
}
private void doChangeControlPressed(DialogField field) {
if (field == fPathField) {
|
7,487 |
Bug 7487 Classpath variable edit error message wrong
|
Using build 2002-01-09 on Windows 2000 From the prefrerence dialog, I opened the page Java > Classpath Variables. I selected the ECLIPSE_HOME variable and pressed Edit. The content came up as ECLIPSE_HOME D:/eclipse-sdk/2001-12-04/eclipse I started editing the path by removing the 2001-12-04 section D:/eclipse-sdk//eclipse At that point I got the following red error message at the bottom of the dialog !VariableCreationDialogerror.invalidpath!
|
resolved fixed
|
c5a405e
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-11T18:33:05Z | 2002-01-11T14:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableCreationDialog.java
|
IPath path= chooseExtJarFile();
if (path != null) {
fPathField.setText(path.toString());
}
}
}
private void doFieldUpdated(DialogField field) {
if (field == fNameField) {
fNameStatus= nameUpdated();
} else if (field == fPathField) {
fPathStatus= pathUpdated();
} else if (field == fDirButton) {
IPath path= chooseExtDirectory();
if (path != null) {
fPathField.setText(path.toString());
}
}
updateStatus(StatusUtil.getMoreSevere(fPathStatus, fNameStatus));
}
private StatusInfo nameUpdated() {
StatusInfo status= new StatusInfo();
String name= fNameField.getText();
if (name.length() == 0) {
status.setError(NewWizardMessages.getString("VariableCreationDialog.error.entername"));
return status;
}
IStatus val= JavaConventions.validateIdentifier(name);
if (val.matches(IStatus.ERROR)) {
|
7,487 |
Bug 7487 Classpath variable edit error message wrong
|
Using build 2002-01-09 on Windows 2000 From the prefrerence dialog, I opened the page Java > Classpath Variables. I selected the ECLIPSE_HOME variable and pressed Edit. The content came up as ECLIPSE_HOME D:/eclipse-sdk/2001-12-04/eclipse I started editing the path by removing the 2001-12-04 section D:/eclipse-sdk//eclipse At that point I got the following red error message at the bottom of the dialog !VariableCreationDialogerror.invalidpath!
|
resolved fixed
|
c5a405e
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-11T18:33:05Z | 2002-01-11T14:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableCreationDialog.java
|
status.setError(NewWizardMessages.getFormattedString("VariableCreationDialog.error.invalidname", val.getMessage()));
} else if (nameConflict(name)) {
status.setError(NewWizardMessages.getString("VariableCreationDialog.error.nameexists"));
}
return status;
}
private boolean nameConflict(String name) {
if (fElement != null && fElement.getName().equals(name)) {
return false;
}
for (int i= 0; i < fExistingNames.size(); i++) {
CPVariableElement elem= (CPVariableElement)fExistingNames.get(i);
if (name.equals(elem.getName())){
return true;
}
}
return false;
}
private StatusInfo pathUpdated() {
StatusInfo status= new StatusInfo();
String path= fPathField.getText();
if (path.length() > 0) {
if (!Path.ROOT.isValidPath(path)) {
status.setError(NewWizardMessages.getString("VariableCreationDialogerror.invalidpath"));
} else if (!new File(path).exists()) {
status.setWarning(NewWizardMessages.getString("VariableCreationDialog.warning.pathnotexists"));
|
7,487 |
Bug 7487 Classpath variable edit error message wrong
|
Using build 2002-01-09 on Windows 2000 From the prefrerence dialog, I opened the page Java > Classpath Variables. I selected the ECLIPSE_HOME variable and pressed Edit. The content came up as ECLIPSE_HOME D:/eclipse-sdk/2001-12-04/eclipse I started editing the path by removing the 2001-12-04 section D:/eclipse-sdk//eclipse At that point I got the following red error message at the bottom of the dialog !VariableCreationDialogerror.invalidpath!
|
resolved fixed
|
c5a405e
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-11T18:33:05Z | 2002-01-11T14:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableCreationDialog.java
|
}
}
return status;
}
private String getInitPath() {
String initPath= fPathField.getText();
if (initPath.length() == 0) {
initPath= fDialogSettings.get(IUIConstants.DIALOGSTORE_LASTEXTJAR);
if (initPath == null) {
initPath= "";
}
} else {
IPath entryPath= new Path(initPath);
if (ArchiveFileFilter.isArchivePath(entryPath)) {
entryPath.removeLastSegments(1);
}
initPath= entryPath.toOSString();
}
return initPath;
}
/*
* Open a dialog to choose a jar from the file system
*/
private IPath chooseExtJarFile() {
String initPath= getInitPath();
|
7,487 |
Bug 7487 Classpath variable edit error message wrong
|
Using build 2002-01-09 on Windows 2000 From the prefrerence dialog, I opened the page Java > Classpath Variables. I selected the ECLIPSE_HOME variable and pressed Edit. The content came up as ECLIPSE_HOME D:/eclipse-sdk/2001-12-04/eclipse I started editing the path by removing the 2001-12-04 section D:/eclipse-sdk//eclipse At that point I got the following red error message at the bottom of the dialog !VariableCreationDialogerror.invalidpath!
|
resolved fixed
|
c5a405e
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-11T18:33:05Z | 2002-01-11T14:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableCreationDialog.java
|
FileDialog dialog= new FileDialog(getShell());
dialog.setText(NewWizardMessages.getString("VariableCreationDialog.extjardialog.text"));
dialog.setFilterExtensions(new String[] {"*.jar;*.zip"});
dialog.setFilterPath(initPath);
String res= dialog.open();
if (res != null) {
fDialogSettings.put(IUIConstants.DIALOGSTORE_LASTEXTJAR, dialog.getFilterPath());
return new Path(res).makeAbsolute();
}
return null;
}
private IPath chooseExtDirectory() {
String initPath= getInitPath();
DirectoryDialog dialog= new DirectoryDialog(getShell());
dialog.setText(NewWizardMessages.getString("VariableCreationDialog.extdirdialog.text"));
dialog.setMessage(NewWizardMessages.getString("VariableCreationDialog.extdirdialog.message"));
dialog.setFilterPath(initPath);
String res= dialog.open();
if (res != null) {
fDialogSettings.put(IUIConstants.DIALOGSTORE_LASTEXTJAR, dialog.getFilterPath());
return new Path(res);
}
return null;
}
}
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/IPreferencesConstants.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui;
/**
* Defines constants which are used to refer to values in the plugin's preference bundle.
*/
public interface IPreferencesConstants {
static final String LINK_PACKAGES_TO_EDITOR= "org.eclipse.jdt.ui.packages.linktoeditor";
static final String SHOW_CU_CHILDREN="org.eclipse.jdt.ui.packages.cuchildren";
static final String LINK_TYPEHIERARCHY_TO_EDITOR= "org.eclipse.jdt.ui.packages.linktypehierarchytoeditor";
static final String SRCBIN_FOLDERS_IN_NEWPROJ= "org.eclipse.jdt.ui.wizards.srcBinFoldersInNewProjects";
static final String OPEN_TYPE_HIERARCHY= "org.eclipse.jdt.ui.openTypeHierarchy";
static final String OPEN_TYPE_HIERARCHY_IN_PERSPECTIVE= "perspective";
static final String OPEN_TYPE_HIERARCHY_IN_VIEW_PART= "viewPart";
static final String DOUBLE_CLICK_GOES_INTO= "packageview.gointo";
static final String EDITOR_SHOW_HOVER= "org.eclipse.jdt.ui.editor.showHover";
static final String EDITOR_SHOW_SEGMENTS= "org.eclipse.jdt.ui.editor.showSegments";
}
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.packageview;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DragSource;
import org.eclipse.swt.dnd.FileTransfer;
import org.eclipse.swt.dnd.Transfer;
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.ScrollBar;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.DecoratingLabelProvider;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.ILabelDecorator;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeViewerListener;
import org.eclipse.jface.viewers.SelectionChangedEvent;
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeExpansionEvent;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IPartListener;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.actions.NewWizardMenu;
import org.eclipse.ui.actions.OpenPerspectiveMenu;
import org.eclipse.ui.actions.OpenWithMenu;
import org.eclipse.ui.actions.RefreshAction;
import org.eclipse.ui.dialogs.PropertyDialogAction;
import org.eclipse.ui.help.ViewContextComputer;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.ui.part.ISetSelectionTarget;
import org.eclipse.ui.part.ResourceTransfer;
import org.eclipse.ui.part.ViewPart;
import org.eclipse.ui.views.internal.framelist.BackAction;
import org.eclipse.ui.views.internal.framelist.ForwardAction;
import org.eclipse.ui.views.internal.framelist.FrameList;
import org.eclipse.ui.views.internal.framelist.GoIntoAction;
import org.eclipse.ui.views.internal.framelist.UpAction;
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
import org.eclipse.search.ui.IWorkingSet;
import org.eclipse.search.ui.SearchUI;
import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaModel;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IOpenable;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.IWorkingCopy;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.ui.IContextMenuConstants;
import org.eclipse.jdt.ui.IPackagesViewPart;
import org.eclipse.jdt.ui.JavaElementContentProvider;
import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.IPreferencesConstants;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.JavaPluginImages;
import org.eclipse.jdt.internal.ui.actions.ContextMenuGroup;
import org.eclipse.jdt.internal.ui.actions.GenerateGroup;
import org.eclipse.jdt.internal.ui.dnd.DelegatingDragAdapter;
import org.eclipse.jdt.internal.ui.dnd.DelegatingDropAdapter;
import org.eclipse.jdt.internal.ui.dnd.LocalSelectionTransfer;
import org.eclipse.jdt.internal.ui.dnd.ResourceTransferDragAdapter;
import org.eclipse.jdt.internal.ui.dnd.TransferDragSourceListener;
import org.eclipse.jdt.internal.ui.dnd.TransferDropTargetListener;
import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
import org.eclipse.jdt.internal.ui.javaeditor.IClassFileEditorInput;
import org.eclipse.jdt.internal.ui.javaeditor.JarEntryEditorInput;
import org.eclipse.jdt.internal.ui.preferences.JavaBasePreferencePage;
import org.eclipse.jdt.internal.ui.preferences.WorkInProgressPreferencePage;
import org.eclipse.jdt.internal.ui.refactoring.actions.RefactoringAction;
import org.eclipse.jdt.internal.ui.refactoring.actions.RefactoringGroup;
import org.eclipse.jdt.internal.ui.reorg.DeleteAction;
import org.eclipse.jdt.internal.ui.reorg.ReorgGroup;
import org.eclipse.jdt.internal.ui.search.JavaSearchGroup;
import org.eclipse.jdt.internal.ui.typehierarchy.MethodsViewerFilter;
import org.eclipse.jdt.internal.ui.typehierarchy.TypeHierarchyMessages;
import org.eclipse.jdt.internal.ui.util.OpenTypeHierarchyUtil;
import org.eclipse.jdt.internal.ui.viewsupport.JavaElementLabels;
import org.eclipse.jdt.internal.ui.viewsupport.JavaElementSorter;
import org.eclipse.jdt.internal.ui.viewsupport.ProblemTreeViewer;
import org.eclipse.jdt.internal.ui.viewsupport.StatusBarUpdater;
/**
* The ViewPart for the ProjectExplorer. It listens to part activation events.
* When selection linking with the editor is enabled the view selection tracks
* the active editor page. Similarly when a resource is selected in the packages
* view the corresponding editor is activated.
*/
public class PackageExplorerPart extends ViewPart implements ISetSelectionTarget, IMenuListener, IPackagesViewPart, IPropertyChangeListener {
public final static String VIEW_ID= JavaUI.ID_PACKAGES;
static final String TAG_SELECTION= "selection";
static final String TAG_EXPANDED= "expanded";
static final String TAG_ELEMENT= "element";
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
static final String TAG_PATH= "path";
static final String TAG_VERTICAL_POSITION= "verticalPosition";
static final String TAG_HORIZONTAL_POSITION= "horizontalPosition";
static final String TAG_FILTERS = "filters";
static final String TAG_FILTER = "filter";
static final String TAG_SHOWLIBRARIES = "showLibraries";
static final String TAG_SHOWBINARIES = "showBinaries";
static final String TAG_WORKINGSET = "workingset";
static final String TAG_HIDEFIELDS= "hidefields";
static final String TAG_HIDESTATIC= "hidestatic";
static final String TAG_HIDENONPUBLIC= "hidenonpublic";
private JavaElementPatternFilter fPatternFilter= new JavaElementPatternFilter();
private LibraryFilter fLibraryFilter= new LibraryFilter();
private BinaryProjectFilter fBinaryFilter= new BinaryProjectFilter();
private WorkingSetFilter fWorkingSetFilter= new WorkingSetFilter();
private MethodsViewerFilter fMemberFilter;
private ProblemTreeViewer fViewer;
private PackageExplorerLabelProvider fJavaElementLabelProvider;
private PackagesFrameSource fFrameSource;
private FrameList fFrameList;
private ContextMenuGroup[] fStandardGroups;
private Menu fContextMenu;
private OpenResourceAction fOpenCUAction;
private Action fOpenToAction;
private Action fShowTypeHierarchyAction;
private Action fShowNavigatorAction;
private PropertyDialogAction fPropertyDialogAction;
private RefactoringAction fDeleteAction;
private RefreshAction fRefreshAction;
private BackAction fBackAction;
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
private ForwardAction fForwardAction;
private GoIntoAction fZoomInAction;
private UpAction fUpAction;
private GotoTypeAction fGotoTypeAction;
private GotoPackageAction fGotoPackageAction;
private AddBookmarkAction fAddBookmarkAction;
private ActionContributionItem[] fFilterActions;
private Separator fFilterSeparator;
private FilterSelectionAction fFilterAction;
private ShowLibrariesAction fShowLibrariesAction;
private ShowBinariesAction fShowBinariesAction;
private FilterWorkingSetAction fFilterWorkingSetAction;
private RemoveWorkingSetFilterAction fRemoveWorkingSetAction;
private IMemento fMemento;
private ISelectionChangedListener fSelectionListener;
private IPartListener fPartListener= new IPartListener() {
public void partActivated(IWorkbenchPart part) {
if (part instanceof IEditorPart)
editorActivated((IEditorPart) part);
}
public void partBroughtToTop(IWorkbenchPart part) {
}
public void partClosed(IWorkbenchPart part) {
}
public void partDeactivated(IWorkbenchPart part) {
}
public void partOpened(IWorkbenchPart part) {
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
}
};
private ITreeViewerListener fExpansionListener= new ITreeViewerListener() {
public void treeCollapsed(TreeExpansionEvent event) {
}
public void treeExpanded(TreeExpansionEvent event) {
Object element= event.getElement();
if (element instanceof ICompilationUnit ||
element instanceof IClassFile)
expandMainType(element);
}
};
public PackageExplorerPart() {
}
/* (non-Javadoc)
* Method declared on IViewPart.
*/
public void init(IViewSite site, IMemento memento) throws PartInitException {
super.init(site, memento);
fMemento= memento;
}
/**
* Initializes the default preferences
*/
public static void initDefaults(IPreferenceStore store) {
store.setDefault(TAG_SHOWLIBRARIES, true);
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
store.setDefault(TAG_SHOWBINARIES, true);
}
/**
* Returns the package explorer part of the active perspective. If
* there isn't any package explorer part <code>null</code> is returned.
*/
public static PackageExplorerPart getFromActivePerspective() {
IViewPart view= JavaPlugin.getActivePage().findView(VIEW_ID);
if (view instanceof PackageExplorerPart)
return (PackageExplorerPart)view;
return null;
}
/**
* Makes the package explorer part visible in the active perspective. If there
* isn't a package explorer part registered <code>null</code> is returned.
* Otherwise the opened view part is returned.
*/
public static PackageExplorerPart openInActivePerspective() {
try {
return (PackageExplorerPart)JavaPlugin.getActivePage().showView(VIEW_ID);
} catch(PartInitException pe) {
return null;
}
}
public void dispose() {
if (fViewer != null)
JavaPlugin.getDefault().getProblemMarkerManager().removeListener(fViewer);
if (fContextMenu != null && !fContextMenu.isDisposed())
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
fContextMenu.dispose();
getSite().getPage().removePartListener(fPartListener);
JavaPlugin.getDefault().getPreferenceStore().removePropertyChangeListener(this);
if (fViewer != null)
fViewer.removeTreeListener(fExpansionListener);
super.dispose();
}
/**
* Implementation of IWorkbenchPart.createPartControl(Composite)
*/
public void createPartControl(Composite parent) {
fViewer= new ProblemTreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
boolean showCUChildren= JavaBasePreferencePage.showCompilationUnitChildren();
fViewer.setContentProvider(new JavaElementContentProvider(showCUChildren, false));
JavaPlugin.getDefault().getProblemMarkerManager().addListener(fViewer);
JavaPlugin.getDefault().getPreferenceStore().addPropertyChangeListener(this);
fJavaElementLabelProvider= new PackageExplorerLabelProvider();
fViewer.setLabelProvider(new DecoratingLabelProvider(fJavaElementLabelProvider, null));
fViewer.setSorter(new JavaElementSorter());
fViewer.addFilter(new EmptyInnerPackageFilter());
fViewer.setUseHashlookup(true);
fViewer.addFilter(fPatternFilter);
fViewer.addFilter(fLibraryFilter);
String title= TypeHierarchyMessages.getString("MethodsViewer.hide_fields.label");
String helpContext= IJavaHelpContextIds.FILTER_FIELDS_ACTION;
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
MembersFilterAction hideFields= new MembersFilterAction(this, title, MethodsViewerFilter.FILTER_FIELDS, helpContext, false);
hideFields.setDescription(TypeHierarchyMessages.getString("MethodsViewer.hide_fields.description"));
hideFields.setToolTipChecked(TypeHierarchyMessages.getString("MethodsViewer.hide_fields.tooltip.checked"));
hideFields.setToolTipUnchecked(TypeHierarchyMessages.getString("MethodsViewer.hide_fields.tooltip.unchecked"));
JavaPluginImages.setLocalImageDescriptors(hideFields, "fields_co.gif");
title= TypeHierarchyMessages.getString("MethodsViewer.hide_static.label");
helpContext= IJavaHelpContextIds.FILTER_STATIC_ACTION;
MembersFilterAction hideStatic= new MembersFilterAction(this, title, MethodsViewerFilter.FILTER_STATIC, helpContext, false);
hideStatic.setDescription(TypeHierarchyMessages.getString("MethodsViewer.hide_static.description"));
hideStatic.setToolTipChecked(TypeHierarchyMessages.getString("MethodsViewer.hide_static.tooltip.checked"));
hideStatic.setToolTipUnchecked(TypeHierarchyMessages.getString("MethodsViewer.hide_static.tooltip.unchecked"));
JavaPluginImages.setLocalImageDescriptors(hideStatic, "static_co.gif");
title= TypeHierarchyMessages.getString("MethodsViewer.hide_nonpublic.label");
helpContext= IJavaHelpContextIds.FILTER_PUBLIC_ACTION;
MembersFilterAction hideNonPublic= new MembersFilterAction(this, title, MethodsViewerFilter.FILTER_NONPUBLIC, helpContext, false);
hideNonPublic.setDescription(TypeHierarchyMessages.getString("MethodsViewer.hide_nonpublic.description"));
hideNonPublic.setToolTipChecked(TypeHierarchyMessages.getString("MethodsViewer.hide_nonpublic.tooltip.checked"));
hideNonPublic.setToolTipUnchecked(TypeHierarchyMessages.getString("MethodsViewer.hide_nonpublic.tooltip.unchecked"));
JavaPluginImages.setLocalImageDescriptors(hideNonPublic, "public_co.gif");
fFilterActions= new ActionContributionItem[] {
new ActionContributionItem(hideFields),
new ActionContributionItem(hideStatic),
new ActionContributionItem(hideNonPublic)
};
fMemberFilter= new MethodsViewerFilter();
fViewer.addFilter(fMemberFilter);
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
fViewer.addFilter(fWorkingSetFilter);
if(fMemento != null)
restoreFilters();
else
initFilterFromPreferences();
fViewer.setInput(findInputElement());
initDragAndDrop();
initFrameList();
initKeyListener();
updateTitle();
MenuManager menuMgr= new MenuManager("#PopupMenu");
menuMgr.setRemoveAllWhenShown(true);
menuMgr.addMenuListener(this);
fContextMenu= menuMgr.createContextMenu(fViewer.getTree());
fViewer.getTree().setMenu(fContextMenu);
getSite().registerContextMenu(menuMgr, fViewer);
makeActions();
fSelectionListener= new ISelectionChangedListener() {
public void selectionChanged(SelectionChangedEvent event) {
handleSelectionChanged(event);
}
};
fViewer.addSelectionChangedListener(fSelectionListener);
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
fViewer.addDoubleClickListener(new IDoubleClickListener() {
public void doubleClick(DoubleClickEvent event) {
handleDoubleClick(event);
}
});
fViewer.getControl().addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent e) {
handleKeyPressed(e);
}
});
getSite().setSelectionProvider(fViewer);
getSite().getPage().addPartListener(fPartListener);
IStatusLineManager slManager= getViewSite().getActionBars().getStatusLineManager();
fViewer.addSelectionChangedListener(new StatusBarUpdater(slManager));
fViewer.addTreeListener(fExpansionListener);
if (fMemento != null)
restoreState(fMemento);
fMemento= null;
WorkbenchHelp.setHelp(fViewer.getControl(), new ViewContextComputer(this, IJavaHelpContextIds.PACKAGE_VIEW));
fillActionBars();
}
private void fillActionBars() {
IActionBars actionBars= getViewSite().getActionBars();
IToolBarManager toolBar= actionBars.getToolBarManager();
toolBar.add(fBackAction);
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
toolBar.add(fForwardAction);
toolBar.add(fUpAction);
fFilterSeparator= new Separator();
if (JavaBasePreferencePage.showCompilationUnitChildren())
addFilterActions(toolBar);
actionBars.updateActionBars();
IMenuManager menu= actionBars.getMenuManager();
menu.add(fFilterAction);
menu.add(fShowLibrariesAction);
menu.add(fFilterWorkingSetAction);
menu.add(fRemoveWorkingSetAction);
menu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
menu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS+"-end"));
}
private Object findInputElement() {
Object input= getSite().getPage().getInput();
if (input instanceof IWorkspace) {
return JavaCore.create(((IWorkspace)input).getRoot());
} else if (input instanceof IContainer) {
return JavaCore.create((IContainer)input);
}
return JavaCore.create(JavaPlugin.getWorkspace().getRoot());
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
}
/**
* Answer the property defined by key.
*/
public Object getAdapter(Class key) {
if (key.equals(ISelectionProvider.class))
return fViewer;
return super.getAdapter(key);
}
/**
* Returns the tool tip text for the given element.
*/
String getToolTipText(Object element) {
String result;
if (!(element instanceof IResource)) {
result= ((ILabelProvider) getViewer().getLabelProvider()).getText(element);
} else {
IPath path= ((IResource) element).getFullPath();
if (path.isRoot()) {
result= PackagesMessages.getString("PackageExplorer.title");
} else {
result= path.makeRelative().toString();
}
}
IWorkingSet ws= fWorkingSetFilter.getWorkingSet();
if (ws == null)
return result;
String wsstr= "Working Set: "+ws.getName();
if (result.length() == 0)
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
return wsstr;
return result + " - " + wsstr;
}
public String getTitleToolTip() {
if (fViewer == null)
return super.getTitleToolTip();
return getToolTipText(fViewer.getInput());
}
/**
* @see IWorkbenchPart#setFocus()
*/
public void setFocus() {
fViewer.getTree().setFocus();
}
/**
* Sets the working set to be used for filtering this part
*/
public void setWorkingSet(IWorkingSet ws) {
fWorkingSetFilter.setWorkingSet(ws);
firePropertyChange(IWorkbenchPart.PROP_TITLE);
fFilterWorkingSetAction.setChecked(ws != null);
fRemoveWorkingSetAction.setEnabled(ws != null);
}
/**
* Filters the members list
*/
public void setMemberFilter(int filterProperty, boolean set) {
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
if (set) {
fMemberFilter.addFilter(filterProperty);
} else {
fMemberFilter.removeFilter(filterProperty);
}
for (int i= 0; i < fFilterActions.length; i++) {
if (((MembersFilterAction)fFilterActions[i].getAction()).getFilterProperty() == filterProperty) {
fFilterActions[i].getAction().setChecked(set);
}
}
getViewer().refresh();
}
/**
* Returns <code>true</code> if the given filter is set.
*/
public boolean hasMemberFilter(int filterProperty) {
return fMemberFilter.hasFilter(filterProperty);
}
/**
* Returns the shell to use for opening dialogs.
* Used in this class, and in the actions.
*/
private Shell getShell() {
return fViewer.getTree().getShell();
}
/**
* Returns the selection provider.
*/
private ISelectionProvider getSelectionProvider() {
return fViewer;
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
}
/**
* Returns the current selection.
*/
private ISelection getSelection() {
return fViewer.getSelection();
}
/**
* Called when the context menu is about to open. Override
* to add your own context dependent menu contributions.
*/
public void menuAboutToShow(IMenuManager menu) {
JavaPlugin.createStandardGroups(menu);
IStructuredSelection selection= (IStructuredSelection) fViewer.getSelection();
Object element= selection.getFirstElement();
fPropertyDialogAction.selectionChanged(selection);
MenuManager newMenu= new MenuManager(PackagesMessages.getString("PackageExplorer.new"));
menu.appendToGroup(IContextMenuConstants.GROUP_NEW, newMenu);
new NewWizardMenu(newMenu, getSite().getWorkbenchWindow(), false);
if (selection.size() == 1 && fViewer.isExpandable(element))
menu.appendToGroup(IContextMenuConstants.GROUP_GOTO, fZoomInAction);
addGotoMenu(menu);
fOpenCUAction.update();
if (fOpenCUAction.isEnabled())
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
menu.appendToGroup(IContextMenuConstants.GROUP_OPEN, fOpenCUAction);
addOpenWithMenu(menu, selection);
addOpenToMenu(menu, selection);
addRefactoring(menu);
ContextMenuGroup.add(menu, fStandardGroups, fViewer);
if (fAddBookmarkAction.canOperateOnSelection())
menu.appendToGroup(IContextMenuConstants.GROUP_REORGANIZE, fAddBookmarkAction);
menu.appendToGroup(IContextMenuConstants.GROUP_BUILD, fRefreshAction);
fRefreshAction.selectionChanged(selection);
menu.add(new Separator());
if (fPropertyDialogAction.isApplicableForSelection())
menu.appendToGroup(IContextMenuConstants.GROUP_PROPERTIES, fPropertyDialogAction);
}
void addGotoMenu(IMenuManager menu) {
MenuManager gotoMenu= new MenuManager(PackagesMessages.getString("PackageExplorer.gotoTitle"));
menu.appendToGroup(IContextMenuConstants.GROUP_GOTO, gotoMenu);
gotoMenu.add(fBackAction);
gotoMenu.add(fForwardAction);
gotoMenu.add(fUpAction);
gotoMenu.add(fGotoTypeAction);
gotoMenu.add(fGotoPackageAction);
}
private void makeActions() {
ISelectionProvider provider= getSelectionProvider();
fOpenCUAction= new OpenResourceAction(provider);
fPropertyDialogAction= new PropertyDialogAction(getShell(), provider);
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
fShowNavigatorAction= new ShowInNavigatorAction(provider);
fAddBookmarkAction= new AddBookmarkAction(provider);
fStandardGroups= new ContextMenuGroup[] {
new BuildGroup(),
new ReorgGroup(),
new GenerateGroup(),
new JavaSearchGroup()
};
fDeleteAction= new DeleteAction(provider);
fRefreshAction= new RefreshAction(getShell());
fFilterAction = new FilterSelectionAction(getShell(), this, PackagesMessages.getString("PackageExplorer.filters"));
fShowLibrariesAction = new ShowLibrariesAction(this, PackagesMessages.getString("PackageExplorer.referencedLibs"));
fShowBinariesAction = new ShowBinariesAction(getShell(), this, PackagesMessages.getString("PackageExplorer.binaryProjects"));
fFilterWorkingSetAction = new FilterWorkingSetAction(getShell(), this, "Filter Working Set...");
fRemoveWorkingSetAction = new RemoveWorkingSetFilterAction(getShell(), this, "Remove Working Set Filter");
fBackAction= new BackAction(fFrameList);
fForwardAction= new ForwardAction(fFrameList);
fZoomInAction= new GoIntoAction(fFrameList);
fUpAction= new UpAction(fFrameList);
fGotoTypeAction= new GotoTypeAction(this);
fGotoPackageAction= new GotoPackageAction(this);
IActionBars actionService= getViewSite().getActionBars();
actionService.setGlobalActionHandler(IWorkbenchActionConstants.DELETE, fDeleteAction);
}
private void addRefactoring(IMenuManager menu){
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
MenuManager refactoring= new MenuManager(PackagesMessages.getString("PackageExplorer.refactoringTitle"));
ContextMenuGroup.add(refactoring, new ContextMenuGroup[] { new RefactoringGroup() }, fViewer);
if (!refactoring.isEmpty())
menu.appendToGroup(IContextMenuConstants.GROUP_REORGANIZE, refactoring);
}
private void addOpenToMenu(IMenuManager menu, IStructuredSelection selection) {
if (selection.size() != 1)
return;
IAdaptable element= (IAdaptable) selection.getFirstElement();
IResource resource= (IResource)element.getAdapter(IResource.class);
if ((resource instanceof IContainer)) {
MenuManager submenu = new MenuManager(PackagesMessages.getString("PackageExplorer.openPerspective"));
submenu.add(new OpenPerspectiveMenu(getSite().getWorkbenchWindow(), resource));
menu.appendToGroup(IContextMenuConstants.GROUP_OPEN, submenu);
}
OpenTypeHierarchyUtil.addToMenu(getSite().getWorkbenchWindow(), menu, element);
}
private void addOpenWithMenu(IMenuManager menu, IStructuredSelection selection) {
if (selection.size() != 1)
return;
IAdaptable element= (IAdaptable)selection.getFirstElement();
Object resource= element.getAdapter(IResource.class);
if (!(resource instanceof IFile))
return;
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
MenuManager submenu= new MenuManager(PackagesMessages.getString("PackageExplorer.openWith"));
submenu.add(new OpenWithMenu(getSite().getPage(), (IFile) resource));
menu.appendToGroup(IContextMenuConstants.GROUP_OPEN, submenu);
}
private boolean isSelectionOfType(ISelection s, Class clazz, boolean considerUnderlyingResource) {
if (! (s instanceof IStructuredSelection) || s.isEmpty())
return false;
IStructuredSelection selection= (IStructuredSelection)s;
Iterator iter= selection.iterator();
while (iter.hasNext()) {
Object o= iter.next();
if (clazz.isInstance(o))
return true;
if (considerUnderlyingResource) {
if (! (o instanceof IJavaElement))
return false;
IJavaElement element= (IJavaElement)o;
Object resource= element.getAdapter(IResource.class);
if (! clazz.isInstance(resource))
return false;
}
}
return true;
}
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
private void initDragAndDrop() {
int ops= DND.DROP_COPY | DND.DROP_MOVE;
final LocalSelectionTransfer lt= LocalSelectionTransfer.getInstance();
Transfer[] transfers= new Transfer[] {
lt,
ResourceTransfer.getInstance(),
FileTransfer.getInstance()};
TransferDropTargetListener[] dropListeners= new TransferDropTargetListener[] {
new SelectionTransferDropAdapter(fViewer),
new FileTransferDropAdapter(fViewer)
};
fViewer.addDropSupport(ops, transfers, new DelegatingDropAdapter(dropListeners));
Control control= fViewer.getControl();
TransferDragSourceListener[] dragListeners= new TransferDragSourceListener[] {
new SelectionTransferDragAdapter(fViewer),
new ResourceTransferDragAdapter(fViewer),
new FileTransferDragAdapter(fViewer)
};
DragSource source= new DragSource(control, ops);
source.addDragListener(new DelegatingDragAdapter(dragListeners));
}
/**
* Handles key events in viewer.
*/
void handleKeyPressed(KeyEvent event) {
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
if (event.character == SWT.DEL && event.stateMask == 0){
fDeleteAction.update();
if (fDeleteAction.isEnabled())
fDeleteAction.run();
}
}
/**
* Handles double clicks in viewer.
* Opens editor if file double-clicked.
*/
private void handleDoubleClick(DoubleClickEvent event) {
IStructuredSelection s= (IStructuredSelection) event.getSelection();
Object element= s.getFirstElement();
if (fOpenCUAction.isEnabled()) {
fOpenCUAction.run();
return;
}
if (fViewer.isExpandable(element)) {
if (JavaBasePreferencePage.doubleClickGoesInto()) {
if (element instanceof IOpenable &&
!(element instanceof ICompilationUnit) &&
!(element instanceof IClassFile)) {
fZoomInAction.run();
}
} else {
fViewer.setExpandedState(element, !fViewer.getExpandedState(element));
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
}
}
}
/**
* Handles selection changed in viewer.
* Updates global actions.
* Links to editor (if option enabled)
*/
private void handleSelectionChanged(SelectionChangedEvent event) {
IStructuredSelection sel= (IStructuredSelection) event.getSelection();
fZoomInAction.update();
linkToEditor(sel);
}
public void selectReveal(ISelection selection) {
ISelection javaSelection= convertSelection(selection);
fViewer.setSelection(javaSelection, true);
}
private ISelection convertSelection(ISelection s) {
List converted= new ArrayList();
if (s instanceof StructuredSelection) {
Object[] elements= ((StructuredSelection)s).toArray();
for (int i= 0; i < elements.length; i++) {
Object e= elements[i];
if (e instanceof IJavaElement)
converted.add(e);
else if (e instanceof IResource) {
IJavaElement element= JavaCore.create((IResource)e);
if (element != null)
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
converted.add(element);
else
converted.add(e);
}
}
}
return new StructuredSelection(converted.toArray());
}
public void selectAndReveal(Object element) {
selectReveal(new StructuredSelection(element));
}
/**
* Returns whether the preference to link selection to active editor is enabled.
*/
boolean isLinkingEnabled() {
return JavaBasePreferencePage.linkPackageSelectionToEditor();
}
/**
* Links to editor (if option enabled)
*/
private void linkToEditor(IStructuredSelection selection) {
Object obj= selection.getFirstElement();
Object element= null;
if (selection.size() == 1) {
if (obj instanceof IJavaElement) {
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
IJavaElement cu= JavaModelUtil.findElementOfKind((IJavaElement)obj, IJavaElement.COMPILATION_UNIT);
if (cu != null)
element= getResourceFor(cu);
if (element == null)
element= JavaModelUtil.findElementOfKind((IJavaElement)obj, IJavaElement.CLASS_FILE);
}
else if (obj instanceof IFile)
element= obj;
if (element == null)
return;
IWorkbenchPage page= getSite().getPage();
IEditorPart editorArray[]= page.getEditors();
for (int i= 0; i < editorArray.length; ++i) {
IEditorPart editor= editorArray[i];
Object input= getElementOfInput(editor.getEditorInput());
if (input != null && input.equals(element)) {
page.bringToTop(editor);
if (obj instanceof IJavaElement)
EditorUtility.revealInEditor(editor, (IJavaElement) obj);
return;
}
}
}
}
private IResource getResourceFor(Object element) {
if (element instanceof IJavaElement) {
if (element instanceof IWorkingCopy) {
IWorkingCopy wc= (IWorkingCopy)element;
IJavaElement original= wc.getOriginalElement();
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
if (original != null)
element= original;
}
try {
element= ((IJavaElement)element).getUnderlyingResource();
} catch (JavaModelException e) {
return null;
}
}
if (!(element instanceof IResource) || ((IResource)element).isPhantom()) {
return null;
}
return (IResource)element;
}
public void saveState(IMemento memento) {
if (fViewer == null) {
if (fMemento != null)
memento.putMemento(fMemento);
return;
}
saveExpansionState(memento);
saveSelectionState(memento);
saveScrollState(memento, fViewer.getTree());
savePatternFilterState(memento);
saveFilterState(memento);
saveWorkingSetState(memento);
saveMemberFilterState(memento);
}
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
protected void saveFilterState(IMemento memento) {
boolean showLibraries= getLibraryFilter().getShowLibraries();
String show= "true";
if (!showLibraries)
show= "false";
memento.putString(TAG_SHOWLIBRARIES, show);
boolean showBinaries= getBinaryFilter().getShowBinaries();
String showBinString= "true";
if (!showBinaries)
showBinString= "false";
memento.putString(TAG_SHOWBINARIES, showBinString);
}
protected void savePatternFilterState(IMemento memento) {
String filters[] = getPatternFilter().getPatterns();
if(filters.length > 0) {
IMemento filtersMem = memento.createChild(TAG_FILTERS);
for (int i = 0; i < filters.length; i++){
IMemento child = filtersMem.createChild(TAG_FILTER);
child.putString(TAG_ELEMENT,filters[i]);
}
}
}
protected void saveScrollState(IMemento memento, Tree tree) {
ScrollBar bar= tree.getVerticalBar();
int position= bar != null ? bar.getSelection() : 0;
memento.putString(TAG_VERTICAL_POSITION, String.valueOf(position));
bar= tree.getHorizontalBar();
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
position= bar != null ? bar.getSelection() : 0;
memento.putString(TAG_HORIZONTAL_POSITION, String.valueOf(position));
}
protected void saveSelectionState(IMemento memento) {
Object elements[]= ((IStructuredSelection) fViewer.getSelection()).toArray();
if (elements.length > 0) {
IMemento selectionMem= memento.createChild(TAG_SELECTION);
for (int i= 0; i < elements.length; i++) {
IMemento elementMem= selectionMem.createChild(TAG_ELEMENT);
Object o= elements[i];
if (o instanceof IJavaElement)
elementMem.putString(TAG_PATH, ((IJavaElement) elements[i]).getHandleIdentifier());
}
}
}
protected void saveExpansionState(IMemento memento) {
Object expandedElements[]= fViewer.getExpandedElements();
if (expandedElements.length > 0) {
IMemento expandedMem= memento.createChild(TAG_EXPANDED);
for (int i= 0; i < expandedElements.length; i++) {
IMemento elementMem= expandedMem.createChild(TAG_ELEMENT);
Object o= expandedElements[i];
if (o instanceof IJavaElement)
elementMem.putString(TAG_PATH, ((IJavaElement) expandedElements[i]).getHandleIdentifier());
}
}
}
protected void saveWorkingSetState(IMemento memento) {
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
IWorkingSet ws= getWorkingSetFilter().getWorkingSet();
if (ws != null) {
memento.putString(TAG_WORKINGSET, ws.getName());
}
}
/**
* Saves the state of the filter actions
*/
public void saveMemberFilterState(IMemento memento) {
memento.putString(TAG_HIDEFIELDS, String.valueOf(hasMemberFilter(MethodsViewerFilter.FILTER_FIELDS)));
memento.putString(TAG_HIDESTATIC, String.valueOf(hasMemberFilter(MethodsViewerFilter.FILTER_STATIC)));
memento.putString(TAG_HIDENONPUBLIC, String.valueOf(hasMemberFilter(MethodsViewerFilter.FILTER_NONPUBLIC)));
}
/**
* Restores the state of the member filter actions
*/
public void restoreMemberFilterState(IMemento memento) {
boolean set= Boolean.valueOf(memento.getString(TAG_HIDEFIELDS)).booleanValue();
setMemberFilter(MethodsViewerFilter.FILTER_FIELDS, set);
set= Boolean.valueOf(memento.getString(TAG_HIDESTATIC)).booleanValue();
setMemberFilter(MethodsViewerFilter.FILTER_STATIC, set);
set= Boolean.valueOf(memento.getString(TAG_HIDENONPUBLIC)).booleanValue();
setMemberFilter(MethodsViewerFilter.FILTER_NONPUBLIC, set);
}
void restoreState(IMemento memento) {
restoreExpansionState(memento);
restoreSelectionState(memento);
restoreScrollState(memento, fViewer.getTree());
}
protected void restoreScrollState(IMemento memento, Tree tree) {
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
ScrollBar bar= tree.getVerticalBar();
if (bar != null) {
try {
String posStr= memento.getString(TAG_VERTICAL_POSITION);
int position;
position= new Integer(posStr).intValue();
bar.setSelection(position);
} catch (NumberFormatException e) {
}
}
bar= tree.getHorizontalBar();
if (bar != null) {
try {
String posStr= memento.getString(TAG_HORIZONTAL_POSITION);
int position;
position= new Integer(posStr).intValue();
bar.setSelection(position);
} catch (NumberFormatException e) {
}
}
}
protected void restoreSelectionState(IMemento memento) {
IMemento childMem;
childMem= memento.getChild(TAG_SELECTION);
if (childMem != null) {
ArrayList list= new ArrayList();
IMemento[] elementMem= childMem.getChildren(TAG_ELEMENT);
for (int i= 0; i < elementMem.length; i++) {
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
Object element= JavaCore.create(elementMem[i].getString(TAG_PATH));
list.add(element);
}
fViewer.setSelection(new StructuredSelection(list));
}
}
protected void restoreExpansionState(IMemento memento) {
IMemento childMem= memento.getChild(TAG_EXPANDED);
if (childMem != null) {
ArrayList elements= new ArrayList();
IMemento[] elementMem= childMem.getChildren(TAG_ELEMENT);
for (int i= 0; i < elementMem.length; i++) {
Object element= JavaCore.create(elementMem[i].getString(TAG_PATH));
elements.add(element);
}
fViewer.setExpandedElements(elements.toArray());
}
}
/**
* Create the KeyListener for doing the refresh on the viewer.
*/
private void initKeyListener() {
fViewer.getControl().addKeyListener(new KeyAdapter() {
public void keyReleased(KeyEvent event) {
doKeyPressed(event);
}
});
}
private void doKeyPressed(KeyEvent event) {
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
if (event.stateMask != 0)
return;
int key= event.keyCode;
if (key == SWT.F5) {
fRefreshAction.selectionChanged(
(IStructuredSelection) fViewer.getSelection());
if (fRefreshAction.isEnabled())
fRefreshAction.run();
} else if (key == SWT.F4) {
OpenTypeHierarchyUtil.open(getSelection(), getSite().getWorkbenchWindow());
} else if (key == SWT.F3) {
fOpenCUAction.update();
if (fOpenCUAction.isEnabled())
fOpenCUAction.run();
}
}
void initFrameList() {
fFrameSource= new PackagesFrameSource(this);
fFrameList= new FrameList(fFrameSource);
fFrameSource.connectTo(fFrameList);
}
/**
* An editor has been activated. Set the selection in this Packages Viewer
* to be the editor's input, if linking is enabled.
*/
void editorActivated(IEditorPart editor) {
if (!isLinkingEnabled())
return;
Object input= getElementOfInput(editor.getEditorInput());
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
Object element= null;
if (input instanceof IFile)
element= JavaCore.create((IFile)input);
if (element == null)
element= input;
if (element != null) {
IStructuredSelection oldSelection= (IStructuredSelection)getSelection();
if (oldSelection.size() == 1) {
Object o= oldSelection.getFirstElement();
if (o instanceof IMember) {
IMember m= (IMember)o;
if (element.equals(m.getCompilationUnit()))
return;
if (element.equals(m.getClassFile()))
return;
}
}
ISelection newSelection= new StructuredSelection(element);
if (!fViewer.getSelection().equals(newSelection)) {
try {
fViewer.removeSelectionChangedListener(fSelectionListener);
fViewer.setSelection(newSelection);
} finally {
fViewer.addSelectionChangedListener(fSelectionListener);
}
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
}
}
}
/**
* A compilation unit or class was expanded, expand
* the main type.
*/
void expandMainType(Object element) {
try {
IType type= null;
if (element instanceof ICompilationUnit) {
ICompilationUnit cu= (ICompilationUnit)element;
IType[] types= cu.getTypes();
if (types.length > 0)
type= types[0];
}
else if (element instanceof IClassFile) {
IClassFile cf= (IClassFile)element;
type= cf.getType();
}
if (type != null) {
final IType type2= type;
Control ctrl= fViewer.getControl();
if (ctrl != null && !ctrl.isDisposed()) {
ctrl.getDisplay().asyncExec(new Runnable() {
public void run() {
Control ctrl= fViewer.getControl();
if (ctrl != null && !ctrl.isDisposed())
fViewer.expandToLevel(type2, 1);
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
}
});
}
}
} catch(JavaModelException e) {
}
}
/**
* Returns the element contained in the EditorInput
*/
Object getElementOfInput(IEditorInput input) {
if (input instanceof IClassFileEditorInput)
return ((IClassFileEditorInput)input).getClassFile();
else if (input instanceof IFileEditorInput)
return ((IFileEditorInput)input).getFile();
else if (input instanceof JarEntryEditorInput)
return ((JarEntryEditorInput)input).getStorage();
return null;
}
/**
* Returns the Viewer.
*/
TreeViewer getViewer() {
return fViewer;
}
/**
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
* Returns the pattern filter for this view.
* @return the pattern filter
*/
JavaElementPatternFilter getPatternFilter() {
return fPatternFilter;
}
/**
* Returns the library filter for this view.
* @return the library filter
*/
LibraryFilter getLibraryFilter() {
return fLibraryFilter;
}
/**
* Returns the working set filter for this view.
* @return the working set filter
*/
WorkingSetFilter getWorkingSetFilter() {
return fWorkingSetFilter;
}
/**
* Returns the Binary filter for this view.
* @return the binary filter
*/
BinaryProjectFilter getBinaryFilter() {
return fBinaryFilter;
}
void restoreFilters() {
IMemento filtersMem= fMemento.getChild(TAG_FILTERS);
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
if(filtersMem != null) {
IMemento children[]= filtersMem.getChildren(TAG_FILTER);
String filters[]= new String[children.length];
for (int i = 0; i < children.length; i++) {
filters[i]= children[i].getString(TAG_ELEMENT);
}
getPatternFilter().setPatterns(filters);
} else {
getPatternFilter().setPatterns(new String[0]);
}
String show= fMemento.getString(TAG_SHOWLIBRARIES);
if (show != null)
getLibraryFilter().setShowLibraries(show.equals("true"));
else
initLibraryFilterFromPreferences();
String showbin= fMemento.getString(TAG_SHOWBINARIES);
if (showbin != null)
getBinaryFilter().setShowBinaries(showbin.equals("true"));
else
initBinaryFilterFromPreferences();
String workingSetName= fMemento.getString(TAG_WORKINGSET);
if (workingSetName != null) {
IWorkingSet ws= SearchUI.findWorkingSet(workingSetName);
if (ws != null) {
getWorkingSetFilter().setWorkingSet(ws);
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
}
}
restoreMemberFilterState(fMemento);
}
void initFilterFromPreferences() {
initBinaryFilterFromPreferences();
initLibraryFilterFromPreferences();
}
void initLibraryFilterFromPreferences() {
JavaPlugin plugin= JavaPlugin.getDefault();
boolean show= plugin.getPreferenceStore().getBoolean(TAG_SHOWLIBRARIES);
getLibraryFilter().setShowLibraries(show);
}
void initBinaryFilterFromPreferences() {
JavaPlugin plugin= JavaPlugin.getDefault();
boolean showbin= plugin.getPreferenceStore().getBoolean(TAG_SHOWBINARIES);
getBinaryFilter().setShowBinaries(showbin);
}
/**
* Updates the title text and title tool tip.
* Called whenever the input of the viewer changes.
*/
void updateTitle() {
Object input= getViewer().getInput();
String viewName= getConfigurationElement().getAttribute("name");
if (input == null
|| (input instanceof IJavaModel)) {
setTitle(viewName);
setTitleToolTip("");
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
} else {
ILabelProvider labelProvider = (ILabelProvider) getViewer().getLabelProvider();
String inputText= labelProvider.getText(input);
String title= PackagesMessages.getFormattedString("PackageExplorer.argTitle", new String[] { viewName, inputText });
setTitle(title);
setTitleToolTip(getToolTipText(input));
}
}
/**
* Sets the decorator for the package explorer.
*
* @param decorator a label decorator or <code>null</code> for no decorations.
*/
public void setLabelDecorator(ILabelDecorator decorator) {
if (decorator == null)
fViewer.setLabelProvider(fJavaElementLabelProvider);
else
fViewer.setLabelProvider(new DecoratingLabelProvider(fJavaElementLabelProvider, decorator));
}
/*
* @see IPropertyChangeListener#propertyChange(PropertyChangeEvent)
*/
public void propertyChange(PropertyChangeEvent event) {
if (fViewer == null)
return;
boolean refreshViewer= false;
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
if (event.getProperty() == IPreferencesConstants.SHOW_CU_CHILDREN) {
IPreferenceStore store= JavaPlugin.getDefault().getPreferenceStore();
IActionBars actionBars= getViewSite().getActionBars();
IToolBarManager toolBar= actionBars.getToolBarManager();
boolean b= store.getBoolean(IPreferencesConstants.SHOW_CU_CHILDREN);
((JavaElementContentProvider)fViewer.getContentProvider()).setProvideMembers(b);
if (b) {
addFilterActions(toolBar);
} else {
toolBar.remove(fFilterSeparator);
for (int i= 0; i < fFilterActions.length; i++)
toolBar.remove(fFilterActions[i]);
}
actionBars.updateActionBars();
refreshViewer= true;
}
if (event.getProperty() == WorkInProgressPreferencePage.PREF_COMPRESS_PKG_NAME_IN_PKG_VIEW) {
fJavaElementLabelProvider.setCompressingPkgNameInPackagesView(WorkInProgressPreferencePage.isCompressingPkgNameInPackagesView());
refreshViewer= true;
}
if (refreshViewer)
fViewer.refresh();
}
protected void addFilterActions(IToolBarManager toolBar) {
toolBar.add(fFilterSeparator);
for (int i= 0; i < fFilterActions.length; i++)
toolBar.add(fFilterActions[i]);
}
}
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/JavaBasePreferencePage.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.preferences;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.jface.preference.BooleanFieldEditor;
import org.eclipse.jface.preference.FieldEditorPreferencePage;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.RadioGroupFieldEditor;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPreferencePage;
import org.eclipse.ui.help.DialogPageContextComputer;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.IPreferencesConstants;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.JavaUIMessages;
/*
* The page for setting java plugin preferences.
*/
public class JavaBasePreferencePage extends FieldEditorPreferencePage implements IWorkbenchPreferencePage {
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/JavaBasePreferencePage.java
|
public JavaBasePreferencePage() {
super(GRID);
setPreferenceStore(JavaPlugin.getDefault().getPreferenceStore());
setDescription(JavaUIMessages.getString("JavaBasePreferencePage.description"));
}
public static void initDefaults(IPreferenceStore store) {
store.setDefault(IPreferencesConstants.LINK_PACKAGES_TO_EDITOR, true);
store.setDefault(IPreferencesConstants.SHOW_CU_CHILDREN, true);
store.setDefault(IPreferencesConstants.LINK_TYPEHIERARCHY_TO_EDITOR, false);
store.setDefault(IPreferencesConstants.OPEN_TYPE_HIERARCHY, IPreferencesConstants.OPEN_TYPE_HIERARCHY_IN_VIEW_PART);
store.setDefault(IPreferencesConstants.SRCBIN_FOLDERS_IN_NEWPROJ, false);
store.setDefault(IPreferencesConstants.DOUBLE_CLICK_GOES_INTO, false);
}
/**
* @see PreferencePage#createControl(Composite)
*/
public void createControl(Composite parent) {
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/JavaBasePreferencePage.java
|
super.createControl(parent);
WorkbenchHelp.setHelp(getControl(), new DialogPageContextComputer(this, IJavaHelpContextIds.JAVA_BASE_PREFERENCE_PAGE));
}
protected void createFieldEditors() {
Composite parent= getFieldEditorParent();
BooleanFieldEditor boolEditor= new BooleanFieldEditor(
IPreferencesConstants.LINK_PACKAGES_TO_EDITOR,
JavaUIMessages.getString("JavaBasePreferencePage.linkPackageView"),
parent
);
addField(boolEditor);
boolEditor= new BooleanFieldEditor(
IPreferencesConstants.LINK_TYPEHIERARCHY_TO_EDITOR,
JavaUIMessages.getString("JavaBasePreferencePage.linkTypeHierarchy"),
parent
);
addField(boolEditor);
boolEditor= new BooleanFieldEditor(
IPreferencesConstants.DOUBLE_CLICK_GOES_INTO,
JavaUIMessages.getString("JavaBasePreferencePage.dblClick"),
parent
);
addField(boolEditor);
boolEditor= new BooleanFieldEditor(
IPreferencesConstants.SHOW_CU_CHILDREN,
JavaUIMessages.getString("JavaBasePreferencePage.cuChildren"),
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/JavaBasePreferencePage.java
|
parent
);
addField(boolEditor);
boolEditor= new BooleanFieldEditor(
IPreferencesConstants.SRCBIN_FOLDERS_IN_NEWPROJ,
JavaUIMessages.getString("JavaBasePreferencePage.folders"),
parent
);
addField(boolEditor);
addField(new SpacerFieldEditor(parent));
RadioGroupFieldEditor editor= new RadioGroupFieldEditor(
IPreferencesConstants.OPEN_TYPE_HIERARCHY,
JavaUIMessages.getString("JavaBasePreferencePage.openTypeHierarchy"),
1,
new String[][] {
{JavaUIMessages.getString("JavaBasePreferencePage.inPerspective"), IPreferencesConstants.OPEN_TYPE_HIERARCHY_IN_PERSPECTIVE},
{JavaUIMessages.getString("JavaBasePreferencePage.inView"), IPreferencesConstants.OPEN_TYPE_HIERARCHY_IN_VIEW_PART}
},
parent);
addField(editor);
}
public void init(IWorkbench workbench) {
}
public static boolean useSrcAndBinFolders() {
IPreferenceStore store= JavaPlugin.getDefault().getPreferenceStore();
return store.getBoolean(IPreferencesConstants.SRCBIN_FOLDERS_IN_NEWPROJ);
}
|
5,651 |
Bug 5651 DCR: Please split up the "Use 'src' and 'bin' folders..." preference
|
Please split the "Use 'src' and 'bin' folders as default in new Java projects" preference into two separate preferences as follows: [ ] "Use 'src' folder as default in new Java projects" [ ] "Use 'bin' folder as default in new Java projects" The best way to describe why I would like this is to paste here a posting I just made to Eclipse Corner that describes how I work. You will notice that I have to do a couple of extra steps to get rid of the 'src' folder. I would just like to eliminate those extra steps. Here is the post: When I run Eclipse, I specify where I want my workspace to be, i.e. C:\eclipse\eclipse.exe -data D:\Eclipse\target So, Eclipse stores all of my projects in D:\Eclipse\target, even though I am running it from C:\eclipse. Of course, the .java and .class files are all mixed together, which I don't like, so when I create a Java project, I tell Eclipse to create 'src' and 'bin' folders. (Window -> Preferences -- Java "Use 'src' and 'bin' folders as default in new Java projects.") Now for one final step, which I do because I don't like the 'src' folder <grin>: - First, I delete the 'src' folder - Then I modify the Properties of the Project (select project, context menu -> Properties) and I also delete the 'src' folder from the Java Build Path - "Source" tab. - After this, I usually select "Use the project as source folder" in the "Source" tab (unless I want to have some other named source folders in the project (not 'src' <g>), in which case I just leave "Use source folders contained in the project" selected). At this point, I am ready to start adding packages to my project. The compiler puts all of my .class files for the projet into the 'bin' directory in: D:\Eclipse\target\MyProject\bin
|
resolved fixed
|
1a487ce
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:21:55Z | 2001-11-08T03:26:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/JavaBasePreferencePage.java
|
public static boolean linkPackageSelectionToEditor() {
IPreferenceStore store= JavaPlugin.getDefault().getPreferenceStore();
return store.getBoolean(IPreferencesConstants.LINK_PACKAGES_TO_EDITOR);
}
public static boolean showCompilationUnitChildren() {
IPreferenceStore store= JavaPlugin.getDefault().getPreferenceStore();
return store.getBoolean(IPreferencesConstants.SHOW_CU_CHILDREN);
}
public static boolean linkTypeHierarchySelectionToEditor() {
IPreferenceStore store= JavaPlugin.getDefault().getPreferenceStore();
return store.getBoolean(IPreferencesConstants.LINK_TYPEHIERARCHY_TO_EDITOR);
}
public static boolean openTypeHierarchyInPerspective() {
return IPreferencesConstants.OPEN_TYPE_HIERARCHY_IN_PERSPECTIVE.equals(
JavaPlugin.getDefault().getPreferenceStore().getString(IPreferencesConstants.OPEN_TYPE_HIERARCHY));
}
public static boolean openTypeHierarchInViewPart() {
return IPreferencesConstants.OPEN_TYPE_HIERARCHY_IN_VIEW_PART.equals(
JavaPlugin.getDefault().getPreferenceStore().getString(IPreferencesConstants.OPEN_TYPE_HIERARCHY));
}
public static boolean doubleClickGoesInto() {
IPreferenceStore store= JavaPlugin.getDefault().getPreferenceStore();
return store.getBoolean(IPreferencesConstants.DOUBLE_CLICK_GOES_INTO);
}
}
|
6,277 |
Bug 6277 Shift Left/Right use CTRL+I
|
Build 20011122. In the edit menu for a Java editor, the accelerators for Shift Left/Right use Ctrl+I. Shouldn't it show as Ctrl+Tab? Tab should be a different keycode than CTRL+I. Currently, the Java editor takes both.
|
resolved fixed
|
9b43529
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:53:47Z | 2001-11-23T21:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javaeditor/BasicEditorActionContributor.java
|
package org.eclipse.jdt.internal.ui.javaeditor;
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
import java.util.ResourceBundle;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.text.ITextOperationTarget;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.texteditor.BasicTextEditorActionContributor;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.ui.texteditor.RetargetTextEditorAction;
import org.eclipse.ui.texteditor.TextEditorAction;
import org.eclipse.jdt.ui.IContextMenuConstants;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.JavaPluginImages;
public class BasicEditorActionContributor extends BasicTextEditorActionContributor {
|
6,277 |
Bug 6277 Shift Left/Right use CTRL+I
|
Build 20011122. In the edit menu for a Java editor, the accelerators for Shift Left/Right use Ctrl+I. Shouldn't it show as Ctrl+Tab? Tab should be a different keycode than CTRL+I. Currently, the Java editor takes both.
|
resolved fixed
|
9b43529
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:53:47Z | 2001-11-23T21:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javaeditor/BasicEditorActionContributor.java
|
protected static class SelectionAction extends TextEditorAction implements ISelectionChangedListener {
protected int fOperationCode;
protected ITextOperationTarget fOperationTarget= null;
public SelectionAction(String prefix, int operation) {
super(JavaEditorMessages.getResourceBundle(), prefix, null);
fOperationCode= operation;
setEnabled(false);
}
/**
* @see TextEditorAction#setEditor(ITextEditor)
*/
public void setEditor(ITextEditor editor) {
if (getTextEditor() != null) {
|
6,277 |
Bug 6277 Shift Left/Right use CTRL+I
|
Build 20011122. In the edit menu for a Java editor, the accelerators for Shift Left/Right use Ctrl+I. Shouldn't it show as Ctrl+Tab? Tab should be a different keycode than CTRL+I. Currently, the Java editor takes both.
|
resolved fixed
|
9b43529
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:53:47Z | 2001-11-23T21:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javaeditor/BasicEditorActionContributor.java
|
ISelectionProvider p= getTextEditor().getSelectionProvider();
if (p != null) p.removeSelectionChangedListener(this);
}
super.setEditor(editor);
if (editor != null) {
ISelectionProvider p= editor.getSelectionProvider();
if (p != null) p.addSelectionChangedListener(this);
fOperationTarget= (ITextOperationTarget) editor.getAdapter(ITextOperationTarget.class);
} else
fOperationTarget= null;
selectionChanged(null);
}
/**
* @see ISelectionChangedListener#selectionChanged(SelectionChangedEvent)
*/
public void selectionChanged(SelectionChangedEvent event) {
boolean isEnabled= (fOperationTarget != null && fOperationTarget.canDoOperation(fOperationCode));
setEnabled(isEnabled);
}
/**
* @see Action#run()
*/
public void run() {
if (fOperationCode != -1 && fOperationTarget != null)
fOperationTarget.doOperation(fOperationCode);
|
6,277 |
Bug 6277 Shift Left/Right use CTRL+I
|
Build 20011122. In the edit menu for a Java editor, the accelerators for Shift Left/Right use Ctrl+I. Shouldn't it show as Ctrl+Tab? Tab should be a different keycode than CTRL+I. Currently, the Java editor takes both.
|
resolved fixed
|
9b43529
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:53:47Z | 2001-11-23T21:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javaeditor/BasicEditorActionContributor.java
|
}
};
protected RetargetTextEditorAction fContentAssist;
protected SelectionAction fShiftRight;
protected SelectionAction fShiftLeft;
public BasicEditorActionContributor() {
super();
fContentAssist= new RetargetTextEditorAction(JavaEditorMessages.getResourceBundle(), "ContentAssistProposal.");
fShiftRight= new SelectionAction("ShiftRight.", ITextOperationTarget.SHIFT_RIGHT);
fShiftLeft= new SelectionAction("ShiftLeft.", ITextOperationTarget.SHIFT_LEFT);
fShiftRight.setImageDescriptor(JavaPluginImages.DESC_MENU_SHIFT_RIGHT);
fShiftLeft.setImageDescriptor(JavaPluginImages.DESC_MENU_SHIFT_LEFT);
}
/**
* @see EditorActionBarContributor#contributeToMenu(IMenuManager)
*/
public void contributeToMenu(IMenuManager menu) {
super.contributeToMenu(menu);
IMenuManager editMenu= menu.findMenuUsingPath(IWorkbenchActionConstants.M_EDIT);
if (editMenu != null) {
editMenu.add(fShiftRight);
|
6,277 |
Bug 6277 Shift Left/Right use CTRL+I
|
Build 20011122. In the edit menu for a Java editor, the accelerators for Shift Left/Right use Ctrl+I. Shouldn't it show as Ctrl+Tab? Tab should be a different keycode than CTRL+I. Currently, the Java editor takes both.
|
resolved fixed
|
9b43529
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T12:53:47Z | 2001-11-23T21:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javaeditor/BasicEditorActionContributor.java
|
editMenu.add(fShiftLeft);
editMenu.add(new Separator(IContextMenuConstants.GROUP_OPEN));
editMenu.add(new Separator(IContextMenuConstants.GROUP_GENERATE));
editMenu.appendToGroup(IContextMenuConstants.GROUP_GENERATE, fContentAssist);
}
}
/**
* @see IEditorActionBarContributor#setActiveEditor(IEditorPart)
*/
public void setActiveEditor(IEditorPart part) {
super.setActiveEditor(part);
IStatusLineManager manager= getActionBars().getStatusLineManager();
manager.setMessage(null);
manager.setErrorMessage(null);
ITextEditor textEditor= null;
if (part instanceof ITextEditor)
textEditor= (ITextEditor) part;
fContentAssist.setAction(getAction(textEditor, "ContentAssistProposal"));
fShiftRight.setEditor(textEditor);
fShiftLeft.setEditor(textEditor);
}
}
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/MessageLine.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.dialogs;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CLabel;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Composite;
/**
* A message line. It distinguishs between "normal" messages and errors.
* Setting an error message hides a currently displayed message until
* <code>clearErrorMessage</code> is called.
*/
public class MessageLine extends CLabel {
public static final RGB RED= new RGB(200, 0, 0);
private static RGB fgDefaultErrorRGB= RED;
private String fMessageText;
private String fErrorText;
private Color fDefaultColor;
private RGB fErrorRGB;
private Color fErrorColor;
/**
* Creates a new message line as a child of the given parent.
* Error message will be shown in <code>RED</code>.
*/
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/MessageLine.java
|
public MessageLine(Composite parent) {
this(parent, SWT.LEFT);
}
/**
* Creates a new message line as a child of the parent and with the given SWT stylebits.
* Error message will be shown in <code>RED</code>.
*/
public MessageLine(Composite parent, int style) {
super(parent, style);
fDefaultColor= getForeground();
fErrorRGB= fgDefaultErrorRGB;
}
/**
* Creates a new message line as a child of the parent and with the given SWT stylebits.
* Error message will be shown with in the given rgb color.
*/
public MessageLine(Composite parent, int style, RGB errorRGB) {
super(parent, style);
fDefaultColor= getForeground();
fErrorRGB= errorRGB;
}
/**
* Clears the currently displayed error message and redisplayes
* the message which was active before the error message was set.
*/
public void clearErrorMessage() {
setErrorMessage(null);
}
/**
* Clears the currently displayed message.
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/MessageLine.java
|
*/
public void clearMessage() {
setMessage(null);
}
/**
* Get the currently displayed error text.
* @return The error message. If no error message is displayed <code>null</code> is returned.
*/
public String getErrorMessage() {
return fErrorText;
}
/**
* Get the currently displayed message.
* @return The message. If no message is displayed <code>null<code> is returned.
*/
public String getMessage() {
return fMessageText;
}
/**
* Sets the default error color used by all message lines.
* Note: a call to this method only affects newly created MessageLines not existing ones.
*/
public static void setDefaultErrorColor(RGB color) {
fgDefaultErrorRGB= color;
}
/**
* Display the given error message. A currently displayed message
* is saved and will be redisplayed when the error message is cleared.
*/
public void setErrorMessage(String message) {
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/MessageLine.java
|
fErrorText= message;
if (message == null) {
setMessage(fMessageText);
} else {
if (fErrorColor == null) {
fErrorColor= new Color(getDisplay(), fErrorRGB);
addDisposeListener(new DisposeListener() {
public void widgetDisposed(DisposeEvent e) {
fErrorColor.dispose();
}
});
}
setForeground(fErrorColor);
setText(message);
}
}
/**
* Set the message text. If the message line currently displays an error,
* the message is stored and will be shown after a call to clearErrorMessage
*/
public void setMessage(String message) {
fMessageText= message;
if (message == null)
message= "";
if (fErrorText == null) {
setForeground(fDefaultColor);
setText(message);
}
}
}
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/SelectionStatusDialog.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.dialogs;
import java.util.Arrays;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.dialogs.SelectionDialog;
import org.eclipse.core.runtime.IStatus;
/**
* An abstract base class for dialogs with a status bar and ok/cancel buttons.
* The status message must be passed over as StatusInfo object and can be
* an error, warning or ok. The OK button is enabled or disabled depending
* on the status.
*/
public abstract class SelectionStatusDialog extends SelectionDialog {
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/SelectionStatusDialog.java
|
private MessageLine fStatusLine;
private IStatus fLastStatus;
private Image fImage;
private boolean fStatusLineAboveButtons= false;
/**
* Creates an instance of a <code>SelectionStatusDialog</code>.
*/
public SelectionStatusDialog(Shell parent) {
super(parent);
}
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/SelectionStatusDialog.java
|
/**
* Controls whether status line appears to the left of the buttons (default)
* or above them.
*
* @param aboveButtons if <code>true</code> status line is placed above buttons; if
* <code>false</code> to the right
*/
public void setStatusLineAboveButtons(boolean aboveButtons) {
fStatusLineAboveButtons= aboveButtons;
}
/**
* Sets the image for this dialog.
* @param image the image.
*/
public void setImage(Image image) {
fImage= image;
}
/**
* Returns the first element from the list of results. Returns <code>null</code>
* if no element has been selected.
*
* @return the first result element if one exists. Otherwise <code>null</code> is
* returned.
*/
public Object getFirstResult() {
Object[] result= getResult();
if (result == null || result.length == 0)
return null;
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/SelectionStatusDialog.java
|
return result[0];
}
/**
* Sets a result element at the given position.
*/
protected void setResult(int position, Object element) {
Object[] result= getResult();
result[position]= element;
setResult(Arrays.asList(result));
}
/**
* Compute the result and return it.
*/
protected abstract void computeResult();
/*
* @see Window#configureShell(shell)
*/
protected void configureShell(Shell shell) {
super.configureShell(shell);
if (fImage != null)
shell.setImage(fImage);
}
/**
* Update the dialog's status line to reflect the given status. It is safe to call
* this method before the dialog has been opened.
*/
protected void updateStatus(IStatus status) {
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/SelectionStatusDialog.java
|
fLastStatus= status;
if (fStatusLine != null && !fStatusLine.isDisposed()) {
updateButtonsEnableState(status);
StatusUtil.applyToStatusLine(fStatusLine, status);
}
}
/**
* Update the status of the ok button to reflect the given status. Subclasses
* may override this method to update additional buttons.
*/
protected void updateButtonsEnableState(IStatus status) {
Button okButton= getOkButton();
if (okButton != null && !okButton.isDisposed())
okButton.setEnabled(!status.matches(IStatus.ERROR));
}
/*
* @see Dialog#okPressed()
*/
protected void okPressed() {
computeResult();
super.okPressed();
}
/*
* @see Window#create()
*/
public void create() {
super.create();
if (fLastStatus != null)
updateStatus(fLastStatus);
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/SelectionStatusDialog.java
|
}
/*
* @see Dialog#createButtonBar(Composite)
*/
protected Control createButtonBar(Composite parent) {
Composite composite= new Composite(parent, SWT.NULL);
GridLayout layout= new GridLayout();
if (fStatusLineAboveButtons) {
layout.marginWidth= 5;
} else {
layout.numColumns= 2;
}
layout.marginHeight= 0; layout.marginWidth= 0;
composite.setLayout(layout);
composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
fStatusLine= new MessageLine(composite);
fStatusLine.setAlignment(SWT.LEFT);
fStatusLine.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
fStatusLine.setMessage("");
GridData gd= new GridData(GridData.FILL_HORIZONTAL);
gd.horizontalIndent= convertWidthInCharsToPixels(1);
fStatusLine.setLayoutData(gd);
super.createButtonBar(composite);
return composite;
}
}
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/StatusDialog.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.dialogs;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.core.runtime.IStatus;
/**
* An abstract base class for dialogs with a status bar and ok/cancel buttons.
* The status message must be passed over as StatusInfo object and can be
* an error, warning or ok. The OK button is enabled or disabled depending
* on the status.
*/
public abstract class StatusDialog extends Dialog {
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/StatusDialog.java
|
private Button fOkButton;
private MessageLine fStatusLine;
private IStatus fLastStatus;
private String fTitle;
private Image fImage;
private boolean fStatusLineAboveButtons;
/**
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/StatusDialog.java
|
* Creates an instane of a status dialog.
*/
public StatusDialog(Shell parent) {
super(parent);
fStatusLineAboveButtons= false;
}
/**
* Specifies whether status line appears to the left of the buttons (default)
* or above them.
*
* @param aboveButtons if <code>true</code> status line is placed above buttons; if
* <code>false</code> to the right
*/
public void setStatusLineAboveButtons(boolean aboveButtons) {
fStatusLineAboveButtons= aboveButtons;
}
/**
* Update the dialog's status line to reflect the given status.
* It is save to call this method before the dialog has been opened.
*/
protected void updateStatus(IStatus status) {
fLastStatus= status;
if (fStatusLine != null && !fStatusLine.isDisposed()) {
updateButtonsEnableState(status);
StatusUtil.applyToStatusLine(fStatusLine, status);
}
}
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/StatusDialog.java
|
/**
* Returns the last status.
*/
public IStatus getStatus() {
return fLastStatus;
}
/**
* Updates the status of the ok button to reflect the given status.
* Subclasses may override this method to update additional buttons.
* @param status the status.
*/
protected void updateButtonsEnableState(IStatus status) {
if (fOkButton != null && !fOkButton.isDisposed())
fOkButton.setEnabled(!status.matches(IStatus.ERROR));
}
/*
* @see Window#create(Shell)
*/
protected void configureShell(Shell shell) {
super.configureShell(shell);
if (fTitle != null)
shell.setText(fTitle);
}
/*
* @see Window#create()
*/
public void create() {
super.create();
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/StatusDialog.java
|
if (fLastStatus != null) {
if (fLastStatus.matches(IStatus.ERROR)) {
StatusInfo status= new StatusInfo();
status.setError("");
fLastStatus= status;
}
updateStatus(fLastStatus);
}
}
/*
* @see Dialog#createButtonsForButtonBar(Composite)
*/
protected void createButtonsForButtonBar(Composite parent) {
fOkButton= createButton(parent, IDialogConstants.OK_ID, IDialogConstants.OK_LABEL, true);
createButton(parent, IDialogConstants.CANCEL_ID, IDialogConstants.CANCEL_LABEL, false);
}
/*
* @see Dialog#createButtonBar(Composite)
*/
protected Control createButtonBar(Composite parent) {
Composite composite= new Composite(parent, SWT.NULL);
GridLayout layout= new GridLayout();
layout.numColumns= 1;
layout.marginHeight= 0;
layout.marginWidth= convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
composite.setLayout(layout);
composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/StatusDialog.java
|
fStatusLine= new MessageLine(composite);
fStatusLine.setAlignment(SWT.LEFT);
fStatusLine.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
fStatusLine.setMessage("");
super.createButtonBar(composite);
return composite;
}
/**
* Sets the title for this dialog.
* @param title the title.
*/
public void setTitle(String title) {
fTitle= title != null ? title : "";
Shell shell= getShell();
if ((shell != null) && !shell.isDisposed())
shell.setText(fTitle);
}
/**
* Sets the image for this dialog.
* @param image the image.
*/
public void setImage(Image image) {
fImage= image;
Shell shell= getShell();
if ((shell != null) && !shell.isDisposed())
shell.setImage(fImage);
}
}
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
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.jface.dialogs.DialogPage;
import org.eclipse.core.runtime.IStatus;
/**
* A utility class to work with IStatus.
*/
public class StatusUtil {
/**
* 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) {
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/StatusUtil.java
|
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;
}
/**
* Returns error-message / warning-message for a status.
* @return Array of size 2. Index 0 is the error message or <null>
* if not an error. Index 1 the warning message or <null> if not a warning.
*/
|
7,252 |
Bug 7252 Can add a variable with no associated jar file to a build path
|
It is possible to add a variable to the build path for a project using add variable but this will not pick up the classes in that directory. The user although warned can still select it. STEPS 1) Define a classpath variable PATH_TEST that is a directory with classes in it 2) Open the properties dialog on a JavaProject 3) Select the Libraries Tag 4) Select Add Variable 5) Select PATH_TEST 6) You will get a message that Resolved path does not exist. However OK is enabled so you can select this and believe it is valid.The UI correctly shows the empty circle to indicate it is not found but it is easy to miss the cause of this.
|
verified fixed
|
a364a78
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-14T16:14:00Z | 2002-01-04T13:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/dialogs/StatusUtil.java
|
private static String[] getErrorMessages(IStatus status) {
String message= status.getMessage();
if (status.matches(IStatus.ERROR) && !"".equals(message)) {
return new String[] { message, null };
} else if (status.matches(IStatus.WARNING | IStatus.INFO)) {
return new String[] { null, message };
} else {
return new String[] { null, null };
}
}
/**
* Applies the status to the status line of a dialog page.
*/
public static void applyToStatusLine(DialogPage page, IStatus status) {
String[] messages= getErrorMessages(status);
page.setErrorMessage(messages[0]);
page.setMessage(messages[1]);
}
/**
* Applies the status to a message line
*/
public static void applyToStatusLine(MessageLine messageLine, IStatus status) {
String[] messages= getErrorMessages(status);
messageLine.setErrorMessage(messages[0]);
messageLine.setMessage(messages[1]);
}
}
|
7,337 |
Bug 7337 NPE when pasting a member (that got deleted)
|
1) create a class with members a and b 2) copy a in the packages view (while show members is enabled) 3) delete a in the packages view 4) paste in the packages view ->NPE 4 org.eclipse.ui 0 java.lang.NullPointerException java.lang.NullPointerException at org.eclipse.jdt.internal.corext.codemanipulation.MemberEdit.connect(M emberEdit.java:96) at org.eclipse.jdt.internal.corext.codemanipulation.TextBufferEditor.add TextEdit(TextBufferEditor.java:86) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.paste(P asteSourceReferencesAction.java:155) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.perform (PasteSourceReferencesAction.java:139) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction$1.run(P asteSourceReferencesAction.java:126) at org.eclipse.swt.custom.BusyIndicator.showWhile(BusyIndicator.java:56) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.run(Pas teSourceReferencesAction.java:123) at org.eclipse.jface.action.Action.runWithEvent(Action.java:452) at org.eclipse.jface.action.ActionContributionItem.handleWidgetSelection (ActionContributionItem.java:407) at org.eclipse.jface.action.ActionContributionItem.handleWidgetEvent(Act ionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Display.runDeferredEvents(Display.java(Compil ed Code)) at org.eclipse.swt.widgets.Display.readAndDispatch(Display.java(Compiled Code)) at org.eclipse.ui.internal.Workbench.runEventLoop(Workbench.java(Compile d Code)) at org.eclipse.ui.internal.Workbench.run(Workbench.java:758) at org.eclipse.core.internal.boot.InternalBootLoader.run(InternalBootLoa der.java:820) at org.eclipse.core.boot.BootLoader.run(BootLoader.java:285) at java.lang.reflect.Method.invoke(Native Method) at org.eclipse.core.launcher.Main.basicRun(Main.java:151) at org.eclipse.core.launcher.Main.run(Main.java:502) at org.eclipse.core.launcher.UIMain.main(UIMain.java:52) java.lang.NullPointerException
|
resolved fixed
|
38b50b8
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-15T12:00:55Z | 2002-01-08T11:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/PasteSourceReferencesAction.java
|
package org.eclipse.jdt.internal.ui.reorg;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.dnd.Clipboard;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IImportContainer;
import org.eclipse.jdt.core.IImportDeclaration;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IPackageDeclaration;
import org.eclipse.jdt.core.ISourceReference;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.corext.codemanipulation.MemberEdit;
import org.eclipse.jdt.internal.corext.refactoring.Assert;
import org.eclipse.jdt.internal.corext.refactoring.reorg.SourceReferenceUtil;
import org.eclipse.jdt.internal.corext.textmanipulation.TextBuffer;
import org.eclipse.jdt.internal.corext.textmanipulation.TextBufferEditor;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.preferences.CodeFormatterPreferencePage;
import org.eclipse.jdt.internal.ui.refactoring.actions.RefactoringAction;
import org.eclipse.jdt.internal.ui.util.ExceptionHandler;
public class PasteSourceReferencesAction extends RefactoringAction {
|
7,337 |
Bug 7337 NPE when pasting a member (that got deleted)
|
1) create a class with members a and b 2) copy a in the packages view (while show members is enabled) 3) delete a in the packages view 4) paste in the packages view ->NPE 4 org.eclipse.ui 0 java.lang.NullPointerException java.lang.NullPointerException at org.eclipse.jdt.internal.corext.codemanipulation.MemberEdit.connect(M emberEdit.java:96) at org.eclipse.jdt.internal.corext.codemanipulation.TextBufferEditor.add TextEdit(TextBufferEditor.java:86) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.paste(P asteSourceReferencesAction.java:155) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.perform (PasteSourceReferencesAction.java:139) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction$1.run(P asteSourceReferencesAction.java:126) at org.eclipse.swt.custom.BusyIndicator.showWhile(BusyIndicator.java:56) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.run(Pas teSourceReferencesAction.java:123) at org.eclipse.jface.action.Action.runWithEvent(Action.java:452) at org.eclipse.jface.action.ActionContributionItem.handleWidgetSelection (ActionContributionItem.java:407) at org.eclipse.jface.action.ActionContributionItem.handleWidgetEvent(Act ionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Display.runDeferredEvents(Display.java(Compil ed Code)) at org.eclipse.swt.widgets.Display.readAndDispatch(Display.java(Compiled Code)) at org.eclipse.ui.internal.Workbench.runEventLoop(Workbench.java(Compile d Code)) at org.eclipse.ui.internal.Workbench.run(Workbench.java:758) at org.eclipse.core.internal.boot.InternalBootLoader.run(InternalBootLoa der.java:820) at org.eclipse.core.boot.BootLoader.run(BootLoader.java:285) at java.lang.reflect.Method.invoke(Native Method) at org.eclipse.core.launcher.Main.basicRun(Main.java:151) at org.eclipse.core.launcher.Main.run(Main.java:502) at org.eclipse.core.launcher.UIMain.main(UIMain.java:52) java.lang.NullPointerException
|
resolved fixed
|
38b50b8
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-15T12:00:55Z | 2002-01-08T11:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/PasteSourceReferencesAction.java
|
public PasteSourceReferencesAction(ISelectionProvider provider) {
super("&Paste", provider);
}
/*
* @see RefactoringAction#canOperateOn(IStructuredSelection)
*/
public boolean canOperateOn(IStructuredSelection selection) {
try{
if (! isAnythingInInterestingClipboard())
return false;
if (selection.size() != 1)
return false;
Object selected= selection.getFirstElement();
if (selected instanceof IClassFile)
return false;
|
7,337 |
Bug 7337 NPE when pasting a member (that got deleted)
|
1) create a class with members a and b 2) copy a in the packages view (while show members is enabled) 3) delete a in the packages view 4) paste in the packages view ->NPE 4 org.eclipse.ui 0 java.lang.NullPointerException java.lang.NullPointerException at org.eclipse.jdt.internal.corext.codemanipulation.MemberEdit.connect(M emberEdit.java:96) at org.eclipse.jdt.internal.corext.codemanipulation.TextBufferEditor.add TextEdit(TextBufferEditor.java:86) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.paste(P asteSourceReferencesAction.java:155) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.perform (PasteSourceReferencesAction.java:139) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction$1.run(P asteSourceReferencesAction.java:126) at org.eclipse.swt.custom.BusyIndicator.showWhile(BusyIndicator.java:56) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.run(Pas teSourceReferencesAction.java:123) at org.eclipse.jface.action.Action.runWithEvent(Action.java:452) at org.eclipse.jface.action.ActionContributionItem.handleWidgetSelection (ActionContributionItem.java:407) at org.eclipse.jface.action.ActionContributionItem.handleWidgetEvent(Act ionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Display.runDeferredEvents(Display.java(Compil ed Code)) at org.eclipse.swt.widgets.Display.readAndDispatch(Display.java(Compiled Code)) at org.eclipse.ui.internal.Workbench.runEventLoop(Workbench.java(Compile d Code)) at org.eclipse.ui.internal.Workbench.run(Workbench.java:758) at org.eclipse.core.internal.boot.InternalBootLoader.run(InternalBootLoa der.java:820) at org.eclipse.core.boot.BootLoader.run(BootLoader.java:285) at java.lang.reflect.Method.invoke(Native Method) at org.eclipse.core.launcher.Main.basicRun(Main.java:151) at org.eclipse.core.launcher.Main.run(Main.java:502) at org.eclipse.core.launcher.UIMain.main(UIMain.java:52) java.lang.NullPointerException
|
resolved fixed
|
38b50b8
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-15T12:00:55Z | 2002-01-08T11:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/PasteSourceReferencesAction.java
|
if (! (selected instanceof ISourceReference))
return false;
if (! (selected instanceof IJavaElement))
return false;
if (((IJavaElement)selected).isReadOnly())
return false;
if (! ((IJavaElement)selected).exists())
return false;
IFile file= SourceReferenceUtil.getFile((ISourceReference)selected);
if (file.isReadOnly())
return false;
if (! file.isAccessible())
return false;
if (selected instanceof IMember && ((IMember)selected).isBinary())
return false;
return canPaste((ISourceReference)selected, getClipboardContents());
} catch (JavaModelException e){
JavaPlugin.log(e);
return false;
}
}
private static Clipboard getClipboard(){
|
7,337 |
Bug 7337 NPE when pasting a member (that got deleted)
|
1) create a class with members a and b 2) copy a in the packages view (while show members is enabled) 3) delete a in the packages view 4) paste in the packages view ->NPE 4 org.eclipse.ui 0 java.lang.NullPointerException java.lang.NullPointerException at org.eclipse.jdt.internal.corext.codemanipulation.MemberEdit.connect(M emberEdit.java:96) at org.eclipse.jdt.internal.corext.codemanipulation.TextBufferEditor.add TextEdit(TextBufferEditor.java:86) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.paste(P asteSourceReferencesAction.java:155) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.perform (PasteSourceReferencesAction.java:139) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction$1.run(P asteSourceReferencesAction.java:126) at org.eclipse.swt.custom.BusyIndicator.showWhile(BusyIndicator.java:56) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.run(Pas teSourceReferencesAction.java:123) at org.eclipse.jface.action.Action.runWithEvent(Action.java:452) at org.eclipse.jface.action.ActionContributionItem.handleWidgetSelection (ActionContributionItem.java:407) at org.eclipse.jface.action.ActionContributionItem.handleWidgetEvent(Act ionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Display.runDeferredEvents(Display.java(Compil ed Code)) at org.eclipse.swt.widgets.Display.readAndDispatch(Display.java(Compiled Code)) at org.eclipse.ui.internal.Workbench.runEventLoop(Workbench.java(Compile d Code)) at org.eclipse.ui.internal.Workbench.run(Workbench.java:758) at org.eclipse.core.internal.boot.InternalBootLoader.run(InternalBootLoa der.java:820) at org.eclipse.core.boot.BootLoader.run(BootLoader.java:285) at java.lang.reflect.Method.invoke(Native Method) at org.eclipse.core.launcher.Main.basicRun(Main.java:151) at org.eclipse.core.launcher.Main.run(Main.java:502) at org.eclipse.core.launcher.UIMain.main(UIMain.java:52) java.lang.NullPointerException
|
resolved fixed
|
38b50b8
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-15T12:00:55Z | 2002-01-08T11:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/PasteSourceReferencesAction.java
|
return new Clipboard(JavaPlugin.getActiveWorkbenchShell().getDisplay());
}
private static boolean isAnythingInInterestingClipboard(){
TypedSource[] elems= (TypedSource[])getClipboard().getContents(TypedSourceTransfer.getInstance());
if (elems == null)
return false;
for (int i= 0; i < elems.length; i++) {
if (! isInterestingSourceReference(elems[i]))
return false;
}
return true;
}
private static boolean isInterestingSourceReference(TypedSource je){
if (je.getType() == IJavaElement.CLASS_FILE)
return false;
if (je.getType() == IJavaElement.COMPILATION_UNIT)
return false;
return true;
}
private static TypedSource[] getClipboardContents(){
Assert.isTrue(isAnythingInInterestingClipboard());
return (TypedSource[])getClipboard().getContents(TypedSourceTransfer.getInstance());
}
private static boolean canPaste(ISourceReference ref, TypedSource[] elements){
return (canPasteIn(ref, elements) || canPasteAfter(ref, elements));
}
|
7,337 |
Bug 7337 NPE when pasting a member (that got deleted)
|
1) create a class with members a and b 2) copy a in the packages view (while show members is enabled) 3) delete a in the packages view 4) paste in the packages view ->NPE 4 org.eclipse.ui 0 java.lang.NullPointerException java.lang.NullPointerException at org.eclipse.jdt.internal.corext.codemanipulation.MemberEdit.connect(M emberEdit.java:96) at org.eclipse.jdt.internal.corext.codemanipulation.TextBufferEditor.add TextEdit(TextBufferEditor.java:86) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.paste(P asteSourceReferencesAction.java:155) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.perform (PasteSourceReferencesAction.java:139) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction$1.run(P asteSourceReferencesAction.java:126) at org.eclipse.swt.custom.BusyIndicator.showWhile(BusyIndicator.java:56) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.run(Pas teSourceReferencesAction.java:123) at org.eclipse.jface.action.Action.runWithEvent(Action.java:452) at org.eclipse.jface.action.ActionContributionItem.handleWidgetSelection (ActionContributionItem.java:407) at org.eclipse.jface.action.ActionContributionItem.handleWidgetEvent(Act ionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Display.runDeferredEvents(Display.java(Compil ed Code)) at org.eclipse.swt.widgets.Display.readAndDispatch(Display.java(Compiled Code)) at org.eclipse.ui.internal.Workbench.runEventLoop(Workbench.java(Compile d Code)) at org.eclipse.ui.internal.Workbench.run(Workbench.java:758) at org.eclipse.core.internal.boot.InternalBootLoader.run(InternalBootLoa der.java:820) at org.eclipse.core.boot.BootLoader.run(BootLoader.java:285) at java.lang.reflect.Method.invoke(Native Method) at org.eclipse.core.launcher.Main.basicRun(Main.java:151) at org.eclipse.core.launcher.Main.run(Main.java:502) at org.eclipse.core.launcher.UIMain.main(UIMain.java:52) java.lang.NullPointerException
|
resolved fixed
|
38b50b8
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-15T12:00:55Z | 2002-01-08T11:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/PasteSourceReferencesAction.java
|
private ISourceReference getSelectedElement(){
return (ISourceReference)getStructuredSelection().getFirstElement();
}
/*
* @see Action#run
*/
public void run() {
new BusyIndicator().showWhile(JavaPlugin.getActiveWorkbenchShell().getDisplay(), new Runnable() {
public void run() {
try {
perform(getSelectedElement());
} catch (CoreException e) {
ExceptionHandler.handle(e, "Paste", "Unexpected exception. See log for details.");
}
}
});
}
static void perform(ISourceReference selected) throws CoreException{
if (canPasteIn(selected, getClipboardContents())){
if (selected instanceof ICompilationUnit)
pasteInCompilationUnit((ICompilationUnit)selected);
else
paste(MemberEdit.ADD_AT_BEGINNING, selected);
} else if (canPasteAfter(selected, getClipboardContents()))
paste(MemberEdit.INSERT_AFTER, selected);
else
Assert.isTrue(false);
|
7,337 |
Bug 7337 NPE when pasting a member (that got deleted)
|
1) create a class with members a and b 2) copy a in the packages view (while show members is enabled) 3) delete a in the packages view 4) paste in the packages view ->NPE 4 org.eclipse.ui 0 java.lang.NullPointerException java.lang.NullPointerException at org.eclipse.jdt.internal.corext.codemanipulation.MemberEdit.connect(M emberEdit.java:96) at org.eclipse.jdt.internal.corext.codemanipulation.TextBufferEditor.add TextEdit(TextBufferEditor.java:86) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.paste(P asteSourceReferencesAction.java:155) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.perform (PasteSourceReferencesAction.java:139) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction$1.run(P asteSourceReferencesAction.java:126) at org.eclipse.swt.custom.BusyIndicator.showWhile(BusyIndicator.java:56) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.run(Pas teSourceReferencesAction.java:123) at org.eclipse.jface.action.Action.runWithEvent(Action.java:452) at org.eclipse.jface.action.ActionContributionItem.handleWidgetSelection (ActionContributionItem.java:407) at org.eclipse.jface.action.ActionContributionItem.handleWidgetEvent(Act ionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Display.runDeferredEvents(Display.java(Compil ed Code)) at org.eclipse.swt.widgets.Display.readAndDispatch(Display.java(Compiled Code)) at org.eclipse.ui.internal.Workbench.runEventLoop(Workbench.java(Compile d Code)) at org.eclipse.ui.internal.Workbench.run(Workbench.java:758) at org.eclipse.core.internal.boot.InternalBootLoader.run(InternalBootLoa der.java:820) at org.eclipse.core.boot.BootLoader.run(BootLoader.java:285) at java.lang.reflect.Method.invoke(Native Method) at org.eclipse.core.launcher.Main.basicRun(Main.java:151) at org.eclipse.core.launcher.Main.run(Main.java:502) at org.eclipse.core.launcher.UIMain.main(UIMain.java:52) java.lang.NullPointerException
|
resolved fixed
|
38b50b8
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-15T12:00:55Z | 2002-01-08T11:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/PasteSourceReferencesAction.java
|
}
private static void paste(int style, ISourceReference selected) throws CoreException{
TextBuffer tb= TextBuffer.acquire(SourceReferenceUtil.getFile(selected));
TextBufferEditor tbe= new TextBufferEditor(tb);
TypedSource[] elems= getClipboardContents();
IJavaElement element= (IJavaElement)selected;
int tabWidth= CodeFormatterPreferencePage.getTabSize();
for (int i= 0; i < elems.length; i++) {
String[] source= new String[]{elems[i].getSource()};
tbe.add(new MemberEdit(element, style, source, tabWidth));
}
if (! tbe.canPerformEdits())
return;
tbe.performEdits(new NullProgressMonitor());
TextBuffer.commitChanges(tb, false, new NullProgressMonitor());
TextBuffer.release(tb);
}
private static void pasteInCompilationUnit(ICompilationUnit unit) throws CoreException{
TextBuffer tb= TextBuffer.acquire(SourceReferenceUtil.getFile(unit));
TextBufferEditor tbe= new TextBufferEditor(tb);
TypedSource[] elems= getClipboardContents();
for (int i= 0; i < elems.length; i++) {
tbe.add(new PasteInCompilationUnitEdit(elems[i].getSource(), elems[i].getType(), unit));
}
if (! tbe.canPerformEdits())
return;
|
7,337 |
Bug 7337 NPE when pasting a member (that got deleted)
|
1) create a class with members a and b 2) copy a in the packages view (while show members is enabled) 3) delete a in the packages view 4) paste in the packages view ->NPE 4 org.eclipse.ui 0 java.lang.NullPointerException java.lang.NullPointerException at org.eclipse.jdt.internal.corext.codemanipulation.MemberEdit.connect(M emberEdit.java:96) at org.eclipse.jdt.internal.corext.codemanipulation.TextBufferEditor.add TextEdit(TextBufferEditor.java:86) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.paste(P asteSourceReferencesAction.java:155) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.perform (PasteSourceReferencesAction.java:139) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction$1.run(P asteSourceReferencesAction.java:126) at org.eclipse.swt.custom.BusyIndicator.showWhile(BusyIndicator.java:56) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.run(Pas teSourceReferencesAction.java:123) at org.eclipse.jface.action.Action.runWithEvent(Action.java:452) at org.eclipse.jface.action.ActionContributionItem.handleWidgetSelection (ActionContributionItem.java:407) at org.eclipse.jface.action.ActionContributionItem.handleWidgetEvent(Act ionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Display.runDeferredEvents(Display.java(Compil ed Code)) at org.eclipse.swt.widgets.Display.readAndDispatch(Display.java(Compiled Code)) at org.eclipse.ui.internal.Workbench.runEventLoop(Workbench.java(Compile d Code)) at org.eclipse.ui.internal.Workbench.run(Workbench.java:758) at org.eclipse.core.internal.boot.InternalBootLoader.run(InternalBootLoa der.java:820) at org.eclipse.core.boot.BootLoader.run(BootLoader.java:285) at java.lang.reflect.Method.invoke(Native Method) at org.eclipse.core.launcher.Main.basicRun(Main.java:151) at org.eclipse.core.launcher.Main.run(Main.java:502) at org.eclipse.core.launcher.UIMain.main(UIMain.java:52) java.lang.NullPointerException
|
resolved fixed
|
38b50b8
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-15T12:00:55Z | 2002-01-08T11:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/PasteSourceReferencesAction.java
|
tbe.performEdits(new NullProgressMonitor());
TextBuffer.commitChanges(tb, false, new NullProgressMonitor());
TextBuffer.release(tb);
}
private static boolean canPasteAfter(ISourceReference ref, TypedSource[] elements){
if (ref instanceof ICompilationUnit)
return false;
if (ref instanceof IImportContainer)
return canPasteAtTopLevel(elements);
if (ref instanceof IImportDeclaration)
return canPasteAtTopLevel(elements);
if (ref instanceof IPackageDeclaration)
return canPasteAtTopLevel(elements);
if (ref instanceof IType)
return canPasteAfterType(elements);
if (ref instanceof IMember)
return canPasteAfterMember(elements);
return false;
}
private static boolean canPasteAfterType(TypedSource[] elems){
return areAllValuesOfType(elems, IJavaElement.TYPE);
}
private static boolean canPasteAtTopLevel(TypedSource[] elements){
for (int i= 0; i < elements.length; i++) {
if (! canPasteAfterImportContainerOrDeclaration(elements[i].getType()))
|
7,337 |
Bug 7337 NPE when pasting a member (that got deleted)
|
1) create a class with members a and b 2) copy a in the packages view (while show members is enabled) 3) delete a in the packages view 4) paste in the packages view ->NPE 4 org.eclipse.ui 0 java.lang.NullPointerException java.lang.NullPointerException at org.eclipse.jdt.internal.corext.codemanipulation.MemberEdit.connect(M emberEdit.java:96) at org.eclipse.jdt.internal.corext.codemanipulation.TextBufferEditor.add TextEdit(TextBufferEditor.java:86) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.paste(P asteSourceReferencesAction.java:155) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.perform (PasteSourceReferencesAction.java:139) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction$1.run(P asteSourceReferencesAction.java:126) at org.eclipse.swt.custom.BusyIndicator.showWhile(BusyIndicator.java:56) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.run(Pas teSourceReferencesAction.java:123) at org.eclipse.jface.action.Action.runWithEvent(Action.java:452) at org.eclipse.jface.action.ActionContributionItem.handleWidgetSelection (ActionContributionItem.java:407) at org.eclipse.jface.action.ActionContributionItem.handleWidgetEvent(Act ionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Display.runDeferredEvents(Display.java(Compil ed Code)) at org.eclipse.swt.widgets.Display.readAndDispatch(Display.java(Compiled Code)) at org.eclipse.ui.internal.Workbench.runEventLoop(Workbench.java(Compile d Code)) at org.eclipse.ui.internal.Workbench.run(Workbench.java:758) at org.eclipse.core.internal.boot.InternalBootLoader.run(InternalBootLoa der.java:820) at org.eclipse.core.boot.BootLoader.run(BootLoader.java:285) at java.lang.reflect.Method.invoke(Native Method) at org.eclipse.core.launcher.Main.basicRun(Main.java:151) at org.eclipse.core.launcher.Main.run(Main.java:502) at org.eclipse.core.launcher.UIMain.main(UIMain.java:52) java.lang.NullPointerException
|
resolved fixed
|
38b50b8
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-15T12:00:55Z | 2002-01-08T11:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/PasteSourceReferencesAction.java
|
return false;
}
return true;
}
private static int getElementType(ISourceReference ref){
return ((IJavaElement)ref).getElementType();
}
private static boolean canPasteAfterImportContainerOrDeclaration(int type){
if (type == IJavaElement.IMPORT_CONTAINER)
return true;
if (type == IJavaElement.IMPORT_DECLARATION)
return true;
if (type == IJavaElement.TYPE)
return true;
return false;
}
private static boolean canPasteAfterMember(TypedSource[] elems){
return areAllMembers(elems);
}
private static boolean canPasteIn(ISourceReference ref, TypedSource[] elements){
if (ref instanceof IImportContainer)
return canPasteInImportContainer(elements);
if (ref instanceof IType)
return canPasteInType(elements);
if (ref instanceof ICompilationUnit)
return canPasteInCompilationUnit(elements);
|
7,337 |
Bug 7337 NPE when pasting a member (that got deleted)
|
1) create a class with members a and b 2) copy a in the packages view (while show members is enabled) 3) delete a in the packages view 4) paste in the packages view ->NPE 4 org.eclipse.ui 0 java.lang.NullPointerException java.lang.NullPointerException at org.eclipse.jdt.internal.corext.codemanipulation.MemberEdit.connect(M emberEdit.java:96) at org.eclipse.jdt.internal.corext.codemanipulation.TextBufferEditor.add TextEdit(TextBufferEditor.java:86) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.paste(P asteSourceReferencesAction.java:155) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.perform (PasteSourceReferencesAction.java:139) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction$1.run(P asteSourceReferencesAction.java:126) at org.eclipse.swt.custom.BusyIndicator.showWhile(BusyIndicator.java:56) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.run(Pas teSourceReferencesAction.java:123) at org.eclipse.jface.action.Action.runWithEvent(Action.java:452) at org.eclipse.jface.action.ActionContributionItem.handleWidgetSelection (ActionContributionItem.java:407) at org.eclipse.jface.action.ActionContributionItem.handleWidgetEvent(Act ionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Display.runDeferredEvents(Display.java(Compil ed Code)) at org.eclipse.swt.widgets.Display.readAndDispatch(Display.java(Compiled Code)) at org.eclipse.ui.internal.Workbench.runEventLoop(Workbench.java(Compile d Code)) at org.eclipse.ui.internal.Workbench.run(Workbench.java:758) at org.eclipse.core.internal.boot.InternalBootLoader.run(InternalBootLoa der.java:820) at org.eclipse.core.boot.BootLoader.run(BootLoader.java:285) at java.lang.reflect.Method.invoke(Native Method) at org.eclipse.core.launcher.Main.basicRun(Main.java:151) at org.eclipse.core.launcher.Main.run(Main.java:502) at org.eclipse.core.launcher.UIMain.main(UIMain.java:52) java.lang.NullPointerException
|
resolved fixed
|
38b50b8
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-15T12:00:55Z | 2002-01-08T11:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/PasteSourceReferencesAction.java
|
return false;
}
private static boolean canPasteInImportContainer(TypedSource[] elements){
return areAllValuesOfType(elements, IJavaElement.IMPORT_DECLARATION);
}
private static boolean canPasteInType(TypedSource[] elements){
return areAllMembers(elements);
}
private static boolean canPasteInCompilationUnit(TypedSource[] elements){
for (int i= 0; i < elements.length; i++) {
if (! canPasteInCompilationUnit(elements[i].getType()))
return false;
}
return true;
}
private static boolean canPasteInCompilationUnit(int type){
if (type == IJavaElement.IMPORT_CONTAINER)
return true;
if (type == IJavaElement.IMPORT_DECLARATION)
return true;
if (type == IJavaElement.PACKAGE_DECLARATION)
return true;
if (type == IJavaElement.TYPE)
return true;
return false;
}
|
7,337 |
Bug 7337 NPE when pasting a member (that got deleted)
|
1) create a class with members a and b 2) copy a in the packages view (while show members is enabled) 3) delete a in the packages view 4) paste in the packages view ->NPE 4 org.eclipse.ui 0 java.lang.NullPointerException java.lang.NullPointerException at org.eclipse.jdt.internal.corext.codemanipulation.MemberEdit.connect(M emberEdit.java:96) at org.eclipse.jdt.internal.corext.codemanipulation.TextBufferEditor.add TextEdit(TextBufferEditor.java:86) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.paste(P asteSourceReferencesAction.java:155) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.perform (PasteSourceReferencesAction.java:139) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction$1.run(P asteSourceReferencesAction.java:126) at org.eclipse.swt.custom.BusyIndicator.showWhile(BusyIndicator.java:56) at org.eclipse.jdt.internal.ui.reorg.PasteSourceReferencesAction.run(Pas teSourceReferencesAction.java:123) at org.eclipse.jface.action.Action.runWithEvent(Action.java:452) at org.eclipse.jface.action.ActionContributionItem.handleWidgetSelection (ActionContributionItem.java:407) at org.eclipse.jface.action.ActionContributionItem.handleWidgetEvent(Act ionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.jface.action.ActionContributionItem$ActionListener.handle Event(ActionContributionItem.java(Compiled Code)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Widget.notifyListeners(Widget.java(Compiled C ode)) at org.eclipse.swt.widgets.Display.runDeferredEvents(Display.java(Compil ed Code)) at org.eclipse.swt.widgets.Display.readAndDispatch(Display.java(Compiled Code)) at org.eclipse.ui.internal.Workbench.runEventLoop(Workbench.java(Compile d Code)) at org.eclipse.ui.internal.Workbench.run(Workbench.java:758) at org.eclipse.core.internal.boot.InternalBootLoader.run(InternalBootLoa der.java:820) at org.eclipse.core.boot.BootLoader.run(BootLoader.java:285) at java.lang.reflect.Method.invoke(Native Method) at org.eclipse.core.launcher.Main.basicRun(Main.java:151) at org.eclipse.core.launcher.Main.run(Main.java:502) at org.eclipse.core.launcher.UIMain.main(UIMain.java:52) java.lang.NullPointerException
|
resolved fixed
|
38b50b8
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-15T12:00:55Z | 2002-01-08T11:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/PasteSourceReferencesAction.java
|
private static boolean areAllValuesOfType(TypedSource[] elements, int type){
for (int i= 0; i < elements.length; i++) {
if (elements[i].getType() != type)
return false;
}
return true;
}
private static boolean areAllMembers(TypedSource[] elements){
for (int i= 0; i < elements.length; i++) {
if (! isMember(elements[i].getType()))
return false;
}
return true;
}
private static boolean isMember(int type){
if (type == IJavaElement.FIELD)
return true;
if (type == IJavaElement.INITIALIZER)
return true;
if (type == IJavaElement.METHOD)
return true;
if (type == IJavaElement.TYPE)
return true;
return false;
}
};
|
7,540 |
Bug 7540 JDT Type hierarchy "Lock view ..." doen't work always
|
If the "Lock view and show members in hierarchy" is selected before any method is selected in method pane, the class pane isn t updated, if a method is selected afterwards. Selecting a method and select "Lock view..." works as expected
|
resolved fixed
|
f58d6b6
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-15T15:27:26Z | 2002-01-14T17:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.typehierarchy;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.custom.CLabel;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.custom.ViewForm;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DragSource;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.ScrollBar;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
|
7,540 |
Bug 7540 JDT Type hierarchy "Lock view ..." doen't work always
|
If the "Lock view and show members in hierarchy" is selected before any method is selected in method pane, the class pane isn t updated, if a method is selected afterwards. Selecting a method and select "Lock view..." works as expected
|
resolved fixed
|
f58d6b6
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-15T15:27:26Z | 2002-01-14T17:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java
|
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.util.Assert;
import org.eclipse.jface.viewers.IBasicPropertyConstants;
import org.eclipse.jface.viewers.IInputSelectionProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IPartListener;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.actions.OpenWithMenu;
import org.eclipse.ui.help.ViewContextComputer;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.ui.part.PageBook;
import org.eclipse.ui.part.ViewPart;
import org.eclipse.jdt.core.IClassFile;
|
7,540 |
Bug 7540 JDT Type hierarchy "Lock view ..." doen't work always
|
If the "Lock view and show members in hierarchy" is selected before any method is selected in method pane, the class pane isn t updated, if a method is selected afterwards. Selecting a method and select "Lock view..." works as expected
|
resolved fixed
|
f58d6b6
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-15T15:27:26Z | 2002-01-14T17:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java
|
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.ui.IContextMenuConstants;
import org.eclipse.jdt.ui.ITypeHierarchyViewPart;
import org.eclipse.jdt.ui.JavaElementLabelProvider;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.actions.AddMethodStubAction;
import org.eclipse.jdt.internal.ui.actions.ContextMenuGroup;
import org.eclipse.jdt.internal.ui.compare.JavaReplaceWithEditionAction;
import org.eclipse.jdt.internal.ui.dnd.BasicSelectionTransferDragAdapter;
import org.eclipse.jdt.internal.ui.dnd.LocalSelectionTransfer;
import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
import org.eclipse.jdt.internal.ui.packageview.BuildGroup;
import org.eclipse.jdt.internal.ui.preferences.JavaBasePreferencePage;
import org.eclipse.jdt.internal.ui.refactoring.actions.RefactoringGroup;
import org.eclipse.jdt.internal.ui.reorg.ReorgGroup;
import org.eclipse.jdt.internal.ui.util.OpenTypeHierarchyUtil;
import org.eclipse.jdt.internal.ui.viewsupport.IProblemChangedListener;
import org.eclipse.jdt.internal.ui.viewsupport.JavaElementLabels;
import org.eclipse.jdt.internal.ui.viewsupport.MarkerErrorTickProvider;
import org.eclipse.jdt.internal.ui.viewsupport.StatusBarUpdater;
/**
* view showing the supertypes/subtypes of its input.
*/
public class TypeHierarchyViewPart extends ViewPart implements ITypeHierarchyViewPart {
|
7,540 |
Bug 7540 JDT Type hierarchy "Lock view ..." doen't work always
|
If the "Lock view and show members in hierarchy" is selected before any method is selected in method pane, the class pane isn t updated, if a method is selected afterwards. Selecting a method and select "Lock view..." works as expected
|
resolved fixed
|
f58d6b6
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-15T15:27:26Z | 2002-01-14T17:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java
|
public static final int VIEW_ID_TYPE= 2;
public static final int VIEW_ID_SUPER= 0;
public static final int VIEW_ID_SUB= 1;
public static final int VIEW_ORIENTATION_VERTICAL= 0;
public static final int VIEW_ORIENTATION_HORIZONTAL= 1;
public static final int VIEW_ORIENTATION_SINGLE= 2;
private static final String DIALOGSTORE_HIERARCHYVIEW= "TypeHierarchyViewPart.hierarchyview";
private static final String DIALOGSTORE_VIEWORIENTATION= "TypeHierarchyViewPart.orientation";
private static final String TAG_INPUT= "input";
private static final String TAG_VIEW= "view";
private static final String TAG_ORIENTATION= "orientation";
private static final String TAG_RATIO= "ratio";
private static final String TAG_SELECTION= "selection";
private static final String TAG_VERTICAL_SCROLL= "vertical_scroll";
|
7,540 |
Bug 7540 JDT Type hierarchy "Lock view ..." doen't work always
|
If the "Lock view and show members in hierarchy" is selected before any method is selected in method pane, the class pane isn t updated, if a method is selected afterwards. Selecting a method and select "Lock view..." works as expected
|
resolved fixed
|
f58d6b6
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-15T15:27:26Z | 2002-01-14T17:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java
|
private IType fSelectedType;
private IJavaElement fInputElement;
private ArrayList fInputHistory;
private IMemento fMemento;
private IProblemChangedListener fHierarchyProblemListener;
private TypeHierarchyLifeCycle fHierarchyLifeCycle;
private ITypeHierarchyLifeCycleListener fTypeHierarchyLifeCycleListener;
private MethodsViewer fMethodsViewer;
private int fCurrentViewerIndex;
private TypeHierarchyViewer[] fAllViewers;
private SelectionProviderMediator fSelectionProviderMediator;
private ISelectionChangedListener fSelectionChangedListener;
private boolean fIsEnableMemberFilter;
private SashForm fTypeMethodsSplitter;
private PageBook fViewerbook;
private PageBook fPagebook;
private Label fNoHierarchyShownLabel;
|
7,540 |
Bug 7540 JDT Type hierarchy "Lock view ..." doen't work always
|
If the "Lock view and show members in hierarchy" is selected before any method is selected in method pane, the class pane isn t updated, if a method is selected afterwards. Selecting a method and select "Lock view..." works as expected
|
resolved fixed
|
f58d6b6
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-01-15T15:27:26Z | 2002-01-14T17:40:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java
|
private Label fEmptyTypesViewer;
private ViewForm fTypeViewerViewForm;
private ViewForm fMethodViewerViewForm;
private CLabel fMethodViewerPaneLabel;
private JavaElementLabelProvider fPaneLabelProvider;
private IDialogSettings fDialogSettings;
private ToggleViewAction[] fViewActions;
private HistoryDropDownAction fHistoryDropDownAction;
private ToggleOrientationAction[] fToggleOrientationActions;
private int fCurrentOrientation;
private EnableMemberFilterAction fEnableMemberFilterAction;
private AddMethodStubAction fAddStubAction;
private FocusOnTypeAction fFocusOnTypeAction;
private FocusOnSelectionAction fFocusOnSelectionAction;
private IPartListener fPartListener;
public TypeHierarchyViewPart() {
fSelectedType= null;
fInputElement= null;
fHierarchyLifeCycle= new TypeHierarchyLifeCycle();
fTypeHierarchyLifeCycleListener= new ITypeHierarchyLifeCycleListener() {
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.