<\/p>\n
In vielen Anwendungsfällen ist es praktisch, wenn man die gleichen Daten in einer übersichtsliste und auch noch im Detail vorfindet. Unter Access erledigt man das normalerweise mit einem Detailformular, das in einem Unterformular oder auch in einem Listenfeld alle Datensätze der zugrunde liegenden Tabelle zur Auswahl anbietet. Mit Access 2007 hat Microsoft die so genannten geteilten Formulare eingeführt – ein Hybrid aus Detailformular und Datenblattansicht. Dieser Beitrag zeigt, wie Sie ein solches Formular erstellen und welche Möglichkeiten es bietet.<\/b><\/p>\n
Geteiltes Formular anlegen<\/b><\/p>\n
Wenn Sie einer Datenbank ein geteiltes Formular hinzufügen möchten, müssen Sie zunächst die Tabelle oder Abfrage, welche die Daten für das Formular liefert, im Navigationsbereich markieren.<\/p>\n
Anschließend klicken Sie im Ribbon (hier unter Access 2010) auf den Eintrag Er-stel-len|Formulare|Weitere For-mu-la-re|Ge-teiltes Formular <\/b>– s. Bild 1.<\/p>\n
![\"Diese](\"..\/fileadmin\/_temp_\/2014_03\/pic_935_001.png\")
<\/p>\n
Bild 1: Diese Meldung erscheint, wenn Sie ein Memofeld mit der Richtext-Formatierung ausstatten.<\/span><\/b><\/p>\n Das Ergebnis sieht dann wie in Bild 2 aus: Im oberen Bereich finden Sie die Detailansicht eines Datensatzes, der untere Bereich enthält die Datenblattansicht der als Datenherkunft verwendeten Tabelle oder Abfrage. Wenn Sie den Datensatz im Detailbereich oder auch im Datenblatt des Formulars wechseln, geschieht dies synchron auch mit dem Datensatz im jeweils anderen Bereich.<\/p>\n Bild 2: Ein per Assistent erstelltes geteiltes Formular<\/span><\/b><\/p>\n Das Interessante dabei ist: Das Formular enthält, obwohl es scheinbar ein Unterformular enthält, nur eine Navigationsleiste. Außerdem finden Sie einen Markierer vor, mit dem Sie die Höhe der beiden Bereiche einstellen können.<\/p>\n Eigenschaften von geteilten Formularen<\/b><\/p>\n Geteilte Formulare haben sicher einige spezielle Eigenschaften. Um diese zu untersuchen, schauen wir uns das Formular in der Entwurfsansicht an. Dort treffen wir eine überraschung an: Der Entwurf sieht genauso aus wie der eines herkömmlichen Formulars in der Formularansicht (s. Bild 3).<\/p>\n Bild 3: Entwurfsansicht des geteilten Formulars<\/span><\/b><\/p>\n Im nächsten Schritt betrachten wir die Eigenschaften des Formulars – mehr bleibt uns nicht übrig, da es ja anscheinend kein eigenes Steuerelement für das Datenblatt gibt.<\/p>\n Das Eigenschaftsfenster liefert zunächst die Erkenntnis, dass die Einstellung der Eigenschaft Standardansicht auf den Wert Geteiltes Formular <\/b>wohl für die entsprechende Ansicht verantwortlich ist (s. Bild 4).<\/p>\n Bild 4: Eigenschaften des geteilten Formulars<\/span><\/b><\/p>\n Diese Eigenschaft heißt unter VBA DefaultView<\/b>, für ein geteiltes Formular geben Sie hier den Wert 5 <\/b>an.<\/p>\n Höhe des Teilers festlegen<\/b><\/p>\n Aber wir finden dort noch weitere interessante Eigenschaften. Die Eigenschaft Größe des geteilten Formulars <\/b>etwa erwartet einen in Zentimetern angegebenen Wert, der mitteilt, welche Höhe der Detailbereich des Formulars einnehmen soll.<\/p>\n Unter VBA verwenden Sie die Eigenschaft SplitFormSize <\/b>des Formulars. Hier erhalten Sie allerdings einen Wert in der Einheit Twips. Wenn Sie die aktuelle Höhe des Formulars in Twips ermitteln möchten, setzen Sie etwa die folgende Abfrage im Direktbereich von Access ab – das Formular sollte dazu als geteiltes Formular geöffnet sein:<\/p>\n Diesen Wert können Sie auch per VBA einstellen. Interessant wird noch, ob sich der Teiler immer auf die Höhe des Detailbereichs bezieht oder immer auf den jeweils oberen Bereich – dies werden wir im nächsten Abschnitt ermitteln.<\/p>\n Teilerposition<\/b><\/p>\n Die Eigenschaft Position der Teilerleiste speichern <\/b>legt fest, ob die vom Benutzer geänderte vertikale oder horizontale Position der Teilerleiste gespeichert und beim nächsten öffnen des Formulars wiederherstellt werden soll.<\/p>\n Unter VBA nutzen Sie die Eigenschaft SplitFormSplitterBarSave<\/b>, die Sie mit einem Boolean<\/b>-Wert füttern, um dies einzustellen.<\/p>\n Formular ausrichten<\/b><\/p>\n Mit der Eigenschaft Ausrichtung des geteilten Formulars <\/b>stellen Sie ein, ob das Detailformular oder das Datenblatt oben angezeigt wird – oder links oder rechts! Die Eigenschaft nimmt nämlich die folgenden Werte an:<\/p>\n Wenn Sie die Einstellung Datenblatt links <\/b>wählen, sieht das Formular etwa wie in Bild 5 aus.<\/p>\n Bild 5: Aufteilung mit dem Datenblatt auf der linken Seite<\/span><\/b><\/p>\n Durch Experimente mit Kombinationen der beiden Werte Datenblatt oben <\/b>und Datenblatt unten <\/b>für diese Eigenschaft und verschiedener Werte für die Eigenschaft Größe des geteilten Formulars <\/b>erfahren wir auch, dass letztere Eigenschaft die Höhe des Detailbereichs angibt – beziehungsweise bei nebeneinander ausgerichteten Bereichen die Breite des Detailbereiches.<\/p>\n Unter VBA verwenden Sie die Eigenschaft SplitFormOrientation<\/b>, um die Ausrichtung einzustellen. Als Werte können Sie die vier VBA-Konstanten acDatasheetOnBottom<\/b>, acDatasheetOnLeft<\/b>, acDatasheetOnRight <\/b>und acDatasheetOnTop <\/b>verwenden (auch per IntelliSense verfügbar, s. Bild 6).<\/p>\n Bild 6: Einstellen der Ausrichtung des geteilten Formulars per VBA im Direktbereich<\/span><\/b><\/p>\n Teilerleiste ein- und ausblenden<\/b><\/p>\n Mit der Eigenschaft Teilerleiste des geteilten Formulars <\/b>legen Sie fest, ob die Teilerleiste überhaupt angezeigt werden soll. Die Eigenschaft nimmt die beiden Werte Ja <\/b>und Nein <\/b>entgegen. Unter VBA entspricht SplitFormSplitterBar <\/b>dieser Eigenschaft. Hier verwenden Sie entsprechend die Werte True <\/b>und False <\/b>beziehungsweise -1 <\/b>und 0<\/b>.<\/p>\n Datenblatteigenschaften<\/b><\/p>\n Die Eigenschaft Datenblatt des geteilten Formulars <\/b>erwartet einen der Werte Bearbeitungen zulassen <\/b>oder Schreibgeschützt<\/b>. Damit legen Sie fest, ob der Benutzer die Daten auch im Datenblattbereich bearbeiten kann oder nicht.<\/p>\n Die VBA-Variante dieser Eigenschaft heißt SplitFormDatasheet<\/b>. Sie enthält eine der beiden VBA-Konstanten acDatasheetAllowEdits <\/b>oder acDatasheet-ReadOnly<\/b>.<\/p>\n Was drucken<\/b><\/p>\n Die Eigenschaft Drucken des geteilten Formulars <\/b>bietet die beiden Werte Nur Datenblatt <\/b>und Nur Formular <\/b>an. Damit stellen Sie ein, welcher Teil des Formulars beim Ausdrucken auf dem Papier landen soll. Die VBA-Variante heißt SplitFormPrinting <\/b>und erwartet eine der beiden Konstanten acFormOnly <\/b>oder acGridOnly<\/b>.<\/p>\n <\/p>\n Geteiltes Formular als Unterformular<\/b><\/p>\n Wenn Sie ein geteiltes Formular als Unterformular eines anderen Formulars verwenden möchten, werden Sie enttäuscht werden: Dies funktioniert schlicht nicht. Das Formular erscheint dann in der Formularansicht.<\/p>\n Geteiltes Formular manuell erstellen<\/b><\/p>\n Wahrscheinlich sollten Ihre Formular nicht so gestaltet sein wie die vom Assistent für geteilte Formular erstellten Exemplare. Sollten Sie ein solches also von Hand erstellen wollen, gehen Sie wie folgt vor:<\/p>\n Bild 7: Geteiltes Formular im Eigenbau<\/span><\/b><\/p>\n Nach dem Wechsel in die Formularansicht sieht das Formular nun wie in Bild 8 aus.<\/p>\n Bild 8: Selbst gebautes geteiltes Formular in Betrieb<\/span><\/b><\/p>\n Finetuning<\/b><\/p>\n Wir wollen noch die eine oder andere Sache anpassen. Als Erstes sollen im Datenblatt nur die Artikelnamen angezeigt werden, keine weiteren Felder. Sie können dies manuell erreichen, indem Sie die auszublendende Spalte im Datenblatt markieren und dann aus dem Kontextmenü den Eintrag Felder ausblenden <\/b>auswählen (s. Bild 9).<\/p>\n Bild 9: Ausblenden einzelner Spalten des Datenblatts<\/span><\/b><\/p>\n Die Idee ist nun, in der Tag<\/b>-Eigenschaft der gebundenen Felder anzugeben, ob ein Feld in der Datenblattansicht erscheinen soll oder nicht (im Eigenschaftsfenster heißt diese Eigenschaft Marke<\/b>). Dazu soll dort der Ausdruck Datenblatt <\/b>eingetragen werden (s. Bild 10).<\/p>\n Bild 10: Vorbereitung eines Feldes, das in der Datenblattansicht erscheinen soll<\/span><\/b><\/p>\n Nun wollen wir beim öffnen des Formulars eine Prozedur auslösen, welche alle Felder durchläuft und diejenigen, deren Eigenschaft Marke <\/b>den Wert Datenblatt enthält, einzublenden – die übrigen sollen ausgeblendet werden.<\/p>\n Dies können wir nun nicht einfach durch Einstellen der Visible<\/b>-Eigenschaft erreichen, denn diese steuert die Sichtbarkeit der Steuerelemente im Detailbereich des Formulars. Wir benötigen die Eigenschaft ColumnWidth<\/b>, die folgende Werte annimmt:<\/p>\n Wenn Sie beispielsweise nur ein einziges Feld im Datenblatt anzeigen möchten, beispielsweise Artikelname<\/b>, könnten Sie die Breite dieses Feldes auf die Breite des Datenblatt-Bereichs einstellen. Wenn Sie mehrere Felder verwenden, sollten Sie für diese die jeweils optimale Spaltenbreite einstellen, bei der die Spaltenbreite an den breitesten sichtbaren Eintrag angepasst wird.<\/p>\n Wir wollen das Beispiel mit dem Artikelnamen als einziger Spalte ausprobieren. Dazu müssten wir zunächst einmal die Breite des Datenblatt-Bereichs ermitteln. Wir wir wissen, liefert die Eigenschaft SplitFormSize <\/b>die Breite des Detailbereichs. Wir benötigen also nur noch die Gesamtbreite des Formulars und müssen dann von dieser die Breite des Detailbereichs abziehen. Die Breite eines Formulars ermitteln wir mit der Eigenschaft InsideWidth<\/b> des Formulars.<\/p>\n Dies ist interessanterweise genau die Breite des Datenblatts – Access ermittelt also nicht etwa die gesamte Breite des Formulars oder des Detailbereichs, sondern die des Datenblattes.<\/p>\n Damit können wir eine kleine Prozedur zusammenstellen, welche die notwendigen Eigenschaften einstellt. Die Prozedur sieht wie in Listing 1 aus und heißt SteuerelementeAnpassen<\/b>.<\/p>\n Listing 1: Anpassen der Spaltenbreiten in der Datenblattansicht<\/span><\/b><\/p>\n Sie durchläuft zunächst in einer For Each<\/b>-Schleife alle Elemente der Controls<\/b>-Auflistung des Formulars und speichert jeweils einen Verweis auf das aktuelle Steuerelement in einer Variablen namens ctl<\/b>.<\/p>\n Darin deaktiviert die Prozedur zunächst die Fehlerbehandlung. Der Grund ist, dass sie danach die Eigenschaft ControlSource <\/b>des aktuellen Steuerelements abfragt. Dies führt zu einem Fehler, wenn die Eigenschaft nicht vorhanden ist – was vor allem bei Bezeichnungsfeldern der Fall ist. Diese Eigenschaft legt fest, ob es sich um ein gebundenes Steuerelement handelt – nur diese wollen wir untersuchen. Enthält strControlSource <\/b>nun eine Zeichenlänge größer als 0<\/b>, liegt ein gebundenes Steuerelement vor. In diesem Fall prüft die Prozedur, ob die Eigenschaft Tag <\/b>den Wert Datenblatt <\/b>enthält. Diese Einstellung haben wir weiter oben nur für das Feld Artikelname <\/b>vorgenommen, damit dieses als einziges Steuerelement im Datenblatt angezeigt wird.<\/p>\n Ist dies der Fall, stellt die Prozedur den Wert der Eigenschaft ColumnHidden <\/b>auf False <\/b>(was eine eventuell ausgeblendete Spalte wieder einblendet) und stellt die Spaltenbreite mit der Eigenschaft ColumnWidth <\/b>auf Me.InsideWidth – 280 <\/b>ein. Die 280 Twips ziehen wir für die Bildlaufleiste ab. Für alle anderen Spalten erhält die Eigenschaft ColumnHidden <\/b>den Wert True<\/b>.<\/p>\n Nun stellt sich nur noch eine Frage: Wann rufen wir diese Prozedur auf Normalerweise erledigen wir so etwas in der Ereignisprozedur, die durch das Ereignis Beim Laden <\/b>ausgelöst wird:<\/p>\n Ein kurzer Test zeigt allerdings, dass dies die Spaltenbreite offensichtlich nicht beeinflusst – und auch die übrigen Spalten werden nicht ausgeblendet.<\/p>\n Also probieren wir die weiteren üblichen Verdächtigen und platzieren den Aufruf von SteuerelementeAnpassen in den Ereignisprozeduren Form_Open<\/b>, Form_Resize<\/b>, Form_Activate <\/b>und Form_Current<\/b>. Das Ergebnis: Nur beim Aufruf über die Ereignisprozedur Form_Open <\/b>geschieht überhaupt etwas! Die nicht bentötigten Spalten werden ausgeblendet. Allerdings stellt die Prozedur nicht die gewünschte Breite ein, sondern eine viel größere – nämlich etwa die Breite des gesamten Formulars.<\/p>\n Wenn Sie mit der Debug.Print<\/b>-Anweisung in jeder der Ereignisprozeduren Form_Open<\/b>, Form_Load <\/b>und Form_Resize <\/b>den Wert der Eigenschaft InsideWidth <\/b>des Formulars ausgeben, erhalten Sie unterschiedliche Werte.<\/p>\n Bei Form_Open <\/b>scheint InsideWidth <\/b>mit der gesamten Formularbreite übereinzustimmen, bei Form_Load <\/b>der Breite des Detailbereichs und erst bei Form_Resize <\/b>der tatsächlichen Breite des Datenblatts:<\/p>\n Außerdem ist aufgefallen, dass das Form_Resize<\/b>-Ereignis nur ausgelöst wird, wenn sich tatsächlich die Breite des Datenblatts ändert. Wenn Sie das Formular einmal so weit zusammenschieben, bis das Datenblatt den Wert 0 <\/b>für die Eigenschaft InsideWidth <\/b>aufweist, werden Sie feststellen, das Form_Resize <\/b>nicht mehr ausgelöst wird.<\/p>\n Das Zwischenfazit lautet nun aber: Die Spalten werden zwar im Ereignis Form_Load <\/b>ein- und ausgeblendet, die Eigenschaft ColumnWidth <\/b>der Spalte Artikelname erhält jedoch den falschen Wert. Wird die Prozedur SteuerelementeAnpassen <\/b>jedoch durch das Ereignis Form_Resize <\/b>aufgerufen, stellt diese die richtige Breite ein. Außerdem ist noch festzustellen, dass ein Aufruf der Prozedur SteuerelementeAnpassen <\/b>etwa über eine Schaltfläche überhaupt keine Wirkung zeigt.<\/p>\n Wir müssen nun also eine von zwei Aktionen bewirken:<\/p>\n Nach einigen Experimenten kam zum Vorschein, dass auch das Verschieben des Teilerbalkens das Ereignis Form_Resize <\/b>auslöst. Vielleicht können wir einfach durch Einstellen der Eigenschaft SplitFormWidth <\/b>beim öffnen des Formulars dafür sorgen, dass Form_Resize <\/b>ausgelöst wird Nein, das funktioniert auch nicht, da InsideWidth <\/b>zu diesem Zeitpunkt ja noch nicht die Breite des Datenblattes liefert.<\/p>\n Also versuchen wir es, indem wir die Eigenschaft TimerInterval <\/b>im Ereignis Form_Open <\/b>auf 1000 <\/b>einstellen und die Position des Teilerbalkens in dem dadurch eine Sekunde später ausgelösten Ereignis Form_Timer <\/b>neu einzustellen – was wiederum das Ereignis Form_Resize <\/b>auslösten soll.<\/p>\n Bingo – so funktioniert es! Wir müssen nun nur noch die beteiligten Prozeduren anpassen. Die Prozedur Form_Open <\/b>stellt das TimerInterval <\/b>auf 100<\/b> ein (eine Zehntelsekunde sollte reichen):<\/p>\n Die Prozedur Form_Timer <\/b>wird nach 100 Millisekunden ausgelöst und stellt die Eigenschaft SplitFormSize <\/b>einfach auf den aktuellen Wert ein. Dann setzt Sie TimerInterval <\/b>auf 0 <\/b>Sekunden, damit der Timer nach dem ersten Aufruf nicht erneut ausgelöst wird:<\/p>\n![\"Ein](\"..\/fileadmin\/_temp_\/2014_03\/pic_935_002.png\")
<\/p>\n![\"Entwurfsansicht](\"..\/fileadmin\/_temp_\/2014_03\/pic_935_003.png\")
<\/p>\n![\"Eigenschaften](\"..\/fileadmin\/_temp_\/2014_03\/pic_935_004.png\")
<\/p>\n Forms!frmArtikelGeteilt.SplitFormSize\r\n 4995 <\/pre>\n
\n
![\"Aufteilung](\"..\/fileadmin\/_temp_\/2014_03\/pic_935_006.png\")
<\/p>\n![\"Einstellen](\"..\/fileadmin\/_temp_\/2014_03\/pic_935_005.png\")
<\/p>\n\n
![\"Geteiltes](\"..\/fileadmin\/_temp_\/2014_03\/pic_935_007.png\")
<\/p>\n![\"Selbst](\"..\/fileadmin\/_temp_\/2014_03\/pic_935_008.png\")
<\/p>\n![\"Ausblenden](\"..\/fileadmin\/_temp_\/2014_03\/pic_935_009.png\")
<\/p>\n![\"Vorbereitung](\"..\/fileadmin\/_temp_\/2014_03\/pic_935_010.png\")
<\/p>\n\n
Private Sub <\/span>SteuerelementeAnpassen()\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>strControlsource As String<\/span>\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 If <\/span>ctl.Tag = \"Datenblatt\" Then<\/span>\r\n ctl.ColumnHidden = False<\/span>\r\n ctl.ColumnWidth = Me.InsideWidth - 280\r\n Else<\/span>\r\n ctl.ColumnHidden = True<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span> ctl\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Load()\r\n SteuerelementeAnpassen\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Debug.Print<\/span> \"Load: \" _\r\n & Me.InsideWidth\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Debug.Print<\/span> \"Open: \" _\r\n & Me.InsideWidth\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_Resize()\r\n Debug.Print<\/span> \"Resize: \" _\r\n & Me.InsideWidth\r\nEnd Sub<\/span><\/pre>\n\n
Private Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Me.TimerInterval = 100\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Timer()\r\n Me.SplitFormSize = Me.SplitFormSize\r\n Me.TimerInterval = 0\r\nEnd Sub<\/span><\/pre>\n