ref SecBufferDesc pInput,

    IntPtr pInput, //PSecBufferDesc SecBufferDesc

    ByVal pInput As IntPtr, _

    IntPtr pInput, //PSecBufferDesc SecBufferDesc

                                                ref SecBufferDesc pInput,

                                                ref SecBufferDesc pInput,

                        ref ClientToken,            // [in] pointer to the input buffers

                        ref ClientToken,            // [in] pointer to the input buffers

/// 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:".

extern static short SQLAllocHandle(ushort HandleType, int InputHandle, out IntPtr OutputHandle);

Private Declare Auto Function SQLAllocHandle Lib "odbc32.dll" (ByVal HandleType As Short, ByVal InputHandle As IntPtr, ByRef OutputHandle As IntPtr) As Short

    private static extern short SQLAllocHandle(short hType, IntPtr inputHandle, out IntPtr outputHandle);

/// <param name="EnvironmentHandle">[Input] Environment handle.</param>

/// <param name="Direction">[Input] Determines which data source the Driver Manager returns information on.</param>

/// <param name="BufferLength1">[Input] Length of the *ServerName buffer, in characters; this does not need to be longer than SQL_MAX_DSN_LENGTH plus the null-termination character.</param>

/// <param name="BufferLength2">[Input] Length in characters of the *Description buffer.</param>

static extern short SQLFreeHandle(ushort HandleType, IntPtr InputHandle);

Declare Function SQLFreeHandle Lib "odbc32.dll" (ByVal HandleType As Short, ByVal InputHandle As IntPtr) As Short

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.

                      DELTA_INPUT GlobalOptions,

                      DELTA_INPUT GlobalOptions,

DELTA_INPUT

     IntPtr pInputConfigInfo,

     int InputConfigInfoLength,

Depending on the value of ConfigId, both pInputConfigInfo and pOutputConfigInfo should point to a different type of structure. If it wasn't for this, I could redifine the PInvoke signature to explicitly specify the underlying structure type.

     HTTP_SERVICE_CONFIG_URLACL_QUERY inputConfigInfoQuery = new HTTP_SERVICE_CONFIG_URLACL_QUERY();

     inputConfigInfoQuery.QueryDesc = HTTP_SERVICE_CONFIG_QUERY_TYPE.HttpServiceConfigQueryExact;

     inputConfigInfoQuery.KeyDesc = keyDesc;

     inputConfigInfoQuery.dwToken = 0;

     IntPtr pInputConfigInfo = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(HTTP_SERVICE_CONFIG_URLACL_QUERY)));

     Marshal.StructureToPtr(inputConfigInfoQuery, pInputConfigInfo, true);

     size = Marshal.SizeOf(inputConfigInfoQuery);

         pInputConfigInfo,

         Marshal.SizeOf(inputConfigInfoQuery),

         pInputConfigInfo,

         Marshal.SizeOf(inputConfigInfoQuery),

     HTTP_SERVICE_CONFIG_URLACL_SET inputConfigInfoSet = new HTTP_SERVICE_CONFIG_URLACL_SET();

     inputConfigInfoSet.KeyDesc = keyDesc;

     inputConfigInfoSet.ParamDesc = paramDesc;

     IntPtr pInputConfigInfo = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(HTTP_SERVICE_CONFIG_URLACL_SET)));

     Marshal.StructureToPtr(inputConfigInfoSet, pInputConfigInfo, false);

         pInputConfigInfo,

         Marshal.SizeOf(inputConfigInfoSet),

         pInputConfigInfo,

         Marshal.SizeOf(inputConfigInfoSet),

             pInputConfigInfo,

             Marshal.SizeOf(inputConfigInfoSet),

     Marshal.FreeCoTaskMem(pInputConfigInfo);

        IntPtr pInputConfigInfo = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(HTTP_SERVICE_CONFIG_SSL_SET)));

        Marshal.StructureToPtr(configSslSet, pInputConfigInfo, false);

            pInputConfigInfo,

            pInputConfigInfo,

                pInputConfigInfo,

        Marshal.FreeCoTaskMem(pInputConfigInfo);

            result = HidP_GetValueCaps(HidP_Input, ref valueCaps[0], ref Capabilities.NumberInputValueCaps, preparsedDataPointer);

      UInt16 InputReportByteLength;

      UInt16 NumberInputButtonCaps;

      UInt16 NumberInputValueCaps;

      UInt16 NumberInputDataIndices;

InputReportByteLength

Specifies the maximum size, in bytes, of all the input reports (including the report ID, if report IDs are used, which is prepended to the report data).

NumberInputButtonCaps

Specifies the number of input HIDP_BUTTON_CAPS structures that HidP_GetButtonCaps returns.

NumberInputValueCaps

Specifies the number of input HIDP_VALUE_CAPS structures that HidP_GetValueCaps returns.

NumberInputDataIndices

Specifies the number of data indices assigned to buttons and values in all input reports.

Callers of the HIDClass support routines use the information provided in this structure when a called routine requires, as input, the size of a report type, the number of link collection nodes, the number of control capabilities, or the number of data indices.

    Implements IInputObject

    Protected BandObjectSite As IInputObjectSite

    BandObjectSite = DirectCast(pUnkSite, IInputObjectSite)

    Public Overridable Sub UIActivateIO(fActivate As Int32, ByRef Msg As MSG) Implements IInputObject.UIActivateIO

    Public Overridable Function HasFocusIO() As Int32 Implements IInputObject.HasFocusIO

    Public Overridable Function TranslateAcceleratorIO(ByRef msg As MSG) As Int32 Implements IInputObject.TranslateAcceleratorIO

    BandObjectSite.OnFocusChangeIS(TryCast(Me, IInputObject), 1)

        BandObjectSite.OnFocusChangeIS(TryCast(Me, IInputObject), 0)

Public Interface IInputObject

Public Interface IInputObjectSite

    Implements IInputObject

    Protected BandObjectSite As IInputObjectSite

    BandObjectSite = DirectCast(pUnkSite, IInputObjectSite)

    Public Overridable Sub UIActivateIO(fActivate As Int32, ByRef Msg As MSG) Implements IInputObject.UIActivateIO

    Public Overridable Function HasFocusIO() As Int32 Implements IInputObject.HasFocusIO

    Public Overridable Function TranslateAcceleratorIO(ByRef msg As MSG) As Int32 Implements IInputObject.TranslateAcceleratorIO

    BandObjectSite.OnFocusChangeIS(TryCast(Me, IInputObject), 1)

        BandObjectSite.OnFocusChangeIS(TryCast(Me, IInputObject), 0)

Public Interface IInputObject

Public Interface IInputObjectSite

public interface IInputObjectSite

            /// <param name="pvaIn">Input arguments</param>

        /// <param name="vaIn">Input Arguments</param>

    /// <param name="hwnd">If user input is required to perform the enumeration, this window handle should be used by the enumeration object as the parent window to take user input.</param>

      ///virtual HRESULT STDMETHODCALLTYPE GetInputProcessorProfiles(

      ///    /* [out] */ ITfInputProcessorProfiles **ppaip,

      int GetInputProcessorProfiles(uint dwThreadId, ref IUnknown ppaip, ref uint pdwThreadId);

      ///virtual HRESULT STDMETHODCALLTYPE SetModalInput(

      int SetModalInput(IUnknown pSink, uint dwThreadId, uint dwFlags);

     IntPtr lpInputBuffer,

     UInt32 nInputBufferSize,

Private Shared Function CallNtPowerInformation(InformationLevel As Int32, lpInputBuffer As IntPtr, nInputBufferSize As UInt32, lpOutputBuffer As IntPtr, nOutputBufferSize As UInt32) As UInt32

        IntPtr lpInputBuffer,

        int nInputBufferSize,

    private const int PBT_APMRESUMESUSPEND = 7; // (0x7) - Operation is resuming from a low-power state.This message is sent after PBT_APMRESUMEAUTOMATIC if the resume is triggered by user input, such as pressing a key.

            Console.WriteLine("\tOperation is resuming from a low-power state.This message is sent after PBT_APMRESUMEAUTOMATIC if the resume is triggered by user input, such as pressing a key.");

    public IntPtr hStdInput;

static extern int ExtEscape (IntPtr hdc, uint nEscape, uint cbInput, byte[] lpszInData, int cbOutput, IntPtr lpszOutData);

        uint cbInput,

                          ByVal cbInput As Int32, _

        uint cbInput,

IME is used to Convert Keyboad input to Local Language.

            // close IME(direct input for Alphabet and Number)

        /// <param name="lpInBuf">Pointer to the input buffer.</param>

static extern uint SendInput(uint cInputs, /* [MarshalAs(UnmanagedType.LPArray)] */ KEYBOARDINPUT[] inputs, int cbSize);

Declare Function SendInput Lib "coredll.dll" (TODO) As TODO

        public struct KEYBOARDINPUT

        public const uint INPUT_KEYBOARD = 1;

        public static extern uint SendInput(uint cInputs, /* [MarshalAs(UnmanagedType.LPArray)] */ KEYBOARDINPUT[] inputs, int cbSize);

        KEYBOARDINPUT[] inputs;

        inputs = new cTabControl.KEYBOARDINPUT[2];

        inputs[0].type = inputs[1].type = cTabControl.INPUT_KEYBOARD;

        inputs[0].wVk = inputs[1].wVk = cTabControl.VK_TAB;

        inputs[1].dwFlags = cTabControl.KEYEVENTF_KEYUP;

        retVal = cTabControl.SendInput(2, inputs, 0x001C);

        throw new Exception(string.Format("SendInput() returned {0}.", error));

        KEYBOARDINPUT[] inputs;

        inputs = new cTabControl.KEYBOARDINPUT[4];

        inputs[0].type = inputs[1].type = inputs[2].type = inputs[3].type = cTabControl.INPUT_KEYBOARD;

        inputs[0].wVk = inputs[3].wVk = cTabControl.VK_SHIFT;

        inputs[1].wVk = inputs[2].wVk = cTabControl.VK_TAB;

        inputs[2].dwFlags = inputs[3].dwFlags = cTabControl.KEYEVENTF_KEYUP;

        retVal = cTabControl.SendInput(4, inputs, 0x001C);

        throw new Exception(string.Format("SendInput() returned {0}.", error));

        KEYBOARDINPUT[] inputs;

        inputs = new cTabControl.KEYBOARDINPUT[4];

        inputs[0].type = inputs[1].type = inputs[2].type = inputs[3].type = cTabControl.INPUT_KEYBOARD;

        inputs[0].wVk = inputs[3].wVk = cTabControl.VK_CTRL;

        inputs[1].wVk = inputs[2].wVk = cTabControl.VK_TAB;

        inputs[2].dwFlags = inputs[3].dwFlags = cTabControl.KEYEVENTF_KEYUP;

        retVal = cTabControl.SendInput(4, inputs, 0x001C);

        throw new Exception(string.Format("SendInput() returned {0}.", error));

        KEYBOARDINPUT[] inputs;

        inputs = new cTabControl.KEYBOARDINPUT[6];

        inputs[0].type = inputs[1].type = inputs[2].type = inputs[3].type = inputs[4].type = inputs[5].type = cTabControl.INPUT_KEYBOARD;

        inputs[0].wVk = inputs[5].wVk = cTabControl.VK_CTRL;

        inputs[1].wVk = inputs[4].wVk = cTabControl.VK_SHIFT;

        inputs[2].wVk = inputs[3].wVk = cTabControl.VK_TAB;

        inputs[2].dwFlags = inputs[5].dwFlags = cTabControl.KEYEVENTF_KEYUP;

        retVal = cTabControl.SendInput(6, inputs, 0x001C);

        throw new Exception(string.Format("SendInput() returned {0}.", error));

        /// <summary>If the calling thread and the thread that owns the window are attached to different input queues,

Microsoft.WindowsCE.Forms.InputPanel.CurrentInputMethod

There's the InputPanel control.

    inputPanel.Enabled = showIt;

    inputPanel.Enabled = !inputPanel.Enabled;

Main benefit of using this over the InputPanel is that there is no control to instantiate in the form initialization process. The main drawback is that you do not have access to the InputPanel.Bounds property. C++ TRUE indicates success. When this function fails, it returns an HRESULT error code.

    /// 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.

        bool bSuccess = ImmGetConversionStatus(HIme, ref iMode, ref iSentence);  //Scan the input method info

    ProcessImageFileMapping, // q: HANDLE (input)

• Use Marshal.StringToCoTaskMemUni() to prepare input parameters (IntPtr) declared to receive strings.
An IntPtr is a pointer to a memory location (unmanaged) that adapts to the platform it is running on (64-bit, etc.) UNLIKE a standard int/Integer. You should always use this type for unmanaged calls that require it, even though an int will appear to work on your development machine.
1/13/2008 4:00:13 AM - Damon Carr-72.43.165.29

static extern int DocumentProperties(IntPtr hwnd, IntPtr hPrinter, [MarshalAs(UnmanagedType.LPWStr)] string pDeviceName, IntPtr pDevModeOutput, IntPtr pDevModeInput, int fMode);

static extern int DocumentProperties(IntPtr hWnd, IntPtr hPrinter, string pDeviceName, IntPtr pDevModeOutput, IntPtr pDevModeInput, fModes fMode);

    Private Shared Function DocumentProperties(ByVal hwnd As IntPtr, ByVal hPrinter As IntPtr, <MarshalAs(UnmanagedType.LPWStr)> ByVal pDeviceName As String, ByVal pDevModeOutput As IntPtr, ByVal pDevModeInput As IntPtr, ByVal fMode As Integer) As Integer

Doesn't work on a x64 system. (i.e. this declaration is wrong for x64, I'm just not quite sure why.). MH:I tested the code extensivly and I think the param "IntPtr pDevModeInput" must not have the "ref" flag. If it has the initial state of the dialog is wrong. EP: Yup, you're right! Thanks!!! I've been trying to figure out why it doesn't work on some drivers for a few weeks now! "ref" removed.

static extern bool XcvData(IntPtr hXcv, [MarshalAs(UnmanagedType.LPWStr)] string pszDataName, IntPtr InputData, uint cbInputData,

        /// <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

    // 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