issue_id
int64 2.04k
425k
| title
stringlengths 9
251
| body
stringlengths 4
32.8k
⌀ | status
stringclasses 6
values | after_fix_sha
stringlengths 7
7
| project_name
stringclasses 6
values | repo_url
stringclasses 6
values | repo_name
stringclasses 6
values | language
stringclasses 1
value | issue_url
null | before_fix_sha
null | pull_url
null | commit_datetime
timestamp[us, tz=UTC] | report_datetime
timestamp[us, tz=UTC] | updated_file
stringlengths 23
187
| chunk_content
stringlengths 1
22k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocOptionsManager.java
|
}
public void setSourcepath(String sourcepath) {
this.fSourcepath= sourcepath;
}
public void setSourceElements(IJavaElement[] elements) {
this.fSourceElements= new ArrayList(Arrays.asList(elements));
}
public void setRoot(IWorkspaceRoot root) {
this.fRoot= root;
}
public void setProject(IJavaProject project) {
this.fProject= project;
}
public void setFromStandard(boolean fromStandard) {
this.fFromStandard= fromStandard;
}
public void setTitle(String title) {
this.fTitle= title;
}
public void setLinks(IJavaProject project, String hrefs) {
ProjectData data= (ProjectData)fLinks.get(project);
data.setlinks(hrefs);
}
public void setBoolean(String flag, boolean value) {
if (flag.equals(AUTHOR))
this.fAuthor= value;
else if(flag.equals(USE))
this.fUse= value;
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocOptionsManager.java
|
else if (flag.equals(VERSION))
this.fVersion= value;
else if (flag.equals(NODEPRECATED))
this.fNodeprecated= value;
else if (flag.equals(NODEPRECATEDLIST))
this.fNoDeprecatedlist= value;
else if (flag.equals(NOINDEX))
this.fNoindex= value;
else if (flag.equals(NOTREE))
this.fNotree= value;
else if (flag.equals(SPLITINDEX))
this.fSplitindex= value;
else if (flag.equals(NONAVBAR))
this.fNonavbar= value;
}
private List getValidSelection(ISelection currentSelection) {
fProject = null;
ArrayList res= new ArrayList();
if (currentSelection instanceof IStructuredSelection) {
IStructuredSelection structuredSelection= (IStructuredSelection) currentSelection;
if (structuredSelection.isEmpty()) {
currentSelection= JavaPlugin.getActiveWorkbenchWindow().getSelectionService().getSelection();
if (currentSelection instanceof IStructuredSelection)
structuredSelection= (IStructuredSelection) currentSelection;
}
Iterator iter= structuredSelection.iterator();
getProject(res, iter);
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocOptionsManager.java
|
}
return res;
}
private void getProject(List selectedElements, Iterator iter) {
fProject = null;
while (iter.hasNext()) {
Object selectedElement = iter.next();
IJavaElement elem = getSelectableJavaElement(selectedElement);
if (elem != null) {
IJavaProject jproj = elem.getJavaProject();
if (jproj != null) {
if (fProject == null){
fProject = jproj;
selectedElements.add(elem);
} else if (fProject.equals(jproj)) {
selectedElements.add(elem); }
}
}
}
if (fProject == null) {
Object[] roots= fRoot.getProjects();
for (int i= 0; i < roots.length; i++) {
IProject p= (IProject) roots[i];
IJavaProject iJavaProject= JavaCore.create(p);
if (getValidProject(iJavaProject)) {
fProject= iJavaProject;
break;
}
}
}
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocOptionsManager.java
|
}
private IJavaElement getSelectableJavaElement(Object obj) {
IJavaElement je= null;
try {
if (obj instanceof IAdaptable) {
je= (IJavaElement) ((IAdaptable) obj).getAdapter(IJavaElement.class);
}
if (je == null) {
return null;
}
switch (je.getElementType()) {
case IJavaElement.JAVA_MODEL :
case IJavaElement.JAVA_PROJECT :
case IJavaElement.CLASS_FILE :
break;
case IJavaElement.PACKAGE_FRAGMENT_ROOT :
if (containsCompilationUnits((IPackageFragmentRoot) je)) {
return je;
}
break;
case IJavaElement.PACKAGE_FRAGMENT :
if (containsCompilationUnits((IPackageFragment) je)) {
return je;
}
break;
default :
ICompilationUnit cu= (ICompilationUnit) je.getAncestor(IJavaElement.COMPILATION_UNIT);
if (cu != null) {
if (cu.isWorkingCopy()) {
cu= (ICompilationUnit) cu.getOriginalElement();
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocOptionsManager.java
|
}
return cu;
}
}
} catch (JavaModelException e) {
JavaPlugin.log(e);
}
IJavaProject project= je.getJavaProject();
if (getValidProject(project))
return project;
else
return null;
}
private boolean getValidProject(IJavaProject project) {
if (project != null) {
try {
IPackageFragmentRoot[] roots= project.getPackageFragmentRoots();
for (int i= 0; i < roots.length; i++) {
if (containsCompilationUnits(roots[i])) {
return true;
}
}
} catch (JavaModelException e) {
JavaPlugin.log(e);
}
}
return false;
}
private boolean containsCompilationUnits(IPackageFragmentRoot root) throws JavaModelException {
if (root.getKind() != IPackageFragmentRoot.K_SOURCE) {
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocOptionsManager.java
|
return false;
}
IJavaElement[] elements= root.getChildren();
for (int i= 0; i < elements.length; i++) {
if (elements[i] instanceof IPackageFragment) {
IPackageFragment fragment= (IPackageFragment) elements[i];
if (containsCompilationUnits(fragment)) {
return true;
}
}
}
return false;
}
private boolean containsCompilationUnits(IPackageFragment pack) throws JavaModelException {
return pack.getCompilationUnits().length > 0;
}
private class ProjectData {
private IJavaProject dataProject;
private String dataHrefs;
private String dataDestdir;
private String dataAntPath;
ProjectData(IJavaProject project) {
dataProject= project;
}
public void setlinks(String hrefs) {
if(hrefs==null)
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocOptionsManager.java
|
dataHrefs="";
else dataHrefs= hrefs;
}
public void setDestination(String destination) {
if(destination==null)
dataDestdir="";
else dataDestdir= destination;
}
public void setAntpath(String antpath) {
if(antpath==null)
dataAntPath= "";
else dataAntPath= antpath;
}
public String getlinks() {
return dataHrefs;
}
public String getDestination() {
return dataDestdir;
}
public String getAntPath() {
return dataAntPath;
}
}
}
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocProjectContentProvider.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.javadocexport;
import java.util.ArrayList;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.ui.JavaPlugin;
public class JavadocProjectContentProvider implements ITreeContentProvider {
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocProjectContentProvider.java
|
/*
* @see ITreeContentProvider#getChildren(Object)
*/
public Object[] getChildren(Object parentElement) {
try {
if (parentElement instanceof IJavaProject) {
IJavaProject project= (IJavaProject) parentElement;
return getPackageFragmentRoots(project);
} else if (parentElement instanceof IPackageFragmentRoot) {
return getPackageFragments((IPackageFragmentRoot) parentElement);
}
} catch (JavaModelException e) {
JavaPlugin.log(e);
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocProjectContentProvider.java
|
}
return new Object[0];
}
/*
* @see IStructuredContentProvider#getElements(Object)
*/
public Object[] getElements(Object inputElement) {
if (inputElement instanceof IWorkspaceRoot) {
ArrayList list= new ArrayList();
try {
IJavaProject[] jprojects= JavaCore.create((IWorkspaceRoot) inputElement).getJavaProjects();
for (int i= 0; i < jprojects.length; i++) {
IJavaProject javaProject= jprojects[i];
IPackageFragment[] els= javaProject.getPackageFragments();
for (int j= 0; j < els.length; j++) {
IPackageFragment iPackageFragment= (IPackageFragment) els[j];
if (iPackageFragment.getCompilationUnits().length > 0) {
list.add(javaProject);
break;
}
}
}
} catch (JavaModelException e) {
JavaPlugin.log(e);
}
return list.toArray();
}
return new Object[0];
}
/*
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocProjectContentProvider.java
|
* @see ITreeContentProvider#getParent(Object)
*/
public Object getParent(Object element) {
IJavaElement parent= ((IJavaElement)element).getParent();
if (parent instanceof IPackageFragmentRoot) {
IPackageFragmentRoot root= (IPackageFragmentRoot) parent;
if (root.getPath().equals(root.getJavaProject().getProject().getFullPath())) {
return root.getJavaProject();
}
}
return parent;
}
/*
* @see ITreeContentProvider#hasChildren(Object)
*/
public boolean hasChildren(Object element) {
try {
if (element instanceof IPackageFragment)
return (((IPackageFragment) element).getChildren().length > 0);
else
return (getChildren(element).length > 0);
} catch (JavaModelException e) {
}
return false;
}
/*
* @see IContentProvider#dispose()
*/
public void dispose() {
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocProjectContentProvider.java
|
}
/*
* @see IContentProvider#inputChanged(Viewer, Object, Object)
*/
public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
}
private Object[] getPackageFragmentRoots(IJavaProject project) throws JavaModelException {
ArrayList result= new ArrayList();
IPackageFragmentRoot[] roots= project.getPackageFragmentRoots();
for (int i= 0; i < roots.length; i++) {
IPackageFragmentRoot root= roots[i];
if (root.getKind() == IPackageFragmentRoot.K_SOURCE) {
if (root.getPath().equals(root.getJavaProject().getProject().getFullPath())) {
return getPackageFragments(root);
}
result.add(root);
}
}
return result.toArray();
}
private Object[] getPackageFragments(IPackageFragmentRoot root) throws JavaModelException {
ArrayList packageFragments= new ArrayList();
IJavaElement[] children= root.getChildren();
for (int i= 0; i < children.length; i++) {
if (((IPackageFragment) children[i]).containsJavaResources())
packageFragments.add(children[i]);
}
return packageFragments.toArray();
}
}
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocSpecificsWizardPage.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.javadocexport;
import java.io.File;
import java.util.ArrayList;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.eclipse.jface.dialogs.ControlEnableState;
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.jdt.internal.ui.dialogs.StatusUtil;
import org.eclipse.jdt.internal.ui.javadocexport.JavadocWizardPage.ToggleSelectionAdapter;
import org.eclipse.jdt.internal.ui.util.SWTUtil;
public class JavadocSpecificsWizardPage extends JavadocWizardPage {
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocSpecificsWizardPage.java
|
protected Button fAntBrowseButton;
private Button fCheckbrowser;
protected Text fAntText;
protected Button fOverViewButton;
private Button fOverViewBrowseButton;
protected Button fAntButton;
private Composite fLowerComposite;
private Label fSeparator;
protected Text fOverViewText;
protected Text fExtraOptionsText;
private StatusInfo fOverviewStatus;
private StatusInfo fAntStatus;
private ControlEnableState fControlEnableState;
private JavadocOptionsManager fStore;
private JavadocWizard fWizard;
private String fDialogSectionName;
private final int OVERVIEWSTATUS=1;
private final int ANTSTATUS= 2;
/**
* Constructor for JavadocWizardPage.
* @param pageName
*/
protected JavadocSpecificsWizardPage(String pageName, JavadocOptionsManager store) {
super(pageName);
setDescription(JavadocExportMessages.getString("JavadocSpecificsWizardPage.description"));
fStore= store;
fOverviewStatus= new StatusInfo();
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocSpecificsWizardPage.java
|
fAntStatus= new StatusInfo();
}
/*
* @see IDialogPage#createControl(Composite)
*/
public void createControl(Composite parent) {
fWizard= (JavadocWizard)this.getWizard();
fLowerComposite= new Composite(parent, SWT.NONE);
fLowerComposite.setLayoutData(createGridData(GridData.FILL_BOTH, 1, 0));
GridLayout layout= createGridLayout(3);
layout.marginHeight= 0;
fLowerComposite.setLayout(layout);
createExtraOptionsGroup(fLowerComposite);
createAntGroup(fLowerComposite);
setControl(fLowerComposite);
}
private void createExtraOptionsGroup(Composite composite) {
Composite c= new Composite(composite, SWT.NONE);
c.setLayout(createGridLayout(3));
c.setLayoutData(createGridData(GridData.FILL_HORIZONTAL, 3, 0));
((GridLayout) c.getLayout()).marginWidth= 0;
fOverViewButton= createButton(c, SWT.CHECK, JavadocExportMessages.getString("JavadocSpecificsWizardPage.overviewbutton.label"), createGridData(1));
fOverViewText= createText(c, SWT.SINGLE | SWT.BORDER , null, createGridData(GridData.FILL_HORIZONTAL, 1, 0));
((GridData) fOverViewText.getLayoutData()).widthHint = 200;
fOverViewBrowseButton= createButton(c, SWT.PUSH, JavadocExportMessages.getString("JavadocSpecificsWizardPage.overviewbrowse.label"), createGridData(GridData.HORIZONTAL_ALIGN_END, 1, 0));
SWTUtil.setButtonDimensionHint(fOverViewBrowseButton);
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocSpecificsWizardPage.java
|
String str= fStore.getOverview();
if (str.equals("")) {
fOverViewText.setEnabled(false);
fOverViewBrowseButton.setEnabled(false);
} else {
fOverViewButton.setSelection(true);
fOverViewText.setText(str);
}
Label jdocLocationLabel= createLabel(composite, SWT.NONE, JavadocExportMessages.getString("JavadocSpecificsWizardPage.extraoptionsfield.label"), createGridData(GridData.HORIZONTAL_ALIGN_BEGINNING, 3, 0));
fExtraOptionsText= createText(composite, SWT.MULTI | SWT.BORDER | SWT.WRAP | SWT.H_SCROLL | SWT.V_SCROLL, null, createGridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.FILL_VERTICAL, 3, 0));
str= fStore.getAdditionalParams();
fExtraOptionsText.setText(str);
fOverViewButton.addSelectionListener(new ToggleSelectionAdapter(new Control[] { fOverViewBrowseButton, fOverViewText }) {
public void validate() {
doValidation(OVERVIEWSTATUS);
}
});
fOverViewText.addModifyListener(new ModifyListener() {
public void modifyText(ModifyEvent e) {
doValidation(OVERVIEWSTATUS);
}
});
fOverViewBrowseButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent event) {
handleFileBrowseButtonPressed(fOverViewText, new String[] { "*.html" }, JavadocExportMessages.getString("JavadocSpecificsWizardPage.overviewbrowsedialog.title"));
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocSpecificsWizardPage.java
|
}
});
}
private void createAntGroup(Composite composite) {
Composite c= new Composite(composite, SWT.NONE);
c.setLayout(createGridLayout(3));
c.setLayoutData(createGridData(GridData.FILL_HORIZONTAL, 3, 0));
((GridLayout) c.getLayout()).marginWidth= 0;
fAntButton= createButton(c, SWT.CHECK, JavadocExportMessages.getString("JavadocSpecificsWizardPage.antscriptbutton.label"), createGridData(3));
Label AntLabel= createLabel(c, SWT.NONE, JavadocExportMessages.getString("JavadocSpecificsWizardPage.antscripttext.label"), createGridData(GridData.HORIZONTAL_ALIGN_BEGINNING, 1, 0));
fAntText= createText(c, SWT.SINGLE | SWT.BORDER, null, createGridData(GridData.FILL_HORIZONTAL, 1, 0));
((GridData) fAntText.getLayoutData()).widthHint = 200;
fAntText.setText(fStore.getAntpath(fWizard.getProject()));
fAntText.setEnabled(false);
fAntBrowseButton= createButton(c, SWT.PUSH, JavadocExportMessages.getString("JavadocSpecificsWizardPage.antscriptbrowse.label"), createGridData(GridData.HORIZONTAL_ALIGN_END, 1, 0));
SWTUtil.setButtonDimensionHint(fAntBrowseButton);
fAntBrowseButton.setEnabled(false);
fCheckbrowser= createButton(c, SWT.CHECK, JavadocExportMessages.getString("JavadocSpecificsWizardPage.openbrowserbutton.label"), createGridData(3));
fAntButton.addSelectionListener(new ToggleSelectionAdapter(new Control[] { fAntText, fAntBrowseButton }) {
public void validate() {
doValidation(ANTSTATUS);
}
});
fAntText.addModifyListener(new ModifyListener() {
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocSpecificsWizardPage.java
|
public void modifyText(ModifyEvent e) {
doValidation(ANTSTATUS);
}
});
fAntBrowseButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent event) {
String temp= fAntText.getText();
IPath path= new Path(temp);
String file= path.lastSegment();
path= path.removeLastSegments(1);
temp= handleFolderBrowseButtonPressed(path.toOSString(),fAntText.getShell(), JavadocExportMessages.getString("JavadocSpecificsWizardPage.antscriptbrowsedialog.title"), JavadocExportMessages.getString("JavadocSpecificsWizardPage.antscriptbrowsedialog.label"));
path= new Path(temp);
path= path.addTrailingSeparator().append(file);
fAntText.setText(path.toOSString());
}
});
}
private void doValidation(int VALIDATE) {
File file= null;
String ext= null;
Path path= null;
switch (VALIDATE) {
case OVERVIEWSTATUS :
fOverviewStatus = new StatusInfo();
if (fOverViewButton.getSelection()) {
path = new Path(fOverViewText.getText());
file = path.toFile();
ext = path.getFileExtension();
if ((file == null) || !file.exists()) {
fOverviewStatus.setError(JavadocExportMessages.getString("JavadocSpecificsWizardPage.overviewnotfound.error"));
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocSpecificsWizardPage.java
|
} else if ((ext == null) || !ext.equalsIgnoreCase("html")) {
fOverviewStatus.setError(JavadocExportMessages.getString("JavadocSpecificsWizardPage.overviewincorrect.error"));
}
}
break;
case ANTSTATUS :
fAntStatus = new StatusInfo();
if (fAntButton.getSelection()) {
path = new Path(fAntText.getText());
ext = path.getFileExtension();
IPath antSeg = path.removeLastSegments(1);
if ((!antSeg.isValidPath(antSeg.toOSString()))
|| (ext == null)
|| !(ext.equalsIgnoreCase("xml")))
fAntStatus.setError(JavadocExportMessages.getString("JavadocSpecificsWizardPage.antfileincorrect.error"));
else if (path.toFile().exists())
fAntStatus.setWarning(JavadocExportMessages.getString("JavadocSpecificsWizardPage.antfileoverwrite.warning"));
}
break;
}
updateStatus(findMostSevereStatus());
}
/*
* @see JavadocWizardPage#onFinish()
*/
protected void finish() {
String str= fExtraOptionsText.getText();
if (str.length() > 0)
fStore.setAdditionalParams(str);
else fStore.setAdditionalParams("");
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocSpecificsWizardPage.java
|
if (fOverViewText.getEnabled())
fStore.setOverview(fOverViewText.getText());
else fStore.setOverview("");
if (fAntText.getEnabled())
fStore.setAntpath(fWizard.getProject(), fAntText.getText());
else fStore.setAntpath(fWizard.getProject(), "");
}
public void setVisible(boolean visible) {
super.setVisible(visible);
if (visible) {
doValidation(OVERVIEWSTATUS);
doValidation(ANTSTATUS);
}
}
public void init() {
updateStatus(new StatusInfo());
}
private IStatus findMostSevereStatus() {
return StatusUtil.getMostSevere(new IStatus[] { fAntStatus, fOverviewStatus});
}
public boolean generateAnt() {
return fAntButton.getSelection();
}
public boolean openInBrowser() {
return fCheckbrowser.getSelection();
}
}
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocStandardWizardPage.java
|
package org.eclipse.jdt.internal.ui.javadocexport;
import java.io.File;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
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.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocStandardWizardPage.java
|
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.jface.viewers.StructuredSelection;
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.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.corext.javadoc.JavaDocLocations;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.dialogs.StatusDialog;
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.jdt.internal.ui.dialogs.StatusUtil;
import org.eclipse.jdt.internal.ui.javadocexport.JavadocWizardPage.ToggleSelectionAdapter;
import org.eclipse.jdt.internal.ui.preferences.JavadocConfigurationBlock;
import org.eclipse.jdt.internal.ui.util.SWTUtil;
import org.eclipse.jdt.internal.ui.wizards.IStatusChangeListener;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.CheckedListDialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.DialogField;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.IListAdapter;
import org.eclipse.jdt.internal.ui.wizards.dialogfields.LayoutUtil;
public class JavadocStandardWizardPage extends JavadocWizardPage {
private JavadocOptionsManager fStore;
private JavadocWizard fWizard;
private Composite fUpperComposite;
private Group fBasicOptionsGroup;
private Group fTagsGroup;
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocStandardWizardPage.java
|
private Button fTitleButton;
private Text fTitleText;
protected Text fStyleSheetText;
protected FlaggedButton fDeprecatedList;
protected FlaggedButton fAuthorCheck;
protected FlaggedButton fVersionCheck;
protected FlaggedButton fDeprecatedCheck;
protected FlaggedButton fHierarchyCheck;
protected FlaggedButton fNavigatorCheck;
protected FlaggedButton fIndexCheck;
protected FlaggedButton fSeperatedIndexCheck;
protected FlaggedButton fUse;
protected Button fStyleSheetBrowseButton;
protected Button fStyleSheetButton;
private CheckedListDialogField fListDialogField;
private IJavaProject lastProject;
private final int STYLESHEETSTATUS= 0;
private StatusInfo fStyleSheetStatus;
protected ArrayList fButtonsList;
private Map fTempLinks;
public JavadocStandardWizardPage(String pageName, JavadocOptionsManager store) {
super(pageName);
setDescription(JavadocExportMessages.getString("JavadcoStandardWizardPage.description"));
fStore= store;
fButtonsList= new ArrayList();
fStyleSheetStatus= new StatusInfo();
}
/*
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocStandardWizardPage.java
|
* @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
*/
public void createControl(Composite parent) {
initializeDialogUnits(parent);
lastProject= null;
fWizard= (JavadocWizard)this.getWizard();
fUpperComposite= new Composite(parent, SWT.NONE);
fUpperComposite.setLayoutData(createGridData(GridData.FILL_VERTICAL | GridData.FILL_HORIZONTAL, 1, 0));
GridLayout layout= createGridLayout(4);
layout.marginHeight= 0;
fUpperComposite.setLayout(layout);
createBasicOptionsGroup(fUpperComposite);
createTagOptionsGroup(fUpperComposite);
createListDialgField(fUpperComposite);
createStyleSheetGroup(fUpperComposite);
setControl(fUpperComposite);
}
private void createBasicOptionsGroup(Composite composite) {
fTitleButton= createButton(composite, SWT.CHECK, JavadocExportMessages.getString("JavadcoStandardWizardPage.titlebutton.label"), createGridData(1));
fTitleText= createText(composite, SWT.SINGLE | SWT.BORDER, null, createGridData(GridData.FILL_HORIZONTAL, 3, 0));
String text= fStore.getTitle();
if(!text.equals("")) {
fTitleText.setText(text);
fTitleButton.setSelection(true);
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocStandardWizardPage.java
|
} else fTitleText.setEnabled(false);
fBasicOptionsGroup= new Group(composite, SWT.SHADOW_ETCHED_IN);
fBasicOptionsGroup.setLayout(createGridLayout(1));
fBasicOptionsGroup.setLayoutData(createGridData(GridData.FILL_HORIZONTAL | GridData.FILL_VERTICAL, 2, 0));
fBasicOptionsGroup.setText(JavadocExportMessages.getString("JavadcoStandardWizardPage.basicgroup.label"));
fUse= new FlaggedButton(fBasicOptionsGroup, JavadocExportMessages.getString("JavadcoStandardWizardPage.usebutton.label"), new GridData(GridData.FILL_HORIZONTAL), fStore.USE, true);
fHierarchyCheck= new FlaggedButton(fBasicOptionsGroup, JavadocExportMessages.getString("JavadcoStandardWizardPage.hierarchybutton.label"), new GridData(GridData.FILL_HORIZONTAL), fStore.NOTREE, false);
fNavigatorCheck= new FlaggedButton(fBasicOptionsGroup, JavadocExportMessages.getString("JavadcoStandardWizardPage.navigartorbutton.label"), new GridData(GridData.FILL_HORIZONTAL), fStore.NONAVBAR, false);
fIndexCheck= new FlaggedButton(fBasicOptionsGroup, JavadocExportMessages.getString("JavadcoStandardWizardPage.indexbutton.label"), new GridData(GridData.FILL_HORIZONTAL), fStore.NOINDEX, false);
fSeperatedIndexCheck= new FlaggedButton(fBasicOptionsGroup, JavadocExportMessages.getString("JavadcoStandardWizardPage.seperateindexbutton.label"), createGridData(GridData.GRAB_HORIZONTAL, 1, convertWidthInCharsToPixels(3)), fStore.SPLITINDEX, true);
fSeperatedIndexCheck.getButton().setEnabled(fIndexCheck.getButton().getSelection());
fIndexCheck.getButton().addSelectionListener(new ToggleSelectionAdapter(new Control[] { fSeperatedIndexCheck.getButton()}) {
public void validate() {
}
});
fTitleButton.addSelectionListener(new ToggleSelectionAdapter(new Control[] { fTitleText}) {
public void validate() {
}
});
}
private void createTagOptionsGroup(Composite composite) {
fTagsGroup= new Group(composite, SWT.SHADOW_ETCHED_IN);
fTagsGroup.setLayout(createGridLayout(1));
fTagsGroup.setLayoutData(createGridData(GridData.FILL_HORIZONTAL | GridData.FILL_VERTICAL, 2, 0));
fTagsGroup.setText(JavadocExportMessages.getString("JavadcoStandardWizardPage.tagsgroup.label"));
fAuthorCheck= new FlaggedButton(fTagsGroup, JavadocExportMessages.getString("JavadcoStandardWizardPage.authorbutton.label"), new GridData(GridData.FILL_HORIZONTAL), fStore.AUTHOR, true);
fVersionCheck= new FlaggedButton(fTagsGroup, JavadocExportMessages.getString("JavadcoStandardWizardPage.versionbutton.label"), new GridData(GridData.FILL_HORIZONTAL), fStore.VERSION, true);
fDeprecatedCheck= new FlaggedButton(fTagsGroup, JavadocExportMessages.getString("JavadcoStandardWizardPage.deprecatedbutton.label"), new GridData(GridData.FILL_HORIZONTAL), fStore.NODEPRECATED, false);
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocStandardWizardPage.java
|
fDeprecatedList= new FlaggedButton(fTagsGroup, JavadocExportMessages.getString("JavadcoStandardWizardPage.deprecatedlistbutton.label"), createGridData(GridData.FILL_HORIZONTAL, 1, convertWidthInCharsToPixels(3)), fStore.NODEPRECATEDLIST, false);
fDeprecatedList.getButton().setEnabled(fDeprecatedCheck.getButton().getSelection());
fDeprecatedCheck.getButton().addSelectionListener(new ToggleSelectionAdapter(new Control[] { fDeprecatedList.getButton()}) {
public void validate() {
}
});
}
private void createStyleSheetGroup(Composite composite) {
Composite c= new Composite(composite, SWT.NONE);
c.setLayout(createGridLayout(3));
c.setLayoutData(createGridData(GridData.FILL_HORIZONTAL, 4, 0));
((GridLayout) c.getLayout()).marginWidth= 0;
fStyleSheetButton= createButton(c, SWT.CHECK, JavadocExportMessages.getString("JavadcoStandardWizardPage.stylesheettext.label"), createGridData(1));
fStyleSheetText= createText(c, SWT.SINGLE | SWT.BORDER, null, createGridData(GridData.FILL_HORIZONTAL, 1, 0));
((GridData) fStyleSheetText.getLayoutData()).widthHint = 200;
fStyleSheetBrowseButton= createButton(c, SWT.PUSH, JavadocExportMessages.getString("JavadocStandardWizardPage.stylesheetbrowsebutton.label"), createGridData(GridData.HORIZONTAL_ALIGN_END, 1, 0));
SWTUtil.setButtonDimensionHint(fStyleSheetBrowseButton);
String str= fStore.getStyleSheet();
if (str.equals("")) {
fStyleSheetText.setEnabled(false);
fStyleSheetBrowseButton.setEnabled(false);
} else {
fStyleSheetButton.setSelection(true);
fStyleSheetText.setText(str);
}
fStyleSheetButton.addSelectionListener(new ToggleSelectionAdapter(new Control[] { fStyleSheetText, fStyleSheetBrowseButton }) {
public void validate() {
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocStandardWizardPage.java
|
doValidation(STYLESHEETSTATUS);
}
});
fStyleSheetText.addModifyListener(new ModifyListener() {
public void modifyText(ModifyEvent e) {
doValidation(STYLESHEETSTATUS);
}
});
fStyleSheetBrowseButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent event) {
handleFileBrowseButtonPressed(fStyleSheetText, new String[] { "*.css" }, JavadocExportMessages.getString("JavadocSpecificsWizardPage.stylesheetbrowsedialog.title"));
}
});
}
private void createListDialgField(Composite composite) {
Composite c= new Composite(composite, SWT.NONE);
c.setLayout(createGridLayout(3));
c.setLayoutData(createGridData(GridData.FILL_HORIZONTAL | GridData.FILL_VERTICAL, 4, 0));
((GridLayout) c.getLayout()).marginWidth= 0;
String[] buttonlabels= new String[] {JavadocExportMessages.getString("JavadcoStandardWizardPage.selectallbutton.label") , JavadocExportMessages.getString("JavadcoStandardWizardPage.clearallbutton.label"), JavadocExportMessages.getString("JavadocStandardWizardPage.configurebutton.label")};
JavadocLinkDialogLabelProvider labelProvider= new JavadocLinkDialogLabelProvider();
fListDialogField= new CheckedListDialogField(new ListAdapter(), buttonlabels, labelProvider);
fListDialogField.setCheckAllButtonIndex(0);
fListDialogField.setUncheckAllButtonIndex(1);
Label listlabel= createLabel(c, SWT.NONE, JavadocExportMessages.getString("JavadcoStandardWizardPage.referencedclasses.label"), createGridData(GridData.HORIZONTAL_ALIGN_BEGINNING, 4, 0));
fListDialogField.doFillIntoGrid(c, 3);
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocStandardWizardPage.java
|
LayoutUtil.setHorizontalGrabbing(fListDialogField.getListControl(null));
fListDialogField.enableButton(2, false);
fTempLinks= createTempLinksStore();
UpdateCheckedListGroup();
}
private Map createTempLinksStore() {
Map temp= new HashMap();
IProject[] projects= fStore.getRoot().getProjects();
for (int i = 0; i < projects.length; i++) {
IProject iProject = projects[i];
IJavaProject javaProject= JavaCore.create(iProject);
if(javaProject!= null) {
String links= fStore.getLinks(javaProject);
temp.put(javaProject, links);
}
}
return temp;
}
private void checkListDialogFieldElements(List referencedClasses) {
List checkedElements= new ArrayList();
String hrefs= (String)fTempLinks.get(fWizard.getProject());
URL url= null;
if(!hrefs.equals("")) {
for (Iterator iterator = referencedClasses.iterator(); iterator.hasNext();) {
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocStandardWizardPage.java
|
IJavaElement element = (IJavaElement) iterator.next();
try {
url= JavaDocLocations.getJavadocBaseLocation(element);
} catch(JavaModelException e) {
JavaPlugin.log(e);
continue;
}
StringTokenizer tokenizer = new StringTokenizer(hrefs, ";");
while(tokenizer.hasMoreElements()) {
String href = (String)tokenizer.nextElement();
if((url!=null) && href.equals(url.toExternalForm())) {
checkedElements.add(element);
break;
}
}
}
}
fListDialogField.setCheckedElements(checkedElements);
}
private void getElements(List referencedClasses, IJavaProject jproject, List visited) throws JavaModelException {
boolean sourceFolderFound= false;
if (visited.contains(jproject)) {
return;
}
visited.add(jproject);
IClasspathEntry[] entries= jproject.getResolvedClasspath(true);
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocStandardWizardPage.java
|
for (int i= 0; i < entries.length; i++) {
IClasspathEntry curr= entries[i];
switch (curr.getEntryKind()) {
case IClasspathEntry.CPE_LIBRARY:
IPackageFragmentRoot el = jproject.getPackageFragmentRoot(curr.getPath().toOSString());
if(el != null) {
if (!referencedClasses.contains(el)) {
referencedClasses.add(el);
}
}
break;
case IClasspathEntry.CPE_PROJECT:
IProject reqProject= (IProject)fStore.getRoot().findMember(curr.getPath().lastSegment());
IJavaProject javaProject = JavaCore.create(reqProject);
if (javaProject != null && javaProject.getProject().isOpen()) {
getElements(referencedClasses, javaProject, visited);
}
break;
case IClasspathEntry.CPE_SOURCE:
if (!sourceFolderFound) {
IPath outputLocation= jproject.getOutputLocation();
IResource resource= fStore.getRoot().findMember(outputLocation);
if (resource != null) {
IJavaElement javaElement= JavaCore.create(resource);
if((javaElement!= null) && (!javaElement.equals(fWizard.getProject()))) {
URL url= JavaDocLocations.getJavadocBaseLocation(javaElement);
if(url != null)
referencedClasses.add(javaElement);
}
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocStandardWizardPage.java
|
}
sourceFolderFound= true;
}
break;
}
}
}
private void doValidation(int VALIDATE) {
File file= null;
String ext= null;
Path path= null;
switch (VALIDATE) {
case STYLESHEETSTATUS :
fStyleSheetStatus = new StatusInfo();
if (fStyleSheetButton.getSelection()) {
path = new Path(fStyleSheetText.getText());
file = new File(fStyleSheetText.getText());
ext = path.getFileExtension();
if ((file == null) || !file.exists()) {
fStyleSheetStatus.setError(JavadocExportMessages.getString("JavadcoStandardWizardPage.stylesheetnopath.error"));
} else if ((ext == null) || !ext.equalsIgnoreCase("css")) {
fStyleSheetStatus.setError(JavadocExportMessages.getString("JavadcoStandardWizardPage.stylesheetnotcss.error"));
}
}
break;
}
updateStatus(findMostSevereStatus());
}
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocStandardWizardPage.java
|
private IStatus findMostSevereStatus() {
return StatusUtil.getMostSevere(new IStatus[] { fStyleSheetStatus});
}
protected void finish() {
if (fTitleButton.getSelection())
fStore.setTitle(fTitleText.getText());
else
fStore.setTitle("");
if (true) {
Object[] buttons = fButtonsList.toArray();
for (int i = 0; i < buttons.length; i++) {
FlaggedButton button = (FlaggedButton) buttons[i];
if (button.getButton().getEnabled())
fStore.setBoolean(
button.getFlag(),
!(button.getButton().getSelection() ^ button.show()));
else
fStore.setBoolean(button.getFlag(), false == button.show());
}
}
if (fStyleSheetText.getEnabled())
fStore.setStyleSheet(fStyleSheetText.getText());
else
fStore.setStyleSheet("");
String hrefs = makeHrefString();
fStore.setLinks(fWizard.getProject(), hrefs);
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocStandardWizardPage.java
|
}
protected String makeHrefString() {
boolean firstTime= true;
StringBuffer buf= new StringBuffer();
List els = fListDialogField.getCheckedElements();
URL url = null;
for (Iterator iterator = els.iterator(); iterator.hasNext();) {
try {
IJavaElement element = (IJavaElement) iterator.next();
url = JavaDocLocations.getJavadocBaseLocation(element);
} catch (JavaModelException e) {
JavaPlugin.log(e);
continue;
}
if (url != null) {
if(firstTime)
firstTime= false;
else buf.append(";");
buf.append(url.toExternalForm());
}
}
return buf.toString();
}
public void setVisible(boolean visible) {
super.setVisible(visible);
if (visible) {
doValidation(STYLESHEETSTATUS);
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocStandardWizardPage.java
|
UpdateCheckedListGroup();
} else {
String hrefs= makeHrefString();
fTempLinks.put(fWizard.getProject(), hrefs);
}
}
public void UpdateCheckedListGroup() {
List referencedClasses = new ArrayList();
List visited = new ArrayList();
try {
IJavaProject currProject = fWizard.getProject();
if (lastProject != currProject) {
lastProject= currProject;
getElements(referencedClasses, currProject, visited);
fListDialogField.removeAllElements();
fListDialogField.addElements(referencedClasses);
checkListDialogFieldElements(referencedClasses);
}
} catch (JavaModelException e) {
JavaPlugin.log(e);
}
}
public void init() {
updateStatus(new StatusInfo());
}
protected class FlaggedButton {
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocStandardWizardPage.java
|
private Button fButton;
private String fFlag;
private boolean fShowFlag;
public FlaggedButton(Composite composite, String message, GridData gridData, String flag, boolean show) {
fFlag= flag;
fShowFlag= show;
fButton= createButton(composite, SWT.CHECK, message, gridData);
fButtonsList.add(this);
setButtonSettings();
}
public Button getButton() {
return fButton;
}
public String getFlag() {
return fFlag;
}
public boolean show() {
return fShowFlag;
}
private void setButtonSettings() {
fButton.setSelection(!(fStore.getBoolean(fFlag) ^ fShowFlag));
}
}
private class ListAdapter implements IListAdapter {
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocStandardWizardPage.java
|
/**
* @see IListAdapter#customButtonPressed(DialogField, int)
*/
public void customButtonPressed(DialogField field, int index) {
if(index == 2)
doEditButtonPressed();
}
/**
* @see IListAdapter#selectionChanged(DialogField)
*/
public void selectionChanged(DialogField field) {
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocStandardWizardPage.java
|
List selection = fListDialogField.getSelectedElements();
if(selection.size() != 1) {
fListDialogField.enableButton(2, false);
} else {
fListDialogField.enableButton(2, true);
}
}
}
/**
* Method doEditButtonPressed.
*/
private void doEditButtonPressed() {
StructuredSelection selection = (StructuredSelection) fListDialogField.getTableViewer().getSelection();
Iterator iter = selection.iterator();
Object obj = selection.getFirstElement();
if (obj instanceof IAdaptable) {
IJavaElement el = (IJavaElement) ((IAdaptable) obj).getAdapter(IJavaElement.class);
JavadocPropertyDialog jdialog = new JavadocPropertyDialog(getShell(), el);
jdialog.open();
}
}
private class JavadocPropertyDialog extends StatusDialog implements IStatusChangeListener {
private JavadocConfigurationBlock fJavadocConfigurationBlock;
private IJavaElement fElement;
public JavadocPropertyDialog(Shell parent, IJavaElement selection) {
super(parent);
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocStandardWizardPage.java
|
setTitle(JavadocExportMessages.getString("JavadocStandardWizardPage.javadocpropertydialog.title"));
fJavadocConfigurationBlock= new JavadocConfigurationBlock( selection, parent , this);
}
protected Control createDialogArea(Composite parent) {
Composite composite= (Composite)super.createDialogArea(parent);
Control inner= fJavadocConfigurationBlock.createContents(composite);
inner.setLayoutData(new GridData(GridData.FILL_BOTH));
return composite;
}
public void statusChanged(IStatus status) {
updateStatus(status);
}
/**
* @see Dialog#okPressed()
*/
protected void okPressed() {
fJavadocConfigurationBlock.performOk();
super.okPressed();
fListDialogField.refresh();
}
}
}
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.javadocexport;
import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionAdapter;
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaModel;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaConventions;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.launching.JavaRuntime;
import org.eclipse.jdt.ui.JavaElementLabelProvider;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.jdt.internal.ui.dialogs.StatusUtil;
import org.eclipse.jdt.internal.ui.jarpackager.CheckboxTreeAndListGroup;
import org.eclipse.jdt.internal.ui.javadocexport.JavadocWizardPage.EnableSelectionAdapter;
import org.eclipse.jdt.internal.ui.preferences.JavadocPreferencePage;
import org.eclipse.jdt.internal.ui.util.SWTUtil;
public class JavadocTreeWizardPage extends JavadocWizardPage {
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
private JavadocProjectContentProvider fProjectContentProvider;
private JavaElementLabelProvider fProjectLabelProvider;
private CheckboxTreeAndListGroup fInputGroup;
protected IWorkspaceRoot fRoot;
protected String fWorkspace;
private final String DOCUMENT_DIRECTORY= "doc";
private File fTempFile;
protected Text fDestinationText;
protected Text fDocletText;
protected Text fDocletTypeText;
protected Button fStandardButton;
protected Button fDestinationBrowserButton;
protected Button fCustomButton;
protected Button fPrivateVisibility;
protected Button fProtectedVisibility;
protected Button fPackageVisibility;
protected Button fPublicVisibility;
private Label fDocletLabel;
private Label fDocletTypeLabel;
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
private Label fDestinationLabel;
private String fDialogSectionName;
protected String fVisibilitySelection;
protected boolean docletselected;
private JavadocOptionsManager fStore;
private JavadocWizard fWizard;
protected StatusInfo fDestinationStatus;
protected StatusInfo fDocletStatus;
protected StatusInfo fTreeStatus;
protected StatusInfo fPreferenceStatus;
protected StatusInfo fWizardStatus;
private final int PREFERENCESTATUS= 0;
private final int CUSTOMSTATUS= 1;
private final int STANDARDSTATUS= 2;
private final int TREESTATUS= 3;
/**
* Constructor for JavadocTreeWizardPage.
* @param pageName
*/
protected JavadocTreeWizardPage(String pageName, JavadocOptionsManager store) {
super(pageName);
setDescription(JavadocExportMessages.getString("JavadocTreeWizardPage.javadoctreewizardpage.description"));
fStore= store;
fDestinationStatus= new StatusInfo();
fDocletStatus= new StatusInfo();
fTreeStatus= new StatusInfo();
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
fPreferenceStatus= new StatusInfo();
fWizardStatus= store.getWizardStatus();
}
/*
* @see IDialogPage#createControl(Composite)
*/
public void createControl(Composite parent) {
initializeDialogUnits(parent);
fWizard = (JavadocWizard)this.getWizard();
Composite composite= new Composite(parent, SWT.NONE);
GridLayout compositeGridLayout= new GridLayout();
composite.setLayoutData(createGridData(GridData.FILL_BOTH, 0, 0));
compositeGridLayout.numColumns= 6;
composite.setLayout(compositeGridLayout);
createInputGroup(composite);
createVisibilitySet(composite);
createOptionsSet(composite);
setControl(composite);
}
protected void createInputGroup(Composite composite) {
Label treeLabel= createLabel(composite, SWT.NONE, JavadocExportMessages.getString("JavadocTreeWizardPage.checkboxtreeandlistgroup.label"), createGridData(6));
Composite c= new Composite(composite, SWT.NONE);
GridLayout layout= new GridLayout();
layout.numColumns= 1;
layout.makeColumnsEqualWidth= true;
c.setLayout(layout);
c.setLayoutData(createGridData(GridData.FILL_BOTH, 6, 0));
ITreeContentProvider treeContentProvider= new JavadocProjectContentProvider();
ITreeContentProvider listContentProvider= new JavadocMemberContentProvider();
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
fInputGroup=
new CheckboxTreeAndListGroup(
c,
fStore.getRoot(),
treeContentProvider,
new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT),
listContentProvider,
new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT),
SWT.NONE,
convertWidthInCharsToPixels(60),
convertHeightInCharsToPixels(10));
fInputGroup.addCheckStateListener(new ICheckStateListener() {
public void checkStateChanged(CheckStateChangedEvent e) {
doValidation(TREESTATUS);
IJavaElement el= null;
Object[] set= fInputGroup.getAllCheckedTreeItems().toArray();
for (int i = 0; i < set.length; i++) {
IJavaElement javaElement = (IJavaElement)set[i];
if(javaElement instanceof IJavaModel)
continue;
else {
el=(IJavaElement) set[i];
break;
}
}
if(el != null)
fWizard.setProject(el.getJavaProject());
}
});
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
try {
setTreeChecked(fStore.getSelectedElements(), fStore.getJavaProject());
} catch(JavaModelException e) {
JavaPlugin.logErrorMessage(e.getMessage());
}
fInputGroup.aboutToOpen();
}
private void createVisibilitySet(Composite composite) {
GridLayout visibilityLayout= createGridLayout(4);
visibilityLayout.marginHeight= 0;
visibilityLayout.marginWidth= 0;
Composite visibilityGroup= new Composite(composite, SWT.NONE);
visibilityGroup.setLayoutData(createGridData(GridData.FILL_HORIZONTAL, 6, 0));
visibilityGroup.setLayout(visibilityLayout);
Label visibilityLabel= createLabel(visibilityGroup, SWT.NONE, JavadocExportMessages.getString("JavadocTreeWizardPage.visibilitygroup.label"), createGridData(GridData.FILL_HORIZONTAL, 4, 0));
fPrivateVisibility= createButton(visibilityGroup, SWT.RADIO, JavadocExportMessages.getString("JavadocTreeWizardPage.privatebutton.label"), createGridData(GridData.FILL_HORIZONTAL, 1, 0));
fPackageVisibility= createButton(visibilityGroup, SWT.RADIO, JavadocExportMessages.getString("JavadocTreeWizardPage.packagebutton.label"), createGridData(GridData.FILL_HORIZONTAL, 1, 0));
fProtectedVisibility= createButton(visibilityGroup, SWT.RADIO, JavadocExportMessages.getString("JavadocTreeWizardPage.protectedbutton.label"), createGridData(GridData.FILL_HORIZONTAL, 1, 0));
fPublicVisibility= createButton(visibilityGroup, SWT.RADIO, JavadocExportMessages.getString("JavadocTreeWizardPage.publicbutton.label"), createGridData(GridData.FILL_HORIZONTAL, 1, 0));
fPrivateVisibility.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
if (((Button) e.widget).getSelection()) {
fVisibilitySelection = fStore.PRIVATE;
}
}
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
});
fPackageVisibility.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
if (((Button) e.widget).getSelection()) {
fVisibilitySelection = fStore.PACKAGE;
}
}
});
fProtectedVisibility.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
if (((Button) e.widget).getSelection()) {
fVisibilitySelection = fStore.PROTECTED;
}
}
});
fPublicVisibility.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
if (((Button) e.widget).getSelection()) {
fVisibilitySelection = fStore.PUBLIC;
}
}
});
setVisibilitySettings();
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
}
protected void setVisibilitySettings() {
fVisibilitySelection = fStore.getAccess();
fPrivateVisibility.setSelection(
fVisibilitySelection.equals(fStore.PRIVATE));
fProtectedVisibility.setSelection(
fVisibilitySelection.equals(fStore.PROTECTED));
fPackageVisibility.setSelection(
fVisibilitySelection.equals(fStore.PACKAGE));
fPublicVisibility.setSelection(
fVisibilitySelection.equals(fStore.PUBLIC));
}
private void createOptionsSet(Composite composite) {
GridLayout optionSetLayout= createGridLayout(3);
optionSetLayout.marginHeight= 0;
optionSetLayout.marginWidth= 0;
Composite optionSetGroup= new Composite(composite, SWT.NONE);
optionSetGroup.setLayoutData(createGridData(GridData.FILL_BOTH, 6, 0));
optionSetGroup.setLayout(optionSetLayout);
fStandardButton= createButton(optionSetGroup, SWT.RADIO, JavadocExportMessages.getString("JavadocTreeWizardPage.standarddocletbutton.label"), createGridData(GridData.HORIZONTAL_ALIGN_FILL, 3, 0));
GridData gd= new GridData();
gd.horizontalSpan= 1;
fDestinationLabel= createLabel(optionSetGroup, SWT.NONE, JavadocExportMessages.getString("JavadocTreeWizardPage.destinationfield.label"), createGridData(GridData.HORIZONTAL_ALIGN_BEGINNING, 1, convertWidthInCharsToPixels(3)));
fDestinationText= createText(optionSetGroup, SWT.SINGLE | SWT.BORDER, null, createGridData(GridData.FILL_HORIZONTAL, 1, 0));
((GridData) fDestinationText.getLayoutData()).widthHint = 200;
fDestinationText.addModifyListener(new ModifyListener() {
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
public void modifyText(ModifyEvent e) {
doValidation(STANDARDSTATUS);
}
});
fDestinationBrowserButton= createButton(optionSetGroup, SWT.PUSH, JavadocExportMessages.getString("JavadocTreeWizardPage.destinationbrowse.label"), createGridData(GridData.HORIZONTAL_ALIGN_FILL, 1, 0));
SWTUtil.setButtonDimensionHint(fDestinationBrowserButton);
fCustomButton= createButton(optionSetGroup, SWT.RADIO, JavadocExportMessages.getString("JavadocTreeWizardPage.customdocletbutton.label"), createGridData(3));
fDocletTypeLabel= createLabel(optionSetGroup, SWT.NONE, JavadocExportMessages.getString("JavadocTreeWizardPage.docletnamefield.label"), createGridData(GridData.HORIZONTAL_ALIGN_FILL, 1, convertWidthInCharsToPixels(3)));
fDocletTypeText= createText(optionSetGroup, SWT.SINGLE | SWT.BORDER, null, createGridData(GridData.HORIZONTAL_ALIGN_FILL, 2, 0));
fDocletTypeText.addModifyListener(new ModifyListener() {
public void modifyText(ModifyEvent e) {
doValidation(CUSTOMSTATUS);
}
});
fDocletLabel= createLabel(optionSetGroup, SWT.NONE, JavadocExportMessages.getString("JavadocTreeWizardPage.docletpathfield.label"), createGridData(GridData.HORIZONTAL_ALIGN_FILL, 1, convertWidthInCharsToPixels(3)));
fDocletText= createText(optionSetGroup, SWT.SINGLE | SWT.BORDER, null, createGridData(GridData.HORIZONTAL_ALIGN_FILL, 2, 0));
fDocletText.addModifyListener(new ModifyListener() {
public void modifyText(ModifyEvent e) {
doValidation(CUSTOMSTATUS);
}
});
fCustomButton.addSelectionListener(
new EnableSelectionAdapter(new Control[] { fDocletLabel, fDocletText, fDocletTypeLabel, fDocletTypeText }, new Control[] { fDestinationLabel, fDestinationText, fDestinationBrowserButton }));
fCustomButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
doValidation(CUSTOMSTATUS);
}
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
});
fStandardButton.addSelectionListener(
new EnableSelectionAdapter(new Control[] { fDestinationLabel, fDestinationText, fDestinationBrowserButton }, new Control[] { fDocletLabel, fDocletText, fDocletTypeLabel, fDocletTypeText }));
fStandardButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent e) {
doValidation(STANDARDSTATUS);
}
});
fDestinationBrowserButton.addSelectionListener(new SelectionAdapter() {
public void widgetSelected(SelectionEvent event) {
String text= handleFolderBrowseButtonPressed(
fDestinationText.getText(), fDestinationText.getShell(),
JavadocExportMessages.getString("JavadocTreeWizardPage.destinationbrowsedialog.title"),
JavadocExportMessages.getString("JavadocTreeWizardPage.destinationbrowsedialog.label"));
fDestinationText.setText(text);
}
});
setOptionSetSettings();
}
public boolean getCustom(){
return fCustomButton.getSelection();
}
private String getDestinationText() {
Object[] els= fInputGroup.getAllCheckedTreeItems().toArray();
try {
for (int i= 0; i < els.length; i++) {
if (els[i] instanceof IJavaProject) {
IJavaProject iJavaProject= (IJavaProject) els[i];
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
return iJavaProject.getUnderlyingResource().getLocation().addTrailingSeparator().append(DOCUMENT_DIRECTORY).toOSString();
}
}
} catch (JavaModelException e) {
return "";
} catch (NullPointerException e) {
return "";
}
return "";
}
private void setOptionSetSettings() {
if(!fStore.fromStandard()) {
fCustomButton.setSelection(true);
fDocletText.setText(fStore.getDocletPath());
fDocletTypeText.setText(fStore.getDocletName());
fDestinationText.setText(fStore.getDestination(fWizard.getProject()));
fDestinationText.setEnabled(false);
fDestinationBrowserButton.setEnabled(false);
fDestinationLabel.setEnabled(false);
} else {
fStandardButton.setSelection(true);
fDestinationText.setText(fStore.getDestination(fWizard.getProject()));
fDocletText.setText(fStore.getDocletPath());
fDocletTypeText.setText(fStore.getDocletName());
fDocletText.setEnabled(false);
fDocletLabel.setEnabled(false);
fDocletTypeText.setEnabled(false);
fDocletTypeLabel.setEnabled(false);
}
}
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
protected void setTreeChecked(
IJavaElement[] sourceElements,
IJavaProject project)
throws JavaModelException {
if (project == null)
return;
if (sourceElements.length < 1)
fInputGroup.initialCheckTreeItem(project);
else {
for (int i = 0; i < sourceElements.length; i++) {
IJavaElement curr = sourceElements[i];
if (curr instanceof ICompilationUnit) {
fInputGroup.initialCheckListItem(curr);
} else if (curr instanceof IPackageFragment) {
fInputGroup.initialCheckTreeItem(curr);
} else if(curr instanceof IJavaProject) {
if(sourceElements.length==1)
fInputGroup.initialCheckTreeItem(curr);
} else if (curr instanceof IPackageFragmentRoot) {
IPackageFragmentRoot root= (IPackageFragmentRoot)curr;
if(!root.isArchive())
fInputGroup.initialCheckTreeItem(curr);
}
}
}
}
private String getSourcePath(IJavaProject project) {
StringBuffer buf= new StringBuffer();
try {
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
IPackageFragmentRoot[] roots= project.getPackageFragmentRoots();
int nAdded= 0;
for (int i= 0; i < roots.length; i++) {
IPackageFragmentRoot curr= roots[i];
if (curr.getKind() == IPackageFragmentRoot.K_SOURCE) {
if (nAdded != 0) {
buf.append(File.pathSeparatorChar);
}
buf.append(curr.getUnderlyingResource().getLocation().toOSString());
nAdded++;
}
}
} catch (JavaModelException e) {
JavaPlugin.log(e);
}
return buf.toString();
}
private String getClassPath(IJavaProject javaProject) {
StringBuffer buf= new StringBuffer();
try {
IPath outputLocation= javaProject.getProject().getLocation().append(javaProject.getOutputLocation());
String[] classPath= JavaRuntime.computeDefaultRuntimeClassPath(javaProject);
int nAdded= 0;
for (int i= 0; i < classPath.length; i++) {
String curr= classPath[i];
if (outputLocation.equals(new Path(curr))) {
continue;
}
if (nAdded != 0) {
buf.append(File.pathSeparatorChar);
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
}
buf.append(curr);
nAdded++;
}
} catch (CoreException e) {
JavaPlugin.log(e);
}
return buf.toString();
}
private IJavaElement[] getSourceElements() {
ArrayList res= new ArrayList();
Iterator checkedElements= fInputGroup.getAllCheckedListItems();
while (checkedElements.hasNext()) {
Object element= checkedElements.next();
if (element instanceof ICompilationUnit) {
ICompilationUnit unit= (ICompilationUnit) element;
IPackageFragment pack= (IPackageFragment) unit.getParent();
if (fInputGroup.isTreeItemGreyChecked(pack) || pack.isDefaultPackage()) {
res.add(unit);
}
}
}
Iterator checkedTreeElements= fInputGroup.getAllCheckedTreeItems().iterator();
while (checkedTreeElements.hasNext()) {
Object element= checkedTreeElements.next();
if (element instanceof IPackageFragment) {
IPackageFragment pack= (IPackageFragment) element;
if (!fInputGroup.isTreeItemGreyChecked(pack) && !pack.isDefaultPackage()) {
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
res.add(pack);
}
}
}
return (IJavaElement[]) res.toArray(new IJavaElement[res.size()]);
}
protected void finish() {
if (fCustomButton.getSelection()) {
fStore.setDocletName(fDocletTypeText.getText());
fStore.setDocletPath(fDocletText.getText());
fStore.setFromStandard(false);
}
if(fStandardButton.getSelection()){
fStore.setFromStandard(true);
fStore.setDestination(fWizard.getProject(), fDestinationText.getText());
}
IJavaProject project= getCurrentProject();
fStore.setProject(project);
fStore.setSourcepath(getSourcePath(project));
fStore.setClasspath(getClassPath(project));
fStore.setAccess(fVisibilitySelection);
fStore.setSourceElements(getSourceElements());
}
private void doValidation(int validate) {
switch (validate) {
case PREFERENCESTATUS :
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
fPreferenceStatus = new StatusInfo();
fDocletStatus= new StatusInfo();
if (JavadocPreferencePage.getJavaDocCommand().length() == 0) {
fPreferenceStatus.setError(
JavadocExportMessages.getString("JavadocTreeWizardPage.javadoccommand.error"));
}
updateStatus(findMostSevereStatus());
break;
case CUSTOMSTATUS :
if (fCustomButton.getSelection()) {
fDestinationStatus = new StatusInfo();
fDocletStatus = new StatusInfo();
String doclet = fDocletTypeText.getText();
String docletPath = fDocletText.getText();
if (doclet.length() == 0) {
fDocletStatus.setError(JavadocExportMessages.getString("JavadocTreeWizardPage.nodocletname.error"));
} else if (
JavaConventions.validateJavaTypeName(doclet).matches(IStatus.ERROR)) {
fDocletStatus.setError(JavadocExportMessages.getString("JavadocTreeWizardPage.invaliddocletname.error"));
} else if ((docletPath.length() == 0) || !validDocletPath(docletPath)) {
fDocletStatus.setError(JavadocExportMessages.getString("JavadocTreeWizardPage.invaliddocletpath.error"));
}
updateStatus(findMostSevereStatus());
}
break;
case STANDARDSTATUS :
if (fStandardButton.getSelection()) {
fDestinationStatus = new StatusInfo();
fDocletStatus= new StatusInfo();
IPath path = new Path(fDestinationText.getText());
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
if (Path.ROOT.equals(path) || Path.EMPTY.equals(path)) {
fDestinationStatus.setError(JavadocExportMessages.getString("JavadocTreeWizardPage.nodestination.error"));
}
File file = new File(path.toOSString());
if (!path.isValidPath(path.toOSString()) || file.isFile()) {
fDestinationStatus.setError(JavadocExportMessages.getString("JavadocTreeWizardPage.invaliddestination.error"));
}
updateStatus(findMostSevereStatus());
}
break;
case TREESTATUS :
fTreeStatus = new StatusInfo();
boolean empty = fInputGroup.getAllCheckedTreeItems().isEmpty();
if (empty)
fTreeStatus.setError(JavadocExportMessages.getString("JavadocTreeWizardPage.invalidtreeselection.error"));
else {
int projCount = 0;
Object[] items = fInputGroup.getAllCheckedTreeItems().toArray();
for (int i = 0; i < items.length; i++) {
IJavaElement element = (IJavaElement) items[i];
if (element instanceof IJavaProject) {
projCount++;
if (projCount > 1)
fTreeStatus.setError(
JavadocExportMessages.getString("JavadocTreeWizardPage.multipleprojectselected.error"));
}
}
}
updateStatus(findMostSevereStatus());
break;
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
}
}
/**
* looks at the currently selected projects and returns the current project
* returns null if more than one project is checked
*/
private IJavaProject getCurrentProject() {
Object[] items= fInputGroup.getAllCheckedTreeItems().toArray();
IJavaProject project= null;
for (int i= 0; i < items.length; i++) {
if (items[i] instanceof IJavaProject) {
if (project != null) {
return null;
}
project= (IJavaProject)items[i];
}
}
return project;
}
private boolean validDocletPath(String docletPath) {
StringTokenizer tokens= new StringTokenizer(docletPath, ";");
while (tokens.hasMoreTokens()) {
File file= new File(tokens.nextToken());
if (!file.exists())
return false;
}
return true;
}
/**
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocTreeWizardPage.java
|
* Finds the most severe error (if there is one)
*/
private IStatus findMostSevereStatus() {
return StatusUtil.getMostSevere(new IStatus[] {fPreferenceStatus, fDestinationStatus, fDocletStatus, fTreeStatus, fWizardStatus });
}
public void init() {
updateStatus(new StatusInfo());
}
public void setVisible(boolean visible) {
super.setVisible(visible);
if (visible) {
doValidation(STANDARDSTATUS);
doValidation(CUSTOMSTATUS);
doValidation(TREESTATUS);
doValidation(PREFERENCESTATUS);
}
}
public IPath getDestination() {
if (fStandardButton.getSelection()) {
return new Path(fDestinationText.getText());
}
return null;
}
public IWizardPage getNextPage() {
return super.getNextPage();
}
}
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWizard.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.javadocexport;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceDescription;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.debug.core.DebugEvent;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.IDebugEventSetListener;
import org.eclipse.debug.core.ILaunch;
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWizard.java
|
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.core.Launch;
import org.eclipse.debug.core.model.IProcess;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.swt.widgets.Display;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IExportWizard;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IWorkbench;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
import org.eclipse.jdt.launching.JavaRuntime;
import org.eclipse.jdt.internal.corext.javadoc.JavaDocLocations;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.JavaPluginImages;
import org.eclipse.jdt.internal.ui.actions.OpenBrowserUtil;
import org.eclipse.jdt.internal.ui.jarpackager.ConfirmSaveModifiedResourcesDialog;
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWizard.java
|
import org.eclipse.jdt.internal.ui.util.ExceptionHandler;
public class JavadocWizard extends Wizard implements IExportWizard {
private JavadocTreeWizardPage fJTWPage;
private JavadocSpecificsWizardPage fJSWPage;
private JavadocStandardWizardPage fJSpWPage;
private IPath fDestination;
private boolean fWriteCustom;
private boolean fFromAnt;
private boolean fOpenInBrowser;
protected final String TreePageDesc= "JavadocTreePage";
protected final String SpecificsPageDesc= "JavadocSpecificsPage";
protected final String StandardPageDesc= "JavadocStandardPage";
private JavadocOptionsManager fStore;
private IWorkspaceRoot fRoot;
private IJavaProject fSelectedProject;
private IFile fXmlJavadocFile;
public JavadocWizard() {
this(null);
}
public JavadocWizard(IFile xmlJavadocFile) {
super();
setDefaultPageImageDescriptor(JavaPluginImages.DESC_WIZBAN_EXPORT_JAVADOC);
setWindowTitle(JavadocExportMessages.getString("JavadocWizard.javadocwizard.title"));
setDialogSettings(JavaPlugin.getDefault().getDialogSettings());
fRoot= ResourcesPlugin.getWorkspace().getRoot();
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWizard.java
|
fXmlJavadocFile= xmlJavadocFile;
fWriteCustom= false;
fFromAnt= (xmlJavadocFile != null);
fSelectedProject= null;
}
/*
* @see IWizard#performFinish()
*/
public boolean performFinish() {
fJTWPage.finish();
if(!fJTWPage.getCustom())
fJSpWPage.finish();
fJSWPage.finish();
if (!checkPreconditions(fStore.getSourceElements())) {
return false;
}
fDestination= new Path(fStore.getDestination(fStore.getJavaProject()));
fDestination.toFile().mkdirs();
if (fJSWPage.openInBrowser()) {
this.fOpenInBrowser= true;
}
try {
URL currURL= JavaDocLocations.getProjectJavadocLocation(fStore.getJavaProject());
URL newURL= fDestination.toFile().toURL();
if (fStore.fromStandard() && ((currURL == null) || !(currURL.equals(newURL)))) {
String message= JavadocExportMessages.getFormattedString("JavadocWizard.updatejavadoclocation.message", new String[] { fStore.getJavaProject().getElementName(), fDestination.toOSString() });
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWizard.java
|
if (MessageDialog.openQuestion(getShell(), JavadocExportMessages.getString("JavadocWizard.updatejavadocdialog.label"), message)) {
JavaDocLocations.setProjectJavadocLocation(fStore.getJavaProject(), newURL);
}
}
} catch (MalformedURLException e) {
JavaPlugin.log(e);
}
if (fJSWPage.generateAnt()) {
fStore.createXML();
refresh(new Path(fStore.getAntpath(fStore.getJavaProject())));
}
if (!fFromAnt) {
getDialogSettings().addSection(fStore.createDialogSettings());
}
try {
String[] args= fStore.createArgumentArray();
if (!executeJavadocGeneration(args))
return false;
} catch(CoreException e) {
JavaPlugin.log(e);
return false;
}
return true;
}
private boolean executeJavadocGeneration(String[] args) {
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWizard.java
|
Process process= null;
try {
process= Runtime.getRuntime().exec(args);
if (process != null) {
StringBuffer buf= new StringBuffer();
for (int i= 0; i < args.length; i++) {
buf.append(args[i]);
buf.append(' ');
}
IDebugEventSetListener listener= new JavadocDebugEventListener();
DebugPlugin.getDefault().addDebugEventListener(listener);
ILaunchConfigurationWorkingCopy wc= null;
try {
ILaunchConfigurationType lcType= DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
String name= JavadocExportMessages.getString("JavadocWizard.launchconfig.name");
wc= lcType.newInstance(null, name);
wc.setAttribute(IDebugUIConstants.ATTR_TARGET_RUN_PERSPECTIVE, (String) null);
wc.setAttribute(IDebugUIConstants.ATTR_PRIVATE, true);
ILaunch newLaunch= new Launch(wc, ILaunchManager.RUN_MODE, null);
IProcess iprocess= DebugPlugin.newProcess(newLaunch, process, JavadocExportMessages.getString("JavadocWizard.javadocprocess.label"));
iprocess.setAttribute(JavaRuntime.ATTR_CMDLINE, buf.toString());
DebugPlugin.getDefault().getLaunchManager().addLaunch(newLaunch);
} catch (CoreException e) {
JavaPlugin.log(e);
}
return true;
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWizard.java
|
}
} catch (IOException e) {
JavaPlugin.log(e);
return false;
}
return false;
}
private boolean checkPreconditions(IJavaElement[] elements) {
ArrayList resources= new ArrayList();
for (int i= 0; i < elements.length; i++) {
try {
if (elements[i] instanceof ICompilationUnit) {
resources.add(elements[i].getCorrespondingResource());
}
} catch(JavaModelException e) {
JavaPlugin.log(e);
}
}
IFile[] unSavedFiles = getUnsavedFiles(resources);
return saveModifiedResourcesIfUserConfirms(unSavedFiles);
}
/**
* Returns the files which are not saved and which are
* part of the files being exported.
*
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWizard.java
|
* @return an array of unsaved files
*/
private IFile[] getUnsavedFiles(List resources) {
IEditorPart[] dirtyEditors = JavaPlugin.getDirtyEditors();
Set unsavedFiles = new HashSet(dirtyEditors.length);
if (dirtyEditors.length > 0) {
for (int i = 0; i < dirtyEditors.length; i++) {
if (dirtyEditors[i].getEditorInput() instanceof IFileEditorInput) {
IFile dirtyFile =
((IFileEditorInput) dirtyEditors[i].getEditorInput()).getFile();
if (resources.contains(dirtyFile)) {
unsavedFiles.add(dirtyFile);
}
}
}
}
return (IFile[]) unsavedFiles.toArray(new IFile[unsavedFiles.size()]);
}
/**
* Asks to confirm to save the modified resources
* and save them if OK is pressed. Must be run in the display thread.
*
* @return true if user pressed OK and save was successful.
*/
private boolean saveModifiedResourcesIfUserConfirms(IFile[] dirtyFiles) {
if (confirmSaveModifiedResources(dirtyFiles)) {
try {
if (saveModifiedResources(dirtyFiles))
return true;
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWizard.java
|
} catch(CoreException e) {
ExceptionHandler.handle(e, getShell(), JavadocExportMessages.getString("JavadocWizard.saveresourcedialogCE.title"), JavadocExportMessages.getString("JavadocWizard.saveresourcedialogCE.message"));
} catch(InvocationTargetException e) {
ExceptionHandler.handle(e, getShell(), JavadocExportMessages.getString("JavadocWizard.saveresourcedialogITE.title"), JavadocExportMessages.getString("JavadocWizard.saveresourcedialogITE.message"));
}
}
return false;
}
/**
* Asks the user to confirm to save the modified resources.
*
* @return true if user pressed OK.
*/
private boolean confirmSaveModifiedResources(IFile[] dirtyFiles) {
if (dirtyFiles == null || dirtyFiles.length == 0)
return true;
Display display= getShell().getDisplay();
if (display == null || display.isDisposed())
return false;
final ConfirmSaveModifiedResourcesDialog dlg= new ConfirmSaveModifiedResourcesDialog(getShell(), dirtyFiles);
final int[] intResult= new int[1];
Runnable runnable= new Runnable() {
public void run() {
intResult[0]= dlg.open();
}
};
display.syncExec(runnable);
return intResult[0] == IDialogConstants.OK_ID;
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWizard.java
|
}
/**
* Save all of the editors in the workbench. Must be run in the display thread.
*
* @return true if successful.
*/
private boolean saveModifiedResources(final IFile[] dirtyFiles) throws CoreException, InvocationTargetException {
IWorkspace workspace= ResourcesPlugin.getWorkspace();
IWorkspaceDescription description= workspace.getDescription();
boolean autoBuild= description.isAutoBuilding();
description.setAutoBuilding(false);
try {
workspace.setDescription(description);
try {
new ProgressMonitorDialog(getShell()).run(false, false, createSaveModifiedResourcesRunnable(dirtyFiles));
} finally {
description.setAutoBuilding(autoBuild);
workspace.setDescription(description);
}
} catch (InterruptedException ex) {
return false;
}
return true;
}
private IRunnableWithProgress createSaveModifiedResourcesRunnable(final IFile[] dirtyFiles) {
return new IRunnableWithProgress() {
public void run(final IProgressMonitor pm) {
IEditorPart[] editorsToSave= JavaPlugin.getDirtyEditors();
String name= JavadocExportMessages.getString("JavadocWizard.savetask.name");
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWizard.java
|
pm.beginTask(name, editorsToSave.length);
try {
List dirtyFilesList= Arrays.asList(dirtyFiles);
for (int i= 0; i < editorsToSave.length; i++) {
if (editorsToSave[i].getEditorInput() instanceof IFileEditorInput) {
IFile dirtyFile= ((IFileEditorInput)editorsToSave[i].getEditorInput()).getFile();
if (dirtyFilesList.contains((dirtyFile)))
editorsToSave[i].doSave(new SubProgressMonitor(pm, 1));
}
pm.worked(1);
}
} finally {
pm.done();
}
}
};
}
/*
* @see IWizard#addPages()
*/
public void addPages() {
fJTWPage= new JavadocTreeWizardPage(TreePageDesc, fStore);
fJSWPage= new JavadocSpecificsWizardPage(SpecificsPageDesc, fStore);
fJSpWPage= new JavadocStandardWizardPage(StandardPageDesc, fStore);
super.addPage(fJTWPage);
super.addPage(fJSpWPage);
super.addPage(fJSWPage);
fJTWPage.init();
fJSpWPage.init();
fJSWPage.init();
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWizard.java
|
this.fSelectedProject= fStore.getJavaProject();
}
public void init(IWorkbench workbench, IStructuredSelection structuredSelection) {
IDialogSettings settings= getDialogSettings().getSection("javadoc");
fStore= new JavadocOptionsManager(fXmlJavadocFile, settings, structuredSelection);
}
private void refresh(IPath path) {
if (fRoot.getContainerForLocation(path) != null) {
try {
fRoot.refreshLocal(fJTWPage.fRoot.DEPTH_INFINITE, null);
} catch (CoreException e) {
JavaPlugin.log(e);
}
}
}
private void spawnInBrowser() {
if (fOpenInBrowser) {
try {
IPath indexFile= fDestination.append("index.html");
URL url= indexFile.toFile().toURL();
OpenBrowserUtil.open(url, getShell(), getWindowTitle());
} catch (MalformedURLException e) {
JavaPlugin.log(e);
}
}
}
private class JavadocDebugEventListener implements IDebugEventSetListener {
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWizard.java
|
public void handleDebugEvents(DebugEvent[] events) {
for (int i= 0; i < events.length; i++) {
if (events[i].getKind() == DebugEvent.TERMINATE) {
try {
if (!fWriteCustom) {
refresh(fDestination);
spawnInBrowser();
}
} finally {
DebugPlugin.getDefault().removeDebugEventListener(this);
}
return;
}
}
}
}
public IWizardPage getNextPage(IWizardPage page) {
if(page instanceof JavadocTreeWizardPage) {
if(!fJTWPage.getCustom()) {
return fJSpWPage;
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWizard.java
|
}
return fJSWPage;
} else if (page instanceof JavadocSpecificsWizardPage) {
return null;
} else if (page instanceof JavadocStandardWizardPage)
return fJSWPage;
else return null;
}
public IWizardPage getPreviousPage(IWizardPage page) {
if(page instanceof JavadocSpecificsWizardPage) {
if(!fJTWPage.getCustom()) {
return fJSpWPage;
}
return fJSWPage;
} else if (page instanceof JavadocTreeWizardPage) {
return null;
} else if (page instanceof JavadocStandardWizardPage)
return fJTWPage;
else return null;
}
protected void setProject(IJavaProject project) {
this.fSelectedProject= project;
}
protected IJavaProject getProject() {
return this.fSelectedProject;
}
}
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWriter.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWriter.java
|
*/
package org.eclipse.jdt.internal.ui.javadocexport;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URL;
import java.util.List;
import java.util.StringTokenizer;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.apache.xml.serialize.Method;
import org.apache.xml.serialize.OutputFormat;
import org.apache.xml.serialize.Serializer;
import org.apache.xml.serialize.SerializerFactory;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.jface.util.Assert;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.corext.javadoc.JavaDocLocations;
import org.eclipse.jdt.internal.ui.JavaPlugin;
public class JavadocWriter {
protected OutputStream fOutputStream;
private IJavaProject fProject;
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWriter.java
|
/**
* Create a JavadocWriter on the given output stream.
* It is the client's responsibility to close the output stream.
*/
public JavadocWriter(OutputStream outputStream) {
Assert.isNotNull(outputStream);
fOutputStream= new BufferedOutputStream(outputStream);
}
/**
* Writes a XML representation of the JAR specification
* to to the underlying stream.
*
* @exception IOException if writing to the underlying stream fails
*/
public void writeXML(JavadocOptionsManager store) throws IOException, CoreException {
DocumentBuilder docBuilder= null;
DocumentBuilderFactory factory= DocumentBuilderFactory.newInstance();
factory.setValidating(false);
try {
docBuilder= factory.newDocumentBuilder();
} catch (ParserConfigurationException ex) {
throw new IOException();
}
Document document= docBuilder.newDocument();
Element project= document.createElement("project");
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWriter.java
|
document.appendChild(project);
try {
fProject= store.getJavaProject();
if(fProject!=null) {
project.setAttribute("name", fProject.getCorrespondingResource().getName());
} else project.setAttribute("name", "project_name");
} catch(DOMException e) {
project.setAttribute("name", "project_name");
} catch(JavaModelException e) {
project.setAttribute("name", "project_name");
}
project.setAttribute("default", "javadoc");
Element javadocTarget= document.createElement("target");
project.appendChild(javadocTarget);
javadocTarget.setAttribute("name", "javadoc");
Element xmlJavadocDesc= document.createElement("javadoc");
javadocTarget.appendChild(xmlJavadocDesc);
if (!store.fromStandard())
xmlWriteDoclet(store, document, xmlJavadocDesc);
else
xmlWriteJavadocStandardParams(store, document,xmlJavadocDesc);
OutputFormat format= new OutputFormat();
format.setIndenting(true);
SerializerFactory serializerFactory= SerializerFactory.getSerializerFactory(Method.XML);
Serializer serializer= serializerFactory.makeSerializer(fOutputStream, format);
serializer.asDOMSerializer().serialize(document);
}
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWriter.java
|
private void xmlWriteJavadocStandardParams(JavadocOptionsManager store, Document document ,Element xmlJavadocDesc) throws DOMException, CoreException {
xmlJavadocDesc.setAttribute(store.DESTINATION, store.getDestination(store.getJavaProject()));
xmlJavadocDesc.setAttribute(store.VISIBILITY, store.getAccess());
xmlJavadocDesc.setAttribute(store.USE, booleanToString(store.getBoolean("use")));
xmlJavadocDesc.setAttribute(store.NOTREE, booleanToString(store.getBoolean("notree")));
xmlJavadocDesc.setAttribute(store.NONAVBAR, booleanToString(store.getBoolean("nonavbar")));
xmlJavadocDesc.setAttribute(store.NOINDEX, booleanToString(store.getBoolean("noindex")));
xmlJavadocDesc.setAttribute(store.SPLITINDEX, booleanToString(store.getBoolean("splitindex")));
xmlJavadocDesc.setAttribute(store.AUTHOR, booleanToString(store.getBoolean("author")));
xmlJavadocDesc.setAttribute(store.VERSION, booleanToString(store.getBoolean("version")));
xmlJavadocDesc.setAttribute(store.NODEPRECATEDLIST, booleanToString(store.getBoolean("nodeprecatedlist")));
xmlJavadocDesc.setAttribute(store.NODEPRECATED, booleanToString(store.getBoolean("nodeprecated")));
xmlJavadocDesc.setAttribute(store.PACKAGENAMES, toPackageList(store.getSourceElements()));
xmlJavadocDesc.setAttribute(store.SOURCEPATH, store.getSourcepath());
xmlJavadocDesc.setAttribute(store.CLASSPATH, store.getClasspath());
String str= store.getOverview();
if (!str.equals(""))
xmlJavadocDesc.setAttribute(store.OVERVIEW, str);
str= store.getStyleSheet();
if (!str.equals(""))
xmlJavadocDesc.setAttribute(store.STYLESHEETFILE, str);
str= store.getTitle();
if(!str.equals(""))
xmlJavadocDesc.setAttribute(store.TITLE, str);
str= store.getAdditionalParams();
if (!str.equals(""))
xmlJavadocDesc.setAttribute(store.EXTRAOPTIONS, str);
if (fProject != null) {
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWriter.java
|
String hrefs = store.getLinks(fProject);
StringTokenizer tokenizer = new StringTokenizer(hrefs, ";");
while (tokenizer.hasMoreElements()) {
String href = (String) tokenizer.nextElement();
Element links = document.createElement("link");
xmlJavadocDesc.appendChild(links);
links.setAttribute(store.HREF, href);
}
}
}
private void xmlWriteDoclet(JavadocOptionsManager store, Document document, Element xmlJavadocDesc) throws DOMException, CoreException {
xmlJavadocDesc.setAttribute(store.PACKAGENAMES, toPackageList(store.getSourceElements()));
xmlJavadocDesc.setAttribute(store.SOURCEPATH, store.getSourcepath());
xmlJavadocDesc.setAttribute(store.CLASSPATH, store.getClasspath());
xmlJavadocDesc.setAttribute(store.VISIBILITY, store.getAccess());
Element doclet= document.createElement("doclet");
xmlJavadocDesc.appendChild(doclet);
doclet.setAttribute(store.NAME, store.getDocletName());
doclet.setAttribute(store.PATH, store.getDocletPath());
String str= store.getOverview();
if (!str.equals(""))
xmlJavadocDesc.setAttribute(store.OVERVIEW, str);
str= store.getAdditionalParams();
if (!str.equals(""))
xmlJavadocDesc.setAttribute(store.EXTRAOPTIONS, str);
}
/**
* Closes this stream.
* It is the client's responsibility to close the stream.
|
17,177
|
Bug 17177 Javadoc wizard doesn't remember checked options between 2 runs
|
Build 20020521 The Javadoc wizard doesn't remember that I checked 'Open generated index file in browser' between 2 runs. As a result, I cannot just press Finish, but I need to press Next twice, then check the option again, then press Finish.
|
verified fixed
|
39d0fdf
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-29T17:34:14Z
| 2002-05-23T10:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/javadocexport/JavadocWriter.java
|
*
* @exception IOException
*/
private String toPackageList(IJavaElement[] sourceElements) throws JavaModelException {
StringBuffer buf= new StringBuffer();
for (int i= 0; i < sourceElements.length; i++) {
if (i > 0) {
buf.append(",");
}
IJavaElement curr= sourceElements[i];
if (curr instanceof IPackageFragment) {
buf.append(curr.getElementName());
} else {
buf.append(curr.getUnderlyingResource().getLocation().toOSString());
}
}
return buf.toString();
}
private String booleanToString(boolean bool){
if(bool)
return "true";
else return"false";
}
public void close() throws IOException {
if (fOutputStream != null) {
fOutputStream.close();
}
}
}
|
18,071
|
Bug 18071 Package Viewer: Too many refreshes
|
F1 - when a working copy is closed, it's package is updated - update on a package results in a refresh as the abstract filter claims that IMAGE is a filter property
|
verified fixed
|
21a786c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T08:22:16Z
| 2002-05-28T15:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/JavaElementContentProvider.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.ui;
import org.eclipse.core.resources.*;
import org.eclipse.jdt.core.*;
import org.eclipse.jdt.internal.ui.*;
import org.eclipse.jdt.internal.ui.viewsupport.*;
import org.eclipse.jface.viewers.*;
import org.eclipse.swt.widgets.*;
/**
* A tree content provider for Java elements. It extends the
* StandardJavaElementContentProvider with support for listening to changes.
* It is recommended to implement a custom listening support
* and to derive from the StandardJavaElementContentProvider directly.
* <p>
* This class may be instantiated; it is not intended to be subclassed.
* </p>
* @see StandardJavaElementContentProvider
*/
public class JavaElementContentProvider extends StandardJavaElementContentProvider implements ITreeContentProvider, IElementChangedListener {
|
18,071
|
Bug 18071 Package Viewer: Too many refreshes
|
F1 - when a working copy is closed, it's package is updated - update on a package results in a refresh as the abstract filter claims that IMAGE is a filter property
|
verified fixed
|
21a786c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T08:22:16Z
| 2002-05-28T15:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/JavaElementContentProvider.java
|
protected TreeViewer fViewer;
protected Object fInput;
/* (non-Javadoc)
* Method declared on IContentProvider.
*/
public void dispose() {
super.dispose();
JavaCore.removeElementChangedListener(this);
}
/* (non-Javadoc)
* Method declared on IContentProvider.
*/
public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
super.inputChanged(viewer, oldInput, newInput);
fViewer= (TreeViewer)viewer;
if (oldInput == null && newInput != null) {
JavaCore.addElementChangedListener(this);
} else if (oldInput != null && newInput == null) {
JavaCore.removeElementChangedListener(this);
}
fInput= newInput;
}
/**
* Creates a new content provider for Java elements.
*/
public JavaElementContentProvider() {
}
/**
* Creates a new content provider for Java elements.
|
18,071
|
Bug 18071 Package Viewer: Too many refreshes
|
F1 - when a working copy is closed, it's package is updated - update on a package results in a refresh as the abstract filter claims that IMAGE is a filter property
|
verified fixed
|
21a786c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T08:22:16Z
| 2002-05-28T15:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/JavaElementContentProvider.java
|
*/
public JavaElementContentProvider(boolean provideMembers, boolean provideWorkingCopy) {
super(provideMembers, provideWorkingCopy);
}
/* (non-Javadoc)
* Method declared on IElementChangedListener.
*/
public void elementChanged(final ElementChangedEvent event) {
try {
processDelta(event.getDelta());
} catch(JavaModelException e) {
JavaPlugin.getDefault().logErrorStatus(JavaUIMessages.getString("JavaElementContentProvider.errorMessage"), e.getStatus());
}
}
/**
* Processes a delta recursively. When more than two children are affected the
* tree is fully refreshed starting at this node. The delta is processed in the
* current thread but the viewer updates are posted to the UI thread.
*/
protected void processDelta(IJavaElementDelta delta) throws JavaModelException {
int kind= delta.getKind();
int flags= delta.getFlags();
IJavaElement element= delta.getElement();
if (!getProvideWorkingCopy() && element instanceof IWorkingCopy && ((IWorkingCopy)element).isWorkingCopy())
return;
if (element != null && element.getElementType() == IJavaElement.COMPILATION_UNIT && !element.getJavaProject().isOnClasspath(element))
return;
|
18,071
|
Bug 18071 Package Viewer: Too many refreshes
|
F1 - when a working copy is closed, it's package is updated - update on a package results in a refresh as the abstract filter claims that IMAGE is a filter property
|
verified fixed
|
21a786c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T08:22:16Z
| 2002-05-28T15:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/JavaElementContentProvider.java
|
if (((flags & IJavaElementDelta.F_CLOSED) != 0) || ((flags & IJavaElementDelta.F_OPENED) != 0)) {
postRefresh(element);
return;
}
if (kind == IJavaElementDelta.REMOVED) {
Object parent= internalGetParent(element);
postRemove(element);
if (parent instanceof IPackageFragment)
updatePackageIcon((IPackageFragment)parent);
if (isPackageFragmentEmpty(element.getParent())) {
if (fViewer.testFindItem(parent) != null)
postRefresh(internalGetParent(parent));
}
return;
}
if (kind == IJavaElementDelta.ADDED) {
Object parent= internalGetParent(element);
if (parent instanceof IPackageFragment) {
Object grandparent= internalGetParent(parent);
if (parent.equals(fInput)) {
postRefresh(parent);
} else {
|
18,071
|
Bug 18071 Package Viewer: Too many refreshes
|
F1 - when a working copy is closed, it's package is updated - update on a package results in a refresh as the abstract filter claims that IMAGE is a filter property
|
verified fixed
|
21a786c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T08:22:16Z
| 2002-05-28T15:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/JavaElementContentProvider.java
|
if (fViewer.testFindItem(parent) == null)
postRefresh(grandparent);
else {
postRefresh(parent);
}
}
} else {
postAdd(parent, element);
}
}
if (element instanceof ICompilationUnit) {
if (getProvideWorkingCopy()) {
IJavaElement original= ((IWorkingCopy)element).getOriginalElement();
if (original != null)
element= original;
}
if (kind == IJavaElementDelta.CHANGED) {
postRefresh(element);
return;
}
}
if ((element instanceof ICompilationUnit) || (element instanceof IClassFile))
return;
if (isClassPathChange(delta)) {
postRefresh(element.getJavaProject());
}
|
18,071
|
Bug 18071 Package Viewer: Too many refreshes
|
F1 - when a working copy is closed, it's package is updated - update on a package results in a refresh as the abstract filter claims that IMAGE is a filter property
|
verified fixed
|
21a786c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T08:22:16Z
| 2002-05-28T15:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/JavaElementContentProvider.java
|
if (delta.getResourceDeltas() != null) {
IResourceDelta[] rd= delta.getResourceDeltas();
for (int i= 0; i < rd.length; i++) {
processResourceDelta(rd[i], element);
}
}
IJavaElementDelta[] affectedChildren= delta.getAffectedChildren();
if (affectedChildren.length > 1) {
if (element instanceof IPackageFragment) {
IJavaElement parent= (IJavaElement)internalGetParent(element);
if (element.equals(fInput)) {
postRefresh(element);
} else {
postRefresh(parent);
}
return;
}
if (element instanceof IPackageFragmentRoot)
postRefresh(skipProjectPackageFragmentRoot((IPackageFragmentRoot)element));
else
postRefresh(element);
return;
}
for (int i= 0; i < affectedChildren.length; i++) {
processDelta(affectedChildren[i]);
|
18,071
|
Bug 18071 Package Viewer: Too many refreshes
|
F1 - when a working copy is closed, it's package is updated - update on a package results in a refresh as the abstract filter claims that IMAGE is a filter property
|
verified fixed
|
21a786c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T08:22:16Z
| 2002-05-28T15:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/JavaElementContentProvider.java
|
}
}
/**
* Updates the package icon
*/
private void updatePackageIcon(final IJavaElement element) {
postRunnable(new Runnable() {
public void run() {
Control ctrl= fViewer.getControl();
if (ctrl != null && !ctrl.isDisposed())
fViewer.update(element, new String[]{IBasicPropertyConstants.P_IMAGE});
}
});
}
/**
* Process resource deltas
*/
private void processResourceDelta(IResourceDelta delta, Object parent) {
int status= delta.getKind();
IResource resource= delta.getResource();
if (resource == null)
return;
if ((status & IResourceDelta.REMOVED) != 0) {
if (parent instanceof IPackageFragment)
|
18,071
|
Bug 18071 Package Viewer: Too many refreshes
|
F1 - when a working copy is closed, it's package is updated - update on a package results in a refresh as the abstract filter claims that IMAGE is a filter property
|
verified fixed
|
21a786c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T08:22:16Z
| 2002-05-28T15:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/JavaElementContentProvider.java
|
postRefresh(internalGetParent(parent));
else
postRemove(resource);
}
if ((status & IResourceDelta.ADDED) != 0) {
if (parent instanceof IPackageFragment)
postRefresh(internalGetParent(parent));
else
postAdd(parent, resource);
}
IResourceDelta[] affectedChildren= delta.getAffectedChildren();
if (affectedChildren.length > 1) {
postRefresh(resource);
return;
}
for (int i= 0; i < affectedChildren.length; i++)
processResourceDelta(affectedChildren[i], resource);
}
private void postRefresh(final Object root) {
postRunnable(new Runnable() {
public void run() {
Control ctrl= fViewer.getControl();
if (ctrl != null && !ctrl.isDisposed())
fViewer.refresh(root);
}
|
18,071
|
Bug 18071 Package Viewer: Too many refreshes
|
F1 - when a working copy is closed, it's package is updated - update on a package results in a refresh as the abstract filter claims that IMAGE is a filter property
|
verified fixed
|
21a786c
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T08:22:16Z
| 2002-05-28T15:33:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/ui/JavaElementContentProvider.java
|
});
}
private void postAdd(final Object parent, final Object element) {
postRunnable(new Runnable() {
public void run() {
Control ctrl= fViewer.getControl();
if (ctrl != null && !ctrl.isDisposed())
fViewer.add(parent, element);
}
});
}
private void postRemove(final Object element) {
postRunnable(new Runnable() {
public void run() {
Control ctrl= fViewer.getControl();
if (ctrl != null && !ctrl.isDisposed())
fViewer.remove(element);
}
});
}
private void postRunnable(final Runnable r) {
Control ctrl= fViewer.getControl();
if (ctrl != null && !ctrl.isDisposed()) {
ctrl.getDisplay().asyncExec(r);
}
}
}
|
18,266
|
Bug 18266 Turning off lightbulb preference doesn't turn the lights off right away
|
When you turn off the lightbulb preference, editors with existing lightbulbs continue to show them. Closing and reopening the editors gets rid of them.
|
verified fixed
|
8038473
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T09:20:57Z
| 2002-05-30T00:53:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/JavaEditorPreferencePage.java
|
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
package org.eclipse.jdt.internal.ui.preferences;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
|
18,266
|
Bug 18266 Turning off lightbulb preference doesn't turn the lights off right away
|
When you turn off the lightbulb preference, editors with existing lightbulbs continue to show them. Closing and reopening the editors gets rid of them.
|
verified fixed
|
8038473
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T09:20:57Z
| 2002-05-30T00:53:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/JavaEditorPreferencePage.java
|
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.List;
import org.eclipse.swt.widgets.TabFolder;
import org.eclipse.swt.widgets.TabItem;
import org.eclipse.swt.widgets.Text;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferenceConverter;
import org.eclipse.jface.preference.PreferencePage;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IDocumentPartitioner;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.jface.text.source.SourceViewer;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPreferencePage;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.ui.texteditor.AbstractTextEditor;
import org.eclipse.ui.texteditor.WorkbenchChainedTextFontFieldEditor;
import org.eclipse.jdt.ui.text.IJavaColorConstants;
import org.eclipse.jdt.ui.text.JavaSourceViewerConfiguration;
import org.eclipse.jdt.ui.text.JavaTextTools;
import org.eclipse.jdt.internal.ui.IJavaHelpContextIds;
import org.eclipse.jdt.internal.ui.JavaPlugin;
import org.eclipse.jdt.internal.ui.JavaPluginImages;
import org.eclipse.jdt.internal.ui.JavaUIMessages;
|
18,266
|
Bug 18266 Turning off lightbulb preference doesn't turn the lights off right away
|
When you turn off the lightbulb preference, editors with existing lightbulbs continue to show them. Closing and reopening the editors gets rid of them.
|
verified fixed
|
8038473
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T09:20:57Z
| 2002-05-30T00:53:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/JavaEditorPreferencePage.java
|
import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
import org.eclipse.jdt.internal.ui.dialogs.StatusUtil;
import org.eclipse.jdt.internal.ui.javaeditor.CompilationUnitDocumentProvider;
import org.eclipse.jdt.internal.ui.javaeditor.CompilationUnitEditor;
import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;
import org.eclipse.jdt.internal.ui.text.ContentAssistPreference;
import org.eclipse.jdt.internal.ui.util.TabFolderLayout;
import org.eclipse.jdt.internal.corext.refactoring.util.DebugUtils;
/*
* The page for setting the editor options.
*/
public class JavaEditorPreferencePage extends PreferencePage implements IWorkbenchPreferencePage {
public static final String BOLD= "_bold";
public static final String PREF_SHOW_TEMP_PROBLEMS= "JavaEditor.ShowTemporaryProblem";
public static final String PREF_SYNC_OUTLINE_ON_CURSOR_MOVE= "JavaEditor.SyncOutlineOnCursorMove";
public final OverlayPreferenceStore.OverlayKey[] fKeys= new OverlayPreferenceStore.OverlayKey[] {
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, AbstractTextEditor.PREFERENCE_COLOR_FOREGROUND),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, AbstractTextEditor.PREFERENCE_COLOR_FOREGROUND_SYSTEM_DEFAULT),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, AbstractTextEditor.PREFERENCE_COLOR_BACKGROUND),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, AbstractTextEditor.PREFERENCE_COLOR_BACKGROUND_SYSTEM_DEFAULT),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.INT, JavaSourceViewerConfiguration.PREFERENCE_TAB_WIDTH),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, IJavaColorConstants.JAVA_MULTI_LINE_COMMENT),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, IJavaColorConstants.JAVA_MULTI_LINE_COMMENT + BOLD),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, IJavaColorConstants.JAVA_SINGLE_LINE_COMMENT),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, IJavaColorConstants.JAVA_SINGLE_LINE_COMMENT + BOLD),
|
18,266
|
Bug 18266 Turning off lightbulb preference doesn't turn the lights off right away
|
When you turn off the lightbulb preference, editors with existing lightbulbs continue to show them. Closing and reopening the editors gets rid of them.
|
verified fixed
|
8038473
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T09:20:57Z
| 2002-05-30T00:53:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/JavaEditorPreferencePage.java
|
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, IJavaColorConstants.JAVA_KEYWORD),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, IJavaColorConstants.JAVA_KEYWORD + BOLD),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, IJavaColorConstants.JAVA_STRING),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, IJavaColorConstants.JAVA_STRING + BOLD),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, IJavaColorConstants.JAVA_DEFAULT),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, IJavaColorConstants.JAVA_DEFAULT + BOLD),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, IJavaColorConstants.JAVADOC_KEYWORD),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, IJavaColorConstants.JAVADOC_KEYWORD + BOLD),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, IJavaColorConstants.JAVADOC_TAG),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, IJavaColorConstants.JAVADOC_TAG + BOLD),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, IJavaColorConstants.JAVADOC_LINK),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, IJavaColorConstants.JAVADOC_LINK + BOLD),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, IJavaColorConstants.JAVADOC_DEFAULT),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, IJavaColorConstants.JAVADOC_DEFAULT + BOLD),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, CompilationUnitEditor.MATCHING_BRACKETS_COLOR),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, CompilationUnitEditor.MATCHING_BRACKETS),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, CompilationUnitEditor.CURRENT_LINE_COLOR),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, CompilationUnitEditor.CURRENT_LINE),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, CompilationUnitEditor.PRINT_MARGIN_COLOR),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.INT, CompilationUnitEditor.PRINT_MARGIN_COLUMN),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, CompilationUnitEditor.PRINT_MARGIN),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, AbstractTextEditor.PREFERENCE_COLOR_FIND_SCOPE),
|
18,266
|
Bug 18266 Turning off lightbulb preference doesn't turn the lights off right away
|
When you turn off the lightbulb preference, editors with existing lightbulbs continue to show them. Closing and reopening the editors gets rid of them.
|
verified fixed
|
8038473
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T09:20:57Z
| 2002-05-30T00:53:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/JavaEditorPreferencePage.java
|
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, CompilationUnitEditor.LINKED_POSITION_COLOR),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, CompilationUnitEditor.PROBLEM_INDICATION_COLOR),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, CompilationUnitEditor.PROBLEM_INDICATION),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, JavaEditorPreferencePage.PREF_SHOW_TEMP_PROBLEMS),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, JavaEditorPreferencePage.PREF_SYNC_OUTLINE_ON_CURSOR_MOVE),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, CompilationUnitDocumentProvider.HANDLE_TEMPORARY_PROBLEMS),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, CompilationUnitEditor.OVERVIEW_RULER),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, JavaEditor.LINE_NUMBER_COLOR),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, JavaEditor.LINE_NUMBER_RULER),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, CompilationUnitEditor.SPACES_FOR_TABS),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, ContentAssistPreference.AUTOACTIVATION),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.INT, ContentAssistPreference.AUTOACTIVATION_DELAY),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, ContentAssistPreference.AUTOINSERT),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, ContentAssistPreference.PROPOSALS_BACKGROUND),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, ContentAssistPreference.PROPOSALS_FOREGROUND),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, ContentAssistPreference.PARAMETERS_BACKGROUND),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, ContentAssistPreference.PARAMETERS_FOREGROUND),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, ContentAssistPreference.AUTOACTIVATION_TRIGGERS_JAVA),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.STRING, ContentAssistPreference.AUTOACTIVATION_TRIGGERS_JAVADOC),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, ContentAssistPreference.SHOW_VISIBLE_PROPOSALS),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, ContentAssistPreference.ORDER_PROPOSALS),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, ContentAssistPreference.CASE_SENSITIVITY),
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, ContentAssistPreference.ADD_IMPORT),
|
18,266
|
Bug 18266 Turning off lightbulb preference doesn't turn the lights off right away
|
When you turn off the lightbulb preference, editors with existing lightbulbs continue to show them. Closing and reopening the editors gets rid of them.
|
verified fixed
|
8038473
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T09:20:57Z
| 2002-05-30T00:53:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/JavaEditorPreferencePage.java
|
new OverlayPreferenceStore.OverlayKey(OverlayPreferenceStore.BOOLEAN, ContentAssistPreference.FILL_METHOD_ARGUMENTS)
};
private final String[][] fSyntaxColorListModel= new String[][] {
{ JavaUIMessages.getString("JavaEditorPreferencePage.multiLineComment"), IJavaColorConstants.JAVA_MULTI_LINE_COMMENT },
{ JavaUIMessages.getString("JavaEditorPreferencePage.singleLineComment"), IJavaColorConstants.JAVA_SINGLE_LINE_COMMENT },
{ JavaUIMessages.getString("JavaEditorPreferencePage.keywords"), IJavaColorConstants.JAVA_KEYWORD },
{ JavaUIMessages.getString("JavaEditorPreferencePage.strings"), IJavaColorConstants.JAVA_STRING },
{ JavaUIMessages.getString("JavaEditorPreferencePage.others"), IJavaColorConstants.JAVA_DEFAULT },
{ JavaUIMessages.getString("JavaEditorPreferencePage.javaDocKeywords"), IJavaColorConstants.JAVADOC_KEYWORD },
{ JavaUIMessages.getString("JavaEditorPreferencePage.javaDocHtmlTags"), IJavaColorConstants.JAVADOC_TAG },
{ JavaUIMessages.getString("JavaEditorPreferencePage.javaDocLinks"), IJavaColorConstants.JAVADOC_LINK },
{ JavaUIMessages.getString("JavaEditorPreferencePage.javaDocOthers"), IJavaColorConstants.JAVADOC_DEFAULT }
};
private final String[][] fAppearanceColorListModel= new String[][] {
{JavaUIMessages.getString("JavaEditorPreferencePage.lineNumberForegroundColor"), JavaEditor.LINE_NUMBER_COLOR},
{JavaUIMessages.getString("JavaEditorPreferencePage.matchingBracketsHighlightColor2"), CompilationUnitEditor.MATCHING_BRACKETS_COLOR},
{JavaUIMessages.getString("JavaEditorPreferencePage.currentLineHighlighColor"), CompilationUnitEditor.CURRENT_LINE_COLOR},
{JavaUIMessages.getString("JavaEditorPreferencePage.problemsHighlightColor"), CompilationUnitEditor.PROBLEM_INDICATION_COLOR},
{JavaUIMessages.getString("JavaEditorPreferencePage.printMarginColor2"), CompilationUnitEditor.PRINT_MARGIN_COLOR},
{JavaUIMessages.getString("JavaEditorPreferencePage.findScopeColor2"), AbstractTextEditor.PREFERENCE_COLOR_FIND_SCOPE},
{JavaUIMessages.getString("JavaEditorPreferencePage.linkedPositionColor2"), CompilationUnitEditor.LINKED_POSITION_COLOR},
};
private OverlayPreferenceStore fOverlayStore;
private JavaTextTools fJavaTextTools;
private Map fColorButtons= new HashMap();
private SelectionListener fColorButtonListener= new SelectionListener() {
|
18,266
|
Bug 18266 Turning off lightbulb preference doesn't turn the lights off right away
|
When you turn off the lightbulb preference, editors with existing lightbulbs continue to show them. Closing and reopening the editors gets rid of them.
|
verified fixed
|
8038473
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T09:20:57Z
| 2002-05-30T00:53:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/JavaEditorPreferencePage.java
|
public void widgetDefaultSelected(SelectionEvent e) {
}
public void widgetSelected(SelectionEvent e) {
ColorEditor editor= (ColorEditor) e.widget.getData();
PreferenceConverter.setValue(fOverlayStore, (String) fColorButtons.get(editor), editor.getColorValue());
}
};
private Map fCheckBoxes= new HashMap();
private SelectionListener fCheckBoxListener= new SelectionListener() {
public void widgetDefaultSelected(SelectionEvent e) {
}
public void widgetSelected(SelectionEvent e) {
Button button= (Button) e.widget;
fOverlayStore.setValue((String) fCheckBoxes.get(button), button.getSelection());
}
};
private Map fTextFields= new HashMap();
private ModifyListener fTextFieldListener= new ModifyListener() {
public void modifyText(ModifyEvent e) {
Text text= (Text) e.widget;
fOverlayStore.setValue((String) fTextFields.get(text), text.getText());
}
};
private ArrayList fNumberFields= new ArrayList();
private ModifyListener fNumberFieldListener= new ModifyListener() {
public void modifyText(ModifyEvent e) {
numberFieldChanged((Text) e.widget);
}
|
18,266
|
Bug 18266 Turning off lightbulb preference doesn't turn the lights off right away
|
When you turn off the lightbulb preference, editors with existing lightbulbs continue to show them. Closing and reopening the editors gets rid of them.
|
verified fixed
|
8038473
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T09:20:57Z
| 2002-05-30T00:53:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/JavaEditorPreferencePage.java
|
};
private WorkbenchChainedTextFontFieldEditor fFontEditor;
private List fSyntaxColorList;
private List fAppearanceColorList;
private ColorEditor fSyntaxForegroundColorEditor;
private ColorEditor fAppearanceForegroundColorEditor;
private ColorEditor fBackgroundColorEditor;
private Button fBackgroundDefaultRadioButton;
private Button fBackgroundCustomRadioButton;
private Button fBackgroundColorButton;
private Button fBoldCheckBox;
private SourceViewer fPreviewViewer;
private Color fBackgroundColor;
private Control fAutoInsertDelayText;
private Control fAutoInsertJavaTriggerText;
private Control fAutoInsertJavaDocTriggerText;
public JavaEditorPreferencePage() {
setDescription(JavaUIMessages.getString("JavaEditorPreferencePage.description"));
setPreferenceStore(JavaPlugin.getDefault().getPreferenceStore());
fOverlayStore= new OverlayPreferenceStore(getPreferenceStore(), fKeys);
}
public static void initDefaults(IPreferenceStore store) {
/*
* Ensure that the display is accessed only in the UI thread.
* Ensure that there are no side effects of switching the thread.
*/
|
18,266
|
Bug 18266 Turning off lightbulb preference doesn't turn the lights off right away
|
When you turn off the lightbulb preference, editors with existing lightbulbs continue to show them. Closing and reopening the editors gets rid of them.
|
verified fixed
|
8038473
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T09:20:57Z
| 2002-05-30T00:53:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/JavaEditorPreferencePage.java
|
final RGB[] rgbs= new RGB[3];
final Display display= Display.getDefault();
display.syncExec(new Runnable() {
public void run() {
Color c= display.getSystemColor(SWT.COLOR_GRAY);
rgbs[0]= c.getRGB();
c= display.getSystemColor(SWT.COLOR_LIST_FOREGROUND);
rgbs[1]= c.getRGB();
c= display.getSystemColor(SWT.COLOR_LIST_BACKGROUND);
rgbs[2]= c.getRGB();
}
});
/*
* Go on in whatever thread this is.
*/
store.setDefault(CompilationUnitEditor.MATCHING_BRACKETS, true);
PreferenceConverter.setDefault(store, CompilationUnitEditor.MATCHING_BRACKETS_COLOR, rgbs[0]);
store.setDefault(CompilationUnitEditor.CURRENT_LINE, true);
PreferenceConverter.setDefault(store, CompilationUnitEditor.CURRENT_LINE_COLOR, new RGB(225, 235, 224));
store.setDefault(CompilationUnitEditor.PRINT_MARGIN, false);
store.setDefault(CompilationUnitEditor.PRINT_MARGIN_COLUMN, 80);
PreferenceConverter.setDefault(store, CompilationUnitEditor.PRINT_MARGIN_COLOR, new RGB(176, 180 , 185));
PreferenceConverter.setDefault(store, AbstractTextEditor.PREFERENCE_COLOR_FIND_SCOPE, new RGB(185, 176 , 180));
store.setDefault(CompilationUnitEditor.PROBLEM_INDICATION, true);
PreferenceConverter.setDefault(store, CompilationUnitEditor.PROBLEM_INDICATION_COLOR, new RGB(255, 0 , 128));
|
18,266
|
Bug 18266 Turning off lightbulb preference doesn't turn the lights off right away
|
When you turn off the lightbulb preference, editors with existing lightbulbs continue to show them. Closing and reopening the editors gets rid of them.
|
verified fixed
|
8038473
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T09:20:57Z
| 2002-05-30T00:53:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/JavaEditorPreferencePage.java
|
store.setDefault(JavaEditorPreferencePage.PREF_SHOW_TEMP_PROBLEMS, true);
store.setDefault(JavaEditorPreferencePage.PREF_SYNC_OUTLINE_ON_CURSOR_MOVE, false);
store.setDefault(CompilationUnitDocumentProvider.HANDLE_TEMPORARY_PROBLEMS, true);
store.setDefault(CompilationUnitEditor.OVERVIEW_RULER, true);
store.setDefault(JavaEditor.LINE_NUMBER_RULER, false);
PreferenceConverter.setDefault(store, JavaEditor.LINE_NUMBER_COLOR, new RGB(0, 0, 0));
WorkbenchChainedTextFontFieldEditor.startPropagate(store, JFaceResources.TEXT_FONT);
PreferenceConverter.setDefault(store, CompilationUnitEditor.LINKED_POSITION_COLOR, new RGB(0, 200 , 100));
PreferenceConverter.setDefault(store, AbstractTextEditor.PREFERENCE_COLOR_FOREGROUND, rgbs[1]);
store.setDefault(AbstractTextEditor.PREFERENCE_COLOR_FOREGROUND_SYSTEM_DEFAULT, true);
PreferenceConverter.setDefault(store, AbstractTextEditor.PREFERENCE_COLOR_BACKGROUND, rgbs[2]);
store.setDefault(AbstractTextEditor.PREFERENCE_COLOR_BACKGROUND_SYSTEM_DEFAULT, true);
store.setDefault(JavaSourceViewerConfiguration.PREFERENCE_TAB_WIDTH, 4);
store.setDefault(CompilationUnitEditor.SPACES_FOR_TABS, false);
PreferenceConverter.setDefault(store, IJavaColorConstants.JAVA_MULTI_LINE_COMMENT, new RGB(63, 127, 95));
store.setDefault(IJavaColorConstants.JAVA_MULTI_LINE_COMMENT + "_bold", false);
PreferenceConverter.setDefault(store, IJavaColorConstants.JAVA_SINGLE_LINE_COMMENT, new RGB(63, 127, 95));
store.setDefault(IJavaColorConstants.JAVA_SINGLE_LINE_COMMENT + "_bold", false);
|
18,266
|
Bug 18266 Turning off lightbulb preference doesn't turn the lights off right away
|
When you turn off the lightbulb preference, editors with existing lightbulbs continue to show them. Closing and reopening the editors gets rid of them.
|
verified fixed
|
8038473
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T09:20:57Z
| 2002-05-30T00:53:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/JavaEditorPreferencePage.java
|
PreferenceConverter.setDefault(store, IJavaColorConstants.JAVA_KEYWORD, new RGB(127, 0, 85));
store.setDefault(IJavaColorConstants.JAVA_KEYWORD + "_bold", true);
PreferenceConverter.setDefault(store, IJavaColorConstants.JAVA_STRING, new RGB(42, 0, 255));
store.setDefault(IJavaColorConstants.JAVA_STRING + "_bold", false);
PreferenceConverter.setDefault(store, IJavaColorConstants.JAVA_DEFAULT, new RGB(0, 0, 0));
store.setDefault(IJavaColorConstants.JAVA_DEFAULT + "_bold", false);
PreferenceConverter.setDefault(store, IJavaColorConstants.JAVADOC_KEYWORD, new RGB(127, 159, 191));
store.setDefault(IJavaColorConstants.JAVADOC_KEYWORD + "_bold", true);
PreferenceConverter.setDefault(store, IJavaColorConstants.JAVADOC_TAG, new RGB(127, 127, 159));
store.setDefault(IJavaColorConstants.JAVADOC_TAG + "_bold", false);
PreferenceConverter.setDefault(store, IJavaColorConstants.JAVADOC_LINK, new RGB(63, 63, 191));
store.setDefault(IJavaColorConstants.JAVADOC_LINK + "_bold", false);
PreferenceConverter.setDefault(store, IJavaColorConstants.JAVADOC_DEFAULT, new RGB(63, 95, 191));
store.setDefault(IJavaColorConstants.JAVADOC_DEFAULT + "_bold", false);
store.setDefault(ContentAssistPreference.AUTOACTIVATION, true);
store.setDefault(ContentAssistPreference.AUTOACTIVATION_DELAY, 500);
store.setDefault(ContentAssistPreference.AUTOINSERT, true);
PreferenceConverter.setDefault(store, ContentAssistPreference.PROPOSALS_BACKGROUND, new RGB(254, 241, 233));
PreferenceConverter.setDefault(store, ContentAssistPreference.PROPOSALS_FOREGROUND, new RGB(0, 0, 0));
PreferenceConverter.setDefault(store, ContentAssistPreference.PARAMETERS_BACKGROUND, new RGB(254, 241, 233));
PreferenceConverter.setDefault(store, ContentAssistPreference.PARAMETERS_FOREGROUND, new RGB(0, 0, 0));
store.setDefault(ContentAssistPreference.AUTOACTIVATION_TRIGGERS_JAVA, ".");
store.setDefault(ContentAssistPreference.AUTOACTIVATION_TRIGGERS_JAVADOC, "@");
|
18,266
|
Bug 18266 Turning off lightbulb preference doesn't turn the lights off right away
|
When you turn off the lightbulb preference, editors with existing lightbulbs continue to show them. Closing and reopening the editors gets rid of them.
|
verified fixed
|
8038473
|
JDT
|
https://github.com/eclipse-jdt/eclipse.jdt.ui
|
eclipse-jdt/eclipse.jdt.ui
|
java
| null | null | null | 2002-05-30T09:20:57Z
| 2002-05-30T00:53:20Z
|
org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/JavaEditorPreferencePage.java
|
store.setDefault(ContentAssistPreference.SHOW_VISIBLE_PROPOSALS, true);
store.setDefault(ContentAssistPreference.CASE_SENSITIVITY, false);
store.setDefault(ContentAssistPreference.ORDER_PROPOSALS, false);
store.setDefault(ContentAssistPreference.ADD_IMPORT, true);
store.setDefault(ContentAssistPreference.FILL_METHOD_ARGUMENTS, false);
}
/*
* @see IWorkbenchPreferencePage#init()
*/
public void init(IWorkbench workbench) {
}
/*
* @see PreferencePage#createControl(Composite)
*/
public void createControl(Composite parent) {
super.createControl(parent);
WorkbenchHelp.setHelp(getControl(), IJavaHelpContextIds.JAVA_EDITOR_PREFERENCE_PAGE);
}
private void handleSyntaxColorListSelection() {
int i= fSyntaxColorList.getSelectionIndex();
String key= fSyntaxColorListModel[i][1];
RGB rgb= PreferenceConverter.getColor(fOverlayStore, key);
fSyntaxForegroundColorEditor.setColorValue(rgb);
fBoldCheckBox.setSelection(fOverlayStore.getBoolean(key + BOLD));
}
private void handleAppearanceColorListSelection() {
int i= fAppearanceColorList.getSelectionIndex();
String key= fAppearanceColorListModel[i][1];
RGB rgb= PreferenceConverter.getColor(fOverlayStore, key);
fAppearanceForegroundColorEditor.setColorValue(rgb);
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.