Ticket #4759: complete patch.patch

File complete patch.patch, 46.7 KB (added by bluddy, 15 years ago)

All the patches together

  • 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        }

  • 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/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/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/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);

  • engines/m4/events.cpp

     
    7373                        if ((_event.kbd.keycode == Common::KEYCODE_LCTRL) || (_event.kbd.keycode == Common::KEYCODE_RCTRL))
    7474                                _ctrlFlag = true;
    7575
    76                         else if (_event.kbd.flags == Common::KBD_CTRL) {
     76                        else if (_event.kbd.hasFlags(Common::KBD_CTRL)) {
    7777                                if ((_event.kbd.keycode == Common::KEYCODE_d) && _ctrlFlag) {
    7878                                        _console->attach();
    7979                                        _console->onFrame();

  • engines/m4/mads_views.cpp

     
    362362
    363363        // Capitalise the letter if necessary
    364364        if (_cheatKeyCtr < CHEAT_SEQUENCE_MAX) {
    365                 if ((flags == Common::KBD_CTRL) && (kc == CHEAT_SEQUENCE[_cheatKeyCtr])) {
     365                if ((flags & Common::KBD_CTRL) && (kc == CHEAT_SEQUENCE[_cheatKeyCtr])) {
    366366                        ++_cheatKeyCtr;
    367367                        if (_cheatKeyCtr == CHEAT_SEQUENCE_MAX)
    368368                                Dialog::display(_vm, 22, cheatingEnabledDesc);

  • engines/tucker/tucker.cpp

     
    607607                case Common::EVENT_KEYDOWN:
    608608                        switch (ev.kbd.keycode) {
    609609                        case Common::KEYCODE_f:
    610                                 if (ev.kbd.flags == Common::KBD_CTRL) {
     610                                if (ev.kbd.hasFlags(Common::KBD_CTRL)) {
    611611                                        _fastMode = !_fastMode;
    612612                                }
    613613                                break;

  • engines/agi/agi.cpp

     
    121121                        _mouse.y = event.mouse.y;
    122122                        break;
    123123                case Common::EVENT_KEYDOWN:
    124                         if (event.kbd.flags == Common::KBD_CTRL && event.kbd.keycode == Common::KEYCODE_d) {
     124                        if (event.kbd.hasFlags(Common::KBD_CTRL) && event.kbd.keycode == Common::KEYCODE_d) {
    125125                                _console->attach();
    126126                                break;
    127127                        }

  • engines/agi/preagi_troll.cpp

     
    104104                                case Common::KEYCODE_KP_ENTER:
    105105                                        return true;
    106106                                case Common::KEYCODE_s:
    107                                         if (event.kbd.flags == Common::KBD_CTRL) {
     107                                        if (event.kbd.hasFlags(Common::KBD_CTRL)) {
    108108                                                if (_soundOn) {
    109109                                                        playTune(2, 1);
    110110                                                        _soundOn = !_soundOn;

  • engines/kyra/gui.cpp

     
    421421        while (_vm->_eventMan->pollEvent(event) && running) {
    422422                switch (event.type) {
    423423                case Common::EVENT_KEYDOWN:
    424                         if (event.kbd.keycode == Common::KEYCODE_q && event.kbd.flags == Common::KBD_CTRL)
     424                        if (event.kbd.keycode == Common::KEYCODE_q && event.kbd.hasFlags(Common::KBD_CTRL))
    425425                                _vm->quitGame();
    426426                        else
    427427                                _keyPressed = event.kbd;

  • engines/kyra/kyra_v1.cpp

     
    262262                switch (event.type) {
    263263                case Common::EVENT_KEYDOWN:
    264264                        if (event.kbd.keycode >= Common::KEYCODE_1 && event.kbd.keycode <= Common::KEYCODE_9 &&
    265                                         (event.kbd.flags == Common::KBD_CTRL || event.kbd.flags == Common::KBD_ALT) && mainLoop) {
     265                                        (event.kbd.hasFlags(Common::KBD_CTRL) || event.kbd.hasFlags(Common::KBD_ALT)) && mainLoop) {
    266266                                int saveLoadSlot = 9 - (event.kbd.keycode - Common::KEYCODE_0) + 990;
    267267
    268                                 if (event.kbd.flags == Common::KBD_CTRL) {
     268                                if (event.kbd.hasFlags(Common::KBD_CTRL)) {
    269269                                        loadGameStateCheck(saveLoadSlot);
    270270                                        _eventList.clear();
    271271                                        breakLoop = true;
    … …  
    274274                                        sprintf(savegameName, "Quicksave %d", event.kbd.keycode - Common::KEYCODE_0);
    275275                                        saveGameState(saveLoadSlot, savegameName, 0);
    276276                                }
    277                         } else if (event.kbd.flags == Common::KBD_CTRL) {
     277                        } else if (event.kbd.hasFlags(Common::KBD_CTRL)) {
    278278                                if (event.kbd.keycode == Common::KEYCODE_d) {
    279279                                        if (_debugger)
    280280                                                _debugger->attach();
    … …  
    384384                                event.kbd.keycode == Common::KEYCODE_UP || event.kbd.keycode == Common::KEYCODE_RIGHT ||
    385385                                event.kbd.keycode == Common::KEYCODE_DOWN || event.kbd.keycode == Common::KEYCODE_LEFT)
    386386                                        _eventList.push_back(Event(event, true));
    387                         else if (event.kbd.keycode == Common::KEYCODE_q && event.kbd.flags == Common::KBD_CTRL)
     387                        else if (event.kbd.keycode == Common::KEYCODE_q && event.kbd.hasFlags(Common::KBD_CTRL))
    388388                                quitGame();
    389389                        else
    390390                                _eventList.push_back(event);

  • engines/gob/util.cpp

     
    114114                        _mouseButtons = (MouseButtons) (((uint32) _mouseButtons) & ~((uint32) kMouseButtonsRight));
    115115                        break;
    116116                case Common::EVENT_KEYDOWN:
    117                         if (event.kbd.flags == Common::KBD_CTRL) {
     117                        if (event.kbd.hasFlags(Common::KBD_CTRL)) {
    118118                                if (event.kbd.keycode == Common::KEYCODE_f)
    119119                                        _fastMode ^= 1;
    120120                                else if (event.kbd.keycode == Common::KEYCODE_g)

  • engines/gob/gob.cpp

     
    109109
    110110void PauseDialog::handleKeyDown(Common::KeyState state) {
    111111        // Close on CTRL+p
    112         if ((state.flags == Common::KBD_CTRL) && (state.keycode == Common::KEYCODE_p))
     112        if ((state.hasFlags(Common::KBD_CTRL)) && (state.keycode == Common::KEYCODE_p))
    113113                close();
    114114}
    115115

  • engines/saga/input.cpp

     
    4444        while (_eventMan->pollEvent(event)) {
    4545                switch (event.type) {
    4646                case Common::EVENT_KEYDOWN:
    47                         if (event.kbd.flags == Common::KBD_CTRL) {
     47                        if (event.kbd.hasFlags(Common::KBD_CTRL)) {
    4848                                if (event.kbd.keycode == Common::KEYCODE_d)
    4949                                        _console->attach();
    5050                        }
    … …  
    5656                        switch (event.kbd.keycode) {
    5757                        case Common::KEYCODE_HASH:
    5858                        case Common::KEYCODE_BACKQUOTE:
    59                         case Common::KEYCODE_QUOTE: // tilde ("~")
     59                        case Common::KEYCODE_TILDE: // tilde ("~")
    6060                                _console->attach();
    6161                                break;
    6262                        case Common::KEYCODE_r:

  • engines/saga/interface.cpp

     
    651651                                return true;
    652652                        }
    653653                }
    654                 if (keystate.keycode == Common::KEYCODE_o && keystate.flags == Common::KBD_CTRL) { // ctrl-o
     654                if (keystate.keycode == Common::KEYCODE_o && keystate.hasFlags(Common::KBD_CTRL)) { // ctrl-o
    655655                        if (_saveReminderState > 0) {
    656656                                setMode(kPanelOption);
    657657                                return true;

  • engines/queen/input.cpp

     
    100100                        _idleTime = 0;
    101101                        switch (event.type) {
    102102                        case Common::EVENT_KEYDOWN:
    103                                 if (event.kbd.flags == Common::KBD_CTRL) {
    104                                         if (event.kbd.keycode == 'd') {
     103                                if (event.kbd.hasFlags(Common::KBD_CTRL)) {
     104                                        if (event.kbd.keycode == Common::KEYCODE_d) {
    105105                                                _debugger = true;
    106                                         } else if (event.kbd.keycode == 'f') {
     106                                        } else if (event.kbd.keycode == Common::KEYCODE_f) {
    107107                                                _fastMode = !_fastMode;
    108108                                        }
    109109                                } else {

  • engines/sci/event.cpp

     
    120120                int modifiers = em->getModifierState();
    121121
    122122                // We add the modifier key status to buckybits
    123                 // SDL sends a keydown event if a modifier key is turned on and a keyup event if it's off
    124                 //
    125                 // FIXME: This code is semi-bogus. It only records the modifier key being *pressed*.
    126                 // It does not track correctly whether capslock etc. is active. To do that, we
    127                 // would have to record the fact that the modifier was pressed in global var,
    128                 // and also watch for Common::EVENT_KEYUP events.
    129                 // But this is still not quite good enough, because not all events might
    130                 // pass through here (e.g. the GUI might be running with its own event loop).
    131                 //
    132                 // The best solution likely would be to add code to the EventManager class
    133                 // for tracking which keys are pressed and which are not...
    134                 if (ev.type == Common::EVENT_KEYDOWN || ev.type == Common::EVENT_KEYUP) {
    135                         switch (ev.kbd.keycode) {
    136                         case Common::KEYCODE_CAPSLOCK:
    137                                 if (ev.type == Common::EVENT_KEYDOWN) {
    138                                         _modifierStates |= SCI_KEYMOD_CAPSLOCK;
    139                                 } else {
    140                                         _modifierStates &= ~SCI_KEYMOD_CAPSLOCK;
    141                                 }
    142                                 break;
    143                         case Common::KEYCODE_NUMLOCK:
    144                                 if (ev.type == Common::EVENT_KEYDOWN) {
    145                                         _modifierStates |= SCI_KEYMOD_NUMLOCK;
    146                                 } else {
    147                                         _modifierStates &= ~SCI_KEYMOD_NUMLOCK;
    148                                 }
    149                                 break;
    150                         case Common::KEYCODE_SCROLLOCK:
    151                                 if (ev.type == Common::EVENT_KEYDOWN) {
    152                                         _modifierStates |= SCI_KEYMOD_SCRLOCK;
    153                                 } else {
    154                                         _modifierStates &= ~SCI_KEYMOD_SCRLOCK;
    155                                 }
    156                                 break;
    157                         default:
    158                                 break;
    159                         }
    160                 }
    161123                //TODO: SCI_EVM_INSERT
    162124
    163125                input.modifiers =
    164126                    ((modifiers & Common::KBD_ALT) ? SCI_KEYMOD_ALT : 0) |
    165127                    ((modifiers & Common::KBD_CTRL) ? SCI_KEYMOD_CTRL : 0) |
    166128                    ((modifiers & Common::KBD_SHIFT) ? SCI_KEYMOD_LSHIFT | SCI_KEYMOD_RSHIFT : 0) |
     129                    ((ev.kbd.flags & Common::KBD_NUM) ? SCI_KEYMOD_NUMLOCK : 0) |
     130                    ((ev.kbd.flags & Common::KBD_CAPS) ? SCI_KEYMOD_CAPSLOCK : 0) |
     131                        ((ev.kbd.flags & Common::KBD_SCRL) ? SCI_KEYMOD_SCRLOCK : 0) |
    167132                        _modifierStates;
    168133
    169134                switch (ev.type) {
    … …  
    173138                        input.character = ev.kbd.ascii;
    174139
    175140                        // Debug console
    176                         if (ev.kbd.flags == Common::KBD_CTRL && ev.kbd.keycode == Common::KEYCODE_d) {
     141                        if (ev.kbd.hasFlags(Common::KBD_CTRL) && ev.kbd.keycode == Common::KEYCODE_d) {
    177142                                // Open debug console
    178143                                Console *con = g_sci->getSciDebugger();
    179144                                con->attach();

  • engines/sword2/sword2.cpp

     
    491491                KeyboardEvent *ke = keyboardEvent();
    492492
    493493                if (ke) {
    494                         if ((ke->kbd.flags == Common::KBD_CTRL && ke->kbd.keycode == Common::KEYCODE_d) || ke->kbd.ascii == '#' || ke->kbd.ascii == '~') {
     494                        if ((ke->kbd.hasFlags(Common::KBD_CTRL) && ke->kbd.keycode == Common::KEYCODE_d) || ke->kbd.ascii == '#' || ke->kbd.ascii == '~') {
    495495                                _debugger->attach();
    496                         } else if (ke->kbd.flags == 0 || ke->kbd.flags == Common::KBD_SHIFT) {
     496                        } else if (ke->kbd.hasFlags(0) || ke->kbd.hasFlags(Common::KBD_SHIFT)) {
    497497                                switch (ke->kbd.keycode) {
    498498                                case Common::KEYCODE_p:
    499499                                        if (_gamePaused)
    … …  
    654654        while (_eventMan->pollEvent(event)) {
    655655                switch (event.type) {
    656656                case Common::EVENT_KEYDOWN:
    657                         if (event.kbd.flags == Common::KBD_CTRL) {
    658                                 if (event.kbd.keycode == 'f') {
     657                        if (event.kbd.hasFlags(Common::KBD_CTRL)) {
     658                                if (event.kbd.keycode == Common::KEYCODE_f) {
    659659                                        if (_gameSpeed == 1)
    660660                                                _gameSpeed = 2;
    661661                                        else

  • engines/draci/draci.cpp

     
    293293                                }
    294294                                break;
    295295                        case Common::KEYCODE_F5:
    296                                 if (event.kbd.flags == 0) {
     296                                if (event.kbd.hasFlags(0)) {
    297297                                        openMainMenuDialog();
    298298                                }
    299299                                break;

  • engines/scumm/input.cpp

     
    110110void ScummEngine::parseEvent(Common::Event event) {
    111111        switch (event.type) {
    112112        case Common::EVENT_KEYDOWN:
    113                 if (event.kbd.keycode >= '0' && event.kbd.keycode <= '9' &&
    114                         ((event.kbd.flags == Common::KBD_ALT && canSaveGameStateCurrently()) ||
    115                         (event.kbd.flags == Common::KBD_CTRL && canLoadGameStateCurrently()))) {
    116                         _saveLoadSlot = event.kbd.keycode - '0';
     113                if (event.kbd.keycode >= Common::KEYCODE_0 && event.kbd.keycode <= Common::KEYCODE_9 &&
     114                        ((event.kbd.hasFlags(Common::KBD_ALT) && canSaveGameStateCurrently()) ||
     115                        (event.kbd.hasFlags(Common::KBD_CTRL) && canLoadGameStateCurrently()))) {
     116                        _saveLoadSlot = event.kbd.keycode - Common::KEYCODE_0;
    117117
    118118                        //  don't overwrite autosave (slot 0)
    119119                        if (_saveLoadSlot == 0)
    120120                                _saveLoadSlot = 10;
    121121
    122122                        sprintf(_saveLoadName, "Quicksave %d", _saveLoadSlot);
    123                         _saveLoadFlag = (event.kbd.flags == Common::KBD_ALT) ? 1 : 2;
     123                        _saveLoadFlag = (event.kbd.hasFlags(Common::KBD_ALT)) ? 1 : 2;
    124124                        _saveTemporaryState = false;
    125                 } else if (event.kbd.flags == Common::KBD_CTRL && event.kbd.keycode == 'f') {
     125                } else if (event.kbd.hasFlags(Common::KBD_CTRL) && event.kbd.keycode == Common::KEYCODE_f) {
    126126                        _fastMode ^= 1;
    127                 } else if (event.kbd.flags == Common::KBD_CTRL && event.kbd.keycode == 'g') {
     127                } else if (event.kbd.hasFlags(Common::KBD_CTRL) && event.kbd.keycode == Common::KEYCODE_g) {
    128128                        _fastMode ^= 2;
    129                 } else if ((event.kbd.flags == Common::KBD_CTRL && event.kbd.keycode == 'd') ||
    130                                 event.kbd.ascii == '~' || event.kbd.ascii == '#') {
     129                } else if ((event.kbd.hasFlags(Common::KBD_CTRL) && event.kbd.keycode == Common::KEYCODE_d)
     130                        || event.kbd.ascii == '~' || event.kbd.ascii == '#') {
    131131                        _debugger->attach();
    132                 } else if (event.kbd.flags == Common::KBD_CTRL && event.kbd.keycode == 's') {
     132                } else if (event.kbd.hasFlags(Common::KBD_CTRL) && event.kbd.keycode == Common::KEYCODE_s) {
    133133                        _res->resourceStats();
    134134                } else {
    135135                        // Normal key press, pass on to the game.
    … …  
    355355#ifdef ENABLE_SCUMM_7_8
    356356void ScummEngine_v8::processKeyboard(Common::KeyState lastKeyHit) {
    357357        // F1 (the trigger for the original save/load dialog) is mapped to F5
    358         if (!(_game.features & GF_DEMO) && lastKeyHit.keycode == Common::KEYCODE_F1 && lastKeyHit.flags == 0) {
     358        if (!(_game.features & GF_DEMO) && lastKeyHit.keycode == Common::KEYCODE_F1 && lastKeyHit.hasFlags(0)) {
    359359                lastKeyHit = Common::KeyState(Common::KEYCODE_F5, 319);
    360360        }
    361361
    362362        // Alt-F5 should bring up the original save/load dialog, so map it to F1.
    363         if (!(_game.features & GF_DEMO) && lastKeyHit.keycode == Common::KEYCODE_F5 && lastKeyHit.flags == Common::KBD_ALT) {
     363        if (!(_game.features & GF_DEMO) && lastKeyHit.keycode == Common::KEYCODE_F5 && lastKeyHit.hasFlags(Common::KBD_ALT)) {
    364364                lastKeyHit = Common::KeyState(Common::KEYCODE_F1, 315);
    365365        }
    366366
    … …  
    383383        // version string is hard coded in the engine, hence we don't invoke
    384384        // versionDialog for it. Dig/FT version strings are partly hard coded, too.
    385385        if (_game.id != GID_CMI && 0 != VAR(VAR_VERSION_KEY) &&
    386             lastKeyHit.keycode == Common::KEYCODE_v && lastKeyHit.flags == Common::KBD_CTRL) {
     386            lastKeyHit.keycode == Common::KEYCODE_v && lastKeyHit.hasFlags(Common::KBD_CTRL)) {
    387387                versionDialog();
    388388
    389389        } else if (cutsceneExitKeyEnabled && lastKeyHit.keycode == Common::KEYCODE_ESCAPE) {
    … …  
    408408#endif
    409409
    410410void ScummEngine_v6::processKeyboard(Common::KeyState lastKeyHit) {
    411         if (lastKeyHit.keycode == Common::KEYCODE_t && lastKeyHit.flags == Common::KBD_CTRL) {
     411        if (lastKeyHit.keycode == Common::KEYCODE_t && lastKeyHit.hasFlags(Common::KBD_CTRL)) {
    412412                SubtitleSettingsDialog dialog(this, _voiceMode);
    413413                _voiceMode = runDialog(dialog);
    414414
    … …  
    442442        ScummEngine::processKeyboard(lastKeyHit);
    443443
    444444        // On Alt-F5 prepare savegame for the original save/load dialog.
    445         if (lastKeyHit.keycode == Common::KEYCODE_F5 && lastKeyHit.flags == Common::KBD_ALT) {
     445        if (lastKeyHit.keycode == Common::KEYCODE_F5 && lastKeyHit.hasFlags(Common::KBD_ALT)) {
    446446                prepareSavegame();
    447447                if (_game.id == GID_MANIAC && _game.version == 0) {
    448448                        runScript(2, 0, 0, 0);
    … …  
    467467        ScummEngine::processKeyboard(lastKeyHit);
    468468
    469469        // On Alt-F5 prepare savegame for the original save/load dialog.
    470         if (lastKeyHit.keycode == Common::KEYCODE_F5 && lastKeyHit.flags == Common::KBD_ALT) {
     470        if (lastKeyHit.keycode == Common::KEYCODE_F5 && lastKeyHit.hasFlags(Common::KBD_ALT)) {
    471471                prepareSavegame();
    472472        }
    473473
    … …  
    504504        if (_game.id == GID_CMI)
    505505                mainmenuKeyEnabled = true;
    506506
    507         if (mainmenuKeyEnabled && (lastKeyHit.keycode == Common::KEYCODE_F5 && lastKeyHit.flags == 0)) {
     507        if (mainmenuKeyEnabled && (lastKeyHit.keycode == Common::KEYCODE_F5 && lastKeyHit.hasFlags(0))) {
    508508                if (VAR_SAVELOAD_SCRIPT != 0xFF && _currentRoom != 0)
    509509                        runScript(VAR(VAR_SAVELOAD_SCRIPT), 0, 0, 0);
    510510
    … …  
    513513                if (VAR_SAVELOAD_SCRIPT != 0xFF && _currentRoom != 0)
    514514                        runScript(VAR(VAR_SAVELOAD_SCRIPT2), 0, 0, 0);
    515515
    516         } else if (restartKeyEnabled && (lastKeyHit.keycode == Common::KEYCODE_F8 && lastKeyHit.flags == 0)) {
     516        } else if (restartKeyEnabled && (lastKeyHit.keycode == Common::KEYCODE_F8 && lastKeyHit.hasFlags(0))) {
    517517                confirmRestartDialog();
    518518
    519         } else if (pauseKeyEnabled && (lastKeyHit.keycode == Common::KEYCODE_SPACE && lastKeyHit.flags == 0)) {
     519        } else if (pauseKeyEnabled && (lastKeyHit.keycode == Common::KEYCODE_SPACE && lastKeyHit.hasFlags(0))) {
    520520                pauseGame();
    521521
    522         } else if (talkstopKeyEnabled && (lastKeyHit.keycode == Common::KEYCODE_PERIOD && lastKeyHit.flags == 0)) {
     522        } else if (talkstopKeyEnabled && (lastKeyHit.keycode == Common::KEYCODE_PERIOD && lastKeyHit.hasFlags(0))) {
    523523                _talkDelay = 0;
    524524                if (_sound->_sfxMode & 2)
    525525                        stopTalk();
    526526
    527         } else if (cutsceneExitKeyEnabled && (lastKeyHit.keycode == Common::KEYCODE_ESCAPE && lastKeyHit.flags == 0)) {
     527        } else if (cutsceneExitKeyEnabled && (lastKeyHit.keycode == Common::KEYCODE_ESCAPE && lastKeyHit.hasFlags(0))) {
    528528                abortCutscene();
    529529
    530530                // VAR_CUTSCENEEXIT_KEY doesn't exist in SCUMM0
    531531                if (VAR_CUTSCENEEXIT_KEY != 0xFF)
    532532                        _mouseAndKeyboardStat = VAR(VAR_CUTSCENEEXIT_KEY);
    533533        } else if (snapScrollKeyEnabled && lastKeyHit.keycode == Common::KEYCODE_r &&
    534                 lastKeyHit.flags == Common::KBD_CTRL) {
     534                lastKeyHit.hasFlags(Common::KBD_CTRL)) {
    535535                _snapScroll ^= 1;
    536536                if (_snapScroll) {
    537537                        messageDialog("Snap scroll on");

  • engines/scumm/dialogs.cpp

     
    725725}
    726726
    727727void SubtitleSettingsDialog::handleKeyDown(Common::KeyState state) {
    728         if (state.keycode == 't' && state.flags == Common::KBD_CTRL) {
     728        if (state.keycode == Common::KEYCODE_t && state.hasFlags(Common::KBD_CTRL)) {
    729729                cycleValue();
    730730
    731731                reflowLayout();

  • engines/touche/touche.cpp

     
    313313                        } else if (event.kbd.keycode == Common::KEYCODE_F10) {
    314314                                _fastWalkMode = false;
    315315                        }
    316                         if (event.kbd.flags == Common::KBD_CTRL) {
     316                        if (event.kbd.hasFlags(Common::KBD_CTRL)) {
    317317                                if (event.kbd.keycode == Common::KEYCODE_f) {
    318318                                        _fastMode = !_fastMode;
    319319                                }

  • engines/agos/event.cpp

     
    459459                        switch (event.type) {
    460460                        case Common::EVENT_KEYDOWN:
    461461                                if (event.kbd.keycode >= Common::KEYCODE_0 && event.kbd.keycode <= Common::KEYCODE_9
    462                                         && (event.kbd.flags == Common::KBD_ALT ||
    463                                                 event.kbd.flags == Common::KBD_CTRL)) {
     462                                        && (event.kbd.hasFlags(Common::KBD_ALT) ||
     463                                                event.kbd.hasFlags(Common::KBD_CTRL))) {
    464464                                        _saveLoadSlot = event.kbd.keycode - Common::KEYCODE_0;
    465465
    466466                                        // There is no save slot 0
    … …  
    469469
    470470                                        memset(_saveLoadName, 0, sizeof(_saveLoadName));
    471471                                        sprintf(_saveLoadName, "Quick %d", _saveLoadSlot);
    472                                         _saveLoadType = (event.kbd.flags == Common::KBD_ALT) ? 1 : 2;
     472                                        _saveLoadType = (event.kbd.hasFlags(Common::KBD_ALT)) ? 1 : 2;
    473473
    474474                                        // We should only allow a load or save when it was possible in original
    475475                                        // This stops load/save during copy protection, conversations and cut scenes
    476476                                        if (!_mouseHideCount && !_showPreposition)
    477477                                                quickLoadOrSave();
    478                                 } else if (event.kbd.flags == Common::KBD_CTRL) {
     478                                } else if (event.kbd.hasFlags(Common::KBD_CTRL)) {
    479479                                        if (event.kbd.keycode == Common::KEYCODE_a) {
    480480                                                GUI::Dialog *_aboutDialog;
    481481                                                _aboutDialog = new GUI::AboutDialog();
    … …  
    492492                                }
    493493
    494494                                if (getGameType() == GType_PP) {
    495                                         if (event.kbd.flags == Common::KBD_SHIFT)
     495                                        if (event.kbd.hasFlags(Common::KBD_SHIFT))
    496496                                                _variableArray[41] = 0;
    497497                                        else
    498498                                                _variableArray[41] = 1;

  • engines/cruise/cruise_main.cpp

     
    17591759                                break;
    17601760                        }
    17611761
    1762                         if (event.kbd.flags == Common::KBD_CTRL) {
     1762                        if (event.kbd.hasFlags(Common::KBD_CTRL)) {
    17631763                                if (event.kbd.keycode == Common::KEYCODE_d) {
    17641764                                        // Start the debugger
    17651765                                        _vm->getDebugger()->attach();

  • engines/tinsel/tinsel.cpp

     
    230230                        continue;
    231231                case Common::KEYCODE_m:
    232232                        // Debug facility - scene hopper
    233                         if (TinselV2 && (evt.kbd.flags == Common::KBD_ALT))
     233                        if (TinselV2 && (evt.kbd.hasFlags(Common::KBD_ALT)))
    234234                                ProcessKeyEvent(PLR_JUMP);
    235235                        break;
    236236                case Common::KEYCODE_q:
    237                         if ((evt.kbd.flags == Common::KBD_CTRL) || (evt.kbd.flags == Common::KBD_ALT))
     237                        if ((evt.kbd.hasFlags(Common::KBD_CTRL)) || (evt.kbd.hasFlags(Common::KBD_ALT)))
    238238                                ProcessKeyEvent(PLR_QUIT);
    239239                        continue;
    240240                case Common::KEYCODE_PAGEUP:
    … …  
    12011201        // Handle any special keys immediately
    12021202        switch (event.kbd.keycode) {
    12031203        case Common::KEYCODE_d:
    1204                 if ((event.kbd.flags == Common::KBD_CTRL) && (event.type == Common::EVENT_KEYDOWN)) {
     1204                // Checks for CTRL flag, ignoring all the sticky flags
     1205                if ((Common::KBD_CTRL == (event.kbd.flags & ~(Common::KBD_NUM|Common::KBD_CAPS|Common::KBD_SCRL))) && (event.type == Common::EVENT_KEYDOWN)) {
    12051206                        // Activate the debugger
    12061207                        assert(_console);
    12071208                        _console->attach();

  • engines/sky/sky.cpp

     
    113113                _skySound->fnUnPauseFx();
    114114                _systemVars.paused = false;
    115115                _skyScreen->setPaletteEndian((uint8 *)_skyCompact->fetchCpt(SkyEngine::_systemVars.currentPalette));
    116         } else if (_keyPressed.flags == Common::KBD_CTRL) {
    117                 if (_keyPressed.keycode == 'f')
     116        } else if (_keyPressed.hasFlags(Common::KBD_CTRL)) {
     117                if (_keyPressed.keycode == Common::KEYCODE_f)
    118118                        _fastMode ^= 1;
    119                 else if (_keyPressed.keycode == 'g')
     119                else if (_keyPressed.keycode == Common::KEYCODE_g)
    120120                        _fastMode ^= 2;
    121                 else if (_keyPressed.keycode == 'd')
     121                else if (_keyPressed.keycode == Common::KEYCODE_d)
    122122                        _debugger->attach();
    123123        } else if (_keyPressed.keycode) {
    124124                switch (_keyPressed.keycode) {

  • engines/lure/game.cpp

     
    195195                                if (events.type() == Common::EVENT_KEYDOWN) {
    196196                                        uint16 roomNum = room.roomNumber();
    197197
    198                                         if ((events.event().kbd.flags == Common::KBD_CTRL) &&
     198                                        if ((events.event().kbd.hasFlags(Common::KBD_CTRL)) &&
    199199                                                (events.event().kbd.keycode == Common::KEYCODE_d)) {
    200200                                                // Activate the debugger
    201201                                                _debugger->attach();

  • engines/lure/fights.cpp

     
    205205                                return;
    206206
    207207                        case Common::KEYCODE_d:
    208                                 if (events.event().kbd.flags == Common::KBD_CTRL) {
     208                                if (events.event().kbd.hasFlags(Common::KBD_CTRL)) {
    209209                                        // Activate the debugger
    210210                                        game.debugger().attach();
    211211                                        return;

  • engines/parallaction/input.cpp

     
    111111                        _hasKeyPressEvent = true;
    112112                        _keyPressed = e.kbd;
    113113
    114                         if (e.kbd.flags == Common::KBD_CTRL && e.kbd.keycode == 'd')
     114                        if (e.kbd.hasFlags(Common::KBD_CTRL) && e.kbd.keycode == Common::KEYCODE_d)
    115115                                _vm->_debugger->attach();
    116116
    117117                        updateMousePos = false;

  • engines/teenagent/teenagent.cpp

     
    474474                        //debug(0, "event");
    475475                        switch (event.type) {
    476476                        case Common::EVENT_KEYDOWN:
    477                                 if ((event.kbd.flags == Common::KBD_CTRL && event.kbd.keycode == 'd') ||
     477                                if ((event.kbd.hasFlags(Common::KBD_CTRL) && event.kbd.keycode == Common::KEYCODE_d) ||
    478478                                        event.kbd.ascii == '~' || event.kbd.ascii == '#') {
    479479                                        console->attach();
    480                                 } else if (event.kbd.flags == 0 && event.kbd.keycode == Common::KEYCODE_F5) {
     480                                } else if (event.kbd.hasFlags(0) && event.kbd.keycode == Common::KEYCODE_F5) {
    481481                                        openMainMenuDialog();
    482                                 } if (event.kbd.flags == Common::KBD_CTRL && event.kbd.keycode == 'f') {
     482                                } if (event.kbd.hasFlags(Common::KBD_CTRL) && event.kbd.keycode == Common::KEYCODE_f) {
    483483                                        _mark_delay = _mark_delay == 80? 40: 80;
    484484                                        debug(0, "mark_delay = %u", _mark_delay);
    485485                                }

  • common/keyboard.h

     
    4040        KEYCODE_PAUSE       = 19,
    4141        KEYCODE_ESCAPE      = 27,
    4242        KEYCODE_SPACE       = 32,
    43         KEYCODE_EXCLAIM     = 33,
    44         KEYCODE_QUOTEDBL    = 34,
    45         KEYCODE_HASH        = 35,
    46         KEYCODE_DOLLAR      = 36,
    47         KEYCODE_AMPERSAND   = 38,
    48         KEYCODE_QUOTE       = 39,
     43        KEYCODE_EXCLAIM     = 33,      // !
     44        KEYCODE_QUOTEDBL    = 34,      // "
     45        KEYCODE_HASH        = 35,      // #
     46        KEYCODE_DOLLAR      = 36,      // $
     47        KEYCODE_AMPERSAND   = 38,      // &
     48        KEYCODE_QUOTE       = 39,      // '
    4949        KEYCODE_LEFTPAREN   = 40,
    5050        KEYCODE_RIGHTPAREN  = 41,
    51         KEYCODE_ASTERISK    = 42,
     51        KEYCODE_ASTERISK    = 42,      // *
    5252        KEYCODE_PLUS        = 43,
    5353        KEYCODE_COMMA       = 44,
    5454        KEYCODE_MINUS       = 45,
    … …  
    105105        KEYCODE_y           = 121,
    106106        KEYCODE_z           = 122,
    107107        KEYCODE_DELETE      = 127,
     108        KEYCODE_TILDE       = 176,      // ~
    108109
    109110        // Numeric keypad
    110111        KEYCODE_KP0         = 256,
    … …  
    215216enum {
    216217        KBD_CTRL  = 1 << 0,
    217218        KBD_ALT   = 1 << 1,
    218         KBD_SHIFT = 1 << 2
     219        KBD_SHIFT = 1 << 2,
     220        KBD_NUM   = 1 << 3,
     221        KBD_CAPS  = 1 << 4,
     222        KBD_SCRL  = 1 << 5
    219223};
    220224
    221225/**
    … …  
    245249        /**
    246250         * Status of the modifier keys. Bits are set in this for each
    247251         * pressed modifier
    248          * @see KBD_CTRL, KBD_ALT, KBD_SHIFT
     252         * @see KBD_CTRL, KBD_ALT, KBD_SHIFT, KBD_NUM, KBD_CAPS, KBD_SCRL
    249253         */
    250254        byte flags;
    251255
    … …  
    266270                ascii = flags = 0;
    267271        }
    268272
     273        /**
     274         * Check for flags, ignoring the sticky flags (KBD_NUM, KBD_CAPS, KBD_SCRL)
     275         */
     276        bool hasFlags(byte f) {
     277                return f == (flags & ~(KBD_NUM|KBD_CAPS|KBD_SCRL));
     278        }
     279
    269280        bool operator ==(const KeyState &x) const {
    270281                return keycode == x.keycode && ascii == x.ascii && flags == x.flags;
    271282        }

  • backends/events/default/default-events.cpp

     
    103103                        _keyRepeatTime = time + kKeyRepeatInitialDelay;
    104104#endif
    105105                        // Global Main Menu
    106                         if (event.kbd.flags == Common::KBD_CTRL && event.kbd.keycode == Common::KEYCODE_F5) {
     106                        if (event.kbd.hasFlags(Common::KBD_CTRL) && event.kbd.keycode == Common::KEYCODE_F5) {
    107107                                if (g_engine && !g_engine->isPaused()) {
    108108                                        Common::Event menuEvent;
    109109                                        menuEvent.type = Common::EVENT_MAINMENU;
    … …  
    135135                                }
    136136                        }
    137137#ifdef ENABLE_VKEYBD
    138                         else if (event.kbd.keycode == Common::KEYCODE_F7 && event.kbd.flags == 0) {
     138                        else if (event.kbd.keycode == Common::KEYCODE_F7 && event.kbd.hasFlags(0)) {
    139139                                if (_vk->isDisplaying()) {
    140140                                        _vk->close(true);
    141141                                } else {
    … …  
    149149                        }
    150150#endif
    151151#ifdef ENABLE_KEYMAPPER
    152                         else if (event.kbd.keycode == Common::KEYCODE_F8 && event.kbd.flags == 0) {
     152                        else if (event.kbd.keycode == Common::KEYCODE_F8 && event.kbd.hasFlags(0)) {
    153153                                if (!_remap) {
    154154                                        _remap = true;
    155155                                        Common::RemapDialog _remapDialog;

  • backends/platform/sdl/sdl.cpp

     
    232232        _overlayscreen(0), _tmpscreen2(0),
    233233        _samplesPerSec(0),
    234234        _cdrom(0), _scalerProc(0), _modeChanged(false), _screenChangeCount(0), _dirtyChecksums(0),
     235        _scrollLock(false),
    235236        _mouseVisible(false), _mouseNeedsRedraw(false), _mouseData(0), _mouseSurface(0),
    236237        _mouseOrigSurface(0), _cursorTargetScale(1), _cursorPaletteDisabled(true),
    237238        _joystick(0),

  • backends/platform/sdl/events.cpp

     
    152152        }
    153153}
    154154
    155 static byte SDLModToOSystemKeyFlags(SDLMod mod) {
    156         byte b = 0;
     155static void SDLModToOSystemKeyFlags(SDLMod mod, Common::Event &event) {
     156
     157        event.kbd.flags = 0;
     158
    157159#ifdef LINUPY
    158160        // Yopy has no ALT key, steal the SHIFT key
    159161        // (which isn't used much anyway)
    160162        if (mod & KMOD_SHIFT)
    161                 b |= Common::KBD_ALT;
     163                event.kbd.flags |= Common::KBD_ALT;
    162164#else
    163165        if (mod & KMOD_SHIFT)
    164                 b |= Common::KBD_SHIFT;
     166                event.kbd.flags |= Common::KBD_SHIFT;
    165167        if (mod & KMOD_ALT)
    166                 b |= Common::KBD_ALT;
     168                event.kbd.flags |= Common::KBD_ALT;
    167169#endif
    168170        if (mod & KMOD_CTRL)
    169                 b |= Common::KBD_CTRL;
     171                event.kbd.flags |= Common::KBD_CTRL;
    170172
    171         return b;
     173        // Sticky flags
     174        if (mod & KMOD_NUM)
     175                event.kbd.flags |= Common::KBD_NUM;
     176        if (mod & KMOD_CAPS)
     177                event.kbd.flags |= Common::KBD_CAPS;
    172178}
    173179
    174180bool OSystem_SDL::pollEvent(Common::Event &event) {
    … …  
    225231
    226232
    227233bool OSystem_SDL::handleKeyDown(SDL_Event &ev, Common::Event &event) {
    228         byte b = 0;
    229         b = event.kbd.flags = SDLModToOSystemKeyFlags(SDL_GetModState());
    230234
     235        SDLModToOSystemKeyFlags(SDL_GetModState(), event);
     236
     237        // Handle scroll lock as a key modifier
     238        if (ev.key.keysym.sym == SDLK_SCROLLOCK)
     239                _scrollLock = !_scrollLock;
     240
     241        if (_scrollLock)
     242                event.kbd.flags |= Common::KBD_SCRL;
     243
    231244        // Alt-Return and Alt-Enter toggle full screen mode
    232         if (b == Common::KBD_ALT && (ev.key.keysym.sym == SDLK_RETURN
    233                                           || ev.key.keysym.sym == SDLK_KP_ENTER)) {
     245        if (event.kbd.hasFlags(Common::KBD_ALT) && (ev.key.keysym.sym == SDLK_RETURN || ev.key.keysym.sym == SDLK_KP_ENTER)) {
    234246                beginGFXTransaction();
    235247                        setFullscreenMode(!_videoMode.fullscreen);
    236248                endGFXTransaction();
    … …  
    245257        }
    246258
    247259        // Alt-S: Create a screenshot
    248         if (b == Common::KBD_ALT && ev.key.keysym.sym == 's') {
     260        if (event.kbd.hasFlags(Common::KBD_ALT) && ev.key.keysym.sym == 's') {
    249261                char filename[20];
    250262
    251263                for (int n = 0;; n++) {
    … …  
    265277        }
    266278
    267279        // Ctrl-m toggles mouse capture
    268         if (b == Common::KBD_CTRL && ev.key.keysym.sym == 'm') {
     280        if (event.kbd.hasFlags(Common::KBD_CTRL) && ev.key.keysym.sym == 'm') {
    269281                toggleMouseGrab();
    270282                return false;
    271283        }
    … …  
    284296        }
    285297#else
    286298        // Ctrl-z and Alt-X quit
    287         if ((b == Common::KBD_CTRL && ev.key.keysym.sym == 'z') || (b == Common::KBD_ALT && ev.key.keysym.sym == 'x')) {
     299        if ((event.kbd.hasFlags(Common::KBD_CTRL) && ev.key.keysym.sym == 'z') || (event.kbd.hasFlags(Common::KBD_ALT) && ev.key.keysym.sym == 'x')) {
    288300                event.type = Common::EVENT_QUIT;
    289301                return true;
    290302        }
    … …  
    296308        }
    297309
    298310        // Ctrl-Alt-<key> will change the GFX mode
    299         if ((b & (Common::KBD_CTRL|Common::KBD_ALT)) == (Common::KBD_CTRL|Common::KBD_ALT)) {
     311        if ((event.kbd.flags & (Common::KBD_CTRL|Common::KBD_ALT)) == (Common::KBD_CTRL|Common::KBD_ALT)) {
    300312                if (handleScalerHotkeys(ev.key))
    301313                        return false;
    302314        }
    … …  
    320332        event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
    321333
    322334        // Ctrl-Alt-<key> will change the GFX mode
    323         byte b = event.kbd.flags = SDLModToOSystemKeyFlags(SDL_GetModState());
    324         if ((b & (Common::KBD_CTRL|Common::KBD_ALT)) == (Common::KBD_CTRL|Common::KBD_ALT)) {
     335        SDLModToOSystemKeyFlags(SDL_GetModState(), event);
     336
     337        // Set the scroll lock sticky flag
     338        if (_scrollLock)
     339                event.kbd.flags |= Common::KBD_SCRL;
     340
     341        if ((event.kbd.flags & (Common::KBD_CTRL|Common::KBD_ALT)) == (Common::KBD_CTRL|Common::KBD_ALT)) {
    325342                // Swallow these key up events
    326343                return false;
    327344        }

  • backends/platform/sdl/sdl.h

     
    412412                kMouseColorKey = 1
    413413        };
    414414
     415        // Scroll lock state - since SDL doesn't track it
     416        bool _scrollLock;
     417       
    415418        // joystick
    416419        SDL_Joystick *_joystick;
    417420