VBA Gestion des événements dans une Interface implémentée par plusieurs classes de TextBox

Version imprimable

Bonjour,

Je suis en train de créer une interface pour me simplifier la vie.
Celle-ci servira à contrôler les saisies dans les TextBox de mon Userform.
Pour cela, je me suis grandement inspiré de ce post
Pour l'exemple, on va considérer deux traitements différents, les TextBox impairs = numéro de sécurité sociale, les pairs : majuscules uniquement.
Voici mon code actuel :
Code de l'UserForm :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
Option Explicit
 
    Dim TB_SS(30) As New cSecuSociale
    Dim WithEvents TBevent_SS As cSecuSociale
 
    Dim TB_NOMS(30) As New cMajuscules
    Dim WithEvents TBevent_Nom As cMajuscules
 
    Private Sub UserForm_Initialize()
    Dim Ctrl As Control, i As Byte
        For Each Ctrl In Me.Controls
             If TypeOf Ctrl Is MSForms.TextBox Then
                If i Mod 2 = 0 Then
                    Set TBevent_SS = New cSecuSociale
                    TB_SS(i).Add TBevent_SS, Ctrl
                Else
                    Set TBevent_Nom = New cMajuscules
                    TB_NOMS(i).Add TBevent_Nom, Ctrl
                End If
                i = i + 1
            End If
        Next Ctrl
    End Sub
 
    Private Sub UserForm_Terminate()
        Erase TB_SS
        Erase TB_NOMS
    End Sub

L'interface nommée ITextbox :

Code:

1
2
3
4
5
6
Option Explicit
 
    Public Sub OnKeyDown(TextBox As MSForms.TextBox, KeyCode As MSForms.ReturnInteger, Shift As Integer)
    End Sub
    Public Sub OnKeyPress(TextBox As MSForms.TextBox, ByVal KeyAscii As MSForms.ReturnInteger)
    End Sub

Module de classe cSecuSociale

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
Option Explicit
 
Implements ITextBox
    Private WithEvents T_Bx As MSForms.TextBox
    Private T_Appel As ITextBox
    Event KeyDown(TextBox As MSForms.TextBox, KeyCode As MSForms.ReturnInteger, Shift As Integer)
 
    Public Sub Add(HEvent As cSecuSociale, TBox As MSForms.TextBox)
        If Not HEvent Is Nothing And Not TBox Is Nothing Then
            If T_Appel Is Nothing Then Set T_Appel = HEvent
            If T_Bx Is Nothing Then
                Set T_Bx = TBox
            End If
        End If
    End Sub
    Private Sub ITextBox_OnKeyDown(TextBox As MSForms.IMdcText, KeyCode As MSForms.ReturnInteger, Shift As Integer)
        Select Case KeyCode
            Case 96 To 105  'chiffres pavé numérique
                If Shift = 1 Then KeyCode = 0
                If Len(TextBox.Text) = 15 Then KeyCode = 0
            Case 48 To 57   'chiffre touches clavier alphanumérique
                If Shift = 0 Then KeyCode = 0
                If Len(TextBox.Text) = 15 Then KeyCode = 0
            Case 8, 9, 16, 46  'touches retour arrière, TAB, Shift, Suppr
                'action à voir
            Case Else
                KeyCode = 0
        End Select
    End Sub
 
    Private Sub T_Bx_KeyDown(ByVal KeyCode As MSForms.ReturnInteger, ByVal Shift As Integer)
        Call T_Appel.OnKeyDown(T_Bx, KeyCode, Shift)
    End Sub
 
    Private Sub ITextBox_OnKeyPress(TextBox As MSForms.IMdcText, ByVal KeyAscii As MSForms.ReturnInteger)
    End Sub

Module de classe cMajuscules

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
Option Explicit
 
Implements ITextBox
 
    Private WithEvents T_Bx As MSForms.TextBox
    Private T_Appel As ITextBox
 
    Event KeyPress(TextBox As MSForms.TextBox, KeyAscii As MSForms.ReturnInteger)
 
    Public Sub Add(HEvent As cMajuscules, TBox As MSForms.TextBox)
        If Not HEvent Is Nothing And Not TBox Is Nothing Then
            If T_Appel Is Nothing Then Set T_Appel = HEvent
            If T_Bx Is Nothing Then Set T_Bx = TBox
        End If
    End Sub
 
    Private Sub ITextBox_OnKeyPress(TextBox As MSForms.IMdcText, ByVal KeyAscii As MSForms.ReturnInteger)
        Select Case KeyAscii
            Case 32 'espace
                KeyAscii = 0
            Case 45  'trait d'union
                If Len(TextBox.Text) = 0 Then KeyAscii = 0
            Case 65 To 90 'majuscules
            Case 97 To 122 'minuscules
                KeyAscii = KeyAscii - 32
            Case Else
                KeyAscii = 0
        End Select
    End Sub
 
    Private Sub T_Bx_KeyPress(ByVal KeyAscii As MSForms.ReturnInteger)
        Call T_Appel.OnKeyPress(T_Bx, KeyAscii)
    End Sub
 
    Private Sub ITextBox_OnKeyDown(TextBox As MSForms.IMdcText, KeyCode As MSForms.ReturnInteger, Shift As Integer)
    End Sub

Au départ, avant de me lancer dans ce projet, j'imaginais créer, depuis l'userForm, une unique variable tableau globale de type ITextbox qui comprendrait tous mes textbox.
Puis, la répartition entre chaque type de classe se serait faite dans l'initialize.
En "faux code", voici ce que j'imaginais faire et qui (bien entendu) ne fonctionne pas :
Faux code de l'UserForm :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Option Explicit
 
    Dim TB(30) As ITextbox
 
    Private Sub UserForm_Initialize()
    Dim Ctrl As Control, i As Byte
        For Each Ctrl In Me.Controls
             If TypeOf Ctrl Is MSForms.TextBox Then
                If T Mod 2 = 0 Then
                    Set TB(i) = New cSecuSociale
                    TB(i).Add Ctrl
                Else
                    Set TB(i) = New cMajuscules
                    TB(i).Add Ctrl
                End If
                i = i + 1
            End If
        Next Ctrl
    End Sub
 
    Private Sub UserForm_Terminate()
        Erase TB
    End Sub

Pensez-vous cela réalisable tout de même?
Parce qu'en fait, à terme, je vais avoir une dizaine de "types" de textbox, donc une dizaine de classes et donc, une dizaine de variables tableaux à déclarer dans l'UserForm...

26/04/2016, 11h50
cerede2000

Bonjour à toi,

Réalisable oui, ce que tu à mit ici me parait correct.
En VBA l'héritage est ultra limité !

Mais en fait ton tableau de contrôles n'as pas besoin d'être typés avec l'interface ;)
Soit tu le laisse en Variant soit tu le type en MSForm control ou textbox

Mais comme tu fais le traitement de chaque type de textbox dans leur classe respective pas de soucis ;)

On pourrais du coup se passer de l'interface qui n'apporte par forcément grand chose, et au niveau des events VBA est-ce que ça va fonctionner... A tester
26/04/2016, 12h16
pijaku

Bonjour cerede,

Merci de ta réponse.
Bon :

Citation:

Mais en fait ton tableau de contrôles n'as pas besoin d'être typés avec l'interface
Soit tu le laisse en Variant soit tu le type en MSForm control ou textbox

J'aimerais faire les choses bien (pour une fois :D), donc Variant = Non, Control non plus.
Pourquoi pas MsForms.Textbox, en effet ça me convient mieux.

Citation:

On pourrais du coup se passer de l'interface qui n'apporte par forcément grand chose

Alors, c'est ce que je me dit de plus en plus.
Cependant, je voulais intégrer, à cette Interface, des méthodes (avec du code donc, pas uniquement le "titre d'une fonction).
Celles-ci seraient communes à toutes mes classes.
Ceci, dans le but de ne pas les répéter dans chacun des modules de classe.
Et c'est là ou je bloque complètement.

Citation:

et au niveau des events VBA est-ce que ça va fonctionner

Pour tout te dire, je teste ça au fur et à mesure, coup par coup...
Pour l'instant ça à l'air de fonctionner, avec même quelques petites surprises à la clé.
26/04/2016, 13h03
cerede2000

Citation:

Cependant, je voulais intégrer, à cette Interface, des méthodes (avec du code donc, pas uniquement le "titre d'une fonction).
Celles-ci seraient communes à toutes mes classes.
Ceci, dans le but de ne pas les répéter dans chacun des modules de classe.
Et c'est là ou je bloque complètement.

Ca tu peux oublier !

Impossible en VBA :mouarf:
L'interface en sert que de squelette en fait et c'est tout :(
Moi aussi au début, venant de Java je voulais faire des supers trucs bien construit en VBA, puis j'ai vite déchanté :aie:
26/04/2016, 13h18
pijaku

Citation:

L'interface en sert que de squelette en fait et c'est tout

Donc elle est inutile.
Je vais essayer de typer mon tableau As MSForms.TextBox.
Je reviens après mes essais.
26/04/2016, 13h47
pijaku

Pour le coup, j'en sors extrêmement déçu.
En fait, un unique module de classe suffit pour faire tout ce que je souhaites.
Mais, pour le coup, c'est beaucoup moins élégant que ce que j'imaginais au départ.

Si quelqu'un a d'autres pistes sur le sujet, je reste preneur.

Merci encore.
26/04/2016, 13h50
cerede2000

Hé oui VBA commence à mon gout largement à daté de ce côté là.
J'aurais aimer que MS prenne un virage qui lui permette d'évoluer vers quelque chose plus proche du C# avec une ouverture .Net ça serai super top !

En effet, un seul module de classe avec quelque méthode spécifique aux traitement de chaque textbox suffit ;)
Après tu peux gérer une enum pour le type de textbox comme ça tu sait facilement le traitement à lui appliquer dans ta classe ;)
26/04/2016, 20h59
clementmarcotte

Bonjour,

Citation:

Envoyé par pijaku

Si quelqu'un a d'autres pistes sur le sujet, je reste preneur.

Merci encore.

Visual Studio Community est gratuit. (Visual Studio Express aussi, mais il trop infirme pour convenir). Avec cela tu peux utiliser VB.net (ou même C#), avec la dernière version de "Visual Studio Tools For Office" pour te créer un complément pour Excel. En fait ce n'est plus VSTO, mais cela revient au même. Faut télécharger, installer et apprendre; mais cela ouvre la porte à la POO et à l'héritage et aussi à WPF. On parle d'être à des milles d'avance sur VBA
27/04/2016, 08h48
pijaku

Bonjour,

@ clementmarcotte :

Citation:

Avec cela tu peux utiliser VB.net (ou même C#), avec la dernière version de "Visual Studio Tools For Office" pour te créer un complément pour Excel.

Cette proposition est intéressante.
Cependant, ma démarche n'est ici nullement professionnelle.
Je ne suis qu'un amateur, je bricole en VBA, en autodidacte, pour le plaisir et celui d'aider d'autres internautes, c'est tout.
Pour tout te dire, la notion même de classe est, pour moi, encore très floue car un peu trop abstraite.
Je ne la comprends pas suffisamment pour travailler avec en VBA, alors je ne te raconte pas la galère que représenterai, pour moi, le passage à VB.net!

De plus, il me semble que créer un complément pour Excel nécessitera d'installer ce complément sur tous les pc qui utiliseront le fichier.
L'ajout de classes ne gênant en rien la transportabilité, j'ai cru bon privilégier cet aspect.

@cerede2000 :

Citation:

Hé oui VBA commence à mon goût largement à dater de ce côté là.
J'aurais aimé que MS prenne un virage qui lui permette d'évoluer vers quelque chose plus proche du C# avec une ouverture .Net ça serai super top !

Il faut savoir également que MS se garde bien de tout nous dire ;)
Il existe pas mal de secrets chez MS, notamment en VBA, qui permettent de réaliser des choses s'approchant (toujours de loin, bien sur, on est d'accord) à ce que l'on pourrait faire avec un vrai langage de développement.
MS développe, en effet, des propriétés cachées, des Attribute cachés également, sortes de compresses qui, appliquées sur la "jambe de bois" de notre VBA_Pinnochio, lui donnent un peu de vie.
Il est possible, à titre d'exemples (et je ne digresserai pas davantage sur le premier) :
- de connaitre le Handle d'un contrôle placé sur un UserForm sans lui attribuer le focus,
- d' "implémenter" les événements Exit, Enter, BeforeUpdate, AfterUpdate, de contrôles dynamiques,
- de réaliser une "vraie" interface contenant des méthodes.

Sur ce dernier point, je dois préalablement tester ma petite découverte d'hier avant de vous livrer un quelconque résultat.
Il est (fort) probable, que je me sois trompé, et qu'au final l'interface que je pense avoir conçu n'en est pas une.
Je compte sur le forum pour me dire ce qu'il en est. C'est pourquoi, je reviendrais vous poster un code d'ici peu, le temps de quelques tests.

Merci encore à toutes et tous.

Suite à cette saine lecture, voici le code que je vous propose :

Module de classe TextBoxCollection.cls :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
'Création Collection :
    Dim myCollection As Collection
 
    Private Sub Class_Initialize()
        Set myCollection = New Collection
    End Sub
 
    Public Sub Class_Terminate()
        Set myCollection = Nothing
    End Sub
 
    Public Sub Add(ByVal Item As Variant, MyCtrl As Control)
        myCollection.Add Item
        If Item.T_Bx Is Nothing Then
            Set Item.T_Bx = MyCtrl
            Set Item.Parent = New ITextBox
        End If
    End Sub

Module de classe Interface ITextBox.cls :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
Option Explicit
 
'http://www.developpez.net/forums/d636773-2/logiciels/microsoft-office/general-vba/polymorphisme-implementation/#post4801023
 
    Public Sub OnKeyDown(TextBox As MSForms.TextBox, KeyCode As MSForms.ReturnInteger, Shift As Integer)
        Select Case KeyCode
            Case 96 To 105  'chiffres pavé numérique
                If Shift = 1 Then KeyCode = 0
                If Len(TextBox.Text) = 15 Then KeyCode = 0
            Case 48 To 57   'chiffre touches clavier alphanumérique
                If Shift = 0 Then KeyCode = 0
                If Len(TextBox.Text) = 15 Then KeyCode = 0
            Case 8, 9, 16, 46  'touches retour arrière, TAB, Shift, Suppr
                'action à voir
            Case Else
                KeyCode = 0
        End Select
    End Sub
 
    Public Sub OnKeyPress(TextBox As MSForms.IMdcText, ByVal KeyAscii As MSForms.ReturnInteger)
        Select Case KeyAscii
            Case 32 'espace
                KeyAscii = 0
            Case 45  'trait d'union
                If Len(TextBox.Text) = 0 Then KeyAscii = 0
            Case 65 To 90 'majuscules
            Case 97 To 122 'minuscules
                KeyAscii = KeyAscii - 32
            Case Else
                KeyAscii = 0
        End Select
    End Sub

Module de classe cSecuSociale.cls :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Option Explicit
 
Implements ITextBox
 
    Event KeyDown(TextBox As MSForms.TextBox, KeyCode As MSForms.ReturnInteger, Shift As Integer)
 
    Public WithEvents T_Bx As MSForms.TextBox
    Public Parent As ITextBox
 
    Private Sub T_Bx_KeyDown(ByVal KeyCode As MSForms.ReturnInteger, ByVal Shift As Integer)
        Call Parent.OnKeyDown(T_Bx, KeyCode, Shift)
    End Sub
 
    Private Sub ITextBox_OnKeyPress(TextBox As MSForms.IMdcText, ByVal KeyAscii As MSForms.ReturnInteger)
    End Sub
    Private Sub ITextBox_OnKeyDown(TextBox As MSForms.TextBox, KeyCode As MSForms.ReturnInteger, Shift As Integer)
    End Sub

Module de classe cMajuscules.cls :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Option Explicit
 
Implements ITextBox
 
    Event KeyPress(TextBox As MSForms.TextBox, KeyAscii As MSForms.ReturnInteger)
 
    Public WithEvents T_Bx As MSForms.TextBox
    Public Parent As ITextBox
 
    Private Sub T_Bx_KeyPress(ByVal KeyAscii As MSForms.ReturnInteger)
        Call Parent.OnKeyPress(T_Bx, KeyAscii)
    End Sub
 
    Private Sub ITextBox_OnKeyDown(TextBox As MSForms.IMdcText, KeyCode As MSForms.ReturnInteger, Shift As Integer)
    End Sub
 
    Private Sub ITextBox_OnKeyPress(TextBox As MSForms.IMdcText, ByVal KeyAscii As MSForms.ReturnInteger)
    End Sub

Code de l'UserForm

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
Option Explicit
 
    Dim TB As New TextBoxCollection
 
    Private Sub UserForm_Initialize()
    Dim Ctrl As Control, i As Integer
    Dim TB_SS() As New cSecuSociale, Cpt_SS As Integer
    Dim TB_M() As New cMajuscules, Cpt_M As Integer
 
        For Each Ctrl In Me.Controls
             If TypeOf Ctrl Is MSForms.TextBox Then
                If i Mod 2 = 0 Then
                    ReDim Preserve TB_SS(Cpt_SS)
                    TB.Add TB_SS(Cpt_SS), Ctrl
                    Cpt_SS = Cpt_SS + 1
                Else
                    ReDim Preserve TB_M(Cpt_M)
                    TB.Add TB_M(Cpt_M), Ctrl
                    Cpt_M = Cpt_M + 1
                End If
                i = i + 1
            End If
        Next Ctrl
    End Sub
 
    Private Sub UserForm_Terminate()
        Set TB = Nothing
    End Sub

EDIT :
On retrouve bien, dans ces codes :
- l'interface (mots clés Implements, déclaration des fonctions obligatoires)
- la possibilité de placer des méthodes dans une Interface.
Mais, comme dit précédemment, je me trompe surement...

27/04/2016, 10h27
cerede2000

Pas mal du tout :)
Ca fonctionne correctement ?

:plusser: !
27/04/2016, 10h30
pijaku

Citation:

Pas mal du tout

Merci !

Citation:

Ca fonctionne correctement ?

Pour l'instant, mes tests tendent à dire que oui.

Mais, comme je l'ai dit, je suis totalement autodidacte en matière de programmation et VBA est le seul langage que je connaisse.
Par conséquent, savoir si ici on peut parler d'interface, ou de polymorphisme ou de simple "béquille", je ne saurais pas le dire...
03/05/2016, 13h20
pijaku
Bonjour,

Je me heurte à une difficulté complémentaire.
Pour l'exemple, je dispose de deux classes qui implémentent une Interface.
Dans cette interface, je dispose d'événements, de méthodes etc...
Je voudrais que, selon la classe qui "interpelle" l'interface, celle-ci appelle une méthode de la classe "appelante".
Est ce clair? et si oui, est ce possible?
Merci

EDIT :
pour essayer d'éclaircir la question, il me faudrait un code comme celui-ci :
Code:

1 2 Dim class As New Classe1 Call class.MethodeX
Ou Classe1 pourrait être variable...

Je suis parvenu à mes fins en ajoutant une énumération des types de classe de textbox et une propriété dans l'interface.
Propriété :

Code:

Private cType As eTypes

énumération :
Code:

1 2 3 4 5 Public Enum eTypes Classe_1 Classe_2 Classe_3 End Enum
la procédure d'appel de la méthode selon la classe :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Private Sub MonEvent() Dim Cl As Variant Set Cl = QuelleClasse(cType) Call Cl.maMethode() Set Cl = Nothing End Sub Public Function QuelleClasse(Typ As eTypes) As Variant Select Case Typ Case 1 Set QuelleClasse = New Classe1 Case 2 Set QuelleClasse = New Classe2 Case 3 Set QuelleClasse = New Classe3 End Select End Function
J'arrive maintenant au bout de mon projet, cela semble bien se dérouler.
Le but est de créer des classes de TextBox afin de contrôler leur saisie en cours de saisie et leur contenu lors de la sortie.
Cela nécessite d'implémenter pour des textbox dynamiques, les événements non pris en charge (enter, exit, before et afterUpdate).
Afin de simplifier le travail de l'utilisateur, j'ai :
> utilisé une Interface pour créer les 4 événements (on n'a plus à y toucher)
> inséré un module "standard" pour gérer l'énumération
> créé plusieurs classes de textbox, pour l'exemple.

Mon classeur de test semble fonctionner tout à fait correctement.
Ne me reste plus qu'à gérer le cas de textbox dans un conteneur (page ou frame).

Si cela vous intéresse, n'hésitez pas à m'en faire part, je reviendrais à ce moment vers vous...

10/05/2016, 14h30
pijaku

Une interface capable de gérer tous types de saisie dans les textbox d'un userform

Bonjour,

Voici la démarche qui m'a poussé à poursuivre ce projet.

En cherchant à intercepter les événement Exit et Enter de textbox construit dynamiquement, je suis tombé sur une solution utilisant l'API ConnectToConnectionPoint SOURCE . La solution de sylkiroad sur DVP ne me convenait pas car beaucoup trop gourmande en ressources...
En faisant mes tests sur un UserForm, je me suis rendu compte que la plus grande difficulté de maintenance de cette méthode réside dans les Attribute VB_UserMemId cachés.
En effet, à chaque copié-collé du module de classe, à chaque suppression, le risque est grand de supprimer cet attribut indispensable au fonctionnement.

De là, je suis parti à la recherche d'une solution qui permettrait d'éviter ces "accidents".
Je suis tombé sur ce tutoriel expliquant le principe de l'interface.
En creusant un peu (Source 1 --- Source 2), j'ai trouvé l'idée assez sympa de pouvoir bénéficier :
> d'une classe gérant les procédures communes (l'interface iTextBox dans le classeur joint)
> d'une classe par type de textbox (les classes cSecuSSociale et cMajuscules dans le classeur joint)
Ainsi, l'on peut facilement gérer les différents types de saisie possible et imaginable dans un userForm.
Il suffit, pour cela, d'insérer un nouveau module de classe (cf module de classe Modele dans le classeur joint), et d'y placer les contrôles souhaités en sortie, en entrée ou dans les événements normalement gérés par ce type de contrôle.

Pièce jointe 209247

Voici donc le résultat.
Merci de bien vouloir me donner vos avis à ce sujet.
Tant au niveau du fond que de la forme du code.

A++
12/05/2016, 12h07
pijaku

Contribution

Bonjour,

Pour celles et ceux qui ne souhaitent pas télécharger les fichiers contenant des macros (je les comprends), je vous ai bricolé une petite contribution disponible ICI.