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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java
|
if (selectedElement instanceof IJavaElement)
adjustInputAndSetSelection((IJavaElement)selectedElement);
else
setSelection(StructuredSelection.EMPTY, true);
}
protected void setInput(Object input) {
if (input == null)
setTitleImage(fOriginalTitleImage);
else if (input instanceof Collection) {
if (((Collection)input).isEmpty())
setTitleImage(fOriginalTitleImage);
else {
Object firstElement= ((Collection)input).iterator().next();
setTitleImage(fTitleProvider.getImage(firstElement));
}
} else
setTitleImage(fTitleProvider.getImage(input));
setViewerInput(input);
}
private void setViewerInput(Object input) {
fProcessSelectionEvents= false;
fViewer.setInput(input);
fProcessSelectionEvents= true;
}
/**
* Sets or clears the title image of this part and
* store the orignal image on the first call.
*/
protected void setTitleImage(Image titleImage) {
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java
|
if (fOriginalTitleImage == null)
fOriginalTitleImage= getTitleImage();
if (titleImage == null)
titleImage= fOriginalTitleImage;
super.setTitleImage(titleImage);
}
protected final StructuredViewer getViewer() {
return fViewer;
}
protected ILabelProvider createLabelProvider() {
return new StandardJavaUILabelProvider(
StandardJavaUILabelProvider.DEFAULT_TEXTFLAGS,
StandardJavaUILabelProvider.DEFAULT_IMAGEFLAGS | JavaElementImageProvider.SMALL_ICONS,
StandardJavaUILabelProvider.getAdornmentProviders(true, null)
);
}
protected ILabelProvider createTitleProvider() {
return new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_BASICS | JavaElementLabelProvider.SHOW_SMALL_ICONS);
}
protected final ILabelProvider getLabelProvider() {
return fLabelProvider;
}
protected final ILabelProvider getTitleProvider() {
return fTitleProvider;
}
/**
* Creates the the viewer of this part.
*
* @param parent the parent for the viewer
*/
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java
|
protected StructuredViewer createViewer(Composite parent) {
return new ProblemTableViewer(parent, SWT.MULTI);
}
protected int getLabelProviderFlags() {
return JavaElementLabelProvider.SHOW_BASICS | JavaElementLabelProvider.SHOW_OVERLAY_ICONS |
JavaElementLabelProvider.SHOW_SMALL_ICONS | JavaElementLabelProvider.SHOW_VARIABLE | JavaElementLabelProvider.SHOW_PARAMETERS;
}
/**
* Adds filters the viewer of this part.
*/
protected void addFilters() {
}
/**
* Creates the the content provider of this part.
*/
protected BaseJavaElementContentProvider createContentProvider() {
return new JavaElementContentProvider(true, this);
}
protected void setInitialInput() {
ISelection selection= getSite().getPage().getSelection();
Object input= getSingleElementFromSelection(selection);
if (!(input instanceof IJavaElement)) {
input= getSite().getPage().getInput();
if (!(input instanceof IJavaElement) && input instanceof IAdaptable)
input= ((IAdaptable)input).getAdapter(IJavaElement.class);
}
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java
|
setInput(findInputForJavaElement((JavaElement)input));
}
protected void setInitialSelection() {
Object input;
ISelection selection= getSite().getPage().getSelection();
if (selection != null && !selection.isEmpty())
input= getSingleElementFromSelection(selection);
else {
input= getSite().getPage().getInput();
if (!(input instanceof IJavaElement)) {
if (input instanceof IAdaptable)
input= ((IAdaptable)input).getAdapter(IJavaElement.class);
else
return;
}
}
if (findElementToSelect((IJavaElement)input) != null)
adjustInputAndSetSelection((IJavaElement)input);
}
final protected void setHelp() {
JavaUIHelp.setHelp(fViewer, getHelpContextId());
}
/**
* Returns the context ID for the Help system
*
* @return the string used as ID for the Help context
*/
abstract protected String getHelpContextId();
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java
|
/**
* Adds additional listeners to this view.
*/
protected void hookViewerListeners() {
fViewer.addSelectionChangedListener(new ISelectionChangedListener() {
public void selectionChanged(SelectionChangedEvent event) {
if (!fProcessSelectionEvents)
return;
if (JavaBrowsingPreferencePage.openEditorOnSingleClick())
new ShowInEditorAction().run(event.getSelection(), getSite().getPage());
else
linkToEditor((IStructuredSelection)event.getSelection());
}
});
fViewer.addDoubleClickListener(new IDoubleClickListener() {
public void doubleClick(DoubleClickEvent event) {
if (fProcessSelectionEvents && !JavaBrowsingPreferencePage.openEditorOnSingleClick())
new ShowInEditorAction().run(event.getSelection(), getSite().getPage());
}
});
}
void adjustInputAndSetSelection(IJavaElement je) {
je= getSuitableJavaElement(je);
IJavaElement elementToSelect= findElementToSelect(je);
IJavaElement newInput= findInputForJavaElement(je);
if (elementToSelect == null && !isValidInput(newInput))
setInput(null);
else if (elementToSelect == null || getViewer().testFindItem(elementToSelect) == null)
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java
|
setInput(findInputForJavaElement(je));
if (elementToSelect != null)
setSelection(new StructuredSelection(elementToSelect), true);
else
setSelection(StructuredSelection.EMPTY, true);
}
/**
* Finds the closest Java element which can be used as input for
* this part and has the given Java element as child
*
* @param je the Java element for which to search the closest input
* @return the closest Java element used as input for this part
*/
protected IJavaElement findInputForJavaElement(IJavaElement je) {
if (je == null || !je.exists())
return null;
if (isValidInput(je))
return je;
return findInputForJavaElement(je.getParent());
}
final protected IJavaElement findElementToSelect(Object obj) {
if (obj instanceof IJavaElement)
return findElementToSelect((IJavaElement)obj);
return null;
}
/**
* Finds the element which has to be selected in this part.
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java
|
*
* @param je the Java element which has the focus
*/
abstract protected IJavaElement findElementToSelect(IJavaElement je);
private Object getSingleElementFromSelection(ISelection selection) {
if (!(selection instanceof StructuredSelection) || selection.isEmpty())
return null;
Iterator iter= ((StructuredSelection)selection).iterator();
Object firstElement= iter.next();
if (!(firstElement instanceof IJavaElement))
return firstElement;
Object currentInput= (IJavaElement)getViewer().getInput();
if (currentInput == null || !currentInput.equals(findInputForJavaElement((IJavaElement)firstElement)))
if (iter.hasNext())
return null;
else
return firstElement;
while (iter.hasNext()) {
Object element= iter.next();
if (!(element instanceof IJavaElement))
return null;
if (!currentInput.equals(findInputForJavaElement((IJavaElement)element)))
return null;
}
return firstElement;
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java
|
}
/**
* Gets the typeComparator.
* @return Returns a JavaElementTypeComparator
*/
protected Comparator getTypeComparator() {
return fTypeComparator;
}
/**
* Links to editor (if option enabled)
*/
private void linkToEditor(IStructuredSelection selection) {
if (selection == null || selection.isEmpty())
return;
Object obj= selection.getFirstElement();
Object element= null;
if (selection.size() == 1) {
if (obj instanceof IJavaElement) {
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();
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java
|
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 void setSelectionFromEditor(IWorkbenchPart part) {
if (part == null)
return;
IWorkbenchPartSite site= part.getSite();
if (site == null)
return;
ISelectionProvider provider= site.getSelectionProvider();
if (provider != null)
setSelectionFromEditor(part, provider.getSelection());
}
private void setSelectionFromEditor(IWorkbenchPart part, ISelection selection) {
if (part instanceof IEditorPart && JavaBrowsingPreferencePage.linkViewSelectionToEditor()) {
IEditorInput ei= ((IEditorPart)part).getEditorInput();
if (selection instanceof ITextSelection) {
int offset= ((ITextSelection)selection).getOffset();
IJavaElement element= getElementForInputAt(ei, offset);
if (element != null) {
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java
|
adjustInputAndSetSelection(element);
return;
}
}
if (ei instanceof IFileEditorInput) {
IFile file= ((IFileEditorInput)ei).getFile();
IJavaElement je= (IJavaElement)file.getAdapter(IJavaElement.class);
if (je == null) {
setSelection(null, false);
return;
}
adjustInputAndSetSelection(je);
} else if (ei instanceof IClassFileEditorInput) {
IClassFile cf= ((IClassFileEditorInput)ei).getClassFile();
adjustInputAndSetSelection(cf);
}
return;
}
}
/**
* 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();
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java
|
return null;
}
private IResource getResourceFor(Object element) {
if (element instanceof IJavaElement) {
if (element instanceof IWorkingCopy) {
IWorkingCopy wc= (IWorkingCopy)element;
IJavaElement original= wc.getOriginalElement();
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;
}
private void setSelection(ISelection selection, boolean reveal) {
if (selection != null && selection.equals(fViewer.getSelection()))
return;
fProcessSelectionEvents= false;
fViewer.setSelection(selection, reveal);
fProcessSelectionEvents= true;
}
/**
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java
|
* Tries to find the given element in a workingcopy.
*/
protected static IJavaElement getWorkingCopy(IJavaElement input) {
try {
if (input instanceof ICompilationUnit)
return EditorUtility.getWorkingCopy((ICompilationUnit)input);
else
return EditorUtility.getWorkingCopy(input, true);
} catch (JavaModelException ex) {
}
return null;
}
/**
* Returns the original element from which the specified working copy
* element was created from. This is a handle only method, the
* returned element may or may not exist.
*
* @param workingCopy the element for which to get the original
* @return the original Java element or <code>null</code> if this is not a working copy element
*/
protected static IJavaElement getOriginal(IJavaElement workingCopy) {
ICompilationUnit cu= getCompilationUnit(workingCopy);
if (cu != null)
return ((IWorkingCopy)cu).getOriginal(workingCopy);
return null;
}
/**
* Returns the compilation unit for the given java element.
*
* @param element the java element whose compilation unit is searched for
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java
|
* @return the compilation unit of the given java element
*/
protected static ICompilationUnit getCompilationUnit(IJavaElement element) {
if (element == null)
return null;
if (element instanceof IMember)
return ((IMember) element).getCompilationUnit();
int type= element.getElementType();
if (IJavaElement.COMPILATION_UNIT == type)
return (ICompilationUnit) element;
if (IJavaElement.CLASS_FILE == type)
return null;
return getCompilationUnit(element.getParent());
}
/**
* Converts the given Java element to one which is suitable for this
* view. It takes into account wether the view shows working copies or not.
*
* @param element the Java element to be converted
* @return an element suitable for this view
*/
protected IJavaElement getSuitableJavaElement(Object obj) {
if (!(obj instanceof IJavaElement))
return null;
IJavaElement element= (IJavaElement)obj;
if (fTypeComparator.compare(element, IJavaElement.COMPILATION_UNIT) > 0)
return element;
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java
|
if (element.getElementType() == IJavaElement.CLASS_FILE)
return element;
if (((BaseJavaElementContentProvider)getViewer().getContentProvider()).getProvideWorkingCopy()) {
IJavaElement wc= getWorkingCopy(element);
if (wc != null)
element= wc;
return element;
}
else {
ICompilationUnit cu= getCompilationUnit(element);
if (cu != null && ((IWorkingCopy)cu).isWorkingCopy())
return ((IWorkingCopy)cu).getOriginal(element);
else
return element;
}
}
/**
* @see JavaEditor#getElementAt(int)
*/
protected IJavaElement getElementForInputAt(IEditorInput input, int offset) {
if (input instanceof IClassFileEditorInput) {
try {
return ((IClassFileEditorInput)input).getClassFile().getElementAt(offset);
} catch (JavaModelException ex) {
return null;
}
}
IWorkingCopyManager manager= JavaPlugin.getDefault().getWorkingCopyManager();
ICompilationUnit unit= manager.getWorkingCopy(input);
if (unit != null)
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/browsing/JavaBrowsingPart.java
|
synchronized (unit) {
try {
unit.reconcile();
return unit.getElementAt(offset);
} catch (JavaModelException x) {
}
}
return null;
}
protected IType getTypeForCU(ICompilationUnit cu) {
cu= (ICompilationUnit)getSuitableJavaElement(cu);
IType primaryType= JavaModelUtil.findPrimaryType(cu);
if (primaryType != null)
return primaryType;
try {
IType[] types= cu.getTypes();
if (types.length > 0)
return types[0];
else
return null;
} catch (JavaModelException ex) {
return null;
}
}
}
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
/*******************************************************************************
* Copyright (c) 2000, 2002 International Business Machines Corp. and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Common Public License v0.5
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/cpl-v05.html
*
* Contributors:
* IBM Corporation - initial implementation
******************************************************************************/
package org.eclipse.jdt.internal.ui.packageview;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
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;
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
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.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.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;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeExpansionEvent;
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
import org.eclipse.jface.viewers.TreeViewer;
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.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.IWorkbenchPartSite;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.ActionGroup;
import org.eclipse.ui.actions.AddBookmarkAction;
import org.eclipse.ui.actions.NewWizardMenu;
import org.eclipse.ui.actions.OpenWithMenu;
import org.eclipse.ui.actions.RefreshAction;
import org.eclipse.ui.dialogs.PropertyDialogAction;
import org.eclipse.ui.internal.OpenNewWindowAction;
import org.eclipse.ui.part.ISetSelectionTarget;
import org.eclipse.ui.part.ResourceTransfer;
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
import org.eclipse.ui.part.ViewPart;
import org.eclipse.ui.views.framelist.BackAction;
import org.eclipse.ui.views.framelist.ForwardAction;
import org.eclipse.ui.views.framelist.FrameList;
import org.eclipse.ui.views.framelist.GoIntoAction;
import org.eclipse.ui.views.framelist.UpAction;
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.internal.corext.util.JavaModelUtil;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.actions.CompositeActionGroup;
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;
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
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.refactoring.actions.IRefactoringAction;
import org.eclipse.jdt.internal.ui.refactoring.actions.RefactoringGroup;
import org.eclipse.jdt.internal.ui.reorg.ReorgGroup;
import org.eclipse.jdt.internal.ui.search.JavaSearchGroup;
import org.eclipse.jdt.internal.ui.util.JavaUIHelp;
import org.eclipse.jdt.internal.ui.viewsupport.JavaElementImageProvider;
import org.eclipse.jdt.internal.ui.viewsupport.JavaElementLabels;
import org.eclipse.jdt.internal.ui.viewsupport.MemberFilterActionGroup;
import org.eclipse.jdt.internal.ui.viewsupport.ProblemTreeViewer;
import org.eclipse.jdt.internal.ui.viewsupport.StandardJavaUILabelProvider;
import org.eclipse.jdt.internal.ui.viewsupport.StatusBarUpdater;
import org.eclipse.jdt.ui.IContextMenuConstants;
import org.eclipse.jdt.ui.IPackagesViewPart;
import org.eclipse.jdt.ui.JavaElementContentProvider;
import org.eclipse.jdt.ui.JavaElementSorter;
import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jdt.ui.actions.GenerateActionGroup;
import org.eclipse.jdt.ui.actions.OpenActionGroup;
import org.eclipse.jdt.ui.actions.ShowActionGroup;
/**
* 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 {
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
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";
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";
private JavaElementPatternFilter fPatternFilter= new JavaElementPatternFilter();
private LibraryFilter fLibraryFilter= new LibraryFilter();
private BinaryProjectFilter fBinaryFilter= new BinaryProjectFilter();
private WorkingSetFilter fWorkingSetFilter= new WorkingSetFilter();
private MemberFilterActionGroup fMemberFilterActionGroup;
private ProblemTreeViewer fViewer;
private StandardJavaUILabelProvider fJavaElementLabelProvider;
private PackagesFrameSource fFrameSource;
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
private FrameList fFrameList;
private ContextMenuGroup[] fStandardGroups;
private Menu fContextMenu;
private OpenResourceAction fOpenCUAction;
private Action fOpenToAction;
private OpenNewWindowAction fOpenNewWindowAction;
private Action fShowTypeHierarchyAction;
private Action fShowNavigatorAction;
private PropertyDialogAction fPropertyDialogAction;
private IRefactoringAction fDeleteAction;
private RefreshAction fRefreshAction;
private BackAction fBackAction;
private ForwardAction fForwardAction;
private GoIntoAction fZoomInAction;
private UpAction fUpAction;
private GotoTypeAction fGotoTypeAction;
private GotoPackageAction fGotoPackageAction;
private AddBookmarkAction fAddBookmarkAction;
private FilterSelectionAction fFilterAction;
private ShowLibrariesAction fShowLibrariesAction;
private ShowBinariesAction fShowBinariesAction;
private FilterWorkingSetAction fFilterWorkingSetAction;
private RemoveWorkingSetFilterAction fRemoveWorkingSetAction;
private IMemento fMemento;
private ISelectionChangedListener fSelectionListener;
private ActionGroup fStandardActionGroups;
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
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) {
}
};
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)
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
* 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);
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.
*/
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
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())
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);
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
fJavaElementLabelProvider=
new StandardJavaUILabelProvider(
StandardJavaUILabelProvider.DEFAULT_TEXTFLAGS | JavaElementLabels.P_COMPRESSED,
StandardJavaUILabelProvider.DEFAULT_IMAGEFLAGS | JavaElementImageProvider.SMALL_ICONS,
StandardJavaUILabelProvider.getAdornmentProviders(true, null)
);
fViewer.setLabelProvider(new DecoratingLabelProvider(
fJavaElementLabelProvider, PlatformUI.getWorkbench().getDecoratorManager())
);
fViewer.setSorter(new JavaElementSorter());
fViewer.addFilter(new EmptyInnerPackageFilter());
fViewer.setUseHashlookup(true);
fViewer.addFilter(fPatternFilter);
fViewer.addFilter(fLibraryFilter);
fMemberFilterActionGroup= new MemberFilterActionGroup(fViewer, "PackageView");
fViewer.addFilter(fWorkingSetFilter);
if(fMemento != null)
restoreFilters();
else
initFilterFromPreferences();
fViewer.setInput(findInputElement());
initDragAndDrop();
initFrameList();
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
initKeyListener();
updateTitle();
MenuManager menuMgr= new MenuManager("#PopupMenu");
menuMgr.setRemoveAllWhenShown(true);
menuMgr.addMenuListener(this);
fContextMenu= menuMgr.createContextMenu(fViewer.getTree());
fViewer.getTree().setMenu(fContextMenu);
IWorkbenchPartSite site= getSite();
site.registerContextMenu(menuMgr, fViewer);
site.setSelectionProvider(fViewer);
site.getPage().addPartListener(fPartListener);
makeActions();
fSelectionListener= new ISelectionChangedListener() {
public void selectionChanged(SelectionChangedEvent event) {
handleSelectionChanged(event);
}
};
fViewer.addSelectionChangedListener(fSelectionListener);
fViewer.addDoubleClickListener(new IDoubleClickListener() {
public void doubleClick(DoubleClickEvent event) {
handleDoubleClick(event);
}
});
IStatusLineManager slManager= getViewSite().getActionBars().getStatusLineManager();
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
fViewer.addSelectionChangedListener(new StatusBarUpdater(slManager));
fViewer.addTreeListener(fExpansionListener);
if (fMemento != null)
restoreState(fMemento);
fMemento= null;
JavaUIHelp.setHelp(fViewer, IJavaHelpContextIds.PACKAGES_VIEW);
fillActionBars();
}
private void fillActionBars() {
IActionBars actionBars= getViewSite().getActionBars();
IToolBarManager toolBar= actionBars.getToolBarManager();
fillToolBar(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"));
fStandardActionGroups.fillActionBars(actionBars);
actionBars.setGlobalActionHandler(IWorkbenchActionConstants.DELETE, fDeleteAction);
actionBars.setGlobalActionHandler(IWorkbenchActionConstants.REFRESH, fRefreshAction);
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
actionBars.setGlobalActionHandler(IWorkbenchActionConstants.BOOKMARK, fAddBookmarkAction);
actionBars.setGlobalActionHandler(IWorkbenchActionConstants.GO_INTO, fZoomInAction);
actionBars.setGlobalActionHandler(IWorkbenchActionConstants.BACK, fBackAction);
actionBars.setGlobalActionHandler(IWorkbenchActionConstants.FORWARD, fForwardAction);
actionBars.setGlobalActionHandler(IWorkbenchActionConstants.UP, fUpAction);
ReorgGroup.addGlobalReorgActions(actionBars, getSelectionProvider());
}
private void fillToolBar(IToolBarManager toolBar) {
toolBar.removeAll();
toolBar.add(fBackAction);
toolBar.add(fForwardAction);
toolBar.add(fUpAction);
if (JavaBasePreferencePage.showCompilationUnitChildren()) {
toolBar.add(new Separator());
fMemberFilterActionGroup.contributeToToolBar(toolBar);
}
}
private Object findInputElement() {
Object input= getSite().getPage().getInput();
if (input instanceof IWorkspace) {
return JavaCore.create(((IWorkspace)input).getRoot());
} else if (input instanceof IContainer) {
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
return JavaCore.create((IContainer)input);
}
return JavaCore.create(JavaPlugin.getWorkspace().getRoot());
}
/**
* 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= JavaElementLabels.getTextLabel(element, StandardJavaUILabelProvider.DEFAULT_TEXTFLAGS);
} else {
IPath path= ((IResource) element).getFullPath();
if (path.isRoot()) {
result= PackagesMessages.getString("PackageExplorer.title");
} else {
result= path.makeRelative().toString();
}
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
}
IWorkingSet ws= fWorkingSetFilter.getWorkingSet();
if (ws == null)
return result;
String wsstr= "Working Set: "+ws.getName();
if (result.length() == 0)
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);
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
}
/**
* 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;
}
/**
* 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) {
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
JavaPlugin.createStandardGroups(menu);
IStructuredSelection selection= (IStructuredSelection) fViewer.getSelection();
int size= selection.size();
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 (size == 1 && fViewer.isExpandable(element))
menu.appendToGroup(IContextMenuConstants.GROUP_GOTO, fZoomInAction);
addGotoMenu(menu);
fOpenCUAction.update();
if (fOpenCUAction.isEnabled())
menu.appendToGroup(IContextMenuConstants.GROUP_OPEN, fOpenCUAction);
addOpenWithMenu(menu, selection);
if (size == 1)
addOpenNewWindowAction(menu, element);
addRefactoring(menu);
ContextMenuGroup.add(menu, fStandardGroups, fViewer);
if (onlyFilesSelected(selection)) {
menu.appendToGroup(IContextMenuConstants.GROUP_REORGANIZE, fAddBookmarkAction);
}
menu.appendToGroup(IContextMenuConstants.GROUP_BUILD, fRefreshAction);
menu.add(new Separator());
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
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 addOpenNewWindowAction(IMenuManager menu, Object element) {
if (element instanceof IJavaElement) {
try {
element= ((IJavaElement)element).getCorrespondingResource();
} catch(JavaModelException e) {
}
}
if (!(element instanceof IContainer))
return;
menu.appendToGroup(
IContextMenuConstants.GROUP_OPEN,
new OpenNewWindowAction(getSite().getWorkbenchWindow(), (IContainer)element));
}
private boolean onlyFilesSelected(IStructuredSelection selection) {
if (selection.isEmpty())
return false;
for (Iterator enum= selection.iterator(); enum.hasNext();) {
Object o= enum.next();
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
if (o instanceof IFile)
continue;
if (o instanceof IAdaptable) {
Object resource= ((IAdaptable)o).getAdapter(IResource.class);
if (!(resource instanceof IFile))
return false;
} else {
return false;
}
}
return true;
}
private void makeActions() {
ISelectionProvider provider= getSelectionProvider();
fOpenCUAction= new OpenResourceAction(provider);
fPropertyDialogAction= new PropertyDialogAction(getShell(), provider);
fShowNavigatorAction= new ShowInNavigatorAction(provider);
fAddBookmarkAction= new AddBookmarkAction(getShell());
provider.addSelectionChangedListener(fAddBookmarkAction);
fStandardGroups= new ContextMenuGroup[] {
new BuildGroup(),
new ReorgGroup(),
new GenerateGroup(),
new JavaSearchGroup()
};
fStandardActionGroups= new CompositeActionGroup(new ActionGroup[] {
new OpenActionGroup(this), new ShowActionGroup(this), new GenerateActionGroup(this)});
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
fDeleteAction= ReorgGroup.createDeleteAction(provider);
fRefreshAction= new RefreshAction(getShell());
provider.addSelectionChangedListener(fRefreshAction);
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);
}
private void addRefactoring(IMenuManager menu){
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 addOpenWithMenu(IMenuManager menu, IStructuredSelection selection) {
if (selection.size() != 1)
return;
IAdaptable element= (IAdaptable)selection.getFirstElement();
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
Object resource= element.getAdapter(IResource.class);
if (!(resource instanceof IFile))
return;
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;
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
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));
}
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
/**
* 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));
}
}
}
/**
* Handles selection changed in viewer.
* Updates global actions.
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
* Links to editor (if option enabled)
*/
private void handleSelectionChanged(SelectionChangedEvent event) {
IStructuredSelection selection= (IStructuredSelection) event.getSelection();
fZoomInAction.update();
linkToEditor(selection);
}
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)
converted.add(element);
else
converted.add(e);
}
}
}
return new StructuredSelection(converted.toArray());
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
}
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) {
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)
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
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();
if (original != null)
element= original;
}
try {
element= ((IJavaElement)element).getUnderlyingResource();
} catch (JavaModelException e) {
return null;
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
}
}
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);
}
protected void saveFilterState(IMemento memento) {
boolean showLibraries= getLibraryFilter().getShowLibraries();
String show= "true";
if (!showLibraries)
show= "false";
memento.putString(TAG_SHOWLIBRARIES, show);
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
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();
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);
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
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) {
IWorkingSet ws= getWorkingSetFilter().getWorkingSet();
if (ws != null) {
memento.putString(TAG_WORKINGSET, ws.getName());
}
}
/**
* Saves the state of the filter actions
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
*/
public void saveMemberFilterState(IMemento memento) {
fMemberFilterActionGroup.saveState(memento);
}
void restoreState(IMemento memento) {
restoreExpansionState(memento);
restoreSelectionState(memento);
restoreScrollState(memento, fViewer.getTree());
}
protected void restoreScrollState(IMemento memento, Tree tree) {
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) {
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
}
}
}
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++) {
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());
}
}
/**
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
* 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) {
if (event.stateMask != 0)
return;
int key= event.keyCode;
if (key == SWT.F5) {
fRefreshAction.selectionChanged(
(IStructuredSelection) fViewer.getSelection());
if (fRefreshAction.isEnabled())
fRefreshAction.run();
} if (event.character == SWT.DEL){
fDeleteAction.update();
if (fDeleteAction.isEnabled())
fDeleteAction.run();
}
}
void initFrameList() {
fFrameSource= new PackagesFrameSource(this);
fFrameList= new FrameList(fFrameSource);
fFrameSource.connectTo(fFrameList);
}
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
/**
* 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());
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;
}
}
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
ISelection newSelection= new StructuredSelection(element);
if (!fViewer.getSelection().equals(newSelection)) {
try {
fViewer.removeSelectionChangedListener(fSelectionListener);
fViewer.setSelection(newSelection);
} finally {
fViewer.addSelectionChangedListener(fSelectionListener);
}
}
}
}
/**
* 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) {
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
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);
}
});
}
}
} 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;
}
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
/**
* Returns the Viewer.
*/
TreeViewer getViewer() {
return fViewer;
}
/**
* 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;
}
/**
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
* Returns the Binary filter for this view.
* @return the binary filter
*/
BinaryProjectFilter getBinaryFilter() {
return fBinaryFilter;
}
void restoreFilters() {
IMemento filtersMem= fMemento.getChild(TAG_FILTERS);
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
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
initBinaryFilterFromPreferences();
String workingSetName= fMemento.getString(TAG_WORKINGSET);
if (workingSetName != null) {
IWorkingSet ws= SearchUI.findWorkingSet(workingSetName);
if (ws != null) {
getWorkingSetFilter().setWorkingSet(ws);
}
}
fMemberFilterActionGroup.restoreState(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);
}
boolean isExpandable(Object element) {
if (fViewer == null)
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
return false;
return fViewer.isExpandable(element);
}
/**
* 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("");
} else {
String inputText= JavaElementLabels.getTextLabel(input, StandardJavaUILabelProvider.DEFAULT_TEXTFLAGS);
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.
* @deprecated To be removed
*/
public void setLabelDecorator(ILabelDecorator decorator) {
|
13,206 |
Bug 13206 Missing resource
|
20020409: Package View>Context Menu>OpenNewWindowAction.text
|
resolved fixed
|
5ba0c30
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:34:36Z | 2002-04-10T12:00:00Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/packageview/PackageExplorerPart.java
|
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;
if (event.getProperty() == JavaBasePreferencePage.SHOW_CU_CHILDREN) {
IActionBars actionBars= getViewSite().getActionBars();
fillToolBar(actionBars.getToolBarManager());
actionBars.updateActionBars();
boolean showCUChildren= JavaBasePreferencePage.showCompilationUnitChildren();
((JavaElementContentProvider)fViewer.getContentProvider()).setProvideMembers(showCUChildren);
refreshViewer= true;
}
if (refreshViewer)
fViewer.refresh();
}
}
|
13,303 |
Bug 13303 Create New Class: Too many comments
|
Now both type- and file- comment contain a message that thay can be configured in the pref page: /** * Created on 10.04.2002 * * To change this generated comment edit the template variable "filecomment": * Workbench>Preferences>Java>Templates. */ /** * @author maeschlimann * * To change this generated comment edit the template variable "typecomment": * Workbench>Preferences>Java>Templates. */ public class A { -> We should disable the option CodeGeneration->create file comment -> Path should be Window>Preferences>Java>Templates
|
resolved fixed
|
a2a8c97
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:36:56Z | 2002-04-10T14:46:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/CodeGenerationPreferencePage.java
|
package org.eclipse.jdt.internal.ui.preferences;
import java.util.StringTokenizer;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPreferencePage;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.JavaUIMessages;
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.jdt.internal.ui.dialogs.StatusUtil;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.DialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IDialogFieldListener;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.LayoutUtil;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.SelectionButtonDialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.Separator;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.StringDialogField;
public class CodeGenerationPreferencePage extends PreferencePage implements IWorkbenchPreferencePage {
|
13,303 |
Bug 13303 Create New Class: Too many comments
|
Now both type- and file- comment contain a message that thay can be configured in the pref page: /** * Created on 10.04.2002 * * To change this generated comment edit the template variable "filecomment": * Workbench>Preferences>Java>Templates. */ /** * @author maeschlimann * * To change this generated comment edit the template variable "typecomment": * Workbench>Preferences>Java>Templates. */ public class A { -> We should disable the option CodeGeneration->create file comment -> Path should be Window>Preferences>Java>Templates
|
resolved fixed
|
a2a8c97
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:36:56Z | 2002-04-10T14:46:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/CodeGenerationPreferencePage.java
|
private static final String PREF_USE_GETTERSETTER_PREFIX= JavaUI.ID_PLUGIN + ".gettersetter.prefix.enable";
private static final String PREF_GETTERSETTER_PREFIX= JavaUI.ID_PLUGIN + ".gettersetter.prefix.list";
private static final String PREF_USE_GETTERSETTER_SUFFIX= JavaUI.ID_PLUGIN + ".gettersetter.suffix.enable";
private static final String PREF_GETTERSETTER_SUFFIX= JavaUI.ID_PLUGIN + ".gettersetter.suffix.list";
private static final String PREF_JAVADOC_STUBS= JavaUI.ID_PLUGIN + ".javadoc";
private static final String PREF_NON_JAVADOC_COMMENTS= JavaUI.ID_PLUGIN + ".seecomments";
private static final String PREF_FILE_COMMENTS= JavaUI.ID_PLUGIN + ".filecomments";
public static String[] getGetterStetterPrefixes() {
IPreferenceStore prefs= JavaPlugin.getDefault().getPreferenceStore();
if (prefs.getBoolean(PREF_USE_GETTERSETTER_PREFIX)) {
String str= prefs.getString(PREF_GETTERSETTER_PREFIX);
|
13,303 |
Bug 13303 Create New Class: Too many comments
|
Now both type- and file- comment contain a message that thay can be configured in the pref page: /** * Created on 10.04.2002 * * To change this generated comment edit the template variable "filecomment": * Workbench>Preferences>Java>Templates. */ /** * @author maeschlimann * * To change this generated comment edit the template variable "typecomment": * Workbench>Preferences>Java>Templates. */ public class A { -> We should disable the option CodeGeneration->create file comment -> Path should be Window>Preferences>Java>Templates
|
resolved fixed
|
a2a8c97
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:36:56Z | 2002-04-10T14:46:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/CodeGenerationPreferencePage.java
|
if (str != null) {
return unpackOrderList(str);
}
}
return new String[0];
}
public static String[] getGetterStetterSuffixes() {
IPreferenceStore prefs= JavaPlugin.getDefault().getPreferenceStore();
if (prefs.getBoolean(PREF_USE_GETTERSETTER_SUFFIX)) {
String str= prefs.getString(PREF_GETTERSETTER_SUFFIX);
if (str != null) {
return unpackOrderList(str);
}
}
return new String[0];
}
public static boolean doCreateComments() {
IPreferenceStore prefs= JavaPlugin.getDefault().getPreferenceStore();
return prefs.getBoolean(PREF_JAVADOC_STUBS);
}
public static boolean doNonJavaDocSeeComments() {
IPreferenceStore prefs= JavaPlugin.getDefault().getPreferenceStore();
return prefs.getBoolean(PREF_NON_JAVADOC_COMMENTS);
}
public static boolean doFileComments() {
IPreferenceStore prefs= JavaPlugin.getDefault().getPreferenceStore();
|
13,303 |
Bug 13303 Create New Class: Too many comments
|
Now both type- and file- comment contain a message that thay can be configured in the pref page: /** * Created on 10.04.2002 * * To change this generated comment edit the template variable "filecomment": * Workbench>Preferences>Java>Templates. */ /** * @author maeschlimann * * To change this generated comment edit the template variable "typecomment": * Workbench>Preferences>Java>Templates. */ public class A { -> We should disable the option CodeGeneration->create file comment -> Path should be Window>Preferences>Java>Templates
|
resolved fixed
|
a2a8c97
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:36:56Z | 2002-04-10T14:46:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/CodeGenerationPreferencePage.java
|
return prefs.getBoolean(PREF_FILE_COMMENTS);
}
private static String[] unpackOrderList(String str) {
StringTokenizer tok= new StringTokenizer(str, ",");
int nTokens= tok.countTokens();
String[] res= new String[nTokens];
for (int i= 0; i < nTokens; i++) {
res[i]= tok.nextToken().trim();
}
return res;
}
/**
* Initializes the current options (read from preference store)
*/
public static void initDefaults(IPreferenceStore prefs) {
prefs.setDefault(PREF_USE_GETTERSETTER_PREFIX, false);
prefs.setDefault(PREF_USE_GETTERSETTER_SUFFIX, false);
prefs.setDefault(PREF_GETTERSETTER_PREFIX, "f, fg, _, m_");
prefs.setDefault(PREF_GETTERSETTER_SUFFIX, "_");
prefs.setDefault(PREF_JAVADOC_STUBS, true);
prefs.setDefault(PREF_NON_JAVADOC_COMMENTS, false);
prefs.setDefault(PREF_FILE_COMMENTS, true);
}
private SelectionButtonDialogField fUseGetterSetterPrefix;
private SelectionButtonDialogField fUseGetterSetterSuffix;
private StringDialogField fGetterSetterPrefix;
private StringDialogField fGetterSetterSuffix;
|
13,303 |
Bug 13303 Create New Class: Too many comments
|
Now both type- and file- comment contain a message that thay can be configured in the pref page: /** * Created on 10.04.2002 * * To change this generated comment edit the template variable "filecomment": * Workbench>Preferences>Java>Templates. */ /** * @author maeschlimann * * To change this generated comment edit the template variable "typecomment": * Workbench>Preferences>Java>Templates. */ public class A { -> We should disable the option CodeGeneration->create file comment -> Path should be Window>Preferences>Java>Templates
|
resolved fixed
|
a2a8c97
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:36:56Z | 2002-04-10T14:46:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/CodeGenerationPreferencePage.java
|
private SelectionButtonDialogField fCreateJavaDocComments;
private SelectionButtonDialogField fCreateNonJavadocComments;
private SelectionButtonDialogField fCreateFileComments;
private IStatus fGetterSetterPrefixStatus;
private IStatus fGetterSetterSuffixStatus;
public CodeGenerationPreferencePage() {
setPreferenceStore(JavaPlugin.getDefault().getPreferenceStore());
setDescription(JavaUIMessages.getString("CodeGenerationPreferencePage.description"));
IDialogFieldListener listener= new IDialogFieldListener() {
public void dialogFieldChanged(DialogField field) {
doDialogFieldChanged(field);
}
};
fGetterSetterPrefixStatus= new StatusInfo();
fGetterSetterSuffixStatus= new StatusInfo();
fUseGetterSetterPrefix= new SelectionButtonDialogField(SWT.CHECK);
fUseGetterSetterPrefix.setDialogFieldListener(listener);
fUseGetterSetterPrefix.setLabelText(JavaUIMessages.getString("CodeGenerationPreferencePage.gettersetter.prefix.checkbox"));
fGetterSetterPrefix= new StringDialogField();
fGetterSetterPrefix.setDialogFieldListener(listener);
fGetterSetterPrefix.setLabelText(JavaUIMessages.getString("CodeGenerationPreferencePage.gettersetter.prefix.list"));
fUseGetterSetterSuffix= new SelectionButtonDialogField(SWT.CHECK);
|
13,303 |
Bug 13303 Create New Class: Too many comments
|
Now both type- and file- comment contain a message that thay can be configured in the pref page: /** * Created on 10.04.2002 * * To change this generated comment edit the template variable "filecomment": * Workbench>Preferences>Java>Templates. */ /** * @author maeschlimann * * To change this generated comment edit the template variable "typecomment": * Workbench>Preferences>Java>Templates. */ public class A { -> We should disable the option CodeGeneration->create file comment -> Path should be Window>Preferences>Java>Templates
|
resolved fixed
|
a2a8c97
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:36:56Z | 2002-04-10T14:46:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/CodeGenerationPreferencePage.java
|
fUseGetterSetterSuffix.setDialogFieldListener(listener);
fUseGetterSetterSuffix.setLabelText(JavaUIMessages.getString("CodeGenerationPreferencePage.gettersetter.suffix.checkbox"));
fGetterSetterSuffix= new StringDialogField();
fGetterSetterSuffix.setDialogFieldListener(listener);
fGetterSetterSuffix.setLabelText(JavaUIMessages.getString("CodeGenerationPreferencePage.gettersetter.suffix.list"));
fCreateJavaDocComments= new SelectionButtonDialogField(SWT.CHECK);
fCreateJavaDocComments.setLabelText(JavaUIMessages.getString("CodeGenerationPreferencePage.javadoc_comment.label"));
fCreateNonJavadocComments= new SelectionButtonDialogField(SWT.CHECK);
fCreateNonJavadocComments.setLabelText(JavaUIMessages.getString("CodeGenerationPreferencePage.see_comment.label"));
fCreateFileComments= new SelectionButtonDialogField(SWT.CHECK);
fCreateFileComments.setLabelText(JavaUIMessages.getString("CodeGenerationPreferencePage.file_comment.label"));
}
private void initFields() {
IPreferenceStore prefs= JavaPlugin.getDefault().getPreferenceStore();
fUseGetterSetterSuffix.setSelection(prefs.getBoolean(PREF_USE_GETTERSETTER_SUFFIX));
String str= prefs.getString(PREF_GETTERSETTER_SUFFIX);
if (str == null) {
str= "";
}
fGetterSetterSuffix.setText(str);
fUseGetterSetterPrefix.setSelection(prefs.getBoolean(PREF_USE_GETTERSETTER_PREFIX));
str= prefs.getString(PREF_GETTERSETTER_PREFIX);
if (str == null) {
str= "";
}
fGetterSetterPrefix.setText(str);
|
13,303 |
Bug 13303 Create New Class: Too many comments
|
Now both type- and file- comment contain a message that thay can be configured in the pref page: /** * Created on 10.04.2002 * * To change this generated comment edit the template variable "filecomment": * Workbench>Preferences>Java>Templates. */ /** * @author maeschlimann * * To change this generated comment edit the template variable "typecomment": * Workbench>Preferences>Java>Templates. */ public class A { -> We should disable the option CodeGeneration->create file comment -> Path should be Window>Preferences>Java>Templates
|
resolved fixed
|
a2a8c97
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:36:56Z | 2002-04-10T14:46:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/CodeGenerationPreferencePage.java
|
fCreateJavaDocComments.setSelection(prefs.getBoolean(PREF_JAVADOC_STUBS));
fCreateNonJavadocComments.setSelection(prefs.getBoolean(PREF_NON_JAVADOC_COMMENTS));
fCreateFileComments.setSelection(prefs.getBoolean(PREF_FILE_COMMENTS));
}
/*
* @see PreferencePage#createControl(Composite)
*/
public void createControl(Composite parent) {
super.createControl(parent);
WorkbenchHelp.setHelp(getControl(), IJavaHelpContextIds.CODE_MANIPULATION_PREFERENCE_PAGE);
}
/*
* @see PreferencePage#createContents(Composite)
*/
protected Control createContents(Composite parent) {
GridLayout layout= new GridLayout();
layout.marginHeight= 0;
layout.marginWidth= 0;
layout.numColumns= 2;
Composite composite= new Composite(parent, SWT.NONE);
composite.setLayout(layout);
int horizontalIndent= convertWidthInCharsToPixels(4);
(new Separator()).doFillIntoGrid(composite, 2, 4);
DialogField javaDocLabel= new DialogField();
javaDocLabel.setLabelText(JavaUIMessages.getString("CodeGenerationPreferencePage.comments.label"));
javaDocLabel.doFillIntoGrid(composite, 2);
|
13,303 |
Bug 13303 Create New Class: Too many comments
|
Now both type- and file- comment contain a message that thay can be configured in the pref page: /** * Created on 10.04.2002 * * To change this generated comment edit the template variable "filecomment": * Workbench>Preferences>Java>Templates. */ /** * @author maeschlimann * * To change this generated comment edit the template variable "typecomment": * Workbench>Preferences>Java>Templates. */ public class A { -> We should disable the option CodeGeneration->create file comment -> Path should be Window>Preferences>Java>Templates
|
resolved fixed
|
a2a8c97
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:36:56Z | 2002-04-10T14:46:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/CodeGenerationPreferencePage.java
|
fCreateJavaDocComments.doFillIntoGrid(composite, 2);
fCreateNonJavadocComments.doFillIntoGrid(composite, 2);
fCreateFileComments.doFillIntoGrid(composite, 2);
(new Separator()).doFillIntoGrid(composite, 2, 4);
DialogField getterSetterLabel= new DialogField();
getterSetterLabel.setLabelText(JavaUIMessages.getString("CodeGenerationPreferencePage.gettersetter.label"));
getterSetterLabel.doFillIntoGrid(composite, 2);
fUseGetterSetterPrefix.doFillIntoGrid(composite, 2);
fGetterSetterPrefix.doFillIntoGrid(composite, 2);
LayoutUtil.setHorizontalIndent(fGetterSetterPrefix.getLabelControl(null), horizontalIndent);
LayoutUtil.setHorizontalGrabbing(fGetterSetterPrefix.getTextControl(null));
fUseGetterSetterSuffix.doFillIntoGrid(composite, 2);
fGetterSetterSuffix.doFillIntoGrid(composite, 2);
LayoutUtil.setHorizontalIndent(fGetterSetterSuffix.getLabelControl(null), horizontalIndent);
initFields();
return composite;
}
private void doDialogFieldChanged(DialogField field) {
if (field == fGetterSetterPrefix || field == fUseGetterSetterPrefix) {
fGetterSetterPrefix.setEnabled(fUseGetterSetterPrefix.isSelected());
if (fUseGetterSetterPrefix.isSelected()) {
String[] prefixes= unpackOrderList(fGetterSetterPrefix.getText());
fGetterSetterPrefixStatus= validateIdentifiers(prefixes, true);
|
13,303 |
Bug 13303 Create New Class: Too many comments
|
Now both type- and file- comment contain a message that thay can be configured in the pref page: /** * Created on 10.04.2002 * * To change this generated comment edit the template variable "filecomment": * Workbench>Preferences>Java>Templates. */ /** * @author maeschlimann * * To change this generated comment edit the template variable "typecomment": * Workbench>Preferences>Java>Templates. */ public class A { -> We should disable the option CodeGeneration->create file comment -> Path should be Window>Preferences>Java>Templates
|
resolved fixed
|
a2a8c97
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:36:56Z | 2002-04-10T14:46:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/CodeGenerationPreferencePage.java
|
} else {
fGetterSetterPrefixStatus= new StatusInfo();
}
}
if (field == fGetterSetterSuffix || field == fUseGetterSetterSuffix) {
fGetterSetterSuffix.setEnabled(fUseGetterSetterSuffix.isSelected());
if (fUseGetterSetterSuffix.isSelected()) {
String[] prefixes= unpackOrderList(fGetterSetterSuffix.getText());
fGetterSetterSuffixStatus= validateIdentifiers(prefixes, false);
} else {
fGetterSetterSuffixStatus= new StatusInfo();
}
}
updateStatus(StatusUtil.getMoreSevere(fGetterSetterPrefixStatus, fGetterSetterSuffixStatus));
}
private void updateStatus(IStatus status) {
setValid(!status.matches(IStatus.ERROR));
StatusUtil.applyToStatusLine(this, status);
}
private IStatus validateIdentifiers(String[] values, boolean prefix) {
for (int i= 0; i < values.length; i++) {
String val= values[i];
if (val.length() == 0) {
if (prefix) {
return new StatusInfo(IStatus.ERROR, JavaUIMessages.getString("CodeGenerationPreferencePage.gettersetter.error.emptyprefix"));
} else {
return new StatusInfo(IStatus.ERROR, JavaUIMessages.getString("CodeGenerationPreferencePage.gettersetter.error.emptysuffix"));
|
13,303 |
Bug 13303 Create New Class: Too many comments
|
Now both type- and file- comment contain a message that thay can be configured in the pref page: /** * Created on 10.04.2002 * * To change this generated comment edit the template variable "filecomment": * Workbench>Preferences>Java>Templates. */ /** * @author maeschlimann * * To change this generated comment edit the template variable "typecomment": * Workbench>Preferences>Java>Templates. */ public class A { -> We should disable the option CodeGeneration->create file comment -> Path should be Window>Preferences>Java>Templates
|
resolved fixed
|
a2a8c97
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:36:56Z | 2002-04-10T14:46:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/CodeGenerationPreferencePage.java
|
}
}
String name= prefix ? val + "x" : "x" + val;
IStatus status= JavaConventions.validateFieldName(name);
if (status.matches(IStatus.ERROR)) {
if (prefix) {
return new StatusInfo(IStatus.ERROR, JavaUIMessages.getFormattedString("CodeGenerationPreferencePage.gettersetter.error.invalidprefix", val));
} else {
return new StatusInfo(IStatus.ERROR, JavaUIMessages.getFormattedString("CodeGenerationPreferencePage.gettersetter.error.invalidsuffix", val));
}
}
}
return new StatusInfo();
}
/*
* @see IWorkbenchPreferencePage#init(IWorkbench)
*/
public void init(IWorkbench workbench) {
}
/*
* @see IPreferencePage#performOk()
*/
public boolean performOk() {
IPreferenceStore prefs= JavaPlugin.getDefault().getPreferenceStore();
prefs.setValue(PREF_USE_GETTERSETTER_SUFFIX, fUseGetterSetterSuffix.isSelected());
prefs.setValue(PREF_GETTERSETTER_SUFFIX, fGetterSetterSuffix.getText());
prefs.setValue(PREF_USE_GETTERSETTER_PREFIX, fUseGetterSetterPrefix.isSelected());
prefs.setValue(PREF_GETTERSETTER_PREFIX, fGetterSetterPrefix.getText());
|
13,303 |
Bug 13303 Create New Class: Too many comments
|
Now both type- and file- comment contain a message that thay can be configured in the pref page: /** * Created on 10.04.2002 * * To change this generated comment edit the template variable "filecomment": * Workbench>Preferences>Java>Templates. */ /** * @author maeschlimann * * To change this generated comment edit the template variable "typecomment": * Workbench>Preferences>Java>Templates. */ public class A { -> We should disable the option CodeGeneration->create file comment -> Path should be Window>Preferences>Java>Templates
|
resolved fixed
|
a2a8c97
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T08:36:56Z | 2002-04-10T14:46:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/CodeGenerationPreferencePage.java
|
prefs.setValue(PREF_JAVADOC_STUBS, fCreateJavaDocComments.isSelected());
prefs.setValue(PREF_NON_JAVADOC_COMMENTS, fCreateNonJavadocComments.isSelected());
prefs.setValue(PREF_FILE_COMMENTS, fCreateFileComments.isSelected());
return super.performOk();
}
/*
* @see PreferencePage#performDefaults()
*/
protected void performDefaults() {
IPreferenceStore prefs= JavaPlugin.getDefault().getPreferenceStore();
fUseGetterSetterSuffix.setSelection(prefs.getDefaultBoolean(PREF_USE_GETTERSETTER_SUFFIX));
String str= prefs.getDefaultString(PREF_GETTERSETTER_SUFFIX);
if (str == null) {
str= "";
}
fGetterSetterSuffix.setText(str);
fUseGetterSetterPrefix.setSelection(prefs.getDefaultBoolean(PREF_USE_GETTERSETTER_PREFIX));
str= prefs.getDefaultString(PREF_GETTERSETTER_PREFIX);
if (str == null) {
str= "";
}
fGetterSetterPrefix.setText(str);
fCreateJavaDocComments.setSelection(prefs.getDefaultBoolean(PREF_JAVADOC_STUBS));
fCreateNonJavadocComments.setSelection(prefs.getDefaultBoolean(PREF_NON_JAVADOC_COMMENTS));
fCreateFileComments.setSelection(prefs.getDefaultBoolean(PREF_FILE_COMMENTS));
super.performDefaults();
}
}
|
13,189 |
Bug 13189 Refactoring - deleting fields - context menu is overriden by message dialog
|
20020409-I on Linux-Motif and w2k: 1. Setup JUnit 2. Enable option 'Code Generator->Remove prefix from field names' 3. Open TestCase.java 4. In the outliner, right click on 'fName'. 5. Observe: No context menu is shown, instead, it asks me right away if I want to delete the getter/setter as well.
|
resolved fixed
|
e23a6cd
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T09:52:56Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/DeleteSourceReferencesAction.java
|
package org.eclipse.jdt.internal.ui.reorg;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
|
13,189 |
Bug 13189 Refactoring - deleting fields - context menu is overriden by message dialog
|
20020409-I on Linux-Motif and w2k: 1. Setup JUnit 2. Enable option 'Code Generator->Remove prefix from field names' 3. Open TestCase.java 4. In the outliner, right click on 'fName'. 5. Observe: No context menu is shown, instead, it asks me right away if I want to delete the getter/setter as well.
|
resolved fixed
|
e23a6cd
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T09:52:56Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/DeleteSourceReferencesAction.java
|
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IField;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.ISourceReference;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.corext.codemanipulation.GetterSetterUtil;
import org.eclipse.jdt.internal.corext.refactoring.Assert;
import org.eclipse.jdt.internal.corext.refactoring.reorg.DeleteSourceReferenceEdit;
import org.eclipse.jdt.internal.corext.refactoring.reorg.SourceReferenceUtil;
import org.eclipse.jdt.internal.corext.refactoring.util.WorkingCopyUtil;
import org.eclipse.jdt.internal.corext.textmanipulation.TextBuffer;
import org.eclipse.jdt.internal.corext.textmanipulation.TextBufferEditor;
import org.eclipse.jdt.internal.corext.textmanipulation.TextEdit;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.preferences.CodeGenerationPreferencePage;
import org.eclipse.jdt.internal.ui.util.ExceptionHandler;
public class DeleteSourceReferencesAction extends SourceReferenceAction{
public DeleteSourceReferencesAction(ISelectionProvider provider) {
|
13,189 |
Bug 13189 Refactoring - deleting fields - context menu is overriden by message dialog
|
20020409-I on Linux-Motif and w2k: 1. Setup JUnit 2. Enable option 'Code Generator->Remove prefix from field names' 3. Open TestCase.java 4. In the outliner, right click on 'fName'. 5. Observe: No context menu is shown, instead, it asks me right away if I want to delete the getter/setter as well.
|
resolved fixed
|
e23a6cd
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T09:52:56Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/DeleteSourceReferencesAction.java
|
super(ReorgMessages.getString("DeleteSourceReferencesAction.delete"), provider);
}
protected void perform() throws CoreException {
if (!confirmDelete())
return;
Map mapping= SourceReferenceUtil.groupByFile(getElementsToProcess());
List emptyCuList= Arrays.asList(getCusLeftEmpty(mapping));
for (Iterator iter= mapping.keySet().iterator(); iter.hasNext();) {
IFile file= (IFile)iter.next();
if (emptyCuList.contains(JavaCore.create(file)))
continue;
if (isReadOnly(file))
continue;
deleteAll(mapping, file);
}
ICompilationUnit[] notDeleted= deleteEmptyCus(mapping);
for (int i= 0; i < notDeleted.length; i++) {
IFile file= (IFile)notDeleted[i].getUnderlyingResource();
if (isReadOnly(file))
continue;
deleteAll(mapping, file);
}
}
private static boolean isReadOnly(IFile file){
if (! file.isReadOnly())
return false;
if (ResourcesPlugin.getWorkspace().validateEdit(new IFile[]{file}, null).isOK())
|
13,189 |
Bug 13189 Refactoring - deleting fields - context menu is overriden by message dialog
|
20020409-I on Linux-Motif and w2k: 1. Setup JUnit 2. Enable option 'Code Generator->Remove prefix from field names' 3. Open TestCase.java 4. In the outliner, right click on 'fName'. 5. Observe: No context menu is shown, instead, it asks me right away if I want to delete the getter/setter as well.
|
resolved fixed
|
e23a6cd
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T09:52:56Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/DeleteSourceReferencesAction.java
|
return false;
return true;
}
private static boolean areAllFilesReadOnly(Map mapping){
for (Iterator iter= mapping.keySet().iterator(); iter.hasNext();) {
if (! isReadOnly((IFile)iter.next()))
return false;
}
return true;
}
/*
* @see RefactoringAction#canOperateOn(IStructuredSelection)
*/
public boolean canOperateOn(IStructuredSelection selection) {
if (! super.canOperateOn(selection))
return false;
try {
Map mapping= SourceReferenceUtil.groupByFile(getElementsToProcess());
return ! areAllFilesReadOnly(mapping);
} catch(JavaModelException e) {
return false;
}
}
private static void deleteAll(Map mapping, IFile file) throws CoreException {
List l= (List)mapping.get(file);
ISourceReference[] refs= (ISourceReference[]) l.toArray(new ISourceReference[l.size()]);
|
13,189 |
Bug 13189 Refactoring - deleting fields - context menu is overriden by message dialog
|
20020409-I on Linux-Motif and w2k: 1. Setup JUnit 2. Enable option 'Code Generator->Remove prefix from field names' 3. Open TestCase.java 4. In the outliner, right click on 'fName'. 5. Observe: No context menu is shown, instead, it asks me right away if I want to delete the getter/setter as well.
|
resolved fixed
|
e23a6cd
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T09:52:56Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/DeleteSourceReferencesAction.java
|
delete(file, getNonFields(refs));
delete(getFields(refs));
}
private static void delete(IFile file, ISourceReference[] nonFields) throws CoreException{
TextBuffer tb= TextBuffer.acquire(file);
try{
TextBufferEditor tbe= new TextBufferEditor(tb);
for (int i= 0; i < nonFields.length; i++) {
Assert.isTrue(! (nonFields[i] instanceof IField));
tbe.add(createDeleteEdit(nonFields[i]));
}
if (! tbe.canPerformEdits())
return;
tbe.performEdits(new NullProgressMonitor());
TextBuffer.commitChanges(tb, false, new NullProgressMonitor());
} finally{
if (tb != null)
TextBuffer.release(tb);
}
}
private static void delete(IField[] fields) throws JavaModelException{
for (int i= 0; i < fields.length; i++) {
fields[i].delete(false, new NullProgressMonitor());
}
}
private static TextEdit createDeleteEdit(ISourceReference ref) throws JavaModelException{
ICompilationUnit cu= SourceReferenceUtil.getCompilationUnit(ref);
cu.reconcile();
|
13,189 |
Bug 13189 Refactoring - deleting fields - context menu is overriden by message dialog
|
20020409-I on Linux-Motif and w2k: 1. Setup JUnit 2. Enable option 'Code Generator->Remove prefix from field names' 3. Open TestCase.java 4. In the outliner, right click on 'fName'. 5. Observe: No context menu is shown, instead, it asks me right away if I want to delete the getter/setter as well.
|
resolved fixed
|
e23a6cd
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T09:52:56Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/DeleteSourceReferencesAction.java
|
return new DeleteSourceReferenceEdit(ref, cu);
}
/**
* returns cus that have <b>not</b> been deleted
*/
private ICompilationUnit[] deleteEmptyCus(Map mapping) throws JavaModelException {
ICompilationUnit[] cusToDelete= getCusLeftEmpty(mapping);
if (cusToDelete.length == 0)
return cusToDelete;
if (! confirmCusDelete(cusToDelete))
return cusToDelete;
List notDeletedCus= new ArrayList();
notDeletedCus.addAll(Arrays.asList(cusToDelete));
for (int i= 0; i < cusToDelete.length; i++) {
if (isReadOnly(cusToDelete[i]) && (! isOkToDeleteReadOnly(cusToDelete[i])))
continue;
cusToDelete[i].delete(false, new NullProgressMonitor());
notDeletedCus.remove(cusToDelete[i]);
}
return (ICompilationUnit[]) notDeletedCus.toArray(new ICompilationUnit[notDeletedCus.size()]);
}
private static boolean isReadOnly(ICompilationUnit cu) throws JavaModelException{
if (cu.isReadOnly())
return true;
if (cu.getUnderlyingResource() != null && cu.getUnderlyingResource().isReadOnly())
|
13,189 |
Bug 13189 Refactoring - deleting fields - context menu is overriden by message dialog
|
20020409-I on Linux-Motif and w2k: 1. Setup JUnit 2. Enable option 'Code Generator->Remove prefix from field names' 3. Open TestCase.java 4. In the outliner, right click on 'fName'. 5. Observe: No context menu is shown, instead, it asks me right away if I want to delete the getter/setter as well.
|
resolved fixed
|
e23a6cd
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T09:52:56Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/DeleteSourceReferencesAction.java
|
return true;
return false;
}
private static boolean isOkToDeleteReadOnly(ICompilationUnit cu){
String message= "Compilation unit \'" + cu.getElementName() + "\' is read-only. Do you still want to delete it?";
return MessageDialog.openQuestion(JavaPlugin.getActiveWorkbenchShell(), ReorgMessages.getString("DeleteSourceReferencesAction.delete1"), message);
}
/*
* @param Map mapping
*/
private static ICompilationUnit[] getCusLeftEmpty(Map mapping) throws JavaModelException{
List cuList= new ArrayList();
for (Iterator iter= mapping.keySet().iterator(); iter.hasNext();) {
IFile file= (IFile) iter.next();
IJavaElement el= JavaCore.create(file);
if (el == null || el.getElementType() != IJavaElement.COMPILATION_UNIT)
continue;
ICompilationUnit cu= (ICompilationUnit)el;
List sourceReferences= (List)mapping.get(file);
if (willBeLeftEmpty(cu, sourceReferences))
cuList.add(cu);
}
return (ICompilationUnit[]) cuList.toArray(new ICompilationUnit[cuList.size()]);
}
private static boolean willBeLeftEmpty(ICompilationUnit cu, List sourceReferences) throws JavaModelException{
IType[] cuTypes= WorkingCopyUtil.getWorkingCopyIfExists(cu).getTypes();
for (int i= 0; i < cuTypes.length; i++) {
if (! sourceReferences.contains(cuTypes[i]))
|
13,189 |
Bug 13189 Refactoring - deleting fields - context menu is overriden by message dialog
|
20020409-I on Linux-Motif and w2k: 1. Setup JUnit 2. Enable option 'Code Generator->Remove prefix from field names' 3. Open TestCase.java 4. In the outliner, right click on 'fName'. 5. Observe: No context menu is shown, instead, it asks me right away if I want to delete the getter/setter as well.
|
resolved fixed
|
e23a6cd
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T09:52:56Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/DeleteSourceReferencesAction.java
|
return false;
}
return true;
}
protected ISourceReference[] getElementsToProcess() {
ISourceReference[] elements= super.getElementsToProcess();
IField[] fields= getFields(elements);
if (fields.length == 0)
return elements;
IMethod[] gettersSetters= getGettersSettersForFields(fields);
if (gettersSetters.length == 0)
return elements;
Set getterSetterSet= new HashSet(Arrays.asList(gettersSetters));
getterSetterSet.removeAll(Arrays.asList(elements));
if (getterSetterSet.isEmpty())
return elements;
if (! confirmGetterSetterDelete())
return elements;
Set newElementSet= new HashSet(Arrays.asList(elements));
newElementSet.addAll(getterSetterSet);
return (ISourceReference[]) newElementSet.toArray(new ISourceReference[newElementSet.size()]);
}
private static ISourceReference[] getNonFields(ISourceReference[] elements){
List nonFields= new ArrayList();
for (int i= 0; i < elements.length; i++) {
if (! (elements[i] instanceof IField))
nonFields.add(elements[i]);
|
13,189 |
Bug 13189 Refactoring - deleting fields - context menu is overriden by message dialog
|
20020409-I on Linux-Motif and w2k: 1. Setup JUnit 2. Enable option 'Code Generator->Remove prefix from field names' 3. Open TestCase.java 4. In the outliner, right click on 'fName'. 5. Observe: No context menu is shown, instead, it asks me right away if I want to delete the getter/setter as well.
|
resolved fixed
|
e23a6cd
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T09:52:56Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/DeleteSourceReferencesAction.java
|
}
return (ISourceReference[]) nonFields.toArray(new ISourceReference[nonFields.size()]);
}
private static IField[] getFields(ISourceReference[] elements){
List fields= new ArrayList();
for (int i= 0; i < elements.length; i++) {
if (elements[i] instanceof IField)
fields.add(elements[i]);
}
return (IField[]) fields.toArray(new IField[fields.size()]);
}
private static IMethod[] getGettersSettersForFields(IField[] fields) {
try {
String[] namePrefixes= CodeGenerationPreferencePage.getGetterStetterPrefixes();
String[] nameSuffixes= CodeGenerationPreferencePage.getGetterStetterSuffixes();
List gettersSetters= new ArrayList();
for (int i= 0; i < fields.length; i++) {
IMethod getter= GetterSetterUtil.getGetter(fields[i], namePrefixes, nameSuffixes);
if (getter != null && getter.exists())
gettersSetters.add(getter);
IMethod setter= GetterSetterUtil.getSetter(fields[i], namePrefixes, nameSuffixes);
if (setter != null && setter.exists())
gettersSetters.add(setter);
}
return (IMethod[]) gettersSetters.toArray(new IMethod[gettersSetters.size()]);
} catch(JavaModelException e) {
ExceptionHandler.handle(e, JavaPlugin.getActiveWorkbenchShell(), ReorgMessages.getString("DeleteSourceReferencesAction.delete_elements"), ReorgMessages.getString("DeleteSourceReferencesAction.exception"));
|
13,189 |
Bug 13189 Refactoring - deleting fields - context menu is overriden by message dialog
|
20020409-I on Linux-Motif and w2k: 1. Setup JUnit 2. Enable option 'Code Generator->Remove prefix from field names' 3. Open TestCase.java 4. In the outliner, right click on 'fName'. 5. Observe: No context menu is shown, instead, it asks me right away if I want to delete the getter/setter as well.
|
resolved fixed
|
e23a6cd
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T09:52:56Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/reorg/DeleteSourceReferencesAction.java
|
return new IMethod[0];
}
}
protected boolean confirmDelete() {
String title= ReorgMessages.getString("deleteAction.confirm.title");
String label= ReorgMessages.getString("deleteAction.confirm.message");
Shell parent= JavaPlugin.getActiveWorkbenchShell();
return MessageDialog.openQuestion(parent, title, label);
}
protected boolean confirmCusDelete(ICompilationUnit[] cusToDelete) {
String message;
if (cusToDelete.length == 1)
message= "After the delete operation the compilation unit \'" + cusToDelete[0].getElementName() + "\' contains no types. \nOK to delete it as well?";
else
message= "After the delete operation " + cusToDelete.length + " compilation units contain no types. \nOK to delete them as well?";
return MessageDialog.openQuestion(JavaPlugin.getActiveWorkbenchShell(), ReorgMessages.getString("DeleteSourceReferencesAction.delete1"), message);
}
protected boolean confirmGetterSetterDelete() {
String title= ReorgMessages.getString("DeleteSourceReferencesAction.confirm_gs_delete");
String label= ReorgMessages.getString("DeleteSourceReferencesAction.delete_gs");
Shell parent= JavaPlugin.getActiveWorkbenchShell();
return MessageDialog.openQuestion(parent, title, label);
}
}
|
13,301 |
Bug 13301 Next Problem action goes to the previous problem
|
build: 20020409 Next Problem action [CTRL+E] doesn't go to the next problem but to the previous problem, it behaves like Previous Problem action [CTRL+SHIFT+E] (which works fine).
|
resolved fixed
|
173a297
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:40:13Z | 2002-04-10T14:46:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/actions/RetargetActionIDs.java
|
/*******************************************************************************
* Copyright (c) 2002 International Business Machines Corp. and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Common Public License v0.5
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/cpl-v05.html
*
* Contributors:
* IBM Corporation - initial API and implementation
******************************************************************************/
package org.eclipse.jdt.internal.ui.actions;
public class RetargetActionIDs {
|
13,301 |
Bug 13301 Next Problem action goes to the previous problem
|
build: 20020409 Next Problem action [CTRL+E] doesn't go to the next problem but to the previous problem, it behaves like Previous Problem action [CTRL+SHIFT+E] (which works fine).
|
resolved fixed
|
173a297
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:40:13Z | 2002-04-10T14:46:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/actions/RetargetActionIDs.java
|
public static String OPEN= "org.eclipse.jdt.ui.OpenAction";
public static String OPEN_SUPER_IMPLEMENTATION= "org.eclipse.jdt.ui.actions.OpenSuperImplementation";
public static String OPEN_TYPE_HIERARCHY= "org.eclipse.jdt.ui.actions.OpenTypeHierarchy";
public static String OPEN_EXTERNAL_JAVA_DOC= "org.eclipse.jdt.ui.actions.OpenExternalJavaDoc";
public static String SHOW_IN_PACKAGE_VIEW= "org.eclipse.jdt.ui.actions.ShowInPackagesView";
public static String SHOW_IN_NAVIGATOR_VIEW= "org.eclipse.jdt.ui.actions.ShowInNaviagtorView";
public static String SHOW_NEXT_PROBLEM= "org.eclipse.jdt.ui.actions.NextProblem";
public static String SHOW_PREVIOUS_PROBLEM= "org.eclipse.jdt.ui.actions.NextProblem";
public static String CONTENT_ASSIST= "org.eclipse.jdt.ui.actions.ContentAssist";
public static String CORRECTION_ASSIST= "org.eclipse.jdt.ui.actions.CorrectionAssist";
public static String CONTENT_ASSIST_CONTEXT_INFORMATION= "org.eclipse.jdt.ui.actions.ContentAssistContentInformation";
public static String SHOW_JAVA_DOC= "org.eclipse.jdt.ui.actions.ShowJavaDoc";
public static String COMMENT= "org.eclipse.jdt.ui.actions.Comment";
public static String UNCOMMENT= "org.eclipse.jdt.ui.actions.Uncomment";
public static String SHIFT_RIGHT= "org.eclipse.jdt.ui.actions.ShiftRight";
public static String SHIFT_LEFT= "org.eclipse.jdt.ui.actions.ShiftLeft";
|
13,301 |
Bug 13301 Next Problem action goes to the previous problem
|
build: 20020409 Next Problem action [CTRL+E] doesn't go to the next problem but to the previous problem, it behaves like Previous Problem action [CTRL+SHIFT+E] (which works fine).
|
resolved fixed
|
173a297
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:40:13Z | 2002-04-10T14:46:40Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/actions/RetargetActionIDs.java
|
public static String FORMAT= "org.eclipse.jdt.ui.actions.Format";
public static String ADD_IMPORT= "org.eclipse.jdt.ui.actions.AddImport";
public static String ORGANIZE_IMPORTS= "org.eclipse.jdt.ui.actions.OrganizeInports";
public static String SURROUND_WITH_TRY_CATCH= "org.eclipse.jdt.ui.actions.SurroundWithTryCatch";
public static String OVERRIDE_METHODS= "org.eclipse.jdt.ui.actions.OverrideMethods";
public static String GENERATE_GETTER_SETTER= "org.eclipse.jdt.ui.actions.GenerateGetterSetter";
public static String ADD_CONSTRUCTOR_FROM_SUPERCLASS= "org.eclipse.jdt.ui.actions.AddConstructorFromSuperclass";
public static String ADD_JAVA_DOC_COMMENT= "org.eclipse.jdt.ui.actions.AddJavaDocComment";
public static String FIND_STRINGS_TO_EXTERNALIZE= "org.eclipse.jdt.ui.actions.FindStringsToExternalize";
public static String EXTERNALIZE_STRINGS= "org.eclipse.jdt.ui.actions.ExternalizeStrings";
public static String SELECT_ENCLOSING_ELEMENT= "org.eclipse.jdt.ui.actions.SelectEnclosingElement";
public static String SELECT_NEXT_ELEMENT= "org.eclipse.jdt.ui.actions.SelectNextElement";
public static String SELECT_PREVIOUS_ELEMENT= "org.eclipse.jdt.ui.actions.SelectPreviousElement";
public static String RESTORE_LAST_SELECTION= "org.eclipse.jdt.ui.actions.RestoreLastSelection";
}
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.javadocexport;
import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
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.Label;
import org.eclipse.swt.widgets.Text;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.launching.JavaRuntime;
import org.eclipse.jdt.ui.JavaElementLabelProvider;
import org.eclipse.jdt.internal.core.JavaProject;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.jdt.internal.ui.dialogs.StatusUtil;
import org.eclipse.jdt.internal.ui.jarpackager.CheckboxTreeAndListGroup;
import org.eclipse.jdt.internal.ui.javadocexport.JavadocWizardPage.EnableSelectionAdapter;
import org.eclipse.jdt.internal.ui.preferences.JavadocPreferencePage;
import org.eclipse.jdt.internal.ui.util.SWTUtil;
public class JavadocTreeWizardPage extends JavadocWizardPage {
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
private JavadocProjectContentProvider fProjectContentProvider;
private JavaElementLabelProvider fProjectLabelProvider;
private CheckboxTreeAndListGroup fInputGroup;
protected IWorkspaceRoot fRoot;
protected String fWorkspace;
private final String DOCUMENT_DIRECTORY= "doc";
private File fTempFile;
protected Text fDestinationText;
protected Text fDocletText;
protected Text fDocletTypeText;
protected Button fStandardButton;
protected Button fDestinationBrowserButton;
protected Button fCustomButton;
protected Button fPrivateVisibility;
protected Button fProtectedVisibility;
protected Button fPackageVisibility;
protected Button fPublicVisibility;
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
private Label fDocletLabel;
private Label fDocletTypeLabel;
private Label fDestinationLabel;
private String fDialogSectionName;
protected String fVisibilitySelection;
protected boolean docletselected;
private JavadocOptionsManager fStore;
private List resources;
protected StatusInfo fDestinationStatus;
protected StatusInfo fDocletStatus;
protected StatusInfo fTreeStatus;
protected StatusInfo fPreferenceStatus;
protected StatusInfo fWizardStatus;
private final int PREFERENCESTATUS= 0;
private final int CUSTOMSTATUS= 1;
private final int STANDARDSTATUS= 2;
private final int TREESTATUS= 3;
/**
* Constructor for JavadocTreeWizardPage.
* @param pageName
*/
protected JavadocTreeWizardPage(String pageName, JavadocOptionsManager store) {
super(pageName);
setDescription(JavadocExportMessages.getString("JavadocTreeWizardPage.javadoctreewizardpage.description"));
fStore= store;
fDestinationStatus= new StatusInfo();
fDocletStatus= new StatusInfo();
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
fTreeStatus= new StatusInfo();
fPreferenceStatus= new StatusInfo();
fWizardStatus= store.getWizardStatus();
}
/*
* @see IDialogPage#createControl(Composite)
*/
public void createControl(Composite parent) {
initializeDialogUnits(parent);
Composite composite= new Composite(parent, SWT.NONE);
GridLayout compositeGridLayout= new GridLayout();
composite.setLayoutData(createGridData(GridData.FILL_BOTH, 0, 0));
compositeGridLayout.numColumns= 6;
composite.setLayout(compositeGridLayout);
createInputGroup(composite);
createVisibilitySet(composite);
createOptionsSet(composite);
setControl(composite);
}
protected void createInputGroup(Composite composite) {
Label treeLabel= createLabel(composite, SWT.NONE, JavadocExportMessages.getString("JavadocTreeWizardPage.checkboxtreeandlistgroup.label"), createGridData(6));
Composite c= new Composite(composite, SWT.NONE);
GridLayout layout= new GridLayout();
layout.numColumns= 1;
layout.makeColumnsEqualWidth= true;
c.setLayout(layout);
c.setLayoutData(createGridData(GridData.FILL_BOTH, 6, 0));
ITreeContentProvider treeContentProvider= new JavadocProjectContentProvider();
ITreeContentProvider listContentProvider= new JavadocMemberContentProvider();
fInputGroup=
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
new CheckboxTreeAndListGroup(
c,
fStore.getRoot(),
treeContentProvider,
new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT),
listContentProvider,
new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT),
SWT.NONE,
convertWidthInCharsToPixels(60),
convertHeightInCharsToPixels(10));
fInputGroup.addCheckStateListener(new ICheckStateListener() {
public void checkStateChanged(CheckStateChangedEvent e) {
doValidation(TREESTATUS);
}
});
try {
setTreeChecked(fStore.getPackagenames().toArray(), fStore.getJavaProject());
} catch(JavaModelException e) {
JavaPlugin.logErrorMessage(e.getMessage());
}
if (fStore.getJavaProject() != null) {
fInputGroup.expandTreeToLevel(fStore.getJavaProject(), 4);
}
fInputGroup.aboutToOpen();
}
private void createVisibilitySet(Composite composite) {
GridLayout visibilityLayout= createGridLayout(4);
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
visibilityLayout.marginHeight= 0;
visibilityLayout.marginWidth= 0;
Composite visibilityGroup= new Composite(composite, SWT.NONE);
visibilityGroup.setLayoutData(createGridData(GridData.FILL_HORIZONTAL, 6, 0));
visibilityGroup.setLayout(visibilityLayout);
Label visibilityLabel= createLabel(visibilityGroup, SWT.NONE, JavadocExportMessages.getString("JavadocTreeWizardPage.visibilitygroup.label"), createGridData(GridData.FILL_HORIZONTAL, 4, 0));
fPrivateVisibility= createButton(visibilityGroup, SWT.RADIO, JavadocExportMessages.getString("JavadocTreeWizardPage.privatebutton.label"), createGridData(GridData.FILL_HORIZONTAL, 1, 0));
fPackageVisibility= createButton(visibilityGroup, SWT.RADIO, JavadocExportMessages.getString("JavadocTreeWizardPage.packagebutton.label"), createGridData(GridData.FILL_HORIZONTAL, 1, 0));
fProtectedVisibility= createButton(visibilityGroup, SWT.RADIO, JavadocExportMessages.getString("JavadocTreeWizardPage.protectedbutton.label"), createGridData(GridData.FILL_HORIZONTAL, 1, 0));
fPublicVisibility= createButton(visibilityGroup, SWT.RADIO, JavadocExportMessages.getString("JavadocTreeWizardPage.publicbutton.label"), createGridData(GridData.FILL_HORIZONTAL, 1, 0));
fPrivateVisibility.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
if (((Button) e.widget).getSelection()) {
fVisibilitySelection = fStore.PRIVATE;
}
}
});
fPackageVisibility.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
if (((Button) e.widget).getSelection()) {
fVisibilitySelection = fStore.PACKAGE;
}
}
});
fProtectedVisibility.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
if (((Button) e.widget).getSelection()) {
fVisibilitySelection = fStore.PROTECTED;
}
}
});
fPublicVisibility.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
if (((Button) e.widget).getSelection()) {
fVisibilitySelection = fStore.PUBLIC;
}
}
});
setVisibilitySettings();
}
protected void setVisibilitySettings() {
fVisibilitySelection = fStore.getAccess();
fPrivateVisibility.setSelection(
fVisibilitySelection.equals(fStore.PRIVATE));
fProtectedVisibility.setSelection(
fVisibilitySelection.equals(fStore.PROTECTED));
fPackageVisibility.setSelection(
fVisibilitySelection.equals(fStore.PACKAGE));
fPublicVisibility.setSelection(
fVisibilitySelection.equals(fStore.PUBLIC));
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
}
private void createOptionsSet(Composite composite) {
GridLayout optionSetLayout= createGridLayout(3);
optionSetLayout.marginHeight= 0;
optionSetLayout.marginWidth= 0;
Composite optionSetGroup= new Composite(composite, SWT.NONE);
optionSetGroup.setLayoutData(createGridData(GridData.FILL_BOTH, 6, 0));
optionSetGroup.setLayout(optionSetLayout);
fStandardButton= createButton(optionSetGroup, SWT.RADIO, JavadocExportMessages.getString("JavadocTreeWizardPage.standarddocletbutton.label"), createGridData(GridData.HORIZONTAL_ALIGN_FILL, 3, 0));
GridData gd= new GridData();
gd.horizontalSpan= 1;
fDestinationLabel= createLabel(optionSetGroup, SWT.NONE, JavadocExportMessages.getString("JavadocTreeWizardPage.destinationfield.label"), createGridData(GridData.HORIZONTAL_ALIGN_BEGINNING, 1, convertWidthInCharsToPixels(3)));
fDestinationText= createText(optionSetGroup, SWT.SINGLE | SWT.BORDER, null, createGridData(GridData.FILL_HORIZONTAL, 1, 0));
fDestinationText.addModifyListener(new ModifyListener() {
public void modifyText(ModifyEvent e) {
doValidation(STANDARDSTATUS);
}
});
fDestinationBrowserButton= createButton(optionSetGroup, SWT.PUSH, JavadocExportMessages.getString("JavadocTreeWizardPage.destinationbrowse.label"), createGridData(GridData.HORIZONTAL_ALIGN_FILL, 1, 0));
SWTUtil.setButtonDimensionHint(fDestinationBrowserButton);
fCustomButton= createButton(optionSetGroup, SWT.RADIO, JavadocExportMessages.getString("JavadocTreeWizardPage.customdocletbutton.label"), createGridData(3));
fDocletTypeLabel= createLabel(optionSetGroup, SWT.NONE, JavadocExportMessages.getString("JavadocTreeWizardPage.docletnamefield.label"), createGridData(GridData.HORIZONTAL_ALIGN_FILL, 1, convertWidthInCharsToPixels(3)));
fDocletTypeText= createText(optionSetGroup, SWT.SINGLE | SWT.BORDER, null, createGridData(GridData.HORIZONTAL_ALIGN_FILL, 2, 0));
fDocletTypeText.addModifyListener(new ModifyListener() {
public void modifyText(ModifyEvent e) {
doValidation(CUSTOMSTATUS);
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
}
});
fDocletLabel= createLabel(optionSetGroup, SWT.NONE, JavadocExportMessages.getString("JavadocTreeWizardPage.docletpathfield.label"), createGridData(GridData.HORIZONTAL_ALIGN_FILL, 1, convertWidthInCharsToPixels(3)));
fDocletText= createText(optionSetGroup, SWT.SINGLE | SWT.BORDER, null, createGridData(GridData.HORIZONTAL_ALIGN_FILL, 2, 0));
fDocletText.addModifyListener(new ModifyListener() {
public void modifyText(ModifyEvent e) {
doValidation(CUSTOMSTATUS);
}
});
fCustomButton.addSelectionListener(
new EnableSelectionAdapter(new Control[] { fDocletLabel, fDocletText, fDocletTypeLabel, fDocletTypeText }, new Control[] { fDestinationLabel, fDestinationText, fDestinationBrowserButton }));
fCustomButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
doValidation(CUSTOMSTATUS);
}
});
fStandardButton.addSelectionListener(
new EnableSelectionAdapter(new Control[] { fDestinationLabel, fDestinationText, fDestinationBrowserButton }, new Control[] { fDocletLabel, fDocletText, fDocletTypeLabel, fDocletTypeText }));
fStandardButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
doValidation(STANDARDSTATUS);
}
});
fDestinationBrowserButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent event) {
String text= handleFolderBrowseButtonPressed(
fDestinationText.getText(), fDestinationText.getShell(),
JavadocExportMessages.getString("JavadocTreeWizardPage.destinationbrowsedialog.title"),
JavadocExportMessages.getString("JavadocTreeWizardPage.destinationbrowsedialog.label"));
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
fDestinationText.setText(text);
}
});
setOptionSetSettings();
}
public boolean getCustom(){
return fCustomButton.getSelection();
}
private String getDestinationText() {
Object[] els= fInputGroup.getAllCheckedTreeItems().toArray();
try {
for (int i= 0; i < els.length; i++) {
if (els[i] instanceof IJavaProject) {
IJavaProject iJavaProject= (IJavaProject) els[i];
return iJavaProject.getUnderlyingResource().getLocation().addTrailingSeparator().append(DOCUMENT_DIRECTORY).toOSString();
}
}
} catch (JavaModelException e) {
return "";
} catch (NullPointerException e) {
return "";
}
return "";
}
private void setOptionSetSettings() {
if(!fStore.fromStandard()) {
fCustomButton.setSelection(true);
fDocletText.setText(fStore.getDocletPath());
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
fDocletTypeText.setText(fStore.getDocletName());
fDestinationText.setText(fStore.getDestination());
fDestinationText.setEnabled(false);
fDestinationBrowserButton.setEnabled(false);
fDestinationLabel.setEnabled(false);
} else {
fStandardButton.setSelection(true);
fDestinationText.setText(fStore.getDestination());
fDocletText.setText(fStore.getDocletPath());
fDocletTypeText.setText(fStore.getDocletName());
fDocletText.setEnabled(false);
fDocletLabel.setEnabled(false);
fDocletTypeText.setEnabled(false);
fDocletTypeLabel.setEnabled(false);
}
}
protected void setTreeChecked(Object[] packagenames, IJavaProject project) throws JavaModelException{
if(project==null)
return;
for (int i = 0; i < packagenames.length; i++) {
if(packagenames[i] instanceof IJavaElement) {
IJavaElement element = (IJavaElement)packagenames[i];
if (element instanceof ICompilationUnit) {
fInputGroup.initialCheckListItem(element);
} else
fInputGroup.initialCheckTreeItem(element);
}
}
}
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
private String getSourcePath(IJavaProject project) {
StringBuffer buf= new StringBuffer();
try {
IPackageFragmentRoot[] roots= project.getPackageFragmentRoots();
int nAdded= 0;
for (int i= 0; i < roots.length; i++) {
IPackageFragmentRoot curr= roots[i];
if (curr.getKind() == IPackageFragmentRoot.K_SOURCE) {
if (nAdded != 0) {
buf.append(File.pathSeparatorChar);
}
buf.append(curr.getUnderlyingResource().getLocation().toOSString());
nAdded++;
}
}
} catch (JavaModelException e) {
JavaPlugin.log(e);
}
return buf.toString();
}
private String getClassPath(IJavaProject javaProject) {
StringBuffer buf= new StringBuffer();
try {
IPath outputLocation= javaProject.getProject().getLocation().append(javaProject.getOutputLocation());
String[] classPath= JavaRuntime.computeDefaultRuntimeClassPath(javaProject);
int nAdded= 0;
for (int i= 0; i < classPath.length; i++) {
String curr= classPath[i];
if (outputLocation.equals(new Path(curr))) {
continue;
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
}
if (nAdded != 0) {
buf.append(File.pathSeparatorChar);
}
buf.append(curr);
nAdded++;
}
} catch (CoreException e) {
JavaPlugin.log(e);
}
return buf.toString();
}
private List getPackagenames() {
Iterator checkedElements= fInputGroup.getAllCheckedListItems();
List list= new ArrayList();
this.resources= new ArrayList();
while (checkedElements.hasNext()) {
Object element = checkedElements.next();
if (element instanceof ICompilationUnit) {
ICompilationUnit unit = (ICompilationUnit) element;
IJavaElement el = unit.getParent();
if (el instanceof IPackageFragment) {
IPackageFragment pack= (IPackageFragment)el;
if (fInputGroup.isTreeItemGreyChecked(pack) || pack.isDefaultPackage()) {
try {
IResource re = unit.getCorrespondingResource();
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
this.resources.add(re);
IPath p = re.getLocation();
String qn = p.toOSString();
list.add(qn);
} catch (JavaModelException e) {
JavaPlugin.log(e);
}
}
}
}
}
Object[] checkedTreeElements= fInputGroup.getAllCheckedTreeItems().toArray();
for (int i= 0; i < checkedTreeElements.length; i++) {
Object element= checkedTreeElements[i];
if (element instanceof IPackageFragment) {
IPackageFragment pack= (IPackageFragment) element;
if (!fInputGroup.isTreeItemGreyChecked(pack) && !pack.isDefaultPackage()) {
try {
ICompilationUnit[] units= pack.getCompilationUnits();
for (int j = 0; j < units.length; j++) {
ICompilationUnit un= units[j];
IResource re= un.getCorrespondingResource();
resources.add(re);
}
} catch(JavaModelException e) {
JavaPlugin.log(e);
}
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
String en= pack.getElementName();
list.add(en);
}
}
}
return list;
}
protected void finish() {
if (fCustomButton.getSelection()) {
fStore.setDocletName(fDocletTypeText.getText());
fStore.setDocletPath(fDocletText.getText());
fStore.setFromStandard(false);
}
if(fStandardButton.getSelection()){
fStore.setFromStandard(true);
fStore.setDestination(fDestinationText.getText());
}
IJavaProject project= getCurrentProject();
fStore.setProject(project);
fStore.setSourcepath(getSourcePath(project));
fStore.setClasspath(getClassPath(project));
fStore.setAccess(fVisibilitySelection);
fStore.setPackagenames(getPackagenames());
}
private void doValidation(int validate) {
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
switch (validate) {
case PREFERENCESTATUS :
fPreferenceStatus = new StatusInfo();
fDocletStatus= new StatusInfo();
if (JavadocPreferencePage.getJavaDocCommand().length() == 0) {
fPreferenceStatus.setError(
JavadocExportMessages.getString("JavadocTreeWizardPage.javadoccommand.error"));
}
updateStatus(findMostSevereStatus());
break;
case CUSTOMSTATUS :
if (fCustomButton.getSelection()) {
fDestinationStatus = new StatusInfo();
fDocletStatus = new StatusInfo();
String doclet = fDocletTypeText.getText();
String docletPath = fDocletText.getText();
if (doclet.length() == 0) {
fDocletStatus.setError(JavadocExportMessages.getString("JavadocTreeWizardPage.nodocletname.error"));
} else if (
JavaConventions.validateJavaTypeName(doclet).matches(IStatus.ERROR)) {
fDocletStatus.setError(JavadocExportMessages.getString("JavadocTreeWizardPage.invaliddocletname.error"));
} else if ((docletPath.length() == 0) || !validDocletPath(docletPath)) {
fDocletStatus.setError(JavadocExportMessages.getString("JavadocTreeWizardPage.invaliddocletpath.error"));
}
updateStatus(findMostSevereStatus());
}
break;
case STANDARDSTATUS :
if (fStandardButton.getSelection()) {
fDestinationStatus = new StatusInfo();
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
fDocletStatus= new StatusInfo();
IPath path = new Path(fDestinationText.getText());
if (Path.ROOT.equals(path) || Path.EMPTY.equals(path)) {
fDestinationStatus.setError(JavadocExportMessages.getString("JavadocTreeWizardPage.nodestination.error"));
}
File file = new File(path.toOSString());
if (!path.isValidPath(path.toOSString()) || file.isFile()) {
fDestinationStatus.setError(JavadocExportMessages.getString("JavadocTreeWizardPage.invaliddestination.error"));
}
updateStatus(findMostSevereStatus());
}
break;
case TREESTATUS :
fTreeStatus = new StatusInfo();
boolean empty = fInputGroup.getAllCheckedTreeItems().isEmpty();
if (empty)
fTreeStatus.setError(JavadocExportMessages.getString("JavadocTreeWizardPage.invalidtreeselection.error"));
else {
int projCount = 0;
Object[] items = fInputGroup.getAllCheckedTreeItems().toArray();
for (int i = 0; i < items.length; i++) {
IJavaElement element = (IJavaElement) items[i];
if (element instanceof IJavaProject) {
projCount++;
if (projCount > 1)
fTreeStatus.setError(
JavadocExportMessages.getString("JavadocTreeWizardPage.multipleprojectselected.error"));
}
}
}
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
updateStatus(findMostSevereStatus());
break;
}
}
/**
* looks at the currently selected projects and returns the current project
* returns null if more than one project is checked
*/
private IJavaProject getCurrentProject() {
Object[] items= fInputGroup.getAllCheckedTreeItems().toArray();
IJavaProject project= null;
for (int i= 0; i < items.length; i++) {
if (items[i] instanceof JavaProject) {
if (project != null) {
return null;
}
project= (JavaProject)items[i];
}
}
return project;
}
private boolean validDocletPath(String docletPath) {
StringTokenizer tokens= new StringTokenizer(docletPath, ";");
while (tokens.hasMoreTokens()) {
File file= new File(tokens.nextToken());
if (!file.exists())
return false;
}
return true;
|
13,161 |
Bug 13161 Javadoc wizard: Message on Export wizard page not conforming to others
|
Build 20020409 All other export operations tell the user what the wizard does. Javadoc wizard says that it's a wizard ("Javadoc Generation Wizard"). It should tell the user what it is going to do.
|
resolved fixed
|
a23dfd9
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-04-11T11:54:34Z | 2002-04-10T09:13:20Z |
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
}
/**
* Finds the most severe error (if there is one)
*/
private IStatus findMostSevereStatus() {
return StatusUtil.getMostSevere(new IStatus[] {fPreferenceStatus, fDestinationStatus, fDocletStatus, fTreeStatus, fWizardStatus });
}
public void init() {
updateStatus(new StatusInfo());
}
public void setVisible(boolean visible) {
super.setVisible(visible);
if (visible) {
doValidation(STANDARDSTATUS);
doValidation(CUSTOMSTATUS);
doValidation(TREESTATUS);
doValidation(PREFERENCESTATUS);
}
}
public IPath getDestination() {
if (fStandardButton.getSelection()) {
return new Path(fDestinationText.getText());
}
return null;
}
public List getResources() {
return resources;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.