Introduction aux classes C++ (Microsoft® Foundation Classes).
Le but de ces classes est de faciliter la programmation sous Windows et de rendre le développement des applications standards (toutes les applications seront
construites sur le même modèle).
Histoire et Evolution
Microsoft® Foundation Class Library (MFC) est une architecture d'application C++ robuste destinée à la programmation C++ pour l'environnement Microsoft Windows™.
MFC 1.0 a été commercialisé en Avril 1992 avec Microsoft C/C++ version 7.0. La version 32-bit pour Windows NT a été conçue plus tard. Les MFC 1.0 se décomposent en 2 parties: les classes à utilisation générale pour les portions non graphique d'une application , et les classes relatives à la partie graphique de l'application (GUI).
Classes à usage générale:
· Informations de type Run-Time
· Persistance des objets
· Classes collection
· Chaînes
· Fichiers
· Date et heure
· Gestion des exceptions
Classes à usage graphique:
· Lancement d'applications, services applications
· Gestion des fenêtres
· Graphique (GDI)
· Multiple document interface (MDI)
· Menus
· Boîtes de dialogue
· Contrôles Windows
· Boites de dialogue standard
· Gestion des objets OLE 1.0
Dix mois plus tard, en février 1993, MFC 2.0 a été distribué avec Visual C++™ 1.0. Le cœur de l 'architecture d'application MFC 1.0 a été étendu pour inclure de nouvelles classes, plus abstraite. En août 1993, la version 32-bit des MFC 2.0 a été inclus dans la version 32-bit de Visual C++ 1.0.
Classes d'architecture:
· Commandes
· Documents et vues
· Impression et aperçu avant impression
· Dialog data exchange and validation (DDX/DDV)
· Aide sensitive
Classes ayant un haut niveau d'abstraction:
· Form view
· Edit view
· Scrolling view
· Splitter window
· Toolbar et status bar
· VBX 1.0 contrôles
Dix mois plus tard, en Décembre 1993, MFC 2.5 est fourni dans Visual C++ 1.5. De nouvelles classe apparaissent pour le support des bases de données via ODBC et de nouvelles fonctionnalités avec OLE 2.0.
Classes bases de données:
· Database engine classes
· Record field exchange (RFX)
· Record view
Classes OLE 2.0:
· Editions visuelle des serveurs
· Editions visuelle des containers
· Glisser et déposer
· Stockage structuré
· Serveurs OLE Automation
· Clients OLE Automation clients
MFC 2.5 se construit au dessus des fonctionnalités de MFC 1.0 et des classes d'architecture abstraites ajoutées dans MFC 2.0. La dernière version des MFC suit la même démarche et rend possible le développement professionnel d'applications sous Windows de manière plus intuitive qu'un développement en C avec le Software Development Kit (SDK).
MFC offre un niveau d'abstraction élevé qui permet au développeur de se préoccuper exclusivement de la partie spécifique de son application, et d'accéder ou de spécialisé des classes existantes. Comme ses prédécesseurs, MFC 2.5 permet aussi l'accès aux API native de Windows pour plus de spécificité.
MFC rend la programmation de Windows et C++ plus productive. A travers cette architecture d'application, toutes les applications développées auront le même aspect, la même homogénéité. MFC 2.5 propose plus de 100 classes C++ réutilisable, fournissant une gamme de services très variés.
MFC 2.5 contient un support pour les bases de données (ODBC) et OLE 2.0. A titre d'information, AppStudio, AppWizard, et ClassWizard on été construit en utilisant les MFC.
MFC partout: Portabilité, Plate-forme, et le future
Les MFC sont aussi supportées par d'autres compilateur tels que Symantec C++ Professional 32-bit. Cette technologie inclues MFC 2.0.
Les MFC représente une famille de classes qui évoluent à chaque nouvelle version d'un système d'exploitation. A tel point que le code développé en utilisant les MFC 2.5 peut être recompilé sous Windows NT en utilisant une nouvelle version de classes 32-bit.
MFC 2.5 encapsule la plupart des fonctionnalités accessibles via l'API Windows. Cela représente 60,000 lignes de code C++ standard. Le code source représente un exemple d'application C++ pour Windows très robuste. De plus, le code des MFC est fourni, permettant ainsi à chacun d'apprendre comment sont implémenté les dernières techniques en matières d'interfaces de programmation.
Classes d'architecture MFC
La clé de la réussite des MFC n'est pas seulement son pouvoir de génération d'un squelette d'application, mais aussi les fonctionnalités de spécialisés des classes existantes qui sont offertes aux programmeurs. Lorsque vous devez implémenter une fonctionnalités dans votre application, l'architecture d'application vous indique sous forme de commentaires où se situe la ou les méthodes à coder. Dans certain cas, la méthode est déjà définie et son implémentation est celles qui est implémenté par défaut. Libre à l'utilisateur de donner une autre interprétation à celle ci.
Les classe fournissent un support pour les commandes, les document, les vues, les impressions, les aides contextuelles et la gestion des boîtes de dialogue.
Les Commandes
Accès à un menu, raccourcis claviers, toolbar sont les commandes standards d'une application. Une commande est une instruction de votre programme qui doit exécuter une certaine action. A l'inverse d'une procédure ou d'une fonction, une commande est un message qui est routé à diverses cibles susceptibles d'intercepter ce message. Les cibles de commandes sont des objets dérivés de la classe CCmdTarget , qui inclue les documents, les vues, les fenêtres et l'application elle même.
L'architecture des commandes assure qu'une action de l'utilisateur, tel une sélection dans un menu, un choix dans une toolbar provoquera une commande au gestionnaire de message approprié. Le routage des messages de commandes peut aussi être utilisé pour mettre à jour l'état visuel des items de menus ou des boutons de la toolbars.
Par exemple, la command Couper du menu Edit peut avoir un item de menu et un bouton sur la toolbar qui peut être actif ou grisé. En utilisant l'architecture de commandes, il très facile de maintenir l'état actif/grisé de l'item de menu et du bouton de la toolbar avec une seule ligne de code à un même emplacement.
Une autre partie des MFC sont les maps de message qui furent introduit dans MFC 1.0 et étendu dans MFC 2.0. Une map de message fournit un mécanisme type-safe pour adresser un message Windows, une notification a un control ou une commande à une fonction membre d'une classe C++. Chaque cible de commandes possède son map de messages qui contient une entrée par identification de command (ID) défini avec AppStudio (éditeur de ressources) et lié à une fonction membre C++. ClassWizard est utilisé pour créer les classes et gérer la map de messages de chaque classe et les gestionnaire appropriés.
MFC 2.5 étend cette utilisation des commandes pour le support d'OLE automation. Chaque classe dérivée de CCmdTarget peut déclarer ces variables membres et ses fonctions membres comme des propriétés et des méthodes OLE.
Documents et Vues
L'architecture Document/Vue fut introduite avec MFC 2.0 pour la gestion des stockage et des affichage spécifique des données stockées. La classe CDocument permet la gestion des données de l'application, et une application dérivera une nouvelle classe de CDocument pour chaque type de
document. La fonctionnalité majeur d'un document est son faciliter à sauvegarder une document et à le charger plus tard. Le programmeur doit juste surcharger la fonction membre Serialize, qui sauvegarde et charge les données de l'application a partir du disque. En implémentant cette fonction, MFC supporte automatiquement les commandes Nouveau fichier, Sauver, Sauver comme, et Ouvrir fichier. MFC se charge d'afficher les boîtes de dialogues correspondantes (common dialog box) pour la gestion des fichiers. Bien que la plupart des document soient associés à des fichiers sur disques, l'architecture CDocument est si flexible qu'elle permet la manipulation de stockage des données, autre comme les fichiers de bases de données ou toute autre sorte de représentation physique des données. AppWizard possède plusieurs options pour la génération du squelette initial d'une application telle que l'utilisation des bases de données.
Chaque document dans une application lancée est attachée a une ou plusieurs vues sur le document. Les vues gère l'aspect graphique des données de l'application sur l'écran. Les vues dérivent de la classe CView et possèdent le code spécifique lié à l'affichage. Une vue représente toute la partie d'une fenêtre sur l'écran, et est une simple fenêtre fille que l'on peut manipuler avec les fonctions membres fournies par la classe CWnd. L'implémentation de l'affichage liée à la vue se fait par la surcharge de la méthode OnDraw de la vue. Après avoir implémenter OnDraw, votre programme supporte automatiquement l'impression et l'aperçu avant impression. La classe dérivée de CView se prend en charge la plupart des messages relatifs à des commandes ou à des actions sur le fenêtre qui manipule de façon graphique, les données de l'application.
Pour supporter des mises à jour rapides, il existe plusieurs API permettant l'optimisation du processus d'affichage pour des applications encore plus professionnelles.
Il est aussi facile de posséder plusieurs vues sur un même document, et chaque vue peut être une classe dérivée de CView différente. Par exemple, une splitter window peut avoir une vue pour chaque panneau.
Pour coordonnée les documents et les vues, MCF utilise la classe CDocTemplate. Cette classe orchestre la création des documents, des vues et de la fenêtre de base (frame window) en réponse à une action de l'utilisateur. Un objet template de document est créé pour chaque type de document et est le point de connexion du document et des types de vues. L'objet application gère les templates de documents. Deux classes de templates de document sont fournies: une pour les documents multiples (MDI), et une pour les documents simple (SDI). La différence en une interface MDI et SDI est encapsulée dans le template de document et dans la classe de la fenêtre principale.
Impression et aperçu avant impression
En utilisant l'architecture Document/Vue, MFC est capable de fournir à l'application une impression indépendante du type d'imprimante. Cela signifie que le même code utilisé par OnDraw dans la classe dérivée de CView est utilisé pour l'affichage sur l'écran et sur l'imprimante. MFC supporte aussi les boîtes de dialogue standards pour l'impression.
En combinaison avec l'impression et l'architecture Document/Vue, MFC supporte l'aperçu avant impression, qui montre une image réduite, sur une ou deux pages, du document tel qu'il apparaîtra sur l'imprimante sélectionné. Cette implémentation donne la possibilité de naviguer dans le document et de zoomer des parties spécifiques. Cette fonctionnalité se fait toujours au moyen de la méthode OnDraw. Le programmer se doit de rendre la fonction d'aperçu avant impression active, et l'architecture d'application fait le reste.
Dialog Data Exchange et Validation (DDX/DDV)
La notion de DDX/DDV a été introduite dans MFC 2.0. DDX permet l'initialisation des contrôles graphiques dans une boîte de dialogue. DDV est un mécanisme de validation de données contenus dans les contrôles de la boîtes de la dialogue. Le cœur des DDX/DDV est la méthode membre DoDataExchange qui est appelée automatiquement par l'architecture d'application lorsque les données doivent est transférées ou validées.
Bien que se soit une méthode très utilisée, les DDX/DDV peuvent être spécialisé pour le support d'autres contrôles graphiques ( exemple: les VBX de Visual Basic), ou substituées par l'utilisation des API native de Windows.
Ce mécanisme a été utilisé en premier avec les boîtes de dialogue en MFC 2.0. En MFC 2.5, le mécanisme a été étendu pour permettre l'utilisation de contrôles graphiques d'accès aux bases de données dans des boites de dialogue dérivées de la classe CRecordView. Les DDX/DDV sont intégrés avec ClassWizard et permettent de définir les variables membres nécessaires et les routines DDX/DDV sans avoir à écrire une ligne de code.
Aide sensitive contextuelle
L'accès aux aides en lignes est essentiel dans la plupart des applications. MFC supporte deux façons d'accéder au fichier(s) .HLP. La première façon consiste à sélectionner l'item Sommaire du menu Aide. La seconde se fait par le biais de la touche F1. Lorsque l'utilisateur presse la touche F1, MFC traite automatiquement le message d'aide approprié. Un contexte d'aide est défini au niveau de la cible de commandes, et l'architecture d'application lance l'aide par défaut. Les classes CFrameWnd, CMDIFrameWnd, et CDialog fournissent l'accès aux fonctions d'aides. Chaque classe cible de commandes, a la possibilité de prendre en charge l'aide contextuelle. La pression de SHIFT+F1invoque le fichier d'aide en se positionnant sur le bon topic, défini par l'objet pointé. Les fichiers d'aides sont générés par des éditeurs capables de générer de fichier au format RTF, comme Microsoft Word.
Un haut niveau d'abstractions
MFC 1.0 fut le pionner de l'architecture d'application, en fournissant des classes réutilisables, mais n'était pas très abstrait et ne permettait pas un rapidité de développement comparé à C.
MFC 2.0 combla le fossé en apportant des classes supportant les contrôles graphiques le plus standard, et en prenant avantage des méthodes pré-codées. Ces classes permettent de réduire de façon considérable le temps de développement. En quelques lignes de programmation, il est possible de créer un éditeur de textes MDI, de changer la classe de vue de base en une vue gérant le scrolling. En plus d'une telle puissance, toutes ces classe de haut niveau peuvent être facilement modifiées en utilisant l'héritage fournit par C++.
Form View
La classe CRecordView des MFC 2.5 est construite à partir de la classe CFormView introduite avec MFC 2.0. CFormView supporte la plupart des fonctionnalités des applications nécessitant des boîtes de dialogue s'intégrant directement dans une fenêtre fille, rendant ainsi plus pratique l'iconisation ou la maximisation de celle ci. De plus, l'encapsulation de la boîte de dialogue dans une fenêtre permet le scrolling des contrôles graphiques présents sur celle ci. Ceci n'est pas possible dans une boîte de dialogue.
Un objet CFormView fourni une vue (une classe dérivée de CView) basée sur une ressource de boîte de dialogue, édité avec AppStudio. Il est possible d'introduire divers contrôles dans cette vue( VBX ...). L'utilisateur peut effectuer un scrolling sur la vue et ce déplacer sur chaque contrôles à l'aide de la touche Tab. L'avantage de la classe CFormView sur une boîte de dialogue standard, est qu'un objet CFormView s'intègre complètement avec l'architecture d'application de telle façon qu l'on peut directement utiliser les fonctions de gestion de document et de vue.
Edit View
CEditView est une simple vue éditeur de texte possédant toute les fonctionnalités d'un contrôle Edit standard Windows. Par défaut, CEditView supporte des fonctionnalités de haut niveau comme l'impression, l'aperçu avant impression, chercher et remplacer, couper, copier, coller, annuler ainsi que le fonctionnalités de fichier standard (ouvrir, sauver, sauver comme).
Etant donné que CEditView dérive de CView, toutes les fonctionnalités de l'architecture concernant les vues sont conservées.
Scrolling View
La plupart des application ne peut afficher q'une partie de leurs données sur l'écran au même moment. La classe CScrollView , qui est une autre classe de haut niveau dérivée de CView, supportes les vues, le scrolling, un zoom ( in ou out) de la vue permettant l'affichage de toutes les portions de la vue. En dérivant de CScrollView, une vue peut supporter le scrolling automatique. CScrollView gère les tailles de fenêtre, les modes de mapping pour le graphisme et plusieurs modes nécessaire à la technologie OLE 2.0, les messages commandes à destination de la barre de défilement.
Splitter Window
Dans une splitter window, la fenêtre peut être éclatée en 2 ou plusieurs panneaux supportant le scrolling. La splitter window permet d'ajuster la taille des divers panneaux. MFC fournit la classe CSplitterWnd de haut niveau pour la gestion des splitter window statiques ou dynamiques. Une splitter window dynamique permet à l'utilisateur de rajouter des panneaux tandis que le modèle statique impose une nombre de panneau constant. Chaque panneau est une vue, et peu être différente. En fait, chaque vue doit dérivée de la classe CView. Dans tous les cas, l'architecture d'application prend en charge l'aspect graphique des différentes vues.
Toolbars et Status Bar
L'un des éléments graphiques le plus répandu est sûrement la toolbar qui permet d'accéder plus facilement aux éléments d'un menu. MFC propose la classe CToolBar permettant de rattacher les contrôles graphiques telles que les listes, les cases à cocher ou les images. Les boutons de la toolbar se dessiner grâce à une ressource bitmap dessinée avec AppStudio.
Un des avantages majeurs de cette classe est la possibilité de gérer l'état actif/grisé des boutons et l'état de l'item de menu correspondant dans la méthode.
MFC fournit la classe CStatusBar pour la gestion des status bar. Les affichages dans cette portion de fenêtre se font suivant les sélection dans les menus.
Dialog Bar et Control Bars
La classe CDialogBar est comme une boîte non modale. Les Dialog bars supportent le déplacement des contrôles via la touche Tab et peuvent être alignés par rapport à la fenêtre principale. Le meilleur exemple est interface de l'aperçu avant impression.
Les classes CToolBar, CStatusBar, et CDialogBar dérivent toutes de la classe de base CControlBar. L'abstraction des MFC permet la réutilisation du code fournit dans cette classe.
Support OLE 1.0
MFC 1.0 et MFC 2.0 supporte la technologie OLE 1.0. Ces classes sont obsolètes depuis MFC 2.5 avec l'apparition de la version OLE 2.0 de ces classes.
VBX 1.0 Contrôles
Les contrôles de Visual Basic (.VBX) sont supportés par la classe CVBControl.
Les classes pour l'API Windows
MFC rend plus simple la programmation Windows en fournissant une classe permettant la création automatique d'une application Windows. C'est la classe CWinApp.
Fenêtre principales
MFC supporte les interfaces MDI et SDI. La gestion de ces fenêtres est en partie assurée par l'architecture d'application. Les fenêtres principales sont gérées par la classe template de document dans les applications qui tirent parti du modèle Document/Vue. Une vue est contenue dans une fenêtre principale ( généralement CFrameWnd ou CMDIChildWnd).
Information de type Run-Time
Tous les objets MFC dérivent directement ou indirectement de la classe CObject. Cette classe fournie des informations sur l'état des objets, des macros d'assertion pour les erreurs.
Persistance des objets
La classe CArchive par le biais de sa méthode Serialize effectue le travail.
Classes Collection
MFC permet la gestion des listes d'objets ou de types suivants: UINT, BYTE, WORD, DWORD, void*, CObject* , et CString. Cette dernière est spécialisée dans le traitement des chaînes.
La dernière version des MFC est livrée avec Visual Studio 6.0 service pack 3.0. Ce sont les MFC 6.1.
