Wenn Sie eine Datenbank an die Benutzer weitergeben, verwenden Sie je nach Zielgruppe eine .accde-Datenbank, also eine Datenbank, in welcher der Entwurf von Tabellen, Abfragen, Formularen, Berichten und VBA nicht mehr möglich ist. Damit schützen wir auch den wertvollen VBA-Code vor den Blicken anderer Menschen. Es bringt aber auch mit sich, dass Änderungen an Eigenschaften wie Spaltenbreiten, Spaltenreihenfolge oder die Sichtbarkeit der Spalten nicht gespeichert werden können, da es sich dabei um Änderungen am Design des Formulars in der Datenblattansicht handelt. Gerade wenn Benutzer die Datenblätter nach ihren eigenen Vorlieben umgestalten und dies bei jedem Öffnen eines Formular erneut erledigen müssen, macht sich schnell Frustration breit. Daher zeigen wir in diesem Beitrag, wie Sie eine Funktion zum Speichern und Wiederherstellen der Spalteneigenschaften von Formularen in der Datenblattansicht programmieren können.<\/b><\/p>\n
Datenblattansichten gibt es in den meisten Datenbanken – wie hier zum Beispiel zur Anzeige der Daten einer Mitarbeitertabelle (siehe Bild 1).<\/p>\n
![\"Beispiel](\"..\/fileadmin\/_temp_\/2025_03\/pic_1547_001.png\")
<\/p>\n
Bild 1: Beispiel für eine Datenblattansicht<\/span><\/b><\/p>\n Sie bieten viele Vorteile, wenn wir die Daten einer Tabelle oder Abfrage als Liste anzeigen wollen.<\/p>\n Dazu gehört die Möglichkeit, die Spaltenbreiten anzupassen, die Spalten nach unseren Wünschen zu arrangieren und Spalten ein- oder auszublenden.<\/p>\n Wir können also folgende Änderungen an der Datenblattansicht durchführen:<\/p>\n Bild 2: Ausblenden einer Spalte<\/span><\/b><\/p>\n Bild 3: Erneutes Einblenden von Spalten<\/span><\/b><\/p>\n Wenn wir in der .accdb<\/b>-Version der Datenbank arbeiten und eine oder mehrere dieser Änderungen vorgenommen haben, können wir das Formular schließen und wieder öffnen und finden alle Einstellungen vor, wie sie zuletzt eingestellt waren. Wenn wir eine solche Änderung vornehmen, stellen wir sogar fest, dass diese Änderungen noch nicht einmal die Rückfrage auslöst, ob Änderungen an diesem Formular gespeichert werden sollen. Selbst nach dem Schließen und erneutem Öffnen der Datenbank finden wir die letzten Einstellungen erneut vor.<\/p>\n Nun wollen wir die Datenbank als .accde<\/b>-Datenbank speichern und somit in einem Format, das keine Änderungen mehr an dem Entwurf der Objekte zulassen sollte.<\/p>\n Dazu klicken wir in Access auf den Reiter Datei <\/b>und dann auf Speichern unter<\/b>. Damit blenden wir den Bereich Speichern unter <\/b>ein, wo wir im rechten Bereich den Befehl ACCDE erstellen <\/b>vorfinden (siehe Bild 4).<\/p>\n Bild 4: Speichern der Datenbank als .accde-Datenbank<\/span><\/b><\/p>\n Klicken wir diesen doppelt an, erscheint ein Dialog, mit dem wir den Namen für die zu erstellende Datei angeben können. Access schlägt hierzu den gleichen Dateinamen vor, allerdings mit der Dateiendung .accde<\/b>. Diesen Dateinamen behalten wir bei und speichern die neue Datei.<\/p>\n Nun öffnen wir die Datenbank in der .accde<\/b>-Version. Das Formular frmMitarbeiterUebersicht <\/b>erscheint genauso wie in der .accdb<\/b>-Version. Dass es sich überhaupt um die .accde<\/b>-Version handelt, können wir leicht feststellen, indem wir versuchen, die Entwurfsansicht des Formulars anzuzeigen. Dies gelingt nicht, weil die entsprechende Schaltfläche im Formular gar nicht verfügbar ist (siehe Bild 5).<\/p>\n Bild 5: In der .accde-Version kann die Entwurfsansicht nicht mehr geöffnet werden.<\/span><\/b><\/p>\n Nun nehmen wir einige Änderungen vor – wir ändern die Reihenfolge der Spalten, passen ihre Breite an, blenden eine Spalte aus und fixieren eine am linken Rand.<\/p>\n Das gelingt alles ohne Probleme. Wenn wir das Formular jedoch schließen und erneut öffnen, finden wir genau die gleiche Ansicht vor, wie wir sie in der Originaldatenbank im .accdb<\/b>-Format vor dem Erstellen der .accde<\/b>-Datenbank eingestellt hatten.<\/p>\n Was nun? Zum Glück können wir die Eigenschaften der Spalten der Datenblattansicht per VBA auslesen.<\/p>\n Das bedeutet, dass wir sie auch wiederherstellen können. Alles, was wir benötigen, ist eine Tabelle, in der wir die Einstellungen speichern können, während das Formular oder die Anwendung geschlossen werden, und aus der wir die Einstellungen wieder auslesen und wiederherstellen können.<\/p>\n Wir starten mit dem Auslesen der Einstellungen der Spalten des Formulars. Dazu öffnen wir zunächst wieder die .accdb<\/b>-Version der Datenbank – in der .accde<\/b>-Datenbank können wir schließlich erst gar nicht auf den VBA-Code zugreifen.<\/p>\n Für das Ermitteln der Positionen, Sichtbarkeit und Breite sowie der fixierten Spalten können wir einige VBA-Eigenschaften verwenden.<\/p>\n Zunächst einmal verwenden wir eine Eigenschaft des Formulars in der Datenblattansicht namens FrozenColumns<\/b>. Diese liefert uns Informationen darüber, wie viele Spalten fixiert sind. Dabei ist der zurückgegebene Wert etwas irreführend:<\/p>\n Beispiel für das Hauptformular frmMitarbeiterUebersicht <\/b>mit dem Unterformular sfmMitarbeiterUebersicht<\/b>:<\/p>\n Zum Ermitteln der Reihenfolge können wir die Eigenschaft ColumnOrder <\/b>der einzelnen Steuerelemente nutzen. Diese liefert uns für jede Spalte den Index, den die aktuelle Spalte in der Reihenfolge hat. Die linke Spalte liefert den Wert 1<\/b>, die zweite von links den Wert 2 <\/b>und so weiter.<\/p>\n Beispiel: <\/p>\n Die Eigenschaft zum Ermitteln der Spaltenbreite lautet ColumnWidth<\/b>. Sie liefert die Breite in Twips:<\/p>\n Schließlich fehlt noch die Sichtbarkeit. Diese ermitteln wir im Gegensatz zu Steuerelementen in Formularen in der Formularansicht nicht mit der Visible<\/b>-Eigenschaft, sondern mit der Eigenschaft ColumnHidden<\/b>. Sie liefert den Wert False<\/b>, wenn das Steuerelement sichtbar ist, und True<\/b>, falls es ausgeblendet ist.<\/p>\n Beispiel:<\/p>\n Die Eigenschaften ColumnOrder<\/b>, ColumnWidth <\/b>und ColumnHidden <\/b>sind keine allgemeinen Eigenschaften von Steuerelementen, werden also von IntelliSense nicht angezeigt, wenn wir über den Typ Control <\/b>darauf zugreifen wollen.<\/p>\n Wir finden die Eigenschaften erst für explizit angegebene Steuerelementtypen, die wir beispielsweise im Objektkatalog sehen (siehe Bild 6).<\/p>\n Bild 6: Die Spalteneigenschaften im Objektkatalog<\/span><\/b><\/p>\n Wir können diese aber auch über den Datentyp Control <\/b>nutzen, vorausgesetzt das referenzierte Steuerelement verfügt über die entsprechende Eigenschaft. Bei Beschriftungsfeldern ist das beispielsweise nicht der Fall.<\/p>\n In der Prozedur aus Listing 1 geben wir zunächst einmal alle Eigenschaften der gebundenen Steuerelemente des Unterformulars sfmMitarbeiterUebersicht <\/b>aus.<\/p>\n Listing 1: Auslesen der Spalteneigenschaften für die Steuerelemente unseres Beispielformulars<\/span><\/b><\/p>\n Dabei referenzieren wir mit der Variablen frm <\/b>das Hauptformular frmMitarbeiterUebersicht <\/b>und mit sfm <\/b>das im Unterformularsteuerelement sfmMitarbeiterUebersicht <\/b>enthaltene Formular.<\/p>\n Bevor wir die Steuerelemente durchlaufen, geben wir die Eigenschaft FrozenColumns <\/b>des Unterformulars aus. Dann durchlaufen wir alle Steuerelemente der Auflistung Controls <\/b>des Unterformulars und referenzieren diese jeweils mit der Variablen ctl <\/b>mit dem Datentyp Control<\/b>.<\/p>\n In der Schleife prüfen wir, ob es sich bei dem aktuellen Steuerelement um ein gebundenes Steuerelement handelt.<\/p>\n Das ist nötig, weil dieses ja auch Bezeichnungsfelder enthält. Dazu versuchen wir bei deaktivierter Fehlerbehandlung, den Wert der Eigenschaft ControlSource <\/b>(Steuerelementinhalt<\/b>) auszulesen und speichern diesen in der Variablen strControlSource<\/b>.<\/p>\n Ist strControlSource <\/b>dann nicht leer, handelt es sich um ein gebundenes Steuerelement. Dann geben wir den Namen des Steuerelements und die Werte der Eigenschaften ColumnHidden<\/b>, ColumnWidth <\/b>und ColumnOrder <\/b>im Direktbereich des VBA-Editors aus. Das Ergebnis für ein Datenblatt mit einigen Anpassungen sieht wie in Bild 7 aus.<\/p>\n Bild 7: Ausgabe der Spalteneigenschaften im Direktbereich des VBA-Editors<\/span><\/b><\/p>\n Es fehlt noch ein Hinweis darauf, dass wir mit dem Fixieren von Spalten eventuell die Reihenfolge der Spalten ändern. Das ist der Fall, wenn wir nicht ausschließlich Spalten am linken Rand fixieren wollen.<\/p>\n Wenn wir beispielsweise nur die zweite Spalte von links fixieren wollen, wird diese ganz nach links verschoben und fixiert.<\/p>\n Wenn wir in einer .accde<\/b>-Datenbank die vom Benutzer eingestellten Spalteneigenschaften speichern und später wieder herstellen wollen, benötigen wir eine Tabelle, um die Informationen zu speichern. Diese soll zumindest einmal für jede Spalte die Position, die Breite und die Sichtbarkeit aufnehmen.<\/p>\n Außerdem wollen wir die Information über die Fixierung von Spalten sichern. Dies ist aber eine Information, die wir für das Formular speichern, in dem sich die Spalten befinden.<\/p>\n Wir wollen die Daten allerdings nicht nur für ein Formular speichern können, sondern gegebenenfalls auch für mehrere. Deshalb müssen wir auch noch Informationen über das betroffene Formular und natürlich auch noch die Steuerelementnamen sichern.<\/p>\n Damit wir die Anzahl der fixierten Spalten nicht mehrfach speichern müssen, legen wir zwei Tabellen an:<\/p>\n Die Tabelle tblColumnsForms <\/b>enthält ein Primärschlüsselfeld namens FormID <\/b>sowie ein Feld für den Formularnamen (Formname<\/b>) und die Anzahl der fixierten Spalten (FrozenColumns<\/b>) – siehe Bild 8.<\/p>\n Bild 8: Tabelle für die Formulare<\/span><\/b><\/p>\n Die Tabelle tblColumnsProperties<\/b> sieht wie in Bild 9 aus. Hier finden wir neben dem Primärschlüsselfeld ColumnID <\/b>das Fremdschlüsselfeld FormID<\/b>, mit dem das Formular festgelegt wird, in dem sich das Steuerelement befindet. Den Namen des Steuerelements speichern wir im Feld Controlname<\/b>.<\/p>\n Bild 9: Tabelle mit den Spalten<\/span><\/b><\/p>\n Außerdem speichern wir in den Feldern ColumnWidth<\/b>, ColumnOrder <\/b>und ColumnHidden <\/b>die jeweiligen Eigenschaftswerte.<\/p>\n Für die beiden Felder FormID <\/b>und Controlname <\/b>legen wir einen eindeutigen Index fest, damit jedes Steuerelement nur einmal für jedes Formular angelegt werden kann.<\/p>\n Für die Beziehung zwischen den beiden Tabellen stellen wir die Löschweitergabe <\/b>auf Ja <\/b>ein. Damit sorgen wir dafür, dass wir beim Speichern der Daten für ein Formular direkt die kompletten Daten der beiden Tabellen nur durch das Löschen des entsprechenden Datensatzes der Tabelle tblColumnsForms <\/b>entfernen können (siehe Bild 10).<\/p>\n Bild 10: Beziehung zwischen den Tabellen<\/span><\/b><\/p>\n Um die Tabellen zu füllen, erstellen wir eine neue, erweiterte Version der zuvor verwendeten Prozedur namens SaveColumnConfiguration<\/b> (siehe Listing 2). Sie beginnt wie die vorherige Version, löscht dann aber zunächst die Daten der Tabelle tblColumnsForms <\/b>und somit auch die Daten der Tabelle tblColumnsProperties<\/b>.<\/p>\n Listing 2: Schreiben der Spalteneigenschaften in die beiden Tabellen tblColumnsForms und tblColumnsProperties<\/span><\/b><\/p>\n Dann legt sie einen neuen Datensatz in der Tabelle tblColumnsForms <\/b>an und trägt dort den Namen des Formulars ein. Anschließend liest sie den Primärschlüsselwert des neu angelegten Datensatzes in die Variable lngFormID <\/b>ein.<\/p>\n Nun durchläuft sie wie zuvor die Schleife über alle Steuerelemente und ermittelt darunter die gebundenen Steuerelemente. Für diese schreibt sie die ID des dazugehörenden Formulars aus der Tabelle tblColumnsForms<\/b>, den Steuerelementnamen, die Spaltenbreite, die Spaltenposition und die Sichtbarkeit in die Felder der Tabelle tblColumnsProperties<\/b>.<\/p>\n Das Ergebnis sehen wir in Bild 11. Für das Formular landet ein Datensatz in der Tabelle tblColumnsForms<\/b>, für jedes Steuerelement einer in der Tabelle tblColumnsProperties<\/b>. Damit sind wir soweit, dass wir nur noch die Konfiguration zurück in das Formular schreiben müssen.<\/p>\n Bild 11: Daten der Tabellen mit den Spalteneigenschaften<\/span><\/b><\/p>\n Zuvor passen wir unsere Prozedur noch leicht an, sodass sie mit der Version aus der Beispieldatenbank übereinstimmt.<\/p>\n Dazu entfernen wir die Deklaration der Formulare (frm<\/b>, sfm<\/b>) sowie die Zuweisung dieser Elemente aus der Prozedur SaveColumnConfiguration <\/b>und fügen der Prozedur einen Parameter namens sfm <\/b>als Parameter zur Kopfzeile hinzu:<\/p>\n Den Aufruf zum Testen können wir nun wie folgt in einer eigenen Prozedur hinterlegen:<\/p>\n In dem Formular, dessen Konfiguration wir speichern wollen, nehmen wir keine Änderungen vor – wohl aber im Unterformular. Hier legen wir eine Prozedur für das Ereignis Beim Entladen <\/b>an und füllen sie mit dem folgenden Code:<\/p>\n Damit wird beim Schließen des Formulars die Konfiguration der Spalten des Datenblatts gespeichert.<\/p>\n Nun wollen wir die Konfiguration beim Laden des Formulars beziehungsweise des Unterformulars wiederherstellen. Das ist allerdings alles andere als trivial, wie sich gleich herausstellen wird.<\/p>\n Der Grund dafür ist, dass wir auf die Eigenschaft FrozenColumns <\/b>nur lesend, aber nicht schreibend zugreifen können. Das bedeutet, dass wir zwar ermitteln können, wie viele Spalten von links aus fixiert wurden, aber wir können diesen Wert für ein neu geöffnetes Formular über diese Eigenschaft nicht wiederherstellen.<\/p>\n Allerdings gibt es die Möglichkeit, dies über die Benutzeroberfläche zu erledigen – zum Beispiel wie weiter oben gezeigt über den Befehl Spalten fixieren <\/b>des Kontextmenüs der Spaltenköpfe des Formulars. Auch finden wir hier einen Befehl namens Fixierung aller Spalten aufheben<\/b>. Und wenn es die Möglichkeit gibt, eine Aktion über die Benutzeroberfläche durchzuführen, finden wir in der Regel auch eine entsprechende Konstante für die Methode Application.RunCommand<\/b>.<\/p>\n Da wir wissen, dass die Eigenschaft zum Fixieren von Spalten FrozenColumns <\/b>heißt, suchen wir einmal im Objektkatalog des VBA-Editors nach Begriffen wie Frozen <\/b>oder Freeze<\/b>. Die Suche ist schnell von Erfolg gekrönt, wie Bild 12 zeigt.<\/p>\n Bild 12: Suchen von RunCommand-Konstanten im Objektkatalog<\/span><\/b><\/p>\n Nun gestaltet es sich allerdings wesentlich umständlicher als mit der Eigenschaft FrozenColumns<\/b>, damit die fixierten Spalten wiederherzustellen. Wir können damit nämlich immer nur eine Spalte gleichzeitig fixieren. Immerhin können wir so von links nach rechts die Anzahl Spalten fixieren, die wir auch in der Konfigurationstabelle gespeichert haben.<\/p>\n So setzen wir nacheinander den Fokus auf die jeweils zu den fixierten Spalten hinzuzufügende Spalte und fixieren diese. Wie das geht, schauen wir uns gleich an.<\/p>\n Die Prozedur LoadColumnConfiguration <\/b>haben wir direkt so aufgebaut wie die Prozedur SaveColumnConfiguration<\/b>. Wir übergeben dieser einen Verweis auf das Formular, das die entsprechende Datenblattansicht anzeigt (siehe Listing 3).<\/p>\n Listing 3: Schreiben der Spalteneinstellungen aus den Tabellen in die Steuerelemente<\/span><\/b><\/p>\n Damit können wir diese beim Laden des Unterformulars wie in der folgenden Ereignisprozedur aufrufen und mit dem Schlüsselwort Me <\/b>einen entsprechenden Verweis übergeben:<\/p>\n Die Prozedur selbst erledigt mehrere Aufgaben. Die erste ist, alle Spalten des Formulars sichtbar zu machen. Dazu durchlaufen wir alle Steuerelemente in einer For Each<\/b>-Schleife über die Auflistung sfm.Controls<\/b>.<\/p>\n Hier ermitteln wir wieder, ob es sich bei dem aktuellen Steuerelement um ein gebundenes Steuerelement handelt. Falls ja, stellen wir die Eigenschaft ColumnHidden <\/b>auf False <\/b>ein und blenden die Spalte somit ein.<\/p>\n Außerdem wollen wir in diesem Durchlauf dafür sorgen, dass die erste Spalte den Fokus erhält. Dazu haben wir eine Variable namens bolFokusGesetzt <\/b>erstellt, die zunächst den Wert False <\/b>enthält. Sobald wir das erste Mal den Fokus gesetzt haben, in diesem Fall für die erste Spalte, wird bolFokusGesetzt <\/b>auf True <\/b>eingestellt, sodass der Fokus auf der ersten Spalte verbleibt.<\/p>\n Nachdem so alle Spalten sichtbar gemacht wurden, entfernen wir auch noch die aktuelle Fixierung, indem wir die Methode RunCommand <\/b>mit dem Parameter acCmdUnfreezeAllColumns <\/b>aufrufen. Dazu muss mindestens eine Spalte den Fokus haben, daher haben wir diese vorher auf die erste Spalte gesetzt.<\/p>\n Danach kümmern wir uns um die eigentliche Wiederherstellung der Konfiguration. Hier tragen wir zunächst den Namen des Formulars in die Variable strFormname <\/b>ein und erstellen ein Recordset auf Basis der Tabelle tblColumnsForms<\/b>, der den Datensatz enthält, der sich auf dieses Formular bezieht. Aus dieser Tabelle lesen wir den Primärschlüsselwert aus und speichern ihn in der Variablen lngFormID<\/b>.<\/p>\n Dann erstellen wir ein zweites Recordset namens rstColumns<\/b>, diesmal auf Basis der Tabelle tblColumnsProperties<\/b>. Diese filtern wir in dem Recordset nach dem Primärschlüsselwert des verknüpften Datensatzes der Tabelle tblColumnsForms<\/b> und sortieren die Daten nach dem Wert des Feldes ColumnOrder<\/b>.<\/p>\n Auf diese Weise können wir die Spalten in der folgenden Do While<\/b>-Schleife gleich in der Reihenfolge durchlaufen, in welcher die Spalten von links nach rechts angeordnet werden sollen.<\/p>\n Wir referenzieren das aktuell anzupassende Steuerelement mit sfm.Controls(rstColumns!ControlName)<\/b>. Dann stellen wir zunächst den Wert der Eigenschaft ColumnOrder <\/b>auf den Wert des Feldes ColumnOrder <\/b>des Recordsets ein. Wenn sich dieses Feld zuvor an einer anderen, weiter hinten liegenden Position befand, werden die Werte der Eigenschaft ColumnOrder <\/b>für alle Felder, die dadurch nach rechts verschoben werden, um 1 erhöht.<\/p>\n Danach stellen wir die Werte der Eigenschaft ColumnWidth <\/b>wieder her.<\/p>\n Und damit kommen wir zum spannenden Teil dieser Prozedur: Wie sorgen wir dafür, dass die ersten n <\/b>Spalten von links als fixierte Spalten markiert werden?<\/p>\n Dazu prüfen wir in einer If…Then<\/b>-Bedingung, ob der aktuelle Wert von rstColumns!ColumnOrder <\/b>kleiner ist als der Wert des Feldes FrozenColumn <\/b>des Recordsets rstForm<\/b>.<\/p>\n Wenn die ersten beiden Spalten fixiert waren, lautet dieser Wert beispielsweise 3<\/b>. Dann fixieren wir so viele Spalten, bis die Anzahl der Spalten gleich 3 <\/b>ist – diese Spalte wird dann nicht mehr fixiert.<\/p>\n Wir setzen den Fokus auf die aktuelle Spalte und rufen dann die Methode RunCommand <\/b>mit dem Parameter acCmdFreezeColumn <\/b>auf.<\/p>\n Schließlich stellen wir noch die Eigenschaft ColumnHidden <\/b>auf den Wert des entsprechenden Feldes des Recordsets rstColumns <\/b>ein. Auf diese Weise passen wir alle Spalten an die in den Tabellen gespeicherten Konfigurationen an.<\/p>\n Nun speichern wir die aktuelle Datenbank im Format .accde <\/b>und starten diese. Hier stellen wir fest, dass alle zuvor geänderten Einstellungen wiederhergestellt wurden.<\/p>\n Wenn wir nun einige Einstellungen ändern und das Formular schließen und erneut öffnen, finden wir die Einstellungen unverändert vor. Das Gleiche geschieht, wenn wir die vollständige Datenbank schließen und erneut öffnen – alle Einstellungen werden wiederhergestellt.<\/p>\n In .accde<\/b>-Datenbanken werden die vom Benutzer vorgenommenen Einstellungen an den Spalten der Datenblattansicht nicht gespeichert. Eventuelle Änderungen, die der Benutzer für eine ergonomischere Arbeitsweise mit den jeweiligen Daten vorgenommen hat, muss er bei jedem Öffnen des Formulars manuell wiederherstellen.<\/p>\n Diese Arbeit wollen wir dem Benutzer ersparen und haben dazu in diesem Beitrag zwei Prozeduren erarbeitet, mit denen wir zunächst die aktuelle, vom Benutzer vorgenommene Konfiguration beim Schließen des Formulars mit der Datenblattansicht in zwei Tabellen speichern.<\/p>\n Die zweite Prozedur wird beim Laden des Formulars mit der Datenblattansicht aufgerufen und liest die Daten aus den Tabellen, um die Konfiguration im Formular wiederherzustellen.<\/p>\n Wenn Sie diese Funktionen in eigenen Anwendungen nutzen wollen, sind nur wenige Schritte zu erledigen:<\/p>\nMögliche Anpassungen der Datenblattansicht<\/h2>\n
\n
![\"Ausblenden](\"..\/fileadmin\/_temp_\/2025_03\/pic_1547_002.png\")
<\/p>\n![\"Erneutes](\"..\/fileadmin\/_temp_\/2025_03\/pic_1547_003.png\")
<\/p>\nVerhalten in der .accdb-Version der Datenbank<\/h2>\n
Speichern der Datenbank als .accde-Datenbank<\/h2>\n
![\"Speichern](\"..\/fileadmin\/_temp_\/2025_03\/pic_1547_004.png\")
<\/p>\nExperimente mit der .accde-Version<\/h2>\n
![\"In](\"..\/fileadmin\/_temp_\/2025_03\/pic_1547_005.png\")
<\/p>\nSpalteneinstellungen manuell speichern und wiederherstellen<\/h2>\n
Ermitteln der Spalteneinstellungen des Formulars<\/h2>\n
Spalteneigenschaften unter VBA<\/h2>\n
Fixierte Spalten per VBA ermitteln<\/h2>\n
\n
Debug.Print<\/span> Forms!frmMitarbeiterUebersicht! sfmMitarbeiterUebersicht.Form.FrozenColumns<\/pre>\nReihenfolge der Spalten per VBA ermitteln<\/h2>\n
Debug.Print<\/span> Forms!frmMitarbeiterUebersicht! sfmMitarbeiterUebersicht!cboAnredeID.ColumnOrder<\/pre>\nSpaltenbreiten ermitteln<\/h2>\n
Debug.Print<\/span> Forms!frmMitarbeiterUebersicht! sfmMitarbeiterUebersicht!cboAnredeID.ColumnWidth<\/pre>\nSichtbarkeit einer Spalte ermitteln<\/h2>\n
Debug.Print<\/span> Forms!frmMitarbeiterUebersicht! sfmMitarbeiterUebersicht!cboAnredeID.ColumnHidden<\/pre>\nKeine Steuerelementeigenschaften<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2025_03\/pic_1547_006.png\")
<\/p>\nDurchlaufen der Spalten und Ermitteln der Eigenschaften<\/h2>\n
Public Sub <\/span>DatenblattAuslesen()\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>sfm As <\/span>Form\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>strControlSource As String<\/span>\r\n Set<\/span> frm = Forms!frmMitarbeiterUebersicht\r\n Set<\/span> sfm = frm!sfmMitarbeiterUebersicht.Form\r\n Debug.Print<\/span> \"Fixierte Spalte: \" & sfm.FrozenColumns\r\n For Each ctl In sfm.Controls\r\n strControlSource = \"\"\r\n On Error Resume Next<\/span>\r\n strControlSource = ctl.ControlSource\r\n On Error GoTo<\/span> 0\r\n If <\/span>Not<\/span> Len<\/span>(strControlSource) = 0 Then<\/span>\r\n Debug.Print<\/span> strControlSource, ctl.ColumnHidden, ctl.ColumnWidth, ctl.ColumnOrder\r\n End If<\/span>\r\n Next<\/span> ctl\r\nEnd Sub<\/span><\/pre>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2025_03\/pic_1547_007.png\")
<\/p>\nFelder fixieren ändert gegebenenfalls Reihenfolge<\/h2>\n
Tabelle zum Speichern vorbereiten<\/h2>\n
\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2025_03\/pic_1547_008.png\")
<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2025_03\/pic_1547_009.png\")
<\/p>\n![\"Beziehung](\"..\/fileadmin\/_temp_\/2025_03\/pic_1547_010.png\")
<\/p>\nSchreiben der Spalteneigenschaften in die Tabellen<\/h2>\n
Public Sub <\/span>SaveColumnConfiguration()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>sfm As <\/span>Form\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>strControlSource As String<\/span>\r\n Dim <\/span>lngFormID As Long<\/span>\r\n \r\n Set<\/span> db = CurrentDb\r\n Set<\/span> frm = Forms!frmMitarbeiterUebersicht\r\n Set<\/span> sfm = frm!sfmMitarbeiterUebersicht.Form\r\n \r\n db.Execute \"DELETE FROM tblColumnsForms WHERE Formname = ''\" & sfm.Name & \"''\", dbFailOnError\r\n db.Execute \"INSERT INTO tblColumnsForms(Formname, FrozenColumns) VALUES(''\" & sfm.Name & \"'', \" & sfm.FrozenColumns _\r\n & \")\", dbFailOnError\r\n lngFormID = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n \r\n For Each ctl In sfm.Controls\r\n strControlSource = \"\"\r\n On Error Resume Next<\/span>\r\n strControlSource = ctl.ControlSource\r\n On Error GoTo<\/span> 0\r\n If <\/span>Not<\/span> Len<\/span>(strControlSource) = 0 Then<\/span>\r\n db.Execute \"INSERT INTO tblColumnsProperties(FormID, Controlname, ColumnWidth, ColumnOrder, \" _\r\n & \"ColumnHidden) VALUES(\" & lngFormID & \", ''\" & ctl.Name & \"'', \" & ctl.ColumnWidth & \", \" _\r\n & ctl.ColumnOrder & \", \" & CInt(ctl.ColumnHidden) & \")\", dbFailOnError\r\n End If<\/span>\r\n Next<\/span> ctl\r\nEnd Sub<\/span><\/pre>\n![\"Daten](\"..\/fileadmin\/_temp_\/2025_03\/pic_1547_011.png\")
<\/p>\nPublic Sub <\/span>SaveColumnConfiguration(sfm As <\/span>Form)\r\n...<\/pre>\nPublic Sub <\/span>Test_SaveColumnConfiguration()\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>sfm As <\/span>Form\r\n Set<\/span> frm = Forms!frmMitarbeiterUebersicht\r\n Set<\/span> sfm = frm!sfmMitarbeiterUebersicht.Form\r\n SaveColumnConfiguration sfm\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Unload(Cancel As Integer<\/span>)\r\n SaveColumnConfiguration Me\r\nEnd Sub<\/span><\/pre>\nKonfiguration beim Laden des Formulars auslesen<\/h2>\n
![\"Suchen](\"..\/fileadmin\/_temp_\/2025_03\/pic_1547_012.png\")
<\/p>\nPublic Sub <\/span>LoadColumnConfiguration(sfm As <\/span>Form)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rstForm As <\/span>DAO.Recordset\r\n Dim <\/span>rstColumns As <\/span>DAO.Recordset\r\n Dim <\/span>strFormname As String<\/span>\r\n Dim <\/span>lngFormID As Long<\/span>\r\n Dim <\/span>strControlSource As String<\/span>\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>bolFokusGesetzt As Boolean<\/span>\r\n \r\n For Each ctl In sfm.Controls\r\n strControlSource = \"\"\r\n On Error Resume Next<\/span>\r\n strControlSource = ctl.ControlSource\r\n On Error GoTo<\/span> 0\r\n If <\/span>Not<\/span> Len<\/span>(strControlSource) = 0 Then<\/span>\r\n Debug.Print<\/span> ctl.Name\r\n ctl.ColumnHidden = False<\/span>\r\n If <\/span>bolFokusGesetzt = False<\/span> Then<\/span>\r\n ctl.SetFocus\r\n bolFokusGesetzt = True<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span> ctl\r\n RunCommand acCmdUnfreezeAllColumns\r\n strFormname = sfm.Name\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rstForm = db.OpenRecordset(\"SELECT * FROM tblColumnsForms WHERE Formname = ''\" & strFormname & \"''\", _\r\n dbOpenDynaset)\r\n lngFormID = rstForm!FormID\r\n Set<\/span> rstColumns = db.OpenRecordset(\"SELECT * FROM tblColumnsProperties WHERE FormID = \" & lngFormID _\r\n & \" ORDER BY ColumnOrder ASC\", dbOpenDynaset)\r\n \r\n Do While<\/span> Not<\/span> rstColumns.EOF\r\n With<\/span> sfm.Controls(rstColumns!ControlName)\r\n .ColumnOrder = rstColumns!ColumnOrder\r\n .ColumnWidth = rstColumns!ColumnWidth\r\n If <\/span>rstColumns!ColumnOrder < rstForm!FrozenColumns Then<\/span>\r\n .SetFocus\r\n RunCommand acCmdFreezeColumn\r\n End If<\/span>\r\n .ColumnHidden = rstColumns!ColumnHidden\r\n End With<\/span>\r\n rstColumns.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Load()\r\n LoadColumnConfiguration Me\r\nEnd Sub<\/span><\/pre>\nTesten der Funktion in einer .accde-Datenbank<\/h2>\n
Zusammenfassung und Ausblick<\/h2>\n
Einbau in eigene Anwendungen<\/h2>\n