<\/p>\n
Wenn man das TreeView-Steuerelement professioneller nutzt, programmiert man unter anderem Ereignisse, die durch das Anklicken von Elementen ausgelöst werden. Damit kann man Ereignisprozeduren auslösen, die beispielsweise Daten zum angeklickten Element in einem Unterformular anzeigen oder man blendet ein Kontextmenü zum jeweils angeklickten Element mit weiteren Optionen ein. Dazu ist es notwendig, zu identifizieren, auf welches Element der Benutzer geklickt hat. Die notwendigen Informationen liefern die Parameter der Prozeduren, das Ermitteln des angeklickten Elements erledigt man mit einer bestimmten Funktion. Seit Kurzem erreichen uns allerdings Meldungen von Lesern, bei denen dies nicht mehr zuverlässig funktioniert: Es werden keine Kontextmenüs mehr angezeigt und auch das Anklicken gelingt nicht mehr wie gewünscht. Interessanterweise tritt das Problem nur bei Verwendung von Office 365 auf. Wir schauen uns in diesem Beitrag an, woher das Problem rührt und wie Sie es lösen können.<\/b><\/p>\nVorbereitung<\/h2>\n
Für die folgenden Experimente legen wir in einem neuen, leeren Formular einfach ein TreeView<\/b>-Steuerelement namens ctlTreeView <\/b>an.<\/p>\n
Dazu wählen wir im Ribbon den Befehl Formularentwurf|Steuerelemente|ActiveX<\/b>-Steuerelemente aus (siehe Bild 1).<\/p>\n
![\"ActiveX-Steuerelement](\"..\/fileadmin\/_temp_\/2024_02\/pic_1492_001.png\")
<\/p>\n
Bild 1: ActiveX-Steuerelement hinzufügen<\/span><\/b><\/p>\n Dies öffnet den Dialog ActiveX-Steuerelement einfügen<\/b>, wo wir den Eintrag Microsoft TreeView Control, version 6.0 <\/b>auswählen (siehe Bild 2).<\/p>\n Bild 2: TreeView-Steuerelement selektieren<\/span><\/b><\/p>\n Danach sehen wir das neue TreeView<\/b>-Steuerelement im Formular und passen seine Größe entsprechend an (siehe Bild 3). Damit können wir zu den Feinheiten der Referenzierung und Programmierung übergehen.<\/p>\n Bild 3: TreeView-Steuerelement nach dem Einbau<\/span><\/b><\/p>\n Nach dem Einfügen des TreeView<\/b>-Steuerelements passen wir noch seinen Namen auf ctlTreeView <\/b>an.<\/p>\n Es gibt zwei Wege, wie man ein TreeView<\/b>-Steuerelement per VBA referenzieren kann. Der erste ist, dieses wie bei den eingebauten Steuerelementen einfach über das Schlüsselwort Me <\/b>in Verbindung mit dem Steuerelementnamen zu referenzieren, hier also ctlTreeView<\/b>. Wenn wir dies im VBA-Editor erledigen und einen weiteren Punkt anfügen, um per IntelliSense auf die Methoden und Eigenschaften des TreeView<\/b>-Steuerelements zuzugreifen, erhalten wir das Ergebnis aus Bild 4. Hier erkennen wir, dass wir nur die allgemeinen Eigenschaften von Steuerelementen anwählen können, nicht jedoch die speziellen Elemente des TreeView-Steuerelements.<\/p>\n Bild 4: Referenzieren des Steuerelements<\/span><\/b><\/p>\n Dazu müssen wir eine Objektvariable anlegen, die wir wie folgt deklarieren:<\/p>\n Diese Variable füllen wir wie folgt:<\/p>\n Wir können das TreeView<\/b>-Steuerelement nicht direkt über Me!ctlTreeView <\/b>referenzieren, weil wir damit nur die Hülle des Steuerelements referenzieren würden. Diese hat den Datentyp CustomControl<\/b>. Dies können wir belegen, indem wir zuerst den Typ von ctlTreeView <\/b>ausgeben:<\/p>\n Erst über das Object<\/b>-Element erhalten wir den gesuchten Typ:<\/p>\n Mit der Referenzierung über die Objektvariable objTreeView<\/b> erhalten wir schließlich auch die TreeView<\/b>-spezifischen Eigenschaften und Methoden per IntelliSense (siehe Bild 5).<\/p>\n Bild 5: Referenzieren des TreeView-Steuerelements per Objektvariable<\/span><\/b><\/p>\n Sie sehen: Ein Grund, das TreeView<\/b>-Steuerelement nicht über das als Container verwendete Steuerelement CustomControl<\/b>, sondern über das darin enthaltene TreeView<\/b>-Steuerelement zu referenzieren, erlaubt den Zugriff auf die Eigenschaften und Methoden per IntelliSense.<\/p>\n Wir wollen exemplarisch das Ereignis MouseDown <\/b>verwenden, weil es das Problem verdeutlicht. Wir können das Ereignis auf zwei Arten in Form einer Ereignisprozedur implementieren. Bei der ersten verwenden wir die Ereignisse des Steuerelements ctlTreeView<\/b>. Um das Ereignis anzulegen, wählen wir im Codefenster des Klassenmoduls des Formulars oben links den Eintrag für das TreeView<\/b>-Steuerelement ctlTreeView <\/b>aus und aus der nun aufgeklappten Liste auf der rechten Seite den Eintrag MouseDown<\/b>. Die automatisch hinzugefügte Ereignisprozedur ctlTreeView_Updated <\/b>können wir wieder löschen (siehe Bild 6).<\/p>\n Bild 6: Anlegen des MouseDown-Ereignisses für ctlTreeView<\/span><\/b><\/p>\n Die neue Ereignisprozedur hat die folgende Signatur:<\/p>\n Button <\/b>liefert einen Hinweis, ob die linke oder rechte Maustaste gedrückt wurde, Shift <\/b>gibt an, ob eine der Tasten Alt<\/b>, Strg <\/b>oder Umschalt <\/b>beim Betätigen der Maustaste gehalten wurde.<\/p>\n Mit x <\/b>und y <\/b>erhalten wir die Koordinaten, an denen der Mausklick erfolgte. Wie es unter Access üblich ist, werden diese Koordinaten im Format Twips <\/b>geliefert.<\/p>\n Wir können das Ereignis allerdings auch für die oben vorgestellte Objektvariable objTreeView <\/b>anlegen. Dazu müssen wir die Deklaration dieser Variablen nur aus der Prozedur Form_Load <\/b>herausholen und in den allgemeinen Teil des Moduls verschieben (siehe Bild 7). Außerdem fügen wir das Schlüsselwort WithEvents <\/b>hinzu, damit der VBA-Editor weiß, dass wir in diesem Klassenmodul Ereignisse für dieses Element implementieren können wollen.<\/p>\n Bild 7: Änderung der Deklaration von objTreeView<\/span><\/b><\/p>\n Damit können wir nun wie zuvor für ctlTreeView<\/b> auch für objTreeView <\/b>die Ereignisse über die Auswahlfelder oben im Codefenster hinzufügen (siehe Bild 8).<\/p>\n Bild 8: Anlegen des MouseDown-Ereignisses für die Objektvariable objTreeView<\/span><\/b><\/p>\n Das erledigen wir wie zuvor und sehen uns dann die Signatur des MouseDown<\/b>-Ereignisses für die Objektvariable objTreeView <\/b>an:<\/p>\n Die Signatur ist bezüglich der Anzahl und der Benennung der Elemente identisch, jedoch unterscheidet sich der Datentyp bei den Parametern x <\/b>und y<\/b>. Während wir es zuvor mit Long<\/b>-Werten zu tun hatten, finden wir nun den Datentyp stdole.OLOE_XPOS_PIXELS <\/b>vor. Lassen wir uns innerhalb dieses Ereignisse jedoch einmal den Datentyp mit Typename<\/b> ausgeben, erhalten wir hier ebenfalls Long <\/b>als Datentyp. Allerdings sehen wir, dass der Datentyp die Zeichenkette PIXELS <\/b>enthält, war darauf hindeutet, dass hier nicht Twips wie bei der gleichnamigen Ereignisprozedur für das Steuerelement geliefert werden, sondern Pixel.<\/p>\n Die Frage ist nun: Ist das auch der Fall?<\/p>\n Dazu fügen wir dem Formular vier Textfelder namens txtCtlX<\/b>, txtCtlY<\/b>, txtObjX <\/b>und txtObjY <\/b>hinzu (siehe Bild 9). Die Textfelder füllen wir beim Auslösen der Ereignisprozeduren beim Ereignis MouseDown <\/b>mit den Werten für die Parameter x <\/b>und y<\/b>:<\/p>\n Bild 9: Steuerelemente zum Anzeigen der x- und y-Werte für die beiden Ereignisprozeduren<\/span><\/b><\/p>\n Und hier wird es spannend: Unter Access in der Version von Office 365 erhalten wir für beide Ereignisprozeduren beim einem Klick in die rechte, untere Ecke unterschiedliche Werte für die Parameter x <\/b>und y<\/b> (siehe Bild 10).<\/p>\n Bild 10: Ergebnis beim Anklicken unter Office 365<\/span><\/b><\/p>\n Das Ereignis für ctlTreeView <\/b>liefert die Werte in der Einheit Twips<\/b>, das Ereignis für objTreeView <\/b>in der Einheit Pixel<\/b>.<\/p>\n Richtig interessant wird es, wenn wir das gleiche Formular in Access 2010 öffnen (Gleiches gilt für Access 2013 und 2016). Hier erhalten wir für das Ereignis MouseOver<\/b> des Steuerelements ctlTreeView <\/b>und der Objektvariablen objTreeView <\/b>beim Anklicken des Steuerelements in der rechten, unteren Ecke alle Werte in der Einheit Twips<\/b> (siehe Bild 11).<\/p>\n Bild 11: Ergebnis beim Anklicken unter Access 2010<\/span><\/b><\/p>\n Aber warum sollte das ein Problem sein? Das schauen wir uns im Anschluss an.<\/p>\n Wir füllen nun das TreeView<\/b>-Steuerelement beim Laden des Formulars mit drei einfachen Node<\/b>-Elementen:<\/p>\n Die Implementierung von Ereignisprozeduren mit den Parametern x <\/b>und y <\/b>basiert meist darauf, dass man irgendeine Aktion auf Basis des Elements durchführen möchte, über dem sich gerade der Mauszeiger befindet. Das betrifft die folgenden Ereignisse:<\/p>\n Hier ist es essenziell, dass wir über die Koordinaten x <\/b>und y <\/b>das richtige Element referenzieren. Wie aber können wir die Koordinaten dazu nutzen?<\/p>\n Dazu verwenden wir die Funktion HitTest <\/b>des TreeView<\/b>-Steuerelements, die wiederum die Parameter x <\/b>und y <\/b>erwartet und einen Verweis auf das Node<\/b>-Element zurückgibt, das sich unter diesen Koordinaten befindet.<\/p>\n Um auszugeben, welchen Node der Benutzer anklickt, fügen wir dem Formular zwei weitere Textfelder namens txtCtlNode <\/b>und txtObjNode <\/b>hinzu (siehe Bild 12).<\/p>\n Bild 12: Steuerelemente zum Anzeigen der angeklickten Node-Elemente<\/span><\/b><\/p>\n Die Prozedur ctlTreeView_MouseDown <\/b>ergänzen wir wie folgt:<\/p>\n Wir versuchen, mit ctlTreeView.HitTest <\/b>das angeklickte Element zu referenzieren und schreiben seinen Text in das Textfeld txtCtlNode<\/b>.<\/p>\n Die Prozedur für das Ereignis objTreeView_MouseDown <\/b>gestalten wir analog: <\/p>\n Klicken wir nun unter Access in der Office 365-Version das erste Node<\/b>-Element an, erhalten wir das erwartete Ergebnis. Ein Klick auf das Node<\/b>-Element mit dem Text Text2 <\/b>liefert allerdings bereits eine Abweichung (siehe Bild 13). ctlTreeView <\/b>liefert korrekterweise den Verweis auf Text2 <\/b>zurück, objTreeView <\/b>liefert Text1<\/b>. Wie kann das sein?<\/p>\n Bild 13: Auswertung des angeklickten Node-Elements mit HitTest<\/span><\/b><\/p>\n Untersuchen wir die gleiche Datenbank unter Access 2010, erhalten wir das Ergebnis aus Bild 14 – hier ist also alles korrekt.<\/p>\n Bild 14: Das gleiche Experiment unter Access 2010<\/span><\/b><\/p>\n Fassen wir die Beobachtungen zusammen, finden wir zunächst einmal:<\/p>\n All diese Beobachtungen gelten für Access in der Version aus Office 365. In älteren Versionen werden die Parameter x <\/b>und y <\/b>jeweils in der Einheit Twips geliefert und verarbeitet.<\/p>\n Dass HitTest <\/b>der Klasse MSCOMCTLLib.TreeView <\/b>noch mit Twips arbeitet, kann man testen, indem man der Prozedur ctlTreeView_MouseDown <\/b>die folgende Zeile hinzufügt:<\/p>\n Achtung: Damit diese Anweisung funktioniert, muss man ein Node<\/b>-Element anklicken, da sonst ein Fehler ausgelöst wird.<\/p>\n Das heißt also, dass wir für x <\/b>und y <\/b>beim MSCOMCTLLib.TreeView<\/b>-Element viel kleinere Werte erhalten als die HitTest<\/b>-Funktion erwartet. So erhalten wir immer noch einen Verweis auf das Element mit dem Text Test1<\/b>, auch wenn wir auf den Bereich rechts davon oder darunter klicken.<\/p>\n Da wir nicht wissen, ob und wann Microsoft dieses Problem behebt, benötigen wir einen Workaround, der auch noch funktioniert, wenn der Fehler behoben ist.<\/p>\n Die erste Möglichkeit ist, einfach nur direkt das Steuerelement zu referenzieren, so wie es im Formularentwurf benannt wurde – also wie in der Prozedur ctlTreeView_MouseDown<\/b>. Hier gibt es folgende potenzielle Nachteile:<\/p>\n Der zuerst genannte Nachteil ist vernachlässigbar, denn wir können ja während der Programmierung mit einer Objektvariablen mit dem Datentyp MSCOMCTLLib.TreeView <\/b>arbeiten und diesen später durch die Referenz auf das Steuerelement mit Me!ctlTreeView.Object <\/b>ersetzen.<\/p>\n Der zweite Nachteil ist entscheidend, wenn wir die Funktionalität des TreeView<\/b>-Steuerelements in einem Klassenmodul kapseln wollen, dem wir einen Verweis auf das TreeView<\/b>-Steuerelement übergeben. Wir haben das beispielsweise im Beitrag TreeView-Konfigurator <\/b>(www.access-im-unternehmen.de\/667<\/b>) so gemacht.<\/p>\n Die zweite Möglichkeit besteht darin, die von MouseDown <\/b>als Pixel gelieferten Werte für x <\/b>und y <\/b>in Twips umzurechnen, bevor wie sie an die HitTest<\/b>-Funktion weitergeben.<\/p>\n Das erledigen wir, indem wir zunächst die folgenden drei API-Funktionen deklarieren:<\/p>\n Zusätzlich benötigen wir noch einen Type, der die X- und Y-Koordinaten aufnimmt und wie folgt deklariert wird:<\/p>\n Dann legen wir eine Prozedur zum Konvertieren der Werte an (siehe Listing 1).<\/p>\n Listing 1: Anpassung der Prozedur für das Vergrößern und Verkleinern<\/span><\/b><\/p>\n Diese rufen wir in der Prozedur objTreeView_MouseDown <\/b>direkt in der ersten Anweisung nach der Deklaration von objNode <\/b>auf:<\/p>\n Nun werden x <\/b>und y <\/b>mit einer Zahl etwa mit dem Wert 15 <\/b>multipliziert und HitTest(x, y) <\/b>kann das richtige Node<\/b>-Element ermitteln.<\/p>\n Damit erhalten wir allerdings ein weiteres Problem: Wenn die das Formular nun unter Access 2010, 2013, 2016 et cetera ausprobieren (2019 und 2021 nicht getestet), wird der als Twips gelieferte Wert für x <\/b>und y <\/b>ebenfalls mit dem ermittelten Faktor multipliziert, was dazu führt, dass nun hier die Ermittlung des angeklickten Node<\/b>-Elements nicht mehr funktioniert.<\/p>\n Wir müssen also prüfen, in welcher Einheit Access die Werte für die Parameter x <\/b>und y <\/b>bei Ereignisprozeduren wie MouseDown <\/b>et cetera liefert. Dazu gibt es eigentlich nur eine Möglichkeit: Wir ermitteln die tatsächliche Mausposition innerhalb des Steuerelements mit anderen Methoden wie beispielsweise API-Funktionen und prüfen, ob die Werte gleich sind.<\/p>\n Dazu müssen wir wissen, dass die API-Funktionen grundsätzlich alle Angaben bezüglich Position und Abmessungen in Pixeln liefern. Wir können also die folgenden beiden API-Funktionen verwenden, um die Position des Mauszeigers im aktuellen Kontext zu ermitteln:<\/p>\n Die API-Funktionen verwenden wir in der überarbeiteten Prozedur für das MouseDown<\/b>-Ereignis des MSCOMCTLLib.TreeView<\/b>-Elements aus Listing 2.<\/p>\n Listing 2: Diese Version prüft, ob der mit X gelieferte Wert dem Wert entspricht, den wir per API ermittelt haben<\/span><\/b><\/p>\n Diese deklariert mit der Variablen pt <\/b>ein Type<\/b>-Element mit dem Datentyp POINTAPI<\/b>. Dieses füllen wir gleich im Anschluss mit der API-Funktion GetCursorPos <\/b>mit den aktuellen Koordinaten des Mauszeigers.<\/p>\n Danach liefern pt.X <\/b>und pt.Y <\/b>die Position des Mauszeigers bezogen auf die linke, obere Ecke des Bildschirms. Wir können diese Werte mit der folgenden Anweisung testweise ausgeben:<\/p>\n Danach rufen wir die API-Funktion ScreenToClient <\/b>auf. Dieser übergeben wir ein Handle auf das MSCOMCTLLib.TreeView<\/b>-Element und die Variable pt<\/b>. Die ScreenToClient<\/b>-Funktion konvertiert die Bildschirmkoordinaten des mit pt<\/b> angegebenen Punkts auf dem Bildschirm in Clientbereichskoordinaten, also in die Koordinaten, die der Punkt in dem mit objTreeView.hWnd <\/b>angegebenen Element aufweist. Die transformierten Werte geben wir beispielsweise mit der folgenden Anweisung aus:<\/p>\n Nun tragen wir die mit den Parametern X <\/b>und Y <\/b>gelieferten Koordinaten in die Textfelder txtObjX <\/b>und txtObjY <\/b>ein. Dem Formular haben wir noch zwei weitere Textfelder namens txtAPIX <\/b>und txtAPIY <\/b>hinzugefügt, denen wir die durch die API-Funktionen ermittelten Koordinaten des Mauszeigers übergeben. Dies sieht dann beispielsweise wie in Bild 15 aus.<\/p>\n Bild 15: Ermitteln der Koordinaten, nun auch per API<\/span><\/b><\/p>\n Nun folgt der entscheidende Schritt: Wir prüfen anhand der X<\/b>-Koordinate, ob diese durch den Parameter X <\/b>in der Einheit Pixel geliefert wurde. Dazu vergleichen wir X <\/b>mit dem als Pixel vorliegenden Wert aus pt.X<\/b>. Sind beide gleich, wurde auch X <\/b>als Pixel geliefert (und folglich auch Y<\/b>). In diesem Fall konvertieren wir die Werte aus ![\"TreeView-Steuerelement](\"..\/fileadmin\/_temp_\/2024_02\/pic_1492_002.png\")
<\/p>\n![\"TreeView-Steuerelement](\"..\/fileadmin\/_temp_\/2024_02\/pic_1492_003.png\")
<\/p>\nTreeView als Steuerelement oder als Objektvariable referenzieren<\/h2>\n
![\"Referenzieren](\"..\/fileadmin\/_temp_\/2024_02\/pic_1492_004.png\")
<\/p>\nDim <\/span>objTreeView As <\/span>MSCOMCTLLib.TreeView<\/pre>\nSet<\/span> objTreeView = Me!ctlTreeView.Object<\/pre>\nDebug.Print<\/span> TypeName(Me!ctlTreeView)\r\nCustomControl<\/pre>\nDebug.Print<\/span> TypeName(Me!ctlTreeView.Object)\r\nTreeView<\/pre>\n![\"Referenzieren](\"..\/fileadmin\/_temp_\/2024_02\/pic_1492_005.png\")
<\/p>\nVerwendung von Ereignissen<\/h2>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2024_02\/pic_1492_006.png\")
<\/p>\nPrivate Sub <\/span>ctlTreeView_MouseDown( _\r\n ByVal Button As Integer<\/span>, _\r\n ByVal Shift As Integer<\/span>, _\r\n ByVal x As Long<\/span>, _\r\n ByVal y As Long<\/span>)<\/pre>\nEreignis für die Objektvariable anlegen<\/h2>\n
![\"Änderung](\"..\/fileadmin\/_temp_\/2024_02\/pic_1492_007.png\")
<\/p>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2024_02\/pic_1492_008.png\")
<\/p>\nPrivate Sub <\/span>objTreeView_MouseDown( _\r\n ByVal Button As Integer<\/span>, _\r\n ByVal Shift As Integer<\/span>, _\r\n ByVal x As <\/span>stdole.OLE_XPOS_PIXELS, _\r\n ByVal y As <\/span>stdole.OLE_YPOS_PIXELS)<\/pre>\n![\"Steuerelemente](\"..\/fileadmin\/_temp_\/2024_02\/pic_1492_009.png\")
<\/p>\nPrivate Sub <\/span>ctlTreeView_MouseDown(_\r\n ByVal Button As Integer<\/span>, _\r\n ByVal Shift As Integer<\/span>, _\r\n ByVal x As Long<\/span>, ByVal y As Long<\/span>)\r\n Me!txtCtlX = x\r\n Me!txtCtlY = y\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>objTreeView_MouseDown( _\r\n ByVal Button As Integer<\/span>, ByVal Shift As Integer<\/span>, _\r\n ByVal x As <\/span>stdole.OLE_XPOS_PIXELS, _\r\n ByVal y As <\/span>stdole.OLE_YPOS_PIXELS)\r\n Me!txtObjX = x\r\n Me!txtObjY = y\r\nEnd Sub<\/span><\/pre>\n![\"Ergebnis](\"..\/fileadmin\/_temp_\/2024_02\/pic_1492_010.png\")
<\/p>\n![\"Ergebnis](\"..\/fileadmin\/_temp_\/2024_02\/pic_1492_011.png\")
<\/p>\nProbleme durch unterschiedliche Einheiten<\/h2>\n
Private Sub <\/span>Form_Load()\r\n Set<\/span> objTreeView = Me!ctlTreeView.Object\r\n objTreeView.Nodes.Add , , \"t1\", \"Test1\"\r\n objTreeView.Nodes.Add , , \"t2\", \"Test2\"\r\n objTreeView.Nodes.Add , , \"t3\", \"Test3\"\r\nEnd Sub<\/span><\/pre>\n\n
![\"Steuerelemente](\"..\/fileadmin\/_temp_\/2024_02\/pic_1492_012.png\")
<\/p>\nPrivate Sub <\/span>ctlTreeView_MouseDown(..., _\r\n ByVal x As Long<\/span>, ByVal y As Long<\/span>)\r\n Dim <\/span>objNode As <\/span>MSComctlLib.Node\r\n Me!txtCtlX = x\r\n Me!txtCtlY = y\r\n Set<\/span> objNode = ctlTreeView.HitTest(x, y)\r\n If <\/span>Not<\/span> objNode Is Nothing Then<\/span>\r\n Me!txtCtlNode = objNode.Text\r\n Else<\/span>\r\n Me!txtCtlNode = Null\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>objTreeView_MouseDown(..., _\r\n ByVal x As <\/span>stdole.OLE_XPOS_PIXELS, _\r\n ByVal y As <\/span>stdole.OLE_YPOS_PIXELS)\r\n Dim <\/span>objNode As <\/span>MSComctlLib.Node\r\n Me!txtObjX = x\r\n Me!txtObjY = y\r\n Set<\/span> objNode = objTreeView.HitTest(x, y)\r\n If <\/span>Not<\/span> objNode Is Nothing Then<\/span>\r\n Me!txtObjNode = objNode.Text\r\n Else<\/span>\r\n Me!txtObjNode = Null\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Auswertung](\"..\/fileadmin\/_temp_\/2024_02\/pic_1492_013.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2024_02\/pic_1492_014.png\")
<\/p>\nInterpretation<\/h2>\n
\n
MsgBox<\/span> objTreeView.HitTest(x, y).Text<\/pre>\nWorkarounds für den Fehler<\/h2>\n
\n
Private <\/span>Declare PtrSafe Function GetDC Lib \"user32\" ( _\r\n ByVal hwnd As Long<\/span>) As Long<\/span>\r\nPrivate <\/span>Declare PtrSafe Function GetDeviceCaps Lib \"gdi32\" _\r\n (ByVal hDC As Long<\/span>, ByVal nIndex As Long<\/span>) As Long<\/span>\r\nPrivate <\/span>Declare PtrSafe Function ReleaseDC Lib \"user32\" _\r\n (ByVal hwnd As Long<\/span>, ByVal hDC As Long<\/span>) As Long<\/span><\/pre>\nPrivate <\/span>Type POINTAPI\r\n X As Long<\/span>\r\n Y As Long<\/span>\r\nEnd Type<\/pre>\nPrivate Sub <\/span>ConvertPixelsToTwips(ByRef x As <\/span>stdole.OLE_XPOS_PIXELS, _\r\n ByRef y As <\/span>stdole.OLE_YPOS_PIXELS)\r\n Dim <\/span>hDC As Long<\/span>\r\n Dim <\/span>RetVal As Long<\/span>\r\n Dim <\/span>TwipsPerPixelX As Long<\/span>\r\n Dim <\/span>TwipsPerPixelY As Long<\/span>\r\n Const LOGPIXELSX = 88\r\n Const LOGPIXELSY = 90\r\n Const TWIPSPERINCH = 1440\r\n hDC = GetDC(0)\r\n TwipsPerPixelX = TWIPSPERINCH \/ GetDeviceCaps(hDC, LOGPIXELSX)\r\n TwipsPerPixelY = TWIPSPERINCH \/ GetDeviceCaps(hDC, LOGPIXELSY)\r\n RetVal = ReleaseDC(0, hDC)\r\n x = x * TwipsPerPixelX\r\n y = y * TwipsPerPixelY\r\nEnd Sub<\/span><\/pre>\nConvertPixelsToTwips x, y<\/pre>\n
Private <\/span>Declare PtrSafe Function ScreenToClient _\r\n Lib \"user32\" (ByVal hWnd As Long<\/span>Ptr, _\r\n lpPoint As <\/span>POINTAPI) As Long<\/span>Ptr\r\nPrivate <\/span>Declare PtrSafe Function GetCursorPos _\r\n Lib \"user32\" (lpPoint As <\/span>POINTAPI) As Long<\/span>Ptr<\/pre>\nPrivate Sub <\/span>objTreeView_MouseDown(ByVal Button As Integer<\/span>, ByVal Shift As Integer<\/span>, ByVal X As <\/span>stdole.OLE_XPOS_PIXELS, _\r\n ByVal Y As <\/span>stdole.OLE_YPOS_PIXELS)\r\n Dim <\/span>objNode As <\/span>MSComctlLib.Node\r\n Dim <\/span>pt As <\/span>POINTAPI\r\n GetCursorPos pt\r\n ScreenToClient CLngPtr(ctlTreeView.hWnd), pt\r\n Me!txtObjX = X\r\n Me!txtObjY = Y\r\n Me!txtAPIX = pt.X\r\n Me!txtAPIY = pt.Y\r\n If <\/span>pt.X = X Then<\/span>\r\n ConvertPixelsToTwips X, Y\r\n End If<\/span>\r\n Set<\/span> objNode = objTreeView.HitTest(X, Y)\r\n If <\/span>Not<\/span> objNode Is Nothing Then<\/span>\r\n Me!txtObjNode = objNode.Text\r\n Else<\/span>\r\n Me!txtObjNode = Null\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nDebug.Print<\/span> \"GetCursorPos: \" & pt.X, pt.Y<\/pre>\nDebug.Print<\/span> \"ScreenToClient: \" & pt.X, pt.Y<\/pre>\n![\"Ermitteln](\"..\/fileadmin\/_temp_\/2024_02\/pic_1492_015.png\")
<\/p>\n