juce/source/src/gui/components/keyboard/juce_KeyPressMappingSet.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_KeyPressMappingSet.h"
  31 #include "../../../core/juce_Time.h"
  32 #include "../../../core/juce_PlatformUtilities.h"
  33 #include "../lookandfeel/juce_LookAndFeel.h"
  34
  35
  36 //==============================================================================
  37 KeyPressMappingSet::KeyPressMappingSet (ApplicationCommandManager* const commandManager_)
  38     : commandManager (commandManager_)
  39 {
  40     // A manager is needed to get the descriptions of commands, and will be called when
  41     // a command is invoked. So you can't leave this null..
  42     jassert (commandManager_ != nullptr);
  43
  44     Desktop::getInstance().addFocusChangeListener (this);
  45 }
  46
  47 KeyPressMappingSet::KeyPressMappingSet (const KeyPressMappingSet& other)
  48     : commandManager (other.commandManager)
  49 {
  50     Desktop::getInstance().addFocusChangeListener (this);
  51 }
  52
  53 KeyPressMappingSet::~KeyPressMappingSet()
  54 {
  55     Desktop::getInstance().removeFocusChangeListener (this);
  56 }
  57
  58 //==============================================================================
  59 const Array <KeyPress> KeyPressMappingSet::getKeyPressesAssignedToCommand (const CommandID commandID) const
  60 {
  61     for (int i = 0; i < mappings.size(); ++i)
  62         if (mappings.getUnchecked(i)->commandID == commandID)
  63             return mappings.getUnchecked (i)->keypresses;
  64
  65     return Array <KeyPress> ();
  66 }
  67
  68 void KeyPressMappingSet::addKeyPress (const CommandID commandID,
  69                                       const KeyPress& newKeyPress,
  70                                       int insertIndex)
  71 {
  72     // If you specify an upper-case letter but no shift key, how is the user supposed to press it!?
  73     // Stick to lower-case letters when defining a keypress, to avoid ambiguity.
  74     jassert (! (CharacterFunctions::isUpperCase (newKeyPress.getTextCharacter())
  75                  && ! newKeyPress.getModifiers().isShiftDown()));
  76
  77     if (findCommandForKeyPress (newKeyPress) != commandID)
  78     {
  79         removeKeyPress (newKeyPress);
  80
  81         if (newKeyPress.isValid())
  82         {
  83             for (int i = mappings.size(); --i >= 0;)
  84             {
  85                 if (mappings.getUnchecked(i)->commandID == commandID)
  86                 {
  87                     mappings.getUnchecked(i)->keypresses.insert (insertIndex, newKeyPress);
  88
  89                     sendChangeMessage();
  90                     return;
  91                 }
  92             }
  93
  94             const ApplicationCommandInfo* const ci = commandManager->getCommandForID (commandID);
  95
  96             if (ci != nullptr)
  97             {
  98                 CommandMapping* const cm = new CommandMapping();
  99                 cm->commandID = commandID;
 100                 cm->keypresses.add (newKeyPress);
 101                 cm->wantsKeyUpDownCallbacks = (ci->flags & ApplicationCommandInfo::wantsKeyUpDownCallbacks) != 0;
 102
 103                 mappings.add (cm);
 104                 sendChangeMessage();
 105             }
 106         }
 107     }
 108 }
 109
 110 void KeyPressMappingSet::resetToDefaultMappings()
 111 {
 112     mappings.clear();
 113
 114     for (int i = 0; i < commandManager->getNumCommands(); ++i)
 115     {
 116         const ApplicationCommandInfo* const ci = commandManager->getCommandForIndex (i);
 117
 118         for (int j = 0; j < ci->defaultKeypresses.size(); ++j)
 119         {
 120             addKeyPress (ci->commandID,
 121                          ci->defaultKeypresses.getReference (j));
 122         }
 123     }
 124
 125     sendChangeMessage();
 126 }
 127
 128 void KeyPressMappingSet::resetToDefaultMapping (const CommandID commandID)
 129 {
 130     clearAllKeyPresses (commandID);
 131
 132     const ApplicationCommandInfo* const ci = commandManager->getCommandForID (commandID);
 133
 134     for (int j = 0; j < ci->defaultKeypresses.size(); ++j)
 135     {
 136         addKeyPress (ci->commandID,
 137                      ci->defaultKeypresses.getReference (j));
 138     }
 139 }
 140
 141 void KeyPressMappingSet::clearAllKeyPresses()
 142 {
 143     if (mappings.size() > 0)
 144     {
 145         sendChangeMessage();
 146         mappings.clear();
 147     }
 148 }
 149
 150 void KeyPressMappingSet::clearAllKeyPresses (const CommandID commandID)
 151 {
 152     for (int i = mappings.size(); --i >= 0;)
 153     {
 154         if (mappings.getUnchecked(i)->commandID == commandID)
 155         {
 156             mappings.remove (i);
 157             sendChangeMessage();
 158         }
 159     }
 160 }
 161
 162 void KeyPressMappingSet::removeKeyPress (const KeyPress& keypress)
 163 {
 164     if (keypress.isValid())
 165     {
 166         for (int i = mappings.size(); --i >= 0;)
 167         {
 168             CommandMapping* const cm = mappings.getUnchecked(i);
 169
 170             for (int j = cm->keypresses.size(); --j >= 0;)
 171             {
 172                 if (keypress == cm->keypresses [j])
 173                 {
 174                     cm->keypresses.remove (j);
 175                     sendChangeMessage();
 176                 }
 177             }
 178         }
 179     }
 180 }
 181
 182 void KeyPressMappingSet::removeKeyPress (const CommandID commandID, const int keyPressIndex)
 183 {
 184     for (int i = mappings.size(); --i >= 0;)
 185     {
 186         if (mappings.getUnchecked(i)->commandID == commandID)
 187         {
 188             mappings.getUnchecked(i)->keypresses.remove (keyPressIndex);
 189             sendChangeMessage();
 190             break;
 191         }
 192     }
 193 }
 194
 195 //==============================================================================
 196 CommandID KeyPressMappingSet::findCommandForKeyPress (const KeyPress& keyPress) const noexcept
 197 {
 198     for (int i = 0; i < mappings.size(); ++i)
 199         if (mappings.getUnchecked(i)->keypresses.contains (keyPress))
 200             return mappings.getUnchecked(i)->commandID;
 201
 202     return 0;
 203 }
 204
 205 bool KeyPressMappingSet::containsMapping (const CommandID commandID, const KeyPress& keyPress) const noexcept
 206 {
 207     for (int i = mappings.size(); --i >= 0;)
 208         if (mappings.getUnchecked(i)->commandID == commandID)
 209             return mappings.getUnchecked(i)->keypresses.contains (keyPress);
 210
 211     return false;
 212 }
 213
 214 void KeyPressMappingSet::invokeCommand (const CommandID commandID,
 215                                         const KeyPress& key,
 216                                         const bool isKeyDown,
 217                                         const int millisecsSinceKeyPressed,
 218                                         Component* const originatingComponent) const
 219 {
 220     ApplicationCommandTarget::InvocationInfo info (commandID);
 221
 222     info.invocationMethod = ApplicationCommandTarget::InvocationInfo::fromKeyPress;
 223     info.isKeyDown = isKeyDown;
 224     info.keyPress = key;
 225     info.millisecsSinceKeyPressed = millisecsSinceKeyPressed;
 226     info.originatingComponent = originatingComponent;
 227
 228     commandManager->invoke (info, false);
 229 }
 230
 231 //==============================================================================
 232 bool KeyPressMappingSet::restoreFromXml (const XmlElement& xmlVersion)
 233 {
 234     if (xmlVersion.hasTagName ("KEYMAPPINGS"))
 235     {
 236         if (xmlVersion.getBoolAttribute ("basedOnDefaults", true))
 237         {
 238             // if the XML was created as a set of differences from the default mappings,
 239             // (i.e. by calling createXml (true)), then we need to first restore the defaults.
 240             resetToDefaultMappings();
 241         }
 242         else
 243         {
 244             // if the XML was created calling createXml (false), then we need to clear all
 245             // the keys and treat the xml as describing the entire set of mappings.
 246             clearAllKeyPresses();
 247         }
 248
 249         forEachXmlChildElement (xmlVersion, map)
 250         {
 251             const CommandID commandId = map->getStringAttribute ("commandId").getHexValue32();
 252
 253             if (commandId != 0)
 254             {
 255                 const KeyPress key (KeyPress::createFromDescription (map->getStringAttribute ("key")));
 256
 257                 if (map->hasTagName ("MAPPING"))
 258                 {
 259                     addKeyPress (commandId, key);
 260                 }
 261                 else if (map->hasTagName ("UNMAPPING"))
 262                 {
 263                     if (containsMapping (commandId, key))
 264                         removeKeyPress (key);
 265                 }
 266             }
 267         }
 268
 269         return true;
 270     }
 271
 272     return false;
 273 }
 274
 275 XmlElement* KeyPressMappingSet::createXml (const bool saveDifferencesFromDefaultSet) const
 276 {
 277     ScopedPointer <KeyPressMappingSet> defaultSet;
 278
 279     if (saveDifferencesFromDefaultSet)
 280     {
 281         defaultSet = new KeyPressMappingSet (commandManager);
 282         defaultSet->resetToDefaultMappings();
 283     }
 284
 285     XmlElement* const doc = new XmlElement ("KEYMAPPINGS");
 286
 287     doc->setAttribute ("basedOnDefaults", saveDifferencesFromDefaultSet);
 288
 289     int i;
 290     for (i = 0; i < mappings.size(); ++i)
 291     {
 292         const CommandMapping* const cm = mappings.getUnchecked(i);
 293
 294         for (int j = 0; j < cm->keypresses.size(); ++j)
 295         {
 296             if (defaultSet == nullptr
 297                  || ! defaultSet->containsMapping (cm->commandID, cm->keypresses.getReference (j)))
 298             {
 299                 XmlElement* const map = doc->createNewChildElement ("MAPPING");
 300
 301                 map->setAttribute ("commandId", String::toHexString ((int) cm->commandID));
 302                 map->setAttribute ("description", commandManager->getDescriptionOfCommand (cm->commandID));
 303                 map->setAttribute ("key", cm->keypresses.getReference (j).getTextDescription());
 304             }
 305         }
 306     }
 307
 308     if (defaultSet != nullptr)
 309     {
 310         for (i = 0; i < defaultSet->mappings.size(); ++i)
 311         {
 312             const CommandMapping* const cm = defaultSet->mappings.getUnchecked(i);
 313
 314             for (int j = 0; j < cm->keypresses.size(); ++j)
 315             {
 316                 if (! containsMapping (cm->commandID, cm->keypresses.getReference (j)))
 317                 {
 318                     XmlElement* const map = doc->createNewChildElement ("UNMAPPING");
 319
 320                     map->setAttribute ("commandId", String::toHexString ((int) cm->commandID));
 321                     map->setAttribute ("description", commandManager->getDescriptionOfCommand (cm->commandID));
 322                     map->setAttribute ("key", cm->keypresses.getReference (j).getTextDescription());
 323                 }
 324             }
 325         }
 326     }
 327
 328     return doc;
 329 }
 330
 331 //==============================================================================
 332 bool KeyPressMappingSet::keyPressed (const KeyPress& key,
 333                                      Component* originatingComponent)
 334 {
 335     bool used = false;
 336
 337     const CommandID commandID = findCommandForKeyPress (key);
 338
 339     const ApplicationCommandInfo* const ci = commandManager->getCommandForID (commandID);
 340
 341     if (ci != nullptr
 342          && (ci->flags & ApplicationCommandInfo::wantsKeyUpDownCallbacks) == 0)
 343     {
 344         ApplicationCommandInfo info (0);
 345
 346         if (commandManager->getTargetForCommand (commandID, info) != 0
 347              && (info.flags & ApplicationCommandInfo::isDisabled) == 0)
 348         {
 349             invokeCommand (commandID, key, true, 0, originatingComponent);
 350             used = true;
 351         }
 352         else
 353         {
 354             if (originatingComponent != nullptr)
 355                 originatingComponent->getLookAndFeel().playAlertSound();
 356         }
 357     }
 358
 359     return used;
 360 }
 361
 362 bool KeyPressMappingSet::keyStateChanged (const bool /*isKeyDown*/, Component* originatingComponent)
 363 {
 364     bool used = false;
 365     const uint32 now = Time::getMillisecondCounter();
 366
 367     for (int i = mappings.size(); --i >= 0;)
 368     {
 369         CommandMapping* const cm =  mappings.getUnchecked(i);
 370
 371         if (cm->wantsKeyUpDownCallbacks)
 372         {
 373             for (int j = cm->keypresses.size(); --j >= 0;)
 374             {
 375                 const KeyPress key (cm->keypresses.getReference (j));
 376                 const bool isDown = key.isCurrentlyDown();
 377
 378                 int keyPressEntryIndex = 0;
 379                 bool wasDown = false;
 380
 381                 for (int k = keysDown.size(); --k >= 0;)
 382                 {
 383                     if (key == keysDown.getUnchecked(k)->key)
 384                     {
 385                         keyPressEntryIndex = k;
 386                         wasDown = true;
 387                         used = true;
 388                         break;
 389                     }
 390                 }
 391
 392                 if (isDown != wasDown)
 393                 {
 394                     int millisecs = 0;
 395
 396                     if (isDown)
 397                     {
 398                         KeyPressTime* const k = new KeyPressTime();
 399                         k->key = key;
 400                         k->timeWhenPressed = now;
 401
 402                         keysDown.add (k);
 403                     }
 404                     else
 405                     {
 406                         const uint32 pressTime = keysDown.getUnchecked (keyPressEntryIndex)->timeWhenPressed;
 407
 408                         if (now > pressTime)
 409                             millisecs = now - pressTime;
 410
 411                         keysDown.remove (keyPressEntryIndex);
 412                     }
 413
 414                     invokeCommand (cm->commandID, key, isDown, millisecs, originatingComponent);
 415                     used = true;
 416                 }
 417             }
 418         }
 419     }
 420
 421     return used;
 422 }
 423
 424 void KeyPressMappingSet::globalFocusChanged (Component* focusedComponent)
 425 {
 426     if (focusedComponent != nullptr)
 427         focusedComponent->keyStateChanged (false);
 428 }
 429
 430
 431 END_JUCE_NAMESPACE