Wednesday, July 30, 2014

Java Swing "Flash" a Component

One line of code:
    new ComponentFlasher().flashNow(myTextField);  // works on buttons too

Sometimes people need help finding messages on screen, or seeing data that has changed. The above code will change the color of the text in the text field myTextField to red, then quickly fade it back to black.

 

ComponentFlasher.java :


import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.LinkedList;
import java.util.List;
import javax.swing.JComponent;
import javax.swing.SwingUtilities;
import javax.swing.Timer;

// Please feel free to reuse, modify and distribute.  
// Please add your own url or email address to this list:
//
// - http://javajon.blogspot.com/
//

/**
 * Class to make it easy to flash a component.
 */
public class ComponentFlasher {

    private final List flashQueue = new LinkedList();
    private final Object FLASH_LOCK = new Object();
    private volatile JComponent flashCurrent = null;
    private final FlashTimer flashTimer = new FlashTimer();
    private final int maxQueueSize = 3;

    public void flashQueue(JComponent componentToAddToQueue) {
        synchronized (FLASH_LOCK) {
            if (flashCurrent == componentToAddToQueue) {
                flashReset(componentToAddToQueue);
            } else {
                final boolean restartTimer = flashQueue.isEmpty() && (flashCurrent == null);
                flashQueue.remove(componentToAddToQueue);
                flashQueue.add(componentToAddToQueue);
                if (restartTimer) {
                    flashTimer.start();
                }
            }
        }
    }

    public void flashNow(final JComponent componentToFlashNow) {
        synchronized (FLASH_LOCK) {
            if (flashCurrent != componentToFlashNow) {
                final boolean restartTimer;
                if (flashCurrent != null) {
                    final JComponent componentToPutBackIntoTheQueue = flashCurrent;
                    flashQueue.remove(componentToPutBackIntoTheQueue);
                    flashQueue.add(0, componentToPutBackIntoTheQueue);

                    SwingUtilities.invokeLater(new Runnable() {
                        @Override
                        public void run() {
                            componentToPutBackIntoTheQueue.setForeground(Color.BLACK);
                        }
                    });

                    restartTimer = false;
                } else {
                    restartTimer = flashQueue.isEmpty();
                }
                flashCurrent = componentToFlashNow;
                if (restartTimer) {
                    flashTimer.start();
                }
            }
            flashReset(componentToFlashNow);
        }
    }

    private void flashReset(final JComponent componentToFlashNow) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                componentToFlashNow.setForeground(Color.RED);
            }
        });
    }

    private void flashIteration(final JComponent componentToFlash) {
        // run this code on the UI thread
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                // find out how red we still are
                final int red = flashCurrent.getForeground().getRed() - 10;
                if (red > 0) {
                    componentToFlash.setForeground(new Color(red, 0, 0));
                } else {
                    synchronized (FLASH_LOCK) {
                        if (flashCurrent == componentToFlash) {
                            flashCurrent = null;
                        }
                    }
                }
            }
        });
    }

    private void checkQueue() {
        // no current component - check queue
        if (!flashQueue.isEmpty()) {
            synchronized (FLASH_LOCK) {
                // recheck the same flags we just checked
                // now that we have the lock we are sure they won't change.
                if (flashCurrent == null) {
                    if (flashQueue.isEmpty()) {
                        // stop the timer
                        flashTimer.stop();
                    } else {
                        // make the next item current
                        while (flashQueue.size() > (maxQueueSize + 1)) {
                            flashQueue.remove(0);
                        }
                        final JComponent next = flashQueue.remove(0);
                        flashCurrent = next;
                        flashReset(next);
                    }
                }
            }
        }
    }

    private class FlashTimer extends Timer {

        public FlashTimer() {
            super(50, new FlashTimerAction());
        }
    }

    private class FlashTimerAction implements ActionListener {

        public FlashTimerAction() {
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            // is there a current component ?
            if (flashCurrent == null) {
                checkQueue();
            } else {
                // current component - copy to send to anon-implementation Runnable
                flashIteration(flashCurrent);
            }
        }
    }
}


Wednesday, July 23, 2014

Easy Right-Click Menus for Any Java Swing Application

Add right mouse click (Select All, Copy, Paste) to an entire Java Swing application in one line of code. Sound too good to be true? Before you load your first screen:

new RightMouseMenuMaker().start();

// load your first frame, window, or swingworker here.
 
Add the above line of code and the following file to your project and you're done.
 
RightMouseMenuMaker.java :

import java.awt.AWTEvent;
import java.awt.Component;
import java.awt.Container;
import java.awt.Toolkit;
import java.awt.event.AWTEventListener;
import java.awt.event.ActionEvent;
import java.awt.event.ContainerEvent;
import java.awt.event.ContainerListener;
import java.awt.event.KeyEvent;
import java.util.ArrayList;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.SwingUtilities;
import javax.swing.text.JTextComponent;
import javax.swing.text.TextAction;

/**
 * Library code to add RIGHT-CLICK menus to a Java Swing desktop application.
 * usage:  
new RightMouseMenuMaker().start();
* * @author javajon.blogspot.com */ public class RightMouseMenuMaker implements AWTEventListener, ContainerListener { private boolean enabled = true; /** * register this event listener as a global event listener. */ public void start() { Toolkit.getDefaultToolkit().addAWTEventListener(this, -1L); } /** * * @return the enabled state */ public boolean isEnabled() { return enabled; } /** * enable or disable this event listener. * * @param enabled */ public void setEnabled(boolean enabled) { this.enabled = enabled; } /** * @see java.awt.event.AWTEventListener * @param event */ @Override public void eventDispatched(AWTEvent event) { if (!this.enabled) { return; } if (event instanceof ContainerEvent) { ContainerEvent ce = (ContainerEvent) event; if (ce.getID() == ContainerEvent.COMPONENT_ADDED) { componentAdded(ce); } } } /** * @see java.awt.event.ContainerListener * @param ce */ @Override public void componentAdded(ContainerEvent ce) { final Component child = ce.getChild(); addRightMouseContextMenus(child); } /** * @see java.awt.event.ContainerListener * @param ce */ @Override public void componentRemoved(ContainerEvent e) { } /** * queue to allow the right mouse menus to be added on a background thread * after the screen has been displayed. on larger screens with numerous * controls, adding the right menu click to each component may take some * time. */ private static final BlockingQueue componentsWaitingForRightMouseMenus = new LinkedBlockingDeque<>(); /** * background thread to add the right mouse menus after the screen has been * displayed. on larger screens with numerous controls, adding the right * menu click to each component may take some time. */ private static final Thread rightMouseMenuMakerThread = new Thread(new ComponentQueue(), "Right Mouse Menu Maker"); /** * start the background thread as soon as the first instance of this class * is created. */ static { rightMouseMenuMakerThread.start(); } /** * adds a right mouse menu to a component and any child components. * @param component */ public static void addRightMouseContextMenus(Component component) { try { componentsWaitingForRightMouseMenus.put(component); } catch (InterruptedException ex) { Logger.getLogger(RightMouseMenuMaker.class.getName()) .log(Level.SEVERE, null, ex); } } /** * adds a right mouse menu to a component and any child components. * @param component */ private static void addRightMouseContextMenusPrivate(Component component) { if (component instanceof JTextComponent) { JTextComponent textComponent = (JTextComponent) component; final JPopupMenu existingContextMenu = textComponent.getComponentPopupMenu(); if (existingContextMenu == null) { final JPopupMenu newContextMenu = getContextMenu(textComponent); textComponent.setComponentPopupMenu(newContextMenu); } } if (component instanceof Container) { Container container = (Container) component; for (Component c : container.getComponents()) { addRightMouseContextMenusPrivate(c); } } } /** * creates a right mouse menu for any JTextComponent. * @return right mouse menu * @see javax.swing.text.JTextComponent * @param textComponent */ public static JPopupMenu getContextMenu( final JTextComponent textComponent) { JMenuItem menuItem; // menu container final JPopupMenu rightClickMenu; rightClickMenu = new JPopupMenu("Edit"); // ----------- final TextAction selectAllAction = new TextAction("Select All") { @Override public void actionPerformed(ActionEvent e) { textComponent.selectAll(); if (getFocusedComponent() != textComponent) { textComponent.grabFocus(); } } }; menuItem = new JMenuItem(selectAllAction); menuItem.setMnemonic(KeyEvent.VK_A); rightClickMenu.add(menuItem); // ----------- rightClickMenu.addSeparator(); // ----------- final TextAction cutAction = new TextAction("Cut") { @Override public void actionPerformed(ActionEvent e) { final String selectedText = textComponent.getSelectedText(); if (selectedText == null || "".equals(selectedText)) { textComponent.selectAll(); } textComponent.cut(); if (getFocusedComponent() != textComponent) { textComponent.grabFocus(); } } }; menuItem = new JMenuItem(cutAction); menuItem.setMnemonic(KeyEvent.VK_T); rightClickMenu.add(menuItem); // ----------- rightClickMenu.addSeparator(); // ----------- final TextAction copyAction = new TextAction("Copy") { @Override public void actionPerformed(ActionEvent e) { final String selectedText = textComponent.getSelectedText(); if (selectedText == null || "".equals(selectedText)) { textComponent.selectAll(); } textComponent.copy(); if (getFocusedComponent() != textComponent) { textComponent.grabFocus(); } } }; menuItem = new JMenuItem(copyAction); menuItem.setMnemonic(KeyEvent.VK_C); rightClickMenu.add(menuItem); // ----------- final TextAction copyAllAction = new TextAction(" Copy All") { @Override public void actionPerformed(ActionEvent e) { textComponent.selectAll(); textComponent.copy(); if (getFocusedComponent() != textComponent) { textComponent.grabFocus(); } } }; menuItem = new JMenuItem(copyAllAction); menuItem.setFont(menuItem.getFont() .deriveFont(menuItem.getFont().getSize2D() * 0.75f)); menuItem.setMnemonic(KeyEvent.VK_O); rightClickMenu.add(menuItem); // ----------- rightClickMenu.addSeparator(); // ----------- final TextAction pasteIntoAction = new TextAction("Paste") { @Override public void actionPerformed(ActionEvent e) { textComponent.paste(); if (getFocusedComponent() != textComponent) { textComponent.grabFocus(); } } }; menuItem = new JMenuItem(pasteIntoAction); menuItem.setMnemonic(KeyEvent.VK_P); rightClickMenu.add(menuItem); // ----------- final TextAction pasteReplaceAllAction = new TextAction(" Replace All") { @Override public void actionPerformed(ActionEvent e) { textComponent.selectAll(); textComponent.paste(); if (getFocusedComponent() != textComponent) { textComponent.grabFocus(); } } }; menuItem = new JMenuItem(pasteReplaceAllAction); menuItem.setFont(menuItem.getFont() .deriveFont(menuItem.getFont().getSize2D() * 0.75f)); menuItem.setMnemonic(KeyEvent.VK_O); rightClickMenu.add(menuItem); // ----------- final TextAction pasteInsertAtStartAction = new TextAction(" Insert at Start") { @Override public void actionPerformed(ActionEvent e) { textComponent.select(0, 0); textComponent.paste(); textComponent.select(0, 0); if (getFocusedComponent() != textComponent) { textComponent.grabFocus(); } } }; menuItem = new JMenuItem(pasteInsertAtStartAction); menuItem.setFont(menuItem.getFont() .deriveFont(menuItem.getFont().getSize2D() * 0.75f)); menuItem.setMnemonic(KeyEvent.VK_B); rightClickMenu.add(menuItem); // ----------- final TextAction pasteAppendAtEndAction = new TextAction(" Append at End") { @Override public void actionPerformed(ActionEvent e) { final String text = textComponent.getText(); if (text == null) { textComponent.select(0, 0); } else { final int length = text.length(); textComponent.select(length, length); } textComponent.paste(); if (getFocusedComponent() != textComponent) { textComponent.grabFocus(); } } }; menuItem = new JMenuItem(pasteAppendAtEndAction); menuItem.setFont(menuItem.getFont() .deriveFont(menuItem.getFont().getSize2D() * 0.75f)); menuItem.setMnemonic(KeyEvent.VK_E); rightClickMenu.add(menuItem); return rightClickMenu; } static class ComponentQueue implements Runnable { public ComponentQueue() { } @Override public void run() { try { while (true) { final ArrayList arrayList = new ArrayList(); // block the thread -- wait until there is a component arrayList.add(componentsWaitingForRightMouseMenus.take()); componentsWaitingForRightMouseMenus.drainTo(arrayList); // short delay -- any more components right away? while (true) { final Component maybe = componentsWaitingForRightMouseMenus .poll(500L, TimeUnit.MILLISECONDS); if (maybe == null) { break; } else { arrayList.add(maybe); componentsWaitingForRightMouseMenus .drainTo(arrayList); } } // marshall the list of components to the UI thread // for further processing SwingUtilities.invokeLater(new Runnable() { @Override public void run() { for (final Component component : arrayList) { addRightMouseContextMenusPrivate(component); } } }); } } catch (InterruptedException ex) { Logger.getLogger(RightMouseMenuMaker.class.getName()) .log(Level.SEVERE, null, ex); } } } }

Friday, July 18, 2014

Java Desktop (e.g. Swing) Network Deployment Batch File

Most networks are fast enough these days to run your JAR right from the network share, but file locking makes deployment difficult with multiple users.

This batch file checks the network location for a newer versions of the JAR file and lib/ folder, and updates the local copy only if a newer copy is available. Then the latest copy is executed locally.

Network-Java-App-Deploy.bat
@echo off

rem JAR file and installation folder (no trailing slashes):
set jar_file=myjavaprogram.jar
set dist_dir=\\server\share\folder

rem users should have read/write access to this folder:
set inst_dir=%appdata%\%jar_file%

rem customize the text to appear in the command window title bar
title Java Application Updater
cls

echo.
echo Java Application Updater
echo.
echo Please feel free to use, reuse, modify, reproduce and distribute.
echo Code is as-is, without warrantee.  User assumes all liability for use.
echo.
echo JAR:   %jar_file%
echo FROM:  %dist_dir%
echo TO:    %inst_dir%
echo.
echo Close the window to cancel . . .
pause

echo.
echo when redistributing, please keep the following URLs 
echo here in the code, so that other's may see the sources
echo and the versions of this batch file:
echo.
echo  - http://javajon.blogspot.com/
echo.

echo.
echo verify %inst_dir%, %username%, temp and lib ...
mkdir "%inst_dir%"
mkdir "%inst_dir%\%username%"
mkdir "%inst_dir%\%username%\temp"
mkdir "%inst_dir%\%username%\lib"

echo.
echo copy application jar file:  %username%\%jar_file% ...
xcopy /D/C/H/R/I/F/K/Y/V "%dist_dir%\%jar_file%" "%inst_dir%\%username%\"

echo.
echo copy lib folder:  %username%\lib ...
xcopy /D/C/H/R/I/F/K/Y/E/V "%dist_dir%\lib\*.*" "%inst_dir%\%username%\lib\"
echo.

cd /D "%inst_dir%\%username%"
cd "%inst_dir%\%username%"
start %jar_file%

goto :skip_xcopy_switches_explanation

 These are the XCOPY command line switches we are using:
 
  single: /D/C/H/R/I/F/K/Y/V
  folder: /D/C/H/R/I/F/K/Y/E/V

 These are the above switches briefly described:
  
  /D - Copy files that are newer than the destination files
  /C - Continue even on error
  /H - Copy hidden and system files, too
  /R - Overwrite read-only files
  /I - Copies more than one file to destination 
    (assumes destination is a directory)
  /F - Displays full path and destination while copying files
  /K - Copies attributes (as opposed to resetting read-only attributes)
  /Y - Copy without confirming replacement of existing files
  /E - Copies any subdirectories, even if they are empty
  /V - Verifies each file as it is written to the destination file

:skip_xcopy_switches_explanation

Add JMenuItem to JMenu after the menu has already been displayed to the user.

How I would do it ...


Temporarily disable new menus to prevent accidental clicks ...


MyMenuListener - How to use it:
        fileMenu.addMenuListener(new MyMenuListener(fileMenu) {

            @Override
            protected void quickMenu(MyMenuListener.MyMenuWorker menuWorker) {

                menuWorker.add(new JMenuItem("Fast New Menu A"));
                menuWorker.add(new JMenuItem("Fast New Menu B"));

            }

            @Override
            protected void slowMenu(MyMenuListener.MyMenuWorker menuWorker) {

                /** do something here that takes a long time. */
                
                menuWorker.add(new JMenuItem("Delayed Menu 1"));
                menuWorker.add(new JMenuItem("Delayed Menu 2"));
                
            }
        });



MyMenuListener - The code:  (as a single executable java file)
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.SwingUtilities;
import javax.swing.SwingWorker;
import javax.swing.Timer;
import javax.swing.event.MenuEvent;
import javax.swing.event.MenuListener;

/**
 * Demonstrates how to add menu items to a menu, dynamically on a background
 * thread using a SwingWorker, after the menu has already been displayed on
 * screen.
 *
 * @author javajon.blogspot.com
 */
public class SwingWorkerMenuBar extends javax.swing.JFrame {

    private javax.swing.JMenu fileMenu;

    /**
     * Creates new form SwingWorkerMenuBar. (yay?)
     */
    public SwingWorkerMenuBar() {
        initComponents();

        /**
         * this part is required for the menu to be dynamic.
         */
        fileMenu.addMenuListener(new MyMenuListener(fileMenu) {

            /**
             * This is the part that catches the menu just before it's displayed
             * so we can make immediate modifications. Any modifications you can
             * make from memory (i.e. without hitting a database or a file
             * system) can be made here and will display with the menu the first
             * time it becomes visible. Caution: if you put your
             * long-running code here then the menu won't show up at all until
             * your long-running code is done.
             */
            @Override
            protected void quickMenu(MyMenuListener.MyMenuWorker menuWorker) {

                menuWorker.add(new JMenuItem("Fast New Menu A"));
                menuWorker.add(new JMenuItem("Fast New Menu B"));

            }

            /**
             * this is where we add menus that might take some time to build ie
             * data has to be looked up in the database or read from a file
             * store or network share.
             */
            @Override
            protected void slowMenu(MyMenuListener.MyMenuWorker menuWorker) {
                for (int i = 500; i >= 50; i = (i / 33) * 25) {
                    try {

                        // simulate processing & send a new menu to UI
                        Thread.sleep(i);
                        menuWorker.add(new JMenuItem("New Menu " + i + " Delay"));

                    } catch (InterruptedException ex) {
                        Logger.getLogger(SwingWorkerMenuBar.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }
            }
        });
        
    }

    public static abstract class MyMenuListener implements MenuListener, ActionListener {

        /**
         * This is the part that catches the menu just before it's displayed so
         * we can make immediate modifications. Any modifications you can make
         * from memory (i.e. without hitting a database or a file system) can be
         * made here and will display with the menu the first time it becomes
         * visible. Caution: if you put your long-running code here then
         * the menu won't show up at all until your long-running code is done.
         *
         * @param menuWorker use this object to add new menus
         */
        protected abstract void quickMenu(MyMenuWorker menuWorker);

        /**
         * this is where we add menus that might take some time to build ie data
         * has to be looked up in the database or read from a file store or
         * network share.
         *
         * @param menuWorker use this object to add new menus
         */
        protected abstract void slowMenu(MyMenuWorker menuWorker);

        /**
         * the menu with which this listener is associated.
         */
        private final JMenu menu;

        /**
         * the menus that have been created using menuWorker.add(menuItem).
         */
        private final List myMenus = new ArrayList();

        /**
         * the menus that have been disabled to prevent the user from
         * accidentally clicking on a menu that wasn't there a moment ago.
         */
        private final List menusToEnable = new ArrayList();

        /**
         * basic lock object to make sure threads are playing nice with shared
         * memory.
         */
        private final Object LOCK = new Object();

        /**
         * this is the part that re-enables menu options.
         */
        private final javax.swing.Timer timer = new Timer(300, this);

        /**
         * constructor.
         * @param menu 
         */
        public MyMenuListener(final JMenu menu) {
            this.menu = menu;
        }

        /**
         * this happens when the user clicks the menu, but before the pop up
         * menu appears.
         * @param e 
         */
        @Override
        public void menuSelected(MenuEvent e) {
            new MyMenuWorker(menu).execute();
        }

        @Override
        public void menuDeselected(MenuEvent e) {

        }

        @Override
        public void menuCanceled(MenuEvent e) {

        }

        /**
         * background worker that can do long-running tasks such as database
         * queries and then add more menu options to the list after the list has
         * already been displayed.
         */
        public class MyMenuWorker extends SwingWorker {

            private boolean quick;
            private int insertAt = 0;
            private final JMenu menu;

            public MyMenuWorker(JMenu menu) {
                synchronized (LOCK) {
                    this.menu = menu;                    

                    // clear out menus that were added last time
                    for (int i = 0; i < menu.getItemCount(); i++) {
                        final JMenuItem menuItem = menu.getItem(i);
                        if (menuItem != null && myMenus.contains(menuItem)) {
                            if (myMenus.remove(menuItem)) {
                                menu.remove(menuItem);
                                i--;
                            }
                        }
                    }

                    // add instant menus
                    this.quick = true;
                }
                quickMenu(this);
                synchronized (LOCK) {
                    this.insertAt = menu.getItemCount(); // end of list
                }
            }

            @Override
            protected Boolean doInBackground() throws Exception {
                synchronized (LOCK) {
                    this.quick = false;
                }
                slowMenu(this);
                return null;
            }

            /**
             * add menu items after the menu has already been shown. these are
             * the menu items that are published above using publish().
             *
             * @param menuItems menu items to add
             */
            @Override
            protected void process(List menuItems) {
                final int originalInsert = insertAt;
                for (final JMenuItem item : menuItems) {
                    myMenus.add(item);
                    menu.add(item, insertAt++);
                }
                tempDisable(menu, originalInsert);
                resizeMenu();
            }

            /**
             * feel free to reuse, modify, or distribute.
             * http://javajon.blogspot.com/
             */
            private void resizeMenu() {
                final JPopupMenu popupMenu = menu.getPopupMenu();
                if (popupMenu.isVisible()) {

                    // redraw the menu
                    menu.revalidate();

                    // resize the menu
                    popupMenu.setVisible(false);
                    popupMenu.setVisible(true);

                }
            }

            /**
             * report errors.
             */
            @Override
            protected void done() {
                try {
                    get();
                } catch (InterruptedException ex) {
                    Logger.getLogger(SwingWorkerMenuBar.class.getName()).log(Level.INFO, null, ex);
                } catch (ExecutionException ex) {
                    Logger.getLogger(SwingWorkerMenuBar.class.getName()).log(Level.INFO, null, ex);
                }
            }

            /**
             * when called from quickMenu() this method
             *
             * @param item
             */
            void add(JMenuItem item) {
                if (quick) {
                    myMenus.add(menu.add(item));
                } else {
                    publish(item);
                }
            }

        }

        /**
         * temporarily disables menu options because they are changing and you
         * don't want the user to click and have the menu option change just
         * before the click is made.
         *
         * @param menu
         * @param firstIndex
         */
        private void tempDisable(
                final JMenu menu,
                final int firstIndex) {

            synchronized (LOCK) {
                int insertAt = 0;
                for (int i = firstIndex; i < menu.getItemCount(); i++) {
                    final JMenuItem menuItem = menu.getItem(i);
                    if (menuItem.isEnabled()) {
                        menuItem.setEnabled(false);
                        if (!menusToEnable.contains(menuItem)) {
                            menusToEnable.add(insertAt++, menuItem);
                        }
                    }
                }

                timer.start();
            }

        }

        /**
         * this is the code that re-enables menus when they have been disabled
         * to prevent accidental clicking. this is the ActionListener
         * implementation for the timer task.
         *
         * @param e
         */
        @Override
        public void actionPerformed(ActionEvent e) {

            synchronized (LOCK) {
                if (menusToEnable.isEmpty()) {

                    /**
                     * if there's nothing to do, kill the timer.
                     */
                    timer.stop();

                } else {

                    /**
                     * re-enable the menus.
                     */
                    SwingUtilities.invokeLater(new Runnable() {
                        @Override
                        public void run() {
                            synchronized (LOCK) {
                                if (!menusToEnable.isEmpty()) {
                                    // enable the first menu that's disabled
                                    for (int i = 0; i < menu.getItemCount(); i++) {
                                        final JMenuItem enableMe = menu.getItem(i);
                                        if (menusToEnable.contains(enableMe)) {
                                            // enable one custom menu and quit
                                            enableMe.setEnabled(true);
                                            enableMe.revalidate();
                                            menusToEnable.remove(enableMe);
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    });

                } // empty / kill timer
            } // synchronized
        }

    }

    /**
     * create a simple form with a file menu.
     */
    private void initComponents() {
        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

        /**
         * simulate a file menu with a single menu option on it.
         */
        final javax.swing.JMenuBar menuBar;
        setJMenuBar(menuBar = new javax.swing.JMenuBar());
        menuBar.add(this.fileMenu = new javax.swing.JMenu("File"));
        fileMenu.add("Existing Menu I");
        fileMenu.add("Existing Menu II");

        /**
         * form content, form size (i think), and center on screen.
         */
        getContentPane().setPreferredSize(new Dimension(400, 260));
        pack();
        setLocationRelativeTo(null);

    }

    /**
     * default program entry point -- generated by NetBeans.
     *
     * @param args the command line arguments
     */
    public static void main(String args[]) {

        /* Create and display the form */
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new SwingWorkerMenuBar().setVisible(true);
            }
        });
    }

}