<\/p>\n
Im Juli\/August 2017 war es wieder mal soweit: Microsoft hat ein Update für einige Office-Varianten geliefert, das die TreeView-Steuerelemente in den Anwendungen auf den betroffenen Rechnern lahmgelegt hat. Zwar gibt es ein paar Wochen später immer einen Patch oder ein weiteres Update zur Behebung des Fehlers, aber wer kurzfristig handeln muss, darf manuell an der Datei MSCOMCTL.ocx und\/oder der Registry herumpfuschen. Das kann man natürlich keinem Kunden zumuten, daher zeigen wir eine mögliche Lösung.<\/b><\/p>\n
Normalerweise beschreiben wir in Access im Unternehmen <\/b>keine Tools von Drittanbietern, die kostenpflichtig sind. Im Falle des Treeviews scheint es jedoch sinnvoll, eine Ausnahme zu machen. Thomas Pfoch hat mit seiner Firma picoware <\/b>einen TreeView<\/b>-Ersatz programmiert, der komplett ohne zusätzliche Dateien wie .ocx<\/b>– oder .dll<\/b>-Dateien auskommt.<\/p>\n
Er verwendet stattdessen ein Unterformular, das er geschickt aufbohrt, um Daten nach den Vorgaben des Benutzers anzuzeigen und diese – wie es für ein Treeview typisch ist – für die untergeordneten Ebenen nach rechts einzurücken.<\/p>\n
Wenn Sie diese Erweiterung nutzen, müssen Sie lediglich einige Objekte aus der Beispieldatenbank, die Sie nach dem Erwerb des Pakets erhalten, in die Zieldatenbank kopieren. Darunter befindet sich auch ein Formular, das Sie als Unterformular in das Zielformular einfügen.<\/p>\n
Im Code, der beim Laden des Zielformulars ausgelöst wird, tragen Sie dann die Anweisungen ein, welche die anzuzeigenden Daten definieren.<\/p>\n
Der picoware-Treeview kostet 299,- EUR (inkl. 19% MwSt.) pro Entwicklerlizenz. Das heißt, dass Sie für jeden Entwickler, der das Tools einsetzt, eine Lizenz benötigen. Dieser Entwickler kann allerdings beliebig viele Anwendungen mit den Treeview-Funktionen ausstatten und weitergeben. Gemessen an dem ärger, den die regelmäßigen Updates der Datei MSCOMCTL.ocx <\/b>mit sich bringen, ist dies nach unserem Ermessen eine sinnvolle Investition.<\/p>\n
Hinzu kommt, dass Sie als Leser von Access im Unternehmen <\/b>im Shop unter www.amvshop.de <\/b>20% Rabatt erhalten, und zwar mit dem Gutscheincode aiu-treeview<\/b>.<\/p>\nVorteile des picoware-Treeviews<\/h2>\n
Zu den Vorteilen des picoware-Treeviews gehören die folgenden:<\/p>\n
Durch die Anpassung an die Eigenarten einer Datenbank mit ihren in Tabellen gespeicherten Daten und durch die Verwendung eines Unterformulars zur Realisierung TreeViews ergeben sich auch ein paar Nachteile:<\/p>\n
Wenn Sie nicht sicher sind, ob das Tool das Richtige für Sie ist, können Sie unter dem Link http:\/\/shop.minhorst.com\/access-tools\/322\/picoware-treeview <\/b>Beispieldatenbanken für verschiedene Access-Versionen herunterladen, welche die Möglichkeiten des Tools demonstrieren. Auf den folgenden Seiten zeigen wir Ihnen, wie Sie das picoware-Treeview <\/b>programmieren.<\/p>\npicoware-Treeview-Elemente hinzufügen<\/h2>\n
Nach dem Erwerb und dem Download erhalten Sie eine Datenbank etwa namens treeview_20170629_1451_Source.mdb<\/b>. Diese enthält alle Objekte, die Sie für den Einsatz in eigenen Datenbanken benötigen.<\/p>\n
Sie brauchen sich keine Mühe zu machen, die benötigen Objekte selbst in die Zieldatenbank zu ziehen. Die Datenbank aus dem Download enthält ein Tool, das Ihnen diese Arbeit abnimmt. Dazu öffnen Sie das Formular namens Tool_CopyCode<\/b>. Dieses zeigt eine Treeview-Ansicht der Verzeichnis- und Dateistruktur auf Ihrer Festplatte an, wobei das Verzeichnis der Quelldatenbank geöffnet wird (s. Bild 1).<\/p>\n
![\"Auswahl](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_001.png\")
<\/p>\n
Bild 1: Auswahl der Zieldatenbank für die Datenbankobjekte<\/span><\/b><\/p>\n Wählen Sie hier die Zieldatenbank aus und klicken Sie auf die Schaltfläche Copy<\/b>. Dies kopiert nun alle notwendigen Datenbankobjekte in die ausgewählte Datenbank. Falls nötig, halten Sie dabei die Umschalttaste gedrückt.<\/p>\n Im ersten Beispiel wollen wir einfach die Daten der Tabelle tblKategorien <\/b>im Treeview anzeigen. Dazu erstellen Sie ein neues Formular namens frmKategorien<\/b>, öffnen es in der Entwurfsansicht und ziehen das Formular USys_pTV_TreeView <\/b>als Unterformular in den Entwurf. Stellen Sie den Namen des Unterformular-Steuerelements auf sfmTreeView <\/b>ein.<\/p>\n Passen Sie außerdem die Größe des Unterformulars an, das initial in der vollen Breite eingefügt wird (s. Bild 2). Stellen Sie außerdem die Eigenschaften Bildlaufleisten<\/b>, Datensatzmarkierer<\/b>, Navigationsschaltflächen <\/b>und Trennlinien <\/b>auf den Wert Nein <\/b>ein – das Hauptformular selbst zeigt keine Daten an, sodass wir diese Elemente nicht benötigen.<\/p>\n Bild 2: Einfügen des Unterformulars und Anpassen der Größe<\/span><\/b><\/p>\n Ein erster Wechsel in die Formularansicht liefert natürlich noch kein sinnvolles Ergebnis – kein Wunder, denn wir füllen das Treeview ja auch noch nicht mit Daten (s. Bild 3). Das ändern wir allerdings in den folgenden Schritten.<\/p>\n Bild 3: Erster Wechsel in die Formularansicht<\/span><\/b><\/p>\n Dazu fügen Sie dem Klassenmodul des Formulars frmKategorien<\/b>, das Sie durch Einstellen der Eigenschaft Enthält Modul <\/b>des Formulars anlegen, eine Objektvariable hinzu, welche das Unterformular zur Anzeige des Treeviews referenzieren soll:<\/p>\n Die Deklaration enthält das Schlüsselwort With-Events<\/b>, damit wir innerhalb der Klasse auch die Ereignisse dieses Formulars beziehungsweise der Formularklasse Form_USys_pTV_TreeView <\/b>implementieren können.<\/p>\n Damit wir das Unterformular zur Anzeige des Treeviews füllen können, weisen wir der Objektvariablen objTreeView <\/b>das im Unterformularsteuerelement sfmTreeView <\/b>gespeicherte Formular zu, und zwar in der Prozedur, die durch das Ereignis Beim öffnen <\/b>des Hauptformulars ausgelöst wird:<\/p>\n Damit wäre das Treeview-Unterformular schon einmal referenziert. Nun wollen wir diese noch mit den gewünschten Daten füllen, in diesem Falle den Namen der Kategorien aus der Tabelle tblKategorien<\/b>.<\/p>\n Beim MSCOMCTL.ocx<\/b>-TreeView hätten Sie jedes Element einzeln mit der Add<\/b>-Methode hinzufügen müssen. Hier spielt das speziell auf die Anzeige von Daten aus Tabellen oder Abfragen ausgelegte picoware-Treeview seine Stärken aus. Sie müssen lediglich eine SQL-Anweisung mit einem bestimmten Format definieren, welche die anzuzeigenden Daten liefert, und diese mit der AddSQL<\/b>-Methode dem in der Variablen objTreeView <\/b>gespeicherten Treeview zuweisen. Das sieht dann beispielsweise wie in Listing 1 aus.<\/p>\n Listing 1: Anzeigen der Kategorien beim öffnen des Formulars<\/span><\/b><\/p>\n Ein Wechsel zur Formularansicht liefert bereits ein akzeptables Ergebnis (s. Bild 4) – und das mit einer sehr überschaubaren Anzahl von Codezeilen! <\/p>\n Bild 4: Die Kategorien im picoware-Treeview<\/span><\/b><\/p>\n Der zum Füllen des Treeviews verwendete SQL-Ausdruck sieht zusammengefasst wie folgt aus:<\/p>\n Hier erkennen Sie drei Felder, die jeweils mit einem ALIAS<\/b>-Namen ausgestattet wurden. Dies dient dem Zweck, dass das Treeview beim Anzeigen der Daten genau weiß, welches Feld die Daten für welchen Zwecke enthält. Wir verwenden die folgenden drei ALIAS<\/b>-Bezeichnungen:<\/p>\n Nun gehen wir einen Schritt weiter und fügen in einer zweiten Ebene noch die zu einer jeden Kategorie gehörenden Artikel hinzu. Dazu kopieren Sie das soeben erstellte Formular und fügen es unter dem Namen frmKategorienArtikel <\/b>erneut in die Datenbank ein (frmKategorie <\/b>markieren, Strg + C<\/b>, Strg + V<\/b>, neuen Namen eingeben). <\/p>\n Am Entwurf des Formulars brauchen Sie keine änderungen vorzunehmen, wir kümmern uns nur um den Code.<\/p>\n Wie zuvor soll beim öffnen des Formulars die Liste der Kategorien erscheinen. Beim Klick auf eines der Plus-Zeichen sollen die zur jeweiligen Kategorie gehörenden Artikel im Treeview angezeigt werden.<\/p>\n Dazu implementieren wir ein Ereignis der Klasse Form_USys_pTV_TreeView<\/b>. Zu diesem Zweck wechseln Sie zum VBA-Fenster des Klassenmoduls des Formulars frmKategorienArtikel<\/b>, wählen im linken Kombinationsfeld des Fensters den Eintrag objTreeView <\/b>und im rechten Kombinationsfeld den Eintrag ItemOpened <\/b>aus (s. Bild 5).<\/p>\n Bild 5: Implementieren einer Ereignisprozedur des picoware-Treeviews<\/span><\/b><\/p>\n Dies legt die folgende Ereignisprozedur an:<\/p>\n Die Ereignisprozedur wird immer ausgelöst, wenn der Benutzer auf einen der Einträge im Treeview klickt. Dies können Sie ausprobieren, indem Sie einen Haltepunkt für die erste Zeile der Prozedur festlegen und auf eine der Kategorien im Beispielformular frmKategorienArtikel <\/b>klicken.<\/p>\n Nun wollen wir die Zeilen hinzufügen, die dafür sorgen, dass beim Anklicken des Plus-Zeichens einer Kategorie die untergeordneten Artikel im Treeview erscheinen. Diese Prozedur sieht wie in Listing 2 aus.<\/p>\n <\/p>\n Listing 2: Ereignisprozedur, welche die Artikel für die angeklickte Kategorie einblendet<\/span><\/b><\/p>\n Eine zusätzliche Zeile deklariert eine Variable namens lngReference <\/b>mit dem Datentyp Long<\/b>, eine weitere füllt diese mit einem Wert, den der Ausdruck Context.SettingLong(„Reference“, -1) <\/b>liefert. Context <\/b>ist einer der beiden Parameter, der beim Auslösen der Ereignisprozedur übergeben wird.<\/p>\n Dieser liefert einige Informationen rund um das angeklickte Element und auch einige mögliche Methoden. In diesem Fall verwenden wir die Funktion SettingLong<\/b>, um den Wert des Attributs Reference <\/b>zu ermitteln. Dabei handelt es sich um den Wert des angeklickten Elements, der in der SQL-Anweisung, welche dieses Element definiert, für das Feld mit dem ALIAS<\/b>-Namen Reference übergeben wurde – in diesem Fall also der Wert des Feldes KategorieID <\/b>für den angeklickten Eintrag.<\/p>\n Diesen Wert speichern wir in der Variablen lngReference<\/b> und nutzen ihn in der nachfolgend zusammengestellten SQL-Anweisung als Vergleichswert des Kriteriums. Für die KategorieID <\/b>mit dem Wert 5 <\/b>sieht die SQL-Abfrage etwa so aus:<\/p>\n Danach folgt dann auch für die Elemente dieser zweiten Ebene der Aufruf der Methode AddSQL <\/b>des Objekts aus objTreeView<\/b>. Diesmal verwenden wir allerdings auch den zweiten Parameter dieser Methode und übergeben dieser den unveränderten Wert des zweiten Parameters der Ereignisprozedur namens RefPath<\/b>.<\/p>\n Was enthält dieser Parameter Dies erfahren wir wieder, indem wir einen Haltepunkt setzen und dann nach dem Abarbeiten der ersten Zeile mit der Maus über den Parameter fahren (s. Bild 6).<\/p>\n Bild 6: Ermitteln eines der Parameter der Ereignisprozedur<\/span><\/b><\/p>\n Es handelt sich also um die Zeichenfolge \/5\/<\/b>, wobei der Wert 5 <\/b>wieder dem Referenzwert des auslösenden Elements entspricht. Diesen übergeben wir der Methode AddSQL<\/b>, damit diese weiß, an welches Element sie die neuen Elemente anfügen soll.<\/p>\n Das Ergebnis der neu hinzugefügten Funktion finden Sie schließlich in der Formularansicht aus Bild 7.<\/p>\n Bild 7: Treeview mit zwei Ebenen<\/span><\/b><\/p>\n Was geschieht aber nun, wenn wir auf das Plus-Zeichen eines der Elemente der zweiten Ebene klicken Dies bewirkt in den meisten Fällen nichts, außer dass das Plus-Zeichen für den angeklickten Eintrag verschwindet.<\/p>\n Es kann aber auch sein, dass sich eine weitere Ebene öffnet, welche nochmal die gleichen Artikel wie die zweite Ebene enthält, von der aus ein Element aufgeklappt wurde. Aber was geschieht dort im Detail Da es nur eine Ereignisprozedur namens ItemOpened <\/b>für alle Elemente des Treeviews gibt, wird diese natürlich auch beim Klicken auf das Plus-Zeichen eines der Elemente der zweiten Ebene mit den Artikeln ausgelöst.<\/p>\n Der Parameter RefPath <\/b>liefert nun einen Wert wie etwa \/5\/52\/<\/b>, wobei der Wert 5 <\/b>dem Referenzwert für das Element der ersten Ebene und 52 <\/b>dem Referenzwert für das Element der zweiten Ebene, also des Artikels, entspricht. Der Ausdruck Context.SettingLong(„Reference“, -1) <\/b>liefert nun den Primärschlüsselwert des angeklickten Elements der zweiten Ebene.<\/p>\n Die SQL-Anweisung ermittelt nun alle Elemente der Tabelle tblArtikel<\/b>, deren Feld KategorieID <\/b>den Wert 52 <\/b>enthält – was in diesem Fall keine Ergebnisse liefert. Hätten wir einen Artikel angeklickt, dessen Wert im Feld ArtikelID <\/b>auch im Feld KategorieID <\/b>eines der Datensätze der Tabelle tblKategorien <\/b>vorkommt, hätte dies alle Datensätze der Tabelle tblArtikel <\/b>zu dieser Kategorie geliefert. Das soll aber natürlich so nicht geschehen.<\/p>\n Also erweitern wir die Ereignisprozedur objTreeView_Item-Opened <\/b>wie in Listing 3. Sie erinnern sich, dass wir gleich in der SQL-Anweisung für das Hinzufügen der Kategorie-Elemente ein Feld mit dem ALIAS<\/b>-Namen RefContext <\/b>und dem Wert ““Kategorie““ <\/b>übergeben haben. Diesen nutzen wir nun, um zu ermitteln, ob der Benutzer auf eines der Elemente der ersten Ebene, also auf eine Kategorie geklickt hat oder auf eines der Objekte einer anderen Ebene.<\/p>\n Listing 3: Neue Version der Ereignisprozedur, welche die Artikel für die angeklickte Kategorie einblendet<\/span><\/b><\/p>\n Wir ermitteln diesen Wert über den Ausdruck Context.SettingNz(„RefContext“, „Root“)<\/b>, was im Falle des Erweiterns eines der Elemente der ersten Ebene den Wert Kategorie <\/b>zurückliefert (ist kein RefContext <\/b>angegeben, lautet der Wert Root<\/b>). Diesen speichern wir in der Variablen strRefContext <\/b>und prüfen ihn in einer Select Case<\/b>-Bedingung. Diese hat nur einen Case<\/b>-Zweig, der im Falle des Wertes Kategorie <\/b>aufgerufen wird und die Einträge der Tabelle tblArtikel <\/b>für die angegebene Kategorie hinzufügt. Wenn wir nun also auf das Plus-Zeichen eines Eintrags der zweiten Ebene, also eines Artikels klicken, liefert Context.SettingNz(„RefContext“, „Root“) <\/b>den Wert Artikel, für den es keinen Case<\/b>-Zweig in der Select Case<\/b>-Variablen gibt. Dementsprechend geschieht auch nichts weiter.<\/p>\n Erst, wenn Sie noch weitere Elemente unterhalb der Artikel-Elemente anzeigen wollten, müssten Sie einen weiteren Case<\/b>-Zweig zur Select Case<\/b>-Bedingung hinzufügen.<\/p>\n Nun haben wir zunächst einmal zwei Ebene mit Daten zum Treeview hinzugefügt. Sie haben auch gesehen, dass das Plus-Zeichen für Einträge der zweiten Ebene, die ja keine weiteren Einträge enthält, verschwinden, wenn Sie diese anklicken. Dies sollte aber bereits vorher so sein, denn wozu benötigt man ein Element zum Aufklappen von untergeordneten Elementen, wenn keine solchen vorhanden sind Also kümmern wir uns um diese kleine Schönheitskorrektur.<\/p>\n In unserem Beispiel ist dazu nur ein recht kleiner Aufwand erforderlich – wir müssen lediglich der SQL-Anweisung ein weiteres Feld zuweisen, das den ALIAS<\/b>-Namen ChildCount <\/b>trägt und den Wert 0 <\/b>enthält:<\/p>\n Das Ergebnis sieht wie in Bild 8 aus.<\/p>\n Bild 8: Keine Erweiterungssymbole in der zweiten Ebene<\/span><\/b><\/p>\n Was aber, wenn wir Ebenen mit Daten haben, die teilweise untergeordneten Elemente besitzen und teilweise nicht Dazu fügen wir etwa eine Kategorie zur Tabelle tblKategorien <\/b>hinzu, für die es in der Tabelle tblArtikel <\/b>keine passenden Artikel gibt.<\/p>\n Damit für dieses Element kein Plus-Zeichen zum Aufklappen des Elements angezeigt wird, müssen wir die SQL-Abfrage für die erste Ebene mit den Kategorien so umformulieren, dass ChildCount <\/b>den Wert 0 <\/b>erhält, wenn keine untergeordneten Element vorliegen und anderenfalls einen anderen Wert.<\/p>\n Diese Abfrage stellen wir der Einfachheit halber zunächst in der Entwurfsansicht einer neuen Abfrage zusammen. Dazu fügen Sie die beiden Tabellen tblKategorien <\/b>und tblArtikel <\/b>hinzu, wobei die Verknüpfung zwischen den beiden Tabellen automatisch mit eingefügt wird.<\/p>\n Fügen Sie die Felder mit den entsprechenden ALIAS<\/b>-Namen wie in Bild 9 zum Entwurfsraster der Abfrage hinzu. Wenn es nun in der Tabelle tblKategorien <\/b>einen Datensatz gibt, mit dem kein Datensatz der Tabelle tblArtikel <\/b>verknüpft ist, wird gar kein Datensatz für diese Kategorie angezeigt. Also stellen wir die Verknüpfungseigenschaften so ein, dass alle Datensätze der Tabelle tblKategorien <\/b>geliefert werden, auch wenn es keinen verknüpften Datensatz in der Tabelle tblArtikel <\/b>gibt. Nun soll auch noch jede Kategorie nur einmal angezeigt werden und nicht für jede Kombination aus Kategorie und Artikel jeweils einmal, also stellen wir die Eigenschaft Keine Duplikate <\/b>der Abfrage auf Nein <\/b>ein. Schließlich fehlt nun noch ein Weg, die Anzahl der Datensätze der Tabelle tblArtikel <\/b>für die jeweilige Kategorie zu liefern.<\/p>\n Bild 9: Abfrage, welche die Daten einer Tabelle samt Anzahl der untergeordneten Elemente liefern soll.<\/span><\/b><\/p>\n Dazu fügen Sie durch einen Klick auf den Ribbon-Eintrag Entwurf|Einblenden\/Ausblenden|Summen <\/b>die Zeile Funktion <\/b>im Abfrageentwurf ein. Hier legen Sie für die Felder Reference: KategorieID <\/b>und Caption: Kategoriename <\/b>den Wert Gruppierung<\/b>, für RefContext: ““Kategorie““ <\/b>den Wert Ausdruck <\/b>und für ChildCount: ArtikelID <\/b>den Wert Anzahl <\/b>fest. Damit erhalten Sie ein Abfrageergebnis wie in Bild 10.<\/p>\n Bild 10: Kategorien mit der Anzahl der Unterelemente<\/span><\/b><\/p>\n Nun wechseln Sie in die SQL-Abfrage, kopieren den Abfragetext und fügen diesen wie in Listing 4 in der Prozedur Form_Open <\/b>für die Variable strSQL <\/b>ein.<\/p>\n Listing 4: Diese Version der Prozedur Form_Open liefert nur Plus-Zeichen für Kategorien, die auch Unterelemente enthalten.<\/span><\/b><\/p>\n Um die optische Seite abzurunden, wollen wir nun noch ein paar individuelle Icons für die Elemente des Treeviews hinzufügen. Dazu legen wir eine neue Kopie unseres Beispielformulars an und nennen dieses frmKategorienArtikelIcons<\/b>. Icons werden in der Tabelle USys_pTV_Icon <\/b>verwaltet, die Sie eventuell nicht sehen – was aber kein Problem ist. Fügen Sie aus der Quelldatenbank mit den Beispielen das Formular Tool_Icons <\/b>zur Zielanwendung hinzu. Um ein Icon etwa aus einer .png<\/b>-Datei zu dieser Tabelle hinzuzufügen, gehen Sie wie folgt vor:<\/p>\n Bild 11: Ein Icon in Paint<\/span><\/b><\/p>\n Legen Sie einen neuen Datensatz im Formular Tools_Icons <\/b>an, klicken Sie auf die noch leere Bild-Spalte mit der entsprechenden Größe (also etwa 16 x 16) des neuen Datensatzes und fügen Sie den Inhalt der Zwischenablage mit Strg + V <\/b>ein. Das Ergebnis sieht dann wie in Bild 12 aus.<\/p>\n Bild 12: Verwalten der Icons<\/span><\/b><\/p>\n Prüfen Sie danach durch einen Blick in die Tabelle USys_pTV_Icon<\/b>, ob für den neuen Datensatz in der Spalte mit der entsprechenden Größe (hier Pic016<\/b>), dass dort Bild <\/b>steht und nicht etwa Bitmap Image<\/b>, was nicht unter Umständen nicht funktioniert (s. Bild 13).<\/p>\n Bild 13: Prüfen, ob das Bild mit dem richtigen Typ angelegt wurde und nicht etwa mals Bitmap Image<\/span><\/b><\/p>\n Wie zeigen wir das Bild nun an Im ersten Fall wollen wir alle Elemente der ersten Ebene mit dem Folder-Symbol ausstatten. Dazu können wir dieses fix unter dem ALIAS<\/b>-Namen IconName<\/b> als Zeichenkette angeben.<\/p>\n Die entsprechende SQL-Abfrage in der Prozedur Form_Open <\/b>des neuen Formulars frmKategorienArtikelIcons <\/b>erweitern wir also um das Feld ““Kategorie““ AS IconName<\/b>:<\/p>\n Das Ergebnis sieht dann wie in Bild 14 aus – die Elemente der ersten Ebene werden nun mit dem Folder-Symbol angezeigt.<\/p>\n Bild 14: Treeview-Einträge mit Icon<\/span><\/b><\/p>\n Sie können natürlich auch für die Einträge einer Ebene individuelle Icons festlegen. Dazu müssen Sie einfach das Feld, welches mit dem ALIAS<\/b>-Namen IconName <\/b>versehen wird, mit dem gewünschten Namen aus der Tabelle USys_pTV_Icon <\/b>füllen.<\/p>\n Das Ergebnis soll dann beispielsweise wie in Bild 15 aussehen. Es soll also zu jedem Datensatz der Tabelle tblKategorien <\/b>ein eigenes Icon angezeigt werden. Für das Beispiel haben wir das Formular frmKategorien<\/b>, das bisher nur die Daten der Tabelle tblKategorien <\/b>angezeigt hat, in das neue Formular frmKategorienIndividuelleIcons <\/b>kopiert.<\/p>\n Bild 15: Individuelle Treeview-Icons<\/span><\/b><\/p>\n Dazu fügen Sie zunächst die gewünschten Icons über das Formular Tool_Icons <\/b>in die Tabelle USys_pTV_Icon <\/b>ein. Danach müssen Sie dafür sorgen, dass der Name des jeweiligen Icons im entsprechenden Datensatz der Tabelle tblKategorien <\/b>gespeichert wird. Dazu fügen wir der Tabelle das Feld Icon <\/b>hinzu und legen die gewünschten Werte an (s. Bild 16). Schließlich passen wir den SQL-Ausdruck in der Prozedzur Form_Open <\/b>des Formulars frmKategorienIndividuelleIcons <\/b>wie folgt an:<\/p>\n Bild 16: Verweise auf die Icons in der Tabelle tblKategorien<\/span><\/b><\/p>\n Wir haben hier also nicht wie im vorherigen Beispiel eine feste Zeichenfolge für das anzuzeigende Icon angegeben, sondern den Namen des Feldes mit dem Namen des Icons.<\/p>\n Zugegeben: Das Plus- und da Minuszeichen, das standardmäßig im picoware-Treeview angezeigt wird, gefällt uns wirklich gut. Aber vielleicht nicht allen Programmierern und Benutzern! Also können Sie diese Symbole natürlich auch ändern. Dazu verwenden wir ausnahmsweise nicht die SQL-Anweisung, sondern eine Eigenschaft der Objektvariablen objTreeView. Diese passen wir etwa im Formular frmKategorienArtikelIcons <\/b>wie folgt in der Prozedur Form_Open <\/b>an:<\/p>\n Dies liefert nun die von Windows XP bekannten Icons für die Plus- und Minuszeichen (s. Bild 17). Aber woher wissen wir, dass wir dazu beispielsweise das Präfix WinXP <\/b>verwenden müssen Dazu reicht ein Blick in das Formular Tool_Icons<\/b>.<\/p>\n Bild 17: Alternative Plus-\/Minuszeichen<\/span><\/b><\/p>\n Hier können Sie durch Filtern nach dem Ausdruck *Plus <\/b>für die Spalte Context <\/b>alle Plus-Zeichen einblenden, die verfügbar sind (s. Bild 18).<\/p>\n Bild 18: Alle alternativen Plus-\/Minuszeichen<\/span><\/b><\/p>\n Lesen Sie einfach das Präfix des gewünschten Sets aus, also den Teil vor dem Unterstrich (_<\/b>) und tragen Sie diesen für die Eigenschaft IconPrefix <\/b>der Objektvariablen objTreeView <\/b>ein. Sie können natürlich auch eigene Sets dieser Elemente anlegen.<\/p>\n Neben dem Aus- und Einklappen von Treeview-Einträgen ist eine der wichtigsten Funktionen natürlich der Mausklick auf einen der Einträge. <\/p>\n Für die folgenden Beispiele haben wir das Formular frmKategorieArtikelIcons <\/b>nach frmKategorieArtikelMausklick <\/b>kopiert.<\/p>\n Wir wollen nun zunächst erreichen, dass ein Meldungsfenster mit dem Primärschlüsselwert des angeklickten Elements erscheint.<\/p>\n Dazu fügen wir dem Klassenmodul des Formulars die Ereignisprozedur ItemSelected <\/b>des Elements objTreeView <\/b>hinzu – wie weiter oben beschrieben über die beiden Kombinationsfelder des VBA-Codefensters. Dieses füllen wir wie folgt:<\/p>\n Wenn Sie nun auf einen der Einträge klicken und diesen so als aktiven Eintrag auswählen, wird dieser nicht nur in blauer und fetter Schrift dargestellt, sondern es erscheint auch noch ein Meldungsfenster, das den Primärschlüsselwert des aktuellen Eintrags ausgibt (s. Bild 19).<\/p>\n Bild 19: Ausgabe der ID des angeklickten Elements<\/span><\/b><\/p>\n Das hilft uns natürlich noch nicht wirklich weiter, wenn wir in mehreren Ebenen die Daten aus verschiedenen Tabellen darstellen. Dann sollten wir noch auf eine der Eigenschaften zugreifen, die wir über den SQL-Ausdruck angeben – nämlich den Wert für das Feld mit dem ALIAS<\/b>-Namen RefContext<\/b>.<\/p>\n Also stellen wir der Ausgabe im Meldungsfenster noch ein Element voran, welches über die Setting<\/b>-Eigenschaft den Wert der Einstellung RefContext <\/b>für das angeklickte Element ausgibt (s. Bild 20):<\/p>\n Bild 20: Ausgabe der Quelle und der ID des angeklickten Elements<\/span><\/b><\/p>\n Welche Möglichkeiten sich daraus ergeben, brauchen wir für Entwickler, die sich bereits mit dem MSCOMCTL-TreeView auseinandergesetzt haben, nicht zu erläutern. Meist sollen beim Anklicken von TreeView-Elementen entsprechende Unterformulare mit den Daten zu den jeweiligen Einträgen geöffnet werden.<\/p>\n Sie können nun über das Ergebnis von Context.Setting(„RefContext“) <\/b>ermitteln, welche Art von Objekt anzuzeigen ist und das entsprechende Unterformular einblenden, mit Context.SettingLong(„Reference“, 0)<\/b> ermitteln Sie den Primärschlüsselwert des darin anzuzeigenden Datensatzes der zugrunde liegenden Tabelle.<\/p>\n Es gibt noch viele weitere Funktionen, die sich mit dem picoware-Treeview abbilden lassen. In vielen Fällen gelingt dies wesentlich einfacher als mit dem MSCOMCTL<\/b>-TreeView, und auf jeden Fall haben Sie die Sicherheit, dass das picoware-Treeview nicht versagt, wenn Microsoft wieder einmal ein unzureichend getestetes Update durchführt. <\/p>\n Außerdem können Sie damit erstellte Treeviews auch auf Systemen nutzen, die mit der 64bit-Variante von Office arbeiten.<\/p>\n Mit dem picoware-Treeview können Sie noch viele weitere Anpassungen am Design vornehmen, zur Laufzeit Knoten einfügen und entfernen, den Hintergrund farbig gestalten, Status- und Checkboxen nutzen, Daten aus reflexiv verknüpften Tabellen anzeigen und mehr.<\/p>\n Wenn Sie uns das Feedback liefern, dass das picoware-Treeview eine Alternative für das MSCOMCTL<\/b>-TreeView ist, werden wir in weiteren Ausgaben auch die übrigen Funktionen des picoware-Treeviews vorstellen.<\/p>\nErstes Beispiel: Kategorien auflisten<\/h2>\n
![\"Einfügen](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_002.png\")
<\/p>\n![\"Erster](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_003.png\")
<\/p>\nPublic <\/span>WithEvents objTreeView As <\/span> Form_USys_pTV_TreeView<\/pre>\nPrivate Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Set<\/span> objTreeView = Me!Treeview.Form\r\nEnd Sub<\/span><\/pre>\nTreeview mit Daten füllen<\/h2>\n
Private Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Dim <\/span>strSQL As String<\/span>\r\n Set<\/span> objTreeView = Me!Treeview.Form\r\n strSQL = \"SELECT KategorieID AS Reference, Kategoriename AS Caption, ''''Kategorie'''' AS RefContext \" _\r\n & \"FROM tblKategorien\"\r\n objTreeView.AddSQL strSQL\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_004.png\")
<\/p>\nErläuterung des SQL-Ausdrucks<\/h2>\n
SELECT KategorieID AS Reference, Kategoriename AS Caption, ''''Kategorie'''' AS RefContext FROM tblKategorien<\/pre>\n
\n
Artikel zu Kategorien hinzufügen<\/h2>\n
![\"Implementieren](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_005.png\")
<\/p>\nPrivate Sub <\/span>objTreeView_ItemOpened(Context As <\/span> USys_pCT_Context, ByVal RefPath As String<\/span>)\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>objTreeView_ItemOpened(Context As <\/span>USys_pCT_Context, ByVal RefPath As String<\/span>)\r\n Dim <\/span>strSQL As String<\/span>\r\n Dim <\/span>lngReference As Long<\/span>\r\n lngReference = Context.SettingLong(\"Reference\", -1)\r\n strSQL = \"Select ArtikelID As <\/span>Reference, ''''Artikel'''' As <\/span>RefContext, Artikelname As <\/span>Caption " _\r\n & "FROM tblArtikel WHERE KategorieID = \" & lngReference\r\n objTreeView.AddSQL strSQL, RefPath\r\nEnd Sub<\/span><\/pre>\nSelect ArtikelID As <\/span>Reference, \r\n''''Artikel'''' As <\/span>RefContext, \r\nArtikelname As <\/span>Caption \r\nFROM tblArtikel \r\nWHERE KategorieID = 5<\/pre>\n![\"Ermitteln](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_006.png\")
<\/p>\n![\"Treeview](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_007.png\")
<\/p>\nöffnen-Klick auf der zweiten Ebene<\/h2>\n
Private Sub <\/span>objTreeView_ItemOpened(Context As <\/span>USys_pCT_Context, ByVal RefPath As String<\/span>)\r\n Dim <\/span>strSQL As String<\/span>\r\n Dim <\/span>lngReference As Long<\/span>\r\n Dim <\/span>strRefContext As String<\/span>\r\n strRefContext = Context.SettingNz(\"RefContext\", \"Root\")\r\n Select Case strRefContext\r\n Case <\/span>\"Kategorie\"\r\n lngReference = Context.SettingLong(\"Reference\", -1)\r\n strSQL = \"Select ArtikelID As <\/span>Reference, ''''Artikel'''' As <\/span>RefContext, Artikelname As <\/span>Caption " _\r\n & "FROM tblArtikel WHERE KategorieID = \" & lngReference\r\n objTreeView.AddSQL strSQL, RefPath\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nUnnötige Plus-Zeichen ausblenden<\/h2>\n
strSQL = \"Select ArtikelID As <\/span>Reference, \r\n''''Artikel'''' As <\/span>RefContext, \r\nArtikelname As <\/span>Caption, \r\n0 AS ChildCount \r\nFROM tblArtikel \r\nWHERE KategorieID = \" & lngReference<\/pre>\n![\"Keine](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_008.png\")
<\/p>\n![\"Abfrage,](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_009.png\")
<\/p>\n![\"Kategorien](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_010.png\")
<\/p>\nPrivate Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Dim <\/span>strSQL As String<\/span>\r\n Set<\/span> objTreeView = Me!sfmTreeview.Form\r\n strSQL = \"SELECT DISTINCT tblKategorien.KategorieID AS Reference, ''''Kategorie'''' AS RefContext, " _\r\n & "tblKategorien.Kategoriename AS Caption, Count(tblArtikel.ArtikelID) AS ChildCount FROM tblKategorien " _\r\n & "LEFT JOIN tblArtikel ON tblKategorien.KategorieID = tblArtikel.KategorieID " _\r\n & "GROUP BY tblKategorien.KategorieID, tblKategorien.Kategoriename\"\r\n objTreeView.AddSQL strSQL\r\nEnd Sub<\/span><\/pre>\nIcons<\/h2>\n
\n
![\"Ein](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_011.png\")
<\/p>\n![\"Verwalten](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_012.png\")
<\/p>\n![\"Prüfen,](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_013.png\")
<\/p>\nPrivate Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n ...\r\n strSQL = \"SELECT ..., ''''Kategorie'''' AS IconName FROM ...\"\r\n ...\r\nEnd Sub<\/span><\/pre>\n![\"Treeview-Einträge](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_014.png\")
<\/p>\nVerschiedene Icons<\/h2>\n
![\"Individuelle](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_015.png\")
<\/p>\n![\"Verweise](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_016.png\")
<\/p>\nPrivate Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Dim <\/span>strSQL As String<\/span>\r\n Set<\/span> objTreeView = Me!sfmTreeview.Form\r\n strSQL = \"SELECT KategorieID AS Reference, \" _\r\n & \"Kategoriename AS Caption, \" _\r\n & \"''''Kategorie'''' AS RefContext, \" _\r\n & \"Icon AS IconName \" _\r\n & \"FROM tblKategorien\"\r\n objTreeView.AddSQL strSQL\r\nEnd Sub<\/span><\/pre>\nIcon für die Schaltfläche zum Ein- und Ausklappen ändern<\/h2>\n
objTreeView.IconPrefix = \"WinXP\"<\/pre>\n
![\"Alternative](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_017.png\")
<\/p>\n![\"Alle](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_018.png\")
<\/p>\nMausklick auf einen Eintrag<\/h2>\n
Private Sub <\/span>objTreeView_ItemSelected(Context As <\/span> USys_pCT_Context, _\r\n ByVal RefPath As String<\/span>)\r\n MsgBox<\/span> Context.SettingLong(\"Reference\", 0)\r\nEnd Sub<\/span><\/pre>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_019.png\")
<\/p>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2017_05\/pic_1098_020.png\")
<\/p>\nMsgBox<\/span> Context.Setting(\"RefContext\") & \" \" & Context.SettingLong(\"Reference\", 0)<\/pre>\nZusammenfassung und Ausblick<\/h2>\n
Download<\/h2>\n