Vide BAP do Xbase++

    HDC hDC;  
    // target device context
    local nFlags := 4   // 4 for the client area DC or 0x1104 for the entire window DC
    local hDC := 0
    local hHandle := oPS:LockHDC(nFlags,@hDC)
         If a printer: hHandle := oXbpPrinter:GetHDC()

   // hHandle is a internal Xbase value if 0 = FAIL
      to release the hDC after using it
      oPs:UnlockHDC( nHandle, hDC)
      If a printer: oXbpPrinter:UnlockHDC()

   LPBYTE file
   // file name if the data is specified in a disk file, otherwise set to
    just use an Xbase++ string. The LPBYTE type not ensure a

   RECT far *rect;
   Just a pointer to rect you can pass a string like this
   L2Bin(nLeft) + L2Bin(nTop) + L2Bin(nRight) + L2Bin(nBottom)

   LONG StartPos;
   // starting character position.
   just an xbase number

   LPINT NextY;
   // (output) This location receives the Y position after printing the
   // entire buffer.
   pass a numeric by reference


Regarding the type of the variable in its own name, I use the following the
     Clipper and in association Pascal, respectively.

    Example: "aValores" is an ARRAY, and "lCor" is logic (boolean)

    CLIPPER:
     a arrays
     n numeric
     l logic
     c character
     d datae
     b code block
     o object
     x undefined (when can contains more than one type of var)

    DELPHI:
     i integer (byte, word, integer...)
     n numeric decimal (float point)
     f file, text ou file
     o object
     c char, shortstring, string
     r record
     p procedure
     d date/time (datetime)
     s set
     l boolean
     v variant
     t tstring
     x other

     Quando se trata de contadores numéricos gerais, como contador de um loop
     Numeric and loop copunters
     For using from I to N

     Example:
     for I:= 1 to N
     next

     or

     for I:= 1 to N do begin
     end;

     Character vars for generic usage from A to H and of indetemined usage from X to Z

     ----------------------
     Signaled numbers (positive and/or negative numbers)
     ============================
     Shortint: -128..127; 8-bits
     Smallint: -32768..32767; 16-bits
     Longint: -2147483648..2147483647; 32-bits
     Integer: -2147483648..2147483647; 32-bits
     Int64: -2^63..2^63-1; 64-bits

     Longint is the same as Integer (older) that was kept for compatibility purpose.
     Integer foi mantido para manter compatibilidade.
     -----------------------------

     Unsigned numbers (only positive values)
     ============================
     Byte: 0..255; 8-bits
     Word: 0..65535; 16-bits
     Longword: 0..4294967295 32-bits
     Cardinal: 0..4294967295; 32-bits


     Cardinal is the same as Longword and was kept only for compatibility purposes.
     -----------------------------

     Boolean
     ============================
     Boolean: 1 byte long

     Can be FALSE ou TRUE. Equivalent to Clipper logic type
     -----------------------------

     Character type.
     ============================
     Char: is only 1 char long. Is the same as the numeric "Byte"

     String: accepts a string. In ancient Pascal was the limit
      255 characters. In Object Pascal Delphi Lime 2 ^ 31 characters.
      You can limit the size with brackets. For example: String [50]
      that accepts only 50 characters.

     ShortString: max length 255 characters
     AnsiString: max length ~2^31 ANSI characters
     WideString: até ~2^30 Unicode characters
     -----------------------------


     Float point types
     ============================
     Real: the same as Double
     Real48: 2.9 x 10^-39..1.7 x 10^38; 6 bytes
     Single: 1.5 x 10^-45..3.4 x 10^38; 4 bytes
     Double: 5.0 x 10^-324..1.7 x 10^308; 8 bytes
     Extended: 3.6 x 10^-4951..1.1 x 10^4932; 10 bytes
     Comp: -2^63+1..2^63-1; 8 bytes
     Currency: -922337203685477.5808..922337203685477.5807; 8 bytes

     The floating-point variables have no equivalent in Clipper.
      Working with huge decimal places as you can look for tracks
      limits. Accuracy is with themselves ... But they must be used with
      parsimony because their calculations are so much slower than integer variables.
     -----------------------------


     Indexed vars (arrays)
     ============================
      Array of <tipo>
     Their sizes are defined between brackets. Example:

     aVet: array [1..17] of string[10];
     Defines an array of 17 elements type String each one with 10 bytes

     Also can be used as:
     aVet array [5..9] of char;
     Defines an array with 5 elements of Char type, but their valid indexes are from 5 to 9

     Another one use:

     aVet: array ['A'..'D'] of byte;
     defines an array of 4 elements tye Byte, but their indexes are type Char
     and only will be accept chars from 'A' to 'D', defined as range. They are case sensitive.