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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
19,857 | Bug 19857 Refactor - need two undos to completely undo method extraction [refactoring] | Build F2 If you use Refactor to extract a method, it requires two 'Undo' operations to undo the refactoring. The first Undo removes the call to the new method, and the second Undo removes the new method. Refactor->Extract Method is a single operation, so it should only require a single Undo. | resolved fixed | aa45367 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-08T16:46:58Z | 2002-06-10T23:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/actions/ExtractMethodAction.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... |
19,857 | Bug 19857 Refactor - need two undos to completely undo method extraction [refactoring] | Build F2 If you use Refactor to extract a method, it requires two 'Undo' operations to undo the refactoring. The first Undo removes the call to the new method, and the second Undo removes the new method. Refactor->Extract Method is a single operation, so it should only require a single Undo. | resolved fixed | aa45367 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-08T16:46:58Z | 2002-06-10T23:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/actions/ExtractMethodAction.java | /**
* Extracts the code selected inside a compilation unit editor into a new method.
* Necessary arguments, exceptions and returns values are computed and an
* appropriate method signature is generated.
*
* <p>
* This class may be instantiated; it is not intended to be subclassed.
* </p>
*
* @since 2.0
*/
... |
19,857 | Bug 19857 Refactor - need two undos to completely undo method extraction [refactoring] | Build F2 If you use Refactor to extract a method, it requires two 'Undo' operations to undo the refactoring. The first Undo removes the call to the new method, and the second Undo removes the new method. Refactor->Extract Method is a single operation, so it should only require a single Undo. | resolved fixed | aa45367 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-08T16:46:58Z | 2002-06-10T23:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/actions/ExtractMethodAction.java | Refactoring refactoring= createRefactoring(SelectionConverter.getInputAsCompilationUnit(fEditor), selection);
new RefactoringStarter().activate(refactoring, createWizard(refactoring), fDialogMessageTitle, false);
} catch (JavaModelException e){
ExceptionHandler.handle(e, fDialogMessageTitle, RefactoringMessages... |
19,857 | Bug 19857 Refactor - need two undos to completely undo method extraction [refactoring] | Build F2 If you use Refactor to extract a method, it requires two 'Undo' operations to undo the refactoring. The first Undo removes the call to the new method, and the second Undo removes the new method. Refactor->Extract Method is a single operation, so it should only require a single Undo. | resolved fixed | aa45367 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-08T16:46:58Z | 2002-06-10T23:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/actions/SurroundWithTryCatchAction.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... |
19,857 | Bug 19857 Refactor - need two undos to completely undo method extraction [refactoring] | Build F2 If you use Refactor to extract a method, it requires two 'Undo' operations to undo the refactoring. The first Undo removes the call to the new method, and the second Undo removes the new method. Refactor->Extract Method is a single operation, so it should only require a single Undo. | resolved fixed | aa45367 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-08T16:46:58Z | 2002-06-10T23:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/actions/SurroundWithTryCatchAction.java | import org.eclipse.jface.text.ITextSelection;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.ISourceRange;
import org.eclipse.jdt.internal.corext.refactoring.base.ChangeContext;
import org.eclipse.jdt.internal.corext.refactoring.base.JavaSourceContext... |
19,857 | Bug 19857 Refactor - need two undos to completely undo method extraction [refactoring] | Build F2 If you use Refactor to extract a method, it requires two 'Undo' operations to undo the refactoring. The first Undo removes the call to the new method, and the second Undo removes the new method. Refactor->Extract Method is a single operation, so it should only require a single Undo. | resolved fixed | aa45367 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-08T16:46:58Z | 2002-06-10T23:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/actions/SurroundWithTryCatchAction.java | private CompilationUnitEditor fEditor;
private static class Query implements ISurroundWithTryCatchQuery {
private Shell fParent;
public Query(Shell shell) {
fParent= shell;
}
public boolean catchRuntimeException() {
MessageDialog dialog = new MessageDialog(
fParent, getDialogTitle(), null,
Refa... |
19,857 | Bug 19857 Refactor - need two undos to completely undo method extraction [refactoring] | Build F2 If you use Refactor to extract a method, it requires two 'Undo' operations to undo the refactoring. The first Undo removes the call to the new method, and the second Undo removes the new method. Refactor->Extract Method is a single operation, so it should only require a single Undo. | resolved fixed | aa45367 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-08T16:46:58Z | 2002-06-10T23:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/actions/SurroundWithTryCatchAction.java | /**
* Note: This constructor is for internal use only. Clients should not call this constructor.
*/
public SurroundWithTryCatchAction(CompilationUnitEditor editor) {
super(editor.getEditorSite());
setText(RefactoringMessages.getString("SurroundWithTryCatchAction.label"));
fEditor= editor;
setEnabled(check... |
19,857 | Bug 19857 Refactor - need two undos to completely undo method extraction [refactoring] | Build F2 If you use Refactor to extract a method, it requires two 'Undo' operations to undo the refactoring. The first Undo removes the call to the new method, and the second Undo removes the new method. Refactor->Extract Method is a single operation, so it should only require a single Undo. | resolved fixed | aa45367 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-08T16:46:58Z | 2002-06-10T23:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/actions/SurroundWithTryCatchAction.java | new BusyIndicatorRunnableContext().run(false, false, op);
} catch (CoreException e) {
ExceptionHandler.handle(e, getDialogTitle(), RefactoringMessages.getString("SurroundWithTryCatchAction.exception"));
} catch (InvocationTargetException e) {
ExceptionHandler.handle(e, getDialogTitle(), RefactoringMessages.g... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | /*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.typehierarchy;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.ecli... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.ScrollBar;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | import org.eclipse.ui.IPartListener;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.actions.ActionContext;
import org.eclipse.ui.actions.ActionGroup;
import org.eclipse.ui.actions.Open... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | import org.eclipse.jdt.internal.ui.actions.AddMethodStubAction;
import org.eclipse.jdt.internal.ui.actions.CompositeActionGroup;
import org.eclipse.jdt.internal.ui.actions.NewWizardsActionGroup;
import org.eclipse.jdt.internal.ui.dnd.DelegatingDragAdapter;
import org.eclipse.jdt.internal.ui.dnd.DelegatingDropAdapter;
i... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | private static final String DIALOGSTORE_HIERARCHYVIEW= "TypeHierarchyViewPart.hierarchyview";
private static final String DIALOGSTORE_VIEWORIENTATION= "TypeHierarchyViewPart.orientation";
private static final String TAG_INPUT= "input";
private static final String TAG_VIEW= "view";
private static final String ... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | private SelectionProviderMediator fSelectionProviderMediator;
private ISelectionChangedListener fSelectionChangedListener;
private boolean fIsEnableMemberFilter;
private SashForm fTypeMethodsSplitter;
private PageBook fViewerbook;
private PageBook fPagebook;
private Label fNoHierarchyShownLabel;
private La... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | private FocusOnSelectionAction fFocusOnSelectionAction;
private IPartListener fPartListener;
private CompositeActionGroup fActionGroups;
private CCPActionGroup fCCPActionGroup;
public TypeHierarchyViewPart() {
fSelectedType= null;
fInputElement= null;
fHierarchyLifeCycle= new TypeHierarchyLifeCycle()... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | fAllViewers= null;
fViewActions= new ToggleViewAction[] {
new ToggleViewAction(this, VIEW_ID_TYPE),
new ToggleViewAction(this, VIEW_ID_SUPER),
new ToggleViewAction(this, VIEW_ID_SUB)
};
fDialogSettings= JavaPlugin.getDefault().getDialogSettings();
fHistoryDropDownAction= new HistoryDropDownA... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | 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) {}
};
fSelectionChangedLi... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | * Adds the entry if new. Inserted at the beginning of the history entries list.
*/
private void addHistoryEntry(IJavaElement entry) {
if (fInputHistory.contains(entry)) {
fInputHistory.remove(entry);
}
fInputHistory.add(0, entry);
fHistoryDropDownAction.setEnabled(true);
}
private void updateHistory... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | * Gets all history entries.
*/
public IJavaElement[] getHistoryEntries() {
if (fInputHistory.size() > 0) {
updateHistoryEntries();
}
return (IJavaElement[]) fInputHistory.toArray(new IJavaElement[fInputHistory.size()]);
}
/**
* Sets the history entries
*/
public void setHistoryEntries(IJavaElement[... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | }
if (member.getElementType() != IJavaElement.TYPE) {
if (fHierarchyLifeCycle.isReconciled() && cu != null) {
try {
member= (IMember) EditorUtility.getWorkingCopy(member);
if (member == null) {
return;
}
} catch (JavaModelException e) {
JavaPlugin.log(e);
return;
}
}
... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | if (fInputElement instanceof IType) {
return (IType) fInputElement;
}
return null;
}
/**
* Sets the input to a new type
* @deprecated
*/
public void setInput(IType type) {
setInputElement(type);
}
/**
* Returns the input element of the type hierarchy.
* Can be of type <code>IType</code> or... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | }
ICompilationUnit cu= ((IMember) element).getCompilationUnit();
if (cu != null && cu.isWorkingCopy()) {
element= cu.getOriginal(element);
if (!element.exists()) {
MessageDialog.openError(getSite().getShell(), TypeHierarchyMessages.getString("TypeHierarchyViewPart.error.title"), TypeHierarch... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | fInputElement= inputElement;
if (fInputElement == null) {
clearInput();
} else {
try {
fHierarchyLifeCycle.ensureRefreshedTypeHierarchy(fInputElement, new BusyIndicatorRunnableContext());
} catch (JavaModelException e) {
JavaPlugin.log(e);
clearInput();
return;
}
fPagebook.sh... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | private void clearInput() {
fInputElement= null;
fHierarchyLifeCycle.freeHierarchy();
updateHierarchyViewer();
updateToolbarButtons();
}
/*
* @see IWorbenchPart#setFocus
*/
public void setFocus() {
fPagebook.setFocus();
}
/*
* @see IWorkbenchPart#dispose
*/
public void dispose() {
fHierar... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | super.dispose();
}
private Control createTypeViewerControl(Composite parent) {
fViewerbook= new PageBook(parent, SWT.NULL);
KeyListener keyListener= createKeyListener();
TypeHierarchyViewer superTypesViewer= new SuperTypeHierarchyViewer(fViewerbook, fHierarchyLifeCycle, this);
initializeTyp... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | }
fEmptyTypesViewer= new Label(fViewerbook, SWT.LEFT);
for (int i= 0; i < fAllViewers.length; i++) {
fAllViewers[i].setInput(fAllViewers[i]);
}
fCurrentViewerIndex= -1;
setView(currViewerIndex);
return fViewerbook;
}
private KeyListener createKeyListener() {
return new KeyAdapter(... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | };
}
private void initializeTypesViewer(final TypeHierarchyViewer typesViewer, KeyListener keyListener, String cotextHelpId) {
typesViewer.getControl().setVisible(false);
typesViewer.getControl().addKeyListener(keyListener);
typesViewer.initContextMenu(new IMenuListener() {
public void menuAboutToShow(IM... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance() };
int ops= DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK;
for (int i= 0; i < fAllViewers.length; i++) {
addDragAdapters(fAllViewers[i], ops, transfers);
addDropAdapters(fAllViewers[i], ops | DND.DROP_DEFAULT, transfers);
}
addDr... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | if (event.stateMask == SWT.CTRL) {
if (event.character == '1') {
setView(VIEW_ID_TYPE);
} else if (event.character == '2') {
setView(VIEW_ID_SUPER);
} else if (event.character == '3') {
setView(VIEW_ID_SUB);
}
}
}
/**
* Returns the inner component in a workbench part.
* @see IWorkb... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | Control methodViewerPart= createMethodViewerControl(fMethodViewerViewForm);
fMethodViewerViewForm.setContent(methodViewerPart);
fMethodViewerPaneLabel= new CLabel(fMethodViewerViewForm, SWT.NONE);
fMethodViewerViewForm.setTopLeft(fMethodViewerPaneLabel);
ToolBar methodViewerToolBar= new ToolBar(fMethodV... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | setOrientation(orientation);
IActionBars actionBars= getViewSite().getActionBars();
IMenuManager viewMenu= actionBars.getMenuManager();
for (int i= 0; i < fToggleOrientationActions.length; i++) {
viewMenu.add(fToggleOrientationActions[i]);
}
viewMenu.add(new Separator(IWorkbenchActionConstants.MB_ADD... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | getSite().setSelectionProvider(fSelectionProviderMediator);
getSite().getPage().addPartListener(fPartListener);
IJavaElement input= determineInputElement();
if (fMemento != null) {
restoreState(fMemento, input);
} else if (input != null) {
setInputElement(input);
} else {
setViewerVisibility(false... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | */
public void setOrientation(int orientation) {
if (fCurrentOrientation != orientation) {
boolean methodViewerNeedsUpdate= false;
if (fMethodViewerViewForm != null && !fMethodViewerViewForm.isDisposed()
&& fTypeMethodsSplitter != null && !fTypeMethodsSplitter.isDisposed()) {
if (orientation == V... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | }
}
private void updateMainToolbar(int orientation) {
IActionBars actionBars= getViewSite().getActionBars();
IToolBarManager tbmanager= actionBars.getToolBarManager();
if (orientation == VIEW_ORIENTATION_HORIZONTAL) {
clearMainToolBar(tbmanager);
ToolBar typeViewerToolBar= new ToolBar(fTypeView... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | }
/**
* Creates the context menu for the hierarchy viewers
*/
private void fillTypesViewerContextMenu(TypeHierarchyViewer viewer, IMenuManager menu) {
JavaPlugin.createStandardGroups(menu);
menu.appendToGroup(IContextMenuConstants.GROUP_SHOW, new Separator(GROUP_FOCUS));
viewer.contributeToContex... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | fActionGroups.setContext(new ActionContext(getSite().getSelectionProvider().getSelection()));
fActionGroups.fillContextMenu(menu);
fActionGroups.setContext(null);
}
private void addOpenWithMenu(IMenuManager menu, IStructuredSelection selection) {
if (selection.size() != 1)
return;
... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | menu.appendToGroup(IContextMenuConstants.GROUP_OPEN, submenu);
}
/**
* Toggles between the empty viewer page and the hierarchy
*/
private void setViewerVisibility(boolean showHierarchy) {
if (showHierarchy) {
fViewerbook.showPage(getCurrentViewer().getControl());
} else {
fViewerbook.showPage(fEmptyTyp... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | }
}
private void internalSelectType(IMember elem, boolean reveal) {
TypeHierarchyViewer viewer= getCurrentViewer();
viewer.removeSelectionChangedListener(fSelectionChangedListener);
viewer.setSelection(elem != null ? new StructuredSelection(elem) : StructuredSelection.EMPTY, reveal);
viewer.addSelectionCha... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | };
BusyIndicator.showWhile(getDisplay(), runnable);
if (!isChildVisible(fViewerbook, getCurrentViewer().getControl())) {
setViewerVisibility(true);
}
} else {
fEmptyTypesViewer.setText(TypeHierarchyMessages.getFormattedString("TypeHierarchyViewPart.nodecl", fInputElement.getElementName()... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | }
}
private void methodSelectionChanged(ISelection sel) {
if (sel instanceof IStructuredSelection) {
List selected= ((IStructuredSelection)sel).toList();
int nSelected= selected.size();
if (fIsEnableMemberFilter) {
IMember[] memberFilter= null;
if (nSelected > 0) {
memberFilter= new IMem... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | if (nSelected != 0) {
List types= new ArrayList(nSelected);
for (int i= nSelected-1; i >= 0; i--) {
Object elem= selected.get(i);
if (elem instanceof IType && !types.contains(elem)) {
types.add(elem);
}
}
if (types.size() == 1) {
fSelectedType= (IType) types.get(0);
update... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | if (fSelectionProviderMediator.getViewerInFocus() != originViewer) {
return;
}
IEditorPart editorPart= EditorUtility.isOpenInEditor(elem);
if (editorPart != null && (elem instanceof IJavaElement)) {
try {
getSite().getPage().removePartListener(fPartListener);
EditorUtility.openInEditor(elem, fals... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | }
return false;
}
private void updateTitle() {
String viewerTitle= getCurrentViewer().getTitle();
String tooltip;
String title;
if (fInputElement != null) {
String[] args= new String[] { viewerTitle, JavaElementLabels.getElementLabel(fInputElement, JavaElementLabels.ALL_DEFAULT) };
title= TypeHie... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | }
}
/**
* Sets the current view (see view id)
* called from ToggleViewAction. Must be called after creation of the viewpart.
*/
public void setView(int viewerIndex) {
Assert.isNotNull(fAllViewers);
if (viewerIndex < fAllViewers.length && fCurrentViewerIndex != viewerIndex) {
fCurrentViewerIndex= ... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | action.setChecked(fCurrentViewerIndex == action.getViewerIndex());
}
}
/**
* Gets the curret active view index.
*/
public int getViewIndex() {
return fCurrentViewerIndex;
}
private TypeHierarchyViewer getCurrentViewer() {
return fAllViewers[fCurrentViewerIndex];
}
/**
* called from EnableMemberFi... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | internalSelectType(fSelectedType, true);
updateMethodViewer(fSelectedType);
}
} else {
methodSelectionChanged(fMethodsViewer.getSelection());
}
}
fEnableMemberFilterAction.setChecked(on);
}
/**
* Called from ITypeHierarchyLifeCycleListener.
* Can be called from any thread
*/
private vo... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | clearInput();
} else {
if (changedTypes == null) {
try {
fHierarchyLifeCycle.ensureRefreshedTypeHierarchy(fInputElement, new BusyIndicatorRunnableContext());
} catch (JavaModelException e) {
JavaPlugin.log(e.getStatus());
clearInput();
return;
}
fMethodsViewer.refresh();
... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | /**
* Determines the input element to be used initially .
*/
private IJavaElement determineInputElement() {
Object input= getSite().getPage().getInput();
if (input instanceof IJavaElement) {
IJavaElement elem= (IJavaElement) input;
if (elem instanceof IMember) {
return elem;
} else {
int kin... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | public void saveState(IMemento memento) {
if (fPagebook == null) {
if (fMemento != null) {
memento.putMemento(fMemento);
}
return;
}
if (fInputElement != null) {
String handleIndentifier= fInputElement.getHandleIdentifier();
if (fInputElement instanceof IType) {
ITypeHierarchy hierarc... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | memento.putString(TAG_SELECTION, selection.getHandleIdentifier());
}
fMethodsViewer.saveState(memento);
}
/**
* Restores the type hierarchy settings from a memento.
*/
private void restoreState(IMemento memento, IJavaElement defaultInput) {
IJavaElement input= defaultInput;
String elementId= mement... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | }
ScrollBar bar= getCurrentViewer().getTree().getVerticalBar();
if (bar != null) {
Integer vScroll= memento.getInteger(TAG_VERTICAL_SCROLL);
if (vScroll != null) {
bar.setSelection(vScroll.intValue());
}
}
String selectionId= memento.getString(TAG_SELECTION);
fMethodsViewer.restoreState(mem... |
24,250 | Bug 24250 Type Hierarchy doesn't show all inherited members on focus change | null | verified fixed | fa04810 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:04:56Z | 2002-10-01T11:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/TypeHierarchyViewPart.java | IType type= ((IClassFile)elem).getType();
if (currentViewer.isElementShown(type)) {
internalSelectType(type, true);
updateMethodViewer(type);
}
} else if (elem instanceof ICompilationUnit) {
IType[] allTypes= ((ICompilationUnit)elem).getAllTypes();
for (int i= 0; i < allTypes.length; i++) {... |
24,199 | Bug 24199 New Classpath Variables | Why should a full rebuild of the workspace be required when you add a classpath variable? Because it's a new variable it doesn't affect any existing projects. It would be more convenient if a rebuild were not required when adding a new classpath variable. Thanks. | resolved fixed | aedfdfd | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:39:40Z | 2002-09-27T18:06:40Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewElementWizard.java | /*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.wizards;
import java.lang.reflect.InvocationTargetException;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.c... |
24,199 | Bug 24199 New Classpath Variables | Why should a full rebuild of the workspace be required when you add a classpath variable? Because it's a new variable it doesn't affect any existing projects. It would be more convenient if a rebuild were not required when adding a new classpath variable. Thanks. | resolved fixed | aedfdfd | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:39:40Z | 2002-09-27T18:06:40Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewElementWizard.java | * @see BasicNewResourceWizard#initializeDefaultPageImageDescriptor
*/
protected void initializeDefaultPageImageDescriptor() {
}
protected void openResource(final IFile resource) {
final IWorkbenchPage activePage= JavaPlugin.getActivePage();
if (activePage != null) {
final Display display= getShell()... |
24,199 | Bug 24199 New Classpath Variables | Why should a full rebuild of the workspace be required when you add a classpath variable? Because it's a new variable it doesn't affect any existing projects. It would be more convenient if a rebuild were not required when adding a new classpath variable. Thanks. | resolved fixed | aedfdfd | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:39:40Z | 2002-09-27T18:06:40Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewElementWizard.java | }
protected void handleFinishException(Shell shell, InvocationTargetException e) {
String title= NewWizardMessages.getString("NewElementWizard.op_error.title");
String message= NewWizardMessages.getString("NewElementWizard.op_error.message");
ExceptionHandler.handle(e, shell, title, message);
}
/*
* @s... |
24,199 | Bug 24199 New Classpath Variables | Why should a full rebuild of the workspace be required when you add a classpath variable? Because it's a new variable it doesn't affect any existing projects. It would be more convenient if a rebuild were not required when adding a new classpath variable. Thanks. | resolved fixed | aedfdfd | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:39:40Z | 2002-09-27T18:06:40Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableBlock.java | /*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.wizards.buildpaths;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import org.eclipse.core.resources.Inc... |
24,199 | Bug 24199 New Classpath Variables | Why should a full rebuild of the workspace be required when you add a classpath variable? Because it's a new variable it doesn't affect any existing projects. It would be more convenient if a rebuild were not required when adding a new classpath variable. Thanks. | resolved fixed | aedfdfd | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:39:40Z | 2002-09-27T18:06:40Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableBlock.java | import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.... |
24,199 | Bug 24199 New Classpath Variables | Why should a full rebuild of the workspace be required when you add a classpath variable? Because it's a new variable it doesn't affect any existing projects. It would be more convenient if a rebuild were not required when adding a new classpath variable. Thanks. | resolved fixed | aedfdfd | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:39:40Z | 2002-09-27T18:06:40Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableBlock.java | private ListDialogField fVariablesList;
private Control fControl;
private List fSelectedElements;
/**
* Constructor for VariableBlock
*/
public VariableBlock(boolean inPreferencePage, String initSelection) {
fSelectedElements= new ArrayList(0);
String[] buttonLabels= new String[] {
NewWizardM... |
24,199 | Bug 24199 New Classpath Variables | Why should a full rebuild of the workspace be required when you add a classpath variable? Because it's a new variable it doesn't affect any existing projects. It would be more convenient if a rebuild were not required when adding a new classpath variable. Thanks. | resolved fixed | aedfdfd | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:39:40Z | 2002-09-27T18:06:40Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableBlock.java | CPVariableElementLabelProvider labelProvider= new CPVariableElementLabelProvider(!inPreferencePage);
fVariablesList= new ListDialogField(adapter, buttonLabels, labelProvider);
fVariablesList.setDialogFieldListener(adapter);
fVariablesList.setLabelText(NewWizardMessages.getString("VariableBlock.vars.label"));
... |
24,199 | Bug 24199 New Classpath Variables | Why should a full rebuild of the workspace be required when you add a classpath variable? Because it's a new variable it doesn't affect any existing projects. It would be more convenient if a rebuild were not required when adding a new classpath variable. Thanks. | resolved fixed | aedfdfd | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:39:40Z | 2002-09-27T18:06:40Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableBlock.java | String name= entries[i];
CPVariableElement elem;
IPath entryPath= JavaCore.getClasspathVariable(name);
if (entryPath != null) {
elem= new CPVariableElement(name, entryPath, reserved.contains(name));
elements.add(elem);
if (name.equals(initSelection)) {
initSelectedElement= elem;
}
} els... |
24,199 | Bug 24199 New Classpath Variables | Why should a full rebuild of the workspace be required when you add a classpath variable? Because it's a new variable it doesn't affect any existing projects. It would be more convenient if a rebuild were not required when adding a new classpath variable. Thanks. | resolved fixed | aedfdfd | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:39:40Z | 2002-09-27T18:06:40Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableBlock.java | }
public Control createContents(Composite parent) {
PixelConverter converter= new PixelConverter(parent);
Composite composite= new Composite(parent, SWT.NONE);
LayoutUtil.doDefaultLayout(composite, new DialogField[] { fVariablesList }, true, 0, 0);
LayoutUtil.setHorizontalGrabbing(fVariablesList.getListCo... |
24,199 | Bug 24199 New Classpath Variables | Why should a full rebuild of the workspace be required when you add a classpath variable? Because it's a new variable it doesn't affect any existing projects. It would be more convenient if a rebuild were not required when adding a new classpath variable. Thanks. | resolved fixed | aedfdfd | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:39:40Z | 2002-09-27T18:06:40Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableBlock.java | public void customButtonPressed(DialogField field, int index) {
switch (index) {
case 0:
editEntries(null);
break;
case 1:
List selected= fVariablesList.getSelectedElements();
editEntries((CPVariableElement)selected.get(0));
break;
} |
24,199 | Bug 24199 New Classpath Variables | Why should a full rebuild of the workspace be required when you add a classpath variable? Because it's a new variable it doesn't affect any existing projects. It would be more convenient if a rebuild were not required when adding a new classpath variable. Thanks. | resolved fixed | aedfdfd | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:39:40Z | 2002-09-27T18:06:40Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableBlock.java | }
public void selectionChanged(DialogField field) {
doSelectionChanged(field);
}
public void dialogFieldChanged(DialogField field) {
}
}
private boolean containsReserved(List selected) {
for (int i= selected.size()-1; i >= 0; i--) {
if (((CPVariableElement)selected.get(i)).isReserv... |
24,199 | Bug 24199 New Classpath Variables | Why should a full rebuild of the workspace be required when you add a classpath variable? Because it's a new variable it doesn't affect any existing projects. It would be more convenient if a rebuild were not required when adding a new classpath variable. Thanks. | resolved fixed | aedfdfd | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:39:40Z | 2002-09-27T18:06:40Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableBlock.java | boolean containsReserved= containsReserved(selected);
fVariablesList.enableButton(1, isSingleSelected && !containsReserved);
fVariablesList.enableButton(3, !containsReserved);
fSelectedElements= selected;
}
private void editEntries(CPVariableElement entry) {
List existingEntries= fVariablesList.... |
24,199 | Bug 24199 New Classpath Variables | Why should a full rebuild of the workspace be required when you add a classpath variable? Because it's a new variable it doesn't affect any existing projects. It would be more convenient if a rebuild were not required when adding a new classpath variable. Thanks. | resolved fixed | aedfdfd | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:39:40Z | 2002-09-27T18:06:40Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableBlock.java | }
public void performDefaults() {
fVariablesList.removeAllElements();
String[] reservedName= getReservedVariableNames();
for (int i= 0; i < reservedName.length; i++) {
CPVariableElement elem= new CPVariableElement(reservedName[i], Path.EMPTY, true);
elem.setReserved(true);
fVariablesList.addElement(... |
24,199 | Bug 24199 New Classpath Variables | Why should a full rebuild of the workspace be required when you add a classpath variable? Because it's a new variable it doesn't affect any existing projects. It would be more convenient if a rebuild were not required when adding a new classpath variable. Thanks. | resolved fixed | aedfdfd | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:39:40Z | 2002-09-27T18:06:40Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableBlock.java | int steps= elements.size() + toRemove.size();
if (steps > 0) {
String title= NewWizardMessages.getString("VariableBlock.needsbuild.title");
String message= NewWizardMessages.getString("VariableBlock.needsbuild.message");
MessageDialog buildDialog= new MessageDialog(getShell(), title, null, message,... |
24,199 | Bug 24199 New Classpath Variables | Why should a full rebuild of the workspace be required when you add a classpath variable? Because it's a new variable it doesn't affect any existing projects. It would be more convenient if a rebuild were not required when adding a new classpath variable. Thanks. | resolved fixed | aedfdfd | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:39:40Z | 2002-09-27T18:06:40Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableBlock.java | private List fToRemove;
private List fToChange;
private boolean fDoBuild;
public VariableBlockRunnable(List toRemove, List toChange, boolean doBuild) {
fToRemove= toRemove;
fToChange= toChange;
fDoBuild= doBuild;
}
/*
* @see IRunnableWithProgress#run(IProgressMonitor)
*/
public void ru... |
24,199 | Bug 24199 New Classpath Variables | Why should a full rebuild of the workspace be required when you add a classpath variable? Because it's a new variable it doesn't affect any existing projects. It would be more convenient if a rebuild were not required when adding a new classpath variable. Thanks. | resolved fixed | aedfdfd | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-09T14:39:40Z | 2002-09-27T18:06:40Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/VariableBlock.java | String[] names= new String[nVariables];
IPath[] paths= new IPath[nVariables];
int k= 0;
for (int i= 0; i < fToChange.size(); i++) {
CPVariableElement curr= (CPVariableElement) fToChange.get(i);
names[k]= curr.getName();
paths[k]= curr.getPath();
k++;
}
for (int i= 0; i < fTo... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/ClasspathContainerDefaultPage.java | package org.eclipse.jdt.internal.ui.wizards.buildpaths;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.Ja... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/ClasspathContainerDefaultPage.java | private StringDialogField fEntryField;
/**
* Constructor for ClasspathContainerDefaultPage.
* @param pageName
*/
public ClasspathContainerDefaultPage() {
super("ClasspathContainerDefaultPage");
setTitle(NewWizardMessages.getString("ClasspathContainerDefaultPage.title"));
setDescription(NewWizardMessages... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/ClasspathContainerDefaultPage.java | fEntryField.setDialogFieldListener(new IDialogFieldListener() {
public void dialogFieldChanged(DialogField field) {
validatePath();
}
});
validatePath();
}
private void validatePath() {
StatusInfo status= new StatusInfo();
String str= fEntryField.getText();
if (str.length() == 0) {
status.setEr... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/ClasspathContainerDefaultPage.java | fEntryField.setFocus();
setControl(composite);
WorkbenchHelp.setHelp(composite, IJavaHelpContextIds.CLASSPATH_CONTAINER_DEFAULT_PAGE);
}
/* (non-Javadoc)
* @see IClasspathContainerPage#finish()
*/
public boolean finish() {
return true;
}
/* (non-Javadoc)
* @see IClasspathContainerPage#getSelection()... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/ClasspathContainerWizard.java | package org.eclipse.jdt.internal.ui.wizards.buildpaths;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.ui.wizards.IClasspathContainerPage;
import org.eclipse.jdt.inter... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/ClasspathContainerWizard.java | private ClasspathContainerDescriptor fPageDesc;
private IClasspathEntry fEntryToEdit;
private IClasspathEntry fNewEntry;
private IClasspathContainerPage fContainerPage;
/**
* Constructor for ClasspathContainerWizard.
*/
public ClasspathContainerWizard(IClasspathEntry entryToEdit) {
super();
fEntryToEdit= e... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/ClasspathContainerWizard.java | public IClasspathEntry getNewEntry() {
return fNewEntry;
}
/* (non-Javadoc)
* @see IWizard#performFinish()
*/
public boolean performFinish() {
if (fContainerPage != null) {
if (fContainerPage.finish()) {
fNewEntry= fContainerPage.getSelection();
return true;
}
}
return false;
}
/* (non-Ja... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/ClasspathContainerWizard.java | }
}
if (containerPage == null) {
containerPage= new ClasspathContainerDefaultPage();
}
containerPage.setSelection(fEntryToEdit);
fContainerPage= containerPage;
addPage(containerPage);
super.addPages();
}
private void handlePageCreationFailed(CoreException e) {
String title= NewWizardMessages.g... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | /*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.wizards.buildpaths;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.ec... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.ui.dialogs.ElementTreeSelectionDialog;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.ui.model.WorkbenchContentProvider;
import org.eclipse.... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | private ListDialogField fClassPathList;
private IJavaProject fCurrJProject;
private ListDialogField fLibrariesList;
private IWorkspaceRoot fWorkspaceRoot;
private IDialogSettings fDialogSettings;
private Control fSWTControl;
private final int IDX_ADDJAR= 0;
private final int IDX_ADDEXT= 1;
private final... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | private final int IDX_EDIT= 5;
private final int IDX_ATTACH= 6;
private final int IDX_REMOVE= 8;
public LibrariesWorkbookPage(IWorkspaceRoot root, ListDialogField classPathList) {
fClassPathList= classPathList;
fWorkspaceRoot= root;
fSWTControl= null;
fDialogSettings= JavaPlugin.getDefault().getDia... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | fLibrariesList.setRemoveButtonIndex(IDX_REMOVE);
fLibrariesList.enableButton(IDX_EDIT, false);
fLibrariesList.enableButton(IDX_ATTACH, false);
fLibrariesList.setViewerSorter(new CPListElementSorter());
}
public void init(IJavaProject jproject) {
fCurrJProject= jproject;
updateLibrariesList();
}
... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | public Control getControl(Composite parent) {
PixelConverter converter= new PixelConverter(parent);
Composite composite= new Composite(parent, SWT.NONE);
LayoutUtil.doDefaultLayout(composite, new DialogField[] { fLibrariesList }, true, SWT.DEFAULT, SWT.DEFAULT);
LayoutUtil.setHorizontalGrabbing(fLibrarie... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | public void customButtonPressed(DialogField field, int index) {
libaryPageCustomButtonPressed(field, index);
}
public void selectionChanged(DialogField field) {
libaryPageSelectionChanged(field);
}
public void dialogFieldChanged(DialogField field) {
libaryPageDialogFieldChanged(field);
}
... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | case IDX_ADDVAR:
libentries= openVariableSelectionDialog(null);
break;
case IDX_ADDADV:
AdvancedDialog advDialog= new AdvancedDialog(getShell());
if (advDialog.open() == AdvancedDialog.OK) {
libentries= advDialog.getResult();
}
break;
case IDX_ATTACH:
List selElements= fLibrariesList.get... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | CPListElement curr= libentries[i];
if (!cplist.contains(curr) && !elementsToAdd.contains(curr)) {
elementsToAdd.add(curr);
addAttachmentsFromExistingLibs(curr);
}
}
fLibrariesList.addElements(elementsToAdd);
fLibrariesList.postSetSelection(new StructuredSelection(libentries));
}
}
/**
*... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | } else if (resource.getType() == IResource.FOLDER) {
if (resource.exists()) {
res= openClassFolderDialog(elem);
} else {
res= openNewClassFolderDialog(elem);
}
} else if (resource.getType() == IResource.FILE) {
res= openJarFileDialog(elem);
}
break;
case IClasspathEntry.CPE_VARI... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | }
}
private boolean canDoSourceAttachment(List selElements) {
if (selElements != null && selElements.size() == 1) {
CPListElement elem= (CPListElement) selElements.get(0);
if (elem.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
return (!(elem.getResource() instanceof IFolder));
} else if (elem.get... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | }
for (int i= 0; i < projelements.size(); i++) {
cpelements.add(projelements.get(i));
}
if (remove || (projelements.size() > 0)) {
fClassPathList.setElements(cpelements);
}
}
private CPListElement[] openNewClassFolderDialog(CPListElement existing) {
String title= (existing == null) ? NewWizardMes... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | ViewerFilter filter= new TypedViewerFilter(acceptedClasses, getUsedContainers(existing));
ILabelProvider lp= new WorkbenchLabelProvider();
ITreeContentProvider cp= new WorkbenchContentProvider();
String title= (existing == null) ? NewWizardMessages.getString("LibrariesWorkbookPage.ExistingClassFolderDialog.n... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | private CPListElement[] openJarFileDialog(CPListElement existing) {
Class[] acceptedClasses= new Class[] { IFile.class };
TypedElementSelectionValidator validator= new TypedElementSelectionValidator(acceptedClasses, existing == null);
ViewerFilter filter= new ArchiveFileFilter(getUsedJARFiles(existing));
ILa... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | }
return null;
}
private IContainer[] getUsedContainers(CPListElement existing) {
ArrayList res= new ArrayList();
if (fCurrJProject.exists()) {
try {
IPath outputLocation= fCurrJProject.getOutputLocation();
if (outputLocation != null) {
IResource resource= fWorkspaceRoot.findMember(outputLocat... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | }
return (IContainer[]) res.toArray(new IContainer[res.size()]);
}
private IFile[] getUsedJARFiles(CPListElement existing) {
List res= new ArrayList();
List cplist= fLibrariesList.getElements();
for (int i= 0; i < cplist.size(); i++) {
CPListElement elem= (CPListElement)cplist.get(i);
if (elem.getEntr... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | lastUsedPath= "";
}
}
String title= (existing == null) ? NewWizardMessages.getString("LibrariesWorkbookPage.ExtJARArchiveDialog.new.title") : NewWizardMessages.getString("LibrariesWorkbookPage.ExtJARArchiveDialog.edit.title");
FileDialog dialog= new FileDialog(getShell(), existing == null ? SWT.MULTI : SW... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | private CPListElement[] openVariableSelectionDialog(CPListElement existing) {
if (existing == null) {
NewVariableEntryDialog dialog= new NewVariableEntryDialog(getShell());
dialog.setTitle(NewWizardMessages.getString("LibrariesWorkbookPage.VariableSelectionDialog.new.title"));
if (dialog.open() == NewVariabl... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | dialog.setTitle(NewWizardMessages.getString("LibrariesWorkbookPage.VariableSelectionDialog.edit.title"));
if (dialog.open() == EditVariableEntryDialog.OK) {
CPListElement elem= new CPListElement(fCurrJProject, IClasspathEntry.CPE_VARIABLE, dialog.getPath(), null);
return new CPListElement[] { elem };
}
... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | if (elem.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
return;
}
try {
IJavaModel jmodel= fCurrJProject.getJavaModel();
IJavaProject[] jprojects= jmodel.getJavaProjects();
for (int i= 0; i < jprojects.length; i++) {
IJavaProject curr= jprojects[i];
if (!curr.equals(fCurrJProject)) {
... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | private static final String DIALOGSTORE_ADV_SECTION= "LibrariesWorkbookPage.advanced";
private static final String DIALOGSTORE_SELECTED= "selected";
private static final String DIALOGSTORE_CONTAINER_IDX= "containerindex";
private DialogField fLabelField;
private SelectionButtonDialogField fCreateFolderField;... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | fAddFolderField= new SelectionButtonDialogField(SWT.RADIO);
fAddFolderField.setLabelText(NewWizardMessages.getString("LibrariesWorkbookPage.AdvancedDialog.addfolder"));
fAddContainerField= new SelectionButtonDialogField(SWT.RADIO);
fAddContainerField.setLabelText(NewWizardMessages.getString("LibrariesWorkbook... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | initializeDialogUnits(parent);
Composite composite= (Composite) super.createDialogArea(parent);
Composite inner= new Composite(composite, SWT.NONE);
GridLayout layout= new GridLayout();
layout.marginHeight= 0;
layout.marginWidth= 0;
inner.setLayout(layout);
fLabelField.doFillIntoGrid(inner,... |
22,662 | Bug 22662 IClasspathContainerPage needs more context [build path] | When adding a container to the buildpath of a project, it would be nice to have more context in the page. At least the classpath of the project that the container will be added to. This way one can handle inter container dependencies (fe this library can be used in combination with this base library, etc) | resolved fixed | 0a3dbc3 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | 2002-10-10T09:07:08Z | 2002-08-21T20:00:00Z | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/buildpaths/LibrariesWorkbookPage.java | } else if (fAddFolderField.isSelected()) {
fResult= openClassFolderDialog(null);
fAdvSettings.put(DIALOGSTORE_SELECTED, 1);
} else if (fAddContainerField.isSelected()) {
String selected= fCombo.getText();
for (int i = 0; i < fDescriptors.length; i++) {
if (fDescriptors[i].getName().equals(select... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.