<\/p>\n
Dateidialoge benötigt man immer wieder. Ob man nun Dateien zum Öffnen oder Bearbeiten auswählen möchte, ob man einen Pfad zum Speichern einer Datei braucht oder ob man ein Verzeichnis selektieren will – am einfachsten geht das mit den praktischen Dateidialogen. Die Office-Bibliothek bietet sogar alle benötigten Varianten über die FileDialog-Klasse an. Dumm ist nur, dass man nicht ständig Filedialoge programmiert, sondern nur alle paar Wochen, Monate oder sogar Jahre. Dann muss man sich immer wieder einarbeiten, um die verschiedenen Parameter – Titel, Schaltflächenbeschriftungen, Standardverzeichnis und -dateiname, Filter, Dateiendungen und so weiter zu definieren. Wie schön wäre es doch, wenn wir solche Dateidialoge mit einem kleinen Assistenten zusammenstellen könnten. Also machen wir uns ans Werk und schaffen einen solchen Wizard!<\/b><\/p>\nWann, wie und wo nutzen wir den Dateidialog-Assistenten?<\/h2>\n
Die erste Frage, die sich stellt, ist: Wo und wie wollen wir diesen Assistenten aufrufen und was genau soll dieser eigentlich produzieren? Als Erstes fällt uns ein, dass er eine Funktion liefern soll, die den Dateidialog aufruft und uns die gewünschte Datei oder das Verzeichnis zurückliefert.<\/p>\n
Wir könnten uns also darauf beschränken, diesen Assistenten für das Zusammenstellen des benötigten Codes zu nutzen und diesen dann beispielsweise an der aktuellen Stelle im Codefenster des VBA-Editors einzufügen oder diesen in die Zwischenablage zu schreiben, damit wir diesen selbst einfügen können.<\/p>\n
In vielen Fällen mag das ausreichen: Dann ruft man den Dateidialog aus einer anderen Prozedur heraus auf und verwendet die gelieferten Informationen in den folgenden Codezeilen für den gewünschten Zweck.<\/p>\n
In anderen Fällen spielt die Benutzeroberfläche eine Rolle: Dann möchte man vielleicht in einem Access-Formular ein Verzeichnis etwa zum Exportieren von Daten anzeigen und auswählen. Dazu fügt man diesem ein Textfeld oder ein Bezeichnungsfeld zur Anzeige des Pfades hinzu und legt daneben eine Schaltfläche an, mit der man den Dateiauswahl-Dialog aufruft.<\/p>\n
Letztlich würde auch hier erst einmal der Assistent zum Zusammenstellen von Funktionen zum Anzeigen von Dateidialogen ausreichen.<\/p>\n
Man könnte die benötigten Steuerelemente und die Programmlogik zum Aufruf der Funktionen dann selbst hinzufügen – immerhin ist das der wesentlich weniger aufwendige Teil dieser Aufgabe.<\/p>\n
Wir werden uns also zunächst darauf beschränken, den Code für die Anzeige von Dateidialogen abhängig von den gewünschten Parametern zu produzieren.<\/p>\n
Wo wollen wir diese Funktionalität bereitstellen? Sinnvoll ist ein COM-Add-In für den VBA-Editor, denn dort werden wir den zu erstellenden Code auch nutzen.<\/p>\n
Wo dort wollen wir die Funktion aufrufen? Hier gibt es drei mögliche Stellen:<\/p>\n
Die Entwicklungsumgebung und Programmiersprache twinBASIC hat sich als zuverlässiges Tool für die Programmierung von COM-Add-Ins und COM-DLLs für Office-Anwendungen und den VBA-Editor erwiesen, sodass wir diesen auch in diesem Artikel für die Erstellung des gewünschten Assistenten nutzen werden.<\/p>\n
Im Artikel twinBASIC: COM-Add-In für den VBA-Editor <\/b>(www.access-im-unternehmen.de\/421<\/b>) stellen wir eine Vorlage für die Programmierung von COM-Add-Ins für den VBA-Editor vor – und erläutern, welche Schritte nötig sind, um diese Vorlage in ein eigenes, neues COM-Add-In umzuwandeln.<\/p>\n
Genau das haben wir gemacht und so ein neues, fast leeres COM-Add-In erzeugt. Die einzigen Elemente, die dieses COM-Add-In enthält, dienen zur Anzeige von Menüeinträgen in einem neuen Menüpunkt im Hauptmenü des VBA-Editors sowie eines Eintrags eines Kontextmenüs, das erscheint, wenn wir mit der rechten Maustaste in das Codefenster klicken.<\/p>\n
Bevor wir starten, stellen wir eine Liste der Informationen zusammen, die wir vor dem Erstellen des Codes für die Anzeige eines Dateiauswahl-Dialogs vom Entwickler ermitteln müssen.<\/p>\n
Was benötigen wir also alles?<\/p>\n
Auf all diese Elemente gehen wir in den folgenden Abschnitten ein.<\/p>\n
Den Wizard wollen wir auf zwei Arten aufrufen können. Die erste ist der Menüeintrag AMV-Tools|amvFileDialogWizard <\/b>(siehe Bild 1).<\/p>\n
![\"Aufruf](\"..\/fileadmin\/_temp_\/2024_02\/pic_420_003.png\")
<\/p>\n
Bild 1: Aufruf per Menüeintrag<\/span><\/b><\/p>\n Die zweite und bevorzugte Möglichkeit ist der Aufruf über das Kontextmenü des Codefensters (siehe Bild 2).<\/p>\n Bild 2: Aufruf per Kontextmenü<\/span><\/b><\/p>\n In Bild 3 zeigen wir, wie der fertige Wizard aussehen soll. Hier sehen wir Eingabefelder für den Titel, den Funktionsnamen, den Buttontext und den beim Öffnen anzuzeigenden Pfad. Für Dialogtyp haben wir ein Kombinationsfeld hinterlegt.<\/p>\n Bild 3: Der FileDialog-Wizard in Aktion<\/span><\/b><\/p>\n Ob der Dialog die Mehrfachauswahl unterstützen soll, legen wir mit einer CheckBox fest. Schließlich kann der Benutzer die Beschreibung und die Dateiendung für Filter über zwei Textfelder eingeben, die mit der Plus-Schaltfläche zur Liste der anzuzeigenden Filter hinzugefügt werden. Mit der Minus-Schaltfläche kann der Benutzer den markierten Filtereintrag wieder entfernen.<\/p>\n Jede Änderung, die der Benutzer an einem der Steuerelemente vornimmt, wirkt sich direkt auf den angezeigten Code aus. Dadurch sieht der Benutzer jederzeit, welcher Code eingefügt wird, wenn er auf die OK<\/b>-Schaltfläche klickt.<\/p>\n Diesen Wizard programmieren wir in den folgenden Abschnitten.<\/p>\n Als Erstes erstellen wir ein neues Projekt auf Basis der Vorlage, die wir im Artikel twinBASIC: COM-Add-In für den VBA-Editor <\/b>(www.vbentwickler.de\/421<\/b>) beschrieben haben. In diesem Artikel haben wir auch gezeigt, an welchen Stellen Änderungen vorgenommen werden müssen, wenn wir ein neues COM-Add-In auf der Basis der Vorlage erstellen wollen. Der erste Schritt ist, dass wir die Hauptklasse in FileDialogWizard <\/b>umbenennen und das auch für einige weitere Elemente im Projekt erledigen.<\/p>\n Viele der Elemente können wir zunächst beibehalten. Dazu gehört auch die Prozedur CreateToolbars<\/b>. Hier haben wir lediglich die beiden Konstanten geändert, welche für die Anzeige des Menü- und des Kontextmenüeintrags verantwortlich sind. Diese lauten nun wie folgt:<\/p>\n Für die beiden Ereignisprozeduren, die durch die beiden Schaltflächen im Menü und im Kontextmenü ausgelöst werden, haben wir jeweils den Aufruf der Prozedur LaunchFileDialogWizard <\/b>eingetragen:<\/p>\n Damit sind die Arbeiten am Modul FileDialogWizard <\/b>bereits erledigt.<\/p>\n Die durch die Menübefehle aufgerufene Methode LaunchFileDialogWizard <\/b>finden wir in Listing 1. Sie ist dafür verantwortlich, das Fenster unseres Assistenten anzuzeigen und den Code anzuhalten, bis dieses Fenster entweder geschlossen oder ausgeblendet wird. Das Fenster initialisieren wir auf Basis des Form<\/b>-Objekts frmFileDialogWizard<\/b>, das wir weiter unten erläutern. An dieser Stelle ist erst einmal wichtig, wie wir es aufrufen, wie wir reagieren, wenn es den Fokus verliert und was dann geschieht. Bevor wir es anzeigen, speichern wir sein Handle in der Variablen lngHwnd<\/b>. Dann öffnen wir es mit der Show<\/b>-Methode und übergeben dieser den Wert vbModal <\/b>als Parameter, damit der aufrufende Code angehalten wird, bis der Benutzer die Arbeit mit dem Fenster abschließt.<\/p>\n Listing 1: Die Prozedur LaunchFileDialogWizard<\/span><\/b><\/p>\n Dann prüfen wir mit der Funktion IsWindow<\/b>, ob das Fenster noch geöffnet ist oder nicht. Im ersten Fall hat der Benutzer das Fenster mit der Abbrechen<\/b>-Schaltfläche oder der Schließen<\/b>-Schaltfläche geschlossen. Dann gibt es nichts weiter zu tun, als die Prozedur zu beenden.<\/p>\n Anderenfalls lesen wir den im Textfeld txtCode <\/b>enthaltenen Code in die Variable strCode <\/b>ein und schließen das Formular mit der Funktion UnloadObjectByHandle<\/b>, wobei wir das Handle des Fensters übergeben.<\/p>\n Danach referenzieren wir das aktuelle Codepane<\/b>– und dann das CodeModule<\/b>-Objekt. Über die Methode GetSelection <\/b>des CodePane<\/b>-Elements lesen wir die aktuelle Position der Markierung aus. Hier wollen wir anschließend den im Wizard zusammengestellten Code einfügen. Um die Markierung zu speichern, übergeben wir dieser Methode die Parameter lngStartLine<\/b>, lngStartColumn<\/b>, lngEndLine <\/b>und lngEndColumn<\/b>, die von dieser Methode gefüllt werden sollen.<\/p>\n Wir benötigen davon nur den Parameter lngStartLine<\/b>, denn in dieser Zeile wollen wir den Code mit der InsertLines<\/b>-Methode einfügen.<\/p>\n Das war einfach bisher – aber nun kommen wir zur eigentlichen Funktion.<\/p>\n Die Klasse clsFileDialogWizard<\/b> ist das Arbeitstier des COM-Add-Ins. Die Klasse nimmt alle notwendigen Informationen entgegen und erstellt den Code der Funktion zum Anzeigen des Dateidialogs. Dazu deklarieren wir in der Klasse zunächst die folgenden lokalen Variablen:<\/p>\n Diese füllen wir über entsprechende Property Let<\/b>-Prozeduren, die nach außen als Eigenschaften präsentiert werden. Für die meisten Eigenschaften ist das recht einfach – sie nehmen einfach den Wert entgegen und speichern diesen in der jeweiligen Variablen:<\/p>\n Nur für den Filter ist es etwas komplizierter. Hierfür definieren wir die Property Let<\/b>-Prozedur aus Listing 2. Sie nimmt eine Variable des Typs Variant <\/b>entgegen. Der Inhalt ist ein Array mit zwei Dimensionen, wobei die Zeilen jeweils die Beschreibung und die Dateiendung für den Filter enthalten.<\/p>\n Listing 2: Die Prozedur Filter<\/span><\/b><\/p>\n Die Prozedur stellt die Anweisungen zum Einstellen des Filters zusammen und speichert diese in der Variablen m_Filter<\/b>. Dabei schreibt sie in die erste Zeile die Anweisung zum Leeren des Filters (.Filters.Clear<\/b>).<\/p>\n Danach durchläuft sie die Zeilen des Arrays in einer For…Next<\/b>-Schleife und fügt für jede Zeile einen Eintrag wie den folgenden zum Filterausdruck hinzu – zum Beispiel:<\/p>\n Die Hauptarbeit in der Klasse übernimmt die Methode CreateFileDialogCode<\/b>, die wir in Listing 3 zeigen. Sie deklariert eine Variable namens strCode<\/b>, in der sie den kompletten Code zusammenträgt. Den Start macht die Kopfzeile der Prozedur, die aus Public Function <\/b>und dem Namen der Funktion aus m_FunktionName<\/b> besteht. Jede Zeile wird mit einem Zeilenumbruch abgeschlossen (vbCrLf<\/b>).<\/p>\n Listing 3: Die Prozedur CreateFileDialog<\/span><\/b><\/p>\n Die folgenden Zeilen fügen die Deklaration der Variablen für das FileDialog<\/b>-Objekt und einer temporären String<\/b>-Variablen hinzu, bevor die Zeile zum Initialisieren des FileDialog<\/b>-Objekts eingefügt wird. In dieser haben wir einen weiteren variablen Anteil, nämlich den Typ des FileDialog<\/b>-Elements. Dieser kann mit der Eigenschaft Type <\/b>übergeben werden und landet in m_Type<\/b>.<\/p>\n Um diese auszuwerten, verwenden wir eine Hilfsfunktion namens GetTypeConstant<\/b>, der wir den MsoFileDialogType <\/b>übergeben und die eine entsprechende Zeichenkette zurückliefert:<\/p>\n Danach folgt die Zuweisung der eigentlichen Eigenschaften. Wenn m_Title <\/b>einen Wert enthält, wird die Zeile .Title = [Titel] <\/b>hinzufügt (der Teil [Titel] <\/b>ist als Platzhalter zu verstehen). Ist ein Wert für ButtonName<\/b> übergeben worden, resultiert dies in der Anweisung .ButtonName = [ButtonName]<\/b>. Hat m_AllowMultiSelect <\/b>den Wert True<\/b>, wird dies mit .AllowMultiSelect = True <\/b>vermerkt. Diese Einstellung wird gleich nochmals berücksichtigt. Wurde ein initial anzuzeigender Pfad angegeben, landet dieser in der Zeile .InitialFilename = [Pfad]<\/b>. Anschließend wird der zuvor bereits zusammengestellte und in m_Filter <\/b>gespeicherte Teil mit den Anweisungen für den Filter hinzugefügt.<\/p>\n Danach kommen wir zum zweiten Teil, der durch die Eigenschaft AllowMultiSelect <\/b>beeinflusst wird. Diese Option legt fest, dass nicht nur eine, sondern gegebenenfalls auch mehrere Dateien ausgewählt werden können. Dem müssen wir bei der Auswertung des Dateiauswahl-Dialogs Rechnung tragen – und somit auch in der Prozedur, die den Code für diese Funktion zusammenstellt.<\/p>\n In diesem Fall fügen wir, falls m_AllowMultiSelect <\/b>den Wert True hat, eine For Each<\/b>-Schleife hinzu, die alle Einträge aus SelectedItems <\/b>durchläuft und sie in einer durch ein Trennzeichen separierten Liste zusammenstellt. Dabei fügen wir das Trennzeichen für jeden Eintrag voran und entfernen diesen für das erste Element anschließend wieder.<\/p>\n Wenn m_AllowMultiSelect <\/b>den Wert False <\/b>hat, fügen wir einfach die Anweisung strTemp = SelectedItems(1) <\/b>hinzu. Schließlich schließen wir die noch offenen If<\/b>– und With<\/b>-Konstrukte und fügen die letzte Anweisung hinzu, welche das Ergebnis aus strTemp <\/b>dem Namen Funktion zuweist. Das Ergebnis wird durch die Return<\/b>-Anweisung an die aufrufende Funktion zurückgegeben.<\/p>\n Damit kommen wir zur grafischen Benutzeroberfläche des COM-Add-Ins. Diese besteht aus einem Form<\/b>-Element, das wir über den Menüeintrag Project|Add|Add Form <\/b>hinzufügen. Dem Form<\/b>-Element fügen wir verschieden Steuerelemente hinzu (siehe Bild 4):<\/p>\n Bild 4: Anlegen eines Form-Elements in twinBASIC<\/span><\/b><\/p>\n Das Klassenmodul zum Form<\/b>-Element enthält zunächst die Deklaration einer Objektvariablen auf Basis der oben vorgestellten Klasse clsFileDialogWizard<\/b>. Danach folgt die Konstruktor-Methode New <\/b>der Form<\/b>-Klasse (siehe Listing 4). Diese deklariert zunächst einige Variablen, bevor sie eine neue Instanz der Klasse clsFileDialogWizard <\/b>erstellt.<\/p>\n![\"Aufruf](\"..\/fileadmin\/_temp_\/2024_02\/pic_420_004.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2024_02\/pic_420_002.png\")
<\/p>\nProgrammierung des COM-Add-Ins zur Bereitstellung des FileDialog-Wizards<\/h2>\n
Neues Projekt erstellen<\/h2>\n
Private <\/span>Const cStrMenu As String<\/span> = \"AMV-Tools\"\r\nPrivate <\/span>Const cStrCommandButton As String<\/span> = \"amvFileDialogWizard\"<\/pre>\nPrivate Sub <\/span>cbbEvents_Click(...) Handles _\r\n cbbEvents.Click\r\n LaunchFileDialogWizard\r\n ...\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>cbbEventsContext_Click(...) _\r\n Handles cbbEventsContext.Click\r\n LaunchFileDialogWizard\r\n ...\r\nEnd Sub<\/span><\/pre>\nDie Methode LaunchFileDialogWizard<\/h2>\n
Public Sub <\/span>LaunchFileDialogWizard()\r\n Dim <\/span>frm As <\/span>frmFileDialogWizard\r\n Dim <\/span>strCode As String<\/span>\r\n Dim <\/span>lngStartLine As Long<\/span>\r\n Dim <\/span>lngStartColumn As Long<\/span>\r\n Dim <\/span>lngEndLine As Long<\/span>\r\n Dim <\/span>lngEndColumn As Long<\/span>\r\n Dim <\/span>lngCurrentLine As Long<\/span>\r\n Dim <\/span>objCodepane As <\/span>CodePane\r\n Dim <\/span>objCodemodule As <\/span>CodeModule\r\n Dim <\/span>lngHwnd As Long<\/span>\r\n Set<\/span> frm = New<\/span> frmFileDialogWizard\r\n lngHwnd = frm.hWnd\r\n frm.Show vbModal\r\n If <\/span>IsWindow(lngHwnd) = 0 Then<\/span>\r\n Exit Sub<\/span>\r\n Else<\/span>\r\n strCode = frm.txtCode\r\n UnloadObjectByHandle(lngHwnd)\r\n Set<\/span> objCodepane = objVBE.ActiveCodePane\r\n Set<\/span> objCodemodule = objCodepane.CodeModule\r\n objCodepane.GetSelection(lngStartLine, lngStartColumn, _\r\n lngEndLine, lngEndColumn)\r\n objCodemodule.InsertLines(lngStartLine, strCode)\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nKlasse zum Erstellen des FileDialog-Codes<\/h2>\n
Private <\/span>m_Title As String<\/span>\r\nPrivate <\/span>m_Type As <\/span>MsoFileDialogType\r\nPrivate <\/span>m_FunctionName As String<\/span>\r\nPrivate <\/span>m_AllowMultiSelect As Boolean<\/span>\r\nPrivate <\/span>m_Separator As String<\/span>\r\nPrivate <\/span>m_ButtonName As String<\/span>\r\nPrivate <\/span>m_InitialFileName As String<\/span>\r\nPrivate <\/span>m_Filter As String<\/span><\/pre>\nPublic Property Let <\/span>Title(str As String<\/span>)\r\n m_Title = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Type(lng As <\/span>MsoFileDialogType)\r\n m_Type = lng\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>FunctionName(str As String<\/span>)\r\n m_FunctionName = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>AllowMultiSelect(bol As Boolean<\/span>)\r\n m_AllowMultiSelect = bol\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Separator(str As String<\/span>)\r\n m_Separator = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>ButtonName(str As String<\/span>)\r\n m_ButtonName = str\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>InitialFilename(str As String<\/span>)\r\n m_InitialFileName = str\r\nEnd Property<\/span><\/pre>\nPublic Property Let <\/span>Filter(var As Variant<\/span>)\r\n Dim <\/span>strTemp As String<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n If <\/span>IsEmpty(var) Then<\/span>\r\n m_Filter = \"\"\r\n Exit Property<\/span>\r\n End If<\/span>\r\n strTemp = \" .Filters.Clear\" & vbCrLf<\/span>\r\n For i = LBound<\/span>(var) To UBound<\/span>(var)\r\n strTemp += \" .Filters.Add \"\"\" & var(i, 1) _\r\n & \"\"\", \"\"\" & var(i, 2) & \"\"\"\" & vbCrLf<\/span>\r\n Next<\/span>\r\n m_Filter = strTemp\r\nEnd Property<\/span><\/pre>\n.Filters.Clear\r\n.Filters.Add \"Alle Dateitypen\", \"*.*\"<\/pre>\n
Zusammenstellen der FileDialog-Funktion<\/h2>\n
Public Function <\/span>CreateFileDialogCode() As String<\/span>\r\n Dim <\/span>strCode As String<\/span>\r\n strCode = \"Public Function \" & m_FunctionName & \"()\" & vbCrLf<\/span>\r\n strCode += \" Dim objFileDialog As <\/span>Office.FileDialog\" & vbCrLf<\/span>\r\n strCode += \" Dim strTemp As String<\/span>\" & vbCrLf<\/span>\r\n strCode += \" Set<\/span> objFileDialog = Application.FileDialog(\" & GetTypeConstant(m_Type) & \")\" & vbCrLf<\/span>\r\n strCode += \" With<\/span> objFileDialog\" & vbCrLf<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(m_Title) = 0 Then<\/span>\r\n strCode += \" .Title = \"\"\" & m_Title & \"\"\"\" & vbCrLf<\/span>\r\n End If<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(m_ButtonName) = 0 Then<\/span>\r\n strCode += \" .ButtonName = \"\"\" & m_ButtonName & \"\"\"\" & vbCrLf<\/span>\r\n End If<\/span>\r\n If <\/span>m_AllowMultiSelect = True<\/span> Then<\/span>\r\n strCode += \" .AllowMultiSelect = True\" & vbCrLf<\/span>\r\n End If<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(m_InitialFileName) = 0 Then<\/span>\r\n strCode += \" .InitialFilename = \"\"\" & m_InitialFileName & \"\"\"\" & vbCrLf<\/span>\r\n End If<\/span>\r\n strCode += m_Filter\r\n strCode += \" If .Show = True<\/span> Then\" & vbCrLf<\/span>\r\n If <\/span>m_AllowMultiSelect Then<\/span>\r\n strCode += \" For Each varFilename In .SelectedItems \" & vbCrLf<\/span>\r\n strCode += \" strTemp = strTemp & \"\"\" & m_Separator & \"\"\" & varFilename\" & vbCrLf<\/span>\r\n strCode += \" Next<\/span> varFilename\" & vbCrLf<\/span>\r\n strCode += \" If Not<\/span> Len<\/span>(strTemp) = 0 Then \" & vbCrLf<\/span>\r\n strCode += \" strTemp = Mid<\/span>(strTemp, 2)\" & vbCrLf<\/span>\r\n strCode += \" End If\" & vbCrLf<\/span>\r\n Else<\/span>\r\n strCode += \" strTemp = .SelectedItems(1) \" & vbCrLf<\/span>\r\n End If<\/span>\r\n strCode += \" End If\" & vbCrLf<\/span>\r\n strCode += \" End With\" & vbCrLf<\/span>\r\n strCode += \" \" & m_FunctionName & \" = strTemp\" & vbCrLf<\/span>\r\n strCode += \"End Function\"\r\n Return strCode\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>GetTypeConstant( _\r\n lngType As <\/span>MsoFileDialogType) As String<\/span>\r\n Select Case lngType\r\n Case <\/span>MsoFileDialogType.msoFileDialogFilePicker\r\n Return \"msoFileDialogFilePicker\"\r\n Case <\/span>MsoFileDialogType.msoFileDialogFolderPicker\r\n Return \"msoFileDialogFolderPicker\"\r\n Case <\/span>MsoFileDialogType.msoFileDialogOpen\r\n Return \"msoFileDialogOpen\"\r\n Case <\/span>MsoFileDialogType.msoFileDialogSaveAs\r\n Return \"msoFileDialogSaveAs\"\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\nErstellen des Form-Elements<\/h2>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2024_02\/pic_420_005.png\")
<\/p>\n\n