Ticket #2239: mythtv-lirc-20060824.diff

libs/libmythtv/tv_play.cpp

@@ -39 +39 @@
 #include "DVDRingBuffer.h"
 #include "datadirect.h"
 #include "sourceutil.h"
+#include "mythkeysequence.h"
 
 #ifndef HAVE_ROUND
 #define round(x) ((int) ((x) + 0.5))
@@ -608 +609 @@
             {
                 query.next();
 
-                QKeySequence keyseq(query.value(0).toString());
+                MythKeySequence keyseq(query.value(0).toString());
 
-                int keynum = keyseq[0];
+                int keynum = keyseq[0]->value();
                 keynum &= ~Qt::UNICODE_ACCEL;
    
                 keyList.prepend(new QKeyEvent(QEvent::KeyPress, keynum, 0, 0));

libs/libmythui/mythmainwindow.cpp

@@ -40 +40 @@
 #include "mythcontext.h"
 #include "mythdbcon.h"
 #include "mythgesture.h"
+#include "mythkeysequence.h"
 
 /* from libmyth */
 #include "screensaver.h"
@@ -95 +96 @@
 class KeyContext
 {
   public:
-    void AddMapping(int key, QString action)
+    void AddMapping(QString key, QString action)
     {
         actionMap[key].append(action);
     }
+    void AddMapping(int key, QString action)
+    {
+        QString keystr; 
+        keystr.setNum(key);
+        actionMap[keystr].append(action);
+    }
 
-    bool GetMapping(int key, QStringList &actions)
+    bool GetMapping(QString key, QStringList &actions)
     {
         if (actionMap.count(key) > 0)
         {
@@ -109 +116 @@
         }
         return false;
     }
+    bool GetMapping(int key, QStringList &actions)
+    {
+        QString keystr; 
+        keystr.setNum(key);
+        return GetMapping(keystr, actions);
+    }
 
-    QMap<int, QStringList> actionMap;
+    //QMap<int, QStringList> actionMap;
+    QMap<QString, QStringList> actionMap;
 };
 
 struct JumpData
@@ -153 +167 @@
     bool popwindows;
 
     QDict<KeyContext> keyContexts;
-    QMap<int, JumpData*> jumpMap;
+    //QMap<int, JumpData*> jumpMap;
+    QMap<QString, JumpData*> jumpMap;
     QMap<QString, JumpData> destinationMap;
     QMap<QString, MHData> mediaHandlerMap;
     QMap<QString, MPData> mediaPluginMap;
@@ -649 +664 @@
                                                0, Qt::NoButton);
                 QObject *key_target = getTarget(*key);
                 QApplication::postEvent(key_target, key);
+                return;
             }
             return;
         }
@@ -672 +688 @@
                 QKeyEvent *key = new QKeyEvent(QEvent::KeyPress, d->escapekey,
                                                0, Qt::NoButton);
                 QApplication::postEvent(this, key);
+                return;
             }
             return;
         }
@@ -705 +722 @@
 {
     actions.clear();
     int keynum = d->TranslateKeyNum(e);
+    bool retval = false;
 
+    QString keystr;
+    keystr.setNum( keynum );
+
+#ifdef USE_LIRC
+    /* If there's LIRC support, we must check for those here -- check the
+     * remoteXXXXX identifiers;
+     */
+    if ((e->ascii( ) == 0) && (e->key( ) == 0) && (e->text( ).left(6) == "remote"))
+    {
+        VERBOSE(VB_GENERAL, QString("MythMainWindow::TranslateKeyPress() - Remote button '%1' received in context '%2'.")
+                                              .arg(e->text( )).arg(context.latin1()) );
+
+        if (allowJumps && 
+            d->jumpMap.count(e->text()) > 0 && d->exitmenucallback == NULL)
+        {
+            d->exitingtomain = true;
+            d->exitmenucallback = d->jumpMap[ e->text() ]->callback;
+            QApplication::postEvent(this, new ExitToMainMenuEvent());
+            return false;
+        }
+
+
+        if ((d->keyContexts[context]) &&
+            (d->keyContexts[context]->GetMapping( e->text(), actions)))
+        {
+            retval = true;
+        }
+
+
+        if ((context != "Global") &&
+            (d->keyContexts["Global"]->GetMapping( e->text(), actions )))
+        {
+            retval = true;
+        }
+
+        return retval;
+    }
+
+#endif // USE_LIRC
+
     if (allowJumps && 
-        d->jumpMap.count(keynum) > 0 && d->exitmenucallback == NULL)
+        d->jumpMap.count(keystr) > 0 && d->exitmenucallback == NULL)
     {
         d->exitingtomain = true;
-        d->exitmenucallback = d->jumpMap[keynum]->callback;
+        d->exitmenucallback = d->jumpMap[keystr]->callback;
         QApplication::postEvent(this, new ExitToMainMenuEvent());
         return false;
     }
 
-    bool retval = false;
 
     if (d->keyContexts[context])
     {
-        if (d->keyContexts[context]->GetMapping(keynum, actions))
+        if (d->keyContexts[context]->GetMapping(keystr, actions))
             retval = true;
     }
 
     if (context != "Global" && 
-        d->keyContexts["Global"]->GetMapping(keynum, actions))
+        d->keyContexts["Global"]->GetMapping(keystr, actions))
     {
         retval = true;
     }
@@ -737 +794 @@
     KeyContext * keycontext = d->keyContexts[context];
     if (keycontext == NULL) return;
 
-    QMap<int,QStringList>::Iterator it;
+    //QMap<int,QStringList>::Iterator it;
+    QMap<QString,QStringList>::Iterator it;
     for (it = keycontext->actionMap.begin();
          it != keycontext->actionMap.end();
          it++)
@@ -763 +821 @@
 void MythMainWindow::BindKey(const QString &context, const QString &action,
                              const QString &key)
 {
-    QKeySequence keyseq(key);
+    MythKeySequence keyseq(key);
 
     if (!d->keyContexts[context])
         d->keyContexts.insert(context, new KeyContext());
 
     for (unsigned int i = 0; i < keyseq.count(); i++)
     {
-        int keynum = keyseq[i];
+        int keynum = keyseq[i]->value();
         keynum &= ~Qt::UNICODE_ACCEL;
+        QString keystr;
+#ifdef USE_LIRC
+        if(keyseq[i]->isRemote()) keystr = keyseq[i]->text();
+        else  // intensional
+#endif // USE_LIRC
+        keystr.setNum( keynum );
 
         QStringList dummyaction = "";
-        if (d->keyContexts[context]->GetMapping(keynum, dummyaction))
+        if (d->keyContexts[context]->GetMapping(keystr, dummyaction))
         {
             VERBOSE(VB_GENERAL, QString("Key %1 is bound to multiple actions "
                                         "in context %2.")
                     .arg(key).arg(context));
         }
 
-        d->keyContexts[context]->AddMapping(keynum, action);
+        d->keyContexts[context]->AddMapping(keystr, action);
         //VERBOSE(VB_GENERAL, QString("Binding: %1 to action: %2 (%3)")
         //                           .arg(key).arg(action)
         //                           .arg(context));
@@ -868 +932 @@
        return;
     }
 
-    QMap<int, JumpData*>::Iterator it;
+    // QMap<int, JumpData*>::Iterator it;
+    QMap<QString, JumpData*>::Iterator it;
     for (it = d->jumpMap.begin(); it != d->jumpMap.end(); ++it)
     {
 
@@ -888 +953 @@
        return;
     }
 
-    QKeySequence keyseq(key);
+    MythKeySequence keyseq(key);
 
     for (unsigned int i = 0; i < keyseq.count(); i++)
     {
-        int keynum = keyseq[i];
+        int keynum = keyseq[i]->value();
         keynum &= ~Qt::UNICODE_ACCEL;
+        QString keystr;
+#ifdef USE_LIRC
+        if (keyseq[i]->isRemote()) keystr = keyseq[i]->text();
+        else // intensional
+#endif
+        keystr.setNum( keynum );
 
-        if (d->jumpMap.count(keynum) == 0)
+        if (d->jumpMap.count( keystr ) == 0)
         {
             //VERBOSE(VB_GENERAL, QString("Binding: %1 to JumpPoint: %2")
             //                           .arg(keybind).arg(destination));
-
-            d->jumpMap[keynum] = &d->destinationMap[destination];
+    
+            d->jumpMap[ keystr ] = &d->destinationMap[destination];
         }
         else
         {
-            VERBOSE(VB_GENERAL, QString("Key %1 is already bound to a jump "
-                                        "point.").arg(key));
+            VERBOSE(VB_GENERAL, QString("%1 is already bound to a jump "
+                                        "point.").arg(keystr));
         }
+        //else
+        //    VERBOSE(VB_GENERAL, QString("JumpPoint: %2 exists, no keybinding")
+        //                               .arg(destination));
     }
-    //else
-    //    VERBOSE(VB_GENERAL, QString("JumpPoint: %2 exists, no keybinding")
-    //                               .arg(destination));
-
 }
 
 void MythMainWindow::RegisterJump(const QString &destination, 
@@ -1259 +1329 @@
         LircKeycodeEvent *lke = (LircKeycodeEvent *)ce;
         int keycode = lke->getKeycode();
 
-        if (keycode) 
+        if (lke->getLircText().left(6) == "remote")
         {
+            /* Attempt to send this to the application;
+             */
+             VERBOSE(VB_GENERAL, QString("MythMainWindow::customEvent() - Sending '%1' to keypress-handler.")
+                                                .arg(lke->getLircText()) );
+ 
+            /* Send a press & release -- abusing the Unicode field for
+             * passing the LIRC logical identifier.
+             */
+            QKeyEvent keyp( QEvent::KeyPress, 0, 0, 0, lke->getLircText( ) );
+            QKeyEvent keyr( QEvent::KeyRelease, 0, 0, 0, lke->getLircText( ) );
+ 
+            QObject *key_target = getTarget(keyp);
+        
+            if (!key_target)
+            {
+                QApplication::sendEvent( this, &keyp );
+                QApplication::sendEvent( this, &keyr );
+            }
+            else
+            {
+                QApplication::sendEvent( key_target, &keyp );
+                QApplication::sendEvent( key_target, &keyr );
+            }
+        }
+        else if (keycode)
+        {
             gContext->ResetScreensaver();
             if (gContext->GetScreenIsAsleep())
                 return;

libs/libmyth/lirc.cpp

@@ -15 +15 @@
 #include "lirc.h"
 #include "lircevent.h"
 #include "util.h"
+#include "mythkeysequence.h"
 
 #if (QT_VERSION < 0x030100)
 #error Native LIRC support requires Qt 3.1 or greater.
@@ -72 +73 @@
         while ((ret = lirc_code2char(lircConfig, ir, &code)) == 0 && 
                code != NULL)
         {
-            QKeySequence a(code);
+            MythKeySequence a(code);
 
             int keycode = 0;
 
@@ -85 +86 @@
 
             for (unsigned int i = 0; i < a.count(); i++)
             {
-                keycode = a[i];
-
-                QApplication::postEvent(mainWindow, new LircKeycodeEvent(code, 
+                if (a[i]->isRemote()) // is really bound to a remoteXXX
+                {
+                    QApplication::postEvent(mainWindow, new LircKeycodeEvent( a[i]->text().latin1(), 0, true  ));
+                }
+                else
+                {
+                    keycode = a[i]->value( );
+                    QApplication::postEvent(mainWindow, new LircKeycodeEvent(code, 
                                         keycode, true));
-                QApplication::postEvent(mainWindow, new LircKeycodeEvent(code, 
+                    QApplication::postEvent(mainWindow, new LircKeycodeEvent(code, 
                                         keycode, false));
 
+                }
+
                 SpawnApp();
             }
         }

libs/libmyth/jsmenu.cpp

@@ -32 +32 @@
 #include <fcntl.h>
 
 #include "mythcontext.h"
+#include "mythkeysequence.h"
 
 #include <iostream>
 using namespace std;
@@ -292 +293 @@
 **--------------------------------------------------------------------------*/
 void JoystickMenuClient::EmitKey(QString code)
 {
-    QKeySequence a(code);
+    MythKeySequence a(code);
 
     int keycode = 0;
 
@@ -305 +306 @@
 
     for (unsigned int i = 0; i < a.count(); i++)
     {
-        keycode = a[i];
+        keycode = a[i]->value();
 
         QApplication::postEvent(mainWindow, new JoystickKeycodeEvent(code, 
                                 keycode, true));

libs/libmyth/libmyth.pro

@@ -19 +19 @@
 HEADERS += dbsettings.h screensaver-null.h output.h visual.h
 HEADERS += langsettings.h audiooutputnull.h mythsocket.h
 HEADERS += DisplayResScreen.h util-x11.h mythdeque.h qmdcodec.h
-HEADERS += exitcodes.h virtualkeyboard.h mythobservable.h mythevent.h
+HEADERS += exitcodes.h virtualkeyboard.h mythobservable.h mythevent.h mythkeysequence.h
 
 SOURCES += dialogbox.cpp lcddevice.cpp mythcontext.cpp mythwidgets.cpp 
 SOURCES += oldsettings.cpp remotefile.cpp settings.cpp
@@ -31 +31 @@
 SOURCES += dbsettings.cpp screensaver.cpp screensaver-null.cpp output.cpp
 SOURCES += langsettings.cpp mythdbcon.cpp audiooutputnull.cpp
 SOURCES += DisplayResScreen.cpp util-x11.cpp qmdcodec.cpp
-SOURCES += virtualkeyboard.cpp mythobservable.cpp mythsocket.cpp
+SOURCES += virtualkeyboard.cpp mythobservable.cpp mythsocket.cpp mythkeysequence.cpp
 
 INCLUDEPATH += ../libmythsamplerate ../libmythsoundtouch ../.. ../
 DEPENDPATH += ../libmythsamplerate ../libmythsoundtouch ../ ../libmythui

libs/libmyth/mythkeysequence.h

@@ +1 @@
+/*
+ * File:    mythkeysequence.h
+ *
+ * Purpose: This implements the MythKeySequence class. QKeySequence cannot
+ *          be easily extended not to ignore 'remoteXXX' identifiers.
+ *
+ *          This replacement class fixes that and removes the need for
+ *          some duplicate code in MythTV and the MythControls-plugin.
+ *
+ * History:
+ *
+ * 20060620
+ *   - Renamed member routine 'keyNum()' to 'value()'.
+ *   - Bugfixed problem with 'F1,M,{,<' only assigning 3 keys.
+ *   - Max.length of sequence configurable through #define MYTHKEY_SEQLEN.
+ */
+
+#ifndef _KEYSEQ_H_
+#define _KEYSEQ_H_
+
+#include <qobject.h>
+#include <qkeysequence.h>
+
+/* The #define's below define internal features;
+ ***********************************************/
+
+// Maximum length of KeySequence -- default same as QKeySequence:
+#ifndef MYTHKEY_SEQLEN
+
+    #define     MYTHKEY_SEQLEN                          4
+#else
+
+    #warning    MYTHKEY_SEQLEN is already defined -- skipping assignment.
+#endif
+
+
+/******************** MythKeySequence / MythKey classes **********************/
+class MythKeySequence;
+
+class MythKey : public QObject
+{
+    Q_OBJECT
+
+    public:
+        MythKey( );
+        MythKey( const int );
+        MythKey( const QString );
+
+        /* Assign the key */
+        bool    setKey( const int );
+        bool    setKey( const QString );
+        void    clear( );
+
+        /* Text representation, ie. Ctrl+PgUp, or remoteGUIDE */
+        QString text( );
+        /* Numeric value, only valid if Keys */
+        int     value( );
+        /* More query stuff */
+        bool    isRemote( );
+        bool    isAssigned( );
+
+        operator int();
+
+    private:
+        bool    key_assigned;   /* .. */
+        int     is_button;      /* Key is a button, i.e. not coming from a keyboard */
+
+        int     key_num;        /* Integer representation of key (is 0 for remote buttons) */
+        QString key_str;        /* Text representation of key / button */
+
+    friend class MythKeySequence;
+};
+
+class MythKeySequence : public QObject
+{
+    Q_OBJECT
+
+    public:
+        MythKeySequence( );
+        MythKeySequence( int k1, int k2=0, int k3=0, int k4=0 );
+        MythKeySequence( const QString & );
+
+        /* Assign multiple keys */
+        uint        setKeys( const QString & );
+
+        /* Query stuff */
+        bool        isEmpty( );
+        void        clear( );
+        uint        count( );
+
+        MythKey*    operator[]( int index );
+        bool        operator ==( const MythKeySequence & );
+        operator    QString( );
+
+        MythKey     keys[ MYTHKEY_SEQLEN ];
+
+    private:
+        uint        keys_assigned;
+};
+
+#endif // _KEYSEQ_H_

libs/libmyth/mythkeysequence.cpp

@@ +1 @@
+/*
+ * File:    mythkeysequence.cpp
+ *
+ * Purpose: See mythkeysequence.h
+ */
+#include <mythkeysequence.h>
+
+/*** MythKey ***
+ ***************/
+MythKey::MythKey( )
+{
+    this->clear( );
+}
+
+MythKey::MythKey( const int key )
+{
+    if (!(this->setKey( key )))
+        this->clear( );
+}
+
+MythKey::MythKey( const QString key )
+{
+    if (!(this->setKey( key )))
+        this->clear( );
+}
+
+/* MythKey member routines */
+void MythKey::clear( )
+{
+    this->key_assigned = false;
+    this->key_str = "";
+    this->key_num = 0;
+}
+
+bool MythKey::setKey( const int key )
+{
+    bool retval = false;
+
+    // Passed by key-num are keys, no buttons
+    this->is_button = 0;
+    QKeySequence keyseq( key );
+    if (keyseq.count( ) > 0)
+    {
+        retval = true;
+        this->key_num = keyseq[ 0 ];
+        this->key_str = QString(keyseq);
+    }
+    this->key_assigned = retval;
+    return retval;
+}
+
+bool MythKey::isRemote( )
+{
+    return this->is_button;
+}
+
+bool MythKey::isAssigned( )
+{
+    return this->key_assigned;
+}
+
+bool MythKey::setKey( const QString key )
+{
+    this->key_assigned = false;
+    bool retval = false;
+    if (key.left( 6 ).lower( ) == "remote")
+    {
+        retval = true;
+        this->is_button = 1;
+
+        /* Use this value as-is, no checking at all */
+        this->key_str = key;
+        this->key_num = 0;
+    }
+    else
+    {
+        this->is_button = 0;
+
+        /* Use the QKeySequence to check this key's validity and to set
+         * appropriate fields. We pass ',,' to make the QKeySequence
+         * see the ',' because it'll fail on a *single* ','  */
+        QString keystr = key.stripWhiteSpace( );
+        QKeySequence keyseq( (keystr == ","?",,":keystr) );
+        if (keyseq[ 0 ])
+        {
+            retval = true;
+            this->key_num = keyseq[ 0 ];
+            this->key_str = key.stripWhiteSpace( );
+        }
+//        else printf( "no keyseq\n" );
+    }
+
+    this->key_assigned = retval;
+    return retval;
+}
+
+
+QString MythKey::text( )
+{
+    if (this->key_assigned)
+    {
+        if (this->key_str.length() == 0)
+        {
+            QString key;
+            key.setNum( this->key_num );
+            return key;
+        }
+            else return this->key_str;
+    }
+
+    return "";
+}
+
+int MythKey::value( )
+{
+    if (this->key_assigned)
+        return this->key_num;
+    else
+        return 0;
+}
+
+MythKey::operator int( )
+{
+    return this->value( );
+}
+
+
+/*** MythKeySequence ***
+ ***********************/
+MythKeySequence::MythKeySequence( )
+{
+    this->clear( );
+}
+
+MythKeySequence::MythKeySequence( int k1, int k2, int k3, int k4 )
+{
+    uint k_index = 0;
+
+    if (k1 > 0) this->keys[ ++k_index ].setKey( k1 );
+    if (k2 > 0) this->keys[ ++k_index ].setKey( k2 );
+    if (k3 > 0) this->keys[ ++k_index ].setKey( k3 );
+    if (k4 > 0) this->keys[ ++k_index ].setKey( k4 );
+}
+
+MythKeySequence::MythKeySequence( const QString &keys )
+{
+    this->setKeys( keys );
+}
+
+
+/* MythKeySequence member routines */
+uint MythKeySequence::setKeys( const QString &keys )
+{
+    unsigned int  token_start = 0, k_index = 0, new_start;
+    unsigned int  i, max=keys.length();
+    unsigned char c_last = 0;
+    bool          fc = (keys[ 0 ] == ","), lc = false;
+    int           commas = (fc?1:0);
+    int           do_comma, do_token;
+    //
+    for (i=1; i< max; i++)
+    {
+        do_comma=do_token=0;
+        if (keys[i] == ",")
+        {
+            /* Got a comma -- if this is the first one there
+             * could be a token before it. */
+            if ((!lc) && (i>1)) do_token=1;
+            else token_start = i + 1;
+
+            lc=true;
+            commas++;
+
+            /* If we reached the end here at 2 comma's, we
+             * should register one. */
+            if ((commas == 2) && (i == max - 1))
+            {
+                do_comma = 1;
+                new_start = i;
+            }
+        }
+        else
+        {
+            /* No comma -- still in a token.
+             */
+            if (commas == 0)
+            {
+                if (i==max-1)
+                {
+                    i = max;
+                    do_token=1;
+
+                    new_start = i + 1;
+                }
+            }
+            else if ((commas == 2) && (fc))
+            {
+                do_comma = 1;
+                new_start = i;
+            }
+            else if ((commas == 2) && (i == max - 1))
+            {
+                do_comma = 1;
+                new_start = i;
+            }
+            else if (commas == 3)
+            {
+                if (i < max - 1)
+                {
+                    do_comma = 1;
+                    new_start = i;
+                }
+            }
+
+            fc=lc=false;
+            commas = 0;
+        }
+
+        if (do_token || do_comma)
+        {
+            if (k_index < MYTHKEY_SEQLEN)
+            {
+                if (this->keys[ k_index ].setKey( do_comma?",":keys.mid( token_start, i - token_start ) ))
+                    k_index++;
+            }
+
+            token_start = i + do_token; //new_start;
+        }
+
+    } // for(..
+
+    if (max == 1)
+    {
+        this->keys[ k_index++ ].setKey( keys.stripWhiteSpace() );
+    }
+    else if ( (c_last != ',') && (c_last != keys.mid( token_start )) && (k_index < MYTHKEY_SEQLEN) )
+    {
+        this->keys[ k_index++ ].setKey( keys.mid( token_start ) );
+    }
+
+    this->keys_assigned = k_index;
+    return k_index;
+}
+
+uint MythKeySequence::count( )
+{
+    return this->keys_assigned;
+}
+
+void MythKeySequence::clear( )
+{
+    this->keys_assigned = 0;
+
+    for(int i=0; i<MYTHKEY_SEQLEN; i++)
+        this->keys[ i ].clear( );
+}
+
+
+MythKey* MythKeySequence::operator[]( int index )
+{
+    if( (index >= 0) && (index < MYTHKEY_SEQLEN) )
+        return &(this->keys[ index ]);
+    return 0;
+}
+
+MythKeySequence::operator QString( )
+{
+    QString retval = "";
+    for (uint i=0; i<MYTHKEY_SEQLEN; i++)
+    {
+        if (this->keys[i].key_assigned)
+        {
+            if (retval != "") retval += ", ";
+                retval += this->keys[i].text( );
+        }
+    }
+    return retval;
+}