APIs

• .NET — System.Console
• Win32 — wincon.h (by topic)
• DOS — conio.h
• Win32 undocumented APIs (search for "internal list")

Terminology

• console — Each process can only have one console. Each console can be shared by multiple processes. (AllocConsole/AttachConsole/FreeConsole)
• screen buffer — Multiple buffers that can be rapidly changed between, and modified in the background. (SetConsoleActiveScreenBuffer/CreateConsoleScreenBuffer)
• screen buffer window — A view of a subset of a screen buffer.
• alias — a native version of AutoHotkey's hotstrings

Distinctions

• There are several ways to build an application that is primarily console-based:
  • compile as a Win32 console app, GetConsoleWindow(), and go nuts
    • The primary benefit this gives you is that your app can be started within an existing cmd.exe (thus can have its stdin/stdout redirected), and it can be started from full-screen text-only mode as well.
    • It can also access the Win32 API, but won't be able to run under 16-bit DOS.
  • compile as a Win32 GUI app, AllocConsole(), and go nuts
    • the benefit of this option is that it allows more flexibility with GUI APIs
  • compile as a 16-bit DOS application
    • downsides: can't call win32 GUI API; upsides: can run outside of Windows too
    • modern versions of Visual Studio can't build 16-bit apps. Visual C++ v5.1 through v8.0 were able to build 16-bit apps.
• There are two modes that any Win32 console can be viewed in (alt-enter to toggle). It's important to be aware that there can be differences in rendering between the two.
  • windowed
    • implemented within csrss.exe (which runs with system privileges, so it's subject to heavy security considerations [1] [2] [3])
  • full-screen text-only
    • the hardware VGA card does the rendering (though Windows doesn't restore all undocumented settings when switching into windowed mode and then back [1] [2])
    • not available from Vista onwards

HOWTO (both windowed and text-only modes)

• Mouse input:
  (in text-only mode, there's a little square mouse that sends the exact same events as in GUI mode... remember edit.com?)
  1. SetConsoleMode(), +ENABLE_MOUSE_INPUT, –ENABLE_QUICK_EDIT_MODE (to modify quick-edit, you have to use an input buffer handle)
  2. ReadConsoleInput() to get the mouse events (.NET definitions: [1] [2])
     (the event data isn't thoroughly documented. Some people have posted the results of their experimentation: [1])
• Change the palette:
  • SetConsolePalette() [1] [2] (undocumented, though its data structure is very similar to Vista's official CONSOLE_SCREEN_BUFFER_INFOEX)
  • SetConsoleScreenBufferInfoEx() (Vista and later)
• Double-buffering:
  • rapid SetConsoleActiveScreenBuffer() (is this is page-swapping?)
  • WriteConsoleOutput() from a draw-buffer to the view-buffer (memcpy)
  • how do know when the vertical interval happens in full-screen mode?

HOWTO (windowed mode only)

• Change font:
  • SetCurrentConsoleFontEx
  • There is a documented back door for enabling more fonts. However, there are very few fonts that work well.
• Hide: ShowWindow(hwndConsole, SW_HIDE);
• Transparency: WS_EX_LAYERED + WS_EX_TRANSPARENT + SetLayeredWindowAttributes()
• Always on top: SetWindowPos(hwnd, HWND_TOPMOST, ...) (WS_EX_TOPMOST doesn't work)
• Change the icon:: SetConsoleIcon() (undocumented). Places to get icon-handles from:
  • System.Drawing.Icon.Handle — the managed C# way to get embedded resources (get it via "((Icon)resource_manager.GetObject(resname))")
  • LoadIcon(GetModuleHandle(null), ...) — the unmanaged way to get embedded resources
  • ExtractIconEx() from an .exe (possibly System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName)
• Graphics: GetDC(GetConsoleWindow()) does work, but it seems like it definitely crosses the line of what's becoming totally pointless

Internal details

• window class = ConsoleWindowClass, obviously
• winsrv.dll — loaded into csrss.exe
  • ConsoleWindowProc(), handles console window messages
  • for certain operations, it will create a new thread inside the console creator's process, and inject console.dll into that process (eg. make the Properties dialog appear)
  • after the Properties dialog closes, to send the data back to csrss, it uses WM_USER+201
• console settings are saved in HKEY_CURRENT_USER\Console\, with sub-keys for "Apply to current window only" settings
• there are some new security restrictions in Vista, but cssrs.exe has a special exception

Speed/performance

• Numerous people report that in windowed-mode, the screen-refresh is pretty low, on the order of ~10fps. In full-screen mode, since that's hardware-based, it's MUCH faster.
• As such, people sometimes resort to doing their own GUI functions to emulate a console. (contest)

Third-party .NET wrappers

• WinConsole
• ConsolePasswordInput — demonstrates how to use the blocking ReadConsoleInput(), among several other things
• JConsole

Third-party C wrappers

• Console2