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
unknown | report_datetime
unknown | updated_file
stringlengths 23
187
| chunk_content
stringlengths 1
22k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.jface.util.Assert;
import org.eclipse.jface.viewers.ColumnWeightData;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TableLayout;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.jdt.internal.ui.util.SWTUtil;
import org.eclipse.jdt.internal.ui.wizards.swt.MGridData;
import org.eclipse.jdt.internal.ui.wizards.swt.MGridLayout;
/**
* A list with a button bar.
* Typical buttons are 'Add', 'Remove', 'Up' and 'Down'.
* List model is independend of widget creation.
* DialogFields controls are: Label, List and Composite containing buttons.
*/
public class ListDialogField extends DialogField { |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | protected TableViewer fTable;
protected ILabelProvider fLabelProvider;
protected ListViewerAdapter fListViewerAdapter;
protected List fElements;
protected String[] fButtonLabels;
private Button[] fButtonControls;
private boolean[] fButtonsEnabled;
private int fRemoveButtonIndex;
private int fUpButtonIndex;
private int fDownButtonIndex;
private Label fLastSeparator;
private Table fTableControl;
private Composite fButtonsControl;
private ISelection fSelectionWhenEnabled;
private TableColumn fTableColumn;
private IListAdapter fListAdapter; |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | private Object fParentElement;
/**
* Creates the <code>ListDialogField</code>.
* @param adapter A listener for button invocation, selection changes.
* @param buttonLabels The labels of all buttons: <code>null</code> is a valid array entry and
* marks a separator.
* @param lprovider The label provider to render the table entries
*/
public ListDialogField(IListAdapter adapter, String[] buttonLabels, ILabelProvider lprovider) {
super();
fListAdapter= adapter;
fLabelProvider= lprovider;
fListViewerAdapter= new ListViewerAdapter();
fParentElement= this;
fElements= new ArrayList(10);
fButtonLabels= buttonLabels;
if (fButtonLabels != null) {
int nButtons= fButtonLabels.length;
fButtonsEnabled= new boolean[nButtons];
for (int i= 0; i < nButtons; i++) {
fButtonsEnabled[i]= true;
}
}
fTable= null;
fTableControl= null;
fButtonsControl= null; |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | fRemoveButtonIndex= -1;
fUpButtonIndex= -1;
fDownButtonIndex= -1;
}
/**
* Sets the index of the 'remove' button in the button label array passed in the constructor.
* The behaviour of the button marked as the 'remove' button will then be handled internally.
* (enable state, button invocation behaviour)
*/
public void setRemoveButtonIndex(int removeButtonIndex) {
Assert.isTrue(removeButtonIndex < fButtonLabels.length);
fRemoveButtonIndex= removeButtonIndex;
}
/**
* Sets the index of the 'up' button in the button label array passed in the constructor.
* The behaviour of the button marked as the 'up' button will then be handled internally.
* (enable state, button invocation behaviour)
*/
public void setUpButtonIndex(int upButtonIndex) {
Assert.isTrue(upButtonIndex < fButtonLabels.length);
fUpButtonIndex= upButtonIndex;
}
/**
* Sets the index of the 'down' button in the button label array passed in the constructor.
* The behaviour of the button marked as the 'down' button will then be handled internally.
* (enable state, button invocation behaviour)
*/
public void setDownButtonIndex(int downButtonIndex) {
Assert.isTrue(downButtonIndex < fButtonLabels.length); |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | fDownButtonIndex= downButtonIndex;
}
private void buttonPressed(int index) {
if (!managedButtonPressed(index)) {
fListAdapter.customButtonPressed(this, index);
}
}
/**
* Checks if the button pressed is handled internally
* @return Returns true if button has been handled.
*/
protected boolean managedButtonPressed(int index) {
if (index == fRemoveButtonIndex) {
remove();
} else if (index == fUpButtonIndex) {
up();
} else if (index == fDownButtonIndex) {
down();
} else {
return false;
}
return true;
} |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | /*
* @see DialogField#doFillIntoGrid
*/
public Control[] doFillIntoGrid(Composite parent, int nColumns) {
assertEnoughColumns(nColumns);
Label label= getLabelControl(parent);
MGridData gd= gridDataForLabel(1);
gd.verticalAlignment= gd.BEGINNING;
label.setLayoutData(gd);
Control list= getListControl(parent);
gd= new MGridData();
gd.horizontalAlignment= gd.FILL;
gd.grabExcessHorizontalSpace= true;
gd.verticalAlignment= gd.FILL;
gd.grabExcessVerticalSpace= true;
gd.grabColumn= 0;
gd.horizontalSpan= nColumns - 2;
gd.widthHint= SWTUtil.convertWidthInCharsToPixels(40, list);
gd.heightHint= SWTUtil.convertHeightInCharsToPixels(15, list);
list.setLayoutData(gd);
Composite buttons= getButtonBox(parent);
gd= new MGridData();
gd.horizontalAlignment= gd.FILL;
gd.grabExcessHorizontalSpace= false;
gd.verticalAlignment= gd.FILL;
gd.grabExcessVerticalSpace= false;
gd.horizontalSpan= 1; |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | buttons.setLayoutData(gd);
return new Control[] { label, list, buttons };
}
/*
* @see DialogField#getNumberOfControls
*/
public int getNumberOfControls() {
return 3;
}
/**
* Sets the minimal width of the buttons. Must be called after widget creation.
*/
public void setButtonsMinWidth(int minWidth) {
if (fLastSeparator != null) {
((MGridData)fLastSeparator.getLayoutData()).widthHint= minWidth;
}
}
/**
* Returns the list control. When called the first time, the control will be created.
* @param The parent composite when called the first time, or <code>null</code>
* after.
*/
public Control getListControl(Composite parent) {
if (fTableControl == null) {
assertCompositeNotNull(parent); |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | fTable= createTableViewer(parent);
fTable.setContentProvider(fListViewerAdapter);
fTable.setLabelProvider(fLabelProvider);
fTable.addSelectionChangedListener(fListViewerAdapter);
fTableControl= (Table)fTable.getControl();
TableLayout tableLayout= new TableLayout();
tableLayout.addColumnData(new ColumnWeightData(100));
fTableColumn= new TableColumn(fTableControl, SWT.NONE);
fTableColumn.setResizable(false);
fTableControl.setLayout(tableLayout);
fTable.setInput(fParentElement);
fTableControl.setEnabled(isEnabled());
if (fSelectionWhenEnabled != null) {
postSetSelection(fSelectionWhenEnabled);
}
fTableColumn.getDisplay().asyncExec(new Runnable() {
public void run() {
if (fTableColumn != null && !fTableColumn.isDisposed()) {
fTableColumn.pack();
}
}
});
}
return fTableControl; |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | }
/**
* Returns the internally used table viewer.
*/
public TableViewer getTableViewer() {
return fTable;
}
/*
* Subclasses may override to specify a different style.
*/
protected int getListStyle(){
return SWT.BORDER + SWT.MULTI + SWT.H_SCROLL + SWT.V_SCROLL;
}
protected TableViewer createTableViewer(Composite parent) {
Table table= new Table(parent, getListStyle());
return new TableViewer(table);
}
protected Button createButton(Composite parent, String label, SelectionListener listener) {
Button button= new Button(parent, SWT.PUSH);
button.setText(label);
button.addSelectionListener(listener);
MGridData gd= new MGridData();
gd.horizontalAlignment= gd.FILL;
gd.grabExcessHorizontalSpace= true;
gd.verticalAlignment= gd.BEGINNING;
gd.heightHint = SWTUtil.getButtonHeigthHint(button);
gd.widthHint = SWTUtil.getButtonWidthHint(button); |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | button.setLayoutData(gd);
return button;
}
private Label createSeparator(Composite parent) {
Label separator= new Label(parent, SWT.NONE);
separator.setVisible(false);
MGridData gd= new MGridData();
gd.horizontalAlignment= gd.FILL;
gd.verticalAlignment= gd.BEGINNING;
gd.heightHint= 4;
separator.setLayoutData(gd);
return separator;
}
/**
* Returns the composite containing the buttons. When called the first time, the control
* will be created.
* @param The parent composite when called the first time, or <code>null</code>
* after.
*/
public Composite getButtonBox(Composite parent) {
if (fButtonsControl == null) {
assertCompositeNotNull(parent);
SelectionListener listener= new SelectionListener() {
public void widgetDefaultSelected(SelectionEvent e) {
doButtonSelected(e);
}
public void widgetSelected(SelectionEvent e) { |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | doButtonSelected(e);
}
};
Composite contents= new Composite(parent, SWT.NULL);
MGridLayout layout= new MGridLayout();
layout.marginWidth= 0;
layout.marginHeight= 0;
contents.setLayout(layout);
if (fButtonLabels != null) {
fButtonControls= new Button[fButtonLabels.length];
for (int i= 0; i < fButtonLabels.length; i++) {
String currLabel= fButtonLabels[i];
if (currLabel != null) {
fButtonControls[i]= createButton(contents, currLabel, listener);
fButtonControls[i].setEnabled(isEnabled() && fButtonsEnabled[i]);
} else {
fButtonControls[i]= null;
createSeparator(contents);
}
}
}
fLastSeparator= createSeparator(contents);
updateButtonState();
fButtonsControl= contents;
} |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | return fButtonsControl;
}
private void doButtonSelected(SelectionEvent e) {
if (fButtonControls != null) {
for (int i= 0; i < fButtonControls.length; i++) {
if (e.widget == fButtonControls[i]) {
buttonPressed(i);
return;
}
}
}
}
/*
* @see DialogField#dialogFieldChanged
*/
public void dialogFieldChanged() {
super.dialogFieldChanged();
if (fTableColumn != null && !fTableColumn.isDisposed()) {
fTableColumn.pack();
}
updateButtonState();
}
private Button getButton(int index) {
if (fButtonControls != null && index >= 0 && index < fButtonControls.length) {
return fButtonControls[index];
} |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | return null;
}
/*
* Updates the enable state of the all buttons
*/
protected void updateButtonState() {
if (fButtonControls != null) {
ISelection sel= fTable.getSelection();
for (int i= 0; i < fButtonControls.length; i++) {
Button button= fButtonControls[i];
if (isOkToUse(button)) {
boolean extraState= getManagedButtonState(sel, i);
button.setEnabled(isEnabled() && extraState && fButtonsEnabled[i]);
}
}
}
}
protected boolean getManagedButtonState(ISelection sel, int index) {
if (index == fRemoveButtonIndex) {
return !sel.isEmpty();
} else if (index == fUpButtonIndex) {
return !sel.isEmpty() && canMoveUp();
} else if (index == fDownButtonIndex) {
return !sel.isEmpty() && canMoveDown();
}
return true;
}
/*
* @see DialogField#updateEnableState |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | */
protected void updateEnableState() {
super.updateEnableState();
boolean enabled= isEnabled();
if (isOkToUse(fTableControl)) {
if (!enabled) {
fSelectionWhenEnabled= fTable.getSelection();
selectElements(null);
} else {
selectElements(fSelectionWhenEnabled);
fSelectionWhenEnabled= null;
}
fTableControl.setEnabled(enabled);
}
updateButtonState();
}
/**
* Sets a button enabled or disabled.
*/
public void enableButton(int index, boolean enable) {
if (fButtonsEnabled != null && index < fButtonsEnabled.length) {
fButtonsEnabled[index]= enable;
updateButtonState();
}
}
/**
* Sets the elements shown in the list. |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | */
public void setElements(List elements) {
fElements= new ArrayList(elements);
if (fTable != null) {
fTable.refresh();
}
dialogFieldChanged();
}
/**
* Gets the elements shown in the list.
* The list returned is a copy, so it can be modified by the user.
*/
public List getElements() {
return new ArrayList(fElements);
}
/**
* Gets the elements shown at the given index.
*/
public Object getElement(int index) {
return fElements.get(index);
}
/**
* Replace an element.
*/
public void replaceElement(Object oldElement, Object newElement) throws IllegalArgumentException {
int idx= fElements.indexOf(oldElement);
if (idx != -1) {
if (oldElement.equals(newElement) || fElements.contains(newElement)) {
return;
} |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | fElements.set(idx, newElement);
if (fTable != null) {
List selected= getSelectedElements();
if (selected.remove(oldElement)) {
selected.add(newElement);
}
fTable.refresh();
fTable.setSelection(new StructuredSelection(selected));
}
dialogFieldChanged();
} else {
throw new IllegalArgumentException();
}
}
/**
* Adds an element at the end of the list.
*/
public void addElement(Object element) {
if (fElements.contains(element)) {
return;
}
fElements.add(element);
if (fTable != null) {
fTable.add(element);
}
dialogFieldChanged();
}
/**
* Adds elements at the end of the list.
*/ |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | public void addElements(List elements) {
int nElements= elements.size();
if (nElements > 0) {
ArrayList elementsToAdd= new ArrayList(nElements);
for (int i= 0; i < nElements; i++) {
Object elem= elements.get(i);
if (!fElements.contains(elem)) {
elementsToAdd.add(elem);
}
}
fElements.addAll(elementsToAdd);
if (fTable != null) {
fTable.add(elementsToAdd.toArray());
}
dialogFieldChanged();
}
}
/**
* Adds an element at a position.
*/
public void insertElementAt(Object element, int index) {
if (fElements.contains(element)) {
return;
}
fElements.add(index, element);
if (fTable != null) {
fTable.add(element); |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | }
dialogFieldChanged();
}
/**
* Adds an element at a position.
*/
public void removeAllElements() {
if (fElements.size() > 0) {
fElements.clear();
if (fTable != null) {
fTable.refresh();
}
dialogFieldChanged();
}
}
/**
* Removes an element from the list.
*/
public void removeElement(Object element) throws IllegalArgumentException {
if (fElements.remove(element)) {
if (fTable != null) {
fTable.remove(element);
}
dialogFieldChanged();
} else {
throw new IllegalArgumentException();
}
} |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | /**
* Removes elements from the list.
*/
public void removeElements(List elements) {
if (elements.size() > 0) {
fElements.removeAll(elements);
if (fTable != null) {
fTable.remove(elements.toArray());
}
dialogFieldChanged();
}
}
/**
* Gets the number of elements
*/
public int getSize() {
return fElements.size();
}
public void selectElements(ISelection selection) {
fSelectionWhenEnabled= selection;
if (fTable != null) {
fTable.setSelection(selection);
}
}
public void postSetSelection(final ISelection selection) {
if (isOkToUse(fTableControl)) {
Display d= fTableControl.getDisplay();
d.asyncExec(new Runnable() { |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | public void run() {
if (isOkToUse(fTableControl)) {
selectElements(selection);
}
}
});
}
}
/**
* Refreshes the table.
*/
public void refresh() {
fTable.refresh();
}
private List moveUp(List elements, List move) {
int nElements= elements.size();
List res= new ArrayList(nElements);
Object floating= null;
for (int i= 0; i < nElements; i++) {
Object curr= elements.get(i);
if (move.contains(curr)) {
res.add(curr);
} else {
if (floating != null) {
res.add(floating);
} |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | floating= curr;
}
}
if (floating != null) {
res.add(floating);
}
return res;
}
private void moveUp(List toMoveUp) {
if (toMoveUp.size() > 0) {
setElements(moveUp(fElements, toMoveUp));
fTable.reveal(toMoveUp.get(0));
}
}
private void moveDown(List toMoveDown) {
if (toMoveDown.size() > 0) {
setElements(reverse(moveUp(reverse(fElements), toMoveDown)));
fTable.reveal(toMoveDown.get(toMoveDown.size() - 1));
}
}
private List reverse(List p) {
List reverse= new ArrayList(p.size());
for (int i= p.size()-1; i >= 0; i--) {
reverse.add(p.get(i));
}
return reverse;
} |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | private void remove() {
removeElements(getSelectedElements());
}
private void up() {
moveUp(getSelectedElements());
}
private void down() {
moveDown(getSelectedElements());
}
private boolean canMoveUp() {
if (isOkToUse(fTableControl)) {
int[] indc= fTableControl.getSelectionIndices();
for (int i= 0; i < indc.length; i++) {
if (indc[i] != i) {
return true;
}
}
}
return false;
}
private boolean canMoveDown() {
if (isOkToUse(fTableControl)) {
int[] indc= fTableControl.getSelectionIndices();
int k= fElements.size() - 1; |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | for (int i= indc.length - 1; i >= 0 ; i--, k--) {
if (indc[i] != k) {
return true;
}
}
}
return false;
}
/**
* Returns the selected elements.
*/
public List getSelectedElements() {
List result= new ArrayList();
if (fTable != null) {
ISelection selection= fTable.getSelection();
if (selection instanceof IStructuredSelection) {
Iterator iter= ((IStructuredSelection)selection).iterator();
while (iter.hasNext()) {
result.add(iter.next());
}
}
}
return result;
}
private class ListViewerAdapter implements IStructuredContentProvider, ISelectionChangedListener { |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/ListDialogField.java | public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
}
public boolean isDeleted(Object element) {
return false;
}
public void dispose() {
}
public Object[] getElements(Object obj) {
return fElements.toArray();
}
public void selectionChanged(SelectionChangedEvent event) {
doListSelected(event);
}
}
private void doListSelected(SelectionChangedEvent event) {
updateButtonState();
if (fListAdapter != null) {
fListAdapter.selectionChanged(this);
}
}
} |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/SelectionButtonDialogFieldGroup.java | /*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.wizards.dialogfields;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.jface.util.Assert;
import org.eclipse.jdt.internal.ui.wizards.swt.MGridData;
import org.eclipse.jdt.internal.ui.wizards.swt.MGridLayout;
/**
* Dialog field describing a group with buttons (Checkboxes, radio buttons..)
*/
public class SelectionButtonDialogFieldGroup extends DialogField { |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/SelectionButtonDialogFieldGroup.java | private Composite fButtonComposite;
private Button[] fButtons;
private String[] fButtonNames;
private boolean[] fButtonsSelected;
private boolean[] fButtonsEnabled;
private int fGroupBorderStyle;
private int fGroupNumberOfColumns;
private int fButtonsStyle;
/**
* Creates a group without border.
*/
public SelectionButtonDialogFieldGroup(int buttonsStyle, String[] buttonNames, int nColumns) {
this(buttonsStyle, buttonNames, nColumns, SWT.NONE);
}
/**
* Creates a group with border (label in border).
* Accepted button styles are: SWT.RADIO, SWT.CHECK, SWT.TOGGLE
* For border styles see <code>Group</code> |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/SelectionButtonDialogFieldGroup.java | */
public SelectionButtonDialogFieldGroup(int buttonsStyle, String[] buttonNames, int nColumns, int borderStyle) {
super();
Assert.isTrue(buttonsStyle == SWT.RADIO || buttonsStyle == SWT.CHECK || buttonsStyle == SWT.TOGGLE);
fButtonNames= buttonNames;
int nButtons= buttonNames.length;
fButtonsSelected= new boolean[nButtons];
fButtonsEnabled= new boolean[nButtons];
for (int i= 0; i < nButtons; i++) {
fButtonsSelected[i]= false;
fButtonsEnabled[i]= true;
}
if (fButtonsStyle == SWT.RADIO) {
fButtonsSelected[0]= true;
}
fGroupBorderStyle= borderStyle;
fGroupNumberOfColumns= (nColumns <= 0) ? nButtons : nColumns;
fButtonsStyle= buttonsStyle;
}
/*
* @see DialogField#doFillIntoGrid
*/ |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/SelectionButtonDialogFieldGroup.java | public Control[] doFillIntoGrid(Composite parent, int nColumns) {
assertEnoughColumns(nColumns);
if (fGroupBorderStyle == SWT.NONE) {
Label label= getLabelControl(parent);
label.setLayoutData(gridDataForLabel(1));
Composite buttonsgroup= getSelectionButtonsGroup(parent);
MGridData gd= new MGridData();
gd.horizontalSpan= nColumns - 1;
gd.grabColumn= 0;
buttonsgroup.setLayoutData(gd);
return new Control[] { label, buttonsgroup };
} else {
Composite buttonsgroup= getSelectionButtonsGroup(parent);
MGridData gd= new MGridData();
gd.horizontalSpan= nColumns;
gd.grabColumn= 0;
buttonsgroup.setLayoutData(gd);
return new Control[] { buttonsgroup };
}
}
/*
* @see DialogField#doFillIntoGrid
*/
public int getNumberOfControls() {
return (fGroupBorderStyle == SWT.NONE) ? 2 : 1;
} |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/SelectionButtonDialogFieldGroup.java | /**
* Sets the minimal size of the buttons. Must be called after the creation of the buttons.
*/
public void setButtonsMinWidth(int minWidth) {
if (fButtonComposite != null) {
Control[] control= fButtonComposite.getChildren();
if (control != null && control.length > 0) {
((MGridData)control[0].getLayoutData()).widthHint= minWidth;
}
}
}
private Button createSelectionButton(int index, Composite group, SelectionListener listener) {
Button button= new Button(group, fButtonsStyle | SWT.LEFT);
button.setFont(group.getFont());
button.setText(fButtonNames[index]);
button.setEnabled(isEnabled() && fButtonsEnabled[index]);
button.setSelection(fButtonsSelected[index]);
button.addSelectionListener(listener);
button.setLayoutData(new MGridData());
return button;
}
/**
* Returns the group widget. When called the first time, the widget will be created.
* @param The parent composite when called the first time, or <code>null</code>
* after.
*/
public Composite getSelectionButtonsGroup(Composite parent) { |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/SelectionButtonDialogFieldGroup.java | if (fButtonComposite == null) {
assertCompositeNotNull(parent);
MGridLayout layout= new MGridLayout();
layout.makeColumnsEqualWidth= true;
layout.numColumns= fGroupNumberOfColumns;
if (fGroupBorderStyle != SWT.NONE) {
Group group= new Group(parent, fGroupBorderStyle);
if (fLabelText != null && fLabelText.length() > 0) {
group.setText(fLabelText);
}
fButtonComposite= group;
} else {
fButtonComposite= new Composite(parent, SWT.NULL);
layout.marginHeight= 0;
layout.marginWidth= 0;
}
fButtonComposite.setLayout(layout);
SelectionListener listener= new SelectionListener() {
public void widgetDefaultSelected(SelectionEvent e) {
doWidgetSelected(e);
}
public void widgetSelected(SelectionEvent e) {
doWidgetSelected(e);
}
};
int nButtons= fButtonNames.length;
fButtons= new Button[nButtons]; |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/SelectionButtonDialogFieldGroup.java | for (int i= 0; i < nButtons; i++) {
fButtons[i]= createSelectionButton(i, fButtonComposite, listener);
}
int nRows= nButtons / fGroupNumberOfColumns;
int nFillElements= nRows * fGroupNumberOfColumns - nButtons;
for (int i= 0; i < nFillElements; i++) {
createEmptySpace(fButtonComposite);
}
}
return fButtonComposite;
}
/**
* Returns a button from the group or <code>null</code> if not yet created.
*/
public Button getSelectionButton(int index) {
if (index >= 0 && index < fButtons.length) {
return fButtons[index];
}
return null;
}
private void doWidgetSelected(SelectionEvent e) {
Button button= (Button)e.widget;
for (int i= 0; i < fButtons.length; i++) {
if (fButtons[i] == button) {
fButtonsSelected[i]= button.getSelection();
dialogFieldChanged();
return;
}
} |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/SelectionButtonDialogFieldGroup.java | }
/**
* Returns the selection state of a button contained in the group.
* @param The index of the button
*/
public boolean isSelected(int index) {
if (index >= 0 && index < fButtonsSelected.length) {
return fButtonsSelected[index];
}
return false;
}
/**
* Sets the selection state of a button contained in the group.
*/
public void setSelection(int index, boolean selected) {
if (index >= 0 && index < fButtonsSelected.length) {
if (fButtonsSelected[index] != selected) {
fButtonsSelected[index]= selected;
if (fButtons != null) {
Button button= fButtons[index];
if (isOkToUse(button)) {
button.setSelection(selected);
}
}
}
}
} |
5,449 | Bug 5449 TVT Text Expansion/Truncations in new java class dialog | null | resolved fixed | 24c773c | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:06:41Z" | "2001-11-02T00:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/dialogfields/SelectionButtonDialogFieldGroup.java | protected void updateEnableState() {
super.updateEnableState();
if (fButtons != null) {
boolean enabled= isEnabled();
for (int i= 0; i < fButtons.length; i++) {
Button button= fButtons[i];
if (isOkToUse(button)) {
button.setEnabled(enabled && fButtonsEnabled[i]);
}
}
}
}
/**
* Sets the enable state of a button contained in the group.
*/
public void enableSelectionButton(int index, boolean enable) {
if (index >= 0 && index < fButtonsEnabled.length) {
fButtonsEnabled[index]= enable;
if (fButtons != null) {
Button button= fButtons[index];
if (isOkToUse(button)) {
button.setEnabled(isEnabled() && enable);
}
}
}
}
} |
4,151 | Bug 4151 Value hovering should show type name not only value (1GIYQVJ) | EG (24.08.2001 14:42:59) value hovering should show the runtime type in addition to the value NOTES: | resolved fixed | d26b1c4 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:22:34Z" | "2001-10-11T03:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/java/hover/JavaDebugHover.java | package org.eclipse.jdt.internal.ui.text.java.hover;
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
import java.util.List;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.core.model.IDebugTarget;
import org.eclipse.debug.core.model.IVariable;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextHover;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.ui.IEditorPart;
import org.eclipse.jdt.debug.core.IJavaDebugTarget;
import org.eclipse.jdt.internal.ui.text.JavaWordFinder;
public class JavaDebugHover implements ITextHover {
protected IEditorPart fEditor; |
4,151 | Bug 4151 Value hovering should show type name not only value (1GIYQVJ) | EG (24.08.2001 14:42:59) value hovering should show the runtime type in addition to the value NOTES: | resolved fixed | d26b1c4 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:22:34Z" | "2001-10-11T03:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/java/hover/JavaDebugHover.java | public JavaDebugHover(IEditorPart editor) {
fEditor= editor;
}
/**
* @see ITextHover#getHoverRegion(ITextViewer, int)
*/
public IRegion getHoverRegion(ITextViewer textViewer, int offset) {
return JavaWordFinder.findWord(textViewer.getDocument(), offset);
}
/**
* @see ITextHover#getHoverInfo(ITextViewer, IRegion)
*/
public String getHoverInfo(ITextViewer textViewer, IRegion hoverRegion) {
DebugPlugin debugPlugin= DebugPlugin.getDefault();
if (debugPlugin == null)
return null;
ILaunchManager launchManager= debugPlugin.getLaunchManager();
if (launchManager == null)
return null;
IDebugTarget[] targets= launchManager.getDebugTargets();
if (targets != null && targets.length > 0) {
try { |
4,151 | Bug 4151 Value hovering should show type name not only value (1GIYQVJ) | EG (24.08.2001 14:42:59) value hovering should show the runtime type in addition to the value NOTES: | resolved fixed | d26b1c4 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-22T14:22:34Z" | "2001-10-11T03:13:20Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/text/java/hover/JavaDebugHover.java | String variableName= textViewer.getDocument().get(hoverRegion.getOffset(), hoverRegion.getLength());
boolean first= true;
StringBuffer buffer= new StringBuffer();
for (int i= 0; i < targets.length; i++) {
IJavaDebugTarget javaTarget = (IJavaDebugTarget) targets[i].getAdapter(IJavaDebugTarget.class);
if (javaTarget != null) {
try {
IVariable variable= javaTarget.findVariable(variableName);
if (variable != null) {
if (!first)
buffer.append('\n');
first= false;
buffer.append(variable.getValue().getValueString());
}
} catch (DebugException x) {
}
}
}
if (buffer.length() > 0)
return buffer.toString();
} catch (BadLocationException x) {
}
}
return null;
}
} |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/ImportOrganizeInputDialog.java | /*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.preferences;
import java.util.HashMap;
import java.util.List;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.util.Assert;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.ui.JavaElementLabelProvider;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.JavaUIMessages;
import org.eclipse.jdt.internal.ui.dialogs.ElementListSelectionDialog; |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/ImportOrganizeInputDialog.java | import org.eclipse.jdt.internal.ui.dialogs.StatusDialog;
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.jdt.internal.ui.util.SWTUtil;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.DialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IDialogFieldListener;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IStringButtonAdapter;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.LayoutUtil;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.StringButtonDialogField;
/**
* Dialog to enter a new package entry in the organize import preference page.
*/
public class ImportOrganizeInputDialog extends StatusDialog {
private class ImportOrganizeInputAdapter implements IDialogFieldListener, IStringButtonAdapter {
/**
* @see IDialogFieldListener#dialogFieldChanged(DialogField)
*/
public void dialogFieldChanged(DialogField field) {
doValidation();
}
/**
* @see IStringButtonAdapter#changeControlPressed(DialogField)
*/
public void changeControlPressed(DialogField field) {
doButtonPressed();
}
}
private StringButtonDialogField fNameDialogField;
private List fExistingEntries; |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/ImportOrganizeInputDialog.java | public ImportOrganizeInputDialog(Shell parent, List existingEntries) {
super(parent);
fExistingEntries= existingEntries;
setTitle(JavaUIMessages.getString("ImportOrganizeInputDialog.title"));
ImportOrganizeInputAdapter adapter= new ImportOrganizeInputAdapter();
fNameDialogField= new StringButtonDialogField(adapter);
fNameDialogField.setLabelText(JavaUIMessages.getString("ImportOrganizeInputDialog.message"));
fNameDialogField.setButtonLabel(JavaUIMessages.getString("ImportOrganizeInputDialog.browse.button"));
fNameDialogField.setDialogFieldListener(adapter);
}
public void setInitialString(String input) {
Assert.isNotNull(input);
fNameDialogField.setText(input);
}
public Object getResult() {
return fNameDialogField.getText();
}
protected Control createDialogArea(Composite parent) {
Composite composite= (Composite) super.createDialogArea(parent);
Composite inner= new Composite(composite, SWT.NONE);
int minimalWidth= convertWidthInCharsToPixels(80);
LayoutUtil.doDefaultLayout(inner, new DialogField[] { fNameDialogField }, true, minimalWidth, 0, 0, 0);
fNameDialogField.postSetFocusOnDialogField(parent.getDisplay()); |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/ImportOrganizeInputDialog.java | return composite;
}
private void doButtonPressed() {
HashMap allPackages= new HashMap();
try {
IWorkspaceRoot root= ResourcesPlugin.getWorkspace().getRoot();
IJavaProject[] projects= JavaCore.create(root).getJavaProjects();
for (int i= 0; i < projects.length; i++) {
IPackageFragment[] packs= projects[i].getPackageFragments();
for (int k=0; k < packs.length; k++) {
IPackageFragment curr= packs[k];
if (!curr.isDefaultPackage() && (curr.hasChildren() || curr.getNonJavaResources().length == 0)) {
allPackages.put(curr.getElementName(), curr);
}
}
}
} catch (JavaModelException e) {
JavaPlugin.log(e.getStatus());
}
Object initialSelection= allPackages.get(fNameDialogField.getText());
ElementListSelectionDialog dialog= new ElementListSelectionDialog(getShell(), new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT));
dialog.setIgnoreCase(false);
dialog.setTitle(JavaUIMessages.getString("ImportOrganizeInputDialog.ChoosePackageDialog.title"));
dialog.setMessage(JavaUIMessages.getString("ImportOrganizeInputDialog.ChoosePackageDialog.description")); |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/ImportOrganizeInputDialog.java | dialog.setEmptyListMessage(JavaUIMessages.getString("ImportOrganizeInputDialog.ChoosePackageDialog.empty"));
dialog.setElements(allPackages.values().toArray());
if (initialSelection != null) {
dialog.setInitialSelections(new Object[] { initialSelection });
}
if (dialog.open() == dialog.OK) {
IPackageFragment res= (IPackageFragment) dialog.getFirstResult();
fNameDialogField.setText(res.getElementName());
}
}
private void doValidation() {
StatusInfo status= new StatusInfo();
String newText= fNameDialogField.getText();
if (newText.length() == 0) {
status.setError(JavaUIMessages.getString("ImportOrganizeInputDialog.error.enterName"));
} else {
IStatus val= JavaConventions.validatePackageName(newText);
if (val.matches(IStatus.ERROR)) {
status.setError(JavaUIMessages.getFormattedString("ImportOrganizeInputDialog.error.invalidName", val.getMessage()));
} else {
if (fExistingEntries.contains(newText)) {
status.setError(JavaUIMessages.getString("ImportOrganizeInputDialog.error.entryExists"));
}
}
}
updateStatus(status);
}
} |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/HistoryListAction.java | package org.eclipse.jdt.internal.ui.typehierarchy;
import java.util.Arrays;
import java.util.List;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.viewers.DoubleClickEvent;
import org.eclipse.jface.viewers.IDoubleClickListener;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.ui.JavaElementLabelProvider;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.JavaPluginImages;
import org.eclipse.jdt.internal.ui.dialogs.StatusDialog;
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.DialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IListAdapter;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.LayoutUtil;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.ListDialogField;
public class HistoryListAction extends Action { |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/HistoryListAction.java | private class HistoryListDialog extends StatusDialog {
private ListDialogField fHistoryList;
private IStatus fHistoryStatus;
private IJavaElement fResult;
private HistoryListDialog(Shell shell, IJavaElement[] elements) {
super(shell);
setTitle(TypeHierarchyMessages.getString("HistoryListDialog.title"));
String[] buttonLabels= new String[] {
TypeHierarchyMessages.getString("HistoryListDialog.remove.button")
}; |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/HistoryListAction.java | IListAdapter adapter= new IListAdapter() {
public void customButtonPressed(DialogField field, int index) {
}
public void selectionChanged(DialogField field) {
doSelectionChanged();
}
};
JavaElementLabelProvider labelProvider= new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_QUALIFIED | JavaElementLabelProvider.SHOW_ROOT);
fHistoryList= new ListDialogField(adapter, buttonLabels, labelProvider);
fHistoryList.setLabelText(TypeHierarchyMessages.getString("HistoryListDialog.label"));
fHistoryList.setRemoveButtonIndex(0);
fHistoryList.setElements(Arrays.asList(elements));
ISelection sel;
if (elements.length > 0) {
sel= new StructuredSelection(elements[0]);
} else {
sel= new StructuredSelection();
}
fHistoryList.selectElements(sel);
}
/*
* @see Dialog#createDialogArea(Composite)
*/
protected Control createDialogArea(Composite parent) { |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/HistoryListAction.java | Composite composite= (Composite) super.createDialogArea(parent);
int minimalWidth= convertWidthInCharsToPixels(80);
int minimalHeight= convertHeightInCharsToPixels(20);
LayoutUtil.doDefaultLayout(composite, new DialogField[] { fHistoryList }, true, minimalWidth, minimalHeight, SWT.DEFAULT, SWT.DEFAULT);
fHistoryList.getTableViewer().addDoubleClickListener(new IDoubleClickListener() {
public void doubleClick(DoubleClickEvent event) {
if (fHistoryStatus.isOK()) {
okPressed();
}
}
});
return composite;
}
private void doSelectionChanged() {
StatusInfo status= new StatusInfo();
List selected= fHistoryList.getSelectedElements();
if (selected.size() != 1) {
status.setError("");
fResult= null;
} else {
fResult= (IJavaElement) selected.get(0);
}
fHistoryStatus= status;
updateStatus(status);
}
public IJavaElement getResult() {
return fResult;
} |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/typehierarchy/HistoryListAction.java | public IJavaElement[] getRemaining() {
List elems= fHistoryList.getElements();
return (IJavaElement[]) elems.toArray(new IJavaElement[elems.size()]);
}
}
private TypeHierarchyViewPart fView;
public HistoryListAction(TypeHierarchyViewPart view) {
fView= view;
setText(TypeHierarchyMessages.getString("HistoryListAction.label"));
JavaPluginImages.setLocalImageDescriptors(this, "history_list.gif");
}
/*
* @see IAction#run()
*/
public void run() {
IJavaElement[] historyEntries= fView.getHistoryEntries();
HistoryListDialog dialog= new HistoryListDialog(JavaPlugin.getActiveWorkbenchShell(), historyEntries);
if (dialog.open() == dialog.OK) {
fView.setHistoryEntries(dialog.getRemaining());
fView.setInputElement(dialog.getResult());
}
}
} |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/ContainerPage.java | /*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.wizards;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot; |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/ContainerPage.java | import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaModel;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.ui.JavaElementContentProvider;
import org.eclipse.jdt.ui.JavaElementLabelProvider;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.dialogs.ElementTreeSelectionDialog;
import org.eclipse.jdt.internal.ui.dialogs.ISelectionValidator;
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
import org.eclipse.jdt.internal.ui.util.JavaModelUtil;
import org.eclipse.jdt.internal.ui.viewsupport.JavaElementSorter;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.DialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IDialogFieldListener;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IStringButtonAdapter;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.StringButtonDialogField;
public abstract class ContainerPage extends NewElementWizardPage { |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/ContainerPage.java | /**
* container field id
*/
protected static final String CONTAINER= "ContainerPage.container";
/**
* Status of last validation
*/
protected IStatus fContainerStatus;
private StringButtonDialogField fContainerDialogField;
/*
* package fragment root corresponding to the input type (can be null)
*/
private IPackageFragmentRoot fCurrRoot;
private IWorkspaceRoot fWorkspaceRoot;
public ContainerPage(String name, IWorkspaceRoot root) {
super(name);
fWorkspaceRoot= root;
ContainerFieldAdapter adapter= new ContainerFieldAdapter();
fContainerDialogField= new StringButtonDialogField(adapter);
fContainerDialogField.setDialogFieldListener(adapter); |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/ContainerPage.java | fContainerDialogField.setLabelText(NewWizardMessages.getString("ContainerPage.container.label"));
fContainerDialogField.setButtonLabel(NewWizardMessages.getString("ContainerPage.container.button"));
fContainerStatus= new StatusInfo();
fCurrRoot= null;
}
/**
* Initializes the fields provided by the container page with a given
* Java element as selection.
* @param elem The initial selection of this page or null if no
* selection was available
*/
protected void initContainerPage(IJavaElement elem) {
IPackageFragmentRoot initRoot= null;
if (elem != null) {
initRoot= JavaModelUtil.getPackageFragmentRoot(elem);
if (initRoot == null || initRoot.isArchive()) {
IJavaProject jproject= elem.getJavaProject();
try {
initRoot= null;
IPackageFragmentRoot[] roots= jproject.getPackageFragmentRoots();
for (int i= 0; i < roots.length; i++) {
if (roots[i].getKind() == IPackageFragmentRoot.K_SOURCE) {
initRoot= roots[i];
break;
}
}
} catch (JavaModelException e) {
JavaPlugin.log(e.getStatus()); |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/ContainerPage.java | }
if (initRoot == null) {
initRoot= jproject.getPackageFragmentRoot("");
}
}
}
setPackageFragmentRoot(initRoot, true);
}
/**
* Utility method to inspect a selection to find a Java element as initial element.
* @return Returns a Java element to use as initial selection, or <code>null</code>,
* if none is found.
*/
protected IJavaElement getInitialJavaElement(IStructuredSelection selection) {
IJavaElement jelem= null;
if (selection != null && !selection.isEmpty()) {
Object selectedElement= selection.getFirstElement();
if (selectedElement instanceof IAdaptable) {
IAdaptable adaptable= (IAdaptable) selectedElement;
jelem= (IJavaElement) adaptable.getAdapter(IJavaElement.class);
if (jelem == null) {
IResource resource= (IResource) adaptable.getAdapter(IResource.class);
if (resource != null) {
IProject proj= resource.getProject();
if (proj != null) {
jelem= JavaCore.create(proj);
}
} |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/ContainerPage.java | }
}
}
if (jelem == null) {
jelem= EditorUtility.getActiveEditorJavaInput();
}
if (jelem == null) {
IProject[] projects= getWorkspaceRoot().getProjects();
if (projects.length > 0) {
jelem= JavaCore.create(projects[0]);
}
}
return jelem;
}
/**
* Creates the controls for the container field.
* @param parent The parent composite
* @param nColumns The number of columns to span
*/
protected void createContainerControls(Composite parent, int nColumns) {
fContainerDialogField.doFillIntoGrid(parent, nColumns);
}
protected void setFocusOnContainer() {
fContainerDialogField.setFocus();
}
private class ContainerFieldAdapter implements IStringButtonAdapter, IDialogFieldListener { |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/ContainerPage.java | public void changeControlPressed(DialogField field) {
containerChangeControlPressed(field);
}
public void dialogFieldChanged(DialogField field) {
containerDialogFieldChanged(field);
}
}
private void containerChangeControlPressed(DialogField field) {
IPackageFragmentRoot root= getPackageFragmentRoot();
root= chooseSourceContainer(root);
if (root != null) {
setPackageFragmentRoot(root, true);
}
}
private void containerDialogFieldChanged(DialogField field) {
if (field == fContainerDialogField) {
fContainerStatus= containerChanged(); |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/ContainerPage.java | }
handleFieldChanged(CONTAINER);
}
/**
* Called after the container field has changed.
* Updates the model and returns the status.
* Model is only valid if returned status is OK
*/
protected IStatus containerChanged() {
StatusInfo status= new StatusInfo();
fCurrRoot= null;
String str= getContainerText();
if ("".equals(str)) {
status.setError(NewWizardMessages.getString("ContainerPage.error.EnterContainerName"));
return status;
}
IPath path= new Path(str);
IResource res= fWorkspaceRoot.findMember(path);
if (res != null) {
int resType= res.getType();
if (resType == IResource.PROJECT || resType == IResource.FOLDER) {
IProject proj= res.getProject();
if (!proj.isOpen()) {
status.setError(NewWizardMessages.getFormattedString("ContainerPage.error.ProjectClosed", proj.getFullPath().toString()));
return status; |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/ContainerPage.java | }
IJavaProject jproject= JavaCore.create(proj);
fCurrRoot= jproject.getPackageFragmentRoot(res);
if (fCurrRoot.exists()) {
try {
if (!proj.hasNature(JavaCore.NATURE_ID)) {
if (resType == IResource.PROJECT) {
status.setWarning(NewWizardMessages.getString("ContainerPage.warning.NotAJavaProject"));
} else {
status.setWarning(NewWizardMessages.getString("ContainerPage.warning.NotInAJavaProject"));
}
return status;
}
} catch (CoreException e) {
status.setWarning(NewWizardMessages.getString("ContainerPage.warning.NotAJavaProject"));
}
try {
if (!JavaModelUtil.isOnBuildPath(jproject, fCurrRoot)) {
status.setWarning(NewWizardMessages.getFormattedString("ContainerPage.warning.NotOnClassPath", str));
}
} catch (JavaModelException e) {
status.setWarning(NewWizardMessages.getFormattedString("ContainerPage.warning.NotOnClassPath", str));
}
if (fCurrRoot.isArchive()) {
status.setError(NewWizardMessages.getFormattedString("ContainerPage.error.ContainerIsBinary", str));
return status;
}
}
return status;
} else { |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/ContainerPage.java | status.setError(NewWizardMessages.getFormattedString("ContainerPage.error.NotAFolder", str));
return status;
}
} else {
status.setError(NewWizardMessages.getFormattedString("ContainerPage.error.ContainerDoesNotExist", str));
return status;
}
}
/**
* Called when a field on a page changed. Every sub type is responsible to
* call this method when a field on its page has changed.
* Subtypes override (extend) the method to add verification when own field has a
* dependency to an other field. (for example the class name input must be verified
* again, when the package field changes (check for duplicated class names))
* @param fieldName The name of the field that has changed (field id)
*/
protected void handleFieldChanged(String fieldName) {
}
/**
* Returns the workspace root.
*/
public IWorkspaceRoot getWorkspaceRoot() {
return fWorkspaceRoot; |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/ContainerPage.java | }
/**
* Returns the PackageFragmentRoot corresponding to the current input.
* @return the PackageFragmentRoot or <code>null</code> if the current
* input is not a valid source folder
*/
public IPackageFragmentRoot getPackageFragmentRoot() {
return fCurrRoot;
}
/**
* Returns the text of the container field.
*/
public String getContainerText() {
return fContainerDialogField.getText();
}
/**
* Sets the current PackageFragmentRoot (model and text field).
* @param canBeModified Selects if the container field can be changed by the user
*/
public void setPackageFragmentRoot(IPackageFragmentRoot root, boolean canBeModified) {
fCurrRoot= root;
String str= (root == null) ? "" : root.getPath().makeRelative().toString();
fContainerDialogField.setText(str);
fContainerDialogField.setEnabled(canBeModified);
} |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/ContainerPage.java | private IPackageFragmentRoot chooseSourceContainer(IJavaElement initElement) {
Class[] acceptedClasses= new Class[] { IPackageFragmentRoot.class, IJavaProject.class };
ISelectionValidator validator= new TypedElementSelectionValidator(acceptedClasses, false) {
public boolean isSelectedValid(Object element) {
try {
if (element instanceof IJavaProject) {
IJavaProject jproject= (IJavaProject)element;
IPath path= jproject.getProject().getFullPath();
return (jproject.findPackageFragmentRoot(path) != null);
} else if (element instanceof IPackageFragmentRoot) {
return (((IPackageFragmentRoot)element).getKind() == IPackageFragmentRoot.K_SOURCE);
}
return true;
} catch (JavaModelException e) {
JavaPlugin.log(e.getStatus());
}
return false;
}
};
acceptedClasses= new Class[] { IJavaModel.class, IPackageFragmentRoot.class, IJavaProject.class };
ViewerFilter filter= new TypedViewerFilter(acceptedClasses) {
public boolean select(Viewer viewer, Object parent, Object element) {
if (element instanceof IPackageFragmentRoot) {
try {
return (((IPackageFragmentRoot)element).getKind() == IPackageFragmentRoot.K_SOURCE);
} catch (JavaModelException e) {
JavaPlugin.log(e.getStatus());
return false; |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/ContainerPage.java | }
}
return super.select(viewer, parent, element);
}
};
JavaElementContentProvider provider= new JavaElementContentProvider();
ILabelProvider labelProvider= new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);
ElementTreeSelectionDialog dialog= new ElementTreeSelectionDialog(getShell(), labelProvider, provider);
dialog.setValidator(validator);
dialog.setSorter(new JavaElementSorter());
dialog.setTitle(NewWizardMessages.getString("ContainerPage.ChooseSourceContainerDialog.title"));
dialog.setMessage(NewWizardMessages.getString("ContainerPage.ChooseSourceContainerDialog.description"));
dialog.addFilter(filter);
dialog.setInput(JavaCore.create(fWorkspaceRoot));
dialog.setInitialSelection(initElement);
if (dialog.open() == dialog.OK) {
Object element= dialog.getFirstResult();
if (element instanceof IJavaProject) {
IJavaProject jproject= (IJavaProject)element;
return jproject.getPackageFragmentRoot(jproject.getProject());
} else if (element instanceof IPackageFragmentRoot) {
return (IPackageFragmentRoot)element;
}
return null;
}
return null;
}
} |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewClassCreationWizardPage.java | /*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.wizards;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot; |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewClassCreationWizardPage.java | import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.help.DialogPageContextComputer;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.codemanipulation.IImportsStructure;
import org.eclipse.jdt.internal.ui.dialogs.StatusUtil;
import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
import org.eclipse.jdt.internal.ui.util.SWTUtil;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.DialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.LayoutUtil;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.SelectionButtonDialogFieldGroup;
import org.eclipse.jdt.internal.ui.wizards.swt.MGridLayout;
public class NewClassCreationWizardPage extends TypePage {
private final static String PAGE_NAME= "NewClassCreationWizardPage";
private SelectionButtonDialogFieldGroup fMethodStubsButtons;
public NewClassCreationWizardPage(IWorkspaceRoot root) {
super(true, PAGE_NAME, root);
setTitle(NewWizardMessages.getString("NewClassCreationWizardPage.title")); |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewClassCreationWizardPage.java | setDescription(NewWizardMessages.getString("NewClassCreationWizardPage.description"));
String[] buttonNames3= new String[] {
NewWizardMessages.getString("NewClassCreationWizardPage.methods.main"), NewWizardMessages.getString("NewClassCreationWizardPage.methods.constructors"),
NewWizardMessages.getString("NewClassCreationWizardPage.methods.inherited")
};
fMethodStubsButtons= new SelectionButtonDialogFieldGroup(SWT.CHECK, buttonNames3, 1);
fMethodStubsButtons.setLabelText(NewWizardMessages.getString("NewClassCreationWizardPage.methods.label"));
}
/**
* Should be called from the wizard with the input element.
*/
public void init(IStructuredSelection selection) {
IJavaElement jelem= getInitialJavaElement(selection);
initContainerPage(jelem);
initTypePage(jelem);
updateStatus(findMostSevereStatus());
fMethodStubsButtons.setSelection(0, false);
fMethodStubsButtons.setSelection(1, false);
fMethodStubsButtons.setSelection(2, true);
}
/**
* Finds the most severe error (if there is one)
*/
private IStatus findMostSevereStatus() {
return StatusUtil.getMostSevere(new IStatus[] { |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewClassCreationWizardPage.java | fContainerStatus,
isEnclosingTypeSelected() ? fEnclosingTypeStatus : fPackageStatus,
fTypeNameStatus,
fModifierStatus,
fSuperClassStatus,
fSuperInterfacesStatus
});
}
/*
* @see ContainerPage#handleFieldChanged
*/
protected void handleFieldChanged(String fieldName) {
super.handleFieldChanged(fieldName);
updateStatus(findMostSevereStatus());
}
/*
* @see WizardPage#createControl
*/
public void createControl(Composite parent) {
Composite composite= new Composite(parent, SWT.NONE);
int nColumns= 4;
MGridLayout layout= new MGridLayout(); |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewClassCreationWizardPage.java | layout.minimumWidth= SWTUtil.convertWidthInCharsToPixels(80, composite);
layout.numColumns= nColumns;
composite.setLayout(layout);
createContainerControls(composite, nColumns);
createPackageControls(composite, nColumns);
createEnclosingTypeControls(composite, nColumns);
createSeparator(composite, nColumns);
createTypeNameControls(composite, nColumns);
createModifierControls(composite, nColumns);
createSuperClassControls(composite, nColumns);
createSuperInterfacesControls(composite, nColumns);
createMethodStubSelectionControls(composite, nColumns);
setControl(composite);
setFocus();
WorkbenchHelp.setHelp(composite, new DialogPageContextComputer(this, IJavaHelpContextIds.NEW_CLASS_WIZARD_PAGE));
}
protected void createMethodStubSelectionControls(Composite composite, int nColumns) {
LayoutUtil.setHorizontalSpan(fMethodStubsButtons.getLabelControl(composite), nColumns);
DialogField.createEmptySpace(composite); |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewClassCreationWizardPage.java | LayoutUtil.setHorizontalSpan(fMethodStubsButtons.getSelectionButtonsGroup(composite), nColumns - 1);
}
/*
* @see TypePage#evalMethods
*/
protected String[] evalMethods(IType type, IImportsStructure imports, IProgressMonitor monitor) throws CoreException {
List newMethods= new ArrayList();
boolean doConstr= fMethodStubsButtons.isSelected(1);
boolean doInherited= fMethodStubsButtons.isSelected(2);
String[] meth= constructInheritedMethods(type, doConstr, doInherited, imports, new SubProgressMonitor(monitor, 1));
for (int i= 0; i < meth.length; i++) {
newMethods.add(meth[i]);
}
if (monitor != null) {
monitor.done();
}
if (fMethodStubsButtons.isSelected(0)) {
String main= "public static void main(String[] args) {}";
newMethods.add(main);
}
return (String[]) newMethods.toArray(new String[newMethods.size()]);
}
} |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewInterfaceCreationWizardPage.java | /*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.wizards;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.help.DialogPageContextComputer;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.dialogs.StatusUtil;
import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
import org.eclipse.jdt.internal.ui.util.SWTUtil;
import org.eclipse.jdt.internal.ui.wizards.swt.MGridLayout;
public class NewInterfaceCreationWizardPage extends TypePage { |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewInterfaceCreationWizardPage.java | private final static String PAGE_NAME= "NewInterfaceCreationWizardPage";
public NewInterfaceCreationWizardPage(IWorkspaceRoot root) {
super(false, PAGE_NAME, root);
setTitle(NewWizardMessages.getString("NewInterfaceCreationWizardPage.title"));
setDescription(NewWizardMessages.getString("NewInterfaceCreationWizardPage.description"));
}
/**
* Should be called from the wizard with the input element.
*/
public void init(IStructuredSelection selection) {
IJavaElement jelem= getInitialJavaElement(selection);
initContainerPage(jelem);
initTypePage(jelem);
updateStatus(findMostSevereStatus());
} |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewInterfaceCreationWizardPage.java | /**
* Finds the most severe error (if there is one)
*/
private IStatus findMostSevereStatus() {
return StatusUtil.getMostSevere(new IStatus[] {
fContainerStatus,
isEnclosingTypeSelected() ? fEnclosingTypeStatus : fPackageStatus,
fTypeNameStatus,
fModifierStatus,
fSuperInterfacesStatus
});
}
/**
* @see ContainerPage#handleFieldChanged
*/
protected void handleFieldChanged(String fieldName) {
super.handleFieldChanged(fieldName);
updateStatus(findMostSevereStatus());
}
/**
* @see WizardPage#createControl |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewInterfaceCreationWizardPage.java | */
public void createControl(Composite parent) {
Composite composite= new Composite(parent, SWT.NONE);
int nColumns= 4;
MGridLayout layout= new MGridLayout();
layout.minimumWidth= SWTUtil.convertWidthInCharsToPixels(80, composite);
layout.numColumns= nColumns;
composite.setLayout(layout);
createContainerControls(composite, nColumns);
createPackageControls(composite, nColumns);
createEnclosingTypeControls(composite, nColumns);
createSeparator(composite, nColumns);
createTypeNameControls(composite, nColumns);
createModifierControls(composite, nColumns);
createSuperInterfacesControls(composite, nColumns);
setControl(composite);
setFocus();
WorkbenchHelp.setHelp(composite, new DialogPageContextComputer(this, IJavaHelpContextIds.NEW_INTERFACE_WIZARD_PAGE));
}
} |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewPackageCreationWizardPage.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.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label; |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewPackageCreationWizardPage.java | import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.help.DialogPageContextComputer;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
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.javaeditor.EditorUtility;
import org.eclipse.jdt.internal.ui.util.SWTUtil;
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.StringDialogField;
import org.eclipse.jdt.internal.ui.wizards.swt.MGridData;
import org.eclipse.jdt.internal.ui.wizards.swt.MGridLayout;
public class NewPackageCreationWizardPage extends ContainerPage { |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewPackageCreationWizardPage.java | private static final String PAGE_NAME= "NewPackageCreationWizardPage";
protected static final String PACKAGE= "NewPackageCreationWizardPage.package";
private StringDialogField fPackageDialogField;
/**
* Status of last validation of the package field
*/
protected IStatus fPackageStatus;
private IPackageFragment fCreatedPackageFragment;
public NewPackageCreationWizardPage(IWorkspaceRoot root) {
super(PAGE_NAME, root);
setTitle(NewWizardMessages.getString("NewPackageCreationWizardPage.title"));
setDescription(NewWizardMessages.getString("NewPackageCreationWizardPage.description"));
fCreatedPackageFragment= null; |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewPackageCreationWizardPage.java | PackageFieldAdapter adapter= new PackageFieldAdapter();
fPackageDialogField= new StringDialogField();
fPackageDialogField.setDialogFieldListener(adapter);
fPackageDialogField.setLabelText(NewWizardMessages.getString("NewPackageCreationWizardPage.package.label"));
fPackageStatus= new StatusInfo();
}
/**
* Should be called from the wizard with the input element.
*/
public void init(IStructuredSelection selection) {
IJavaElement jelem= getInitialJavaElement(selection);
initContainerPage(jelem);
setPackageText("");
updateStatus(findMostSevereStatus());
}
/**
* @see WizardPage#createControl
*/
public void createControl(Composite parent) {
Composite composite= new Composite(parent, SWT.NONE);
int nColumns= 3;
int widthHint= SWTUtil.convertWidthInCharsToPixels(80, composite);
MGridLayout layout= new MGridLayout(); |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewPackageCreationWizardPage.java | layout.marginWidth= 0;
layout.marginHeight= 0;
layout.minimumWidth= widthHint;
layout.minimumHeight= SWTUtil.convertHeightInCharsToPixels(20, composite);
layout.numColumns= 3;
composite.setLayout(layout);
Label label= new Label(composite, SWT.WRAP);
label.setText(NewWizardMessages.getString("NewPackageCreationWizardPage.info"));
MGridData gd= new MGridData();
gd.widthHint= widthHint;
gd.horizontalSpan= 3;
label.setLayoutData(gd);
createContainerControls(composite, nColumns);
createPackageControls(composite, nColumns);
fPackageDialogField.setFocus();
setControl(composite);
WorkbenchHelp.setHelp(composite, new DialogPageContextComputer(this, IJavaHelpContextIds.NEW_PACKAGE_WIZARD_PAGE));
}
protected void createPackageControls(Composite composite, int nColumns) {
fPackageDialogField.doFillIntoGrid(composite, nColumns - 1);
DialogField.createEmptySpace(composite);
}
private class PackageFieldAdapter implements IDialogFieldListener { |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewPackageCreationWizardPage.java | public void dialogFieldChanged(DialogField field) {
fPackageStatus= packageChanged();
handleFieldChanged(PACKAGE);
}
}
/**
* Called when a dialog field on this page changed
* @see ContainerPage#fieldUpdated
*/
protected void handleFieldChanged(String fieldName) {
super.handleFieldChanged(fieldName);
if (fieldName == CONTAINER) {
fPackageStatus= packageChanged();
}
updateStatus(findMostSevereStatus());
}
/**
* Finds the most severe error (if there is one)
*/
protected IStatus findMostSevereStatus() { |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewPackageCreationWizardPage.java | return StatusUtil.getMoreSevere(fContainerStatus, fPackageStatus);
}
/**
* Verify the input for the package field
*/
private IStatus packageChanged() {
StatusInfo status= new StatusInfo();
String packName= fPackageDialogField.getText();
if (!"".equals(packName)) {
IStatus val= JavaConventions.validatePackageName(packName);
if (val.getSeverity() == IStatus.ERROR) {
status.setError(NewWizardMessages.getFormattedString("NewPackageCreationWizardPage.error.InvalidPackageName", val.getMessage()));
return status;
} else if (val.getSeverity() == IStatus.WARNING) {
status.setWarning(NewWizardMessages.getFormattedString("NewPackageCreationWizardPage.warning.DiscouragedPackageName", val.getMessage()));
}
} else {
status.setError(NewWizardMessages.getString("NewPackageCreationWizardPage.error.EnterName"));
return status;
}
IPackageFragmentRoot root= getPackageFragmentRoot();
if (root != null) {
IPackageFragment pack= root.getPackageFragment(packName);
try {
IPath rootPath= root.getPath();
IPath outputPath= root.getJavaProject().getOutputLocation();
if (rootPath.isPrefixOf(outputPath) && !rootPath.equals(outputPath)) { |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewPackageCreationWizardPage.java | IPath packagePath= pack.getUnderlyingResource().getFullPath();
if (outputPath.isPrefixOf(packagePath)) {
status.setError(NewWizardMessages.getString("NewPackageCreationWizardPage.error.IsOutputFolder"));
return status;
}
}
if (pack.exists()) {
if (pack.containsJavaResources() || !pack.hasSubpackages()) {
status.setError(NewWizardMessages.getString("NewPackageCreationWizardPage.error.PackageExists"));
} else {
status.setWarning(NewWizardMessages.getString("NewPackageCreationWizardPage.warning.PackageNotShown"));
}
}
} catch (JavaModelException e) {
JavaPlugin.log(e.getStatus());
}
}
return status;
}
protected String getPackageText() {
return fPackageDialogField.getText();
}
protected void setPackageText(String str) {
fPackageDialogField.setText(str);
} |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewPackageCreationWizardPage.java | /**
* @see NewElementWizardPage#getRunnable
*/
public IRunnableWithProgress getRunnable() {
return new IRunnableWithProgress() {
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
try {
createPackage(monitor);
} catch (JavaModelException e) {
throw new InvocationTargetException(e);
} catch (CoreException e) {
throw new InvocationTargetException(e);
}
}
};
}
public IPackageFragment getNewPackageFragment() {
return fCreatedPackageFragment;
}
protected void createPackage(IProgressMonitor monitor) throws JavaModelException, CoreException, InterruptedException {
IPackageFragmentRoot root= getPackageFragmentRoot();
String packName= getPackageText();
fCreatedPackageFragment= root.createPackageFragment(packName, true, monitor);
}
} |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderCreationWizardPage.java | /*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.wizards;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path; |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderCreationWizardPage.java | import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.ui.actions.WorkspaceModifyDelegatingOperation;
import org.eclipse.ui.help.DialogPageContextComputer;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.ui.model.WorkbenchContentProvider;
import org.eclipse.ui.model.WorkbenchLabelProvider;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.ui.JavaElementLabelProvider;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.dialogs.ElementListSelectionDialog;
import org.eclipse.jdt.internal.ui.dialogs.ElementTreeSelectionDialog;
import org.eclipse.jdt.internal.ui.dialogs.ISelectionValidator;
import org.eclipse.jdt.internal.ui.dialogs.StatusDialog;
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.jdt.internal.ui.dialogs.StatusUtil;
import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
import org.eclipse.jdt.internal.ui.util.CoreUtility;
import org.eclipse.jdt.internal.ui.util.ExceptionHandler; |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderCreationWizardPage.java | import org.eclipse.jdt.internal.ui.util.SWTUtil;
import org.eclipse.jdt.internal.ui.wizards.buildpaths.BuildPathsBlock;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.DialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IDialogFieldListener;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IStringButtonAdapter;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.SelectionButtonDialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.Separator;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.StringButtonDialogField;
import org.eclipse.jdt.internal.ui.wizards.swt.MGridData;
import org.eclipse.jdt.internal.ui.wizards.swt.MGridLayout;
public class NewSourceFolderCreationWizardPage extends NewElementWizardPage {
private static final String PAGE_NAME= "NewSourceFolderCreationWizardPage";
private StringButtonDialogField fProjectField;
private StatusInfo fProjectStatus;
private StringButtonDialogField fRootDialogField;
private StatusInfo fRootStatus;
private SelectionButtonDialogField fEditClassPathField;
private IWorkspaceRoot fWorkspaceRoot;
private IJavaProject fCurrJProject;
private IClasspathEntry[] fEntries;
private IPath fOutputLocation;
private IPackageFragmentRoot fCreatedRoot;
public NewSourceFolderCreationWizardPage(IWorkspaceRoot root) { |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderCreationWizardPage.java | super(PAGE_NAME);
setTitle(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.title"));
setDescription(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.description"));
fWorkspaceRoot= root;
RootFieldAdapter adapter= new RootFieldAdapter();
fProjectField= new StringButtonDialogField(adapter);
fProjectField.setDialogFieldListener(adapter);
fProjectField.setLabelText(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.project.label"));
fProjectField.setButtonLabel(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.project.button"));
fRootDialogField= new StringButtonDialogField(adapter);
fRootDialogField.setDialogFieldListener(adapter);
fRootDialogField.setLabelText(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.root.label"));
fRootDialogField.setButtonLabel(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.root.button"));
fEditClassPathField= new SelectionButtonDialogField(SWT.PUSH);
fEditClassPathField.setDialogFieldListener(adapter);
fEditClassPathField.setLabelText(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.editclasspath.button"));
fRootStatus= new StatusInfo();
fProjectStatus= new StatusInfo();
}
public void init(IStructuredSelection selection) { |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderCreationWizardPage.java | if (selection == null || selection.isEmpty()) {
setDefaultAttributes();
return;
}
Object selectedElement= selection.getFirstElement();
if (selectedElement == null) {
selectedElement= EditorUtility.getActiveEditorJavaInput();
}
String projPath= null;
if (selectedElement instanceof IResource) {
IProject proj= ((IResource)selectedElement).getProject();
if (proj != null) {
projPath= proj.getFullPath().makeRelative().toString();
}
} else if (selectedElement instanceof IJavaElement) {
IJavaProject jproject= ((IJavaElement)selectedElement).getJavaProject();
if (jproject != null) {
projPath= jproject.getProject().getFullPath().makeRelative().toString();
}
}
if (projPath != null) {
fProjectField.setText(projPath);
fRootDialogField.setText("");
} else {
setDefaultAttributes();
} |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderCreationWizardPage.java | }
private void setDefaultAttributes() {
String projPath= "";
try {
IProject[] projects= fWorkspaceRoot.getProjects();
for (int i= 0; i < projects.length; i++) {
IProject proj= projects[i];
if (proj.hasNature(JavaCore.NATURE_ID)) {
projPath= proj.getFullPath().makeRelative().toString();
break;
}
}
} catch (CoreException e) {
}
fProjectField.setText(projPath);
fRootDialogField.setText("");
}
/**
* @see WizardPage#createControl
*/
public void createControl(Composite parent) {
Composite composite= new Composite(parent, SWT.NONE);
MGridLayout layout= new MGridLayout(); |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderCreationWizardPage.java | layout.marginWidth= 0;
layout.marginHeight= 0;
layout.minimumWidth= SWTUtil.convertWidthInCharsToPixels(80, composite);
layout.minimumHeight= SWTUtil.convertHeightInCharsToPixels(20, composite);
layout.numColumns= 3;
composite.setLayout(layout);
fProjectField.doFillIntoGrid(composite, 3);
fRootDialogField.doFillIntoGrid(composite, 3);
fRootDialogField.setFocus();
(new Separator()).doFillIntoGrid(composite, 3);
fEditClassPathField.doFillIntoGrid(composite, 3);
Control control= fEditClassPathField.getSelectionButton(null);
MGridData gd= (MGridData) control.getLayoutData();
gd.verticalAlignment= MGridData.END;
gd.horizontalAlignment= MGridData.BEGINNING;
setControl(composite);
WorkbenchHelp.setHelp(composite, new DialogPageContextComputer(this, IJavaHelpContextIds.NEW_PACKAGEROOT_WIZARD_PAGE));
}
private class RootFieldAdapter implements IStringButtonAdapter, IDialogFieldListener {
public void changeControlPressed(DialogField field) {
packRootChangeControlPressed(field);
} |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderCreationWizardPage.java | public void dialogFieldChanged(DialogField field) {
packRootDialogFieldChanged(field);
}
}
private void packRootChangeControlPressed(DialogField field) {
if (field == fRootDialogField) {
IFolder folder= chooseFolder();
if (folder != null) {
IPath path= folder.getFullPath().removeFirstSegments(1);
fRootDialogField.setText(path.toString());
}
} else if (field == fProjectField) {
IJavaProject jproject= chooseProject();
if (jproject != null) {
IPath path= jproject.getProject().getFullPath().makeRelative();
fProjectField.setText(path.toString());
}
}
}
private void packRootDialogFieldChanged(DialogField field) {
if (field == fRootDialogField) {
updateRootStatus();
} else if (field == fProjectField) {
updateProjectStatus();
updateRootStatus();
} else if (field == fEditClassPathField) {
if (showClassPathPropertyPage()) {
updateProjectStatus();
updateRootStatus(); |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderCreationWizardPage.java | }
}
updateStatus(findMostSevereStatus());
}
private void updateProjectStatus() {
fCurrJProject= null;
String str= fProjectField.getText();
if ("".equals(str)) {
fProjectStatus.setError(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.error.EnterProjectName"));
return;
}
IPath path= new Path(str);
if (path.segmentCount() != 1) {
fProjectStatus.setError(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.error.InvalidProjectPath"));
return;
}
IProject project= fWorkspaceRoot.getProject(path.toString());
if (!project.exists()) {
fProjectStatus.setError(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.error.ProjectNotExists"));
return;
}
try {
if (project.hasNature(JavaCore.NATURE_ID)) {
fCurrJProject= JavaCore.create(project);
fEntries= fCurrJProject.getRawClasspath();
fOutputLocation= fCurrJProject.getOutputLocation();
fProjectStatus.setOK(); |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderCreationWizardPage.java | return;
}
} catch (CoreException e) {
JavaPlugin.log(e);
fCurrJProject= null;
}
fProjectStatus.setError(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.error.NotAJavaProject"));
}
private void updateRootStatus() {
fRootDialogField.enableButton(fCurrJProject != null);
if (fCurrJProject == null) {
return;
}
String str= fRootDialogField.getText();
if (str.length() == 0) {
fRootStatus.setError(NewWizardMessages.getFormattedString("NewSourceFolderCreationWizardPage.error.EnterRootName", fCurrJProject.getProject().getFullPath().toString()));
} else {
IPath path= fCurrJProject.getProject().getFullPath().append(str);
if (!fWorkspaceRoot.getWorkspace().validatePath(path.toString(), IResource.FOLDER).isOK()) {
fRootStatus.setError(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.error.InvalidRootName"));
} else {
IResource res= fWorkspaceRoot.findMember(path);
if (res != null) {
if (res.getType() != IResource.FOLDER) {
fRootStatus.setError(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.error.NotAFolder"));
return;
}
} |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderCreationWizardPage.java | IClasspathEntry[] newEntries= new IClasspathEntry[fEntries.length + 1];
for (int i= 0; i < fEntries.length; i++) {
IClasspathEntry curr= fEntries[i];
if (curr.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
if (path.equals(curr.getPath())) {
fRootStatus.setError(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.error.AlreadyExisting"));
return;
}
}
newEntries[i]= curr;
}
newEntries[fEntries.length]= JavaCore.newSourceEntry(path);
IStatus status= JavaConventions.validateClasspath(fCurrJProject, newEntries, fOutputLocation);
if (!status.isOK()) {
fRootStatus.setError(status.getMessage());
return;
}
fRootStatus.setOK();
}
}
}
protected IStatus findMostSevereStatus() {
return StatusUtil.getMoreSevere(fProjectStatus, fRootStatus);
}
/**
* @see NewElementWizardPage#getRunnable |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderCreationWizardPage.java | */
public IRunnableWithProgress getRunnable() {
return new IRunnableWithProgress() {
public void run(IProgressMonitor monitor) throws InvocationTargetException {
try {
fCreatedRoot= createPackageFragmentRoot(monitor, getShell());
} catch (JavaModelException e) {
throw new InvocationTargetException(e);
} catch (CoreException e) {
throw new InvocationTargetException(e);
}
}
};
}
protected IPackageFragmentRoot getNewPackageFragmentRoot() {
return fCreatedRoot;
}
protected IPackageFragmentRoot createPackageFragmentRoot(IProgressMonitor monitor, Shell shell) throws CoreException, JavaModelException {
String relPath= fRootDialogField.getText();
IFolder folder= fCurrJProject.getProject().getFolder(relPath);
IPath path= folder.getFullPath();
if (!folder.exists()) {
CoreUtility.createFolder(folder, true, true, monitor);
}
IClasspathEntry[] entries= fCurrJProject.getRawClasspath(); |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderCreationWizardPage.java | int nEntries= entries.length;
IClasspathEntry[] newEntries= new IClasspathEntry[nEntries + 1];
for (int i= 0; i < nEntries; i++) {
newEntries[i]= entries[i];
}
newEntries[nEntries]= JavaCore.newSourceEntry(path);
fCurrJProject.setRawClasspath(newEntries, monitor);
return fCurrJProject.getPackageFragmentRoot(folder);
}
private IFolder chooseFolder() {
Class[] acceptedClasses= new Class[] { IFolder.class };
ISelectionValidator validator= new TypedElementSelectionValidator(acceptedClasses, false);
Object[] notWanted= getFilteredExistingContainerEntries();
ViewerFilter filter= new TypedViewerFilter(acceptedClasses, notWanted);
ILabelProvider lp= new WorkbenchLabelProvider();
ITreeContentProvider cp= new WorkbenchContentProvider();
ElementTreeSelectionDialog dialog= new ElementTreeSelectionDialog(getShell(), lp, cp);
dialog.setValidator(validator);
dialog.setTitle(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.ChooseExistingRootDialog.title"));
dialog.setMessage(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.ChooseExistingRootDialog.description"));
dialog.addFilter(filter);
dialog.setInput(fCurrJProject.getProject());
IResource res= fWorkspaceRoot.findMember(new Path(fRootDialogField.getText()));
if (res != null) {
dialog.setInitialSelection(res); |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderCreationWizardPage.java | }
if (dialog.open() == dialog.OK) {
return (IFolder) dialog.getFirstResult();
}
return null;
}
private IJavaProject chooseProject() {
IJavaProject[] projects;
try {
projects= JavaCore.create(fWorkspaceRoot).getJavaProjects();
} catch (JavaModelException e) {
JavaPlugin.log(e.getStatus());
projects= new IJavaProject[0];
}
ILabelProvider labelProvider= new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);
ElementListSelectionDialog dialog= new ElementListSelectionDialog(getShell(), labelProvider);
dialog.setTitle(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.ChooseProjectDialog.title"));
dialog.setMessage(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.ChooseProjectDialog.description"));
dialog.setElements(projects);
dialog.setInitialSelections(new Object[] { fCurrJProject });
if (dialog.open() == dialog.OK) {
return (IJavaProject) dialog.getFirstResult();
}
return null;
}
private class EditClassPathDialog extends StatusDialog implements IStatusChangeListener { |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderCreationWizardPage.java | private BuildPathsBlock fBuildPathsBlock;
public EditClassPathDialog(Shell parent) {
super(parent);
fBuildPathsBlock= new BuildPathsBlock(fWorkspaceRoot, this, false);
}
public void create() {
super.create();
fBuildPathsBlock.init(fCurrJProject, null, null);
}
protected Control createDialogArea(Composite parent) {
Composite composite= (Composite)super.createDialogArea(parent);
Control inner= fBuildPathsBlock.createControl(composite);
inner.setLayoutData(new GridData(GridData.FILL_BOTH));
return composite;
}
public void statusChanged(IStatus status) {
updateStatus(status);
}
protected void buttonPressed(int buttonId) {
if (buttonId == IDialogConstants.OK_ID) { |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderCreationWizardPage.java | IRunnableWithProgress runnable= fBuildPathsBlock.getRunnable();
if (invokeRunnable(runnable)) {
setReturnCode(OK);
} else {
setReturnCode(CANCEL);
}
}
close();
}
private boolean invokeRunnable(IRunnableWithProgress runnable) {
IRunnableWithProgress op= new WorkspaceModifyDelegatingOperation(runnable);
try {
getWizard().getContainer().run(false, true, op);
} catch (InvocationTargetException e) {
Shell shell= getShell();
String title= NewWizardMessages.getString("NewSourceFolderCreationWizardPage.op_error.title");
String message= NewWizardMessages.getString("NewSourceFolderCreationWizardPage.op_error.message");
ExceptionHandler.handle(e, shell, title, message);
return false;
} catch (InterruptedException e) {
return false;
}
return true;
}
}
private boolean showClassPathPropertyPage() {
EditClassPathDialog dialog= new EditClassPathDialog(getShell());
dialog.setTitle(NewWizardMessages.getString("NewSourceFolderCreationWizardPage.EditClassPathDialog.title")); |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/NewSourceFolderCreationWizardPage.java | return (dialog.open() == EditClassPathDialog.OK);
}
private IContainer[] getFilteredExistingContainerEntries() {
if (fCurrJProject == null) {
return new IContainer[0];
}
List res= new ArrayList();
try {
IResource container= fWorkspaceRoot.findMember(fCurrJProject.getOutputLocation());
if (container != null) {
res.add(container);
}
} catch (JavaModelException e) {
JavaPlugin.log(e.getStatus());
}
for (int i= 0; i < fEntries.length; i++) {
IClasspathEntry elem= fEntries[i];
if (elem.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
IResource container= fWorkspaceRoot.findMember(elem.getPath());
if (container != null) {
res.add(container);
}
}
}
return (IContainer[]) res.toArray(new IContainer[res.size()]);
}
} |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/TypePage.java | /*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.wizards;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jdt.core.Flags;
import org.eclipse.jdt.core.IBuffer;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject; |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/TypePage.java | import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.ISourceRange;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.ITypeHierarchy;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.Signature;
import org.eclipse.jdt.core.search.IJavaSearchScope;
import org.eclipse.jdt.core.search.SearchEngine;
import org.eclipse.jdt.ui.IJavaElementSearchConstants;
import org.eclipse.jdt.ui.JavaElementLabelProvider;
import org.eclipse.jdt.internal.compiler.env.IConstants;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.JavaPluginImages;
import org.eclipse.jdt.internal.ui.codemanipulation.IImportsStructure;
import org.eclipse.jdt.internal.ui.codemanipulation.ImportsStructure;
import org.eclipse.jdt.internal.ui.codemanipulation.StubUtility;
import org.eclipse.jdt.internal.ui.dialogs.ElementListSelectionDialog;
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.jdt.internal.ui.dialogs.TypeSelectionDialog;
import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
import org.eclipse.jdt.internal.ui.preferences.ImportOrganizePreferencePage;
import org.eclipse.jdt.internal.ui.util.JavaModelUtil;
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.IListAdapter;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IStringButtonAdapter;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.LayoutUtil;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.ListDialogField; |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/TypePage.java | import org.eclipse.jdt.internal.ui.wizards.dialogfields.SelectionButtonDialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.SelectionButtonDialogFieldGroup;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.Separator;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.StringButtonDialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.StringButtonStatusDialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.StringDialogField;
import org.eclipse.jdt.internal.ui.wizards.swt.MGridData;
/**
* <code>TypePage</code> contains controls and validation routines for a 'New Type WizardPage'
* Implementors decide which components to add and to enable. Implementors can also
* customize the validation code.
* <code>TypePage</code> is intended to serve as base class of all wizards that create types.
* Applets, Servlets, Classes, Interfaces...
* See <code>NewClassCreationWizardPage</code> or <code>NewInterfaceCreationWizardPage</code> for an
* example usage of TypePage.
*/
public abstract class TypePage extends ContainerPage {
private final static String PAGE_NAME= "TypePage";
protected final static String PACKAGE= PAGE_NAME + ".package";
protected final static String ENCLOSING= PAGE_NAME + ".enclosing";
protected final static String ENCLOSINGSELECTION= ENCLOSING + ".selection";
protected final static String TYPENAME= PAGE_NAME + ".typename";
protected final static String SUPER= PAGE_NAME + ".superclass";
protected final static String INTERFACES= PAGE_NAME + ".interfaces";
protected final static String MODIFIERS= PAGE_NAME + ".modifiers";
protected final static String METHODS= PAGE_NAME + ".methods";
private class InterfacesListLabelProvider extends LabelProvider { |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/TypePage.java | private Image fInterfaceImage;
public InterfacesListLabelProvider() {
super();
fInterfaceImage= JavaPlugin.getDefault().getImageRegistry().get(JavaPluginImages.IMG_OBJS_INTERFACE);
}
public Image getImage(Object element) {
return fInterfaceImage;
}
}
private StringButtonStatusDialogField fPackageDialogField;
private SelectionButtonDialogField fEnclosingTypeSelection;
private StringButtonDialogField fEnclosingTypeDialogField;
private boolean fCanModifyPackage; |
6,207 | Bug 6207 Java project properties dialog grows taller than screen | build 20011116 The Java Build Path/Order page in the project properties dialog always grows the table to show all items. In a workspace with many source folders the properties dialog grows so tall that you can no longer see the ok/cancel buttons. I noticed this while using WSDD (Eclipse 1.0 based) to create P3ML bundles. P3ML consists of about 20 bundles with each bundle living in a separate source folder. Note that the resize only happens when the dialog is reopened. If you create source folders in the properties dialog and then switch to the order page you will see scroll bars. Also, it seems that this only happens when there is a large number of source folders. When I reference a lot of projects the height of the order page is limited and the table shows scroll bars. | resolved fixed | 1b69a90 | JDT | https://github.com/eclipse-jdt/eclipse.jdt.ui | eclipse-jdt/eclipse.jdt.ui | java | null | null | null | "2001-11-23T15:07:47Z" | "2001-11-21T22:00:00Z" | org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/wizards/TypePage.java | private boolean fCanModifyEnclosingType;
private IPackageFragment fCurrPackage;
private IType fCurrEnclosingType;
private StringDialogField fTypeNameDialogField;
private StringButtonDialogField fSuperClassDialogField;
private ListDialogField fSuperInterfacesDialogField;
private IType fSuperClass;
private SelectionButtonDialogFieldGroup fAccMdfButtons;
private SelectionButtonDialogFieldGroup fOtherMdfButtons;
private IType fCreatedType;
protected IStatus fEnclosingTypeStatus;
protected IStatus fPackageStatus;
protected IStatus fTypeNameStatus;
protected IStatus fSuperClassStatus;
protected IStatus fModifierStatus;
protected IStatus fSuperInterfacesStatus;
private boolean fIsClass;
private int fStaticMdfIndex;
private final int PUBLIC_INDEX= 0, DEFAULT_INDEX= 1, PRIVATE_INDEX= 2, PROTECTED_INDEX= 3;
private final int ABSTRACT_INDEX= 0, FINAL_INDEX= 1; |