WPF 4.0 introduit plusieurs nouveautés. L’une d’elle permet de changer le style de la sélection des zones de textes et le style du curseur d’insertion.

Avant WPF 4.0, nos zones de textes ressemblaient à ceci :

Sélection de texte

Curseur d’insertion 

 

Maintenant il nous est possible de faire (ça me rappelle la sélection texte de Blend :)):

Pour la sélection de texte, la propriété SelectionBrush permet de changer la couleur de sélection, l’opacité… etc, cette propriété “DependancyProperty” est disponible dans chaque contrôle héritant de TextBoxBase.

Pour reproduire la sélection visible dans l’image ci-dessus :

<TextBox.SelectionBrush>
    <LinearGradientBrush EndPoint="0,1" StartPoint="0,0">
        <GradientStop Color="#00314f" Offset="0"/>
        <GradientStop Color="#9eb2c4" Offset="0.375"/>
        <GradientStop Color="#9eb2c4" Offset="0.375"/>
        <GradientStop Color="#00314f" Offset="1"/>
    </LinearGradientBrush>
</TextBox.SelectionBrush>

Ici j’utilise un LinearGradientBrush, mais vous pouvez aussi très bien passer par d’autres pinceaux, avec les propriétés BitmapCacheBrush, DrawingBrush, ImageBrush, RadialGradientBrush, un SolidColorBrush ou bien un VisualBrush.

CaretBrush est à peu de chose près la même propriété que SelectionBrush, la différence est que celui ci est prévu pour le curseur d’insertion.

<TextBox.CaretBrush>
    <SolidColorBrush Color="DarkGray"></SolidColorBrush>
</TextBox.CaretBrush>

Comme nous pouvons le constater, c’est très simple à mettre en place. Par contre, il faut faire attention à l’accessibilité de notre application.

A bientôt :)

En parcourant Codeplex, j’ai trouvé un control sympathique reproduisant l’interface utilisateur d’Office 2010. Bien sûr, il existe aussi le control de Microsoft mais il reproduit que l’interface d’Office 2007 et qu’en version CTP.
Ce control est vraiment simple et rapide, et en licence MS-PL ! :-)


Pour télécharger le control, rendez-vous sur sa page codeplex.

A bientôt,
Mathieu

Apparu sous Windows Vista et Windows Server 2008, l’API Application Recovery & Restart (ARR) vous permet de « ressusciter » vos applications.

Vous pouvez utiliser cette API dans le cas où vous voulez sauvegarder les données et l’état de votre application avant que celle-ci ne plante complètement (exception, freeze de l’interface… etc).

Pour illustrer cette API, je vais utiliser un exemple basique d’un champ de texte multiligne où des données peuvent être saisies par l’utilisateur et un bouton permettant de simuler le crash de l’application.

En premier lieu nous allons faire un peu d’interop :

internal static class ApplicationRecoveryNativeMethods
{
    internal delegate int ApplicationRecoveryCallback(IntPtr pvParameter);

    [DllImport("kernel32.dll")]
    internal static extern void ApplicationRecoveryFinished
                               ([MarshalAs(UnmanagedType.Bool)] bool success);

    [DllImport("kernel32.dll")]
    [PreserveSig]
    internal static extern uint ApplicationRecoveryInProgress
                      ([Out, MarshalAs(UnmanagedType.Bool)] out bool canceled);

    [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
    [PreserveSig]
    internal static extern uint RegisterApplicationRecoveryCallback
       (IntPtr pRecoveryCallback, IntPtr param, uint pingInterval, uint flags);

    [DllImport("kernel32.dll")]
    [PreserveSig]
    internal static extern uint RegisterApplicationRestart
      ([MarshalAs(UnmanagedType.BStr)] string commandLineArgs, RestartFlags flags);
}

Ensuite, j’ai déclaré une classe en static qui simplifie l’accès à ces méthodes :

public static class ApplicationRecovery
{
    // Renvoie cette chaîne lors du redémarrage de l'application suite au plantage
    public const string COMMAND_LINE = "{8B2A75FA-FFD6-487A-A27B-3C28A9243C46}";

    public delegate void ApplicationCrashHandler();
    public static event ApplicationCrashHandler OnApplicationCrash;

    private static 
     ApplicationRecoveryNativeMethods.ApplicationRecoveryCallback RecoverApplication;

    public static bool RegisterApplicationRestart()
    {
        uint val = ApplicationRecoveryNativeMethods
                  .RegisterApplicationRestart(COMMAND_LINE, RestartFlags.NONE);
        if (val == 0)
        {
            // On indique le callback
            RecoverApplication = 
            new ApplicationRecoveryNativeMethods.ApplicationRecoveryCallback(Recovery);
            // On enregistre le callback et on indique au système le temps 
           // approximatif de recovery (ici 30sec)
            val = ApplicationRecoveryNativeMethods.RegisterApplicationRecoveryCallback(
                  Marshal.GetFunctionPointerForDelegate(RecoverApplication), 
                  IntPtr.Zero, 30000, 0);
        }
        return val == 0;
    }

    private static int Recovery(IntPtr ptr)
    {
        if (OnApplicationCrash != null)
        {
            OnApplicationCrash();
            // Indique que tout est fini
            ApplicationRecoveryNativeMethods.ApplicationRecoveryFinished(true);
        }
        return 0;
    }
}

Et ensuite dans mon projet exemple, j’utilise la classe ci-dessus :

// On peut aussi tout simplement se baser sur le fichier de recovery
// s'il existe ou non

//bool isRecovery = false;
//if (File.Exists("recovery_xxxxxx.xxx"))
//{
//    isRecovery = true;
//}

bool isRecovery = false;
if (args.Length > 0)
{
    if (args[0] == Recovery.ApplicationRecovery.COMMAND_LINE)
    {
        isRecovery = true;
    }
}

MainWindow win = new MainWindow(isRecovery);

Recovery.ApplicationRecovery.OnApplicationCrash += 
             new Recovery.ApplicationRecovery.ApplicationCrashHandler
                        (win.ApplicationRecovery_OnApplicationCrash);
if (!Recovery.ApplicationRecovery.RegisterApplicationRestart())
{
    MessageBox.Show("Error blabla");
}
SampleApplication.App app = new SampleApplication.App();
app.Run(win);

Note : pour des raisons « pratiques », la restauration et le redémarrage de l’application n’est possible qu’au bout de 60 sec (sinon, si dans le cas où ça plante direct au démarrage, on redémarre en boucle).

Télécharger mon projet exemple ici.

A bientôt,

Mathieu

Je dispose depuis quelques temps d’un nouvel utilitaire dans ma boîte à outil : il s’agit de NDepend. Ce logiciel est développé par Patrick Smacchia (MVP). Je tiens d’ailleurs à le remercier pour m’avoir fait découvrir son outil.

Avec NDepend, vous pouvez explorer en détail la complexité de votre code grâce à son langage (CQL) très proche du SQL. Si vous devez travailler sur des projets complexes avec plusieurs développeurs, ou que vous avez des besoins de refactoring, cet outil devient vite indispensable car vous avez une vue précise du projet, de sa qualité, et vous pouvez l’explorer à votre guise.

Voici un exemple de rapport généré ici (testé sur BlogEngine.NET).

Par exemple, vous voulez afficher les méthodes qui ont beaucoup de variables locales (le code suivant existe par défaut dans le logiciel) :

WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE NbVariables > 15 ORDER BY NbVariables DESC

Donc vous aurez compris que vous pourrez facilement écrire vos propres requêtes pour vos propres besoins.

NDepend s’intègre aussi à Visual Studio (2005/2008 et 2010 pour la version 3) et Reflector. 

Pour les fonctionnalités du produit, allez voir directement sur le site officiel. J’y ai également apprécié la documentation très complète et en plusieurs vidéos, qui est un excellent moyen de découvrir NDepend dans ses moindres fonctionnalités.
Je vous recommande vivement de vous intéresser à ce produit ;).

A bientôt ! :)

Après la mise à disposition des abonnés MSDN des versions RC (Release Candidate) de Visual Studio 2010 et du Framework .NET 4.0 lundi, Microsoft vient de les mettre à disposition du public.

Pour rappel, Microsoft s’est essentiellement concentré sur les problèmes de performances des précédentes versions Beta.
Scott Guthrie a d’ailleurs déclaré sur Twitter le 11 janvier 2010 “I'm testing on an ultra-thin which has a 3.3 Windows score (3.9 CPU, 3.3 graphics, 5400 RPM hard drive). VS10 now works well on it.”, ce qui présage quelque chose de bon pour cette version RC :).

Pour l’installation de la version RC, il ne faut pas oublier de désinstaller la version Beta.

Pour télécharger Visual Studio 2010 Ultimate, rendez-vous sur cette page.
Pour le Framework .NET 4.0, cela se passe ici.

A bientôt !