Attachment #37479 for bug #92762

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 92762
Collapse All | Expand All

Lines 286-292 Link Here

(-)openide/dialogs/src/org/openide/DialogDisplayer.java (-1 / +1 lines)
286	}	286	}
287		287
288	public void updateOptions() {	288	public void updateOptions() {
289	Set addedOptions = new HashSet(5);	289	Set<Object> addedOptions = new HashSet<Object>(5);
290	Object[] options = nd.getOptions();	290	Object[] options = nd.getOptions();
291		291
292	if (options == null) {	292	if (options == null) {




    /** 'North' or 'South' */
    private String imageAlignment = "North"; // NOI18N

    /** Iterator between panels in the wizard and its settings */
    private SettingsAndIterator<?> data;

    /** Change listener that invokes method update state */
    private ChangeListener weakChangeListener;

    // base listener which won't be directly attached, will only wrapped by WeakListener
    private Listener baseListener;

    /** current panel */
    private Panel current;

    /** settings to be used for the panels */
    private Object settings;

    /** message format to create title of the document */
    private MessageFormat titleFormat;


    * @param settings the settings to pass to panels, or <code>null</code>
    * @see #WizardDescriptor(WizardDescriptor.Iterator, Object)
    */
    public <Data> WizardDescriptor(Panel<Data>[] wizardPanels, Data settings) {
        this(new SettingsAndIterator<Data>(new ArrayIterator<Data>(wizardPanels), settings));
    }
    
    /** Create a new wizard from a fixed list of panels with settings
    * defaulted to <CODE>this</CODE>.
    *
    * @param wizardPanels the panels to use
    * @see #WizardDescriptor(WizardDescriptor.Iterator, Object)
    */
    public WizardDescriptor(Panel<WizardDescriptor>[] wizardPanels) {
        this(SettingsAndIterator.create(new ArrayIterator<WizardDescriptor>(wizardPanels)));
        this(wizardPanels, CLOSE_PREVENTER);
    }

    /** Create wizard for a sequence of panels, passing some settings to the panels.

    * @see WizardDescriptor.Panel#readSettings
    * @see WizardDescriptor.Panel#storeSettings
    */
    public <Data>WizardDescriptor(Iterator<Data> panels, Data settings) {
        this(new SettingsAndIterator<Data>(panels, settings));
    }
    
    private <Data> WizardDescriptor(SettingsAndIterator<Data> data) {
        super("", "", true, DEFAULT_OPTION, null, CLOSE_PREVENTER); // NOI18N

        this.data = data;

        baseListener = new Listener();


        super.setOptions(new Object[] { previousButton, nextButton, finishButton, cancelButton });
        super.setClosingOptions(new Object[] { finishOption, cancelButton });

        this.panels = panels;

        // attach the change listener to iterator
        weakChangeListener = WeakListeners.change(baseListener, data.getIterator(this));
        data.getIterator(this).addChangeListener(weakChangeListener);

        callInitialize();
    }

    *
    * @param panels iterator over all {@link WizardDescriptor.Panel}s that can appear in the wizard
    */
    public WizardDescriptor(Iterator<WizardDescriptor> panels) {
        this(SettingsAndIterator.create(panels));
        this(panels, CLOSE_PREVENTER);
    }

    /** Initializes settings.

    * Correctly updates the buttons.
    * @param panels the new list of {@link WizardDescriptor.Panel}s
    */
    @SuppressWarnings("unchecked")
    public final synchronized void setPanels(Iterator panels) {
        if (data.getIterator(this) != null) {
            data.getIterator(this).removeChangeListener(weakChangeListener);
        }

        data = data.clone(panels);
        weakChangeListener = WeakListeners.change(baseListener, data.getIterator(this));
        data.getIterator(this).addChangeListener(weakChangeListener);
        init = false;

        updateState();

    * </PRE></code>
    */
    protected synchronized void updateState() {
        updateStateOpen(data);
    }
    private <A> void updateStateOpen(SettingsAndIterator<A> data) {
        Panel<A> p = data.getIterator(this).current();

        // listeners on the panel
        if (data.current != p) {
            if (data.current != null) {
                // remove
                data.current.removeChangeListener(weakChangeListener);
                data.current.storeSettings(data.getSettings(this));
            }

            // Hack - obtain current panel again
            // It's here to allow dynamic change of panels in wizard
            // (which can be done in storeSettings method)
            p = data.getIterator(this).current();

            // add to new, detach old change listener and attach new one
            data.getIterator(this).removeChangeListener(weakChangeListener);
            weakChangeListener = WeakListeners.change(baseListener, p);
            data.getIterator(this).addChangeListener(weakChangeListener);
            p.addChangeListener(weakChangeListener);

            data.current = p;
            p.readSettings(data.getSettings(this));
        }

        boolean next = data.getIterator(this).hasNext();
        boolean prev = data.getIterator(this).hasPrevious();
        boolean valid = p.isValid();

        // AWT sensitive code

            panelName = ""; // NOI18N
        }

        Object[] args = { panelName, data.getIterator(this).name() };
        MessageFormat mf = getTitleFormat();

        if (autoWizardStyle) {

    
    // for xtesting usage only
    boolean isForwardEnabled () {
        return data.getIterator(this).current ().isValid () && !validationRuns;
    }

    private void updateStateInAWT () {
        Panel<?> p = data.getIterator(this).current ();        
        boolean next = data.getIterator(this).hasNext ();
        boolean prev = data.getIterator(this).hasPrevious ();
        boolean valid = p.isValid () && !validationRuns;

        nextButton.setEnabled (next && valid);
        previousButton.setEnabled (prev);
        cancelButton.setEnabled (true);
        
        if (data.current instanceof FinishablePanel) {
            // check if isFinishPanel
            if (((FinishablePanel)data.current).isFinishPanel ()) {
                finishButton.setEnabled (valid);
            } else {
                // XXX What if the last panel is not FinishPanel ??? enable ?

            // original way
            finishButton.setEnabled (
                valid &&
                (!next || (data.current instanceof FinishPanel))
            );
        }
    }

     * wizard window exceeds screen bounds after resize.
     */
    private void resizeWizard(Window parentWindow, Dimension prevSize) {
        Dimension curSize = data.getIterator(this).current().getComponent().getPreferredSize();

        // only enlarge if needed, don't shrink
        if ((curSize.width > prevSize.width) || (curSize.height > prevSize.height)) {

    /** Overrides superclass method. Adds reseting of wizard
     * for <code>CLOSED_OPTION</code>. */
    public void setValue(Object value) {
        setValueOpen(value, data);
    }
    
    private <A> void setValueOpen(Object value, SettingsAndIterator<A> data) {
        Object convertedValue = backConvertOption(value);

        // set new value w/o fire PROP_VALUE change
        Object oldValue = getValue();
        setValueWithoutPCH(convertedValue);

        } else if (FINISH_OPTION.equals(convertedValue) || NEXT_OPTION.equals(convertedValue)) {
            //Bugfix #25820: make sure that storeSettings
            //is called before propertyChange.
            if (data.current != null) {
                data.current.storeSettings(data.getSettings(this));
            }
        }



    /** Resets wizard when after closed/cancelled/finished the wizard dialog. */
    private void resetWizard() {
        resetWizardOpen(data);
    }
    
    private <A> void resetWizardOpen(SettingsAndIterator<A> data) {
        if (data.current != null) {
            data.current.storeSettings(data.getSettings(this));
            data.current.removeChangeListener(weakChangeListener);
            data.current = null;

            if (wizardPanel != null) {
                wizardPanel.resetPreferredSize();

        callUninitialize();

        // detach the change listener at the end of wizard
        data.getIterator(this).removeChangeListener(weakChangeListener);
    }

    private int getIntFromBundle(String key) {


    // helper methods which call to InstantiatingIterator
    private void callInitialize() {
        assert data.getIterator(this) != null;

        if (data.getIterator(this) instanceof InstantiatingIterator) {
            ((InstantiatingIterator) data.getIterator(this)).initialize(this);
        }

        newObjects = Collections.EMPTY_SET;
    }

    private void callUninitialize() {
        assert data.getIterator(this) != null;

        if (data.getIterator(this) instanceof InstantiatingIterator) {
            ((InstantiatingIterator) data.getIterator(this)).uninitialize(this);
        }
    }

    private void callInstantiate() throws IOException {
        callInstantiateOpen(data);
    }
    
    private <A> void callInstantiateOpen(SettingsAndIterator<A> data) throws IOException {
        Iterator<A> panels = data.getIterator(this);
        
        assert panels != null;
        
        err.log (Level.FINE, "Is AsynchronousInstantiatingIterator? " + (panels instanceof AsynchronousInstantiatingIterator));

        }
         
        // bugfix #44444, force store settings before do instantiate new objects
        panels.current().storeSettings(data.getSettings(this));

        if (panels instanceof InstantiatingIterator) {
            showWaitCursor();

    /** Iterator on the sequence of panels.
    * @see WizardDescriptor.Panel
    */
    public interface Iterator<Data> {
        /** Get the current panel.
        * @return the panel
        */
        public Panel<Data> current();

        /** Get the name of the current panel.
        * @return the name

     *
     * Please see complete guide at http://performance.netbeans.org/howto/dialogs/wizard-panels.html
     */
    public interface Panel<Data> {
        /** Get the component displayed in this panel.
         *
         * Note; method can be called from any thread, but not concurrently

        * @exception IllegalStateException if the the data provided
        * by the wizard are not valid.
        */
        public void readSettings(Data settings);

        /** Provides the wizard panel with the opportunity to update the
        * settings with its current customized state.

        * in fact the <code>TemplateWizard</code>.
        * @param settings the object representing wizard panel state
        */
        public void storeSettings(Data settings);

        /** Test whether the panel is finished and it is safe to proceed to the next one.
        * If the panel is valid, the "Next" (or "Finish") button will be enabled.

    * implementing this interface.
    * @deprecated 4.28 Use FinishablePanel instead.
    */
    public interface FinishPanel<Data> extends Panel<Data> {
    }

    /** A special interface for panels that need to do additional
     * validation when Next or Finish button is clicked.
     * @since 4.28
     */
    public interface ValidatingPanel<Data> extends Panel<Data> {
        /**
         * Is called when Next of Finish buttons are clicked and
         * allows deeper check to find out that panel is in valid

     *
     * @since 6.2 (16 May 2005)
     */
    public interface AsynchronousValidatingPanel<Data> extends ValidatingPanel<Data> {

        /**
         * Called synchronously from UI thread when Next

     * Finish button.
     * @since 4.28
     */
    public interface FinishablePanel<Data> extends Panel<Data> {
        /** Specify if this panel would enable Finish button. Finish button is
         * enabled if and only if isValid() returns true and isFinishPanel()
         * returns true.

     * in a template's declaration.)
     * @since org.openide/1 4.33
     */
    public interface InstantiatingIterator<Data> extends Iterator<Data> {
        /** Returns set of instantiated objects. If instantiation fails then wizard remains open to enable correct values.
         *
         * @throws IOException

     * in a template's declaration.)
     * @since org.openide/1 6.5
     */
    public interface AsynchronousInstantiatingIterator<Data> extends InstantiatingIterator<Data> {

        /**
         * Is called in separate thread when the Finish button

     * in a template's declaration.)
     * @since org.openide.dialogs 7.1
     */
    public interface ProgressInstantiatingIterator<Data> extends AsynchronousInstantiatingIterator<Data> {

        /**
         * Is called in separate thread when the Finish button


    /** Special iterator that works on an array of <code>Panel</code>s.
    */
    public static class ArrayIterator<Data> extends Object implements Iterator<Data> {
        /** Array of items.
        */
        private Panel<Data>[] panels;

        /** Index into the array
        */

        /** Construct an iterator.
        * @param array the list of panels to use
        */
        public ArrayIterator(Panel<Data>[] array) {
            panels = array;
            index = 0;
        }

        * constructed using default constructor.
        * (for example during deserialization.
        * Default implementation returns empty array. */
        @SuppressWarnings("unchecked")
        protected Panel<Data>[] initializePanels() {
            return new Panel[0];
        }

        /* The current panel.
        */
        public Panel<Data> current() {
            return panels[index];
        }



        /** Action listener */
        public void actionPerformed(ActionEvent ev) {
            final Iterator<?> panels = data.getIterator(WizardDescriptor.this);
            if (wizardPanel != null) {
                wizardPanel.setErrorMessage(" ", null); //NOI18N
            }

            assert ESTIMATED_HEIGHT == Utilities.loadImage ("org/netbeans/modules/dialogs/warning.gif").getHeight (null) : "Use only 16px icon.";
            preferredSize.height = Math.max (ESTIMATED_HEIGHT, preferredSize.height);
            return preferredSize;
        }
    }
    
    private static final class SettingsAndIterator<Data> {
        private final Iterator<Data> panels;
        private final Data settings;
        private final boolean useThis;
        /** current panel */
        private Panel<Data> current;

        
        public SettingsAndIterator(Iterator<Data> iterator, Data settings) {
            this(iterator, settings, false);
        }
        public SettingsAndIterator(Iterator<Data> iterator, Data settings, boolean useThis) {
            this.panels = iterator;
            this.settings = settings;
            this.useThis = useThis;
        }
        public static SettingsAndIterator<WizardDescriptor> create(Iterator<WizardDescriptor> iterator) {
            return new SettingsAndIterator<WizardDescriptor>(iterator, null, true);
        }

        public Iterator<Data> getIterator(WizardDescriptor caller) {
            return panels;
        }
        
        @SuppressWarnings("unchecked")
        public Data getSettings(WizardDescriptor caller) {
            return useThis ? (Data)caller : settings;
        }
        
        public SettingsAndIterator<Data> clone(Iterator<Data> it) {
            SettingsAndIterator<Data> s = new SettingsAndIterator<Data>(it, settings, useThis);
            return s;
        }
    }
}




 *
 * @author Jiri Rechtacek
 */
final class NewObjectWizardPanel implements WizardDescriptor.FinishablePanel<WizardDescriptor> {
    private NewObjectPanel newObjectPanelUI;
    /** listener to changes in the wizard */
    private ChangeListener listener;

     * This method can be called multiple times on one instance of <code>WizardDescriptor.Panel</code>.
     * @param settings the object representing wizard panel state, as originally supplied to {@link WizardDescriptor#WizardDescriptor(WizardDescriptor.Iterator,Object)}
     */
    public void readSettings(WizardDescriptor settings) {
        this.wizard = (TemplateWizard)settings;
        DataObject template = wizard.getTemplate ();
        if (template != null) {

     * This method can be called multiple times on one instance of <code>WizardDescriptor.Panel</code>.
     * @param settings the object representing a settings of the wizard
     */
    public void storeSettings(WizardDescriptor settings) {
        String name = getPanelUI ().getNewObjectName ();
        if (name.equals (NewObjectPanel.defaultNewObjectName ())) {
            name = null;




    static java.awt.Dimension PREF_DIM = new java.awt.Dimension (560, 350);

    /** panel */
    private Panel<WizardDescriptor> templateChooser;
    /** panel */
    private Panel<WizardDescriptor> targetChooser;
    /** whether to show target chooser */
    private boolean showTargetChooser = true;
    

    /** Returns wizard panel that is used to choose a template.
     * @return wizard panel
     */
    public Panel<WizardDescriptor> templateChooser () {
        synchronized (this) {
            if (templateChooser == null) {
                templateChooser = createTemplateChooser ();

     * name of the template.
     * @return wizard panel
     */
    public Panel<WizardDescriptor> targetChooser () {
        synchronized (this) {
            if (targetChooser == null) {
                targetChooser = createTargetChooser ();

     * 
     * @return the panel
     */
    protected Panel<WizardDescriptor> createTemplateChooser () {
        return new TemplateWizardPanel1 ();
    }


     * 
     * @return the panel
     */
    protected Panel<WizardDescriptor> createTargetChooser () {
        if (showTargetChooser) {
            return new TemplateWizardPanel2 ();
        } else {
            return new NewObjectWizardPanel ();
        }
    }
    
    /** Allows subclasses to provide their own default iterator

    * @param obj the data object
    * @return custom iterator or null
    */
    @SuppressWarnings("unchecked")
    public static Iterator getIterator (DataObject obj) {
        Object unknownIterator = obj.getPrimaryFile ().getAttribute(CUSTOM_ITERATOR);
        if (unknownIterator == null) {

            it = (Iterator)unknownIterator;
        // own brigde for each one iterator type
        } if (unknownIterator instanceof WizardDescriptor.InstantiatingIterator) {
            it = new InstantiatingIteratorBridge((WizardDescriptor.InstantiatingIterator<WizardDescriptor>) unknownIterator);
        }
        if (it != null) {
            return it;

    * <P>
    * Implements <code>Node.Cookie</code> since version 2.13
    */
    public interface Iterator extends WizardDescriptor.Iterator<WizardDescriptor>,
    java.io.Serializable, org.openide.nodes.Node.Cookie {
        /** Instantiates the template using information provided by
         * the wizard. If instantiation fails then wizard remains open to enable correct values.

        /** Get the current panel.
        * @return the panel
        */
        public Panel<WizardDescriptor> current() {
            return targetChooser ();
        }
        

    }
    
    private static class InstantiatingIteratorBridge implements TemplateWizard.Iterator {
        private WizardDescriptor.InstantiatingIterator<WizardDescriptor> instantiatingIterator;
        public InstantiatingIteratorBridge (WizardDescriptor.InstantiatingIterator<WizardDescriptor> it) {
            instantiatingIterator = it;
        }
        

            instantiatingIterator.addChangeListener (l);
        }
        
        public org.openide.WizardDescriptor.Panel<WizardDescriptor> current () {
            return instantiatingIterator.current ();
        }
        

Lines 57-63 Link Here

(-)openide/loaders/src/org/openide/loaders/TemplateWizardIterImpl.java (-2 / +2 lines)
57	/** Getter for the first panel.	57	/** Getter for the first panel.
58	* @return the first and default panel	58	* @return the first and default panel
59	*/	59	*/
60	private WizardDescriptor.Panel firstPanel () {	60	private WizardDescriptor.Panel<WizardDescriptor> firstPanel () {
61	return wizardInstance.templateChooser();	61	return wizardInstance.templateChooser();
62	}	62	}
63		63
Lines 114-120 Link Here
114	/** Get the current panel.	114	/** Get the current panel.
115	* @return the panel	115	* @return the panel
116	*/	116	*/
117	public WizardDescriptor.Panel current() {	117	public WizardDescriptor.Panel<WizardDescriptor> current() {
118	return showingPanel ? firstPanel () : getIterator ().current ();	118	return showingPanel ? firstPanel () : getIterator ().current ();
119	}	119	}
120		120




 *
 * @author Jiri Rechtacek
 */
class TemplateWizardIteratorWrapper implements WizardDescriptor.Iterator<WizardDescriptor>, ChangeListener {

    private TemplateWizardIterImpl iterImpl;
    

    /** Get the current panel.
     * @return the panel
     */
    public WizardDescriptor.Panel<WizardDescriptor> current() {
        return iterImpl.current ();
    }


        return iterImpl.instantiate (handle);
    }
    
    static class InstantiatingIterator extends TemplateWizardIteratorWrapper implements WizardDescriptor.InstantiatingIterator<WizardDescriptor> {
        public InstantiatingIterator (TemplateWizardIterImpl it) {
            super (it);
        }
    }
    
    static class AsynchronousInstantiatingIterator extends InstantiatingIterator implements WizardDescriptor.AsynchronousInstantiatingIterator<WizardDescriptor> {
        public AsynchronousInstantiatingIterator (TemplateWizardIterImpl it) {
            super (it);
        }
    }
    
    static class ProgressInstantiatingIterator extends InstantiatingIterator implements WizardDescriptor.ProgressInstantiatingIterator<WizardDescriptor> {
        private TemplateWizardIterImpl itImpl;
        public ProgressInstantiatingIterator (TemplateWizardIterImpl it) {
            super (it);




 *
 * @author Jiri Rechtacek
 */
final class TemplateWizardPanel1 implements WizardDescriptor.Panel<WizardDescriptor> {
    private TemplateWizard1 templateWizard1UI;
    /** listener to changes in the wizard */
    private ChangeListener listener;

    * This method can be called multiple times on one instance of <code>WizardDescriptor.Panel</code>.
    * @param settings the object representing wizard panel state, as originally supplied to {@link WizardDescriptor#WizardDescriptor(WizardDescriptor.Iterator,Object)}
    */
    public void readSettings(WizardDescriptor settings) {
        getPanelUI ().implReadSettings (settings);
    }
    

    * This method can be called multiple times on one instance of <code>WizardDescriptor.Panel</code>.
    * @param settings the object representing a settings of the wizard
    */
    public void storeSettings(WizardDescriptor settings) {
        getPanelUI ().implStoreSettings (settings);
    }
    




 *
 * @author Jiri Rechtacek
 */
final class TemplateWizardPanel2 implements WizardDescriptor.FinishablePanel<WizardDescriptor> {
    private TemplateWizard2 templateWizard2UI;
    /** listener to changes in the wizard */
    private ChangeListener listener;

     * by the wizard are not valid.
     *
     */
    public void readSettings(WizardDescriptor settings) {
        this.settings = (WizardDescriptor)settings;
        getPanelUI ().implReadSettings (settings);
    }

     * @param settings the object representing wizard panel state
     *
     */
    public void storeSettings(WizardDescriptor settings) {
        getPanelUI ().implStoreSettings (settings);
        this.settings = null;
    }

Return to bug 92762

Lines 68-76 Link Here

(-)openide/loaders/src/org/openide/loaders/TemplateWizard.java (-13 / +18 lines)
68	static java.awt.Dimension PREF_DIM = new java.awt.Dimension (560, 350);	68	static java.awt.Dimension PREF_DIM = new java.awt.Dimension (560, 350);
69		69
70	/** panel */	70	/** panel */
71	private Panel templateChooser;	71	private Panel<WizardDescriptor> templateChooser;
72	/** panel */	72	/** panel */
73	private Panel targetChooser;	73	private Panel<WizardDescriptor> targetChooser;
74	/** whether to show target chooser */	74	/** whether to show target chooser */
75	private boolean showTargetChooser = true;	75	private boolean showTargetChooser = true;
76		76
Lines 271-277 Link Here
271	/** Returns wizard panel that is used to choose a template.	271	/** Returns wizard panel that is used to choose a template.
272	* @return wizard panel	272	* @return wizard panel
273	*/	273	*/
274	public Panel templateChooser () {	274	public Panel<WizardDescriptor> templateChooser () {
275	synchronized (this) {	275	synchronized (this) {
276	if (templateChooser == null) {	276	if (templateChooser == null) {
277	templateChooser = createTemplateChooser ();	277	templateChooser = createTemplateChooser ();
Lines 284-290 Link Here
284	* name of the template.	284	* name of the template.
285	* @return wizard panel	285	* @return wizard panel
286	*/	286	*/
287	public Panel targetChooser () {	287	public Panel<WizardDescriptor> targetChooser () {
288	synchronized (this) {	288	synchronized (this) {
289	if (targetChooser == null) {	289	if (targetChooser == null) {
290	targetChooser = createTargetChooser ();	290	targetChooser = createTargetChooser ();
Lines 307-313 Link Here
307	*	307	*
308	* @return the panel	308	* @return the panel
309	*/	309	*/
310	protected Panel createTemplateChooser () {	310	protected Panel<WizardDescriptor> createTemplateChooser () {
311	return new TemplateWizardPanel1 ();	311	return new TemplateWizardPanel1 ();
312	}	312	}
313		313
Lines 315-322 Link Here
315	*	315	*
316	* @return the panel	316	* @return the panel
317	*/	317	*/
318	protected Panel createTargetChooser () {	318	protected Panel<WizardDescriptor> createTargetChooser () {
319	return showTargetChooser ? (Panel)new TemplateWizardPanel2 () : (Panel)new NewObjectWizardPanel ();	319	if (showTargetChooser) {
		320	return new TemplateWizardPanel2 ();
		321	} else {
		322	return new NewObjectWizardPanel ();
		323	}
320	}	324	}
321		325
322	/** Allows subclasses to provide their own default iterator	326	/** Allows subclasses to provide their own default iterator
Lines 661-666 Link Here
661	* @param obj the data object	665	* @param obj the data object
662	* @return custom iterator or null	666	* @return custom iterator or null
663	*/	667	*/
		668	@SuppressWarnings("unchecked")
664	public static Iterator getIterator (DataObject obj) {	669	public static Iterator getIterator (DataObject obj) {
665	Object unknownIterator = obj.getPrimaryFile ().getAttribute(CUSTOM_ITERATOR);	670	Object unknownIterator = obj.getPrimaryFile ().getAttribute(CUSTOM_ITERATOR);
666	if (unknownIterator == null) {	671	if (unknownIterator == null) {
Lines 672-678 Link Here
672	it = (Iterator)unknownIterator;	677	it = (Iterator)unknownIterator;
673	// own brigde for each one iterator type	678	// own brigde for each one iterator type
674	} if (unknownIterator instanceof WizardDescriptor.InstantiatingIterator) {	679	} if (unknownIterator instanceof WizardDescriptor.InstantiatingIterator) {
675	it = new InstantiatingIteratorBridge((WizardDescriptor.InstantiatingIterator) unknownIterator);	680	it = new InstantiatingIteratorBridge((WizardDescriptor.InstantiatingIterator<WizardDescriptor>) unknownIterator);
676	}	681	}
677	if (it != null) {	682	if (it != null) {
678	return it;	683	return it;
Lines 808-814 Link Here
808	* <P>	813	* <P>
809	* Implements <code>Node.Cookie</code> since version 2.13	814	* Implements <code>Node.Cookie</code> since version 2.13
810	*/	815	*/
811	public interface Iterator extends WizardDescriptor.Iterator,	816	public interface Iterator extends WizardDescriptor.Iterator<WizardDescriptor>,
812	java.io.Serializable, org.openide.nodes.Node.Cookie {	817	java.io.Serializable, org.openide.nodes.Node.Cookie {
813	/** Instantiates the template using information provided by	818	/** Instantiates the template using information provided by
814	* the wizard. If instantiation fails then wizard remains open to enable correct values.	819	* the wizard. If instantiation fails then wizard remains open to enable correct values.
Lines 887-893 Link Here
887	/** Get the current panel.	892	/** Get the current panel.
888	* @return the panel	893	* @return the panel
889	*/	894	*/
890	public Panel current() {	895	public Panel<WizardDescriptor> current() {
891	return targetChooser ();	896	return targetChooser ();
892	}	897	}
893		898
Lines 936-943 Link Here
936	}	941	}
937		942
938	private static class InstantiatingIteratorBridge implements TemplateWizard.Iterator {	943	private static class InstantiatingIteratorBridge implements TemplateWizard.Iterator {
939	private WizardDescriptor.InstantiatingIterator instantiatingIterator;	944	private WizardDescriptor.InstantiatingIterator<WizardDescriptor> instantiatingIterator;
940	public InstantiatingIteratorBridge (WizardDescriptor.InstantiatingIterator it) {	945	public InstantiatingIteratorBridge (WizardDescriptor.InstantiatingIterator<WizardDescriptor> it) {
941	instantiatingIterator = it;	946	instantiatingIterator = it;
942	}	947	}
943		948
Lines 949-955 Link Here
949	instantiatingIterator.addChangeListener (l);	954	instantiatingIterator.addChangeListener (l);
950	}	955	}
951		956
952	public org.openide.WizardDescriptor.Panel current () {	957	public org.openide.WizardDescriptor.Panel<WizardDescriptor> current () {
953	return instantiatingIterator.current ();	958	return instantiatingIterator.current ();
954	}	959	}
955		960

Lines 29-35 Link Here

(-)openide/loaders/src/org/openide/loaders/TemplateWizardIteratorWrapper.java (-5 / +5 lines)
29	*	29	*
30	* @author Jiri Rechtacek	30	* @author Jiri Rechtacek
31	*/	31	*/
32	class TemplateWizardIteratorWrapper implements WizardDescriptor.Iterator, ChangeListener {	32	class TemplateWizardIteratorWrapper implements WizardDescriptor.Iterator<WizardDescriptor>, ChangeListener {
33		33
34	private TemplateWizardIterImpl iterImpl;	34	private TemplateWizardIterImpl iterImpl;
35		35
Lines 63-69 Link Here
63	/** Get the current panel.	63	/** Get the current panel.
64	* @return the panel	64	* @return the panel
65	*/	65	*/
66	public WizardDescriptor.Panel current() {	66	public WizardDescriptor.Panel<WizardDescriptor> current() {
67	return iterImpl.current ();	67	return iterImpl.current ();
68	}	68	}
69		69
Lines 143-161 Link Here
143	return iterImpl.instantiate (handle);	143	return iterImpl.instantiate (handle);
144	}	144	}
145		145
146	static class InstantiatingIterator extends TemplateWizardIteratorWrapper implements WizardDescriptor.InstantiatingIterator {	146	static class InstantiatingIterator extends TemplateWizardIteratorWrapper implements WizardDescriptor.InstantiatingIterator<WizardDescriptor> {
147	public InstantiatingIterator (TemplateWizardIterImpl it) {	147	public InstantiatingIterator (TemplateWizardIterImpl it) {
148	super (it);	148	super (it);
149	}	149	}
150	}	150	}
151		151
152	static class AsynchronousInstantiatingIterator extends InstantiatingIterator implements WizardDescriptor.AsynchronousInstantiatingIterator {	152	static class AsynchronousInstantiatingIterator extends InstantiatingIterator implements WizardDescriptor.AsynchronousInstantiatingIterator<WizardDescriptor> {
153	public AsynchronousInstantiatingIterator (TemplateWizardIterImpl it) {	153	public AsynchronousInstantiatingIterator (TemplateWizardIterImpl it) {
154	super (it);	154	super (it);
155	}	155	}
156	}	156	}
157		157
158	static class ProgressInstantiatingIterator extends InstantiatingIterator implements WizardDescriptor.ProgressInstantiatingIterator {	158	static class ProgressInstantiatingIterator extends InstantiatingIterator implements WizardDescriptor.ProgressInstantiatingIterator<WizardDescriptor> {
159	private TemplateWizardIterImpl itImpl;	159	private TemplateWizardIterImpl itImpl;
160	public ProgressInstantiatingIterator (TemplateWizardIterImpl it) {	160	public ProgressInstantiatingIterator (TemplateWizardIterImpl it) {
161	super (it);	161	super (it);