<\/p>\n
In letzter Zeit programmiere ich gern Standardlösungen, die ich dann ohne großen Programmieraufwand in weitere Anwendungen übernehmen kann. In diesem Fall ging es um ein Textfeld zur Eingabe eines Dateinamens beziehungsweise um eine Schaltfläche zum Öffnen eines Datei öffnen-Dialogs. Die Kombination brauche ich immer wieder, sei es, um eine Datei für den Import von Daten auszuwählen oder den Pfad zum Backend der aktuellen Datenbank zu aktualisieren. Dieser Beitrag zeigt, wie Sie alles in eine Klasse packen und Ihre Formulare blitzschnell damit ausstatten.<\/b><\/p>\n
Spätestens, wenn Sie eine Frontend-Backend-Lösung auf Basis von Access erstellen, wobei das Backend zumindest theoretisch seinen Speicherplatz wechseln kann, müssen Sie dem Anwender des Frontends die Möglichkeit bieten, manuell das Backend auszuwählen.<\/p>\n
Die gleiche Situation tritt immer dann ein, wenn Ihre Anwendung Daten aus beliebigen anderen Dateien wie etwa Excel-, XML-, Text- oder Worddokumenten importieren soll. Auch dann wird normalerweise der Benutzer aufgefordert, die gewünschte Datei auszuwählen.<\/p>\n
Dabei gibt es unterschiedliche Ausprägungen: Mal soll der Benutzer nur einen Dialog zum Auswählen der Datei öffnen können, woraufhin der die Datei betreffende Vorgang direkt beginnt, mal soll die ausgewählte Datei in einem Textfeld angezeigt werden, bevor der Benutzer die entsprechende Aktion mit einer zweiten Schaltfläche startet.<\/p>\n
Traurige Tatsache ist, dass man den betroffenen Code jeweils von einer Datenbankdatei zur nächsten kopiert und teilweise der gleiche Code gleich mehrfach in einer einzigen Datei auftaucht – und dies auch noch in unterschiedlichen Ausprägungen.<\/p>\n
Dateiauswahl mit Klasse<\/b><\/p>\n
Die in diesem Beitrag vorgestellte Lösung soll die komplette Funktionalität in einer einzigen Klasse liefern. Diese wird im betroffenen Formular deklariert und instanziert und stellt dann nicht nur die üblichen Funktionen zum Auswählen von Datei, Speicherort und Verzeichnis bereit, sondern bestückt auch Schaltflächen mit den entsprechenden Funktionen.<\/p>\n
Einfache Dateiauswahl-Schaltfläche<\/b><\/p>\n
Im Detail bedeutet dies, dass Sie sich noch nicht einmal mehr um die Ereignisprozedur kümmern müssen, die etwa eine Schaltfläche zum Auswählen einer Datei für die Dateiauswahl auslösen müsste.<\/p>\n
Nehmen wir an, Sie wollen ein Formular mit einem Textfeld namens txtVerzeichnisUndDateiname <\/b>und einer Schaltfläche namens cmdAuswaehlen <\/b>bestücken. Die Schaltfläche soll einen Datei öffnen<\/b>-Dialog anzeigen und im Anschluss die ausgewählte Datei in das Textfeld schreiben.<\/p>\n
Das Formular sieht dann im Entwurf etwa so wie in Bild 1 aus. Das Anlegen, Benennen und Ausrichten der Steuerelemente war auch schon fast der größte Teil der Arbeit – Sie müssen nun nur noch die Klasse clsFiles <\/b>aus der Beispieldatenbank in die betroffene Datenbank importieren und ein paar Zeilen Code in das Beim Öffnen<\/b>-Ereignis des Formulars schreiben.<\/p>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2011_01\/DateiOeffnenSchaltflaeche-web-images\/pic001.png\")
<\/p>\n
Bild 1: Beispiel für die Auswahl einer Datei per Textfeld und Schaltfläche<\/span><\/b><\/p>\n Im Kopf des Klassenmoduls des Formulars landet die Objektvariable, welche einen Verweis auf die noch zu erzeugende Instanz der Klasse clsFiles <\/b>speichert:<\/p>\n In der Ereignisprozedur Form_Open <\/b>wird dann zunächst die Instanz der Klasse clsFiles <\/b>erzeugt und der Variablen objFiles <\/b>zugewiesen.<\/p>\n Die beiden folgenden Anweisungen füllen zwei Eigenschaften des Objekts objFiles <\/b>mit Verweisen auf die Schaltfläche, die den Datei auswählen<\/b>-Dialog aktivieren soll, sowie auf das Textfeld, in dem der Pfad und der Dateiname der ausgewählten Datei landen sollen.<\/p>\n Danach können Sie bereits in die Formularansicht wechseln und auf die Schaltfläche Datei auswählen <\/b>klicken. Es erscheint ein Datei auswählen<\/b>-Dialog wie in Bild 2. Die damit ausgewählte Datei landet samt Pfad im Textfeld txtVerzeichnisUndDateiname<\/b>.<\/p>\n Bild 2: Der Datei auswählen-Dialog<\/span><\/b><\/p>\n Und es kommt noch besser: Fügen Sie eine weitere Schaltfläche namens cmdOeffnen <\/b>hinzu und betiteln Sie diese mit Öffnen<\/b>. Erweitern Sie die Prozedur von oben um die folgende Zeile:<\/p>\n Wenn Sie nun das Formular öffnen, finden Sie weitere Funktionalität vor: Solange kein gültiger Dateiname im Textfeld steht, bleibt die Öffnen<\/b>-Schaltfläche deaktiviert.<\/p>\n Erst, wenn Sie mit dem Datei auswählen<\/b>-Dialog eine Datei ausgewählt haben, wird die Öffnen<\/b>-Schaltfläche aktiviert. ändern Sie jedoch auch nur einen Buchstaben des Dateinamens, sodass diese nicht mehr im Dateisystem gefunden werden kann, wird die Öffnen<\/b>-Schaltfläche wieder deaktiviert.<\/p>\n Ein Klick auf die Öffnen<\/b>-Schaltfläche startet schließlich die Standardanwendung für die ausgewählte Datei und öffnet diese.<\/p>\n Ordner und Verzeichnis getrennt<\/b><\/p>\n Das funktioniert auch, wenn Sie Ordner und Verzeichnis in zwei Textfeldern anzeigen. Das Beispielformular für diesen Fall sieht im Entwurf wie in Bild 3 aus.<\/p>\n Bild 3: Beispielformular mit separaten Textfeldern für Pfad und Dateiname<\/span><\/b><\/p>\n Im Beispielcode haben wir zur besseren Unterscheidbarkeit den Objektnamen objFiles2 <\/b>gewählt (auch deshalb, weil Sie in der Beispieldatenbank mehrere Beispiele in einem Formular finden).<\/p>\n Wir deklarieren wieder die Objektvariable für clsFiles<\/b>:<\/p>\n In der Beim Öffnen<\/b>-Prozedur sieht der Code nur unwesentlich anders aus. Der einzige Unterschied ist, dass wir nun Verweise auf zwei Textfelder an die beiden Eigenschaften Textbox_File <\/b>und Textbox_Folder <\/b>des Objekts objFiles2 <\/b>übergeben:<\/p>\n Der Klick auf die Schaltfläche Auswählen <\/b>öffnet wiederum den Datei auswählen<\/b>-Dialog, allerdings werden Pfad und Datei diesmal gleich auf die entsprechenden Textfelder aufgeteilt (s. Bild 4). Die übrige Funktionalität bleibt gleich.<\/p>\n Bild 4: Frisch eingelesener Pfad und Dateiname<\/span><\/b><\/p>\n Dateiangaben in gebundenen Formularen<\/b><\/p>\n Gelegentlich kommt es vor, dass man Pfadangaben in Tabellen speichert – beispielsweise, um den Pfad zu einem Bild eines Mitarbeiters anzugeben, das man nicht in der Datenbank speichern möchte.<\/p>\n Auch hier funktionieren die Textfelder für die Angabe von Pfad und\/oder Dateiname und die entsprechenden Schaltflächen. Dies bezieht sich explizit auf die Öffnen<\/b>-Schaltfläche, die ja nur aktiviert sein soll, wenn die angegebene Datei tatsächlich vorhanden ist.<\/p>\n Zwei Beispiele finden Sie in den Formularen frmDateienGebunden <\/b>und frmDateienGebunden_PfadUndDatei<\/b>.<\/p>\n Feinheiten einstellen<\/b><\/p>\n In der Basiseinstellung zeigt die Klasse die Dialoge zum Auswählen von Dateien mit dem Titel Datei auswählen<\/b>, dem aktuellen Datenbankverzeichnis als Startverzeichnis sowie einem auf Datenbankdateien fixierten Filter an.<\/p>\n All diese Eigenschaften können Sie je nach Anwendungsfall individuell einstellen. Das Startverzeichnis, das der Datei auswählen<\/b>-Dialog anzeigen soll, stellen Sie beispielsweise mit der Eigenschaft StartDir <\/b>ein:<\/p>\n Auch der Filter lässt sich manuell einstellen. Die folgende Zuweisung zeigt etwa nur Access-Datenbanken mit der Dateiendung .mdb oder .accdb an:<\/p>\n Schließlich können Sie noch den Titel des jeweiligen Dialogs beeinflussen:<\/p>\n Integration in VBA-Code<\/b><\/p>\n Die Klasse liefert auch die üblichen Funktionen für den Einbau in Ihren VBA-Code:<\/p>\n Einfache Datei auswählen<\/b><\/p>\n Wenn Sie eine einzelne Datei auswählen und den Namen in einer Variablen speichern möchten, gehen Sie wie folgt vor:<\/p>\n Sie erstellen also wie in den vorherigen Beispielen ein Objekt auf Basis der Klasse clsFiles<\/b>, stellen die Eigenschaften für die Erscheinungsweise des Dialogs ein und zeigen diesen dann an. <\/p>\n Mehrfachauswahl<\/b><\/p>\n Auch eine Mehrfachauswahl wie in Bild 5 lässt sich mit dieser Klasse realisieren. Die Auswahl mehrerer Dateien erfolgt dabei genau wie im Windows Explorer: Entweder Sie drücken die Umschalttaste, um alle Dateien zwischen zwei markierten Einträgen auszuwählen, oder Sie drücken die Strg<\/b>-Taste und wählen gezielt Dateien aus.<\/p>\n Bild 5: Mehrfachauswahl im Datei auswählen-Dialog<\/span><\/b><\/p>\n Dazu stellen Sie zusätzlich zu den Eigenschaften des vorherigen Beispiels die Option MultipleFiles <\/b>auf True <\/b>ein. Die OpenFileName<\/b>-Methode liefert eine Zeichenkette zurück, bei der die ausgewählten Dateinamen durch das Tabulatorzeichen voneinander getrennt werden.<\/p>\n <\/p>\n Dieses Ergebnis wandelt die folgende Beispielprozedur mit der Split<\/b>-Funktion in ein Array mit den einzelnen Dateinamen um und gibt die enthaltenen Einträge dann innerhalb einer Schleife im Direktfenster aus:<\/p>\n Verzeichnisauswahl<\/b><\/p>\n Die Verzeichnisauswahl erledigt die Methode GetPath<\/b>. Auch hier verwenden Sie die üblichen Eigenschaften, um das Aussehen des Dialogs zu beeinflussen sowie das Startverzeichnis festzulegen.<\/p>\n Der Dialog liefert immer das Verzeichnis zurück, das beim Schließen im Textfeld Ordner<\/b> zu sehen ist (s. Bild 6).<\/p>\n Bild 6: Auswahl eines Verzeichnisses<\/span><\/b><\/p>\n Datei öffnen<\/b><\/p>\n Die Funktion OpenFile <\/b>öffnet die als Parameter angegebene Datei. Sie erwartet schlicht den Dateinamen als Parameter und sieht wie in Listing 1<\/a><\/span> aus. Die Funktion verwendet eine API-Funktion namens OpenDocument<\/b>, deren Deklaration Sie in der Beispieldatenbank finden.<\/p>\n Listing 1: Öffnen eines Dokuments mit der dafür vorgesehenen Anwendung<\/p>\n Wie funktioniert das<\/b><\/p>\n Die Klasse clsFiles <\/b>enthält eine ganze Menge Property<\/b>-, Sub<\/b>– und Function<\/b>-Prozeduren und zusätzlich einige Ereignisprozeduren, die auf das Betätigen der festgelegten Schaltflächen oder änderungen der Dateiangaben in den Textfeldern reagieren.<\/p>\n Schauen wir uns zunächst die Techniken an, die zum Realisieren der Anzeige der einfachen Dialoge nötig sind.<\/p>\n Datei auswählen-Dialog in clsFiles<\/b><\/p>\n Für den Datei auswählen<\/b>-Dialog brauchen Sie prinzipiell nur die Methode OpenFileName<\/b> aus Listing 2<\/a><\/span>. Diese zeigt den Dialog der nicht dokumentierten WizHook<\/b>-Klasse an.<\/p>\n Listing 2: Funktion zum Aufruf des Datei anzeigen-Dialogs<\/p>\n Allein mit dieser Methode ist es allerdings nicht getan, weil Sie ja nicht unbedingt immer mit den Standardwerten für den Titel, den Filter und das Startverzeichnis des Dialogs arbeiten möchten. Also gibt es ein recht flexibles Konstrukt, das benutzerdefinierte Abweichungen von den Standardwerten verarbeitet.<\/p>\n Dies manifestiert sich zunächst im Deklarationsbereich der Klasse, wo Sie die folgenden vier Variablen finden:<\/p>\n Hier werden vom aufrufenden Code angegebene änderungen der Standardwerte für Startverzeichnis, Titel, Filter und Einfach-\/Mehrfachauswahl gespeichert.<\/p>\n Damit Sie von außen auf diese privaten Variablen zugreifen können, gibt es entsprechende Property Let<\/b>-Methoden, die wie folgt aussehen:<\/p>\n Diese Properties sorgen dafür, dass die entsprechenden Eigenschaften via IntelliSense ausgewählt und zum Füllen der privat deklarierten Variablen verwendet werden können (s. Bild 7).<\/p>\n Bild 7: Per IntelliSense verfügbare Eigenschaften<\/span><\/b><\/p>\n Nun fließt in der Funktion OpenFileName <\/b>jedoch nur m_MultipleFilenames <\/b>direkt in den Aufruf des Dialogs ein. Ansonsten finden sich dort Funktionen wie GetTitle<\/b>, GetStartDir <\/b>oder GetFilter<\/b>. Was hat es damit auf sich<\/p>\n Diese Funktionen prüfen, ob die aufrufende Routine einen Wert für die jeweilige Eigenschaft übergeben hat. Falls ja, wird dieser als Funktionsergebnis zurückgeliefert, falls nicht, verwendet die Funktion einen Standardwert als Rückgabewert. Für den Titel und den Filter sieht dies so aus:<\/p>\n Die Funktion GetStartDir<\/b> ist noch ein wenig aufwendiger gestaltet. Sie prüft zunächst, ob m_StartDir <\/b>bereits einen benutzerdefinierten Wert enthält. Falls nicht, untersucht die Funktion den Wert einer weiteren Eigenschaft namens m_Folder<\/b>.<\/p>\n Diese wird gefüllt, wenn Sie die Klasse clsFiles <\/b>zum Bestücken von Schaltflächen und Textfeldern mit den entsprechenden Funktionen zur Dateiauswahl verwenden:<\/p>\n Verzeichnis auswählen in clsFiles<\/b><\/p>\n Die Funktion GetPath <\/b>verwendet wiederum eine Funktion der WizHook<\/b>-Klasse. Auch hier kommen die bereits beschriebenen Einrichtungen zum Übergeben von Titel, Filter und Startverzeichnis zum Zuge:<\/p>\n Speichern unter-Dialog in clsFiles<\/b><\/p>\n Der Speichern unter<\/b>-Dialog ist etwas umfangreicher aufgebaut, da dieser auf eine API-Funktion und eine spezielle Struktur zurückgreift. Aus Platzgründen können wir den Code hier nicht abbilden.<\/p>\n Die Funktion GetSaveFile <\/b>greift jedoch ebenfalls auf die drei Funktionen GetTitel<\/b>, GetFilter <\/b>und GetStartDir <\/b>zurück.<\/p>\n Schaltfläche mit Datei auswählen-Dialog ausstatten<\/p>\n Kommen wir zum komplizierteren Teil: Wie schafft es die Klasse, einer Schaltfläche völlig ohne jeden Code die Funktion zum Öffnen etwa des Datei auswählen<\/b>-Dialogs unterzujubeln Dazu muss die Schaltfläche zunächst der Klasse bekannt gemacht werden. Dies geschieht, wie in den Beispielen oben beschrieben, durch eine Zeile wie die folgende:<\/p>\n Die Property Set<\/b>-Prozedur, die diese Zuweisung verarbeitet, sieht wie in Listing 3<\/a><\/span> aus. Die erste Zeile weist die Schaltfläche einer Variablen zu, die wie folgt deklariert ist:<\/p>\n Listing 3: Anzeigen von Dialogen zum Auswählen einzelner und mehrerer Dateien<\/p>\n Dann stellt sie die Eigenschaft OnClick <\/b>auf den Wert [Event Procedure] <\/b>ein. Zusammen mit dem Schlüsselwort WithEvents <\/b>in der Deklaration der Objektvariablen für die Schaltfläche sorgt dies dafür, dass Access beim Klick auf diese Schaltfläche innerhalb der Klasse clsFiles <\/b>nach einer Ereignisprozedur für dieses Ereignis sucht.<\/p>\nDim objFiles As clsFiles<\/pre>\n
Private Sub Form_Open(Cancel As Integer)\r\n Set objFiles = New clsFiles\r\n With objFiles\r\n Set .Commandbutton_ChooseDocument = _\r\n Me!cmdAuswaehlen\r\n Set .Textbox_FolderAndFile = Me!txtVerzeichnisUndDateiname\r\n End With\r\nEnd Sub<\/pre>\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2011_01\/DateiOeffnenSchaltflaeche-web-images\/pic002.png\")
<\/p>\nSet .CommandButton_OpenDocument = Me!cmdOeffnen<\/pre>\n
![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2011_01\/DateiOeffnenSchaltflaeche-web-images\/pic003.png\")
<\/p>\nDim objFiles2 As clsFiles<\/pre>\n
Private Sub Form_Open(Cancel As Integer)\r\n Set objFiles2 = New clsFiles\r\n With objFiles2\r\n Set .CommandButton_OpenDocument = _\r\n Me!cmdOeffnen2\r\n Set .Commandbutton_ChooseDocument = _\r\n Me!cmdAuswaehlen2\r\n Set .Textbox_File = Me!txtDateiname\r\n Set .Textbox_Folder = Me!txtVerzeichnis\r\n End With\r\nEnd Sub<\/pre>\n
![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2011_01\/DateiOeffnenSchaltflaeche-web-images\/pic004.png\")
<\/p>\nobjFiles.StartDir = "c:\\"<\/pre>\n
objFiles.Filter = "Access-Dateien (*.accdb,*.mdb)"<\/pre>\n
objFiles.Title = "Access-Datei auswählen"<\/pre>\n
\n
Public Sub Einfachauswahl()\r\n Dim objFiles As clsFiles\r\n Dim strFile As String\r\n Set objFiles = New clsFiles\r\n With objFiles\r\n .StartDir = "c:\\"\r\n .Title = "Einzelne Datei auswählen"\r\n .Filter = "Alle Dateien (*.*)"\r\n strFile = .OpenFileName\r\n End With\r\n Debug.Print strFile\r\nEnd Sub<\/pre>\n
![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2011_01\/DateiOeffnenSchaltflaeche-web-images\/pic005.png\")
<\/p>\nPublic Sub Mehrfachauswahl()\r\n Dim objFiles As clsFiles\r\n Dim strFiles() As String\r\n Dim i As Integer\r\n Set objFiles = New clsFiles\r\n With objFiles\r\n .StartDir = "c:\\"\r\n .MultipleFiles = True\r\n .Title = "Einzelne Datei auswählen"\r\n .Filter = "Alle Dateien (*.*)"\r\n strFiles = Split(.OpenFileName, vbTab)\r\n End With\r\n For i = LBound(strFiles) To UBound(strFiles)\r\n Debug.Print strFiles(i)\r\n Next i\r\nEnd Sub<\/pre>\n
Public Sub Verzeichnisauswahl()\r\n Dim objFiles As clsFiles\r\n Set objFiles = New clsFiles\r\n With objFiles\r\n .Title = "Verzeichnis auswählen"\r\n .StartDir = "c:\\"\r\n Debug.Print .GetPath\r\n End With\r\nEnd Sub<\/pre>\n
![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2011_01\/DateiOeffnenSchaltflaeche-web-images\/pic006.png\")
<\/p>\nPublic Function OpenDocument(DocumentFile As String) As Long\r\n Dim ret As Long\r\n If Len(DocumentFile) > 0 Then\r\n ret = ShellExecute(Application.hWndAccessApp, "open", DocumentFile, vbNullChar, "", 1)\r\n If Err Then\r\n OpenDocument = 0\r\n ElseIf ret > 32 Then\r\n OpenDocument = -1\r\n Else\r\n OpenDocument = ret\r\n End If\r\n Else\r\n OpenDocument = 0\r\n End If\r\nEnd Function<\/pre>\n
Function OpenFileName() As String\r\n Dim strTemp As String\r\n Dim intFlags As Integer\r\n If m_MultipleFiles = True Then\r\n intFlags = &H48\r\n Else\r\n intFlags = &H40\r\n End If\r\n WizHook.Key = 51488399\r\n Call WizHook.GetFileName(Application.hWndAccessApp, "Microsoft Access", GetTitle, "Öffnen", _\r\n strTemp, GetStartDir, GetFilter, 1&, 0&, intFlags, True)\r\n OpenFileName = strTemp\r\nEnd Function<\/pre>\n
Dim m_StartDir As String\r\nDim m_Title As String\r\nDim m_Filter As String\r\nDim m_MultipleFiles As Boolean<\/pre>\n
Public Property Let StartDir(str As String)\r\n m_StartDir = str\r\nEnd Property\r\nPublic Property Let MultipleFiles(bol As Boolean)\r\n m_MultipleFiles = bol\r\nEnd Property\r\nPublic Property Let Title(str As String)\r\n m_Title = str\r\nEnd Property\r\nPublic Property Let Filter(str As String)\r\n m_Filter = str\r\nEnd Property<\/pre>\n
![\"pic007.png\"](\"..\/fileadmin\/_temp_\/2011_01\/DateiOeffnenSchaltflaeche-web-images\/pic007.png\")
<\/p>\nPrivate Function GetTitle() As String\r\n If Len(m_Title) = 0 Then\r\n GetTitle = "Datei auswählen"\r\n Else\r\n GetTitle = m_Title\r\n End If\r\nEnd Function\r\nPrivate Function GetFilter() As String\r\n If Len(m_Filter) = 0 Then\r\n GetFilter = "Alle Dateien (*.*)"\r\n Else\r\n GetFilter = m_Filter\r\n End If\r\nEnd Function<\/pre>\n
Private Function GetStartDir() As String\r\n If Len(m_StartDir) = 0 Then\r\n GetStartDir = m_Folder\r\n If Len(GetStartDir) = 0 Then\r\n GetStartDir = CurrentProject.Path\r\n End If\r\n End If\r\n GetStartDir = m_StartDir\r\nEnd Function<\/pre>\n
Public Function GetPath() As String\r\n WizHook.Key = 51488399\r\n Call WizHook.GetFileName(Application.hWndAccessApp, _\r\n "Microsoft Access", GetTitle, "Öffnen", GetPath, GetStartDir, "", 0&, 3, 96, True)\r\nEnd Function<\/pre>\n
Set .Commandbutton_ChooseDocument = Me!cmdAuswaehlen<\/pre>\n
Dim WithEvents m_cmdChooseDocument As CommandButton<\/pre>\n
Public Property Set Commandbutton_ChooseDocument(cmd As CommandButton)\r\n Set m_cmdChooseDocument = cmd\r\n m_cmdChooseDocument.OnClick = "[Event Procedure]"\r\n SetForm cmd.Parent\r\nEnd Property<\/pre>\n