J'ai commencé la rédaction de ce tutoriel il y a quelques mois, j'espère que ça vous plaira (il y a peut-être quelques erreurs de BBCode, ne faites pas attention).
Les objets com
Comment ça marche ?
- Késako ?
- Syntaxe et utilisation...
- Quelques objets utiles...
- OLE : Intégration à une GUI
TP : Création d'un navigateur Web
- Cahier des charges
- Un peu d'algorithmie...
- Les outils nécessaires
- Correction
(partie DLL in coming)
Bonjour à vous !
Aujourd'hui mon tutoriel va porter sur l'exploitation de ressources externes avec AutoIt.
Mais tout d'abord, qu'est-ce que c'est que des ressources externes ?
Les ressources externes sont constituées de toutes les fonctions Windows exploitables dans votre script, de toutes les bibliothèques graphiques de Windows, des objets provenant d'autres programmes utilisables dans votre script, etc...
Concrètement, dans ce tutoriel, je vais aborder avec vous l'utilisation d'objets COM et des DLL Windows avec AutoIt.
T'es bien gentil, mais ça va me servir à quoi tout ça ?
Bonne question :)
Voila une petite liste de ce que vous saurez faire à la fin de ce tutoriel :
* Utiliser des DLL, soit par exemple :
- Afficher une fenêtre en mode fondu grâce à l'exploitation de la DLL kernel32
- Réduire le coût en mémoire de l'un de vos scripts grâce à l'exploitation de la DLL user332
- Créer des boites de message, gérer des pressions de clavier et de souris grâce au DLL user
- Utiliser des icônes intégrées à des DLL
etc...
* Utiliser des objets COM, soit par exemple :
- Créer rapidement et facilement un logiciel de navigation Web exploitant l'objet COM d'Internet Explorer ou de Firefox
- Manipuler automatiquement Excel grâce à son objet COM
- Manipuler des fenêtres grâce à l'objet shell32
...et plein d'autres choses ![/b]
Il suffit de voir le nombre de programmes manipulables grâce à leur Objet com, ou le nombre de DLL exploitables dans Windows pour vous donner une idée de la longueur de cette liste ! En tant que programmeur, savoir manipuler des objets COM et des DLL est très intéressant et ouvre de nombreuses perspectives.
Je vous donne les bases générales, c'est à vous de les adapter à chaque fois que vous en aurez besoin dans un script.
On va commencer par l'essentiel : la syntaxe et le fonctionnement.
Désolé, il fallait y passer quand même :twisted:
C'est parti !
Comment ça marche ?
Késako ?
Tout d'abord...ça veut dire quoi COM ?
COM signifie "Component Object Model" en anglais. C'est la solution de Microsoft pour inter-connecter des programmes usant d'une interface commune. Dès leur invention, des centaines de programmes ont intégré un objet COM pour permettre une manipulation inter-programmes.
Et pas forcement du "Made by Microsoft" comme certains le pensent !
On peut citer comme exemple Firefox, qui adapte un objet COM pratique et puissant.
Avant d'utiliser l'objet COM d'un programme, vous devez connaitre au préalable la manière dont ils peuvent être appelés, et à quelles fins. Des commandes secondaires sont alors nécessaires pour contrôler convenablement un objet com.
Et comment fait-on pour connaitre ces commandes ?
Pour cela, il vous suffit de consulter des bibliothèques en ligne, ou une documentation sur le programme que vous tentez de manipuler.
La plupart des objets COM créés par Microsoft ont leur bibliothèque ici :
http://msdn.microsoft.com/
Vous pouvez également télécharger un outil puissant créé par : Object Microsoft Viewer.
Un petit screenshoot :
![[Image Introuvable]](https://blog.dekc.net/wp-content/uploads/2010/03/oleviewer.png)
Loading Image
Exemple : Pour afficher les commandes usitées par le navigateur par défaut de Microsoft, suivez cette arborescence :
Object Classes-->Grouped by component Category-->Control-->Microsoft Web Browser
Ensuite, faites un clic droit sur "IDispatch", puis cliquez sur "View...", et enfin sur "View TypeInfo". Vous avez alors accès à toutes les commandes COM inétgrées à Internet Exploreur.
Indexées à Object Viewer, la quasi-totalité des objets COM créés par Microsoft.
Pour le reste, vous devrez faire vos recherches tout seuls !
Vous pourrez alors utiliser n'importe quel objet com, pourvu que le créateur de cet objet aie pensé a publier une documentation sur cet objet. Ce logiciel à l'avantage d'être gratuit mais n'est pas très complet. Quitte à payer pour de meilleures performances, je vous propose ce logiciel shareware :
http://www.brinesoft.com/ObjectBrowser.asp
Mais certains objets COM n'ont pas le même fonctionnement.
Il y a plusieurs types d'objets com's :
Les OOP
Object Oriented Programming.
Ces objets sont destinés à la "fusion" partielle de plusieurs programmes par le partage de données et de fonctions. Nous ne les aborderons pas dans ce tutoriel.
Les DDE
Dynamic Data Exchange.
Ces objets sont utilisés pour l'échange d'informations inter-processus, donc entre différentes applications. Nous ne les aborderons pas pour le moment.
Les OLE
Object Linking and Embedding.
Ces objets ont la particularité de pouvoir être intégrés directement dans une GUI. Ces objets sont les plus utilisés, ils seront abordés dans ce tutoriel.
Les ActiveX
Ces objets sont apparentés aux objets OLE. On les considère aujourd'hui comme la nouvelle génération d'objets OLE. Leur manipulation est quasiment la même pour les deux, il n'y aura donc pas deux parties distinctes les concernant.
Je crois qu'on a terminé notre petit tour :)
On peut passer à la pratique...
Syntaxe et utilisation...
Je vous fait un petit résumé des commandes nécessaires à la manipulation des objets com.
C'est très simple, vous allez le voir.
ObjCreate()
La commande ObjCreate sert à la création d'un objet COM quelconque. Cette commande a quatre flags :
ObjCreate ( "classname" [, "servername" [,"username", ["password"]]] )
Nous ne nous intéresserons qu'au premier pour l'instant.
Cette commande retourne une certaine valeur, qui vous permettra par la suite de manipuler votre objet com. Par conséquent, cette valeur doit être stockée dans une variable dès son appel.
comme ceci :
$objet = ObjCreate ("MonObjetcom.Application")
Pour l'instant, rien de bien compliqué : l'objet COM appelé est ici "MonObjetcom.Application" (le nom des objets COM peut contenir des points).
On n'a pas besoin d'indiquer le chemin d'accès de la DLL qui gère cet objet, puisuqu'il est indexé à Windows : cela signifie qu'il lui est intégré automatiquement.
Mais...comment on fait pour manipuler notre objet maintenant ?
Il suffit d'inscrire le nom de la variable contenant l'objet COM suivi d'un point et de la commande à utiliser. La commande qui suit le point est alors affichée en bleu\italique, pour indiquer qu'elle s'applique à un objet.
Souvenez-vous de cet architecture :
Variable_Objet+Point+commande_com
Par exemple, en supposant que l'application "MonObjetcom" a une commande nommée "Action" permettant d'effectuer une action quelconque, alors le code adéquat est :
$objet = ObjCreate ("MonObjetcom.Application")
$objet.Action
Voila un exemple concret manipulant l'objet "shell" défini par la DLL shell32 :
$oShell = ObjCreate("shell.application")
$oShell.MinimizeAll
Si tout marche bien, vous devriez voir toutes vos fenêtres se réduire :)
Mais avant d'utiliser un objet com, il faut déjà qu'il soit installé et coreectement indexé à Windows !
Pour le vérifier, il suffit d'utiliser la commande IsObj, appelable comme cela :
IsObj ($variable_de_l'objet)
Voila un script d'exemple :
$objet = ObjCreate("MonObjet.application")
If not IsObj($objet) Then
Msgbox(0,"Erreur","L'objet 'MonObjet' n'est pas disponible")
Else
Msgbox(0,"Error","L'objet 'MonObjet' a été créé avec succès.")
Endif
Cela peut être utile si votre application est destinée à un utilisateur dont vous ne connaissez pas les ressources disponibles de son ordinateur.
Par contre, indiquer à chaque fois la variable de l'objet et la commande, c'est un peu fatiguant est pas très lisible.
Heureusement que la syntaxe With\EndWith existe ! Grâce à cet outil, vous pourrez utiliser vos objets COM plus facilement.
Explications avec un code sans With\EndWith :
$object = ObjCreate ("MonObj.Application")
$object.LoadForm
$object.GetList
$object.Navigate
$object.SelectRange(a:12)
Et le même code avec :
$object = ObjCreate ("MonObj.Application")
With $object
.LoadForm
.GetList
.Navigate
.Select.Range(a:12)
EndWith
En fait, l'indicateur With intègre ligne par ligne la chaîne placée devant lui. Vous pouvez alors coder un script contrôlant un objet COM d'une manière lisible et claire.
Tout compris ? Passons à la suite !
Quelques objets utiles...
Je vais ici aborder quelques objets qui vous seront bien utiles lors de la création de comandes complexes.
Tout d'abord, je vais aborder l'objet miracle : Shell.
L'objet COM Shell est intégré à Windows dans la toutes ses versions. Cet objet est défini par la DLL shell32.
Cet objet s'appelle comme cela :
$object = ObjCreate("Shell.Application")
Il assimile un panel de commandes très intéressantes. Petite liste et deux-trois exemples utiles...
CascadeWindows
Passe toutes les fenêtres du bureau en mode cascade. C'est l'équivalent de la commande WinMinimizeAll().
$object.CascadeWindows
Explore
Ouvre un dossier spécifié dans une fenêtre de l'Explorateur Windows.
$object.Explore(@DesktopDir)
FileRun
Affiche le dialogue d'exécutiion à l'utilisateur. Cette méthode a le même effet qu'un clic sur le Start menu et en sélectionnant Exécuter.
$object.Explore(@ProgramFilesDir)
MinimizeAll
Minimize toutes les fenêtres présentes sur le bureau.
$object.MinimizeAll
UndoMinimizeALL
Restaure toutes les fenêtres de bureau dans le même état où elles étaient avant la dernière utilisation de MinimizeAll. C'est l'équivalent de la commande WinMinimizeAllUndo().
ShutDownWindows
Affiche la boîte de dialogue "Arrêter l'ordinateur". C'est la même chose que de cliquer sur le "démarreré et de sélectionner Arrêter.
$object.ShutDownWindows
SetTime
Affiche la boîte de dialogue Date et heure.
$object.SetTime
TileHorizontally
Aligne toutes les fenêtres du bureau horizontalement.
$object.TileHorizontally
FindFiles
Ouvre la boîte de dialogue "Rechercher".
$object.FindFiles
Help
Affiche le centre d'aide de Windows.
$object.Help
TrayProperties
Affiche la boîte de dialogue "Propriétés dela barre de tâche".
$object.TrayProperties
Open
Ouvre le chemin d'accès spécifié.
$object.Open(@DocumentsCommonDir)
Etonnant de voir totues les commandes possibles avec un seul objet, non ? :)
Eh, mais tu ne nous a toujours pas expliqué comment intégrer un objet COM a notre GUI !
En effet ! Si votre objet est de type OLE, alors vous pouvez donc l'intégrer à une GUI !
Voyons comment on va se débrouiller...
Précédemment, on a vu comment manipuler un objet COM d'une manière "brute".
Maintenant, on va voir comment intégrer un objet de type OLE et le manipuler ensuite normalement.
Tout d'abord, partons d'un code simple avec une GUI de format 750x500 :
$GUI = GUICreate ("Tutoriel SDZ", 750, 500)
GUISetState()
While GUIGetMsg() <> -3
WEnd
Aaaloors. Il faut savoir que pour créer un objet, il faut passer par la commande GUICtrlCreateObj dont voici les flags :
GUICtrlCreateObj ( $Variable_Objet, left, top [, width [, height ]] )
On va donc créer notre objet de format 750 fois 500 pixels également :
Global $objet
$GUI = GUICreate ("Tutoriel SDZ", 750, 500)
$GUI_Objet = GUICtrlCreateObj ($objet, 0, 0, 750, 500)
GUISetState()
While GUIGetMsg() <> -3
WEnd
Puis, on stocke un ObjCreate dans la variable "$objet". Prenons par exemple l'objet d'Internet Explorer, défini par "Shell.Explorer.2" :
$objet = ObjCreate("Shell.Explorer.2")
$GUI = GUICreate ("Tutoriel SDZ", 750, 500)
$GUI_Objet = GUICtrlCreateObj ($objet, 0, 0, 750, 500)
GUISetState()
While GUIGetMsg() <> -3
WEnd
Vous devriez voir à l'exécution de ce code une fenêtre au contenu blanc : c'est parce qu'on a pas encore navigué vers une page Web.
Après consultation de la documentation Windows sur l'objet d'Internet Explorer, on peut lire qu'il existe une commande de navigation dont voici les options :
Navigate(Url, flags, target, postdata, headers)
Par défaut, nous allons utiliser ces flags :
$object.Navigate("www.monurl.com", 0, "", "", "")
Nous allons donc commencer par afficher le site Dev-Area dans notre GUI, en se conformant à la documentation :
$objet = ObjCreate("Shell.Explorer.2")
$GUI = GUICreate ("Tutoriel Dev-Area", 750, 500)
$GUI_Objet = GUICtrlCreateObj ($objet, 0, 0, 750, 500)
GUISetState()
$objet.Navigate ("www.dev-area.fr.nf", 0, "", "", "")
While GUIGetMsg() <> -3
WEnd
Lançons le script (appuyez sur F5 ![[Image Introuvable]](https://www.siteduzero.com/images/smilies/magicien.png)
Loading Image)...
Le script une fois lancé...
Rhoooo ! Magie !
Sous vos yeux ébahis, la page d'accueil de Dev-Area vient de s'afficher :)
Et on a bien notre objet INTEGRE dans notre GUI !
Afin d'obtenir le même résultat pour d'autres programmes, veillez à ce que l'objet de ce logiciel soit bien de type OLE.
Ma foi, nous avons déjà un petit navigateur bien sympatique.
Voyons voir si vous pouvez faire mieux...
TP en vue ! :twisted: diable.png
eh, mais ils sont passés ou ?
Ah non, ne partez pas tout de suite !
Je vous jure que ça sera très facile ! Ou, du moins, humainement possible...
Révisez bien !
TP : Création d'un navigateur Web
Dans ce TP, vous allez devoir réaliser votre propre navigateur Web basé sur les ressources d'Internet Explorer.
Accrochez-vous !
Attention ! Ce TP est destiné aux zéros ayant une bonne expérience en AutoIt ! Pour les autres, ça risque d'etre compliqué !
Cahier des charges
Un petit cahier des charges de ce que vous devrez apporter à votre programme :
* Une GUI simple, avec deux boutons et une barre d'adresse ;
o La barre d'adresse doit afficher en continu l'URL de la page consultée
o Une barre de processus doit afficher l'état de la navigation
* Un objet "Internet Explorer" simple
Ca n'a pas l'air compliqué comme ça, mais pourtant vous allez trimer diable.png
Un peu d'algorithmie...
Je vais vous aider un peu :)
Voyons tout d'abord comment devrait fonctionner notre programme.
Je vous fait un petit listing des actions à efefctuer dans l'ordre :
1. Création de la GUI :
* Objet Internet Explorer
* Boutons Suivant\Précédent
* Barre d'adresse
2. Activation de la boucle principale ;
* Détecte une pression des boutons de navigation
Difficile pas vrai ? Surtout quand on a pas les bons outils en main :)
Ne vous inquiétez pas, la partie suivante va y remédier :)
Les outils nécessaires
Avant de nous attaquer au codage, il va vous falloir quand même quelques informations clés !
Heureusement, je suis là pour ça :)
Les choses vont se corser avec cette étape, en commençant par récupérer l'URL !
Nous allons devoir passer par la commande ObjEvent, dont voici les flags :
ObjEvent ( $Objet, "Préfixe_de_la_fonction" [, "nom de l'interface"] )
Je m'explique : en fait cette commande permet d'appeler directement une fonction dès que l'objet COM à manipuler effectue une certaine action. Ici, pour l'action, nous allons tenir compte de l'information "Navigate.complete" renvoyée par l'objet Internet Explorer quand la connexion à une page est terminée.
Le problème avec ObjEvent, c'est que nous allons devoir indiquer aussi le préfixe de la fonction à appeler lors de la réalisation de cette action. Je m'explique. Prenons un petit bout de code simple :
$objet = ObjCreate ("Shell.Explorer.2") ;On crée l'objet Internet Explorer
$objet.Navigate("www.google.fr") ;On navigue vers google.fr
ObjEvent($objet, "IEEvent_", "DWebBrowserEvents")
;On indique qu'il faut appeler une fonction commençant par "IEEvent_" selon les différentes réactions de l'objet.
Je m'explique : si la réaction de l'objet est "Navigatecomplete", alors la commande va appeler "IEEvent_Navigatecomplete".
Il y a des dizaines d'autres informations que peut ici renvoyer l'obet IE : ProgressChange, NavigateError, etc...
Oui, mais là à quoi ça nous sert ? A la base on veut récupérer seulement récupérer l'URL actif !
En fait, à l'appel de cette fonction, la commande va aussi renvoyer l'URL de la page active ! comme ceci :
$objet = ObjCreate ("Shell.Explorer.2")
$objet.Navigate("www.google.fr")
ObjEvent($objet, "IEEvent_", "DWebBrowserEvents")
Func IEEvent_Navigatecomplete($URL)
ToolTip ("L'url actif est :"&$URL)
EndFunc
Par exemple ici, dès la navigation d'une page, une petite bulle affichera l'URL de la page active.
Pratique...mais un peu compliqué :lol: langue.png
On va devoir créer des boutons de navigation aussi !
Afin de naviguer vers la page précédente, utilisez la commande suivante :
.GoBack()
$objet.GoBack()
Un mode évènementiel pour les objets..
ObjEvent ( "AutoIt[/b].Error" [, "function name"] )
Vous l'avez compris, ici on se sert de l'objet COM de gestion d'erreur d'AutoIt pour détecter une erreur quelconque dans l'appel d'une fonction COM précédemment créée. Voila un petit bout de code vous montrer son fonctionnement :
$objet = ObjCreate ("InternetExplorer.Application.1") ;Pour changer, j'appelle un objet COM IE un peut différent de celui abordé précédemment.
$o_erreur = ObjEvent("AutoIt.Error","Erreur") ;Je configure la gestion des erreurs : a partir de cet instant, si on appelle mal une fonction COM, la fonction "Erreur" sera appelée automatiquement.
$objet.DansesLeTwist ; J'appelle volontairement une fonction inexistante
Func Erreur() ;La fonction est alors appelée
MsgBox (64, "Erreur", "Erreur - la fonction appelée est inconnue.")
EndFunc
Tout compris ? Dans notre cas, vous n'aurez qu'a créer une fonction d'erreur au cas ou il y aurait un problème avec la commande .GoForward ou .GoBack.
Bon, et bien je crois que je vous ai donné tous les outils nécessaires !
A vous de vous débrouiller maintenant.
Correction
Bien bien, je pense qu'il est temps de passer à la correction !
J'espère pour vous que vous avez bien travaillé au préalable.
La correction que je vous donne est bien sûr un peu plus complète. J'ai commenté les grandes lignes du script, à vous de voir ce qui manquait au votre ou ce qui allait :)
Bien sûr, l'exemple que je donne est très loin d'être parfait. Je vous fournit ce code à titre indicatif, soyons clairs :)
Voila le code :
(c'est à bertho de le faire, j'ai la flemme :p )
J'espère que vous avez bien suivi ce tutoriel, et surtout que ça vous servira ;)