<\/p>\n
Eigentlich bieten die Datenblatt- und auch die Formularansicht eine Menge Werkzeuge, mit denen der Benutzer die Daten nach Wunsch filtern oder sortieren kann. Dummerweise stehen diese Möglichkeiten in der Runtime-Version von Access nicht zur Verfügung. Damit Sie auch Benutzer ohne Vollversion mit dem gewohnten Komfort beglücken können, bringen wir Ihren Formularen neue Techniken zum Aufruf von Filtern und Sortierungen bei.<\/b><\/p>\n
Access bietet vor allem seit Access 2007 sehr praktische Filter- und Sortierfunktionen. So können Sie beispielsweise in der Datenblattansicht auf den kleinen Pfeil im Spaltenkopf klicken, um die Sortier- und Filteroptionen auszuwählen. Das daraufhin erscheinende Popup-Menü zeigt zwei Einträge zum Sortieren der Feldwerte in aufsteigender und absteigender Reihenfolge, die Möglichkeit zur Eingabe eines Textfilters oder auch das Auswählen konkreter Werte, die angezeigt werden sollen – oder auch nicht (s. Bild 1).<\/p>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2010_06\/FilterPerKontextmenue-web-images\/pic001.png\")
<\/p>\n
Bild 1: Filter- und Sortiermöglichkeiten in der Datenblattansicht<\/span><\/b><\/p>\n Hinweis: Access 2003 und älter bieten nicht so praktische Filter- und Sortiermöglichkeiten, daher gehen wir auf diese hier nicht ein. Unsere Lösung können Sie hingegen auch mit älteren Access-Versionen verwenden – wir werfen nur einen genauen Blick auf die Access 2007\/2010-Techniken, um die Anforderungen für die Lösung zu ermitteln.<\/p>\n Sie können Filter und Sortierungen für mehrere Spalten festlegen, wobei diese mit UND <\/b>verknüpft werden. Damit lassen sich etwa alle Adressen auswählen, deren Vorname mit A <\/b>und deren Nachname mit B <\/b>beginnt. Wenn Sie das Popupfenster zum Einstellen von Filter- und Sortierkriterien für eine gefilterte Spalte anzeigen, ist der Eintrag Filter löschen aus <Feldname> <\/b>aktiviert (s. Bild 2). Hiermit können Sie einzelne Filter wieder entfernen.<\/p>\n Bild 2: Löschen einzelner Filter<\/span><\/b><\/p>\n Alle Filter entfernen Sie mit einem Eintrag im Ribbon, der unter Access 2010 wie in Bild 3 aussieht.<\/p>\n Bild 3: Entfernen aller aktiven Filter<\/span><\/b><\/p>\n Die Filter- und Sortiermöglichkeiten stehen auch in der Formularansicht über das Kontextmenü zur Verfügung (s. Bild 4).<\/p>\n Bild 4: Filtern per Kontextmenü in der Formularansicht<\/span><\/b><\/p>\n Datentypabhängiger Filter<\/b><\/p>\n Die Möglichkeiten der Filterfunktion erschließen sich erst, wenn Sie sich einmal die Einträge des Kontextmenüs für verschiedene Datentypen ansehen. Wenn Sie beispielsweise das Kontextmenü für ein Datumsfeld öffnen, können Sie sogar alle Daten eines bestimmten Quartals oder Monats auswählen (s. Bild 5).<\/p>\n Bild 5: Umfangreiche Filtermöglichkeiten für Datumsangaben<\/span><\/b><\/p>\n All diese Möglichkeiten wollen wir beim Nachbau einer solchen Filter- und Sortierfunktion via Kontextmenü natürlich offenhalten.<\/p>\n Spezialfall Runtime<\/b><\/p>\n Neben den älteren Access-Versionen, die weniger gut mit Filter- und Sortierfunktionen ausgestattet sind, gibt es mit der Runtime-Version von Access einen weiteren Spezialfall: Die praktischen Helferlein lassen sich dort nur über die Spaltenköpfe in der Datenblattansicht aufrufen, aber nicht über Kontextmenüs.<\/p>\n Der Grund für das Fehlen der Filter- und Sortierfunktionen in Anwendungen, die mit der Access-Runtime geöffnet werden, ist ganz einfach: Microsoft hat dort ganz einfach alle eingebauten Menüs beziehungsweise Ribbons sowie Kontextmenüs rausgeworfen.<\/p>\n Sie können das Verhalten der Runtime für eine beliebige Datenbankanwendung folgendermaßen nachstellen:<\/p>\n Filter nachrüsten<\/b><\/p>\n Da Sie wahrscheinlich nicht alle Daten ausschließlich in Formularen in der Datenblattansicht anzeigen möchten, müssen Sie Anwendungen, die als Runtime-Version weitergegeben werden sollen, mit eigenen Filterfunktionen ausrüsten – zumindest dort, wo keine Datenblattansicht vorliegt.<\/p>\n Wir beginnen mit zwei Einträgen in das Kontextmenü, die das auf- und absteigende Sortieren des jeweiligen Feldes erlauben. Bevor wir damit beginnen, sind jedoch einige Überlegungen notwendig:<\/p>\n Die Sortierung nach nur einem Feld wäre am einfachsten und dürfte in der Praxis auch für die meinsten Fälle ausreichend sein. Jedoch kann es durchaus auch vorkommen, dass der Benutzer nach mehr als einem Kriterium sortieren möchte.<\/p>\n In dem Fall müssen wir uns überlegen, in welcher Reihenfolge der Felder die Sortierungg erfolgen. Bei der eingebauten Sortierfunktion wird das jeweils neueste Sortierkriterium vorne an den OrderBy<\/b>-Ausdruck angehängt. Wenn Sie also zunächst eine aufsteigende Sortierung nach dem Vornamen anwenden, hat die OrderBy-Eigenschaft des Formulars den folgenden Wert:<\/p>\n Wenn Sie anschließend eine absteigende Sortierung nach dem Nachnamen festlegen, sieht der Ausdruck so aus:<\/p>\n Die Reihenfolge ist insofern wichtig, als dass immer zuerste nach dem erstgenannten Feld sortiert wird und erst dann nach den folgenden Feldern. Das heißt, dass sich die hinteren Sortierkriterien nur noch auswirken, wenn die vorderen Felder gleiche Inhalte aufweisen, die in der Sortierreihenfolge gleichrangig sind.<\/p>\n Übernehmen wir also dieser Vorgehensweise und stellen das Sortierkriterium so zusammen, dass die zuletzt hinzugefügte Sortierung die höchste Priorität erhält.<\/p>\n Wer genau beobachtet, stellt übrigens fest, dass die Standardfunktion zum Hinzufügen von Sortierkriterien nicht das Entfernen einzelner Sortierkriterien erlaubt – dies funktioniert nur für die komplette Sortierung. Dieses Feature werden wir natürlich noch hinzufügen.<\/p>\n Unser Kontextmenü sollte also die folgenden Einträge enthalten:<\/p>\n Hinzufügen der Kontextmenüeinträge<\/b><\/p>\n Als Nächstes kümmern wir uns um die Erstellung der Kontextmenüeinträge. Diese können wir entweder dauerhaft speichern oder zur Laufzeit zusammenstellen. Da Sie wie der Autor dieser Zeilen nach der Lektüre zahlloser Beiträge zu diesem Thema in der dynamischen Erstellung von Kontextmenüs bewandert sein dürften, wählen wie diese Variante.<\/p>\n Die Funktionen zum Sortieren der Datensätze ist die einfachere, sie dürfte vor allem in Datenblatt- und Endlosansichten Verwendung finden. Die hier vorgestellte Lösung kann in Haupt- und Unterformularen und auch in modalen Dialogen eingesetzt werden.<\/p>\n Erstellen der Kontextmenüs<\/b><\/p>\n Unser erstes Ziel ist das Erstellen eines Kontextmenüs wie in Bild 6. Der kleine Haken ist, dass wir je nach Datentyp des Feldes unterschiedliche Texte anzeigen wollen. Damit möchten wir auch Benutzer einfangen, die sonst wenig bis gar nicht mit Datenbankanwendungen arbeiten.<\/p>\n Bild 6: Kontextmenü zum Sortieren eines Textfeldes<\/span><\/b><\/p>\n Für ein Textfeld lautet der Text zum Anwenden einer aufsteigenden Sortierung beispielsweise Von A bis Z sortieren <\/b>und umgekehrt Von Z bis A sortieren<\/b>, bei Datumsfeldern soll es Von früheren zu späteren Daten sortieren <\/b>und Von späteren zu früheren Daten sortieren<\/b> und so weiter.<\/p>\n Ablauf der Erstellung<\/b><\/p>\n Die Erstellung eines Kontextemenüs beginnt mit dem Laden des Formulars, dessen Steuerelemente mit den Sortier-Funktionen gefüllt werden sollen. Die komplette Funktionalität dafür steckt in zwei Klassenmodulen namens clsSortAndFilter <\/b>und clsSortAndFilterControl<\/b>.<\/p>\n Für den Einbau der Sortierfunktion brauchen Sie nur wenige Zeilen zum betroffenen Formular hinzuzufügen. Die erste deklariert ein Objekt auf Basis der Klasse clsSortAndFilter <\/b>und landet im Kopf des Formularmoduls:<\/p>\n Danach legen Sie eine Ereignisprozedur an, die durch das Ereignis Beim Laden <\/b>des Formulars ausgelöst wird. Beachten Sie, dass Sie bei Verwendung eines Unterformulars auch dort die Beim Laden<\/b>-Ereignisprozedur anlegen müssen.<\/p>\n Diese Prozedur erstellt lediglich eine neue Instanz der Klasse clsSortAndFilter<\/b> und weist sie der frisch deklarierten Objektvariablen zu. Außerdem verwendet es die Eigenschaft Form<\/b> dieser Klasse, um einen Verweis auf das mit Sortiermenüs zu bestückende Formular zu übergeben:<\/p>\n Steuerelemente mit Kontextmenüs versehen<\/b><\/p>\n Das Zuweisen des Formularverweises an die Eigenschaft Form <\/b>löst die Property Get<\/b>-Methode aus Listing 1<\/a><\/span> aus.<\/p>\n Listing 1: Diese Property Set-Methode ist die Steuerzentrale für das Anlegen der Sortier-Kontextmenüs.<\/p>\n <\/p>\n Diese schreibt zunächst den Objektverweis in die private Variable m_Form, die im Kopf des Klassenmoduls wie folgt deklariert wird:<\/p>\n Dann erzeugt sie neue Instanzen der folgenden Collection<\/b>-Objekte, deren Funktion wir gleich im Anschluss erläutern:<\/p>\n Um später den Datentyp des Feldes zu untersuchen, an welches das aktuell untersuchte Steuerelement gebunden ist, erstellt die Prozedur ein neues Recordset<\/b>-Objekt und füllt es mit den gleichen Daten, die auch das Formular enthält.<\/p>\n Danach durchläuft die Prozedur im Wesentlichen in einer For Each<\/b>-Schleife alle Steuerelemente des Formulars auf m_Form<\/b>. Das aktuelle Steuerelement wird dabei jeweils in der Variablen ctl <\/b>gespeichert und genauer untersucht. Diese Untersuchung konzentriert sich darauf, ob das Steuerelement gebunden oder ungebunden ist. Dies findet die Prozedur über die Eigenschaft ControlSource <\/b>heraus, die nur bei gebundenen Steuerelementen mit dem Namen des Herkunftsfeldes gefüllt ist.<\/p>\n Da diese Eigenschaft nur bei bestimmten Steuerelementtypen vorhanden ist und die Abfrage der Eigenschaft einen Fehler auslöst, wenn sie nicht vorhanden ist, wird die Fehlerbehandlung für diese Abfrage außer Kraft gesetzt. Die Prozedur leert also die Variable strControlSource <\/b>und versucht sie dann mit dem Namen der Eigenschaft ControlSource <\/b>(im Eigenschaftsfenster Steuerelementinhalt<\/b>) zu füllen. Wenn die Variable nach diesem Versuch noch leer ist, ist das Steuerelement offensichtlich ungebunden und wird nicht mit einem Kontextmenü versehen. Anderenfalls wird das Steuerelement innerhalb einer If…Then<\/b>-Bedingung genauer untersucht.<\/p>\n Dort kommt das vor Beginn der For Each<\/b>-Schleife erzeugte und gefüllte Recordset<\/b>-Objekt rst zum Zuge: Die Prozedur ermittelt dort das Feld, an welches das aktuelle Steuerelement gebunden ist, und speichert einen Verweis darauf in der Objektvariablen fld<\/b>. Die folgende Select Case<\/b>-Bedingung prüft daraufhin über die Eigenschaft Type <\/b>den den Datentyp des Feldes und setzt die Prozedur in einem von vier Zweigen fort: für Zahlen, Texte, Datumsangaben und Ja\/Nein<\/b>-Felder.<\/p>\n Innerhalb dieser Zweige erfolgt zuerst der Aufruf der Prozedur CreateSortBar <\/b>mit zwei Parametern. Diese enthalten die Texte, welche das Kontextemenü zum Aufwärts- und Abwärtssortieren des jeweiligen Feldes anzeigen soll.<\/p>\n Nach dem Erstellen der Kontextmenüs wird dieses dem aktuellen Steuerelement über die Eigenschaft ShortcutMenuBar <\/b>als Kontextmenü zugewiesen.<\/p>\n Menü erstellen<\/b><\/p>\n Die Prozedur CreateSortBar <\/b>ist für das Erstellen der Kontextmenüs verantwortlich (s. Listing 2<\/a><\/span>). Sie nimmt die von der aufrufenden Prozedur übergebenen Text für die beiden Einträge zum Hinzufügen einer Sortierung sowie den Namen des Kontextmenüs entgegen.<\/p>\n Listing 2: Die Methode CreateSortBar steuert das Erstellen eines Kontextmenüs mit den vier Steuerelementen zum Einstellen der Sortierung.<\/p>\n Danach ruft sie zunächst die Prozedur CreateCommandbar <\/b>auf, um ein neues Kontextmenü mit dem angegebenen Namen zu erstellen – zum Beispiel cbrText<\/b>. Anschließend statten die vier Aufrufe der Prozedur CreateCommandBarButton <\/b>die neue Kontextmenüleiste mit den vier Einträgen zum Sortieren in aufsteigender und absteigender Reihenfolge, zum Entfernen der Sortierung des aktuellen Feldes und zum Entfernen aller Sortierungen aus.<\/p>\n Die Prozedur CreateCommandBar<\/b> finden Sie in Listing 3<\/a><\/span>. Sie entfernt eine eventuell vorhandene Menüleiste gleichen Namens und legt diese dann entsprechend der mit dem Parameter strCommandbar <\/b>übergebenen Bezeichnung neu an.<\/p>\n Listing 3: Die eigentliche Erstellung der nackten Kontextmenüleiste erledigt diese Prozedur.<\/p>\n Schaltflächen zum Kontextmenü hinzufügen<\/b><\/p>\n Jetzt wird es spannend: Das Anlegen der Einträge des Kontextmenüs ist nämlich nicht gerade trivial. Der Hintergrund für die folgende, etwas kompliziert anmutende Vorgehensweise ist, dass wir irgendwo den Code unterbringen müssen, der durch einen Mausklick auf einen der Einträge des Kontextmenüs ausgelöst wird. Die erstbeste Variante dafür wäre ein Standardmodul mit Public Function<\/b>-Prozeduren. Sie könnten die Namen dieser Prozeduren einfach der Eigenschaft OnAction <\/b>der Menüschaltflächen zuweisen.<\/p>\n Beim Anklicken eines dieser Einträge würden dann die öffentlichen Funktionen ausgeführt. Das Sortier-System soll aber möglichst geschlossen sein, um eine saubere Architektur zu liefern: Der einzige Kontakt von außen sollten die Instanzierung der Klasse und das Zuweisen des Formularverweises sein. Wenn wir ein öffentliches Modul verwenden, um dort Funktionen auszulagern, sind diese nicht mehr sauber gekapselt.<\/p>\n Die zweite Variante wäre es, die durch die Menüeinträge aufgerufenen Funktionen gleich in das betroffene Formular zu packen. Dies würde immerhin den Umweg über ein externes Standardmodul einsparen. Allerdings würde dies auch bedeuten, dass wir den gleichen Code in allen Formularmodulen unterbringen müssten, die mit der Sortierfunktion ausgestattet werden sollen – auch keine gute Idee.<\/p>\n Also gehen wir einen zunächst komplizierten, aber sauberen Weg. Dieser wird durch die Prozedur CreateCommandBarButton <\/b>eingeleitet, die für jede der vier pro Kontextmenü anzulegenden Schaltflächen einmal aufgerufen wird. Die Prozedur erzeugt je Kontextmenüeintrag eine neue Instanz der Klasse clsSortAndFilterControl<\/b>.<\/p>\n Listing 4: Die Prozedur CreateCommandBarButton wird für jeden zu erzeugenden Eintrag des Kontextmenüs einmal aufgerufen.<\/p>\n Diese dient als Kapselklasse für jedes der CommandBarButton<\/b>-Objekte, die wir dem Kontextmenü hinzufügen. Das heißt, dass jedes CommandBarButton<\/b>-Objekt innerhalb eines auf der Klasse clsSortAndFilterControl <\/b>basierenden Objekts deklariert und instanziert sowie mit den gewünschten Eigenschaften ausgestattet wird – in diesem Falle nur die Beschriftung.<\/p>\n Die Prozedur CreateCommandBarButton <\/b>erzeugt also eine neue Instanz von clsSortAndFilterControl <\/b>und ruft dann dessen Methode CreateButton <\/b>auf, wobei ein Verweis auf das CommandBar<\/b>-Objekt, die Bezeichnung der Schaltfläche, ein Parameter zur Festlegung der durchzuführenden Aktion (aufsteigend oder absteigend filtern, einen oder alle Filter aufheben) und ein Verweis auf die aufrufende Klasse übergeben werden. Was diese Methode genau erledigt, schauen wir uns weiter unten an.<\/p>\n Wichtig ist, dass das Objekt objSortAndFilterControl <\/b>nun jeweils die Referenz auf eine der Schaltflächen der aktuell erstellten Kontextmenüleiste enthält. Und damit dieses Objekt und damit auch der Menüeintrag nach dem Erstellen nicht im Nirwana verschwinden, sammeln wir all diese Objekte in der Collection colCommandbarButtons<\/b>.<\/p>\n![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2010_06\/FilterPerKontextmenue-web-images\/pic003.png\")
<\/p>\n![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2010_06\/FilterPerKontextmenue-web-images\/pic004.png\")
<\/p>\n![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2010_06\/FilterPerKontextmenue-web-images\/pic002.png\")
<\/p>\n![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2010_06\/FilterPerKontextmenue-web-images\/pic005.png\")
<\/p>\n\n
\n
[tblAdressen].[Vorname]<\/pre>\n
[tblAdressen].[Nachname] DESC, [tblAdressen].[Vorname]<\/pre>\n
\n
![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2010_06\/FilterPerKontextmenue-web-images\/pic006.png\")
<\/p>\nDim objSortAndFilter As clsSortAndFilter<\/pre>\n
Private Sub Form_Load()\r\n Set objSortAndFilter = New clsSortAndFilter\r\n With objSortAndFilter\r\n Set .Form = Me\r\n End With\r\nEnd Sub<\/pre>\n
Public Property Set Form(frm As Form)\r\n Dim ctl As Control\r\n Dim strControlSource As String\r\n Dim db As DAO.Database\r\n Dim rst As DAO.Recordset\r\n Dim fld As DAO.Field\r\n Set m_Form = frm\r\n Set colOrderBy = New Collection\r\n Set colCommandbarButtons = New Collection\r\n Set db = CurrentDb\r\n Set rst = db.OpenRecordset(m_Form.RecordSource, dbOpenDynaset)\r\n For Each ctl In m_Form.Controls\r\n strControlSource = ""\r\n On Error Resume Next\r\n strControlSource = ctl.ControlSource\r\n On Error GoTo 0\r\n If Len(strControlSource) > 0 Then\r\n ''Datentyp des Feldes herausfinden\r\n Set fld = rst.Fields(strControlSource)\r\n Select Case fld.Type\r\n ''Zahlentypen\r\n Case dbBigInt, dbByte, dbCurrency, dbDecimal, dbDouble, dbFloat, dbInteger, _\r\n dbLong, dbNumeric, dbSingle\r\n CreateSortBar "Aufsteigend sortieren", "Absteigend sortieren", "cbrNumber"\r\n ctl.ShortcutMenuBar = "cbrNumber"\r\n ''Text\r\n Case dbChar, dbText, dbMemo, dbGUID\r\n CreateSortBar "Von A bis Z sortieren", "Von Z bis A sortieren", "cbrText"\r\n ctl.ShortcutMenuBar = "cbrText"\r\n ''Datum\r\n Case dbDate, dbTime, dbTimeStamp\r\n CreateSortBar "Von früheren zu späteren Daten sortieren", _\r\n "Von späteren zu früheren Daten sortieren", "cbrDate"\r\n ctl.ShortcutMenuBar = "cbrDate"\r\n ''Boolean\r\n Case dbBoolean\r\n CreateSortBar "Von Ja nach Nein sortieren", "Von Nein nach Ja sortieren", "cbrBoolean"\r\n ctl.ShortcutMenuBar = "cbrBoolean"\r\n Case Else\r\n Debug.Print fld.Name, fld.Type\r\n End Select\r\n End If\r\n Next ctl\r\nEnd Property<\/pre>\n
Private m_Form As Form<\/pre>\n
Public colOrderBy As Collection\r\nPublic colCommandbarButtons As Collection<\/pre>\n
Private Sub CreateSortBar(strUp As String, strDown As String, strName As String)\r\n CreateCommandbar strName, cbr\r\n CreateCommandBarButton cbr, strUp, "AddSortAsc"\r\n CreateCommandBarButton cbr, strDown, "AddSortDESC"\r\n CreateCommandBarButton cbr, "Sortierung für dieses Feld entfernen", "DropSort"\r\n CreateCommandBarButton cbr, "Alle Sortierungen entfernen", "DropAllSort"\r\nEnd Sub<\/pre>\n
Private Function CreateCommandbar(strCommandbar As String, cbr As CommandBar)\r\n On Error Resume Next\r\n CommandBars(strCommandbar).Delete\r\n On Error GoTo 0\r\n Set cbr = CommandBars.Add(strCommandbar, msoBarPopup, , True)\r\nEnd Function<\/pre>\n
Private Sub CreateCommandBarButton(cbr As CommandBar, strCaption As String, strAction As String)\r\n Dim objSortAndFilterControl As clsSortAndFilterControl\r\n Set objSortAndFilterControl = New clsSortAndFilterControl\r\n With objSortAndFilterControl\r\n .CreateButton cbr, strCaption, strAction, Me\r\n colCommandbarButtons.Add objSortAndFilterControl\r\n End With\r\nEnd Sub<\/pre>\n
![\"pic007.png\"](\"..\/fileadmin\/_temp_\/2010_06\/FilterPerKontextmenue-web-images\/pic007.png\")
<\/p>\n![\"pic008.png\"](\"..\/fileadmin\/_temp_\/2010_06\/FilterPerKontextmenue-web-images\/pic008.png\")
<\/p>\n![\"pic009.png\"](\"..\/fileadmin\/_temp_\/2010_06\/FilterPerKontextmenue-web-images\/pic009.png\")
<\/p>\n![\"pic010.png\"](\"..\/fileadmin\/_temp_\/2010_06\/FilterPerKontextmenue-web-images\/pic010.png\")
<\/p>\n