Detect "Shift + Arrow Key" in Windows C++ Console Application (win32)

Question

I found an old VT100 Terminal editor written in C++ that I wanted to convert into a Windows Terminal console application, since the new windows terminal supports VT100 escape codes.

One of the questions I had while porting the Application to C++ under windows was:

How do I detect key sequences such as "Shift+Arrow Key" and "Shift+Ctrl+Arrow Key". When I try to use getch() it doesn't seem to detect the shift key in combination with arrow keys.

Here's How I'm currently detecting key presses in my Console Application:

#define KEY_BACKSPACE        0x101
#define KEY_ESC              0x102
#define KEY_INS              0x103
#define KEY_DEL              0x104
#define KEY_LEFT             0x105
#define KEY_RIGHT            0x106
#define KEY_UP               0x107
#define KEY_DOWN             0x108
#define KEY_HOME             0x109
#define KEY_END              0x10A
#define KEY_ENTER            0x10B
#define KEY_TAB              0x10C
#define KEY_PGUP             0x10D
#define KEY_PGDN             0x10E

#define KEY_CTRL_LEFT        0x10F
#define KEY_CTRL_RIGHT       0x110
#define KEY_CTRL_UP          0x111
#define KEY_CTRL_DOWN        0x112
#define KEY_CTRL_HOME        0x113
#define KEY_CTRL_END         0x114
#define KEY_CTRL_TAB         0x115

#define KEY_SHIFT_LEFT       0x116
#define KEY_SHIFT_RIGHT      0x117
#define KEY_SHIFT_UP         0x118
#define KEY_SHIFT_DOWN       0x119
#define KEY_SHIFT_PGUP       0x11A
#define KEY_SHIFT_PGDN       0x11B
#define KEY_SHIFT_HOME       0x11C
#define KEY_SHIFT_END        0x11D
#define KEY_SHIFT_TAB        0x11E

#define KEY_SHIFT_CTRL_LEFT  0x11F
#define KEY_SHIFT_CTRL_RIGHT 0x120
#define KEY_SHIFT_CTRL_UP    0x121
#define KEY_SHIFT_CTRL_DOWN  0x122
#define KEY_SHIFT_CTRL_HOME  0x123
#define KEY_SHIFT_CTRL_END   0x124

#define KEY_F1               0x125
#define KEY_F3               0x126
#define KEY_F5               0x127

#define KEY_ALT_LEFT         0x128
#define KEY_ALT_RIGHT        0x129
#define KEY_ALT_UP           0x130
#define KEY_ALT_DOWN         0x131
#define KEY_ALT_HOME         0x132
#define KEY_ALT_END          0x133
#define KEY_ALT_TAB          0x134
#define KEY_ALT_PGUP         0x135
#define KEY_ALT_PGDN         0x136

#define KEY_UNKNOWN          0xFFF

#if defined(WIN32) || defined(_WIN64)
    #include "windows.h"
    #include "conio.h"
#endif

int getkey_win32() {
    int c1;
    int c2;

    c1 = (int)getch();

    // unmapable  How to detect Shift + Arrow Key??
    //#define KEY_SHIFT_LEFT       0x116
    //#define KEY_SHIFT_RIGHT      0x117
    //#define KEY_SHIFT_UP         0x118
    //#define KEY_SHIFT_DOWN       0x119
    //#define KEY_SHIFT_PGUP       0x11A
    //#define KEY_SHIFT_PGDN       0x11B
    //#define KEY_SHIFT_HOME       0x11C
    //#define KEY_SHIFT_END        0x11D
    //#define KEY_SHIFT_CTRL_LEFT  0x11F
    //#define KEY_SHIFT_CTRL_RIGHT 0x120
    //#define KEY_SHIFT_CTRL_UP    0x121
    //#define KEY_SHIFT_CTRL_DOWN  0x122
    //#define KEY_SHIFT_CTRL_HOME  0x123
    //#define KEY_SHIFT_CTRL_END   0x124


    if (c1 == 0) {
        c2 = (int)getch();

        switch(c2) {
            case 0x9b: return KEY_ALT_LEFT;
            case 0x9d: return KEY_ALT_RIGHT;
            case 0x98: return KEY_ALT_UP;
            case 0xa0: return KEY_ALT_DOWN;
            case 0x99: return KEY_ALT_PGUP;
            case 0xa1: return KEY_ALT_PGDN;
            case 0x97: return KEY_ALT_HOME;
            case 0x9F: return KEY_ALT_END;
            case 0x3b: return KEY_F1;
            case 0x3d: return KEY_F3;
            case 0x3f: return KEY_F5;

            default:   return KEY_UNKNOWN;
        }
    }
    else if (c1 == 0xe0) {
        c2 = (int)getch();

        switch(c2) {
            case 0x73: return KEY_CTRL_LEFT;
            case 0x74: return KEY_CTRL_RIGHT;
            case 0x8d: return KEY_CTRL_UP;
            case 0x91: return KEY_CTRL_DOWN;
            case 0x77: return KEY_CTRL_HOME;
            case 0x75: return KEY_CTRL_END;
            case 0x52: return KEY_INS;
            case 0x53: return KEY_DEL;
            case 0x4b: return KEY_LEFT;
            case 0x4d: return KEY_RIGHT;
            case 0x48: return KEY_UP;
            case 0x50: return KEY_DOWN;
            case 0x47: return KEY_HOME;
            case 0x4f: return KEY_END;
            case 0x49: return KEY_PGUP;
            case 0x51: return KEY_PGDN;
            default:   return KEY_UNKNOWN;
        }

    }
    else {
        switch(c1) {
            case 0x08: return KEY_BACKSPACE;
            case 0x1b: return KEY_ESC;
            case 0x0d: return KEY_ENTER;
            case 0x09: return KEY_TAB;
            default: return c1;
        }

    }

}

score 2 · Answer 1 · answered Sep 10 '22 at 15:40

Alas, getch() is the wrong tool. You can use it, but you need to keep track of the shift state yourself. You can also use the GetKeyState() or GetAsyncKeyState() functions as exampled in the other answer.

The correct way to do this, until recently, was to use the Windows Console API function ReadConsoleInput(), and again keep track.

These days, Windows Terminal / Windows Console applications are expected to follow the new Microsoft Ecosystem Roadmap which basically says “use virtual terminal sequences”. It isn’t a perfect replacement (not by any means) but it does have the added bonus of making your terminal application easily portable to *nixen.

There are two main references for virtual terminal input sequences:

There is one bit left: you must properly initialize the Windows Terminal / Windows Console to use the virtual terminal sequences. At the very minimum, I recommend something like:

HANDLE hstdin  = GetStdHandle( STD_INPUT_HANDLE )
HANDLE hstdout = GetStdHandle( STD_OUTPUT_HANDLE )

DWORD input_mode, output_mode;
GetConsoleMode( hstdin,  &input_mode );
GetConsoleMode( hstdout, &output_mode );

SetConsoleMode( hstdin,  ENABLE_VIRTUAL_TERMINAL_INPUT | ENABLE_EXTENDED_FLAGS );
SetConsoleMode( hstdout, ENABLE_PROCESSED_OUTPUT | ENABLE_VIRTUAL_TERMINAL_PROCESSING );

UINT input_codepage = GetConsoleCP();
SetConsoleCP( 65001 );
setlocale( LC_ALL, ".UTF-8" );

printf(
  "\033[\?1049h"    // use alternate buffer
  "\033[\?25l" );   // hide caret

You can add ENABLE_MOUSE_INPUT to the input flags as well, if you wish. Read up on SetConsoleMode() for more.

Finally, don’t forget to install an at_exit() handler to restore things when you terminate.

printf(
  "\033[\?1049l"    // done with alternate buffer
  "\033[\?25h"  );  // show caret
SetConsoleCP( input_codepage );
SetConsoleMode( hstdin,  input_mode );
SetConsoleMode( hstdout, output_mode );

There are all kinds of horrible ways your application can terminate as well. It is up to you whether or not you wish to install various other handlers for the random abnormal exit conditions you may encounter. Windows is pretty good about cleaning up after your program, but not perfect.

For a full-window application, it is also useful to track whether or not the user has resized the window.

There are a gazillion other details to worry about, but that should get you started.

Finally, as an unrelated but useful note, it is nice to know whether your console application was run from Explorer or not.

Any thoughts on how to capture Ctrl+C and Ctrl+V from windows terminal so that application can manage these keystrokes instead? I noticed that when I do a Ctrl+C and Ctrl+V from,the console application it gets sent to the microsoft terminal Application instead of my console application running until the terminal.... I had a similar problem with ctrl-tab and shift-tab... — Bimo, Sep 10 '22 at 16:09
If you put the terminal into “raw mode” as I exampled above, all the automatic Ctrl+C, etc processing is disabled. I even turned off the “Quick Edit” stuff. Your application is only denied keystrokes hooked by the OS and the window manager (which on Windows is Explorer). — Dúthomhas, Sep 10 '22 at 16:57
Admittedly, parsing VT input sequences is more obnoxious than just getting a single key code from something like `getch()`. — Dúthomhas, Sep 10 '22 at 17:01
After some experimentation, I've determined that Windows terminal doesn't capture Ctrl-C unless the Mouse has text highlighted in the terminal, HOWEVER, it always captures Ctrl-V presumably so you can paste from windows clipboard at anytime... I had to change my mapping for editor paste to ctrl-B to work around this problem... I guess I can call Ctrl-B the Clipboard paste managed by my console app... — Bimo, Sep 10 '22 at 17:07
Argh, it looks like Windows Terminal trapping Ctrl+C and Ctrl+V is a known issue. I don’t have a presentable solution for you right now, but I suspect you may have to override the terminal window proc. Dang it just keeps getting uglier and uglier... (It works just fine on the Window Console...) — Dúthomhas, Sep 10 '22 at 17:22

score 0 · Answer 2 · answered Sep 10 '22 at 15:07

Here's a program that I used to figure out how to detect Shift+ArrowKey and Shift+Ctrl+ArrowKey. Just run the program and type the key combo to see the codes for it.


#include <windows.h>
#include <conio.h>
#include <stdio.h>

using namespace std;

int main()
{
    int shiftkey;
    int i1;
    int i2;


    while(1) {
        i1 = (int)getch();
        shiftkey = ((GetKeyState(VK_SHIFT) & 0x8000) == 0x8000);

        printf("shift:%d i1:%02x ", shiftkey, i1);
        if (i1 == 0xe0) {
            i2 = (int)getch();
            printf(" i2:%02x", i2);
        }
        else if (i1 == 0) {
            i2 = (int)getch();
            printf(" i2:%02x", i2);
        }
        printf("\n");
    }

    return 0;
}

Bimo · Answer 3 · 2022-09-10T16:07:21.603

#define KEY_BACKSPACE        0x101
#define KEY_ESC              0x102
#define KEY_INS              0x103
#define KEY_DEL              0x104
#define KEY_LEFT             0x105
#define KEY_RIGHT            0x106
#define KEY_UP               0x107
#define KEY_DOWN             0x108
#define KEY_HOME             0x109
#define KEY_END              0x10A
#define KEY_ENTER            0x10B
#define KEY_TAB              0x10C
#define KEY_PGUP             0x10D
#define KEY_PGDN             0x10E

#define KEY_CTRL_LEFT        0x10F
#define KEY_CTRL_RIGHT       0x110
#define KEY_CTRL_UP          0x111
#define KEY_CTRL_DOWN        0x112
#define KEY_CTRL_HOME        0x113
#define KEY_CTRL_END         0x114
#define KEY_CTRL_TAB         0x115

#define KEY_SHIFT_LEFT       0x116
#define KEY_SHIFT_RIGHT      0x117
#define KEY_SHIFT_UP         0x118
#define KEY_SHIFT_DOWN       0x119
#define KEY_SHIFT_PGUP       0x11A
#define KEY_SHIFT_PGDN       0x11B
#define KEY_SHIFT_HOME       0x11C
#define KEY_SHIFT_END        0x11D
#define KEY_SHIFT_TAB        0x11E


#define KEY_SHIFT_CTRL_LEFT  0x11F
#define KEY_SHIFT_CTRL_RIGHT 0x120
#define KEY_SHIFT_CTRL_UP    0x121
#define KEY_SHIFT_CTRL_DOWN  0x122
#define KEY_SHIFT_CTRL_HOME  0x123
#define KEY_SHIFT_CTRL_END   0x124


#define KEY_F1                0x125
#define KEY_F3                0x126
#define KEY_F5                0x127

#define KEY_SHIFT_F1          0x200
#define KEY_SHIFT_F3          0x201
#define KEY_SHIFT_F5          0x202

#define KEY_ALT_LEFT          0x203
#define KEY_ALT_RIGHT         0x204
#define KEY_ALT_UP            0x205
#define KEY_ALT_DOWN          0x206
#define KEY_ALT_HOME          0x207
#define KEY_ALT_END           0x208
#define KEY_ALT_TAB           0x209
#define KEY_ALT_PGUP          0x20A
#define KEY_ALT_PGDN          0x20B

#define KEY_SHIFT_ALT_LEFT    0x20C
#define KEY_SHIFT_ALT_RIGHT   0x20D
#define KEY_SHIFT_ALT_UP      0x20E
#define KEY_SHIFT_ALT_DOWN    0x20F
#define KEY_SHIFT_ALT_HOME    0x210
#define KEY_SHIFT_ALT_END     0x211
#define KEY_SHIFT_ALT_TAB     0x212
#define KEY_SHIFT_ALT_PGUP    0x213
#define KEY_SHIFT_ALT_PGDN    0x214

#define KEY_SHIFT_INS         0x221
#define KEY_SHIFT_DEL         0x222

#define KEY_SHIFT_CTRL_PGUP   0x223
#define KEY_SHIFT_CTRL_PGDN   0x224
#define KEY_CTRL_PGUP         0x225
#define KEY_CTRL_PGDN         0x226
#define KEY_SHIFT_CTRL_INS    0x227
#define KEY_CTRL_INS          0x228
#define KEY_SHIFT_CTRL_DEL    0x229
#define KEY_CTRL_DEL          0x22A
#define KEY_SHIFT_ESC         0x22B
#define KEY_SHIFT_ENTER       0x22C

#define KEY_UNKNOWN           0xFFF

#if defined(WIN32) || defined(_WIN64)

#include "windows.h"
#include "conio.h"

int getkey__windows_console_app() {
    int c1;
    int c2;
    int shift;

    c1     = (int)getch();
    shift  = ((GetKeyState(VK_SHIFT) & 0x8000) == 0x8000);

    if (c1 == 0) {
        c2     = (int)getch();
        switch(c2) {
            case 0x3b: return (shift) ? KEY_SHIFT_F1          : KEY_F1;
            case 0x3d: return (shift) ? KEY_SHIFT_F3          : KEY_F3;
            case 0x3f: return (shift) ? KEY_SHIFT_F5          : KEY_F5;

            case 0x9b: return (shift) ? KEY_SHIFT_ALT_LEFT    : KEY_ALT_LEFT;
            case 0x9d: return (shift) ? KEY_SHIFT_ALT_RIGHT   : KEY_ALT_RIGHT;
            case 0x98: return (shift) ? KEY_SHIFT_ALT_UP      : KEY_ALT_UP;;
            case 0xa0: return (shift) ? KEY_SHIFT_ALT_DOWN    : KEY_ALT_DOWN;
            case 0x99: return (shift) ? KEY_SHIFT_ALT_PGUP    : KEY_ALT_PGUP;
            case 0xa1: return (shift) ? KEY_SHIFT_ALT_PGDN    : KEY_ALT_PGDN;
            case 0x97: return (shift) ? KEY_SHIFT_ALT_HOME    : KEY_ALT_HOME;
            case 0x9F: return (shift) ? KEY_SHIFT_ALT_END     : KEY_ALT_END;

            default:   return KEY_UNKNOWN;
        }
    }
    else if (c1 == 0xe0) {
        c2 = (int)getch();

        switch(c2)  {
            case 0x4b: return (shift) ? KEY_SHIFT_LEFT        : KEY_LEFT;
            case 0x4d: return (shift) ? KEY_SHIFT_RIGHT       : KEY_RIGHT;
            case 0x48: return (shift) ? KEY_SHIFT_UP          : KEY_UP;
            case 0x50: return (shift) ? KEY_SHIFT_DOWN        : KEY_DOWN;
            case 0x49: return (shift) ? KEY_SHIFT_PGUP        : KEY_PGUP;
            case 0x51: return (shift) ? KEY_SHIFT_PGDN        : KEY_PGDN;
            case 0x52: return (shift) ? KEY_SHIFT_INS         : KEY_INS;
            case 0x53: return (shift) ? KEY_SHIFT_DEL         : KEY_DEL;
            case 0x47: return (shift) ? KEY_SHIFT_HOME        : KEY_HOME;
            case 0x4f: return (shift) ? KEY_SHIFT_END         : KEY_END;

            case 0x73: return (shift) ? KEY_SHIFT_CTRL_LEFT   : KEY_CTRL_LEFT;
            case 0x74: return (shift) ? KEY_SHIFT_CTRL_RIGHT  : KEY_CTRL_RIGHT;
            case 0x8d: return (shift) ? KEY_SHIFT_CTRL_UP     : KEY_CTRL_UP;
            case 0x91: return (shift) ? KEY_SHIFT_CTRL_DOWN   : KEY_CTRL_DOWN;
            case 0x86: return (shift) ? KEY_SHIFT_CTRL_PGUP   : KEY_CTRL_PGUP;
            case 0x76: return (shift) ? KEY_SHIFT_CTRL_PGDN   : KEY_CTRL_PGDN;
            case 0x92: return (shift) ? KEY_SHIFT_CTRL_INS    : KEY_CTRL_INS;
            case 0x93: return (shift) ? KEY_SHIFT_CTRL_DEL    : KEY_CTRL_DEL;
            case 0x77: return (shift) ? KEY_SHIFT_CTRL_HOME   : KEY_CTRL_HOME;
            case 0x75: return (shift) ? KEY_SHIFT_CTRL_END    : KEY_CTRL_END;

            default:   return KEY_UNKNOWN;
        }

    }
    else {
        switch(c1) {
            case 0x08: return KEY_BACKSPACE;
            case 0x1b: return (shift) ? KEY_SHIFT_ESC   : KEY_ESC;
            case 0x0d: return (shift) ? KEY_SHIFT_ENTER : KEY_ENTER;
            case 0x09: return (shift) ? KEY_SHIFT_TAB   : KEY_TAB;

            default: return c1;
        }

    }

}
#endif

Code-only answer are fairly useless. At a minimum an answer needs to include the following: `1` An explanation of the core issue, and `2` How the proposed solution addresses the issue. As posted, I don't even know whether this even is an answer. Probably a good idea to take the [tour], since you haven't. — IInspectable, Sep 10 '22 at 15:48
actually, i had a small mistake that i fixed in above code already... moved the shift to after first getch... — Bimo, Sep 10 '22 at 16:11
Its very self-explanator... all it does is checks the shift key after the first getch and then adds that shift flag inside of case. to distinguish... this is because getch doesn't detech shift for extended keyboard characters.. — Bimo, Sep 10 '22 at 16:15
*"Self-explanatory"* code can explain the "how", not the "why". The latter is **far** more valuable. — IInspectable, Sep 11 '22 at 16:39

Detect "Shift + Arrow Key" in Windows C++ Console Application (win32)

3 Answers3