<\/p>\n
Im Beitrag „Neue Datensätze oben anfügen“ haben wir uns angesehen, wie Sie ein Unterformular in der Datenblattansicht, das nur einen leeren, neuen Datensatz anzeigt, über einem normalen Datenblatt mit den Daten der gleichen Tabelle platzieren. Damit erhält der Benutzer die Möglichkeit, einen Datensatz oben einzufügen und nicht, wie sonst üblich, unten. Das Problem hierbei ist, dass der Benutzer immer noch die Spalten des oberen Formulars anders anordnen oder ihre Breite ändern kann. Das wirkt sich nicht automatisch auf die Spalten des darunter positionierten Formulars aus. Also müssen wir noch ein wenig Arbeit investieren, um dieses Verhalten zu dieser Lösung hinzuzufügen.<\/b><\/p>\n
Wir rufen uns zuerst noch einmal die Konstellation der Lösung aus dem Beitrag Neue Datensätze oben anfügen <\/b>(www.access-im-unternehmen\/1160<\/b>) ins Gedächtnis. Hier haben wir ganz oben im Formular frmArtikel <\/b>ein Unterformular mit geringer Höhe platziert, welches nur die Spaltenköpfe sowie eine einzige Zeile anzeigen soll, die den neuen, leeren Datensatz anzeigt, der sonst unten im Datenblatt angezeigt wird (siehe Bild 1).<\/p>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2019_02\/pic_1169_001.png\")
<\/p>\n
Bild 1: Entwurf der beiden übereinander angeordneten Unterformulare in der Datenblattansicht<\/span><\/b><\/p>\n Wenn wir in die Formularansicht wechseln, sehen wir, dass das obere Unterformular genau so platziert ist, dass die Spaltenüberschriften des unteren Unterformulars nicht zu sehen sind. Dadurch erscheint die Ansicht so, als ob es sich tatsächlich nur um ein Formular in der Datenblattansicht handelt, bei dem die Zeile zum Einfügen eines neuen Datensatzes ganz oben angezeigt wird (siehe Bild 2).<\/p>\n Bild 2: Formularansicht der beiden Unterformulare in der Datenblattansicht<\/span><\/b><\/p>\n Wenn wir nun allerdings die Breiten der Spaltenüberschriften ändern oder deren Anordnung ändern, wirkt sich dies nur auf die Spaltenköpfe selbst und die Zeile mit dem neuen Datensatz im oberen Unterformular aus (siehe Bild 3). Das Verhalten ist ganz normal, denn das untere Unterformular weiß ja nichts vom oberen Unterformular.<\/p>\n Bild 3: Das Anpassen der Spaltenköpfe wirkt sich nicht auf das untere Formular aus.<\/span><\/b><\/p>\n Wenn wir wollen, dass die Spalten des unteren Unterformulars synchron mit den Spalten des oberen Unterformulars geändert werden, müssen wir die Ereignisse identifizieren, die beim ändern der Spaltenbreiten und beim ändern der Reihenfolge der Spalten ausgelöst werden. Wie finden wir diese heraus<\/p>\n Falls uns kein Ereignis aufgrund seines Namens auffällt, legen wir für die möglichen Ereignisse jeweils eine Ereignisprozedur an und fügen darin entweder eine Debug.Print<\/b>-Anweisung ein, die den Namen der Ereignisprozedur ausgibt, oder fügen Haltepunkte zu den jeweiligen Prozedurköpfen hinzu.<\/p>\n Hier kommen die folgenden Ereigniseigenschaften in Frage:<\/p>\n Also hinterlegen wir testweise die folgenden Ereignisprozeduren für die Ereigniseigenschaften:<\/p>\n Hier erkennen wir dann, dass diese Ereignisse immer ausgelöst werden, wenn der Benutzer auf einen der Bereiche mit Ausnahme der Felder zur Eingabe der Daten eine Aktion mit der Maus ausführt – also in den Spaltenköpfen, im Datensatzmarkierer und in dem grauen Bereich links von den Spaltenköpfen und oberhalb des Datensatzmarkierers.<\/p>\n <\/p>\n Bevor nun losprogrammieren, müssen wir noch festlegen, wann die Spalten des unteren Unterformulars an die des oberen Unterformulars angepasst werden sollen. Erledigen wir dies nur, wenn der Benutzer eine Aktion zum Vergrößern oder Verkleinern der Breite oder zum Verschieben einer Spalte durchgeführt hat (also beim Ereignis Bei Maustaste auf<\/b>) oder immer, wenn der Benutzer die Maus bewegt Wir entscheiden uns zunächst für die erstere Methode. Wenn wir dann tatsächlich die Synchronisierung zu jedem Zeitpunkt ausprobieren wollen, brauchen wir die entsprechenden Anweisungen ja nur noch in das Ereignis Bei Mausbewegung <\/b>einzufügen.<\/p>\n Der Ereignisprozedur Bei Maustaste auf <\/b>fügen wir nun den Aufruf der noch zu programmierenden Prozedur SpaltenSynchronisieren <\/b>hinzu:<\/p>\n Die Prozedur zum Synchronisieren der Spalten könnten wir im oberen Unterformular sfmArtikelNeu<\/b> implementieren. Allerdings müssten wir dann von dort aus das Unterformular, dessen Spalten wir manipulieren wollen, über das übergeordnete Formular referenzieren. Das ist schlechter Programmierstil.<\/p>\n Also programmieren wir diesmal gleich eine Klasse, mit der wir die beiden betroffenen Formulare referenzieren und die wir wiederum im Hauptformular deklarieren und instanzieren. Auf diese Weise haben wir erstens eine sauber programmierte Lösung und zweitens eine Lösung, die wir mit wenigen Zeilen Code in anderen Formularen wiederverwenden können.<\/p>\n Also fügen wir ein Klassenmodul namens clsSpaltenSynchronisieren <\/b>zum VBA-Projekt hinzu. Dieses erhält zwei private deklarierte Variablen, welche die Verweise auf die beiden betroffenen Unterformulare aufnehmen sollen. Beide Variablen versehen wir mit dem Schlüsselwort With-Events<\/b>, damit wir für diese auch Ereignisse in der aktuellen Klasse implementieren können:<\/p>\n Damit die beiden Variablen mit den Verweisen auf die entsprechenden Unterformulare gefüllt werden können, legen wir noch zwei Property Set<\/b>-Prozeduren an:<\/p>\n Für das Formular in m_SubFormNeu <\/b>legen wir noch den Wert [Event Procedure] <\/b>für die Eigenschaft OnMouseUp <\/b>fest. So weiß die Klasse auch, dass das Ereignis hier ausgeführt werden soll.<\/p>\n Damit wir gleich testen können, während wir die Prozedur zum Synchronisieren der Spalten programmieren, fügen wir dem Klassenmodul des Hauptformulars direkt die notwendigen Elemente hinzu. Als Erstes eine Objektvariable für die Klasse objSpaltenSynchronisieren<\/b>:<\/p>\n Dann erweitern wir die Ereignisprozedur Form_Load <\/b>um die folgenden Zeilen, in denen wir clsSpaltenSynchronisieren <\/b>instanzieren und die beiden Eigenschaften für das obere und das untere Unterformular füllen:<\/p>\n In der Klasse clsSpaltenSynchronisieren <\/b>legen wir nun die Ereignisprozedur an, die beim Loslassen der Maustaste auf einem der Spaltenköpfe ausgelöst werden soll. Diese fügen wir für die Objektvariable m_SubFormNeu <\/b>hinzu.<\/p>\n Dazu wählen Sie im linken Kombinationsfeld des Codefensters den Eintrag m_SubFormNeu <\/b>aus und im rechten den Eintrag MouseUp<\/b>. Die so hinzugefügte Ereignisprozedur erweitern wir wie folgt:<\/p>\n Nun schauen wir uns an, wie wir die Prozedur SpaltenSynchronisieren<\/b> programmieren müssen. Diese sieht im ersten Entwurf wie in Listing 1 aus. Hier durchlaufen wir alle Steuerelemente des oberen Unterformulars und prüfen, ob seine Eigenschaft Steuerelementinhalt <\/b>(unter VBA ControlSource<\/b>) einen Wert enthält. Dazu fragen wir die Eigenschaft ControlSource <\/b>ab und tragen den Wert in die Variable strControlSource <\/b>ein.<\/p>\n Treffen wir in der For Each<\/b>-Schleife etwa auf ein Bezeichnungsfeld, führt der Zugriff auf die Eigenschaft ControlSource <\/b>zu einem Fehler, da die Eigenschaft für diesen Steuerelementtyp gar nicht definiert ist.<\/p>\n Deshalb fassen wir die Anweisung zum Abfragen des Steuerelementinhalts in On Error Resume Next <\/b>und On Error Goto 0 <\/b>ein, um für diesen Fall einen Laufzeitfehler zu verhindern. Hat strControlSource<\/b>, das wir vor dem Versuch, es mit der Eigenschaft ControlSource <\/b>zu füllen, noch leeren, danach einen Wert, handelt es sich bei dem aktuellen Steuer-element um ein gebundenes Steuer-element. In diesem Fall prüfen wir, ob es ein Textfeld, ein Kombinationsfeld oder ein Kontrollkästchen ist und weisen es einer Variablen mit dem passenden Typ zu. Dann stellen wir die Eigenschaften ColumnWidth <\/b>und ColumnOrder <\/b>des gleichnamigen Steuerelements im unteren Unterformular auf den Wert der Eigenschaft im oberen Unterformular ein.<\/p>\n Damit gelingen zwei Operationen bereits ohne Probleme: Das Einstellen der Spaltenbreiten im unteren Unterformular nach dem Ziehen der Breite im oberen Unterformular sowie das Einstellen der Reihenfolge nach dem Verschieben eines Elements im oberen Formular.<\/p>\n Es gibt aber noch eine weitere Möglichkeit, die Spaltenbreite einzustellen, und zwar per Doppelklick auf den schmalen Streifen zwischen zwei Spalten. Danach stellt Access die Breite der linken Spalte automatisch auf den optimalen Wert ein – gemessen an den Inhalten der Spaltenüberschrift und der darunter liegenden Datensätze. Nun ergibt sich allerdings das Problem, dass wir, wenn wir nun doppelt auf einen der Spaltenzwischenräume im oberen Formular klicken, nur die Breite der Spalte im oberen Formular optimieren. Dabei kann es natürlich passieren, dass die Breite der Spaltenüberschrift schmaler ist als die Breite der sichtbaren Einträge in der gleichen Spalte des Unterformulars – die Einträge sind dann nicht mehr komplett sichtbar, wie es normalerweise der Fall sein sollte.<\/p>\n Interessant ist jedoch, was dort geschieht: Normalerweise wird die Spaltenbreite auf -2 <\/b>eingestellt, wenn man mit einem Doppelklick auf den Spaltenzwischenraum die optimierte Spaltenbreite erhalten möchte. Wenn wir diesen Wert auf die Spalten im unteren Formular übertragen, müsste dort auch -2 <\/b>eingestellt werden, was aber nicht der Fall zu sein scheint, denn es werden ja nicht alle Einträge komplett angezeigt (wenn die Spaltenüberschrift weniger breit als die Inhalte der Spalte selbst ist). Stattdessen wird die Spalte im Unterformular auf einen Zahlenwert eingestellt, welcher der Breite der Spaltenbreite im oberen Unterformular entspricht, zum Beispiel 1575<\/b>.<\/p>\n Was tun wir, um der automatischen Anpassung der Spaltenbreite in beiden Formularen gerecht zu werden Dazu fügen wir zunächst die folgende Variable zum Klassenmodul hinzu:<\/p>\n![\"Formularansicht](\"..\/fileadmin\/_temp_\/2019_02\/pic_1169_002.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2019_02\/pic_1169_003.png\")
<\/p>\nSpalten synchron halten<\/h2>\n
\n
Private Sub <\/span>Form_Click()\r\n Debug.Print<\/span> \"Beim Klicken\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_MouseDown(Button As Integer<\/span>, _\r\n Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Debug.Print<\/span> \"Bei Maustaste ab\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_MouseMove(Button As Integer<\/span>, _\r\n Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n If <\/span>Not<\/span> Button = 0 Then<\/span>\r\n Debug.Print<\/span> \"Bei Mausbewegung\"\r\n End If<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_MouseUp(Button As Integer<\/span>, _\r\n Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Debug.Print<\/span> \"Bei Maustaste auf\"\r\nEnd Sub<\/span><\/pre>\nWann synchronisieren<\/h2>\n
Private Sub <\/span>Form_MouseUp(Button As Integer<\/span>, _\r\n Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n SpaltenSynchronisieren\r\nEnd Sub<\/span><\/pre>\nProzedur zum Synchronisieren der Spalten<\/h2>\n
Private <\/span>WithEvents m_SubFormNeu As <\/span>Form\r\nPrivate <\/span>WithEvents m_Subform As <\/span>Form<\/pre>\nPublic Property Set<\/span> <\/span>SubformNeu(frm As <\/span>Form)\r\n Set<\/span> m_SubFormNeu = frm\r\n With<\/span> m_SubFormNeu\r\n .OnMouseUp = \"[Event Procedure]\"\r\n End With<\/span>\r\nEnd Property<\/span>\r\nPublic Property Set<\/span> <\/span>Subform(frm As <\/span>Form)\r\n Set<\/span> m_Subform = frm\r\nEnd Property<\/span><\/pre>\nVorbereitung des Hauptformulars<\/h2>\n
Dim <\/span>objSpaltenSynchronisieren As <\/span>clsSpaltenSynchronisieren<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n ...\r\n Set<\/span> objSpaltenSynchronisieren = New<\/span> clsSpaltenSynchronisieren\r\n With<\/span> objSpaltenSynchronisieren\r\n Set<\/span> .Subform = Me!sfmArtikel.Form\r\n Set<\/span> .SubformNeu = Me.sfmArtikelNeu.Form\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nEreignisse in der Klasse clsSpaltenSynchronisieren<\/h2>\n
Private Sub <\/span>m_SubFormNeu_MouseUp(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n SpaltenSynchronisieren\r\nEnd Sub<\/span><\/pre>\nDie Prozedur SpaltenSynchronisieren<\/h2>\n
Automatische Größe per Doppelklick<\/h2>\n
Private <\/span>bolDblClick As Boolean<\/span><\/pre>\n