{"id":55000713,"date":"2010-04-01T00:00:00","date_gmt":"2020-05-22T22:12:02","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=713"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Trojanische_Kontextmenues_am_Beispiel_Excel","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Trojanische_Kontextmenues_am_Beispiel_Excel\/","title":{"rendered":"Trojanische Kontextmenüs am Beispiel Excel"},"content":{"rendered":"

\"\"<\/p>\n

Die guten alten Trojaner lassen uns nicht in Ruhe – auch wenn das trojanische Pferd eigentlich gar kein trojanisches, sondern ein griechisches Pferd war: Der Begriff des Trojaners verfolgt uns sogar bis ins Computerzeitalter. Der vorliegende Beitrag beschäftigt sich auch mit diesem Thema, allerdings geht es hier um ein trojanisches Kontextmenü, mit dem Sie von Access aus Funktionen in andere Office-Anwendungen einschleusen. Dreht der Autor jetzt völlig durch Sie werden sehen: Vielleicht schicken ja auch Sie schon bald einen Trojaner in Richtung Word, Excel oder Outlook …<\/b><\/p>\n

Ein praxisnahes Beispiel für ein trojanisches Kontextmenü liefert der Beitrag Ferngesteuerter Seriendruck mit Access und Word <\/b>(www.access-im-unternehmen.de\/714<\/b>). Dort geht es um eine Access-Anwendung, die Seriendruckdokumente auf Basis beliebiger Datenherkünfte erzeugen soll. Dabei öffnet der Benutzer von Access aus eine Word-Instanz mit einem vorhandenen oder auch neuen Dokument, um dieses mit den für diese Anwendung notwendigen Platzhaltern auszustatten. Der Clou dabei: Die Platzhalter, die den Feldern der zuvor in Access ausgewählten Tabelle entsprechen, werden so im Kontextmenü von Word angeboten, dass man die Textmarke nach dem Positionieren der Einfügemarke per Kontextmenü in das Word-Dokument einfügen kann. Außerdem schließt der Benutzer die Bearbeitung des Word-Dokuments ebenfalls mit einer Kontextmenüschaltfläche ab.<\/p>\n

Natürlich ist diese Vorgehensweise nicht ganz trivial (sonst würde es ja jeder machen): Die VBA-Funktion, die für das Einfügen der Textmarke im Word-Dokument sorgt, steckt nämlich in einem Modul der Access-Anwendung. Und auch wenn es noch relativ einfach ist, ein Kontextmenü der Word-Anwendung mit eigenen Befehlen zu bestücken oder diese anderweitig zu manipulieren, so reicht es längst nicht aus, einfach die VBA-Funktion des Access-Moduls für die OnAction<\/b>-Eigenschaft des Kontextmenüeintrags anzugeben: Word wiegelt diesen Versuch mit einer humorlosen Meldung ab, dass die Funktion nicht gefunen werden könne.<\/p>\n

Beispiel: Excel<\/b><\/p>\n

Ein Beispiel für den Einsatz eines trojanischen Kontextmenüs in Word finden Sie in der Beispieldatenbank zum oben genannten Beitrag, daher beschäftigen wir uns hier mit einer praktischen Excel-Anwendung. Dabei möchten wir von Access aus eine Excel-Instanz mit einem zuvor ausgewählten Dokument öffnen, einen Bereich dieses Dokuments referenzieren und dann irgendetwas mit diesem Bereich veranstalten – was, bleibt Ihrer Fantasie überlassen.<\/p>\n

Excel-Instanz holen<\/b><\/p>\n

Bevor wir von Access aus irgendwelche Anpassungen am Menü von Excel durchführen können, müssen wir zunächst eine Excel-Instanz erstellen und einen Verweis darauf in einer Objekt-Variablen speichern. Für mehr Komfort bei der Entwicklung setzen wir zunächst einen Verweis auf die Bibliothek Microsoft Excel x.0 Object Library<\/b> (VBA-Editor, Menü Extras|Verweise<\/b>). Falls Sie eine andere Anwendung, wie etwa Word oder Outlook, infiltrieren möchten, binden Sie natürlich den entsprechenden Verweis ein. Und da wir exzessiv mit dem CommandBars<\/b>-Objektmodell arbeiten werden, kann natürlich auch ein Verweis auf die Bibliothek Microsoft Office x.0 Object Library <\/b>nicht schaden.<\/p>\n

Den Verweis auf die Excel-Instanz und auf das darin erzeugte Excel-Dokument speichern Sie in entsprechenden Objektvariablen, die Sie in einem neuen Standardmodul namens mdlExcel <\/b>anlegen:<\/p>\n

Public objExcel As Excel.Application\r\nPublic objWorkbook As Excel.Workbook<\/pre>\n
Wenn Sie später auf Late Binding <\/b>umstellen und die Verweise aus dem Projekt entfernen möchten, ändern Sie diese beiden Zeilen wie folgt:<\/p>\n
Dim objExcel As Object\r\nDim objWorkbook As Object<\/pre>\n
Nachdem objExcel <\/b>und objWorkbook <\/b>global verfügbar sind, können wir uns für das Öffnen und Schließen dieser Elemente eigene Prozeduren gönnen. Die erste erzeugt zunächst eine Excel-Instanz und erstellt ein neues Workbook:<\/p>\n
Public Sub ExcelStarten()\r\n    Set objExcel = CreateObject("Excel.Application")\r\n    Set objWorkbook = objExcel.Workbooks.Add()\r\nEnd Sub<\/pre>\n
Die nächste Routine schließt das Dokument, ohne es zu speichern, und beendet auch die Excel-Instanz:<\/p>\n
Public Sub ExcelBeenden()\r\n    objWorkbook.Close False\r\n    Set objWorkbook = Nothing\r\n    objExcel.Quit\r\n    Set objExcel = Nothing\r\nEnd Sub<\/pre>\n
Wenn Sie beide hintereinander aufrufen, geschieht gar nichts Sichtbares – was auch logisch ist: Wir haben die Excel-Instanz nicht sichtbar gemacht. Das geschieht mit dieser Anweisung, die Sie nach Ausführen von ExcelStarten <\/b>im Direktfenster ausprobieren können:<\/p>\n
objExcel.Visible = True<\/pre>\n
Vorerst wollen wir Excel aber gar nicht sichtbar machen. Erstmal statten wir das entsprechende Kontextmenü von Excel mit einem neuen Eintrag aus, der die aktuelle Auswahl zur weiteren Bearbeitung an Access übergibt. In der Prozedur, die diese Aufgabe erledigt, brauchen wir zwei Objektvariablen. Die erste referenziert die Kontextmenüleiste, der wir einen Eintrag hinzufügen möchten, die zweite den neuen Eintrag selbst:<\/p>\n
Dim cbr As Commandbar\r\nDim cbc As CommandBarControl<\/pre>\n
Bevor wir das neue Steuerelement hinzufügen können, müssen wir herausfinden, welches Kontextmenü überhaupt erscheint, wenn wir mit der rechten Maustaste auf einen Bereich im Excel-Worksheet klicken. Dies bekommen wir leicht heraus. Dazu öffnen wir Excel und ein Workbook mit der Prozedur ExcelStarten <\/b>und rufen die folgende Routine auf:<\/p>\n
Public Sub KontextmenueIdentifizieren()\r\n    Dim cbr As Commandbar\r\n    Dim cbc As CommandBarControl\r\n    For Each cbr In objExcel.CommandBars\r\n        If cbr.Type = msoBarTypePopup Then\r\n            Set cbc = cbr.Controls.Add(1, , , , True)\r\n            cbc.Caption = "Name des Kontextmenüs: " & cbr.Name\r\n        End If\r\n    Next cbr\r\nEnd Sub<\/pre>\n
Damit fügen Sie jedem Kontextmenü der gesamten Anwendung einen Eintrag hinzu, der sich am Beispiel des Kontextmenüs einer Zelle wie in Bild 1 auswirkt und einen Eintrag mit der Angabe des Namens der Kontextmenüleiste hinzufügt.<\/p>\n
\"pic001.png\"<\/p>\n
Bild 1: Ermitteln des Namens eines Kontextmenüs<\/span><\/b><\/p>\n
Das Kontextmenü Cell<\/b> wird auch aufgerufen, wenn Sie einen Bereich aus mehreren Zellen markieren, wir brauchen uns also offensichtlich nur um dieses eine Kontextmenü zu kümmern. Gehen wir also in die Vollen und legen unseren Kontextmenüeintrag an:<\/p>\n
Public Sub TrojanermenueAnlegen()\r\n    Dim cbr As Commandbar\r\n    Dim cbc As CommandBarButton\r\n    Set cbr = objExcel.CommandBars("Cell")\r\n    Set cbc = cbr.Controls.Add(1, , , , True)\r\n    With cbc\r\n        .Caption = "Auswahl nach Access übernehmen"\r\n        .BeginGroup = True\r\n        .OnAction = "=AuswahlUebernehmen()"\r\n    End With\r\nEnd Sub<\/pre>\n
<\/p>\n
Und damit beim Anklicken des Eintrags auch etwas geschieht, fügen wir noch schnell eine entsprechende Funktion ins Modul ein, die einfach nur ein Meldungsfenster anzeigen soll:<\/p>\n
Public Function AuswahlUebernehmen()\r\n    MsgBox "Auswahl übernehmen"\r\nEnd Function<\/pre>\n
Nach dem Aufrufen der Prozedur TrojanerAnlegen <\/b>und einem Klick auf den neuen Eintrag geschieht allerdings Unerwartetes: Es gibt eine Fehlermeldung, weil die Funktion nicht vorhanden sei. Das konnte ja auch nicht klappen: Woher soll die in Excel angelegte Menüschaltfläche auch wissen, dass sich ihre OnAction<\/b>-Funktion in einer externen Access-Datenbank befindet<\/p>\n
CommandBar per Klasse<\/b><\/p>\n
Aber wer sich schon einmal mit COM-Add-Ins beschäftigt hat, der weiß auch, dass es Möglichkeiten gibt, anderen Anwendungen Menüeinträge hinzuzufügen, deren Aktion von der hinzufügenden Anwendung ausgeführt wird.<\/p>\n
Der Schlüssel ist vermutlich, dass wir das Steuerelement als Objekt mit dem Vermerk WithEvents <\/b>deklarieren müssen und eine eigene Ereignisprozedur für den Klick auf das Steuerelement anlegen. Die WithEvents<\/b>-Klausel kann allerdings nur innerhalb von Klassenmodulen verwendet werden, sodass wir uns für ein erstes Experiment einfach ein kleines Formular zum Aufruf von Excel, zum Einbau des Trojanermenüeintrags und zum Unterbringen des Ereignisses bauen. Dieses sieht im Entwurf wie in Bild 2 aus und enthält lediglich eine Schaltfläche namens cmdExceltrojaner<\/b>. Statt des im bisherigen Beispielcode verwendeten CommandBarControl<\/b>-Objekts verwenden wir ein Objekt des Typs CommandBarButton <\/b>– dieses kann gegebenüber dem CommandBarControl<\/b>-Objekt das Ereignis Click <\/b>auslösen.<\/p>\n
\"pic002.png\"<\/p>\n
Bild 2: Diese Schaltfläche schickt den Trojaner nach Excel.<\/span><\/b><\/p>\n
Die Deklaration der Excel-Objekte und die beiden Prozeduren ExcelStarten<\/b> und ExcelBeenden <\/b>können im Standardmodul mdlExcel <\/b>verbleiben, den Rest gestalten wir im Klassenmodul des Formulars frmExceltrojaner <\/b>neu. Als Erstes bringen wir dort die CommandBar<\/b>-Variable sowie die mit dem Schlüsselwort WithEvents <\/b>versehene Variable für die Menüschaltfläche unter:<\/p>\n
Dim cbr As Commandbar\r\nDim WithEvents cbb As CommandBarButton<\/pre>\n
Ein Klick auf die Schaltfläche cmdExceltrojaner <\/b>löst die folgende Ereignisprozedur aus, die zunächst über die Prozedur ExcelStarten <\/b>die Excel-Instanz samt neuem Dokument erzeugt und dann die Routine TrojanermenueAnlegen <\/b>aufruft:<\/p>\n
Private Sub cmdExceltrojaner_Click()\r\n    ExcelStarten\r\n    TrojanermenueAnlegen\r\nEnd Sub<\/pre>\n
Diese wiederum erzeugt einen Verweis auf das Kontextmenü namens Cell <\/b>und legt ein neues Steuerelement darin an. Dann stellt sie die Beschriftung des Steuerelements ein, sorgt dafür, dass dieses in einer neuen Gruppe erscheint und übergibt einen Wert für die Tag<\/b>-Eigenschaft:<\/p>\n
Private Sub TrojanermenueAnlegen()\r\n    Set cbr = objExcel.CommandBars("Cell")\r\n    Set cbb = cbr.Controls.Add(1, , , , True)\r\n    With cbb\r\n        .Caption = "Auswahl nach Access übernehmen"\r\n        .BeginGroup = True\r\n        .Tag = "AuswahlUebernehmen"\r\n    End With\r\nEnd Sub<\/pre>\n
Die Tag<\/b>-Eigenschaft müssen Sie in diesem Fall nicht unbedingt setzen, aber unter Word wird keine Ereignisprozedur für ein CommandBarButton<\/b>-Objekt oder andere Menüsteuerelemente ausgelöst, wenn dies von einer anderen Anwendung angelegt und die Tag<\/b>-Eigenschaft nicht gesetzt wurde – mehr dazu unter http:\/\/support.microsoft.com\/kb\/826931\/en-us<\/b>.<\/p>\n
Schauen wir uns schließlich noch das Ereignis an, das Sie mit den beiden Kombinationsfeldern im Kopf des Codefensters des Klassenmoduls des Formulars anlegen können (siehe Bild 3):<\/p>\n
\"pic003.png\"<\/p>\n
Bild 3: Mit diesen beiden Kombinationsfeldern legen Sie Ereignisprozeduren für Objekte an, die mit dem Schlüsselwort WithEvents deklariert wurden.<\/span><\/b><\/p>\n
Private Sub cbb_Click(ByVal Ctrl As Office.CommandBarButton, CancelDefault As Boolean)\r\n    Dim strAddress As String\r\n    strAddress = objExcel.Selection.Address\r\n    ExcelBeenden\r\n    MsgBox "Ausgewählter Bereich: " & strAddress\r\nEnd Sub<\/pre>\n
Diese Prozedur ermittelt die Adresse des aktuell ausgewählten Bereichs im Excel-Tabellenblatt zum Zeitpunkt der Betätigung des neuen Menüeintrags. Dann beendet sie Excel mithilfe der Prozedur ExcelBeenden<\/b> und gibt schließlich die Adresse des ausgewählten Bereichs in einem Meldungsfenster aus.<\/p>\n
Flexiblere Gestaltung<\/b><\/p>\n
Dies ist die einfachste Variante für eine neue Schaltfläche im Kontextmenü einer anderen Anwendung. In der Lösung zum oben erwähnten Beitrag zum Seriendruck in Word sieht dies anders aus: Hier sollen gleich mehrere neue Schaltflächen angelegt werden, und das auch noch in verschiedenen Kontextmenüs. Gleichzeitig besitzt diese Variante einen dynamischen Anteil, denn die Anzahl der anzulegenden CommandBarButtons <\/b>ist variabel und hängt von der gewählten Datenherkunft ab.<\/p>\n
Die Beispieldatenbank enthält eine Klasse, die wir hierzu im Modul des Formulars frmExcelTrojaner <\/b>deklarieren und später instanzieren. Die Deklaration sieht so aus:<\/p>\n
Dim WithEvents objExcelCommandbar As clsExcelCommandBar<\/pre>\n
Um die Klasse auszuprobieren, legen wir eine zweite Schaltfläche namens cmdVieleExcelTrojaner <\/b>an. Diese erhält die folgende Prozedur für die Ereigniseigenschaft Beim Klicken<\/b>:<\/p>\n
Private Sub cmdVieleExcelTrojaner_Click()\r\n    ExcelStarten\r\n    Set cbrExcel = objExcel.CommandBars("Cell")\r\n    Set objCommandbar = New clsCommandBar\r\n    With objCommandbar\r\n        .AddCommandBarButton cbrExcel, _\r\n        "Aktuelle Markierung", _\r\n        "Aktuelle Markierung", True\r\n        .AddCommandBarButton cbrExcel, _\r\n        "Funktion 1", "Funktion 1"\r\n        ''... weitere Aufrufe\r\n        .AddCommandBarButton cbrExcel, _\r\n        "Beenden", "Beenden", True\r\n    End With\r\nEnd Sub<\/pre>\n
Die Routine verwendet die Methode AddCommandBarButton<\/b> des auf der Klasse clsCommandbar <\/b>basierenden Objekts objCommandbar<\/b>, um eine Reihe von Kontextmenüeinträgen anzulegen. Diese Methode erwartet die folgenden Parameter:<\/p>\n