API - Application Programmer's Interface

When Microsoft wrote Windows they put a huge 
 amount of code into procedure libraries which programmers can access. No matter 
 which language you're using (VB, C++, ...) you can use the Windows API to 
 greatly expand the power of your application. 

 There are a lot of Windows programs whose code is 
 spread across multiple files. The .EXE file does not always contain all of the 
 code that a programmer might use. For example, by creating his own library of 
 procedures (usually in the form of a file with a .DLL extension) a programmer 
 can allow more than one of his applications to access the same code. 

 Microsoft does a similar thing with Windows. 
 There are many files which have code that you can access, but the three most 
 often named files are: 
 

        
• user32.dll - controls 
          the visible objects that you see on the screen 

        
• gdi32 - home of most 
          graphics oriented API 

        
• kernel32.dll - provides 
          access to low level operating system features 

 

Later, I'll bring up some of the other files 
 whose procedures you might want access. However, there are some key issues 
 which you should note before making a decision to use an API call. 
 

        
• Version Compatibility
  
          Microsoft has long been known to update it's files without much 
          fanfare - read that as without telling anyone about it until it's 
          already happened! And often, the updated code may not perform 
          exactly as did the older version. Users often find this out by 
          seeing unexected errors or by having their system crash and/or 
          lock up on them! In VB5 there were a huge number of programmer's 
          who got bit by this problem. 

  
          If you stick with the basic 3 OS 
          files listed above, you won't see to much of this. But the 
          further away you go from the main 3 files, the more likely you 
          are to get into code which hasn't seen the testing and 
          improvement cycle that the main Windows OS files have gone 
          through. 


        
• File Size
  
          One of the very major downsides to the concept of API is 
          that all of this great code lives in some very big files! Worse 
          yet, sometimes the API you want are spread over multiple files 
          and you may be using only one or two procedures from enormous 
          files which have hundreds of procedures in them. Where this 
          becomes a problem is in a)load time - where it can takes several 
          seconds to load the procedure libraries, and b) - where you want 
          to distribute your application and in order to make sure that all 
          of the procedure libraries are on your user's machine, you have 
          to put all of them into the distribute files. This can add many 
          megabytes of files to your distribution applications. It is a 
          major problem for distribution of software over the net, where 5 
          minutes per megabyte can deter a usage from trying out an 
          application just because he doesn't want to wait for the 
          download! 

        
• Documentation
  
          Finding the documentation of what procedures are in a library and 
          how to use them can be very difficult. On my PC I have 3,380 
          files with a .DLL extension with a total size of 539MB. That's a 
          lot of code! Unfortunately I can count on one hand the pages of 
          documentation that I have to tell me what that code is or does! 
          You'll learn how to use DLLs in this tutorial, but without 
          the documentation from the creator of the DLLs you cannot use 
          them successfully. 

 

Despite these problems, the powerful magic of 
 the API is that they are code which you don't have to write. If you've read my 
 Beginner's section you know that I am a big fan of using 3rd party software to 
 lighten my own programming load. As with 3rd party controls, the API provide 
 procedures which someone else wrote, debugged, and made availble for you to 
 benefit from. In the Windows DLLs files, there are literally thousands of 
 procedures. The key to API programming is learning which of these procedures 
 are useful and which ones you are unlikely to ever need! This tutorial tries to 
 address just that problem. 

Getting 
 Started It's actually simpler than you might imagine. By now, you've 
 already written procedures for your own VB programs. Using procedures from 
 other files is almost exactly the same as using procedures from within your own 
 program. 

The one big difference is that 
 you must tell your application which file the procedure is contained in. To do 
 so, you must put 1 line of code into your VB program. And, you have to do this 
 for every external procedure that you plan to use. I suppose it would be nice 
 for VB to have the ability to find the procedures for you - but you can see 
 that searching through the 3,380 procedures on my PC might slow my applications 
 down a lot! 

Ok, let's get to an 
 example. Telling VB about the procedure you want to use is known as "declaring" 
 the procedure, and (no surprise) it uses a statement which starts with the word 
 declare. Here's what a declaration looks like: 

Declare Function ExitWindowsEx Lib "user32" (ByVal uFlags as Long, ByVal dwReserved as Long) as Long

Let's take about the parts of the declaration 
 statement: 
 

        
• "Declare"
  
          This is reserved word that VB uses to begin a declaration. There 
          is no alternative - you have to use it. 

        
• "Function"
  
          Also a reserved word, but in this case it distinguishes between a 
          SUB procedured and a FUNCTION procedure. The API use Function 
          procedures so that they can return a value to indicate the 
          results of the action. Although you can discard the returned 
          value, it's also possible to check the return value to determine 
          that the action was successfully completed. completed. 
          alternative - you have to use it. 

        
• "ExitWindowsEx"
  
          Inside each DLL is a list of the procedures that it contains. 
          Normally, in a VB declaration statement you simply type in the 
          name of the procedure just as it is named in the DLL. Sometimes, 
          the DLL true name of the procedure may be a name that is illegal 
          in VB. For those cases, VB allows you to put in the text string 
          "Alias NewProcedurename" right behind the filename. In this 
          example, VB would make a call to the procedure by using the name 
          "NewProcedureName". 

        
• "Lib 'user32'"
  
          Here's where you tell VB which file the procedure is in. Normally 
          you would put "user32.dll", showing the extension of the 
          procedure library. For the special case of the three Windows 
          system DLLs listed above, the API will recognize the files when 
          simply named "user32", "kernel32", and "gdi32" - without the DLL 
          extensions shown. In most other cases you must give the complete 
          file name. Unless the file is in the system PATH, you must also 
          give the complete path to the file. 

        
• "(ByVal uFlags as Long ...)"
  
          Exactly like your own procedures, Windows API functions can have 
          a list of arguments. However, while your VB procedures often use 
          arguments passed by reference (i.e., their values can be 
          changed), most Windows API require that the arguments be passed 
          by value (i.e, a copy of the argument is passed to the DLL and 
          the originial variable cannot be changed). 

  
          Also, you'll note that a constant 
          or variable is normally used as the argument for an API call. 
          It's technically acceptable to simply use a number for an 
          argument but it is common practice among experienced programmers 
          to create constants (or variables) whose name is easy to remember 
          and then to use those in the argument list. When you're reading 
          or debugging your code later, the use of these easy to read 
          constant/variable names makes it much easier to figure out what 
          went wrong! 


        
• "as Long"
  
          This is exactly like the code you use to create your own 
          functions. Windows API are functions which return values and you 
          must define what type of variable is returned. 

 

While I make it sound simple (and it is), 
 there are still issues which ought to concern you when using the Windows API. 
 Because the API code executes outside the VB program itself, your own program 
 is susceptable to error in the external procedure. If the external procedure 
 crashes, then your own program will crash as well. It is very common for an API 
 problem to freeze your system and force a reboot. 

 The biggest issue that VB programmers would see 
 in this case is that any unsaved code will be lost!. So remember the 
 rule when using API - save often! 

 Because many of the DLLs you will use have been debugged extensively you 
 probably won't see many cases where the DLL crashes because of programming bug. 
 Far more frequently VB programmers will see a crash because they passed 
 arguments to the procedure which the procedure could not handle! For example, 
 passing a string when an integer was needed will likely crash the system. The 
 DLLs don't include extensive protection in order to keep their own code size 
 small and fast. 

It is simple to say 
 that if you pass the correct type of argument, that you won't see API crashes. 
 However, the documentation is not always clear exactly what argument type is 
 needed, plus when writing code it is all too common to simply make a mistake!
 

Finally, it is the case that most of 
 the DLLs you'll want to use were written in C++. The significance of this is 
 that the data types in C++ do not map cleanly into the data types that are used 
 in Visual Basic. Here are some of the issues which you need to be aware of:
 

        
• Issue1 

        
• Issue2 

 

Okay, stay with me just a bit longer and we'll 
 get into the actual use of some API. But first, here is a list of other DLLs 
 which have procedures that could be of use to you. These DLLs will show up 
 later in this tutorial when we get to the API which I recommend that you 
 consider for use in your own applications. 

        
• Advapi32.dll - Advanced API 
          services including many security and Registry calls 

        
• Comdlg32.dll - Common dialog 
          API library 

        
• Lz32.dll - 32-bit compression 
          routines 

        
• Mpr.dll - Multiple Provider 
          Router library 

        
• Netapi32.dll - 32-bit Network 
          API library 

        
• Shell32.dll - 32-bit Shell API 
          library 

        
• Version.dll - Version library
          

        
• Winmm.dll - Windows multimedia 
          library 

        
• Winspool.drv - Print spoolder 
          interface 

 

Often, the documentation that you might find 
 for an API will be written for a C++ programmer. Here's a short table which 
 helps you translate the C++ variable type declaration to its equivalent in 
 Visual Basic: 

 
 ATOM 
 ByVal variable as Integer 
 
 
 BOOL 
 ByVal variable as Long 
 
 
 BYTE 
 ByVal variable as Byte 
 
 
 CHAR 
 ByVal variable as Byte 
 
 
 COLORREF 
 ByVal variable as Long 
 
 
 DWORD 
 ByVal variable as Long 
 
 
 HWND 
 ByVal variable as Long 
 
 
 HDC 
 ByVal variable as Long 
 
 
 HMENU 
 ByVal variable as Long 
 
 
 INT 
 ByVal variable as Long 
 
 
 UINT 
 ByVal variable as Long 
 
 
 LONG 
 ByVal variable as Long 
 
 
 LPARAM 
 ByVal variable as Long 
 
 
 LPDWORD 
 variable as Long 
 
 
 LPINT 
 variable as Long 
 
 
 LPUINT 
 variable as Long 
 
 
 LPRECT 
 variable as Type any variable of that User 
 Type 
 
 
 LPSTR 
 ByVal variable as String 
 
 
 LPCSTR 
 ByVal variable as String 
 
 
 LPVOID 
 variable As Any use ByVal when passing a 
 string 
 
 
 LPWORD 
 variable as Integer 
 
 
 LPRESULT 
 ByVal variable as Long 
 
 
 NULL 
 ByVal Nothing or ByVal 0& or vbNullString
 
 
 
 SHORT 
 ByVal variable as Integer 
 
 
 VOID 
 Sub Procecure not applicable 
 
 
 WORD 
 ByVal variable as Integer 
 
 
 WPARAM 
 ByVal variable as Long 
 
 
 

We're not quite ready to get into using the 
 API. Here is a scattering of issues/comments about using API which you will 
 want to be aware of: 

        
• Declare 
          
  
                 
  • DECLARE in 
                   standard module are PUBLIC by default and be used 
                   anywhere in your app 
  
                 
  • DECLARE in any 
                   other module are PRIVATE to that module and MUST BE 
                   marked PRIVATE 
  
                 
  • Procedure names 
                   are CASE-SENSITIVE 
  
                 
  • You cannot 
                   Declare a 16-bit API function in VB6 
  
          
  
          

        
• ALIAS 
          
  
                 
  • Is the "real" 
                   name of the procedure as found in the DLL 
                   
  
                 
  • If the API uses 
                   string, you MUST use ALIAS with "A" to specify the 
                   correct character set (A=ANSI W=UNICODE) 
                   
  
                 
  • WinNT supports W, 
                   but Win95/Win98 do not 
  
                 
  • Some DLLs have 
                   illegal VB name, so you must use ALIAS to rename 
                   the procedure 
  
                 
  • Can also be the 
                   ordinal number of the procedure 
  
          
  
          

        
• Variable Type 
          
  
                 
  • Very few DLLs 
                   recognize VARIANT 
  
                 
  • ByRef is VB 
                   default 
  
                 
  • Most DLLs expect 
                   ByVal 
  
                 
  • In C 
                   documentation, C passes all arguments except arrays 
                   by value 
  
                 
  • AS ANY can be 
                   used but it turns off all type checking 
                   
  
          
  
          

        
• Strings 
          
  
                 
  • API generally 
                   require fixed length strings 
  
                 
  • Pass string ByVal 
                   means passing pointer to first data byte in the 
                   string 
  
                 
  • Pass string ByRef 
                   means passing memory address to another memory 
                   addresss which refers to first data byte in the 
                   string 
  
                 
  • Most DLLs expect 
                   LPSTR (ASCIIZ) strings (end in a null character), 
                   which point to the first data byte 
  
                 
  • VB Strings should 
                   be passed ByVal (in general) 
  
                 
  • VB uses BSTR 
                   strings (header + data bytes) - BSTR is passed as a 
                   pointer to the header 
  
                 
  • DLL can modify 
                   data in a string variable that it receives as an 
                   argument - WARNING: if returned value is longer 
                   than passed value, system error occurs! 
                   
  
                 
  • Generally, API do 
                   not expect string buffers longer than 255 
                   characters 
  
                 
  • C & VB both treat 
                   a string array as an array of pointers to string 
                   data 
  
                 
  • Most API require 
                   you to pass the length of the string and to fill 
                   the string wih spaces 
  
          
  
          

        
• Arrays 
          
  
                 
  • Pass entire array 
                   by passing the first element of the array ByRef
                   
  
                 
  • Pass individual 
                   elements of array just like any other variable
                   
  
                 
  • If pass pass 
                   binary data to DLL, use array of Byte characters
                   
  
          
  
          

        
• Callback Function 
          
  
                 
  • Use AddressOf to 
                   pass a user-defined function that the DLL procedure 
                   can use 
  
                 
  • Must have 
                   specific set of arguments, AS DEFINED by the API 
                   procedure 
  
                 
  • Procedure MUST be 
                   in a .BAS module 
  
                 
  • Passed procedure 
                   must be As Any or As Long 
  
          
  
          

        
• Passing a null value
          
          
  
                 
  • To pass a null 
                   value - zero-length string ("") will not work
                   
  
                 
  • To pass a null 
                   value - use vbNullString 
  
                 
  • To pass a null 
                   value - change Type to Long and then use 0& 
                   
  
          
  
          

        
• Window Handle 
          
  
                 
  • A handle is 
                   simply a number assigned by Windows to each window
                   
  
                 
  • In VB, the handle 
                   is the same as the property hWnd 
  
                 
  • Handles are 
                   always Long variable types 
  
          
  
          

        
• Callbacks 
          
  
                 
  • Some API can run 
                   one of you own VB functions. Your VB function is 
                   called a "Callback" 
  
                 
  • VB supports 
                   callbacks with a function "AddressOf", which give 
                   the API the location of the function to execute
                   
  
                 
  • Callback 
                   functions must be in a module. They cannot be in a 
                   form. 
  
          
  
          

        
• Subclassing 
          
  
                 
  • All windows work 
                   by processing messages from the Windows operating 
                   system 
  
                 
  • You can change 
                   how a window responds to a message by intercepting 
                   the message 
  
                 
  • To intercept a 
                   message, use the API SetWindowsLong 
  
          
  
          

        
• Miscellaneous 
          
  
                 
  • Control 
                   properties MUST be passed by value (use 
                   intermediate value to pass ByRef) 
  
                 
  • Handles - always 
                   declare as ByVal Long 
  
                 
  • Variant - to pass 
                   Variant to argument that is not a Variant type, 
                   pass the Variant data ByVal 
  
                 
  • UDT - cannot be 
                   passed except as ByRef 
  
          
  
          

 

Which API Should I Use?

 Finally we get to the good part. First the bad news, then the good news. In 
 this section I do not provide code that you can simply copy into your own 
 applications. The good news is that I provide a list of features that you might 
 want to incorporate into your own application and then tell you which of the 
 API to use. For the purposes of this relatively short tutorial, the best I can 
 do is to point you off in the right direction! 

 In case you don't know, VB6 comes with a tool to 
 help you use API in your own applications. The API Viewer is installed 
 automatically with VB, and to use it go to the Start/Programs/VB/Tools menu and 
 select "API Viewer". The viewer actions much like my own VB Information 
 Center Code Librarian in that you can browse through the various API, 
 select one for copying to the clipboard, and then paste the declaration into 
 your own application's code window. You'll definitely want to try this out. The 
 data file that comes with the viewer if very extensive, listing 1550 API 
 Declarations. 

In my case I use API 
 regularly, but I've never come close to using 1550 API. At best, I barely have 
 broken the 100 mark. It seems that for the most part I can get VB to do 
 whatever task I want without resorting to the API. However, in some cases you 
 just can do any better than a few lines of API code to get the job done! So, 
 here's my own list of useful tasks and the API needed to perform them: 
 

 
 
 Play 
 sound 
 Declare 
 Function sndPlaySound Lib "winmm.dll" Alias "sndPlaySoundA" (ByVal 
 lpszSoundName as string, ByVal uFlags as Long) as Long 

 Result = sndPlaySound (SoundFile, 1) 
 
 
  
 
 
 
 SubClassing 
 Declare 
 Function CallWindowProc Lib "user32" Alias "CallWindowProcA" (ByVal 
 lpPrevWndFunc as Long, ByVal hwnd as Long, byval msg as long, byval wParam as 
 long, byval lParam as Long ) as long 

 Declare Function SetWindowLong Lib "user32" Alias "SetWindowLongA" (ByVal hwnd 
 As Long, ByVal nIndex As Long, ByVal dwNewLong As Long) As Long 
 
 
  
 
 
 Run 
 associated EXE 
 Declare 
 Function ShellExecute Lib "shell32.dll" Alias "ShellExecuteA" (ByVal hwnd As 
 Long, ByVal lpOperation As String, ByVal lpFile As String, ByVal lpParameters 
 As String, ByVal lpDirectory As String, ByVal nShowCmd As Long) As Long 
 
 
 
  
 
 
 List 
 window handles 
 Declare 
 Function EnumWindows Lib "user32" (ByVal lpEnumFunc As Long, ByVal lParam As 
 Long) As Long 
 
 
  
 
 
 Find 
 prior instance of EXE 
 Declare 
 Function FindWindow Lib "user32" Alias "FindWindowA" (ByVal lpClassName As 
 String, ByVal lpWindowName As String) As Long 
 
 
  
 
 
 Draw 
 dotted rectangle 
 Declare 
 Function DrawFocusRect Lib "user32" Alias "DrawFocusRect" (ByVal hdc As Long, 
 lpRect As RECT) As Long 
 
 
  
 
 
 Invert 
 colors of rectangle 
 Declare 
 Function InvertRect Lib "user32" Alias "InvertRect" (ByVal hdc As Long, lpRect 
 As RECT) As Long 
 
 
  
 
 
 Get 
 cursor position 
 Declare 
 Function GetCursorPos Lib "user32" Alias "GetCursorPos" (lpPoint As POINTAPI) 
 As Long 
 
 
  
 
 
 Always on 
 top 
 Declare 
 Function SetWindowPos Lib "user32" Alias "SetWindowPos" (ByVal hwnd As Long, 
 ByVal hWndInsertAfter As Long, ByVal x As Long, ByVal y As Long, ByVal cx As 
 Long, ByVal cy As Long, ByVal wFlags As Long) As Long 
 
 
  
 
 
 Send 
 messages to a window 
 Declare 
 Function SendMessage Lib "user32" Alias "SendMessageA" (ByVal hwnd As Long, 
 ByVal wMsg As Long, ByVal wParam As Long, lParam As Any) As Long 
 
 
  
 
 
 Find 
 directories 
 Declare 
 Function GetWindowsDirectory Lib "kernel32" Alias "GetWindowsDirectoryA" (ByVal 
 lpBuffer As String, ByVal nSize As Long) As Long 

 Declare Function GetSystemDirectory Lib "kernel32" Alias "GetSystemDirectoryA" 
 (ByVal lpBuffer As String, ByVal nSize As Long) As Long 

 Declare Function GetTempPath Lib "kernel32" Alias "GetTempPathA" (ByVal 
 nBufferLength As Long, ByVal lpBuffer As String) As Long 

 Declare Function GetCurrentDirectory Lib "kernel32" Alias "GetCurrentDirectory" 
 (ByVal nBufferLength As Long, ByVal lpBuffer As String) As Long 
 
 
  
 
 
 Text 
 alignment 
 Declare 
 Function GetTextAlign Lib "gdi32" Alias "GetTextAlign" (ByVal hdc As Long) As 
 Long 

 Declare Function SetTextAlign Lib "gdi32" Alias "SetTextAlign" (ByVal hdc As 
 Long, ByVal wFlags As Long) As Long 
 
 
  
 
 
 Flash a 
 title bar 
 Declare 
 Function FlashWindow Lib "user32" Alias "FlashWindow" (ByVal hwnd As Long, 
 ByVal bInvert As Long) As Long 
 
 
  
 
 
 
 Manipulate bitmaps 
 Declare 
 Function BitBlt Lib "gdi32" Alias "BitBlt" (ByVal hDestDC As Long, ByVal x As 
 Long, ByVal y As Long, ByVal nWidth As Long, ByVal nHeight As Long, ByVal 
 hSrcDC As Long, ByVal xSrc As Long, ByVal ySrc As Long, ByVal dwRop As Long) 
 As Long 

 Declare Function PatBlt Lib "gdi32" Alias "PatBlt" (ByVal hdc As Long, ByVal x 
 As Long, ByVal y As Long, ByVal nWidth As Long, ByVal nHeight As Long, ByVal 
 dwRop As Long) As Long 

 Declare Function StretchBlt Lib "gdi32" Alias "StretchBlt" (ByVal hdc As Long, 
 ByVal x As Long, ByVal y As Long, ByVal nWidth As Long, ByVal nHeight As Long, 
 ByVal hSrcDC As Long, ByVal xSrc As Long, ByVal ySrc As Long, ByVal nSrcWidth 
 As Long, ByVal nSrcHeight As Long, ByVal dwRop As Long) As Long 

 Declare Function CreateCompatibleBitmap Lib "gdi32" Alias "CreateCompatibleBitmap" 
 (ByVal hdc As Long, ByVal nWidth As Long, ByVal nHeight As Long) As Long 

 Declare Function CreateCompatibleDC Lib "gdi32" Alias "CreateCompatibleDC" (ByVal 
 hdc As Long) As Long 
 
 
  
 
 
 Rotate 
 text 
 Declare 
 Function CreateFontIndirect Lib "gdi32" Alias "CreateFontIndirectA" (lpLogFont 
 As LOGFONT) As Long 
 
 
  
 
 
 Timing
 
 Declare 
 Function GetTickCount Lib "kernel32" Alias "GetTickCount" () As Long 
 
 
 
  
 
 
 File 
 information 
 Declare 
 Function GetFileAttributes Lib "kernel32" Alias "GetFileAttributesA" (ByVal 
 lpFileName As String) As Long 

 Declare Function GetFileSize Lib "kernel32" Alias "GetFileSize" (ByVal hFile 
 As Long, lpFileSizeHigh As Long) As Long 

 Declare Function GetFullPathName Lib "kernel32" Alias "GetFullPathNameA" (ByVal 
 lpFileName As String, ByVal nBufferLength As Long, ByVal lpBuffer As String, 
 ByVal lpFilePart As String) As Long 
 
 
  
 
 
 Get 
 window information 
 Declare 
 Function GetClassName Lib "user32" Alias "GetClassNameA" (ByVal hwnd As Long, 
 ByVal lpClassName As String, ByVal nMaxCount As Long) As Long 

 Declare Function GetWindowText Lib "user32" Alias "GetWindowTextA" (ByVal hwnd 
 As Long, ByVal lpString As String, ByVal cch As Long) As Long 

 Declare Function GetParent Lib "user32" Alias "GetParent" (ByVal hwnd As Long) 
 As Long 
 
 
  
 
 
 Identify 
 window at cursor 
 Declare 
 Function WindowFromPoint Lib "user32" Alias "WindowFromPoint" (ByVal xPoint As 
 Long, ByVal yPoint As Long) As Long 
 
 
  
 
 
 Registry 
 editing 
 Declare 
 Function RegCreateKey Lib "advapi32.dll" Alias "RegCreateKeyA" (ByVal hKey As 
 Long, ByVal lpSubKey As String, phkResult As Long) As Long 

 Declare Function RegDeleteKey Lib "advapi32.dll" Alias "RegDeleteKeyA" (ByVal 
 hKey As Long, ByVal lpSubKey As String) As Long 

 Declare Function RegDeleteValue Lib "advapi32.dll" Alias "RegDeleteValueA" (ByVal 
 hKey As Long, ByVal lpValueName As String) As Long 

 Declare Function RegQueryValueEx Lib "advapi32.dll" Alias "RegQueryValueExA" (ByVal 
 hKey As Long, ByVal lpValueName As String, ByVal lpReserved As Long, lpType As 
 Long, lpData As Any, lpcbData As Long) As Long 

 Declare Function RegSetValueEx Lib "advapi32.dll" Alias "RegSetValueExA" (ByVal 
 hKey As Long, ByVal lpValueName As String, ByVal Reserved As Long, ByVal 
 dwType As Long, lpData As Any, ByVal cbData As Long) As Long 
 
 
  
 
 
 Drawing 
 functions 
 Declare 
 Function MoveToEx Lib "gdi32" Alias "MoveToEx" (ByVal hdc As Long, ByVal x As 
 Long, ByVal y As Long, lpPoint As POINTAPI) As Long 

 Declare Function LineTo Lib "gdi32" Alias "LineTo" (ByVal hdc As Long, ByVal x 
 As Long, ByVal y As Long) As Long 

 Declare Function Ellipse Lib "gdi32" Alias "Ellipse" (ByVal hdc As Long, ByVal 
 X1 As Long, ByVal Y1 As Long, ByVal X2 As Long, ByVal Y2 As Long) As Long
 
 
 
  
 
 
 Get icon 
 Declare 
 Function 
 ExtractIcon Lib "shell32.dll" Alias "ExtractIconA" (ByVal hInst As Long, ByVal 
 lpszExeFileName As String, ByVal nIconIndex As Long) As Long 
 
 
  
 
 
 Screen 
 capture 
 Declare 
 Function SetCapture Lib "user32" Alias "SetCapture" (ByVal hwnd As Long) As 
 Long 

 Declare Function CreateDC Lib "gdi32" Alias "CreateDCA" (ByVal lpDriverName As 
 String, ByVal lpDeviceName As String, ByVal lpOutput As String, lpInitData As 
 DEVMODE) As Long 

 Declare Function DeleteDC Lib "gdi32" Alias "DeleteDC" (ByVal hdc As Long) As 
 Long 

 Declare Function BitBlt Lib "gdi32" Alias "BitBlt" (ByVal hDestDC As Long, 
 ByVal x As Long, ByVal y As Long, ByVal nWidth As Long, ByVal nHeight As Long, 
 ByVal hSrcDC As Long, ByVal xSrc As Long, ByVal ySrc As Long, ByVal dwRop As 
 Long) As Long 

 Declare Function ReleaseCapture Lib "user32" Alias "ReleaseCapture" () As Long
 

 Declare Function ClientToScreen Lib "user32" Alias "ClientToScreen" (ByVal 
 hwnd As Long, lpPoint As POINTAPI) As Long 
 
 
  
 
 
 Get user 
 name 
 Declare 
 Function GetUserName Lib "advapi32.dll" Alias "GetUserNameA" (ByVal lpBuffer 
 As String, nSize As Long) As LongDeclare Function GetUserName Lib 
 "advapi32.dll" Alias "GetUserNameA" (ByVal lpBuffer As String, nSize As Long) 
 As Long 
 
 
  
 
 
 Get 
 computer name 
 Declare 
 Function GetComputerName Lib "kernel32" Alias "GetComputerNameA" (ByVal 
 lpBuffer As String, nSize As Long) As LongDeclare Function GetComputerName Lib 
 "kernel32" Alias "GetComputerNameA" (ByVal lpBuffer As String, nSize As Long) 
 As Long 
 
 
  
 
 
 Get 
 volume name/serial# 
 Declare 
 Function GetVolumeInformation Lib "kernel32" Alias "GetVolumeInformationA" (ByVal 
 lpRootPathName As String, ByVal lpVolumeNameBuffer As String, ByVal 
 nVolumeNameSize As Long, lpVolumeSerialNumber As Long, 
 lpMaximumComponentLength As Long, lpFileSystemFlags As Long, ByVal 
 lpFileSystemNameBuffer As String, ByVal nFileSystemNameSize As Long) As Long
 
 
 
  
 
 
 Identify 
 drive type 
 Declare 
 Function GetDriveType Lib "kernel32" Alias "GetDriveTypeA" (ByVal nDrive As 
 String) As Long 
 
 
  
 
 
 Get free 
 space 
 Declare 
 Function GetDiskFreeSpace Lib "kernel32" Alias "GetDiskFreeSpaceA" (ByVal 
 lpRootPathName As String, lpSectorsPerCluster As Long, lpBytesPerSector As 
 Long, lpNumberOfFreeClusters As Long, lpTotalNumberOfClusters As Long) As Long
 
 
 
  
 
 
 INI 
 editing 
 Declare 
 Function WritePrivateProfileSection Lib "kernel32" Alias "WritePrivateProfileSectionA" 
 (ByVal lpAppName As String, ByVal lpString As String, ByVal lpFileName As 
 String) As Long 

 Declare Function WritePrivateProfileString Lib "kernel32" Alias "WritePrivateProfileStringA" 
 (ByVal lpApplicationName As String, ByVal lpKeyName As Any, ByVal lpString As 
 Any, ByVal lpFileName As String) As Long 

 Declare Function GetPrivateProfileInt Lib "kernel32" Alias "GetPrivateProfileIntA" 
 (ByVal lpApplicationName As String, ByVal lpKeyName As String, ByVal nDefault 
 As Long, ByVal lpFileName As String) As Long 

 Declare Function GetPrivateProfileSection Lib "kernel32" Alias "GetPrivateProfileSectionA" 
 (ByVal lpAppName As String, ByVal lpReturnedString As String, ByVal nSize As 
 Long, ByVal lpFileName As String) As Long 

 Declare Function GetPrivateProfileString Lib "kernel32" Alias "GetPrivateProfileStringA" 
 (ByVal lpApplicationName As String, ByVal lpKeyName As Any, ByVal lpDefault As 
 String, ByVal lpReturnedString As String, ByVal nSize As Long, ByVal 
 lpFileName As String) As Long 
 
 
  
 
 
 Put icon 
 in system tray 
 Declare 
 Function CallWindowProc Lib "user32" Alias "CallWindowProcA" (ByVal 
 lpPrevWndFunc As Long, ByVal hWnd As Long, ByVal Msg As Long, ByVal wParam As 
 Long, ByVal lParam As Long) As Long 

 Declare Function GetWindowLong Lib "user32" Alias "GetWindowLongA" (ByVal hwnd 
 As Long, ByVal nIndex As Long) As Long 

 Declare Function SetWindowLong Lib "user32" Alias "SetWindowLongA" (ByVal hwnd 
 As Long, ByVal nIndex As Long, ByVal dwNewLong As Long) As Long 

 Declare Function Shell_NotifyIcon Lib "shell32.dll" Alias " Shell_NotifyIconA" 
 (ByVal dwMessage As Long, lpData As NOTIFYICONDATA) As Long 

 Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (Destination As 
 Any, Source As Any, ByVal Length As Long) 

 Declare Function DrawEdge Lib "user32" Alias "DrawEdge" (ByVal hdc As Long, 
 qrc As RECT, ByVal edge As Long, ByVal grfFlags As Long) As Long 
 
 
  
 
 
 Wait for 
 program to stop 
 Declare 
 Function CreateProcess Lib "kernel32" Alias "CreateProcessA" (ByVal 
 lpApplicationName As String, ByVal lpCommandLine As String, 
 lpProcessAttributes As SECURITY_ATTRIBUTES, lpThreadAttributes As 
 SECURITY_ATTRIBUTES, ByVal bInheritHandles As Long, ByVal dwCreationFlags As 
 Long, lpEnvironment As Any, ByVal lpCurrentDriectory As String, lpStartupInfo 
 As STARTUPINFO, lpProcessInformation As PROCESS_INFORMATION) As Long 

 Declare Function WaitForSingleObject Lib "kernel32" Alias "WaitForSingleObject" 
 (ByVal hHandle As Long, ByVal dwMilliseconds As Long) As Long 
 
 
  
 
 
 Stop 
 ctrl-alt-del 
 Declare 
 Function SystemParametersInfo Lib "user32" Alias "SystemParametersInfoA" (ByVal 
 uAction As Long, ByVal uParam As Long, ByRef lpvParam As Any, ByVal fuWinIni 
 As Long) As Long