/*******************************************************************************
* Mission Control Technologies, Copyright (c) 2009-2012, United States Government
* as represented by the Administrator of the National Aeronautics and Space
* Administration. All rights reserved.
*
* The MCT platform is licensed under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0.
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*
* MCT includes source code licensed under additional open source licenses. See
* the MCT Open Source Licenses file included with this distribution or the About
* MCT Licenses dialog available at runtime from the MCT Help menu for additional
* information.
*******************************************************************************/
/**
* MCTActionManager.java Aug 18, 2008
*
* This code is property of the National Aeronautics and Space Administration
* and was produced for the Mission Control Technologies (MCT) Project.
*
*/
package gov.nasa.arc.mct.gui.impl;
import gov.nasa.arc.mct.gui.ContextAwareAction;
import gov.nasa.arc.mct.gui.ContextAwareMenu;
import gov.nasa.arc.mct.gui.MenuItemInfo;
import gov.nasa.arc.mct.gui.menu.MenuFactory;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.swing.Action;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* This class manages the actions in MCT.
*
* @author nshi
*/
public final class ActionManager {
private static final Logger MENU_TOOLTIP_LOGGER = LoggerFactory.getLogger("gov.nasa.arc.mct.gui.menus");
private static Map<String, List<Class<? extends ContextAwareMenu>>> commandMenuMap = new HashMap<String, List<Class<? extends ContextAwareMenu>>>();
private static Map<String, List<Class<? extends ContextAwareAction>>> commandKeyActionMap = new HashMap<String, List<Class<? extends ContextAwareAction>>>();
/**
* Registers a new menu within MCT. Each menu within MCT
* has an identifier, its command key. This command key
* is used to look up the menu by ID using {@link #getMenu(String, ActionContextImpl)}.
*
* @param menuClass the class that implements the menu
* @param commandKey the unique identifier for the new menu
*/
public static void registerMenu(Class<? extends ContextAwareMenu> menuClass, String commandKey) {
List<Class<? extends ContextAwareMenu>> menuList = commandMenuMap.get(commandKey);
if (menuList == null) {
menuList = new ArrayList<Class<? extends ContextAwareMenu>>();
commandMenuMap.put(commandKey, menuList);
}
menuList.add(menuClass);
}
/**
* Finds a menu that has the given command key and is applicable
* in the given action context. If more than one such menu exits,
* return the first one registered.
*
* @param commandKey the command key of menus to find
* @param context the action context in which the menu should be applicable
* @return the applicable menu
*/
public static ContextAwareMenu getMenu(String commandKey, ActionContextImpl context) {
List<Class<? extends ContextAwareMenu>> menuList = commandMenuMap.get(commandKey);
if (menuList != null) {
for (Class<? extends ContextAwareMenu> menuClass : menuList) {
try {
ContextAwareMenu menu = menuClass.newInstance();
if (menu.canHandle(context)) {
menu.addMenuListener(MenuFactory.createMenuListener(menu));
// Populate built-in menus and/or menu items
menu.initialize();
// Populate extended menus and/or menu items
MenuExtensionManager manager = MenuExtensionManager.getInstance();
for (String menubarPath : menu.getExtensionMenubarPaths()) {
List<MenuItemInfo> extendedMenus = manager.getExtendedMenus(menubarPath);
menu.addMenuItemInfos(menubarPath, extendedMenus);
}
if (MENU_TOOLTIP_LOGGER.isDebugEnabled())
menu.setToolTipText(menu.getClass().getName());
return menu;
}
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
return null;
}
/**
* Registers an action for use within MCT. An action is associated
* with a command key, which ties a menu entry to an action.
*
* @param actionClass the class implementing the action
* @param commandKey the command key for the action
*/
public static void registerAction(Class<? extends ContextAwareAction> actionClass, String commandKey) {
List<Class<? extends ContextAwareAction>> actionClasses = commandKeyActionMap.get(commandKey);
if (actionClasses == null)
actionClasses = new ArrayList<Class<? extends ContextAwareAction>>();
actionClasses.add(actionClass);
commandKeyActionMap.put(commandKey, actionClasses);
}
/**
* Removes an action with the given class and command key.
*
* @param actionClass the class implementing the action
* @param commandKey the command key for the action to remove
*/
public static void unregisterAction(Class<? extends ContextAwareAction> actionClass, String commandKey) {
List<Class<? extends ContextAwareAction>> list = commandKeyActionMap.get(commandKey);
list.remove(actionClass);
if (list.isEmpty()) commandKeyActionMap.remove(commandKey);
}
/**
* Removes a submenu with the given class and command key.
*
* @param menuClass the class implementing the submenu
* @param commandKey the command key for the submenu to remove
*/
public static void unregisterMenu(Class<? extends ContextAwareMenu> menuClass, String commandKey) {
List<Class<? extends ContextAwareMenu>> list = commandMenuMap.get(commandKey);
list.remove(menuClass);
if (list.isEmpty()) commandKeyActionMap.remove(commandKey);
}
/**
* Removes a single action object.
*
* @param action the action to remove
*/
public static void deregisterAction(ContextAwareAction action) {
if (action.getValue(Action.ACTION_COMMAND_KEY) != null) {
if (commandKeyActionMap.containsKey(action.getValue(Action.ACTION_COMMAND_KEY))) {
if (commandKeyActionMap.get(action.getValue(Action.ACTION_COMMAND_KEY)) != null) {
commandKeyActionMap.remove(action.getValue(Action.ACTION_COMMAND_KEY));
}
}
}
}
/**
* Returns the first action that can handle the context.
* @param key commandKey
* @param context action context
* @return an action or null if none applicable
*/
public static ContextAwareAction getAction(String key, ActionContextImpl context) {
List<Class<? extends ContextAwareAction>> actionClassList = commandKeyActionMap.get(key);
if (actionClassList == null)
return null;
for (Class<? extends ContextAwareAction> actionClass : actionClassList) {
try {
ContextAwareAction action = actionClass.newInstance();
if (action.canHandle(context))
return action;
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
return null;
}
}