Attachment #93697 for bug #165005

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 165005
Collapse All | Expand All




        }
    }

    /**
     * Create a modal progress dialog which can show a progress bar that is
     * wired up to the passed Progress Handle.
     * @param handle A progress handle which a background task will modify
     * the progress level of
     * @param includeDetail Whether or not to show a label for progress details
     * @return A dialog
     */
    public static JDialog createModalProgressDialog(ProgressHandle handle, boolean includeDetail) {
        assert EventQueue.isDispatchThread();
        JPanel panel = new JPanel();
        panel.setLayout(new BorderLayout());
        panel.add(ProgressHandleFactory.createMainLabelComponent(handle), BorderLayout.SOUTH);
        panel.add(ProgressHandleFactory.createProgressComponent(handle), BorderLayout.CENTER);
        panel.setBorder(BorderFactory.createEmptyBorder(12, 12, 12, 12));
        panel.setSize(new Dimension(400, 100));
        panel.setPreferredSize(new Dimension(400, 50));
        JDialog dlg = new JDialog(WindowManager.getDefault().getMainWindow(), true);
        dlg.setSize(400, 100);
        dlg.getContentPane().setLayout(new BorderLayout());
        dlg.getContentPane().add(panel, BorderLayout.CENTER);
        if (includeDetail) {
            dlg.getContentPane().add(ProgressHandleFactory.createDetailLabelComponent(handle));
        }
        dlg.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
        dlg.setAlwaysOnTop(true);
        dlg.setLocationRelativeTo(WindowManager.getDefault().getMainWindow());
        return dlg;
    }

    /**
     * Run a runnable on a background thread while showing progress in a modal
     * dialog.
     * @param handle The progress handle that will show progress
     * @param run The runnable, which will be dispatched using RequestProcessor.getDefault()
     * @param includeDetail Whether or not you intend to set detailed text status messages on
     * the progress handle
     */
    public static void showProgressDialogAndRun (final ProgressHandle handle, final Runnable run, boolean includeDetail) {
        final JDialog dlg = createModalProgressDialog(handle, includeDetail);
        class WR extends WindowAdapter implements Runnable {

            public void run() {
                if (!EventQueue.isDispatchThread()) {
                    try {
                        run.run();
                    } finally {
                        EventQueue.invokeLater(this);
                    }
                } else {
                    dlg.setVisible(false);
                    dlg.dispose();
                }
            }

            @Override
            public void windowOpened(WindowEvent e) {
                RequestProcessor.getDefault().post(this);
            }
        }
        WR wr = new WR();
        dlg.addWindowListener(wr);
        dlg.setVisible(true);
    }

    public static Node createWaitNode() {
        return new WaitNode();
    }

Lines 76-81 Link Here

(-)a/javacard.project/src/org/netbeans/modules/javacard/project/JCProject.java (-47 / +40 lines)
76	import org.netbeans.api.java.project.JavaProjectConstants;	76	import org.netbeans.api.java.project.JavaProjectConstants;
77	import org.netbeans.api.progress.ProgressHandle;	77	import org.netbeans.api.progress.ProgressHandle;
78	import org.netbeans.api.progress.ProgressHandleFactory;	78	import org.netbeans.api.progress.ProgressHandleFactory;
		79	import org.netbeans.api.progress.ProgressRunnable;
		80	import org.netbeans.api.progress.ProgressUtils;
79	import org.netbeans.api.project.FileOwnerQuery;	81	import org.netbeans.api.project.FileOwnerQuery;
80	import org.netbeans.api.project.Project;	82	import org.netbeans.api.project.Project;
81	import org.netbeans.api.project.ProjectInformation;	83	import org.netbeans.api.project.ProjectInformation;
Lines 98-104 Link Here
98	import org.netbeans.modules.javacard.project.deps.ResolvedDependencies;	100	import org.netbeans.modules.javacard.project.deps.ResolvedDependencies;
99	import org.netbeans.modules.javacard.project.deps.ResolvedDependency;	101	import org.netbeans.modules.javacard.project.deps.ResolvedDependency;
100	import org.netbeans.modules.javacard.api.BadPlatformOrDevicePanel;	102	import org.netbeans.modules.javacard.api.BadPlatformOrDevicePanel;
101	import org.netbeans.modules.javacard.common.GuiUtils;
102	import org.netbeans.modules.javacard.project.ui.UnsupportedEncodingDialog;	103	import org.netbeans.modules.javacard.project.ui.UnsupportedEncodingDialog;
103	import org.netbeans.modules.javacard.spi.Card;	104	import org.netbeans.modules.javacard.spi.Card;
104	import org.netbeans.modules.javacard.spi.Cards;	105	import org.netbeans.modules.javacard.spi.Cards;
Lines 1017-1070 Link Here
1017	if (platform.equals(newPlatform) && device.equals(newDevice)) {	1018	if (platform.equals(newPlatform) && device.equals(newDevice)) {
1018	return;	1019	return;
1019	}	1020	}
1020	final ProgressHandle progress = ProgressHandleFactory.createHandle(NbBundle.getMessage(	1021	class PlatformSaver implements ProgressRunnable<Void>, Mutex.ExceptionAction<Void> {
1021	JCProject.class, "MSG_SAVING_PROPERTIES")); //NOI18N	1022	private ProgressHandle handle;
1022	Runnable r = new Runnable() {	1023	@Override
		1024	public Void run(ProgressHandle handle) {
		1025	handle.switchToDeterminate(6);
		1026	this.handle = handle;
		1027	handle.progress(1);
		1028	try {
		1029	ProjectManager.mutex().writeAccess(this);
		1030	} catch (MutexException ex) {
		1031	Exceptions.printStackTrace(ex);
		1032	}
		1033	return null;
		1034	}
1023		1035
1024	boolean first = true;	1036	@Override
1025		1037	public Void run() throws Exception {
1026	public void run() {	1038	handle.progress(2);
1027	if (!EventQueue.isDispatchThread()) {	1039	EditableProperties props = antHelper.getProperties(
1028	if (first) {	1040	AntProjectHelper.PROJECT_PROPERTIES_PATH);
1029	progress.start(6);	1041	handle.progress(3);
1030	first = false;	1042	props.setProperty(
1031	progress.progress(1);	1043	ProjectPropertyNames.PROJECT_PROP_ACTIVE_PLATFORM,
1032	ProjectManager.mutex().writeAccess(this);	1044	newPlatform);
1033	} else {	1045	props.setProperty(
1034	progress.progress(2);	1046	ProjectPropertyNames.PROJECT_PROP_ACTIVE_DEVICE,
1035	EditableProperties props = antHelper.getProperties(	1047	newDevice);
1036	AntProjectHelper.PROJECT_PROPERTIES_PATH);	1048	handle.progress(4);
1037	progress.progress(3);	1049	antHelper.putProperties(
1038	props.setProperty(	1050	AntProjectHelper.PROJECT_PROPERTIES_PATH,
1039	ProjectPropertyNames.PROJECT_PROP_ACTIVE_PLATFORM,	1051	props);
1040	newPlatform);	1052	handle.progress(5);
1041	props.setProperty(	1053	return null;
1042	ProjectPropertyNames.PROJECT_PROP_ACTIVE_DEVICE,
1043	newDevice);
1044	progress.progress(4);
1045	antHelper.putProperties(
1046	AntProjectHelper.PROJECT_PROPERTIES_PATH,
1047	props);
1048	progress.progress(5);
1049	try {
1050	ProjectManager.getDefault().saveProject(JCProject.this);
1051	} catch (IOException ex) {
1052	Exceptions.printStackTrace(ex);
1053	} catch (IllegalArgumentException ex) {
1054	Exceptions.printStackTrace(ex);
1055	} finally {
1056	EventQueue.invokeLater(this);
1057	}
1058	}
1059	} else {
1060	synchronized (JCProject.this) {
1061	cachedBadProjectOrCard = null;
1062	}
1063	supp.fireChange();
1064	}
1065	}	1054	}
1066	};	1055	}
1067	GuiUtils.showProgressDialogAndRun(progress, r, false);	1056	ProgressUtils.showProgressDialogAndRun(new PlatformSaver(), NbBundle.getMessage(
		1057	JCProject.class, "MSG_SAVING_PROPERTIES"), true);
		1058	synchronized (JCProject.this) {
		1059	cachedBadProjectOrCard = null;
		1060	}
1068	}	1061	}
1069	}	1062	}
1070		1063




import java.awt.Toolkit;
import java.io.IOException;
import org.netbeans.api.progress.ProgressHandle;
import org.netbeans.api.progress.ProgressRunnable;
import org.netbeans.api.progress.ProgressUtils;
import org.netbeans.modules.javacard.project.JCProject;
import org.netbeans.modules.javacard.project.deps.DependenciesProvider;
import org.netbeans.modules.javacard.project.deps.ResolvedDependencies;

    @Override
    protected void actionPerformed(JCProject target) {
        DependenciesProvider prov = target.getLookup().lookup(DependenciesProvider.class);
        ProgressUtils.showProgressDialogAndRun(new WaitRunnable(target, prov),
                NbBundle.getMessage(AddDependencyAction.class,
                "MSG_LOADING_DEPS"), false);
        WaitRunnable wr = new WaitRunnable(target, prov, handle);
        GuiUtils.showProgressDialogAndRun(handle, wr, false);
    }

    @Override

        return target.getLookup().lookup(DependenciesProvider.class) != null;
    }

    private static class WaitRunnable implements ProgressRunnable<Void> {
        private Cancellable c;
        private final DependenciesProvider prov;
        private final ProgressHandle handle;
        private final JCProject project;
        WaitRunnable (JCProject project, DependenciesProvider prov) {
            this.project = project;
            this.prov = prov;
            this.handle = handle;
        }

        public Void run(ProgressHandle handle) {
            handle.start();
            handle.switchToIndeterminate();
            try {
                R r = new R(project);
                c = prov.requestDependencies(r);

            } finally {
                handle.finish();
            }
            return null;
        }

    }

    private static class R implements DependenciesProvider.Receiver, Runnable {




import javax.swing.Action;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.netbeans.api.progress.ProgressUtils;
import org.netbeans.api.progress.ProgressHandleFactory;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectInformation;
import org.netbeans.modules.javacard.common.GuiUtils;
import org.netbeans.modules.javacard.project.JCProject;
import org.netbeans.modules.javacard.project.deps.ArtifactKind;
import org.netbeans.modules.javacard.project.deps.DependenciesProvider;

        }

        private void remove() {
            ProgressUtils.showProgressDialogAndRun(this, NbBundle.getMessage(RA.class, "MSG_REMOVING_DEPENDENCY",
                    getLookup().lookup(DependencyDescriptor.class).getName()));
            GuiUtils.showProgressDialogAndRun(handle, this, false);
        }
    }





import java.util.Map;
import java.util.Set;
import javax.swing.JDialog;
import org.netbeans.api.progress.ProgressRunnable;
import org.netbeans.api.progress.ProgressUtils;
import org.netbeans.modules.javacard.spi.JavacardPlatform;
import org.netbeans.modules.propdos.AntStyleResolvingProperties;


    JavacardPlatformWizardIterator(FileObject baseDir) {
        this.baseDir = baseDir;
    }

    
    public Set instantiate() throws IOException {
        class PlatformCreator implements ProgressRunnable<Set<Object>> {
            @Override
            public Set<Object> run(ProgressHandle handle) {
                "PROGRESS_CREATING_PLATFORM")); //NOI18N
        final JDialog dlg = GuiUtils.createModalProgressDialog(handle, false);
        final Runnable r = new Runnable() {

            public void run() {
                try {
                    return instantiate(handle);
                    dlg.setVisible(false);
                    dlg.dispose();
                } catch (IOException ex) {
                    Exceptions.printStackTrace(ex);
                    return null;
                }
            }
        }
        Set<Object> set = ProgressUtils.showProgressDialogAndRun(new PlatformCreator(), NbBundle.getMessage(JavacardPlatformWizardIterator.class,
                "PROGRESS_CREATING_PLATFORM"), false); //NOI18N
        return set == null ? Collections.<Object>emptySet() : set;
            @Override
            public void windowOpened(WindowEvent e) {
                RequestProcessor.getDefault().post(r);
            }

        });
        dlg.setVisible(true);
        return result[0] == null ? Collections.EMPTY_SET : result[0];
    }



Lines 327-333 Link Here

(-)a/javacard.ri.platform/src/org/netbeans/modules/javacard/ri/platform/installer/RIPlatformFactory.java (-1 / +1 lines)
327	h.setInitialDelay(20);	327	h.setInitialDelay(20);
328	h.setDisplayName(NbBundle.getMessage(JavacardPlatformWizardIterator.class,	328	h.setDisplayName(NbBundle.getMessage(JavacardPlatformWizardIterator.class,
329	"PROGRESS_CREATING_PLATFORM")); //NOI18N	329	"PROGRESS_CREATING_PLATFORM")); //NOI18N
330	h.start(14);	330	h.switchToDeterminate(14);
331	}	331	}
332	step++;	332	step++;
333	h.progress(step);	333	h.progress(step);

Return to bug 165005

Lines 157-227 Link Here

(-)a/javacard.common/src/org/netbeans/modules/javacard/common/GuiUtils.java (-65 lines)
157	}	157	}
158	}	158	}
159		159
160	/**
161	* Create a modal progress dialog which can show a progress bar that is
162	* wired up to the passed Progress Handle.
163	* @param handle A progress handle which a background task will modify
164	* the progress level of
165	* @param includeDetail Whether or not to show a label for progress details
166	* @return A dialog
167	*/
168	public static JDialog createModalProgressDialog(ProgressHandle handle, boolean includeDetail) {
169	assert EventQueue.isDispatchThread();
170	JPanel panel = new JPanel();
171	panel.setLayout(new BorderLayout());
172	panel.add(ProgressHandleFactory.createMainLabelComponent(handle), BorderLayout.SOUTH);
173	panel.add(ProgressHandleFactory.createProgressComponent(handle), BorderLayout.CENTER);
174	panel.setBorder(BorderFactory.createEmptyBorder(12, 12, 12, 12));
175	panel.setSize(new Dimension(400, 100));
176	panel.setPreferredSize(new Dimension(400, 50));
177	JDialog dlg = new JDialog(WindowManager.getDefault().getMainWindow(), true);
178	dlg.setSize(400, 100);
179	dlg.getContentPane().setLayout(new BorderLayout());
180	dlg.getContentPane().add(panel, BorderLayout.CENTER);
181	if (includeDetail) {
182	dlg.getContentPane().add(ProgressHandleFactory.createDetailLabelComponent(handle));
183	}
184	dlg.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
185	dlg.setAlwaysOnTop(true);
186	dlg.setLocationRelativeTo(WindowManager.getDefault().getMainWindow());
187	return dlg;
188	}
189
190	/**
191	* Run a runnable on a background thread while showing progress in a modal
192	* dialog.
193	* @param handle The progress handle that will show progress
194	* @param run The runnable, which will be dispatched using RequestProcessor.getDefault()
195	* @param includeDetail Whether or not you intend to set detailed text status messages on
196	* the progress handle
197	*/
198	public static void showProgressDialogAndRun (final ProgressHandle handle, final Runnable run, boolean includeDetail) {
199	final JDialog dlg = createModalProgressDialog(handle, includeDetail);
200	class WR extends WindowAdapter implements Runnable {
201
202	public void run() {
203	if (!EventQueue.isDispatchThread()) {
204	try {
205	run.run();
206	} finally {
207	EventQueue.invokeLater(this);
208	}
209	} else {
210	dlg.setVisible(false);
211	dlg.dispose();
212	}
213	}
214
215	@Override
216	public void windowOpened(WindowEvent e) {
217	RequestProcessor.getDefault().post(this);
218	}
219	}
220	WR wr = new WR();
221	dlg.addWindowListener(wr);
222	dlg.setVisible(true);
223	}
224
225	public static Node createWaitNode() {	160	public static Node createWaitNode() {
226	return new WaitNode();	161	return new WaitNode();
227	}	162	}

Lines 43-50 Link Here

(-)a/javacard.project/src/org/netbeans/modules/javacard/project/deps/ui/AddDependencyAction.java (-14 / +8 lines)
43	import java.awt.Toolkit;	43	import java.awt.Toolkit;
44	import java.io.IOException;	44	import java.io.IOException;
45	import org.netbeans.api.progress.ProgressHandle;	45	import org.netbeans.api.progress.ProgressHandle;
46	import org.netbeans.api.progress.ProgressHandleFactory;	46	import org.netbeans.api.progress.ProgressRunnable;
47	import org.netbeans.modules.javacard.common.GuiUtils;	47	import org.netbeans.api.progress.ProgressUtils;
48	import org.netbeans.modules.javacard.project.JCProject;	48	import org.netbeans.modules.javacard.project.JCProject;
49	import org.netbeans.modules.javacard.project.deps.DependenciesProvider;	49	import org.netbeans.modules.javacard.project.deps.DependenciesProvider;
50	import org.netbeans.modules.javacard.project.deps.ResolvedDependencies;	50	import org.netbeans.modules.javacard.project.deps.ResolvedDependencies;
Lines 67-77 Link Here
67	@Override	67	@Override
68	protected void actionPerformed(JCProject target) {	68	protected void actionPerformed(JCProject target) {
69	DependenciesProvider prov = target.getLookup().lookup(DependenciesProvider.class);	69	DependenciesProvider prov = target.getLookup().lookup(DependenciesProvider.class);
70	ProgressHandle handle = ProgressHandleFactory.createHandle(	70	ProgressUtils.showProgressDialogAndRun(new WaitRunnable(target, prov),
71	NbBundle.getMessage(AddDependencyAction.class,	71	NbBundle.getMessage(AddDependencyAction.class,
72	"MSG_LOADING_DEPS")); //NOI18N	72	"MSG_LOADING_DEPS"), false);
73	WaitRunnable wr = new WaitRunnable(target, prov, handle);
74	GuiUtils.showProgressDialogAndRun(handle, wr, false);
75	}	73	}
76		74
77	@Override	75	@Override
Lines 79-98 Link Here
79	return target.getLookup().lookup(DependenciesProvider.class) != null;	77	return target.getLookup().lookup(DependenciesProvider.class) != null;
80	}	78	}
81		79
82	private static class WaitRunnable implements Runnable {	80	private static class WaitRunnable implements ProgressRunnable<Void> {
83	private Cancellable c;	81	private Cancellable c;
84	private final DependenciesProvider prov;	82	private final DependenciesProvider prov;
85	private final ProgressHandle handle;
86	private final JCProject project;	83	private final JCProject project;
87	WaitRunnable (JCProject project, DependenciesProvider prov, ProgressHandle handle) {	84	WaitRunnable (JCProject project, DependenciesProvider prov) {
88	this.project = project;	85	this.project = project;
89	this.prov = prov;	86	this.prov = prov;
90	this.handle = handle;
91	}	87	}
92		88
93	public void run() {	89	public Void run(ProgressHandle handle) {
94	handle.start();
95	handle.switchToIndeterminate();
96	try {	90	try {
97	R r = new R(project);	91	R r = new R(project);
98	c = prov.requestDependencies(r);	92	c = prov.requestDependencies(r);
Lines 110-117 Link Here
110	} finally {	104	} finally {
111	handle.finish();	105	handle.finish();
112	}	106	}
		107	return null;
113	}	108	}
114
115	}	109	}
116		110
117	private static class R implements DependenciesProvider.Receiver, Runnable {	111	private static class R implements DependenciesProvider.Receiver, Runnable {

Lines 12-23 Link Here

(-)a/javacard.project/src/org/netbeans/modules/javacard/project/deps/ui/DependenciesChildren.java (-5 / +2 lines)
12	import javax.swing.Action;	12	import javax.swing.Action;
13	import javax.swing.event.ChangeEvent;	13	import javax.swing.event.ChangeEvent;
14	import javax.swing.event.ChangeListener;	14	import javax.swing.event.ChangeListener;
15	import org.netbeans.api.progress.ProgressHandle;	15	import org.netbeans.api.progress.ProgressUtils;
16	import org.netbeans.api.progress.ProgressHandleFactory;
17	import org.netbeans.api.project.FileOwnerQuery;	16	import org.netbeans.api.project.FileOwnerQuery;
18	import org.netbeans.api.project.Project;	17	import org.netbeans.api.project.Project;
19	import org.netbeans.api.project.ProjectInformation;	18	import org.netbeans.api.project.ProjectInformation;
20	import org.netbeans.modules.javacard.common.GuiUtils;
21	import org.netbeans.modules.javacard.project.JCProject;	19	import org.netbeans.modules.javacard.project.JCProject;
22	import org.netbeans.modules.javacard.project.deps.ArtifactKind;	20	import org.netbeans.modules.javacard.project.deps.ArtifactKind;
23	import org.netbeans.modules.javacard.project.deps.DependenciesProvider;	21	import org.netbeans.modules.javacard.project.deps.DependenciesProvider;
Lines 246-254 Link Here
246	}	244	}
247		245
248	private void remove() {	246	private void remove() {
249	ProgressHandle handle = ProgressHandleFactory.createHandle(NbBundle.getMessage(RA.class, "MSG_REMOVING_DEPENDENCY",	247	ProgressUtils.showProgressDialogAndRun(this, NbBundle.getMessage(RA.class, "MSG_REMOVING_DEPENDENCY",
250	getLookup().lookup(DependencyDescriptor.class).getName()));	248	getLookup().lookup(DependencyDescriptor.class).getName()));
251	GuiUtils.showProgressDialogAndRun(handle, this, false);
252	}	249	}
253	}	250	}
254		251

Lines 67-72 Link Here

(-)a/javacard.ri.platform/src/org/netbeans/modules/javacard/ri/platform/installer/JavacardPlatformWizardIterator.java (-24 / +11 lines)
67	import java.util.Map;	67	import java.util.Map;
68	import java.util.Set;	68	import java.util.Set;
69	import javax.swing.JDialog;	69	import javax.swing.JDialog;
		70	import org.netbeans.api.progress.ProgressRunnable;
		71	import org.netbeans.api.progress.ProgressUtils;
70	import org.netbeans.modules.javacard.spi.JavacardPlatform;	72	import org.netbeans.modules.javacard.spi.JavacardPlatform;
71	import org.netbeans.modules.propdos.AntStyleResolvingProperties;	73	import org.netbeans.modules.propdos.AntStyleResolvingProperties;
72		74
Lines 87-123 Link Here
87	JavacardPlatformWizardIterator(FileObject baseDir) {	89	JavacardPlatformWizardIterator(FileObject baseDir) {
88	this.baseDir = baseDir;	90	this.baseDir = baseDir;
89	}	91	}
90
91		92
92	public Set instantiate() throws IOException {	93	public Set instantiate() throws IOException {
93	final Set[] result = new Set[1];	94	class PlatformCreator implements ProgressRunnable<Set<Object>> {
94	final ProgressHandle handle = ProgressHandleFactory.createHandle(	95	@Override
95	NbBundle.getMessage(JavacardPlatformWizardIterator.class,	96	public Set<Object> run(ProgressHandle handle) {
96	"PROGRESS_CREATING_PLATFORM")); //NOI18N
97	final JDialog dlg = GuiUtils.createModalProgressDialog(handle, false);
98	final Runnable r = new Runnable() {
99
100	public void run() {
101	try {	97	try {
102	result[0] = instantiate(handle);	98	return instantiate(handle);
103	dlg.setVisible(false);
104	dlg.dispose();
105	} catch (IOException ex) {	99	} catch (IOException ex) {
106	Exceptions.printStackTrace(ex);	100	Exceptions.printStackTrace(ex);
		101	return null;
107	}	102	}
108	}	103	}
109	};	104	}
110	dlg.addWindowListener (new WindowAdapter() {	105	Set<Object> set = ProgressUtils.showProgressDialogAndRun(new PlatformCreator(), NbBundle.getMessage(JavacardPlatformWizardIterator.class,
111		106	"PROGRESS_CREATING_PLATFORM"), false); //NOI18N
112		107	return set == null ? Collections.<Object>emptySet() : set;
113	@Override
114	public void windowOpened(WindowEvent e) {
115	RequestProcessor.getDefault().post(r);
116	}
117
118	});
119	dlg.setVisible(true);
120	return result[0] == null ? Collections.EMPTY_SET : result[0];
121	}	108	}
122		109
123		110