Faire un OCX

FRED87 wrote:

Comment faut il faire pour réaliser un OCX dans VB ?

Pourquoi ne pas tout simplement lire la documentation?

Visual Basic Documentation
Component Tools Guide
Creating ActiveX Components
Creating an ActiveX Control

ou l'équivalent en français que je n'ai pas sous la main, désolé. Tout y
est.

Même doc ici:
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vbcon98/html/vbconcreatingactivexcontrol.asp

Un petit coup de Google vous donnera immédiatement d'autres liens.

La création d'un ActiveX Control, que ce soit en VB ou en utilisant un
autre langage, demande de porter attention à de nombreux détails qui
feront la différence entre un composant bâclé et un composant
professionnel. Personne ne pourra vous expliquer tout cela dans un
simple message. Il faut déjà une bonne journée de cours pour couvrir
l'essentiel.

Bonne lecture.

--
Patrick Philippot - Microsoft MVP [.Net]
MainSoft Consulting Services
www.mainsoft.fr

Hello,

Pour faire simple, un contrôle activeX a des méthodes, des fonctions, des
propriétés et des événements.

En ce qui concerne les méthodes/fonctions, le usercontrol affiche celle qui
lui sont publiques.
Exemple:
Créer un projet de type Exe Standard
Ajouter un UserControl (Contrôle Utilisateur)
Renommer ce contrôle MyTestControl
Dans le code de MyTestControl ajouter:
Option Explicit

'Cette sub de l'usercontrol
'pourra être appelée de l'extérieur
Public Sub DoSomething(Arg1 As String)
MsgBox Arg1
End Sub

'Cette fonction du usercontrol
'pourra être appelée de l'extérieur
Public Function GimmeSomething(Arg1 As Long) As Long
GimmeSomething = Arg1 * 3
End Function

'Cette fonction du usercontrol
'NE pourra PAS être appelée de l'extérieur:
'elle est privée
Private Function MyInternalFunction(Arg1 As String) As Long
MyInternalFunction = Len(Arg1)
End Function

Sur la form par défaut du projet (Form1) crée une instance du usercontrol.
Tu dois pour ce faire avoir fermé la fenêtre de design du usercontrol.
Sur la form, le usercontrol sera nommé: MyTestControl1
Dans le code de la form, place ce code:
Option Explicit

Private Sub Form_Load()
MyTestControl1.DoSomething "Test" 'affiche Test
MsgBox MyTestControl1.GimmeSomething(3) 'retourne 9
'MyTestControl1.MyInternalFunction n'apparait pas dans la liste
intellisence : elle est privée
End Sub

Tu peux tester ton contrôle en faisant Play dans l'IDE.

'*************************************

Les propriétés te permettent de stoquer diverses valeurs décrivant le
comportement de ton contrôle.

La méthode simple pour définir une propriété est d'utiliser une variable
publique.
Dans le code de MyTestControl, ajoute ceci:
Public MyProperty As String

Dans la form, tu pourra définir/retrouver une valeur pour la propriété à
l'aide de
MyTestControl1.MyProperty = "Valeur"
Msgbox MyTestControl1.MyProperty

Cette forme ne permet pas beaucoup de contrôle sur les données de la
propriété.
Une seconde méthode consiste à utiliser des "Property".
Voici un exemple permetant d'utiliser des valeurs de 1 à 10.
Dans le code de MyTestControl:
'Dans les déclarations:
'Variable qui permet de retenir la valeur de la propriété
Private mMyProp2 As Byte

'Plus loin dans le code

'Lorsque l'on retrouve la valeur (Get)
Public Property Get MyProp2() As Byte
'Retourne la valeur stoquée
MyProp2 = mMyProp2
End Property

'Lorsque l'on définit la valeur (Let)
Public Property Let MyProp2(NewValue As Byte)
'Définit la variable en interne
If NewValue > 0 And NewValue < 11 Then 'Valeur valides : 1-10
mMyProp2 = NewValue
'Appeler une procédure pour retracer le contrôle si nécessaire
End If
End Property

Pour définir/retrouver la valeur, on utilisera:
MyTestControl1.MyProp2 = 1
Msgbox MyTestControl1.MyProp2

Il y a encore beaucoup à dire sur les propriétés (et notament sur le
property bag)... j'y reviendrai par après dans ce post.

'**************************************

Maintenant, passons aux événenments.
Ceux ci sont tout d'abord déclarés par
Public Event MyEvent(Arg As Type, Arg2 As Type, ...)
Et ensuite appelés par
RaiseEvent MyEvent(Valeur ou Variable, ...)

Prévenons l'utilisateur de notre super ultra génial usercontrol que la
seconde propriété (MyProp2) a changé.
Pour ce faire, ajoutons dans les déclarations:
Public Event Prop2Changed(OldValue As Byte, NewValue As Byte)

Ensuite, modifions le property Let pour MyProp2:
Public Property Let MyProp2(NewValue As Byte)
'Définit la variable en interne
If NewValue > 0 And NewValue < 11 Then 'Valeur valides : 1-10
'Si la valeur a changé
If mMyProp2 <> NewValue Then
'On appelle l'événement correspondant
RaiseEvent Prop2Changed(mMyProp2, NewValue)
End If

mMyProp2 = NewValue
'Appeler une procédure pour retracer le contrôle si nécessaire
End If
End Property

Dans la form, grâce au deux combos au dessus de la fenêtre de code, nous
pouvons sélectionner le nouvel événement:
Private Sub MyTestControl1_Prop2Changed(OldValue As Byte, NewValue As Byte)

On pourrait avertir l'utilisateur du changement:
Private Sub MyTestControl1_Prop2Changed(OldValue As Byte, NewValue As Byte)
MsgBox "Changement : " & OldValue & "=>" & NewValue
End Sub

'*************************************

Revenons sur différents points du code.
Si tu as réexécuté le code, tu devrais voir à un moment:
Changement : 0 => 1
Pourtant 0 est une valeur non valide de la propriété!
Mais c'est aussi la valeur par défaut de la variable.
On pourait se dire dans une première approche qu'il suffit de tester la
variable dans Get et changer ou non la valeur stoquée.
Mais voyons d'abord s'il n'y a pas un autre mécanisme.
Le UserControl a pour événement InitProperties qui nous permet justement
d'initialiser nos propriétés.
Ajoutons donc ceci à MyTestControl:
Private Sub UserControl_InitProperties()
mMyProp2 = 1
End Sub

La valeur aura alors pour valeur 1 par défaut.
Si tu exécute le code, tu ne verras cependant aucun changement.

'************************************************

Ceci est du au fait que les propriétés doivent être stoquées entre le design
et l'exécution dans un propbag.
L'InitProperties n'est appelé qu'une fois à la création pour définir ces
propriétés. Il faut encore les enregistrer.
Pour ce faire nous avons UserControl_ReadProperties et
UserControl_WriteProperties
Enregistrons donc notre propriété:
'Dans MyTestControl:
Private Sub UserControl_ReadProperties(PropBag As PropertyBag)
'ReadProperty Nom de la propriété, Valeur par défaut
mMyProp2 = PropBag.ReadProperty("MyProp2", 1)
End Sub

Private Sub UserControl_WriteProperties(PropBag As PropertyBag)
'WriteProperty Nom de la propriété, Valeur, Valeur par défaut
PropBag.WriteProperty "MyProp2", mMyProp2, 1
End Sub

Ici effectivement, la valeur sera enregistrée et comme on passera de la
valeur 1 à la valeur 1, on n'aura plus de notification de changement!

'**********************************************
Il faut tout de même compléter l'enregistrement de propriétés en notifiant
le contrôle utilisateur qu'une propriété a changé.
Pour celà, on va éditer (une deuxième fois) le Let MyProp2:

'Lorsque l'on définit la valeur (Let)
Public Property Let MyProp2(NewValue As Byte)
'Définit la variable en interne
If NewValue > 0 And NewValue < 11 Then 'Valeur valides : 1-10
'Si la valeur a changé (la différence des deux est non nulle)
If mMyProp2 <> NewValue Then
'On appelle l'événement correspondant
RaiseEvent Prop2Changed(mMyProp2, NewValue)
End If

mMyProp2 = NewValue

'On notifie du changement
UserControl.PropertyChanged "MyProp2"
'Appeler une procédure pour retracer le contrôle si nécessaire
End If
End Property

Ceci permet de mettre à jour une fenêtre de propriétés ou encore d'indiquer
au contrôle qu'il doit enregistrer les propriétés.

'*************************************************
Un dernier point. Nous appelons Prop2Changed avec des valeur ByRef (par
défaut).
Ceci permet au destinataire de l'événement de modifier l'un ou l'autre
argument.
C'est très pratique lorsque l'on veut utiliser un mécanisme d'annulation: on
appel un événement avec un argument Cancel et on teste la variable de
retour.
Voici un exemple:
Public Event MyOperation(Cancel As Boolean)

Public Sub Toto()
Dim DoCancel As Boolean
RaiseEvent MyOperation(DoCancel)
If DoCancel Then
'On annule l'opération
Else
'On ne l'annule pas
End If
End Sub

Dans notre cas, on voulait seulement notifier du changement! Pas touche aux
valeur!
Editions donc dans les déclaations la ligne
Public Event Prop2Changed(OldValue As Byte, NewValue As Byte)
Et ajoutons que nous passons les valeurs ByVal:
Public Event Prop2Changed(Byval OldValue As Byte, Byval NewValue As Byte)

De cette manière on empêche celui qui reçoit la notification de changer les
valeurs.

'**********************************************

Il est aussi possible de générer les méthodes, événements, ... du contrôle à
partir d'un assistant:
Ajouter : UserControl
Et sélectionner l'assistant Interface de contrôles ActiveX.
Celà permet de simplifier grandement le processus de création d'un contrôle.

Pour finir je dirais que j'espère:
-ne pas avoir dit trop de concetés
-ne pas avoir écrit beaucoup trop et avoir ennuyé tout le monde ;-)
-et surtout t'avoir aidé :-)

--
François Picalausa (MVP VB)
http://faq.vb.free.fr --- http://msdn.microsoft.com
http://apisvb.europe.webmatrixhosting.net

"FRED87" <anonymous@discussions.microsoft.com> a écrit dans le message
de news:2138101c45a7a$40d5cd40$a101280a@phx.gbl

Comment faut il faire pour réaliser un OCX dans VB ?

Quelqu'un aurait'il un petit exemple simple pour que je
comprenne la mécanique "Les class , les sub etc ..."

Et comment faire pour pouvoir appeller les fonctions de
cet OCX

Patrick Philippot wrote:

La création d'un ActiveX Control, que ce soit en VB ou en utilisant un
autre langage, demande de porter attention à de nombreux détails qui
feront la différence entre un composant bâclé et un composant
professionnel. Personne ne pourra vous expliquer tout cela dans un
simple message. Il faut déjà une bonne journée de cours pour couvrir
l'essentiel.

François apporte donc un démenti cinglant à cette affirmation
péremptoire et paresseuse :-) J'admire l'effort. Mais ne serait-il pas
préférable d'apporter après coup des précisions sur les détails de mise
en oeuvre plutôt que d'essayer de résumer ce qui est difficilement
synthétisable?

Je n'ai pas de position totalement arrêtée sur le sujet mais ce genre de
questions très générales me laisse toujours dubitatif sur le type de
réponse à y apporter. Sommes nous ici pour remplacer la doc?

Parmi les cours que j'enseigne, il y a un cours VB6 avec un chapitre sur
la fabrication des ActiveX Controls. Je parle pendant des heures sur le
sujet. C'est peut-être pour cela que j'ai du mal à envisager des
réponses aussi synthétiques via un newsgroup. Je ne sais pas.

En tous cas, Fred87 a bien de la chance... :-)

--
Patrick Philippot - Microsoft MVP [.Net]
MainSoft Consulting Services
www.mainsoft.fr

Pour m'être risqué à ce genre de sport, mon expérience est que réaliser un
"vrai" ocx demande beaucoup de travail et de debuggage.

Je suis personnellement revenu en arrière, n'ayant pas besoin d'une
réutilisation forcenée du code. J'ai contourné la question autrement, à 1 ou
2 exceptions près.

Ma recommandation serait :
Il faut vraiment que cela vaille le coup. Ceci dit, j'ai trouvé l'expérience
passionnante.

Ce n'est que mon expérience...

Christian


"Patrick Philippot" <patrick.philippot@mainsoft.xx> a écrit dans le message
de news:%23rt64TpWEHA.3512@TK2MSFTNGP12.phx.gbl...

FRED87 wrote:
> Comment faut il faire pour réaliser un OCX dans VB ?
>

Pourquoi ne pas tout simplement lire la documentation?

Visual Basic Documentation
Component Tools Guide
Creating ActiveX Components
Creating an ActiveX Control

ou l'équivalent en français que je n'ai pas sous la main, désolé. Tout y
est.

Même doc ici:

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vbcon98/html/vbconcreatingactivexcontrol.asp

Un petit coup de Google vous donnera immédiatement d'autres liens.

La création d'un ActiveX Control, que ce soit en VB ou en utilisant un
autre langage, demande de porter attention à de nombreux détails qui
feront la différence entre un composant bâclé et un composant
professionnel. Personne ne pourra vous expliquer tout cela dans un
simple message. Il faut déjà une bonne journée de cours pour couvrir
l'essentiel.

Bonne lecture.

--
Patrick Philippot - Microsoft MVP [.Net]
MainSoft Consulting Services
www.mainsoft.fr

Merci à tous pour ces bon tuyaux, il me seront d'un bon
secours.

Je viens de faire quelques test avec un OCX tout simple de
ma fabrication, je commence à bien comprendre le
fonctionnement.

En fait il me faut un ocx particulier que je puisse
utiliser dans MSAccess , la maintenant il n'y à plus
qu'à ...

Encore Merci pour vos réponse

FRED87