IndependentModeler/src/cz/cvut/promod/services/actionService/NotationSpecificActions.java

   1 package cz.cvut.promod.services.actionService;
   2
   3 import cz.cvut.promod.services.actionService.actionUtils.ProModAction;
   4 import org.apache.log4j.Logger;
   5
   6 import javax.swing.*;
   7 import java.util.HashMap;
   8 import java.util.Map;
   9
  10 /**
  11  * ProMod, master thesis project
  12  * User: Petr Zverina, petr.zverina@gmail.com
  13  * Date: 17:19:25, 2.11.2009
  14  */
  15
  16 /**
  17  * Notation specific actions holder.
  18  */
  19 public class NotationSpecificActions {
  20
  21     private final Logger LOG = Logger.getLogger(NotationSpecificActions.class);
  22
  23     private final Map<String, ProModAction> notationActionsMap;
  24
  25     private final Map<String, ModuleSpecificActions> moduleActionsMap;
  26
  27
  28     public NotationSpecificActions(){
  29         notationActionsMap = new HashMap<String, ProModAction>();
  30         moduleActionsMap = new HashMap<String, ModuleSpecificActions>();
  31     }
  32
  33      /**
  34      * @param actionIdentifier is the action identifier
  35      * @return returns the action is such a action exists, null otherwise
  36      */
  37     public ProModAction getAction(final String actionIdentifier) {
  38         if(notationActionsMap.containsKey(actionIdentifier)){
  39             return notationActionsMap.get(actionIdentifier);
  40         }
  41
  42         return null;
  43     }
  44
  45     /**
  46      * @param moduleIdentifier is the module identifier
  47      * @param actionIdentifier is the action identifier
  48      * @return returns the action is such a action exists, null otherwise
  49      */
  50     public ProModAction getAction(final String moduleIdentifier, final String actionIdentifier) {
  51         if(moduleActionsMap.containsKey(moduleIdentifier)){
  52             return moduleActionsMap.get(moduleIdentifier).getAction(actionIdentifier);
  53         }
  54
  55         return null;
  56     }
  57
  58     /**
  59      * Sets the action.
  60      * @param moduleIdentifier module identifier
  61      * @param actionIdentifier action identifier
  62      * @param newProModAction the action itself
  63      */
  64     public void setAction(final String moduleIdentifier, final String actionIdentifier, final ProModAction newProModAction) {
  65         if(moduleIdentifier == null){
  66             if(notationActionsMap.containsKey(actionIdentifier)){
  67                 LOG.error("An attempt to insert the same notation action to the notation actions map, action identifier: " + actionIdentifier + ".");
  68             } else {
  69                 notationActionsMap.put(actionIdentifier, newProModAction);
  70             }
  71
  72         } else {
  73             if(moduleActionsMap.containsKey(moduleIdentifier)){
  74                 moduleActionsMap.get(moduleIdentifier).setAction(actionIdentifier, newProModAction);
  75             } else {
  76                 final ModuleSpecificActions moduleSpecificActions = new ModuleSpecificActions();
  77                 moduleSpecificActions.setAction(actionIdentifier, newProModAction);
  78                 moduleActionsMap.put(moduleIdentifier, moduleSpecificActions);
  79             }
  80         }
  81     }
  82
  83     /**
  84      * Updates the action visibility on the basis of active notation.
  85      * @param notationIdentifier is the identifier of active notation.
  86      */
  87     public void updateActionVisibility(final String notationIdentifier) {
  88         for(final ProModAction proModAction : notationActionsMap.values()){
  89             proModAction.updateActionVisibility(notationIdentifier);
  90         }
  91
  92         for(final ModuleSpecificActions moduleSpecificActions : moduleActionsMap.values()){
  93             moduleSpecificActions.updateActionVisibility(notationIdentifier);
  94         }
  95     }
  96
  97     /**
  98      * Tests whether there is no other already registered action with the same accelerator key definition
  99      * by this notation. Additionally, check all registered actions of this notation's modules.
 100      *
 101      * @param keyStroke is the accelerator key to be tested
 102      * @return true if there is such a action, false otherwise
 103      */
 104     public boolean existAcceleratorKey(final KeyStroke keyStroke){
 105         for(final ProModAction action : notationActionsMap.values()){
 106             final KeyStroke key = (KeyStroke) action.getValue(AbstractAction.ACCELERATOR_KEY);
 107
 108             if(key != null && key.equals(keyStroke)){
 109                 return true;
 110             }
 111         }
 112
 113         for(final ModuleSpecificActions moduleSpecificActions : moduleActionsMap.values()){
 114             if(moduleSpecificActions.existAcceleratorKey(keyStroke)){
 115                 return true;
 116             }
 117         }
 118
 119         return false;
 120     }
 121
 122     /**
 123      * Check whether such a action has been already registered by a notation or any of it's modules.
 124      *
 125      * @param action is the action to be checked
 126      * @return true if such a actions has been already registered, false otherwise
 127      */
 128     public boolean existAction(final ProModAction action) {
 129         if(notationActionsMap.values().contains(action)){
 130             return true;
 131         }
 132
 133         for(final ModuleSpecificActions moduleSpecificActions : moduleActionsMap.values()){
 134             if(moduleSpecificActions.exist(action)){
 135                 return true;
 136             }
 137         }
 138
 139         return false;
 140     }
 141 }