HWND CreateWindow(
    LPCTSTR lpClassName,  // pointer to registered class name
    LPCTSTR lpWindowName, // pointer to window name
    DWORD dwStyle,    // window style
    int x,            // horizontal position of window
    int y,            // vertical position of window
    int nWidth,       // window width
    int nHeight,      // window height
    HWND hWndParent,  // handle to parent or owner window
    HMENU hMenu,      // handle to menu or child-window identifier
    HANDLE hInstance, // handle to application instance
    LPVOID lpParam    // pointer to window-creation data
   );

General CONFUSION When I first tried to understand the relation and corespondence of Pascal number variables (Byte, Word, Cardinal, Integer) and the C-Code number variables, It somehow seemed Clear (direct corespondence) and Confused to me at the same time. Much of my confusion came from the code variable naming "Traditions" used in both MS C-Code Help and in Borland-Delphi Pascal. I know that I looked at many pascal "Code Examples" to show how to use API functions, with a "Wild Mix" and confusing use of variable type declaration. Like this- var Style: LongWord; Parent: HWND; uReturn: UINT; Insts: DWord; hMenu: THandle; Param: ULONG; dwCap: Cardinal; From this variable declaration, I somehow thought that all of these variable types were "Different" and need to be "Exactly" like this for the function to work. There are seven different variable types used above, for the Same unsigned 32-bit number variable type, the Delphi-Pascal Cardinal type. The to the delphi code compilier it would be - var Style: Cardinal; Parent: Cardinal; uReturn: Cardinal; Insts: Cardinal; hMenu: Cardinal; Param: Cardinal; dwCap: Cardinal; You may be helped if you can see that there are MANY diferent variable type names for 32-bit numbers. An Integer type is the same as all of these - LongInt, Long, Int . . Here at Delphi Zeus, I try to use the "Cardinal" and "Integer" for all variable declarations of 32-bit numbers.

Pointer Types
• Since many parameters in a windows API function are declared as a Pointer type, it was nessary to have many pointer types declared in windows.pas, here are some of the more common -
LPSTR = PChar;
PByte = ^Byte;
PLongint = ^Longint;
PInteger = ^Integer;
PINT = ^Integer;
PLongWord = ^LongWord;
PSmallInt = ^Smallint;
PDWORD = ^DWORD;
LPDWORD = PDWORD;
PDouble = ^Double;
PShortInt = ^ShortInt;

Please Note - Because many API functions were used in 16-BIT Windows OS, Usually the C-Code pointer types do not have a "P" in front of them, they Have a "LP" to prefix the Normal type, like "LPDWORD". Not all of the parameter variable types in the "Win32 API Help" Function defintions can be directly "translated" to Delphi Pascal variable types, particulaly the ones with a LP prefix. You will see a LPDWORD type (a pointer type) in the API Help and the Delphi Pascal function will use a Cardinal type (a non-pointer type) for it's parameter. Many times this is due to different Methods that parameters can be passed in Pascal and C-Code. As an Example, let's look at the GetComputerName( ) function. This is how it is defined in the API Help -

BOOL GetComputerName(
    LPTSTR lpBuffer,  // address of name buffer 
    LPDWORD nSize     // address of size of name buffer 
   );

function GetComputerName(
    lpBuffer: PChar;  // address of name buffer 
    var nSize: Cardinal // size of name buffer
    ): Boolean;

A common variable name "Identifier" for a pointer type in API C-Code is "buffer", as in lpBuffer above. This is used many times for an "Output" variable name, of a memory block that will recieve the information from the function, often a PChar type. The pointer name lpBuffer may also be used for an Input parameter, if the pointer is UnTyped. You must remember that the Delphi compilier does NOT initialize a Pointer type with any memory, so you will need to to get a memory allocation for any pointer type that you pass to an API function as a "Buffer".

  C Strings, a LPSTR Pointer Type
You will see several Pointer to "string" types used in the API Help. These strings are Null terminated character arrays, Usually a Pointer to this string is used, with a type designation, based on a Long Pointer "LP" to a String "STR", a LPSTR API type, which is usually a PChar Delphi Pascal type. However, the LPSTR type is almost never used in the documentation, additional Charaters may be added to LPSTR, between the "LP" and the "STR" to try an give additional information about how this string may be used as the function parameter. A "CT" is added for LPCTSTR, which may indicate that this is an Input string, and not changed by the function (But for Delphi it is still a PChar type). Another is LPTSTR, the " T " may indicate that this is an Output string, and the function does Not read this string, but adds charaters to this string for a function output. In some Structures (Records) a LPCSTR may be used as a pointer to a String type, (Still a Pascal PChar). And you may see a few other letters between the "LP" and "STR", but it will again be a Pascal PChar type.

VOID ZeroMemory(
   PVOID Destination,
   DWORD Length  
   );

procedure ZeroMemory(
   Destination: Pointer;
   Length: Cardinal
   );

// for a POINT

typedef struct tagPOINT {
    LONG x;
    LONG y;
} POINT;

// for a RECT

typedef struct _RECT {
    LONG left;
    LONG top;
    LONG right;
    LONG bottom;
} RECT;

"the \\ is an \"Escape\" character"

\t   Tab Stop
\'   Single Quote
\"   Double Quote
\?   Question Mark
\\   Backslash
\n   New Line
\r   Carriage Return
\b   Backspace

procedure GetText;
  var
  Length: Integer;
  Text: PChar;
  Str1: String;

begin
Length := GetWindowTextLength(hEdit1)+1;
if Length < 2 then Exit;
GetMem(Text,Length);
GetWindowText(hEdit1,Text,Length);
Str1 := String(Text);
FreeMem(Text);
end;

HANDLE hFile;  // variables are listed at the begining
               // there is NO declaration like "var"
 
HANDLE hTempFile; 
 
DWORD  dwBytesRead, dwBytesWritten; 
 
char szTempName[MAX_PATH]; 
    // szTempName would be an Array[0..MAX_PATH] of Char
char buffer[4096]; 
 
// Open the file. 
 
hFile = CreateFile("ORIGINAL.TXT",        // filename 
// double quotes are use like single quote for Text
    GENERIC_READ,                 // open for reading 
    0,                            // do not share 
    NULL,                         // no security 
    OPEN_EXISTING,                // existing file only 
    FILE_ATTRIBUTE_NORMAL,        // normal file 

    NULL);                        // no attr. template 
if (hFile == INVALID_HANDLE_VALUE) { 
    ErrorHandler("Could not open file."); // process error 
} 
 
// Create a temporary file. 
 
GetTempFileName("\\TEMP", // dir. for temp. files 
    "NEW",                // temp. filename prefix 
    0,                    // create unique name 
    szTempName);          // buffer for name 

hTempFile = CreateFile((LPTSTR) szTempName,  // filename
// the (LPTSTR) szTempName is roughly like Typecasting in Pascal
// PChar(szTempName); 
    GENERIC_READ | GENERIC_WRITE, // open for read-write 

    0,                            // do not share 
    NULL,                         // no security 
    CREATE_ALWAYS,                // overwrite existing file
    FILE_ATTRIBUTE_NORMAL,        // normal file 
    NULL);                        // no attr. template 

if (hTempFile == INVALID_HANDLE_VALUE) { 
    ErrorHandler("Could not create temporary file."); 
}  

do 
{
    if (ReadFile(hFile, buffer, 4096, 
        &dwBytesRead, NULL)) { 
// the & above is roughly like the @ in Pascal
        CharUpperBuff(buffer, dwBytesRead); 
 
        WriteFile(hTempFile, buffer, dwBytesRead, 
            &dwBytesWritten, NULL); 
    } 
} while (dwBytesRead == 4096);  
 
CloseHandle(hFile); 
CloseHandle(hTempFile); 
 
// Move the temporary file to the new text file.
 
if (!MoveFile(szTempName, "ALLCAPS.TXT")) { 
    ErrorHandler("Could not move temp. file."); 

}

var
hFile, hTempFile: THandle; 
BytesRead, BytesWritten: Cardinal; 
TempName: Array[0..MAX_PATH] of Char; 
buffer: Array[0..4095] of Char;

hFile := CreateFile('ORIGINAL.TXT',        // filename 
    GENERIC_READ,                 // open for reading 
    0,                            // do not share 
    nil,                         // no security 
    OPEN_EXISTING,                // existing file only 
    FILE_ATTRIBUTE_NORMAL,        // normal file 
    0);                        // no attr. template 
if hFile = INVALID_HANDLE_VALUE then
  begin 
  ErrorHandler('Could not open file.'); // process error
  Exit;
  end;

// Create a temporary file. 
 
GetTempFileName('\\TEMP', // dir. for temp. files 
    'NEW',                // temp. filename prefix 
    0,                    // create unique name 
    TempName);          // buffer for name 

hTempFile := CreateFile(TempName,  // filename 
    GENERIC_READ or GENERIC_WRITE, // open for read-write 

    0,                            // do not share 
    nil,                         // no security 
    CREATE_ALWAYS,                // overwrite existing file
    FILE_ATTRIBUTE_NORMAL,        // normal file 
    0);                        // no attr. template 

if hTempFile = INVALID_HANDLE_VALUE then
  begin
  CloseHandle(hFile); 
  ErrorHandler('Could not create temporary file.');
  Exit;
  end;

Repeat
  if ReadFile(hFile, buffer, SizeOf(buffer), 
        BytesRead, nil) then 
   begin
   CharUpperBuff(buffer, BytesRead); 
   WriteFile(hTempFile, buffer, BytesRead, 
            BytesWritten, nil);
   end;
until BytesRead <> SizeOf(buffer); // 4096 
 
CloseHandle(hFile); 
CloseHandle(hTempFile);

// Move the temporary file to the new text file.
 
if not MoveFile(TempName, 'ALLCAPS.TXT') then 
    ErrorHandler('Could not move temp. file.');