Mouse input differences when using ENABLE_VIRTUAL_TERMINAL_INPUT

### Windows Terminal version

1.16.10261.0

### Windows build number

Microsoft Windows [Version 10.0.19045.2846]

### Other Software

_No response_

### Steps to reproduce

Compile this C code as a console application, and try it in both conhost and Windows Terminal. (Move the mouse over the window.)

```
#include
#include
#include

int main(void)
{
/* Get handles for stdin and stdout */
HANDLE stdinH = GetStdHandle( STD_INPUT_HANDLE );
HANDLE stdoutH = GetStdHandle( STD_OUTPUT_HANDLE );
if (!stdinH || !stdoutH
|| (stdinH == INVALID_HANDLE_VALUE )
|| (stdoutH == INVALID_HANDLE_VALUE ))
{
return 1;
}

/* Set console output mode */
DWORD outMode;
if (!GetConsoleMode(stdoutH, &outMode))
{
return 2;
}
DWORD newMode = outMode;
newMode |= ENABLE_PROCESSED_OUTPUT | ENABLE_VIRTUAL_TERMINAL_PROCESSING;
newMode &= ~ENABLE_WRAP_AT_EOL_OUTPUT;
newMode &= ~DISABLE_NEWLINE_AUTO_RETURN;
newMode &= ~ENABLE_LVB_GRID_WORLDWIDE;
if (!SetConsoleMode(stdoutH, newMode))
{
return 3;
}

/* Set console input mode */
DWORD inMode;
if (!GetConsoleMode(stdinH, &inMode))
{
SetConsoleMode(stdoutH, outMode);
return 4;
}
newMode = inMode;
newMode &= ~ENABLE_ECHO_INPUT;
newMode &= ~ENABLE_INSERT_MODE;
newMode &= ~ENABLE_LINE_INPUT;
newMode |= ENABLE_MOUSE_INPUT;
newMode &= ~ENABLE_PROCESSED_INPUT;
newMode &= ~ENABLE_QUICK_EDIT_MODE;
newMode |= ENABLE_EXTENDED_FLAGS; /* Needed when changing _QUICK_EDIT_MODE */
newMode |= ENABLE_WINDOW_INPUT;
newMode |= ENABLE_VIRTUAL_TERMINAL_INPUT;
//newMode &= ~ENABLE_VIRTUAL_TERMINAL_INPUT;
if (!SetConsoleMode(stdinH, newMode))
{
SetConsoleMode(stdoutH, outMode);
return 5;
}

/* Enable keypad application mode */
printf("\x1b=");

while (1)
{
DWORD numRead;
INPUT_RECORD rec;
BOOL successB = ReadConsoleInput( stdinH, &rec, 1, &numRead );
if ( !successB || (numRead != 1) )
{
break;
}

if (rec.EventType == KEY_EVENT)
{
char c = rec.Event.KeyEvent.uChar.AsciiChar;
printf(" KEY %s ", rec.Event.KeyEvent.bKeyDown ? "down" : "up ");
if (isprint(c))
{
printf("'%c'\n", c);
}
else
{
printf("\\x%02x'\n", (int)c);
}

/* Exit when X pressed */
if ((c == 'x') || (c == 'X'))
{
break;
}
}
else if (rec.EventType == MOUSE_EVENT)
{
printf(" MOUSE dwMousePosition=%d,%d dwButtonState=0x%08x dwControlKeyState=0x%08x dwEventFlags=0x%08x\n",
(int)rec.Event.MouseEvent.dwMousePosition.X,
(int)rec.Event.MouseEvent.dwMousePosition.Y,
(int)rec.Event.MouseEvent.dwButtonState,
(int)rec.Event.MouseEvent.dwControlKeyState,
(int)rec.Event.MouseEvent.dwEventFlags );
}
}

/* Clean up */
SetConsoleMode(stdoutH, outMode);
SetConsoleMode(stdinH, inMode);

return 0;
}
```

### Expected Behavior

The same behaviour in both conhost and Windows Terminal.

### Actual Behavior

In Windows Terminal, I receive mouse input only as virtual terminal input sequences. In conhost, I receive mouse input only as MOUSE_EVENT INPUT_RECORDs.

My guess is this is an intentional difference rather than a bug, but I wanted to ask some questions. I would like my program to work the same whether run in Windows Terminal or conhost. I would like to enable ENABLE_VIRTUAL_TERMINAL_INPUT to get VT sequences for key presses at least. Here are my questions:

1. Is it possible to get the same mouse input behaviour (either VT sequences or input records) in both conhost and Windows Terminal, with ENABLE_VIRTUAL_TERMINAL_INPUT enabled? If so how? (Maybe a setting for Windows Terminal that I couldn't find?)
2. Where can I find documentation of the mouse input VT sequences?

Thanks

Start by compiling and running the provided C sample with ENABLE_VIRTUAL_TERMINAL_INPUT in both conhost and Windows Terminal, comparing the mouse input received. Read the console input-mode behavior and the mouse input VT sequence documentation; the issue is resolved when the cross-host behavior and documented way to obtain the desired input are established.

Written by the indexing model from the issue text.