Changeset 859

Timestamp:

06/04/07 05:31:03 (2 years ago)

Author:

ok_computer

Message:

Adding a work-around for corrupt key event text when the SDL widget is active. This appears to be related to some sort of timing issue with the Qt event loop. Lower-case keys are transposed to upper-case. This is most marked when playback is active.

Note that the work-around is not active by default.

Location:

trunk/jahwidgets/src/qt3

Files:

• python/application.cpp (modified) (1 diff)
• wrapper/application.cpp (modified) (3 diffs)
• wrapper/application.hpp (modified) (1 diff)

trunk/jahwidgets/src/qt3/python/application.cpp

@@ -68 +68 @@
         .def( "processEventsCallback", &jw::_application::processEventsCallback )
         .def( "hasPendingEventsCallback", &jw::_application::hasPendingEventsCallback )
+        .def( "setFixupKeyEvents", &jw::_application::setFixupKeyEvents )
         ;
 }

trunk/jahwidgets/src/qt3/wrapper/application.cpp

@@ -52 +52 @@
 };
 
+// We subclass QApplication only to workaround a bug on windows with key events.
+// It appears that in-corporating playback into the app's event loop is causing some timing issues with Qt keyboard event handling (note that the problems could also be due to SDL interferring with the event, but this doesn't appear to be the case). The symptons are thus:
+// * When a clip is not playing most key event text is correct, although occasionaly a lowercase char becomes uppercase
+// * When playing back most chars are transposed to upper case.
+// Only the key event's text is incorrect; the key code and modifier appear to always be ok.
+class Application : public QApplication
+{
+public:
+  Application ( int & argc, char ** argv )
+          : QApplication( argc, argv ),
+                fixupKeyEvents( false )
+  {}
+
+// We only need to check the key events on win32
+#if defined( Q_OS_WIN32 )
+  virtual bool notify( QObject* receiver, QEvent* event )
+  {
+        // Check key events, and ensure that their text is correct
+        if ( fixupKeyEvents 
+                 && (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) )
+        {
+          QKeyEvent* ke = dynamic_cast<QKeyEvent*>(event);
+          if ( (ke->state() & Qt::ShiftButton) != Qt::ShiftButton 
+                   // Qt always stores letters as uppercase
+                   && ke->key() >= 'A' && ke->key() <= 'Z'
+                   && ke->text().length() == 1 ) 
+                {
+                  //qDebug( "Correcting QKeyEvent: %s", ke->text().latin1() );
+                  
+                  // Create a new event with the correct text
+                  QKeyEvent correctEvent( ke->type(), 
+                                                                  ke->key(),
+                                                                  ke->ascii(),
+                                                                  ke->state(),
+                                                                  // Note that this is NOT unicode safe...
+                                                                  QChar( char(ke->key() + 32) ),
+                                                                  ke->isAutoRepeat(),
+                                                                  ke->count() );
+                  return QApplication::notify( receiver, &correctEvent );
+                }
+        }
+
+        return QApplication::notify( receiver, event );
+  }
+#endif
+
+        // Flag to switch on/off the keyevent fixup
+        bool fixupKeyEvents;
+};
+
 /// trivial opaque wrapper for QApplication
 application::application()
@@ -59 +109 @@
         
         static EventLoop el;
-        static QApplication app( dummy_argc, dummy_argv );
+        static Application app( dummy_argc, dummy_argv );
         el.app_ = this;
 
@@ -180 +230 @@
 }
 
+void application::setFixupKeyEvents( bool fix )
+{
+        dynamic_cast<Application*>(qApp)->fixupKeyEvents = fix;
+}
+
 } }

trunk/jahwidgets/src/qt3/wrapper/application.hpp

@@ -43 +43 @@
     virtual bool hasPendingEventsCallback();
 
+        /// Indicate that we want the app to work-around corrupt key-events.
+        /// The default is not to apply this work-around
+        void setFixupKeyEvents( bool );
+
 public slots:
     /// Called just before the app quits. Subclasses can override to receive notification