Par exemple, j’ai un textbox sur ma form qui est associé à une chaine (String) dans ma classe. Toute modification de ce textbox entraine automatiquement une modification de ma chaine. Inversement, toute modification de cette chaine en code, implique une répercution visuelle sur la valeur du textbox.

Voici comment implémenter un tel binding :

Le principe est d’utiliser l’interface INotifyPropertyChanged. L’appel de l’événement PropertyChanged permet d’informer que la valeur a changé et automatiquement répercuter ce changement.

Voici comment faire en C++/CLI (plus loin, la version C#) :

Tout d’abord, la form doit implémenter INotifyPropertyChanged

public ref class Form1 : public System::Windows::Forms::Form, INotifyPropertyChanged

Ceci implique de définir l’événement suivant :

virtual event PropertyChangedEventHandler ^PropertyChanged;

Il nous faut ensuite une propriété de type String. C’est cette propriété qui sera bindée à notre TextBox :

On note l’appel à la méthode NotifyPropertyChanged pour indiquer une changement de valeur.

La méthode NotifyPropertyChanged appelle l’événement PropertyChanged pour signaler le changement afin qu’il soit répercuté à tous les endroits où le binding est effectué.

Ne pas oublier de définir le binding, au plus tot, dans le form_load par exemple :
textBox1->DataBindings->Add("Text", this, "Chaine");

Et le tour est joué.

Voici la syntaxe pour du C# :

public partial class Form1 : Form, INotifyPropertyChanged

Pour enregistrer le contenu d’un textbox avec une SaveFileDialog, il suffit d’utiliser le stream fournir par OpenFile :

C’est tout

Accéder au tutoriel pour travailler avec les fichiers de configuration en C#

Si des mots comme XAML , classes partielles, etc … vous disent quelque chose, c’est que vous avez eu le plaisir de gouter à cette nouvelle forme de développement en C#. Mais quid du C++/CLI ?

Et bien, pas grand chose justement ; il n’y a pas de support du C++/CLI pour faire des développements .Net 3.0, et donc pas d’intégration dans visual studio ; c’est le cas au jour d’aujourd’hui, gageons qu’avec l’avénement d’orcas, il y ait des choses faite dans le sens du C++.

Mais est-ce que ca veut dire que rien n’est faisable en C++/CLI ? Etant donné que le C++/CLI est un langage comme un autre qui peut utiliser le framework.net, qu’est-ce qui pourrait nous empecher de faire des développements WPF ? Et bien, plusieurs choses justement, le fait par exemple que le C++/CLI ne supporte pas les classes partielles (même si ce n’est pas limitatif) et que CodeDom ne sache pas convertir le XAML en C++.

Tout ca pour dire que Visual C++ ne permet pas d’utiliser du XAML, mais rien n’empeche d’utiliser Visual C++ pour faire des applications WPF.

C’est ce que je vais vous montrer dans ce billet, et surement dans d’autres …

Tout d’abord, il faut être capable d’utiliser le framework 3.0, il faut donc installer le Microsoft .NET Framework 3.0 Redistributable Package. Et ensuite le Microsoft® Windows® Software Development Kit for Windows Vista™ and .NET Framework 3.0 Runtime Components.

Voilà, vous êtes prêt à développer des applications WPF en C++/CLI.

Tout d’abord, créez un nouveau projet clr vide.
Rajoutez les références vers

System
PresentationCore
PresentationFramework
WindowsBase

Enfin dans les propriétés du projet, changez le sub-system à Windows (sinon vous aurez une console qui trainera …) (linker-> system -> subsystem) et définissez un point d’entrée (main par exemple) (linker -> Advanced -> Entry point).

Il y a plusieurs techniques pour créer une application WPF, plus ou moins adpatées à vos besoins. Je vais commencer par vous décrire la plus simple à mettre en place, sans utiliser de XAML. Il va s’agir de créer les composants de notre fenêtre « à la main », sur le même principe qu’un programme WinForms, mais sans être aidé de l’IDE…

Il faut savoir que le framework se base sur la Classe Window qui se trouve dans les références que nous avons ajouté à la création du projet. Pour créer notre propre fenêtre, nous allons donc créer une classe qui va dériver de cette classe de base (un peu comme pour les winforms, où l’on hérite de Form).

Alors, qu’y a-t-il de beau la dedans ?
Notre classe MaFenetre qui dérive de Window ; des contrôles (Canvas, TextBox et Button) ; leurs instanciations et le renseignement de leurs attributs ; l’ajout d’un événement associé au clic du bouton et une fonction qui va s’occuper de faire quelque chose quand on clic sur ce bouton.
Comme vous le voyez, ca ressemble beaucoup aux Winforms, à part que pour l’événement, on se sert de RoutedEventArgs. . Notez aussi que le Canvas est simplement un conteneur de contrôles.

Voilà pour la fenêtre, plutôt simple non ?

Nous avons maintenant besoin d’un objet d’application, créons donc une classe qui dérive de Application. La classe d’application a pour but de fournir les fonctionnalités pour démarrer une application WPF.
Voyons le code :

On dérive de Application, on surchage a méthode OnStartup, qui, vous l’aurez devinée, est appelée au démarrage de l’application. C’est ici donc que nous instancions notre fenêtre et qu’on l’affiche (méthode Show()).

Il ne reste plus qu’à définir le point d’entrée, main :

On instancie la classe d’application et on appelle la méthode Run().

Et voilà, c’est fini. Compilez, lancez l’application, rentrez un mot dans la textBox et cliquez, vous obtiendrez cette minimale application WPF.

Vous voilà prêt à démarrer dans la programmation WPF avec le C++/CLI. Notez quand même que nous n’utilisons pas de XAML et que tous les contrôles sont créés à la main, ce qui nous prive d’un des avantages du XAML, à savoir la séparation du code technique de la présentation.

Mais cette technique peut s’avérer suffisante pour certains besoins et certains types d’application. Nous verrons plus tard comment intégrer du XAML dans un projet C++/CLI.

Vous me direz : quel intéret d’utiliser le C++/CLI pour faire des applications WPF ? et vous aurez raison de vous poser cette question. A part pour le sport, la bonne raison d’utiliser le C++/CLI pour faire des applications WPF est la fantastique capacité du C++/CLI à gérer l’intéropérabilité avec des applications natives. Ainsi, si votre application C++ native a besoin d’un petit lifting ou de pouvoir accéder au framework.net 3, vous saurez comment faire …

Télécharger le programme d’exemple.

Bonne prog,

Nico

Imaginons que nous voulions faire une application qui ouvre une fenetre qui possède un textBox et un bouton. Lors du click sur le bouton, on affiche une deuxième form qui possède elle aussi un bouton et un textBox (ca aurait pu etre un label). On souhaite lors du clic sur le bouton de la deuxième form afficher la valeur saisie dans le textBox de la première form…

Voici comment on peut faire :

Dans la form1, je dépose le textBox1 et le boutton
J’ajoute une nouvelle form, Form2 dans laquelle je mets le textbox et le bouton.

le but est de pouvoir lire la valeur saisie dans la Form1 depuis la Form2 sachant que c’est la form1 qui va créer la form2.

Donc, en toute logique, dans la form1, on va avoir à un endroit la création et l’affichage de la form2. Comme il faut que la form2 connaisse la form1, on va lui passer l’objet form1 (c’est à dire this), disons dans le constructeur :

Dans la form2, on aura donc fatalement la récupération de la form1 dans le constructeur :

et au moment de récupérer la valeur, on aura un

textBox1->Text = currForm1->GetValeur();

GetValeur sera bien sur une méthode publique de form1 :

Tant est si bien que dans Form1.h, on va devoir faire un

#include "Form2.h"

pour pouvoir instancier la form2

et dans la Form2.h, on va devoir faire un

#include "Form1.h"

pour pouvoir utiliser la form1

Si vous essayez de compiler directement comme ca, il va y avoir une tripotée d’erreurs, la plus significative étant qu’il ne connait pas Form2, avec une erreur du genre dans Form1.h :
error C2143: erreur de syntaxe : absence de ‘;’ avant ‘^’ sur la ligne

Form2 ^ currForm2;

Comme on s’en doute, chaque fichier incluant l’autre, il y a des inclusions croisées qui empechent la bonne compilation.

Pour que ceci compile, il faut plusieurs choses :
Déjà, déporter l’impémentation des méthodes des classes dans un .cpp (plus précisément, toutes celles qui utilisent des méthodes ou des attributs de Form2 pour le fichier form1.h et toutes celles qui utilisent des méthodes ou des attributs de Form1 pour form2.h).

Donc, il faut créer un fichier Form1.cpp (form2.cpp étant généré automatiquement lors de l’ajout d’une nouvelle form).

Dans mon .h, j’ai donc laissé la définition des méthodes :

et dans le .cpp, j’ai mis l’implémentation des méthodes :

NB : ne pas oublier le namespace, ni l’opérateur de résolution de portée.

Idem dans form2.h

private: System::Void button1_Click(System::Object^  sender, System::EventArgs^  e);

et dans le Form2.cpp

Voilà pour le premier point.

Il reste encore à faire une chose pour que ca compile, c’est faire une déclaration anticipée de Form1 dans le fichier Form2.h.
par exemple, en premier dans le namespace

ref class Form1;

il restera plus qu’à faire de meme dans le fichier form1.h : déclarer form2 de cette facon :

ref class Form2;

Compilez mainteant, tout est ok

Télécharger le projet example

Bonne prog,

Nico