<\/p>\n
Wenn Sie Ereignisse auslösen möchten, sobald der Benutzer an irgendeine Stelle eines Datensatzes in der Datenblattansicht klickt, müssen Sie theoretisch für jedes einzelne Steuerelement eine entsprechende Ereignisprozedur anlegen. Bei Formularen mit vielen Feldern kann das recht mühselig werden. Daher stellt dieser Beitrag eine Klasse vor, der Sie das Unterformular in der Datenblattansicht übergeben und die Ihnen Ereignisse für die gängigen Ereignisse wie Klick, Doppelklick et cetera bereitstellt. Diese müssen Sie dann nur noch einfach im Hauptformular implementieren.<\/b><\/p>\n
Die hier vorgestellte Klasse soll folgende Funktionen bieten:<\/p>\n
Im Beispiel aus Bild 1 werten wir beispielsweise den Primärschlüsselwert, die Aktion (also Click<\/b>, DblClick<\/b>, MouseUp <\/b>oder MouseDown<\/b>) und den Namen des angeklickten Steuerelements aus und zeigen diesen in den drei Textfeldern des Formulars an.<\/p>\n
![\"Unterformular](\"..\/fileadmin\/_temp_\/2015_05\/pic_999_001.png\")
<\/p>\n
Bild 1: Unterformular mit Ereignisprozeduren im Hauptformular<\/span><\/b><\/p>\n Um dies zu realisieren, sind, sobald die beiden Klassen clsDatasheetForm <\/b>und clsDatasheetControl <\/b>einmal in das Projekt importiert wurden, nur einige wenige Zeilen Code erforderlich.<\/p>\n Dabei deklarieren wir zunächst eine Variable, welche ein Objekt auf Basis der Klasse clsDatasheetForm<\/b> aufnimmt, und zwar unter dem Namen objDatasheetForm<\/b>. Außerdem erstellen wir eine Ereignisprozedur, die durch das Ereignis Beim Laden <\/b>des Formulars ausgelöst wird. Diese sieht wie in Listing 1 aus (dort finden Sie auch die Deklaration des Objekts objDatasheetForm<\/b>). Die Prozedur erstellt eine neue Instanz der Klasse clsDatasheetForm<\/b> und speichert den Verweis auf das neue Objekt in der Variablen objDatasheetForm<\/b>.<\/p>\n Listing 1: Ereignisprozedur, welche die Datenblattereignisse zugreifbar macht<\/span><\/b><\/p>\n Für diese stellt sie nun drei Eigenschaften ein:<\/p>\n Damit ist die Arbeit noch nicht getan. Schließlich müssen wir noch die Ereignisse definieren, die im Klassenmodul des Hauptformulars ausgelöst werden sollen, wenn ein Benutzer auf ein Feld eines Datensatzes im Unterformular klickt.<\/p>\n Dazu wählen Sie im VBA-Codefenster im linken Kombinationsfeld den Eintrag objDatasheetForm <\/b>aus und im rechten einen der vier Einträge Click<\/b>, DblClick<\/b>, MouseDown <\/b>oder MouseUp <\/b>– je nachdem, welches Ereignis Sie implementieren möchten. Der VBA-Editor legt dann automatisch den Prozedurrumpf für das jeweilige Ereignis an – genau so, als ob Sie ein Ereignis eines Formulars oder Steuerelements über das Eigenschaftsfenster der Entwurfsansicht anlegen (s. Bild 2).<\/p>\n Bild 2: Anlegen einer Ereignisprozedur für das Objekt objDatasheetForm<\/span><\/b><\/p>\n In dieser Liste sehen Sie, dass objDatasheetForm <\/b>vier Ereignisse anbietet – Click<\/b>, DblClick<\/b>, MouseDown <\/b>und MouseUp<\/b>.<\/p>\n Wir wollen alle vier implementieren, um Spielmaterial für unsere Beispielanwendung zu haben. So können Sie gut erkennen, wie Sie die Klassen einsetzen können.<\/p>\n Allerdings schauen wir uns nur eine Ereignisprozedur hier an – die übrigen sind alle gleich aufgebaut. Die folgende Prozedur wird ausgelöst, wenn der Benutzer mit der Maus auf eines der Steuerelemente eines Datensatzes im Unterformular klickt – oder auf den Datensatzmarkierer:<\/p>\n Der Parameter ctl <\/b>liefert einen Verweis auf das Steu-erelement, das der Benutzer angeklickt hat. Ist ctl <\/b>leer, bedeutet dies, dass der Benutzer nicht auf ein Steuerelement, sondern auf den Datensatzmarkierer geklickt hat.<\/p>\n Die erste Anweisung trägt den Text Click <\/b>in das Textfeld txtAktion <\/b>des Formulars ein. Dass hier das Click<\/b>-Ereignis ausgelöst wurde, wissen wir natürlich, weil wir uns gerade im objDatasheetForm_Click<\/b>-Ereignis befinden. Die folgende If…Then<\/b>-Bedingung prüft, ob ctl <\/b>nicht den Wert Nothing <\/b>enthält.<\/p>\n In diesem Fall gibt die Prozedur den Namen des angeklickten Steuerelements im Textfeld txtControl <\/b>aus. Anderenfalls wissen wir, dass der Benutzer anderswo im Formular geklickt hat, und tragen den Text Form <\/b>in das Textfeld ein.<\/p>\n Schließlich haben wir dem Objekt für die Eigenschaft PrimaryKey <\/b>den Wert ArtikelID <\/b>übergeben. Deshalb liefert die Ereignisprozedur mit dem Parameter varPKValue <\/b>den Wert dieses Feldes für den angeklickten Datensatz. Auch diesen geben wir aus – diesmal im Textfeld txtPKWert<\/b>.<\/p>\n Aufgrund der gelieferten Informationen wird deutlich, welche Möglichkeiten sich hier bieten. Sie können etwa über einen Doppelklick auf einen der Datensätze im Unterformular ein Detailformular mit weiteren Informationen zum Datensatz liefern – ohne für jedes einzelne Steuerelement, über das der Benutzer den Datensatz anklicken könnte, eine eigene Ereignisprozedur anlegen zu müssen.<\/p>\n Gut: Im Hintergrund geschieht genau dies. Aber, wie Sie gleich sehen werden, auf dynamische Art und Weise, bei der Sie keine Zeile Code mehr hinzufügen müssen.<\/p>\n Die Programmierung der Klassen, die im Hintergrund dafür sorgen, dass die Ereignisse aller Steuerelemente des Datenblattformulars abgefangen und an das Hauptformular weitergegeben werden, scheint auf den ersten Blick recht kompliziert zu sein. Wenn man sich etwas hineinarbeitet, findet man sich allerdings gut zurecht.<\/p>\n Für die bessere übersicht haben wir in Bild 3 ein kleines Schema der beteiligten Elemente aufgezeichnet. Links sind das Formular mit dem Unterformular und einige Steuerelemente.<\/p>\n Bild 3: Schema der Formulare und Klassen<\/span><\/b><\/p>\n Auf der rechten Seite sehen Sie die Klasse clsData-sheetForm<\/b>. Darin befindet sich die Auflistung colCon-trols<\/b>, die wiederum einige Elemente des Typs clsData-sheetControl <\/b>enthält. <\/p>\n Das Ereignis Beim Laden <\/b>des Hauptformulars erstellt ein Objekt auf Basis der Klasse clsDatasheetForm<\/b>. Dabei übergibt dieses einen Verweis auf das Unterformular an das Objekt objDatasheetForm<\/b>. objDatasheetForm <\/b>wiederum liest nach dem Zuweisen des Formulars alle Steuerelemente wie Textfelder, Kombinationsfelder, Listenfelder und Kontrollkästchen ein und legt für jedes eine eigene Instanz der Klasse clsDatasheetControl <\/b>an. Diese landen in der Collection colControls<\/b>.<\/p>\n Die Instanzen der Klasse clsDatasheetControl <\/b>referenzieren wiederum jeweils eines der Steuerelemente des Unterformulars.<\/p>\n Dabei implementieren diese Klassen jeweils die Ereignisse Beim Klicken<\/b>, Beim Doppelklicken<\/b>, Bei Maustaste ab <\/b>und Bei Maustaste auf<\/b>. Das heißt, dass in der Klasse clsDatasheetControl <\/b>eine Ereignisprozedur ausgelöst wird, wenn der Benutzer auf eines der Steuerelemente klickt.<\/p>\n Die Objekte auf Basis von clsDatasheetControl <\/b>referenzieren aber nicht nur jeweils das ihnen zugeteilte Steuerelement, sondern auch die Instanz der Klasse clsDatasheetForm<\/b>, deren Collection colControl <\/b>sie angehören. Dadurch kann clsDatasheetControl <\/b>auf die in clsDatasheetForm <\/b>enthaltenen Prozeduren Click<\/b>, DblClick<\/b>, MouseDown <\/b>und MouseUp <\/b>zugreifen.<\/p>\n Wenn der Benutzer also auf ein Steuerelement klickt, wird das in der Klasse clsDatasheetControl <\/b>implementierte Ereignis OnClick <\/b>ausgelöst. Dieses wiederum ruft die Methode Click <\/b>der Klasse clsDatasheetForm <\/b>auf.<\/p>\n Diese löst das Ereignis OnClick <\/b>der Klasse clsData-sheetForm <\/b>aus, das seinerseits im Klassenmodul des Hauptformulars implementiert ist. Dort können wir dann das angeklickte Steuerelemente ermitteln und beispielsweise den Primärschlüsselwert des markierten Datensatzes einlesen oder ein weiteres Formular etwa zur Anzeige eines Detaildatensatzes zum angeklickten Datensatz aufrufen.<\/p>\n Aber warum ist das nun so kompliziert Ginge das nicht auch direkt vom Hauptformular aus Natürlich: Sie müssten dort allerdings von Hand für jedes Steuerelement im Unterformular die vier Ereignisse Beim Klicken<\/b>, Beim Doppelklicken<\/b>, Bei Maustaste ab <\/b>und Bei Maustaste auf <\/b>programmieren.<\/p>\n <\/p>\n Bei zehn Steuerelementen sind das schon 40 Ereignisprozeduren, die selbst bei Copy and Paste mit den damit verbundenen Fehlern beim Anpassen eine Menge Arbeit machen. Die beiden Klassen brauchen Sie nur zur Zielanwendung hinzuzufügen und können diese dann mit den oben gezeigten Anweisungen steuern, ohne zig Ereignisprozeduren programmieren zu müssen.<\/p>\n Die Klasse clsDatasheetForm <\/b>deklariert vier Variablen. Diese nehmen den Verweis auf das Unterformular, die Collection zum Speichern der Instanzen der Klasse clsDatasheetControl<\/b>, den Namen des Primärschlüsselfelds (m_PrimaryKey<\/b>) und einen Boolean<\/b>-Wert namens m_SelectRow <\/b>auf, der festlegt, ob die gesamte Zeile beim Anklicken markiert werden soll:<\/p>\n Für das Erstellen der Objekte auf Basis der Klasse clsDatasheetCollection <\/b>deklarieren wir außerdem folgende Variable:<\/p>\n Damit das instanzierende Formular die Ereignisse der Klasse clsDatasheetForm <\/b>implementieren kann, deklarieren wir diese wie folgt als Public Events<\/b>:<\/p>\n Die obigen Member-Variablen füllen wir über geeignete Propery Set<\/b>– und Property Let<\/b>-Prozeduren. Die wichtigste weist m_Form <\/b>den Verweis auf das Unterformular zu (s. Listing 2) und heißt DatasheetForm<\/b>. Die als Parameter übergebene Form<\/b>-Variable landet in m_Form<\/b>. Dann stellt die Prozedur die Eigenschaften OnMouseDown<\/b>, OnMouseUp<\/b>, OnClick <\/b>und OnDblClick <\/b>auf [Event Procedure] <\/b>ein, damit in diesem Klassenmodul die entsprechenden Ereignisse implementiert werden können.<\/p>\n Listing 2: Füllen der Klasse mit dem Unterformular<\/span><\/b><\/p>\n Danach instanziert die Prozedur die Collection colControls <\/b>und durchläuft in einer For Each<\/b>-Schleife alle Steuerelemente des Unterformulars.<\/p>\n Trifft es dabei auf ein Textfeld, Listenfeld, Kombinationsfeld oder ein Kontrollkästchen, legt es dafür ein neues Objekt auf Basis der Klasse clsDatasheetControl <\/b>an und weist diesem sowohl einen Verweis auf das Steuerelement als auch auf sich selbst (also auf objDatasheetForm<\/b>) zu. Anschließend speichert sie den Verweis auf die neue clsDatasheetControl<\/b>-Instanz in der Collection colControls<\/b>.<\/p>\n Um festzulegen, ob beim Anklicken eines Steuerelements gleich die ganze Zeile markiert werden soll, stellt die Klasse die Eigenschaft SelectRowOnClick <\/b>zur Verfügung. Diese nimmt einen Boolean<\/b>-Wert entgegen und stellt zunächst die Member-Variable m_SelectRow <\/b>auf den übergebenen Wert ein. Danach muss Sie diese Einstellung noch den einzelnen Instanzen von clsDatasheetControl <\/b>übergeben.<\/p>\n Dazu durchläuft sie in einer For Each<\/b>-Schleife alle Elemente von colControls <\/b>und stellt deren Eigenschaft SelectRowOnClick <\/b>auf den übergebenen Wert ein:<\/p>\n Für die übergabe des Primärschlüssels ist die folgende Property Let<\/b>-Prozedur gedacht. Sie trägt lediglich den übergebenen Wert in die Variable m_PrimaryKey <\/b>ein:<\/p>\n Nun sorgen wir dafür, dass sich etwas tut, wenn der Benutzer auf den Datensatzmarkierer eines Datensatzes im Unterformular klickt. Dies löst die Ereignisse Form_Click<\/b>, Form_MouseUp <\/b>und Form_MouseDown <\/b>aus, beim Doppelklick auch Form_DblClick<\/b>. Diese Ereignisse haben wir in Listing 3 implementiert.<\/p>\n Listing 3: Implementierung der verschiedenen Maus-Ereignisse des Unterformulars<\/span><\/b><\/p>\n Die Ereignisprozeduren sind ähnlich aufgebaut. Sie prüfen, ob m_PrimaryKey <\/b>einen Wert enthält und somit, ob ein Primärschlüsselwert für den angeklickten Datensatz zurückgegeben werden soll.<\/p>\n Falls ja, löst die Prozedur das Ereignis Click <\/b>aus und übergibt diesem als ersten Parameter den Wert Nothing <\/b>(hier sollte normalerweise das Steuerelement angegeben werden, auf das der Benutzer geklickt hat, was aber hier nicht der Fall ist) und als zweiten Parameter den Wert des angegebenen Primärschlüsselfeldes.<\/p>\n Sollte m_PrimaryKey <\/b>leer sein, gibt die Prozedur einfach nur die Werte Nothing <\/b>und Null <\/b>für die Parameter weiter.<\/p>\n Wenn der Benutzer nun eines der Steuerelemente im Unterformular anklickt, löst er damit – kleiner Vorgriff – beispielsweise das in der Klasse clsDatasheetControl <\/b>implementierte Ereignis OnClick <\/b>eines Textfeldes aus. Dieses ruft dann unter anderem die Methode Click <\/b>der Klasse clsDatasheetForm <\/b>auf. Diese sieht so aus:<\/p>\n Hier geschieht also genau das Gleiche wie bei den Ereignissen, die durch das Anklicken des Datensatzmarkierers ausgelöst werden.<\/p>\n Einziger Unterschied: Statt des Wertes Nothing <\/b>(für das Formular) übergibt die Prozedur einen Verweis auf das auslösende Steuerelement (ctl<\/b>) an das Ereignis.<\/p>\n Die übrigen drei Methoden namens DblClick<\/b>, MouseDown <\/b>und MouseUp <\/b>sehen genauso aus.<\/p>\n Fehlt noch die Klasse clsDatasheetControl<\/b>. Diese wird ja für jedes Textfeld, Kombinationsfeld, Listenfeld und Kontrollkästchen erstellt.<\/p>\n Dementsprechend halten wir auch in jeder Instanz von clsDatasheetControl <\/b>je eine Variable für die vier Steuerelementtypen vor – je nachdem, welches übergeben wird, nutzen wir die eine oder andere Variable. Diese deklariert die Klasse wie folgt:<\/p>\n Außerdem benötigen wir eine Variable für die instanzierende Klasse clsDatasheetForm<\/b>, damit wir auf die vier Methoden Click<\/b>, DblClick<\/b>, MouseUp <\/b>und MouseDown <\/b>zugreifen können:<\/p>\n Außerdem muss die Klasse clsDatasheetForm<\/b> den Instanzen der Klasse clsDatasheetControl <\/b>noch mitteilen, ob die gesamte Zeile beim Anklicken eines Datensatzes markiert werden soll. Dies speichert die folgende Variable:<\/p>\n Den Verweis auf das Steuerelement nimmt die Eigenschaft DatasheetControl <\/b>entgegen, und zwar in Form der gleichnamigen Property Set<\/b>-Prozedur. Den mit dem Steuerelement gefüllten Parameter ctl <\/b>prüft die Prozedur direkt auf die Eigenschaft ControlType<\/b>.<\/p>\n Je nachdem, ob es sich um acTextBox<\/b>, acComboBox<\/b>, acListBox <\/b>oder acCheckBox <\/b>handelt, weist die Prozedur ctl <\/b>einer der Variablen m_TextBox<\/b>, m_ComboBox<\/b>, m_ListBox <\/b>oder m_CheckBox <\/b>zu. Für das jeweilige Objekt stellt die Prozedur dann die Eigenschaften OnMouseDown<\/b>, OnMouseUp<\/b>, OnMouseClick <\/b>und OnMouseDblClick <\/b>auf [Event Procedure] <\/b>ein:<\/p>\nDim <\/span>WithEvents objDatasheetForm As <\/span>clsDataSheetForm\r\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objDatasheetForm = New<\/span> clsDatasheetForm\r\n With<\/span> objDatasheetForm\r\n Set<\/span> .DatasheetForm = Me!sfmArtikel.Form\r\n .PrimaryKey = \"ArtikelID\"\r\n .SelectRowOnClick = True<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2015_05\/pic_999_002.png\")
<\/p>\nPrivate Sub <\/span>objDatasheetForm_Click(ctl As <\/span>Control, _\r\n varPKValue)\r\n Me!txtAktion = \"Click\"\r\n If <\/span>Not<\/span> ctl Is Nothing Then<\/span>\r\n Me!txtControl = ctl.Name\r\n Else<\/span>\r\n Me!txtControl = \"Form\"\r\n End If<\/span>\r\n Me!txtPKWert = varPKValue\r\nEnd Sub<\/span><\/pre>\nTechnische Informationen zur Klasse clsDatasheetForm<\/h2>\n
![\"Schema](\"..\/fileadmin\/_temp_\/2015_05\/pic_999_003.png\")
<\/p>\nCode der Klasse clsDatasheetForm<\/h2>\n
Private <\/span>WithEvents m_Form As <\/span>Access.Form\r\nPrivate <\/span>colControls As <\/span>Collection\r\nPrivate <\/span>m_PrimaryKey As String<\/span>\r\nPrivate <\/span>m_SelectRow As Boolean<\/span><\/pre>\nDim <\/span>m_DataSheetControl As <\/span>clsDatasheetControl<\/pre>\nPublic <\/span>Event DblClick(ctl As <\/span>Control, varPKValue As Variant<\/span>)\r\nPublic <\/span>Event MouseDown(ctl As <\/span>Control, varPKValue As Variant<\/span>)\r\nPublic <\/span>Event MouseUp(ctl As <\/span>Control, varPKValue As Variant<\/span>)\r\nPublic <\/span>Event Click(ctl As <\/span>Control, varPKValue As Variant<\/span>)<\/pre>\nPublic Property Set<\/span> <\/span>DatasheetForm(frm As <\/span>Form)\r\n Dim <\/span>ctl As <\/span>Control\r\n Set<\/span> m_Form = frm\r\n With<\/span> m_Form\r\n .OnMouseDown = \"[Event Procedure]\"\r\n .OnMouseUp = \"[Event Procedure]\"\r\n .OnClick = \"[Event Procedure]\"\r\n .OnDblClick = \"[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>acTextBox, acComboBox, acListBox, acCheckBox\r\n Set<\/span> m_DataSheetControl = New<\/span> clsDataSheetControl\r\n With<\/span> m_DataSheetControl\r\n Set<\/span> .DataSheetControl = ctl\r\n Set<\/span> .DataSheetForm = Me\r\n .SelectRowOnClick = m_SelectRow\r\n End With<\/span>\r\n colControls.Add m_DataSheetControl\r\n End Select<\/span>\r\n Next<\/span> ctl\r\nEnd Property<\/span><\/pre>\nZeile markieren oder nicht<\/h2>\n
Public Property Let <\/span>SelectRowOnClick(bol As Boolean<\/span>)\r\n Dim <\/span>objDatasheetcontrol As <\/span>clsDataSheetControl\r\n m_SelectRow = bol\r\n For Each objDatasheetcontrol In colControls\r\n objDatasheetcontrol.SelectRowOnClick = m_SelectRow\r\n Next<\/span> objDatasheetcontrol\r\nEnd Property<\/span><\/pre>\nPublic Property Let <\/span>PrimaryKey( str As String<\/span>)\r\n m_PrimaryKey = str\r\nEnd Property<\/span><\/pre>\nPrivate Sub <\/span>m_Form_Click()\r\n If <\/span>Not<\/span> Len<\/span>(m_PrimaryKey) = 0 Then<\/span>\r\n RaiseEvent Click(Nothing, m_Form.Controls(m_PrimaryKey))\r\n Else<\/span>\r\n RaiseEvent Click(Nothing, Null)\r\n End If<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>m_Form_DblClick(Cancel As Integer<\/span>)\r\n If <\/span>Not<\/span> Len<\/span>(m_PrimaryKey) = 0 Then<\/span>\r\n RaiseEvent DblClick(Nothing, m_Form.Controls(m_PrimaryKey))\r\n Else<\/span>\r\n RaiseEvent DblClick(Nothing, Null)\r\n End If<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>m_Form_MouseDown(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n If <\/span>Not<\/span> Len<\/span>(m_PrimaryKey) = 0 Then<\/span>\r\n RaiseEvent MouseDown(Nothing, m_Form.Controls(m_PrimaryKey))\r\n Else<\/span>\r\n RaiseEvent MouseDown(Nothing, Null)\r\n End If<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>m_Form_MouseUp(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n If <\/span>Not<\/span> Len<\/span>(m_PrimaryKey) = 0 Then<\/span>\r\n RaiseEvent MouseUp(Nothing, m_Form.Controls(m_PrimaryKey))\r\n Else<\/span>\r\n RaiseEvent MouseUp(Nothing, Null)\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>Click(ctl As <\/span>Control)\r\n If <\/span>Not<\/span> Len<\/span>(m_PrimaryKey) = 0 Then<\/span>\r\n RaiseEvent Click(ctl, m_Form.Controls(m_PrimaryKey))\r\n Else<\/span>\r\n RaiseEvent Click(ctl, Null)\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nDie Klasse clsDatasheetControl<\/h2>\n
Private <\/span>WithEvents m_TextBox As <\/span>Access.TextBox\r\nPrivate <\/span>WithEvents m_ListBox As <\/span>Access.Listbox\r\nPrivate <\/span>WithEvents m_ComboBox As <\/span>Access.ComboBox\r\nPrivate <\/span>WithEvents m_CheckBox As <\/span>Access.CheckBox<\/pre>\nPrivate <\/span>m_DataSheetForm As <\/span>clsDataSheetForm<\/pre>\nPrivate <\/span>m_SelectRow As Boolean<\/span><\/pre>\nEntgegennehmen der Steuerelemente<\/h2>\n
Public Property Set<\/span> <\/span>DatasheetControl(ctl As <\/span>Control)\r\n Select Case ctl.ControlType\r\n Case <\/span>acTextBox\r\n Set<\/span> m_TextBox = ctl\r\n m_TextBox.OnMouseDown = \"[Event Procedure]\"\r\n m_TextBox.OnMouseUp = \"[Event Procedure]\"\r\n m_TextBox.OnDblClick = \"[Event Procedure]\"\r\n m_TextBox.OnClick = \"[Event Procedure]\"\r\n Case <\/span>acComboBox\r\n Set<\/span> m_ComboBox = ctl\r\n m_ComboBox.OnMouseDown = \"[Event Procedure]\"\r\n m_ComboBox.OnMouseUp = \"[Event Procedure]\"\r\n m_ComboBox.OnDblClick = \"[Event Procedure]\"\r\n m_ComboBox.OnClick = \"[Event Procedure]\"\r\n Case <\/span>acListBox\r\n Set<\/span> m_ListBox = ctl\r\n m_ListBox.OnMouseDown = \"[Event Procedure]\"\r\n m_ListBox.OnMouseUp = \"[Event Procedure]\"\r\n m_ListBox.OnDblClick = \"[Event Procedure]\"\r\n m_ListBox.OnClick = \"[Event Procedure]\"\r\n Case <\/span>acCheckBox\r\n