<\/p>\n
TreeViews sind sehr flexible Steuer-elemente, die sich vor allem zur Darstellung von Daten in hierarchischen Strukturen etabliert haben. Sie bieten viele verschiedene Möglichkeiten zur Visualisierung von Daten. Außerdem lassen sich die gängigen Ereignisse für die Elemente des TreeView-Steuerelements abbilden – zum Beispiel Mausklicks, Drag and Drop und so weiter. Leider bietet das TreeView-Steuerelement keine eingebaute Möglichkeit, wie bei den Standard-Steuerelementen Kontextmenüs anzuzeigen. Daher schauen wir uns in diesem Beitrag an, wie Sie ein TreeView-Steuerelement um Kontextmenü-Funktionen erweitern und welche Strategien dabei wichtig sind.<\/b><\/p>\n
Aktionen zu TreeView-Einträgen<\/b><\/p>\n
Ein TreeView, das Daten aus verknüpften Tabellen hierarchisch anzeigt, ist in vielen Szenarien sinnvoll: egal, ob Sie nun Kunden, Projekte und Aufgaben, Bauteile mit den einzelnen Elementen oder andere Daten abbilden. Sie können Elemente auf- und zuklappen, Elemente anklicken, um Details dazu in weiteren Steuerelementen anzuzeigen und vieles mehr.<\/p>\n
Was aber noch fehlt, ist die Möglichkeit, Befehle für das aktuell angeklickte Element anzuzeigen. Wenn das TreeView-Steuerelement beispielsweise einen Kunden anzeigt, möchten Sie vielleicht verschiedene Aktionen für diesen Kunden ausführen – ein neues Projekt anlegen, den Kunden löschen oder eine Mail an diesen Kunden schicken.<\/p>\n
Natürlich könnte man solche Befehle über Schaltflächen auslösen, die in einem Detailformular angezeigt werden, das nach einem Klick auf das Kundenelement im TreeView erscheint.<\/p>\n
Die Lösung: Ein Kontextmenü<\/b><\/p>\n
Es geht aber auch noch eleganter, und zwar mit einem Kontextmenü, das genau die zu dem angeklickten Element gehörenden Befehle anzeigt.<\/p>\n
Ein Kontextmenü hat den Vorteil, dass es keinen Platz benötigt – Sie zeigen es an, indem Sie mit der rechten Maustaste auf das Element klicken, wählen die gewünschte Aktion aus und es verschwindet wieder. Im Detailformular würden die Befehle beziehungsweise die Schaltflächen Platz wegnehmen.<\/p>\n
Der Nachteil von Kontextmenüs ist, dass der Benutzer erst einmal wissen muss, dass es diese gibt – immerhin gibt es in der Regel keinen Hinweis darauf, dass sich durch einen Rechtsklick auf ein Element weitere Optionen erschließen lassen.<\/p>\n
Beispieldaten<\/b><\/p>\n
Die Beispieldaten zu diesem Beitrag stammen aus den beiden Tabellen tblKunden <\/b>und tblProjekte<\/b>. Diese sind über das Fremdschlüsselfeld KundeID <\/b>der Tabelle tblProjekte <\/b>verknüpft (siehe Bild 1).<\/p>\n
![\"Datenquelle](\"..\/fileadmin\/_temp_\/2020_04\/pic_1243_001.png\")
<\/p>\n
Bild 1: Datenquelle des TreeView-Steuerelements<\/span><\/b><\/p>\n Die beiden Tabellen haben wir mit einigen Beispieldaten gefüllt – siehe Bild 2.<\/p>\n Bild 2: Daten der beiden Tabellen tblKunden und tblProjekte<\/span><\/b><\/p>\n TreeView-Steuerelement<\/b><\/p>\n Das TreeView<\/b>-Steuerelement fügen wir unter dem Namen ctlTreeView <\/b>zu einem neuen Formular namens frmKundenProjekte <\/b>hinzu (siehe Bild 3).<\/p>\n Bild 3: TreeView und ImageList in der Entwurfsansicht<\/span><\/b><\/p>\n Hier erkennen Sie auch, dass wir bereits ein ImageList<\/b>-Steuerelement hinzugefügt haben.<\/p>\n Dieses nennen wir ctlImageList <\/b>und fügen ihm gleich noch zwei Icons hinzu, die wir mit den Werten user <\/b>und folder <\/b>für die Eigenschaft Key<\/b> versehen (siehe Bild 4).<\/p>\n Bild 4: Bilder im ImageList-Steuerelement<\/span><\/b><\/p>\n Formular vorbereiten<\/b><\/p>\n Da das Formular keine Daten anzeigen soll, stellen wir seine Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen <\/b>und Bildlaufleisten <\/b>auf den Wert Nein <\/b>ein und Automatisch zentrieren <\/b>auf Ja<\/b>.<\/p>\n TreeView formatieren<\/b><\/p>\n Danach stellen wir bereits die notwendigen Eigenschaften für das TreeView<\/b>-Steuerelement ein, was wir per VBA erledigen statt über den Eigenschaften-Dialog des Steuerelements.<\/p>\n Allein das ImageList<\/b>-Steuerelement weisen wir über den Eigenschaften-Dialog zu, und zwar über den Wert ctl-ImageList <\/b>für die Eigenschaft ImageList<\/b>.<\/p>\n Im Klassenmodul des Formulars hinterlegen wir eine Objektvariable für das TreeView<\/b>-Steuerelement:<\/p>\n Dann implementieren wir die Ereignisprozedur, die durch das Ereignis Beim Laden <\/b>des Formulars ausgelöst wird, und stellen darin die wichtigsten Eigenschaften des TreeView<\/b>-Steuerelements ein:<\/p>\n Dazu gehören die Eigenschaften Appearance <\/b>(wir wollen keinen 3D-Effekt, daher stellen wir diese Eigenschaft auf den Wert ccFlat <\/b>ein), BorderStyle<\/b>, LineStyle <\/b>und Style <\/b>– diese Eigenschaft erhält den Wert tvwTreelinesPlusMinusPictureText<\/b>, damit wir ein TreeView wie in Bild 5 erhalten.<\/p>\n Bild 5: Kunden und Projekte im TreeView<\/span><\/b><\/p>\n Die letzte Anweisung der Prozedur ruft eine weitere Routine namens FillTreeView <\/b>auf, die wie in Listing 1 aussieht. Diese Routine referenziert zunächst das Database<\/b>-Objekt der aktuellen Datenbank und füllt dann ein Recordset<\/b>-Objekt mit den Daten der Tabelle tblKunden <\/b>– und zwar nach dem Feld Kunde<\/b> sortiert.<\/p>\n Listing 1: Diese Prozedur füllt das TreeView-Steuerelement<\/span><\/b><\/p>\n Die Datensätze dieses Recordsets durchläuft sie dann in einer Do While<\/b>-Schleife. Innerhalb dieser Schleife erstellt sie zunächst jeweils ein Node<\/b>-Element im TreeView<\/b>-Steuerelement. Dabei weist sie mit der Add<\/b>-Methode der Nodes<\/b>-Auflistung ein Element in der ersten Ebene zu – deshalb bleiben die ersten beiden Parameter der Methode leer.<\/p>\n Der dritte Parameter gibt den Key an, also einen eindeutigen Identifizierer für das Node<\/b>-Element im TreeView<\/b>-Steuerelement. Für den Wert gibt es genau eine Voraussetzung: Er muss mit einem Buchstaben beginnen. Wir können also nicht einfach den Primärschlüsselwert des Kunden für die Eigenschaft Key <\/b>angeben.<\/p>\n Das ist aber auch kein Problem, denn wenn wir das tun könnten, würden wir schnell doppelte Key<\/b>-Werte produzieren, denn ein Primärschlüsselwert kann ja durchaus mehrfach in den Tabellen vorkommen, deren Daten im TreeView<\/b>-Steuerelement angezeigt werden sollen.<\/p>\n Also fügen wir einfach einen Buchstaben voran, der die Art des Eintrags kennzeichnet – hier k <\/b>für Kunde -, und fügen dahinter den Primärschlüsselwert ein. Für den Primärschlüsselwert 123 <\/b>lautet der Key<\/b>-Wert dann also k123<\/b>.<\/p>\n Dahinter folgt der anzuzeigende Text, den wir aus dem Feld Kunde <\/b>des Recordsets entnehmen (rstKunden!Kunde<\/b>). Schließlich geben wir für den Parameter Image <\/b>den Wert user <\/b>an.<\/p>\n Dieser entspricht dem Icon aus dem ImageList<\/b>-Steuer-element, das wir in Zusammenhang mit dem Kunden-Element anzeigen wollen.<\/p>\n Danach erstellt die Prozedur ein weiteres Recordset, dass diesmal alle Datensätze der Tabelle tblProjekte <\/b>enthält, die über das Feld KundeID <\/b>mit dem Kunden verknüpft sind, den wir gerade im Datensatz der übergeordneten Do While<\/b>-Schleife bearbeiten.<\/p>\n Diese Projekt-Datensätze durchlaufen wir ebenfalls in einer Do While<\/b>-Schleife. Innerhalb der Schleife legen wir für jedes Projekt ein neues Element unterhalb des jeweiligen Kunden-Elements an. Für diese Zuordnung nutzen wir die ersten beiden Parameter der Add<\/b>-Methode der Nodes<\/b>-Auflistung.<\/p>\n Der erste nimmt den Key<\/b>-Wert des Node<\/b>-Elements entgegen, unter dem wir das Projekt-Element anlegen wollen.<\/p>\n Der zweite legt fest, in welchem Verhältnis das neue Element zu dem mit dem ersten Parameter referenzierten Element stehen soll – in diesem Fall soll es untergeordnet werden, also verwenden wir den Wert tvwChild<\/b>.<\/p>\n Der dritte, vierte und fünfte Parameter werden analog zum Aufruf der Add<\/b>-Methode für die Kunden-Nodes gefüllt. Der wichtigste Unterschied ist, dass der Wert der Key<\/b>-Eigenschaft mit p <\/b>beginnt (für Projekt). Außerdem verwenden wir das Icon mit der Bezeichnung folder<\/b>.<\/p>\n Auf diese Weise füllen wir mit der Prozedur schnell das TreeView mit allen Datensätzen der beiden Tabellen tblKunden <\/b>und tblProjekte<\/b>.<\/p>\n Kontextmenü anzeigen<\/b><\/p>\n Wenn es keine Eigenschaft gibt, mit der wir ein Kontextmenü zuweisen können und auch kein spezielles Ereignis vorliegt, das dies erledigen würde – wie zeigen wir das Kontextmenü dann an<\/p>\n <\/p>\n Das erledigen wir über einen kleinen Umweg, nämlich über das Ereignis, dass durch das Herunterdrücken der rechten Maustaste ausgelöst wird. Auch dafür gibt es kein spezielles Ereignis, daher nutzen wir das Ereignis, das beim Herunterdrücken beliebiger Maustasten ausgelöst wird: nämlich Bei Maustaste ab<\/b>. Bei ActiveX-Steuerelementen finden wir dieses Ereignis nicht im Eigenschaftsfenster, daher legen wir es direkt über den VBA-Editor an.<\/p>\n Dazu wählen Sie im linken Kombinationsfeld den Namen des Steuerelements aus, hier ctlTreeView<\/b>, und dann im rechten Kombinationsfeld den Eintrag MouseDown<\/b>.<\/p>\n Dies legt dann die Ereignisprozedur ctlTreeView_MouseDown<\/b> an (siehe Bild 6).<\/p>\n Bild 6: Anlegen der Ereignisprozedur für das Ereignis Bei Maustaste ab<\/span><\/b><\/p>\n Auf rechten Mausklick reagieren<\/b><\/p>\n Die Ereignisprozedur füllen wir wie in Listing 2. Sie nimmt unter anderem mit X und Y die aktuelle Position des Mauszeigers entgegen – diese werden wir gleich noch nutzen.<\/p>\n Listing 2: Diese Prozedur reagiert auf Klicks mit der rechten Maustaste.<\/span><\/b><\/p>\n Zunächst einmal ist zu beachten, dass das Ereignis Bei Maustaste ab <\/b>bei jedem Mausklick ausgelöst wird – sowohl mit der linken und der rechten, aber auch mit der mittleren Taste. Welche Maustaste gedrückt wurde, werten wir in einer Select Case<\/b>-Bedingung aus. Diese untersucht den Wert eines weiteren Parameters, nämlich Button<\/b>.<\/p>\n Hat Button den Wert acRightButton<\/b>, hat der Benutzer die rechte Maustaste verwendet und wir führen die Anweisung im ersten und einzigen Case<\/b>-Zweig der Bedingung aus.<\/p>\n In diesem verwenden wir die soeben erwähnten Parameter X <\/b>und Y <\/b>in der HitTest<\/b>-Eigenschaft, um herauszufinden, auf welches Element im TreeView<\/b>-Steuerelement der Benutzer geklickt hat.<\/p>\n Sollte HitTest <\/b>einen Verweis auf ein Element des Typs MSComctlLib.Node <\/b>liefern, wird dieser mit der Variablen objNode <\/b>referenziert. Ob dies der Fall ist, prüft die folgende If…Then<\/b>-Bedingung. Diese prüft, ob objNode <\/b>nicht den Wert Nothing <\/b>aufweist, was bedeutet, dass HitTest <\/b>einen Verweis auf eines der Node<\/b>-Elemente geliefert hat. Ist das der Fall, untersuchen wir das Node<\/b>-Element und lesen einige Informationen daraus aus.<\/p>\n Typ des angeklickten Elements ermitteln<\/b><\/p>\n Als Erstes ermitteln wir den Typ des angeklickten Elements, also ob es sich um ein Kunden- oder ein Projekt-Element handelt. Woran können wir dies festmachen Am ersten Buchstaben des mit der Key<\/b>-Eigenschaft gelieferten Wertes.<\/p>\n Diesen ermitteln wir mit Left(objNode.Key, 1) <\/b>und speichern das Ergebnis in der Variablen strTyp<\/b>. Außerdem benötigen wir gegebenenfalls noch den Primärschlüsselwert des jeweilige Elements. Diesen lesen wir mit Mid(objNode.Key, 2) <\/b>aus, was alle Zeichen der Key<\/b>-Eigenschaft ab dem zweiten Zeichen liefert.<\/p>\n Schließlich lesen wir noch den angezeigten Text in die Variable strText <\/b>ein, den die Eigenschaft Text <\/b>liefert.<\/p>\n Mit der folgenden Select Case<\/b>-Unterscheidung prüfen wir, um welchen Typ es sich bei dem angeklickten Element handelt. Daher prüfen wir hier den Wert der Variablen strTyp<\/b>. Hat die Variable den Wert k<\/b>, soll die Prozedur zunächst eine Meldung anzeigen, welche den Namen des Kunden ausgibt. Handelt es sich um den Wert p<\/b>, wird der Name des Projekts ausgegeben (siehe Bild 7).<\/p>\n Bild 7: Meldungsfenster statt Kontextmenü<\/span><\/b><\/p>\n Damit haben wir schon einmal die beiden Fälle für die unterschiedlichen Elementarten abgedeckt. Was aber geschieht, wenn der Benutzer auf den leeren Bereich im TreeView<\/b>-Steuerelement klickt Auch hier kann die Anzeige eines Kontextmenüs nützlich sein – zum Beispiel wenn Sie das Anlegen neuer Elemente der obersten Ebene des TreeView<\/b>-Steuerelements über das Kontextmenü erlauben wollen.<\/p>\n Dieser Fall tritt auf, wenn objNode <\/b>nach dem Auswerten von HitTest <\/b>kein Element enthält. Wir können dann also davon ausgehen, dass der Benutzer in den leeren Bereich des TreeView<\/b>-Steuerelements geklickt hat.<\/p>\n In diesem Fall können wir einfach den Else<\/b>-Zweig nutzen, um das gewünschte Kontextmenü anzuzeigen.<\/p>\n Kontextmenü anzeigen<\/b><\/p>\n Nun müssen wir noch die Anweisungen, die bisher bei Rechtsklick auf das TreeView<\/b>-Steuerelement eine Meldung angezeigt haben, durch Anweisungen zur Anzeige von Kontextmenüs ersetzen.<\/p>\n Um ein Kontextmenü anzuzeigen, müssen wir dieses zunächst zusammenstellen. Dazu benötigen wir einen Verweis auf die Bibliothek Microsoft Office x.0 Object Library<\/b>. Diesen fügen Sie über den Verweise<\/b>-Dialog hinzu (VBA-Editor, Menüeintrag Extras|Verweise<\/b>) – siehe Bild 8.<\/p>\n Bild 8: Verweis auf die Bibliothek Microsoft Office x.0 Object Library<\/span><\/b><\/p>\n Danach programmieren wir die Funktion für die Anzeige eines Kontextmenüs für ein Kundenelement im TreeView<\/b>-Steuerelement. Die Funktion heißt KontextmenueKunden <\/b>und erwartet zwei Parameter:<\/p>\n Die Funktion finden Sie in Listing 3. Sie deklariert die Variable cbr <\/b>für das CommandBar<\/b>-Objekt, also für das Menü selbst. Die Variable cbc <\/b>nimmt einen Verweis auf die zu erstellende Schaltfläche im Menü auf. Mit objPicture <\/b>referenzieren wir ein StdPicture<\/b>-Objekt, welches das Bild zur Anzeige im Kontextmenü enthält.<\/p>\n Listing 3: Anzeigen eines ersten Kontetxmenüs<\/span><\/b><\/p>\n Das neue Kontextmenü soll TreeView_Kunden <\/b>heißen. Da es immer wieder neu erstellt werden muss, kann es sein, dass noch die zuvor erstellte Version existiert. Diese löschen wir mit der Delete<\/b>-Methode des Elements der Auflistung CommandBars <\/b>mit diesem Namen. Da ein Fehler auftritt, wenn das CommandBar<\/b>-Objekt nicht vorhanden ist, deaktivieren wir zuvor mit On Error Resume Next <\/b>die Fehlerbehandlung.<\/p>\n Nun erstellen wir mit der Add-Methode der gleichen Auflistung das neue Kontextmenü. Der Add<\/b>-Methode übergeben wir als Parameter den Namen des zu erstellenden Menüs und den Wert msoBarPopup <\/b>dafür, dass es als Kontextmenü erstellt wird.<\/p>\n Der dritte Parameter gibt an, dass wir kein Hauptmenü erzeugen wollen und der vierte, dass das Menü temporär erstellt werden soll. Damit wird dieses nach dem Schließen der Anwendung wieder gelöscht.<\/p>\n Danach fügen wir dem mit cbr <\/b>referenzierten Kontextmenü eine neue Schaltfläche hinzu. Dazu nutzen wir die Add<\/b>-Methode der Controls<\/b>-Auflistung des CommandBar<\/b>-Objekts. Dieser übergeben wir den Wert msoControlButton <\/b>dafür, dass ein Steuer-element dieses Typs hinzugefügt wird.<\/p>\n Für das mit der Variablen cbc <\/b>referenzierte neue Element stellen wir dann noch einige Eigenschaften ein:<\/p>\n Nachdem wir das Kontextmenü mit seiner bisher einzigen Schaltfläche fertiggestellt haben, wollen wir es auch noch anzeigen. Dazu nutzen wir die Methode ShowPopup <\/b>des CommandBar<\/b>-Objekts aus der Variablen cbr<\/b>.<\/p>\n Das Ergebnis sieht schließlich wie in Bild 9 aus.<\/p>\n Bild 9: Erstes Kontextmenü mit einem Befehl<\/span><\/b><\/p>\n Funktion der Schaltfläche<\/b><\/p>\n Natürlich soll ein Klick auf die Kontextmenü-Schaltfläche auch noch etwas bewirken – in diesem Fall das Löschen eines Kundendatensatzes. Wir wollen diese Aktion selbst nicht zu Ende programmieren, sondern zeigen nur eine entsprechende Meldung an – es geht schließlich nur darum zu zeigen, wie die aufgerufene Funktion aussehen muss.<\/p>\n Dazu legen wir die folgende Funktion in einem Standardmodul an:<\/p>\n Die Funktion heißt also genau so wie für die Eigenschaft OnAction <\/b>angegeben. Außerdem muss Sie den übergebenen Parameter entgegennehmen. Die Funktion zeigt wie in Bild 10 eine Meldung an.<\/p>\n Bild 10: Per Kontextmenü angezeigte Meldung<\/span><\/b><\/p>\n Die MsgBox<\/b>-Anweisung können Sie noch durch Anweisungen ersetzen, welche die tatsächliche Aufgabe der Kontextmenü-Schaltfläche erledigen.<\/p>\n Weitere Schaltflächen zum Kontextmenü hinzufügen<\/b><\/p>\n Wenn Sie nicht nur eine Schaltfläche benötigen, sondern mehrere, dann können Sie ganz einfach den Codeblock zum Anlegen einer Schaltfläche kopieren, hinter den bestehenden Codeblock einfügen und die notwendigen Einstellungen wie Beschriftung, auszuführender Befehl und Bilder anpassen.<\/p>\n Wenn Sie einige Schaltflächen hinzufügen möchten, wird das allerdings schnell unübersichtlich und fehleranfällig.<\/p>\n Also nehmen wir eine kleine Vereinfachung vor, indem wir diese Befehle in eine eigene Routine auslagern, die wir dann von der eigentlichen Prozedur aus für jede Schaltfläche aufrufen.<\/p>\n Diese Routine finden Sie in Listing 4. Sie erwartet folgende Parameter:<\/p>\n Listing 4: Prozedur zum Hinzufügen einer Schaltfläche zu einem Kontextmenü<\/span><\/b><\/p>\n Die Routine übernimmt die gleichen Funktionen, die wir zuvor in dem entsprechenden Block in der Prozedur KontextmenueKunden <\/b>erledigt haben – nur dass wir diese Anweisungen nun nur noch einmal anzulegen brauchen. Zusätzlich haben wir noch die Option eingebaut, vor einem Kontextmenü-Eintrag einen Trennstrich einzufügen. Dieser wird eingefügt, wenn der Parameter bolSeparator <\/b>den Wert True <\/b>hat. Dadurch stellt die Prozedur den Wert der Eigenschaft BeginGroup <\/b>auf True <\/b>ein.<\/p>\n Wieviel Code wir dadurch in der eigentlichen Prozedur einsparen, sehen wir in Listing 5. Hier benötigen wir für jede anzulegende Schaltfläche nur noch jeweils einen Aufruf der Prozedur AddCommandBarButton<\/b>. Dem zweiten Aufruf haben wir als letzten Parameter den Wert True <\/b>hinzugefügt, damit eine Trennlinie vor diesem Element eingefügt wird. Das Ergebnis sieht wie in Bild 11 aus.<\/p>\n Bild 11: Kontextmenü mit zwei Einträgen<\/span><\/b><\/p>\n Bilder speichern<\/b><\/p>\n Wenn Sie wie im Beispiel Bilder im Kontextmenü anzeigen wollen, brauchen Sie nur zwei Schritte durchzuführen:<\/p>\n Für den ersten Schritt gibt es mehrere Möglichkeiten. Der einfachste ist der über den Entwurf eines Formulars. Sie können ein neues oder ein beliebiges existierendes Formular öffnen und für dieses den Ribbonbefehl Entwurf|Steuerelemente|Bild einfügen <\/b>aufrufen. Dies zeigt einen Dialog an, mit dem Sie die Bilddatei auswählen können. Nach dem Schließen des Dialogs zeigt Access beim Überfahren des Formularentwurfs als Mauszeiger ein Symbol zum Einfügen eines Bild-Steuerelements an. Da wir das Bild gar nicht zum Formular hinzufügen wollen, brechen wir den Vorgang an dieser Stelle mit der Escape<\/b>-Taste ab. Die Bilddatei wurde allerdings dennoch zur Tabelle MSysResources <\/b>hinzugefügt. Die dort gespeicherten Bilddateien können Sie anzeigen, indem Sie erneut auf die Schaltfläche Bild einfügen <\/b>klicken (siehe Bild 12). Die hier angegebenen Beschriftungen geben Sie dann für den vierten Parameter der Prozedur AddCommandButton <\/b>an.<\/p>\n Bild 12: Betrachten verfügbarer Bilddateien<\/span><\/b><\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Dieser Beitrag zeigt, wie Sie Kontextmenü-Einträge für die Elemente eines TreeView<\/b>-Steuerelements anzeigen lassen können. Die Programmierung der Funktionen dieser Kontextmenü-Befehle ist noch ein anderes Thema – immerhin werden dort nicht nur Daten-Operationen ausgeführt wie die folgenden:<\/p>\n![\"Daten](\"..\/fileadmin\/_temp_\/2020_04\/pic_1243_004.png\")
<\/p>\n![\"TreeView](\"..\/fileadmin\/_temp_\/2020_04\/pic_1243_003.png\")
<\/p>\n![\"Bilder](\"..\/fileadmin\/_temp_\/2020_04\/pic_1243_002.png\")
<\/p>\nDim <\/span>WithEvents objTreeView As <\/span>MSComctlLib.TreeView<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objTreeView = Me!ctlTreeView.Object\r\n With<\/span> objTreeView\r\n .Appearance = ccFlat\r\n .BorderStyle = ccNone\r\n .LineStyle = tvwRootLines\r\n .Style = tvwTreelinesPlusMinusPictureText\r\n End With<\/span>\r\n FillTreeView\r\nEnd Sub<\/span><\/pre>\n![\"Kunden](\"..\/fileadmin\/_temp_\/2020_04\/pic_1243_005.png\")
<\/p>\nPrivate Sub <\/span>FillTreeView()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rstKunden As <\/span>DAO.Recordset\r\n Dim <\/span>rstProjekte As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rstKunden = db.OpenRecordset(\"SELECT * FROM tblKunden ORDER BY Kunde\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstKunden.EOF\r\n objTreeView.Nodes.Add , , \"k\" & rstKunden!KundeID, rstKunden!Kunde, \"user\"\r\n Set<\/span> rstProjekte = db.OpenRecordset(\"SELECT * FROM tblProjekte WHERE KundeID = \" & rstKunden!KundeID, _\r\n dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstProjekte.EOF\r\n objTreeView.Nodes.Add \"k\" & rstKunden!KundeID, tvwChild, \"p\" & rstProjekte!ProjektID, _\r\n rstProjekte!Projekt, \"folder\"\r\n rstProjekte.MoveNext<\/span>\r\n Loop<\/span>\r\n rstKunden.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2020_04\/pic_1243_006.png\")
<\/p>\nPrivate Sub <\/span>ctlTreeView_MouseDown(ByVal Button As Integer<\/span>, ByVal Shift As Integer<\/span>, ByVal X As Long<\/span>, ByVal Y As Long<\/span>)\r\n Dim <\/span>strTyp As String<\/span>\r\n Dim <\/span>lngID As Long<\/span>\r\n Dim <\/span>strText As String<\/span>\r\n Dim <\/span>objNode As <\/span>MSComctlLib.Node\r\n Select Case Button\r\n Case <\/span>acRightButton\r\n Set<\/span> objNode = objTreeView.HitTest(X, Y)\r\n If <\/span>Not<\/span> objNode Is Nothing Then<\/span>\r\n strTyp = Left<\/span>(objNode.Key, 1)\r\n lngID = Mid<\/span>(objNode.Key, 2)\r\n strText = objNode.Text\r\n Select Case strTyp\r\n Case <\/span>\"k\"\r\n MsgBox<\/span> \"Rechtsklick auf Kunde '\" & strText & \"'\"\r\n Case <\/span>\"p\"\r\n MsgBox<\/span> \"Rechtsklick auf Projekt '\" & strText & \"'\"\r\n End Select<\/span>\r\n Else<\/span>\r\n MsgBox<\/span> \"Rechtsklick auf leeren Bereich\"\r\n End If<\/span>\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Meldungsfenster](\"..\/fileadmin\/_temp_\/2020_04\/pic_1243_007.png\")
<\/p>\n![\"Verweis](\"..\/fileadmin\/_temp_\/2020_04\/pic_1243_008.png\")
<\/p>\n\n
Private Sub <\/span>KontextmenueKunden(lngID As Long<\/span>, strText As String<\/span>)\r\n Dim <\/span>cbr As <\/span>Office.CommandBar\r\n Dim <\/span>cbc As <\/span>Office.CommandBarButton\r\n Dim <\/span>objPicture As <\/span>StdPicture\r\n On Error Resume Next<\/span>\r\n CommandBars(\"TreeView_Kunden\").Delete\r\n Set<\/span> cbr = CommandBars.Add(\"TreeView_Kunden\", msoBarPopup, False, True<\/span>)\r\n With<\/span> cbr\r\n Set<\/span> cbc = .Controls.Add(msoControlButton)\r\n With<\/span> cbc\r\n .Caption = \"Kunde löschen\"\r\n .OnAction = \"=KundeLoeschen(\" & lngID & \")\"\r\n Set<\/span> objPicture = ResourceToPicture(\"user_16_delete\")\r\n .Picture = objPicture\r\n .Mask = MaskFromPicture(objPicture)\r\n End With<\/span>\r\n .ShowPopup\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n\n
![\"Erstes](\"..\/fileadmin\/_temp_\/2020_04\/pic_1243_009.png\")
<\/p>\nPublic Function <\/span>KundeLoeschen(lngID As Long<\/span>)\r\n MsgBox<\/span> \"Kunde mit der ID \" & lngID & \" wird gelöscht.\"\r\nEnd Function<\/span><\/pre>\n![\"Per](\"..\/fileadmin\/_temp_\/2020_04\/pic_1243_010.png\")
<\/p>\nPrivate Sub <\/span>AddCommandBarButton(cbr As <\/span>CommandBar, strCaption As String<\/span>, strOnAction As String<\/span>, strPicture As String<\/span>, _\r\n Optional<\/span> bolSeparator As Boolean<\/span>)\r\n Dim <\/span>cbc As <\/span>CommandBarButton\r\n Dim <\/span>objPicture As <\/span>StdPicture\r\n Set<\/span> cbc = cbr.Controls.Add(msoControlButton)\r\n With<\/span> cbc\r\n .Caption = strCaption\r\n .OnAction = strOnAction\r\n Set<\/span> objPicture = ResourceToPicture(strPicture)\r\n .Picture = objPicture\r\n .Mask = MaskFromPicture(objPicture)\r\n If <\/span>bolSeparator = True<\/span> Then<\/span>\r\n .BeginGroup = True<\/span>\r\n End If<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n\n
![\"Kontextmenü](\"..\/fileadmin\/_temp_\/2020_04\/pic_1243_011.png\")
<\/p>\n\n
![\"Betrachten](\"..\/fileadmin\/_temp_\/2020_04\/pic_1243_012.png\")
<\/p>\n