Dateitypen mit dem eigenen Programm verknüpfen Wenn man ein Programm schreibt, das mit bestimmten Dateitypen umgehen kann, möchte man natürlich auch, dass die Dateien mit dem Programm sinnvoll verknüpft werden. Wie man das in VB realisiert, das möchten wir Ihnen in diesem Workshop zeigen.
Autor:  DB1MWE	Bewertung:     [ Jetzt bewerten ]	Views:  38.931

Geben Sie hier Ihre persönliche Bewertung ab! Anzahl Bewertungen bisher: 8 Bewertung insgesamt: gut Durchschnittliche Bewertung: 4.4 von 5 Sternen

sehr gut     gut     nützlich     mittelmäßig     mangelhaft

Wenn man ein Programm schreibt, das mit bestimmten Dateitypen umgehen kann, möchte man natürlich auch, dass die Dateien mit dem Programm sinnvoll verknüpft werden. Wie man das in VB realisiert, das möchten wir Ihnen in diesem Workshop zeigen.

Die Rolle der Registry

Dateitypen werden unter Windows in der Registry mit Programmen verknüpft. Dabei gibt es, wie so oft in der Registry keine genaue Regel, aber einen oft-genutzten Weg.

Um sinnvoll mit der Registry arbeiten zu können benötigen wir erst einmal die Grundbegriffe. Die Registry besteht aus Schlüsseln und Werten, sie ist ähnlich aufgebaut wie der Dateipfad z.B. des Windows-Explorers.

Schlüssel:
Schlüssel kann man mit Ordnern vergleichen. In ihnen liegen ähnlich Dateien Werte. Es gibt in der Registry i.d. Regel 5 "Hauptschlüssel":

• HKEY_CLASSES_ROOT
• HKEY_CURRENT_USER
• HKEY_LOCAL_MACHINE
• HKEY_USERS
• HKEY_CURRENT_CONFIG

Werte:
Werte liegen in den Schlüsseln. Ein Unterschied ist, dass jeder Schlüssel auch einen sogenannten Standard-Wert besitzt.

Alles, was ich in diesem Workshop ansprechen werde, liegt im Hauptschlüssel HKEY_CLASSES_ROOT, die anderen werden vernachlässigt. HKEY_CLASSES_ROOT werde ich im Folgenden kurz "HKEY" nennen.

Der Aufbau in HKEY_CLASSES_ROOT

Grundlegend sollte hierzu bekannt sein, dass man den Windows-Registry-Editor folgendermaßen öffnet:

Start-Menü -> Ausführen -> Eingeben: regedit -> OK

Wenn man sich nun mal gerade den Schlüssel HKEY_CLASSES_ROOT ansieht, wird man schon schnell auf die Datei-Verknüpfungsfunktionen stoßen. Diese laufen am Beispiel der txt-Dateien folgendermaßen ab:

• In HKEY existiert für diese Dateiendung ein Schlüssel (also .txt).
• In diesem Schlüssel ist der Standard-Wert eine Art Verknüpfung, bei mir zum Beispiel "txtfile".

Dadurch wird "weitergeleitet" auf einen Schlüssel mit diesem Namen, der ebenfalls in HKEY liegt. Bei mir wäre dies also "HKEY_CLASSES_ROOT\txtfile". Wenn man sich diesen Schlüssel nun betrachtet, so liegen in ihm alle relevanten Informationen, die da wären:

• Bezeichnung des Dateityps (normalerweise zum Beispiel: "Textdatei")
• Welches Icon für diesen Dateityp verwendet werden soll
• Welche Pfad-Anweisung beim Ausführen dieses Dateityps gestartet werden soll

Die Bezeichnung des Dateityps

Sie liegt einfach als Standard-Wert in diesem Schlüssel. Sie dient nur dazu, den Nutzer über den Datei-Inhalt zu informieren, hat also keinen Einfluss auf die korrekte Ausführung. Bei .txt-Dateien zum Beispiel: "Textdatei".

Das Standard-Icon des Dateityps

In diesem Schlüssel liegt normalerweise ein Unterschlüssel "DefaultIcon". In diesem ist wiederum als Standard-Wert der Pfad zu einem Icon abgelegt. Dadurch wird der Datei dann das Icon zugewiesen. Das läuft generell so:

Pfad zu einer Icon-Datei (.ico)
also: C:\Test\Test.ico
oder, der Pfad zur Programm-exe, ein Komma und eine passende Index-Nummer in der exe-Datei:
z.B. so: C:\Test\test.exe,0"

Dabei wird der Index 0 verwendet, wenn das Programm-Icon eingesetzt werden soll.

Die Pfad-Anweisung

Außerdem liegt noch ein Schlüssel "shell" darin. Dieser hat sehr oft mehrere Unterschlüssel. Dies sind die verschiedenen Aktionen, die im Kontextmenü angeboten werden, wenn man eine solche Datei mit der rechten Maustaste anklickt. Standardmäßig wird der Schlüssel "open" ausgeführt. Ich werde mich nur diesem widmen, die anderen funktionieren genauso.

Kurz zur Erinnerung: Um beim Beispiel zu bleiben, wir befinden uns zur Zeit im Schlüssel
HKEY_CLASSES_ROOT\txtfile\shell\open

Er hat mindestens den Unterschlüssel "command". Manchmal auch "ddeexec", wenn DDE verwendet wird, was man aberi. d. Regel nicht braucht und deshalb der Einfachheit halber bleiben lassen sollte. Dieser Schlüssel "command" hat als Standard-Wert die Pfad-Anweisung, die ausgeführt werdensoll. Bei txt-Dateien ist dies, wenn man nichts geändert hat (Windows XP), z.B. folgendes:

C:\WINDOWS\system32\NOTEPAD.EXE %1

Das ist auch ganz schnell erklärt: Der erste Teil ist der Pfad zur Anwendung. Wenn man aber nur dies schreibt, wird nur die Anwendung gestartet, nicht mit dem Befehl, die Datei zu öffnen. Das %1 ist eine Art reservierte Variable, die immer den Pfad der aufrufenden Datei enthält. Wenn man dies nun also schreibt, wird die Anwendung (hier Notepad) gestartet und ihr als Parameter der Pfad übergeben. Dadurch kann die Anwendung dies "abfragen" und die jeweilige Datei öffnen.

Die Praxis

Nun will ich hier kurz eine Routine beschreiben, die eine beliebige Dateiendung mit dem Programm, in dem sie eingesetzt wird, verknüpft.

Hierzu brauchen wir ein "Standard-EXE"-Projekt - ohne Form nur mit einem Modul - und zur einfachen Handhabung der Registry die Registry-Tipps von Heinz Prelle.

Zuerst kommen in das Modul folgende Deklarationen:

Option Explicit
 
' Benötigte API-Deklarationen
Private Declare Function CharLower Lib "user32" _
  Alias "CharLowerA" ( _
  ByVal lpsz As String) As String
 
Private Declare Function RegOpenKey Lib "advapi32.dll" _
  Alias "RegOpenKeyA" ( _
  ByVal hKey As Long, _
  ByVal lpSubKey As String, _
  phkResult As Long) As Long
 
Private 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
 
Private 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
 
Private Declare Function RegCloseKey Lib "advapi32.dll" ( _
  ByVal hKey As Long) As Long
 
Private Declare Function RegCreateKey Lib "advapi32.dll" _
  Alias "RegCreateKeyA" ( _
  ByVal hKey As Long, _
  ByVal lpSubKey As String, _
  phkResult As Long) As Long
 
Private Declare Function RegDeleteValue Lib "advapi32.dll" _
  Alias "RegDeleteValueA" ( _
  ByVal hKey As Long, _
  ByVal lpValueName As String) As Long
 
Private Declare Function RegOpenKeyEx Lib "advapi32.dll" _
  Alias "RegOpenKeyExA" ( _
  ByVal hKey As Long, _
  ByVal lpSubKey As String, _
  ByVal ulOptions As Long, _
  ByVal samDesired As Long, _
  phkResult As Long) As Long
 
Private Declare Function RegEnumKey Lib "advapi32.dll" _
  Alias "RegEnumKeyA" ( _
  ByVal hKey As Long, _
  ByVal dwIndex As Long, _
  ByVal lpName As String, _
  ByVal cbName As Long) As Long
 
Const KEY_ENUMERATE_SUB_KEYS = &H8
Const ERROR_SUCCESS = 0&
Const HKEY_CLASSES_ROOT = &H80000000
Const REG_SZ = 1

' Wert (String/Text) für einen bestimmten
' Schlüsselnamen speichern. Sollte der Schlüssel nicht
' existieren, wird dieser autom. erstellt.
Sub regSaveString(hKey As Long, sPath As String, sValue As String, _
 iData As String)
  Dim vRet As Variant
  RegCreateKey hKey, sPath, vRet
  RegSetValueEx vRet, sValue, 0, REG_SZ, ByVal iData, Len(iData)
  RegCloseKey vRet
End Sub

Dann kommt der eigentliche Programmteil:

Public Sub Main()
  ' Dateityp registrieren
  RegisterFileType ".txt"
End Sub

Sub RegisterFileType(ByVal FileType As String)
  Dim TypeName As String
 
  If FileType = "" Then
    MsgBox "Dateiendung benötigt.", vbCritical
    Exit Sub
  End If
 
  FileType = CharLower(FileType)
  If Left(FileType, 1) <> "." Then
    TypeName = FileType
    FileType = "." & FileType
  Else
    TypeName = Right(FileType, Len(FileType) - 1)
  End If
 
  TypeName = TypeName & "file"
 
  regSaveString HKEY_CLASSES_ROOT, FileType, "", TypeName
  regSaveString HKEY_CLASSES_ROOT, TypeName & "\shell\open\command", _
    "", App.Path & "\" & App.EXEName & ".exe %1"
  regSaveString HKEY_CLASSES_ROOT, TypeName & "\DefaultIcon", _
    "", App.Path & "\" & App.EXEName & ".exe,0"
 
  MsgBox "Dateityp: " & FileType & vbCrLf & "Registriert auf: " & _
  TypeName & vbCrLf & "open-Anweisung: " & App.Path & "\" & _
  App.EXEName & ".exe %1"
End Sub

Damit haben wir eine Routine, die uns egal welche Dateiendung auf den Pfad unseres Programms registriert. Dabei wird nur die Dateiendung benötigt. Sie wird mit einem Schlüssel "verlinkt", der aus der Dateiendung ohne den Punkt und dem Suffix "file" besteht. Eine .txt-Datei ist also "txtfile", .jpg-Dateien "jpgfile" usw. Außerdem wird in Zukunft bei diesen Dateien das Icon des Programms angezeigt. Den aufrufenden Pfad können wir ganz einfach per Command-Funktion (siehe Tipp) herausfinden.

Möglich wäre mit den Tipps von Heinz Prelle auch eine Funktion, die für einen Dateityp den zu öffnenden Pfad anzeigt. Dies hier ist nur ein Grundbeispiel, die Weiterentwicklung durch eigene Ideen überlasse ich gerne jedem selbst.

Noch viel Spaß im vb@rchiv und ein herzliches 73 wünscht

db1MWe