<\/p>\n
Lernen Sie alternative Formulare und Steuerelemente kennen.<\/p>\n
Formulare, VBA<\/p>\n
Access 97 und höher<\/p>\n
Sascha Trowitzsch, Berlin<\/b><\/p>\n
Der Access-Entwickler sucht ständig nach neuen Mitteln, die Oberfläche seiner Anwendungen ansprechender und funktioneller zu gestalten. ActiveX-Steuerelemente zum Nachrüsten gibt es wie Sand am Meer, doch bringen diese meist Probleme bei der Weitergabe mit sich. Aber warum in die Ferne schweifen Die MSForms-Library bringt eine ganze Reihe von Steuerelementen mit – und ist quasi Bestandteil von Access. Und das Beste: Diese Steuerelemente lassen sich sogar zur Laufzeit anlegen! <\/b><\/p>\n
Access im Unternehmen hat schon in anderen Beiträgen auf die begrenzte Anzahl von Steuerelementen und deren Möglichkeiten in Access hingewiesen und Alternativen wie das TreeView, das ListView oder grafische Schaltflächen vorgestellt. Und das ist nur die Spitze des Eisbergs: Kommerzielle Steuerelemente und passende Eigenentwicklungen für alle möglichen Einsatzzwecke gibt es zuhauf. Das Problem ist die Weitergabe von Anwendungen, die solche Steuerelemente verwenden: Man handelt sich mit solchen Fremdsteuerelementen häufig Installations- oder Verweisprobleme ein. Dabei findet man in der Microsoft Forms Library eine Fundgrube von Steuerelementen vor, die mit jeder Access-Version inklusive der Runtime automatisch mitinstalliert werden. Auf den folgenden Seiten lernen Sie die Steuerelemente dieser Library kennen und erfahren, wie Sie diese unter Access einsetzen.<\/p>\n
Unter Word und Excel sind sie gang und gäbe: Die UserForms der MSForms-Library (fm20.dll). Sie werden dort meist für benutzerdefinierte Dialoge eingesetzt. Im VBA-Projekt eines Word-Dokuments oder einer Excel-Arbeitsmappe lassen sie sich über den Menübefehl Einfügen\/UserForm des VBA-Editors in das Projekt integrieren und können dann unter Zuhilfenahme des Fensters Werkzeugsammlung mit Steuerelementen versehen werden. <\/p>\n
In Access-Datenbanken hingegen findet man nur sehr selten solche UserForms. Und das hat auch einen Grund: Der Menübefehl Einfügen\/UserForm steht aus unerfindlichen Gründen im VBA-Editor von Access standardmäßig nicht zur Verfügung. Doch das lässt sich leicht ändern, wenn Sie die Menüleiste modifizieren: Dazu wählen Sie einfach den Eintrag Anpassen aus dem Kontextmenü der Menüleiste aus und fügen dem Menü Einfügen wie in Bild 1 den Eintrag UserForm hinzu. Ein Klick auf diesen Eintrag erzeugt dann ein neues UserForm und zeigt dessen Entwurf im Code-Bereich des VBA-Editors an.<\/p>\n
![](\"..\/fileadmin\/_temp_\/{3196FE61-0CE0-4B25-BD78-2FCA39D6F9AC}\/pic001.png\")
<\/p>\n
<\/b><\/p>\n
Bild 1: UserForm-Eintrag zur Menüleiste hinzufügen<\/span><\/b><\/p>\n Ein UserForm ist genauso ein Formular wie das Access-eigene. Allerdings ist es kein Child-Fenster der MDI-Umgebung, sondern ein eigenständiges Fenster, das mit einem als modaler Dialog geöffneten Access-Formular verwandt ist. Steuerelemente fügen Sie ihm über eine eigene Werkzeugsammlung hinzu, die sichtbar wird, wenn die UserForm im Entwurf den Fokus hat.<\/p>\n <\/b><\/p>\n Bild 2: UserForms im Projekt-Explorer<\/span><\/b><\/p>\n Sollte diese Toolbox nicht angezeigt werden, aktivieren Sie diese mit dem Menüeintrag Ansicht\/Werkzeugsammlung des VBA-Editors. Im Projekt-Explorer finden Sie das UserForm in der erst jetzt sichtbaren Kategorie Formulare (siehe Bild 2). Diese Bezeichnung mag etwas irreführend sein, befinden sich doch die Access-Formulare in der Kategorie Microsoft Access Klassenobjekte.<\/p>\n Die UserForms sind im Objektmodell auch nicht Teil der Forms-Auflistung von Access, sondern haben eine eigene Auflistung: VBA.UserForms (Typ Object).<\/p>\n Haben Sie ein UserForm im Entwurf geöffnet, dann lässt es sich über den Ausführen-Pfeil der Menüleiste im Runtime-Modus öffnen. Mit einem Doppelklick auf eines der enthaltenen Steuerlemente oder das UserForm selbst gelangen Sie in dessen VBA-Code. Alternativ klicken Sie mit der rechten Maustaste im Projekt-Explorer auf den passenden Eintrag und wählen aus dem Kontextmenü den Eintrag Code anzeigen aus.<\/p>\n Warum und wann sollte man nun UserForms in Access-Datenbanken verwenden Ein Anwendungsfall sind kleine Dialoge und Meldungsfenster, für die ein Access-Formular eigentlich überdimensioniert ist. Ein UserForm ist spart viele Ressourcen, weil es keine Funktionalität zur Datenbindung enthält.<\/p>\n Ein anderer Grund sind die MSForms-Steuerelemente der Werkzeugsammlung, die teilweise über mehr Einstellmöglichkeiten verfügen (vor allem grafische) als die analogen Access-Steuerelemente und manchmal auch leichter zu programmieren sind.<\/p>\n Beispiele sind die Listbox, die Combobox, das Multipage-Element (Registerkarten) und das Image-Steuerelement. Den SpinButton oder die Scrollbar gibt es in Access erst gar nicht.<\/p>\n Eingebettete ActiveX-Steuerelemente funktionieren in UserForms besser als in Access-Formularen – dort verhalten Sie sich oft unerwartet oder sind gar nicht zu gebrauchen.<\/p>\n Die in Bild 3 dargestellte Werkzeugsammlung enthält übrigens noch die benutzerdefinierten Reiter „ActiveX“ und „Neue Seite“. Wie Sie die Sammlung um neue Reiter oder Steuerelemente erweitern können, erläutert die Visual Basic-Hilfe unter Microsoft Forms-Referenz\/übersicht zum Entwurf.<\/p>\n <\/b><\/p>\n Bild 3: Werkzeugsammlung der MSForms-Steuerelemente<\/span><\/b><\/p>\n Wie Sie weiter unten sehen werden, lassen sich MSForms-Steuerelemente genauso gut in ein Access-Formular einbauen. Es ist allerdings einfacher, deren Eigenschaften über das Eigenschaftsfenster des VBA-Editors einzustellen, wenn sie in ein UserForm integriert sind.<\/p>\n Schließlich gibt es noch einen weiteren Grund für den Einsatz von UserForms: Sie können darin zur Laufzeit Steuerelemente erzeugen.<\/p>\n In Access-Formularen ist das nicht möglich, ohne diese in der Entwurfsansicht anzuzeigen, was in einer professionellen Anwendung nicht passieren sollte.<\/p>\n Hier behilft man sich oft mit einem vorher im Entwurf angelegten „Vorrat“ von Steuerelementen, die zur Laufzeit sichtbar oder unsichtbar geschaltet werden. Weiter unten erfahren Sie, wie Sie MSForms-Steuerelemente zur Laufzeit erzeugen.<\/p>\n Was spricht gegen den Einsatz von UserForms Weder UserForms noch die Steuerelemente der MSForms-Bibliothek lassen sich so einfach wie die in Access eingebauten Formulare oder Steuerelemente an eine Datenherkunft binden.<\/p>\n Sie müssen grundsätzlich per VBA und Recordsets mit Daten aus Tabellen oder Abfragen gefüllt werden, was sie in dieser Hinsicht kompliziert und unflexibel macht.<\/p>\n Dass Sie ein entworfenes UserForm im VBA-Editor mit dem „Ausführen“-Pfeil öffnen können, wissen Sie bereits. Dem Benutzer einer fertigen Anwendung können Sie das natürlich nicht zumuten – dort müssen Sie Menüeinträge oder Schaltflächen zum öffnen von Elementen der Benutzerumgebung bereitstellen, die den notwendigen Code ausführen. Access-Formulare öffnet man in VBA mit dieser DoCmd-Methode:<\/p>\n Für UserForms existiert keine analoge Anweisung, aber es gibt drei alternative Möglichkeiten. Sie können eine neue Instanz der entsprechenden UserForm-Klasse instanzieren und sie anschließend mit der Methode Show anzeigen:<\/p>\n Auf ähnliche Weise lässt sich auch die Load-Anweisung von VBA verwenden:<\/p>\n Beide Lösungen haben aber den Nachteil, dass Sie den Namen des zu öffnenden Elements nicht per Variable übergeben können, wie es bei der DoCmd.OpenForm-Methode von Access möglich ist. Die trickreiche dritte Lösung gestattet aber auch dies:<\/p>\n Die im Objektkatalog vorhandene, aber versteckte Methode Add der UserForms-Auflistung gibt eine neue Instanz des in sName angegebenen UserForms zurück.<\/p>\n Im Code-Beispiel ist die Methode Show noch mit dem Parameter vbModal versehen. Das bewirkt, dass das UserForm als modaler Dialog geöffnet wird, was die Ausführung des Codes an dieser Stelle anhält.<\/p>\n Das Schließen eines UserForms erledigt die Unload-Methode von VBA:<\/p>\n Auch hier haben wir wieder den Nachteil, dass man die Instanz des Formulars nicht per String-Variable übergeben kann. Leider kennt das UserForms-Objekt auch kein Pendant zu Add wie etwa die von anderen Objekten bekannte Remove-Methode. Um dennoch das Entladen eines UserForms per Variable zu ermöglichen, ist ein Umweg über die kleine Routine aus Quellcode 1 nötig.<\/p>\n Quellcode 1: Namentlich benanntes UserForm schließen<\/b><\/p>\n Sie finden diese und die Prozedur zum öffnen eines UserForms im Modul mdlMSForms der Beispieldatenbank.<\/p>\n Die Steuerelemente der MSForms-Library sind fast ausschließlich ActiveX-Komponenten. Als solche können Sie diese über den Menübefehl Einfügen\/ActiveX-Steuerelement… in die Entwurfsansicht eines Formulars oder Berichts eingefügen. Wenn Sie diesen Menübefehl aufrufen, finden Sie die MSForms-Steuerelemente in der Liste der ActiveX-Komponenten unter Microsoft Forms 2.0 …. Die Beispieldatenbank enthält ein Formular namens frmAllControls, das alle derart verfügbaren Steuerelemente enthält. Sehen Sie es sich an, um eine übersicht zu erhalten.<\/p>\n <\/p>\n Gelegentlich hört man, dass es Probleme mit diesen Steuerelementen beim Einsatz in Access-Formularen gebe. Ich selbst konnte derlei noch in keiner Access-Version feststellen oder reproduzieren.<\/p>\n Eigenschaften der Steuerelemente einstellen<\/b><\/p>\n Die Eigenschaften der Steuerelemente lassen sich nur recht unkomfortabel einstellen. Im Eigenschaftsfenster von Access findet sich auf der Registerseite Andere jeweils nur eine Auswahl der tatsächlich vorhandenen Eigenschaften. Leider fördert auch ein Klick auf die …-Schaltfläche der Eigenschaft Benutzerdefiniert keine weiteren Eigenschaften zutage, wie man dies von anderen ActiveX-Steuerelementen gewohnt ist. <\/p>\n Es gibt zwei Möglichkeiten, um ein MS-Forms-Steuerelement zum Bearbeiten vorzubereiten:<\/p>\n Die erste liefert der Eintrag [Steuerelementname]-Objekt\/Bearbeiten (wobei [Steuerelementname] durch die Bezeichnung des jeweiligen Objekts wie in Bild 4 zu ersetzen ist).<\/p>\n <\/b><\/p>\n Bild 4: Editieren eines MSForms-Labels<\/span><\/b><\/p>\n Ein Doppelklick auf das Steuerelement bewirkt dasselbe. Es bekommt dabei einen schraffierten Rahmen, der den Bearbeitungsmodus andeuten soll.<\/p>\n Je nach Steuerelement sieht dieses Bearbeiten anders aus: Bei Textboxen, Labels oder Buttons kann man lediglich die Beschriftung oder den Textinhalt eingeben. Beim Rahmensteuerelement (Frame) oder der Multipage (Register) lässt sich jedoch über ein weiteres Kontextmenü ein MSForms-Eigenschaftsfenster öffnen (siehe Bild 5).<\/p>\n <\/b><\/p>\n Bild 5: Kontextmenü des MSForms-Multipage-Steuerelements<\/span><\/b><\/p>\n Die dort aufgeführten Eigenschaften lassen sich nicht wie gewohnt direkt editieren. Stattdessen markiert man eine Zeile und stellt mit dem Steuerelement im oberen Bereich des Eigenschaftsfensters den gewünschten Wert ein beziehungsweise wählt diesen aus (siehe Bild 6).<\/p>\n <\/b><\/p>\n Bild 6: MSForms-Eigenschaftenfenster zum Multipage-Steuerelement als Popupfenster<\/span><\/b><\/p>\n Einfacher als die nicht gerade intuitive Anpassung der MSForms-Steuerelemente ist der Weg über den VBA-Editor: Dieser bietet ebenfalls ein Eigenschaftsfenster (Ansicht\/Eigenschaftsfenster oder F4), das die Eigenschaften des aktuell im Access-Fenster markierten Objekts oder Steuerelements anzeigt. Am Besten funktioniert dies, wenn Sie zwei Monitore zur Verfügung haben und auf dem einen Bildschirm den Formularentwurf und im anderen den VBA-Editor anzeigen.<\/p>\n Die Beispieldatenbank verdeutlicht die Features rund um die MSForms-Bibliothek über verschiedene UserForms und Access-Formulare mit MSForms-Steuerelementen.<\/p>\n Die Datenbank zeigt nach dem öffnen zunächst ein Switchboard-Formular mit sieben Schaltflächen zum Aufrufen der verschiedenen Beispielformulare an.<\/p>\n Davon macht auch die Ereignisprozedur Form_Load des Formulars Gebrauch.<\/p>\n Schaltfläche 3 öffnet das Formular frmMSFrame, in das ein MSForms-Rahmensteuerelement (Frame) eingebunden ist.<\/p>\n Ein Frame ist ein Container für weitere Steuerelemente. Es verhält sich gewissermaßen genauso wie ein UserForm. In ein Access-Formular eingebaut simuliert es ein Unterformular. Wenn sie das Frame in der Entwurfsansicht doppelklicken, dann können Sie im Kontextmenü die Werkzeugsammlung aufrufen, mit deren Hilfe sie ihm die weiteren Steuerelemente verpassen. Anschließend stellen Sie deren Eigenschaften so wie im Entwurf eines UserForms im VBA-Editor ein.<\/p>\n Erwähnenswert ist noch der Formularcode von frmMSFrame: Wenn Sie MSForms-Steuerelemente in ein Access-Formular aufnehmen, dann können Sie deren Ereignisprozeduren nicht im Eigenschaftsfenster von Access einstellen. Das ist bei allen ActiveX-Steuerelementen so. Stattdessen wählt man im VBA-Editor in der linken Combobox des Codefensters den Steuerelementnamen aus und bekommt dann in der rechten Combobox die Ereignisse präsentiert. Wählt man eines davon aus, entsteht automatisch der Rumpf für die passende Prozedur.<\/p>\n Die Namen der in einen Frame eingebetteten Steuerelemente werden sie jedoch in diesen Auswahlfeldern vergeblich suchen, da sie untergeordnete Steuerelemente darstellen. Um dennoch Ereignisprozeduren für sie schreiben zu können, müssen Sie passende Objektvariablen im Code anlegen.<\/p>\n Quellcode 2: Objektvariable ctlText1 WithEvents an MSForms-Steuerelement Textbox1 binden<\/b><\/p>\n Die Routine Form_Load aus Quellcode 2 wird beim Laden des Formulars ausgeführt. Es weist der im Modulkopf deklarierten Objektvariablen ctlTxt1 das dem Frame-Steuerelement untergeordnete Steuerelement Textbox1 zu:<\/p>\n Da die Variable mit dem Schlüsselwort WithEvents („mit Ereignissen“) deklariert ist, zeigt das rechte Kombinationsfeld des Codefensters die passenden Ereignisse an, wenn das Steuerelement im linken Kombinationsfeld ausgewählt ist.<\/p>\n Quellcode 2 enthält außerdem eine Ereignisprozedur für das im Frame enthaltene Textfeld: Es sorgt dafür, dass beim Klick in das Textfeld eine Meldung angezeigt wird – probieren Sie es einfach einmal aus.<\/p>\n Schaltfläche 4 startet das Formular frmMultipage. Es enthält das Multipage-Steuerelement der MSForms-Bibliothek, das dem Register-Steuerelement von Access entspricht, und zeigt eine von dessen der Spezialitäten: Jede Registerseite kann ein anderes Hintergrundbild anzeigen.<\/p>\n Die Bilder werden dabei im Load-Ereignis des Formulars geladen. Man kann sie zwar auch im Formularentwurf über die Eigenschaft Picture und einen Dialog zur Bilddatei-Auswahl in das Steuerelement einfügen, es hat sich jedoch gezeigt, dass sie dabei nicht zuverlässig gespeichert werden.<\/p>\n Neben diesem Feature lässt sich das Multipage-Element flexibler formatieren als das Access-Registerkartensteuerelement. Sie fügen diesem Steuerelement neue Seiten hinzu, indem Sie doppelt darauf klicken und dann im Kontextmenü den Eintrag „Einfügen“ auswählen.<\/p>\n <\/b><\/p>\n Bild 7: Neue Seiten in das Multipage-Element einfügen<\/span><\/b><\/p>\n Mit einem Klick auf Schaltfläche 5 öffnen Sie ein Formular, das eine Anwendungsmöglichkeit für das MSForms-Frame zeigt. ctlFrame enthält ein weiteres Frame, dem zwei weitere Steuerelemente untergeordnet sind: ein Bezeichnungsfeld und ein Bild-Element. Beim Klick auf die Schaltfläche Bilder zeigen füllt sich das Pseudo-Unterformular mit der Vorschau auf Bilddateien im Anwendungsverzeichnis. Der VBA-Code hierfür hat gerade einmal 20 Zeilen! Sein Herzstück sind die zwei Methoden Copy und Paste des Objekts Frame.Controls. Der Ablauf der Prozedur sieht so aus:<\/p>\n Zuerst wird das untergeordnete Frame in die Zwischenablage kopiert:<\/p>\n Das führt dazu, dass nicht nur dieses Frame, sondern auch alle darin enthaltenen Steuerelemente kopiert werden! Anschließend durchsucht die Routine das Anwendungsverzeichnis mit der VBA-Funktion Dir() und lädt jede gefundene Datei mit LoadPicture:<\/p>\n Das funktioniert natürlich nur für Bilddateien. Deshalb sorgt ein On Error Resume Next vor dieser Zeile dafür, dass Fehler aufgrund ungültiger Dateien nicht angezeigt werden. Die folgende Zeile prüft dann, ob die Bilddatei erfolgreich geladen wurde:<\/p>\n In diesem Fall – und das ist der Clou der Geschichte – wird nun der in der Zwischenablage befindliche Satz von Steuerelementen in das Frame übernommen:<\/p>\n Anschließend stellt die Routine einige Eigenschaften der neu eingefügten Steuerelemente ein: Das Bezeichnungsfeld zeigt den Dateinamen an (Caption), das Image-Element wird mit dem in der Datei enthaltenen Bild gefüllt, und mit der Top-Eigenschaft wird das neue Frame so positioniert, dass es unterhalb des zuvor angelegten erscheint. Eine Schleife sorgt dafür, dass alle im Verzeichnis enthaltenen Dateien eingelesen werden.<\/p>\n Dieses Verfahren zeigt, wie man zur Laufzeit neue Steuerelemente erzeugen kann – und das auch noch auf einfachste Weise per Copy & Paste und anschließendes Anpassen.<\/p>\n Die Schaltflächen 6 und 7 des Switchboards öffnen zwei weitere UserForms, die die Möglichkeiten zum dynamischen Erzeugen von MSForms-Steuerelementen ausführlicher demonstrieren.<\/p>\n UserForm2 produziert bei Mausklick auf die Schaltfläche Neue Elemente erzeugen aus dem Nichts verschiedene Steuerelemente und ordnet diese reihenweise an.<\/p>\n UserForm3 ist komplett leer, wenn Sie es im VBA-Editor aufrufen. Beim Start über die Schaltfläche 7 des Switchboards weist ihm die öffentliche Prozedur FillForm jedoch ein zuvor erzeugtes Recordset zu. Diese Prozedur erzeugt dann aus dessen Feldern automatisch alle benötigten Steuerelemente, um seine Inhalte in einer Art Endlosformular zu präsentieren.<\/p>\n Die dazu notwendigen Techniken werden im folgenden Kapitel genauer erläutert.<\/p>\n Die weiter oben vorgestellte Copy and Paste-Methode bietet eine einfache Möglichkeit, neue Steuerelemente in einem Frame oder einem UserForm zu generieren. Sie erfordert allerdings einen Satz der gewünschten Steuerelemente als „Kopiervorlage“. Diese lassen sich jedoch zur Laufzeit von Grund auf neu erzeugen. Das Verfahren ist fast identisch zur Vorgehensweise in Formularen unter Visual Basic 6.<\/p>\n Neue MSForms-Steuerelemente können in den folgenden Elementen\/Steuerelementen erzeugt werden:<\/p>\n Jedes der genannten Elemente besitzt eine Controls-Auflistung, die als Startpunkt zum Generieren neuer Steuerelementen dient.<\/p>\n Ein einfaches Beispiel ist das Erzeugen eines Bezeichnungsfeldes in einem UserForm. Dazu sind die folgenden Anweisungen erforderlich:<\/p>\n Hier wird zunächst die Variable oCtl als allgemeines Control-Objekt der MSForms-Library deklariert. Sie kann dann auf beliebige Arten von Steuerelementen verweisen. Me verweist genauso wie bei Access-Formularen auf das UserForm. Dessen Controls-Objekt kennt die Methode Add. Sie erwartet als Parameter lediglich die ProgID, also die Klassenbezeichnung eines MSForms-Steuerelements – die übrigen beiden Parameter sind optional. Damit gleicht sie der Methode CreateObject von VBA.<\/p>\n In der Tat lässt sich auch damit ein MSForms-Objekt instanzieren, wie folgende im Direktfenster abgesetzte Anweisung zeigt:<\/p>\n Die Ausgabe dieser Anweisung lautet Label. Die beiden zusätzlichen Parameter der Add-Methode sind der Name des neuen Steuerelements – hier Bez1 – und ein Boolescher Wert, der angibt, ob das Steuerelement direkt sichtbar sein soll. Den Codeausschnitt oben hätte man auch so schreiben können:<\/p>\n Hier zeigt sich auch, wie mit dem im Ursprungszustand erzeugten Control weiter zu verfahren ist. Nach dem Anlegen im UserForm hat es einige Standardeigenschaften, die per Code geändert werden müssen. Zum Beispiel wird es automatisch in der linken oberen Ecke des Containers platziert. Unser Bezeichnungsfeld wird also nun mit Eigenschaftswerten ausgestattet:<\/p>\n Die Eigenschaften der jeweiligen Steuerelemente entnehmen Sie dem Objektkatalog, nachdem Sie dort die MSForms-Bibliothek ausgewählt haben. Es empfiehlt sich dabei, über das Kontextmenü die Option Versteckte Elemente anzeigen zu aktivieren. In unserem Label-Objekt wurde zum Beispiel die versteckte Eigenschaft Fontname gesetzt.<\/p>\n Nach dem gleichen Schema lassen sich auch alle anderen Steuerelemente erzeugen. Man muss dazu nur deren Klassenbezeichnung kennen. Tab. 1 enthält die Gesamtliste der ProgIDs.<\/p>\n Steuerelement<\/b><\/p>\n<\/td>\n Klassenbezeichnung<\/b><\/p>\n<\/td>\n<\/tr>\n Bezeichnungsfeld<\/p>\n Forms.Label.1<\/p>\n Bildelement<\/p>\n Forms.Image.1<\/p>\n Bildlaufleiste<\/p>\n Forms.ScrollBar.1<\/p>\n Drehfeld<\/p>\n Forms.SpinButton.1<\/p>\n Kombinationsfeld<\/p>\n Forms.ComboBox.1<\/p>\n Kontrollkästchen<\/p>\n Forms.CheckBox.1<\/p>\n Listenfeld<\/p>\n Forms.ListBox.1<\/p>\n Optionsfeld<\/p>\n Forms.OptionButton.1<\/p>\n Rahmen<\/p>\n Forms.Frame.1<\/p>\n Register (überfl.)<\/p>\n Forms.TabStrip.1<\/p>\n Registerseiten<\/p>\n Forms.MultiPage.1<\/p>\n Schaltfläche<\/p>\n Forms.CommandButton.1<\/p>\n Textfeld<\/p>\n Forms.TextBox.1<\/p>\n Umschaltfeld<\/p>\n Forms.ToggleButton.1<\/p>\n<\/table>\n Tab. 1: Steuerelemente und Klassenbezeichnungen<\/b><\/p>\n Die möglichen Eigenschaften dieser Elemente gehen aus dem Objektkatalog hervor. Damit Sie nicht raten müssen, was sich hinter den Bezeichnungen verbirgt oder wie die genaue Syntax einer dort eingebauten Methode aussieht, markieren Sie die Eigenschaft und drücken F1. Die VBA-Hilfe liefert nämlich zu allen Elementen eine ausführliche Beschreibung. Eine Schilderung auch nur der wichtigsten Features würde den hier verfügbaren Raum sprengen.<\/p>\n Zurück zu den beiden UserForms der Demo-Datenbank: Der VBA-Code der UserForm frmUserForm2 enthält die Ereignisprozedur cmdNewCtls_Click. Diese erzeugt hintereinander in Schleifen diverse Controls im Frame1 und versieht diese mit Eigenschaftswerten.<\/p>\n Interessant ist hier noch der Scroll-Bereich für das UserForm. Nachdem die Controls angelegt wurden, dann sind sie in der UserForm eventuell nicht alle sichtbar, weil sie außerhalb des sichtbaren Bereichs platziert wurden. Deshalb ist das UserForm mit einem horizontalen Scrollbalken ausgestattet. Seine Einstellung ScrollWidth gibt an, um wie viele Pixel man den sichtbaren Bereich verschieben kann. Sinnvoll ist es hier, in etwa denselben Wert wie für die Breite des enthaltenen Frames zu nehmen:<\/p>\n übrigens sind alle Maße in der MSForms-Bibliothek in Pixels anzugeben, nicht in Twips wie in Access (ein Pixel = 15 Twips bei 96dpi Bildschirmauflösung).<\/p>\n Auch das frmUserForm1 der Beispieldatenbank ist zunächst weitgehend leer und enthält lediglich ein Frame namens SubWnd. Dieses wird dann über die öffentliche Methode FillForm mit Steuerelementen bestückt.<\/p>\n Die Prozedur erwartet ein beliebiges DAO-Recordset als Parameter. Die Routine durchläuft die Fields-Auflistung des angegebenen Recordsets und bestimmt den Datentyp der Felder. Beim Typ Boolean erzeugt sie eine Checkbox, in allen anderen Fällen eine Textbox. Deren Value-Eigenschaften füllt die Routine dann mit den Field-Werten des Recordsets. Für die Spaltenköpfe kommen Labels zum Einsatz, deren Caption-Eigenschaften sich aus den Namen der Felder des Recordsets ergeben. <\/p>\n Zum Schluss berechnet die Routine anhand der Zahl der Felder und Datensätze den Scrollbereich des Formulars und stellt dessen Eigenschaften entsprechend ein. Das Ergebnis ist eine Darstellung des Recordsets in einer Art Endlosformular. Beachten Sie dabei, dass für jede Zelle der Tabelle ein eigenes Steuerelement angelegt wird. Ergo kann auch jede Zelle später individuell formatiert werden.<\/p>\n Jedes Steuerelement ist ein eigenes Windows-Fenster. Damit wird auch klar, dass dies eine ressourcenfressende Angelegenheit ist. Das UserForm eignet sich nicht für die Anzeige von Recordsets mit Tausenden von Datensätzen. Ein Test mit 3000 Datensätzen und zwölf Feldern hat zwar ergeben, dass auch das möglich ist, die Verarbeitung wird dann aber außerordentlich zäh. Irgendwann sprengt der Bedarf an Ressourcen das Speicherlimit des Windows-GDI. Prinzipiell scheint aber die Zahl an Steuerelementen, die ein UserForm aufnehmen kann, nicht begrenzt zu sein.<\/p>\n Die Initialize-Prozedur des UserForms sollte Sie übrigens nicht irritieren. Sie arbeitet mit API-Funktionen, um dem Formular bestimmte Fenstereigenschaften zu verpassen. Immerhin können Sie daran erkennen, dass MSForms-Steuerelemente, da sie alle ein Fenster-Handle besitzen, mit API-Funktionen verändert werden können – im Gegensatz zu Access-Steuerelementen. Es ist allerdings nicht ganz einfach, an diese Handles zu gelangen, wie diese Zeile zeigt:<\/p>\n Mit den Elementen der von Office grundsätzlich installierten MSForms-Bibliothek lässt sich die Benutzeroberfläche einer Access-Datenbank deutlich aufwerten. Gerade die beiden zuletzt beschriebenen UserForms der Beispieldatenbank zeigen, wie flexibel MSForms und deren Steuerelemente eingesetzt werden können, wenn sie dynamisch zur Laufzeit erzeugt werden. Bei Ihren eigenen Versuchen, die Benutzeroberfläche mit diesen Steuerelementen zu ergänzen, helfen Ihnen die Sektion MSForms in der VBA-Hilfe und der VBA-Objektkatalog weiter.<\/p>\n Enthaltene Beispieldateien:<\/p>\n MSFormsDemo.zip<\/p>\n![](\"..\/fileadmin\/_temp_\/{3196FE61-0CE0-4B25-BD78-2FCA39D6F9AC}\/pic002.png\")
<\/p>\nPro UserForms<\/h3>\n
![](\"..\/fileadmin\/_temp_\/{3196FE61-0CE0-4B25-BD78-2FCA39D6F9AC}\/pic003.png\")
<\/p>\nContra UserForms<\/h3>\n
DoCmd.OpenForm \"frmXY\"<\/pre>\n
Dim oForm As Object\r\nSet oForm = New frmUserForm1\r\noForm.Caption = \"Ein Titel\"\r\noForm.Show<\/pre>\n
Load frmUserForm1\r\nfrmUserForm1.Show<\/pre>\n
Dim sName As String\r\nsName =\"frmUserForm1\"\r\nVBA.UserForms.Add(sName).Show vbModal<\/pre>\n
Unload frmUserForm1<\/pre>\n
Sub UnloadUserForm(sName As String)\r\n Dim i As Long\r\n \r\n For i = 0 To VBA.UserForms.Count\r\n If UserForms.Item(i).Name = sName Then\r\n Unload UserForms.Item(i)\r\n Exit For\r\n End If\r\n Next i\r\nEnd Sub<\/pre>\n
MSForms-Steuerelemente bearbeiten<\/h3>\n
![](\"..\/fileadmin\/_temp_\/{3196FE61-0CE0-4B25-BD78-2FCA39D6F9AC}\/pic004.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{3196FE61-0CE0-4B25-BD78-2FCA39D6F9AC}\/pic005.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{3196FE61-0CE0-4B25-BD78-2FCA39D6F9AC}\/pic006.png\")
<\/p>\nUserForm per VBA öffnen<\/h3>\n
Alle auf einen Streich<\/h3>\n
Set CommandButton.Picture = LoadPicture(\"c:\\meinbild.jpg\")<\/pre>\n
Alles im Rahmen<\/h3>\n
Private WithEvents ctlTxt1 As MSForms.TextBox\r\nPrivate Sub Form_Load()\r\n Set ctlTxt1 = _ ctlFra-me.Object.Controls(\"Textbox1\")\r\nEnd Sub\r\nPrivate Sub ctlTxt1_MouseDown(ByVal Button _ As Integer, ByVal Shift As Integer, _ ByVal x As Single, ByVal y As Single)\r\n MsgBox \"Textbox Mousedown\"\r\nEnd Sub<\/pre>\n
ctlFrame.Object.Controls(\"Textbox1\")<\/pre>\n
Multipage statt Register<\/h3>\n
![](\"..\/fileadmin\/_temp_\/{3196FE61-0CE0-4B25-BD78-2FCA39D6F9AC}\/pic007.png\")
<\/p>\nFrame im Frame<\/h3>\n
ctlFrame.Object.Controls.Copy<\/pre>\n
Set oPic = LoadPicture(sPath & \"\\\" & sFile<\/pre>\n
If Not oPic Is Nothing Then ...<\/pre>\n
ctlFrame.Paste<\/pre>\n
Dynamische Steuerelemente<\/h3>\n
Dim oCtl As MSForms.Control\r\nSet oCtl = Me.Controls.Add( _\r\n\"Forms.Label.1\", \"Bez1\", True)<\/pre>\n
Typename(CreateObject(\"Forms.Label.1\"))<\/pre>\n
Dim oCtl As MSForms.Control\r\nSet oCtl = _\r\n Me.Controls.Add(\"Forms.Label.1\")\r\noCtl.Name = \"Bez1\"\r\noCtl.Visible = True<\/pre>\n
With oCtl\r\n .Visible = True\r\n .Top = 10 ''Pixel\r\n .Left = 20 ''Pixel\r\n .Caption = \"Beschreibung\"\r\n .Fontname = \"Arial\"\r\nEnd With<\/pre>\n
\n
\n \n \n Beispiel-UserForms<\/h3>\n
Me!Frame1.Width = 780 ''Pixel!\r\nMe.ScrollWidth = 792<\/pre>\n
GetParent(GetParent(SubWnd.[_GethWnd]))<\/pre>\n
Downloads zu diesem Beitrag<\/h3>\n