<api name="modal_run_methods"/>

        <summary>SPI added</summary>

        <version major="1" minor="10"/>

        <date day="1" month="2" year="2010"/>

        <author login="tboudreau"/>

        <compatibility addition="yes"/>

        <description>

            <p>

                Added methods to ProgressUtils for invoking a runnable or

                similar with

                a modal dialog blocking the UI and showing progress:

                <ul>

                    <li><code>public static void showProgressDialogAndRun(Runnable operation, String displayName)</code></li>

                    <li><code>public static <T> T showProgressDialogAndRun(final ProgressRunnable<T> operation, final String displayName, boolean includeDetailLabel)</code></li>

                    <li><code>public static void showProgressDialogAndRun(Runnable operation, ProgressHandle progress, boolean includeDetailLabel</code></li>

                </ul>

                Added interface ProgressRunnable for performing background

                work, and an SPI class ProgressRunOffEdtProvider which is

                implemented by the Progress UI module.

            </p>

        </description>

        <issue number="165005"/>

    </change>

    <change id="spi">

    String getDisplayName() {

        synchronized (internal) {

            return internal.getDisplayName();

        }

    }

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2010 Sun Microsystems, Inc.

 */

package org.netbeans.api.progress;

/**

 * Callable used by ProgressUtils.showProgressDialogAndRun to do background

 * work while a modal progress dialog is shown blocking all application windows.

 *

 * @author Tim Boudreau

 */

public interface ProgressRunnable<T> {

    /**

     * Perform the background work

     * @param handle A progress handle to post background work progress from.

     * The handle, when passed in, has had start() and setToIndeterminate() called.

     * @return The result of the background computation

     */

    public T run(ProgressHandle handle);

}

import java.util.concurrent.atomic.AtomicReference;

import org.netbeans.modules.progress.spi.ProgressRunOffEdtProvider;

    /**

     * Show a modal progress dialog that blocks the main window, while running

     * the passed runnable on a background thread.

     * <p/>

     * This method is thread-safe, and will block until the operation has

     * completed, regardless of what thread calls this method.

     * <p/>

     * Unless you are being passed the runnable or progress handle from foreign

     * code (such as in WizardDescriptor.progressInstantiatingIterator), it

     * is usually simpler to use the version of this method that takes a

     * <code>ProgressCallable</code>.

     *

     * @param operation A runnable to run in the background

     * @param progress A progress handle to create a progress bar for

     * @param includeDetailLabel True if the caller will use

     * ProgressHandle.progress (String, int), false if not.  If true, the

     * created dialog will include a label that shows progress details.

     */

    public static void showProgressDialogAndRun(Runnable operation, ProgressHandle progress, boolean includeDetailLabel) {

        if (PROVIDER instanceof ProgressRunOffEdtProvider) {

            ProgressRunOffEdtProvider p = (ProgressRunOffEdtProvider) PROVIDER;

            p.showProgressDialogAndRun(operation, progress, includeDetailLabel);

        } else {

            PROVIDER.runOffEventDispatchThread(operation, progress.getDisplayName(), new AtomicBoolean(false), false, 0, 0);

        }

    }

    /**

     * Show a modal progress dialog that blocks the main window, while running

     * the passed runnable on a background thread.

     * <p/>

     * This method is thread-safe, and will block until the operation has

     * completed, regardless of what thread calls this method.

     *

     * @param <T> The result type - use Void if no return type needed

     * @param operation A runnable-like object which performs work in the

     * background, and is passed a ProgressHandle to update progress

     * @param displayName The display name for this operation

     * @param includeDetailLabel If true, include a lable to show progress

     * details (needed only if you plan to call ProgressHandle.setProgress(String, int)

     * @return The result of the operation.

     */

    public static <T> T showProgressDialogAndRun(final ProgressRunnable<T> operation, final String displayName, boolean includeDetailLabel) {

        if (PROVIDER instanceof ProgressRunOffEdtProvider) {

            ProgressRunOffEdtProvider p = (ProgressRunOffEdtProvider) PROVIDER;

            return p.showProgressDialogAndRun(operation, displayName, includeDetailLabel);

        } else {

            final AtomicReference<T> ref = new AtomicReference<T>();

            PROVIDER.runOffEventDispatchThread(new Runnable() {

                @Override

                public void run() {

                    ProgressHandle handle = ProgressHandleFactory.createHandle(displayName);

                    handle.start();

                    handle.switchToIndeterminate();

                    try {

                        ref.set(operation.run(handle));

                    } finally {

                        handle.finish();

                    }

                }

            }, displayName, new AtomicBoolean(false), true, 0, 0);

            return ref.get();

        }

    }

    /**

     * Show a modal progress dialog that blocks the main window, while running

     * the passed runnable on a background thread with an indeterminate-state

     * progress bar.

     * <p/>

     * This method is thread-safe, and will block until the operation has

     * completed, regardless of what thread calls this method.

     * .

     * @param operation A runnable to run

     * @param displayName The display name of the operation, to show in the dialog

     */

    public static void showProgressDialogAndRun(Runnable operation, String displayName) {

        showProgressDialogAndRun(new RunnableWrapper(operation), displayName, false);

    }

    private static final class RunnableWrapper implements ProgressRunnable<Void> {

        private final Runnable toRun;

        RunnableWrapper(Runnable toRun) {

            this.toRun = toRun;

        }

        @Override

        public Void run(ProgressHandle handle) {

            toRun.run();

            return null;

        }

    }

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2010 Sun Microsystems, Inc.

 */

package org.netbeans.modules.progress.spi;

import org.netbeans.api.progress.ProgressRunnable;

import org.netbeans.api.progress.ProgressHandle;

/**

 * Extension to RunOffEDTProvider which allows for a modal dialog to

 * be shown which contains a progress bar.

 *

 * @author Tim Boudreau

 */

public interface ProgressRunOffEdtProvider extends RunOffEDTProvider{

    /**

     * Show a modal progress dialog that blocks the main window while running

     * a background process.  This call should block until the work is

     * completed.

     *

     * @param operation A runnable that needs to be run with the UI blocked

     * @param handle A progress handle that will be updated to reflect

     * the progress of the operation

     * @param showDetails If true, a label should be provided in the progress

     * dialog to show detailed progress messages

     */

    void showProgressDialogAndRun(Runnable operation, ProgressHandle handle, boolean showDetails);

    /**

     * Show a modal progress dialog that blocks the main window while running

     * a background process.  This call should block until the work is

     * completed.

     *

     * @param <T> The type of the return value

     * @param toRun A ProgressCallable which will be passed a progress handle

     * on a background thread, can do its work and (optionally) return a value

     * @param displayName The display name of the work being done

     * @param includeDetailLabel Show the detail levels.  Set to true if the

     * caller will use ProgressHandle.progress (String, int) to provide

     * detailed progress messages

     * @return The result of the call to ProgressRunnable.call()

     */

    <T> T showProgressDialogAndRun(ProgressRunnable<T> toRun, String displayName, boolean includeDetailLabel);

}

                    <test-dependency>

                        <code-name-base>org.netbeans.modules.nbjunit</code-name-base>

                        <compile-dependency/>

                    </test-dependency>

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.EventQueue;

import java.awt.Font;

import java.awt.Frame;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.GridLayout;

import java.awt.RenderingHints;

import java.awt.Toolkit;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

import javax.swing.BorderFactory;

import javax.swing.JComponent;

import javax.swing.JDialog;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.WindowConstants;

import org.netbeans.api.progress.ProgressRunnable;

import org.netbeans.api.progress.ProgressHandle;

import org.netbeans.api.progress.ProgressHandleFactory;

import org.netbeans.modules.progress.spi.ProgressRunOffEdtProvider;

import org.openide.util.Exceptions;

import org.openide.util.Utilities;

    @Override

    public void showProgressDialogAndRun(Runnable operation, ProgressHandle handle, boolean includeDetailLabel) {

       AbstractWindowRunner wr = new RunnableWindowRunner(operation, handle, includeDetailLabel);

       wr.start();

       if (!EventQueue.isDispatchThread()) {

            try {

                wr.await();

            } catch (InterruptedException ex) {

                Exceptions.printStackTrace(ex);

            }

       }

    }

    @Override

    public <T> T showProgressDialogAndRun(ProgressRunnable<T> toRun, String displayName, boolean includeDetailLabel) {

        AbstractWindowRunner<T> wr = new ProgressBackgroundRunner<T>(toRun, displayName, includeDetailLabel);

        wr.start();

        if (!EventQueue.isDispatchThread()) {

             try {

                 wr.await();

             } catch (InterruptedException ex) {

                 Exceptions.printStackTrace(ex);

             }

        }

        return wr.getResult();

    }

    private static abstract class AbstractWindowRunner<T> extends WindowAdapter implements Runnable {

        private volatile JDialog dlg;

        private final boolean includeDetail;

        protected final ProgressHandle handle;

        private final CountDownLatch latch = new CountDownLatch(1);

        private volatile T operationResult;

        AbstractWindowRunner(ProgressHandle handle, boolean includeDetail) {

            this.includeDetail = includeDetail;

            this.handle = handle;

        }

        @Override

        public final void windowOpened(WindowEvent e) {

            dlg = (JDialog) e.getSource();

            RequestProcessor.getDefault().post(this);

            grayOutMainWindow();

        }

        @Override

        public final void windowClosed(WindowEvent e) {

            ungrayMainWindow();

            latch.countDown();

        }

        final void await() throws InterruptedException {

            latch.await();

        }

        final void start() {

            if (EventQueue.isDispatchThread()) {

                createModalProgressDialog(handle, includeDetail);

            } else {

                CountDownLatch dlgLatch = new CountDownLatch(1);

                DialogCreator dc = new DialogCreator(dlgLatch);

                EventQueue.invokeLater (dc);

                try {

                    dlgLatch.await();

                } catch (InterruptedException ex) {

                    throw new IllegalStateException(ex);

                }

            }

        }

        protected abstract T runBackground();

        T getResult() {

            return operationResult;

        }

        @Override

        public void run() {

            if (!EventQueue.isDispatchThread()) {

                try {

                    operationResult = runBackground();

                } finally {

                    EventQueue.invokeLater(this);

                }

            } else {

                dlg.setVisible(false);

                dlg.dispose();

            }

        }

        private final class DialogCreator implements Runnable {

            private final CountDownLatch latch;

            DialogCreator (CountDownLatch latch) {

                this.latch = latch;

            }

            @Override

            public void run() {

                createModalProgressDialog(handle, includeDetail);

                latch.countDown();

            }

        }

        private JDialog createModalProgressDialog(ProgressHandle handle, boolean includeDetail) {

            assert EventQueue.isDispatchThread();

            int edgeGap = Utilities.isMac() ? 12 : 8;

            int compGap = Utilities.isMac() ? 9 : 5;

            JPanel panel = new JPanel(new GridLayout(includeDetail ? 3 : 2, 1, compGap, compGap));

            JLabel mainLabel = ProgressHandleFactory.createMainLabelComponent(handle);

            Font f = mainLabel.getFont();

            if (f != null) {

                mainLabel.setFont (f.deriveFont(Font.BOLD));

            }

            panel.add(mainLabel);

            JComponent progressBar = ProgressHandleFactory.createProgressComponent(handle);

            progressBar.setMinimumSize(new Dimension (400, 32));

            panel.add(progressBar);

            if (includeDetail) {

                JLabel details = ProgressHandleFactory.createDetailLabelComponent(handle);

                details.setMinimumSize(new Dimension(300, 16));

                panel.add(details);

            }

            panel.setBorder (BorderFactory.createCompoundBorder(

                    BorderFactory.createRaisedBevelBorder(),

                    BorderFactory.createEmptyBorder(edgeGap, edgeGap, edgeGap, edgeGap)));

            panel.setMinimumSize(new Dimension(400, 100));

            Frame mainWindow = WindowManager.getDefault().getMainWindow();

            JDialog result = new JDialog(mainWindow, true);

            result.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);

            result.setUndecorated(true);

            result.setSize(400, 100);

            result.getContentPane().setLayout(new BorderLayout());

            result.getContentPane().add(panel, BorderLayout.CENTER);

            result.pack();

            int reqWidth = result.getWidth();

            result.setSize(Math.max (reqWidth,

                    mainWindow instanceof JFrame ?

                        ((JFrame) mainWindow).getContentPane().getWidth() / 3 :

                        mainWindow.getWidth()), result.getHeight());

            result.setLocationRelativeTo(WindowManager.getDefault().getMainWindow());

            result.addWindowListener(this);

            result.setVisible(true);

            return result;

        }

        private Component oldGlassPane;

        private void grayOutMainWindow() {

            assert EventQueue.isDispatchThread();

            Frame f = WindowManager.getDefault().getMainWindow();

            if (f instanceof JFrame) {

                Map<?,?> hintsMap = (Map)(Toolkit.getDefaultToolkit().getDesktopProperty("awt.font.desktophints")); //NOI18N

                //Avoid translucent painting on, for example, remote X terminal

                if (hintsMap == null || !RenderingHints.VALUE_TEXT_ANTIALIAS_OFF.equals(hintsMap.get(RenderingHints.KEY_TEXT_ANTIALIASING))) {

                    JFrame jf = (JFrame) f;

                    TranslucentMask mask = new TranslucentMask();

                    oldGlassPane = jf.getGlassPane();

                    jf.setGlassPane(mask);

                    mask.setVisible(true);

                    mask.setBounds (0, 0, jf.getContentPane().getWidth(), jf.getContentPane().getHeight());

                    mask.invalidate();

                    mask.revalidate();

                    mask.repaint();

                    jf.getRootPane().paintImmediately(0, 0, jf.getRootPane().getWidth(), jf.getRootPane().getHeight());

                }

            }

        }

        private void ungrayMainWindow() {

            if (oldGlassPane != null) {

                JFrame jf = (JFrame) WindowManager.getDefault().getMainWindow();

                jf.setGlassPane(oldGlassPane);

                jf.invalidate();

                jf.repaint();

            }

        }

    }

    static final class TranslucentMask extends JComponent { //pkg private for tests

        TranslucentMask() {

            setVisible(false); //so we will trigger a property change

        }

        @Override

        public boolean isOpaque() {

            return false;

        }

        @Override

        public void paint (Graphics g) {

            Graphics2D g2d = (Graphics2D) g;

            Color translu = new Color (180, 180, 180, 148);

            g2d.setColor(translu);

            g2d.fillRect (0, 0, getWidth(), getHeight());

        }

    }

    private static final class ProgressBackgroundRunner<T> extends AbstractWindowRunner<T> {

        private final ProgressRunnable<T> toRun;

        public ProgressBackgroundRunner(ProgressRunnable<T> toRun, String displayName, boolean includeDetail) {

            super (ProgressHandleFactory.createHandle(displayName), includeDetail);

            this.toRun = toRun;

        }

        @Override

        protected T runBackground() {

            handle.start();

            handle.switchToIndeterminate();

            T result;

            try {

                result = toRun.run(handle);

            } finally {

                handle.finish();

            }

            return result;

        }

    }

    private static final class RunnableWindowRunner extends AbstractWindowRunner<Void> {

        private Runnable toRun;

        public RunnableWindowRunner(Runnable toRun, ProgressHandle progress, boolean includeDetail) {

            super (progress, includeDetail);

            this.toRun = toRun;

        }

        @Override

        protected Void runBackground() {

            toRun.run();

            return null;

        }

    }

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2010 Sun Microsystems, Inc.

 */

package org.netbeans.modules.progress.ui;

import java.awt.EventQueue;

import java.awt.Frame;

import java.awt.Image;

import java.awt.RenderingHints;

import java.awt.Toolkit;

import java.beans.PropertyChangeListener;

import java.util.Map;

import java.util.Set;

import javax.swing.Action;

import javax.swing.JFrame;

import org.netbeans.api.progress.ProgressHandle;

import org.openide.nodes.Node;

import org.openide.util.Exceptions;

import org.openide.windows.Mode;

import org.openide.windows.TopComponent;

import org.openide.windows.TopComponentGroup;

import org.openide.windows.WindowManager;

import org.junit.After;

import static org.junit.Assert.*;

import org.junit.AfterClass;

import org.junit.Before;

import org.junit.BeforeClass;

import org.junit.Test;

import org.netbeans.api.progress.ProgressRunnable;

import org.netbeans.api.progress.ProgressUtils;

import org.netbeans.junit.MockServices;

import org.openide.windows.Workspace;

/**

 *

 * @author Tim Boudreau

 */

public class RunOffEDTImplTest {

    public RunOffEDTImplTest() {

    }

    @BeforeClass

    public static void setUpClass() throws Exception {

    }

    @AfterClass

    public static void tearDownClass() throws Exception {

    }

    @Before

    public void setUp() {

        MockServices.setServices(WM.class, RunOffEDTImpl.class);

    }

    @After

    public void tearDown() {

    }

    private static boolean canTestGlassPane() {

        Map<?,?> hintsMap = (Map)(Toolkit.getDefaultToolkit().getDesktopProperty("awt.font.desktophints")); //NOI18N

        //Avoid translucent painting on, for example, remote X terminal

        return hintsMap == null || !RenderingHints.VALUE_TEXT_ANTIALIAS_OFF.equals(hintsMap.get(RenderingHints.KEY_TEXT_ANTIALIASING));

    }

    @Test

    public void testShowProgressDialogAndRun_3args_1_EQ() throws Exception {

        EventQueue.invokeAndWait(new Runnable() {

            @Override

            public void run() {

                testShowProgressDialogAndRun_3args_1();

            }

        });

    }

    @Test

    public void testShowProgressDialogAndRun_3args_2_EQ() throws Exception {

        EventQueue.invokeAndWait(new Runnable() {

            @Override

            public void run() {

                testShowProgressDialogAndRun_3args_2();

            }

        });

    }

    @Test

    public void testShowProgressDialogAndRun_3args_1() {

        assertEquals ("Done", ProgressUtils.showProgressDialogAndRun(new CB(), "Doing Stuff", true));

    }

    @Test

    public void testShowProgressDialogAndRun_3args_2() {

        final JFrame jf = (JFrame) WindowManager.getDefault().getMainWindow();

        class R implements Runnable {

            boolean hasRun;

            public void run() {

                try {

                    Thread.sleep(200);

                } catch (InterruptedException ex) {

                    Exceptions.printStackTrace(ex);

                }

                if (canTestGlassPane()) {

                    assertTrue (jf.getGlassPane() instanceof RunOffEDTImpl.TranslucentMask);

                }

                hasRun = true;

            }

        };

        R r = new R();

        ProgressUtils.showProgressDialogAndRun(r, "Something");

        assertTrue (r.hasRun);

    }

    private class CB implements ProgressRunnable<String> {

        @Override

        public String run(ProgressHandle handle) {

            handle.switchToDeterminate(5);

            for (int i= 0; i < 5; i++) {

                try {

                    Thread.sleep(200);

                } catch (InterruptedException ex) {

                    Exceptions.printStackTrace(ex);

                }

                handle.progress("Job " + i, i);

            }

            return "Done";

        }

    }

    public static final class WM extends WindowManager {

        private final JFrame jf = new JFrame ("Main Window");

        public WM() {

            jf.setVisible(true);

        }

        @Override

        public Mode findMode(String name) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        public Mode findMode(TopComponent tc) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        public Set<? extends Mode> getModes() {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        public Frame getMainWindow() {

            return jf;

        }

        @Override

        public void updateUI() {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        protected Component createTopComponentManager(TopComponent c) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        public Workspace createWorkspace(String name, String displayName) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        public Workspace findWorkspace(String name) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        public Workspace[] getWorkspaces() {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        public void setWorkspaces(Workspace[] workspaces) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        public Workspace getCurrentWorkspace() {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        public TopComponentGroup findTopComponentGroup(String name) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        public void addPropertyChangeListener(PropertyChangeListener l) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        public void removePropertyChangeListener(PropertyChangeListener l) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        protected void topComponentOpen(TopComponent tc) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        protected void topComponentClose(TopComponent tc) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        protected void topComponentRequestActive(TopComponent tc) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        protected void topComponentRequestVisible(TopComponent tc) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        protected void topComponentDisplayNameChanged(TopComponent tc, String displayName) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        protected void topComponentHtmlDisplayNameChanged(TopComponent tc, String htmlDisplayName) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        protected void topComponentToolTipChanged(TopComponent tc, String toolTip) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        protected void topComponentIconChanged(TopComponent tc, Image icon) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        protected void topComponentActivatedNodesChanged(TopComponent tc, Node[] activatedNodes) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        protected boolean topComponentIsOpened(TopComponent tc) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        protected Action[] topComponentDefaultActions(TopComponent tc) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        protected String topComponentID(TopComponent tc, String preferredID) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

        @Override

        public TopComponent findTopComponent(String tcID) {

            throw new UnsupportedOperationException("Not supported yet.");

        }

    }

}