According to http://www.high-point.com/RadioControl.htm

According to http://www.high-point.com/RadioControl.htm

[DllImport("iPAQUtil.dll", EntryPoint = "iPAQGetSerialNumber")]

According to http://www.high-point.com/RadioControl.htm

According to http://www.high-point.com/RadioControl.htm

• "a+" - Open a file for reading and appending. All writing operations are performed at the end of the file, protecting the previous content to be overwritten. You can reposition (fseek, rewind) the internal pointer to anywhere in the file for reading, but writing operations will move it back to the end of file. The file is created if it does not exist.

[DllImport("msvcrt.dll", EntryPoint = "memcpy", CallingConvention = CallingConvention.Cdecl, SetLastError = false)]

    <DllImport("msvcrt.dll", EntryPoint:="memcpy", CallingConvention:=CallingConvention.Cdecl)> _

System.Buffer.BlockCopy, Marshal.Copy and Array.Copy provide similar services, but require one or two managed arrays instead of pointers.

[DllImport("msvcrt.dll", EntryPoint = "memset", CallingConvention = CallingConvention.Cdecl, SetLastError = false)]

<DllImport("msvcrt.dll", EntryPoint := "memset", CallingConvention := CallingConvention.Cdecl, SetLastError := False)> _

dest - Pointer to destination.

<DllImport("winspool.drv", EntryPoint:="ClosePrinter", _

[DllImport("winspool.Drv", EntryPoint = "DocumentPropertiesW", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]

  <DllImport("winspool.Drv", EntryPoint:="DocumentPropertiesW", SetLastError:=True, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _

Obtain a pointer to the DEVMODE struct (either printerHandle or printerName can be NULL | IntPtr.ZERO):

        /// Pointer to a null-terminated string that specifies the name of the driver (for example, QMS 810).

        /// Pointer to a null-terminated string that specifies the environment for which the driver was written (for example, Windows NT x86, Windows IA64, and Windows x64.

        /// Pointer to a null-terminated string that specifies a file name or a full path and file name for the file that contains the device driver (for example, C:\DRIVERS\Pscript.dll).

        /// Pointer to a null-terminated string that specifies a file name or a full path and file name for the file that contains driver data (for example, C:\DRIVERS\Qms810.ppd).

        /// Pointer to a null-terminated string that specifies a file name or a full path and file name for the device driver's configuration dynamic-link library (for example, C:\DRIVERS\Pscrptui.dll).

        /// Pointer to a null-terminated string that specifies a file name or a full path and file name for the device driver's help file (for example, C:\DRIVERS\Pscrptui.hlp).

        /// A pointer to a MultiSZ buffer that contains a sequence of null-terminated strings. Each null-terminated string in the buffer contains the name of a file the driver depends on. The sequence of strings is terminated by an empty, zero-length string. If pDependentFiles is not NULL and does not contain any file names, it will point to a buffer that contains two empty strings.

        /// A pointer to a null-terminated string that specifies a language monitor (for example, "PJL monitor"). This member can be NULL and should be specified only for printers capable of bidirectional communication.

        /// A pointer to a null-terminated string that specifies the default data type of the print job (for example, "EMF").

        /// A pointer to a null-terminated string that specifies previous printer driver names that are compatible with this driver. For example, OldName1\0OldName2\0\0.

        /// Pointer to a null-terminated string that specifies the manufacturer's name.

        /// Pointer to a null-terminated string that specifies the URL for the manufacturer.

        /// Pointer to a null-terminated string that specifies the hardware ID for the printer driver.

        /// Pointer to a null-terminated string that specifies the provider of the printer driver (for example, "Microsoft Windows 2000")

[DllImport("Winspool.drv", SetLastError=true, EntryPoint="EnumJobsA")]

    'Copy data from the datas array to the unmanaged memory pointer.

    'Marshal data from the buffer pointer to a managed object.

[DllImport("winspool.drv", EntryPoint="EnumPrintProcessorDatatypes")]

    EntryPoint = "FindFirstPrinterChangeNotification",

[DllImport("winspool.Drv", EntryPoint="FlushPrinter", SetLastError=true, CharSet=CharSet.Ansi,ExactSpelling=true, CallingConvention=CallingConvention.StdCall)]

[DllImport("winspool.Drv", EntryPoint = "OpenPrinterA", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]

   <DllImport("winspool.drv", EntryPoint:="OpenPrinterA", _

   <DllImport("winspool.drv", EntryPoint:="OpenPrinterA", ExactSpelling:=True, _

   <DllImport("winspool.drv", EntryPoint:="OpenPrinterA", ExactSpelling:=True, _

   [<DllImport("winspool.drv", EntryPoint="OpenPrinterA", SetLastError=true, CharSet=CharSet.Ansi, ExactSpelling=true,  

    [DllImport("winspool.Drv", EntryPoint = "ReadPrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]

[DllImport("winspool.Drv", EntryPoint="ResetPrinterA", SetLastError=true, CharSet=CharSet.Ansi,ExactSpelling=true, CallingConvention=CallingConvention.StdCall)]

[DllImport("winspool.drv", EntryPoint="SetJobA")]

[DllImport("winspool.drv", EntryPoint = "WritePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]

    <DllImport("winspool.Drv", EntryPoint:="WritePrinter", SetLastError:=True, CharSet:=CharSet.Unicode, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _

        GL_POINT_BIT = 0x00000002,

        GL_POINTS = 0x0000,

        GL_POINT_TOKEN = 0x0701,

        GL_POINT_SMOOTH = 0x0B10,

        GL_POINT_SIZE = 0x0B11,

        GL_POINT_SIZE_RANGE = 0x0B12,

        GL_POINT_SIZE_GRANULARITY = 0x0B13,

        GL_POINT_SMOOTH_HINT = 0x0C51,

        GL_FEEDBACK_BUFFER_POINTER = 0x0DF0,

        GL_SELECTION_BUFFER_POINTER = 0x0DF3,

        GL_POINT = 0x1B00,

        GL_POLYGON_OFFSET_POINT = 0x2A01,

        GL_VERTEX_ARRAY_POINTER = 0x808E,

        GL_NORMAL_ARRAY_POINTER = 0x808F,

        GL_COLOR_ARRAY_POINTER = 0x8090,

        GL_INDEX_ARRAY_POINTER = 0x8091,

        GL_TEXTURE_COORD_ARRAY_POINTER = 0x8092,

        GL_EDGE_FLAG_ARRAY_POINTER = 0x8093,

        GL_VERTEX_ARRAY_POINTER_EXT = 0x808E,

        GL_NORMAL_ARRAY_POINTER_EXT = 0x808F,

        GL_COLOR_ARRAY_POINTER_EXT = 0x8090,

        GL_INDEX_ARRAY_POINTER_EXT = 0x8091,

        GL_TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092,

        GL_EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093,

        GLU_POINT = 100010,

    public static extern void glColorPointer(int size, uint type, int stride, int[] pointer);

    public static extern void glEdgeFlagPointer(int stride, int[] pointer);

    public static extern void glEvalPoint1(int i);

    public static extern void glEvalPoint2(int i, int j);

    public static extern void glGetPointerv(uint pname, int[] params_notkeyword);

    public static extern void glIndexPointer(uint type, int stride, int[] pointer);

    public static extern void glInterleavedArrays(uint format, int stride, int[] pointer);

    public static extern void glMap1d(uint target, double u1, double u2, int stride, int order, double[] points);

    public static extern void glMap1f(uint target, float u1, float u2, int stride, int order, float[] points);

    public static extern void glMap2d(uint target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, double[] points);

    public static extern void glMap2f(uint target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float[] points);

    public static extern void glNormalPointer(uint type, int stride, float[] pointer);

    public static extern void glPointSize(float size);

    public static extern void glTexCoordPointer(int size, uint type, int stride, float[] pointer);

    public static extern void glVertexPointer(int size, uint type, int stride, float[] pointer);

[DllImport("opengl32", EntryPoint = "wglUseFontOutlines", CallingConvention=CallingConvention.Winapi)]

    public POINTFLOAT  gmfptGlyphOrigin;

public struct POINTFLOAT

                    System.Drawing.GraphicsUnit.Point,

When the function succeeds, the caller of this function can free the memory pointed to by pbFont because the system has made its own copy of the memory. To remove the fonts that were installed, call RemoveFontMemResourceEx. However, when the process goes away, the system will unload the fonts even if the process did not call RemoveFontMemResourceEx.

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

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

[DllImport("gdi32.dll", EntryPoint = "BitBlt", SetLastError = true)]

[DllImport("gdi32.dll", EntryPoint = "CopyEnhMetaFile", SetLastError = true, CharSet = CharSet.Auto)]

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

[DllImport("gdi32.dll", EntryPoint = "CreateCompatibleDC", SetLastError=true)]

    [DllImport("gdi32.dll", EntryPoint = "CreateDC", CharSet = CharSet.Auto, SetLastError = true)]

If the function succeeds, the return value is a handle to the newly created device-independent bitmap (and ppvBits will point to the bitmap’s bit values). If the function fails, the return value is NULL (and ptr ppvBits will be NULL). To get extended error information, call GetLastError.

in Pointer to a null-terminated character string that specifies the name of the device driver (for example, Epson).

in Pointer to a null-terminated character string that specifies the name of the specific output device being used, as shown by the Print Manager (for example, Epson FX-80). It is not the printer model name. The lpszDevice parameter must be used.

in Pointer to a DEVMODE structure containing device-specific initialization data for the device driver. The DocumentProperties function retrieves this structure filled in for a specified device. The lpdvmInit parameter must be NULL if the device driver is to use the default initialization (if any) specified by the user.

// create a bitmap and get a pointer suitable for GDI

void PaintLine3(IntPtr hbitmap, Point start, Point end, bool erase)

Please update references to point to the new topic.

static extern IntPtr CreatePolygonRgn(POINT [] lppt, int cPoints,

POINT

System.Drawing.Point can be used instead POINT.

static extern IntPtr CreatePolygonRgn(Point[] lppt, int cPoints, int fnPolyFillMode);

static extern IntPtr CreatePolyPolygonRgn(POINT [] lppt, int [] lpPolyCounts,

POINT

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

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

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

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

static extern bool DPtoLP(IntPtr hdc, [In, Out] POINT [] lpPoints, int nCount);

POINT

POINT [] points = { new POINT(rect.Left, rect.Top), new POINT(rect.Right, rect.Bottom) };

bool ret = DPtoLP(m_hdc, points, 2);

        //If anyone knows of a better way to get the pointer please let me know

        //If anyone knows of a better way to get the pointer please let me know

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

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

static extern bool GetBrushOrgEx(IntPtr hdc, out POINT lppt);

POINT

/// <param name="iFirstChar">Specifies the code point of the first character in the group of consecutive

/// <param name="iLastChar">Specifies the code point of the last character in the group of consecutive

/// <param name="lpABCF">Pointer to an array of ABCFLOAT structures that receives the character widths,

/// function retrieves widths for any font. The widths returned by this function are in the IEEE floating-point

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

static extern bool GetCurrentPositionEx(IntPtr hdc, out POINT lpPoint);

POINT

static extern bool GetDCOrgEx(IntPtr hdc, out POINT lpPoint);

POINT

/// <param name="lpvBits">A pointer to a buffer to receive the bitmap data. If this parameter is <see cref="IntPtr.Zero"/>, the function passes the dimensions and format of the bitmap to the <see cref="BITMAPINFO"/> structure pointed to by the <paramref name="lpbi"/> parameter.</param>

/// <param name="lpbi">A pointer to a <see cref="BITMAPINFO"/> structure that specifies the desired format for the DIB data.</param>

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

• lpvBuffer: Points to a byte array to receive the font information. If this parameter is NULL, the function returns the size of the buffer required for the font data.

    /// <param name="lpvBuffer">Points to a lpvBuffer to receive the font information. If this parameter is NULL, the function returns the size of the <paramref name="lpvBuffer"/> required for the font data.</param>

    [MarshalAs(UnmanagedType.Struct)] public POINTFX pfxStart;

    public struct POINT

    public struct POINTFX

    [MarshalAs(UnmanagedType.Struct)] public POINT gmptGlyphOrigin;

                            int pointFxSize = Marshal.SizeOf(typeof(POINTFX));

                                    POINTFX[] curvePoints = new POINTFX[curveHeader.cpfx];

                                        curvePoints[i] = (POINTFX)Marshal.PtrToStructure(new IntPtr(buffer.ToInt32()+index), typeof(POINTFX));

                                        index+=pointFxSize;

                                            short x = curvePoints[i].x.value;

                                            short y = (short)-curvePoints[i].y.value;

    // ...do something with line points...

                                            POINTFX pfxB = curvePoints[i];

                                            POINTFX pfxC = curvePoints[i+1];

                                            } // ...do something with curve points...

static extern int GetPath(IntPtr hdc, [Out] POINT [] lpPoints,

POINT

      // Since pointers are used, this whole routine is 'unsafe'

      // [RBS] Added missing second pointer identifier

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

static extern bool GetTextExtentExPoint(IntPtr hdc, [MarshalAs(UnmanagedType.LPWStr)] string lpszStr,

static extern bool GetTextExtentPoint32(IntPtr hdc, string lpString,

static extern bool GetTextExtentPoint32(IntPtr hdc, string lpString, int cbString, out SIZE lpSize);

    GDI.GetTextExtentPoint32(hdc, text, text.Length,out sz);

static extern bool GetTextExtentPoint32(IntPtr hdc, string lpString,

static extern bool GetTextExtentPoint32(IntPtr hdc, string lpString,

    GDI.GetTextExtentPoint32(hdc, text, text.Length,out sz);

static extern bool GetViewportOrgEx(IntPtr hdc, out POINT lpPoint);

POINT

static extern bool GetWindowOrgEx(IntPtr hdc, out POINT lpPoint);

POINT