<\/p>\n
Wenn Sie die Daten einer Tabelle oder Abfrage in einem Formular in der Datenblattansicht anzeigen, können Sie über das Kontextmenü komfortabel damit arbeiten – beispielsweise, um Spalten ein- oder auszublenden. Dieses Kontextmenü fehlt leider komplett, wenn Sie die Runtime-Version von Access verwenden. Der Benutzer hat dann keine Möglichkeit, die Spalten nach seinen eigenen Wünschen ein- oder auszublenden. Dieser Beitrag reicht eine Lösung nach, mit der Sie auch dieses Feature in Runtime-Datenbanken anbieten können.<\/b><\/p>\n
Wenn Sie in einem Datenblatt in einem Formular beispielsweise mit der rechten Maustaste auf einen der Spaltenköpfe klicken, erscheint das Kontextmenü aus Bild 1.<\/p>\n
![\"Dieses](\"..\/fileadmin\/_temp_\/2014_03\/pic_936_001.png\")
<\/p>\n
Bild 1: Dieses Kontextmenü lässt sich in der Runtime-Version von Access nicht blicken.<\/span><\/b><\/p>\n Wenn Sie die Datenbank dann mit der Runtime-Version von Access öffnen (oder zumindest im Runtime-Modus), fehlen sämtliche Kontextmenüs des Datenblatts.<\/p>\n Das ist unpraktisch, da sich ja damit eine Reihe von Aufgaben gleich an Ort und Stelle erledigen lässt – beispielsweise das Ein- und Ausblenden einzelner Spalten.<\/p>\n Bevor wir uns dies im Detail ansehen, noch der Hinweis, wie Sie die Datenbank im Runtime-Modus öffnen können:<\/p>\n Ob Sie die Datenbank im Runtime-Modus öffnen, erkennen Sie beispielsweise daran, dass weder eingebaute Menüs noch Ribbons sichtbar sind.<\/p>\n Spalten ein- und ausblenden<\/b><\/p>\n Der Kontextmenübefehl Felder ausblenden <\/b>für das Kontextmenü einer oder mehrerer markierter Spalten blendet die markierten Spalten einfach aus. Wenn Sie den Menübefehl Felder wieder einblenden <\/b>auswählen, erscheint der Dialog aus Bild 2, mit dem Sie alle Felder komfortabel ein- oder ausblenden können.<\/p>\n Bild 2: Komfortables Ein- und Ausblenden von Feldern<\/span><\/b><\/p>\n Kontextmenü ersetzen<\/b><\/p>\n Unsere erste Aufgabe ist es, das bestehende Kontextmenü zu ersetzen beziehungsweise in der Runtime-Version von Access überhaupt ein Kontextmenü anzuzeigen, wenn der Benutzer mit der rechten Maustaste auf die Spaltenköpfe der Datenblattansicht klickt. <\/p>\n Dazu benötigen wir zunächst einmal einen Verweis auf die Bibliothek Microsoft Office x.0 Object Library<\/b>. Diesen fügen Sie über den Dialog aus Bild 3 hinzu, den Sie vom VBA-Editor aus mit dem Menü-befehl Extras|Verweise <\/b>öffnen. Mit diesem fügen Sie dem VBA-Projekt die CommandBars<\/b>-Auflistung und weitere gleich benötigte Elemente hinzu.<\/p>\n Bild 3: Hinzufügen eines Verweises auf die Office-Bibliothek<\/span><\/b><\/p>\n Benutzerdefinierte Kontextmenüs werden per VBA zusammengestellt und mit der Methode ShowPopup<\/b> des entsprechenden CommandBar<\/b>-Elements angezeigt.<\/p>\n In welcher Ereignisprozedur des Formulars aber lösen wir diese Aktionen aus Die Lösung ist das Ereignis Bei Maustaste ab <\/b>des Formulars selbst. öffnen Sie das Formular in der Entwurfsansicht, wählen Sie im Eigenschaftsfenster den Eintrag Formular <\/b>aus und selektieren dann den Wert [Ereignisprozedur] <\/b>für die Eigenschaft Bei Maustaste ab<\/b>. Klicken Sie dann auf die Schaltfläche mit den drei Punkten (…) rechts von der Eigenschaft, um die entsprechende Prozedur im VBA-Editor anzulegen (s. Bild 4).<\/p>\n Bild 4: Ereignis, das beim Drücken der Maustaste ausgelöst wird<\/span><\/b><\/p>\n Diese Prozedur füllen Sie wie in Listing 1. Die Prozedur deklariert je eine Objektvariable für ein CommandBar<\/b>– und ein CommandBarButton<\/b>-Objekt sowie eine Variable, welche den Namen des zu erzeugenden Kontextmenüs speichert (strKontextmenue<\/b>).<\/p>\n Listing 1: Anzeigen eines Kontextmenüs für die Spaltenköpfe des Datenblatts<\/span><\/b><\/p>\n Die Prozedur prüft dann zunächst anhand des Parameters Button<\/b>, welche Maustaste der Benutzer angeklickt. Wir wollen eine Aktion nur für die rechte Maustaste ausführen, also prüfen wir auf den Wert 2<\/b>.<\/p>\n In diesem Fall legen wir zunächst den Namen des Kontextmenüs fest (cbrDatenblatt<\/b>) und speichern diesen in der Variablen strKontextmenue<\/b>. Dann deaktivieren wir die Fehlerbehandlung und löschen ein eventuell bereits vorhandenes CommandBar<\/b>-Objekt gleichen Namens.<\/p>\n Die Fehlerbehandlung haben wir ausgeschaltet, damit das Fehlen dieses Kontextmenüs keinen Fehler beim Versuch auslöst, dieses zu löschen.<\/p>\n Nun erstellen wir mit der Add<\/b>-Methode der CommandBars<\/b>-Auflistung ein neues CommandBar<\/b>-Objekt und legen für dieses fest, dass es den in strKontextmenue <\/b>gespeicherten Namen erhalten, als Kontextmenü angezeigt werden (msoBarPopup<\/b>) und temporär erstellt werden soll.<\/p>\n Danach folgen bereits die beiden ersten Befehle, mit denen wir das Ausblenden der aktuell markierten Spalten sowie die Anzeige eines Dialogs zum Ein- und Ausblenden aller Spalten realisieren wollen.<\/p>\n Der Erste wird durch ein CommandBarButton<\/b>-Objekt ausgelöst, das die Beschriftung Spalten ausblenden <\/b>trägt und beim Anklicken die über die OnAction<\/b>-Eigenschaft festgelegte VBA-Funktion SpaltenAusblenden <\/b>aufruft. Auf ähnliche Weise fügen wir die zweite Schaltfläche mit der Beschriftung Spalten bearbeiten <\/b>und der VBA-Funktion SpaltenDialog <\/b>hinzu.<\/p>\n Schließlich zeigt die ShopPopup<\/b>-Methode des mit der Variablen cbr <\/b>referenzierten CommandBar<\/b>-Objekts das Kontextmenü an.<\/p>\n Dieses erscheint nun zunächst wie in Bild 5.<\/p>\n Bild 5: Anzeige des Kontextmenüs<\/span><\/b><\/p>\n Achtung, Fehlerbehandlung außer Betrieb!<\/b><\/p>\n An dieser Stelle ist es sehr wichtig, auf die Besonderheit der Fehlerbehandlung nach dem Aufruf von Funktionen über Kontextmenü-Einträge hinzuweisen.<\/p>\n Wenn Sie dazu eine VBA-Funktion verwenden, die für die Eigenschaft OnAction <\/b>angegeben wird, ist die Fehlerbehandlung in der VBA-Funktion außer Kraft gesetzt. Wenn ein Fehler auftritt, wird einfach der nachfolgende Befehl ausgeführt, und wenn ein Fehler in einer weiteren durch die Funktion aufgerufenen Routine entsteht, wird diese augenblicklich beendet und die aufrufende Funktion fortgesetzt. Sollte also einmal etwas nicht wie erwartet funktionieren, sollten Sie diese Möglichkeit nicht außer Acht lassen.<\/p>\n Spalten ausblenden<\/b><\/p>\n Die erste Funktion namens SpaltenAusblenden<\/b> soll die aktuell markierten Spalten ausblenden. Dazu fügen Sie die Funktion aus Listing 2 zum Klassenmodul des Formulars hinzu.<\/p>\n <\/p>\n Listing 2: Ausblenden der aktuellen Spalten<\/span><\/b><\/p>\n Die Funktion durchläuft alle Steuerelemente des Formulars in einer For Each<\/b>-Schleife und referenziert das jeweils aktuelle Steuerelement mit der Variablen ctl<\/b>. Dann schalten wir die Fehlerbehandlung aus, denn wir wollen, wenn es sich bei dem Steuerelement um ein gebundenes Steuerelement handelt, den Namen des gebundenen Feldes in der Variablen strControlsource <\/b>speichern. Ist das Steuerelement nicht an ein Feld der Datenherkunft gebunden, löst dies einen Fehler aus, der allerdings nicht angezeigt wird, und strControlsource <\/b>behält die zuvor zugewiesene leere Zeichenkette („“<\/b>).<\/p>\n Ist die Länge der in strControlsource <\/b>enthaltenen Zeichenkette größer als 0<\/b>, schaut sich die Funktion das Steuerelement genauer an. Nun muss sie nämlich prüfen, ob es sich tatsächlich um ein Steuerelement handelt, das an eines der Felder der Datenherkunft gebunden ist – es kann ja auch sein, dass das Feld einen berechneten Ausdruck enthält.<\/p>\n Dazu durchläuft die Prozedur in einer For Each<\/b>-Schleife alle Felder des Recordsets des Formulars und gleicht den Inhalt der Variablen strControlsource <\/b>mit dem Namen des aktuellen Feldes ab.<\/p>\n Sind beide Werte gleich, erfolgt eine weitere Prüfung – nämlich ob die Spalte, auf die sich das Steuerelement bezieht, vom Benutzer markiert wurde. Dazu zieht die Funktion drei Informationen hinzu: Die in der Eigenschaft Column-Order <\/b>des Steuerelements enthaltene Zahl, welche die Reihenfolge repräsentiert sowie die Eigenschaften SelLeft <\/b>und SelWidth <\/b>des Formulars. SelLeft <\/b>liefert die Zahl der ersten markierten Spalte, SelWidth <\/b>die Anzahl der markierten Spalten.<\/p>\n Dabei beginnt die Zählung von SelWidth <\/b>mit dem Wert 2<\/b>, die von ColumnOrder <\/b>mit 1<\/b>. Dementsprechend prüft das Kriterium der If…Then<\/b>-Bedingung, ob die ColumnOrder <\/b>des Steuerelements größer gleich dem Wert von SelLeft – 1 <\/b>ist oder ob ColumnOrder <\/b>kleiner oder gleich Me.SelLeft + Me.SelWidth – 1 <\/b>ist. Ist das der Fall, stellt die Funktion den Wert der Eigenschaft ColumnHidden <\/b>für das aktuelle Steuerelement und somit für die entsprechende Spalte des Datenblatts auf den Wert True <\/b>ein.<\/p>\n Die innere For Each<\/b>-Schleife wird in diesem Fall verlassen, sonst sucht die Funktion weiter nach einem Feldnamen, der mit dem Inhalt von strControlsource <\/b>übereinstimmt.<\/p>\n Diese Schritte wiederholt die Funktion für alle Steuerelemente. Auf diese Weise können Sie eines oder mehrere Spalten des Datenblatts markieren und per Kontextmenü ausblenden.<\/p>\n Ein-\/Ausblenden-Formular<\/b><\/p>\n Nun stellt sich die Frage: Wie blenden wir die ausgeblendeten Spalten wieder ein – und können wir das Ein- und Ausblenden noch komfortabler gestalten<\/p>\n Dazu bauen wir im Prinzip den Dialog nach, den Access für den Kontextmenü-Eintrag Felder wieder einblenden <\/b>anzeigt (siehe Screenshot weiter oben).<\/p>\n Zunächst benötigen wir dazu eine VBA-Funktion, die beim Anklicken des dazu bereits angelegten Kontextmenü-Eintrags ausgeführt wird.<\/p>\n Die Funktion sieht wie in Listing 3 aus und öffnet mit der DoCmd.OpenForm<\/b>-Methode das Formular frmFelderEinAusblenden<\/b> als modalen Dialog. Dabei übergibt die Funktion per öffnungsargument den Namen des aufrufenden Formulars an das Formular frmFelderEinAusblenden<\/b>.<\/p>\n Listing 3: Aufrufen des Formulars zum Ein- und Ausblenden von Spalten<\/span><\/b><\/p>\n Dieses Formular sieht im Entwurf wie in Bild 6 aus. Es enthält nur zwei Steuerelemente: ein Kontrollkästchen namens Anzeigen <\/b>und ein Textfeld namens Feldname <\/b>mit jeweils gleichnamigen Steuerelementinhalten.<\/p>\n Bild 6: Entwurf des Formulars frmFelderEinAusblenden<\/span><\/b><\/p>\n Damit kommen wir gleich zur Datenherkunft: Diese besteht aus einer Abfrage, welche die Tabelle tblFelder <\/b>als Datenquelle einsetzt (s. Bild 7). Diese Tabelle enthält die folgenden Felder:<\/p>\n Bild 7: Entwurf der Tabelle tblFelder<\/span><\/b><\/p>\n Die Abfrage auf Basis dieser Tabelle enthält alle Felder der Tabelle, sortiert die Datensätze aber zusätzlich nach dem Wert des Feldes ReihenfolgeID<\/b> (s. Bild 8). Dies geschieht, damit die Datensätze später im Formular in der gleichen Reihenfolge angezeigt werden können wie im Originalformular.<\/p>\n Bild 8: Datenherkunft des Formulars frmFelderEinAusblenden<\/span><\/b><\/p>\n Für das Formular stellen Sie außerdem die Eigenschaft Standardansicht <\/b>auf Endlosformular <\/b>und Navigationsschaltflächen <\/b>und Datensatzmarkierer <\/b>auf Nein <\/b>ein. Außerdem soll das Formular keinen neuen Datensatz anzeigen, daher erhält die Eigenschaft Anfügen zulassen <\/b>ebenfalls den Wert Nein<\/b>.<\/p>\n Schließlich sollten Sie aus optischen Gründen noch die alternierende Hintergrundfarbe auf Weiß einstellen (gilt nur für neuere Access-Versionen).<\/p>\n Füllen des Ein-\/Ausblenden-Formulars<\/b><\/p>\n Die Hauptarbeit bei der Programmierung des Formulars frmFelderEinAusblenden <\/b>liegt im Ermitteln der Datenherkunft für das Formular.<\/p>\n Die Tabelle tblFelder <\/b>ist nämlich noch nicht von vornherein gefüllt, sondern soll erst noch mit den Feldern der Datenblattansicht des Formulars und den entsprechenden Eigenschaften ausgestattet werden.<\/p>\n Diese Aufgabe erledigt die Ereignisprozedur aus Listing 4, die durch das Ereignis Beim Laden <\/b>des Formulars ausgelöst wird. Die Prozedur füllt zunächst die Variable db <\/b>mit einem Verweis auf das aktuelle Database<\/b>-Objekt. Dann leert sie die Tabelle tblFelder<\/b>, die gegebenenfalls noch die Daten vom vorherigen Aufruf des Formulars frmFelderEinAusblenden <\/b>enthält. Beim Aufruf des Formulars hat das aufrufende Formular seinen Namen per öffnungsargument übergeben. Dieses wird nun aus der Eigenschaft OpenArgs <\/b>ausgelesen und in die Variable strFormular <\/b>eingetragen.<\/p>\n Listing 4: Füllen der Datenherkunft des Formulars frmFelderEinAusblenden<\/span><\/b><\/p>\n Da wir in der vorliegenden Prozedur und auch noch in einer weiteren Prozedur auf die Steuerelemente dieses Formulars zugreifen müssen, speichern wir einen Verweis auf dieses Formular in der wie folgt im Kopf des Klassenmoduls Form_frmFelderEinAusblenden <\/b>deklarierten Variablen:<\/p>\n Diese füllt die Prozedur dann mit dem entsprechenden Element der Forms-Auflistung. Nun ermittelt die Prozedur aus der Eigenschaft RecordSource <\/b>die Datenherkunft des Formulars und speichert diese in der Variablen strDatenherkunft<\/b>.<\/p>\n Auf Basis der Datenherkunft erstellt die Prozedur anschließend ein Recordset-Objekt. Da wir allerdings nur an den Feldern der Datenherkunft interessiert sind und nicht an den enthaltenen Daten, wollen wir der Datenherkunft noch die Bedingung 1=2 <\/b>hinzufügen, damit das im Anschluss erstellte Recordset keine Datensätze zurückliefert.<\/p>\n Nun kann es sich bei der Datenherkunft um einen Tabellen- oder Abfragenamen handeln oder auch um eine SELECT<\/b>-Abfrage. Das nun folgende verschachtelte If…Then<\/b>-Konstrukt prüft zunächst, ob die Datenherkunft mit SELECT <\/b>beginnt.<\/p>\n Falls nein, stellt sie dem Ausdruck in strDatenherkunft <\/b>ein SELECT * FROM <\/b>voran und fügt hinten ein WHERE 1=2 <\/b>an. So wird aus tblArtikel <\/b>die Datenherkunft SELECT * FROM tblArtikel WHERE 1=2<\/b>. Enthält strDatenherkunft <\/b>hingegen bereits den Ausdruck WHERE<\/b>, hängt die Prozedur lediglich das Kriterium 1=2 <\/b>mit dem AND<\/b>-Operator an die bestehende WHERE<\/b>-Klausel an.<\/p>\n Nun erstellt die Prozedur ein Recordset auf Basis von strDatenherkunft<\/b> und durchläuft in einer For Each<\/b>-Schleife alle Field<\/b>-Elemente der Fields<\/b>-Auflistung des Recordsets. Wir gehen grundsätzlich davon aus, dass ein Feld eingeblendet werden soll und stellen die Variable bolAnzeigen <\/b>auf den Wert True <\/b>ein. Außerdem legen wir für die Reihenfolge den Wert 0 <\/b>fest – für den Fall, dass diese nicht ermittelt werden kann.<\/p>\n Nun durchläuft die Prozedur alle Elemente der Controls<\/b>-Auflistung des Formulars mit der Datenblattansicht. Bei ausgeschalteter Fehlerbehandlung liest die Prozedur dann den Steuerelementinhalt des aktuell mit ctl<\/b> referenzierten Steuerelements in die Variable strControlSource <\/b>ein – oder weist dieser eine leere Zeichenkette für den Fall zu, dass das Steuerelement keinen Steuerelementinhalt <\/b>aufweist.<\/p>\n Dies ist wieder das gleiche Spiel, das Sie bereits weiter oben in ähnlicher Form kennengelernt haben: Nun prüft die Prozedur nämlich, ob der Steuerelementinhalt <\/b>des aktuellen Steuerelements mit dem Namen des aktuell mit fld <\/b>referenzierten Feldes der Datenherkunft übereinstimmt. Falls ja, stellt die Prozedur den Wert von bolAnzeigen <\/b>auf den negierten Wert der Eigenschaft ColumnHidden <\/b>des Steuerelements und somit der entsprechenden Spalte im Formular ein. intReihenfolge <\/b>erhält den Wert der Eigenschaft Column-Order <\/b>des Steuerelements.<\/p>\n Für Steuerelemente, deren Reihenfolge nicht ermittelt werden konnte, stellt die Prozedur den Wert 100 <\/b>für intReihenfolgeID <\/b>ein. In diesem Fall verlässt die Prozedur nun die innere For Each<\/b>-Schleife über die Steuerelemente des Formulars.<\/p>\n Nun hat die Prozedur die erforderlichen Informationen zusammen, um einen Datensatz in die Tabelle tblFelder <\/b>zu schreiben. Dies geschieht mit einer INSERT INTO<\/b>-SQL-Anweisung, die in einem Beispiel etwa so aussieht:<\/p>\n Das Feld Anzeigen <\/b>des Datensatzes für das Feld ArtikelID <\/b>erhält den Wert 0<\/b>, was bedeutet, dass das Feld aktuell ausgeblendet ist. Die Reihenfolge ist gegenüber der Originalreihenfolge verändert, weshalb das Feld ReihenfolgeID <\/b>den Wert 2 <\/b>enthält und nicht 1<\/b>. Die Anweisung für die folgende Spalte sieht etwa wie folgt aus:<\/p>\n Damit hätten wir auch gleich das Feld, das als erste Spalte angezeigt wird. Das Feld Anzeigen <\/b>erhält den Wert -1<\/b>, die Spalte ist also aktuell eingeblendet.<\/p>\n Nach dem Durchlaufen aller Felder der Datenherkunft des aufrufenden Formulars, hier frmArtikel<\/b>, aktualisiert die Prozedur noch die Datenherkunft des Formulars frmFelderEinAusblenden <\/b>mit der Requery<\/b>-Methode.<\/p>\n Das Ergebnis sieht nun wie in Bild 9 aus – die nicht sichtbaren Spalten werden ohne Haken im Kontrollkästchen angezeigt.<\/p>\n\n
![\"Komfortables](\"..\/fileadmin\/_temp_\/2014_03\/pic_936_002.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2014_03\/pic_936_003.png\")
<\/p>\n![\"Ereignis,](\"..\/fileadmin\/_temp_\/2014_03\/pic_936_004.png\")
<\/p>\nPrivate Sub <\/span>Form_MouseDown(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n Dim <\/span>cbc As <\/span>CommandBarButton\r\n Dim <\/span>strKontextmenue As String<\/span>\r\n Select Case Button\r\n Case <\/span>2\r\n strKontextmenue = \"cbrDatenblatt\"\r\n On Error Resume Next<\/span>\r\n CommandBars(strKontextmenue).Delete\r\n On Error GoTo<\/span> 0\r\n Set<\/span> cbr = CommandBars.Add(strKontextmenue, msoBarPopup, False, True<\/span>)\r\n Set<\/span> cbc = cbr.Controls.Add(msoControlButton)\r\n With<\/span> cbc\r\n .Caption = \"Spalten ausblenden\"\r\n .OnAction = \"=SpaltenAusblenden()\"\r\n End With<\/span>\r\n Set<\/span> cbc = cbr.Controls.Add(msoControlButton)\r\n With<\/span> cbc\r\n .Caption = \"Spalten bearbeiten\"\r\n .OnAction = \"=SpaltenDialog()\"\r\n End With<\/span>\r\n cbr.ShowPopup\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2014_03\/pic_936_005.png\")
<\/p>\nPublic Function <\/span>SpaltenAusblenden()\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>strControlsource As String<\/span>\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n For Each ctl In Me.Controls\r\n On Error Resume Next<\/span>\r\n strControlsource = \"\"\r\n strControlsource = ctl.ControlSource\r\n On Error GoTo<\/span> 0\r\n If <\/span>Len<\/span>(strControlsource) > 0 Then<\/span>\r\n For Each fld In Me.Recordset.Fields\r\n If <\/span>strControlsource = fld.Name Then<\/span>\r\n If <\/span>ctl.ColumnOrder >= Me.SelLeft<\/span> - 1 And ctl.ColumnOrder < Me.SelLeft<\/span> + Me.SelWidth - 1 Then<\/span>\r\n ctl.ColumnHidden = True<\/span>\r\n End If<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n Next<\/span> fld\r\n End If<\/span>\r\n Next<\/span> ctl\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>SpaltenDialog()\r\n DoCmd.OpenForm \"frmFelderEinAusblenden\", WindowMode:=acDialog, OpenArgs:=Me.Name\r\nEnd Function<\/span><\/pre>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2014_03\/pic_936_006.png\")
<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2014_03\/pic_936_007.png\")
<\/p>\n\n
![\"Datenherkunft](\"..\/fileadmin\/_temp_\/2014_03\/pic_936_008.png\")
<\/p>\nPrivate Sub <\/span>Form_Load()\r\n Dim <\/span>db As <\/span>DAO.Data8String\r\n Dim <\/span>intReihenfolgeID As Integer<\/span>\r\n Dim <\/span>strControlsource As String<\/span>\r\n Dim <\/span>ctl As <\/span>Control\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblFelder\", dbFailOnError\r\n strFormular = Me.OpenArgs\r\n Set<\/span> frm = Forms(strFormular)\r\n strDatenherkunft = Forms(strFormular).RecordSource\r\n Set<\/span> rst = db.OpenRecordset(strDatenherkunft, dbOpenDynaset)\r\n If <\/span>InStr<\/span>(1, strDatenherkunft, \" WHERE \") = 0 Then<\/span>\r\n If <\/span>Not<\/span> Left<\/span>(strDatenherkunft, 7) = \"SELECT \" Then<\/span>\r\n strDatenherkunft = \"SELECT * FROM \" & strDatenherkunft & \" WHERE 1=2\"\r\n End If<\/span>\r\n Else<\/span>\r\n strDatenherkunft = strDatenherkunft & \" AND 1=2\"\r\n End If<\/span>\r\n For Each fld In rst.Fields\r\n bolAnzeigen = True<\/span>\r\n intReihenfolgeID = 0\r\n For Each ctl In frm.Controls\r\n On Error Resume Next<\/span>\r\n strControlsource = \"\"\r\n strControlsource = ctl.ControlSource\r\n If <\/span>strControlsource = fld.Name Then<\/span>\r\n bolAnzeigen = Not<\/span> ctl.ColumnHidden\r\n intReihenfolgeID = ctl.ColumnOrder\r\n If <\/span>intReihenfolgeID = 0 Then<\/span>\r\n intReihenfolgeID = 100\r\n End If<\/span>\r\n Exit For<\/span>\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n Next<\/span> ctl\r\n db.Execute \"INSERT INTO tblFelder(Feldname, Anzeigen, ReihenfolgeID) VALUES(''\" & fld.Name & \"'', \" _\r\n & CInt(bolAnzeigen) & \", \" & intReihenfolgeID & \")\", dbFailOnError\r\n Next<\/span> fld\r\n Me.Requery\r\nEnd Sub<\/span><\/pre>\nDim <\/span>frm As <\/span>Form<\/pre>\nINSERT INTO tblFelder(Feldname, Anzeigen, ReihenfolgeID) VALUES(''ArtikelID'', 0, 2)<\/pre>\nINSERT INTO tblFelder(Feldname, Anzeigen, ReihenfolgeID) VALUES(''Artikelname'', -1, 1)<\/pre>\n![\"Das](\"..\/fileadmin\/_temp_\/2014_03\/pic_936_009.png\")
<\/p>\n