//Initialize pointers

/// <param name="ServerName">[Output] Pointer to a buffer in which to return the data source name.</param>

/// <param name="NameLength1Ptr">[Output] Pointer to a buffer in which to return the total number of bytes (excluding the null-termination byte)

/// <param name="Description">[Output] Pointer to a buffer in which to return the description of the driver associated with the data source.

/// <param name="NameLength2Ptr">[Output] Pointer to a buffer in which to return the total number of bytes (excluding the null-termination

Simple attributes are passed in the pointer itself, hence the overloaded signature.

[DllImport("glu32.dll", EntryPoint ="gluErrorString")]

[DllImport(GLU_DLL, EntryPoint ="gluQuadricDrawStyle")]

[DllImport(GLU_DLL, EntryPoint ="gluSphere")]

        EntryPoint = "DeleteUrlCacheEntryA",

      EntryPoint:="DeleteUrlCacheEntryA", _

    [DllImport(@"wininet", SetLastError = true, CharSet = CharSet.Auto, EntryPoint = "DeleteUrlCacheGroup", CallingConvention = CallingConvention.StdCall)]

       EntryPoint:="DeleteUrlCacheGroup", _

[DllImport(@"wininet",SetLastError=true,CharSet=CharSet.Auto,EntryPoint="FindFirstUrlCacheEntryA",CallingConvention=CallingConvention.StdCall)]

       EntryPoint:="FindFirstUrlCacheEntryA", _

       EntryPoint:="FindFirstUrlCacheGroup", _

        EntryPoint:="FindNextUrlCacheEntryA", _

       EntryPoint:="FindNextUrlCacheGroup", _

lpszCommand (in) A pointer to a string that contains the command to send to the FTP server.

dwContext (in) A pointer to a variable that contains an application-defined value used to identify the application context in callback operations.

phFtpCommand (out) A pointer to a handle that is created if a valid data socket is opened. The fExpectResponse parameter must be set to TRUE for phFtpCommand to be filled.

    [DllImport("wininet.dll", EntryPoint = "InternetConnectW", CharSet = CharSet.Auto, SetLastError = true)]

    [DllImport("wininet.dll", EntryPoint = "InternetOpenW", CharSet = CharSet.Auto, SetLastError = true)]

    [DllImport("wininet.dll", EntryPoint = "FtpPutFile")]

    [DllImport("wininet.dll", EntryPoint = "FtpGetFile", SetLastError = true, CharSet = CharSet.Auto)]

    [DllImport("wininet.dll", EntryPoint = "FtpOpenFile", SetLastError = true, CharSet = CharSet.Auto)]

    [DllImport("wininet.dll", EntryPoint = "InternetCloseHandle")]

    [DllImport("wininet.dll", EntryPoint = "GetLastError")]

    // (in) Pointer to a string that contains the canonical URL to be cracked

    // (out) Pointer to a URL_COMPONENTS structure that receives the URL components

///     C++ ( lpdwFlags [out]. Type: LPDWORD )<br />Pointer to a variable that receives the connection description. This

[DllImport("wininet.dll", EntryPoint = "InternetQueryOption")]

    <DllImport("wininet.dll", SetLastError:=True, CharSet:=CharSet.Auto, EntryPoint:="PrivacySetZonePreferenceW", CallingConvention:=CallingConvention.StdCall)> _

    <DllImport("wininet.dll", SetLastError:=True, CharSet:=CharSet.Auto, EntryPoint:="PrivacySetZonePreferenceW", CallingConvention:=CallingConvention.StdCall)> _

    [DllImportAttribute("irprops.cpl", EntryPoint="BluetoothEnableDiscovery", SetLastError=true)]

    /// <param name="pbtfrp">Pointer to a BLUETOOTH_FIND_RADIO_PARAMS structure</param>

    /// <param name="phRadio">Pointer to where the first enumerated radio handle will be returned. When no longer needed, this handle must be closed via CloseHandle.</param>

    <DllImport("user32.dll", EntryPoint:="BlockInput", SetLastError:=True, CharSet:=CharSet.Auto, CallingConvention:=CallingConvention.StdCall)>

    <DllImport("user32.dll", EntryPoint:="BlockInput", SetLastError:=True, CharSet:=CharSet.Auto, CallingConvention:=CallingConvention.StdCall)>

First i tried it with a PointL struct dmPosition.x and dmPosition.y until i luckily found this page:

static extern IntPtr ChildWindowFromPointEx(IntPtr hWndParent, Point pt, uint uFlags);

Public Function ChildWindowFromPointEx(ByVal hWndParent As IntPtr, ByVal P As POINTAPI, ByVal uFlags As CWPFlags) As IntPtr

ChildWindowFromPointFlags Enum

static extern IntPtr ChildWindowFromPointEx(IntPtr hWndParent, Point pt, uint uFlags);

Public Function ChildWindowFromPointEx(ByVal hWndParent As IntPtr, ByVal P As POINTAPI, ByVal uFlags As CWPFlags) As IntPtr

public enum ChildWindowFromPointFlags : uint

static extern bool ClientToScreen(IntPtr hWnd, ref Point lpPoint);

Private Shared Function ClientToScreen(ByVal hWnd As IntPtr, ByRef lpPoint As Point) As Boolean

POINT

    static extern bool ClientToScreen(IntPtr hwnd, ref Point lpPoint);

        Point point;

        point = new Point();

        coordinatesFound = ClientToScreen(handle, ref point);

            SetCursorPos(point.X + x, point.Y + y);

Control.PointToScreen

    [DllImport("user32.dll", EntryPoint="CreateDesktop", CharSet=CharSet.Unicode, SetLastError=true)]

    [DllImport("user32.dll", EntryPoint="CloseDesktop", CharSet =  CharSet.Unicode, SetLastError = true)]

    <DllImport("user32.dll", EntryPoint:="CreateDesktop", CharSet:=CharSet.Unicode, SetLastError:=True)> _

    <DllImport("user32.dll", EntryPoint:="CloseDesktop", CharSet:=CharSet.Unicode, SetLastError:=True)> _

[DllImport("user32.dll", EntryPoint="CreateWindowStation", CharSet=CharSet.Unicode, SetLastError=true)]

/// <param name="lpClassName">Pointer to a null-terminated string or a class atom created by a previous call to the RegisterClass or RegisterClassEx function. The atom must be in the low-order word of lpClassName; the high-order word must be zero. If lpClassName is a string, it specifies the window class name. The class name can be any name registered with RegisterClass or RegisterClassEx, provided that the module that registers the class is also the module that creates the window. The class name can also be any of the predefined system class names.</param>

/// <param name="lpWindowName">Pointer to a null-terminated string that specifies the window name. If the window style specifies a title bar, the window title pointed to by lpWindowName is displayed in the title bar. When using CreateWindow to create controls, such as buttons, check boxes, and static controls, use lpWindowName to specify the text of the control. When creating a static control with the SS_ICON style, use lpWindowName to specify the icon name or identifier. To specify an identifier, use the syntax "#num". </param>

/// <param name="hInstance">Handle to the instance of the module to be associated with the window.</param> <param name="lpParam">Pointer to a value to be passed to the window through the CREATESTRUCT structure (lpCreateParams member) pointed to by the lParam param of the WM_CREATE message. This message is sent to the created window by this function before it returns.

/// <para>If an application calls CreateWindow to create a MDI client window, lpParam should point to a CLIENTCREATESTRUCT structure. If an MDI client window calls CreateWindow to create an MDI child window, lpParam should point to a MDICREATESTRUCT structure. lpParam may be NULL if no additional data is needed.</para></param>

''' <param name="lpClassName">Pointer to a null-terminated string or a class atom created by a previous call to the RegisterClass or RegisterClassEx function. The atom must be in the low-order word of lpClassName; the high-order word must be zero. If lpClassName is a string, it specifies the window class name. The class name can be any name registered with RegisterClass or RegisterClassEx, provided that the module that registers the class is also the module that creates the window. The class name can also be any of the predefined system class names.</param>

''' <param name="lpWindowName">Pointer to a null-terminated string that specifies the window name. If the window style specifies a title bar, the window title pointed to by lpWindowName is displayed in the title bar. When using CreateWindow to create controls, such as buttons, check boxes, and static controls, use lpWindowName to specify the text of the control. When creating a static control with the SS_ICON style, use lpWindowName to specify the icon name or identifier. To specify an identifier, use the syntax "#num". </param>

''' <param name="hInstance">Handle to the instance of the module to be associated with the window.</param> <param name="lpParam">Pointer to a value to be passed to the window through the CREATESTRUCT structure (lpCreateParams member) pointed to by the lParam param of the WM_CREATE message. This message is sent to the created window by this function before it returns.

''' <para>If an application calls CreateWindow to create a MDI client window, lpParam should point to a CLIENTCREATESTRUCT structure. If an MDI client window calls CreateWindow to create an MDI child window, lpParam should point to a MDICREATESTRUCT structure. lpParam may be NULL if no additional data is needed.</para></param>

[DllImport("user32.dll", EntryPoint="DdeCreateStringHandleA")]

hWnd is the pointer to the window you want to close/destroy. Create a new IntPtr object with the window's handle as a parameter to it's constructor. Make sure the pointers are in decimal, not in hex as spy++ gives them to you.

static extern bool DragDetect(IntPtr hwnd, POINT pt);

POINT

public static bool DragDetect(IntPtr hWnd, Point pt) {

        Point newPt = Control.MousePosition;

      public RECT(System.Drawing.Point location, System.Drawing.Size size)

    RECT(System::Drawing::Point location, System::Drawing::Size size) {

        /// Submenu arrow pointing left. This is used for the right-to-left cascading menus used with right-to-left languages such as Arabic or Hebrew.

/// <param name="pointer">Pointer to a GCHandle that holds a reference to the list to fill</param>

private static bool EnumWindow(IntPtr handle, IntPtr pointer)

     GCHandle gch = GCHandle.FromIntPtr(pointer);

/// <param name="parameter">Caller-defined variable; we use it for a pointer to our list</param>

    [DllImport("user32.dll", EntryPoint = "GetWindowText",

    [DllImport("user32.dll", EntryPoint = "EnumDesktopWindows",

    /// entry point of the program

<DllImport("user32.dll", EntryPoint:="EnumDisplayDevices", CharSet:=CharSet.Auto, CallingConvention:=CallingConvention.StdCall)> _

        //Copy the string pointed to by lpString into a "real" string.

        //Copy the string pointed to by lpString into a "real" string.

<DllImport("user32.dll", EntryPoint:="EnumWindowStations", _

<DllImport("user32.dll", EntryPoint:="EnumWindowStations", _

static extern bool GetCaretPos(out Point lpPoint);

Private Declare Function GetCaretPos Lib "user32" (ByRef lpPoint As Point) As Integer

Dim pt As Point

[DllImport("user32.dll", EntryPoint="GetClassLong")]

[DllImport("user32.dll", EntryPoint="GetClassLongPtr")]

<DllImport("user32.dll", EntryPoint:="GetClassLong")> _

<DllImport("user32.dll", EntryPoint:="GetClassLongPtr")> _

[DllImport("user32.dll", EntryPoint="GetClassLong")]

[DllImport("user32.dll", EntryPoint="GetClassLongPtr")]

<DllImport("user32.dll", EntryPoint:="GetClassLong")> _

<DllImport("user32.dll", EntryPoint:="GetClassLongPtr")> _

     //Get pointer to clipboard data in the selected format

     IntPtr ClipboardDataPointer = GetClipboardData(SelectedFormat);

     //the above pointer points at to a place we can access it.

     UIntPtr Length = GlobalSize(ClipboardDataPointer);

     IntPtr gLock = GlobalLock(ClipboardDataPointer);

static extern bool GetCursorPos(out POINT lpPoint);

// DON'T use System.Drawing.Point, the order of the fields in System.Drawing.Point isn't guaranteed to stay the same.

    Public Shared Function GetCursorPos(ByRef lpPoint As POINT) As <MarshalAs(UnmanagedType.Bool)> Boolean

   (ByRef lpPoint As POINT) as boolean

   Public Function GetCursorPos(<[In](), Out()> ByRef pt As POINT) As Boolean

Point declaration

   Public Structure POINT

POINT

    private ulong lpPoint = 0;

    [DllImport("user32.dll")] static extern bool GetCursorPos(out ulong _lpPoint);

        GetCursorPos(out lpPoint);

        int _x   =   (int)( lpPoint & 0x00000000FFFFFFFF);

        ulong _y = (ulong)( lpPoint & 0xFFFFFFFF00000000) >> 32;

POINT p;

struct POINT

     public POINT ptScreenPos;       // A POINT structure that receives the screen coordinates of the cursor.

static extern bool GetCursorPos(out POINT lpPoint);

// DON'T use System.Drawing.Point, the order of the fields in System.Drawing.Point isn't guaranteed to stay the same.

    Public Shared Function GetCursorPos(ByRef lpPoint As POINT) As <MarshalAs(UnmanagedType.Bool)> Boolean

   (ByRef lpPoint As POINT) as boolean

   Public Function GetCursorPos(<[In](), Out()> ByRef pt As POINT) As Boolean

Point declaration

   Public Structure POINT

POINT

POINT p;

    ByVal location As Point, ByVal size As Size) As Image

    Public Function GetDesktopImage(ByVal loc As System.Drawing.Point, _

      Dim ptScr As System.Drawing.Point = Me.PointToScreen(loc)

      g.CopyFromScreen(loc, New Point(0, 0), area, CopyPixelOperation.SourceCopy)

   <System.Runtime.InteropServices.DllImportAttribute("user32.dll", EntryPoint:="GetIconInfo")>  _

The hbmColor and hbmMask are pointers to unmanaged data and must be deleted after use. The following code will grab the icon info for a cursor handle and dispose of the unmanaged resources, if needed:

    public Point HotPoint {

        return new Point(ii.xHotspot, ii.yHotspot);

    [DllImport("gdi32.dll", EntryPoint = "DeleteObject")]

out Pointer to the buffer that receives the NULL-terminated string. If the string is as long or longer than lpString, the string is truncated and the terminating NULL character is added. If lpString is NULL, the function returns the length of the menu string.

out Pointer to the buffer that receives the NULL-terminated string. If the string is as long or longer than lpString, the string is truncated and the terminating NULL character is added. If lpString is NULL, the function returns the length of the menu string.

If you change the return type from uint to int, then you can do new Point(GetMessagePos()).

static extern int GetMouseMovePointsEx(uint cbSize, [In] ref MOUSEMOVEPOINT

   lppt, [Out] MOUSEMOVEPOINT [] lpptBuf, int nBufPoints, uint resolution);

    public const int GMMP_USE_DISPLAY_POINTS     = 1;

    public const int GMMP_USE_HIGH_RESOLUTION_POINTS = 2;

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] // For GetMouseMovePointsEx

    public struct MOUSEMOVEPOINT {

    internal static extern int GetMouseMovePointsEx(

                    [In] ref MOUSEMOVEPOINT pointsIn,

                    [Out] MOUSEMOVEPOINT[] pointsBufferOut,

                    int nBufPoints,

    uint mode  = GMMP_USE_DISPLAY_POINTS;

    MOUSEMOVEPOINT mp_in  = new MOUSEMOVEPOINT();

    MOUSEMOVEPOINT[] mp_out = new MOUSEMOVEPOINT[64];

    int nNumPointsRequired = 20 ; // set number of points to desired value less than 64

    // Set the Current Position in currentPosition, of type POINT

    int cpt = GetMouseMovePointsEx((uint)(Marshal.SizeOf(mp_in)), ref mp_in, mp_out, nNumPointsRequired, mode);

    EntryPOint:="GetRawInputDeviceList", SetLastError:=True)> _

        // First call the system routine with a null pointer

[DllImport( "user32.dll", SetLastError=true,  EntryPoint="GetScrollBarInfo")]

         lvMain.Location=new Point(0,0);

    ''' <param name="lpdwProcessId">A pointer to a variable that receives the process identifier. If this parameter is not NULL, GetWindowThreadProcessId copies the identifier of the process to the variable; otherwise, it does not. </param>

On this platform this function is in fact a macro that calls GetWindowLong, so the EntryPoint property has to be set to the real function:

[DllImport("user32.dll", EntryPoint="GetWindowLong")]

<DllImport("user32.dll", EntryPoint:="GetWindowLong")> _

[DllImport("user32.dll", EntryPoint="GetWindowLongPtr")]

<DllImport("user32.dll", EntryPoint:="GetWindowLongPtr")> _

[DllImport("user32.dll", EntryPoint="GetWindowLong")]

[DllImport("user32.dll", EntryPoint="GetWindowLongPtr")]

<DllImport("user32.dll", EntryPoint:="GetWindowLong")> _

<DllImport("user32.dll", EntryPoint:="GetWindowLongPtr")> _

On this platform this function is in fact a macro that calls GetWindowLong, so the EntryPoint property has to be set to the real function:

[DllImport("user32.dll", EntryPoint="GetWindowLong")]

<DllImport("user32.dll", EntryPoint:="GetWindowLong")> _

[DllImport("user32.dll", EntryPoint="GetWindowLongPtr")]

<DllImport("user32.dll", EntryPoint:="GetWindowLongPtr")> _

[DllImport("user32.dll", EntryPoint="GetWindowLong")]

[DllImport("user32.dll", EntryPoint="GetWindowLongPtr")]

<DllImport("user32.dll", EntryPoint:="GetWindowLong")> _

<DllImport("user32.dll", EntryPoint:="GetWindowLongPtr")> _