<\/p>\n
Wollen Sie Access um Funktionen erweitern, stehen Sie vor der Entscheidung, ob Sie ein Access-Add-In oder ein COM-Add-In bauen. Ersteres ist dem Access-Entwickler natürlich lieber, weil er sich nicht auf ungewohntes Terrain begeben muss. Wir zeigen am Beispiel eines Steuerelement-Rename-Tools, was Sie beim Bau eines Access-Add-Ins beachten müssen.<\/b><\/p>\n
Ein Access-Add-In ist in erster Instanz eine herkömmliche Access-Datenbank, die allerdings einige Besonderheiten aufweist. Als Erstes wäre da die Tatsache zu nennen, dass sie natürlich nicht allein, sondern immer in Zusammenhang mit einer anderen Access-Anwendung geöffnet wird – immerhin soll das Add-In ja bei der Entwicklung einer Anwendung helfen. Dazu müssen Sie einige Voraussetzungen erfüllen: Als Erstes benötigt die Add-In-Datenbank eine öffentliche Funktion in einem Standardmodul, welche zum Aufrufen des Add-Ins beziehungsweise der enthaltenen Funktion nötig ist.<\/p>\n
Dabei gibt es zwei Möglichkeiten:<\/p>\n
Registry<\/b><\/p>\n
Damit ein Add-In beim Bearbeiten einer anderen Anwendung zur Verfügung steht, benötigen Sie ein paar Registry-Einträge. Bei einem Menü-Add-In, das man unter Access 2003 über den Menüeintrag Extras|Add-Ins <\/b>öffnen möchte, liegen diese in der Registry im Pfad HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Office\\12.0\\Access\\Menu Add-Ins<\/b> (12.0 ersetzen Sie dabei durch die jeweilige Office-Version).<\/p>\n
Dort benötigen Sie zunächst einen Schlüssel mit dem Namen des Add-Ins, zum Beispiel ControlRenamer<\/b>. Unterhalb dieses Schlüssels legen Sie dann die folgenden Einträge des Typs Zeichenfolge <\/b>an:<\/p>\n Zur Vereinfachung beim Anlegen eines Add-Ins hat Microsoft sich etwas einfallen lassen: Sie können die benötigten Informationen in einer Tabelle namens USysRegInfo <\/b>unterbringen. Diese sieht wie in Bild 1 aus und hat eine Besonderheit: Tabellen, deren Name mit USys…<\/b> beginnt, zeigt Access standardmäßig nicht an. Dies geschieht erst, wenn Sie die Anzeige ausgeblendeter Objekte aktivieren (unter Accesss 2003 und älter: Access-Optionen, Registerseite Ansicht<\/b>, Eigenschaft Ausgeblendete Objekte<\/b>, unter Access 2007: Rechtsklick auf den Kopf des Navigationsbereichs, Eintrag Navigationsoptionen<\/b>, Option Ausgeblendete Objekte anzeigen<\/b>).<\/p>\n Bild 1: Der Add-In-Manager liest diese Einträge aus und schreibt sie in die Registry.<\/span><\/b><\/p>\n Wenn Sie jetzt noch eine Funktion namens Autostart<\/b> in einem Standardmodul anlegen, die wie folgt aussieht, können Sie das Add-In bereits registrieren:<\/p>\n Dazu schließen Sie die Add-In-Datenbank und benennen sie in .mda <\/b>(Access 2003 und älter) oder .accda <\/b>(Access 2007) um, um den gängigen Konventionen zu entsprechen. Dann öffnen Sie eine beliebige Datenbank unter Access und rufen den Add-In-Manager auf (unter Access 2003 und älter: Extras|Add-Ins|Add-In-Manager<\/b>, unter Access 2007: Ribboneintrag Datenbanktools|Add-Ins|Add-In-Manager<\/b>). Dieser sieht wie in Bild 2 aus und zeigt nach einem Klick auf die Schaltfläche Hinzufügen… <\/b>einen Datei öffnen<\/b>-Dialog an. Wählen Sie hier die soeben erstellte Add-In-Datenbank aus und klicken Sie auf Öffnen<\/b>.<\/p>\n Bild 2: Der Add-In-Manager von Access<\/span><\/b><\/p>\n Der Add-In-Manager zeigt daraufhin einen entsprechenden Eintrag in der Liste der Add-Ins an, wobei dieser im Gegensatz zu den anderen möglicherweise schon vorhandenen Add-Ins nicht durch ein x <\/b>markiert ist. Dies ist jedoch kein Grund zur Sorge: Beim nächsten Öffnen des Add-In-Managers ist auch dieser Eintrag entsprechend markiert.<\/p>\n Außerdem sollte auch das über den Add-Ins-Menüeintrag zu öffnende Menü den Namen des neuen Add-Ins anzeigen. Mit einem Klick auf dieses lösen Sie es aus und zeigen so das in obiger Routine programmierte Meldungsfenster an.<\/p>\n Was ist geschehen<\/b><\/p>\n Der Add-In-Manager hat nun zweierlei Dinge erledigt:<\/p>\n Dadurch ruft Access beim Klick auf den Add-In-Eintrag nun jeweils die angegebene Funktion des neuen Add-Ins auf, das sich im Add-In-Verzeichnis des aktuellen Benutzers befindet.<\/p>\n Achtung, Falle!<\/b><\/p>\n Besonders wichtig ist das oben beschriebene Umkopieren der Add-In-Datenbank in das Add-In-Verzeichnis, wenn Sie nachträglich änderungen am Add-In vornehmen: Dies erledigen Sie dann entweder direkt mit der im Add-In-Verzeichnis gespeicherten Datenbank oder Sie bearbeiten die in einem Entwicklungs-Verzeichnis enthaltene Datenbank und kopieren die jeweils neue Version in das Add-In-Verzeichnis. Dabei leistet eine kleine Batch-Datei namens CopyToAddInsPath.bat <\/b>mit folgendem Inhalt gute Dienste:<\/p>\n Hier müssen Sie noch die Platzhalter <Originalverzeichnis> <\/b>und <Add-In-Verzeichnis> <\/b>ersetzen. Die Option \/Y <\/b>sorgt dafür, dass eine bestehende Datei ohne Rückfrage überschrieben wird, der Befehl Pause <\/b>lässt die Eingabeaufforderung geöffnet, damit Sie sich vom Erfolg der Aktion überzeugen können.<\/p>\n Feinheiten<\/b><\/p>\n Möglicherweise möchten Sie Ihr Add-In richtig rund machen – sodass es beispielsweise im Add-In-Manager einen entsprechenden Text für den Autor und die Beschreibung des Add-Ins anzeigt. Dies ist natürlich hilfreich, gerade wenn man mit mehreren Add-Ins arbeitet und mit einem Blick erfahren möchte, was ein bestimmtes Add-In für eine Aufgabe hat. Um die beiden in Bild 2 zu erkennenden Felder zu füllen, schließen Sie die Add-In-Datenbank und zeigen über das Kontextmenü ihres Eintrags im Windows Explorer ihr Eigenschaftsfenster an. Dort brauchen Sie nur die beiden Eigenschaften Autor <\/b>und Kommentar <\/b>mit den gewünschten Texten zu versehen – fertig!<\/p>\n Add-In entfernen<\/b><\/p>\n Zum Entfernen eines Add-Ins, etwa um es erneut sauber zu installieren, sind zwei Schritte nötig:<\/p>\n Steuerelemente umbenennen<\/p>\n Kommen wir zur Aufgabe unseres Beispiel-Add-Ins: Wenn man ein Formular oder einen Bericht an eine Datenherkunft wie eine Tabelle oder Abfrage bindet und Elemente dieser Datenherkunft aus der Feldliste in den Entwurf zieht, legt Access automatisch Steuerelemente an, die im Wesentlichen zwei Eigenschaften aufweisen: den Namen des Feldes als Name des Steuerelements und gleichzeitig als Steuerelementinhalt. Für den Steuerelementinhalt ist dies okay, den Namen des Steuerelements möchte man aber vielleicht einer Namenskonvention anpassen. Diese könnte beispielsweise für verschiedene Steuerelemente bestimmte Präfixe verlangen:<\/p>\n <\/p>\n Meist verzichten Entwickler darauf, gebundene Steuerelemente so umzubenennen, und behalten die Feldnamen als Steuerelementnamen bei. Unser Add-In soll die gebundenen Steuerelemente eines Formulars automatisch umbenennen.<\/p>\n Wie aber geschieht dies am einfachsten Immerhin sollte der Benutzer noch ein wenig Kontrolle darüber behalten, wie seine Steuerelemente später heißen. Grundsätzlich macht das geplante Add-In natürlich am meisten Sinn, wenn man es direkt nach dem Erstellen der Steuerelemente einsetzt und nicht erst nach dem Hinzufügen von Ereignisprozeduren, die durch die betroffenen Steuerelemente ausgelöst werden oder auf deren Inhalt zugreifen. Für eine möglichst große Kontrolle soll der Benutzer vor dem Umbenennen vorher sehen, für welche Steuerelemente eine Namensänderung Sinn macht, und dann selbst auswählen, ob dies auch für alle angegebenen Steuerelemente geschehen soll. Das Add-In soll dazu die betroffenen Formulare und Berichte sowie ihre Steuerelemente in einem Formular anzeigen.<\/p>\n Das sieht, wenn das Add-In einmal fertig ist, wie in Bild 3 aus. Es zeigt ein Kombinationsfeld zum Auswählen aller vorhandenen Formulare und Berichte an. Beim Einlesen der Objekte werden jedoch nur diejenigen berücksichtigt, die überhaupt noch gebundene Steuerelemente enthalten, deren Name mit dem Feldnamen übereinstimmt.<\/p>\n Bild 3: Das fertige Add-In zum Anpassen von Steuerelementbezeichnungen<\/span><\/b><\/p>\n Das Listenfeld unter dem Kombinationsfeld zeigt alle gebundenen Steuerelemente des ausgewählten Formulars oder Berichts an, deren Name-Eigenschaft mit der Steuerelementinhalt-Eigenschaft übereinstimmt.<\/p>\n Der Benutzer kann mit zwei Schaltflächen alle Einträge markieren oder abwählen und per Mausklick auf die Listenfeldeinträge auch einzelne Elemente herauspicken, die er mit einem Präfix versehen möchte. Klickt er auf die Schaltfläche Steuerelementnamen ändern<\/b>, fragt das Add-In noch kurz nach, ob es die änderungen wirklich vornehmen soll, und führt diese dann aus.<\/p>\n Formularbau<\/b><\/p>\n Das Formular sieht in der Entwurfsansicht wie in Bild 4 aus. Die Datensatzherkunft des Kombinationsfelds cboObjects <\/b>enthält zunächst die Werte einer Tabelle namens tblObjects<\/b>, die des Listenfelds lstControls <\/b>ist zunächst leer, wird aber später aus einer weiteren Tabelle namens tblControls <\/b>gespeist.<\/p>\n Bild 4: Das Add-In-Formular in der Entwurfsansicht<\/span><\/b><\/p>\n Warum Tabellen in der Add-In-Datenbank Nun, wir arbeiten mit Access, und wenn die Möglichkeit besteht, Informationen in Tabellen zu speichern und diese so ganz leicht in Steuerelementen wie etwa Kombinations- oder Listenfeldern anzuzeigen, sollte man das auch ausnutzen.<\/p>\n Wie kommt das Kombinationsfeld cboObjects <\/b>zu seinen Daten Das Add-In füllt die Tabellen tblObjects <\/b>und tblControls <\/b>erstmalig beim Laden des Formulars, und zwar über die Routine ScanDatabase <\/b>aus Listing 1.<\/p>\n Listing 1: Diese Routine durchläuft alle Formular- und Berichtsobjekte und ruft für jedes die Prozedur ScanObject auf.<\/p>\n ScanDatabase <\/b>durchläuft zunächst die Auflistung AllForms <\/b>der Formulare des Objekts CurrentProjects <\/b>und erledigt anschließend das Gleiche für die Berichte. Sie ruft für jedes Objekt einmal die Routine ScanObject <\/b>auf (s. Listing 2). Diese Routine ermittelt zunächst den Namen und den Typ des Objekts und schreibt diese in die Tabelle tblObjects<\/b>, die wie in Bild 5 aussieht.<\/p>\n Listing 2: Diese Routine liest Informationen aus Formularen und Berichten sowie aus deren Steuerelementen ein und schreibt sie in die beiden Tabellen tblObjects und tblControls.<\/p>\n Bild 5: Die beiden Tabellen der Add-In-Datenbank<\/span><\/b><\/p>\n Dann öffnet sie das Objekt mit der dem Objekttyp entsprechenden Anweisung und durchläuft alle enthaltenen Steuerelemente. Dabei untersucht sie nur die Kontrollkästchen, Kombinationsfelder, Listenfelder und Textfelder und prüft, ob der Wert der Eigenschaft Name <\/b>dem Wert der Eigenschaft ControlSource <\/b>entspricht.<\/p>\n Ist das der Fall, legt die Routine einen neuen Eintrag in der Tabelle tblControls <\/b>an (siehe Bild 5).<\/p>\n Nachdem die Routine ScanObject <\/b>für alle Formulare und Berichte je einmal aufgerufen wurde, untersucht die Prozedur ScanDatabase <\/b>aus Listing 1 noch, ob die Tabelle tblObjects <\/b>Einträge aufweist, für die die Tabelle tblControls <\/b>keine Steuerelemente enthält. Die beiden Routinen zum Füllen der beiden Tabellen tblObjects <\/b>und tblControls <\/b>werden erstmalig beim Öffnen des Formulars ausgelöst. Im gleichen Zuge sorgt die Routine InitializeForm<\/b> (s. Listing 3) dafür, dass das Kombinationsfeld cboObjects <\/b>aktualisiert wird und nunmehr alle in der Tabelle tblObjects <\/b>enthaltenen Datensätze anzeigt.<\/p>\n Listing 3: InitializeForm füllt mit ScanDatabases die Tabellen des Add-Ins und aktualisiert dann deren Steuerelemente.<\/p>\n InitializeForm <\/b>ruft weiterhin die Routine FillControls <\/b>auf, die dem Listenfeld lstControls <\/b>einen neuen SQL-Ausdruck als Datensatzherkunft zuweist (s. Listing 4). Dieser besteht aus allen Datensätzen der Tabelle tblControls<\/b>, deren ObjectID <\/b>mit dem im Kombinationsfeld angezeigten Datensatz der Tabelle tblObjects <\/b>übereinstimmt.<\/p>\n Listing 4: Die Routine FillControls aktualisiert die Datensatzherkunft des Listenfelds lstControls in Abhängigkeit vom Kombinationsfeld cboObjects.<\/p>\n Der Benutzer braucht nun nur noch die gewünschten Steuerelemente zu markieren und auf die Schaltfläche cmdChangeNames <\/b>zu klicken:<\/p>\n Dies löst die entsprechende Ereignisprozedur aus, die über die Routine ChangeNames<\/b> zunächst das entsprechende Formular oder den Bericht öffnet und dann über die Auflistung der Steuerelemente die Bezeichnungen der betroffenen Steuerelemente um das jeweilige Präfix ergänzt (Routine ChangeName<\/b>, alle Listing 5).<\/p>\n Listing 5: Diese Routinen sind für das ändern der Steuerelementnamen verantwortlich und ergänzen diese jeweils um das entsprechende Präfix.<\/p>\n Zugriff auf Host- und Add-In-Datenbank: CurrentDB vs. CodeDB, Currentproject vs. Codeproject und die Domänenfunktionen<\/b><\/p>\n Die Routine aus Listing 1 liefert ein gutes Beispiel dafür, dass man es bei der Arbeit mit Access-Add-Ins gleich mit zwei Datenbanken zu tun hat: mit der Host-Anwendung, also der Access-Datenbank, von der aus man das Add-In aufruft, und mit der Add-In-Datenbank selbst.<\/p>\n Es kann passieren, dass ein Add-In auf die Tabellen der Host-Datenbank sowie auch auf die eigenen Tabellen zugreift, und genauso kann es vorkommen, dass das Add-In Objekte wie Formulare und Berichte aus Host- und Add-In-Datenbank referenzieren muss.<\/p>\n Der Zugriff auf die in Tabellen gespeicherten Daten geschieht per VBA normalerweise über das Database<\/b>-Objekt, das man beim alltäglichen Umgang mit Access-Datenbanken über die Funktion CurrentDB <\/b>bezieht. Darüber kommt man aber nicht an die Daten in der Add-In-Datenbank heran. Um das Database<\/b>-Objekt der Add-In-Datenbank zu verwenden, braucht man die Funktion CodeDB<\/b>, wie auch in der Routine ScanDatabase <\/b>aus Listing 1 geschehen.<\/p>\n Das Gleiche gilt für den Zugriff auf die Objekte: Wer etwa alle Formulare über die AllForms<\/b>-Auflistung durchlaufen möchte, bezieht sich dabei üblicherweise auf CurrentProject<\/b>. Auch hierfür gibt es ein Add-In-Pendant, nämlich CodeProject<\/b>.<\/p>\n Und worauf greifen eigentlich die Domänenfunktionen wie DLookup<\/b>, DCount <\/b>oder DMax <\/b>zu Diese beziehen sich immer auf die Host-Datenbank. Wenn Sie solche Funktionen mit den Daten in der Add-In-Datenbank verwenden, müssen Sie selbst Hand anlegen: Bauen Sie sich eigene Domänenfunktionen wie im Beitrag Schnelle Domänenfunktionen <\/b>(Shortlink 644, Ausgabe 1\/2009) beschrieben, und beziehen Sie sich darin auf CodeDB<\/b> statt auf CurrentDB<\/b>. Solche Funktionen könnte man dann CLookup <\/b>oder CCount <\/b>nennen (wobei C <\/b>für CodeDB <\/b>steht). Im Übrigen sollten Sie sowieso eher mit den schnellen Ersatzfunktionen für die eingebauten Domänenfunktionen arbeiten …<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Dieses Add-In steht in Versionen für Access 2007 sowie für Access 2000 bis 2003 zur Verfügung. Sie sollten es unmittelbar nach dem Hinzufügen gebundener Steuerelemente zu einem Formular oder Bericht verwenden, um deren Steuerelementnamen um ein Präfix zu erweitern. Wenn ein gebundenes Steuerelement einen anderen Namen als das dadurch repräsentierte Feld hat, sind Sie auf jeden Fall auf der richtigen Seite, wenn Sie entweder auf das Steuerelement oder auf das darin angezeigte Feld zugreifen möchten. Wenn Sie andere Ideen für nützliche Add-Ins haben, können Sie dieses hier als Vorlage verwenden: Füllen Sie es einfach mit der benötigten Benutzeroberfläche und legen Sie die passenden Funktionen an. Hilfreich ist dabei sicher ein Blick in unseren Kasten Zugriff auf Host- und Add-In-Datenbank …<\/b>, der einige Besonderheiten beim Zugriff auf die Daten und Objekte der beim Einsatz eines Add-Ins beteiligten Datenbanken aufzeigt.<\/p>\n<\/p>\n Enthaltene Beispieldateien:<\/p>\n ControlRenamer.mda<\/p>\n\n
![\"pic001.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Add-Ins-web-images\/pic001_opt.jpeg\")
<\/p>\nPublic Function Autostart()\r\n MsgBox "ControlRenamer"\r\nEnd Function<\/pre>\n
![\"pic002.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Add-Ins-web-images\/pic002_opt.jpeg\")
<\/p>\n\n
Copy "<Originalverzeichnis>\\ControlRename.accda" "<Add-In-Verzeichnis>" \/Y\r\nPause<\/pre>\n
\n
\n
![\"pic003.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Add-Ins-web-images\/pic003_opt.jpeg\")
<\/p>\n![\"pic004.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Add-Ins-web-images\/pic004_opt.jpeg\")
<\/p>\nPrivate Sub ScanDatabase()\r\n Dim dbAddin As DAO.Database\r\n Dim obj As AccessObject\r\n Set dbAddin = CodeDb\r\n dbAddin.Execute "DELETE FROM tblObjects", dbFailOnError\r\n For Each obj In CurrentProject.AllForms\r\n ScanObject obj, dbAddin\r\n Next obj\r\n For Each obj In CurrentProject.AllReports\r\n ScanObject obj, dbAddin\r\n Next obj\r\n dbAddin.Execute "DELETE FROM tblObjects WHERE ID NOT IN " _\r\n & "(SELECT DISTINCT ObjectID FROM tblControls)", dbFailOnError\r\nEnd Sub<\/pre>\n
Private Sub ScanObject(obj As AccessObject, dbAddin As DAO.Database)\r\n '' ... Deklarationen ...\r\n If Not obj.Name = Me.Name Then\r\n strObjectname = obj.Name\r\n lngObjecttype = obj.Type\r\n dbAddin.Execute "INSERT INTO tblObjects(Objectname, Objecttype) VALUES(''" _\r\n & strObjectname & "'', " & lngObjecttype & ")", dbFailOnError\r\n lngObjectID = dbAddin.OpenRecordset("SELECT @@IDENTITY").Fields(0)\r\n If lngObjecttype = 2 Then ''Form\r\n DoCmd.OpenForm strObjectname, view:=acDesign, WindowMode:=acHidden\r\n Set objFormReport = Forms(strObjectname)\r\n Else ''Report\r\n DoCmd.OpenReport strObjectname, view:=acViewDesign, WindowMode:=acHidden\r\n Set objFormReport = Reports(strObjectname)\r\n End If\r\n For Each ctl In objFormReport.Controls\r\n Select Case ctl.ControlType\r\n Case acCheckBox, acComboBox, acListBox, acTextBox\r\n strControlname = ctl.Name\r\n lngControltype = ctl.ControlType\r\n strControlsource = ctl.ControlSource\r\n If strControlname = strControlsource Then\r\n Select Case ctl.ControlType\r\n Case acCheckBox: strPrefix = "chk"\r\n Case acComboBox: strPrefix = "cbo"\r\n Case acListBox: strPrefix = "lst"\r\n Case acTextBox: strPrefix = "txt"\r\n End Select\r\n dbAddin.Execute "INSERT INTO tblControls(Controlname, Controltype, ControlSource, " _\r\n & "Prefix, ObjectID) VALUES(''" & strControlname & "'', " & lngControltype & ", ''" _\r\n & strControlsource & "'', ''" & strPrefix & "'', " & lngObjectID & ")", dbFailOnError\r\n End If\r\n End Select\r\n Next ctl\r\n If lngObjecttype = 2 Then\r\n DoCmd.Close acForm, strObjectname\r\n Else\r\n DoCmd.Close acReport, strObjectname\r\n End If\r\n End If\r\nEnd Sub<\/pre>\n![\"pic005.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Add-Ins-web-images\/pic005_opt.jpeg\")
<\/p>\nPrivate Sub InitializeForm()\r\n ScanDatabase\r\n Me!cboObjects.Requery\r\n Me!cboObjects = Me!cboObjects.ItemData(0)\r\n FillControls\r\nEnd Sub<\/pre>\n
Private Sub FillControls()\r\n Dim strSQL As String\r\n strSQL = "SELECT ID, Controlname AS [Aktuelle Bezeichnung], " _\r\n & "Prefix & Controlname AS [Neue Bezeichnung] " _\r\n & "FROM tblControls WHERE ObjectID = " & Me!cboObjects\r\n Me!lstControls.RowSource = strSQL\r\nEnd Sub<\/pre>\n
Private Sub cmdChangeNames_Click()\r\n If MsgBox("Achtung: Dies ändert die Namen der links markierten gebundenen Steuerelemente." _\r\n & vbCrLf & "Eventuelle änderungen am Quellcode müssen Sie selbst durchführen." _\r\n & vbCrLf & "Fortfahren", _\r\n vbYesNo + vbCritical, "änderung von Steuerelementnamen") = vbYes Then\r\n ChangeNames\r\n End If\r\nEnd Sub\r\nPrivate Sub ChangeNames()\r\n '' ... Deklaration ...\r\n Set dbAddin = CodeDb\r\n lngObjectID = Me!cboObjects\r\n lngObjecttype = dbAddin.OpenRecordset("SELECT Objecttype FROM tblObjects WHERE ID = " _\r\n & lngObjectID).Fields(0)\r\n strObjectname = dbAddin.OpenRecordset("SELECT Objectname FROM tblObjects WHERE ID = " _\r\n & lngObjectID).Fields(0)\r\n Select Case lngObjecttype\r\n Case 2 ''Formular\r\n DoCmd.OpenForm strObjectname, view:=acDesign, WindowMode:=acHidden\r\n Set obj = Forms(strObjectname)\r\n For Each var In Me!lstControls.ItemsSelected\r\n ChangeName obj, Me!lstControls.ItemData(var)\r\n Next var\r\n DoCmd.Close acForm, strObjectname, acSaveYes\r\n Case Else\r\n DoCmd.OpenReport strObjectname, view:=acViewDesign, WindowMode:=acHidden\r\n Set obj = Reports(strObjectname)\r\n For Each var In Me!lstControls.ItemsSelected\r\n ChangeName obj, Me!lstControls.ItemData(var)\r\n Next var\r\n DoCmd.Close acReport, strObjectname, acSaveYes\r\n End Select\r\n InitializeForm\r\nEnd Sub\r\nPrivate Sub ChangeName(obj As Object, lngControlID As Long)\r\n Dim strControlname As String\r\n Dim dbAddin As DAO.Database\r\n Dim strPrefix As String\r\n Set dbAddin = CodeDb\r\n strControlname = dbAddin.OpenRecordset("SELECT Controlname FROM tblControls WHERE ID = " _\r\n & lngControlID).Fields(0)\r\n strPrefix = dbAddin.OpenRecordset("SELECT Prefix FROM tblControls WHERE ID = " _\r\n & lngControlID).Fields(0)\r\n obj.Controls(strControlname).Name = strPrefix & strControlname\r\nEnd Sub<\/pre>\nDownloads zu diesem Beitrag<\/h2>\n