Ticket #9613: multikeybindings_v6.patch

mythtv/libs/libmythtv/dbcheck.cpp

@@ -5962 +5962 @@
 "  description varchar(255) default NULL,"
 "  keylist varchar(128) default NULL,"
 "  hostname varchar(64) NOT NULL default '',"
+"  multikey varchar(128) default NULL,"
 "  PRIMARY KEY  (destination,hostname)"
 ");",
 "CREATE TABLE keybindings ("
@@ -5970 +5971 @@
 "  description varchar(255) default NULL,"
 "  keylist varchar(128) default NULL,"
 "  hostname varchar(64) NOT NULL default '',"
+"  multikey varchar(128) default NULL,"
 "  PRIMARY KEY  (`context`,`action`,hostname)"
 ");",
 "CREATE TABLE keyword ("

mythtv/libs/libmythtv/tv_play.cpp

@@ -874 +874 @@
       endOfPlaybackTimerId(0),      embedCheckTimerId(0),
       endOfRecPromptTimerId(0),     videoExitDialogTimerId(0),
       pseudoChangeChanTimerId(0),   speedChangeTimerId(0),
-      errorRecoveryTimerId(0),      exitPlayerTimerId(0)
+      errorRecoveryTimerId(0),      exitPlayerTimerId(0),
+      multikeyContext(new MultikeyContext())
 {
     memset(&ddMapLoader, 0, sizeof(pthread_t));
     VERBOSE(VB_GENERAL, LOC + "Creating TV object");
     ctorTime.start();
@@ -1213 +1214 @@
     }
     ReturnPlayerLock(mctx);
 
+    if (multikeyContext)
+    {
+        delete multikeyContext;
+        multikeyContext = NULL;
+    }
+
     VERBOSE(VB_PLAYBACK, "TV::~TV() -- end");
@@ -3299 +3306 @@
     if (ignoreKeys)
     {
         handled = GetMythMainWindow()->TranslateKeyPress(
-                  "TV Playback", e, actions);
+                  "TV Playback", e, actions, true, multikeyContext);
 
         if (handled || actions.isEmpty())
+        {
+            CommitMultikey(actx);
             return true;
+        }
 
         bool esc   = has_action("ESCAPE", actions) ||
                      has_action("BACK", actions);
@@ -3310 +3320 @@
         bool play  = has_action(ACTION_PLAY,  actions);
 
         if ((!esc || browsehelper->IsBrowsing()) && !pause && !play)
+        {
+            CommitMultikey(actx);
             return false;
+        }
     }
 
     OSD *osd = GetOSDLock(actx);
@@ -3324 +3337 @@
     if (editmode && !handled)
     {
         handled |= GetMythMainWindow()->TranslateKeyPress(
-                   "TV Editing", e, actions);
+                   "TV Editing", e, actions, true, multikeyContext);
 
         if (!handled)
         {
@@ -3368 +3381 @@
     }
 
     if (handled)
+    {
+        CommitMultikey(actx);
         return true;
+    }
 
     // If text is already queued up, be more lax on what is ok.
     // This allows hex teletext entry and minor channel entry.
@@ -3380 +3396 @@
         if (ok || txt=="_" || txt=="-" || txt=="#" || txt==".")
         {
             AddKeyToInputQueue(actx, txt.at(0).toLatin1());
+            CommitMultikey(actx, false);
             return true;
         }
     }
@@ -3390 +3407 @@
     {
         QStringList tt_actions;
         handled = GetMythMainWindow()->TranslateKeyPress(
-                  "Teletext Menu", e, tt_actions);
+                  "Teletext Menu", e, tt_actions, true, multikeyContext);
 
         if (!handled && !tt_actions.isEmpty())
         {
@@ -3399 +3416 @@
                 if (actx->player->HandleTeletextAction(tt_actions[i]))
                 {
                     actx->UnlockDeletePlayer(__FILE__, __LINE__);
+                    CommitMultikey(actx);
                     return true;
                 }
             }
@@ -3410 +3428 @@
     {
         QStringList itv_actions;
         handled = GetMythMainWindow()->TranslateKeyPress(
-                  "TV Playback", e, itv_actions);
+                  "TV Playback", e, itv_actions, true, multikeyContext);
 
         if (!handled && !itv_actions.isEmpty())
         {
@@ -3419 +3437 @@
                 if (actx->player->ITVHandleAction(itv_actions[i]))
                 {
                     actx->UnlockDeletePlayer(__FILE__, __LINE__);
+                    CommitMultikey(actx);
                     return true;
                 }
             }
@@ -3427 +3446 @@
     actx->UnlockDeletePlayer(__FILE__, __LINE__);
 
     handled = GetMythMainWindow()->TranslateKeyPress(
-              "TV Playback", e, actions);
+              "TV Playback", e, actions, true, multikeyContext);
 
     if (handled || actions.isEmpty())
+    {
+        CommitMultikey(actx);
         return true;
+    }
 
     handled = false;
 
@@ -3457 +3479 @@
 #endif // DEBUG_ACTIONS
 
     if (handled)
+    {
+        CommitMultikey(actx);
         return true;
+    }
 
     if (!handled)
     {
@@ -3471 +3496 @@
             {
                 AddKeyToInputQueue(actx, '0' + val);
                 handled = true;
+                CommitMultikey(actx, false);
             }
         }
     }
@@ -3478 +3504 @@
     return true;
 }
 
+void TV::CommitMultikey(PlayerContext *ctx, bool updateOSD)
+{
+    MultikeyContext::MultikeyStatus status;
+    QString prefix;
+    multikeyContext->Commit(status, prefix);
+    bool isMultikey = (QKeySequence(prefix).count() > 1);
+    if (updateOSD)
+    {
+        switch (status)
+        {
+        case MultikeyContext::kMKnoPrefix:
+            // clear the OSD text
+            HideOSDWindow(ctx, "osd_input");
+            break;
+        case MultikeyContext::kMKpartialMatch:
+            SetOSDText(ctx, "osd_input", "osd_number_entry",
+                       prefix, kOSDTimeout_Med);
+            break;
+        case MultikeyContext::kMKfullMatch:
+            // same as partial match but with short timeout
+            if (isMultikey)
+                SetOSDText(ctx, "osd_input", "osd_number_entry",
+                           prefix, kOSDTimeout_Short);
+            break;
+        case MultikeyContext::kMKbadMatch:
+            // same as full match but with error text
+            SetOSDText(ctx, "osd_input", "osd_number_entry",
+                       prefix + ": " + QObject::tr("Unknown key sequence"),
+                       kOSDTimeout_Short);
+            break;
+        }
+    }
+}
+
 bool TV::BrowseHandleAction(PlayerContext *ctx, const QStringList &actions)
 {
     if (!browsehelper->IsBrowsing())

mythtv/libs/libmythtv/tv_play.h

@@ -41 +41 @@
 
 class QDateTime;
 class OSD;
+class MultikeyContext;
 class RemoteEncoder;
 class MythPlayer;
 class DetectLetterbox;
@@ -386 +387 @@
     void ClearInputQueues(const PlayerContext*, bool hideosd);
     bool CommitQueuedInput(PlayerContext*);
     bool ProcessSmartChannel(const PlayerContext*, QString&);
+    void CommitMultikey(PlayerContext*, bool updateOSD=true);
 
     // query key queues
     bool HasQueuedInput(void) const
@@ -842 +844 @@
     TimerContextMap      signalMonitorTimerId;
     TimerContextMap      tvchainUpdateTimerId;
 
+    MultikeyContext     *multikeyContext;
+
   public:
     // Constants
     static const int kInitFFRWSpeed; ///< 1x, default to normal speed

mythtv/libs/libmythui/mythmainwindow.cpp

@@ -86 +86 @@
 #define LOC_WARN QString("MythMainWindow, Warning: ")
 #define LOC_ERR  QString("MythMainWindow, Error: ")
 
+class MultikeyData
+{
+public:
+    void AddMultikeyMapping(const QString &multikey, QString action)
+    {
+        QKeySequence seq(multikey);
+        switch (seq.count())
+        {
+        case 4:
+            ++multikeyPrefixes[QKeySequence(seq[0], seq[1], seq[2])];
+            // fallthrough
+        case 3:
+            ++multikeyPrefixes[QKeySequence(seq[0], seq[1])];
+            // fallthrough
+        case 2:
+            ++multikeyPrefixes[QKeySequence(seq[0])];
+            // fallthrough
+        case 1:
+            multikeyActionMap[seq].append(action);
+        }
+    }
+
+    bool IsMultikeyPrefix(const QString &multikey)
+    {
+        return multikeyPrefixes.count(QKeySequence(multikey));
+    }
+
+    bool GetMultikeyMapping(const QString &multikey, QStringList &actions)
+    {
+        QKeySequence seq(multikey);
+        if (multikeyActionMap.count(seq) > 0)
+        {
+            actions += multikeyActionMap[seq];
+            return true;
+        }
+        return false;
+    }
+
+private:
+    QMap<QKeySequence, QStringList> multikeyActionMap;
+    QMap<QKeySequence, int> multikeyPrefixes;
+};
+
 class KeyContext
 {
   public:
     void AddMapping(int key, QString action)
     {
         actionMap[key].append(action);
+        multiData.AddMultikeyMapping(QKeySequence(key).toString(), action);
     }
 
     bool GetMapping(int key, QStringList &actions)
@@ -105 +149 @@
     }
 
     QMap<int, QStringList> actionMap;
+    MultikeyData multiData;
 };
 
 struct JumpData
@@ -216 +261 @@
     QHash<QString, KeyContext *> keyContexts;
     QMap<int, JumpData*> jumpMap;
     QMap<QString, JumpData> destinationMap;
+    MultikeyData jumpMultikeyData;
     QMap<QString, MPData> mediaPluginMap;
 
     void (*exitmenucallback)(void);
@@ -264 +310 @@
     bool m_pendingUpdate;
 };
 
+// Returns false if the key couldn't be added (prefix too long).
+bool MultikeyContext::AddKey(int key)
+{
+    currentPrefix = oldPrefix;
+    bool result = true;
+    QKeySequence seq(currentPrefix);
+    int k1 = seq[0];
+    int k2 = seq[1];
+    int k3 = seq[2];
+    int k4 = seq[3];
+    if (k1 == 0)
+        k1 = key;
+    else if (k2 == 0)
+        k2 = key;
+    else if (k3 == 0)
+        k3 = key;
+    else if (k4 == 0)
+        k4 = key;
+    else
+        result = false;
+    if (result)
+        currentPrefix = QKeySequence(k1, k2, k3, k4).toString();
+    return result;
+}
+
 // Make keynum in QKeyEvent be equivalent to what's in QKeySequence
 int MythMainWindowPrivate::TranslateKeyNum(QKeyEvent* e)
 {
@@ -1440 +1511 @@
  * \param e       The keypress event to lookup.
  * \param actions The QStringList that will contain the list of actions.
  * \param allowJumps if true then jump points are allowed
+ * \param prefixContext if non-NULL then multi-key bindings are allowed.
  *
  * \return true if the key event has been handled (the keypress was a jumpoint)
            false if the caller should continue to handle keypress
  */
 bool MythMainWindow::TranslateKeyPress(const QString &context,
                                        QKeyEvent *e, QStringList &actions,
-                                       bool allowJumps)
+                                       bool allowJumps,
+                                       MultikeyContext *prefixContext)
 {
     actions.clear();
 
@@ -1460 +1533 @@
     }
 
     int keynum = d->TranslateKeyNum(e);
-
-    QStringList localActions;
-    if (allowJumps && (d->jumpMap.count(keynum) > 0) &&
-        (!d->jumpMap[keynum]->localAction.isEmpty()) &&
-        (d->keyContexts.value(context)) &&
-        (d->keyContexts.value(context)->GetMapping(keynum, localActions)))
-    {
-        if (localActions.contains(d->jumpMap[keynum]->localAction))
-            allowJumps = false;
+    bool checkOnlyJumpPoints = false;
+    bool wasEmpty = prefixContext ? prefixContext->GetPrefix().isEmpty() : true;
+    bool noOverflow = prefixContext ? prefixContext->AddKey(keynum) : true;
+    const QString singleKey = QKeySequence(keynum).toString();
+    const QString prefix = prefixContext ? prefixContext->GetPrefix() : singleKey;
+    MultikeyContext::MultikeyStatus status;
+    JumpData *singleKeyJump = NULL, *multiKeyJump = NULL;
+        // There is a potential race condition where an input timeout
+        // thread resets the context at the same time this code is
+        // operating on it.
+    QStringList singleKeyJumpActions, multiKeyJumpActions;
+    QStringList singleKeyActions, multiKeyActions;
+    KeyContext *kctx = d->keyContexts.value(context);
+    KeyContext *gctx = d->keyContexts.value("Global");
+
+    if (allowJumps)
+    {
+        // Find single-key jumppoint bindings.  This is only used when
+        // a multi-key sequence (regular or jumppoint) is aborted
+        // mid-sequence with a single-key jump point.
+        if (d->jumpMultikeyData.GetMultikeyMapping(singleKey, singleKeyJumpActions))
+            singleKeyJump = &d->destinationMap[singleKeyJumpActions[0]];
+        // Find multi-key jumppoint bindings.
+        if (noOverflow && d->jumpMultikeyData.GetMultikeyMapping(prefix, multiKeyJumpActions))
+            multiKeyJump = &d->destinationMap[multiKeyJumpActions[0]];
+    }
+    // Find regular bindings (both single- and multi-key) in the given
+    // and global contexts.
+    if (kctx)
+    {
+        if (noOverflow)
+            kctx->multiData.GetMultikeyMapping(prefix, multiKeyActions);
+        kctx->multiData.GetMultikeyMapping(singleKey, singleKeyActions);
+    }
+    if (gctx && context != "Global")
+    {
+        if (noOverflow)
+            gctx->multiData.GetMultikeyMapping(prefix, multiKeyActions);
+        gctx->multiData.GetMultikeyMapping(singleKey, singleKeyActions);
+    }
+
+    // Disable the jump point if there is a corresponding local action
+    // for the key sequence.
+    if (multiKeyJump &&
+        !multiKeyJump->localAction.isEmpty() &&
+        multiKeyActions.contains(multiKeyJump->localAction))
+    {
+        multiKeyJump = singleKeyJump = NULL;
+    }
+    if (singleKeyJump &&
+        !singleKeyJump->localAction.isEmpty() &&
+        singleKeyActions.contains(singleKeyJump->localAction))
+    {
+        multiKeyJump = singleKeyJump = NULL;
+        multiKeyActions = singleKeyActions;
+    }
+
+    // Execute the jump point if there is one.
+    if (multiKeyJump || (singleKeyJump && multiKeyActions.isEmpty()))
+    {
+        JumpData *jumpEntry = multiKeyJump ? multiKeyJump : singleKeyJump;
+        if (!jumpEntry->exittomain && d->exitmenucallback == NULL)
+        {
+            if (prefixContext)
+                prefixContext->SetStatus(MultikeyContext::kMKfullMatch);
+            void (*callback)(void) = jumpEntry->callback;
+            callback();
+            return true;
+        }
+        if (d->exitmenucallback == NULL)
+        {
+            if (prefixContext)
+                prefixContext->SetStatus(MultikeyContext::kMKfullMatch);
+            d->exitingtomain = true;
+            d->exitmenucallback = jumpEntry->callback;
+            QCoreApplication::postEvent(
+                this, new QEvent(MythEvent::kExitToMainMenuEventType));
+            return true;
+        }
     }
 
-    if (allowJumps && d->jumpMap.count(keynum) > 0 &&
-            !d->jumpMap[keynum]->exittomain && d->exitmenucallback == NULL)
+    // Handle a regular action if there is one.
+    if (!multiKeyActions.isEmpty())
     {
-        void (*callback)(void) = d->jumpMap[keynum]->callback;
-        callback();
-        return true;
+        if (prefixContext)
+            prefixContext->SetStatus(MultikeyContext::kMKfullMatch);
+        actions = multiKeyActions;
+        return false;
     }
 
-    if (allowJumps &&
-        d->jumpMap.count(keynum) > 0 && d->exitmenucallback == NULL)
+    // No full match, so handle partial matches and bad matches.
+    if (noOverflow)
     {
-        d->exitingtomain = true;
-        d->exitmenucallback = d->jumpMap[keynum]->callback;
-        QCoreApplication::postEvent(
-            this, new QEvent(MythEvent::kExitToMainMenuEventType));
-        return true;
+        // Check for a partial match.
+        if ((kctx && kctx->multiData.IsMultikeyPrefix(prefix)) ||
+            (gctx && context != "Global" && gctx->multiData.IsMultikeyPrefix(prefix)) ||
+            (d->jumpMultikeyData.IsMultikeyPrefix(prefix)))
+        {
+            if (prefixContext)
+                prefixContext->SetStatus(MultikeyContext::kMKpartialMatch);
+            return false;
+        }
     }
-
-    if (d->keyContexts.value(context))
-        d->keyContexts.value(context)->GetMapping(keynum, actions);
-
-    if (context != "Global")
-        d->keyContexts.value("Global")->GetMapping(keynum, actions);
-
+    if (prefixContext)
+        prefixContext->SetStatus(wasEmpty ? MultikeyContext::kMKnoPrefix :
+                                 MultikeyContext::kMKbadMatch);
     return false;
 }
 
@@ -1523 +1667 @@
 }
 
 void MythMainWindow::BindKey(const QString &context, const QString &action,
-                             const QString &key)
+                             const QString &key, const QString &multikey)
 {
     QKeySequence keyseq(key);
 
@@ -1551 +1695 @@
         if (action == "ESCAPE" && context == "Global" && i == 0)
             d->escapekey = keynum;
     }
+
+    QStringList multidummyaction("");
+    if (d->keyContexts.value(context)->multiData.GetMultikeyMapping(multikey, multidummyaction))
+    {
+        VERBOSE(VB_GENERAL, QString("Multikey %1 is bound to multiple actions "
+                                    "in context %2.")
+                .arg(multikey).arg(context));
+    }
+    d->keyContexts.value(context)->multiData.AddMultikeyMapping(multikey, action);
 }
 
 void MythMainWindow::RegisterKey(const QString &context, const QString &action,
                                  const QString &description, const QString &key)
 {
     QString keybind = key;
+    QString multikeybind = "";
 
     MSqlQuery query(MSqlQuery::InitCon());
 
     if (d->m_useDB && query.isConnected())
     {
-        query.prepare("SELECT keylist, description FROM keybindings WHERE "
+        query.prepare("SELECT keylist, description, multikey FROM keybindings WHERE "
                       "context = :CONTEXT AND action = :ACTION AND "
                       "hostname = :HOSTNAME ;");
         query.bindValue(":CONTEXT", context);
@@ -1573 +1727 @@
         {
             keybind = query.value(0).toString();
             QString db_description = query.value(1).toString();
+            multikeybind = query.value(2).toString();
 
             // Update keybinding description if changed
             if (db_description != description)
@@ -1599 +1754 @@
         else
         {
             QString inskey = keybind;
+            QString insmultikey = multikeybind;
 
             query.prepare("INSERT INTO keybindings (context, action, "
-                          "description, keylist, hostname) VALUES "
+                          "description, keylist, hostname, multikey) VALUES "
                           "( :CONTEXT, :ACTION, :DESCRIPTION, :KEYLIST, "
-                          ":HOSTNAME );");
+                          ":HOSTNAME, :MULTIKEY );");
             query.bindValue(":CONTEXT", context);
             query.bindValue(":ACTION", action);
             query.bindValue(":DESCRIPTION", description);
             query.bindValue(":KEYLIST", inskey);
             query.bindValue(":HOSTNAME", GetMythDB()->GetHostName());
+            query.bindValue(":MULTIKEY", insmultikey);
 
             if (!query.exec() && !(GetMythDB()->SuppressDBMessages()))
             {
@@ -1617 +1774 @@
         }
     }
 
-    BindKey(context, action, keybind);
+    BindKey(context, action, keybind, multikeybind);
 }
 
 QString MythMainWindow::GetKey(const QString &context,
@@ -1662 +1819 @@
 }
 
 
-void MythMainWindow::BindJump(const QString &destination, const QString &key)
+void MythMainWindow::BindJump(const QString &destination, const QString &key,
+                              const QString &multikey)
 {
     /* make sure the jump point exists */
     if (d->destinationMap.find(destination) == d->destinationMap.end())
@@ -1684 +1842 @@
             //                           .arg(keybind).arg(destination));
 
             d->jumpMap[keynum] = &d->destinationMap[destination];
+            d->jumpMultikeyData.AddMultikeyMapping(QKeySequence(keynum).toString(), destination);
         }
         else
         {
@@ -1695 +1854 @@
     //    VERBOSE(VB_GENERAL, QString("JumpPoint: %2 exists, no keybinding")
     //                               .arg(destination));
 
+    d->jumpMultikeyData.AddMultikeyMapping(multikey, destination);
 }
 
 void MythMainWindow::RegisterJump(const QString &destination,
@@ -1703 +1863 @@
                                   bool exittomain, QString localAction)
 {
     QString keybind = key;
+    QString multikeybind = "";
 
     MSqlQuery query(MSqlQuery::InitCon());
     if (query.isConnected())
     {
-        query.prepare("SELECT keylist FROM jumppoints WHERE "
+        query.prepare("SELECT keylist, multikey FROM jumppoints WHERE "
                       "destination = :DEST and hostname = :HOST ;");
         query.bindValue(":DEST", destination);
         query.bindValue(":HOST", GetMythDB()->GetHostName());
@@ -1715 +1876 @@
         if (query.exec() && query.next())
         {
             keybind = query.value(0).toString();
+            multikeybind = query.value(1).toString();
         }
         else
         {
             QString inskey = keybind;
+            QString insmultikey = multikeybind;
 
             query.prepare("INSERT INTO jumppoints (destination, description, "
-                          "keylist, hostname) VALUES ( :DEST, :DESC, :KEYLIST, "
-                          ":HOST );");
+                          "keylist, hostname, multikey) VALUES ( :DEST, :DESC, :KEYLIST, "
+                          ":HOST, :MULTIKEY );");
             query.bindValue(":DEST", destination);
             query.bindValue(":DESC", description);
             query.bindValue(":KEYLIST", inskey);
             query.bindValue(":HOST", GetMythDB()->GetHostName());
+            query.bindValue(":MULTIKEY", insmultikey);
 
             if (!query.exec() || !query.isActive())
             {
@@ -1739 +1903 @@
         { callback, destination, description, exittomain, localAction };
     d->destinationMap[destination] = jd;
 
-    BindJump(destination, keybind);
+    BindJump(destination, keybind, multikeybind);
 }
 
 void MythMainWindow::JumpTo(const QString& destination, bool pop)

mythtv/libs/libmythui/mythmainwindow.h

@@ -27 +27 @@
 class MythPainterWindowD3D9;
 class MythRender;
 
+class MultikeyContext
+{
+ public:
+    enum MultikeyStatus {
+        kMKnoPrefix,
+        kMKpartialMatch,
+        kMKfullMatch,
+        kMKbadMatch
+    };
+    MultikeyContext(void)
+        : oldPrefix(""), currentPrefix(""), status(kMKnoPrefix) {}
+    void SetStatus(MultikeyStatus why) { status = why; }
+    const QString &GetPrefix(void) { return currentPrefix; }
+    bool AddKey(int key);
+    void Commit(MultikeyStatus &s, QString &prefix) {
+        prefix = currentPrefix;
+        s = status;
+        if (status != kMKpartialMatch)
+        {
+            currentPrefix = "";
+            status = kMKnoPrefix;
+        }
+        oldPrefix = currentPrefix;
+    }
+ private:
+    QString oldPrefix;
+    QString currentPrefix;
+    MultikeyStatus status;
+};
+
 class MUI_PUBLIC MythMainWindow : public QWidget
 {
     Q_OBJECT
@@ -48 +78 @@
     MythScreenStack *GetStackAt(int pos);
 
     bool TranslateKeyPress(const QString &context, QKeyEvent *e,
-                           QStringList &actions, bool allowJumps = true)
+                           QStringList &actions, bool allowJumps = true,
+                           MultikeyContext *prefixContext = NULL)
                            MUNUSED_RESULT;
 
     void ResetKeys(void);
     void ClearKey(const QString &context, const QString &action);
     void ClearKeyContext(const QString &context);
     void BindKey(const QString &context, const QString &action,
-                 const QString &key);
+                 const QString &key, const QString &multikey);
     void RegisterKey(const QString &context, const QString &action,
                      const QString &description, const QString &key);
     QString GetKey(const QString &context, const QString &action) const;
 
     void ClearJump(const QString &destination);
-    void BindJump(const QString &destination, const QString &key);
+    void BindJump(const QString &destination, const QString &key,
+                  const QString &multikey);
     void RegisterJump(const QString &destination, const QString &description,
                       const QString &key, void (*callback)(void),
                       bool exittomain = true, QString localAction = "");

mythtv/programs/mythfrontend/keybindings.cpp

@@ -283 +283 @@
     }
 
     GetMythMainWindow()->ClearKey(id.GetContext(), id.GetAction());
-    GetMythMainWindow()->BindKey(id.GetContext(), id.GetAction(), keys);
+    GetMythMainWindow()->BindKey(id.GetContext(), id.GetAction(), keys, "");
 }
 
 /** \fn KeyBindings::CommitJumppoint(const ActionID&)
@@ -312 +312 @@
     }
 
     GetMythMainWindow()->ClearJump(id.GetAction());
-    GetMythMainWindow()->BindJump(id.GetAction(), keys);
+    // XXX- The following line causes the jumppoint editor to erase
+    // from memory (but not from the database) any existing multikey
+    // binding for the jumppoint.  Fixing this would require further
+    // digging into action{,set}.{h,cpp}.
+    GetMythMainWindow()->BindJump(id.GetAction(), keys, "");
 }
 
 /** \fn KeyBindings::CommitChanges(void)