static extern int Escape(IntPtr hdc, int nEscape, int cbInput,

static extern int ExtEscape(IntPtr hdc, int nEscape, int cbInput,

    Public Shared Function ExtEscape(ByVal hdc As IntPtr, ByVal nEscape As Integer, ByVal cbInput As Integer, ByVal lpszInData As String, ByVal cbOutput As Integer, ByRef lpszOutData As IntPtr) As Integer

    //Here only to catch errors where input is not a number (EXIT, for example, is a string)        

Return the Input Panel button to its visible state.

Hide the Input Panel button.

A request to display the input panel. Any pending SIP_DOWN requests are ignored.

A request to hide the input panel. When this value is used, a timer is set and the input panel is lowered only after the timer message is received. This approach prevents the input panel from flashing when one control requests SIP_DOWN and another control immediately requests SIP_UP.

forces the input panel to be hidden immediately, without setting a timer. If you want the input panel hidden and are sure there will be no SIP_UP requests — for example, because your application is a full-screen game — use this value.

tells the system to ignore any pending down requests. That is, if SHSipPreference is called with the SIP_DOWN flag, the system sets a timer and after the timer fires, the input panel is lowered. However, if you call SIP_UNCHANGED before the timer fires, then the input panel will stay in its current location.

    // http://pinvoke.net/default.aspx/kernel32/FlushConsoleInputBuffer.html

    static extern bool FlushConsoleInputBuffer(

        IntPtr hConsoleInput

    // http://pinvoke.net/default.aspx/kernel32/GetNumberOfConsoleInputEvents.html

    static extern bool GetNumberOfConsoleInputEvents(

        IntPtr hConsoleInput,

    // http://pinvoke.net/default.aspx/kernel32/PeekConsoleInput.html

    static extern bool PeekConsoleInput(

        IntPtr hConsoleInput,

        [Out] INPUT_RECORD[] lpBuffer,

        IntPtr hConsoleInput,

    // http://pinvoke.net/default.aspx/kernel32/ReadConsoleInput.html

    [DllImport("kernel32.dll", EntryPoint = "ReadConsoleInputW", CharSet = CharSet.Unicode)]

    static extern bool ReadConsoleInput(

        IntPtr hConsoleInput,

        [Out] INPUT_RECORD[] lpBuffer,

    // http://pinvoke.net/default.aspx/kernel32/WriteConsoleInput.html

    static extern bool WriteConsoleInput(

        IntPtr hConsoleInput,

        INPUT_RECORD[] lpBuffer,

    public struct INPUT_RECORD

        uint nInBufferSize,                            // input buffer size

       Dim bBuffer As Byte       ' Input buffer.

static extern bool FlushConsoleInputBuffer(IntPtr hConsoleInput);

This code segment will allow you to grab the Console input buffer using CreateFileW and Flush the input using FlushConsoleInputBuffer

  private static extern bool FlushConsoleInputBuffer(IntPtr hConsoleInput);

  private static extern IntPtr GetInputBuffer(

  //C# method to flush console input

    //"CONIN$" will allow you to grab the input buffer regardless if it is being redirected.

    IntPtr inBuffer = GetInputBuffer("CONIN$", 0x40000000 | 0x80000000,

    //throw an error if the input buffer is not obtained

    FlushConsoleInputBuffer(inBuffer);

    /* Retrieves the input code page used by the console associated with the calling process.

        A console uses its input code page to translate keyboard input into the corresponding character value. */

System.Console.InputEncoding.CodePage

    ENABLE_PROCESSED_INPUT = &H1

    ENABLE_LINE_INPUT = &H2

    ENABLE_ECHO_INPUT = &H4

    ENABLE_WINDOW_INPUT = &H8

    ENABLE_MOUSE_INPUT = &H10

    /// <returns>The long path.  Null or empty if the input is null or empty.</returns>

/// The ToLongName function retrieves the long file name form of a specified short input path

/// The ToLongPathNameToShortPathName function retrieves the short path form of a specified long input path

      public IntPtr hStdInput;

const int STD_INPUT_HANDLE = -10;

       /* Reads data from the specified console input buffer without removing it from the buffer. */

    [DllImport("kernel32.dll", EntryPoint = "PeekConsoleInputW", CharSet = CharSet.Unicode, SetLastError = true)]

    internal static extern BOOL PeekConsoleInput(

        IntPtr hConsoleInput,

        [MarshalAs(UnmanagedType.LPArray), Out] INPUT_RECORD[] lpBuffer,

[DllImport("kernel32.dll",EntryPoint="ReadConsoleInputW",CharSet=CharSet.Unicode)]

static extern bool ReadConsoleInput(

        IntPtr hConsoleInput,

        [Out] INPUT_RECORD [] lpBuffer,

• INPUT_RECORD
Used to report input events in the console input buffer
10/29/2012 4:50:51 PM - -87.68.67.5

        ENABLE_PROCESSED_INPUT = 0x0001,

        ENABLE_LINE_INPUT = 0x0002,

        ENABLE_ECHO_INPUT = 0x0004,

        ENABLE_WINDOW_INPUT = 0x0008,

        ENABLE_MOUSE_INPUT = 0x0010,

    private enum ConsoleInputModes : uint

        ENABLE_PROCESSED_INPUT = 0x0001,

        ENABLE_LINE_INPUT = 0x0002,

        ENABLE_ECHO_INPUT = 0x0004,

        ENABLE_WINDOW_INPUT = 0x0008,

        ENABLE_MOUSE_INPUT = 0x0010,

    ENABLE_PROCESSED_INPUT = &H1

    ENABLE_LINE_INPUT = &H2

    ENABLE_ECHO_INPUT = &H4

    ENABLE_WINDOW_INPUT = &H8

    ENABLE_MOUSE_INPUT = &H10

    /* Writes data directly to the console input buffer. */

    [DllImport("kernel32.dll", EntryPoint = "WriteConsoleInputW", CharSet = CharSet.Unicode, SetLastError = true)]

    internal static extern BOOL WriteConsoleInput(

        IntPtr hConsoleInput,

        [MarshalAs(UnmanagedType.LPArray), In] INPUT_RECORD[] lpBuffer,

/// If there are no arguments in the path, the function returns a pointer to the end of the input string.

''' If there are no arguments in the path, the function returns a pointer to the end of the input string.

This is similar, but not identical, to Path.GetFileName. If the input string ends with a directory, the directory is returned rather than nothing; for example, "C:\foo\" becomes "foo\", "C:" stays "C:".

        /// <summary> 2357 - Could not determine the type of input. </summary>

        /// <summary> 2662 - There is no DFS name whose entry path matches the input Entry Path. </summary>

    public static PropertyKey WPD_PROPERTY_MTP_EXT_OPERATION_CODE = new PropertyKey(0x4d545058, 0x1a2e, 0x4106, 0xa3, 0x57, 0x77, 0x1e, 0x8, 0x19, 0xfc, 0x56, 1001);    // [ VT_UI4 ] : Input param which identifies the vendor-extended MTP operation code

    public static PropertyKey WPD_PROPERTY_MTP_EXT_OPERATION_PARAMS = new PropertyKey(0x4d545058, 0x1a2e, 0x4106, 0xa3, 0x57, 0x77, 0x1e, 0x8, 0x19, 0xfc, 0x56, 1002);    // [ VT_UNKNOWN ] : Input IPortableDevicePropVariantCollection (of VT_UI4) specifying the params for the vendor operation

    public static PropertyKey WPD_PROPERTY_MTP_EXT_TRANSFER_TOTAL_DATA_SIZE = new PropertyKey(0x4d545058, 0x1a2e, 0x4106, 0xa3, 0x57, 0x77, 0x1e, 0x8, 0x19, 0xfc, 0x56, 1007);    // [ VT_UI8 ] : Input (when writing data) or output (when reading data) param which specifies total data size in bytes (excluding any overhead)

    public static PropertyKey WPD_PROPERTY_MTP_EXT_TRANSFER_NUM_BYTES_TO_READ = new PropertyKey(0x4d545058, 0x1a2e, 0x4106, 0xa3, 0x57, 0x77, 0x1e, 0x8, 0x19, 0xfc, 0x56, 1008); // [ VT_UI4 ] : Input param specifying the number of bytes to read from device in a series of read calls

    public static PropertyKey WPD_PROPERTY_MTP_EXT_TRANSFER_NUM_BYTES_TO_WRITE = new PropertyKey(0x4d545058, 0x1a2e, 0x4106, 0xa3, 0x57, 0x77, 0x1e, 0x8, 0x19, 0xfc, 0x56, 1010); // [ VT_UI4 ] : Input specifying the number of bytes to send to device in a series of write calls

    public const int SEE_MASK_WAITFORINPUTIDLE  = 0x02000000;

    public const int SEE_MASK_WAITFORINPUTIDLE  = 0x02000000;

        /// Name translation: Input name mapped to more than one output name.

        /// Name translation: Input name found, but not the associated output format.

        /// User input required for operation to succeed

        /// Common prefix is input moniker

        /// An outgoing call cannot be made since the application is dispatching an input-synchronous call.

        public const int RPC_E_CANTCALLOUT_ININPUTSYNCCALL = (int)(0x8001010D - 0x100000000);

        public const int OSS_MORE_INPUT = (int)(0x80093004 - 0x100000000);

private const UInt32 WM_INPUTLANGCHANGE    = 0x0051;

private const UInt32 WM_INPUTLANGCHANGEREQUEST = 0x0050;

   WM_INPUTLANGCHANGE = &H51

   WM_INPUTLANGCHANGEREQUEST = &H50

WM_INPUTLANGCHANGEREQUEST equ 050h

WM_INPUTLANGCHANGE    equ 051h

    /// Use to determine the amount of data pending in the network's input buffer that can be read from socket s.

        /// Use to determine the amount of data pending in the network's input buffer that can be read from socket s.

        /// but is not removed from the input queue.

static extern int GdiplusStartup(out IntPtr token, ref StartupInput input,

ByRef input As StartupInput, ByRef output As StartupOutput) As Integer

                       ByRef input As GdipStartupInput, _

struct StartupInput

->If there are any bytes in the input buffer, ReadFile returns immediately with the bytes in the buffer.

->If there are no bytes in the input buffer, ReadFile waits until a byte arrives and then returns immediately.

    internal sbyte EofChar;          // end of input character

    struct DELTA_INPUT

Structure DELTA_INPUT

    Private Shared Function ConvertFileTimeToDateTime(input As FILETIME) As DateTime

    Dim longTime As ULong = (CType(input.dwHighDateTime, ULong) << 32) Or input.dwLowDateTime

    internal struct HARDWAREINPUT

Structure HARDWAREINPUT

   internal enum INPUT_TYPE : uint {

      INPUT_MOUSE = 0,

      INPUT_KEYBOARD = 1,

      INPUT_HARDWARE = 2

Structure INPUT_TYPE

    public struct INPUT_RECORD

  Public Structure INPUT_RECORD

  Public Enum InputEventTypes

   internal enum INPUT_TYPE : uint {

      INPUT_MOUSE = 0,

      INPUT_KEYBOARD = 1,

      INPUT_HARDWARE = 2

Structure INPUT_TYPE

    internal struct KEYBDINPUT

Structure KEYBDINPUT

        ///Input Method Editor (IME) Kana mode

        ///The VK_PACKET key is the low word of a 32-bit Virtual Key value used for non-keyboard input methods. For more information,

        ///see Remark in KEYBDINPUT, SendInput, WM_KEYDOWN, and WM_KEYUP

    struct LASTINPUTINFO

        public static readonly int SizeOf = Marshal.SizeOf(typeof(LASTINPUTINFO));

    Structure LASTINPUTINFO

   type LastInputInfo = {

    internal struct MOUSEINPUT

Structure MOUSEINPUT

    ''' You can specify an index on input to indicate the initial filter description and filter

    ''' When the dialog box returns, it sets these flags to indicate the user's input.

Structure RAWINPUTMOUSE

/// <summary>Value type for raw input devices.</summary>

public struct RAWINPUTDEVICE

    /// <summary>Top level collection Usage page for the raw input device.</summary>

    /// <summary>Top level collection Usage for the raw input device. </summary>

    public RawInputDeviceFlags Flags;

''' <summary>Value type for raw input devices.</summary>

Public Structure RAWINPUTDEVICE

    ''' <summary>Top level collection Usage page for the raw input device.</summary>

    ''' <summary>Top level collection Usage for the raw input device. </summary>

    Public Flags As RawInputDeviceFlags

HIDUsagePage, HIDUsage, RawInputDeviceFlags

    /// Value type for a raw input header.

    public struct RAWINPUTHEADER

        /// <summary>Type of device the input is coming from.</summary>

        public RawInputType Type;

    ''' Value type for a raw input header.

    Public Structure RawInputHeader

        ''' <summary>Type of device the input is coming from.</summary>

        Public Type As RawInputType

    /// Value type for raw input from a HID.

    public struct RAWINPUTHID

Structure RAWINPUTHID

    /// Value type for raw input from a keyboard.

    ''' Value type for raw input from a keyboard.

Structure RAWINPUTMOUSE

  public uint dwBytesRecorded; // used for input only

Have a look at SendInput for an example of where these constants are used.

   // For use with the INPUT struct, see SendInput for an example

   public const int INPUT_MOUSE     = 0;

   public const int INPUT_KEYBOARD  = 1;

   public const int INPUT_HARDWARE  = 2;

    ' For use with the INPUT struct, see SendInput for an example

    INPUT_MOUSE = 0

    INPUT_KEYBOARD = 1

    INPUT_HARDWARE = 2