MatrixMenus.java

package net.squiz.matrix.ui;

import net.squiz.matrix.core.*;
import net.squiz.matrix.debug.*;
import net.squiz.matrix.assetmap.*;
import net.squiz.matrix.matrixtree.*;

import javax.swing.*;
import javax.swing.tree.*;
import java.util.*;
import java.awt.*;
import javax.swing.event.*;
import java.awt.event.*;
import java.net.*;

public class MatrixMenus implements MatrixConstants {

    private static JMenu addMenu;
    private static ImageLoader loader = new ImageLoader();
    public static final String DEFAULT_ASSET_ICON = "default_asset.png";

    // cannot instantiate
    private MatrixMenus() {}

    public static JPopupMenu getPopupScreenMenu(MatrixTreeNode node) {
        return getScreenMenu(node).getPopupMenu();
    }

    public static JPopupMenu getPopupScreenMenu(
        MatrixTreeNode node, ActionListener listener) {
            return getScreenMenu(node, listener).getPopupMenu();
    }

    public static JMenu getScreenMenu(MatrixTreeNode node) {
        return getScreenMenu(node, getDefaultScreenMenuListener(node));
    }

    public static JMenu getScreenMenu(MatrixTreeNode node, ActionListener listener) {
        JMenu menu        = new JMenu();
        final Asset asset = node.getAsset();
        AssetType type    = asset.getType();
        Iterator screens  = type.getScreens();

        while (screens.hasNext()) {
            AssetTypeScreen screen = (AssetTypeScreen) screens.next();
            JMenuItem item = new JMenuItem(screen.getScreenName());
            item.setFont(MatrixTreeBus.getActiveTree().getFontInUse());
            item.addActionListener(listener);
            item.setActionCommand(screen.getCodeName());
            menu.add(item);
        }
        return menu;
    }

    public static ActionListener getDefaultScreenMenuListener(final MatrixTreeNode node) {
        ActionListener screenListener = new ActionListener() {
            public void actionPerformed(ActionEvent evt) {
                Asset asset = node.getAsset();
                String command = evt.getActionCommand();

                String assetPath = MatrixToolkit.rawUrlEncode(node.getAssetPath(), true);
                String linkPath  = MatrixToolkit.rawUrlEncode(node.getLinkPath(), true);
                String assetid   = MatrixToolkit.rawUrlEncode(asset.getId(), true);

                String screenUrl = getScreenUrl(
                    assetid,
                    assetPath,
                    linkPath,
                    command
                );
                try {
                    AssetMap.getURL(screenUrl);
                } catch (MalformedURLException mue) {
                    Object[] transArgs = {
                        mue.getMessage()
                    };
                    String message = Matrix.translate("asset_map_error_screen_url", transArgs);
                    GUIUtilities.error(message, Matrix.translate("asset_map_dialog_title_error"));
                    Log.log(message, MatrixMenus.class, mue);
                }
            }
        };
        return screenListener;
    }
    private static String getScreenUrl(
        String assetid,
        String assetPath,
        String linkPath,
        String screenName) {
            String url =
                Matrix.getProperty("parameter.url.baseurl") +
                Matrix.getProperty("parameter.backendsuffix") +
                "/?SQ_BACKEND_PAGE=main&backend_section=" +
                "am&am_section=edit_asset&assetid=" + assetid +
                "&sq_asset_path=" + assetPath + "&sq_link_path=" +
                linkPath + "&asset_ei_screen=" + screenName;
            return url;
    }

    // }}}

    // {{{ Use Me Menu

    public static JPopupMenu getUseMeMenu(final MatrixTreeNode node) {
        JPopupMenu menu = new JPopupMenu();

        ActionListener useMeListener = new ActionListener() {
            public void actionPerformed(ActionEvent evt) {
                Asset asset = node.getAsset();
                String[] info = new String[] {
                    asset.getId(),
                    node.getName(),
                    node.getURL(),
                    node.getLinkid(),
                    asset.getType().toString(),
                };
                netscape.javascript.JSObject window = netscape.javascript.JSObject.getWindow(AssetMap.getApplet());
                window.call("asset_finder_done", info);
                MatrixTreeBus.stopAssetFinderMode();
            }
        };

        JMenuItem item = new JMenuItem(Matrix.translate("asset_map_menu_useme"));
        item.addActionListener(useMeListener);
        item.setFont(MatrixTreeBus.getActiveTree().getFontInUse());
        menu.add(item);

        return menu;
    }

    // }}}

    // {{{ Add Menu

    public static ActionListener getMatrixTreeAddMenuListener(final MatrixTree tree) {
        ActionListener addMenuListener = new ActionListener() {
            public void actionPerformed(ActionEvent evt) {
                if (evt.getSource() instanceof JMenuItem) {
                    JMenuItem item = (JMenuItem) evt.getSource();

                    tree.initiateAddMode(
                    new TreePath[] { new TreePath(MatrixMenus.getTypeCodeFromEvent(evt)) },
                        item.getLocation()
                    );
                }
            }
        };
        return addMenuListener;
    }

    public static JPopupMenu getPopupAddMenu(ActionListener listener) {
        JPopupMenu popupAddMenu = getAddMenu(listener).getPopupMenu();
        popupAddMenu.addPopupMenuListener(loader);
        return popupAddMenu;
    }

    public static JMenu getAddMenu(ActionListener listener) {

        // if the menu is not null, then we have already created it
        // so just return it
    //  if (menu != null)
    //      return menu;

        addMenu = new JMenu(Matrix.translate("asset_map_menu_add_new"));
        addMenu.addMenuListener(loader);
        Iterator it = AssetManager.getAssetTypes();

        while (it.hasNext()) {
            AssetType type = (AssetType) it.next();

            // if this asset type is not createable by this user
            // then we don't want it in the menu
            if (!(type.isCreatable()))
                continue;

            // get a list of menu paths for this asset type
            // this may be null which indicates that there are no
            // paths for this asset type (it exists in the root "Add" menu)

            String[] paths = type.getMenuPath();
            MenuElement parentMenu = addMenu;

            if (paths.length > 0) {

                boolean found = false;
                String path = null;
                MenuElement[] elements = null;

                for (int i = 0; i < paths.length; i++) {
                    path = paths[i];
                    found = false;

                    // get the current parent menu, and see if we
                    // already have this path
                    elements = parentMenu.getSubElements();

                    if (elements.length > 0 && elements[0] instanceof JPopupMenu)
                        elements = elements[0].getSubElements();

                    for (int j = 0; j < elements.length; j++) {
                        Component component = (Component) elements[j];
                        if (component instanceof JMenu) {
                            if (component.getAccessibleContext().getAccessibleName().equals(path)) {
                                // set the current parent menu to the menu that we just found
                                parentMenu = (JMenu) component;
                                found = true;
                            }
                        }
                    }//end for

                    if (!found) {
                        // if we cant find it, create a new JMenu to
                        // list this asset type
                        JMenu newMenu = new JMenu(path);
                        newMenu.getAccessibleContext().setAccessibleName(path);
                        newMenu.addMenuListener(loader);

                        addNewItem(
                            parentMenu,
                            newMenu,
                            getMenuIndex(path, parentMenu, newMenu.getClass()),
                            listener
                        );

                        // if there are no more paths for this menu,
                        // then we want to add this asset type under the
                        // newly created menu

                        if (i == paths.length - 1) {
                            addMenuItem(newMenu, type, listener);
                        }
                    } else {
                        // else we found the JMenu for this path
                        // so just add the new asset type under that menu
                        addMenuItem(parentMenu, type, listener);
                    }//end if not found
                }//end for
            } else {
                // there are no paths for this asset type so just add it in
                // the root "Add" menu
                addMenuItem(addMenu, type, listener);
            }//end if has paths
        }//end while

        return addMenu;
    }

    private static int getMenuIndex(String name, MenuElement parentMenu, Class cls){
        int i = 0;
        MenuElement[] components = parentMenu.getSubElements();
        for (i = 0; i < components.length; i++) {

            // because the way that popups work, there may be some menus
            // whose only child is a popupmenu, in that case, we want the children
            // of the popup menu to be processed
            if (components[i] instanceof JPopupMenu)
                return getMenuIndex(name, components[i], cls);

            Component nextMenu = (Component) components[i];
            String otherName = "";

            if (nextMenu.getClass().equals(JMenuItem.class)) {
                String typeCode = nextMenu.getAccessibleContext().getAccessibleName();
                otherName = AssetManager.getAssetType(typeCode).getName();
            } else {
                otherName = nextMenu.getAccessibleContext().getAccessibleName();
            }
            // if its just a single item, then we want it down the bottom
            if (cls.equals(JMenuItem.class) && nextMenu.getClass().equals(JMenu.class))
                continue;
            if (name.compareToIgnoreCase(otherName) < 0)
                return i;
        }
        return i;
    }

    private static void addMenuItem(MenuElement parentMenu, AssetType type, ActionListener listener) {
        JMenuItem newItem = new JMenuItem(type.getName());
        // newItem.addActionListener(this);
        newItem.getAccessibleContext().setAccessibleName(type.getTypeCode());
        // add single com menu items down the bottom
        int index = getMenuIndex(type.getName(),
            parentMenu,
            newItem.getClass()
        );
        addNewItem(parentMenu, newItem, index, listener);
    }

    private static void addNewItem(
        MenuElement parent,
        JMenuItem item,
        int index,
        ActionListener listener) {
            item.setFont(MatrixTreeBus.getActiveTree().getFontInUse());
            if (parent instanceof JPopupMenu)
                ((JPopupMenu) parent).add(item, index);
            else
                ((JMenu) parent).add(item, index);
            item.addActionListener(listener);
    }

    public static String getTypeCodeFromEvent(ActionEvent evt) {
        JMenuItem item = (JMenuItem) evt.getSource();
        return item.getAccessibleContext().getAccessibleName();
    }

    static class ImageLoader implements MenuListener, PopupMenuListener {

        private void loadImages(MenuElement menu) {
            final MenuElement[] elements = menu.getSubElements();
            for (int i = 0; i < elements.length; i++) {
                if (!(elements[i] instanceof JMenu)) {
                    String typeCode = ((Component) elements[i])
                        .getAccessibleContext().getAccessibleName();
                    final AssetType type = AssetManager.getAssetType(typeCode);

                    // because the way that popups work, there may be some menus
                    // whose only child is a popupmenu, in that case, we want
                    // the children of the popup menu to be processed
                    if (elements[i] instanceof JPopupMenu) {
                        loadImages(elements[i]);
                    } else {
                        final JMenuItem nextItem = (JMenuItem) elements[i];
                        // Use an initial loadingIcon and fetch the actual icon
                        // in a thread
                        if (!type.isIconLoaded()) {
                            nextItem.setIcon(GUIUtilities.getAssetMapIcon(DEFAULT_ASSET_ICON));
                            MatrixSwingWorker worker = new MatrixSwingWorker() {
                                public Object construct() {
                                    Icon icon = type.getIcon();
                                    nextItem.setIcon(icon);
                                    return null;
                                }
                            };
                            worker.start();
                        } else {
                            nextItem.setIcon(type.getIcon());
                        }
                    }
                }//end if
            }//end for
        }

        public void menuSelected(MenuEvent evt) {
            JMenu menu = (JMenu) evt.getSource();
            loadImages(menu);
        }

        public void popupMenuWillBecomeVisible(PopupMenuEvent evt) {
            JPopupMenu menu = (JPopupMenu) evt.getSource();
            loadImages(menu);
        }

        public void menuCanceled(MenuEvent evt) {}
        public void menuDeselected(MenuEvent evt) {}
        public void popupMenuCanceled(PopupMenuEvent evt) {}
        public void popupMenuWillBecomeInvisible(PopupMenuEvent evt) {}

    }//end class ImageLoader
}