juce/source/src/application/juce_ApplicationCommandManager.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../core/juce_StandardHeader.h"
  27
  28 BEGIN_JUCE_NAMESPACE
  29
  30 #include "juce_ApplicationCommandManager.h"
  31 #include "juce_Application.h"
  32 #include "../gui/components/windows/juce_ComponentPeer.h"
  33 #include "../gui/components/keyboard/juce_KeyPressMappingSet.h"
  34 #include "../gui/components/windows/juce_ResizableWindow.h"
  35 #include "../gui/components/juce_Desktop.h"
  36 #include "../events/juce_MessageManager.h"
  37 #include "../threads/juce_Process.h"
  38
  39
  40 //==============================================================================
  41 ApplicationCommandManager::ApplicationCommandManager()
  42     : firstTarget (nullptr)
  43 {
  44     keyMappings = new KeyPressMappingSet (this);
  45
  46     Desktop::getInstance().addFocusChangeListener (this);
  47 }
  48
  49 ApplicationCommandManager::~ApplicationCommandManager()
  50 {
  51     Desktop::getInstance().removeFocusChangeListener (this);
  52     keyMappings = nullptr;
  53 }
  54
  55 //==============================================================================
  56 void ApplicationCommandManager::clearCommands()
  57 {
  58     commands.clear();
  59     keyMappings->clearAllKeyPresses();
  60     triggerAsyncUpdate();
  61 }
  62
  63 void ApplicationCommandManager::registerCommand (const ApplicationCommandInfo& newCommand)
  64 {
  65     // zero isn't a valid command ID!
  66     jassert (newCommand.commandID != 0);
  67
  68     // the name isn't optional!
  69     jassert (newCommand.shortName.isNotEmpty());
  70
  71     if (getCommandForID (newCommand.commandID) == 0)
  72     {
  73         ApplicationCommandInfo* const newInfo = new ApplicationCommandInfo (newCommand);
  74         newInfo->flags &= ~ApplicationCommandInfo::isTicked;
  75         commands.add (newInfo);
  76
  77         keyMappings->resetToDefaultMapping (newCommand.commandID);
  78
  79         triggerAsyncUpdate();
  80     }
  81     else
  82     {
  83         // trying to re-register the same command with different parameters?
  84         jassert (newCommand.shortName == getCommandForID (newCommand.commandID)->shortName
  85                   && (newCommand.description == getCommandForID (newCommand.commandID)->description || newCommand.description.isEmpty())
  86                   && newCommand.categoryName == getCommandForID (newCommand.commandID)->categoryName
  87                   && newCommand.defaultKeypresses == getCommandForID (newCommand.commandID)->defaultKeypresses
  88                   && (newCommand.flags & (ApplicationCommandInfo::wantsKeyUpDownCallbacks | ApplicationCommandInfo::hiddenFromKeyEditor | ApplicationCommandInfo::readOnlyInKeyEditor))
  89                        == (getCommandForID (newCommand.commandID)->flags & (ApplicationCommandInfo::wantsKeyUpDownCallbacks | ApplicationCommandInfo::hiddenFromKeyEditor | ApplicationCommandInfo::readOnlyInKeyEditor)));
  90     }
  91 }
  92
  93 void ApplicationCommandManager::registerAllCommandsForTarget (ApplicationCommandTarget* target)
  94 {
  95     if (target != nullptr)
  96     {
  97         Array <CommandID> commandIDs;
  98         target->getAllCommands (commandIDs);
  99
 100         for (int i = 0; i < commandIDs.size(); ++i)
 101         {
 102             ApplicationCommandInfo info (commandIDs.getUnchecked(i));
 103             target->getCommandInfo (info.commandID, info);
 104
 105             registerCommand (info);
 106         }
 107     }
 108 }
 109
 110 void ApplicationCommandManager::removeCommand (const CommandID commandID)
 111 {
 112     for (int i = commands.size(); --i >= 0;)
 113     {
 114         if (commands.getUnchecked (i)->commandID == commandID)
 115         {
 116             commands.remove (i);
 117             triggerAsyncUpdate();
 118
 119             const Array <KeyPress> keys (keyMappings->getKeyPressesAssignedToCommand (commandID));
 120
 121             for (int j = keys.size(); --j >= 0;)
 122                 keyMappings->removeKeyPress (keys.getReference (j));
 123         }
 124     }
 125 }
 126
 127 void ApplicationCommandManager::commandStatusChanged()
 128 {
 129     triggerAsyncUpdate();
 130 }
 131
 132 //==============================================================================
 133 const ApplicationCommandInfo* ApplicationCommandManager::getCommandForID (const CommandID commandID) const noexcept
 134 {
 135     for (int i = commands.size(); --i >= 0;)
 136         if (commands.getUnchecked(i)->commandID == commandID)
 137             return commands.getUnchecked(i);
 138
 139     return nullptr;
 140 }
 141
 142 String ApplicationCommandManager::getNameOfCommand (const CommandID commandID) const noexcept
 143 {
 144     const ApplicationCommandInfo* const ci = getCommandForID (commandID);
 145
 146     return ci != nullptr ? ci->shortName : String::empty;
 147 }
 148
 149 String ApplicationCommandManager::getDescriptionOfCommand (const CommandID commandID) const noexcept
 150 {
 151     const ApplicationCommandInfo* const ci = getCommandForID (commandID);
 152
 153     return ci != nullptr ? (ci->description.isNotEmpty() ? ci->description : ci->shortName)
 154                          : String::empty;
 155 }
 156
 157 StringArray ApplicationCommandManager::getCommandCategories() const
 158 {
 159     StringArray s;
 160
 161     for (int i = 0; i < commands.size(); ++i)
 162         s.addIfNotAlreadyThere (commands.getUnchecked(i)->categoryName, false);
 163
 164     return s;
 165 }
 166
 167 Array<CommandID> ApplicationCommandManager::getCommandsInCategory (const String& categoryName) const
 168 {
 169     Array <CommandID> results;
 170
 171     for (int i = 0; i < commands.size(); ++i)
 172         if (commands.getUnchecked(i)->categoryName == categoryName)
 173             results.add (commands.getUnchecked(i)->commandID);
 174
 175     return results;
 176 }
 177
 178 //==============================================================================
 179 bool ApplicationCommandManager::invokeDirectly (const CommandID commandID, const bool asynchronously)
 180 {
 181     ApplicationCommandTarget::InvocationInfo info (commandID);
 182     info.invocationMethod = ApplicationCommandTarget::InvocationInfo::direct;
 183
 184     return invoke (info, asynchronously);
 185 }
 186
 187 bool ApplicationCommandManager::invoke (const ApplicationCommandTarget::InvocationInfo& info_, const bool asynchronously)
 188 {
 189     // This call isn't thread-safe for use from a non-UI thread without locking the message
 190     // manager first..
 191     jassert (MessageManager::getInstance()->currentThreadHasLockedMessageManager());
 192
 193     ApplicationCommandInfo commandInfo (0);
 194     ApplicationCommandTarget* const target = getTargetForCommand (info_.commandID, commandInfo);
 195
 196     if (target == nullptr)
 197         return false;
 198
 199     ApplicationCommandTarget::InvocationInfo info (info_);
 200     info.commandFlags = commandInfo.flags;
 201
 202     sendListenerInvokeCallback (info);
 203
 204     const bool ok = target->invoke (info, asynchronously);
 205
 206     commandStatusChanged();
 207
 208     return ok;
 209 }
 210
 211 //==============================================================================
 212 ApplicationCommandTarget* ApplicationCommandManager::getFirstCommandTarget (const CommandID)
 213 {
 214     return firstTarget != nullptr ? firstTarget
 215                                   : findDefaultComponentTarget();
 216 }
 217
 218 void ApplicationCommandManager::setFirstCommandTarget (ApplicationCommandTarget* const newTarget) noexcept
 219 {
 220     firstTarget = newTarget;
 221 }
 222
 223 ApplicationCommandTarget* ApplicationCommandManager::getTargetForCommand (const CommandID commandID,
 224                                                                           ApplicationCommandInfo& upToDateInfo)
 225 {
 226     ApplicationCommandTarget* target = getFirstCommandTarget (commandID);
 227
 228     if (target == nullptr)
 229         target = JUCEApplication::getInstance();
 230
 231     if (target != nullptr)
 232         target = target->getTargetForCommand (commandID);
 233
 234     if (target != nullptr)
 235         target->getCommandInfo (commandID, upToDateInfo);
 236
 237     return target;
 238 }
 239
 240 //==============================================================================
 241 ApplicationCommandTarget* ApplicationCommandManager::findTargetForComponent (Component* c)
 242 {
 243     ApplicationCommandTarget* target = dynamic_cast <ApplicationCommandTarget*> (c);
 244
 245     if (target == nullptr && c != nullptr)
 246         // (unable to use the syntax findParentComponentOfClass <ApplicationCommandTarget> () because of a VC6 compiler bug)
 247         target = c->findParentComponentOfClass ((ApplicationCommandTarget*) nullptr);
 248
 249     return target;
 250 }
 251
 252 ApplicationCommandTarget* ApplicationCommandManager::findDefaultComponentTarget()
 253 {
 254     Component* c = Component::getCurrentlyFocusedComponent();
 255
 256     if (c == nullptr)
 257     {
 258         TopLevelWindow* const activeWindow = TopLevelWindow::getActiveTopLevelWindow();
 259
 260         if (activeWindow != nullptr)
 261         {
 262             c = activeWindow->getPeer()->getLastFocusedSubcomponent();
 263
 264             if (c == nullptr)
 265                 c = activeWindow;
 266         }
 267     }
 268
 269     if (c == nullptr && Process::isForegroundProcess())
 270     {
 271         // getting a bit desperate now - try all desktop comps..
 272         for (int i = Desktop::getInstance().getNumComponents(); --i >= 0;)
 273         {
 274             ApplicationCommandTarget* const target
 275                 = findTargetForComponent (Desktop::getInstance().getComponent (i)
 276                                               ->getPeer()->getLastFocusedSubcomponent());
 277
 278             if (target != nullptr)
 279                 return target;
 280         }
 281     }
 282
 283     if (c != nullptr)
 284     {
 285         ResizableWindow* const resizableWindow = dynamic_cast <ResizableWindow*> (c);
 286
 287         // if we're focused on a ResizableWindow, chances are that it's the content
 288         // component that really should get the event. And if not, the event will
 289         // still be passed up to the top level window anyway, so let's send it to the
 290         // content comp.
 291         if (resizableWindow != nullptr && resizableWindow->getContentComponent() != nullptr)
 292             c = resizableWindow->getContentComponent();
 293
 294         ApplicationCommandTarget* const target = findTargetForComponent (c);
 295
 296         if (target != nullptr)
 297             return target;
 298     }
 299
 300     return JUCEApplication::getInstance();
 301 }
 302
 303 //==============================================================================
 304 void ApplicationCommandManager::addListener (ApplicationCommandManagerListener* const listener)
 305 {
 306     listeners.add (listener);
 307 }
 308
 309 void ApplicationCommandManager::removeListener (ApplicationCommandManagerListener* const listener)
 310 {
 311     listeners.remove (listener);
 312 }
 313
 314 void ApplicationCommandManager::sendListenerInvokeCallback (const ApplicationCommandTarget::InvocationInfo& info)
 315 {
 316     listeners.call (&ApplicationCommandManagerListener::applicationCommandInvoked, info);
 317 }
 318
 319 void ApplicationCommandManager::handleAsyncUpdate()
 320 {
 321     listeners.call (&ApplicationCommandManagerListener::applicationCommandListChanged);
 322 }
 323
 324 void ApplicationCommandManager::globalFocusChanged (Component*)
 325 {
 326     commandStatusChanged();
 327 }
 328
 329
 330 END_JUCE_NAMESPACE