Ticket #4759: 3 - convert_engines_to_use_new_hasFlags_method.patch

File 3 - convert_engines_to_use_new_hasFlags_method.patch, 23.1 KB (added by Templier, 14 years ago)

3 - Convert engines to use the new hasFlags method

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

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