Visual C++ 2010 premières impressions

On peut constater un changement de couleur général de l'interface orientée sur la couleur bleue.

Je n'ai pas constaté de problèmes de lenteur, cette version se comporte normalement.

Comme vous l'avez peut être appris, cette nouvelle version ne travaille plus avec le fichier .ncb mais utilise une base SQL (locale) pour tenir les informations relatives aux classes (classview) et d'IntelliSense.
En cas de problèmes nous étions habitués à supprimer le .ncb dorénavant une nouvelle commande apparait dans le menu projet pour scanner la solution.


Donc plus de fichier .ncb , mais un fichier qui porte l'extension .SDF qui est un fichier exploité par SQL Server Compact database.
Un onglet de paramétrage de l'IntelliSense a été rajouté dans les options :



Une section qui peut être intéressante à modifier est la " fallback location ".
Par défaut l'ide utilise le répertoire de votre solution pour stocker les fichiers .SDF en indiquant un répertoire dans la rubrique " fallback location " l'ide utilisera cet emplacement pour créer ses fichiers.
N'oubliez pas de paramétrer votre anti-virus pour exclure ce fichier de l'analyse.
IntelliSense a aussi évolué puisqu'il donne maintenant des informations sur la validité ou la cohérence du code écrit,
Exemples :



Ou encore :


A l'usage cette fonctionnalité est très pratique, d'un simple coup d'œil je sais que mon code ne compilera pas m'évitant ainsi de lancer la compilation pour voir les erreurs…

La réponse est oui, il est maintenant possible de distribuer son programme dans un répertoire avec les DLL MFC et celle de la CRT.
Il ne sera donc plus nécessaire à priori d'utiliser vcredist .

- La nouvelle interface utilise WPF, le premier apport important est le zoom vectoriel rendu possible sur un fichier source.
Il suffit d'utiliser la molette de la souris avec la touche CTLR enfoncée pour zoomer sur le texte.
- Gestion des projets récents :



Les projets ouverts peuvent être punaisés comme sur la barre d'outils de Seven.

- Nouvelles possibilités de l'interface MDI :

Le menu contextuel sur l'onglet du document donne de nouvelles fonctionnalités :



Une fonctionnalité qui me manquait depuis longtemps : la commande " float " qui permet de détacher la fenêtre des onglets MDI, cela permet de disposer un élément en dehors de l'interface de l'éditeur.
Cette fonctionnalité s'applique bien sûr aux autres éléments de l'interface comme le gestionnaire de projets ou par exemple un fichier source :


Les fenêtres de l'interface se ferment par la croix directement disponible sur l'onglet :


- Personnaliser la page d'accueil de Visual Studio

Quand j'ai commencé à m'intéresser à ce sujet sur les versions bêta il fallait travailler sur un fichier au format XAML, avec la RC exit le format XAML retour au XML

Les fichiers à modifier sont situés à l'emplacement d'installation de Visual Studio 2010, ce qui donne sur ma machine :
D:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\StartPages\en
Il y a un fichier par type d'environnement, dans mon cas j'ai modifié le fichier Links.Ultimate.VC.xml.
Rajouter une nouvelle section est un jeu d'enfant, et je me suis concocté une nouvelle section pour rester connecté avec ma tribu :



L'image est une capture au format .png de la page d'accueil de developpez.com,
J'ai ensuite rajouté la section suivante juste en dessous de celle de " Community and Learning Resources "

    <item>
        <title id="welcome_developpez_title">Communauté developpez.com</title>
        <image>D:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\StartPages\en\developpez.PNG</image>
        <description id="welcome_developpez_desc">le club des professionnels de l'informatique</description>
        <commands>
          <command>
            <commandtype>Browse</commandtype>
            <title id="welcome_developpez_cmd1_title">La Faq Visual C++</title>
            <parameter>http://cpp.developpez.com/faq/vc/</parameter>
          </command>
          <command>
            <commandtype>Browse</commandtype>
            <title id="welcome_developpez_cmd2_title">La Faq C++</title>
            <parameter>http://cpp.developpez.com/faq/cpp/</parameter>
          </command>
          <command>
            <commandtype>Browse</commandtype>
            <title id="welcome_developpez_cmd3_title">Forums Visual C++</title>
            <parameter>http://www.developpez.net/forums/f29/c-cpp/outils-c-cpp/visual-cpp/</parameter>
          </command>          
        </commands>
      </item>

A mon avis la solution retenue en XML est plus simple que la précédente en .XAML.
- Cibler une autre plateforme de construction du projet :



Il est possible de spécifier Visual 9.0 pour la construction du binaire de votre application, dans ce contexte Visual 2010 utilisera Visual 2008 (qui devra être présent sur la machine) pour construire le projet.

Avant vous définissiez vos différents chemins de recherche pour les sources, bibliothèques etc dans le menu options de Visual.
Et bien c'est fini, ce paramétrage a migré dans votre projet !


Vous pouvez exporter le paramétrage des chemins de recherches définis globalement dans Visual studio 2008 pour les réintégrer dans Visual 2010.
Au final dans chaque nouveau projet ou projet migré on retrouve l'ensemble des chemins de recherche dans les différentes sections, pour ma part je trouve ça gênant :



Pour définir globalement vos chemins de recherche il existe plusieurs solutions :
Pour les définir par l'ide il faut appeler à partir d'un projet l'option View / property manager.



L'item Microsoft.Cpp.Win32.user.props contient la définition des chemins par défaut.
Il est possible de modifier directement ce fichier au format xml stocké par utilisateur.
Il est situé à l'emplacement (sous seven):
C:\Users\user\AppData\Local\Microsoft\MSBuild\v4.0
En voici un exemple vierge de toutes modifications:

<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <ExecutablePath>$(ExecutablePath)</ExecutablePath>
    <IncludePath>;$(IncludePath)</IncludePath>
    <ReferencePath>$(ReferencePath)</ReferencePath>
    <LibraryPath> $(LibraryPath)</LibraryPath>
    <SourcePath>$(SourcePath)</SourcePath>
    <ExcludePath>$(ExcludePath)</ExcludePath>
  </PropertyGroup>
</Project>

Il vous faudra donc rajouter toutes vos définitions globales dans ce fichier en séparant les chemins par des " ; ", ou en passant par l'interface de l'IDE.

Bon on arrive au même fonctionnement qu'avec Visual Studio 2008, la différence est que le paramétrage a migré dans un fichier stocké par utilisateur, ce qui je trouve gênant c'est la pollution par défaut des chemins de recherche dans le projet.
Je ne comprends pas bien pourquoi ces choix ont été fait, je trouve cela bien compliqué, l'ancien système avait le mérite d'être clair.

- La classe CTaskDialog

Cette nouvelle classe permet de définir rapidement des boîtes à messages plus évoluées que la classique boîte de dialogue obtenue par la fonction MessageBox.
Cette nouvelle classe de dialogue ne sera disponible qu'avec Windows Vista et Seven,
c'est une encapsulation directe de l'api Win32, la méthode DoModal appelle directement dans COMCTL32.DLL la fonction TaskDialogIndirect.

Un petit exemple ?
J'ai rajouté ces quelques lignes dans mon projet de tests sur un bouton d'une FormView :

void Ctestvc2010View::OnBnClickedButtontaskdlg()
{
// TODO: Add your control notification handler code here	
CTaskDialog dlg(_T("Une CTaskDialog présente des informations d'une manière claire et cohérente"), _T("Que pensez-vous de CTaskDialog?"), _T("Exemple CTaskDialog"), 0,
                     TDF_ENABLE_HYPERLINKS | TDF_USE_COMMAND_LINKS , _T("J'espère que vous l'aimez!"));

       dlg.AddCommandControl( 10, _T("&Utilisez-la!\nC'est la meilleure boîte dialogue que vous pouvez avoir!!"));
       dlg.AddCommandControl( 20, _T("&Peut-être?\nVous ne voulez pas l'essayer ?"));
       dlg.AddCommandControl( 25, _T("&Aucune chance!\nJe ne vais pas l'utiliser!"));

       dlg.AddRadioButton( 3, _T("Beaucoup"));
       dlg.AddRadioButton( 7, _T("Un Petit peu "));
       dlg.AddRadioButton( 4, _T("Pas du tout"));
    
       dlg.SetMainIcon(TD_SHIELD_ICON);
       dlg.SetFooterIcon(TD_INFORMATION_ICON);
       INT_PTR nResult = dlg.DoModal();
	  
}

C'est une traduction directe de l'exemple que l'on peut trouver sur le blog de l'équipe Visual US.
Un aperçu du résultat (sous Seven):



- Redémarrage de l'application après un crash

Ce système que vous avez peut être déjà expérimenté dans office 2007 ou Visual Studio permet de relancer l'application avec une restauration de l'environnement de travail, celui-ci étant régulièrement sauvegardé par l'application.
La bibliothèque MFC implémente donc maintenant ce mécanisme qui devient une option de l'assistant à la génération du programme.

- DPI Awareness:

Cette option permet d'adapter le texte et les contrôles de nos applications MFC en fonction du réglage des fontes Windows :



La petite fonte correspondant à 96 dpi, la moyenne à 120 dpi et la grande à 144 dpi.
Cette option est intégrée directement dans le réglage de nos projets :



- Transaction sur les opérations fichiers et sur les fonctions associées à la base de registres:
Une nouvelle classe ATL CAtlTransactionManager permettant de gérer les transactions des fichiers a été rajoutée.
Les différentes classes MFC de manipulations de fichier ou de répertoires ont été modifiées pour supporter cette fonctionnalité.

CFile(CAtlTransactionManager *);
CStdioFile(CAtlTransactionManager *);
CAtlFile(CAtlTransactionManager *);
CFileFind(CAtlTransactionManager *);

Les apis : AfxRegCreateKey, AfxRegOpenKey, AfxRegDeleteKey disposent désormais d'un paramètre TransactionManager.

Exemple avec AfxRegCreateKey :

LONG AFXAPI AfxRegCreateKey(HKEY hKey, LPCTSTR lpSubKey, PHKEY phkResult, CAtlTransactionManager* pTM = NULL);

Cet exemple issu du blog US de Visual Studio illustre l'utilisation de la transaction (commit) et du retour arrière (rollback) :

 CAtlTransactionManager tmCommit;
 CFile cfile1(_T("c:\\TransactionFileSystemDemo\\cfile1.txt"), CFile::modeCreate, &tmCommit);

 CStdioFile stdiofile1(_T("c:\\TransactionFileSystemDemo\\cstdiofile1.txt"), CFile::modeCreate, &tmCommit);

 CAtlFile atlfile1(&tmCommit);
 atlfile1.Create(_T("c:\\TransactionFileSystemDemo\\atlfile1.txt"), STANDARD_RIGHTS_REQUIRED, FILE_SHARE_READ, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL);

 tmCommit.Commit();
 tmCommit.Close(); 

CAtlTransactionManager tmRollback;
CFile cfile2(_T("c:\\TransactionFileSystemDemo\\cfile2.txt"), CFile::modeCreate, &tmRollback);
 CStdioFile stdiofile2(_T("c:\\TransactionFileSystemDemo\\cstdiofile2.txt"), CFile::modeCreate, &tmRollback);
 CAtlFile atlfile2(&tmRollback);

 atlfile2.Create(_T("c:\\TransactionFileSystemDemo\\atlfile2.txt"), STANDARD_RIGHTS_REQUIRED, FILE_SHARE_READ, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL);

 tmRollback.Rollback();
tmRollback.Close();

- Le support du multi-touch

Les applications MFC peuvent prendre en compte le multi-touch de Windows Seven.
Voici rapidement comment procéder :
Dans la méthode InitInstance de votre classe d'application rajouter les lignes suivantes pour tester le support matériel du multi-touch :

BYTE digitizerStatus = (BYTE) GetSystemMetrics(SM_DIGITIZER);
if ((digitizerStatus & (0x80 + 0x40)) == 0) //Stack Ready + MultiTouch
{
 AfxMessageBox(L"Pas de périphérique Multi-Touch disponible");
	 return FALSE;
}	 
BYTE nInputs = (BYTE) GetSystemMetrics(SM_MAXIMUMTOUCHES);	 
CString str;
str.Format(L"Périphérique Multi-Touch disponibl avec  %d points.", nInputs);
//AfxMessageBox(str);

Pour indiquer que votre application cliente est apte a recevoir les messages Multi-Touch il faudra appeler la méthode CWnd::RegisterTouchWindow() le message WM_CREATE de votre fenêtre fille (la child ) de traitement.

int CChildFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CMDIChildWndEx::OnCreate(lpCreateStruct) == -1)
		return -1;
	if (!RegisterTouchWindow()) return -1;
}

L'appel de cette méthode rend l'application capable de recevoir les messages WM_TOUCH .
Il vous faut ensuite rajouter manuellement dans la child la méthode suivante :

virtual BOOL OnTouchInput(CPoint pt, int nInputNumber, int nInputsCount, PTOUCHINPUT pInput);

Cette méthode va nous permettre de traiter les différents événements possibles:

BOOL CChildView::OnTouchInput(CPoint pt, int nInputNumber, int nInputsCount, PTOUCHINPUT pInput)
{    
   if ((pInput->dwFlags & TOUCHEVENTF_DOWN) == TOUCHEVENTF_DOWN) // Touch Down event
   {
        // votre traitement
	return TRUE;
   }
   else if ((pInput->dwFlags & TOUCHEVENTF_MOVE) == TOUCHEVENTF_MOVE) // Touch Move event
   {
        // votre traitement
	return TRUE;
   }
   else if ((pInput->dwFlags & TOUCHEVENTF_UP) == TOUCHEVENTF_UP) // Touch Move event
   {
        // votre traitement
	return TRUE;
   }
	 
   return FALSE;
}

Voila pour la mise en place de l'architecture il ne reste plus qu'à mettre en place votre traitement.

- Le retour de Class Wizard.

Cet outil présent dans Visual 6.0 a été enlevé avec Visual 2002, il fait son grand retour dans Visual studio 2010.
Il faut dire que cela fait des années que tout le monde le réclame.

Le raccourci clavier n'est pas le même que sous Visual 6.0 (CTRL+X) mais CTRL+MAJ+X
On retrouve enfin les mêmes fonctionnalités dont nous disposions sous Visual 6.0.

Pour ceux qui n'ont pas connu class wizard c'est une boite à onglet permettant de réaliser l'ensemble des opérations possibles sur une classe fenêtre : messages, ajout de données membres etc …
Plutôt que de courir à différents endroits pour effectuer des opérations tout est disponible dans un seul outil, et surtout plusieurs actions peuvent être réalisées en même temps comme l'ajout de plusieurs variables associées à des contrôles, ce qui n'était pas (plus) le cas avant.



- Image de fond dans les dialogues :
Il est maintenant possible de rajouter une image en fond d'une boîte de dialogue avec la " mockup bar " , celle-ci est disponible en bas de l'éditeur de ressources.


Un clic sur le bouton de parcours de fichier dans la barre permet de sélectionner une image que l'on pourra positionner grâce aux zones d'offset et régler l'opacité.
Malgré cela je ne peux que regretter l'absence d'un dispositif permettant de régler la couleur de fond d'une boîte de dialogue ou d'une FormView.

- Autorisation d'affichage des Activex dans l'éditeur de ressources:
Si des Activex sont présents dans vos ressources, Visual vous demandera l'autorisation de les afficher. (Ce qui risque à la longue de devenir fatiguant).

Certains d'entre vous ont du remarquer depuis Visual 2008 l'absence de l'application qui permettait de tester un Activex, celle-ci est en fait disponible dans les exemples des MFC Situés à l'emplacement suivant :
Pour VS2008 : [Program Files]\Microsoft Visual Studio 9.0\ Samples\1033\AllVCLanguageSamples.zip
Pour VS2010: [Program Files]\Microsoft Visual Studio 10.0\Samples\1033\VC2010Samples.zip
L'exemple se nomme TSTCON dans le dossier OLE.


Un clic sur le bouton de parcours de fichier dans la barre permet de sélectionner une image que l'on pourra positionner grâce aux zones d'offset et régler l'opacité.
Malgré cela je ne peux que regretter l'absence d'un dispositif permettant de régler la couleur de fond d'une boîte de dialogue ou d'une FormView.

- Autorisation d'affichage des Activex dans l'éditeur de ressources.
Si des Activex sont présents dans vos ressources, Visual vous demandera l'autorisation de les afficher. (Ce qui risque à la longue de devenir fatiguant).

Certains d'entre vous ont du remarquer depuis Visual 2008 l'absence de l'application qui permettait de tester un Activex, celle-ci est en fait disponible dans les exemples des MFC
Situés à l'emplacement suivant :
Pour VS2008 : [Program Files]\Microsoft Visual Studio 9.0\ Samples\1033\AllVCLanguageSamples.zip
Pour VS2010: [Program Files]\Microsoft Visual Studio 10.0\Samples\1033\VC2010Samples.zip
L'exemple se nomme TSTCON dans le dossier OLE.


- Prévisualisation des documents dans la barre de Windows Seven



J'ai généré une application multi document MFC avec une CEditView , comme vous le voyez sur l'exemple ci-dessus j'ai ouvert trois onglets dans mon application MFC qui deviennent visibles dans la barre d'application de Windows Seven.
De plus, le clic sur le document dans la barre des taches active l'onglet correspondant dans l'application.
Au moment de la génération de l'application j'ai aussi coché les options de prévisualisation du document et de l'affichage simplifié :



Ces options permettent la prévisualisation du document dans l'explorateur Windows, son affichage simplifié (Thumbnail) et la recherche de contenu.
Toute la logique de traitement est générée automatiquement dans la classe document, il faudra adapter ce code pour vos documents.

- Programmation du Ruban (ribbon) :

Le ruban est maintenant directement éditable dans l'éditeur de ressource, sa description est au format XML.
Sa composition est donc moins laborieuse que dans Visual 2008 ou il fallait tout coder manuellement :



L'ensemble des contrôles nécessaires à la création du ruban est donc disponible dans la boîte à outils.
Une remarque personnelle : le ruban c'est beau mais ne se prête pas à toutes les applications ; Les écrans d'aujourd'hui sont pratiquement tous au format large (wide) et la perte de surface en hauteur provoquée par ce style d'interface est très pénalisante.
Il serait intéressant (c'est un appel du pied) de disposer de la même interface à la verticale de l'écran…

Le tableau ci-dessus expose les avancées du support de C++0x pour Visual 2010 par rapport à Visual 2008.

Cette bibliothèque permet de paralléliser des applications natives en C++, elle rentre en concurrence avec celle d'Intel : TBB. (voir mon compte rendu des Techdays 2008)

La bonne nouvelle c'est qu'Intel utilisera pour la partie Windows le moteur d'exécution de Microsoft : le Concurrency Runtime.
Cette bibliothèque adopte le style standard de la Template Librairie (STL) tout en tirant parti des nouvelles caractéristiques du standard C++0x avec notamment les expressions lambda.
En voici un aperçu express des différentes fonctionnalités :
On peut distinguer quatre parties :

a) Le parallélisme de tache
o task_handle
o task_group

b) Les primitives de synchronisation
o reader_writer
o enter_critical
o Event

c) Les algorithmes
o parallel_for
o parallel_for_each
o parallel_invoke
o parallel_accumulate

d) Les containeurs avec gestion de la concurrence
o concurrent_queue
o concurrent_vector
o concurrent_unordered_map
o combinable

Il est à noter que le débuggeur de Visual studio a été remanié pour tenir compte du parallélisme avec une vision par thread par tache etc.



Voila pour l'essentiel je vous invite à consulter MSDN pour plus d'informations.

Beaucoup de nouveautés et de points positifs pour ce produit qui va pointer son nez très bientôt dans sa version définitive (mi avril).
Nouvelles fonctionnalités, confort d'utilisation de l'IDE amélioré, Visual 2010 est en nette évolution par rapport à Visual 2008.

Voila pour ce tour d'horizon rapide pour découvrir les principales nouveautés de l'interface de Visual Studio 2010 et les nouveautés liées au C++.

Je remercie toute l'équipe C++, pour leur relecture attentive du document, notamment PetitPapaNoël Merci à jbarreau-mainson pour la correction finale de cet article