<\/p>\n
Von Internetseiten kennen Sie diesen Effekt längst: Wenn Sie mit der Maus über einen Link etwa in der Navigationsleiste fahren, wird die jeweils überfahrene Schaltfläche mit einem speziellen Effekt hervorgehoben – beispielsweise in einer anderen Farbe. Da wir doch nun in Access mittlerweile auch Schaltflächen komfortabel mit Icons ausstatten können, sollten ähnliche Effekte doch auch hier möglich sein Wir zeigen, ob und wie dies funktioniert. <\/b><\/p>\n
Voraussetzungen<\/b><\/p>\n
Der Teil dieses Beitrags, der das angezeigte Icon wechselt, setzt mindestens Access 2010 voraus.<\/p>\n
Schriftart wechseln<\/b><\/p>\n
Um die grundsätzliche Funktion der hier vorgestellten Technik zu demonstrieren, verwenden wir eine Formatierungsänderung, die in allen Access-Versionen verfügbar sein dürfte – der Wechsel von der Standardschriftbreite zur fetten Schrift. Dazu legen Sie einfach ein neues Formular in einer Beispieldatenbank an und fügen diesem eine Schaltfläche mit einem beliebigen Text hinzu. Die Eigenschaft Schriftbreite <\/b>enthält in diesem Zustand der Schaltfläche natürlich den Wert Normal<\/b> (s. Bild 1).<\/p>\n
![\"Beispielformular](\"..\/fileadmin\/_temp_\/2014_03\/pic_933_001.png\")
<\/p>\n
Bild 1: Beispielformular mit der zu bearbeitenden Schaltfläche<\/span><\/b><\/p>\n Nun soll die Schaltfläche ihren Inhalt beim Darüberfahren mit der Maus fett anzeigen. Sie ahnen es bereits: Die Ereigniseigenschaft Bei Mausbewegung <\/b>der Schaltfläche spielt dabei eine Rolle. Machen wir uns als ans Werk und legen für diese Ereigniseigenschaft eine entsprechende Ereignisprozedur an. Durch Auswählen des Eintrags [Ereignisprozedur] und anschließendes Anklicken der Schaltfläche mit den drei Punkten zeigen Sie die neu erzeugte Ereignisprozedur direkt im VBA-Editor an (siehe Bild 2).<\/p>\n Bild 2: Anlegen einer Prozedur, die durch das Ereignis Bei Mausbewegung ausgelöst wird.<\/span><\/b><\/p>\n Diese Ereignisprozedur füllen Sie nun mit der folgenden Anweisung aus Listing 1 auf. Wechseln wir in die Formularansicht und probieren aus, ob die Prozedur funktioniert. Das Ergebnis: Es klappt! Allerdings mit zwei kleinen Schönheitsfehlern: Erstens wird die Schriftart beim Verlassen der Schaltfläche nicht wieder normal eingestellt, und zweitens flackert die Schaltfläche ständig, wenn man mit die Maus darüber bewegt.<\/p>\n Listing 1: ändern der Eigenschaft Schriftbreite in Fett<\/span><\/b><\/p>\n Schaltfläche wieder normal darstellen<\/b><\/p>\n Ersteres ist schon ein kleines Problem: Die Schaltflächen von Access bieten nämlich kein Ereignis etwa namens Beim Verlassen <\/b>et cetera. Was tun wir also Klar: Wir fragen ab, wann der Mauszeiger wieder den Bereich außerhalb der Schaltfläche kreuzt. Dabei handelt es sich in diesem Fall um den Detailbereich. Auch dieser liefert die Ereigniseigenschaft Bei Mausbewegung<\/b>, sodass wir einfach den Detailbereich durch Anklicken markieren und die gewünschte Ereignisprozedur anlegen (s. Bild 3).<\/p>\n Bild 3: Per Ereignis abgreifen, wann der Mauszeiger die Schaltfläche verlässt<\/span><\/b><\/p>\n Die Prozedur finden Sie in Listing 2.<\/p>\n Listing 2: Ursprüngliche Textbreite wiederherstellen<\/span><\/b><\/p>\n Um das zweite Problem mit dem Flackern kümmern wir uns weiter unten. Zunächst stellen wir uns die Frage: Was geschieht eigentlich, wenn wir dem dem Formular nun eine zweite Schaltfläche hinzufügen Dies betrachten wir im Formular frmHoverEffektZweiSchaltflaechen <\/b>der Beispieldatenbank (s. Bild 4). Dieses enthält zwei Schaltflächen namens cmdBeispielschaltflaeche1 <\/b>und cmdBeispielschaltflaeche2<\/b>. Beide Schaltflächen erhalten eine Ereignisprozedur, die durch das Ereignis Bei Mausbewegung <\/b>ausgelöst wird und die Schrift der jeweiligen Schaltfläche auf Fett <\/b>einstellt.<\/p>\n Bild 4: Neues Formular, diesmal mit zwei Schaltflächen<\/span><\/b><\/p>\n Und auch die entsprechende Ereignisprozedur für den Detailbereich müssen wir anpassen. Es kann ja nun auch geschehen, dass nicht die erste, sondern die zweite Schaltfläche mit fetter Schrift dargestellt wird. Also stellen wir vorsichtshalber gleich beide Schaltflächen entsprechend ein – s. Listing 3.<\/p>\n Listing 3: Ursprüngliche Textbreite für zwei Schaltfläche wiederherstellen<\/span><\/b><\/p>\n Auch das funktioniert wie gewünscht – zumindest, bis wir die beiden Schaltflächen direkt neben- oder übereinander platzieren, sodass der Detailbereich dazwischen nicht sichtbar ist (s. Bild 5). Dies ist zwar ungewöhnlich, aber wenn man wenig Platz hat oder eine Web-ähnliche Navigationsleiste erstellen möchte, kann eine solche Konstellation durchaus vorkommen.<\/p>\n Bild 5: Formular mit zwei direkt nebeneinander liegenden Schaltflächen<\/span><\/b><\/p>\n Das Problem bei der Sache ist, dass beim Wechsel von der linken zur rechten Schaltfläche zwar die rechte Schaltfläche mit fetter Schrift dargestellt wird, die linke aber nicht in den Anfangszustand zurückversetzt wird. Der Grund ist leicht nachvollziehbar: Der Mauszeiger überstreift zwischenzeitlich nicht den Detailbereich, also werden die beiden Schaltflächen auch nicht auf normale Schriftstärke zurückgesetzt.<\/p>\n Das bedeutet, dass wir für die Ereignisprozedur beim überfahren der zweiten Schaltfläche die Schriftart der ersten Schaltfläche zurücksetzen müssen und umgekehrt (s. Listing 4). Das ist in diesem Rahmen zwar machbar, aber was geschieht, wenn Sie nicht nur zwei, sondern vielleicht 20 Schaltflächen auf einem Formular unterbringen Nein, das ist definitiv zu viel Aufwand. Sie müssten dann nicht nur für jede der 20 Schaltflächen je eine Ereignisprozedur für das Ereignis Bei Mausbewegung einrichten, sondern auch noch in jeder dieser Prozeduren die aktuelle Schaltfläche mit fetter Schrift versehen und die übrigen 19 Schaltflächen auf normale Schriftbreite einstellen. Und jede weitere Schaltfläche zieht die änderung der entsprechenden Ereignisprozedur aller vorhandenen Schaltflächen nach sich.<\/p>\n Listing 4: Aktuelle Schaltfläche mit fetter Schrift, vorherige Schaltfläche normal anzeigen<\/span><\/b><\/p>\n Hover-Effekt mit Klasse<\/b><\/p>\n Wir werden also, wie in so vielen Fällen, in denen eine undefinierte Anzahl von Steuerelementen mit bestimmten Ereignissen ausgestattet werden müssen, ein oder zwei Klassen anlegen, welche die benötigte Funktionalität bereithalben. Um es vorweg zu nehmen: Sie müssen dem Klassenmodul eines Formulars nur noch wenige Zeilen Code hinzufügen, um den gewünschten Hover-Effekt für beliebig viele Schaltflächen zu erzielen.<\/p>\n Das Beispiel für den Einsatz dieser Klassen finden Sie im Formular frmHoverEffekt_Fett_Klasse<\/b>. Diese Formular besitzt zunächst zwei Schaltflächen, genau wie das Formular des vorherigen Beispiels. Legen Sie nun eine Ereignisprozedur für die Ereigniseigenschaft Beim Laden des Formulars an und hinterlegen Sie dafür den Code aus Listing 5. Zusätzlich fügen Sie noch die folgende Deklarationszeile zum Klassenmodul Form_frmHoverEffekt_Fett_Klasse <\/b>hinzu (beziehungsweise zum Klassenmodul des betroffenen Formulars, wenn Sie die Funktion zu einem eigenen Formular hinzufügen möchten):<\/p>\n Listing 5: Zuweisen der Funktionen der Klasse clsMouseOverForm zu einem Formular<\/span><\/b><\/p>\n Die Prozedur Form_Load<\/b> erstellt eine neue Instanz der Klasse clsMouseOverForm <\/b>und speichert den Verweis darauf in der Variablen objMouseOverForm<\/b>. Die einzige weitere Anweisung teilt dem Objekt objMouseOverForm <\/b>über die Eigenschaft Form <\/b>mit, auf welches Formular sich die Klasse beziehen soll beziehungsweise die Schaltflächen welchen Formulars den Hover-Effekt erhalten sollen.<\/p>\n Diese Klasse erzeugen Sie im VBA-Editor über den Menüeintrag Einfügen|Klassenmodul<\/b>. Speichern Sie die Klasse unter dem Namen clsMouseOverForm<\/b>.<\/p>\n Instanzieren der Klasse<\/b><\/p>\n Wenn der Benutzer nun das Formular öffnet, löst dies automatisch die Ereignisprozedur Form_Load <\/b>aus. Beim Instanzieren des neuen Objekts auf Basis der Klasse clsMouseOverForm <\/b>geschieht noch nichts. Erst mit dem Zuweisen des Formulars zur Eigenschaft Form des Objekts objMouseOverForm <\/b>wird eine Property Set<\/b>-Prozedur der Klasse ausgelöst. Diese sieht wie in Listing 6 aus. Die Prozedur speichert zunächst einen Verweis auf das Formular in einer Variablen, die wie folgt im Kopf des Klassenmoduls clsMouseOverForm <\/b>deklariert wird:<\/p>\n Listing 6: Zuweisen des Formulars und Einstellen einiger Eigenschaften<\/span><\/b><\/p>\n Die Deklaration mit dem Schlüsselwort WithEvents <\/b>sorgt dafür, dass wir innerhalb des aktuellen Klassenformulars Ereignisprozeduren für das in dieser Variablen referenzierte Formular implementieren können. Das ist gerade einer der Tricks bei dieser Lösung: Sie sollen nicht zahlreiche Ereignisprozeduren zum formular hinzufügen, sondern nur die Klasse clsMouseOverForm <\/b>instanzieren und diesem sagen, welches Formular mit den Ereignisprozeduren auszustatten ist – den Rest übernimmt die Klasse dann selbst.<\/p>\n Auf die gleiche Weise füllt die Property Set<\/b>-Prozedur die Variable frmDetail <\/b>mit einem Verweis auf den Detailbereich des Formulars. Diese deklariert die Klasse wie folgt:<\/p>\n Den Verweis auf den Detailbereich erhalten wir über den Ausdruck m_Form.Section(0)<\/b>.<\/p>\n Die folgenden Anweisungen sorgen dafür, dass die Eigenschaft Bei Mausbewegung <\/b>(OnMouseMove<\/b>) des mit m_Form <\/b>referenzierten Formulars mit dem Wert [Event Procedure] <\/b>(im Eigenschaftsfenster [Ereignisprozedur]<\/b>) gefüllt wird. Das Gleiche erledigt die Prozedur für den in frmDetail <\/b>gespeicherten Detailbereich.<\/p>\n Anschließend kümmert sich die Prozedur um die im Formular enthaltenen Steuerelemente. Dazu instanziert sie zunächst ein Collection<\/b>-Objekt, das mit der folgenden Variablen im Kopf des Klassenmoduls deklariert wird:<\/p>\n Die Property Set<\/b>-Prozedur Form <\/b>durchläuft nun in einer For Each<\/b>-Schleife alle Steuerelemente des referenzierten Formulars und weist das aktuellen Control<\/b>-Objekt der Variablen ctl <\/b>zu. Innerhalb der Schleife prüft die Prozedur die Eigenschaft ControlType <\/b>des Steuerelements. Handelt es sich um eine Schaltfläche (ControlType = acCommandButton<\/b>), führt die Prozedur weitere Anweisungen aus. Die erste erstellt ein neues Objekt auf Basis einer zweiten Klasse namens clsMouseOverControl<\/b>. Die Details dieser Klasse besprechen wir weiter unten – zunächst schauen wir uns an, wie diese instanziert und bestückt wird.<\/p>\n Die Instanzierung erfolgt wie gewohnt über die New<\/b>-Methode. Die Klasse clsMouseOverControl<\/b> verfügt über eine Eigenschaft namens CommandButton<\/b>, der Sie den Verweis auf das aktuell mit der For Each<\/b>-Schleife durchlaufene und mit cmd<\/b> referenzierte Steuerelement zuweisen. Außerdem bietet die Klasse eine weitere Eigenschaft namens Parent<\/b>, der Sie einen Verweis auf die aktuelle Klasse, also clsMouseOverForm<\/b>, zuweisen. Diese referenzieren Sie einfach mit dem Schlüsselwort Me<\/b>. Das war es schon fast. Es fehlt jedoch noch ein entscheidender Schritt, bevor wir die nächste Schaltfläche auf die gleiche Weise in einer Instanz der Klasse clsMouseOverControl <\/b>erstellen: Wir müssen das soeben erstellt Objekt objMouse-OverControl <\/b>noch verewigen, damit es beim nächsten Schleifendurchlauf nicht einfach überschrieben wird. Dazu fügen wir die Objektvariable objMouseOverControl <\/b>einfach mit der Add<\/b>-Methode zum Collection<\/b>-Objekt colControls <\/b>hinzu!<\/p>\n <\/p>\n Die Collection ist ja im allgemeinen Teil des Klassenmoduls clsMouseOverForm <\/b>deklariert und bleibt somit solange erhalten wie die Instanz des Klassenmoduls selbst. Und da diese ja beim Laden des Formulars wiederum in der Variablen objMouseOverForm <\/b>im Klassenmodul des Formulars gespeichert wird, bleiben die Elemente der Collection solange verfügbar, bis der Benutzer das Formular schließt.<\/p>\n Auf die gleiche Weise durchläuft die Prozedur alle Steuerelemente des Formulars und fügt für jede Schaltfläche eine neue Instanz der Klasse clsMouseOverControl <\/b>zur Collection colControls <\/b>hinzu.<\/p>\n Die Klasse clsMouseOverControl<\/b><\/p>\n Das waren die vorbereitenden Aktionen innerhalb der Klasse clsMouseOverForm<\/b>. Bevor wir zu den Teilen des Codes kommen, welche die Aktionen bei der Benutzung des Formulars beschreiben, schauen wir uns einige Details der Klasse clsMouseOverControl <\/b>an.<\/p>\n Zunächst einmal wäre da die Property Set<\/b>-Prozedur, welche den Verweis auf das CommandButton<\/b>-Objekt entgegen nimmt, dessen Ereignisse in der Klasse clsMouseOverControl <\/b>implementiert werden sollen. Diese sieht wie in Listing 7 aus und schreibt den mit der Variablen cmd <\/b>übergebenen Verweis in die lokale Variable m_cmd<\/b>. Diese wird wie folgt im Kopf des Klassenmoduls clsMouseOverControl <\/b>deklariert:<\/p>\n Listing 7: Zuweisen der Referenz auf die Schaltfläche<\/span><\/b><\/p>\n Anschließend trägt die Prozedur noch den Wert [Event Procedure] <\/b>für die Eigenschaft OnMouseMove <\/b>für dieses Steuerelement ein.<\/p>\n Die zweite Property Set<\/b>-Prozedur nimmt den Verweis auf die Instanz der erzeugenden Klasse entgegen, die im Objekt objMouseOverForm <\/b>gespeichert ist (s. Listing 8). Die Prozedur speichert den Verweis auf dieses Objekt in der Variablen m_Form<\/b>:<\/p>\n Listing 8: Zuweisen der Referenz auf die Klasse clsMouseOverForm<\/span><\/b><\/p>\n Funktion der beiden Klassen<\/b><\/p>\n Wir haben nun also in unserem Beispiel ein Objekt des Typs clsMouseOverForm <\/b> (gespeichert in der Variablen objMouseOverForm <\/b>im Klassenmodul des Formulars) und für jede Schaltfläche ein Objekt des Typs clsMouseOverControl <\/b>(gespeichert in einer Collection <\/b>in clsMouseOverForm<\/b>).<\/p>\n Wenn der Benutzer nun mit der Maus über eine der Schaltflächen fährt, soll für diese die Schriftart auf Fett eingestellt werden. Gleichzeitig soll die Schrift auf allen übrigen Schaltflächen nicht fett erscheinen. Wenn die Maus eine Schaltfläche verlässt und nicht auf einer anderen Schaltfläche landet, sollen alle Schaltflächen nicht fett dargestellt werden.<\/p>\n Hier entsteht zunächst das Problem, dass wir beim überfahren einer Schaltfläche dafür sorgen müssen, dass keine der übrigen Schaltflächen mit fetter Schrift dargestellt wird.<\/p>\n Dazu gibt es zwei Möglichkeiten: Entweder wir durchlaufen alle übrigen Schaltflächen und stellen ihre Schriftart entsprechend ein, oder wir speichern jeweils einen Verweis auf die aktuell überfahrene Schaltfläche in einer Variablen. Wenn die Maus nun eine andere Schaltfläche überfährt, brauchen wir nur die Fett<\/b>-Eigenschaft der zuvor in der Variablen gespeicherten Schaltfläche auf Nein <\/b>einzustellen.<\/p>\n Wir wollen den letzten, möglicherweise etwas komplizierteren, aber schnelleren Weg einschlagen. Dazu deklarieren Sie in der Klasse clsMouseOverForm <\/b>die folgende Variable, mit der ein Verweis auf das zuletzt überfahrene CommandButton<\/b>-Objekt gespeichert werden soll:<\/p>\n Danach fügen Sie der Klasse eine Property Set<\/b>-Prozedur hinzu, mit der wir das aktive Steuerelement einstellen können:<\/p>\n Außerdem benötigen wir noch die Möglichkeit, dieses Steuerelement auszulesen. Dies bewerkstelligen wir mit einer entsprechenden Property Get<\/b>-Prozedur, die wie folgt aussieht:<\/p>\n Damit gelangen wir direkt zu der Implementierung der Ereignisprozedur für das Ereignis Bei Mausbewegung <\/b>in der Klasse clsMouseOverControl<\/b>, die ja für alle Schaltflächen ausgelöst wird, wenn der Benutzer mit der Maus darüberfährt. Diese sieht wie in Listing 9 aus.<\/p>\n Listing 9: Diese Prozedur wird beim überfahren einer Schaltfläche ausgelöst.<\/span><\/b><\/p>\n Die Prozedur prüft zunächst zwei Bedingungen per Or-Verknüpfung:<\/p>\n Trifft einer von beiden Fällen ein, war die aktuell mit der Maus überfahrene Schaltfläche zuletzt nicht die fett markierte Schaltfläche, sondern entweder keine oder eine andere. Innerhalb der If…Then<\/b>-Bedingung prüft eine weitere Bedingung, ob zuletzt eine Schaltfläche in ctlAktiv <\/b>gespeichert war (was der Fall ist, wenn der Mauszeiger gerade von einer benachbarten Schaltfläche auf die aktuelle Schaltfläche verschoben wurde). In diesem Fall stellt die Prozedur die Eigenschaft FontBold <\/b>der zuvor aktiven Schaltfläche auf False <\/b>ein.<\/p>\n Außerdem speichert sie die aktuell mit der Maus überfahrene Schaltfläche in der Eigenschaft ctlAktiv <\/b>der Klasse clsMouseOverForm <\/b>und stellt FontBold <\/b>für diese Schaltfläche auf True <\/b>ein.<\/p>\n Und genau diese Abfolge wird für alle Schaltflächen des Formulars durchgeführt, sodass immer die Schaltfläche, auf der sich der Mauszeiger befindet, mit fetter Schrift angezeigt wird.<\/p>\n Nun müssen wir noch für den Fall vorsorgen, dass der Benutzer den Mauszeiger auf einen Bereich verschiebt, der keine Schaltfläche enthält.<\/p>\n Dies liegt wiederum im Verantwortungsbereich der Klasse clsMouseOverForm<\/b>. Diese soll ja eine Ereignisprozedur erhalten, die beim überfahren des Detailbereichs mit der Maus ausgelöst wird. Die Ereignisprozedur sieht wie in Listing 10 aus und könnte eigentlich immer, wenn sie ausgelöst wird, die Eigenschaft FontBold <\/b>der zuletzt überfahrenen und mit m_Aktiv <\/b>referenzierten Schaltfläche auf False <\/b>einstellen.<\/p>\n Listing 10: Diese Prozedur wird beim überfahren des Detailbereichs ausgelöst.<\/span><\/b><\/p>\n Allerdings würde dies dann viele Male pro Sekunde geschenen, weil das Ereignis Form_MouseMove <\/b>ja in kurzen Abständen während der Mausbewegung feuert. Das ständige Einstellen der FontBold<\/b>-Eigenschaft würde zu starkem Flackern des Formulars führen.<\/p>\n Also prüft die Prozedur, ob m_Aktiv <\/b>nicht den Wert Nothing <\/b>enthält, also ob eine der Schaltflächen als aktiv markiert ist. Ist dies der Fall, erfolgen zwei Schritte:<\/p>\n Das war es – das Formular zeugt nun jeweils die überfahrene Schaltfläche mit fetter Schrift an.<\/p>\n Um zu prüfen, ob dies auch tatsächlich immer funktioniert, fügen wir dem Formular einfach noch eine Schaltfläche hinzu und öffnen es erneut in der Formularansicht. Und auch dies gelingt!<\/p>\n Neue Möglichkeiten ab Access 2007<\/b><\/p>\n Mit Access 2007 hat Microsoft neue Eigenschaften für Schaltflächen eingeführt (ab hier finden Sie alle Beispiele in der Datenbank HoverEffekt2010.accdb<\/b>). Die neuen Eigenschaften finden Sie im Eigenschaftsfenster im Bereich Format <\/b>(s. Bild 6):<\/p>\n Bild 6: Eigenschaften, die Hintergrund- und Rahmenfarbe beim Mouseover anpasst<\/span><\/b><\/p>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2014_03\/pic_933_002.png\")
<\/p>\nPrivate Sub <\/span>cmdBeispielschaltflaeche_MouseMove(Button As Integer<\/span>, _\r\n Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Me!cmdBeispielschaltflaeche.FontBold = True<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Per](\"..\/fileadmin\/_temp_\/2014_03\/pic_933_003.png\")
<\/p>\nPrivate Sub <\/span>Detailbereich_MouseMove(Button As Integer<\/span>, Shift As Integer<\/span>, _\r\n X As Single<\/span>, Y As Single<\/span>)\r\n Me!cmdBeispielschaltflaeche.FontBold = False<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Neues](\"..\/fileadmin\/_temp_\/2014_03\/pic_933_004.png\")
<\/p>\nPrivate Sub <\/span>Detailbereich_MouseMove(Button As Integer<\/span>, Shift As Integer<\/span>, _\r\n X As Single<\/span>, Y As Single<\/span>)\r\n Me!cmdBeispielschaltflaeche1.FontBold = False<\/span>\r\n Me!cmdBeispielschaltflaeche2.FontBold = False<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Formular](\"..\/fileadmin\/_temp_\/2014_03\/pic_933_005.png\")
<\/p>\nPrivate Sub <\/span>cmdBeispielschaltflaeche2_MouseMove(Button As Integer<\/span>, _\r\n Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Me!cmdBeispielschaltflaeche1.FontBold = False<\/span>\r\n Me!cmdBeispielschaltflaeche2.FontBold = True<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objMouseOverForm = New<\/span> clsMouseOverForm\r\n With<\/span> objMouseOverForm\r\n Set<\/span> .Form = Me\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nDim <\/span>objMouseOverForm As <\/span>clsMouseOverForm<\/pre>\nDim <\/span>WithEvents m_Form As <\/span>Form<\/pre>\nPublic Property Set<\/span> <\/span>Form(frm As <\/span>Form)\r\n Dim <\/span>objMouseOverControl As <\/span>clsMouseOverControl\r\n Dim <\/span>ctl As <\/span>control\r\n Set<\/span> m_Form = frm\r\n Set<\/span> frmDetail = m_Form.Section(0)\r\n With<\/span> m_Form\r\n .OnMouseMove = \"[Event Procedure]\"\r\n End With<\/span>\r\n With<\/span> frmDetail\r\n .OnMouseMove = \"[Event Procedure]\"\r\n End With<\/span>\r\n Set<\/span> colControls = New<\/span> Collection\r\n For Each ctl In m_Form.Controls\r\n Select Case ctl.ControlType\r\n Case <\/span>acCommandButton\r\n Set<\/span> objMouseOverControl = New<\/span> clsMouseOverControl\r\n With<\/span> objMouseOverControl\r\n Set<\/span> .Commandbutton = ctl\r\n Set<\/span> .Parent = Me\r\n End With<\/span>\r\n colControls.Add objMouseOverControl\r\n End Select<\/span>\r\n Next<\/span> ctl\r\nEnd Property<\/span><\/pre>\nDim <\/span>WithEvents frmDetail As <\/span>Section<\/pre>\nDim <\/span>colControls As <\/span>Collection<\/pre>\nDim <\/span>WithEvents m_cmd As <\/span>Commandbutton<\/pre>\nPublic Property Set<\/span> <\/span>Commandbutton(cmd As <\/span>Commandbutton)\r\n Set<\/span> m_cmd = cmd\r\n With<\/span> m_cmd\r\n .OnMouseMove = \"[Event Procedure]\"\r\n End With<\/span>\r\nEnd Property<\/span><\/pre>\nDim <\/span>m_Parent As <\/span>clsMouseoverForm<\/pre>\nPublic Property Set<\/span> <\/span>Parent(obj As <\/span>clsMouseoverForm)\r\n Set<\/span> m_Parent = obj\r\nEnd Property<\/span><\/pre>\nDim <\/span>m_Aktiv As <\/span>control<\/pre>\nPublic Property Get <\/span>ctlAktiv() As <\/span>control\r\n Set<\/span> ctlAktiv = m_Aktiv\r\nEnd Property<\/span><\/pre>\nPublic Property Set<\/span> <\/span>ctlAktiv(ctl As <\/span>control)\r\n Set<\/span> m_Aktiv = ctl\r\nEnd Property<\/span><\/pre>\nPrivate Sub <\/span>m_cmd_MouseMove(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n If <\/span>m_Parent.ctlAktiv Is Nothing Or Not<\/span> m_Parent.ctlAktiv Is m_cmd Then<\/span>\r\n If <\/span>Not<\/span> m_Parent.ctlAktiv Is Nothing Then<\/span>\r\n m_Parent.ctlAktiv.FontBold = False<\/span>\r\n End If<\/span>\r\n Set<\/span> m_Parent.ctlAktiv = m_cmd\r\n m_cmd.FontBold = True<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n\n
Private Sub <\/span>frmDetail_MouseMove(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n If <\/span>Not<\/span> m_Aktiv Is Nothing Then<\/span>\r\n m_Aktiv.FontBold = False<\/span>\r\n Set<\/span> m_Aktiv = Nothing\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n\n
![\"Eigenschaften,](\"..\/fileadmin\/_temp_\/2014_03\/pic_933_006.png\")
<\/p>\n\n