public struct CMINVOKECOMMANDINFOEX {

        public int            cbSize;        // Marshal.SizeOf(CMINVOKECOMMANDINFO)

        public int            dwHotKey;        // Optional hot key to assign to any application activated by the command. If the fMask member does not specify CMIC_MASK_HOTKEY, this member is ignored.

        public IntPtr        hIcon;            // Icon to use for any application activated by the command. If the fMask member does not specify CMIC_MASK_ICON, this member is ignored.

        public string        lpVerbW;                // Unicode verb, for those commands that can use it.

        public string        lpParametersW;        // Unicode parameters, for those commands that can use it.

        public string        lpDirectoryW;        // Unicode directory, for those commands that can use it.

        public POINT        ptInvoke;                // Point where the command is invoked. This member is not valid prior to Microsoft Internet Explorer 4.0.

Structure CMINVOKECOMMANDINFOEX

public static extern bool CreateProcessWithTokenW(IntPtr hToken, LogonFlags dwLogonFlags, string lpApplicationName, string lpCommandLine, CreationFlags dwCreationFlags, IntPtr lpEnvironment, string lpCurrentDirectory, [In] ref STARTUPINFO lpStartupInfo, out PROCESS_INFORMATION lpProcessInformation);

    Public Shared Function CreateProcessWithTokenW(hToken As IntPtr, dwLogonFlags As Integer, lpApplicationName As String, lpCommandLine As String, dwCreationFlags As Integer, lpEnvironment As IntPtr, lpCurrentDirectory As IntPtr, ByRef lpStartupInfo As STARTUPINFO, ByRef lpProcessInformation As PROCESS_INFORMATION) As Boolean

  *  Structure returned to the NCB command NCBENUM.

        public uint dwCommandId;

        byte ncb_command;

   Dim ncb_command As Byte

   UCHAR   ncb_command;        /* command code           */

                   /* state when an ASYNCH command   */

        public ushort Command;

    /// Wrapper for the ScsiPassThrough command

        /// Constructor for the command to send to the robot

            public string lpCommand;

   Public lpCommand As String

        public int CurrentCommands;

    public bool CommandQueueing;

        public int idCommand;

        Public idCommand As Int32

        public int idCommand;

     public ShowWindowCommands ShowCmd;

     Public showCmd As ShowWindowCommand

POINT, RECT, ShowWindowCommands

   COMMAND = 1,

   DDECOMMAND,

   qa.GetString(ASSOCF.NOTRUNCATE, ASSOCSTR.COMMAND,

   qa.GetString(ASSOCF.NOTRUNCATE, ASSOCSTR.COMMAND,

     Console.WriteLine("No command line is associated to .doc print verb.");

    Command = 1,

    DDECommand,

/// Finds the command line arguments within a given path.

''' Finds the command line arguments within a given path.

        // execute this command, to convert pdf to tiff

static extern UInt32 MsiApplyPatch(string patchPackage, string installPackage, INSTALLTYPE installType, string commandLine);

commandLine

   Specifies command line property settings

static extern UInt32 MsiInstallProduct(string packagePath, string commandLine);

Declare Function MsiInstallProduct Lib "msi.dll" (packagePath As String, commandLine As String) As UInt32

szCommandLine

A null-terminated string that specifies the command line property settings. This should be a list of the format Property=Setting Property=Setting. For more information, see About Properties.

To perform an administrative installation, include ACTION=ADMIN in szCommandLine. For more information, see the ACTION property.

You can completely remove a product by setting REMOVE=ALL in szCommandLine.

        // The sql command. Note the "?" placeholder for the value.

        // Open a view to use to apply the change. Here's where you specify your sql command.

        void IContextMenu.GetCommandString(int idCmd, uint uFlags, int pwReserved, StringBuilder commandString, int cchMax)

                commandString = new StringBuilder("...");

                commandString = new StringBuilder("...");

        void IContextMenu.InvokeCommand (IntPtr pici)

                Type typINVOKECOMMANDINFO = Type.GetType("ShellExt.INVOKECOMMANDINFO");

                INVOKECOMMANDINFO ici = (INVOKECOMMANDINFO)Marshal.PtrToStructure(pici, typINVOKECOMMANDINFO);

            Win32.ShowWindow(hwnd, ShowWindowCommands.Normal );

enum DeferWindowPosCommands :uint {

Public Enum DeferWindowPosCommands As UInteger

Public Enum DeferWindowPosCommands

        internal const UInt32 MF_BYCOMMAND    =0x00000000;

    internal const UInt32 MF_BYCOMMAND    =0x00000000;

     Main(System.Environment.GetCommandLineArgs())

Compile at bash command line with: gcc -Wall idle.c

internal const UInt32 MF_BYCOMMAND =0x00000000;

MF_BYCOMMAND

Indicates that uIDItem gives the identifier of the menu item. If neither the MF_BYCOMMAND nor MF_BYPOSITION flag is specified, the MF_BYCOMMAND flag is the default flag.

Sendmessage(hwndMain, WM_COMMAND, intMID,  0) 'Click the MenuItem!

internal const UInt32 MF_BYCOMMAND =0x00000000;

MF_BYCOMMAND

Indicates that uIDItem gives the identifier of the menu item. If neither the MF_BYCOMMAND nor MF_BYPOSITION flag is specified, the MF_BYCOMMAND flag is the default flag.

    /// <param name="uiCommand">Command to issue when retrieving data.</param>

    public static extern int GetRawInputData(IntPtr hRawInput, RawInputCommand uiCommand, out RAWINPUT pData, ref int pcbSize, int cbSizeHeader);

    /// <param name="uiCommand">Command to issue when retrieving data.</param>

    public static extern int GetRawInputData(IntPtr hRawInput, RawInputCommand uiCommand, byte[] pData, ref int pcbSize, int cbSizeHeader);

            outSize = Win32API.GetRawInputData(m.LParam, RawInputCommand.Input, out input, ref size, Marshal.SizeOf(typeof(RAWINPUTHEADER)));

    public static extern uint GetRawInputDeviceInfo(int deviceHandle, uint command, ref DeviceInfo data, ref uint dataSize);

static extern uint GetRawInputDeviceInfo(IntPtr hDevice, uint uiCommand, IntPtr pData, ref uint pcbSize);

Declare Function GetRawInputDeviceInfo Lib "user32.dll" Alias "GetRawInputDeviceInfoW" (ByVal hDevice As IntPtr, ByVal uiCommand As DeviceInfoTypes, ByVal pData As IntPtr, ByRef pcbSize As UInteger) As Integer

Sendmessage(hwndMain, WM_COMMAND, intMID,  0) 'Click the MenuItem!

DialogBoxCommandID

This code assumes a form called frmMain with a command button called cmdClick a picture box called picClicker and a text box called txtResults

Note Twips are no more. Also, I stripped the FOR loop of delta moves from the command button click to the middle of the picture box.

private const int WM_SYSCOMMAND = 0x112;

   SendMessage(ctrl.Handle, WM_SYSCOMMAND, MOUSE_MOVE, ref nul);

    const int WM_SYSCOMMAND = 274;

    SendMessage(proc.MainWindowHandle, WM_SYSCOMMAND, SC_MAXIMIZE, 0);

Public Shared Function ShowWindowAsync(hWnd As IntPtr, <MarshalAs(UnmanagedType.I4)>nCmdShow As ShowWindowCommands) As <MarshalAs(UnmanagedType.Bool)> Boolean

ShowWindowCommands

Public Function ShowWindowAsync(hWnd As IntPtr, <MarshalAs(UnmanagedType.I4)>nCmdShow As ShowWindowCommands) As <MarshalAs(UnmanagedType.Bool)> Boolean

ShowWindowCommands

///<Summary>Commands to pass to WinHelp()</Summary>

enum WinHelpCommands : uint

     HELP_COMMAND      = 0x0102;

'''<Summary>Commands to pass to WinHelp()</Summary>

Public Enum WinHelpCommands As UInteger

     HELP_COMMAND      = &H0102

Public Enum WinHelpCommands

     HELP_COMMAND       As Long = &H0102

static extern Int32 mciSendString(string command, StringBuilder buffer, int bufferSize, IntPtr hwndCallback);

Private Shared Function mciSendString(ByVal command As String, ByVal buffer As StringBuilder, ByVal bufferSize As Integer, ByVal hwndCallback As IntPtr) As Integer

Declare Ansi Function mciSendString Lib "winmm.dll" Alias "mciSendStringA" (ByVal command As String, ByRef buffer As StringBuilder, ByVal bufferSize As Integer, ByVal hWndCallback As IntPtr) As Integer

string sCommand = "open \"" + strFilePath + "\" type mpegvideo alias MediaFile";

mciSendString(sCommand, null, 0, 0);

sCommand = "play MediaFile notify";

mciSendString(sCommand, null, 0, _frmObject.Handle.ToInt64());

static extern Int32 mciSendString(string command, string buffer, int bufferSize, IntPtr hwndCallback);

private void EjectCdCommand()

private void CloseCdCommand()

     Dim sCommand As String = "open """ + strFilePath + """ type waveaudio alias MediaFile"

     mciSendString(sCommand, Nothing, 0, IntPtr.Zero)

     sCommand = "play MediaFile notify"

     mciSendString(sCommand, Nothing, 0, Me.Handle.ToInt64())

      public enum Command : int

Declare Function Command Lib "ws2_32.dll" (TODO) As TODO

Command

    public static extern int ioctlsocket(IntPtr s, Command cmd, ref int argp);

        //Native.ioctlsocket(this.socketPtr, Native.Command.FIONREAD, ref BufferRet);

        //Native.ioctlsocket(this.socketPtr, Native.Command.FIONREAD, ref BufferRet);

static extern IntPtr CommandLineToArgvW(

Declare Function CommandLineToArgv Lib "shell32.dll" Alias "CommandLineToArgvW" ( _

        ptrToSplitArgs = CommandLineToArgvW(unsplitArgumentLine, out numberOfArgs);

        // CommandLineToArgvW returns NULL upon failure.

            // Free memory obtained by CommandLineToArgW.

    static extern IntPtr CommandLineToArgvW(

    public enum ShowCommands : int

static extern UInt32 SHSetUnreadMailCount(string pszMailAddress, UInt32 dwCount, string pszShellExecuteCommand);

  Public Shared Function SHSetUnreadMailCount(ByVal pszMailAddress As String, ByVal dwCount As Integer, ByVal pszShellExecuteCommand As String) As Integer

TextOut, unlike the Text property, have to be called every time Windows asks for a control to repaint. By using the Graphics.CopyFromScreen method one can copy the output of a Textout command and use that for repainting.

Unlike graphics.drawstring, Textout can work with fonts other than True Type, Open Type, and PostScript fonts. If you have a font that's supported by Windows but not .net you can most likely use this command to draw it.

If you need to check for an existing console (ie, if the program was launched from the command window) please see AttachConsole,

When running an application that is GUI from a console window, you may want to echo something to that console window (such as command line options when the user specifies /? on the command line), but also don't want a console window popping up when you don't need it (such is the behavior of a windows C# 'Console Application'). In this case these work great, and are fully compatible thereafter with the .NET Console.xxx static functions.

When running an application that is GUI from a console window, you may want to echo something to that console window (such as command line options when the user specifies /? on the command line), but also don't want a console window popping up when you don't need it (such is the behavior of a windows C# 'Console Application'). In this case these work great, and are fully compatible thereafter with the .NET Console.xxx static functions.

        public uint dwCommandId;

   string lpCommandLine,

    lpCommandLine As String, _

     string CommandLine = @" c:\boot.ini";

     retValue = CreateProcess(Application,CommandLine,

     Dim CommandLine As String = " c:\boot.ini"

     retValue = CreateProcess(Application, CommandLine, pSec, tSec, False, NORMAL_PRIORITY_CLASS, IntPtr.Zero, vbNull, sInfo, pInfo)