.lib "Advapi32.dll"

ADVAPI32_RegOpenKey%(hKeyParent%,SubKey$,phkResult*):"RegOpenKeyA"
ADVAPI32_RegCloseKey%(hKey%):"RegCloseKey"
ADVAPI32_RegFlushKey%(hKey%):"RegFlushKey"
ADVAPI32_RegCreateKey%(hKeyParent%,SubKey$,phkResult*):"RegCreateKeyA"
ADVAPI32_RegDeleteKey%(hKeyParent%,SubKey$):"RegDeleteKeyA"
ADVAPI32_RegSetValueEx%(hKey%,ValueName$,Reserved%,nType%,Bytes*,size%):"RegSetValueExA"
ADVAPI32_RegDeleteValue%(hKey%,ValueName$):"RegDeleteValueA"
ADVAPI32_RegEnumKey%(hKey%,idx%,Key*,size%):"RegEnumKeyA"
ADVAPI32_RegEnumValue%(hKey%,idx%,ValueName*,NameSize*,Reserved%,nType*,ValueBytes*,ValueSize*):"RegEnumValueA"
ADVAPI32_RegQueryValueEx%(hKey%,ValueName$,Reserved%,nType*,ValueBytes*,ValueSize*):"RegQueryValueExA"

;---------------------------------------------------
; REQUIRES ADVAPI32.DECLS
;---------------------------------------------------


; REGISTRY ROOTS
Const HKEY_CLASSES_ROOT         = -2147483648
Const HKEY_CURRENT_USER         = -2147483647
Const HKEY_LOCAL_MACHINE      = -2147483646
Const HKEY_USERS         = -2147483645

; RETURN VALUE CONSTANTS
Const ERROR_SUCCESS          = 0
Const ERROR_EOF            = 259     ; NO MORE ENTRIES IN KEY

; DATA TYPES FOR KEYS
Const REG_SZ            = 1   ; DATA STRING
Const REG_EXPAND_SZ         = 2
Const REG_BINARY         = 3   ; BINARY DATA IN ANY FORM.
Const REG_DWORD            = 4    ; A 32-BIT NUMBER.
Const REG_MULTI_SZ         = 7 

; GLOBAL VAR HOLDING LAST ERROR #
Global reg_lasterr         = ERROR_SUCCESS


;---------------------------------------------------
; ENUMERATES THE KEYS CONTAINED IN THE PASSED SUBKEY
; AND RETURNS THEM AS A DELIMITED STRING IN THE FORMAT:
; KEY=VALUE|KEY=VALUE|KEY=VALUE
;---------------------------------------------------
Function Reg_EnumValues$(RegKey%,SubKey$,delim$="|",types=False)
   
   Local cRetVal$ = "",key$="",val$=""
   Local keybank  = CreateBank(100),keybanksize=CreateBank(4),valbank=CreateBank(100),valbanksize=CreateBank(4),typebank=CreateBank(4)
   Local char     = 0
   Local nIdx     = 0
   Local nType    = 0

   ; OPEN THE KEY
   Local hKey = Reg_OpenKey(RegKey,SubKey$)
   If hKey<>-1   
      ; READ IN THE VALUES
      Repeat
         ; INIT THE BANKS
         PokeInt (typebank,0,0)
         PokeInt (valbanksize,0,100)
         PokeInt (keybanksize,0,100)
      
         ; CLEAR OUT THE TEMP VALUES
         key$=""
         val$=""
         
         If ADVAPI32_RegEnumValue(hKey,nIdx,keybank,keybanksize,0,typebank,valbank,valbanksize)<>ERROR_EOF
            nType = PeekInt(typebank,0)
            
            ; TACK ON THE DELIMITER
            If cRetVal$<>""
               cRetVal$ = cRetVal$+delim$
            EndIf

            ; BUILD THE KEY NAME
            For char = 0 To PeekInt (keybanksize,0)-1
               If PeekByte (keybank,char)=0 Then Exit
               key$ = key$ + Chr(PeekByte(keybank,char))
            Next

            Select nType
               ; READ IN A STRING OR BINARY VALUE
               Case REG_SZ, REG_BINARY, REG_EXPAND_SZ
                  ; BUILD THE VALUE
                  For char = 0 To PeekInt (valbanksize,0)-1
                     If PeekByte (valbank,char) = 0 Then Exit
                     val$ = val$ + Chr(PeekByte (valbank,char))
                  Next
               ; READ IN AN INTEGER
               Case REG_DWORD
                  val$ = PeekInt(valbank,0)                  
            End Select

            If types
               cRetVal$ = (cRetVal$+PeekInt(typebank,0)+";"+key$+"="+val$)
            Else
               cRetVal$ = (cRetVal$+key$+"="+val$)
            EndIf
         Else
            Exit
         EndIf         
         
         nIdx=nIdx+1
      Forever
      Reg_CloseKey(hKey)
   EndIf
   
   FreeBank typebank
   FreeBank valbank
   FreeBank valbanksize
   FreeBank keybank
   FreeBank keybanksize
   
   Return cRetVal$

End Function


;---------------------------------------------------
; ENUMERATES THE KEYS CONTAINED IN THE PASSED SUBKEY
; AND RETURNS THEM AS A DELIMITED STRING IN THE FORMAT:
; KEY|KEY|KEY
;---------------------------------------------------
Function Reg_EnumKeys$(RegKey%,SubKey$,delim$="|")

   Local cRetVal$ = ""
   Local keybank  = CreateBank(100)
   Local nIdx     = 0

   ; OPEN THE KEY FIRST   
   Local hKey=Reg_OpenKey(RegKey,SubKey$)
   If hKey <> -1   
      Repeat         
         If ADVAPI32_RegEnumKey(hKey,nIdx,keybank,BankSize(keybank))<>ERROR_EOF         
            ; TACK ON THE DELIMITER
            If cRetVal$ <> ""
               cRetVal$=cRetVal$+delim$
            EndIf
            
            For char = 0 To BankSize (keybank)-1
               If PeekByte (keybank,char)=0 Then Exit
               cRetVal$ = cRetVal$ + Chr(PeekByte (keybank,char))
            Next
         Else
            Exit
         EndIf
         
         nIdx = nIdx + 1
      Forever
      Reg_CloseKey(hKey)
   EndIf

   FreeBank keybank
   Return cRetVal$

End Function


;---------------------------------------------------
; DELETES A VALUE FROM THE REGISTRY.  RETURNS TRUE/FALSE.
;---------------------------------------------------
Function Reg_DeleteValue%(RegKey%,SubKey$,ValueName$)
   
   Local hKey    = Reg_OpenKey(RegKey,SubKey$)
   Local lRetVal = False
   If hKey <> -1
      Local nRslt = ADVAPI32_RegDeleteValue(hKey,ValueName$)      
      If (nRslt = ERROR_SUCCESS)
         lRetVal = True
      Else
         reg_lasterr = nRslt
      EndIf
      Reg_CloseKey(hKey)
   EndIf
   Return lRetVal

End Function


;---------------------------------------------------
; GETS A VALUE FROM THE REGISTRY AND RETURNS IT AS A STRING. 
; WILL RETURN THE PASSED DEFAULT IF THE VALUE REQUESTED IS
; NOT FOUND IN THE REGISTRY.
;---------------------------------------------------
Function Reg_GetValue$(RegKey%,SubKey$,ValueName$,Dflt$="",types=False)
   
   Local cRetVal$ = Dflt$
   Local hKey     = Reg_OpenKey(RegKey,SubKey$)
   Local char     = 0
   Local nType    = 0
   
   ; OPEN THE KEY
   If hKey<>-1
      Local valbank     = CreateBank(100),
      Local valbanksize = CreateBank(4)
      Local typebank    = CreateBank(4)
   
      ; INIT THE BANKS
      PokeInt (typebank,0,0)
      PokeInt (valbanksize,0,100)
   
      Local nRslt = ADVAPI32_RegQueryValueEx(hKey,ValueName$,0,typebank,valbank,valbanksize)
      
      If nRslt = ERROR_SUCCESS
         cRetVal$ = ""
         nType = PeekInt(typebank,0)
         
         ; BUILD THE VALUE
         Select nType
            ; READ IN A STRING OR BINARY VALUE
            Case REG_SZ, REG_BINARY, REG_EXPAND_SZ
               ; BUILD THE VALUE
               For char = 0 To PeekInt (valbanksize,0)-1
                  If PeekByte (valbank,char) = 0 Then Exit
                  cRetVal$ = cRetVal$ + Chr(PeekByte(valbank,char))
               Next
            ; READ IN AN INTEGER
            Case REG_DWORD
               cRetVal$ = PeekInt(valbank,0)                  
         End Select
         
         ; TACK ON THE TYPE IF REQUESTED
         If types Then cRetVal$ = nType + ";" + cRetVal$
      Else
         reg_lasterr = nRslt
      EndIf
      Reg_CloseKey(hKey)
   EndIf
   
   Return cRetVal$
   
End Function


;---------------------------------------------------
; SETS A VALUE IN THE REGISTRY. DEFAULTS TO TYPE STRING,
; BUT CAN PASS REG_DWORD AND REG_BINARY. RETURNS TRUE/FALSE.
;---------------------------------------------------
Function Reg_SetValue%(RegKey%,SubKey$,ValueName$,Value$,nType=REG_SZ)
   
   Local hKey    = Reg_OpenKey(RegKey,SubKey$)
   Local lRetVal = False
   If hKey <> -1
      Local valbank
      
      ; CREATE A BANK TO HOLD THE INFO
      Select nType
         Case REG_SZ, REG_BINARY, REG_EXPAND_SZ
            valbank = CreateBank(Len(Value$))            
            For i = 1 To Len(Value$)
               PokeByte(valbank,i-1,Asc(Mid(Value$,i,1)))
            Next            
         Case REG_DWORD
            valbank = CreateBank(4)
            PokeInt (valbank,0,Int(Value$))
      End Select
   
      Local nRslt = ADVAPI32_RegSetValueEx(hKey,ValueName$,0,nType,valbank,BankSize(valbank))
      
      If nRslt = ERROR_SUCCESS 
         lRetVal = True
      Else
         reg_lasterr = nRslt
      EndIf
      
      Reg_CloseKey(hKey)
   EndIf
   
   Return lRetVal
   
End Function


;---------------------------------------------------
; DELETES THE PASSED KEY FROM THE REGISTRY.  RETURNS TRUE/FALSE.
;---------------------------------------------------
Function Reg_DeleteKey%(RegKey%,KeyName$)
   reg_lasterr=ERROR_SUCCESS
   Local nRslt=ADVAPI32_RegDeleteKey(RegKey,KeyName$)
   
   If nRslt<>ERROR_SUCCESS
      reg_lasterr=nRslt
   EndIf
   
   Return (nRslt=ERROR_SUCCESS)
End Function


;---------------------------------------------------
; RETURNS THE REGISTRY HANDLE OR -1 IF FAILED.
;---------------------------------------------------
Function Reg_CreateKey%(RegKey%,KeyName$)

   reg_lasterr   = ERROR_SUCCESS
   Local regbank = CreateBank(4)
   Local hKey    = -1

   Local nRslt = ADVAPI32_RegCreateKey (RegKey%,KeyName$,regbank)

   If nRslt = ERROR_SUCCESS
      hKey = PeekInt(regbank,0)
   Else
      reg_lasterr = nRslt
   EndIf

   FreeBank regbank   

   Return hKey

End Function


;---------------------------------------------------
; RETURNS THE REGISTRY HANDLE OR -1 IF FAILED
;---------------------------------------------------
Function Reg_OpenKey%(RegKey%,KeyName$)
   
   reg_lasterr   = ERROR_SUCCESS
   Local regbank = CreateBank(4)
   Local hKey    = -1

   Local nRslt = ADVAPI32_RegOpenKey(RegKey%,KeyName$,regbank)

   If nRslt = ERROR_SUCCESS
      hKey=PeekInt(regbank,0)
   Else
      reg_lasterr=nRslt
   EndIf

   FreeBank regbank

   Return hKey

End Function


;---------------------------------------------------
; CLOSES THE REGISTRY KEY.  RETURNS TRUE/FALSE.
;---------------------------------------------------
Function Reg_CloseKey%(RegKey%)
   
   reg_lasterr = ERROR_SUCCESS
   Local nRslt = ADVAPI32_RegCloseKey(RegKey)
   
   If nRslt <> ERROR_SUCCESS Then reg_lasterr=nRslt
   
   Return (nRslt = ERROR_SUCCESS)

End Function


;---------------------------------------------------
; RETURNS TRUE IF THE KEY EXISTS
;---------------------------------------------------
Function Reg_IsKey%(RegKey%,KeyName$)

   Local hKey    = Reg_OpenKey(RegKey,KeyName$)
   Local lRetVal = False

   If hKey<>-1 Then Reg_CloseKey(hKey) : lRetVal = True
   
   Return lRetVal

End Function


;---------------------------------------------------
; FUNCTION: REGISTERS A FILE EXTENSION TO THE .EXE
;---------------------------------------------------
Function Reg_RegisterFileType(extension$,exeName$)

   If Mid(extension$,1,1) <> "." Then extension$ = "." + extension$
   
   extension$ = Lower(extension$)
   
   typeName$  = Right(extension$,3) + "file"
   
   If Right(exeName$,4) <> ".exe" Then exeName$ = exeName$ + ".exe"

   KeyHandle% = Reg_CreateKey (HKEY_CLASSES_ROOT,extension$)
   If KeyHandle <> -1 Then
      Reg_SetValue (HKEY_CLASSES_ROOT,extension$,"",typeName$,REG_SZ)   
      Reg_CloseKey(KeyHandle)
   End If

   KeyHandle% = Reg_CreateKey (HKEY_CLASSES_ROOT,typeName + "\shell\open\command" )
   If KeyHandle <> -1 Then
      Reg_SetValue (HKEY_CLASSES_ROOT,typeName + "\shell\open\command","",chr(34) + CurrentDir() + exeName$ + chr(34) + " %1",REG_SZ)   
      Reg_CloseKey(KeyHandle)
   End If

   KeyHandle% = Reg_CreateKey (HKEY_CLASSES_ROOT,typeName + "\DefaultIcon" )
   If KeyHandle <> -1 Then
      Reg_SetValue (HKEY_CLASSES_ROOT,typeName + "\DefaultIcon","",chr(34) + CurrentDir() + exeName$ + chr(34) + ",0",REG_SZ)   
      Reg_CloseKey(KeyHandle)
   End If

End Function

Include "registry.bb"
Reg_RegisterFileType(".abc","MeinTool.exe")