Ticket #4759: 2 - gui_check_for_modifiers_in_keypad_handling.patch

File 2 - gui_check_for_modifiers_in_keypad_handling.patch, 13.7 KB (added by Templier, 15 years ago)

2 - Check of modifiers in widgets (fixes regression in r46808)

  • gui/console.cpp

     
    302302                        slideUpAndClose();
    303303                break;
    304304                }
     305
    305306        case Common::KEYCODE_ESCAPE:
    306307                slideUpAndClose();
    307308                break;
     309
    308310        case Common::KEYCODE_BACKSPACE:
    309311                if (_caretVisible)
    310312                        drawCaret(true);
    … …  
    316318                scrollToCurrent();
    317319                drawLine(pos2line(_currentPos));
    318320                break;
    319         case Common::KEYCODE_TAB:
    320         {
     321
     322        case Common::KEYCODE_TAB: {
    321323                if (_completionCallbackProc) {
    322324                        int len = _currentPos - _promptStartPos;
    323325                        assert(len >= 0);
    … …  
    339341                        delete[] str;
    340342                }
    341343                break;
    342         }
     344                }
     345
     346        // Keypad & special keys
     347        //   - if num lock is set, we always go to the default case
     348        //   - if num lock is not set, we either fall down to the special key case
     349        //     or ignore the key press in case of 0 (INSERT) or 5
     350
     351        case Common::KEYCODE_KP0:
     352        case Common::KEYCODE_KP5:
     353                if (state.flags & Common::KBD_NUM)
     354                        defaultKeyDownHandler(state);
     355                break;
     356
     357        case Common::KEYCODE_KP_PERIOD:
     358                if (state.flags & Common::KBD_NUM) {
     359                        defaultKeyDownHandler(state);
     360                        break;
     361                }
    343362        case Common::KEYCODE_DELETE:
    344363                if (_currentPos < _promptEndPos) {
    345364                        killChar();
    346365                        drawLine(pos2line(_currentPos));
    347366                }
    348367                break;
    349         case Common::KEYCODE_PAGEUP:
    350                 if (state.flags == Common::KBD_SHIFT) {
    351                         _scrollLine -= _linesPerPage - 1;
    352                         if (_scrollLine < _firstLineInBuffer + _linesPerPage - 1)
    353                                 _scrollLine = _firstLineInBuffer + _linesPerPage - 1;
     368
     369        case Common::KEYCODE_KP1:
     370                if (state.flags & Common::KBD_NUM) {
     371                        defaultKeyDownHandler(state);
     372                        break;
     373                }
     374        case Common::KEYCODE_END:
     375                if (state.hasFlags(Common::KBD_SHIFT)) {
     376                        _scrollLine = _promptEndPos / kCharsPerLine;
     377                        if (_scrollLine < _linesPerPage - 1)
     378                                _scrollLine = _linesPerPage - 1;
    354379                        updateScrollBuffer();
    355                         draw();
     380                } else {
     381                        _currentPos = _promptEndPos;
    356382                }
     383                draw();
    357384                break;
     385
     386        case Common::KEYCODE_KP2:
     387                if (state.flags & Common::KBD_NUM) {
     388                        defaultKeyDownHandler(state);
     389                        break;
     390                }
     391        case Common::KEYCODE_DOWN:
     392                historyScroll(-1);
     393                break;
     394
     395        case Common::KEYCODE_KP3:
     396                if (state.flags & Common::KBD_NUM) {
     397                        defaultKeyDownHandler(state);
     398                        break;
     399                }
    358400        case Common::KEYCODE_PAGEDOWN:
    359                 if (state.flags == Common::KBD_SHIFT) {
     401                if (state.hasFlags(Common::KBD_SHIFT)) {
    360402                        _scrollLine += _linesPerPage - 1;
    361403                        if (_scrollLine > _promptEndPos / kCharsPerLine) {
    362404                                _scrollLine = _promptEndPos / kCharsPerLine;
    … …  
    367409                        draw();
    368410                }
    369411                break;
     412
     413        case Common::KEYCODE_KP4:
     414                if (state.flags & Common::KBD_NUM) {
     415                        defaultKeyDownHandler(state);
     416                        break;
     417                }
     418        case Common::KEYCODE_LEFT:
     419                if (_currentPos > _promptStartPos)
     420                        _currentPos--;
     421                drawLine(pos2line(_currentPos));
     422                break;
     423
     424        case Common::KEYCODE_KP6:
     425                if (state.flags & Common::KBD_NUM) {
     426                        defaultKeyDownHandler(state);
     427                        break;
     428                }
     429        case Common::KEYCODE_RIGHT:
     430                if (_currentPos < _promptEndPos)
     431                        _currentPos++;
     432                drawLine(pos2line(_currentPos));
     433                break;
     434
     435        case Common::KEYCODE_KP7:
     436                if (state.flags & Common::KBD_NUM) {
     437                        defaultKeyDownHandler(state);
     438                        break;
     439                }
    370440        case Common::KEYCODE_HOME:
    371                 if (state.flags == Common::KBD_SHIFT) {
     441                if (state.hasFlags(Common::KBD_SHIFT)) {
    372442                        _scrollLine = _firstLineInBuffer + _linesPerPage - 1;
    373443                        updateScrollBuffer();
    374444                } else {
    … …  
    376446                }
    377447                draw();
    378448                break;
    379         case Common::KEYCODE_END:
    380                 if (state.flags == Common::KBD_SHIFT) {
    381                         _scrollLine = _promptEndPos / kCharsPerLine;
    382                         if (_scrollLine < _linesPerPage - 1)
    383                                 _scrollLine = _linesPerPage - 1;
    384                         updateScrollBuffer();
    385                 } else {
    386                         _currentPos = _promptEndPos;
     449
     450        case Common::KEYCODE_KP8:
     451                if (state.flags & Common::KBD_NUM) {
     452                        defaultKeyDownHandler(state);
     453                        break;
    387454                }
    388                 draw();
    389                 break;
    390455        case Common::KEYCODE_UP:
    391456                historyScroll(+1);
    392457                break;
    393         case Common::KEYCODE_DOWN:
    394                 historyScroll(-1);
     458
     459        case Common::KEYCODE_KP9:
     460                if (state.flags & Common::KBD_NUM) {
     461                        defaultKeyDownHandler(state);
     462                        break;
     463                }
     464        case Common::KEYCODE_PAGEUP:
     465                if (state.hasFlags(Common::KBD_SHIFT)) {
     466                        _scrollLine -= _linesPerPage - 1;
     467                        if (_scrollLine < _firstLineInBuffer + _linesPerPage - 1)
     468                                _scrollLine = _firstLineInBuffer + _linesPerPage - 1;
     469                        updateScrollBuffer();
     470                        draw();
     471                }
    395472                break;
    396         case Common::KEYCODE_RIGHT:
    397                 if (_currentPos < _promptEndPos)
    398                         _currentPos++;
    399                 drawLine(pos2line(_currentPos));
    400                 break;
    401         case Common::KEYCODE_LEFT:
    402                 if (_currentPos > _promptStartPos)
    403                         _currentPos--;
    404                 drawLine(pos2line(_currentPos));
    405                 break;
     473
    406474        default:
    407                 if (state.ascii == '~' || state.ascii == '#') {
    408                         slideUpAndClose();
    409                 } else if (state.flags == Common::KBD_CTRL) {
    410                         specialKeys(state.keycode);
    411                 } else if ((state.ascii >= 32 && state.ascii <= 127) || (state.ascii >= 160 && state.ascii <= 255)) {
    412                         for (i = _promptEndPos - 1; i >= _currentPos; i--)
    413                                 buffer(i + 1) = buffer(i);
    414                         _promptEndPos++;
    415                         putchar((byte)state.ascii);
    416                         scrollToCurrent();
    417                 }
     475                defaultKeyDownHandler(state);
    418476        }
    419477}
    420478
     479void ConsoleDialog::defaultKeyDownHandler(Common::KeyState &state) {
     480        if (state.ascii == '~' || state.ascii == '#') {
     481                slideUpAndClose();
     482        } else if (state.hasFlags(Common::KBD_CTRL)) {
     483                specialKeys(state.keycode);
     484        } else if ((state.ascii >= 32 && state.ascii <= 127) || (state.ascii >= 160 && state.ascii <= 255)) {
     485                for (int i = _promptEndPos - 1; i >= _currentPos; i--)
     486                        buffer(i + 1) = buffer(i);
     487                _promptEndPos++;
     488                putchar((byte)state.ascii);
     489                scrollToCurrent();
     490        }
     491}
     492
    421493void ConsoleDialog::insertIntoPrompt(const char* str) {
    422494        unsigned int l = strlen(str);
    423495        for (int i = _promptEndPos - 1; i >= _currentPos; i--)

  • gui/console.h

     
    178178        void updateScrollBuffer();
    179179        void scrollToCurrent();
    180180
     181        void defaultKeyDownHandler(Common::KeyState &state);
     182
    181183        // Line editing
    182184        void specialKeys(int keycode);
    183185        void nextLine();

  • gui/editable.cpp

     
    100100                endEditMode();
    101101                dirty = true;
    102102                break;
     103
    103104        case Common::KEYCODE_ESCAPE:
    104105                abortEditMode();
    105106                dirty = true;
    106107                break;
     108
    107109        case Common::KEYCODE_BACKSPACE:
    108110                if (_caretPos > 0) {
    109111                        _caretPos--;
    … …  
    114116                }
    115117                forcecaret = true;
    116118                break;
     119
     120        // Keypad & special keys
     121        //   - if num lock is set, we always go to the default case
     122        //   - if num lock is not set, we either fall down to the special key case
     123        //     or ignore the key press in case of 0 (INSERT), 2 (DOWN), 3 (PGDWN)
     124        //     5, 8 (UP) and 9 (PGUP)
     125
     126        case Common::KEYCODE_KP0:
     127        case Common::KEYCODE_KP2:
     128        case Common::KEYCODE_KP3:
     129        case Common::KEYCODE_KP5:
     130        case Common::KEYCODE_KP8:
     131        case Common::KEYCODE_KP9:
     132                if (state.flags & Common::KBD_NUM)
     133                        defaultKeyDownHandler(state, dirty, forcecaret, handled);
     134                break;
     135
     136        case Common::KEYCODE_KP_PERIOD:
     137                if (state.flags & Common::KBD_NUM) {
     138                        defaultKeyDownHandler(state, dirty, forcecaret, handled);
     139                        break;
     140                }
    117141        case Common::KEYCODE_DELETE:
    118142                if (_caretPos < (int)_editString.size()) {
    119143                        _editString.deleteChar(_caretPos);
    … …  
    123147                }
    124148                forcecaret = true;
    125149                break;
     150
     151        case Common::KEYCODE_KP1:
     152                if (state.flags & Common::KBD_NUM) {
     153                        defaultKeyDownHandler(state, dirty, forcecaret, handled);
     154                        break;
     155                }
     156        case Common::KEYCODE_END:
     157                dirty = setCaretPos(_editString.size());
     158                forcecaret = true;
     159                break;
     160
     161        case Common::KEYCODE_KP4:
     162                if (state.flags & Common::KBD_NUM) {
     163                        defaultKeyDownHandler(state, dirty, forcecaret, handled);
     164                        break;
     165                }
    126166        case Common::KEYCODE_LEFT:
    127167                if (_caretPos > 0) {
    128168                        dirty = setCaretPos(_caretPos - 1);
    … …  
    130170                forcecaret = true;
    131171                dirty = true;
    132172                break;
     173
     174        case Common::KEYCODE_KP6:
     175                if (state.flags & Common::KBD_NUM) {
     176                        defaultKeyDownHandler(state, dirty, forcecaret, handled);
     177                        break;
     178                }
    133179        case Common::KEYCODE_RIGHT:
    134180                if (_caretPos < (int)_editString.size()) {
    135181                        dirty = setCaretPos(_caretPos + 1);
    … …  
    137183                forcecaret = true;
    138184                dirty = true;
    139185                break;
     186
     187        case Common::KEYCODE_KP7:
     188                if (state.flags & Common::KBD_NUM) {
     189                        defaultKeyDownHandler(state, dirty, forcecaret, handled);
     190                        break;
     191                }
    140192        case Common::KEYCODE_HOME:
    141193                dirty = setCaretPos(0);
    142194                forcecaret = true;
    143195                break;
    144         case Common::KEYCODE_END:
    145                 dirty = setCaretPos(_editString.size());
    146                 forcecaret = true;
    147                 break;
     196
    148197        default:
    149                 if (tryInsertChar((byte)state.ascii, _caretPos)) {
    150                         _caretPos++;
    151                         dirty = true;
    152                         forcecaret = true;
    153 
    154                         sendCommand(_cmd, 0);
    155                 } else {
    156                         handled = false;
    157                 }
     198                defaultKeyDownHandler(state, dirty, forcecaret, handled);
    158199        }
    159200
    160201        if (dirty)
    … …  
    166207        return handled;
    167208}
    168209
     210void EditableWidget::defaultKeyDownHandler(Common::KeyState &state, bool &dirty, bool &forcecaret, bool &handled) {
     211        if (tryInsertChar((byte)state.ascii, _caretPos)) {
     212                _caretPos++;
     213                dirty = true;
     214                forcecaret = true;
     215
     216                sendCommand(_cmd, 0);
     217        } else {
     218                handled = false;
     219        }
     220}
     221
    169222int EditableWidget::getCaretOffset() const {
    170223        int caretpos = 0;
    171224        for (int i = 0; i < _caretPos; i++)

  • gui/editable.h

     
    8181        bool adjustOffset();
    8282        void makeCaretVisible();
    8383
     84        void defaultKeyDownHandler(Common::KeyState &state, bool &dirty, bool &forcecaret, bool &handled);
     85
    8486        void setFontStyle(ThemeEngine::FontStyle font) { _font = font; }
    8587
    8688        virtual bool tryInsertChar(byte c, int pos);

  • gui/ListWidget.cpp

     
    286286        bool dirty = false;
    287287        int oldSelectedItem = _selectedItem;
    288288
    289         if (!_editMode && isprint((unsigned char)state.ascii)) {
     289        if (!_editMode && state.keycode <= Common::KEYCODE_z && isprint((unsigned char)state.ascii)) {
    290290                // Quick selection mode: Go to first list item starting with this key
    291291                // (or a substring accumulated from the last couple key presses).
    292292                // Only works in a useful fashion if the list entries are sorted.
    … …  
    339339                                        sendCommand(kListItemActivatedCmd, _selectedItem);
    340340                        }
    341341                        break;
     342
     343                // Keypad & special keys
     344                //   - if num lock is set, we do not handle the keypress
     345                //   - if num lock is not set, we either fall down to the special key case
     346                //     or ignore the key press for 0, 4, 5 and 6
     347
     348                case Common::KEYCODE_KP_PERIOD:
     349                        if (state.flags & Common::KBD_NUM) {
     350                                handled = false;
     351                                break;
     352                        }
    342353                case Common::KEYCODE_BACKSPACE:
    343                 case Common::KEYCODE_KP_PERIOD:
    344354                case Common::KEYCODE_DELETE:
    345355                        if (_selectedItem >= 0) {
    346356                                if (_editable) {
    … …  
    350360                                }
    351361                        }
    352362                        break;
    353                 case Common::KEYCODE_UP:
    354                         if (_selectedItem > 0)
    355                                 _selectedItem--;
     363
     364                case Common::KEYCODE_KP1:
     365                        if (state.flags & Common::KBD_NUM) {
     366                                handled = false;
     367                                break;
     368                        }
     369                case Common::KEYCODE_END:
     370                        _selectedItem = _list.size() - 1;
    356371                        break;
     372
     373
     374                case Common::KEYCODE_KP2:
     375                        if (state.flags & Common::KBD_NUM) {
     376                                handled = false;
     377                                break;
     378                        }
    357379                case Common::KEYCODE_DOWN:
    358380                        if (_selectedItem < (int)_list.size() - 1)
    359381                                _selectedItem++;
    360382                        break;
    361                 case Common::KEYCODE_PAGEUP:
    362                         _selectedItem -= _entriesPerPage - 1;
    363                         if (_selectedItem < 0)
    364                                 _selectedItem = 0;
    365                         break;
     383
     384                case Common::KEYCODE_KP3:
     385                        if (state.flags & Common::KBD_NUM) {
     386                                handled = false;
     387                                break;
     388                        }
    366389                case Common::KEYCODE_PAGEDOWN:
    367390                        _selectedItem += _entriesPerPage - 1;
    368391                        if (_selectedItem >= (int)_list.size() )
    369392                                _selectedItem = _list.size() - 1;
    370393                        break;
     394
     395                case Common::KEYCODE_KP7:
     396                        if (state.flags & Common::KBD_NUM) {
     397                                handled = false;
     398                                break;
     399                        }
    371400                case Common::KEYCODE_HOME:
    372401                        _selectedItem = 0;
    373402                        break;
    374                 case Common::KEYCODE_END:
    375                         _selectedItem = _list.size() - 1;
     403
     404                case Common::KEYCODE_KP8:
     405                        if (state.flags & Common::KBD_NUM) {
     406                                handled = false;
     407                                break;
     408                        }
     409                case Common::KEYCODE_UP:
     410                        if (_selectedItem > 0)
     411                                _selectedItem--;
    376412                        break;
     413
     414                case Common::KEYCODE_KP9:
     415                        if (state.flags & Common::KBD_NUM) {
     416                                handled = false;
     417                                break;
     418                        }
     419                case Common::KEYCODE_PAGEUP:
     420                        _selectedItem -= _entriesPerPage - 1;
     421                        if (_selectedItem < 0)
     422                                _selectedItem = 0;
     423                        break;
     424
    377425                default:
    378426                        handled = false;
    379427                }

  • gui/PopUpWidget.cpp

     
    222222                return;
    223223
    224224        switch (state.keycode) {
     225
    225226        case Common::KEYCODE_RETURN:
    226227        case Common::KEYCODE_KP_ENTER:
    227228                setResult(_selection);
    228229                close();
    229230                break;
    230         case Common::KEYCODE_UP:
    231                 moveUp();
     231
     232        // Keypad & special keys
     233        //   - if num lock is set, we ignore the keypress
     234        //   - if num lock is not set, we fall down to the special key case
     235
     236        case Common::KEYCODE_KP1:
     237                if (state.flags & Common::KBD_NUM)
     238                        break;
     239        case Common::KEYCODE_END:
     240                setSelection(_popUpBoss->_entries.size()-1);
    232241                break;
     242
     243        case Common::KEYCODE_KP2:
     244                if (state.flags & Common::KBD_NUM)
     245                        break;
    233246        case Common::KEYCODE_DOWN:
    234247                moveDown();
    235248                break;
     249
     250        case Common::KEYCODE_KP7:
     251                if (state.flags & Common::KBD_NUM)
     252                        break;
    236253        case Common::KEYCODE_HOME:
    237254                setSelection(0);
    238255                break;
    239         case Common::KEYCODE_END:
    240                 setSelection(_popUpBoss->_entries.size()-1);
     256
     257        case Common::KEYCODE_KP8:
     258                if (state.flags & Common::KBD_NUM)
     259                        break;
     260        case Common::KEYCODE_UP:
     261                moveUp();
    241262                break;
     263
    242264        default:
    243265                break;
    244266        }