<\/p>\n
![\"Zu](\"..\/fileadmin\/_temp_\/2021_01\/pic_1282_001.png\")
<\/p>\n
Bild 1: Zu benennende Steuerelemente<\/span><\/b><\/p>\n Als ich neulich mal wieder einige Steuerelemente zu einem Formular hinzugefügt habe, die durchnummerierte Namen erhalten sollten wie txt01, txt02 und so weiter, kam die Eingebung: Warum diese langweilige Arbeit immer wieder von Hand erledigen, statt einfach ein Tool dafür zu entwickeln Gesagt, getan: Es sollte ein kleines Add-In her, mit dem sich diese erste kleine Aufgabe vereinfachen ließ. Wie Sie vermutlich auch, programmiere ich nämlich lieber als dass ich immer wiederkehrende Aufgaben durchführe. Das Durchnummerieren von markierten Steuerelementen nach bestimmten Vorgaben soll die erste Funktion dieses Add-Ins sein. Ihnen und mir fallen sicher noch noch weitere Ideen für den Einsatz dieses Add-Ins ein!<\/b><\/p>\n Der Auslöser für die Programmierung des in diesem Beitrag beschriebenen Add-Ins ist das unscheinbare Formular aus Bild 1.<\/p>\n Bild 1: Zu benennende Steuerelemente<\/span><\/b><\/p>\n Die drei Kombinationsfelder sollen die Namen cboSucheNach1<\/b>, cboSucheNach2 <\/b>und cboSucheNach3 <\/b>erhalten und die Textfelder rechts daneben die Namen txtSucheNach1<\/b>, txtSucheNach2 <\/b>und txtSucheNach3<\/b>.<\/p>\n Darauf, das von Hand zu erledigen, hatte ich keine Lust. Also habe ich zuerst eine kleine Prozedur geschrieben, die wie in Listing 1 aussieht.<\/p>\n Listing 1: Prozedur zum Benennen von Steuerelementen<\/span><\/b><\/p>\n Sie erwartet die folgenden Parameter, um die Benennung der Steuerelemente so flexibel wie möglich zu machen:<\/p>\n Ein Aufruf dieser Prozedur sieht beispielsweise wie folgt aus:<\/p>\n Hier wird immer der Basisname cboSucheNach[] <\/b>verwendet, bei dem die Zeichenfolge [] <\/b>durch die aktuelle Zahl ersetzt wird – in diesem Fall mit einer Stelle, also ohne führende 0 <\/b>bei den ersten Einträgen.<\/p>\n Die Prozedur trägt zuerst den Wert der Startzahl aus dem Parameter intStart <\/b>in die Variable intNummer <\/b>ein. Dann referenziert sie das aktuell geöffnete Formular mit Screen.ActiveForm<\/b>. Diese erste Fassung enthält noch keine Prüfung, ob beispielsweise überhaupt ein Formular geöffnet ist oder ob der Benutzer Steuerelemente zum Umbenennen markiert hat.<\/p>\n Dann verwendet die Prozedur den Wert aus dem Parameter intStellen<\/b>, um in strStellen <\/b>eine Zeichenkette mit so vielen Nullen zu füllen, wie es in intStellen <\/b>angegeben ist. Damit starten wir in eine For Each<\/b>-Schleife über alle Steuerelemente des mit frm<\/b> referenzierten Formulars.<\/p>\n In der Schleife prüfen wir zuerst in einer If…Then<\/b>-Bedingung, ob das aktuell durchlaufene Steuerelement markiert ist. Dazu nutzen wir die Eigenschaft InSelection<\/b>. In der If…Then<\/b>-Bedingung stellen wir die Eigenschaft Name <\/b>des mit ctl <\/b>referenzierten aktuellen Steuerelements auf die gewünschte Bezeichnung ein.<\/p>\n Diese ermitteln wir, indem wir den Platzhalter strPlatzhalter <\/b>in strBezeichnung <\/b>mit Replace <\/b>ersetzen, und zwar durch den Wert aus der Variablen intNummer <\/b>mit dem Format aus strStellen<\/b>.<\/p>\n Damit haben wir den größten Teil bereits erledigt. Bevor wir ein Add-In auf Basis dieser Prozedur anlegen, wollen wir jedoch noch zwei Prüfungen einbauen. Die Erste soll untersuchen, ob überhaupt ein Formular in der Entwurfsansicht geöffnet ist. Dazu deklarieren wir eine Variable namens bolEntwurfsansicht<\/b>:<\/p>\n Die Abfrage von Screen.ActiveForm fassen wir in On Error Resume Next<\/b>\/On Error Goto 0 <\/b>ein, um die Fehlerbehandlung für diese eine Anweisung zu deaktivieren. Der Grund ist, dass der Aufruf ohne geöffnetes Formular einen Fehler auslöst, den wir vermeiden wollen. Dann prüft die Prozedur, ob frm <\/b>leer ist, was der Fall ist, wenn kein Formular geöffnet ist. Ist frm <\/b>nicht leer, prüfen wir mit der Eigenschaft CurrentView<\/b>, ob die aktuelle Ansicht die Entwurfsansicht ist. Falls ja, stellen wir die Variable bolEntwurfsansicht <\/b>auf True <\/b>ein:<\/p>\n Hat bolEntwurfsansicht <\/b>danach noch den Wert False<\/b>, ist das aktive Element entweder kein Formular oder dieses ist nicht in der Entwurfsansicht geöffnet. In diesem Fall gibt die Prozedur eine entsprechende Meldung aus und wird abgebrochen:<\/p>\n <\/p>\n Außerdem kann es sein, dass wir die gleichen Steuerelemente zu Testzwecken mehrere Male umbenennen oder dass diese aus anderen Gründen zuvor bereits solche Namen erhalten haben, wie Sie diese mit der Prozedur zuweisen wollen. Dabei kann es vorkommen, dass Sie einem Steuerelement einen Namen geben wollen, der bereits vergeben ist. Dies würde einen Fehler auslösen.<\/p>\n Um dies zu verhindern, durchlaufen wir eine ähnliche For Each<\/b>-Schleife wie diejenige, welche die gewünschten Namen zuweist, bereits vorher und vergeben Namen wie xyz1<\/b>, xyz2 <\/b>und so weiter für die Steuerelemente, bevor diese ihre endgültigen Namen erhalten. Danach müssen wir intNummer <\/b>erneut mit intStart <\/b>initialisieren:<\/p>\n Es kann sein, dass die Aktivierreihenfolge der zu benennenden Steuerelemente nicht der Reihenfolge entspricht, in der die Steuerelemente neben- oder untereinander angeordnet sind.<\/p>\n Die For Each<\/b>-Schleife über alle Control<\/b>-Elemente des Formulars durchläuft diese jedoch in der Reihenfolge, die der Aktivierreihenfolge entspricht.<\/p>\n Die Aktivierreihenfolge können Sie jedoch zuvor über den Dialog Reihenfolge <\/b>einstellen, wenn die Aktivierreihenfolge nicht stimmt (siehe Bild 2). Diesen Dialog öffnen Sie über den Ribbon-Befehl Entwurf|Tools|Eigenschaften<\/b>.<\/p>\n Bild 2: Aktivierreihenfolge der Steuerelemente<\/span><\/b><\/p>\n Damit der Benutzer die Parameter bequem eingeben kann, wenn er das Add-In aufgerufen hat, stellen wir ihm ein passendes Formular zur Verfügung. Dieses soll die zuletzt verwendeten Werte außerdem speichern. Dazu erstellen wir zuerst eine Tabelle namens tblOptionen<\/b>. Diese enthält die Felder aus Bild 3.<\/p>\n Bild 3: Entwurf der Tabelle zum Speichern der Add-In-Optionen<\/span><\/b><\/p>\n Das Formular zur Eingabe dieser Optionen benennen wir frmSteuerelementeNummerieren<\/b>. Nach dem Anlegen stellen wir seine Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen<\/b>, Trennlinien <\/b>und Bildlaufleisten <\/b>auf Nein <\/b>und Automatisch zentrieren <\/b>auf Ja <\/b>ein.<\/p>\n Außerdem legen wir als Datensatzquelle die Tabelle tblOptionen <\/b>fest und stellen die Eigenschaft Zyklus <\/b>auf Aktueller Datensatz <\/b>ein. So kann der Benutzer nicht versehentlich einen zweiten Satz Optionen hinzufügen. Schließlich ziehen wir die vier Felder der Tabelle aus der Feldliste in den Detailbereich des Formularentwurfs. Außerdem fügen wir eine Schaltfläche namens cmdSteuerelementeBenennen<\/b> hinzu. Das Ergebnis finden Sie in Bild 4.<\/p>\n Bild 4: Formular zum Eingeben der Parameter<\/span><\/b><\/p>\n Die Prozedur, die durch die Schaltfläche cmdSteuerelementeBenennen<\/b> ausgelöst wird, braucht nun prinzipiell nur noch die Prozedur SteuerelementeBenennen <\/b>aufzurufen und dieser die Parameter aus den Textfeldern zu übergeben. Dazu definieren wir die folgende Prozedur:<\/p>\n Nun öffnen wir das Zielformular in der Entwurfsansicht und markieren die umzubenennenden Felder. Wenn wir dann das Formular frmSteuerelementeNummerieren <\/b>öffnen, die Parameter einstellen und auf die Schaltfläche cmdSteuerelementeBenennen<\/b> klicken, erhalten wir die Meldung aus Bild 5.<\/p>\n Bild 5: Das Zielformular wird nicht gefunden.<\/span><\/b><\/p>\n Das ist auch kein Wunder, denn zum Zeitpunkt des Aufrufs der Prozedur SteuerelementeBenennen <\/b>wird das Formular frmSteuerelementeNummerieren <\/b>mit Screen.ActiveForm <\/b>referenziert und nicht frmMetadatenDurchsuchen<\/b>.<\/p>\n Also müssen wir uns überlegen, wie wir das tatsächlich zu bearbeitende Formular ermitteln. Mit Screen.ActiveForm <\/b>kommen wir zu diesem Zeitpunkt jedenfalls nicht mehr an das im Entwurf angezeigte Formular heran.<\/p>\n Sagte ich „zu diesem Zeitpunkt“ Es muss ja gar nicht dieser Zeitpunkt sein. Wir können ja auch beim Öffnen des Formulars frmSteuerelementeNummerieren <\/b>schon prüfen, welches Formular zu diesem Zeitpunkt das aktive Formular ist.<\/p>\n Dazu fügen wir dem Klassenmodul des Formulars frmSteuerelementeNummerieren <\/b>die folgende Variable hinzu:<\/p>\n Diese füllen wir gleich beim Öffnen des Formulars in der Prozedur, die durch das Ereignis Beim Öffnen <\/b>ausgelöst wird. Hierhin ziehen wir auch gleich die Prüfung vor, ob es sich bei dem Formular um ein Formular in der Entwurfsansicht handelt.<\/p>\n Diese Prozedur namens Form_Open <\/b>ermittelt wieder bei deaktivierter Fehlerbehandlung einen Verweis auf das aktuelle Formular (siehe Listing 2). Da das Formular frmSteuerelemente-Nummerieren <\/b>zu diesem Zeitpunkt noch nicht angezeigt wird, ermittelt Screen.ActiveForm <\/b>das korrekte Formular und referenziert es mit frm<\/b>.<\/p>\n Listing 2: Prozedur, die beim Öffnen des Add-In-Formulars ausgelöst wird<\/span><\/b><\/p>\n Dann prüft die Prozedur, ob sich das Formular in der richtigen Ansicht befindet und zeigt eine Meldung an, falls kein Formular in der Entwurfsansicht das aktuelle Formular ist. Hier kommt eine Änderung gegenüber der Variante, die wir aus der Prozedur Steuerelemente <\/b>übernommen haben: Mit dem Einstellen des Parameters Cancel <\/b>auf den Wert True <\/b>wird das Öffnen des Formular in diesem Fall abgebrochen. Anderenfalls schreibt die Prozedur den Namen des zu untersuchenden Formulars in die Variable strForm<\/b>.<\/p>\n Nachdem der Benutzer die Parameter in das Formular frmSteuerelementeNummerieren <\/b>eingegeben hat, ruft er mit einem Klick auf die Schaltfläche cmdSteuerelementeBenennen <\/b>die neue Version der folgenden Prozedur auf. Diese übergibt nun als ersten Parameter der Prozedur SteuerelementeBenennen <\/b>den Namen des anzupassenden Formulars:<\/p>\n Wie wir die Prozedur SteuerelementeBenennen <\/b>angepasst haben, können Sie dem Modul mdlAddIn <\/b>der Beispieldatenbank entnehmen.<\/p>\n Um die Datenbank mit den bisher hinzugefügten Elementen in ein Add-In umzuwandeln, sind noch einige Schritte erforderlich.<\/p>\n Der Erste ist das Umbenennen auf die Dateiendung .accda<\/b>.<\/p>\n Der Zweite ist das Hinzufügen einer Funktion, die den gleichen Namen trägt wie in der Tabelle USysRegInfo <\/b>für den ersten Datensatz angegeben, hier Autostart<\/b>. Diese wird beim Start des Add-Ins aufgerufen. Sie soll das Formular frmSteuerelementeNummerieren <\/b>öffnen. Dabei können Fehler auftauchen.<\/p>\n Einer davon ist der Fehler mit der Nummer 2501<\/b>, der bei Abbrechen des Öffnens eines mit DoCmd.OpenForm <\/b>geöffneten Formulars ausgelöst wird. Diesen wollen wir ignorieren, damit der Benutzer nicht irritiert wird, und zeigen nur Fehlermeldungen für Fehler mit anderen Fehlermeldungen als 2501 <\/b>an:<\/p>\n Danach fügen wir die Tabelle USysRegInfo<\/b> wie in Bild 6 hinzu. Diese Tabelle enthält die Informationen, anhand derer das Add-In in die Registry eingetragen wird. Die dortigen Informationen werden hingegen von Access beim Start ausgelesen und in einen Eintrag in das Add-In-Menü im Ribbon umgewandelt.<\/p>\n Bild 6: Hinzufügen der Tabelle USysRegInfo<\/span><\/b><\/p>\n Damit im Add-In-Manager aussagekräftige Informationen für dieses Add-In erscheinen, füllen Sie die Datenbankeigenschaften der Add-In-Datenbank wie in Bild 7.<\/p>\n Bild 7: Datenbank-Einstellungen, die im Add-In-Manager angezeigt werden<\/span><\/b><\/p>\n Nach der Durchführung dieser Schritte schließen Sie die Add-In-Datenbank.<\/p>\n Öffnen Sie nun eine weitere Datenbank und wählen Sie im Ribbon den Eintrag Datenbanktools|Add-Ins|Add-In-Manager <\/b>aus. Im nun erscheinenden Dialog Add-In-Manager <\/b>klicken Sie auf Neues hinzufügen… <\/b>und wählen die .accda<\/b>-Datenbank aus. Danach erscheint das Add-In wie in Bild 8 in der Liste der Add-Ins.<\/p>\n Bild 8: Das neue Add-In im Add-In-Manager<\/span><\/b><\/p>\n Anschließend können Sie das Add-In aus der Liste der Add-Ins im Ribbon auswählen und verwenden.<\/p>\n Ziel des Add-Ins ist es, das Benennen von Steuerelementen nach einem Schema wie txt01<\/b>, txt02<\/b>, txt03 <\/b>et cetera zu vereinfachen und diese Arbeit nicht mehr von Hand ausführen zu müssen. Wenn Sie vor einer solchen Aufgabe stehen, führen Sie folgende Schritte aus:<\/p>\n<\/p>\nPublic Sub <\/span>SteuerelementeBenennen(strBezeichnung As String<\/span>, strPlatzhalter As String<\/span>, intStellen As Integer<\/span>, _\r\n Optional<\/span> intStart As Integer<\/span> = 1)\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>intNummer As Integer<\/span>\r\n Dim <\/span>strStellen As String<\/span>\r\n intNummer = intStart\r\n Set<\/span> frm = Screen.ActiveForm\r\n strStellen = String(intStellen, \"0\")\r\n For Each ctl In frm.Controls\r\n If <\/span>ctl.InSelection Then<\/span>\r\n ctl.Name = Replace<\/span>(strBezeichnung, strPlatzhalter, Format(intNummer, strStellen))\r\n intNummer = intNummer + 1\r\n End If<\/span>\r\n Next<\/span> ctl\r\nEnd Sub<\/span><\/pre>\n\n
SteuerelementeBenennen \"cboSucheNach[]\", \"[]\", 1, 1<\/pre>\n
Prüfungen<\/h2>\n
Dim <\/span>bolEntwurfsansicht As Boolean<\/span><\/pre>\n...\r\nOn Error Resume Next<\/span>\r\nSet<\/span> frm = Screen.ActiveForm\r\nOn Error Goto 0\r\nIf <\/span>Not<\/span> frm Is Nothing Then<\/span>\r\n If <\/span>frm.CurrentView = acCurViewDesign Then<\/span>\r\n bolEntwurfsansicht = True<\/span>\r\n End If<\/span>\r\nEnd If<\/span><\/pre>\nIf <\/span>bolEntwurfsansicht = False<\/span> Then<\/span>\r\n MsgBox<\/span> \"Es ist kein Formular in der Entwurfsansicht geöffnet.\", vbOKOnly + vbExclamation, \"Kein Formular geöffnet\"\r\n Exit Sub<\/span>\r\nEnd If<\/span><\/pre>\nFor Each ctl In frm.Controls\r\n If <\/span>ctl.InSelection Then<\/span>\r\n ctl.Name = \"xyz\" & intNummer\r\n intNummer = intNummer + 1\r\n End If<\/span>\r\nNext<\/span> ctl\r\nintNummer = intStart<\/pre>\nUngünstige Aktivierreihenfolge<\/h2>\n
![\"Aktivierreihenfolge](\"..\/fileadmin\/_temp_\/2021_01\/pic_1282_002.png\")
<\/p>\nParameter per Formular eingeben<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2021_01\/pic_1282_003.png\")
<\/p>\n![\"Formular](\"..\/fileadmin\/_temp_\/2021_01\/pic_1282_004.png\")
<\/p>\nPrivate Sub <\/span>cmdSteuerelementeBenennen_Click()\r\n SteuerelementeBenennen Me!Bezeichnung, _\r\n Me!Platzhalter, Me!Stellen, Me!Start\r\nEnd Sub<\/span><\/pre>\n![\"Das](\"..\/fileadmin\/_temp_\/2021_01\/pic_1282_005.png\")
<\/p>\nDim <\/span>strForm As String<\/span><\/pre>\nPrivate Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>bolEntwurfsansicht As Boolean<\/span>\r\n On Error Resume Next<\/span>\r\n Set<\/span> frm = Screen.ActiveForm\r\n On Error GoTo<\/span> 0\r\n If <\/span>Not<\/span> frm Is Nothing Then<\/span>\r\n If <\/span>frm.CurrentView = acCurViewDesign Then<\/span>\r\n bolEntwurfsansicht = True<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n If <\/span>bolEntwurfsansicht = False<\/span> Then<\/span>\r\n MsgBox<\/span> \"Es ist kein Formular in der Entwurfsansicht geöffnet.\", vbOKOnly + vbExclamation, \"Kein Formular geöffnet\"\r\n Cancel = True<\/span>\r\n Else<\/span>\r\n strForm = frm.Name\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdSteuerelementeBenennen_Click()\r\n SteuerelementeBenennen strForm, Me!Bezeichnung, _\r\n Me!Platzhalter, Me!Stellen, Me!Start\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/span><\/pre>\nAdd-In erstellen<\/h2>\n
Public Function <\/span>Autostart()\r\n On Error Resume Next<\/span>\r\n DoCmd.OpenForm \"frmSteuerelementeNummerieren\", WindowMode:=acDialog\r\n Select Case Err.Number\r\n Case <\/span>2501\r\n Case Else<\/span>\r\n Err.Raise Err.Number, , Err.Description\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2021_01\/pic_1282_007.png\")
<\/p>\n![\"Datenbank-Einstellungen,](\"..\/fileadmin\/_temp_\/2021_01\/pic_1282_006.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2021_01\/pic_1282_008.png\")
<\/p>\nFunktion im Überblick<\/h2>\n