<\/p>\n
Kontextmenüs sind die beste Möglichkeit, schnell die zum aktuell unter dem Mauszeiger befindlichen Element passenden Befehle anzuzeigen und auszuwählen. Viele Benutzer verwenden Kontextmenüs einfach nicht, weil sie nichts mit der rechten Maustaste anzufangen wissen, und auch Entwickler lassen sie links liegen, weil sie die Chancen nicht erkennen. Wir zeigen, wie Sie wo mit dem Kontextmenü für perfekte Ergonomie sorgen können.<\/b><\/p>\n
Grundsätzlich muss man bei Kontextmenüs zwei Wege der Erstellung unterscheiden: Bis Access 2003 gibt es einen komfortablen Dialog für diese Aufgabe, den wir zu Beginn besprechen. Mit Access 2007 hat Microsoft jedoch das Ribbon eingeführt und zwar die Kontextmenüs verschont, aber die Menü- und Symbolleisten sowie den Anpassen-Dialog zum einfachen Erstellen dieser Elemente rausgeworfen (vielleicht kommt er mit der nächsten Office-Version zurück – wer weiß).<\/p>\n
Ab Access 2007 ist man somit auf alternative Methoden angewiesen, die in erster Linie auf den Einsatz von VBA hinauslaufen. Der zweite Teil dieses Beitrags beschäftigt sich mit diesem Thema. Schließlich gibt es einige Gelegenheiten für den Einsatz von Kontextmenüs, die wir im dritten Teil dieses Beitrags vorstellen.<\/p>\n
Kontextmenüs per Anpassen-Dialog<\/b><\/p>\n
Der Anpassen<\/b>-Dialog ist die bequemste Variante zum Erstellen von Menü- und Symbolleisten und auch für Kontextmenüs. Dieser Dialog ist nur bis einschließlich Access 2003 verfügbar und lässt sich, wie treffend, über den Eintrag Anpassen <\/b>des Kontextmenüs der Menü- und Symbolleisten aufrufen.<\/p>\n
Neues Kontextmenü anlegen<\/b><\/p>\n
Ein neues Kontextmenü legen Sie ausgehend vom Anpassen<\/b>-Dialog wie folgt an:<\/p>\n Bild 1: Anlegen einer neuen Symbolleiste, die einmal ein Kontextmenü werden soll<\/span><\/b><\/p>\n<\/p>\n Bild 2: Symbolleiste mit Schaltflächen<\/span><\/b><\/p>\n Bild 3: Umwandeln der Symbolleiste in ein Kontextmenü<\/span><\/b><\/p>\n Access hat das Kontextmenü in eine übergeordnete Symbolleiste namens Kontextmenü<\/b> verschoben. Wenn Sie den gleichnamigen Eintrag in der Liste der Symbolleisten aktivieren, erscheint eine lange Leiste mit dem Eintrag Benutzerdefiniert<\/b>, der auch unser Kontextmenü mit den drei Beispielschaltflächen enthält (siehe Bild 4).<\/p>\n Bild 4: Ein Kontextmenü unter vielen<\/span><\/b><\/p>\n Sie brauchen nun nur noch die Eigenschaften der Schaltflächen, wie das Symbol oder die Beschriftung, einzustellen und festzulegen, welche Funktion Access beim Mausklick auf eine Schaltfläche auslösen soll.<\/p>\n Dazu zeigen Sie wiederum das Kontextmenü der gewünschten Schaltfläche an und wählen den Eintrag Eigenschaften <\/b>aus (siehe Bild 5). Wichtig ist hier vor allem die Eigenschaft Bei Aktion<\/b>, der Sie den Namen einer VBA-Funktion mit führendem Gleichheitszeichen und abschließendem Klammernpaar zuweisen. Diese Funktion muss in einem Standardmodul als öffentliche Funktion deklariert sein, für das Beispiel aus der Abbildung also etwa so:<\/p>\n Bild 5: Eigenschaften einer Schaltfläche bearbeiten<\/span><\/b><\/p>\n Kontextmenü anzeigen<\/b><\/p>\n Nun müssen wir das Kontextmenü nur noch anzeigen. Am einfachsten erledigt man dies, indem man den Namen des Kontextmenüs der Eigenschaft Kontextmenüleiste<\/b> eines Formulars, Berichts oder der darin enthaltenen Steuerelemente zuweist und dann die richtige Stelle mit der rechten Maustaste anklickt. Für den Moment wollen wir uns die Erstellung zusätzlicher Elemente sparen und dies einfach per VBA erledigen.<\/p>\n Dafür stellt Access einige Objekte und Methoden bereit. Die CommandBars<\/b>-Auflistung enthält alle Symbolleisten (zu denen auch die Kontextmenüs gehören) und gibt einen Verweis auf den gewünschten Eintrag zurück, wenn man den Namen der Kontextmenüleiste als Index angibt (dies ginge auch über einen numerischen Index). Die Methode ShowPopup <\/b>zeigt schließlich die Kontextmenüleiste an, und zwar an der Stelle des Mauszeigers (siehe Bild 6). Diese Anweisung setzen Sie im Direktfenster des VBA-Editors ab, den Sie von Access und auch vom VBA-Editor aus mit der Tastenkombination Strg + G <\/b>einblenden können.<\/p>\n Bild 6: Anzeigen eines Kontextmenüs per VBA<\/span><\/b><\/p>\n Ein Klick auf den ersten Eintrag des Kontextmenüs liefert schließlich das erwartete Meldungsfenster.<\/p>\n Eingebaute Befehle<\/b><\/p>\n Wir sind im ersten Ansatz davon ausgegangen, dass man normalerweise komplett benutzerdefinierte Kontextmenüs entwirft. Dies ist natürlich nicht immer der Fall; manchmal möchte man vielleicht auch einfach ein paar eingebaute Befehle, wie etwa zum Drucken oder Speichern des aktuellen Objekts, verfügbar machen. Solche Befehle fügen Sie genau wie die benutzerdefinierten über die Registerseite Befehle <\/b>des Anpassen<\/b>-Dialogs hinzu.<\/p>\n Eingebaute Symbole<\/p>\n Ein wenig Farbe bringen Sie mit den zur Verfügung stehenden Symbolen in das Kontextmenü. Mit den Kontextmenüeinträgen der Menübefehle können Sie im Anpassen-Modus die Symbole vorhandener Befehle kopieren und den benutzerdefinierten Elementen hinzufügen. Weiter unten erfahren Sie, wie Sie auch benutzerdefinierte Symbole zu den Schaltflächen von Kontextmenüs hinzufügen können.<\/p>\n Kontextmenüs unter Access 2007<\/b><\/p>\n Nachdem Microsoft den Dialog zum Anpassen von Menüs, Symbolleisten und Kontextmenüs mit Access 2007 gestrichen hat, sind Sie dort beim Erstellen von Kontextmenüs auf einen kleinen Trick angewiesen – oder Sie verwenden direkt VBA.<\/p>\n Die Geschichte mit dem Trick sieht so aus: Sie können mit bestimmten Einstellungen versehene .mdb<\/b>-Datenbanken unter Access 2007 so öffnen, dass diese ihre Menü- und Symbolleisten genau so wie unter einer älteren Access-Version anzeigen. Wir haben solch ein Exemplar als Beispieldatenbank hinzugefügt (KontextmenuesMitA2007.mdb<\/b>), das beim Start eine Menüleiste anzeigt und auch das Anzeigen des Anpassen<\/b>-Dialogs per Kontextmenü zulässt (siehe Bild 7). Hiermit können Sie auch unter Access 2007 Kontextmenüs erstellen. Was aber haben Sie davon, wenn Sie diese in einer .accdb<\/b>– und nicht in einer .mdb<\/b>-Datei brauchen Nun, Sie können die Kontextmenüs einfach in die .accdb<\/b>-Datenbank importieren.<\/p>\n Bild 7: Der Anpassen-Dialog ist auch unter Access 2007 noch verfügbar.<\/span><\/b><\/p>\n Dazu müssen Sie nur den Ribbon-Befehl Externe Daten|Importieren|Access <\/b>anklicken, die Quelldatenbank (also die .mdb<\/b>-Datei) auswählen, im Dialog Objekte importieren <\/b>mit der Schaltfläche Optionen <\/b>die erweiterten Optionen anzeigen und dort die Option Menüs und Symbolleisten <\/b>aktivieren (siehe Bild 8).<\/p>\n Bild 8: Importieren von Kontextmenüs aus einer .mdb-Datei in eine Access 2007-Datenbank<\/span><\/b><\/p>\n Mit der oben vorgestellten ShowPopup<\/b>-Methode können Sie nun schnell prüfen, ob die mit dem Anpassen<\/b>-Dialog zusammengestellten Kontextmenüs erfolgreich importiert wurden.<\/p>\n Kontextmenüs von älteren Access-Versionen importieren<\/b><\/p>\n Wenn Sie noch eine ältere Version von Access verwenden und Kontextmenüs in Access 2007 benötigen, können Sie diese auf die gleiche Art und Weise importieren.<\/p>\n Kontextmenüs per VBA erstellen<\/b><\/p>\n Am effizientesten und am flexibelsten ist die Erstellung der Kontextmenüs per VBA. Das liegt auch daran, dass wir eine Menge nützlicher Funktionen zusammengetragen haben, die etwa das codegesteuerte Hinzufügen benutzerdefinierter Images erlauben. VBA bietet aber auch viel mehr Möglichkeiten: So können Sie damit beispielsweise zur Laufzeit Einträge zu Kontextmenüs hinzufügen, um diese etwa in Abhängigkeit von den in den Tabellen der Datenbank enthaltenen Daten zu füllen – aber sehen Sie doch einfach selbst.<\/p>\n Die CommandBars-Auflistung<\/b><\/p>\n Die CommandBars<\/b>-Auflistung gibt es in zwei Ausführungen: erstens im Application<\/b>-Objekt von Access und zweitens in der Office-Bibliothek, die Sie aber nur benötigen, wenn Sie mit den darunter liegenden Elementen arbeiten möchten – und das ist im Folgenden der Fall, weshalb Sie zunächst einen Verweis auf die Bibliothek Microsoft Office xx.0 Object Library <\/b>anlegen.<\/p>\n Als Erstes geben wir die komplette Liste der Kontextmenüs der Anwendung aus, was prinzipiell dem Ausgeben aller CommandBars<\/b>-Einträge entspricht, sich aber auf solche Elemente beschränkt, deren Eigenschaft Type <\/b>den Wert 2 <\/b>für msoBarTypePopup <\/b>aufweist:<\/p>\n Steuerelemente in Kontextmenüs<\/b><\/p>\n Die in Kontextmenüs enthaltenen Steuerelemente erhalten Sie über die Controls<\/b>-Auflistung eines Commandbar<\/b>-Elements.<\/p>\n <\/p>\n Die folgende angepasste Version der obigen Routine gibt nur Kontextmenüs inklusive der Beschriftungen und Typen der enthaltenen Steuerelemente aus – zur besseren Übersicht um zwei Leerzeichen eingerückt:<\/p>\n Die Ausgabe für unser kleines von Hand erstelltes Kontextmenü sieht damit etwa so aus: <\/p>\n Auskunft über den jeweiligen Steuerelementtyp gibt die Type<\/b>-Eigenschaft, die ihre Werte aus der Enumeration MsoControlType <\/b>bezieht. Im Wesentlichen dürften Sie hier auf die folgenden beiden Elemente treffen:<\/p>\n Kontextmenü hinzufügen<\/b><\/p>\n Ein Kontextmenü fügen Sie mit wenigen Codezeilen zur Liste der vorhandenen Commandbars <\/b>hinzu. Die Hauptarbeit übernimmt die Add<\/b>-Methode der CommandBars<\/b>-Auflistung, die unter anderem den Namen der neuen Kontextmenüleiste erwartet.<\/p>\n Dass Sie eine Kontextmenüleiste und keine Menü- oder Symbolleiste anlegen möchten, teilen Sie nicht etwa über die Type<\/b>-Eigenschaft des CommandBar<\/b>-Objekts, sondern über den zweiten Parameter der Add<\/b>-Methode mit. Dieser heißt Position <\/b>und erhält den Wert msoBarPopup<\/b>. Die folgende Routine weist das neue Kontextmenü der Objektvariablen cbr <\/b>zu, damit man gegebenenfalls weitere Eigenschaften anpassen kann:<\/p>\n Wenn beim Anlegen schon ein Kontextmenü gleichen Namens vorhanden ist, löst die Add<\/b>-Methode einen Fehler aus. Wenn Sie häufiger änderungen an der Definition des Kontextmenüs vornehmen, können Sie dieses mit der folgenden Anweisung zunächst löschen und im Anschluss neu erstellen:<\/p>\n Da auch dies einen Fehler auslöst, wenn das zu löschende Kontextmenü gar nicht existiert, schalten Sie die Fehlerbehandlung vorübergehend aus:<\/p>\n Steuerelemente hinzufügen<\/b><\/p>\n Das CommandBar<\/b>-Objekt enthält eine Controls<\/b>-Auflistung, der Sie Steuerelemente hinzufügen können. Dies geschieht ganz einfach über die Add<\/b>-Methode der Controls<\/b>-Auflistung, wie folgendes Beispiel zeigt:<\/p>\n Genau das Kontextmenü selbst weist in der Routine die neue Schaltfläche einer Objektvariablen zu, die diesmal den Typ CommandBarButton <\/b>hat.<\/p>\n Auf diese Weise können Sie anschließend leicht weitere Eigenschaften wie die Beschriftung angeben oder die VBA-Routine, die ein Klick auf die Schaltfläche auslösen soll.<\/p>\n Weitere Eigenschaften von <\/b><\/p>\n Das oben verwendete CommandBarButton<\/b>-Element können Sie mit den folgenden Eigenschaften Ihren Bedürfnissen anpassen:<\/p>\n Eingebaute Steuerelemente<\/b><\/p>\n Sie können auch eingebaute Elemente der Menüs der Office-Anwendungen in benutzerdefinierte Kontextmenüs integrieren. Dazu geben Sie die ID <\/b>des gewünschten Elements direkt beim Hinzufügen des Eintrags an. Im folgenden Beispiel wird das Element mit der ID 3 <\/b>hinzugefügt, was dem Speichern<\/b>-Befehl entspricht:<\/p>\n Beachten Sie, dass Sie die ID <\/b>nur als Parameter der Add<\/b>-Methode, nicht aber nach dem Erstellen über eine Eigenschaft zuweisen können.<\/p>\n Die Routine aus Listing 1 gibt ein langes Kontextmenü mit allen IDs aus.<\/p>\n Listing 1: Kontextmenü mit Bild<\/p>\n Benutzerdefinierte Symbole in Kontextmenüs<\/b><\/p>\n Per VBA können Sie den Einträgen von Kontextmenüs auch benutzerdefinierte Symbole zuweisen. Dies bringt in der Regel ein kleines Problem mit sich: Kontextmenüs unterstützen keine transparenten Bildformate, sondern verlangen nach einer speziellen Vorgehensweise zum Einbringen von Transparenz.<\/p>\n Ein einfaches Bild ohne Transparenz fügen Sie einfach über die Picture<\/b>-Eigenschaft des jeweiligen Steuerelements hinzu. Diese Eigenschaft erwartet einen Verweis auf ein Bild des Datentyps StdPicture<\/b>, das Sie auf Basis einer im gleichen Verzeichnis wie die Datenbank gespeicherten Bilddatei mit der LoadPicture<\/b>-Methode hinzufügen können. Der notwendige Code sieht ungefähr so wie in Listing 2 aus.<\/p>\n Listing 2: Kontextmenü mit Bild<\/p>\n Dieses Beispiel funktioniert leider nur mit wenigen Bildformaten und bringt den erwarteten ausgefüllten statt transparenten Hintergrund (siehe Bild 9). Die Transparenz erreichen Sie durch das Hinzufügen einer sogenannten Maske. Diese sieht prinzipiell genau so wie das anzuzeigende Bild aus, nur dass sie alle transparenten Bereiche weiß und alle nicht transparenten Bereiche schwarz darstellt. Für unser im obigen Beispiel verwendetes Herz sieht das so wie in Bild 10 aus. Durch Hinzufügen der folgenden kleinen Zeile ändern Sie die Darstellung, die dann wie in Bild 11 erscheint:<\/p>\n Bild 9: Ein Menüelement mit benutzerdefiniertem Icon<\/span><\/b><\/p>\n Bild 10: Die Maske rechts lässt das Herz links im Kontextmenü transparent erscheinen.<\/span><\/b><\/p>\n Bild 11: Perfekte Transparenz dank Maske<\/span><\/b><\/p>\n Nun ist das Anlegen einer Maske für jedes in einem Kontextmenü erscheinende Bild eine Menge Arbeit, und auch die Einschränkung der über die Methode LoadImage <\/b>verfügbaren Bildtypen schreit nach einer alternativen Vorgehensweise.<\/p>\n Unser GDI-Spezialist Sascha Trowitzsch bietet dazu eine Funktion namens LoadPicturePlus <\/b>an, die im Gegensatz zur LoadPicture<\/b>-Methode alle gängigen Bildtypen zulässt.<\/p>\n Leider werden die Bilder auch so nicht automatisch transparent dargestellt.<\/p>\n Allerdings gibt es noch eine weitere Routine namens MaskFromPicture<\/b>, die aus einer herkömmlichen Bilddatei die gewünschte Maske zaubert. Die beiden Funktionen finden Sie im Modul mdlGDIPlus<\/b> der Beispieldatenbank.<\/p>\n Die Routine aus Listing 3 liest ein Bild aus dem Dateisystem ein, weist dieses der Menüschaltfläche als Picture <\/b>zu, erzeugt daraus die Maske und weist diese der Eigenschaft Mask <\/b>hinzu.<\/p>\n Listing 4: Dynamische Kontextmenüs anzeigen<\/p>\n Einsatzmöglichkeiten für Kontextmenüs<\/b><\/p>\n Kontextmenüs können prinzipiell überall erscheinen, wo der Benutzer mit der rechten Maustaste hinklickt. Die Schwierigkeit ist nur, den richtigen Kontext zu ermitteln. In den folgenden Abschnitten zeigen wir einige Möglichkeiten für die Anzeige von Kontextmenüs.<\/p>\n Kontextmenüs in Formularen<\/b><\/p>\n Die einfachste Variante ist das Zuweisen eines Kontextmenüs zur Eigenschaft Kontextmenüleiste <\/b>eines Formulars. Das Kontextmenü erscheint dann bei Klicks auf den kompletten Formularbereich mit Ausnahme der Leiste am unteren Rand und mit Ausnahme von Unterformularen.<\/p>\n Auch das Anklicken von Steuerelementen zeigt das Formular-Kontextmenü an – zumindest solange das Steuerelement kein eigenes Kontextmenü besitzt: Die meisten Steuerelemente enthalten nämlich selbst eine Eigenschaft namens Kontextmenüleiste<\/b>.<\/p>\n Die Eigenschaft Kontextmenü <\/b>mit den möglichen Werten Ja <\/b>und Nein <\/b>ist den Formularen (und Berichten) vorbehalten. Stellen Sie diese Eigenschaft auf Nein<\/b> ein, zeigt das Formular beim Rechtsklick gar keine Kontextmenüs an – außer in Unterformularen (und Unterberichten).<\/p>\n Datenabhängige Kontextmenübefehle<\/b><\/p>\n Interessant sind Kontextmenübefehle zum Beispiel in Zusammenhang mit Datensatzoperationen. Schnell mal eben die Details zu einem Eintrag in der Datenblattansicht anzeigen oder einen Datensatz löschen Kein Problem! Allerdings gibt es verschiedene Möglichkeiten, dies zu erledigen.<\/p>\n Als Beispiel dient das Formular frmArtikel<\/b>, das die Einträge der Tabelle tblArtikel <\/b>anzeigt.<\/p>\n Es soll ein Kontextmenü erhalten, das die beiden Befehle aus Bild 12 anzeigt und die entsprechenden Aktionen ausführt (im Beispiel reicht uns jedoch die Anzeige einfacher Meldungsfenster mit entsprechenden Texten). Die beiden Menüeinträge rufen die Funktionen mnuArtikelLoeschen <\/b>und mnuArtikelBearbeiten <\/b>auf. Dieses Kontextmenü definiert man einmal und braucht sich dann nicht mehr darum zu kümmern, weil sowohl das Aussehen als auch die aufgerufenen Funktionen gleich bleiben.<\/p>\n Bild 12: Ein Kontextmenü in der Datenblattansicht<\/span><\/b><\/p>\n Wie wissen die aufgerufenen Funktionen nun, welchen Datensatz sie überhaupt löschen oder anzeigen sollen Dazu verwenden Sie weitere Funktionen, die etwa einen Verweis auf das aktuelle Formular liefern:<\/p>\n Statt des Meldungsfensters könnten Sie hier etwa eine DELETE<\/b>-Anweisung platzieren, die den aktuellen Datensatz löscht und die Anzeige aktualisiert.<\/p>\n Der Verweis mit Screen.ActiveForm <\/b>funktioniert allerdings nur, wenn das Formular nicht als Unterformular verwendet wird. Ist das der Fall, müssen Sie sich mit folgendem Ausdruck auf das Formular beziehen:<\/p>\n Daten in Kontextmenüeintrag einbeziehen<\/b><\/p>\n Die Abfrage des zu löschenden oder anzuzeigenden Datensatzes kann man natürlich auch direkt in das Kontextmenü einbauen.<\/p>\n Während Sie das Kontextmenü im vorigen Beispiel einmalig einrichten, müssen Sie das datenabhängige Kontextmenü jeweils beim Klick auf die rechte Maustaste erstellen.<\/p>\n Das Wichtigste hierbei ist die grundsätzlich andere Vorgehensweise zum Anzeigen des Kontextmenüs. Im vorherigen Beispiel war die Menüleiste bereits vorhanden und für die Eigenschaft Kontextmenüleiste <\/b>angegeben, was zum automatischen Anzeigen beim Rechtsklick führt.<\/p>\n Nun sollen aber zumindest die Caption<\/b> und die OnAction<\/b>-Eigenschaft in Abhängigkeit vom Datensatz erstellt werden, auf dem der Benutzer den Rechtsklick ausführt.<\/p>\n Dies geht natürlich nicht, wenn das Kontextmenü schon vorhanden ist. Wie aber soll man das Kontextmenü beim Rechtsklick neu bauen Indem man einfach die Ereignisse des Formulars und seiner Steuerelemente ausnutzt, in diesem Fall Bei Maustaste<\/b>.<\/p>\n Dieses Ereignis feuert immer, wenn man die Maustaste herunterdrückt und dann loslässt. Sie werden schnell feststellen, dass das entsprechende Ereignis des Formulars oder auch des Detailbereichs Ihnen nicht weiterhilft, denn ein Klick auf ein Steuerelement (und daraus besteht ein Datensatz in der Datenblattansicht im Wesentlichen) schlägt nicht bis zum darunter liegenden Formular durch.<\/p>\n Stattdessen verwenden Sie einfach die Bei Maustaste auf<\/b>-Ereignisprozedur der Steuerelemente im Detailbereich:<\/p>\n Bild 13: Anlegen der Ereigniseigenschaft für den Rechtsklick auf das Textfeld<\/span><\/b><\/p>\n Private Sub Artikelname_MouseUp(Button As _<\/p>\n If Button = 2 Then<\/p>\n ArtikelKontextmenue<\/p>\n End If<\/p>\n End Sub<\/p>\n Die in dieser Routine aufgerufene Funktion ArtikelKontextmenue <\/b>erledigt die eigentliche Aufgabe – dies aber nur, wenn der Parameter Button <\/b>der Ereignisprozedur den Wert 2 <\/b>aufweist, was bedeutet, dass der Benutzer die rechte Taste verwendet hat.<\/p>\n Kontextmenü dynamisch anlegen<\/b><\/p>\n In der Routine wird zunächst die bestehende Kontextmenüleiste namens ArtikelDynamisch <\/b>gelöscht und neu angelegt. Die Routine sieht wie in Listing 4 aus und löscht zunächst ein eventuell vorhandenes Kontextmenü mit dem Namen ArtikelDynamisch<\/b>.<\/p>\n Dann legt es dieses neu an und fügt die beiden Einträge hinzu, wobei es direkt den Artikelnamen in die Caption <\/b>des Eintrags und die ArtikelID <\/b>in den Aufruf der für OnAction <\/b>angegebenen Funktion einfügt.<\/p>\n Schließlich sorgt die ShowPopup<\/b>-Methode für die Anzeige des Kontextmenüs.<\/p>\n In den für die Eigenschaft OnAction <\/b>angegebenen Funktionen müssen Sie natürlich auch noch die entsprechenden Parameter einbauen, was wie folgt aussieht:<\/p>\n Fertig! Sie brauchen nun nur noch in die Datenblattansicht zu wechseln und das Kontextmenü des soeben mit einer Ereignisprozedur bestückten Textfelds aufzurufen und es erscheint das Kontextmenü aus Bild 14.<\/p>\n Bild 14: Ein datenabhängiges Kontextmenü<\/span><\/b><\/p>\n Überraschung!<\/b><\/p>\n Bislang herrschte die Meinung vor, dass die für die OnAction <\/b>angegebenen Funktionen öffentlich in einem Standardmodul deklariert werden müssten.<\/p>\n Ein Versuch brachte anderes zutage: Wenn Sie das Kontextmenü im Kontext mit einem Formular aufrufen, können Sie die Funktion auch gleich im Klassenmodul des Formulars unterbringen.<\/p>\n Dies bringt diverse Vorteile mit sich: Zunächst können Sie, da sich diese Funktion in der Formularklasse befindet, auch direkt auf seine Elemente zugreifen, also etwa ein Textfeld über Me!Artikelname <\/b>ansprechen. Die Funktionen sehen dann etwa so aus:<\/p>\n Außerdem haben Sie die Funktionen des Formulars kompakt in einem einzigen Modul und können dieses anderweitig verwenden, ohne noch ein Standardmodul mitschleppen zu müssen.<\/p>\n Kontextmenü im Listenfeld<\/b><\/p>\n Im Listenfeld können Sie das Kontextmenü fast genauso wie in der Datenblattansicht von Formularen einsetzen.<\/p>\n Der Unterschied ist, dass Sie dort die Eigenschaft Kontextmenüleiste <\/b>des Listenfeld-Steuerelements mit dem Namen des Kontextmenüs füllen müssen – zumindest wenn Sie nur ein statisches Kontextmenü wie in Bild 15 verwenden möchten.<\/p>\n\n
![\"abb001.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Kontextmenues-web-images\/abb001_opt.jpeg\")
<\/p>\n![\"abb004.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Kontextmenues-web-images\/abb004_opt.jpeg\")
<\/p>\n![\"abb002.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Kontextmenues-web-images\/abb002_opt.jpeg\")
<\/p>\n![\"abb003.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Kontextmenues-web-images\/abb003_opt.jpeg\")
<\/p>\n![\"abb005.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Kontextmenues-web-images\/abb005_opt.jpeg\")
<\/p>\nPublic Function Meldungsfenster()\r\n MsgBox "Ich wurde vom Kontextmenü µ\r\n aufgerufen."\r\nEnd Function<\/pre>\n
![\"abb006.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Kontextmenues-web-images\/abb006_opt.jpeg\")
<\/p>\nCommandbars("MeinKontextmenue").ShowPopup<\/pre>\n![\"abb007.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Kontextmenues-web-images\/abb007_opt.jpeg\")
<\/p>\n![\"abb008.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Kontextmenues-web-images\/abb008_opt.jpeg\")
<\/p>\nPublic Sub KontextmenuesAusgeben()\r\nDim cbr As CommandBar\r\nFor Each cbr In CommandBars\r\n If cbr.Type = 2 Then\r\n Debug.Print cbr.Name\r\nEnd If\r\nNext cbr\r\nEnd Sub<\/pre>\n
Public Sub KontextmenuesAusgeben()\r\nDim cbr As CommandBar\r\nDim cbc As CommandBarControl\r\nFor Each cbr In CommandBars\r\nIf cbr.Type = 2 Then\r\nDebug.Print cbr.Name\r\nFor Each cbc In cbr.Controls\r\n Debug.Print , cbc.Caption\r\nNext cbc\r\nEnd If\r\nNext cbr\r\nEnd Sub<\/pre>\n
MeinKontextmenue\r\nMeldungsfenster zeigen\r\nBenutzerdefiniert\r\nBenutzerdefiniert<\/pre>\n
\n
Public Sub KontextmenueHinzufuegen()\r\nDim cbr As CommandBar\r\nSet cbr = CommandBars.Add("Neues Kontextµ\r\nmenü", msoBarPopup)\r\nWith cbr\r\n'... weitere Anpassungen\r\nEnd With\r\nEnd Sub<\/pre>\nCommandBars("Neues Kontextmenü").Delete<\/pre>\nOn Error Resume Next\r\nCommandBars("Neues Kontextmenü").Delete\r\nOn Error GoTo 0<\/pre>\nPublic Sub KontextmenueHinzufuegen()\r\nDim cbr As CommandBar\r\nDim cbb As CommandBarButton\r\nOn Error Resume Next\r\nCommandBars("Neues Kontextmenü").Delete\r\nOn Error GoTo 0\r\nSet cbr = CommandBars.Add("Neues Kontextmenü", msoBarPopup)\r\nWith cbr\r\nSet cbb = cbr.Controls.Add(msoControlButton)\r\nWith cbb\r\n.Caption = "Beispielbefehl"\r\n.OnAction = "Beispielfunktion"\r\nEnd With\r\nEnd With\r\nEnd Sub<\/pre>\nCommandBarButton-Elementen<\/pre>\n
\n
Set cbb = cbr.Controls.Add(msoControlButton, 3)<\/pre>\n
Public Sub ControlIDsAusgeben()\r\nDim cbr As CommandBar\r\nDim cbb As CommandBarButton\r\nDim i As Integer\r\nOn Error Resume Next\r\nCommandBars("Neues Kontextmenü").Delete\r\nOn Error GoTo 0\r\nSet cbr = CommandBars.Add("Neues Kontextmenü", msoBarPopup)\r\nWith cbr\r\nFor i = 1 To 1000\r\n On Error Resume Next\r\n Set cbb = cbr.Controls.Add(msoControlButton, i)\r\n If Err.Number = 0 Then\r\n cbb.Caption = cbb.Caption & " (" & i & ")"\r\n End If\r\n On Error GoTo 0\r\nNext i\r\nEnd With\r\ncbr.ShowPopup\r\nEnd Sub<\/pre>\nPublic Sub KontextmenueMitImage()\r\nDim cbr As CommandBar\r\nDim cbb As CommandBarButton\r\nDim strPic As String\r\nDim objPic As StdPicture\r\nOn Error Resume Next\r\nCommandBars("Kontextmenü mit Icons").Delete\r\nOn Error GoTo 0\r\nSet cbr = CommandBars.Add("Kontextmenü mit Icons", msoBarPopup)\r\nWith cbr\r\nSet cbb = cbr.Controls.Add(msoControlButton)\r\nWith cbb\r\n.Caption = "Icon mit Herz"\r\n.Picture = stdole.LoadPicture(CurrentProject.Path & "\\heart.bmp")\r\nEnd With\r\nEnd With\r\ncbr.ShowPopup\r\nEnd Sub<\/pre>\n![\"abb009.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Kontextmenues-web-images\/abb009_opt.jpeg\")
<\/p>\n![\"abb010.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Kontextmenues-web-images\/abb010_opt.jpeg\")
<\/p>\n![\"abb011.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Kontextmenues-web-images\/abb011_opt.jpeg\")
<\/p>\n.Mask = stdole.LoadPicture(CurrentProject.Path & "\\mask.bmp")<\/pre>\n
Private Sub ArtikelKontextmenue()\r\n Dim cbr As CommandBar\r\n Dim cbb As CommandBarButton\r\n On Error Resume Next\r\n CommandBars("ArtikelDynamisch").Delete\r\n On Error GoTo 0\r\n Set cbr = CommandBars.Add("ArtikelDynamisch", msoBarPopup)\r\n With cbr\r\n Set cbb = cbr.Controls.Add(msoControlButton)\r\n With cbb\r\n .Picture = LoadPicturePlus(CurrentProject.Path & "\\delete.png")\r\n .Mask = MaskFromPicture(.Picture)\r\n .Caption = "Artikel '" & Me!Artikelname & "' löschen"\r\n .OnAction = "=mnuArtikelLoeschenDynamisch(" & Me!ArtikelID & ")"\r\n End With\r\n Set cbb = cbr.Controls.Add(msoControlButton)\r\n With cbb\r\n .Picture = LoadPicturePlus(CurrentProject.Path & "\\edit.png")\r\n .Mask = MaskFromPicture(.Picture)\r\n .Caption = "Artikel '" & Me!Artikelname & "' bearbeiten"\r\n .OnAction = "=mnuArtikelBearbeitenDynamisch(" & Me!ArtikelID & ")"\r\n End With\r\n End With\r\n cbr.ShowPopup\r\n End Sub<\/pre>\n![\"abb012.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Kontextmenues-web-images\/abb012_opt.jpeg\")
<\/p>\nPublic Function mnuArtikelLoeschen()\r\nMsgBox "Artikel '" & Screen.ActiveForm!ArtikelID & "' löschen"\r\nEnd Function<\/pre>\n
Screen.ActiveForm!frmArtikel.Form<\/pre>\n
\n
![\"abb013.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Kontextmenues-web-images\/abb013_opt.jpeg\")
<\/p>\nInteger, Shift As Integer, _\r\nX As Single, Y As Single)<\/pre>\n
Public Function mnuArtikelLoeschenDynamisch( _\r\nlngArtikelID As Long)\r\nMsgBox "Artikel '" & lngArtikelID _\r\n& "' löschen"\r\nEnd Function\r\nPublic Function mnuArtikelBearbeitenDynamisch( _\r\nlngArtikelID As Long)\r\nMsgBox "Artikel '" & lngArtikelID _\r\n& "' bearbeiten"\r\nEnd Function<\/pre>\n
![\"abb014.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Kontextmenues-web-images\/abb014_opt.jpeg\")
<\/p>\nPublic Function mnuArtikelLoeschen()\r\nMsgBox "Artikel '" _\r\n& Me!ArtikelID & "' löschen"\r\nEnd Function\r\nPublic Function mnuArtikelBearbeiten()\r\nMsgBox "Artikel '" & Me!ArtikelID & "' bearbeiten"\r\nEnd Function<\/pre>\n
![\"abb015.tif\"](\"..\/fileadmin\/_temp_\/2008_06\/Kontextmenues-web-images\/abb015_opt.jpeg\")
<\/p>\n