<\/p>\n
Das Anlegen neuer Elemente in einem TreeView-Steuerelement, das die Daten aus ein oder mehreren Tabellen anzeigt, ist nicht immer trivial. Soll das Anlegen über ein Detailformular erfolgen und der Eintrag dann zum TreeView hinzugefügt werden Oder reicht vielleicht die Bezeichnung des neuen Elements zunächst aus, um dieses zum TreeView hinzuzufügen – dann wäre eine InputBox oder die direkte Angabe im TreeView eine Lösung. Dieser Beitrag zeigt verschiedene Möglichkeiten, um neue Elemente anzulegen.<\/b><\/p>\n
Varianten<\/b><\/p>\n
Wer ein TreeView<\/b>-Steuerelement einsetzt, beabsichtigt zunächst die Anzeige hierarchischer Daten in übersichtlicher Form.<\/p>\n
Gelegentlich kommt der Wunsch hinzu, die Daten direkt über das TreeView<\/b>-Steuerelement zu bearbeiten oder zumindest von dort aus die zur Bearbeitung notwendigen Formulare zu öffnen beziehungsweise Unterformulare mit den entsprechenden Daten zu füllen. In diesem Beitrag schauen wir uns an, wie Sie neue Elemente zu den verschiedenen TreeView<\/b>-Steuerelementen hinzufügen. Dabei gibt es im Wesentlichen die folgenden Varianten:<\/p>\n Letztere Variante kann beispielsweise in den folgenden beiden Ausprägungen auftauchen:<\/p>\n Der Fall mit dem Unterformular ist einigermaßen kompliziert, denn: Was soll beim Anlegen eines neuen Datensatzes zuerst geschehen – soll erst ein neues Element im TreeView<\/b>-Steuerelement angelegt werden oder erst ein neuer Datensatz Und wann und wie werden die änderungen im Datensatz in das TreeView<\/b>-Steuerelement übertragen Diese und andere Fragen beantworten wir auf den folgenden Seiten.<\/p>\n Speichern der Daten<\/b><\/p>\n Eines haben alle Varianten gemeinsam: Es soll immer ein Datensatz zu der Tabelle hinzugefügt werden, welche die Elemente der aktuellen Ebene des TreeView<\/b>-Steuerelements liefert (wobei eine Ebene natürlich auch Elemente aus verschiedenen Tabellen enthalten kann). Gleichzeitig soll ein neuer Eintrag zum TreeView<\/b>-Steuerelement hinzugefügt werden.<\/p>\n Auslösen des Anlegevorgangs<\/b><\/p>\n Einen neuen Eintrag können Sie auf verschiedene Arten zum TreeView<\/b>-Steuerelement hinzufügen. Die komfortabelste Möglichkeit ist sicher der Einsatz von Kontextmenüs, da diese immer nur die für das jeweilige Element verfügbaren Befehle anzeigen.<\/p>\n Wenn das TreeView<\/b>-Steuerelement nur Daten aus einer reflexiv verknüpften Tabelle anzeigt, reicht sicher auch eine Schaltfläche außerhalb des TreeView<\/b>-Steuerelements aus, um ein neues Element zum aktuell markierten Element hinzuzufügen.<\/p>\n Beim Hinzufügen eines Elements muss aber in jedem Fall feststehen, unterhalb welches anderen Elements das neue Element angelegt werden soll – oder ob dieses als neues Root-Element ohne übergeordnetes Element zu erstellen ist.<\/p>\n Bei TreeView<\/b>-Steuerelementen, die Daten aus mehreren hierarchisch verknüpften Tabellen anzeigen, müssen Sie außerdem wissen, zu welcher Tabelle das neue Element hinzugefügt werden soll.<\/p>\n Dies ergibt sich aber in der Regel aus dem Aufbau der Tabellen und geschieht somit in Abhängigkeit vom übergeordneten Element. Interessant wird dies, wenn Sie ein TreeView<\/b>-Steuerelement mit den Daten aus Tabellen mit gemischten Beziehungen füllen – also sowohl aus reflexiv verknüpften Tabellen als auch aus anderen hierarchisch verknüpften Tabellen. Dies ist beispielsweise der Fall, wenn Sie Verzeichnisse und Dateien abbilden. Jedes Verzeichnis kann Verzeichnisse und Dateien enthalten, also müssen Sie für jedes Verzeichnis auch Befehle zum Hinzufügen von Verzeichnissen und Dateien bereitstellen.<\/p>\n Beispiel Stückliste<\/b><\/p>\n Ein Beispiel, dass sowohl reflexiv verknüpfte Elemente als auch 1:n-Verknüpfungen enthält, ist die Stückliste. Der Beitrag Stücklisten <\/b>(www.access-im-unternehmen.de\/923<\/b>) liefert das Beispiel für den vorliegenden Beitrag. Dort finden Sie Baugruppen, die aus weiteren Baugruppen oder aus Einzelteilen bestehen können. Ein Einzelteil hingegen ist eine atomare Einheit und kann nicht in weitere Elemente aufgeteilt werden.<\/p>\n Dieses Beispiel enthält sowohl Daten aus einer Tabelle, die prinzipiell nur die Bezeichnung der Elemente speichert (Baugruppen) also auch solche, die mehrere Attribute erfordern (Einzelteile). Wir können uns im Rahmen dieses Beitrags also an diesem Beispiel austoben.<\/p>\n Wichtig ist an dieser Stelle, dass das TreeView<\/b>-Steuerelement mit einer Variablen namens objTreeView <\/b>referenziert wird, die gleich beim Laden des Formulars gefüllt wird. Daher können wir in den folgenden Beispielprozeduren jeweils direkt auf objTreeview <\/b>zugreifen und auch für dieses Objekt die benötigten Ereignisprozeduren implementieren.<\/p>\n Einfache Elemente hinzufügen<\/b><\/p>\n Wie oben erläutert, ist der einfachste Fall für das Hinzufügen von Elementen zu einem TreeView<\/b>-Steuerelement der, bei dem im ersten Schritt allein die Bezeichnung des jeweiligen Elements angegeben und dann sowohl in einem neuen Element im TreeView<\/b>-Steuerelement angezeigt als auch in der zugrunde liegenden Tabelle gespeichert wird. Im Beispiel handelt es sich dabei um die Baugruppen. Wir schauen uns zwei Methoden an – die mit der InputBox <\/b>und die mit dem direkten Anlegen im TreeView<\/b>-Steuerelement.<\/p>\n Element per InputBox hinzufügen<\/b><\/p>\n Um Elemente einfach hinzuzufügen, haben wir einige Schaltfflächen im oberen Bereich des Beispielformulars mit dem TreeView<\/b>-Steuerelement untergebracht (s. Bild 1). Wie das TreeView<\/b>-Steuerelement gefüllt wird, erfahren Sie im oben bereits erwähnten Beitrag Stücklisten<\/b>.<\/p>\n Bild 1: Schaltflächen zum Anlegen neuer Elemente<\/span><\/b><\/p>\n Die Schaltfläche cmdNeueBaugruppeI<\/b> soll eine InputBox <\/b>anzeigen, welche die Bezeichnung der neuen Baugruppe abfragt. Anschließend soll der Eintrag an der gewünschten Stelle im TreeView<\/b>-Steuerelement angelegt und in der Datenbank gespeichert werden.<\/p>\n Die Prozedur, die durch das Ereignis Beim Klicken <\/b>der Schaltfläche ausgelöst wird, finden Sie in Listing 1. Die Prozedur speichert zunächst einen mit der Eigenschaft SelectedItem <\/b>ermittelten Verweis auf das aktuell markierte Element im TreeView<\/b>-Steuerelement in der Variablen objNode<\/b>. Sie ermittelt den Key<\/b>-Wert des Elements und speichert diesen in der Variablen strKey<\/b>. Nun benötigen wir ein paar Informationen, die sich in der Key<\/b>-Eigenschaft befinden. Der Inhalt von Key <\/b>ist normalerweise auf eine von zwei Arten aufgebaut:<\/p>\n Listing 1: Anlegen eines neuen TreeView-Elements per InputBox<\/span><\/b><\/p>\n Der Key könnte also etwa r0<\/b>, p123 <\/b>oder b13 <\/b>lauten. Im vorliegenden Fall haben wir es allerdings mit einem TreeView<\/b>-Steuerelement zu tun, das Daten aus einer reflexiven Beziehung enthält. Ein Element, etwa eine Baugruppe oder ein Einzelteil, könnte also mehrfach im TreeView<\/b>-Steuerelement vorkommen. Jeder Key <\/b>darf aber nur einmal vorkommen, sodass wir die Eindeutigkeit anderweitig sicherstellen müssen. In diesem Fall besteht der Key<\/b>-Wert aus einer Abfolge aller Key<\/b>-Werte in der Hierarchie vom Root-Element bis zum aktuellen Element, und zwar getrennt durch ein spezielles Zeichen wie etwa das Pipe-Zeichen: r0|p1|b2|b27|e12<\/b>.<\/p>\n Um aus einem solchen Ausdruck den kennzeichnenden Buchstaben für den Typ des Elements sowie den Primärschlüsselwert zu ermitteln, haben wir eine kleine Hilfsprozedur entwickelt.<\/p>\n Diese heißt KeyParsen <\/b>und sieht wie in Listing 2 aus (siehe Modul mdlTools<\/b>). Die Prozedur erwartet drei Parameter. strKey <\/b>übergibt den Key<\/b>-Wert und die Parameter strTyp <\/b>und lngID <\/b>sind Rückgabeparameter, die in der Prozedur KeyParsen <\/b>gefüllt werden.<\/p>\n Listing 2: Die Funktion KeyParsen<\/span><\/b><\/p>\n KeyParsen <\/b>ermittelt zunächst mit der InStrRev<\/b>-Funktion die Position des hintersten Pipe-Zeichens. Ist diese größer 0<\/b>, schneidet die Prozedur den Teil vor diesem Trennzeichen ab, sodass strKey <\/b>anschließend nur noch den Key <\/b>des aktuellen Elements enthält. Falls kein Pipe-Zeichen vorliegt, scheint es sich bereits um einen einfachen Key<\/b>-Wert zu handeln (entweder, weil es ein Root-Element ist oder weil alle Key<\/b>-Werte einfache Key<\/b>-Werte sind). strType<\/b> wird dann mit dem ersten Zeichen aus strKey <\/b>gefüllt, lngID <\/b>mit der darauf folgenden Zeichenkette (dies funktioniert nur mit TreeView<\/b>-Steuerelementen, die nur einfache Buchstaben verwenden – sollten Sie mehr Buchstaben benötigen, müssen Sie den Mechanismus auf zwei oder mehr Buchstaben zu Beginn des Key<\/b>-Wertes umstellen). Normalerweise sollten jedoch 26 verschiedene Typen ausreichen, was den Buchstaben des Alphabets entspricht (der Key<\/b>-Wert muss immer mit einem Buchstaben beginnen).<\/p>\n Die Prozedur cmdNeueBaugruppeI_Click <\/b>ruft also die Routine KeyParsen <\/b>auf, um strTyp <\/b>und lngID <\/b>einzulesen. Dann ermittelt sie per InputBox <\/b>den Namen der neuen Baugruppe (s. Bild 2) und speichert das Ergebnis in der Variablen strBezeichnung<\/b>. Hat der Benutzer einen Wert ungleich dem Standardwert [Neue Baugruppe] <\/b>eingegeben, erfolgen die weiteren Schritte. Die Prozedur prüft anhand von strKey <\/b>den Typ des übergeordneten Elements. Wenn es das Root-Element ist (r<\/b>), legt die Prozedur einen neuen Datensatz in der Tabelle tblBaugruppen <\/b>an und stellt den Wert von IstProdukt <\/b>auf -1 <\/b>(True<\/b>) ein. Die folgende Anweisung ermittelt den Primärschlüsselwert des neuen Datensatzes und speichert diesen in lngNeuID<\/b>. Damit kann sie nun das neue Element im TreeView<\/b>-Steuer-element anlegen. Dabei verwendet sie den Key <\/b>des mit objNode <\/b>referenzierten Elements als Bezugspunkt und legt das neue Element als Kind-Element an. Der Key <\/b>wird aus dem Key <\/b>des übergeordneten Elements, dem Pipe-Zeichen, dem Buchstaben p <\/b>(für Produkt) und dem Primärschlüsselwert gebildet (für TreeViews ohne reflexive Beziehung reichen der Buchstabe und der Primärschlüsselwert aus). Als Bezeichnung kommt schließlich der per InputBox <\/b>ermittelte Ausdruck zum Einsatz.<\/p>\n Bild 2: Anlegen eines neuen Elements per InputBox<\/span><\/b><\/p>\n Sollte die Baugruppe unterhalb einer als Produkt gekennzeichneten Baugruppe oder einer einfachen Baugruppe (strKey <\/b>gleich p <\/b>oder b<\/b>) angelegt worden sein, ist ein zusätzlicher Schritt nötig. Zunächst legt die Prozedur wieder den Datensatz in tblBaugruppen <\/b>an (diesmal mit dem Wert 0<\/b>\/False <\/b>im Feld IstProdukt<\/b>) und erstellt das Element im TreeView<\/b>-Steuerelement unterhalb des aktuellen Elements. Um die Abhängigkeit von dem übergeordneten Element nach dem Schließen und erneuten öffnen des Formulars wiederherstellen zu können, muss dieser noch in Form eines Datensatzes in der reflexiven Verknüpfungstabelle tblBaugruppenZuordnungen <\/b>gespeichert werden.<\/p>\n Im Anschluss an diese Schritte stellt die Prozedur noch den Wert der Eigenschaft Expanded <\/b>des übergeordneten Node<\/b>-Objekts auf True <\/b>ein und klappt damit die untergeordneten Elemente aus. Das neue Element wird als aktuelles Element markiert und das TreeView<\/b>-Steuerelement erhält den Fokus, damit die Markierung des aktuellen Steuerelements gut zu erkennen ist (sonst wird dieses nur schwach grau dargestellt).<\/p>\n <\/p>\n Element direkt hinzufügen<\/b><\/p>\n Alternativ zur ersten Methode können Sie auch direkt ein neues Element unterhalb des aktuell markierten Elements anlegen und dieses gleich zum Bearbeiten durch den Benutzer vorbereiten (s. Bild 3).<\/p>\n Bild 3: Direktes Anlegen eines neuen Elements<\/span><\/b><\/p>\n Die Prozedur, die durch einen Mausklick auf die Schaltfläche cmdNeueBaugruppeII <\/b>ausgelöst wird, finden Sie in Auszügen in Listing 3. Warum in Auszügen Weil die Prozedur fast genauso aufgebaut ist wie die Prozedur aus dem vorherigen Beispiel.<\/p>\n Listing 3: Diese Prozedur legt ein neues Node-Objekt an und bietet seine Bearbeitung an.<\/span><\/b><\/p>\n Sie ermittelt die Informationen zum übergeordneten Element, prüft den Typ dieses Elements und ruft dann eine von zwei möglichen INSERT INTO<\/b>-Anweisungen innerhalb einer Select Case<\/b>-Bedingung auf. Dort gibt es jedoch den Unterschied, dass die Prozedur nicht zuvor die Bezeichnung des neu hinzuzufügenden Elements abgefragt hat. Diese soll der Benutzer aber ja auch später eingeben, daher verwendet die INSERT INTO <\/b>zunächst den Wert [Neue Baugruppe] <\/b>als Wert für die Bezeichnung des neuen Node<\/b>-Elements.<\/p>\n Nach dem Anlegen des neuen Elements und dem Erstellen des entsprechenden Datensatzes in der Tabelle tblBaugruppen <\/b>(beziehungsweise in tblBaugruppenZuordnungen<\/b>) markiert die Prozedur das neue Element noch durch Einstellen der Eigenschaft StartLabelEdit <\/b>zum Bearbeiten.<\/p>\n Ereignis beim ändern des neuen Eintrags<\/b><\/p>\n Da der Eintrag nun hinzugefügt und zum ändern durch den Benutzer vorbereitet wurde, braucht der Benutzer nur noch die neue Bezeichnung der Baugruppe einzufügen und die Eingabe zu bestätigen. Durch diese Aktion allein ändert er jedoch nur den angezeigten Wert. Nach dem Schließen und öffnen des Formulars zeigt dieses wieder den vorherigen Wert (hier [Neue Baugruppe]<\/b>) an.<\/p>\n Typischerweise wird der Benutzer den neuen Eintrag aber direkt nach dem Anlegen auch anpassen. Damit die vorgenommenen änderungen auch in der Datenbank gespeichert werden, legen Sie eine Ereignisprozedur an, die durch das Ereignis AfterLabelEdit <\/b>des TreeView<\/b>-Steuerelements ausgelöst wird (s. Listing 4). Die Prozedur referenziert zunächst das aktuell markierte Element im TreeView<\/b>-Steuerelement mit der Variablen objNode<\/b>. Dann ermittelt sie den Key<\/b>-Wert und speichert diesen in der Variablen strKey<\/b>. Ein Aufruf der Prozedur KeyParsen <\/b>ermittelt aus dem Key <\/b>den Typ des Elements sowie den Primärschlüsselwert des betroffenen Datensatzes.<\/p>\n Listing 4: Prozedur, die nach dem ändern eines der Einträge im TreeView-Steuerelement ausgelöst wird<\/span><\/b><\/p>\n Der Parameter NewString <\/b>der Prozedur objTreeView_AfterLabelEdit <\/b>liefert die durch den Benutzer eingegebene neue Bezeichnung. Hat das Element den Typ p <\/b>oder b<\/b>, aktualisiert die Prozedur den Wert des Feldes Baugruppe <\/b>des Datensatzes mit dem Primärschlüsselwert aus lngID <\/b>mit der neu eingegebenen Bezeichnung. Anschließend werden eventuelle Unterelemente angezeigt, das Element markiert und der Fokus auf das TreeView<\/b>-Steuerelement gelegt.<\/p>\n Elemente mit Details anlegen<\/b><\/p>\n Die Einzelteile, aus denen eine Baugruppe besteht, enthalten einige weitere Eigenschaften. Angenommen, diese werden für weitere Aufgaben benötigt, reicht es natürlich nicht aus, Einzelteile einfach wie bei den beiden oben erwähnten Methoden anzulegen – also nur die Bezeichnung anzugeben und den Rest irgendwann später nachzutragen.<\/p>\n Erfahrungsgemäß geschieht dies nämlich oft nicht zeitnah, was zu einem lückenhaften Datenbestand führt.<\/p>\n Also schauen wir uns an, wie Sie solche Elemente anlegen können. Die erste Variante ist das Anzeigen eines Detailformulars zur Eingabe eines neuen Datensatzes, der erst nach der Eingabe aller notwendigen Informationen geschlossen werden kann und dann das neue Element im TreeView<\/b>-Steuerelement anzeigt.<\/p>\n Die zweite Variante geht davon aus, dass die Details der Elemente im TreeView<\/b>-Steuerelement in einem Unterformular im gleichen Formular wie das TreeView<\/b>-Steuerelement angezeigt werden.<\/p>\n TreeView-Element per Detailformular anlegen<\/b><\/p>\n Die Beispieldatenbank enthält ein bereits vorbereitetes Formular namens frmEinzelteil<\/b>. Dieses erlaubt das Anlegen eines einzelnen Datensatzes in der Tabelle tblEinzelteile<\/b>. Das Formular besitzt eine Schaltfläche namens cmdOK<\/b>, welche das Formular unsichtbar macht:<\/p>\n Ein Klick auf die Schaltfläche cmd-Neues-EinzelteilI <\/b>des Formulars frmStueck-listeTreeView<\/b> löst die Prozedur aus Listing 5 aus. Diese referenziert wieder das aktuell markierte Node<\/b>-Element, da das neue Einzelteil unterhalb dieses Elements angelegt werden soll.<\/p>\n Listing 5: Anlegen eines neuen Einzelteils erst per Detailformular, dann im TreeView-Steuerelement<\/span><\/b><\/p>\n Die folgenden Anweisungen ermitteln wieder den Key<\/b>-Wert des Node<\/b>-Elements und daraus den Typ und den Primärschlüsselwert des Elements, unter dem der neue Einzelteil-Datensatz angelegt werden soll. Hier gibt es wieder zwei Möglichkeiten: entweder das Einzelteil soll gleich als neues Produkt angelegt werden oder als Teil einer Baugruppe.<\/p>\n Nun öffnet die Prozedur das Formular frmEinzelteil<\/b>, und zwar als modalen Dialog. Auf diese Weise wird der Code bei der aufrufenden Anweisung angehalten. Außerdem übergibt die Prozedur dem Aufruf der Methode OpenForm <\/b>den Wert acFormAdd <\/b>für den Parameter DataMode<\/b>. Auf diese Weise zeigt das Formular gleich einen leeren, neuen Datensatz an (s. Bild 4).<\/p>\n Bild 4: Anlegen eines neuen Elements per Formular<\/span><\/b><\/p>\n Wenn der Benutzer auf die Schaltfläche cmdOK<\/b> klickt, macht er das Formular unsichtbar und die aufrufende Prozedur läuft weiter. Dabei prüft diese zunächst mit der Hilfsfunktion IstFormular-Ge-oeffnet<\/b>, ob das Formular noch geöffnet ist. Ist dies der Fall, liest die Prozedur den Wert des Primärschlüsselfeldes EinzelteilID <\/b>in die Variable lngEinzelteilID <\/b>ein. Vorsichtshalber verwendet die Prozedur dabei die Funktion Nz<\/b>, die den Wert 0 <\/b>zurückliefert, sollte das Einzelteil-ID <\/b>noch den Wert Null <\/b>enthalten. Besitzt lngEinzelteilID <\/b>danach einen Wert größer 0<\/b>, speichert die Prozedur zunächst den gegebenenfalls noch in Bearbeitung befindlichen Datensatz des Formulars frmEinzelteil<\/b>, indem sie die Eigenschaft Dirty <\/b>auf den Wert False <\/b>einstellt. Dann liest sie die Bezeichnung des Einzelteils aus dem Feld Einzelteil <\/b>in die Variable strEinzelteil <\/b>ein.<\/p>\n Schließlich folgt die Unterscheidung nach dem beim Aufruf der Prozedur aktiven Element im TreeView<\/b>-Steuerelement: War das Root-Element mit der Beschriftung Produkte <\/b>aktiv, soll das Einzelteil gleich als Produkt angelegt werden (also mit IstProdukt <\/b>gleich -1<\/b>\/True<\/b>) – unabhängig davon, was der Benutzer im Formular frmEinzelteil <\/b>angegeben hat. In diesem Fall hat strTyp <\/b>den Wert r,<\/b> was in einer Select Case<\/b>-Bedingung ausgewertet wird. Dort aktualisiert die Prozedur noch das Feld IstProdukt <\/b>mit dem Wert -1 <\/b>und legt das neue Element im TreeView<\/b>-Steuerelement an. War hingegen eines der Elemente aktiv, die im TreeView<\/b>-Steuerelement mit dem Buchstaben p <\/b>für Produkt <\/b>oder b <\/b>wie Bauteil <\/b>gekennzeichnet sind, soll das neue Einzelteil gleich als Teil einer Baugruppe angelegt werden.<\/p>\n In diesem Fall muss ein neuer Eintrag zur Verknüpfungstabelle tblBaugruppenEinzelteile <\/b>hinzugefügt werden, welcher das neue Einzelteil mit der im TreeView<\/b>-Steuerelement markierten Baugruppe verknüpft. Schließlich legt die Prozedur noch ein neues Einzelteil<\/b>-Element im TreeView<\/b>-Steuerelement an, und zwar unterhalb des zuletzt markierten Elements.<\/p>\n Nachdem diese Aufgaben erledigt sind, kann die Prozedur auch das bislang nur unsichtbare Formular frmEinzelteil <\/b>schließen.<\/p>\n Anlegen von Elementen mit Unterformular<\/b><\/p>\n Fehlt noch eine weitere interessante Variante, die oft Anwendung finden dürfte: das Anlegen von Elementen im Unterformular auf dem gleichen Formular wie das TreeView<\/b>-Element.<\/p>\n Dazu fügen wir der Einfachheit halber das Formular frmEinzelteil <\/b>dem Formular frmStuecklisteTreeView <\/b>als Unterformular hinzu (s. Bild 5). Damit dieses eingeblendet wird, sobald der Benutzer im TreeView<\/b>-Steuerelement auf ein Einzelteil<\/b>-Element klickt, fügen Sie eine Ereignisprozedur hinzu, die durch das Ereignis NodeClick <\/b>des TreeView<\/b>-Steuerelements ausgelöst wird.<\/p>\n Bild 5: TreeView-Steuerelement und Unterfomular in einem Formular<\/span><\/b><\/p>\n Die Prozedur sieht wie in Listing 6 aus und analysiert zunächst die in der Key<\/b>-Eigenschaft des mit dem Parameter Node <\/b>übergebenen angeklickten Elements. Falls strTyp <\/b>den Wert e <\/b>enthält, handelt es sich um ein Einzelteil. In diesem Fall soll das Unterformular-Steuerelement frmEinzelteil <\/b>sichtbar gemacht werden. Außerdem soll die Prozedur den Inhalt des Unterformulars so filtern, dass nur der zum aktuell angeklickten Element passende Datensatz angezeigt wird. Die dazu nötigen Informationen liefert die Key<\/b>-Eigenschaft. Hat der Benutzer ein anderes Element angeklickt, blendet die Prozedur das Unterformular-Steuerelement aus.<\/p>\n Listing 6: Aktivieren und Filtern des Unterformulars beim Klick auf ein TreeView-Element<\/span><\/b><\/p>\n Nun kommen wir zum interessanten Teil: Was soll geschehen, wenn der Benutzer auf die Schaltfläche cmdNeuesEinzelteilII <\/b>klickt Prinzipiell könnte dies mehrere Aktionen auslösen:<\/p>\n Aber was geschieht als Nächstes Wenn der neue Datensatz im Unterformular angezeigt wird, sieht der Benutzer nicht direkt, ob das neue Einzelteil an der gewünschten Stelle im TreeView<\/b>-Steuerelement eingefügt wurde. Wenn das Element zunächst nur im TreeView<\/b>-Steuerelement angelegt wird, könnte das Problem auftreten, dass der Benutzer nicht mehr die vollständigen Daten im Unterformular eingibt.<\/p>\n Also wählen wir die sichere Variante: Wir legen direkt ein neues Element an und vergeben einen Dummy-Wert für die Bezeichnung des Einzelteils. Dann können wir diesen Wert gleichzeitig im TreeView<\/b>-Steuerelement und auch im Unterformular anzeigen und der Benutzer kann die Daten im Unterformular bequem ergänzen.<\/p>\n Damit der Benutzer die Gelegenheit hat, das Anlegen abzubrechen, fügen wir dem Unterformular noch eine Schaltfläche namens cmdAbbrechen <\/b>hinzu, die den neuen Datensatz verwirft und den Eintrag im TreeView<\/b>-Steuerelement wieder entfernt.<\/p>\n Und um dem Ganzen die Krone aufzusetzen, sorgen wir auch noch dafür, dass die vom Benutzer im Unterformular geänderte Bezeichnung des Einzelteils in Echtzeit auf das entsprechende Element im TreeView<\/b>-Steuerelement übertragen wird.<\/p>\n Neuer Datensatz<\/b><\/p>\n Damit das Unterformular zum Anlegen eines neuen Datensatzes eingeblendet wird, muss der Benutzer zunächst auf die Schaltfläche cmdNeuesEinzelteilII<\/b> klicken. Dies löst dann die Ereignisprozedur aus Listing 7 aus. Die Prozedur führt die bereits besprochenen Schritte zur Ermittlung des aktuell markierten Elements im TreeView<\/b>-Steuerelement durch. Danach stellt die Prozedur die Eigenschaft Visible <\/b>des Unterformular-Steuerelements frmEinzelteil <\/b>auf True <\/b>ein, um dieses einzublenden. Das Unterformular erhält den Fokus und mit der Methode GotoRecord <\/b>des DoCmd<\/b>-Objekts und dem Wert acNewRec <\/b>für den Parameter Record <\/b>wird ein neuer Datensatz angelegt. Damit der neue Datensatz im Unterformular und später im TreeView<\/b>-Steuerelement mit gleichem Namen erscheint, stellt die Prozedur dann den Wert des Feldes Einzelteil <\/b>auf [Neues Einzelteil] <\/b>ein. Dann speichert sie den Primärschlüsselwert des neuen, aber noch nicht gesicherten Datensatzes in der Variablen lngNeuID <\/b>ab.<\/p>\n\n
\n
![\"Schaltflächen](\"..\/fileadmin\/_temp_\/2014_01\/pic_919_001.png\")
<\/p>\nPrivate Sub <\/span>cmdNeueBaugruppeI_Click()\r\n Dim <\/span>objNode As <\/span>MSComctlLib.Node\r\n Dim <\/span>objNodeNeu As <\/span>MSComctlLib.Node\r\n Dim <\/span>strKey As String<\/span>\r\n Dim <\/span>strTyp As String<\/span>\r\n Dim <\/span>lngID As Long<\/span>\r\n Dim <\/span>lngNeuID As Long<\/span>\r\n Dim <\/span>strBezeichnung As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> objNode = objTreeView.SelectedItem\r\n strKey = objNode.Key\r\n KeyParsen strKey, strTyp, lngID\r\n strBezeichnung = InputBox(\"Geben Sie die Bezeichnung der neuen Baugruppe an.\", _\r\n \"Neue Baugruppe\", \"[Neue Baugruppe]\")\r\n If <\/span>Len<\/span>(strBezeichnung) > 0 And Not<\/span> strBezeichnung = \"[Neue Baugruppe]\" Then<\/span>\r\n Set<\/span> db = CurrentDb\r\n Select Case strTyp\r\n Case <\/span>\"r\"\r\n db.Execute \"INSERT INTO tblBaugruppen(Baugruppe, IstProdukt) VALUES(''\" _\r\n & strBezeichnung & \"'', -1)\", dbFailOnError\r\n lngNeuID = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n Set<\/span> objNodeNeu = objTreeView.Nodes.Add(objNode.Key, tvwChild, objNode.Key _\r\n & \"|p\" & lngNeuID, strBezeichnung, \"elements_hierarchy\")\r\n Case <\/span>\"p\", \"b\"\r\n db.Execute \"INSERT INTO tblBaugruppen(Baugruppe, IstProdukt) VALUES(''\" _\r\n & strBezeichnung & \"'', 0)\", dbFailOnError\r\n lngNeuID = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n db.Execute \"INSERT INTO tblBaugruppenzuordnungen(BaugruppeVaterID, " _\r\n & "BaugruppeKindID) VALUES(\" & lngID & \", \" _\r\n & lngNeuID & \")\", dbFailOnError\r\n Set<\/span> objNodeNeu = objTreeView.Nodes.Add(objNode.Key, tvwChild, objNode.Key _\r\n & \"|p\" & lngNeuID, strBezeichnung, \"gearwheels\")\r\n End Select<\/span>\r\n objNode.Expanded = True<\/span>\r\n objTreeView.SelectedItem = objNodeNeu\r\n Me!ctlTreeView.SetFocus\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n\n
Public Sub <\/span>KeyParsen(ByVal strKey As String<\/span>, strTyp As String<\/span>, lngID As Long<\/span>)\r\n Dim <\/span>lngPosPipe As Long<\/span>\r\n lngPosPipe = InStrRev<\/span>(strKey, \"|\")\r\n If <\/span>lngPosPipe > 0 Then<\/span>\r\n strKey = Mid<\/span>(strKey, lngPosPipe + 1)\r\n End If<\/span>\r\n strTyp = Left<\/span>(strKey, 1)\r\n lngID = Mid<\/span>(strKey, 2)\r\nEnd Sub<\/span><\/pre>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2014_01\/pic_919_002.png\")
<\/p>\n![\"Direktes](\"..\/fileadmin\/_temp_\/2014_01\/pic_919_003.png\")
<\/p>\nPrivate Sub <\/span>cmdNeueBaugruppeII_Click()\r\n ...\r\n Select Case strTyp\r\n Case <\/span>\"r\"\r\n db.Execute \"INSERT INTO tblBaugruppen(Baugruppe, IstProdukt) " _\r\n & "VALUES(''[Neue Baugruppe]'', -1)\", dbFailOnError\r\n ...\r\n Case <\/span>\"p\", \"b\"\r\n db.Execute \"INSERT INTO tblBaugruppen(Baugruppe, IstProdukt) " _\r\n & "VALUES(''[Neue Baugruppe]'', 0)\", dbFailOnError\r\n ...\r\n End Select<\/span>\r\n ...\r\n objTreeView.StartLabelEdit\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>objTreeView_AfterLabelEdit(Cancel As Integer<\/span>, NewString As String<\/span>)\r\n Dim <\/span>objNode As <\/span>MSComctlLib.Node\r\n Dim <\/span>strKey As String<\/span>\r\n Dim <\/span>strTyp As String<\/span>\r\n Dim <\/span>lngID As Long<\/span>\r\n Dim <\/span>strBezeichnung As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> objNode = objTreeView.SelectedItem\r\n strKey = objNode.Key\r\n KeyParsen strKey, strTyp, lngID\r\n strBezeichnung = NewString\r\n Set<\/span> db = CurrentDb\r\n Select Case strTyp\r\n Case <\/span>\"p\", \"b\"\r\n db.Execute \"UPDATE tblBaugruppen SET Baugruppe = ''\" & strBezeichnung _\r\n & \"'' WHERE BaugruppeID = \" & lngID, dbFailOnError\r\n End Select<\/span>\r\n objNode.Expanded = True<\/span>\r\n objTreeView.SelectedItem = objNode\r\n Me!ctlTreeView.SetFocus\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdOK_Click()\r\n Me.Visible = False<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdNeuesEinzelteilI_Click()\r\n Dim <\/span>strForm As String<\/span>\r\n Dim <\/span>lngEinzelteilID As Long<\/span>, lngBaugruppeID As Long<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>objNode As <\/span>MSComctlLib.Node, objNodeNeu As <\/span>MSComctlLib.Node\r\n Dim <\/span>strKey As String<\/span>, strTyp As String<\/span>, strEinzelteil As String<\/span>\r\n Set<\/span> objNode = objTreeView.SelectedItem\r\n strKey = objNode.Key\r\n KeyParsen strKey, strTyp, lngBaugruppeID\r\n strForm = \"frmEinzelteil\"\r\n DoCmd.OpenForm strForm, windowMode:=acDialog, Datamode:=acFormAdd\r\n If <\/span>IstFormularGeoeffnet(strForm) Then<\/span>\r\n lngEinzelteilID = Nz(Forms(strForm)!EinzelteilID)\r\n If <\/span>lngEinzelteilID > 0 Then<\/span>\r\n Forms(strForm).Dirty = False<\/span>\r\n strEinzelteil = Nz(Forms(strForm)!Einzelteil)\r\n Set<\/span> db = CurrentDb\r\n Select Case strTyp\r\n Case <\/span>\"r\"\r\n db.Execute \"UPDATE tblEinzelteile SET IstProdukt = -1 WHERE EinzelteilID = \" _\r\n & lngEinzelteilID, dbFailOnError\r\n Set<\/span> objNodeNeu = objTreeView.Nodes.Add(objNode.Key, tvwChild, objNode.Key _\r\n & \"|p\" & lngEinzelteilID, strEinzelteil, \"elements_hierarchy\")\r\n Case <\/span>\"p\", \"b\"\r\n db.Execute \"INSERT INTO tblBaugruppenEinzelteile(BaugruppeID, EinzelteilID) " _\r\n "VALUES(\" & lngBaugruppeID & \", \" & lngEinzelteilID & \")\", dbFailOnError\r\n Set<\/span> objNodeNeu = objTreeView.Nodes.Add(objNode.Key, tvwChild, _\r\n objNode.Key & \"|e\" & lngEinzelteilID, strEinzelteil, \"gearwheel\")\r\n End Select<\/span>\r\n End If<\/span>\r\n DoCmd.Close acForm, strForm\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2014_01\/pic_919_004.png\")
<\/p>\n![\"TreeView-Steuerelement](\"..\/fileadmin\/_temp_\/2014_01\/pic_919_005.png\")
<\/p>\nPrivate Sub <\/span>objTreeView_NodeClick(ByVal Node As <\/span>MSComctlLib.Node)\r\n Dim <\/span>strKey As String<\/span>, strTyp As String<\/span>\r\n Dim <\/span>lngID As Long<\/span>\r\n strKey = Node.Key\r\n KeyParsen strKey, strTyp, lngID\r\n Select Case strTyp\r\n Case <\/span>\"e\"\r\n With<\/span> Me!frmEinzelteil\r\n .Visible = True<\/span>\r\n .Form.Filter = \"EinzelteilID = \" & lngID\r\n .Form.FilterOn = True<\/span>\r\n End With<\/span>\r\n Case Else<\/span>\r\n Me!frmEinzelteil.Visible = False<\/span>\r\n End Select<\/span>\r\n SchaltflaechenAktivieren\r\nEnd Sub<\/span><\/pre>\n\n
Private Sub <\/span>cmdNeuesEinzelteilII_Click()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>objNode As <\/span>MSComctlLib.Node, objNodeNeu As <\/span>MSComctlLib.Node\r\n Dim <\/span>strKey