Création d’OCX – Les Mrd Trucs

1) Création d'un nouveau Projet ActiveX.

Tout d’abord, commencez par créer un nouveau projet en faisant FICHIER|NOUVEAU Projet|Contrôle ActiveX & OK

Vous vous trouvez à présent dans l’espace de création de contrôle ActiveX, le projet, qui porte pour l’instant le nom de projet1. Nous allons lui donner un nom qui permettra de l’identifier lors de son ouverture ou sa recherche sur le disque dur. Cliquez dans l’explorateur de Projet sur Projet1(Projet1), la Fenêtre des propriétés affiche maintenant un tableau avec la propriété (NAME) qui contient la valeut Projet1, faite un double-clique sur Projet1 et Entrez le nouveau nom du projet: « DefileZone » sans espace ni caractère particulier.

Dans ce projet, nous allons créer un contrôle qui servira à faire défiler du texte selon plusieurs options que l’utilisateur pourra modifier (Direction du défilement, Texte à afficher, Couleur de fond, du texte, ?). Pour créer le contrôle, il nous faut une fenêtre vide, Visual Basic en a créé une pour vous, elle se nomme UserControl1, nous allons renommer ce contrôle pour mieux l’identifier parmi tous les autres que possède déjà Visual Basic, pour cela, cliquez dans l’explorateur de projet sur UserControl1 (UserControl1) et modifier la propriété (NAME) pour qu’elle affiche DefileText, en effet, le nom du contrôle doit être différent de celui du projet.

Maintenant que le projet et le contrôle sont initialisés, il est conseillé de les enregistrer, faites donc un clic sur la disquette, une fenêtre d’enregistrement s’affiche, choisissez un répertoire et créez en un nouveau que vous appelez DefileZone, vous y enregistrer le contrôle qui prend l’extension .ctl et le Projet .vbp en cliquant sur Enregistrer à deux reprises. Dès maintenant, lorsque vous verrez ce symbole vous enregistrerez votre projet pour ne pas perdre les données (Panne ou plantage?) Voilà le projet créé, nous allons maintenant passer à la création du modèle.

2) La création du contrôle.

Plaçons les contrôle dont nous aurons besoins pour réaliser notre DefileText, placez donc un Label et un timer, peux importe la taille que vous donnez au label, mais placez le aux coordonnées (0,0), soit manuellement en maintenant le bouton de la souris enfoncé et en déplaçant le pointeur, soit dans la fenêtre des propriétés, en mettant les propriétés TOP et LEFT à 0. Réglez aussi le nom du label à « Dtext » et le nom du timer à « Dtimer », question de s’y retrouver si on ajoutait des timers et des labels. Voilà, les contrôles dont nous aurons besoins sont placés, nous allons entrer le code en commençant par celui qui va régler automatiquement la taille du lable, nous allons donc allez dans l’événement Resize du contrôle, double-cliquez sur le fond gris du contrôle, vous arrivez dans la page de code de celui-ci., dans l’événement UserControl_Initialize() , choisissez Resize dans la liste déroulante en haut à droite, vous voilà alors dans l’événement UserControl_Resize() qui va nous permettre de régler la taille du label. Il n’y a que deux possibilité, soit la taille du contrôle est réglée par l’utilisateur, soit il prend la taille du label, le choix se fera en fonction de la propriété AutoSize du Label que l’utilisateur pourra modifier, voici le code en détail:

Private Sub
    UserControl_Resize()
   If Dtext.AutoSize = True Then
        ‘La largeur du contrôle devient la largeur du Dtext
        UserControl.Width = Dtext.Width
        ‘La hauteur du contrôle devient la heuteur du Dtext
        UserControl.Height = Dtext.Height
   End If
End Sub

Après le code de redimensionnement, il nous reste encore à programmez le Timer et à le configurer pour qu’il décale le texte dans une des 4 directions puis le fasse revenir par le côté opposé pour qu’il défile. Il va donc falloir que nous tenions compte de plusieurs arguments: la direction et la vitesse. Nous allons donc créer 2 variables grâce aux lignes de code placées tout en haut de la page de code (Car les déclarations publiques doivent se trouver dans les première lignes de code):

Public Direction As String ‘Direction est une chaine de caractère donc String
Public Speed As Integer ‘Speed est un nombre de point, donc Integer

Les variables sont déclarées et commentées, donc nous allons nous occuper du Timer, en commençant par régler ses propriétés, réglez donc Enabled sur False et Interval sur 100, cela signifie que le timer sera désactivé par défaut et qu’il agira toutes les 100 millisecondes. Faites ensuite un double-clique sur le Timer pour passez en mode codage, vous arrivez dans l’événement DTimer_Timer(), tout ce qui se trouve dans cet événement se déclanchera toutes les 100 millisecondes si le Timer est Enabled (Activé). Nous allons utiliser le code suivant pour le défilement:

Private Sub DTimer_Timer()
    If Direction = « right » Then
        ‘On place le curseur en haut du contrôle
        DText.Top = 0
        ‘On décale Dtext de Speed vers la droite
        DText.Left = DText.Left + Speed
        ‘Si Dtext sort de l’écran, on le remet à droite de l’écran
        If DText.Left > UserControl.Width Then DText.Left = -DText.Width
   ElseIf Direction = « left » Then
        ‘On place le curseur en haut du contrôle
        DText.Top = 0
        ‘On décale Dtext de Speed vers la gauche
        DText.Left = DText.Left – Speed
        ‘Si Dtext sort de l’écran, on le remet à gauche de l’écran
        If DText.Left + DText.Width < 0 Then DText.Left = UserControl.Width
   ElseIf Direction = « top » Then
        ‘On place le curseur à gauche du contrôle
        DText.Left = 0
        ‘On décale Dtext de Speed vers le haut
        DText.Top = DText.Top – Speed
        ‘Si Dtext sort de l’écran, on le remet en bas de l’écran
        If DText.Top + DText.Height < 0 Then DText.Top = UserControl.Height
   ElseIf Direction = « bottom » Then
        ‘On place le curseur à gauche du contrôle
        DText.Left = 0
        ‘On décale Dtext de Speed vers le bas
        DText.Top = DText.Top + Speed
        ‘Si Dtext sort de l’écran, on le remet en haut de l’écran
        If DText.Top > UserControl.Height Then DText.Top = -DText.Height
   End If
End Sub

Et voilà, le contrôle en lui-même est terminé.

3) Les propriétés.

Nous allons passer à la création des propriétés auxquelles l’utilisateur pourra accéder. Nous allons les déclarer publiques pour l’envoie et la réception de valeurs, grâce à GET et LET. La première propriété à laquelle l’utilisateur doit accéder est le texte du Dtext, nous allons simplement appeler cette propriété Text, voici les deux Properties que nous allons ajouter à la suite du code, donc tout en bas (Ceci n’est pas une obligation mais il vaut mieux respecter toujours le même ordre pour s’y retrouver: Code, Propriétés, Méthodes, Fonctions, Evénements). Donc nous allons créer la propriété Text avec les lignes de codes suivantes:

Public Property Get Text() As String
‘Text renvoie le caption du Dtext
Text = DText.Caption
End Property

Public Property Let Text(ByVal New_text As String)
   ‘DText prend la caption que l’utilisateur envoie
   DText.Caption = New_text
   ‘Pour que le label prenne la taille du texte on le met pendant un instant en AutoSize = True
   ‘Puis on remet la valeur d’origine à AutoSize
   avant = DText.AutoSize: DText.AutoSize = True: DText.AutoSize = avant
   ‘On indique le changement au programme
   PropertyChanged « text »
End Property

Nous allons faire le même pour les autres propriétés: Direction, Speed, mais aussi BackColor, ForeColor, Font, AutoSize et ToolTipText:

‘Pour BackColor
Public Property Get BackColor() As OLE_COLOR
BackColor = DText.BackColor
End Property

Public Property Let BackColor(ByVal New_BackColor As OLE_COLOR)
   DText.BackColor = New_BackColor
   UserControl.BackColor = New_BackColor
   PropertyChanged « BackColor »
End Property

‘Pour ForeColor
Public Property Get ForeColor() As OLE_COLOR
ForeColor = DText.ForeColor
End Property

Public Property Let ForeColor(ByVal New_ForeColor As OLE_COLOR)
DText.ForeColor = New_ForeColor
PropertyChanged « ForeColor »
End Property

‘Pour ToolTipText
Public Property Get ToolTipText() As String
ToolTipText = DText.ToolTipText
End Property

Public Property Let ToolTipText(ByVal New_ToolTipText As String)
DText.ToolTipText = New_ToolTipText
PropertyChanged « ToolTipText »
End Property

‘Pour Font
Public Property Get Font() As Font
Set Font = DText.Font
End Property

Public Property Set Font(ByVal New_Font As Font)
Set DText.Font = New_Font
PropertyChanged « Font »
End Property

‘Pour AutoSize
Public Property Get AutoSize() As Boolean
AutoSize = DText.AutoSize
End Property

Public Property Let AutoSize(ByVal New_AutoSize As Boolean)
DText.AutoSize = New_AutoSize
PropertyChanged « AutoSize «
End Property

Les propriétés sont maintenant presque terminées. En effet elles ne sont pas mémorisées lors du lancement du programme, donc nous allons les enregistrer en mémoire grâce à la méthode UserControl_WriteProperties. Nous devons créer un sac de propriété et y enregistrer toutes les valeurs, en spécifiant le nom de la propriété. La valeur et la valeur par défaut:

Private Sub UserControl_WriteProperties(PropBag As PropertyBag)
   ‘On utilise le sac de propriétés PropBag et on y enregistre les propriétés et leurs valeurs
   Call PropBag.WriteProperty(« Direction », Direction, « right »)
   Call PropBag.WriteProperty(« Speed », Speed, 12)
   Call PropBag.WriteProperty(« BackColor », UserControl.BackColor, &H8000000F)
   Call PropBag.WriteProperty(« ForeColor », DText.ForeColor, &H80000012)
   Call PropBag.WriteProperty(« ToolTipText », DText.ToolTipText, «  »)
   Call PropBag.WriteProperty(« Text », DText.Caption, «  »)
   Call PropBag.WriteProperty(« AutoSize », DText.AutoSize, False)
   Call PropBag.WriteProperty(« Font », DText.Font, Ambient.Font)
End Sub

L’étape suivante consiste à lire les prpriétés lors du chargement du contrôle, cette fois grâce à UserControl_ReadProperties:

Private Sub UserControl_ReadProperties(PropBag As PropertyBag)
   Direction = PropBag.ReadProperty(« Direction », « right »)
   Speed = PropBag.ReadProperty(« Speed », 12)
   UserControl.BackColor = PropBag.ReadProperty(« BackColor », &H8000000F)
   DText.BackColor = PropBag.ReadProperty(« BackColor », &H8000000F)
   DText.ForeColor = PropBag.ReadProperty(« ForeColor », &H80000012)
   DText.ToolTipText = PropBag.ReadProperty(« ToolTipText », «  »)
   DText.Caption = PropBag.ReadProperty(« Text », «  »)
   DText.AutoSize = PropBag.ReadProperty(« AutoSize », False)
   Set DText.Font = PropBag.ReadProperty(« Font », Ambient.Font)
   ‘Pour que le label prenne la taille du texte on le met pendant un instant en AutoSize = True
   ‘Puis on remet la valeur d’origine à AutoSize
   avant = DText.AutoSize: DText.AutoSize = True: DText.AutoSize = avant
End Sub

C’est fini pour les propriétés.

4) Les méthodes.

Après les propriétés, nous allons ajouter une méthode, Command, qui demandera un argument, et selon cet argument la méthode executera une action. Les méthodes sont des Sub mais Publiques, elles peuvent donc recevoir des arguments mais ne renvoient aucune valeur. Voici le code de la méthode Command:

Public Sub Command(AExecuter As String)
   ‘La méthode Command demande un argument, « AExecuter »
   ‘Si cet argument vaut start alors on lance le DTimer
   If LCase(AExecuter) = « start » Then DTimer.Enabled = True
   ‘Si l’argument vaut stop on stop le DTimer
   If LCase(AExecuter) = « stop » Then DTimer.Enabled = False
End Sub

C’est la seule méthode que nous allons mettre, mais vous pouvez en ajouter.

5) Les Fonctions.

Les fonction ne sont autre que des méthodes qui renvoie une valeur, nous n’avons pas besoin de fonction dans notre contrôle, mais voici la méthode Command modifiée pour qu’elle renvoie une valeur, nous allons l’appeler Execute et elle renverra un valeur Boolean qui indiquera si une action a été effectuée avec l’argument. Ici ce n’est plus un Sub mais un Function qui est employé:

Public Function Execute(AExecut As String) As Boolean
   ‘On place la valeur par défaut de Execute sur True
   Execute = True
   ‘La méthode Command demande un argument, « AExecut »
   ‘Si cet argument vaut start alors on lance le Dtimer
   If LCase(AExecut) = « start » Then
       DTimer.Enabled = True
   ‘Si l’argument vaut stop on stop le DTimer
   ElseIf LCase(AExecut) = « stop » Then
       DTimer.Enabled = False
   ‘Si rien n’a été fait Execute devient False
   Else
       Execute = False
   EndIf
End Function

Voilà, déjà terminé…

6) Les Evénements.

Les événements permettent à l’utilisateur de réagir directement à une action réalisée sur le contrôle, par exemple l’événement MouseMove permet de déclencher une action lorsque la souris passe sur le contrôle. Pour l’instant aucun événement n’est placé dans votre contrôle, mais nous allons en ajouter quelques uns. Les événements doivent être déclarés avec les arguments qu’ils utilisent, voici comment les déclarer:

Event Click()
Event DblClick()
Event KeyDown(KeyCode As Integer, Shift As Integer)
Event KeyPress(KeyAscii As Integer)
Event KeyUp(KeyCode As Integer, Shift As Integer)
Event MouseDown(Button As Integer, Shift As Integer, X As Single, Y As Single)
Event MouseMove(Button As Integer, Shift As Integer, X As Single, Y As Single)
Event MouseUp(Button As Integer, Shift As Integer, X As Single, Y As Single)
Event Resize()

Voilà pour leur déclaration. Maintenant il ne reste plus qu’a définir le moment où ils seront appelés. Par exemple, l’événement Click sera appelé lorsque l’utilisateur cliquera sur le contrôle ou sur le label. Nous allons donc introduire un petit code dans ces deux événements déjà existant:

Private Sub UserControl_Click()
   ‘On appelle Click quand l’utilisateur clique sur le contrôle
   RaiseEvent Click
End Sub

Private Sub DText_Click()
   ‘On appelle Click quand l’utilisateur clique sur le DText
   RaiseEvent Click
End Sub

Nous allons faire de même pour les autres événements. DblClick suit exactement le même modèle que Click, et Resize aussi, mais les autres événements demandent des arguments, qui sont très facile à récupérer:

Private Sub UserControl_DblClick()
   ‘On appelle DblClick quand l’utilisateur double-clique sur le contrôle
   RaiseEvent DblClick
End Sub

Private Sub DText_DblClick()
   ‘On appelle DblClick quand l’utilisateur double-clique sur le DText
   RaiseEvent DblClick
End Sub

Private Sub UserControl_KeyDown(KeyCode As Integer, Shift As Integer)
   RaiseEvent KeyDown(KeyCode, Shift)
End Sub

Private Sub UserControl_KeyPress(KeyAscii As Integer)
   RaiseEvent KeyPress(KeyAscii)
End Sub

Private Sub UserControl_KeyUp(KeyCode As Integer, Shift As Integer)
   RaiseEvent KeyUp(KeyCode, Shift)
End Sub

Private Sub UserControl_MouseDown(Button As Integer, Shift As Integer, X As Single, Y As Single)
   RaiseEvent MouseDown(Button, Shift, X, Y)
End Sub

Private Sub UserControl_MouseMove(Button As Integer, Shift As Integer, X As Single, Y As Single)
   RaiseEvent MouseMove(Button, Shift, X, Y)
End Sub

Private Sub UserControl_MouseUp(Button As Integer, Shift As Integer, X As Single, Y As Single)
   RaiseEvent MouseUp(Button, Shift, X, Y)
End Sub

Vous pouvez remarquer que tous les arguments sont déjà donnés par les événement du contrôle. Il suffit donc de les transmettre à l’événement que nous avons mis, ainsi MouseUp reprend la valeur Button, Shift, X et Y de UserControl_MouseUp. Nous n’avons fait que transmettre les événements déjà existant, mais nous allons maintenant en créer un nouveau, Sort, qui se déclenchera lorsque le Dtext sortira du contrôle, il renverra un argument Cote qui indiquera de quel côté du contrôle le Dtext est sorti. Déclarons le d’abord, toujours tout en haut du code, juste en dessous des autres déclarations:

Event Sort(Cote As String) ‘L’événement Sort donne le côté où est sorti le DText

Et maintenant nous allons ajouter la procédure d’appel de l’événement dans le timer. Voici donc ce que devient le code du Dtimer, le code qui a été ajouté est sur un fond gris:

Private Sub DTimer_Timer()
   If Direction = « right » Then
       DText.Left = DText.Left + Speed
       If DText.Left > UserControl.Width Then
           DText.Left = -DText.Width
           RaiseEvent Sort(« right »)
       End If
   ElseIf Direction = « left » Then
       DText.Left = DText.Left – Speed
       If DText.Left + DText.Width < 0 Then
           DText.Left = UserControl.Width
           RaiseEvent Sort(« left »)
       End If
   ElseIf Direction = « top » Then
       DText.Top = DText.Top – Speed
       If DText.Top + DText.Height < 0 Then
           DText.Top = UserControl.Height
           RaiseEvent Sort(« top »)
       End If
   ElseIf Direction = « bottom » Then
       DText.Top = DText.Top + Speed
       If DText.Top > UserControl.Height Then
           DText.Top = -DText.Height
           RaiseEvent Sort(« bottom »)
       End If
   End If
End Sub

Voilà les événements sont en place, c’est terminé.

7) Enregistrement en OCX et ajout dans un programme.

Il ne reste plus qu’a créer le fichier OCX. Pour cela, faites FICHIER, CREER DefileZone.ocx et enregistrez le en cliquant sur OK

A présent, créez un nouveau projet ou ouvrez en un et cliquez avec le bouton droit de la souris dans la fenêtre des contrôles, puis sur Composants? et choisissez Parcourir, ouvrez DefileZone.ocx et faites OK. Voilà, il ne vous reste qu’a utiliser le contrôle comme tous les autres.