private const uint MIDICAPS_STREAM = 8;      // driver supports midiStreamOut directly

Unlike Environment.TickCount, you can directly set the resolution of this timer with the TimeBeginPeriod function.

        WAVE_FORMAT_DIRECT = 8

  WAVE_FORMAT_DIRECT = 8

  WAVE_FORMAT_DIRECT = 8

Use "Auto" in the Declare statement to have the correct character set selected automatically.

See http://social.msdn.microsoft.com/Forums/en-US/windowspro-audiodevelopment/thread/14926e01-635e-4360-998b-ec6124d888a7 - correct C# signature at the bottom (including uDeviceId). This is based on http://msdn.microsoft.com/en-us/library/windows/desktop/dd743866%28v=vs.85%29.aspx which shows a UINT_PTR for that parameter. Note that the _PTR parameters are the only ones that are different sizes in 32 vs. 64 bit mode. In .Net you use IntPtr for that purpose.

    const int MSIDBOPEN_DIRECT =       2;  // database direct read/write without transaction

    const int MSIDBOPEN_CREATEDIRECT = 4;  // create new database, direct mode read/write

        int iOpenMode = MSIDBOPEN_DIRECT;

static extern int GdipAddPathRectanglesI(HandleRef path,

   HandleRef rects, int count);

Declare Function GdipAddPathRectanglesI Lib "gdiplus.dll" (TODO) As TODO

static extern int GdipAddPathRectangleI(HandleRef path, int x, int y,

Declare Function GdipAddPathRectangleI Lib "gdiplus.dll" (TODO) As TODO

static extern int GdipAddPathRectangles(HandleRef path,

   HandleRef rects, int count);

Declare Function GdipAddPathRectangles Lib "gdiplus.dll" (TODO) As TODO

   ref GPRECT layoutRect, HandleRef format);

   ref GPRECT dstRect, ref GPRECT srcRect, int unit, out int state);

static extern int GdipBitmapLockBits(HandleRef bitmap, ref GPRECT rect,

static extern int GdipCombineRegionRectI(HandleRef region,

   ref GPRECT gprect, CombineMode mode);

Declare Function GdipCombineRegionRectI Lib "gdiplus.dll" (TODO) As TODO

internal static extern int GdipMeasureString(HandleRef graphics, string textString, int length, HandleRef font, ref GPRECTF layoutRect, HandleRef stringFormat, [In, Out] ref GPRECTF boundingBox, out int codepointsFitted, out int linesFilled);

static extern bool AdjustWindowRectEx(ref Rect lpRect, uint dwStyle,

Public Function AdjustWindowRectEx(<MarshalAs(UnmanagedType.Struct)>byref lpRect As RECT, _

Public Declare Function AdjustWindowRectEx Lib "user32" _

         (lpRect As RECT, _

RECT

System.Windows.Rect

static extern bool AdjustWindowRectEx(ref RECT lpRect, uint dwStyle,

Public Function AdjustWindowRectEx(<MarshalAs(UnmanagedType.Struct)>byref lpRect As RECT, _

Public Declare Function AdjustWindowRectEx Lib "user32" _

         (lpRect As RECT, _

RECT

static extern TODO AlignRects(TODO);

Declare Function AlignRects Lib "user32.dll" (TODO) As TODO

The multiple-window-position structure is an internal structure; an application cannot access it directly.

Useful to create a temporary block in input for sensitive GUI operations. For instance when manually activating a screen saver from within a GUI function, a short blocking delay will prevent the user mouse movements directly after selection from accidently escaping the screen saver.

///     installed hooks will not receive hook notifications and may behave incorrectly as a result. You should call

   IntPtr lpRect, uint cKids, IntPtr [] lpKids);

static extern TODO ClientRectangle(TODO);

Declare Function ClientRectangle Lib "user32.dll" (TODO) As TODO

Control.RectangleToScreen

static extern bool ClipCursor(ref RECT lpRect);

Private Declare Function ClipCursor Lib "user32"(ByRef lpRect As RECT) As Long

public struct RECT

    /// Left position of the rectangle.

    /// Top position of the rectangle.

    /// Right position of the rectangle.

    /// Bottom position of the rectangle.

    /// Operator to convert a RECT to Drawing.Rectangle.

    /// <param name="rect">Rectangle to convert.</param>

    /// <returns>A Drawing.Rectangle</returns>

    public static implicit operator Rectangle(RECT rect)

        return Rectangle.FromLTRB(rect.Left, rect.Top, rect.Right, rect.Bottom);

    /// Operator to convert Drawing.Rectangle to a RECT.

    /// <param name="rect">Rectangle to convert.</param>

    /// <returns>RECT rectangle.</returns>

    public static implicit operator RECT(Rectangle rect)

        return new RECT(rect.Left, rect.Top, rect.Right, rect.Bottom);

    public RECT(int left, int top, int right, int bottom)

RECT rect =new RECT( 10, 10, 20, 20 );

ClipCursor(ref rect);

string folderPath = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);

If you come across this error "System.Runtime.InteropServices.MarshalDirectiveException: Cannot marshal 'parameter #6': Invalid managed/unmanaged type combination (this value type must be paired with Struct).", you may want to use

static extern IntPtr CreateIconIndirect([In] ref ICONINFO piconinfo);

private static extern IntPtr CreateIconIndirect([In] ref ICONINFO iconInfo);

     IntPtr handle = CreateIconIndirect(ref ii);

static extern IntPtr CreateIconIndirect([In] ref ICONINFO piconinfo);

private static extern IntPtr CreateIconIndirect([In] ref ICONINFO iconInfo);

     IntPtr handle = CreateIconIndirect(ref ii);

                    // Get info about the directory

                RECT rect;

                        Win32.GetClientRect (hWnd, out rect) ;

                        Win32.DrawText (hdc, "Hello, Windows 98!", -1, ref rect,

Either use this name directly or modify the first line of the signature to:

static extern bool DrawAnimatedRects(IntPtr hwnd, int idAni,

   [In] ref RECT lprcFrom, [In] ref RECT lprcTo);

Since only IDANI_CAPTION is implemented, to get the effect of IDANI_OPEN, simply swap the lprcFrom and lprcTo rectangles, but still specify the IDANI_CAPTION constant.

    struct RECT

      public RECT(System.Drawing.Rectangle rectangle)

        Left = rectangle.Left;

        Top = rectangle.Top;

        Right = rectangle.Right;

        Bottom = rectangle.Bottom;

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

    static extern bool DrawAnimatedRects(System.IntPtr hwnd, int idAni,

      [System.Runtime.InteropServices.In] ref RECT lprcFrom,

      [System.Runtime.InteropServices.In] ref RECT lprcTo);

    static extern bool GetWindowRect(System.IntPtr hWnd, out RECT lpRect);

      RECT from = new RECT(form.Location, form.Size);

      RECT to;

        GetWindowRect(hWnd, out to);

        DrawAnimatedRects(form.Handle, IDANI_CAPTION, ref to, ref from);

        DrawAnimatedRects(form.Handle, IDANI_CAPTION, ref from, ref to);

    ref struct RECT {

    RECT() {

    RECT(System::Drawing::Rectangle rectangle) {

        Left = rectangle.Left;

        Top = rectangle.Top;

        Right = rectangle.Right;

        Bottom = rectangle.Bottom;

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

    bool DrawAnimatedRects(int hwnd, int idAni, RECT^ lprcFrom, RECT^ lprcTo);

    bool GetWindowRect(int hWnd, RECT^ lpRect);

    RECT^ from=gcnew RECT(this->Location, this->Size);

    RECT^ to=gcnew RECT();

        GetWindowRect(hWnd, to);

        DrawAnimatedRects(this->Handle.ToInt32(), IDANI_CAPTION, to, from);

        DrawAnimatedRects(this->Handle.ToInt32(), IDANI_CAPTION, from, to);

static extern bool DrawEdge(IntPtr hdc, ref RECT qrc, uint edge,

RECT

static extern bool DrawFocusRect(IntPtr hDC, [In] ref RECT lprc);

RECT

    Public Declare Auto Function DrawFocusRect Lib "user32" ( _

    ByRef lpRect As Rect _

    <StructLayout(LayoutKind.Explicit)> Public Structure Rect

Where DrawFocusRect is used:

    Dim FR As Win32.Rect

    FR = New Win32.Rect

    Win32.DrawFocusRect(hdc, FR)      'static/shared method

        // The following style can be used to adjust the bounding rectangle of the push button.

        /// Bounding rectangle is adjusted to exclude the surrounding edge of the push button.

        DFCS_ADJUSTRECT = 0x2000,

   ref RECT lprc, uint dwDTFormat, ref DRAWTEXTPARAMS lpDTParams);

private const int DT_CALCRECT = 0x00000400;

   ref RECT lprc, uint dwDTFormat, ref DRAWTEXTPARAMS lpDTParams);

    delegate bool MonitorEnumDelegate(IntPtr hMonitor, IntPtr hdcMonitor, ref Rect lprcMonitor, IntPtr dwData);

    public struct Rect

        public Rect MonitorArea { get; set; }

        public Rect WorkArea { get; set; }

        delegate (IntPtr hMonitor, IntPtr hdcMonitor, ref Rect lprcMonitor,  IntPtr dwData)

static extern int FillRect(IntPtr hDC, [In] ref RECT lprc, IntPtr hbr);

Private Shared Function FillRect(hDC As IntPtr, ByRef lprc As RECT, hbr As IntPtr) As Integer

RECT

static extern int FrameRect(IntPtr hdc, [In] ref RECT lprc, IntPtr hbr);

RECT

static extern bool GetClientRect(IntPtr hWnd, out RECT lpRect);

Private Shared Function GetClientRect(ByVal hWnd As System.IntPtr, _

   ByRef lpRECT As RECT) As Integer

RECT

The Win32 RECT structure is not compatible with the .NET System.Drawing.Rectangle structure.

public static RECT GetClientRect(IntPtr hWnd)

    RECT result;

    GetClientRect(hWnd, out result);

RECT clientRect = GetClientRect(handle);

ClientRectangle property of the System.Windows.Forms.Control class

    public RECT rcItem;

    public RECT rcButton;

     Public rcItem As RECT

     Public rcButton As RECT

RECT

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/gdi/rectangl_0tiq.asp

    /// <summary>DCX_WINDOW: Returns a DC that corresponds to the window rectangle rather

    /// than the client rectangle.</summary>

        public System.Drawing.Rectangle rcCaret;

        public System.Drawing.Rectangle rcCaret;

    internal struct Rect

        public Rect rcCaret;

static extern bool GetMenuItemRect(IntPtr hWnd, IntPtr hMenu, uint uItem, out RECT lprcItem);

internal delegate bool MonitorEnumProc(IntPtr hMonitor, IntPtr hdcMonitor, ref RECT lprcMonitor, IntPtr dwData);

private bool MonitorEnumCallBack(IntPtr hMonitor, IntPtr hdcMonitor, ref RECT lprcMonitor, IntPtr dwData)

DoNotIndirectlyExposeMethodsWithLinkDemands

'NativeMethods.GetParentSafe(IntPtr)' calls into 'Marshal.GetLastWin32Error()' which has a LinkDemand. By making this call, 'Marshal.GetLastWin32Error()' is indirectly exposed to user code. Review the following protection:

    public Rectangle rcScrollBar;

This didn't work for me with the Rectangle type for SCROLLBARINFO.rcScrollBar. To rectify this I altered this declaration to type RECT using the following standard definition.

public struct RECT

Declare Function GetScrollInfo Lib "user32" (ByVal hWnd As IntPtr, ByVal fnBar As ScrollBarDirection, ByRef lpsi As SCROLLINFO) As Integer

      GetScrollInfo( RichTextBox1.Handle, (int) ScrollBarDirection.SB_HORZ, ref si );

The SM_ARRANGE setting specifies how the system arranges minimized windows, and consists of a starting position and a direction. The starting position can be one of the following values.

The direction in which to arrange can be one of the following values.

public extern static bool GetUpdateRect(IntPtr hWnd, ref RECT rect, bool bErase);

Private Shared Function GetUpdateRect(ByVal hWnd As IntPtr, ByRef rect As RECT, ByVal bErase As Boolean) As Boolean

RECT

Dim rRect As New RECT

GetUpdateRect(Me.Handle, rRect, bErase)