A telecharger

IHM
DLL, COM et DirectX
Windows : les DLL
! Les bibliothèques de liens dynamiques (ou DLL :
dynamic link library), comme winmm.dll, sont des fichiers
séparés des programmes
! Ces fichiers contiennent du code binaire correspondant à
des fonctions qui peuvent être appelées par des
programmes ou par d'autres DLL
! Une bibliothèque ne devient active que lorsqu'elle est
appelée
! Windows lui-même fonctionne avec trois bibliothèques de
liens dynamiques qui correspondent à trois parties de
Windows : Kernel, User et GDI.
1
Windows : utilité des DLL
! Plusieurs programmes peuvent se partager le code
binaire d’une fonction si celle-ci est dans une DLL (plutôt
que de répéter dans chaque programme la même portion de code source)
! Les programmes se branchent à l'exécution sur les DLL
correspondantes (d'ou le nom de lien dynamique).
! Lors de l ’édition de liens, il faut lier le programme avec
une bibliothèque d'importation ou 'bibliothèque de
référencement' (Elle possède elle aussi l'extension '.lib ’)
" Celle-ci ne contient pas de code mais des informations pour les
liens dynamiques afin d'indiquer dans quelles DLL se trouvent le
code binaire des fonctions utilisées
Edition de liens avec une bibliothèque statique
2
Edition de liens avec une bibliothèque dynamique
Réutilisation du code...
! Lorsque l'on écrit une DLL en C++, par exemple,
l'algorithme propriétaire de C++, qui dénature les
noms, rend impossible l'utilisation de la DLL par
autre chose qu'un client composé avec le même
compilateur.
! Cet objet n'est utilisable ni avec Visual Basic ni
par des clients Java.
! Si un développeur modifie et redéploie une DLL, il
doit s'assurer qu'aucun numéro de la DLL n'a
changé, auquel cas les liaisons statiques à cette
DLL provoqueraient une incompatibilité avec le
client.
3
Réutilisation du binaire
! Aller plus loin et permettre la réutilisation du binaire…
! Créer des composants logiciels pouvant être appelés
et exécutés dans les OS adaptés.
" Intégration forte au niveau de l'OS : notion de middleware
" Nécessité de pouvoir lancer l'exécution des objets à distance.
(version objet des RPC) # raison du développement de CORBA
Rappel : ce sont ces middleware qui supporte les Desktop
Environment de linux : CORBA pour Gnome, ORB pour KDE
! Du coté de Microsoft : Component Object Model
(modèle d'objets composants)
! COM est une spécification très largement respectée,
destinée à offrir des interfaces de programmation
réutilisables et indépendantes du langage.
! Trois motivations à la base de l'effort COM/OLE :
" il faut pouvoir distribuer des binaires
" on doit pouvoir accéder aux composants par-dessus la barrière du
langage de programmation
" il doit être possible d'ajouter des composants au système, et que les
anciens composants puissent les utiliser sans recompilation
! COM permet ces trois points, et il crée donc ce nouveau type de
software qu'est le "Component Software" (VBX pour Visual Basic).
! Alternative (compétition ?) :
" CORBA, beaucoup de similitudes avec COM
" OPENDOC, créé par CIL (Component Integration Labs), qui repose sur
l'implémentation d'IBM de CORBA : SOM
! quelques efforts pour porter COM/DCOM sur d’autres plates-formes:
" Implémentation de DCOM sous Linux : EntireX
(Software AG http://www.softwareag.com/entirex/)
" Ponts COM et .NET vers Java : Jintegra et Ja.Net
(Intrasyc http://www.intrinsyc.com/)
4
! COM+ est le résultat d'une lente évolution qui débuta en
1990
" 1990 : OLE/OLE 2 (Object Linking & Embedding): Architecture
de base de Windows. Permet la coopération Multi-Applications
(documents composites)
" 1992 : COM (Component Object Model) est livré avec
Windows98 et Windows NT 4.0. Coeur de OLE2.
" 1996 : DCOM est la version pour les objets Distribués. Il permet à
un composant de se "déplacer" et de s'exécuter sur une autre
machine.
" 1996 : ActiveX version Internet d'accès aux objets COM/DCOM.
Les contrôles ActiveX permettent de faciliter la distribution des
composants à travers l'Internet, et d'intégrer DCOM sur le
navigateur Web.
! Un objet COM dispose d’interfaces
! COM permet l’interoperabilité en fournissant une
matrice de pointeurs vers les méthodes exportées
par l'interface
5
Classe de base IUnknow
! Toutes le interfaces COM reposent sur l'interface IUnknow qui joue
le rôle d'une classe de base abstraite en C++ pour fournir un jeu de
fonctions à implémenter et pour permettre l'ajout de fonctions
complémentaires par chaque interface. La définition de IUnknow
inclut trois fonctions :
" QueryInterface()
• Sert à atteindre les pointeurs dirigeant vers les interface dérivées de
l'interface en cours.
" AddRef
• Incrémente le compteur de références de l'interface en cours.
" Release
• Sert à libérer une interface qui
n'est plus utilisée.
Décrémente le compteur de
références et détruit l'objet
lorsque le compte atteint zéro.
Les objets COM
! L'interface de base, qu'il est obligatoire d'implémenter
pour un objet, est l'interface IUnknown. Cette interface
est disponible pour tous les objets OLE/COM.
! L'interface IUnknown possède, entre autres, une méthode appelée
QueryInterface() qui permet à un programme utilisant l'objet considéré de
prendre connaissance de l'existence d'une interface implémentée dans
l'objet. Si l'interface demandée existe, la méthode QueryInterface() renvoie
un pointeur sur celle-ci afin que l'objet demandeur puisse l'utiliser.
! Chaque interface d'un objet est identifiée de façon unique par un GUID
(Globally Unique IDentifier) attribué par Microsoft pour éviter tout conflit
d'identifiant. Ce dernier, codé sur 128 bits, est stocké dans la base des
registres de Windows. Dans cette base, pour chaque GUID, on trouve le
nom et la localisation du serveur (DLL par exemple) fournissant l'objet dont
on veut accéder à l'une de ses interfaces. On trouve également pour chaque
interface un certain nombre d'informations telles que sa version, les types de
données reconnus, etc.
6
interface IUnknown
{
virtual HRESULT QueryInterface(IID& iid, void** ppvObj) = 0;
virtual ULONG AddRef() = 0;
virtual ULONG Release() = 0;
}
Demande d'interface
7
Quel est le lien entre COM et les IHM !
! Avec Windows 95, Microsoft a voulu créer une meilleure
plateforme pour les jeux. Cela a pris la forme de pilotes
qui permettent un accès direct aux fonctionnalités
matérielles des unités graphiques, audio et vidéo; les
développeurs n'ont plus besoin d'écrire leurs propres
pilotes.
" Souvent, un pilote par type de carte graphique / carte son
! La SDK directX est entièrement basée sur des objets
COM
! C'est pourquoi, à chaque fois que vous installez une
nouvelle version de DirectX sur votre PC, les
programmes qui utilisait les anciennes versions de la
DirectX fonctionnent toujours. Vous pouvez aussi
programmer de nouvelles applications en utilisant les
anciennes fonctions de DirectX 1,2,3,4…
! Tous les objets COM ont une interface commune
Iunknown qui elle peut être modifiée et qui permet
d'accéder aux différentes interfaces et leurs méthodes.
8
DirectX : Les éléments
! DirectDraw
DirectDraw permet d'exploiter les capacités 2D d'une carte
graphique tout en autorisant l'utilisant des services du GDI
(Graphic Device Interface), l'API graphique de Windows.
! Direct3D
Direct3D permet de créer des scènes de 3D, d'en manipuler
les objets avec une palette de services et de les afficher en
utilisant les capacités 3D d'une carte graphique quand elle
en dispose. Direct3D dispose de deux modes de
d'utilisation:
" Le mode immédiat permet de gérer la transformation,
l'illumination et le rendu de simples primitives (triangles,
points, droites).
" Le mode retenu met à la disposition du développeur un moteur
3D complet capable de gérer des objets.
DirectX : Les éléments
! DirectSound
DirectSound permet d'exploiter les capacités d'entrée-sortie
d'une carte son pour numériser, mixer des échantillons
sonores et en restituer le résultat, éventuellement
agrémenté d'effets 3D perfectionnés.
! DirectInput
DirectInput permet de récupérer les informations transmises
par l'utilisateur, que ce soit par l'intermédiaire de la souris,
du clavier ou du joystick. Elle permet aussi de renvoyer des
données vers des périphériques à retour de force.
! DirectPlay
DirectPlay permet de mettre en place et d'administrer un
dialogue point à point ou client-serveur entre plusieurs
utilisateurs désirant évoluer simultanément dans un même
contexte ; par exemple pour une interactivité entre joueurs
connectés par Internet, par un réseau local ou par une
connexion directe (modem ou câble série).
9
Éléments DirectMedia
! DirectX Transform
DirectX Transform pour la création d'effets graphiques
dynamiques en 2D et en 3D, notamment pour la fusion des
couches alpha et les distorsions de surface.
! DirectAnimation
DirectAnimation est un ensemble de contrôles (chemins de
déplacement, sprites, éléments de 3D, séquenceurs) qu'il
est possible de référencer depuis une page Web. Ces
contrôles disposent d'API qui permettent de les manipuler
via un script JScript ou VBscript ou encore une applet Java.
Il est possible d'intégrer ces contrôles dans une application
développée en Java, en Visual Basic ou en C++.
! DirectShow
DirectShow permet de jouer des séquences vidéo et audio
(accédés en local ou à distance) et d'en capturer via des
périphériques spécialistes. DirectShow supporte de
nombreux formats : MPEG-1, WAV, MIDI, MPEG-2, PCM,
DSS, AVI, …
DirectX
! L'avantage des fonctions de DirectX
pour les programmeurs est que celles-ci
utilisent (si possible) un algorithme
alternatif (confié au processeur) quand
le matériel installé ne gère pas ce type
de traitement. Il fonctionne comme une
surcouche de Windows, évitant
théoriquement aux programmeurs de
devoir s'occuper des différences
matérielles qui existent entre les
différents PCs. Par exemple, si une
carte vidéo n'a pas de fonctions dédiées
à la 3D, DirectX demandera au
processeur de s'occuper du rendu d'une
image de synthèse ou le rendu 3D en
temps réel.
10
DirectShow et MCI
! Les premières versions de DirectX n'eurent pas d'effet
sur les applications multimédia; DirectSound, la partie de
DirectX chargée de jouer le son, n'était pas prévu pour
de telles applications et ne pouvait pas enregistrer le son.
! Depuis, Microsoft a ajouté DirectShow qui rend plus
facile la programmation des applications multimédia.
! DirectShow encapsule l'interface MCI
Programmer en DirectX
! Ne pas avoir peur de COM…
! Suffisamment de documentation et d’exemples
(DirectX SDK, internet)
! L'accès bas niveau aux objets est souvent masqué par
des fonctions de + haut niveau.
! Permet l’utilisation de tous les composants de windows
(drivers WDM, filtres direct show, ect…)
" Utilisation de GraphEdit
11
! Comme dans toute conception objet, un objet COM doit
être instancié avant de pouvoir être utilisé. Voici à quoi
ressemble l'instanciation d'un objet COM en langage C
sous Windows:
// Création d'une instance COM de DirectDraw7
LPDIRECTDRAW7 lpDD7 = NULL;
GUID *lpDevice = NULL;
CoInitialize(NULL);
if (FAILED(CoCreateInstance(CLSID_DirectDraw7, NULL,
CLSCTX_ALL, IID_IDirectDraw7, (LPVOID *)&lpDD7))) {
CoUninitialize();
return(FALSE);
}
if (FAILED(lpDD7->Initialize(lpDevice))) {
CoUninitialize();
return(FALSE);
}
! CoInitialize() permet d'initialiser la librairie COM. Son
appel est obligatoire avant tout usage de COM.
CoUninitialize() pour la fermeture de la librairie COM
! CoCreateInstance() permet de créer une instance de
l'objet COM dont l'interface est indiquée
(IID_IDirectDraw7). Dans ce cas, nous créons une
instance de DirectDraw version 7.
Reportez-vous à la documentation et aux fichiers d'entête
de DirectX pour savoir quelles sont les différentes
interfaces disponibles pour les différents composants de
DirectX.
12
! Les énumérations deviennent très courantes… via des
fonctions réflexes.
! Exemple : lorsque avec DirectX vous souhaitez
connaître la liste des périphériques d'entrée disponibles
sur l'ordinateur, vous devez utiliser une fonction callback
! La méthode importante ici est EnumDevices qui passe
en paramètre le nom de la fonction callback
// Enumère les périphériques d'entrée pour charger la listbox
// Appelé directement ou indirectement depuis le WinMain
LPDIRECTINPUT8 lpDi8 = NULL;
if (FAILED(DirectInput8Create(hInstance, DIRECTINPUT_VERSION,
IID_IDirectInput8, (LPVOID *)&lpDi8, NULL)))
return(FALSE);
if (FAILED(lpDi8->EnumDevices(DI8DEVCLASS_ALL,
EnumDirectInputDevicesCallback, hListBox,
DIEDFL_ATTACHEDONLY)))
return(FALSE);
! Voici le code de la fonction callback :
// --------------------------------------------------------// Fonction callback d'énumération des périphériques
// d'entrée et de chargement de la listbox
// ---------------------------------------------------------BOOL CALLBACK
EnumDirectInputDevicesCallback(LPCDIDEVICEINSTANCE lpddi,
LPVOID pvRef)
{
HWND hListBox = (HWND)pvRef;
SendMessage(hListBox, LB_ADDSTRING, 0,
(LPARAM)lpddi->tszProductName);
return(DIENUM_CONTINUE);
}
13
! Puis beaucoup de copier-coller
! Et des appels de fonctions de haut niveau…
g_pDisplay = new CDisplay();
g_pDisplay->CreateFullScreenDisplay( hWnd, SCREEN_WIDTH,
SCREEN_HEIGHT, SCREEN_BPP );
// Create a surface, and draw a bitmap resource on it.
hr = g_pDisplay->CreateSurfaceFromBitmap( &g_pAnimationSurface,
MAKEINTRESOURCE(IDB_ANIMATE_SHEET ), SPRITE_DIAMETER * 5,
SPRITE_DIAMETER * 6 );
if( NULL == ( g_pD3D = Direct3DCreate8( D3D_SDK_VERSION ) ) )
return E_FAIL;
. . .
D3DXMatrixLookAtLH( &matView, &D3DXVECTOR3( 0.0f, 3.0f,-5.0f ),
&D3DXVECTOR3( 0.0f, 0.0f, 0.0f ),
&D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) );
g_pd3dDevice->SetTransform( D3DTS_VIEW, &matView );
DirectX
! Attention : DirectX n'inclut pas
les objets / méthodes pour la
réalisation / gestion des IHM
(pas de contrôles prédéfinis).
14
Perspectives IHM
! Les applications interactives sont de plus en plus souvent
implémentées au-dessus de librairies graphiques
évoluées telles qu'OpenGL ou DirectX.
! Toutefois, jusque très récemment, la plupart des
systèmes de fenêtrage étaient toujours basés sur des
modèles graphiques vieux de plus de 15 ans, tels que
GDI, QuickDraw ou la Xlib. Aqua, l'interface utilisateur de
MacOS X donne pourtant une petite idée de ce que
pourrait être un système de fenêtrage reposant sur un
modèle graphique évolué incluant la transparence, le
placage de textures, des transformations 3D ou
l'éclairage.
Interface Aqua
15
AVALON
! Les prochaines versions de Windows sont annoncées
avec une fusion du GDI et de DirectX : Nom de code
AVALON
! L'interface reposera sur les WGF (Windows Graphic
Foundation).
! Fera partie du successeur de XP (Nom de code
longhorn, puis VISTA) prévu pour 2006
AVALON
16
17
18