<\/p>\n
Wer seinen Anwendern eine Freude machen möchte, liefert ihnen eine ergonomische Anwendung. Ein Faktor, der dazu beitragen kann, ist das Speichern der Position und Größe von Elementen der Benutzeroberfläche und das Wiederherstellen beim erneuten Öffnen. Wie das für Formulare funktioniert, zeigt dieser Beitrag.<\/b><\/p>\n
Die Position eines Formulars speichern und wiederherstellen Das kann Access doch wohl allein, oder Nein, kann es nicht: Bestenfalls erscheint das Anwendungsfenster von Access an der gleichen Stelle, wenn Sie es erneut öffnen, aber bei der Anzeige von Formularen müssen Sie schon nachhelfen.<\/p>\n
Zunächst einmal gibt es verschiedene Möglichkeiten, die Position eines Formulars grundsätzlich zu beeinflussen.<\/p>\n
Die einfachste Variante ist das Einstellen der Eigenschaft Automatisch zentrieren <\/b>auf den Wert Ja<\/b>, was dazu führt, dass Access ein Formular nach dem Öffnen in der Mitte des Access-Fensters anzeigt (siehe Bild 1).<\/p>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2009_04\/FormularpositionSpeichern-web-images\/pic001_opt.jpeg\")
<\/p>\n
Bild 1: Einstellen der Eigenschaft Automatisch zentrieren<\/span><\/b><\/p>\n Eine weitere Möglichkeit ist das Maximieren des Formulars gleich nach dem Öffnen. Dazu legen Sie eine Prozedur für das Ereignis Beim Öffnen <\/b>des Formulars an, die wie folgt aussieht:<\/p>\n Das ist nicht immer praktisch, weil die Maximierung sich auch auf alle anderen, nicht als modaler Dialog geöffneten Elemente wie Formulare und Berichte auswirkt.<\/p>\n Auch die Position und die Größe lässt sich mit einer einzigen Anweisung festlegen, und zwar mit der DoCmd<\/b>-Methode MoveSize<\/b>. Die folgende Anweisung etwa schiebt das Formular nach ganz links oben und macht es 5.000 x 5.000 Twips groß:<\/p>\n Wenn Sie einen oder mehrere Werte nicht angeben, behält das Formular die bestehende Position in x- oder y-Richtung beziehungsweise die Breite oder Höhe bei. Für viele Fälle mag es schon ausreichen, wenn ein neues Fenster nicht irgendwo am Rand erscheint, sondern zentriert oder an einer fest definierten Position angezeigt wird. Das gilt insbesondere für modale Dialoge, deren besondere Eigenschaft es ja ist, keinen Zugriff auf die übrigen Elemente der Benutzeroberfläche zuzulassen, bis das Formular wieder geschlossen wurde.<\/p>\n Ganz anders sieht es aus, wenn Sie ein Formular mit ergänzenden Informationen zum aktuell angezeigten Formular öffnen oder wenn ein weiteres Formular Funktionen liefert, die sich auf bereits geöffnete Elemente der Benutzeroberfläche auswirken.<\/p>\n Ein Beispiel ist ein Dialog, der von einem Formular in der Datenblattansicht aus geöffnet wird und einige Suchfelder für dieses Formular anbietet. Dieses möchte der Benutzer vermutlich so anordnen, dass es die für ihn interessanten Spalten oder Zeilen des Suchergebnisses nicht verdeckt.<\/p>\n Wenn der Benutzer diese Suche oft verwendet, möchte er das Formular sicher nicht jedes Mal wieder verschieben, sodass Sie ihm diese Arbeit abnehmen und die Position beim Schließen speichern und sie beim nächsten Öffnen wiederherstellen.<\/p>\n Der Einfachheit halber verwenden wir zu Beispielzwecken einfache Formulare ohne Anzeige von Daten und ohne Suchfunktion. Das erste Formular namens frmBasis <\/b>ruft dabei das zweite Formular frmOnTop <\/b>auf und stellt dieses so ein, dass es immer über dem ersten Formular angezeigt wird, auch wenn es den Fokus verliert. Alle Grundlagen dazu finden Sie im Beitrag Formulare im Blickpunkt <\/b>(Shortlink 654).<\/p>\n Ganz oben<\/b><\/p>\n Damit das Formular frmOnTop <\/b>immer über dem aufrufenden Formular frmBasis <\/b>angezeigt wird, der Benutzer aber immer noch auf die Steuerelemente von frmBasis <\/b>zugreifen kann, sind die folgenden Schritte nötig:<\/p>\n Der erste Schritt wäre damit geschafft. Die folgenden Schritte könnten wir zwar auch mit einem ganz normal geöffneten Formular durchführen, aber mit der vorliegenden Konstellation haben Sie gleich die Grundlage für praktische Einsatzzwecke.<\/p>\n Position speichern<\/b><\/p>\n Nun soll beim Schließen des Formulars seine Position gespeichert werden. Nur, wohin speichern wir diese Die Antwort ist nicht ganz trivial und hängt von den Gegebenheiten ab. Falls es sich um eine Desktop-Anwendung für einzelne Arbeitsplätze handelt, schreiben wir die Daten einfach in eine lokale Tabelle.<\/p>\n Wenn es sich um eine Frontend-Backend-Lösung handelt, bei der jeder Benutzer sein eigenes Frontend verwendet, speichern wir die Formularposition in einer Tabelle im Frontend. Eventuell greifen aber auch mehrere Benutzer auf das gleiche Frontend zu und wollen alle individuellen Positionen speichern – hier werden die Daten am besten in einer Tabelle im Backend abgelegt, die gleichzeitig einen Verweis auf den Benutzer speichert.<\/p>\n Wir halten das Beispiel einfach und gehen von der Einzelplatz-Anwendung und der Speicherung der Positionen in einer einfachen Tabelle aus. Diese heißt tblPositionen <\/b>und besitzt die in Bild 2 abgebildeten sechs Felder. Legen Sie außerdem einen eindeutigen Index für das Feld Formularname <\/b>fest, um zu verhindern, dass für ein Formular gleich mehrere Positionen gespeichert werden können (siehe Bild 3).<\/p>\n Bild 2: Diese Tabelle speichert die Formularpositionen<\/span><\/b><\/p>\n Bild 3: Der eindeutige Schlüssel verhindert, dass mehr als eine Position je Formular gespeichert wird.<\/span><\/b><\/p>\n <\/p>\n Die Position soll beim Schließen des Formulars gespeichert werden, also kommt zum Beispiel das Ereignis Beim Schließen <\/b>infrage. Fügen wir dort also eine Anweisung ein, welche die aktuelle Position des Formulars in einem Datensatz der Tabelle tblFormularpositionen <\/b>speichert.<\/p>\n Uups – woher bekommt man denn eigentlich die Höhe, Breite, linke und obere Position des Formulars und brauchen wir eigentlich die absoluten Koordinaten oder soll die Formularposition in Abhängigkeit von der Position des Access-Fensters gespeichert werden Wir gehen in diesem Fall davon aus, dass wir die Position in Abhängigkeit vom Access-Fenster speichern.<\/p>\n Zum besseren Verständnis der nachfolgenden Erläuterung dient Abb. 4. xA <\/b>und yA <\/b>definieren den Abstand vom linken und oberen Bildschirmrand zum linken und oberen Rand des Access-Fensters. xF <\/b>und yF <\/b>entsprechen der Entfernung des Formulars vom linken und oberen Bildschirmrand. Aus der Differenz von xF <\/b>und xA <\/b>erhalten Sie die Position des Formulars innerhalb des Access-Fensters. dx <\/b>und dy <\/b>geben die Höhe und Breite des Formulars an.<\/p>\n Bild 4: Wichtige Maße beim Speichern und Wiederherstellen von Formularpositionen<\/span><\/b><\/p>\n Um diese Informationen mit geeigneten API-Funktionen zu erhalten, brauchen wir einen speziellen Datentyp, der über die API-Funktionen gefüllt wird. Diese enthält den Abstand des linken Fensterrands zum linken Bildschirmrand, den Abstand des oberen Fensterrands zum oberen Bildschirmrand, den Abstand des rechten Bildschirmrands zum linken Fensterrand und den Abstand des unteren Fensterrands zum oberen Bildschirmrand:<\/p>\n Die API-Funktion GetWindowRect <\/b>erwartet ein Handle auf das Fenster, dessen Koordinaten Sie in diese Struktur einlesen möchten. Ein Handle ist schlicht und einfach ein Long<\/b>-Wert von Windows, der das Fenster identifiziert.<\/p>\n Das Handle für ein Formular erhalten Sie über seine Eigenschaft hWnd<\/b>, das Handle für das Access-Fenster über den Ausdruck Application.hWndAccessApp<\/b>.<\/p>\n Die API-Funktion GetWindowRect <\/b>und den Datentyp Rect <\/b>deklarieren Sie am besten in einem Standardmodul (in der Beispieldatenbank mdlFormularposition<\/b>).<\/p>\n Wenn Sie die API-Funktion aufrufen möchten, müssen Sie zuvor eine Variable deklarieren, die den Typ des oben festgelegten Datentyps Rect <\/b>aufweist, und diese nebst dem Fensterhandle der API-Funktion als Parameter übergeben. Diese füllt dann die Variable des Typs Rect<\/b>, sodass Sie anschließend über die Eigenschaften Left<\/b>, Right<\/b>, Top <\/b>und Bottom <\/b>auf die Koordinaten zugreifen können.<\/p>\n Die Funktion aus Listing 1 erwartet einen Verweis auf ein Formular (frm<\/b>) und vier weitere Parameter zum Zurückgeben der Position (sngLeft<\/b>, sngTop<\/b>) und der Größe (sngWidth<\/b>, sngHeight<\/b>) des Formulars.<\/p>\n Listing 1: Diese Funktion holt die Koordinaten des angegebenen Formulars.<\/p>\n Sie deklariert zwei Rect<\/b>-Variablen zum Speichern der Koordinaten des übergebenen Formulars sowie des Accessfensters. Diese werden durch zwei Aufrufe der API-Funktion GetWindowRect <\/b>gefüllt. Die letzten vier Zeilen berechnen aus den so gewonnenen Werten die Informationen in der gewünschten Form, nämlich als linken und oberen Abstand des Formulars vom Access-Rand und als Höhe und Breite des Formulars.<\/p>\n Die Funktion GetFormPosition <\/b>soll beim Schließen des Formulars in der Ereignisprozedur Form_Close <\/b>aufgerufen und ausgewertet werden. Die entsprechende Prozedur finden Sie in Listing 2. Die Routine deklariert die vier für den Aufruf der Funktion GetFormPosition <\/b>notwendigen Variablen sngLeft<\/b>, sngTop<\/b>, sngWidth <\/b>und sngHeight <\/b>und lässt diese dann füllen.<\/p>\n Listing 3: Beim Öffnen eines Formulars soll dessen gespeicherte Position und Größe wiederhergestellt werden.<\/p>\n Der Rest ist kein Hexenwerk mehr: Die erste SQL-Execute-Anweisung versucht, einen neuen Datensatz in der Tabelle tblFormularpositionen <\/b>anzulegen. Gelingt dies nicht, weil bereits ein Datensatz mit dem gleichen Formularnamen vorhanden ist, löst dies Fehler 3022 <\/b>aus – und der wird gleich im Anschluss abgefangen, indem die Routine die Daten des vorhandenen Datensatzes für das Formular überschreibt.<\/p>\n Der Inhalt der Tabelle tblFormularpositionen<\/b> sieht nun beispielsweise wie in Bild 5 aus.<\/p>\n Bild 5: Die Tabelle tblFormularpositionen mit den Daten eines Formulars<\/span><\/b><\/p>\n Position wiederherstellen<\/b><\/p>\n Beim Wiederherstellen der Position auf Basis der in der Tabelle gespeicherten Daten kommt die Ereignisprozedur Beim Öffnen <\/b>des Formulars zum Einsatz. Diese sieht wie in Listing 3 aus und öffnet zunächst eine Datensatzgruppe auf Basis der Tabelle tblFormularpositionen<\/b>. Die WHERE<\/b>-Bedingung sorgt dafür, dass die Datensatzgruppe als einzigen Datensatz den für den angegebenen Formularnamen gespeicherten liefert. Gegebenenfalls bleibt die Datensatzgruppe auch leer – in diesem Fall sind Position und Größe zuvor noch nicht gespeichert worden.<\/p>\n Falls die Routine einen passenden Datensatz findet, schreibt sie die Koordinaten und die Breite in die Variablen sngTop<\/b>, sngLeft<\/b>, sngWidth <\/b>und sngHeight <\/b>und übergibt diese nebst einem Objektverweis auf sich selbst (also das aufrufende Formular) an die Funktion SetFormPosition<\/b>. Diese deklariert wiederum eine Rect<\/b>-Variable für die Koordinaten des Access-Fensters und füllt diese über deren Handle. Der Grund für die Notwendigkeit dieser Koordinaten liegt in der API-Funktion MoveWindow<\/b>, die wir für das Positionieren und Anpassen des Formulars verwenden. Diese Funktion erwartet die absoluten Werte, also jeweils vom oberen und linken Bildschirmrand aus gemessen. Die Funktion wird so deklariert (in einer Zeile):<\/p>\n Nach dem Ermitteln der Koordinaten des Access-Fensters modifiziert die Routine SetFormPosition <\/b>zunächst die aus der Tabelle tblFormularpositionen <\/b>eingelesenen und von der Ereignisprozedur Form_Load <\/b>übergebenen Variablen sngLeft<\/b>, sngTop<\/b>, sngWidth <\/b>und sngHeight<\/b>, sodass aus diesen relativen Werten, die sich auf die Position innerhalb des Access-Fensters beziehen, absolute Angaben in Bezug auf den Bildschirm werden. Erst dann kann die Funktion SetFormPosition <\/b>die API-Routine MoveWindow <\/b>mit den benötigten Informationen füttern und so die alte Position und Größe des Formulars wiederherstellen.<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Das Speichern der Position von Formularen mag auf den ersten Blick unnötiger Aufwand sein, aber wenn Sie die nötigen Routinen einmal in die Anwendung eingearbeitet haben, lohnt es sich: Der Benutzer wird es Ihnen danken, wenn er entsprechende Formulare nicht jedes Mal neu hin- und herschieben oder deren Größe anpassen muss.<\/p>\n In bestimmten Fällen kann es sinnvoll sein, die absolute Position des Formulars zu speichern. Diese Anforderung können Sie durch kleine änderungen an der vorliegenden Lösung leicht umsetzen. In der Beispieldatenbank finden Sie diese Umsetzung bereits: Sie können dort über die Variable bolAbsolut<\/b> in der Ereignisprozedur Beim Schließen <\/b>festlegen, ob die absoluten oder relativen Werte gespeichert werden sollen.<\/p>\n Listing 2: Ermitteln und speichern der Koordinaten beim Schließen des Formulars<\/p>\n<\/td>\n<\/tr>\n Listing 4: Für das Einstellen von Position und Größe ist diese Routine verantwortlich.<\/p>\n<\/td>\n<\/tr>\n Enthaltene Beispieldateien:<\/p>\n FormularpositionSpeichern.mdb<\/p>\nPrivate Sub Form_Open(Cancel As Integer)\r\n DoCmd.Maximize\r\n End Sub<\/pre>\n
DoCmd.MoveSize 0,0,5000,5000<\/pre>\n
\n
Private Sub Form_Open(Cancel As Integer)\r\n SetWindowOnTop Me.hwnd\r\n End Sub<\/pre>\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2009_04\/FormularpositionSpeichern-web-images\/pic002_opt.jpeg\")
<\/p>\n![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2009_04\/FormularpositionSpeichern-web-images\/pic003_opt.jpeg\")
<\/p>\n![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2009_04\/FormularpositionSpeichern-web-images\/pic004_opt.jpeg\")
<\/p>\nPrivate Type Rect\r\nLeft As Long\r\nTop As Long\r\nRight As Long\r\nBottom As Long\r\nEnd Type<\/pre>\n
Private Declare Function GetWindowRect\r\nLib \"USER32\" (ByVal hWnd As Long, lpRect As Rect) As Long<\/pre>\n
Public Function GetFormPosition(frm As Form, sngLeft As Single, _\r\n sngTop As Single, sngWidth As Single, sngHeight As Single)\r\n Dim rectForm As Rect\r\n Dim rectParent As Rect\r\n GetWindowRect frm.hWnd, rectForm\r\n GetWindowRect Application.hWndAccessApp, rectParent\r\n sngLeft = rectForm.Left - rectParent.Left\r\n sngTop = rectForm.Top - rectParent.Top\r\n sngWidth = rectForm.Right - rectParent.Left - rectForm.Left\r\n sngHeight = rectForm.Bottom - rectParent.Top - rectForm.Top\r\nEnd Function<\/pre>\n
Private Sub Form_Open(Cancel As Integer)\r\n Dim db As DAO.Database\r\n Dim rst As DAO.Recordset\r\n Dim sngLeft As Single\r\n Dim sngTop As Single\r\n Dim sngWidth As Single\r\n Dim sngHeight As Single\r\n SetWindowOnTop Me.hwnd\r\n Set db = CurrentDb\r\n Set rst = db.OpenRecordset(\"SELECT * FROM tblFormularpositionen WHERE Formularname = €€ _\r\n & Me.Name & \"€™€, dbOpenDynaset)\r\n Do While Not rst.EOF\r\n sngLeft = rst!PositionLinks\r\n sngTop = rst!PositionOben\r\n sngWidth = rst!PositionBreite\r\n sngHeight = rst!PositionHoehe\r\n mdlFormularposition.SetFormPosition Me, sngLeft, sngTop, sngWidth, sngHeight\r\n rst.MoveNext\r\n Loop\r\n End Sub<\/pre>\n
![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2009_04\/FormularpositionSpeichern-web-images\/pic005_opt.jpeg\")
<\/p>\nPrivate Declare Function MoveWindow\r\nLib \"USER32\" (ByVal hWnd As Long,\r\nByVal X As Long, ByVal Y As Long,\r\nByVal nWidth As Long,\r\nByVal nHeight As Long,\r\nByVal bRepaint As Long) As Long<\/pre>\n
\n\n
\n \n \n \n Private Sub Form_Close()\r\n Dim db As DAO.Database\r\n Dim sngLeft As Single\r\n Dim sngTop As Single\r\n Dim sngWidth As Single\r\n Dim sngHeight As Single\r\n mdlFormularposition.GetFormPosition Me, sngLeft, sngTop, sngWidth, sngHeight\r\n Set db = CurrentDb\r\n On Error Resume Next\r\n db.Execute \"INSERT INTO tblFormularpositionen(Formularname, PositionLinks, PositionOben,\r\n PositionBreite, PositionHoehe) VALUES(€€ & Me.Name & \"€™, \" & sngLeft & \", \" & sngTop\r\n & \", \" & sngWidth & \", \" & sngHeight & \")€, dbFailOnError\r\n If Err.Number = 3022 Then\r\n db.Execute \"UPDATE tblFormularpositionen SET PositionLinks = \" & sngLeft & \", PositionOben\r\n = \" & sngTop & \", PositionBreite = \" & sngWidth & \", PositionHoehe = \" & sngHeight\r\n & \" WHERE Formularname = €€ & Me.Name & \"€™€, dbFailOnError\r\n End If\r\n End Sub<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
\n\n
\n \n \n \n Public Function SetFormPosition(frm As Form, sngLeft As Single, sngTop As Single, _\r\n sngWidth As Single, sngHeight As Single)\r\n Dim rectParent As Rect\r\n GetWindowRect Application.hWndAccessApp, rectParent\r\n sngLeft = sngLeft + rectParent.Left\r\n sngTop = sngTop + rectParent.Top\r\n sngWidth = sngWidth + rectParent.Left\r\n sngHeight = sngHeight + rectParent.Top\r\n MoveWindow frm.hWnd, sngLeft, sngTop, sngWidth, sngHeight, True\r\nEnd Function<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Downloads zu diesem Beitrag<\/h3>\n