Classic VB Corner

Stuffing the Console Keyboard Buffer

Console applications are alive and well in Administrator Land. Here’s how your console application can leave instructions for the command processor upon your exit.

While the thought of a “DOS box” may send shudders through many a soul, folks who are tasked with administering machines are still spending lots of time there. The simple truth is, console applications are hellaciously efficient for all sorts of repetitive tasks. I will confess up front that I still write quite a number of them myself, with the help of vbAdvance and my own Console module that offers drop-in support for most of the unique needs of console apps.

Occasionally, you want to tell the command processor to do something after your application ends. In this column, I’m going to show you how to stuff the console keyboard buffer, to achieve this goal. Specifically, I wanted a graphical version of the dirt-standard CD (change directory) command. I hate typing out full paths. So, as a bonus, we’ll build a new CDW command that provides a Select Folder dialog before performing this trick.

Here’s the basic flow of execution, after the command line processing and so on. The BrowseForFolderByPath function simply displays the dialog produced by SHBrowseForFolder, allowing the user (me!) to select which directory to change to:

Public Sub Main()
   Dim Path As String
   Dim drive As String
   Dim keys As String
   ' Get user pick, and act on it...
   Path = BrowseForFolderByPath(CurDir, Con.hWnd, _
      "Select the folder you'd like to make current.", True, True)
   If Len(Path) Then
      ' Change drive, if necessary...
      drive = Left$(Path, 2)
      If InStr(UCase$(CurDir), UCase$(drive)) <> 1 Then
         keys = drive & vbCr
      End If
      ' Change path...
      keys = keys & "cd " & CleanPath(Path) & vbCr
      Call KeyStuff(keys)
      Con.SetFocus True
      Con.WriteLine "Action cancelled.", , conStandardError
      If Con.Compiled Then
         Call ExitProcess(1)
      End If
   End If
End Sub

If a good path is returned, I then break it into drive and path portions, each piece followed by a carriage return to effectively produce two distinct commands. Then, it’s simply a matter of stuffing the keyboard buffer, with that call to my own KeyStuff routine, and exiting the program. Then, it's simply a matter of stuffing the keyboard buffer, with that call to my own KeyStuff routine, and exiting Sub Main normally. However, if the user selected Cancel on the folder selection dialog, ExitProcess is called, returning an error code to the calling process.

Public Function KeyStuff(ByVal keys As String) As Long
   Dim hStdIn As Long
   Dim InputRec() As InputKeyRecord
   Dim EventsWritten As Long
   Dim i As Long
   Dim nRet As Integer
   ' Bail if nothing came in.
   If Len(keys) = 0 Then Exit Function
   ' Get handle to console input.
   hStdIn = GetStdHandle(STD_INPUT_HANDLE)
   ' Pop off keys one at a time.
   ReDim InputRec(0 To (Len(keys) * 2) - 1)
   For i = 0 To UBound(InputRec) Step 2
      With InputRec(i)
         .EventType = KEY_EVENT
         .wRepeatCount = 1
         .bKeyDown = 1  'True
         .uChar = Asc(Mid$(keys, ((i / 2) + 1), 1))
         ' vKeyCode is in lo-order byte.
         nRet = VkKeyScan(.uChar)
         .wVirtualKeyCode = ByteLo(nRet)
         ' Shift state is in hi-order byte.
         nRet = ByteHi(nRet)
         If nRet And 1 Then
            ' Shift key (either) pressed
            .dwControlKeyState = _
               .dwControlKeyState Or SHIFT_PRESSED
         End If
         If nRet And 2 Then
            ' Control key (either) pressed
            .dwControlKeyState = _
               .dwControlKeyState Or RIGHT_CTRL_PRESSED
         End If
         If nRet And 4 Then
            ' Alt key (either) pressed
            .dwControlKeyState = _
               .dwControlKeyState Or RIGHT_ALT_PRESSED
         End If
         .wVirtualScanCode = MapVirtualKey(.wVirtualKeyCode, 0)
      End With
      ' Corresponding key release
      InputRec(i + 1) = InputRec(i)
      InputRec(i + 1).bKeyDown = False
   Next i
   ' Stuff the buffer, and return number of events written.
   nRet = WriteConsoleInput( _
      hStdIn, InputRec(0), UBound(InputRec) + 1, EventsWritten)
   KeyStuff = EventsWritten
   ' Clean up.
   Call CloseHandle(hStdIn)
End Function

The general idea is to build up a series of KEY_EVENT_RECORD structures to pass to the WriteConsoleInput API function. We’ll add two records per character, one record for each key down action and a corresponding record for the related key up action. That’s why the loop above has a Step 2 iterator, as we add the second record at the end of the loop, and it’s identical in all regards except for the KeyDown element.

With each character we want to send, VkKeyScan is called to separate the character into a virtual key code (the low byte of VkKeyScan’s return) and its shift state (the high byte) based on the current keyboard. The shift state then needs to be translated a bit, as VkKeyScan returns very generalized information, but the dwControlKeyState can be highly specific in differentiating specific shift keys. This is just a straight-forward housekeeping chore, really.

Finally, we make the call to WriteConsoleInput, passing our array of input structures. The “trick” to this working is that our application exits at this point, without ever attempting to read any further input from the console. So the stuffed input is left waiting for the parent process upon our exit.

If you write console apps, perhaps this will add one more tool to your arsenal. You can download the complete KeyStuff sample from my Web site, of course. It includes a compiled copy of the CDW command line utility, so even if you’re not still using VB6 you might still want to grab the download.

About the Author

Karl E. Peterson wrote Q&A, Programming Techniques, and various other columns for VBPJ and VSM from 1995 onward, until Classic VB columns were dropped entirely in favor of other languages. Similarly, Karl was a Microsoft BASIC MVP from 1994 through 2005, until such community contributions were no longer deemed valuable. He is the author of's new Classic VB Corner column. You can contact him through his Web site if you'd like to suggest future topics for this column.

comments powered by Disqus


  • GitHub Copilot for Azure Gets Preview Glitches

    This reporter, recently accepted to preview GitHub Copilot for Azure, has thus far found the tool to be, well, glitchy.

  • New .NET 9 Templates for Blazor Hybrid, .NET MAUI

    Microsoft's fifth preview of .NET 9 nods at AI development while also introducing new templates for some of the more popular project types, including Blazor Hybrid and .NET MAUI.

  • What's Next for ASP.NET Core and Blazor

    Since its inception as an intriguing experiment in leveraging WebAssembly to enable dynamic web development with C#, Blazor has evolved into a mature, fully featured framework. Integral to the ASP.NET Core ecosystem, Blazor offers developers a unique combination of server-side rendering and rich client-side interactivity.

  • Nearest Centroid Classification for Numeric Data Using C#

    Here's a complete end-to-end demo of what Dr. James McCaffrey of Microsoft Research says is arguably the simplest possible classification technique.

  • .NET MAUI in VS Code Goes GA

    Visual Studio Code's .NET MAUI workload, which evolves the former Xamarin.Forms mobile-centric framework by adding support for creating desktop applications, has reached general availability.

Subscribe on YouTube