Ticket #10053: mythinputevent-2011-10-18.diff

mythtv/libs/libmythui/libmythui.pro

@@ -30 +30 @@
 HEADERS += mythvirtualkeyboard.h mythuishape.h mythuiguidegrid.h
 HEADERS += mythrender_base.h mythfontmanager.h mythuieditbar.h
 HEADERS += mythdisplay.h mythuivideo.h mythudplistener.h
-HEADERS += mythuiexp.h
+HEADERS += mythuiexp.h mythinputmanager.h mythinputevent.h 
 
 SOURCES  = mythmainwindow.cpp mythpainter.cpp mythimage.cpp mythrect.cpp
 SOURCES += myththemebase.cpp  mythpainter_qimage.cpp mythpainter_yuva.cpp
@@ -47 +47 @@
 SOURCES += mythgenerictree.cpp mythuibuttontree.cpp mythuiutils.cpp
 SOURCES += mythvirtualkeyboard.cpp mythuishape.cpp mythuiguidegrid.cpp
 SOURCES += mythfontmanager.cpp mythuieditbar.cpp
-SOURCES += mythdisplay.cpp mythuivideo.cpp mythudplistener.cpp
+SOURCES += mythdisplay.cpp mythuivideo.cpp mythudplistener.cpp mythinputevent.cpp
 
 
 inc.path = $${PREFIX}/include/mythtv/libmythui/
@@ -64 +64 @@
 inc.files += x11colors.h mythgenerictree.h mythuibuttontree.h
 inc.files += mythvirtualkeyboard.h mythuishape.h mythuiguidegrid.h
 inc.files += mythuieditbar.h mythuifilebrowser.h mythuivideo.h
-inc.files += mythuiexp.h mythuiactions.h
+inc.files += mythuiexp.h mythuiactions.h mythinputevent.h
 
 INSTALLS += inc
 

mythtv/libs/libmythui/lirc.cpp

@@ -22 +22 @@
 #include "mythdb.h"
 #include "mythsystem.h"
 #include "lircevent.h"
+#include "mythinputevent.h"
 #include "lirc_client.h"
 
 #include <sys/types.h>
@@ -297 +298 @@
             LOG(vtype, LOG_ERR, LOC +
                 QString("Failed to read config file '%1'").arg(configFile));
 
-            lirc_deinit(d->lircState);
+            /*lirc_deinit(d->lircState);
             d->lircState = NULL;
-            return false;
+            return false;*/
+            return true;
         }
     }
 
@@ -330 +332 @@
     return doRun;
 }
 
+/**
+ * Send a MythInoutEvent from date
+ * use when no .lircrc found or config can not be converted to QKeyEvnt
+ */
+void LIRC::processData(const QByteArray &data)
+{
+    QString remoteName;
+    QString buttonName;
+    QString code(data);
+    QStringList codes = code.split(" ");
+    if (codes.size() == 4)
+    {
+        buttonName=QString(codes.at(2));
+        remoteName=QString(codes.at(3));
+        LOG(VB_GENERAL, LOG_ERR, QString("lircd: %1 %2")
+                .arg(buttonName).arg(remoteName));
+        MythInputEvent * event = new MythInputEvent("lirc", remoteName, buttonName);
+        QCoreApplication::postEvent(m_mainWindow, event);
+    }
+}
+
 void LIRC::Process(const QByteArray &data)
 {
     QMutexLocker static_lock(&lirclib_lock);
 
-    // lirc_code2char will make code point to a static datafer..
-    char *code = NULL;
-    int ret = lirc_code2char(
-        d->lircState, d->lircConfig, const_cast<char*>(data.constData()), &code);
-
-    while ((0 == ret) && code)
+    if (d->lircConfig)
     {
-        QString lirctext(code);
-        QString qtcode = code;
-        qtcode.replace("ctrl-",  "ctrl+",  Qt::CaseInsensitive);
-        qtcode.replace("alt-",   "alt+",   Qt::CaseInsensitive);
-        qtcode.replace("shift-", "shift+", Qt::CaseInsensitive);
-        qtcode.replace("meta-",  "meta+",  Qt::CaseInsensitive);
-        QKeySequence a(qtcode);
-
-        // Send a dummy keycode if we couldn't convert the key sequence.
-        // This is done so the main code can output a warning for bad
-        // mappings.
-        if (!a.count())
-        {
-            QCoreApplication::postEvent(
-                m_mainWindow, new LircKeycodeEvent(
-                    QEvent::KeyPress, 0,
-                    (Qt::KeyboardModifiers)
-                    LircKeycodeEvent::kLIRCInvalidKeyCombo,
-                    QString(), lirctext));
-        }
+        // lirc_code2char will make code point to a static datafer..
+        char *code = NULL;
+        int ret = lirc_code2char(
+            d->lircState, d->lircConfig, const_cast<char*>(data.constData()), &code);
 
-        vector<LircKeycodeEvent*> keyReleases;
-        for (unsigned int i = 0; i < a.count(); i++)
+            LOG(VB_GENERAL, LOG_ERR, QString("lircd: ret %1")
+                    .arg(ret));
+
+        while ((0 == ret) && code)
         {
-            int keycode = a[i];
-            Qt::KeyboardModifiers mod = Qt::NoModifier;
-            mod |= (Qt::SHIFT & keycode) ? Qt::ShiftModifier : Qt::NoModifier;
-            mod |= (Qt::META  & keycode) ? Qt::MetaModifier  : Qt::NoModifier;
-            mod |= (Qt::CTRL  & keycode) ? Qt::ControlModifier: Qt::NoModifier;
-            mod |= (Qt::ALT   & keycode) ? Qt::AltModifier   : Qt::NoModifier;
-
-            keycode &= ~Qt::MODIFIER_MASK;
-
-            QString text = "";
-            if (!mod)
-                text = QString(QChar(keycode));
-
-            QCoreApplication::postEvent(
-                m_mainWindow, new LircKeycodeEvent(
-                    QEvent::KeyPress, keycode, mod, text, lirctext));
-
-            keyReleases.push_back(
-                new LircKeycodeEvent(
-                    QEvent::KeyRelease, keycode, mod, text, lirctext));
-        }
+            QString lirctext(code);
+            QString qtcode = code;
+            qtcode.replace("ctrl-",  "ctrl+",  Qt::CaseInsensitive);
+            qtcode.replace("alt-",   "alt+",   Qt::CaseInsensitive);
+            qtcode.replace("shift-", "shift+", Qt::CaseInsensitive);
+            qtcode.replace("meta-",  "meta+",  Qt::CaseInsensitive);
+            QKeySequence a(qtcode);
+
+            LOG(VB_GENERAL, LOG_ERR, QString("lircd:  %1")
+                    .arg(code));
+
+            // Send a dummy keycode if we couldn't convert the key sequence.
+            // This is done so the main code can output a warning for bad
+            // mappings.
+            if (!a.count())
+            {
+            LOG(VB_GENERAL, LOG_ERR, QString("lircd: dummy code %1")
+                    .arg(QString(data)));
+                processData(data);
+                /*QCoreApplication::postEvent(
+                    m_mainWindow, new LircKeycodeEvent(
+                        QEvent::KeyPress, 0,
+                        (Qt::KeyboardModifiers)
+                        LircKeycodeEvent::kLIRCInvalidKeyCombo,
+                        QString(), lirctext));*/
+            }
+
+            vector<LircKeycodeEvent*> keyReleases;
+            for (unsigned int i = 0; i < a.count(); i++)
+            {
+                int keycode = a[i];
+                Qt::KeyboardModifiers mod = Qt::NoModifier;
+                mod |= (Qt::SHIFT & keycode) ? Qt::ShiftModifier : Qt::NoModifier;
+                mod |= (Qt::META  & keycode) ? Qt::MetaModifier  : Qt::NoModifier;
+                mod |= (Qt::CTRL  & keycode) ? Qt::ControlModifier: Qt::NoModifier;
+                mod |= (Qt::ALT   & keycode) ? Qt::AltModifier   : Qt::NoModifier;
+
+                keycode &= ~Qt::MODIFIER_MASK;
+
+                QString text = "";
+                if (!mod)
+                    text = QString(QChar(keycode));
+
+                QCoreApplication::postEvent(
+                    m_mainWindow, new LircKeycodeEvent(
+                        QEvent::KeyPress, keycode, mod, text, lirctext));
+
+                keyReleases.push_back(
+                    new LircKeycodeEvent(
+                        QEvent::KeyRelease, keycode, mod, text, lirctext));
+            }
 
-        for (int i = (int)keyReleases.size() - 1; i>=0; i--)
-            QCoreApplication::postEvent(m_mainWindow, keyReleases[i]);
+            for (int i = (int)keyReleases.size() - 1; i>=0; i--)
+                QCoreApplication::postEvent(m_mainWindow, keyReleases[i]);
 
-        ret = lirc_code2char(
-            d->lircState, d->lircConfig, const_cast<char*>(data.constData()), &code);
+            ret = lirc_code2char(
+                d->lircState, d->lircConfig, const_cast<char*>(data.constData()), &code);
+        }
+    }
+    else
+    {
+        processData(data);
     }
 }
 

mythtv/libs/libmythui/lirc.h

@@ -42 +42 @@
     virtual void run(void);
     QList<QByteArray> GetCodes(void);
     void Process(const QByteArray &data);
+    void processData(const QByteArray &data);
 
     mutable QMutex  lock;
     static  QMutex  lirclib_lock;

mythtv/libs/libmythui/mythmainwindow.cpp

@@ -52 +52 @@
 #include "lircevent.h"
 #include "mythudplistener.h"
 #include "mythrender_base.h"
+#include "mythinputmanager.h"
 
 #ifdef USING_APPLEREMOTE
 #include "AppleRemoteListener.h"
@@ -115 +116 @@
     MediaPlayCallback playFn;
 };
 
+
+class ButtonMapping
+{
+  public:
+    ButtonMapping(const QString &buttonName):m_buttonName(buttonName),m_jump(0){};
+    QString buttonName(){return m_buttonName;};
+    void addMapping(const QString &context, const QString & action)
+    {
+        m_contextMapping[context].append(action);
+    }
+
+    bool getMapping(const QString &context, QStringList &actions)
+    {
+        if (m_contextMapping.count(context) > 0)
+        {
+            actions += m_contextMapping[context];
+            return true;
+        }
+        return false;
+    };
+    
+    void addJump(JumpData * jump)
+    {
+        m_jump=jump;
+    }
+
+    JumpData * getJump()
+    {
+        return m_jump;
+    }
+    void clearJump(const QString &destination)
+    {
+        if (m_jump && m_jump->destination == destination)
+            m_jump=NULL;
+    }
+
+  private:
+    QString m_buttonName;
+    JumpData * m_jump;
+    QMap<QString,QStringList> m_contextMapping; //i.e context -> action(s)
+};
+
+class RemoteMapping
+{
+  public:
+    RemoteMapping(const QString &remoteName):m_remoteName(remoteName){}
+    QString remoteName(){return m_remoteName;};
+    void addMapping(const QString &buttonName, const QString &context, const QString & action)
+    {
+        if (!m_buttonMapping.contains(buttonName))
+        {
+            m_buttonMapping[buttonName]=new ButtonMapping(buttonName);
+        }
+        m_buttonMapping[buttonName]->addMapping(context, action);
+    }
+    bool getMapping(const QString &buttonName, const QString &context, QStringList &actions)
+    {
+        if (m_buttonMapping.contains(buttonName))
+            return m_buttonMapping[buttonName]->getMapping(context, actions);
+        return false;
+    }
+    void addJump(const QString &buttonName, JumpData * jump)
+    {
+        if (!m_buttonMapping.contains(buttonName))
+        {
+            m_buttonMapping[buttonName]=new ButtonMapping(buttonName);
+        }
+        m_buttonMapping[buttonName]->addJump(jump);
+    }
+    JumpData * getJump(const QString &buttonName)
+    {
+        ButtonMapping * buttonMapping = m_buttonMapping.value(buttonName);
+        if (buttonMapping)
+        {
+            return buttonMapping->getJump();
+        }
+        return NULL;
+    }
+    void clearJump(const QString &destination)
+    {
+        ButtonMapping*buttonMapping;
+        foreach (buttonMapping, m_buttonMapping)
+            buttonMapping->clearJump(destination);
+    }
+  private:
+    QMap<QString,ButtonMapping*> m_buttonMapping;
+    QString m_remoteName;
+};
+
+class InputMapping
+{
+  public:
+    InputMapping(const QString &inputName)
+        :m_inputName(inputName){};
+    QString inputName(){return m_inputName;};
+    void addMapping(const QString &remoteName, const QString &buttonName, const QString &context, const QString & action)
+    {
+        if (!m_remoteMapping.contains(remoteName))
+        {
+            m_remoteMapping[remoteName]=new RemoteMapping(remoteName);
+        }
+        m_remoteMapping[remoteName]->addMapping(buttonName, context, action);
+    }
+    bool getMapping(const QString &remoteName, const QString &buttonName, const QString &context, QStringList &actions)
+    {
+        if (m_remoteMapping.contains(remoteName))
+            return m_remoteMapping[remoteName]->getMapping(buttonName, context, actions);
+        return true;
+    }
+    void addJump(const QString &remoteName, const QString &buttonName, JumpData * jump)
+    {
+        if (!m_remoteMapping.contains(remoteName))
+        {
+            m_remoteMapping[remoteName]=new RemoteMapping(remoteName);
+        }
+        m_remoteMapping[remoteName]->addJump(buttonName, jump);
+    }
+    JumpData * getJump(const QString &remoteName, const QString &buttonName)
+    {
+        if (m_remoteMapping.contains(remoteName))
+        {
+            return m_remoteMapping[remoteName]->getJump(buttonName);
+        }
+        return NULL;
+    }
+    void clearJump(const QString &destination)
+    {
+        RemoteMapping*remoteMapping;
+        foreach (remoteMapping, m_remoteMapping)
+            remoteMapping->clearJump(destination);
+    }
+  private:
+    QMap <QString,RemoteMapping*> m_remoteMapping;
+    QString m_inputName;
+};
+
+
 class MythMainWindowPrivate
 {
   public:
@@ -211 +351 @@
     QMap<int, JumpData*> jumpMap;
     QMap<QString, JumpData> destinationMap;
     QMap<QString, MPData> mediaPluginMap;
+    QMap<QString, InputMapping*> inputsMapping;
 
     void (*exitmenucallback)(void);
 
@@ -1430 +1583 @@
     }
 }
 
+bool MythMainWindow::TranslateKeyPress(const QString &context,
+                                       MythInputEvent *e, QStringList &actions,
+                                       bool allowJumps)
+{
+    actions.clear();
+
+    QStringList localActions;
+
+    JumpData * jump = NULL;
+
+    if (allowJumps)
+    {
+        InputMapping * inputMapping = d->inputsMapping.value(e->inputName());
+        if (inputMapping)
+        {
+            jump = inputMapping->getJump(e->remoteName(),
+                    e->buttonName());
+            if (jump)
+            {
+                inputMapping->getMapping(e->remoteName(),
+                        e->buttonName(), context, localActions);
+                if (localActions.contains(jump->localAction))
+                    allowJumps = false;                
+            }
+        }
+    }
+
+    if (allowJumps && jump && !jump->exittomain && d->exitmenucallback == NULL)
+    {
+        d->exitingtomain = true;
+        d->exitmenucallback = jump->callback;
+        QCoreApplication::postEvent(
+            this, new QEvent(MythEvent::kExitToMainMenuEventType));
+        return true;
+    }
+
+    if (d->inputsMapping.value(e->inputName()))
+    {
+        d->inputsMapping.value(e->inputName())->getMapping(e->remoteName(),
+            e->buttonName(), context, actions);
+
+        d->inputsMapping.value(e->inputName())->getMapping(e->remoteName(),
+            e->buttonName(), "Global", actions);
+    }
+    return false; 
+}
+
 /**
  * \brief Get a list of actions for a keypress in the given context
  * \param context The context in which to lookup the keypress for actions.
@@ -1444 +1644 @@
                                        QKeyEvent *e, QStringList &actions,
                                        bool allowJumps)
 {
+    MythInputEvent * me = dynamic_cast<MythInputEvent *>(e);
+    if (me)
+    {
+        bool handled =  TranslateKeyPress(context,me, actions, allowJumps);
+        if (handled || actions.size()>0) 
+            return handled;
+    }
+
     actions.clear();
 
     // Special case for custom QKeyEvent where the action is embedded directly
@@ -1579 +1787 @@
     {
         query.prepare("SELECT keylist, description FROM keybindings WHERE "
                       "context = :CONTEXT AND action = :ACTION AND "
-                      "hostname = :HOSTNAME ;");
+                      "hostname = :HOSTNAME AND input='' AND device='';");
         query.bindValue(":CONTEXT", context);
         query.bindValue(":ACTION", action);
         query.bindValue(":HOSTNAME", GetMythDB()->GetHostName());
@@ -1617 +1825 @@
             QString inskey = keybind;
 
             query.prepare("INSERT INTO keybindings (context, action, "
-                          "description, keylist, hostname) VALUES "
+                          "description, keylist, hostname, input, device) VALUES "
                           "( :CONTEXT, :ACTION, :DESCRIPTION, :KEYLIST, "
-                          ":HOSTNAME );");
+                          ":HOSTNAME , '', '');");
             query.bindValue(":CONTEXT", context);
             query.bindValue(":ACTION", action);
             query.bindValue(":DESCRIPTION", description);
@@ -1634 +1842 @@
     }
 
     BindKey(context, action, keybind);
+
+    if (d->m_useDB && query.isConnected())
+    {
+        query.prepare("SELECT input, device, keylist FROM keybindings WHERE "
+                      "context = :CONTEXT AND action = :ACTION AND "
+                      "hostname = :HOSTNAME AND input!='' AND device!='';");
+        query.bindValue(":CONTEXT", context);
+        query.bindValue(":ACTION", action);
+        query.bindValue(":HOSTNAME", GetMythDB()->GetHostName());
+        if (query.exec())
+        {
+        while (query.next())
+        {
+            QString inputName  = query.value(0).toString();
+            QString remoteName = query.value(1).toString();
+            QString buttonName = query.value(2).toString();
+            LOG(VB_GENERAL, LOG_ERR,
+            QString("MythMainWindow::RegisterKey %1 %2 %3")
+                    .arg(inputName).arg(remoteName).arg(buttonName));
+            if (!d->inputsMapping.value(inputName))
+                d->inputsMapping[inputName]=new InputMapping(inputName);
+            d->inputsMapping[inputName]->addMapping(remoteName, buttonName, context, action);
+        }
+        }
+    }
 }
 
 QString MythMainWindow::GetKey(const QString &context,
@@ -1660 +1893 @@
 
 void MythMainWindow::ClearJump(const QString &destination)
 {
+    InputMapping * inputMapping;
+    foreach(inputMapping, d->inputsMapping)
+        inputMapping->clearJump(destination);
+
     /* make sure that the jump point exists (using [] would add it)*/
     if (d->destinationMap.find(destination) == d->destinationMap.end())
     {
@@ -1729 +1966 @@
     if (query.isConnected())
     {
         query.prepare("SELECT keylist FROM jumppoints WHERE "
-                      "destination = :DEST and hostname = :HOST ;");
+                      "destination = :DEST and hostname = :HOST and input='' and device='';");
         query.bindValue(":DEST", destination);
         query.bindValue(":HOST", GetMythDB()->GetHostName());
 
@@ -1742 +1979 @@
             QString inskey = keybind;
 
             query.prepare("INSERT INTO jumppoints (destination, description, "
-                          "keylist, hostname) VALUES ( :DEST, :DESC, :KEYLIST, "
-                          ":HOST );");
+                          "keylist, hostname, input, device) VALUES ( :DEST, :DESC, :KEYLIST, "
+                          ":HOST, '', '' );");
             query.bindValue(":DEST", destination);
             query.bindValue(":DESC", description);
             query.bindValue(":KEYLIST", inskey);
@@ -1761 +1998 @@
     d->destinationMap[destination] = jd;
 
     BindJump(destination, keybind);
+
+    //TODO Xavier load additionnal jumppoint for remote
+    if (query.isConnected())
+    {
+        query.prepare("SELECT input, device, keylist FROM jumppoints WHERE "
+                      "destination = :DEST and hostname = :HOST and input!='' and device!='';");
+        query.bindValue(":DEST", destination);
+        query.bindValue(":HOST", GetMythDB()->GetHostName());
+
+        if (query.exec() && query.next())
+        {
+            QString inputName  = query.value(0).toString();
+            QString remoteName = query.value(1).toString();
+            QString buttonName = query.value(2).toString();
+
+            if (!d->inputsMapping.value(inputName))
+                d->inputsMapping[inputName]=new InputMapping(inputName);
+            d->inputsMapping[inputName]->addJump(remoteName, buttonName, &jd);
+        }
+    }
 }
 
 void MythMainWindow::ClearAllJumps()

mythtv/libs/libmythui/mythmainwindow.h

@@ -6 +6 @@
 #include "mythuiactions.h"
 #include "mythuitype.h"
 #include "mythscreenstack.h"
+#include "mythinputevent.h"
 
 class QEvent;
 
@@ -48 +49 @@
     MythScreenStack *GetStack(const QString &stackname);
     MythScreenStack *GetStackAt(int pos);
 
+    bool TranslateKeyPress(const QString &context, MythInputEvent *e,
+                           QStringList &actions, bool allowJumps = true)
+                           MUNUSED_RESULT;
+
     bool TranslateKeyPress(const QString &context, QKeyEvent *e,
                            QStringList &actions, bool allowJumps = true)
                            MUNUSED_RESULT;