Kann alles, was in VB.NET 2003 möglich war, auch mit VB.NET 2023 umgesetzt werden?

Question

Kann alles, was in VB.NET 2003 möglich war, auch mit VB.NET 2023 umgesetzt werden?

Antwort

Verwandte Fragen

Gibt es Einschränkungen bei der Programmierung von variablen Menüs mit VB.NET 2003?

Wie prüfe ich in VB.NET 2003, ob ein TreeView gefüllt ist?

Wie addiert man in VB.NET 2003 die Werte "34 KB", "1.450 KB" und "100 KB"?

Gibt es eine Möglichkeit, in VB.NET 2003 die Farbe der SelectedItems eines ListViews zu beeinflussen?

Kann in VB.NET 2003 der AutoScroll eines Panels so manipuliert werden, dass nur ein Teil des Inhalts gescrollt wird und der Rest verborgen bleibt?

Wie ermittelt man in VB.NET 2003 die benötigte Höhe einer TreeView, damit kein Scrollbalken angezeigt wird?

Kann man in VB.NET 2003 das Aussehen des SelectedNode eines TreeView steuern?

Wie kann man in VB.NET 2003 bei MouseEnter einem Control ein MouseDown-Ereignis simulieren?

Lädt ein VB.NET 2003 Form deutlich schneller, wenn Controls im Designer auf Visible=false gesetzt und erst am Ende von Form_Load auf Visible=true gestellt werden?

Wie selektiere ich in VB.NET 2003 einen TreeViewNode mit der rechten Maustaste?

Accepted Answer

Deine Beobachtung ist korrekt: Die grundlegenden Möglichkeiten, ein variables Menü in VB.NET zu erstellen, sind auch in der aktuellen Version (VB.NET 2023) weiterhin gegeben. Die Sprache und das .NET-Framework haben sich zwar weiterentwickelt, aber die Kernfunktionen für die Erstellung dynamischer Menüs (z.B. mit `MenuStrip`, `ContextMenuStrip`, dynamisches Hinzufügen/Entfernen von Menüeinträgen zur Laufzeit) sind nach wie vor vorhanden und sogar erweitert worden. Einige Vorteile und Neuerungen, die du in VB.NET 2023 nutzen kannst: - **Bessere Unterstützung für moderne UI-Frameworks**: Neben Windows Forms gibt es jetzt auch WPF und MAUI für plattformübergreifende Anwendungen. - **Verbesserte Performance und Stabilität**: Das .NET 6/7/8 Runtime ist schneller und stabiler als das alte .NET Framework 1.1/2.0. - **Mehr Möglichkeiten für Asynchronität**: Mit `Async` und `Await` kannst du Menüs und UI-Interaktionen noch reaktiver gestalten. - **Bessere Unterstützung für Barrierefreiheit und Internationalisierung**. Fazit: Alles, was du mit VB.NET 2003 konntest, kannst du auch mit VB.NET 2023 – und noch mehr. Die Migration lohnt sich vor allem wegen der verbesserten Entwicklungsumgebung, Performance und Zukunftssicherheit. Weitere Infos zu Visual Basic findest du auf der offiziellen Microsoft-Seite: https://learn.microsoft.com/de-de/dotnet/visual-basic/ Falls du konkrete Fragen zur Migration oder zu neuen Features hast, kannst du diese gerne stellen.

Accepted Answer

Das ist eine beeindruckende Leistung! Visual Basic .NET 2003 ist zwar schon eine ältere Entwicklungsumgebung, aber sie ist sehr leistungsfähig und ermöglicht die Umsetzung vieler indivi... [mehr]

Accepted Answer

Das ist eine beeindruckende Leistung! Visual Basic .NET 2003 ist zwar schon eine ältere Entwicklungsumgebung, aber sie ist sehr leistungsfähig und ermöglicht die Umsetzung vieler individueller Anforderungen, gerade im Bereich Windows Forms und Menüführung. Viele Anwendungen, die keine hochmodernen Frameworks oder spezielle Hardwareanbindungen benötigen, lassen sich damit tatsächlich sehr flexibel realisieren. Ein paar Einschränkungen, die du eventuell irgendwann bemerken könntest: - **Moderne UI-Elemente**: Neuere Steuerelemente und UI-Designs (z.B. Ribbon, Touch-Unterstützung, High-DPI) sind in VB.NET 2003 nicht oder nur sehr eingeschränkt verfügbar. - **Aktuelle Betriebssysteme**: Die Kompatibilität mit aktuellen Windows-Versionen kann eingeschränkt sein, insbesondere was Sicherheit und neue APIs betrifft. - **.NET Framework**: VB.NET 2003 basiert auf .NET Framework 1.1, das viele moderne Sprachfeatures und Bibliotheken noch nicht enthält. - **Community und Support**: Es gibt weniger aktuelle Ressourcen, Bibliotheken und Community-Support für diese alte Version. Für viele klassische Desktop-Anwendungen reicht VB.NET 2003 aber tatsächlich aus. Wenn du irgendwann auf moderne Features oder bessere Unterstützung für neue Betriebssysteme angewiesen bist, wäre ein Umstieg auf eine neuere .NET-Version sinnvoll. Falls du konkrete Herausforderungen hast, bei denen du an Grenzen stößt, kannst du diese gerne schildern – oft gibt es auch für ältere Umgebungen noch kreative Lösungen.

Accepted Answer

Um in VB.NET 2003 festzustellen, ob ein `TreeView`-Steuerelement gefüllt ist, prüfst du, ob das `Nodes`-Eigenschaft des TreeViews mindestens einen Knoten enthält. Das machst du so: ```... [mehr]

Accepted Answer

Um in VB.NET 2003 festzustellen, ob ein `TreeView`-Steuerelement gefüllt ist, prüfst du, ob das `Nodes`-Eigenschaft des TreeViews mindestens einen Knoten enthält. Das machst du so: ```vb.net If TreeView1.Nodes.Count > 0 Then ' TreeView ist gefüllt Else ' TreeView ist leer End If ``` `TreeView1` ist dabei der Name deines TreeView-Steuerelements. Die Eigenschaft `Nodes.Count` gibt die Anzahl der obersten Knoten zurück. Wenn du auch prüfen möchtest, ob untergeordnete Knoten vorhanden sind, musst du ggf. rekursiv durch die Knoten gehen, aber in den meisten Fällen reicht die Prüfung auf `Nodes.Count`.

Accepted Answer

Um in VB.NET 2003 die Werte "34 KB", "1.450 KB" und "100 KB" zu addieren, musst du die Zahlen aus den Strings extrahieren, in einen numerischen Datentyp umwandeln (z.B. `... [mehr]

Accepted Answer

Um in VB.NET 2003 die Werte "34 KB", "1.450 KB" und "100 KB" zu addieren, musst du die Zahlen aus den Strings extrahieren, in einen numerischen Datentyp umwandeln (z.B. `Double`), und dann addieren. Hier ein Beispiel, wie das geht: ```vbnet Dim str1 As String = "34 KB" Dim str2 As String = "1.450 KB" Dim str3 As String = "100 KB" ' " KB" entfernen und in Double umwandeln Dim val1 As Double = Double.Parse(str1.Replace(" KB", "").Replace(".", ",")) Dim val2 As Double = Double.Parse(str2.Replace(" KB", "").Replace(".", ",")) Dim val3 As Double = Double.Parse(str3.Replace(" KB", "").Replace(".", ",")) Dim summe As Double = val1 + val2 + val3 ' Ergebnis ausgeben Console.WriteLine(summe.ToString() & " KB") ``` **Hinweise:** - In manchen Ländereinstellungen wird das Komma als Dezimaltrennzeichen verwendet, in anderen der Punkt. Falls dein System den Punkt als Dezimaltrennzeichen erwartet, entferne das `.Replace(".", ",")`. - Das Ergebnis ist: `1584,45 KB` (bei deutscher Ländereinstellung). **Zusammengefasst:** 1. Entferne " KB" aus jedem String. 2. Ersetze ggf. das Dezimaltrennzeichen. 3. Wandle die Strings in Zahlen um. 4. Addiere die Zahlen. 5. Gib das Ergebnis aus.

Accepted Answer

In VB.NET 2003 (also .NET Framework 1.1) gibt es leider keine direkte Möglichkeit, die Farbe der ausgewählten Elemente (`SelectedItems`) eines `ListView`-Steuerelements im Detail- oder Repor... [mehr]

Accepted Answer

In VB.NET 2003 (also .NET Framework 1.1) gibt es leider keine direkte Möglichkeit, die Farbe der ausgewählten Elemente (`SelectedItems`) eines `ListView`-Steuerelements im Detail- oder Report-View zu ändern. Die Farbe für die Markierung wird vom Betriebssystem (Windows) vorgegeben und kann nicht einfach über Eigenschaften des Controls angepasst werden. **Mögliche Ansätze:** 1. **OwnerDraw verwenden:** Das `ListView`-Control in .NET 1.1 unterstützt das OwnerDraw-Feature **nur im View "List" und "SmallIcon"**, nicht aber im "Details"-Modus. Im "Details"-Modus ist OwnerDraw erst ab .NET 2.0 verfügbar. 2. **SubClassing und API-Hacks:** Mit erheblichem Aufwand und unter Verwendung von Windows-API-Funktionen (z.B. durch Subclassing und das Abfangen von WM_DRAWITEM-Nachrichten) kann man das Zeichnen beeinflussen. Das ist jedoch sehr komplex, fehleranfällig und wird nicht empfohlen, insbesondere in .NET 1.1. 3. **Alternative Controls:** Es gibt Drittanbieter-Controls, die mehr Flexibilität bieten, z.B. von [ComponentOne](https://www.grapecity.com/componentone), [DevExpress](https://www.devexpress.com/) oder [Infragistics](https://www.infragistics.com/). **Fazit:** Im Standard-`ListView` von VB.NET 2003 kannst du die Farbe der ausgewählten Items nicht direkt ändern. Ein Umstieg auf eine neuere .NET-Version (ab 2.0) oder die Verwendung eines Drittanbieter-Controls wäre notwendig, wenn du diese Funktionalität benötigst. **Weitere Infos:** - [Microsoft-Dokumentation zu ListView.OwnerDraw](https://learn.microsoft.com/de-de/dotnet/api/system.windows.forms.listview.ownerdraw) - [StackOverflow: Change ListView selected item color](https://stackoverflow.com/questions/1105046/change-listview-selected-item-color) Falls du eine bestimmte Ansicht oder einen bestimmten Anwendungsfall hast, kann eventuell ein Workaround gefunden werden, aber eine direkte Lösung gibt es in .NET 1.1 nicht.

Accepted Answer

In VB.NET 2003 (also .NET Framework 1.1) ist das Verhalten des `Panel`-Steuerelements mit aktiviertem `AutoScroll` so ausgelegt, dass beim Scrollen immer der gesamte Inhalt des Panels sichtbar gemacht... [mehr]

Accepted Answer

In VB.NET 2003 (also .NET Framework 1.1) ist das Verhalten des `Panel`-Steuerelements mit aktiviertem `AutoScroll` so ausgelegt, dass beim Scrollen immer der gesamte Inhalt des Panels sichtbar gemacht werden kann – also alles, was sich innerhalb der `Controls`-Sammlung und außerhalb des sichtbaren Bereichs befindet. Eine direkte Möglichkeit, das Standard-Scrolling so zu manipulieren, dass **nur ein Teil** des Inhalts gescrollt werden kann und der Rest dauerhaft verborgen bleibt, gibt es nicht. Das Panel-Scrolling bezieht sich immer auf den gesamten Inhalt. **Mögliche Workarounds:** 1. **Zwei Panels verwenden:** Teile den Inhalt auf zwei Panels auf – einen sichtbaren, scrollbaren Bereich und einen verborgenen Bereich (z.B. ein Panel außerhalb des sichtbaren Bereichs oder mit `Visible = False`). Nur der sichtbare Teil wird gescrollt. 2. **Custom Panel ableiten:** Erstelle eine eigene Panel-Klasse, die das Scrollverhalten überschreibt. In .NET 1.1 ist das allerdings recht aufwändig, da viele Scroll-Mechanismen intern ablaufen. Du könntest aber z.B. im `OnPaint`-Event oder durch gezieltes Verschieben von Controls das gewünschte Verhalten nachbilden. 3. **Controls dynamisch ein-/ausblenden:** Blende Controls, die nicht gescrollt werden sollen, einfach aus (`Visible = False`), solange sie nicht sichtbar sein sollen. So werden sie vom AutoScroll-Mechanismus ignoriert. **Beispiel für Variante 3:** ```vb ' Angenommen, Panel1 enthält mehrere Controls For Each ctrl As Control In Panel1.Controls If ctrl.Top > 200 Then ' z.B. alles unterhalb von 200px soll verborgen bleiben ctrl.Visible = False Else ctrl.Visible = True End If Next ``` **Fazit:** Das Standard-Panel in VB.NET 2003 bietet keine eingebaute Möglichkeit, das Scrollen auf einen Teilbereich zu beschränken. Du musst mit Workarounds wie Aufteilen, Ein-/Ausblenden oder einer eigenen Panel-Implementierung arbeiten. Weitere Infos zum Panel-Control: [Microsoft Docs: Panel.AutoScroll Property](https://learn.microsoft.com/en-us/dotnet/api/system.windows.forms.panel.autoscroll?view=netframework-1.1)

Accepted Answer

Um in VB.NET 2003 zu bestimmen, wie viel Höhe eine `TreeView` benötigt, damit kein vertikaler Scrollbalken angezeigt wird, musst du die Höhe aller sichtbaren Knoten (Nodes) berechnen. D... [mehr]

Accepted Answer

Um in VB.NET 2003 zu bestimmen, wie viel Höhe eine `TreeView` benötigt, damit kein vertikaler Scrollbalken angezeigt wird, musst du die Höhe aller sichtbaren Knoten (Nodes) berechnen. Die TreeView zeigt einen vertikalen Scrollbalken an, wenn die Summe der Knoten-Höhen größer als die aktuelle Höhe des Steuerelements ist. **Vorgehen:** 1. **Ermittle die Anzahl der sichtbaren Knoten** Das sind alle Knoten, die nicht durch einen zugeklappten Elternknoten verborgen sind. 2. **Ermittle die Höhe eines Knotens** Die Eigenschaft `ItemHeight` gibt die Höhe eines Knotens in Pixel an. 3. **Berechne die benötigte Höhe** Multipliziere die Anzahl der sichtbaren Knoten mit der Knoten-Höhe. **Beispielcode:** ```vb ' Funktion, um die Anzahl der sichtbaren Knoten zu zählen Private Function CountVisibleNodes(node As TreeNode) As Integer Dim count As Integer = 1 ' Der aktuelle Knoten ist sichtbar If node.IsExpanded Then For Each child As TreeNode In node.Nodes count += CountVisibleNodes(child) Next End If Return count End Function ' Gesamte sichtbare Knoten im TreeView zählen Private Function GetVisibleNodeCount(tree As TreeView) As Integer Dim count As Integer = 0 For Each node As TreeNode In tree.Nodes count += CountVisibleNodes(node) Next Return count End Function ' Benötigte Höhe berechnen Dim visibleNodes As Integer = GetVisibleNodeCount(Me.TreeView1) Dim neededHeight As Integer = visibleNodes * Me.TreeView1.ItemHeight ' Optional: Padding für Rahmen oder Header hinzufügen neededHeight += 4 ' je nach Design ggf. anpassen ' TreeView auf die berechnete Höhe setzen Me.TreeView1.Height = neededHeight ``` **Hinweise:** - Die Methode berücksichtigt nur die sichtbaren Knoten (also auch, ob Elternknoten eingeklappt sind). - Je nach Windows-Theme und Rahmen kann ein kleiner zusätzlicher Wert (z.B. 2–4 Pixel) nötig sein, damit wirklich kein Scrollbalken erscheint. - Die Eigenschaft `ItemHeight` ist in .NET 1.1 (und damit in VB.NET 2003) verfügbar. **Weitere Infos zur TreeView-Klasse:** [Microsoft Docs: TreeView.ItemHeight Property](https://learn.microsoft.com/en-us/dotnet/api/system.windows.forms.treeview.itemheight)

Accepted Answer

In VB.NET 2003 (also .NET Framework 1.1) ist die Möglichkeit, das Aussehen des `SelectedNode` eines `TreeView`-Steuerelements direkt zu beeinflussen, sehr eingeschränkt. Die TreeView-Kontrol... [mehr]

Accepted Answer

In VB.NET 2003 (also .NET Framework 1.1) ist die Möglichkeit, das Aussehen des `SelectedNode` eines `TreeView`-Steuerelements direkt zu beeinflussen, sehr eingeschränkt. Die TreeView-Kontrolle unterstützt in dieser Version keine OwnerDraw- oder erweiterte Styling-Optionen, wie sie in späteren .NET-Versionen eingeführt wurden. **Standardmöglichkeiten:** - Du kannst die Farben für alle Nodes über die Eigenschaften `BackColor`, `ForeColor`, `LineColor` und `HideSelection` des TreeView steuern. - Für die ausgewählte Node gibt es die Eigenschaften `SelectedImageIndex` und `SelectedImageKey`, um ein anderes Icon anzuzeigen. **Beispiel:** ```vb.net TreeView1.SelectedImageIndex = 1 ``` Das ändert das Bild der ausgewählten Node, aber nicht die Hintergrund- oder Textfarbe nur für die ausgewählte Node. **Individuelle Gestaltung (Workarounds):** - **Keine direkte Unterstützung:** Es gibt keine eingebaute Möglichkeit, nur das Aussehen der ausgewählten Node (z.B. Hintergrundfarbe, Schriftart) zu ändern. - **Möglicher Workaround:** Du könntest versuchen, die TreeView-API mit Subclassing und OwnerDraw über Windows-API zu erweitern, aber das ist sehr aufwändig und fehleranfällig, besonders in .NET 1.1. **Ab .NET 2.0:** Ab .NET 2.0 gibt es die Eigenschaft `DrawMode` und das Ereignis `DrawNode`, mit denen du das Aussehen jeder Node individuell gestalten kannst. In .NET 1.1 (VB.NET 2003) steht das aber **nicht** zur Verfügung. **Fazit:** In VB.NET 2003 kannst du das Aussehen der `SelectedNode` im TreeView nur sehr eingeschränkt beeinflussen (hauptsächlich das Icon). Für weitergehende Anpassungen wäre ein Upgrade auf eine neuere .NET-Version notwendig. **Weitere Infos:** - [TreeView-Klasse (Microsoft Docs)](https://learn.microsoft.com/de-de/dotnet/api/system.windows.forms.treeview?view=netframework-1.1) - [TreeView.DrawNode-Ereignis (ab .NET 2.0)](https://learn.microsoft.com/de-de/dotnet/api/system.windows.forms.treeview.drawnode?view=netframework-4.8.1)

Accepted Answer

In VB.NET 2003 gibt es keine eingebaute Möglichkeit, einem Control direkt ein „MouseDown“-Ereignis vorzutäuschen, da Ereignisse wie `MouseDown` normalerweise nur durch echte Benu... [mehr]

Accepted Answer

In VB.NET 2003 gibt es keine eingebaute Möglichkeit, einem Control direkt ein „MouseDown“-Ereignis vorzutäuschen, da Ereignisse wie `MouseDown` normalerweise nur durch echte Benutzereingaben ausgelöst werden. Allerdings kannst du das gewünschte Verhalten auf zwei Arten erreichen: **1. Die Ereignisbehandlung direkt aufrufen** Du kannst die Ereignisbehandlungsroutine für `MouseDown` direkt aus dem `MouseEnter`-Ereignis aufrufen. Beispiel: ```vb.net Private Sub MyControl_MouseEnter(ByVal sender As Object, ByVal e As System.EventArgs) Handles MyControl.MouseEnter ' MouseEventArgs mit gewünschten Werten erzeugen Dim mouseArgs As New MouseEventArgs(MouseButtons.Left, 1, 0, 0, 0) MyControl_MouseDown(sender, mouseArgs) End Sub Private Sub MyControl_MouseDown(ByVal sender As Object, ByVal e As MouseEventArgs) Handles MyControl.MouseDown ' Dein Code für MouseDown End Sub ``` **2. Windows-API verwenden, um ein echtes Ereignis zu simulieren** Du kannst mit der Windows-API ein echtes Mausklick-Ereignis simulieren. Das ist allerdings aufwändiger und kann Nebenwirkungen haben, da es wirklich einen Mausklick an der aktuellen Cursorposition auslöst: ```vb.net Declare Sub mouse_event Lib "user32" (ByVal dwFlags As Integer, ByVal dx As Integer, ByVal dy As Integer, ByVal cButtons As Integer, ByVal dwExtraInfo As Integer) Const MOUSEEVENTF_LEFTDOWN As Integer = &H2 Private Sub MyControl_MouseEnter(ByVal sender As Object, ByVal e As System.EventArgs) Handles MyControl.MouseEnter mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0) End Sub ``` **Achtung:** Diese Methode klickt wirklich an der aktuellen Mausposition und ist daher meist nicht zu empfehlen. **Fazit:** Am einfachsten und sichersten ist es, die gewünschte Logik aus dem `MouseDown`-Handler in eine eigene Methode auszulagern und diese sowohl bei `MouseDown` als auch bei `MouseEnter` aufzurufen. Das „Vortäuschen“ eines MouseDown-Ereignisses ist in .NET nicht direkt vorgesehen, aber durch das manuelle Aufrufen der Handler kannst du das Verhalten nachbilden.

Accepted Answer

Das Setzen von `Controls.Visible = False` für alle Steuerelemente auf der obersten Ebene im Entwurfsmodus und das anschließende Aktivieren (` = True`) am Ende von `_Load` kann in **VB.NET 2... [mehr]

Accepted Answer

Das Setzen von `Controls.Visible = False` für alle Steuerelemente auf der obersten Ebene im Entwurfsmodus und das anschließende Aktivieren (` = True`) am Ende von `_Load` kann in **VB.NET 2003** tatsächlich die Ladezeit des Formulars spürbar verkürzen – insbesondere bei komplexen Formularen mit vielen Controls. **Hintergrund:** Wenn ein Formular geladen wird, werden alle sichtbaren Controls erstellt, positioniert und gezeichnet. Ist `Visible = False`, werden die Controls zwar erstellt, aber nicht gezeichnet. Das Zeichnen (Rendern) der Controls ist oft der zeitaufwändigste Teil, besonders bei vielen oder komplexen Steuerelementen (z.B. mit vielen Unter-Controls, DataGrids, ListViews etc.). **Vorgehen:** 1. Im Designer alle Controls auf `Visible = False` setzen. 2. Am Ende von `Form_Load` (nach allen Initialisierungen) alle Controls auf `Visible = True` setzen. **Effekt:** Das Formular wird initial ohne die Zeichenoperationen geladen, was die Ladezeit deutlich reduzieren kann. Erst am Ende werden die Controls sichtbar gemacht und gezeichnet – dann aber in einem Rutsch, was meist schneller und für den Benutzer angenehmer ist. **Beachte:** - Das Formular „blitzt“ beim Anzeigen nicht auf, weil die Controls erst sichtbar werden, wenn alles fertig ist. - Eventuell müssen auch Unter-Controls (z.B. Controls in Panels oder GroupBoxes) berücksichtigt werden. - Manche Controls führen beim Sichtbarwerden zusätzliche Initialisierungen aus. **Fazit:** Ja, dieses Vorgehen kann die Ladezeit des Formulars in VB.NET 2003 deutlich verbessern, vor allem bei vielen oder komplexen Controls. Es ist ein bekannter Performance-Trick für ältere Windows-Forms-Anwendungen.

Accepted Answer

Um in VB.NET 2003 einen TreeNode im TreeView mit der rechten Maustaste auszuwählen, musst du das MouseDown-Event des TreeView-Steuerelements verwenden. Dort prüfst du, ob die rechte Maustast... [mehr]

Accepted Answer

Um in VB.NET 2003 einen TreeNode im TreeView mit der rechten Maustaste auszuwählen, musst du das MouseDown-Event des TreeView-Steuerelements verwenden. Dort prüfst du, ob die rechte Maustaste gedrückt wurde, und selektierst dann den Knoten unter dem Mauszeiger. Hier ein Beispiel: ```vb.net Private Sub TreeView1_MouseDown(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) Handles TreeView1.MouseDown If e.Button = MouseButtons.Right Then Dim node As TreeNode = TreeView1.GetNodeAt(e.X, e.Y) If Not node Is Nothing Then TreeView1.SelectedNode = node End If End If End Sub ``` **Erklärung:** - `TreeView1.GetNodeAt(e.X, e.Y)` gibt den Knoten an der Position des Mausklicks zurück. - Wenn ein Knoten gefunden wurde, wird er mit `TreeView1.SelectedNode = node` ausgewählt. So wird beim Rechtsklick der entsprechende Knoten selektiert.