alt shouldnt stick either

1 files changed, 13 insertions, 7 deletions

diff --git a/inputmethods/multikey/keyboard.cpp b/inputmethods/multikey/keyboard.cpp
index 08318bd..84c0c74 100644
--- a/inputmethods/multikey/keyboard.cpp
+++ b/inputmethods/multikey/keyboard.cpp
@@ -319,115 +319,114 @@ void Keyboard::drawKeyboard(QPainter &p, int row, int col)
     }
 
 }
 
 
 /* Keyboard::mousePressEvent {{{1 */
 void Keyboard::mousePressEvent(QMouseEvent *e)
 {
     int row = (e->y() - (usePicks ? picks->height() : 0)) / keyHeight + 1;
     if (row > 5) row = 5;
 
     // figure out the column
     int col = 0; 
     for (int w = 0; e->x() >= w; col++)
         if (col < keys->numKeys(row)) // it segfaults if it trys to read past numKeys
             w += keys->width(row,col) * defaultKeyWidth;
         else break;
 
     if (col <= 0) return;
 
     col --; // rewind one...
 
     qkeycode = keys->qcode(row, col);
     unicode = keys->uni(row, col);
 
     // might need to repaint if two or more of the same keys.
     // should be faster if just paint one key even though multiple keys exist.
     bool need_repaint = FALSE; 
 
     // circumflex and diaeresis support
     // messy to have this here, but too hard to implement any other method
     if (unicode == 0x2c6) { 
 
         unicode = 0; 
         if (shift || lock) {
 
             // diaeresis
             qkeycode = 0x2001; 
         }
         else {
             
             // circumflex
             qkeycode = 0x2000; 
         }
     }
 
     // Back accent character support
 
-    //if (unicode == 0x60) { // the keys from 2c6 ~ 2cf should be used instead of the ascii one
+    // the keys from 2c6 ~ 2cf should be used instead of the ascii one
     if (unicode == 0x2cb) {
 
         unicode = 0;
         if (shift || lock) {
 
             // circumblex
             qkeycode = 0x2000;
         }
         else {
 
             // back accent
             qkeycode = 0x2002;
         }
     }
 
     // Accent character support
 
-    //if (unicode == 0xb4) {
     if (unicode == 0x2ca) {
 
         unicode = 0;
         if (shift || lock) {
 
             // diaeresis
             qkeycode = 0x2001;
         }
         else {
 
             // accent
             qkeycode = 0x2003;
         }
     }
 
 
     if (unicode == 0) { // either Qt char, or nothing
 
         if (qkeycode == Qt::Key_F1) { // toggle the pickboard
 
             if ( configdlg ) { 
 
                 delete (ConfigDlg *) configdlg; 
                 configdlg = 0;
             }
             else {
                configdlg = new ConfigDlg ();
                connect(configdlg, SIGNAL(setMapToDefault()), 
                        this, SLOT(setMapToDefault()));
                connect(configdlg, SIGNAL(setMapToFile(QString)), 
                        this, SLOT(setMapToFile(QString)));
                connect(configdlg, SIGNAL(pickboardToggled(bool)), 
                        this, SLOT(togglePickboard(bool)));
                connect(configdlg, SIGNAL(repeatToggled(bool)),
                        this, SLOT(toggleRepeat(bool)));
                connect(configdlg, SIGNAL(reloadKeyboard()),
                        this, SLOT(reloadKeyboard()));
                connect(configdlg, SIGNAL(configDlgClosed()),
                        this, SLOT(cleanupConfigDlg()));
                configdlg->showMaximized();
                configdlg->show();
                configdlg->raise();
             }
 
         } else if (qkeycode == Qt::Key_Control) {
             need_repaint = TRUE;
 
             if (ctrl) {
@@ -480,98 +479,98 @@ void Keyboard::mousePressEvent(QMouseEvent *e)
              * same thing with meta
 
             if (meta) { *meta = 0; meta = 0; }
             if (circumflex) { *circumflex = 0; circumflex = 0; }
             if (diaeresis) { *diaeresis = 0; diaeresis = 0; }
 
              */
 
         } else if (qkeycode == Qt::Key_CapsLock) {
             need_repaint = TRUE;
 
             if (lock) {
                 *lock = 0;
                 lock = 0;
             }
             else {
                 lock = keys->pressedPtr(row, col);;
                 *lock = true;;
                 if (shift) {
                     *shift = 0;
                     shift = 0;
                 }
             }
 
             /*
             if (meta) { *meta = 0; meta = 0; }
             if (circumflex) { *circumflex = 0; circumflex = 0; }
             if (diaeresis) { *diaeresis = 0; diaeresis = 0; }
             */
 
         } else if (qkeycode == Qt::Key_Meta) {
             need_repaint = TRUE;
 
             if (meta) {
                 *meta = 0;
                 meta = 0;
 
             } else {
 
                 meta = keys->pressedPtr(row, col);
                 *meta = true;
             }
 
             // reset all the other keys
             if (shift) { *shift = 0; shift = 0; } 
             if (lock) { *lock = 0; lock = 0; }
             if (circumflex) { *circumflex = 0; circumflex = 0; }
             if (diaeresis) { *diaeresis = 0; diaeresis = 0; }
-	       if (baccent) { *baccent = 0; baccent = 0; }
-	       if (accent) { *accent = 0; accent = 0; }
+	        if (baccent) { *baccent = 0; baccent = 0; }
+	        if (accent) { *accent = 0; accent = 0; }
 
             // dont need to emit this key... acts same as alt
             qkeycode = 0;
 
         // circumflex
         } else if (qkeycode == 0x2000) {
             need_repaint = TRUE;
 
             if (circumflex) {
 
                 *circumflex = 0;
                 circumflex = 0;
 
             } else {
 
                 circumflex = keys->pressedPtr(row, col);
                 *circumflex = true;
             }
 
             /* no need to turn off shift or lock if circumflex
              * keys are pressed
              
             if (shift) { *shift = 0; shift = 0; }
             if (lock) { *lock = 0; lock = 0; }
 
              */
             
             // have to reset all the other keys
             if (meta) { *meta = 0; meta = 0; }
             if (diaeresis) { 
                 
                 // *diaeresis and *circumflex point to the same thing
                 // when diaeresis is enabled and you hit the circumflex
                 // since they are the same key, it should turn off the
                 // key
                 
                 *diaeresis = 0; 
                 diaeresis = 0; 
                 circumflex = 0;
             }
 
             qkeycode = 0;
 
         // diaeresis
         } else if (qkeycode == 0x2001) {
             need_repaint = TRUE;
 
             if (diaeresis) {
@@ -580,135 +579,135 @@ void Keyboard::mousePressEvent(QMouseEvent *e)
                 diaeresis = 0;
 
             } else {
 
                 diaeresis = keys->pressedPtr(row, col);
                 *diaeresis = true;
             }
 
              
             if (shift) { *shift = 0; shift = 0; }
 
             /*
              *
             if (lock) { *lock = 0; lock = 0; }
              *
              */
 
             if (meta) { *meta = 0; meta = 0; }
             if (circumflex) { 
 
                 // *circumflex = 0; 
                 //
                 // same thing the diaeresis pointer points too
                 
                 circumflex = 0; 
             }
 
 
             qkeycode = 0;
 
         // Back accent
         } else if (qkeycode == 0x2002) {
             need_repaint = TRUE;
 
             if (baccent) {
 
                 *baccent = 0;
                 baccent = 0;
 
             } else {
 
                 baccent = keys->pressedPtr(row, col);
                 *baccent = true;
             }
 
 
             if (shift) { *shift = 0; shift = 0; }
             if (meta) { *meta = 0; meta = 0; }
-		  if (accent) { *accent = 0; accent = 0; }
+		    if (accent) { *accent = 0; accent = 0; }
 
             qkeycode = 0;
         
 	   // Accent
         } else if (qkeycode == 0x2003) {
             need_repaint = TRUE;
 
             if (accent) {
 
                 *accent = 0;
                 accent = 0;
 
             } else {
 
                 accent = keys->pressedPtr(row, col);
                 *accent = true;
             }
 
 
             if (shift) { *shift = 0; shift = 0; }
             if (meta) { *meta = 0; meta = 0; }
-		  if (baccent) { *baccent = 0; }
+		    if (baccent) { *baccent = 0; }
 
             qkeycode = 0;
         }
 
     }
     else { // normal char
         if ((shift || lock) && keys->shift(unicode)) {
 
             // make diaeresis/circumflex -> shift input shifted
             // diaeresis/circumflex chars
             
             if (circumflex && keys->circumflex(keys->shift(unicode)))
                 unicode = keys->circumflex(keys->shift(unicode));
             else if (diaeresis && keys->diaeresis(keys->shift(unicode)))
                 unicode = keys->diaeresis(keys->shift(unicode));
-	    else if (baccent && keys->baccent(keys->shift(unicode)))
+	        else if (baccent && keys->baccent(keys->shift(unicode)))
                 unicode = keys->baccent(keys->shift(unicode));
             else if (accent && keys->accent(keys->shift(unicode)))
                 unicode = keys->accent(keys->shift(unicode));
             else if (meta && keys->meta(keys->shift(unicode)))
                 unicode = keys->meta(keys->shift(unicode));
             else
                 unicode = keys->shift(unicode);
         }
         else if (meta && keys->meta(unicode)) {
             unicode = keys->meta(unicode);
         }
         else if (circumflex && keys->circumflex(unicode)) {
             unicode = keys->circumflex(unicode);
         }
         else if (diaeresis && keys->diaeresis(unicode)) {
 
             unicode = keys->diaeresis(unicode);
         }
 	   else if (baccent && keys->baccent(unicode)) {
             unicode = keys->baccent(unicode);
         }
         else if (accent && keys->accent(unicode)) {
             unicode = keys->accent(unicode);
         }
     }
 
     // korean parsing
     if (keys->lang == "ko") {
 
         unicode = parseKoreanInput(unicode);
     }
 
     modifiers = (ctrl ? Qt::ControlButton : 0) | (alt ? Qt::AltButton : 0);
 
     if ('A' <= unicode && unicode <= 'z' && modifiers) {
 
         qkeycode = QChar(unicode).upper();
         unicode = qkeycode - '@';
     }
 
     QWSServer::sendKeyEvent(unicode, qkeycode, modifiers, true, false); 
 
     // pickboard stuff
     if (usePicks) {
 
         KeyboardConfig *dc = picks->dc;
     
         if (dc) {
@@ -730,96 +729,103 @@ void Keyboard::mousePressEvent(QMouseEvent *e)
     // painting
     pressed = TRUE;
 
     pressedKeyRow = row;
     pressedKeyCol = col;
 
     if (need_repaint) repaint(FALSE);
     else { // just paint the one key pressed
 
 
 
         QPainter p(this);
         drawKeyboard(p, row, col);
 
     }
 
     if (useRepeat) repeatTimer->start( 800 );
     //pressTid = startTimer(80);
 
 }
 
 
 /* Keyboard::mouseReleaseEvent {{{1 */
 void Keyboard::mouseReleaseEvent(QMouseEvent*)
 {
     pressed = FALSE;
     //if ( pressTid == 0 )
 #if defined(Q_WS_QWS) || defined(_WS_QWS_)
     if ( unicode != -1 ) {
 	emit key( unicode, qkeycode, modifiers, false, false );
 	repeatTimer->stop();
     }
 #endif
     if (shift && unicode != 0) {
 
 
         *shift = 0; // unpress shift key
         shift = 0;  // reset the shift pointer
         repaint(FALSE);
 
     } 
     if (ctrl && unicode != 0) {
 
         *ctrl = 0;
         ctrl = 0;
         repaint(FALSE);
 
     }
+    if (alt && alt != 0) {
+
+        *alt = 0;
+        alt = 0;
+        repaint(FALSE);
+
+    }
     
     /*
      * do not make the meta key release after being pressed
      *
 
     else if (meta && unicode != 0) {
 
         *meta = 0;
         meta = 0;
         repaint(FALSE);
     }
 
      */
 
     else clearHighlight();
 }
 
 /* Keyboard::timerEvent {{{1 */
 
 /* dont know what this does, but i think it is here so that if your screen
  * sticks (like on an ipaq) then it will stop repeating if you click another
  * key... but who knows what anything does in this thing anyway?
 
  void Keyboard::timerEvent(QTimerEvent* e)
 {
     if ( e->timerId() == pressTid ) {
 	killTimer(pressTid);
 	pressTid = 0;
 	if ( !pressed )
         cout << "calling clearHighlight from timerEvent\n";
 	    //clearHighlight();
     }
 }
 */
 
 void Keyboard::repeat()
 {
 
   repeatTimer->start( 200 );
   emit key( unicode, qkeycode, modifiers, true, true );
 }
 
 void Keyboard::clearHighlight()
 {
     if ( pressedKeyRow >= 0 && pressedKeyCol >= 0) {
 	    int tmpRow = pressedKeyRow;
         int tmpCol = pressedKeyCol;