|
Introduction
- 1ère partie : Caractéristiques des contrôle
ActiveX
-
Définition d'un contrôle
ActiveX
Différence entre un contrôle
standard et un contrôle ActiveX
ActiveX et COM
- 2ème partie : Intégration d'un contrôle ActiveX
- Présentation de notre
application
Développement de notre
application
Introduction
Nous allons décrire dans cet article tous
les avantages que nous avons en intégrant à
nos applications des contrôles ActiveX. Nous verrons
donc dans un premier temps ce qu'est un contrôle ActiveX,
puis ses différences avec un contrôle "traditionnel".Nous
ferons un peu de théorie ensuite avec COM pour expliquer
un peu comment fonctionne un contrôle ActiveX,et enfin
nous développerons une application qui utilise un contrôle
ActiveX.
1er partie : Caractéristiques
des contrôles ActiveX
Définition
d'un contrôle ActiveX
Un contrôle ActiveX est un composant spécial
que vous allez pouvoir insérer dans votre application
au même titre qu'un simple bouton,ou une boite d'édition.
Ce composant recevra donc des événements qui
pourrons être traités au seins du programme,tout
comme nous le faisons avec les contrôles que nous connaissons
déja. Cependant certains détails le différencient
radicalement des composants que nous connaissons déjà.
Différence
entre un contrôle standard et un contrôle ActiveX
L'une des plus grandes particularité des contrôles
ActiveX est la possibilité de pouvoir les intégrer
dans différents type d'application : une application
Win32, dans Internet Explorer, Netscape, ou une simple application
console. Un contrôle ActiveX n'est pas forcément
visuel,il s'agit d'un module compilé qu'il nous est
possible d'implémenter au sein de notre programme.
Ce module peut par conséquent ne pas avoir de représentation
graphique,si son seul but est de calculer une distance par
exemple.
Contrairement aux contrôles standard, un contrôle
ActiveX doit d'avoir être enregistré dans la
base de registre avant de pouvoir être utilisé
dans un programme. Ces contrôles sont souvent stockés
sous forme de fichiers .ocx dont il faudra indiquer l'emplacement
durant la phase d'inscription du contrôle dans la base
de registre (opération faisable avec regsvr32).
ActiveX et
COM
- La technologie COM a été développé
pour permettre la communication interprocessus (c'est un
peu comme la technologie .Net).En effet la technologie COM
repose sur un système de communication via interface.
Considérons deux applications A et B. Sans la technologie
COM, l'application A serait uniquement capable de lancer
la B et inversement. Cependant pour ce qui est d'accéder
à une fonction particuliere de B, cela s'avère
d'une extrême complexité, voir impossible !
Supposons maintenant que ces deux programmes fonctionnent
avec la technologie COM. Dans ce cas chacun de ces deux
programmes aurait une interface composé en fait d'une
série de fonctions accessible aux autres programmes.
Le programme A peut par conséquent appeler une fonction
particulière de B qui entraînera l'exécution
d'une procédure interne de l'application B. C'est
en s'appuyant sur cette technologie que les contrôles
ActiveX ont été développé.
En effet un contrôle ActiveX est un module compilé,
ce qui à priori ne faciliterait pas une communication
complexe avec lui. Mais via l'interface qu'impose la technologie
COM, nous pouvons "piloter" notre contrôle
sans grande difficulté. Cette interface est le coeur
même de la technologie COM, tout développeur
voulant créer un composant COM doit prévoir
une interface qui permettra aux autres processus de communiquer
avec le composant qu'il développe.
2e partie : Intégration d'un contrôle
ActiveX
Présentation
de notre application
Afin d'illustrer ce cours, nous allons développer
un lecteur d'animation flash. Il va sans dire que nous n'allons
pas re-coder réellement le lecteur, nous allons plutôt
greffer à notre application un contrôle ActiveX
qui sera capable d'afficher une animation flash. Ensuite en
rajoutant un peu de code C++ (et oui, il faut bien coder quand
même ! ), nous allons contrôler notre animation.
Développement
de notre application
- Etape 1 : Création de notre application
Pour développer notre application, nous allons créer
un projet MFC, en basé sur une boite de dialogue. Nous
appellerons flash1.

Etape 2 : Designons notre application
Notre application aura plusieurs contrôles :
-Un boutons nous permettant de choisir notre fichier flash
sur notre disque dur
-Un bouton play pour commencer l'animation
-Un bouton suivant pour passer à l'image suivante
-Un bouton précédent pour passer à l'image
précédente
-Un bouton Spécial qui nous permettra d'exécuter
une opération spécial sur notre application
(ici un zoom)
-Un contrôle d'édition qui affichera le numéro
de l'image afficher

Si vous avez correctement suivi le premier cours, vous ne
devriez pas avoir de problème pour implémenter
ces boutons dans notre application,et leur associer des boutons.
Notons cependant que les boutons Play,Suivant,Précédent,
et Spécial seront désactivé par défaut
au lancement du programme,il seront activé après
avoir chargé une animation.
Etape 3 : Implémentation du contrôle ActiveX
Comme vous avez pu le constater notre boite d'outils ne possède
pas notre controle ActiveX. Pour le rajouter nous devons faire
un click droit sur notre boite de dialogue et sélectionner
l'option : Add ActiveX control. A ce stade Microsoft
Visual C++ 6.0 nous demande de sélectionner le control
que nous voulons, remarquez le nombre impressionnant, et diversifié
de control ActiveX à notre disposition.

Nous allons donc choisir le contrôle Shockwave Flash
Object

Puis l'insérerons dans notre boite de dialogue comme
un contrôle classic

Etape 4 : Wrapper une classe pour notre contrôle
ActiveX
Après avoir inséré notre control, il
nous faut pouvoir le manipuler, c'est la raison pour laquelle
Visual C++ 6.0 nous propose de Wrapper une classe pour notre
control, pour comprendre ce que cela signifie, nous devons
revenir sur le mode de fonctionnement d'un control ActiveX.
Vous vous souvenez qu'un control ActiveX est un module à
part compilé. Ce module possède une interface
composé de plusieurs fonction que l'on peut appeler
pour contrôler notre composant. C'est précisément
là l'utilité d'une classe Wrappée. Il
s'agit en fait d'une classe taillée sur mesure qui
sera composé de toute les méthodes et propriétés
de l'interface de notre contrôle. Il suffira ensuite
de créer un objet de cette classe qui nous permettra
de manipuler notre control, via les méthodes de notre
objet.

Pour Wrapper une classe pour notre contrôle,
il nous suffit d'associer une donnée membre de type
control à notre contrôle ActiveX. Nous
appelerons cette donnée membre m_lecteur.En
validant, Visual C++ 6.0 nous proposera automatiquement de
Wrapper une classe pour notre composant, chose que nous allons
accepter.



Etape 5 : Boite de dialogue pour sélectionner
notre animation flash
En cliquant sur notre bouton Choisir une
animation une boite de dialogue de sélection de
fichier devra apparaître nous permettant de choisir
l'animation à lancer. Rassurez vous, nous n'aurons
pas à recoder cette boite de dialogue, quelques lignes
de code feront l'affaire.
Les MFC fournissent une classe CFileDialog
qui nous permet d'obtenir exactement le type de fenêtre
que nous voulons, en créant un objet, nous fournirons
par la même occasion au constructeur les éléments
clés de notre fenêtre : titre,type de fichier
accepté,etc... Puis nous afficherons notre boite de
dialogue à l'aide de la méthode DoModal();
La méthode CFileDialog::GetPathName()
nous permettra de récupérer le chemin du
fichier sélectionné par l'utilisateur dans notre
boite de dialogue.
Voici ci dessous le code permettant d'afficher
notre notre de dialogue:

Etape 6 : Ouvrir notre animation Flash
Une fois que nous avons récupéré
le chemin de notre application flash, on va la charger dans
notre contrôle ActiveX à partir de notre objet
m_lecteur en appelant la méthode CFileDialog::SetMovie(LPSTR
url). Nous rajouterons donc au code d'ouverture du fichier
de l'étape 4 ceci:

Etape 7 : Code du bouton Play
Les instructions ici seront très simple,
si l'animation est en cours et on passe sur pause, et si on
est sur pause, on continue l'animation. La méthode
permettant de savoir si l'animation est en cours ou non est
IsPlaying() qui renvoie true si l'animation
est en cours, et false dans le cas contraire. Nous
obtenons donc le code suivant pour notre méthode Play():

Etape 8 : Code pour passer à Image
suivante et précédente
Ici encore les instructions sont très
simples, il s'agit en fait d'appeler la méthode Foward()
pour passer à l'image suivante, et GotoFrame
pour revenir ou aller à une position particulière.
Nous obtenons donc le code suivant:

Etape 9 : Code du bouton spécial
Parmi la panoplie de méthodes disponibles
pour notre contrôle, nous avons une méthode Zoom
qui nous permet de zoomer sur notre animation. Afin d'avoir
un effet de transition entre les différents zooms,
nous allons faire appel à un timer qui sera appelé
tous les 100 dixièmes de seconde.
L'implémentation d'un timer se fait
grace à ClassWizard (Ctrl+W), nous associons une méthode
OnTimer à l'évemenent WM_TIMER, cette méthode
sera appelé tous les 100 dixièmes de seconde.
Implémentation d'un Timer:


Code :
Etape 10 : Image en cours
Nous devons remettre à jours notre
compteur de l'image en cours de façons quasi permante,
pour ce faire,nous allons là encore faire apelle à
un timer qui sera appelé tous les 10 dixiemes de secondes
pour mettre à jours le champs concerné.
Pour obtenir le numéro de l'image
en cours,il suffit d'apeller la méthode CurrentFrame()
:

Etape 11 : Compilation
Il nous suffit maintenant de compiler notre
projet pour enfin pouvoir le tester !
|
|
 |
Pour afficher ou poster un commentaire, cliquez sur ce lien : Forum-Microsoft
|
|