<\/p>\n
Was lange währt, wird endlich gut: Hier kommt der zweite Teil zu der vor einigen Ausgaben begonnenen Reihe zum Thema Stücklisten. Nachdem das TreeView-Steuerelement zur Anzeige und zum Bearbeiten von Baugruppen und Teilen steht, erweitern wir die Lösung nun um Kontextmenü-Einträge, mit denen Sie Baugruppen und Elemente hinzufügen, bearbeiten und entfernen können.<\/b><\/p>\nKontextmenüs für die Stückliste<\/h2>\n
Im ersten Teil der Beitragsreihe haben wir bereits ein erstes Kontextmenü mit Untermenüs zur Anwendung hinzugefügt. Dieses wird angezeigt, wenn der Benutzer mit der rechten Maustaste auf den Root-Eintrag des TreeViews mit der Beschriftung Produkte <\/b>klickt. Es erscheint dann ein Kontextmenü mit den beiden Einträgen Baugruppen <\/b>und Einzelteile<\/b>, die wiederum Untermenüs mit den vorhandenen Elementen anzeigen (s. Bild 1).<\/p>\n
![\"Kontextmenü](\"..\/fileadmin\/_temp_\/2017_02\/pic_1084_001.png\")
<\/p>\n
Bild 1: Kontextmenü zum Anlegen von Produkten<\/span><\/b><\/p>\n Nach dem Anklicken einer der Baugruppen beziehungsweise eines der Einzelteile wird dieses direkt unterhalb des Elements Produkte <\/b>angelegt.<\/p>\n Es fehlen allerdings noch einige weitere Kontextmenüs – beispielsweise, um Baugruppen weitere Baugruppen oder Elemente hinzuzufügen, um Baugruppen und Teile zu entfernen oder auch um Baugruppen oder Teile zu markieren, zu kopieren und an anderen Stellen wieder einzufügen.<\/p>\n Zur Erinnerung an den ersten Teil der Beitragsreihe: Wir unterscheiden prinzipiell zwischen Baugruppen (Tabelle tblBaugruppen<\/b>) und Einzelteilen (tblEinzelteile<\/b>) sowie zwischen Produkten. Letztere sind Baugruppen oder Einzelteile, die im Datensatz ihrer Tabelle mit dem Wert True <\/b>im Feld IstProdukt <\/b>gekennzeichnet sind.<\/p>\n Produkte werden immer direkt unterhalb des Root-Elements Produkte <\/b>angezeigt, alle anderen dort, wo sie zugeordnet wurden. Es kann natürlich auch Baugruppen oder Einzelteile geben, die nur in der Tabelle verfügbar sind, aber noch keinem Produkt oder keiner Baugruppe untergeordnet sind und dementsprechend nicht im TreeView erscheinen.<\/p>\n Die wichtigste Prozedur beim Anzeigen von Kontextmenüs ist die, welche beim Herunterdrücken der rechten Maustaste ausgelöst wird. In unserem Fall sieht diese wie in Listing 1 aus.<\/p>\n Listing 1: Aufrufen eines Kontextmenü-Eintrags<\/span><\/b><\/p>\n Achtung: Möglicherweise kommt Ihnen diese Prozedur bekannt vor, da wir diese im ersten Teil schon einmal vorgestellt haben. Bei der Weiterentwicklung haben wir jedoch ein paar kleine Optimierungen vorgenommen, welche das Anlegen und Entfernen von Elementen wesentlich erleichtern. Dazu gehört unter anderem, dass wir bei den Aufrufen der Prozeduren KontextmenueEinzelteil <\/b>und KontextmenueBaugruppe <\/b>nun immer auch den Key<\/b>-Wert des aktuellen Elements mitgeben – mehr dazu weiter unten.<\/p>\n Die Prozedur prüft anhand des Parameters Button<\/b>, welche Maustaste der Benutzer heruntergedrückt hat. Handelt es sich um die rechte Maustaste (acRightButton<\/b>), soll das Kontextmenü eingeblendet werden. Unsere Prozedur dient dabei als eine Art Verteiler, die prüfen soll, auf welcher Elementart die rechte Maustaste betätigt wurde, und dann eine entsprechende Prozedur zum Anzeigen des Kontextmenüs aufruft. Bevor dies geschieht, ermittelt sie mit der HitTest<\/b>-Methode des TreeView<\/b>-Elements auf welchem Element die rechte Maustaste betätigt wurde. Das Ergebnis landet in der MSComCtlLib.Node<\/b>-Variablen objNode<\/b>. Sollte diese anschließend nicht den Wert Nothing <\/b>enthalten, hat der Benutzer tatsächlich ein Element angeklickt.<\/p>\n In diesem Fall ermitteln wir aus der Key<\/b>-Variablen des Elements, der beispielsweise den Wert r0<\/b>, r0|b18 <\/b>oder r0|b18|e50 <\/b>enthalten kann, den Buchstaben des hintersten Elements, hier also r<\/b>, b <\/b>oder e<\/b>, und speichern diesen in der Variablen strTyp<\/b>. Die Zahl hinter diesem Element, die dem Primärschlüsselwert des entsprechenden Eintrags einer der Tabellen tblBaugruppen <\/b>oder tblEinzelteile <\/b>entspricht, landet hingegen in der Variablen lngID<\/b>. Der Inhalt von strTyp<\/b> wird in der folgenden Select Case<\/b>-Bedingung geprüft. Abhängig vom Wert rufen wir dann eine der Prozeduren KontextmenueRoot <\/b>(r<\/b>, Root-Element), KontextmenueEinzelteil <\/b>(p<\/b>, Produkt-Element), KontextmenueBaugruppe <\/b>(b<\/b>, Bauteil-Element) oder KontextmenueEinzelteil <\/b>(e<\/b>, Einzelteil-Element) auf. Dieser übergeben wir den Primärschlüssel des aktuellen Elements sowie den Key<\/b>-Wert (zum Beispiel r0<\/b>, r0|b18 <\/b>oder r0|b18|e50<\/b>).<\/p>\n Schauen wir uns erst das Root-Kontextmenü an. Die entsprechende Prozedur heißt KontextmenueRoot <\/b>und sieht wie in Listing 2 aus. Die Prozedur löscht zunächst ein eventuell bereits vorhandenes Kontextmenü namens TreeView_Root<\/b> – vorsichtshalber bei deaktivierter Fehlerbehandlung, da der Versuch, ein nicht vorhandenes Kontextmenü zu löschen, einen Fehler auslösen würde. Danach legen wir dieses direkt neu an, und zwar mit der dafür vorgesehenen Methode Add<\/b>. Diese erwartet als Parameter den Namen des Menüs, die Art (da die Add<\/b>-Methode früher auch für das Anlegen von Menüleisten und Symbolleisten verantwortlich war – hier msoBarPopup <\/b>für Kontextmenü) sowie die Angabe, ob es sich um ein temporäres Menü handelt, das mit dem Schließen der Anwendung wieder entsorgt werden kann.<\/p>\n Listing 2: Kontextmenü für das Root-Element einblenden<\/span><\/b><\/p>\n Danach folgt der Aufruf zweier weiterer Routinen, nämlich KontextmenueBaugruppen <\/b>und KontextmenueEinzelteile<\/b>:<\/p>\n Nach dem Anlegen der Kontextmenü-Elemente für die Baugruppen und die Einzelteile wird das Menü mit der Popup<\/b>-Methode des CommandBar<\/b>-Objekts eingeblendet.<\/p>\n Die Prozedur KontextmenueBaugruppen <\/b>(s. Listing 3) erwartet drei Parameter – einen Verweis auf das Kontextmenü (cbr<\/b>), die ID des Elements, von dem aus das Kontextmenü aufgerufen wurde, sowie den Wert der Key<\/b>-Eigenschaft dieses Elements.<\/p>\n Listing 3: Untermenü für die Baugruppen hinzufügen<\/span><\/b><\/p>\n Die Prozedur legt mit der Variablen cbp<\/b> ein Steuerelement des Typs msoControlPopup <\/b>an, also ein Untermenü, und weist diesem den Text Baugruppen <\/b>hinzu. Das Untermenü soll einen Eintrag mit der Bezeichnung Neue Baugruppe <\/b>sowie eine Auflistung der bisher verfügbaren Baugruppen erhalten. Also legen wir zunächst eine einzelne Schaltfläche an (Typ msoControlButton<\/b>), speichern diese in der Variablen cbc <\/b>und weisen den Text Neue Baugruppe <\/b>sowie für die OnAction<\/b>-Eigenschaft den Wert =NeueBaugruppe(0) <\/b>hinzu. Der Wert 0 <\/b>für den einzigen Parameter kennzeichnet, dass die Baugruppe in der obersten Ebene, also als Produkt angelegt werden soll – dazu später mehr.<\/p>\n Danach ermittelt die Prozedur die anzuzeigenden Baugruppen. Wenn die Funktion vom Root-Element aus aufgerufen wurde, sollen alle Elemente erscheinen, die noch nicht über das Feld IstProdukte <\/b>als Produkt gekennzeichnet sind und ohnehin schon als Produkt-Elemente angezeigt werden.<\/p>\n Wurde das Kontextmenü von einer Baugruppe aus aufgerufen, erzeugt die Prozedur mit Hilfe der Funktion AuszuschliessendeBaugruppen <\/b>eine Liste der Baugruppen, die nicht angelegt werden können, da dies einen Zirkelbezug erzeugen würde. Mehr dazu weiter unten. Dies ergibt eine Liste wie 1, 2, 3<\/b>, die dann innerhalb der folgenden If…Then<\/b>-Bedingung zu einer WHERE<\/b>-Bedingung hinzugefügt wird. Diese sieht anschließend etwa wie folgt aus:<\/p>\n Danach erstellen wir ein Recordset auf Basis der Tabelle tblBaugruppen<\/b>, in der wir alle Baugruppen erfassen, die dem aktuellen Element untergeordnet werden können, ohne einen Zirkelbezug auszulösen. Falls der Prozedur mit dem Parameter strKey <\/b>ein Wert wie etwa r0|b1|b2 <\/b>übermittelt wurde, soll dieser auch in der Funktion als Parameter enthalten sein, die durch einen der nun anzulegenden Kontextmenübefehle aufgerufen wird. Dazu wandeln wir die Zeichenkette wie r0|b1|b2 <\/b>in die Zeichenkette , “r0|b1|b2“ <\/b>um, damit wir diese in der folgenden Schleife leicht als Parameter zu der Funktion hinzufügen können.<\/p>\n In einer Do While<\/b>-Schleife durchlaufen wir nun alle Datensätze dieses Recordsets und legen für jeden Datensatz einen neuen Eintrag im Kontextmenü an. Die Einträge erhalten jeweils den Namen der Baugruppe als Beschriftung und einen Ausdruck für die Eigenschaft OnAction<\/b>, der die Funktion BaugruppeHinzufuegen <\/b>mit dem Primärschlüsselwert des aktuellen Datensatzes als Parameter enthält – also beispielsweise folgenden Wert, wenn strKey <\/b>leer war:<\/p>\n Enthielt strKey <\/b>hingegen einen Wert, lautet der Funktionsaufruf wie folgt:<\/p>\n Das Ergebnis sieht dann etwa wie in Bild 2 aus.<\/p>\n Bild 2: Anzeigen der Baugruppen im Kontextmenü für das Root-Element<\/span><\/b><\/p>\n Die zweite von der Prozedur KontextmenueRoot <\/b>aufgerufene Prozedur heißt KontextmenueEinzelteile <\/b>und sieht wie in Listing 4 aus. Diese Prozedur erwartet die gleichen drei Parameter wie die Prozedur KontextmenueBaugruppen<\/b>.<\/p>\n <\/p>\n Listing 4: Untermenü für die Einzelteile hinzufügen<\/span><\/b><\/p>\n Sie erstellt ein Untermenü mit der Beschriftung Einzelteile <\/b>und speichert dieses in der Variablen cbp<\/b>. Diesem fügt sie nun eine einzelne Schaltfläche hinzu, welche den Text Neues Einzelteil <\/b>und die Funktion =NeuesEinzelteil(0)<\/b> besitzt. Danach erstellt die Prozedur ein Recordset auf Basis der Tabelle tblEinzelteile <\/b>und durchläuft diese Datensätze genau wie bei den Bauteilen.<\/p>\n Dabei erstellt sie für jeden Eintrag eine neue Schaltfläche im Kontextuntermenü und weist diesem als Bezeichnung den Wert des Feldes Einzelteil <\/b>zu. Auch der Wert der Eigenschaft OnAction <\/b>mit der Funktion, die beim Betätigen dieses Kontextmenü-Eintrags ausgelöst werden soll, ist prinzipiell mit den von den Baugruppen bekannten Funktionen identisch – allein der Name der Funktion heißt EinzelteilHinzufuegen <\/b>und nicht BaugruppeHinzufuegen<\/b>. Ein Beispiel für einen solchen Funktionsaufruf sieht so aus:<\/p>\n Das resultierende Kontextmenü sieht wie in Bild 3 aus.<\/p>\n Bild 3: Kontextmenü zum Hinzufügen eines Einzelteils zum Root-Element<\/span><\/b><\/p>\n Eine Baugruppe kann weitere Baugruppen und Einzelteile enthalten. Das Kontextmenü soll also auch die beiden Einträge zum Hinzufügen von Baugruppen und Einzelteilen enthalten. Außerdem benötigen wir einen Eintrag, mit dem wir die aktuelle Baugruppe aus dem Produkt beziehungsweise der übergeordneten Baugruppe entfernen können.<\/p>\n Es wird schon hier offensichtlich: Wir benötigen Teile des zuvor definierten Kontextmenüs nochmal. Da wir komplett gleiche Code-Segmente nicht mehrfach in verschiedene Prozeduren schreiben wollen, um die Wartbarkeit zu erhöhen, haben wir die mehrfach verwendeten Teile einfach in eigene Routinen ausgegliedert – also beispielsweise in die Prozeduren KontextmenueBaugruppen <\/b>und KontextmenueEinzelteile<\/b>, die wir dann von den Prozeduren, in denen diese eigentlich zum Einsatz kommen, aufrufen.<\/p>\n Soeben haben wir uns angesehen, wie das Kontextmenü für das Root-Element gefüllt wird. Das Kontextmenü für eine Baugruppe sieht nicht wesentlich anders aus. Es soll allerdings einen Eintrag zum Entfernen einer Baugruppe enthalten.<\/p>\n Daher wollen wir nun auf ähnliche Weise die Prozedur KontextmenueBaugruppe <\/b>füllen. Diese soll auch die beiden Untermenüs Baugruppen <\/b>und Einzelteile <\/b>enthalten sowie auch noch einen Unterpunkt, mit dem die aktuelle Baugruppe aus dem Projekt beziehungsweise aus der übergeordneten Baugruppe entfernen werden kann (s. Bild 4).<\/p>\n Bild 4: Kontextmenü zum Entfernen einer Baugruppe<\/span><\/b><\/p>\n Die Prozedur KontextmenueBaugruppe<\/b>, die von der Prozedur objTreeView_MouseDown <\/b>aufgerufen wird, wenn der Key<\/b> des angeklickten Elements im letzten Element den Buchstaben b <\/b>enthält (also zum Beispiel für r0|e123<\/b>), sieht wie folgt aus:<\/p>\n Zusätzlich zum Aufruf der beiden Prozeduren KontextmenueBaugruppen <\/b>und KontextmenueEinzelteile <\/b>enthält es zuvor noch ein paar Anweisungen, welche dem Kontextmenü im Untermenü noch einen Eintrag mit der Beschriftung Baugruppe entfernen <\/b>zuweist.<\/p>\n Bisher haben wir ja nur die Kontextmenüs besprochen, was in Anbetracht verschiedener Elemente, die dynamisch aus mehreren Tabellen zusammengestellt werden müssen, keine allzu triviale Aufgabe war. Nun kümmern wir uns um die Funktionen, die durch einen Mausklick auf die zuvor erstellten Menüeinträge aufgerufen werden. In der Tat benötigen wir hier auf jeden Fall Funktionen, mit Prozeduren gelingt dies nicht.<\/p>\n Die erste Funktion heißt BaugruppeHinzufügen <\/b>(s. Listing 5) und wird immer dann ausgelöst, wenn der Benutzer einen der Einträge Bau-grup-pen|[Bau-grup-pen-name]<\/b> des Kontextmenüs anklickt. Die Prozedur kann von den über die Prozeduren KontextmenueRoot <\/b>und KontextmenueBaugruppe <\/b>aus erstellten Kontextmenüs aus aufgerufen werden.<\/p>\n Listing 5: Eine Baugruppe hinzufügen<\/span><\/b><\/p>\n Im ersten Fall kommt mit dem Parameter lngBaugruppeParentID <\/b>der Wert 0 <\/b>und mit strKey <\/b>eine leere Zeichenkette, weil das Kontextmenü in diesem Fall für das Root-Element erstellt wurde. Anderenfalls enthält lngBaugruppeParentID <\/b>den Primärschlüsselwert der übergeordneten Baugruppe und strKey <\/b>den Schlüssel dieses Elements. Dies wird im weiteren Verlauf eine Rolle spielen.<\/p>\n Die Funktion ermittelt zunächst einige Informationen – zum Beispiel den Namen der Baugruppe, die hinzugefügt werden soll. Diesen liefert der Aufruf einer DLookup<\/b>-Funktion mit dem Wert aus lngBaugruppe <\/b>als Kriterium. Dieser kommt mit dem ersten Parameter der Funktion.<\/p>\n Die nächste DLookup<\/b>-Funktion liefert die aktuelle Menge des Bauteils unterhalb des übergeordneten Bauteils. Diese findet sich in der Verknüpfungstabelle tblBaugruppenzuordnungen<\/b>, das Ergebnis landet in der Variablen intMenge<\/b>. Warum dies Nun: Es kann ja sein, dass eine Baugruppe oder auch ein Einzelteil mehr als einmal innerhalb eines Produkts beziehungsweise einer Baugruppe vorkommt (genau genommen ist das sogar sehr wahrscheinlich). Wenn die Funktion vom Root-Element aus aufgerufen wurde, spielt die Menge keine Rolle, denn dann wird die Baugruppe als Produkt eingestellt (also als Baugruppe, deren Feld IstProdukt <\/b>den Wert True <\/b>hat). Wurde die Funktion hingegen von einer Baugruppe aus aufgerufen, kann die Anzahl größer als eins sein, weshalb wir zuvor die Menge abfragen.<\/p>\n In der aktuellen Fassung kann die Menge nur erhöht werden, indem man eine Baugruppe oder ein Einzelteil ein weiteres Mal zur jeweils übergeordneten Gruppe hinzufügt.<\/p>\n Die Menge wird in jedem Fall um eins erhöht. Sollte das Bauteil noch nicht unter dem übergeordneten Bauteil vorhanden sein, wurde zuvor der Wert 0 <\/b>für intMenge <\/b>ermittelt, die Menge lautet dann 1<\/b>.<\/p>\n Nun folgt eine If…Then<\/b>-Bedingung, die zwei Fälle unterscheidet: lngBaugruppeParentID <\/b>hat den Wert 0 <\/b>(Aufruf vom Root-Element) oder einen anderen Wert (Aufruf von einer Baugruppe). Im ersten Fall aktualisiert die Prozedur lediglich den Wert des Feldes IstProdukt <\/b>für die hinzuzufügende Baugruppe auf True<\/b>. Außerdem fügt die Prozedur die Baugruppe als neues Produkt mit der Add<\/b>-Methode der Nodes<\/b>-Auflistung zum übergeordneten Element hinzu und legt dann mit der Funktion TreeViewFuellen_Rek<\/b>, die im ersten Teil der Beitragsreihe beschrieben wird, auch noch die diesem Element untergeordneten Elemente an.<\/p>\n Hat lngBaugruppeParentID <\/b>einen anderen Wert als 0<\/b>, wurde die Funktion von einer Baugruppe aus aufgerufen. Dann fügen wir einen Datensatz zur Tabelle tblBaugruppenzuordnungen <\/b>hinzu, der die übergeordnete Baugruppe und die hinzuzufügende Baugruppe vereint. Als Menge wird der Wert aus intMenge <\/b>eingetragen.<\/p>\n Sollte diese Kombination bereits in der Tabelle gespeichert sein, löst dies den Fehler 3022<\/b> aus, der allerdings nicht behandelt wird, da wir die Fehlerbehandlung zuvor abgeschaltet haben. Stattdessen fügen wir keinen neuen Datensatz zu dieser Tabelle hinzu, sondern aktualisieren den vorhandenen Datensatz mit dieser Kombination so, dass dieser die neue Anzahl aus der Variablen intMenge <\/b>erhält. In diesem Fall entfernen wir das vorhandene Element mit der Remove<\/b>-Methode aus dem TreeView<\/b>-Steuerelement. Anschließend rufen wir die bereits aus dem ersten Teil der Beitragsreihe bekannte Funktion TreeViewFuellen_Rek <\/b>auf, welche nicht nur das Baugruppe<\/b>-Element hinzufügt, sondern auch eventuell bereits darunter angelegte weitere Baugruppen und Einzelteile. Zur Erinnerung: Wir können ja jede Baugruppe und jedes Einzelteil beliebig oft in verschiedenen Produkten und Baugruppen unterbringen.<\/p>\n Nun wollen wir auch noch dafür sorgen, dass der Benutzer Einzelteile zur Baugruppe hinzufügen kann. Dafür zeichnet die Funktion EinzelteilHinzufuegen <\/b>verantwortlich (s. Listing 6). Diese ist prinzipiell wie die Funktion BaugruppeHinzufuegen<\/b>. Sie unterscheidet sich im Wesentlichen dadurch, dass sie nur einzelne Elemente hinzufügt und keine Baugruppen, die wiederum aus weiteren Baugruppen und Einzelteilen bestehen können. Dementsprechend fallen hier die rekursiven Aufrufe weg.<\/p>\nProdukte, Baugruppen und Einzelteile<\/h2>\n
Baugruppen oder Teile per Kontextmenü entfernen<\/h2>\n
Private Sub <\/span>objTreeView_MouseDown(ByVal Button As Integer<\/span>, ByVal Shift As Integer<\/span>, _\r\n ByVal x As <\/span>stdole.OLE_XPOS_PIXELS, ByVal y As <\/span>stdole.OLE_YPOS_PIXELS)\r\n Dim <\/span>objNode As <\/span>MSComctlLib.Node\r\n Dim <\/span>strTyp As String<\/span>\r\n Dim <\/span>lngID As Long<\/span>\r\n Dim <\/span>strKey As String<\/span>\r\n Dim <\/span>strKeyItem As String<\/span>\r\n Select Case Button\r\n Case <\/span>acRightButton\r\n Set<\/span> objNode = objTreeView.HitTest(x, y)\r\n If <\/span>Not<\/span> objNode Is Nothing Then<\/span>\r\n strKey = objNode.Key\r\n strKeyItem = Mid<\/span>(objNode.Key, InStrRev<\/span>(objNode.Key, \"|\") + 1)\r\n strTyp = Left<\/span>(strKeyItem, 1)\r\n lngID = Mid<\/span>(strKeyItem, 2)\r\n Select Case strTyp\r\n Case <\/span>\"r\"\r\n KontextmenueRoot strKey\r\n Case <\/span>\"b\"\r\n KontextmenueBaugruppe lngID, strKey\r\n Case <\/span>\"e\"\r\n KontextmenueEinzelteil lngID, strKey\r\n End Select<\/span>\r\n End If<\/span>\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>KontextmenueRoot(Optional<\/span> strKey As String<\/span>)\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n On Error Resume Next<\/span>\r\n CommandBars(\"TreeView_Root\").Delete\r\n On Error GoTo<\/span> 0\r\n Set<\/span> cbr = CommandBars.Add(\"TreeView_Root\", msoBarPopup, False, True<\/span>)\r\n With<\/span> cbr\r\n KontextmenueBaugruppen cbr, 0, \"r0\"\r\n KontextmenueEinzelteile cbr, 0, \"r0\"\r\n .ShowPopup\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nKontextmenueBaugruppen cbr, 0, \"r0\"\r\nKontextmenueEinzelteile cbr, 0, \"r0\"<\/pre>\n
Menüeinträge für die Baugruppen<\/h2>\n
Public Sub <\/span>KontextmenueBaugruppen(cbr As <\/span>CommandBar, Optional<\/span> lngBaugruppeParentID As Long<\/span>, Optional<\/span> ByVal strKey As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>cbp As <\/span>CommandBarPopup\r\n Dim <\/span>cbc As <\/span>CommandBarButton\r\n Dim <\/span>strIN As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> cbp = cbr.Controls.Add(msoControlPopup)\r\n cbp.Caption = \"Baugruppen\"\r\n Set<\/span> cbc = cbp.Controls.Add(msoControlButton)\r\n With<\/span> cbc\r\n .Caption = \"Neue Baugruppe\"\r\n .OnAction = \"=NeueBaugruppe(0)\"\r\n End With<\/span>\r\n If <\/span>lngBaugruppeParentID = 0 Then<\/span>\r\n strWHERE = \" WHERE IstProdukt = FALSE\"\r\n Else<\/span>\r\n strWHERE = AuszuschliessendeBaugruppen(lngBaugruppeParentID)\r\n If <\/span>Len<\/span>(strWHERE) > 0 Then<\/span>\r\n strWHERE = \" WHERE BaugruppeID NOT IN (\" & strIN & \")\"\r\n End If<\/span>\r\n End If<\/span>\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT BaugruppeID, Baugruppe FROM tblBaugruppen \" & strWHERE _\r\n & \" ORDER BY Baugruppe\", dbOpenDynaset)\r\n If <\/span>Not<\/span> Len<\/span>(strKey) = 0 Then<\/span>\r\n strKey = \", ''\" & strKey & \"''\"\r\n End If<\/span>\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Set<\/span> cbc = cbp.Controls.Add(msoControlButton)\r\n With<\/span> cbc\r\n .Caption = rst!Baugruppe\r\n .OnAction = \"=BaugruppeHinzufuegen(\" & rst!BaugruppeID & \", \" & lngBaugruppeParentID & strKey & \")\"\r\n End With<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nWHERE BaugruppeID NOT IN (1, 2, 3)<\/pre>\n
=BaugruppeHinzufuegen(123, 0)<\/pre>\n
=BaugruppeHinzufuegen(123, 0, ''r0|b1|b2'')<\/pre>\n
![\"Anzeigen](\"..\/fileadmin\/_temp_\/2017_02\/pic_1084_005.png\")
<\/p>\nMenüeinträge für die Einzelteile<\/h2>\n
Public Sub <\/span>KontextmenueEinzelteile(cbr As <\/span>CommandBar, Optional<\/span> lngBaugruppeParentID As Long<\/span>, Optional<\/span> ByVal _\r\n strKey As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>cbp As <\/span>CommandBarPopup\r\n Dim <\/span>cbc As <\/span>CommandBarButton\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> cbp = cbr.Controls.Add(msoControlPopup)\r\n cbp.Caption = \"Einzelteile\"\r\n Set<\/span> cbc = cbp.Controls.Add(msoControlButton)\r\n With<\/span> cbc\r\n .Caption = \"Neues Einzelteil\"\r\n .OnAction = \"=NeuesEinzelteil(0)\"\r\n End With<\/span>\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT EinzelteilID, Einzelteil FROM tblEinzelteile ORDER BY Einzelteil\", _\r\n dbOpenDynaset)\r\n If <\/span>Not<\/span> Len<\/span>(strKey) = 0 Then<\/span>\r\n strKey = \", ''\" & strKey & \"''\"\r\n End If<\/span>\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Set<\/span> cbc = cbp.Controls.Add(msoControlButton)\r\n With<\/span> cbc\r\n .Caption = rst!Einzelteil\r\n .OnAction = \"=EinzelteilHinzufuegen(\" & rst!EinzelteilID & \", \" & lngBaugruppeParentID & strKey & \")\"\r\n End With<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\n=EinzelteilHinzufuegen(65, 47, ''r0|b46|b47'')<\/pre>\n
![\"Kontextmenü](\"..\/fileadmin\/_temp_\/2017_02\/pic_1084_006.png\")
<\/p>\nKontextmenü für eine Baugruppe<\/h2>\n
Kontextmenü für Baugruppen<\/h2>\n
![\"Kontextmenü](\"..\/fileadmin\/_temp_\/2017_02\/pic_1084_007.png\")
<\/p>\nPrivate Sub <\/span>KontextmenueBaugruppe(lngID As Long<\/span>, _\r\n Optional<\/span> strKey As String<\/span>)\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n Dim <\/span>cbc As <\/span>CommandBarButton\r\n On Error Resume Next<\/span>\r\n CommandBars(\"TreeView_Baugruppe\").Delete\r\n On Error GoTo<\/span> 0\r\n Set<\/span> cbr = CommandBars.Add(\"TreeView_Baugruppe\", _\r\n msoBarPopup, False, True<\/span>)\r\n With<\/span> cbr\r\n Set<\/span> cbc = cbr.Controls.Add(msoControlButton)\r\n With<\/span> cbc\r\n .Caption = \"Baugruppe entfernen\"\r\n .OnAction = \"=BaugruppeEntfernen(\" _\r\n & lngID & \", ''\" & strKey & \"'')\"\r\n End With<\/span>\r\n KontextmenueBaugruppen cbr, lngID, strKey\r\n KontextmenueEinzelteile cbr, lngID, strKey\r\n .ShowPopup\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nAnlegen von Baugruppen<\/h2>\n
Public Function <\/span>BaugruppeHinzufuegen(lngBaugruppeID As Long<\/span>, Optional<\/span> lngBaugruppeParentID As Long<\/span>, _\r\n Optional<\/span> strKey As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strBaugruppe As String<\/span>\r\n Dim <\/span>intMenge As Integer<\/span>\r\n Dim <\/span>lngError As Long<\/span>\r\n Set<\/span> db = CurrentDb\r\n strBaugruppe = DLookup(\"Baugruppe\", \"tblBaugruppen\", \"BaugruppeID = \" & lngBaugruppeID)\r\n intMenge = Nz(DLookup(\"Menge\", \"tblBaugruppenzuordnungen\", \"BaugruppeVaterID = \" & lngBaugruppeParentID _\r\n & \" AND BaugruppeKindID = \" & lngBaugruppeID), 0)\r\n intMenge = intMenge + 1\r\n If <\/span>lngBaugruppeParentID = 0 Then<\/span>\r\n db.Execute \"UPDATE tblBaugruppen SET IstProdukt = True<\/span> WHERE BaugruppeID = \" & lngBaugruppeID, dbFailOnError\r\n objTreeView.Nodes.Add \"r0\", tvwChild, \"r0|b\" & lngBaugruppeID, strBaugruppe, \"gearwheels\"\r\n TreeViewFuellen_Rek db, lngBaugruppeID, \"r0|b\" & lngBaugruppeID\r\n Else<\/span>\r\n On Error Resume Next<\/span>\r\n db.Execute \"INSERT INTO tblBaugruppenzuordnungen(BaugruppeVaterID, BaugruppeKindID, Menge) VALUES(\" _\r\n & lngBaugruppeParentID & \", \" & lngBaugruppeID & \", \" & intMenge & \")\", dbFailOnError\r\n If <\/span>Err.Number = 3022 Then<\/span>\r\n db.Execute \"UPDATE tblBaugruppenzuordnungen SET Menge = \" & intMenge & \" WHERE BaugruppeVaterID = \" _\r\n & lngBaugruppeParentID & \" AND BaugruppeKindID = \" & lngBaugruppeID, dbFailOnError\r\n objTreeView.Nodes.Remove strKey & \"|b\" & lngBaugruppeID\r\n End If<\/span>\r\n TreeViewFuellen_Rek db, lngBaugruppeParentID, strKey\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nEinzelteil hinzufügen<\/h2>\n
Public Function <\/span>EinzelteilHinzufuegen(lngEinzelteilID As Long<\/span>, Optional<\/span> lngBaugruppeParentID As Long<\/span>, _\r\n Optional<\/span> strKey