Größe und Position der geöffneten Objekte ermitteln<\/h2>\n
Die erste Aufgabe ist bereits die anspruchsvollste: Wie können wir alle geöffneten Objekte ermitteln und wie finden wir die aktuelle Position und Größe dieser Objekte heraus?<\/p>\n
Für diese Aufgabe gibt es keine Lösung, mit der wir alle Objekte gleichermaßen behandeln können. So gibt es zwar Auflistungen namens Forms <\/b>und Reports<\/b>, mit denen direkt auf die aktuell geöffneten Formulare und Berichte zugegriffen werden kann.<\/p>\n
Entsprechende Auflistungen für Tabellen und Abfragen beispielsweise namens Tables <\/b>oder Queries <\/b>suchen wir jedoch vergeblich.<\/p>\n
Wenn wir jedoch nach diesen Schlüsselwörtern im Objektkatalog des VBA-Editors suchen, finden wir schnell passende Einträge, nämlich AllTables <\/b>und AllQueries <\/b>(siehe Bild 1).<\/p>\n
![\"Finden](\"..\/fileadmin\/_temp_\/2022_05\/pic_1386_001.png\")
<\/p>\n
Bild 1: Finden von geeigneten Auflistungen für den Zugriff auf Tabellen und Abfragen<\/span><\/b><\/p>\n Damit haben wir zumindest schon einmal Auflistungen für alle Objekttypen gefunden – nun schauen wir uns an, wie wir an die jeweils gewünschten Informationen wie Name, aktuelle Ansicht, Position vom linken und oberen Rand, Höhe und Breite gelangen.<\/p>\n Bei Formularen und Berichten macht Access es uns ein wenig leichter als bei Tabellen und Abfragen, die wir uns im Anschluss anschauen. Mit der Forms<\/b>– und der Reports<\/b>-Auflistung können wir direkt die aktuell geöffneten Objekte referenzieren. Mit der folgenden Prozedur durchlaufen wir beispielsweise alle Formulare, die aktuell geöffnet sind:<\/p>\n Die Werte der Eigenschaften WindowLeft<\/b>, WindowTop<\/b>, WindowWidth <\/b>und WindowHeight <\/b>liefert Access in der Einheit Twips<\/b>. Vorneweg: Diese Eigenschaften sind schreibgeschützt und wir können diese später nicht nutzen, um die Größe und die Position der Formulare und Berichte wiederherzustellen. Allerdings arbeitet auch die Methode, die wir dazu später nutzen werden, mit Angaben in dieser Einheit. Daher verzichten wir an dieser Stelle auf eine Beschreibung, was Twips genau sind.<\/p>\n Den Namen des jeweiligen Formulars oder Berichts lesen wir einfach aus der Eigenschaft Name <\/b>aus. Spannend ist nun noch, die aktuelle Ansicht zu ermitteln.<\/p>\n Formulare können in den Ansichten Einzelnes Formular<\/b>, Endlosformular<\/b>, Datenblatt <\/b>oder Geteiltes Formular <\/b>angezeigt werden (siehe Bild 2). Bei Berichten kommen noch die Ansichten Berichtssicht <\/b>und Seitenansicht <\/b>hinzu.<\/p>\n Bild 2: Mögliche Ansichten für ein Formular<\/span><\/b><\/p>\n Diese Eigenschaft können wir per VBA einerseits über CurrentView <\/b>ermitteln. CurrentView <\/b>liefert die folgenden Werte:<\/p>\n Aber Moment – das sind ja gar nicht die Werte, die wir für die Eigenschaft Standardansicht <\/b>aus dem Eigenschaftenblatt auswählen können. Diese können wir der VBA-Eigenschaft DefaultView <\/b>eines Form<\/b>-Objekts entnehmen und die Werte stimmen nicht mit den Zahlenwerten für die Eigenschaft CurrentView <\/b>überein.<\/p>\n Im Gegenteil – es gibt sogar für Formulare und Berichte teilweise gleiche Werte mit unterschiedlicher Bedeutung:<\/p>\n Für Berichte gibt es die folgenden beiden Werte:<\/p>\n Wie aber kommen wir an die aktuelle Ansicht? Immerhin kann der Benutzer diese ja, wenn die möglichen Ansichten nicht auf eine Ansicht eingeschränkt ist, wechseln. Daher verwenden wir die Eigenschaft CurrentView<\/b>, um die aktuelle Ansicht zu ermitteln.<\/p>\n Etwas komplizierter wird die Analyse bei Tabellen und Abfragen. Wie bereits erwähnt, gibt es keine Auflistung, die alle derzeit geöffneten Tabellen oder Abfragen auflistet.<\/p>\n Also schauen wir, was wir mit den beiden Auflistungen AllTables <\/b>und AllQueries<\/b>, die wir weiter oben im Objektkatalog gefunden haben, für unsere Zwecke nutzen können.<\/p>\n Um diese Auflistungen zu durchlaufen, wollen wir zunächst herausfinden, welchen Datentyp die damit referenzierten Elemente überhaupt aufweisen. Dazu greifen wir einfach auf das erste Element einer solchen Auflistung zu und lassen uns den Objekttyp mit der Funktion Typename <\/b>im Direktbereich ausgeben:<\/p>\n Jetzt, da wir den Objekttypen kennen, können wir die Elemente direkt in einer For Each<\/b>-Schleife durchlaufen und auch per IntelliSense auf die Eigenschaften der Elemente zugreifen (siehe Bild 3).<\/p>\n Bild 3: Erkunden der Eigenschaften von AccessObject-Elementen<\/span><\/b><\/p>\n Um herauszufinden, welche Objekte geöffnet sind und in welcher Ansicht sie dann angezeigt werden, verwenden wir die folgende Prozedur:<\/p>\n Damit erhalten wir beispielsweise folgendes Ergebnis, wenn die beiden Tabellen tblObjecttypes <\/b>und tblTest <\/b>in der Datenblattansicht und die Tabelle tblObjects <\/b>in der Entwurfsansicht geöffnet sind:<\/p>\n Interessant sind für Tabellen die folgenden Ansichten:<\/p>\n Abfragen durchlaufen wir auf ähnliche Weise – wir verwenden hier lediglich die Auflistung AllQueries<\/b>:<\/p>\n Interessant ist hier, dass es eigentlich noch eine weitere Ansicht gibt, nämlich die SQL-Ansicht (siehe Bild 4). Wenn wir eine Abfrage in dieser Ansicht öffnen und die Prozedur GeoeffneteAbfrageDurchlaufen <\/b>starten, gibt diese ebenfalls den Wert 0 <\/b>für die Eigenschaft CurrentView <\/b>zurück.<\/p>\n Bild 4: Die SQL-Ansicht einer Abfrage<\/span><\/b><\/p>\n Davon ausgehend, dass der Benutzer nicht den Zustand von in der SQL-Ansicht geöffneten Abfragen speichern möchte, stellt das aber auch im Rahmen dieses Beitrags kein Problem dar.<\/p>\n Nachdem wir die Größe und Position von Formularen und Berichten direkt über die Eigenschaften der Form<\/b>– beziehungsweise Report<\/b>-Objekte ermitteln können, schauen wir uns nun die Tabellen und Abfragen an. Da das AccessObject<\/b>-Element keine diesbezüglichen Eigenschaften offeriert, müssen wir einen kleinen Umweg gehen, um die Informationen zu beschaffen.<\/p>\n Ausgehend davon, dass wir ohnehin nur geöffnete Elemente verwenden wollen, können wir dann das Screen<\/b>-Objekt nutzen, welches uns Informationen über die jeweils aktiven Objekte liefert, also die Objekte, die aktuell den Fokus besitzen. Mit dem Screen<\/b>-Objekt können wir über die folgenden Eigenschaften auf die jeweiligen Objekte zugreifen:<\/p>\n Hier sehen wir also eine weitere Einschränkung bezüglich der Ansichten, die wir beim Speichern von Position und Größe berücksichtigen können: Die Entwurfsansicht von Tabellen oder Abfragen fällt weg, da wir diese nicht mit den Active…<\/b>-Eigenschaften referenzieren können.<\/p>\n Die Eigenschaft ActiveDatasheet<\/b> liefert tatsächlich nur einen Objektverweis zurück, wenn aktuell eine Tabelle oder Abfrage in der Datenblattansicht geöffnet ist. Aber auch das ist kein Problem, zumindest nicht gemessen an dem Wunsch des Lesers, die Position und Größe von in der Datenblattansicht geöffneten Elementen zu ermitteln und zu speichern.<\/p>\n Allerdings hilft uns Screen.ActiveDatasheet <\/b>noch nicht weiter, wenn das Objekt, das wir untersuchen wollen, nicht den Fokus hat. Deshalb müssen wir, bevor wir auf eine geöffnete Tabelle in der Datenblattansicht zugreifen wollen, zunächst den Fokus auf diese Tabelle verschieben. Dass sie überhaupt geöffnet ist, können wir voraussetzen, denn wir wollen ja nur die Position und Größe von Tabellen ermitteln, die derzeit im Arbeitsbereich sichtbar sind.<\/p>\n <\/p>\n Den Namen der zu untersuchenden Tabelle kennen wir über die Name<\/b>-Eigenschaft auch. Also können wir die DoCmd.SelectObject<\/b>-Methode nutzen, um die zu untersuchende Tabelle oder Abfrage in den Fokus zu setzen – beispielsweise so:<\/p>\n Als Nächstes erstellen wir die Tabelle, in der wir die Größe, Position und Ansicht der aktuell geöffneten Objekte speichern wollen.<\/p>\n Welche Informationen wir speichern wollen, haben wir bereits ausführlich besprochen, daher hier nur der Verweis auf den Entwurf der Tabelle tblObjects <\/b>in Bild 5.<\/p>\n Bild 5: Tabelle zum Speichern der Objekteigenschaften<\/span><\/b><\/p>\n Außerdem noch die Information, dass wir den Typ des jeweiligen Objekts im Feld Objecttype <\/b>als Zahlenwert speichern und dabei auf die folgenden Werte zurückgreifen:<\/p>\n Den Wert für das Feld ObjectView <\/b>wählen wir wie von der Eigenschaft CurrentView <\/b>geliefert.<\/p>\n In der Prozedur SaveObjectInfo <\/b>aus Listing 1 leeren wir zunächst die Tabelle tblObjects<\/b>. Dann durchlaufen wir alle Elemente der Auflistung AllTables <\/b>und prüfen in der enthaltenen If…Then<\/b>-Bedingung mit der Eigenschaft IsLoaded<\/b>, ob das jeweilige Element geöffnet ist. Falls ja, ermitteln wir den Namen und selektieren das Objekt mit DoCmd.SelectObject<\/b>.<\/p>\n Listing 1: Prozedur zum Speichern der Informationen zu den geöffneten Objekten<\/span><\/b><\/p>\n Damit hat es anschließend den Fokus, auch wenn dies zuvor nicht der Fall war. Danach ermitteln wir die weiteren gesuchten Informationen und tragen diese in die Variablen ein. Diese nutzen wir in der anschließend ausgeführten INSERT INTO<\/b>-Aktionsabfrage, um einen neuen Datensatz mit allen benötigten Informationen in der Tabelle tblObjects <\/b>zu speichern.<\/p>\n Auf ähnliche Weise gehen wir anschließend bei den Abfragen vor – hier verwenden wir allerdings die Auflistung AllQueries <\/b>und setzen einen anderen Wert für intType<\/b>.<\/p>\n Schließlich folgen die beiden For Each<\/b>-Schleifen über die Auflistungen Forms <\/b>und Reports<\/b>, in denen wir die Daten zu den Formularen und Berichten ermitteln und diese in die Tabelle tblObjects <\/b>eintragen.<\/p>\n Das Ergebnis sieht für ein paar Beispielelemente wie in Bild 6 aus.<\/p>\n Bild 6: Eigenschaften einiger Beispielelemente in der Tabelle tblObjects<\/span><\/b><\/p>\n Bevor wir uns um die Prozedur kümmern, mit der wir die Objekte aus der Tabelle tblObjects <\/b>öffnen und ihre Positionen wiederherstellen, wollen wir uns die Arbeit beim Testen der Prozedur etwas vereinfachen – statt die aktuell geöffneten Objekte immer wieder von Hand schließen zu müssen, durchlaufen wir diese einfach innerhalb der Auflistungen, die wir bereits kennengelernt haben, und schließen diese dort automatisch:<\/p>\n Danach programmieren wir die Prozedur, welche die Elemente aus der Tabelle tblObjects <\/b>öffnet und ihre Größe und Position wiederherstellt. Bei Größe und Position können wir einfach die gespeicherten Werte übernehmen und in die entsprechenden Eigenschaften schreiben. Bei der Ansicht wird es etwas komplizierter. Der Grund ist: Wir haben zwar den Wert der Eigenschaft von CurrentView <\/b>gespeichert (siehe weiter oben), aber wir können nur die Werte für die Eigenschaft DefaultView <\/b>beim erneuten Öffnen der Elemente nutzen.<\/p>\n Die Form<\/b>– und Report<\/b>-Klassen bieten zwar die CurrentView<\/b>-Eigenschaft in VBA an, aber dabei handelt es sich um schreibgeschützte Eigenschaften. Wir können die zu verwendende Ansicht nur beim Öffnen des jeweiligen Objekts einstellen, also in der DoCmd.Open…<\/b>-Methode, die je nach zu öffnendem Objekt OpenTable<\/b>, OpenQuery <\/b>und so weiter heißt. Wir müssen daher die im Feld ObjectView <\/b>gespeicherten Werte noch umwandeln.<\/p>\n Dabei können wir hier und da Vereinfachungen treffen. Wir gehen zum Beispiel davon aus, dass der Benutzer Tabellen und Abfragen nur in der Datenblattansicht öffnen möchte und nicht mehrere Tabellen in der Entwurfsansicht nebeneinander platziert. <\/p>\n Bei Formularen unterscheiden wir die Ansichten Formularansicht<\/b>, Endlosansicht <\/b>und Datenblattansicht<\/b>. In der Liste der Werte für den zweiten Parameter der Methode DoCmd.OpenForm <\/b>finden wir allerdings nur die folgenden Werte:<\/p>\n Interessant ist die Anzeige in der Formularansicht, in der Endlosansicht und in der Datenblattansicht. Ob das Formular in der Formularansicht oder in der Endlosansicht geöffnet wird, können wir nicht steuern – wir geben den Parameter acNormal <\/b>an und Access öffnet das Formular in der Ansicht, die als Standardansicht eingestellt ist. Wenn wir für das Feld ObjectView <\/b>also den Wert 1 <\/b>gespeichert haben, müssen wir als zweiten Parameter in DoCmd.OpenForm <\/b>den Wert 0<\/b> nutzen. <\/p>\n Wenn das Formular beim Speichern in der Datenblattansicht angezeigt wurde, enthält das Feld ObjectView <\/b>den Wert 2<\/b>. In diesem Fall verwenden wir den Wert 3 <\/b>(acFormDS<\/b>) für den zweiten Parameter der OpenForm<\/b>-Methode.<\/p>\n Bei den Berichten sieht es etwas anders aus. Hier speichern wir im Feld ObjectView<\/b> entweder den Wert 5 <\/b>für acCurViewPreview <\/b>beziehungsweise Seitenansicht oder 6 <\/b>für acCurViewReportBrowse<\/b> beziehungsweise Berichtsansicht. Beim Öffnen mit DoCmd.OpenReport <\/b>müssen wir allerdings die Werte acViewPreview <\/b>nutzen beziehungsweise acViewReport<\/b>.<\/p>\n Die Prozedur sieht insgesamt wie in Listing 2 aus. Wir deklarieren für die Übersetzung der Ansicht für Formulare und Berichte die beiden Variablen intFormView <\/b>mit dem Typ AcFormView <\/b>und intReportView <\/b>mit dem Typ AcView<\/b>. Die hinter AcFormView <\/b>und acView <\/b>liegenden Enumerationen entsprechen den Parametern der Methoden DoCmd.OpenForm <\/b>beziehungsweise DoCmd.OpenReport<\/b>.<\/p>\n Listing 2: Prozedur zum Wiederherstellen der Objekte<\/span><\/b><\/p>\n Dann erstellen wir ein Recordset auf Basis der Tabelle Formulare und Berichte analysieren<\/h2>\n
Public Sub <\/span>Formulare()\r\n Dim <\/span>frm As <\/span>Form\r\n For Each frm In Forms\r\n Debug.Print<\/span> frm.Name, frm.WindowLeft, frm.WindowTop, frm.WindowWidth, frm.WindowHeight\r\n Next<\/span> frm\r\nEnd Sub<\/span><\/pre>\n![\"Mögliche](\"..\/fileadmin\/_temp_\/2022_05\/pic_1386_002.png\")
<\/p>\n\n
\n
\n
Tabellen und Abfragen analysieren<\/h2>\n
Typename(CurrentData.AllTables(0))\r\nAccessObject<\/pre>\n
![\"Erkunden](\"..\/fileadmin\/_temp_\/2022_05\/pic_1386_003.png\")
<\/p>\nPublic Sub <\/span>GeoeffneteTabellenDurchlaufen()\r\n Dim <\/span>objTable As <\/span>AccessObject\r\n For Each objTable In CurrentData.AllTables\r\n Debug.Print<\/span> objTable.Name;\r\n If <\/span>objTable.IsLoaded Then<\/span>\r\n Debug.Print<\/span> objTable.CurrentView\r\n Else<\/span>\r\n Debug.Print<\/span>\r\n End If<\/span>\r\n Next<\/span> objTable\r\nEnd Sub<\/span><\/pre>\nMSysAccessStorage\r\nMSysACEs\r\n... weitere nicht geöffnete Systemtabellen\r\nMSysRelationships\r\nMSysResources\r\ntblObjects 0 \r\ntblObjecttypes 2 \r\ntblTest 2 <\/pre>\n
\n
Public Sub <\/span>GeoeffneteAbfragenDurchlaufen()\r\n Dim <\/span>objQuery As <\/span>AccessObject\r\n For Each objQuery In CurrentData.AllQueries\r\n Debug.Print<\/span> objQuery.Name;\r\n If <\/span>objQuery.IsLoaded Then<\/span>\r\n Debug.Print<\/span> objQuery.CurrentView\r\n Else<\/span>\r\n Debug.Print<\/span>\r\n End If<\/span>\r\n Next<\/span> objQuery\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2022_05\/pic_1386_004.png\")
<\/p>\nPosition und Größe von Tabellen und Abfragen ermitteln<\/h2>\n
\n
DoCmd.SelectObject acTable, objTable.Name<\/pre>\n
Tabelle zum Speichern der Objekteigenschaften<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2022_05\/pic_1386_005.png\")
<\/p>\n\n
Public Sub <\/span>SaveObjectInfo()\r\n Dim <\/span>obj As <\/span>AccessObject\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>rpt As <\/span>Report\r\n Dim <\/span>strName As String<\/span>\r\n Dim <\/span>intTop As Integer<\/span>, intWidth As Integer<\/span>, intHeight As Integer<\/span>, intLeft As Integer<\/span>\r\n Dim <\/span>intType As <\/span>AcObjectType\r\n Dim <\/span>intView As <\/span>AcView\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblObjects\", dbFailOnError\r\n For Each obj In CurrentData.AllTables\r\n If <\/span>obj.IsLoaded Then<\/span>\r\n strName = obj.Name\r\n DoCmd.SelectObject acTable, strName\r\n intType = acTable\r\n intView = Screen.ActiveDatasheet.CurrentView\r\n intTop = Screen.ActiveDatasheet.WindowTop\r\n intLeft<\/span> = Screen.ActiveDatasheet.WindowLeft\r\n intWidth = Screen.ActiveDatasheet.WindowWidth\r\n intHeight = Screen.ActiveDatasheet.WindowHeight\r\n db.Execute \"INSERT INTO tblObjects(Objectname, Objecttype, ObjectTop, ObjectLeft, ObjectWidth, \" _\r\n & \"ObjectHeight, ObjectView) VALUES(''\" & strName & \"'', \" & intType & \", \" & intTop & \", \" & intLeft<\/span> _\r\n & \", \" & intWidth & \", \" & intHeight & \", \" & intView & \")\", dbFailOnError\r\n End If<\/span>\r\n Next<\/span> obj\r\n ''... Abfragen analog zu Tabellen\r\n For Each frm In Forms\r\n strName = frm.Name\r\n intType = acForm\r\n intView = frm.CurrentView\r\n intTop = frm.WindowTop\r\n intLeft<\/span> = frm.WindowLeft\r\n intWidth = frm.WindowWidth\r\n intHeight = frm.WindowHeight\r\n db.Execute \"INSERT INTO tblObjects(Objectname, Objecttype, ObjectTop, ObjectLeft, ObjectWidth, \" _\r\n & \"ObjectHeight, ObjectView) VALUES(''\" & strName & \"'', \" & intType & \", \" & intTop & \", \" & intLeft<\/span> _\r\n & \", \" & intWidth & \", \" & intHeight & \", \" & intView & \")\", dbFailOnError\r\n Next<\/span> frm\r\n ''...Berichte analog zu Formularen\r\nEnd Sub<\/span><\/pre>\n![\"Eigenschaften](\"..\/fileadmin\/_temp_\/2022_05\/pic_1386_006.png\")
<\/p>\nWiederherstellen der Objekte<\/h2>\n
Public Sub <\/span>CloseAllObjects()\r\n Dim <\/span>obj As <\/span>AccessObject\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>rpt As <\/span>Report\r\n For Each obj In CurrentData.AllTables\r\n If <\/span>obj.IsLoaded Then<\/span>\r\n DoCmd.Close acTable, obj.Name\r\n End If<\/span>\r\n Next<\/span> obj\r\n For Each obj In CurrentData.AllQueries\r\n If <\/span>obj.IsLoaded Then<\/span>\r\n DoCmd.Close acQuery, obj.Name\r\n End If<\/span>\r\n Next<\/span> obj\r\n For Each frm In Forms\r\n DoCmd.Close acForm, frm.Name\r\n Next<\/span> frm\r\n For Each rpt In Reports\r\n DoCmd.Close acReport, rpt.Name\r\n Next<\/span> rpt\r\nEnd Sub<\/span><\/pre>\n\n
Public Sub <\/span>OpenObjects()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>intFormView As <\/span>AcFormView\r\n Dim <\/span>intReportView As <\/span>AcView\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblObjects\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Select Case rst!Objecttype\r\n Case <\/span>acTable\r\n DoCmd.OpenTable rst!Objectname, acViewNormal\r\n Case <\/span>acQuery\r\n DoCmd.OpenQuery rst!Objectname, acViewNormal\r\n Case <\/span>acForm\r\n Select Case rst!ObjectView\r\n Case <\/span>1\r\n intFormView = acNormal\r\n Case <\/span>2\r\n intFormView = acFormDS\r\n End Select<\/span>\r\n DoCmd.OpenForm rst!Objectname, intFormView\r\n Case <\/span>acReport\r\n Select Case rst!ObjectView\r\n Case <\/span>5\r\n intReportView = acViewPreview\r\n Case <\/span>6\r\n intReportView = acViewReport\r\n End Select<\/span>\r\n DoCmd.OpenReport rst!Objectname, intReportView\r\n End Select<\/span>\r\n DoCmd.MoveSize rst!ObjectLeft, rst!ObjectTop, rst!ObjectWidth, rst!ObjectHeight\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\n