<\/p>\n
Wenn Sie selbst eine Anwendung programmieren und ein Formular nicht so funktioniert wie gewünscht, wissen Sie, wie die Steuer-elemente heißen, an welche Datenquellen sie gebunden sind und so weiter. Vielleicht ist die Entwicklung der Anwendung auch etwas länger her und Sie müssen sich erst wieder einarbeiten – oder Sie erhalten von einem Kunden eine Anwendung mit der Bitte, dort eine Funktion in einem Formular zu überprüfen. In den beiden letzteren Fällen ist es recht mühsam, zwischen Formular- und Entwurfsansicht zu wechseln, um Steuerelementnamen, Datenherkünfte und andere Informationen herauszufinden, die zur Lösung des Problems beitragen könnten. Der vorliegende Beitrag zeigt, wie Sie ein Formular schnell mithilfe eines zur Laufzeit hinzugefügten Kontextmenüs analysieren können, um schneller Lösungen zu finden.<\/b><\/p>\n
Die üblichen Mittel, die einem zur Verfügung stehen, um Informationen über das Formular, die enthaltenen Steuer-elemente oder ihre Eigenschaften zu ermitteln, sind die Elemente der Screen<\/b>-Klasse. Dieses bietet Eigenschaften wie ActiveForm <\/b>für das Ermitteln eines Verweises auf das aktuelle Formular oder ActiveControl <\/b>für das Ermitteln des aktuellen Steuerelements.<\/p>\n
Den Namen des aktuellen Formulars können Sie so beispielsweise über das Direktfenster ermitteln, ohne in die Entwurfsansicht wechseln zu müssen. Dazu geben Sie den folgenden Befehl ein:<\/p>\n
Debug.Print<\/span> Screen.ActiveForm.Name<\/pre>\nVielleicht wollen Sie auch auf die Eigenschaften des aktuellen Steuer-elements zugreifen. Dann verwenden Sie ActiveControl<\/b>:<\/p>\nDebug.Print<\/span> Screen.ActiveControl.Name<\/pre>\nWenn Sie dann auf eine spezielle Eigenschaft des Formulars oder Steuerelements zugreifen wollen, die Sie nicht genau kennen, weil Sie diese sonst immer per IntelliSense eingeben, wird es allerdings schwierig, weil zumindest Screen.ActiveControl <\/b>nur einige allgemeine Eigenschaften liefert.<\/p>\n
Geplante Lösung<\/b><\/p>\n
Was wir nun machen wollen, ist die Bereitstellung aller Eigenschaften eines Formulars oder Steuerelements über das Kontextmenü des jeweiligen Elements. Wenn der Entwickler also mit der rechten Maustaste auf ein Formular oder Steuer-element klickt, soll ein Kontextmenü erscheinen, das zusätzlich zu den eingebauten Befehlen noch weitere Einträge enthält – einen, der direkt den Namen des Elements anzeigt und einen, der in einem Untermenü alle Eigenschaften des Elements samt Werten liefert.<\/p>\n
Das soll etwa wie in Bild 1 aussehen. Diese Kontextmenü-Einträge wollen wir für alle Elemente des Formulars liefern – also sowohl für das Formular selbst, für die Steuer-elemente als auch für die Elemente in Unterformularen, unabhängig davon, ob es sich um die Datenblatt- oder die Formularansicht handelt.<\/p>\n
![\"Anzeige](\"..\/fileadmin\/_temp_\/2020_04\/pic_1245_001.png\")
<\/p>\n
Bild 1: Anzeige der Eigenschaften per Kontextmenü<\/span><\/b><\/p>\nRealisierung<\/b><\/p>\n
Im aufwendigsten Fall fügt man für jedes Formular und für jedes Steuer-element eine Ereignisprozedur hinzu, die durch das Ereignis Bei Maustaste ab <\/b>ausgelöst wird.<\/p>\n
In dieser Prozedur prüft man dann, ob der Benutzer die linke oder die rechte Taste gedrückt hat. Im Falle der rechten Maustaste soll dann das nun anzuzeigende Kontextmenü erweitert werden, und zwar um ein Element mit dem Namen des Formulars oder Steuerelements und mit einem Untermenü mit den Eigenschaften des Elements.<\/p>\n
Allerdings müsste man das dann für alle Formulare und Steuer-elemente machen, die man untersuchen möchte – und das wollen wir nicht. Stattdessen arbeiten wir, wie schon des Öfteren, mit zwei Klassenmodulen, denen wir die Formulare und Steuer-elemente zuweisen und welche die notwendigen Ereignisprozeduren bereits enthalten.<\/p>\n
Diese schauen wir uns nun an – zuerst das Klassenmodul, mit dem wir das Formular referenzieren und das die Kontextmenü-Befehle für dieses bereitstellt.<\/p>\n
Klassenmodul für die Kontextmenüs in Formularen<\/b><\/p>\n
Dieses Klassenmodul nennen wir clsForm<\/b>.<\/p>\n
Das Formular verwendet die folgenden Variablen:<\/p>\n
Private <\/span>WithEvents m_frm As <\/span>Form\r\nPrivate <\/span>WithEvents m_Detail As <\/span>Section\r\nPublic <\/span>colControls As <\/span>Collection\r\nPrivate <\/span>m_IsSubform As Boolean<\/span><\/pre>\nDie beiden Variablen m_frm <\/b>und m_Detail <\/b>werden mit dem Schlüsselwort WithEvents <\/b>ausgestattet, wodurch wir in dem Klassenmodul, in dem die Objekte deklariert sind, Ereignisprozeduren für diese Objekte implementieren können.<\/p>\n
Die Klasse stellt eine öffentliche Eigenschaft namens Form <\/b>zur Verfügung, die das mit den Kontextmenüs auszustattende Formular entgegennimmt und die wie folgt aussieht:<\/p>\nPublic Property Set<\/span> <\/span>Form(frm As <\/span>Form)\r\n Dim <\/span>objControl As <\/span>clsControl\r\n Dim <\/span>ctl As <\/span>Control\r\n Set<\/span> m_frm = frm\r\n With<\/span> m_frm\r\n .OnMouseDown = \"[Event Procedure]\"\r\n End With<\/span>\r\n Set<\/span> m_Detail = Form.Section(0)\r\n With<\/span> m_Detail\r\n .OnMouseDown = \"[Event Procedure]\"\r\n End With<\/span>\r\n Set<\/span> colControls = New<\/span> Collection\r\n For Each ctl In m_frm.Controls\r\n Set<\/span> objControl = New<\/span> clsControl\r\n With<\/span> objControl\r\n .IsSubform = m_IsSubform\r\n Set<\/span> .Control = ctl\r\n colControls.Add objControl\r\n End With<\/span>\r\n Next<\/span> ctl\r\nEnd Property<\/span><\/pre>\nDiese Property Set<\/b>-Prozedur speichert zunächst den mit frm <\/b>übergebenen Verweis auf das betreffende Formular in der Variablen m_frm<\/b>. Dann stellt es für die Ereignis-eigenschaft Bei Maustaste ab <\/b>(OnMouseDown<\/b>) des Formulars den Wert Ereignisprozedur <\/b>ein ([Event Procedure]<\/b>). Danach ermittelt die Prozedur den Detailbereich des Formulars und referenziert diesen mit der Variablen m_Detail<\/b>. Auch dafür stellt sie den Wert [Event Procedure] <\/b>für die Eigenschaft OnMouseDown <\/b>ein. Danach durchläuft die Methode die Steuerelemente im Formular und legt für jedes Steuer-element eine neue Instanz der Klasse clsControl<\/b>, die wir weiter unten erläutern, an und weist der Eigenschaft Control <\/b>dieses Objekts das aktuelle Steuer-element zu. Gegebenenfalls befinden wir uns gerade in einem Unterformular, dann wird noch der Wert True <\/b>für die Eigenschaft IsSubform <\/b>übergeben. Schließlich landen alle Objekte auf Basis der Klasse clsControl <\/b>in der Collection colControls<\/b>.<\/p>\n
Rechter Mausklick auf Formular oder Detailbereich<\/b><\/p>\n
Wenn der Benutzer mit der rechten Maustaste auf das Formular oder den Detailbereich klickt, löst er die Prozedur m_Detail_MouseDown <\/b>aus. Diese legen Sie an, indem Sie im Codefenster der Klasse clsForm <\/b>im linken Kombinationsfeld den Eintrag m_Detail <\/b>und im rechten den Eintrag MouseDown <\/b>auswählen (siehe Bild 2).<\/p>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2020_04\/pic_1245_002.png\")
<\/p>\n
Bild 2: Anlegen einer Ereignisprozedur für eine Objektvariable<\/span><\/b><\/p>\nDadurch wird eine Ereignisprozedur angelegt, die wir wie in Listing 1 ergänzen. Hier deklarieren wir zunächst zwei Variablen, um eine Menüleiste und eine Menüschaltfläche zu referenzieren.<\/p>\n
Private Sub <\/span>m_Detail_MouseDown(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n Dim <\/span>cbb As <\/span>CommandBarButton\r\n If <\/span>m_frm.CurrentView = acCurViewDatasheet Then<\/span>\r\n Set<\/span> cbr = CommandBars(\"Form DataSheetCell\")\r\n Else<\/span>\r\n If <\/span>m_IsSubform Then<\/span>\r\n Set<\/span> cbr = CommandBars(\"Form View Subform\")\r\n Else<\/span>\r\n Set<\/span> cbr = CommandBars(\"Form View popup\")\r\n End If<\/span>\r\n End If<\/span>\r\n On Error Resume Next<\/span>\r\n Do While<\/span> Err.Number = 0\r\n cbr.Controls(\"Steuerelement-Infos anzeigen\").Delete\r\n Loop<\/span>\r\n On Error Resume Next<\/span>\r\n Do While<\/span> Err.Number = 0\r\n cbr.Controls(\"Eigenschaften\").Delete\r\n Loop<\/span>\r\n Set<\/span> cbb = cbr.Controls.Add(msoControlButton, , , , True<\/span>)\r\n With<\/span> cbb\r\n If <\/span>m_IsSubform Then<\/span>\r\n .Caption = \"Unterformular: \" & m_frm.Name\r\n Else<\/span>\r\n .Caption = \"Formular: \" & m_frm.Name\r\n End If<\/span>\r\n End With<\/span>\r\n PropertiesHinzufuegen cbr\r\nEnd Sub<\/span><\/pre>\nListing 1: Prozedur beim Mausklick auf ein Formular<\/span><\/b><\/p>\nKontextmenüs identifizieren<\/b><\/p>\n
Nun folgen wichtige Schritte, in denen wir festlegen, welches Kontextmenü überhaupt mit unseren zusätzlichen Einträgen versehen werden soll. Access zeigt nämlich immer andere Kontextmenüs an, wenn Sie unterschiedliche Elemente mit der rechten Maustaste anklicken – und deren Namen wir durch den Aufruf einer bestimmten Prozedur ermitteln können. Diese sieht wie folgt aus:<\/p>\n
Public Sub <\/span>ButtonMitNameZuKontextmenuesHinzufuegen()\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n Dim <\/span>cbb As <\/span>CommandBarButton\r\n For Each cbr In CommandBars\r\n On Error Resume Next<\/span>\r\n Set<\/span> cbb = cbr.Controls.Add( msoControlButton, , , , True<\/span>)\r\n cbb.Caption = cbr.Name\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n Debug.Print<\/span> cbr.Name\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n Next<\/span>\r\nEnd Sub<\/span><\/pre>\nDie Prozedur durchläuft alle Einträge der CommandBars<\/b>-Auflistung von Access und fügt jedem ein Element des Typs msoControlButton <\/b>hinzu, also eine einfache Schaltfläche.<\/p>\n
Die Beschriftung des jeweiligen Elements füllen wir mit dem Namen des aktuellen Kontextmenüs. Dadurch zeigt jedes Kontextmenü von nun an als letzten Eintrag seinen Namen an – wie am Beispiel eines Datenblatts zu erkennen (siehe Bild 3).<\/p>\n
![\"Anzeige](\"..\/fileadmin\/_temp_\/2020_04\/pic_1245_003.png\")
<\/p>\n
Bild 3: Anzeige des Kontextmenü-Namens im Kontextmenü<\/span><\/b><\/p>\nKontextmenü im Kontext des jeweiligen Objekts anpassen<\/b><\/p>\n
Dann prüfen wir, ob das aktuelle Formular in der Datenblattansicht angezeigt wird, was der Fall ist, wenn die Eigenschaft CurrentView <\/b>den Wert acCurViewDatasheet <\/b>liefert. In diesem Fall erstellen wir ein CommandBar<\/b>-Objekt auf Basis des Menüs Form DataSheetCell<\/b>.<\/p>\n
Anderenfalls, also wenn das Formular nicht in der Datenblattansicht angezeigt wird, prüfen wir den Inhalt der Variablen m_IsSubform<\/b>. Ist dieser True<\/b>, befinden wir uns gerade in einem Unterformular. Dann zeigt der rechte Mausklick das Menü Form View Subform <\/b>an, welches wir der Variablen cbr <\/b>zuweisen. Ist es kein Unterformular, verwenden wir das Kontextmenü namens Form View Popup<\/b>.<\/p>\n
Danach löschen wir alle eventuell bereits aus vorherigen Anwendungen vorhandenen Schaltflächen mit den Beschriftungen Steuerelement-Infos anzeigen <\/b>und Eigenschaften <\/b>aus dem Kontextmenü. Das erledigen wir bei deaktivierter Fehlerbehandlung in jeweils einer Do While<\/b>-Schleife, die verlassen wird, wenn ein Fehler aufgetaucht ist – und das geschieht, wenn das Löschen der genannten Elemente nicht mehr erfolgreich ist, weil kein passendes Element mehr gefunden werden konnte.<\/p>\n
Dann fügen wir mit der Add<\/b>-Methode der Controls<\/b>-Auflistung der Menüleiste aus cbr <\/b>ein neues Element zur Menüleiste <\/b>hinzu und referenzieren dieses mit der Variablen cbb<\/b>.<\/p>\n
Für diese legen wir dann die Beschriftung fest, wobei diese wieder vom Wert der Variablen m_IsSubform <\/b>abhängt. Weist diese den Wert True <\/b>auf, haben wir ein Unterformular und geben den Text Unterformular <\/b>gefolgt von einem Doppelpunkt und den aus m_frm.Name <\/b>ermittelten Formularnamen an. Anderenfalls lautet der Text Formular: <\/b>plus dem Formularnamen.<\/p>\n
Schließlich rufen wir die Prozedur PropertiesHinzufuegen <\/b>auf und übergeben dieser die Variable mit dem Verweis auf das CommandBar<\/b>-Objekt.<\/p>\n
Eigenschaften in Kontextmenü eintragen<\/b><\/p>\n
Die Prozedur PropertiesHinzufuegen <\/b>trägt die Eigenschaften des Formulars als Elemente des noch hinzuzufügenden Untermenüs Eigenschaften <\/b>ein (siehe Listing 2). Sie erwartet eine Verweis auf das CommandBar<\/b>-Objekt, dem das Untermenü hinzugefügt werden soll und deklariert die Variablen cbp <\/b>(CommandBarPopup<\/b>, für das Untermenü), prp <\/b>(Property<\/b>, für das Durchlaufen der Eigenschaften des Formulars) und cbb <\/b>(CommandBarButton<\/b>, für die anzulegenden Elemente im Untermenü).<\/p>\nPrivate Sub <\/span>PropertiesHinzufuegen(cbr As <\/span>CommandBar)\r\n Dim <\/span>cbp As <\/span>CommandBarPopup\r\n Dim <\/span>prp As <\/span>DAO.Property\r\n Dim <\/span>cbb As <\/span>CommandBarButton\r\n Set<\/span> cbp = cbr.Controls.Add(msoControlPopup, , , , True<\/span>)\r\n On Error Resume Next<\/span>\r\n Do While<\/span> Err.Number = 0\r\n cbr.Controls(\"Eigenschaften\").Delete\r\n Loop<\/span>\r\n On Error GoTo<\/span> 0\r\n cbp.Caption = \"Eigenschaften\"\r\n For Each prp In m_frm.Properties\r\n Set<\/span> cbb = cbp.Controls.Add(msoControlButton, , , , True<\/span>)\r\n On Error Resume Next<\/span>\r\n cbb.Caption = prp.Name & \": \" & prp.Value\r\n On Error GoTo<\/span> 0\r\n Next<\/span> prp\r\nEnd Sub<\/span><\/pre>\n<\/p>\n
Listing 2: Prozedur zum Hinzufügen der Eigenschaften samt ihrer Werte<\/span><\/b><\/p>\nDas CommandBarPopup<\/b>-Element cbp <\/b>legen wir wieder mit der Add<\/b>-Methode der Controls<\/b>-Auflistung des CommandBar<\/b>-Objekts an, diesmal mit dem Typ msoControlPopup <\/b>als Wert des ersten Parameters.<\/p>\n
Dann entfernen wir wieder eventuell vorhandene Elemente namens Eigenschaften <\/b>und weisen dem neu erstellten Element genau diesen Namen zu. Schließlich durchlaufen wir alle Eigenschaften der Properties<\/b>-Auflistung des Formulars aus m_frm<\/b> in einer For Each<\/b>-Schleife. Dabei legen wir für jede Eigenschaft ein neues Element im Untermenü an und weisen diesem als Beschriftung den Namen der Eigenschaft (prp.Name<\/b>) und den Wert der Eigenschaft zu (prp.Value<\/b>).<\/p>\n
Damit ist das Kontextmenü für das Abfragen der Eigenschaften des Formulars so erweitert, dass es die gewünschten Informationen beim Rechtsklick anzeigt.<\/p>\n
Die Klasse clsControls für die Kontextmenüs der Steuer-elemente<\/b><\/p>\n
In der Klasse, die für jede einzelne Steuer-element des Formulars angelegt wird – und auch für Unterformulare und die darin enthaltenen Steuer-elemente -, deklarieren wir zunächst einige Variablen. Als Erstes benötigen wir für jeden gängigen Steuerelementtyp eine Variable, mit der wir das Steuer-element referenzieren können. Diese deklarieren wir mit dem Schlüsselwort WithEvents<\/b>, damit wir wieder das Ereignis Bei Maustaste ab <\/b>im gleichen Klassenmodul implementieren können. Wir deklarieren deshalb für jeden Steuerelementtyp eine eigene Variable, weil diese zwar eine Menge gemeinsamer Eigenschaften aufweisen, jeder Steuerelementtyp aber auch einige individuelle Eigenschaften aufweist:<\/p>\nPrivate <\/span>WithEvents txt As <\/span>TextBox\r\nPrivate <\/span>WithEvents chk As <\/span>CheckBox\r\nPrivate <\/span>WithEvents cbo As <\/span>ComboBox\r\nPrivate <\/span>WithEvents cmd As <\/span>CommandButton\r\nPrivate <\/span>WithEvents lst As <\/span>ListBox\r\nPrivate <\/span>WithEvents lbl As <\/span>Label\r\nPrivate <\/span>WithEvents opt As <\/span>OptionButton\r\nPrivate <\/span>WithEvents ogr As <\/span>OptionGroup\r\nPrivate <\/span>WithEvents tgl As <\/span>ToggleButton\r\nPrivate <\/span>WithEvents sfm As <\/span>SubForm<\/pre>\nWir haben hier die wichtigsten Steuerelementtypen berücksichtigt. Sie können noch weitere Steuerelementtypen hinzufügen, wenn Sie Bedarf haben.<\/p>\n
Außerdem benötigen wie eine Variable, die wir vorübergehend mit dem Verweis auf das Steuer-element füllen:<\/p>\n
Private <\/span>m_ctl As <\/span>Control<\/pre>\nMit objForm <\/b>wollen wir die Instanz der Klasse clsForm <\/b>referenzieren, welche die Steuerelement-Klasse clsControl <\/b>angelegt hat:<\/p>\nPrivate <\/span>objForm As <\/span>clsForm<\/pre>\nUnd in m_IsSubform <\/b>speichern wir wiederum die Information, ob das Steuer-element sich in einem Unterformular befindet:<\/p>\nPrivate <\/span>m_IsSubform As Boolean<\/span><\/pre>\nZum Einstellen der Eigenschaft m_IsSubform <\/b>verwenden wir die folgende Property Let<\/b>-Prozedur:<\/p>\nPublic Property Let <\/span>IsSubform(bol As Boolean<\/span>)\r\n m_IsSubform = bol\r\nEnd Property<\/span><\/pre>\nDie Property Set<\/b>-Prozedur Control <\/b>erlaubt das Hinzufügen des Steuerelements zur Eigenschaft m_ctl<\/b>. Sie wird von der übergeordneten Klasse clsForm <\/b>gefüllt, wenn diese die Steuer-elemente des Formulars durchläuft und für jedes Steuer-element ein Objekt des Typs clsControl <\/b>anlegt (siehe Listing 3).<\/p>\nPublic Property Set<\/span> <\/span>Control(ctl As <\/span>Control)\r\n Set<\/span> m_ctl = ctl\r\n Debug.Print<\/span> ctl.Name, ctl.Parent.Name\r\n Select Case m_ctl.ControlType\r\n Case <\/span>acTextBox\r\n Set<\/span> txt = m_ctl\r\n txt.OnMouseDown = \"[Event Procedure]\"\r\n Case <\/span>acCheckBox\r\n Set<\/span> chk = m_ctl\r\n chk.OnMouseDown = \"[Event Procedure]\"\r\n Case <\/span>acComboBox\r\n Set<\/span> cbo = m_ctl\r\n cbo.OnMouseDown = \"[Event Procedure]\"\r\n Case <\/span>acCommandButton\r\n Set<\/span> cmd = m_ctl\r\n cmd.OnMouseDown = \"[Event Procedure]\"\r\n Case <\/span>acListBox\r\n Set<\/span> lst = m_ctl\r\n lst.OnMouseDown = \"[Event Procedure]\"\r\n Case <\/span>acLabel\r\n Set<\/span> lbl = m_ctl\r\n lbl.OnMouseDown = \"[Event Procedure]\"\r\n Case <\/span>acOptionButton\r\n Set<\/span> opt = m_ctl\r\n opt.OnMouseDown = \"[Event Procedure]\"\r\n Case <\/span>acOptionGroup\r\n Set<\/span> ogr = m_ctl\r\n ogr.OnMouseDown = \"[Event Procedure]\"\r\n Case <\/span>acToggleButton\r\n Set<\/span> tgl = m_ctl\r\n tgl.OnMouseDown = \"[Event Procedure]\"\r\n Case <\/span>acSubform\r\n Set<\/span> sfm = m_ctl\r\n If <\/span>Not<\/span> sfm.Form.HasModule Then<\/span>\r\n MsgBox<\/span> \"Unterformular '\" & sfm.Form.Name & \"' hat kein Klassenmodul, daher werden \" _\r\n & \"Kontextmenüeinträge nicht hinzugefügt.\"\r\n End If<\/span>\r\n Set<\/span> objForm = New<\/span> clsForm\r\n With<\/span> objForm\r\n .IsSubform = True<\/span>\r\n Set<\/span> .Form = sfm.Form\r\n End With<\/span>\r\n Case Else<\/span>\r\n Debug.Print<\/span> m_ctl.ControlType\r\n End Select<\/span>\r\nEnd Property<\/span><\/pre>\nListing 3: Property Set-Prozedur für das Einstellen des Steuerelements der Klasse clsControl<\/span><\/b><\/p>\nDen mit ctl<\/b> übergebenen Verweis auf das Steuer-element speichert die Prozedur in der Variablen m_ctl<\/b>. Dann prüft sie den Typ des Steuerelements über die Eigenschaft ControlType<\/b>. Abhängig davon stellt sie eine der weiter oben vorgestellten Variablen auf das Steuer-element aus m_ctl <\/b>ein. Wenn es sich beispielsweise um ein Textfeld handelt, wird die Variable txt <\/b>mit dem Verweis aus m_ctl <\/b>gefüllt, wenn es sich um ein Kontrollkästchen handelt, landet der Verweis aus m_ctl <\/b>in der Variablen chk <\/b>und so weiter.<\/p>\n
Eine etwas andere Behandlung erfährt das Steuer-element, wenn es sich dabei um ein Unterformular handelt, das den Typ acSubform <\/b>aufweist. In diesem Fall stellen wir zwar wiederum die Variable sfm <\/b>auf den Wert von m_ctl <\/b>ein. Danach prüfen wir aber noch anhand der Eigenschaft HasModule<\/b>, ob das Formular ein Klassenmodul hat. Falls nicht, geben wir eine Meldung aus, denn in diesem Fall können wir zwar das Kontextmenü erweitern, aber die dafür implementierte Ereignisprozedur kann nur ausgelöst werden, wenn das als Unterformular verwendete Formular auch ein Klassenmodul enthält.<\/p>\n
Wenn ein Klassenmodul vorhanden ist, erstellen wir ein neues Element des Typs clsForm<\/b>, dem wir über die Eigenschaft IsSubform <\/b>den Wert True <\/b>zuweisen, da es sich um ein Unterformular handelt. Außerdem stellen wir die Eigenschaft Form <\/b>auf das in sfm <\/b>enthaltene Formular ein.<\/p>\n
Dadurch, dass wir das erledigen, wird in der Klasse clsForm<\/b>, die das Unterformular aufnimmt, auch wieder die For Each<\/b>-Schleife über alle Steuerelemente ausgeführt, um die im Unterformular enthaltenen Steuer-elemente mit den entsprechenden Kontextmenü-Einträgen auszustatten. Sollte das Unterformular weitere Unterformulare enthalten, setzt sich dies entsprechend fort.<\/p>\n
Ereignisprozeduren für die Steuer-elemente<\/b><\/p>\n
Da wir das mit ctl <\/b>übergebene Steuer-element einer der Steuerelement-spezifischen Variablen cbo<\/b>, chk<\/b>, cmd<\/b>, lbl <\/b>und so weiter übergeben, die ihrerseits mit dem Schlüsselwort WithEvents <\/b>deklariert wurden, und wir nicht vorher wissen, in welcher der Variablen das Steuerelement landet, müssen wir auch für jedes dieser Steuer-elemente die Bei Maustaste ab<\/b>-Ereignisprozedur implementieren. Das sieht dann wie folgt aus:<\/p>\nPrivate Sub <\/span>cbo_MouseDown(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n KontextmenueAnzeigen Button, Shift, X, Y\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>chk_MouseDown(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y