<\/p>\n
„Ein TreeView füllen – mit hierarchischen Daten Das ist doch wohl ein alter Hut!“ Das stimmt wohl, denn genau dafür ist dieses Steuerelement ja nun auch gemacht. Wir vereinfachen das Füllen des TreeViews aber ein wenig, indem wir eine Methode bereitstellen, bei der Sie nur noch die Namen der betroffenen Tabelle in eine weitere Tabelle schreiben und die beim Klicken auf die Elemente des TreeViews durchzuführenden Aktionen festlegen müssen.<\/b><\/p>\n
Haben Sie schon mal ein TreeView programmiert, das zumindest die üblichen Funktionen wie das Hinzufügen untergeordneter Elemente, das Löschen des aktuellen Knotens, das Auf- und Zuklappen von Zweigen, sowie das automatische Speichern des Zustands des TreeViews implementiert<\/p>\n
Und welches zusätzlich, um die Performance zu verbessern, nur jeweils die sichtbaren Elemente plus der folgenden Ebene anlegt, damit nicht alle Elemente gleich zu Beginn geladen werden müssen und dies somit möglicherweise zu Verzögerungen führt<\/p>\n
Nun, dann wissen Sie, wie viel Arbeit so etwas verursachen kann – egal, ob Sie die Daten aus den Tabellen eines hierarchisch aufgebauten Datenmodells beziehen oder aus einer Tabelle, die reflexiv mit sich selbst verknüpft ist.<\/p>\n
Wenn Sie sich mit ein paar Randbedingungen abfinden und die nachfolgend vorgestellten Standardfunktionen für Ihren Anwendungsfall ausreichen, können Sie die Lösung dieses Beitrags gleich einsetzen. Wenn nicht, müssen Sie entweder selbst noch Funktionen hinzufügen oder uns die fehlenden Funktionen mitteilen – wir werden uns nicht scheuen, sinnvolle Erweiterungen für Sie zu entwickeln und in einer späteren Ausgabe von Access im Unternehmen <\/b>zu veröffentlichen.<\/p>\n
Bild 1 zeigt ein Beispiel für ein mit dem hier vorgestellten Tool gesteuerten TreeView-Steuerelement. Sie können damit sowohl die Daten aus hierarchisch angeordneten Tabellen als auch von Daten aus reflexiven Beziehungen darstellen – auch gemischt. In den folgenden Abschnitten erfahren Sie, wie dies funktioniert und welche Voraussetzungen nötig sind.<\/p>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2009_03\/TreeView-web-images\/pic001_opt.jpeg\")
<\/p>\n
Bild 1: TreeView mit hierarchischen und reflexiven Tabellen<\/span><\/b><\/p>\n Voraussetzungen des Datenmodells<\/p>\n Die Voraussetzungen beziehen sich in erster Linie auf den Aufbau der Tabellen, deren Daten im TreeView angezeigt werden sollen. Diese sehen so aus:<\/p>\n Abfragen statt Tabellen<\/b><\/p>\n Die geforderten Informationen können auch in Form einer Abfrage bereitgestellt werden. Dies macht beispielsweise Sinn, wenn Personennamen im TreeView angezeigt werden sollen und diese Namen nicht in einem einzelnen Feld, sondern in Feldern wie Vorname<\/b> und Nachname <\/b>liegen. Sie können dann eine Abfrage definieren, die diese Felder zu einem Feld zusammenfasst, das dann als Herkunft für die anzuzeigenden Felder dient.<\/p>\n Auch kann es sein, dass eine reflexive Beziehung nicht direkt über ein in der Tabelle befindliches Fremdschlüsselfeld hergestellt wird, sondern über eine Verknüpfungstabelle, welche neben einem Primärschlüsselfeld zwei Fremdschlüsselfelder für die Aufnahme der beiden Primärschlüsselwerte der beteiligten Datensätze aufnehmen soll. Auch hier müssen Sie eine Abfrage so erstellen, dass diese die eigentlichen Daten der Tabelle enthält und auch die Verknüpfungstabelle aufnimmt. Ein Beispiel finden Sie weiter unten.<\/p>\n Notwendige Elemente<\/b><\/p>\n Die hier vorgestellte Lösung ist kein externes Tool, das Ihnen den Code für das TreeView-Steuerelement zusammenbaut, sondern es liefert selbst den Code. Es erstellt also kein TreeView, sondern es steuert seine Erstellung und auch das TreeView und seine Elemente selbst. Aus der Beispieldatenbank zu diesem Beitrag müssen Sie die folgenden Elemente in die Zieldatenbank importieren:<\/p>\n Notwendige Verweise<\/b><\/p>\n Außerdem brauchen Sie einen Verweis auf die Microsoft Office x.0 Object Library<\/b> sowie OLE Automation<\/b>, die Sie im Verweise<\/b>-Dialog (Extras|Verweise<\/b>) des VBA-Editors einstellen.<\/p>\n Grundgerüst<\/b><\/p>\n Das Grundgerüst unserer Lösung besteht aus einem Formular mit den folgenden Steuerelementen:<\/p>\n Hinzu kommt, soweit gewünscht, ein Unterformularsteuerelement zur Anzeige der Unterformulare mit den Detaildaten zum jeweils im TreeView-Steuerelement ausgewählten Element. Wenn Sie die oben genannten Steuerelemente zu einem neuen Formular namens frmProjekte<\/b> hinzugefügt haben, können Sie das Projekt erstmalig kompilieren, was im Erfolgsfall heißt, dass alle Komponenten und Verweise vorliegen.<\/p>\n Steuerelemente benennen<\/b><\/p>\n Da das ImageList-Steuerelement und das TreeView-Steuerelement später vom Code aus referenziert werden sollen, vergeben Sie nun aussagekräftige Namen für diese Elemente, am besten die folgenden:<\/p>\n TreeView konfigurieren<\/b><\/p>\n Wir kümmern uns zunächst nur um das Anlegen der nötigen Tabellen und um das Füllen des TreeView-Steuerelements. Zuallererst benötigen wir eine Tabelle, welche die Daten für die Elemente der ersten Ebene liefert.<\/p>\n Diese Tabelle nennen wir tblProjekte <\/b>und füllen sie mit den Feldern aus Bild 2. Dies sind die mindestens notwendigen Felder für die Integration der Daten einer Tabelle in das TreeView – zumindest unter Verwendung unserer Lösung. Legen Sie dann zu Beispielzwecken einige Datensätze wie in Bild 3 an.<\/p>\n Bild 2: Die Tabelle mit den Elementen der obersten Ebene in der Entwurfsansicht …<\/span><\/b><\/p>\n Bild 3: … und in der Datenblattansicht mit einigen Einträgen.<\/span><\/b><\/p>\n TreeViewHandler aufrufen<\/b><\/p>\n Damit das Formular beim Öffnen mit den gewünschten Daten gefüllt wird, müssen Sie dafür sorgen, dass es eine spezielle Klasse namens clsTreeViewHandler <\/b>instanziert und dieser einige Informationen zuweist. Dies ist nicht besonders aufwendig und kann in der Ereignisprozedur Form_Load <\/b>geschehen. Theoretisch ginge auch Form_Open<\/b>, hier kann es jedoch zu Problemen kommen, weil die ActiveX-Steuerelemente möglicherweise noch nicht initialisiert sind.<\/p>\n Für den Verweis auf die Klasse clsTreeViewHandler <\/b>legen Sie folgende modulweit gültige Variable im Klassenmodul des Formulars fest:<\/p>\n Diese instanzieren Sie gleich in der ersten Zeile der Ereignisprozedur Form_Load<\/b>. Anschließend weisen Sie dem neu erzeugten Objekt Verweise auf das TreeView<\/b>-Steuerelement und das ImageList<\/b>-Steuerelement zu und rufen die beiden Methoden InitTreeView <\/b>und FillTree <\/b>auf:<\/p>\n InitTreeView <\/b>erwartet noch einen Parameter, zu diesem kommen wir gleich. Erstmal müssen wir noch festlegen, welche Daten überhaupt im TreeView angezeigt werden sollen – wir sind noch nicht so weit, dass sich der TreeViewHandler die benötigten Tabellen selbst zusammensucht.<\/p>\n Dazu öffnen Sie das Formular frmTreeViewConf<\/b>, das erst einmal eine InputBox <\/b>zur Eingabe des Namens eines TreeViews voranschickt (siehe Bild 4). Die Eingabe speichert der TreeView-Konfigurator in der Tabelle tblTreeViews<\/b>. Der Hintergrund ist, dass eine Datenbank durchaus mehr als ein TreeView-Steuerelement enthalten kann (genau genommen kann sogar ein einziges Formular mehr als ein TreeView-Steuerelement anzeigen) und der TreeView-Konfigurator diese auch verwalten können soll.<\/p>\n Bild 4: Abfrage der Bezeichnung des TreeViews<\/span><\/b><\/p>\n Dann folgt der große Moment: Der TreeView-Konfigurator erscheint und erschlägt Sie vermutlich erstmal durch seine vielen Elemente (siehe Bild 5). Das TreeView-Steuerelement Projektbaum <\/b>ist im oberen Kombinationsfeld bereits ausgewählt.<\/p>\n Bild 5: Der TreeView-Konfigurator<\/span><\/b><\/p>\n Der obere Teil zeigt eine Übersicht aller im TreeView anzuzeigenden Tabellen an. Dort wählen Sie eine Tabelle aus und erhalten im Bereich darunter alle Details dieser Tabelle, die Sie dort auch direkt bearbeiten können. Außerdem finden Sie dort Steuerelemente zum Anlegen einer neuen Tabelle, zum Löschen der aktuell angezeigten Tabelle, sowie zum Speichern.<\/p>\n Der untere Bereich zeigt ebenfalls eine Liste an, die Sie allerdings direkt bearbeiten können. Dort tragen Sie alle Kontextmenüeinträge ein, die in Zusammenhang mit den Elementen der aktuellen Tabelle im TreeView erscheinen sollen, wenn der Benutzer mit der rechten Maustaste darauf klickt. Wie Sie Code anlegen, um auf diese Mausklicks zu reagieren, erfahren Sie später.<\/p>\n Nun tragen Sie die bereits angelegte Tabelle tblProjekte <\/b>in den TreeView-Konfigurator ein. Die Daten dieser Tabelle sehen nun etwa so wie in Bild 6 aus. Im Einzelnen bedeuten diese Einträge Folgendes:<\/p>\n Bild 6: Die Werte für die erste Tabelle im TreeView-Konfigurator<\/span><\/b><\/p>\n Der erste Test<\/p>\n Vor dem ersten Test ist noch eine Anpassung im Code nötig: Wir haben der Methode InitTreeView <\/b>in der Ereignisprozedur Form_Load <\/b>zunächst den Wert 1 <\/b>als Parameter mitgegeben.<\/p>\n <\/p>\n Dort muss aber die ID der soeben im TreeView-Konfigurator angelegten TreeViews-Konfiguration stehen, die Sie dem Textfeld aus Bild 7 entnehmen können.<\/p>\n Bild 7: Der TreeView-Konfigurator zeigt die ID des aktuell ausgewählten TreeViews an.<\/span><\/b><\/p>\n Das Ergebnis ist ernüchternd: Die beiden Einträge der ersten angelegten Tabelle sehen ein wenig aus wie bestellt und nicht abgeholt – dies bekommt man fast auch mit einem einfachen Listenfeld hin (siehe Bild 8).<\/p>\n Bild 8: Das TreeView-Steuerelement mit der ersten Beispieltabelle<\/span><\/b><\/p>\n Erstmal fehlt hier ein schickes Icon und zweitens wären Plus-Zeichen zum Aufklappen untergeordneter Elemente nicht schlecht (und entsprechende Minus-Zeichen zum Minimieren).<\/p>\n Okay: Um die Icons haben wir uns noch gar nicht gekümmert und um Plus-Zeichen zum Ein- und Ausklappen von untergeordneten Elementen braucht man erstens erst einmal untergeordnete Elemente.<\/p>\n Zweite Tabelle hinzufügen<\/p>\n Fügen wir also eine weitere Tabelle zum TreeView-Konfigurator hinzu. Diese soll tblMeilensteine <\/b>heißen und enthält gegenüber der Tabelle tblProjekte <\/b>noch ein weiteres Feld zum Herstellen der Beziehung mit dieser Tabelle. Im Beziehungsfenster der Datenbank sieht dies wie in Bild 9 aus. Die Tabelle tragen Sie nun ebenfalls in den TreeView-Konfigurator ein, und zwar mit den folgenden Werten:<\/p>\n Bild 9: Die Tabelle tblMeilensteine und ihre Verknüpfung mit der Tabelle tblProjekte<\/span><\/b><\/p>\n Das Ergebnis kann sich schon eher sehen lassen (siehe Bild 10). Es erscheinen zumindest einige untergeordnete Elemente (die Sie allerdings zuvor noch anlegen müssen).<\/p>\n Bild 10: Schon besser: Unterelemente zum Ein- und Ausklappen<\/span><\/b><\/p>\n Sonderfälle für untergeordnete Tabellen<\/b><\/p>\n Auch das System für das Hinzufügen weiterer Tabellen sollte nun klar sein. Es gibt eigentlich nur noch zwei Sonderfälle, die wichtig sind:<\/p>\n Behandlung reflexiver Beziehungen<\/b><\/p>\n Wenn eine Tabelle mit sich selbst verknüpft ist, tragen Sie diese einfach zweimal in den TreeView-Konfigurator ein. Der erste Eintrag dient dazu, die Einträge ganz normal unterhalb der Elemente einer übergeordneten Tabelle einzusortieren. Der zweite stellt dann die Beziehung der Elemente dieser Tabelle untereinander her.<\/p>\n Im Gegensatz zur üblichen Notation von Tabellen im TreeView-Konfigurator tragen Sie als ParentTable <\/b>die gleiche Tabelle nochmal ein, die Sie bereits als ThisTable <\/b>eingetragen haben, und als FKIDField <\/b>geben Sie das Fremdschlüsselfeld an, das den Wert des Primärschlüsselfeldes des Datensatzes in der gleichen Tabelle enthält, dem der aktuelle Datensatz untergeordnet werden soll.<\/p>\n Das Ergebnis sollte etwa so aussehen wie in Bild 11. Dort wurden einige Aufgaben-Elemente untereinander angeordnet. Die Tabelle tblAufgaben<\/b> muss dazu freilich ein weiteres Fremdschlüsselfeld erhalten, sodass diese nun wie in Bild 12 aussieht.<\/p>\n Bild 11: TreeView mit reflexiv verknüpften Elementen<\/span><\/b><\/p>\n Bild 12: Die Tabelle tblAufgaben besitzt mit KundenstoryID und ParentaufgabeID zwei Fremdschlüsselfelder.<\/span><\/b><\/p>\n Was fürs Auge<\/b><\/p>\n Weiter oben haben wir das Fehlen von Icons bemängelt. Auch hier nimmt der TreeView-Konfigurator Ihnen einige Arbeit ab. Im harten Entwickleralltag müssten Sie zunächst alle benötigten Bilder in das dafür vorgesehene ImageList<\/b>-Steuerelement laden und den TreeView-Elementen dann beim Anlegen die Bezeichnung der Bilder mit auf den Weg geben. Der Weg des TreeView-Konfigurators sieht ganz anders aus:<\/p>\n Dabei gibt es eine Besonderheit: Normalerweise sollten alle Elemente einer Tabelle auch das gleiche Bild anzeigen. Möglicherweise wollen Sie aber über das Bild verschiedene Status verschiedener Elemente aus der gleichen Tabelle darstellen – beispielsweise um erledigte Aufgaben mit einem Häkchen zu versehen.<\/p>\n Daher enthält auch jede Tabelle ein Feld namens Image<\/b>, das für jeden Datensatz eine individuelle Bildbezeichnung aufnimmt. Beim Füllen des TreeView-Steuerelements prüft der TreeView-Konfigurator dann, ob der einzelne Datensatz ein individuelles Bild erfordert, und zeigt dieses gegebenenfalls an.<\/p>\n Ist keines angegeben, wird das allgemein für Datensätze dieser Tabelle vorgemerkte Bild verwendet. Schließlich kann, wie es beim aktuellen Zustand unseres Beispiels der Fall ist, auch gar kein Bild angegeben worden sein – in diesem Fall wird eben überhaupt kein Bild angezeigt.<\/p>\n Wie aber gelangen die Bilder überhaupt in die Tabelle tblImages<\/b> Dazu verwenden Sie eine Routine namens SaveFileToOLEField<\/b>. Der folgende Aufruf etwa speichert eine im aktuellen Verzeichnis befindliche Datei namens application.png <\/b>im Feld ImageObject <\/b>der Tabelle tblImages<\/b>:<\/p>\n Anschließend müssen Sie für den neuen Datensatz noch das Feld ImageName <\/b>füllen, und zwar mit application.png<\/b>. Die Datei liegt nun in einem Format in diesem Feld vor, das der TreeView-Konfigurator in das ImageList<\/b>-Steuerelement einlesen kann.<\/p>\n Die Tabelle tblImages <\/b>der Beispieldatenbank enthält einige Beispielbilder, die Sie den einzelnen Tabellen beziehungsweise Datensätzen wie folgt zuweisen können:<\/p>\n Da die Tabelle tblAufgaben <\/b>im TreeView-Konfigurator zweimal enthalten ist, müssen Sie auch beiden Exemplaren das entsprechende Image zuweisen.<\/p>\n Damit Sie erkennen, dass sich auch individuell in den Datensätzen der Tabellen eingetragene Bilder auswirken, fügen Sie einem Datensatz der Tabelle tblAufgaben <\/b>das Bild note_ok.png <\/b>hinzu, das zusätzlich zum Bild note.png <\/b>noch ein Erledigt-Symbol aufweist. Bild 13 zeigt das Ergebnis.<\/p>\n Bild 13: TreeView mit Icons<\/span><\/b><\/p>\n Ereignisse abfangen<\/b><\/p>\n Nun haben Sie zwar ein schönes TreeView, aber was hilft das, wenn Sie noch nicht einmal den Mausklick auf eines der Elemente abfangen und mit entsprechendem Code darauf reagieren können – also so, wie Sie es vielleicht von vorherigen TreeView-Entwicklungen gewohnt sind<\/p>\n Der TreeView-Konfigurator bietet eine vereinfachte Handhabung solcher Ereignisse. Das Ziel beim Schreiben von Code für den Mausklick auf ein Element des TreeView-Steuerelements ist normalerweise, seine Details in einem neben dem TreeView-Steuerelement angezeigten Unterformular anzuzeigen.<\/p>\n Dies erfordert zunächst die Identifikation des betroffenen TreeView-Elements, und dann geht es erst richtig los: Sie müssen auf Basis dieser Information herausfinden, welcher Datensatz aus welcher Tabelle durch dieses Element abgebildet wird, und zeigen dann dessen Daten an.<\/p>\n Der TreeView-Konfigurator nimmt Ihnen den größten Teil dieser Aufgabe ab. Dadurch, dass Sie mit der Eigenschaft KeyChar <\/b>einen Buchstaben festgelegt haben, der für jede Tabelle eindeutig ist, und dadurch, dass die Key<\/b>-Eigenschaft des aktuellen Elements nicht nur diesen Buchstaben, sondern auch noch den Wert des Primärschlüsselfelds des betroffenen Datensatzes enthält, kann das entsprechende Ereignis leicht die benötigten Informationen aufbereiten.<\/p>\n Im Klassenmodul des Formulars können Sie nun, da Sie das clsTreeViewHandler<\/b>-Element als WithEvents <\/b>deklariert haben, auf dessen Ereignisse zurückgreifen. Wählen Sie einfach im linken Kombinationsfeld des Codefensters den Eintrag objTreeViewHandler <\/b>und im rechten NodeClick <\/b>aus (siehe Bild 14). Wenn Sie schon Erfahrung im Umgang mit der Programmierung des TreeView-Steuerelements haben, wird Ihnen auffallen, dass der nun erscheinende Prozedurkopf ganz anders aussieht als der des Click-Ereignisses herkömmlicher TreeView-Steuerelemente:<\/p>\n Bild 14: Anlegen eines NodeClick-Ereignisses im VBA-Editor<\/span><\/b><\/p>\n Er liefert nämlich ganz andere Parameter, mit denen Sie im vorliegenden Fall viel mehr anfangen können als mit den sonst gelieferten. Die Parameter lauten:<\/p>\n Damit können Sie alles erledigen, was in Zusammenhang mit der Anzeige von Daten bezogen auf dieses Element nötig ist: Zum Beispiel das Anzeigen eines Unterformulars mit dem ausgewählten Datensatz als Datenherkunft.<\/p>\n Auch für den Doppelklick gibt es ein entsprechendes Ereignis, das sich anbietet, um ein Popup-Formular mit den Daten des hinter dem jeweiligen Element stehenden Datensatzes zu öffnen.<\/p>\n Wie das genau funktioniert, zeigen wir im Beitrag Softwareprojektverwaltung <\/b>(s. Shortlink 669). An dieser Stelle beschränken wir uns auf die grundlegende Funktionsweise, bei der einfach nur ein Meldungsfenster mit den übergebenen Informationen erscheint. Dazu bestücken Sie die Ereignisprozedur wie in Listing 1.<\/p>\n Listing 1: Anzeigen eines Meldungsfensters beim Anklicken eines TreeView-Elements<\/p>\n Das Ergebnis sieht dann etwa so wie in Bild 15 aus.<\/p>\n Bild 15: Nach dem Klick auf ein Element im TreeView erscheint diese Meldung, die Sie natürlich auch durch beliebige andere Elemente wie etwa Detailformulare ersetzen können.<\/span><\/b><\/p>\n Kontextmenüs<\/b><\/p>\n Im TreeView sind Kontextmenüs ein wichtiges Instrument zum Durchführen von Aktionen wie Löschen des aktuellen Datensatzes oder Hinzufügen neuer Unterknoten. Vielleicht soll Ihr TreeView-Steuerelement auch Dateien repräsentieren, für die es Kontextmenüeinträge zum Öffnen oder Drucken bereitstellt – der Fantasie sind hier keine Grenzen gesetzt.<\/p>\n Zunächst einmal müssen Sie dafür sorgen, dass beim Rechtsklick auf die Elemente des TreeViews überhaupt Kontextmenüeinträge angezeigt werden. Dazu öffnen Sie erneut den TreeView-Konfigurator, wählen die Tabelle aus, für deren Einträge Sie Kontextmenübefehle festlegen möchten, und widmen sich dann dem Unterformular ganz unten. Markieren Sie beispielsweise die Tabelle tblProjekte <\/b>und legen Sie unten die beiden Einträge aus Bild 16 an.<\/p>\n Bild 16: Anlegen von Kontextmenüeinträgen<\/span><\/b><\/p>\n Die Werte der ersten Spalte entsprechen dem im Kontextmenü angezeigten Text, die der zweiten enthaltenen Parameterwerte, die der weiter unten beschriebenen Ereignisprozedur beim Auswählen eines Kontextmenüeintrags übergeben werden.<\/p>\n Wenn Sie das Formular frmProjekte <\/b>nun erneut öffnen und mit der rechten Maustaste auf einen der Projekt-Einträge klicken, erscheint schon das Kontextmenü aus Bild 17.<\/p>\n Bild 17: Das frisch angelegte Kontextmenü<\/span><\/b><\/p>\n Nun müssen Sie nur noch entscheiden, was nach dem Klick auf einen der Kontextmenüeinträge geschehen soll. Grundlage dafür ist eine weitere Ereignisprozedur des Objekts objTreeViewHandler <\/b>namens ShortcutMenuClick<\/b>. Dieses sieht nach dem Anlegen wie folgt aus:<\/p>\n Sie sehen die gleichen Parameter, die Sie bereits vom Click<\/b>-Ereignis her kennen, und ein zusätzliches Element namens strParameter<\/b>. Dieser liefert genau den Wert, den Sie in der zweiten Spalte des Kontextmenü-Unterformulars im TreeView-Konfigurator angegeben haben.<\/p>\n Aufgrund dieses Werts wissen Sie genau, welchen Kontextmenüeintrag der Benutzer angeklickt hat, und mit den drei übrigen Parametern liefert die Ereignisprozedur ausreichend Informationen, um das Element des TreeViews zu identifizieren, mit dem die gewünschte Aktion durchgeführt werden soll.<\/p>\n TreeView-Elemente löschen<\/b><\/p>\n Wie setzen Sie dies nun ein Wir schauen uns das am Beispiel eines Löschvorgangs an. Ein Projekt soll also gelöscht werden. Die Ereignisprozedur liefert dazu beispielsweise die folgenden Informationen:<\/p>\n Diese werten Sie in der Ereignisroutine wie in Listing 2 aus.<\/p>\n Listing 2: Auswerten einer Kontextmenü-Aktion<\/p>\n Dies löscht recht zuverlässig den ausgewählten Datensatz. Wie aber wird das TreeView-Steuerelement aktualisiert, also das entsprechende Element entfernt<\/p>\n Beim nächsten Öffnen geschieht das zwar automatisch, weil der Datensatz nicht mehr vorhanden ist, aber das Element soll ja direkt nach dem Löschen nicht mehr zu sehen sein.<\/p>\n Dazu können Sie eine der Methoden des TreeViewHandlers verwenden. Die für diesen Fall geeignete heißt schlicht DeleteCurrentNode<\/b> und wird so aufgerufen:<\/p>\n Parameter sind nicht nötig, weil das betroffene Element ja durch den Aufruf des Kontextmenüs ausgewählt wurde und die Methode das aktuell ausgewählte Element aus dem TreeView entfernt.<\/p>\n TreeView-Elemente hinzufügen<\/p>\n Wer Elemente entfernen möchte, muss zunächst einmal welche hinzufügen. Wenn man dies ausschließlich über Kontextmenüeinträge erledigen möchte, fällt direkt beim Versuch, ein Projekt anzulegen, eine Schwachstelle des Aufbaus unseres TreeViews auf: Es gibt kein Element, das den Projekt-Elementen übergeordnet ist, und somit gibt es auch keine wirklich geeignete Stelle, um einen Neues Projekt<\/b>-Kontextmenüeintrag anzulegen.<\/p>\n Wir tricksen an dieser Stelle ein wenig und führen eine neue Tabelle namens tblRoot <\/b>ein, die nur die Felder ID<\/b>, Root<\/b>, Image <\/b>und Expanded <\/b>enthält und mit einem Datensatz gefüllt ist, der in der Reihenfolge der zuvor genannten Felder diese Werte enthält: 1<\/b>, Projekte<\/b>, application.png<\/b>, true<\/b>.<\/p>\n Fügen Sie diese Tabelle zum TreeView-Konfigurator hinzu, wie Sie es zuvor mit der Tabelle tblProjekte <\/b>gemacht haben. Die Tabelle tblProjekte <\/b>hingegen soll nun dieser Root-Tabelle untergeordnet werden.<\/p>\n Dazu braucht sie zunächst ein Fremdschlüsselfeld namens RootID<\/b>. Damit der TreeView-Konfigurator erkennt, dass die Tabelle tblProjekte <\/b>der Tabelle tblRoot <\/b>untergeordnet ist, müssen Sie dem Datensatz für die Tabelle tblProjekte <\/b>noch den Wert tblRoot <\/b>für Parenttabelle und RootID <\/b>für FKID <\/b>hinzufügen.<\/p>\n Wenn Sie nun das Formular frmProjekte <\/b>öffnen, befindet sich vor dem Element mit der Bezeichnung Projekte <\/b>allerdings noch ein Plus-Zeichen zum Ein- und Ausklappen aller Projekte. Wenn dieses nicht angezeigt werden soll, müssen Sie in der Form_Open<\/b>-Ereignisprozedur hinter dem Aufruf der Methode InitTreeView <\/b>noch die Eigenschaft LineStyle<\/b> auf tvwTreeLines <\/b>einstellen:<\/p>\n Dies ist eine von mehreren Eigenschaften, die das Aussehen des TreeViews beeinflussen. Viele davon werden automatisch auf bestimmte Standardwerte eingestellt, die nicht unbedingt den üblicherweise beim TreeView-Steuerelement voreingestellten Werten entsprechen. Sie können diese Eigenschaften jedoch per Code für objTreeViewHandler <\/b>einstellen.<\/p>\n Noch ein kleiner Hinweis: Einstellungen, die Sie direkt im Eigenschaften-Dialog des TreeView-Steuerelements vornehmen, werden per Code überschrieben. Sie können sich dies also direkt sparen und die entsprechenden Einstellungen im Form_Open<\/b>-Ereignis hinter dem Aufruf der InitTreeView<\/b>-Methode platzieren.<\/p>\n Kommen wir aber nun zum Anlegen von Projekten: Dazu legen Sie im TreeView-Konfigurator für den Eintrag tblRoot <\/b>ein Kontextmenü <\/b>mit dem Eintrag Neues Projekt <\/b>und dem Parameter AddProject <\/b>an.<\/p>\n Dieses erscheint dann auch beim nächsten Öffnen des Formulars frmProjekte<\/b>.<\/p>\n Zum Anlegen eines neuen Projekts brauchen Sie ein paar Zeilen mehr als zum Löschen eines Elements – in einfachsten Fall aber auch nicht viel mehr. Dabei gehen wir davon aus, dass Sie einfach nur den Projektnamen eingeben müssen, um den neuen Datensatz anzulegen.<\/p>\n Dies erledigen wir ganz schnell mit einer InputBox<\/b>. Wenn die Konsistenz Ihrer Daten die Eingabe weiterer Informationen erfordert, schauen Sie sich die nächste Variante an.<\/p>\n Im vorliegenden einfachen Fall deklarieren Sie zunächst zwei Variablen in der Ereignisprozedur objTreeViewHandler_ShortcutMenuClick<\/b>, die Sie bereits zuvor kennengelernt haben:<\/p>\n Dann erweitern Sie das bestehende Select Case<\/b>-Konstrukt wie in Listing 3.<\/p>\n Die Anweisungen fragen zunächst per InputBox <\/b>den Namen des neuen Projekts ab und schreiben dann einen neuen Datensatz in die Tabelle tblProjekte<\/b>.<\/p>\n Auch hier soll der neue Datensatz gleich im TreeView angezeigt werden, was ein Aufruf der Methode NewChildNode <\/b>des Objekts objTreeViewHandler <\/b>erledigt. Dieser erwartet zwei Parameter: den Namen der Tabelle sowie den Wert des Primärschlüsselfelds der Tabelle.<\/p>\n Woher weiß diese Methode, an welches Element es das neue Element anfügen soll Es nimmt ganz einfach das aktuell ausgewählte Element, dessen Kontextmenü den Vorgang ins Rollen gebracht hat. Den Namen der Tabelle müssen Sie angeben, weil Sie ja auch Einträge verschiedener Tabellen unterhalb eines einzigen Elements speichern können, und die Angabe des Primärschlüsselwerts ist zwingend notwendig, weil der TreeViewHandler sonst nicht weiß, welches Element er dem TreeView hinzufügen soll.<\/p>\n Elemente hinzufügen, die zweite<\/b><\/p>\n Wenn das neue Element mehr als die Angabe der Bezeichnung erfordert, um in der entsprechenden Tabelle angelegt zu werden, kommen Sie mit einer InputBox <\/b>nicht aus und das Anzeigen mehrerer InputBox<\/b>-Fenster hintereinander ist definitiv nicht ergonomisch.<\/p>\n Stattdessen bauen Sie einfach ein Formular, das die entsprechende Tabelle als Datenherkunft besitzt und die benötigten Felder abfragt. Öffnen Sie das Formular als modalen Dialog und machen Sie es nach einem Klick auf die OK<\/b>-Schaltfläche zunächst unsichtbar, um den Wert des Primärschlüsselfelds des neu hinzugefügten Datensatzes auszulesen und es dann zu schließen.<\/p>\n Ist die ID bekannt, können Sie den Vorgang wie zuvor beschrieben mit einem Aufruf der Methode NewChildNode <\/b>fortsetzen.<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Die Funktionen der aktuellen Version haben Sie in diesem Beitrag kennengelernt. In der Lösung aus dem Beitrag Softwareprojektverwaltung <\/b>(s. Shortlink 669) haben wir den TreeView-Konfigurator eingesetzt und ein Formular mit umfangreichen Funktionen damit ausgestattet.<\/p>\n Mit dem TreeView-Konfigurator erhalten Sie ein Werkzeug, das die Erstellung und Konfiguration von TreeView-Steuerelementen maßgeblich vereinfacht. Sie brauchen einfach nur noch die Tabellen entsprechend aufzubauen und festzulegen, was bei verschiedenen Aktionen wie dem einfachen oder doppelten Anklicken von Elementen oder der Auswahl von Kontextmenüpunkten geschehen soll.<\/p>\n Auch die Konfiguration der Kontextmenüeinträge wäre sehr viel aufwendiger, wenn Sie dies komplett per Code realisieren müssten.<\/p>\n Die bisher verwendeten Funktionen sind allerdings noch nicht das Ende der Fahnenstange, es gibt noch zahlreiche andere Möglichkeiten, die umgesetzt werden können:<\/p>\n Wenn die aktuelle Version noch nicht alle Funktionen bietet, die Sie benötigen, können Sie das TreeView-Steuerelement natürlich wie gewohnt um weitere Funktionen ergänzen. Vergessen Sie aber nicht, uns zu berichten, was noch fehlt!<\/p>\n Der TreeView-Konfigurator wird von uns weiterentwickelt. Wenn Sie mit der hier vorgestellten Version experimentieren und Sie neue Ideen haben, was man noch damit anstellen könnte, schreiben Sie uns einfach eine Mail an info@access-im-unternehmen.de<\/b>.<\/p>\n Listing 3: Hinzufügen eines Datensatzes per Kontextmenü<\/p>\n Enthaltene Beispieldateien:<\/p>\n TreeViewConfigurator.mdb<\/p>\n\n
\n
\n
\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2009_03\/TreeView-web-images\/pic002_opt.jpeg\")
<\/p>\n![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2009_03\/TreeView-web-images\/pic003_opt.jpeg\")
<\/p>\nPrivate WithEvents objTreeViewHandler As µ\r\nclsTreeViewHandler<\/pre>\n
Private Sub Form_Load()\r\n Set objTreeViewHandler = New clsTreeViewHandler\r\n With objTreeViewHandler\r\n Set .TreeViewInst = Me.ctlTreeView.Object\r\n Set .ImageListInst = Me.ctlImageList.Object\r\n .InitTreeView (1)\r\n .FillTree\r\n End With\r\n End Sub<\/pre>\n
![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2009_03\/TreeView-web-images\/pic004_opt.jpeg\")
<\/p>\n![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2009_03\/TreeView-web-images\/pic005_opt.jpeg\")
<\/p>\n![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2009_03\/TreeView-web-images\/pic006_opt.jpeg\")
<\/p>\n\n
![\"pic017.png\"](\"..\/fileadmin\/_temp_\/2009_03\/TreeView-web-images\/pic017_opt.jpeg\")
<\/p>\n![\"pic007.png\"](\"..\/fileadmin\/_temp_\/2009_03\/TreeView-web-images\/pic007_opt.jpeg\")
<\/p>\n![\"pic008.png\"](\"..\/fileadmin\/_temp_\/2009_03\/TreeView-web-images\/pic008_opt.jpeg\")
<\/p>\n\n
![\"pic009.png\"](\"..\/fileadmin\/_temp_\/2009_03\/TreeView-web-images\/pic009_opt.jpeg\")
<\/p>\n\n
![\"pic011.png\"](\"..\/fileadmin\/_temp_\/2009_03\/TreeView-web-images\/pic011_opt.jpeg\")
<\/p>\n![\"pic010.png\"](\"..\/fileadmin\/_temp_\/2009_03\/TreeView-web-images\/pic010_opt.jpeg\")
<\/p>\n\n
SaveFileOoOLEField CurrentProject.Path & \"\\application.png\", \"tblImages\", \"ImageObject\", False<\/pre>\n
\n
![\"pic012.png\"](\"..\/fileadmin\/_temp_\/2009_03\/TreeView-web-images\/pic012_opt.jpeg\")
<\/p>\n![\"pic013.png\"](\"..\/fileadmin\/_temp_\/2009_03\/TreeView-web-images\/pic013_opt.jpeg\")
<\/p>\nPrivate Sub objTreeViewHandler_NodeClick(strTable As String, strPKID As String, lngPKID As Long)<\/pre>\n
\n
Private Sub objTreeViewHandler_NodeClick(strTable As String, strPKID As String, lngPKID As Long)\r\n MsgBox \"Sie haben einen Eintrag aus der Tabelle €š\" & strTable & \"€ mit dem Wert €š\" _\r\n & lngPKID & \"€ im Primärschlüsselfeld €š\" & strPKID & \"€ angeklickt.\"\r\n End Sub<\/pre>\n
![\"pic014.png\"](\"..\/fileadmin\/_temp_\/2009_03\/TreeView-web-images\/pic014_opt.jpeg\")
<\/p>\n![\"pic015.png\"](\"..\/fileadmin\/_temp_\/2009_03\/TreeView-web-images\/pic015_opt.jpeg\")
<\/p>\n![\"pic016.png\"](\"..\/fileadmin\/_temp_\/2009_03\/TreeView-web-images\/pic016_opt.jpeg\")
<\/p>\n Private Sub objTreeViewHandler_ShortcutMenuClickµ\r\n (strParameter As String, strThisTable As String,µ\r\n strPKID As String, lngPKIDValue As Long)<\/pre>\n
\n
Private Sub objTreeViewHandler_ShortcutMenuClick(strParameter As String, strThisTable As String, _\r\n strPKID As String, lngPKIDValue As Long)\r\n Select Case strParameter\r\n Case \"DeleteProject\"\r\n If MsgBox(\"Möchten Sie das Projekt wirklich löschen\", vbYesNo + vbExclamation, _\r\n \"Löschvorgang\") = vbYes Then\r\n dbs.Execute \"DELETE FROM \" & strThisTable & \" WHERE \" & strPKID & \" = \" _\r\n & lngPKIDValue, dbFailOnError\r\nEnd If\r\nEnd Select\r\nEnd Sub<\/pre>\n
objTreeViewHandler.DeleteCurrentNode<\/pre>\n
.LineStyle = tvwTreeLines<\/pre>\n
Dim strProjekt As String\r\n Dim lngProjektID As Long<\/pre>\n
\n
Select Case strParameter\r\n ...\r\n Case \"AddProject\"\r\n strProjekt = InputBox(\"Geben Sie die Bezeichnung des neuen Projekts an.\", \"Neues Projekt\")\r\n If Len(strProjekt) > 0 Then\r\n dbs.Execute \"INSERT INTO tblProjekte(Projekt, RootID) VALUES(€š\" & strProjekt _\r\n & \"€, \" & lngPKIDValue & \")\", dbFailOnError\r\n lngProjektID = dbs.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n objTreeViewHandler.NewChildNode \"tblProjekte\", lngProjektID\r\n End If\r\n End Select<\/pre>\n
Downloads zu diesem Beitrag<\/h3>\n