Il est très souvent utile d'agrandir un panneau spécifique au sein d'une application. J'ai réalisé une extension à base de propriétés attachées qui permet très simplement de maximiser des éléments au sein d'un conteneur de type Grid. Voici un exemple d'éléments contenus au sein d'une grille.

Pour cela, il suffit tout d'abord de spécifier que la grille peut maximiser ces enfants. Ensuite chaque enfant peut être maximiser via l'utilisation d'un bouton sur lequel vous définissez la cible de l'agrandissement. La transition est un fondu entre le visuel de départ et celui d'arrivée. La durée de la transition, exprimée sous forme de millisecondes, peut être configurée. Durant celle-ci et jusqu'à sa fin, le contenu de la grille n'est plus interactif. La capture ci-dessous illustre les différentes méthodologies et possibilités en terme de code XAML.

Voici l'exemple ci-dessous en fonctionnement.

je mets cette extension en téléchargement ici.

Comme beaucoup d'autres petits détails, vous aurez sans aucun doute remarqué qu'il n'est pas possible de définir la propriété ClipToBounds dans Silverlight contrairement à WPF. Autrement dit, vous ne pouvez pas faire en sorte qu'un objet contenu dans un autre ne dépasse pas des limites de son parent sauf si cela est prévu nativement. Comme d'habitude, la solution consiste à créer une extension ou un comportement. J'ai fais une propriété attachée ainsi qu'un comportement qui facilitent cette mise en oeuvre.

Voici une copie d'écran réalisée sous Blend.

Et voici le code très simpliste qui permet de créer cet effet via une AttachedProperty :

public static class ClippingExtension
    {
 
        public static bool GetClipToBounds(DependencyObject obj)
        {
            return (bool)obj.GetValue(ClipToBoundsProperty);
        }
 
        public static void SetClipToBounds(DependencyObject obj, bool value)
        {
            obj.SetValue(ClipToBoundsProperty, value);
        }
 
        // Using a DependencyProperty as the backing store for ClipToBounds.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ClipToBoundsProperty =
            DependencyProperty.RegisterAttached("ClipToBounds", typeof(bool), typeof(FrameworkElement), new PropertyMetadata(false,OnClipToBoundsChanged));
 
 
        private static void OnClipToBoundsChanged (DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            FrameworkElement f = d as FrameworkElement;
 
            if (f == null)
            {
                return;
            }
 
            if (System.Convert.ToBoolean(e.NewValue))
            {
                f.SizeChanged += new SizeChangedEventHandler(f_SizeChanged);
 
                RectangleGeometry rg = new RectangleGeometry();
 
                rg.Rect = new Rect() { Width = f.ActualWidth, Height = f.ActualHeight };
 
                f.Clip = rg;
            }
            else
            {
                f.SizeChanged -= new SizeChangedEventHandler(f_SizeChanged);
 
                f.Clip = null;
            }
 
        }
 
        static void f_SizeChanged(object sender, SizeChangedEventArgs e)
        {
            FrameworkElement f = sender as FrameworkElement;
 
            if (f == null)
            {
                return;
            }
 
            RectangleGeometry rg = new RectangleGeometry();
 
            rg.Rect = new Rect() { Width=f.RenderSize.Width, Height=f.RenderSize.Height };
 
            f.Clip = rg;
 
        }
    }

J'ai récemment eu besoin d'utiliser un Slider avec deux thumbs, certaines librairies le proposent, mais de manière générale, je ne les trouve pas simple à "templatiser". N'en ayant pas trouver d'adéquat à télécharger, je l'ai codé et je le fournirai en version finale avec la prochaine version de la librairie Tweened. Le look du contrôle n'est pas terminé. Un RangeSlider permet de filtrer ou de définir une plage de valeur. Cela peut être du double, des DateTime (ou tout autre type à l'aide d'un converter).
Le contrôle fourni ne propose pour l'instant que le mode horizontal mais je prévois la version avec affichage verticale. Il est possible de définir le mode d'update de la propriété Value durant le drag ou lors du relâché. Cela est très utile lorsque vous souhaitez éviter un rafraichissement trop fréquent coté Vue-Modèle par exemple. Coté intégration graphique, c'est exactement la même procédure que pour le slider classique et donc assez facile à personnaliser.

Voici une exemple.

Lorsque vous développez une application Silverlight ou Wpf, certaines questions se posent avec plus de force. C'est notamment le cas concernant l'ergonomie. Définir un zoning simple et sans heurts est indispensable pour une utilisation intuitive de votre application. Vous remarquerez souvent que certains usages ou même certaines entités métier présentent plusieurs facettes.
Prenons l'exemple de plusieurs classes héritant d'une classe ou implémentant une interface. Nous pourrions partir du principe que chaque sous-classe présente des membres communs a la classe mère ainsi qu'un jeu de propriétés ou de méthodes qui lui est spécifique. Lorsqu'une vue de l'application représente ce type d'instance, nous pouvons répartir l'affichage de cette dernière en deux zones distinctes que l'utilisateur n'aura pas forcément besoin de voir en même temps. La rotation 3D de la surface est un bon moyen d'y parvenir. Je mets à disposition un nouveau contrôle utilisateur : le FlipControl. Il est constitué de deux faces qui exposent chacune, un visuel distinct. On affiche successivement les deux faces par une rotation 3D sur l'axe horizontal ou vertical.
Je mets donc à disposition un contrôle de ce type directement utilisable dans Blend. C'est un ContentControl qui possède les propriétés Header, FrontContent, BackContent et FrontTemplate et BackTemplate représentant le DataContext de chaque face.

Il possède également une propriété IsFlipped sur laquelle vous pourrez créer une liaison de donnée afin de déclencher une rotation 3D du contrôle. L'avantage principal de ce FlipControl est de faciliter la configuration du contenu de chaque face directement dans Blend.

Les sources de base ainsi que le projet de test sont téléchargeables à cette adresse.

Dans le cadre d'un projet Silverlight sur tablette tactile, j'ai récemment eu besoin d'un Slider sans limite de valeur. Autrement dit, la valeur Maximum est indéfinie ou alors très éloignée. L'idée est d'augmenter la vitesse d'incrémentation au fur et à mesure du drag du contrôle Thumb. Vous pouvez tester le contrôle ci dessous. Il est possible de définir le pas du changement de valeur ainsi que la finesse d'accélération.

Si vous avez déjà développé pour Windows Phone 7, vous avez déjà du remarquer certaines interactions problématiques. C'est notamment le cas lorsque vous utilisez les contrôles de base. Par exemple, lorsque vous cliquez sur un bouton par inadvertance (très souvent le cas pour les enfants), cela bloque toute autre tentative d'écoute sur un autre contrôle. Pour le vérifier posez deux boutons dans une grille windows phone 7 et compilez le projet sur le device. Lorsque vous cliquez sur le premier bouton, la diffusion de tout autre événement souris ou contact (tels que MouseLeftButtonDown par exemple) est impossible. Vous vous trouvez dans un cas classique d'interaction Multi-Touch sans l'avoir prévu. Afin de réaliser des applications réellement multitouch qui prennent ce genre de problématiques en compte, il existe différentes solutions plus ou moins efficaces .

Utiliser des événements plus adaptés : ManipulationStarted, ManipulationDelta et ManipulationCompleted. Ceux-ci sont directement implémentés dans le framework au niveau de la classe UIElement. Ces événements fournissent plus de détail concernant l'interaction utilisateur en cours. C'est cette solution qui est privilégiée dans 90% des cas. Toutefois cela ne répond pas à notre problématique principale.

Implémenter l'API de Gesture proposée par le Toolkit Windows Phone 7. Cette API facilite la vie lorsqu'il est nécessaire de connaitre l'écartement entre deux contacts, la rotation du segment entre des contacts et tout autre type d'opérations de ce genre. Le problème est qu'encore une fois, cela n'est pas une bonne solution car les événements proposés ne concernent qu'une seule surface (contrôle) à la fois. De plus l'implémentation de cette API n'est pas très pratique à mettre en oeuvre et ajoute une surcouche à l'API native et engendre de faibles performances (voir figure ci-dessous).

La seule bonne solution, et la plus exhaustive en matière de possibilités, consiste à Utiliser la classe static Touch. Celle-ci représente le plus bas niveau de traitement MultiTouch. Elle vous permet d'écouter un unique évènement nommé FrameReported. L'objet événementiel récupéré par l'écouteur possède plusieurs informations qui permettent de développer votre propre classe Wrapper MultiTouch ou encore des contrôles particuliers. Ces informations sont contenus dans l'objet événementiel de type TouchFrameEventArgs. L'objet événementiel permet de récupérer le premier contact, de supprimer la diffusion d'événements souris via la méthode SuspendMousePromotionUntilTouchUp. TouchFrameEventArgs donne également accès à la liste des contacts en cours sur une surface via la méthode GetTouchPoints. Cette liste est relative au contexte conteneur passé lors de l'appel de la méthode. De la même manière que GetPosition() de la classe MouseButtonEventArgs, passer null renvoie la liste relative au VisualRoot, donc à l'application elle-même. Chaque contact sur la surface est de type TouchPoint. A ce stade, l'API commence à être réellement utile puisqu'il est possible, pour chaque contact, de récupérer des informations utiles comme sa dimension , son action(relaché, déplacé, appuyé) et sa position relative au conteneur. Voici un exemple :

public MainPage()
{
    InitializeComponent();
 
    Touch.FrameReported += new TouchFrameEventHandler(Touch_FrameReported);
 
}
 
void Touch_FrameReported(object sender, TouchFrameEventArgs e)
{
     var tp = e.GetPrimaryTouchPoint(null);
 
     switch(tp.Action)
     {
           case TouchAction.Down:
           break;
 
           case TouchAction.Move:
           break;
 
           case TouchAction.Up:
           break;
 
           default:
           break;
     }
}

Sur un projet en cours, j'ai du développé un contrôle ContactButton permettant de résoudre cette problématique. L'objectif d'un point de vue utilisateur était d'activer certains menus lorsque deux boutons à la fois étaient cliqués. Ce contrôle est basé sur l'API native multiTouch de Silverlight et sur les classes d'AutomationPeer. L'idée est de diffuser un événement lorsque plusieurs boutons d'un même groupe sont cliqués en même temps. Il est possible d'écouter un événement static de la classe ContactButton afin de récupérer le groupe de bouton cliqué. Au moins deux boutons d'un même groupe doivent être appuyés en même temps pour que la classe diffuse l'événement. Il est également possible d'écouter un groupe spécifique. Voici comme utiliser ces événements :

public TestTwinBehavior()
{
    InitializeComponent();
 
    tcb1.ContactSelectionChanged += new EventHandler(tcb1_ContactSelectionChanged);
 
    ContactButton.ContactGroupChanged += new EventHandler(ContactButton_ContactGroupChanged);
}
 
void ContactButton_ContactGroupChanged(object sender, ContactButtonGroupEventArgs e)
{
    Debug.WriteLine(e.ContactButtonGroupName);
}
 
void tcb1_ContactSelectionChanged(object sender, Tweened.WP7.Controls.ContactButtonGroupEventArgs e)
{
    foreach (ButtonBase item in e.ContactedButtons)
    {
        Debug.WriteLine(item.Name);
    }
}

Je mets à disposition un projet et la dll qui l'accompagne. En outre, le contrôle LayoutGridSelector est fourni avec des améliorations concernant le support des thèmes visuels Windows Phone 7.

Vous l'avez sans doute remarqué si vous avez un Windows Phone 7, la Market place windows Phone c'est juste la jungle. Vous trouverez souvent ce que vous recherchez et sans doute beaucoup plus. C'est ce dernier point qui me pose le plus de problème : vous trouverez très souvent plusieurs applications avec le même nom (sans parler des musiques), des logos très légèrement modifiés et des fonctionnalités similaires. Sans même parler de piratage car cela n'est pas possible, n'importe quel développeur ou entreprise peut à loisir créer une application avec des fonctionnalités identiques lorsque celles-ci ne sont pas complexes à développer. Vous trouverez donc souvent 3 / 4 (et quelques fois plus) applications portant le même nom.

Ce problème est, il me semble, complètement propre à Windows phone 7 car en tant qu'utilisateur, je n’ai pas remarqué ce phénomène sur l'AppStore.

Pour résumer même si l’application est sortie un mois , deux mois ou 1 an avant et fut la première portant ce nom, rien n’empêche un développeur ou une entreprise de déposer la même application par la suite avec un logo similaire et un nom exactement identique. La réponse de Microsoft est : il est nécessaire de porter plainte en justice pour protéger le nom de l'application et l'idée de logo. Imaginez donc que vous deviez porter dix plaintes pour 10 applications différentes. Dès lors en tant que développeur Windows Phone 7 et Silverlight, je me pose les questions suivantes :

1 - Je trouve une bonne idée avec un nom idéal et je suis une petite structure, comment faire pour protéger mon application ?

2 - Comment faire pour que mon application soit rapidement trouvée sur la market place ?

3 - Qu’est-ce qui différencie mon application des autres et qu'est-ce qui la protège ?

A titre personnel, je pense qu'une petite structure a très peu de moyens pour se défendre mis à part une action légale. Sur la Market place votre application et son nom surtout pourrait être déposées avec les mêmes fonctionnalités, seul recours la loi. Mais quelle loi, il me semble que cet aspect là est très délicat car il faudra sans doute déposer un brevet internationale et/ou passer par tous les outils possibles à votre disposition.

Pour que votre applications soit rapidement trouvée, pas de mystère, il faut quelle soit utilisée et bien notée par les WindowsPhonaute (ou Marketplacenaute), ou que vous possédiez d'autres moyens marketing comme un site, une campagne de pub, ou une application hors windows phone qui y soit reliée. Cette question renvoie à la question trois.

Ce qui va différencier votre applications des autres ayant le même nom :

• Les ScreenShots avec des contenus graphiques uniques. Ce contenu est beaucoup plus difficile à copier contrairement au nom. Une banque d'image unique de par son contenu par exemple.
• Les fonctionnalités complexes, qui ne sont pas à la portée de tous.
• Une expérience utilisateur sans aucune faille.

Tous ces éléments seront autant de protection contre la recopie de votre application. Mais alors qu'est-ce qu'il y a de changer avec l'AppStore ? Je dirai un aspect romantique, l'aspect Christophe Colomb . On a tous eu l'idée de créer un jour l'application avec THE IDEE(IDEA . Sauf qu'aujourd'hui, le développeur qui dans son coin souhaite créer cette application même avec l'idée du siècle, ne pourra pas assurer la protection de son application faute de moyens financiers. Car le nom qu'il dépose peut, du jour au lendemain être complètement piraté. De longs mois de procédures juridique sont à la clef de tous recours. Cela peut couter très cher...

Aucune réponse technique à ce problème n'est la bonne, aucune réponse légale n'est bonne non plus à moins que vous fassiez partie d'une moyenne / grande entreprise et que vous disposiez de beaucoup, beaucoup de temps devant vous. La bonne réponse est multiple c'est la réponse artistique, la réponse de l'unique, la réponse du contenu et d'un développement parfait, d'une ergonomie parfaite. Cela sera beaucoup plus dur à copier. Donc à ceux qui postent des applications juste pour en poster alors que d'autres du même type existent, s'il vous plait arrêtez, vous ne gagnerez pas d'argent de cette manière. Cela nuit à la MarketPlace et au fantastique outil qu'est Windows Phone 7.

Pour les nécessités d'un projet, j'ai récemment eu besoin de conserver l'historique des sélections effectuées au sein d'un groupe de RadioButton. Cette classe existe sur des environnements comme Flex de manière native mais pas sur Silverlight, du coup, il est nécessaire de concevoir un mini framework pour avoir le même type de fonctionnalités. Généralement la classe RadioButtonGroup possède un événement Selected diffusé lorsqu'un des RadioButton est sélectionné au sein du groupe. Toutefois pour les besoins de la production, nous avions besoin d'historier les sélections successives car ceux-ci était utilisés comme menu. Du coup, j'ai développé une mini API permettant de faire cela et un peu plus.

Cette API est composée de différents éléments :
- La classe RadioButtonGroup
- Des propriétés attachées pour activer / désactiver / stocker un groupe de radio boutton associé.
- Une méthode d'extension
- Un comportement facilitant l'activation de RadioButtonGroup (à glisser dans Blend sur un RadioButton)

Il est intéressant de constater qu'utiliser un comportement peut s'avérer bien plus souple qu'utiliser une Attached Property. Bien qu'une Attached Property puisse être définit dans un style, celle-ci le constructeur d'une MainPage ne pourra pas accéder à une instance de RadioButtonGroup directement. Vous pourrez le faire uniquement sur le Loaded. Dans le cas du comportement cela n'est pas vrai car le RadioButtonGroup est instancié via la méthode OnAttached qui est appelée dès que le comportement est affecté à un RadioButton, c'est à dire bien avant son affichage effectif. Je mets un projet de test au téléchargement ici.

Pour chacun d'eux, je mets le code en clair dans les sections ci-dessous :

La classe RadioButtonGroup

Celle-ci possède plusieurs membres très utiles :

• SelectionChanged

Cet événement est diffusé lorsqu'un RadioButton du groupe est sélectionné.

• Children

CollectionObservable contenant tous les RadioButton du groupe

• Historic

CollectionObservable contenant l'historique de sélection

• Current

Propriété renvoyant le RadioButton actuellement sélectionné

• Last

Propriété renvoyant le RadioButton précédemment sélectionné

• Add

Méthode permettant d'ajouter un RadioButton au groupe

• Remove

Méthode permettant de supprimer un RadioButton du groupe

• CancelLastSelection

Annule la dernière sélection. Très pratique pour certaines fonctionnalités spécifiques aux menus

public class RadioButtonGroup : INotifyPropertyChanged
{
 
    ///
    /// This event is fired when the selected RadioButton has been modified.
    ///
    public event EventHandler
 SelectionChanged;
 
    private bool _IsCanceledByGroup;
    public bool IsCanceledByGroup
    {
        get
        {
            return _IsCanceledByGroup;
        }
        set
        {
            _IsCanceledByGroup = value;
        }
    }
 
    ///
    /// ObservableCollection wich contains an historic of selected RadioButton
    ///
    private ObservableCollection _Historic = new ObservableCollection();
    public ObservableCollection Historic
    {
        get
        {
            return _Historic;
        }
        set
        {
            _Historic = value;
        }
    }
 
    ///
    /// ObservableCollection of RadioButton contained by the RadioButtonGroup
    ///
    private ObservableCollection _Children = new ObservableCollection();
    public ObservableCollection Children
    {
        get
        {
            return _Children;
        }
        set
        {
            _Children = value;
        }
    }
 
    ///
    /// Returns Current Selected RadioButton in the group
    ///
    private RadioButton _Current;
    public RadioButton Current
    {
        get
        {
            return _Current;
        }
        set
        {
            if (!Object.ReferenceEquals(_Current, value))
            {
                _Current = value;
 
                NotifyPropertyChanged("Current");
 
                if (SelectionChanged != null)
                {
                    SelectionChanged(this, new SelectedChangedEventArgs() { Last=_Last,Current=_Current, CurrentGroup=this });
                }
 
            }
        }
    }
 
    ///
    /// Returns last selected RadioButton in the group
    ///
    private RadioButton _Last;
    public RadioButton Last
    {
        get
        {
            return _Last;
        }
        set
        {
            if (!Object.ReferenceEquals(_Current, value))
            {
                _Last = value;
 
                NotifyPropertyChanged("Last");
            }
        }
    }
 
    ///
    /// Add a RadioButton to the RadioButtonGroup
    ///
    ///
 
    public void Add(RadioButton rb)
    {
        _Children.Add(rb);
        rb.Checked += new RoutedEventHandler(rb_Checked);
    }
 
    ///
    /// Remove a RadioButton contained by the RadioButtonGroup
    ///
    ///
 
    public void Remove(RadioButton rb)
    {
        _Children.Remove(rb);
        rb.Checked -= new RoutedEventHandler(rb_Checked);
    }
 
    ///
    /// Cancel last selection in the group and select the one before
    ///
    /// Return Current Selection after CancelLastSelection method has been called.
    public void CancelLastSelection()
    {
 
        if (Historic.Count > 1)
        {
            Historic.RemoveAt(Historic.Count - 1);
        }
        Historic[Historic.Count - 1].IsChecked = true;
    }
 
    private void rb_Checked(object sender, RoutedEventArgs e)
    {
        Current = sender as RadioButton;
 
        Historic.Add(Current);
 
        Last = Historic[Historic.Count - 1];
    }
 
    #region NPC members
 
    public event PropertyChangedEventHandler PropertyChanged;
 
    private void NotifyPropertyChanged(string prop)
    {
        if (PropertyChanged != null)
        {
            PropertyChangedEventArgs e = new PropertyChangedEventArgs(prop);
            PropertyChanged(this, e);
        }
    }
 
    #endregion
 
}

Des propriétés de dépendance attachées (aux RadioButton) facilitant l'activation et l'instanciation d'un objet RadioButtonGroup.

ActivateRadioButtonGroup permet d'activer la gestion via RadioButtonGroup.
CommitProperty permet de sélectionné un RadioButton lorsqu'une propriété de votre choix est modifiée.

namespace Tweened.Extensions.RadioButtonEx
{
 
    public static partial class RadioButtonExtension
    {
        #region static Dictionnary string / RadioButtonGroup named RadioButtonGroups
        private static Dictionary _RadioButtonGroups = new Dictionary();
        ///
        /// Contains RadioButtonGroups in the application
        ///
        public static Dictionary RadioButtonGroups
        {
            get
            {
                return _RadioButtonGroups;
            }
            set
            {
                _RadioButtonGroups = value;
            }
        }
        #endregion
 
        #region Commit DependencyProperty enables the radiobutton to autoselect if some property has changed
        ///
        /// Enable the radiobutton to autoselect if some property has changed
        ///
        public static object GetCommitProperty(DependencyObject obj)
        {
            return (object)obj.GetValue(CommitPropertyProperty);
        }
 
        public static void SetCommitProperty(DependencyObject obj, object value)
        {
            obj.SetValue(CommitPropertyProperty, value);
        }
 
        // Using a DependencyProperty as the backing store for CommitProperty.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty CommitPropertyProperty =
            DependencyProperty.RegisterAttached("CommitProperty", typeof(object), typeof(RadioButton), new PropertyMetadata(null,
                                                                                                        new PropertyChangedCallback(OnCommitProperty)));
 
        private static void OnCommitProperty(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            RadioButton rb = d as RadioButton;
            if (rb == null)
            {
                return;
            }
 
            if (e.NewValue != e.OldValue)
            {
 
                rb.IsChecked = e.NewValue != null;
            }
        }
        #endregion
 
        #region ActivateRadioButtonGroup DependencyProperty enables RadioButtonGroup management for a given RadioButton
 
        ///
        /// Retrieves the RadioButtonGroup wich hold the RadioButton.
        ///
        ///
 
        ///
        public static RadioButtonGroup GetRadioButtonGroup(DependencyObject obj)
        {
            return (RadioButtonGroup)obj.GetValue(RadioButtonGroupProperty);
        }
 
        public static void SetRadioButtonGroup(DependencyObject obj, RadioButtonGroup value)
        {
            obj.SetValue(RadioButtonGroupProperty, value);
        }
 
        // Using a DependencyProperty as the backing store for RadioButtonGroup.  This enables animation, styling, binding, etc...
        private static readonly DependencyProperty RadioButtonGroupProperty =
            DependencyProperty.RegisterAttached("RadioButtonGroup", typeof(RadioButtonGroup), typeof(RadioButton), null);
 
        ///
        /// Activate RadioButton Group managment
        ///
        ///
 
        ///
        public static bool GetActivateRadioButtonGroup(DependencyObject obj)
        {
            return (bool)obj.GetValue(ActivateRadioButtonGroupProperty);
        }
 
        public static void SetActivateRadioButtonGroup(DependencyObject obj, bool value)
        {
            obj.SetValue(ActivateRadioButtonGroupProperty, value);
        }
 
        // Using a DependencyProperty as the backing store for ActivateRadioButtonGroup.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ActivateRadioButtonGroupProperty =
            DependencyProperty.RegisterAttached("ActivateRadioButtonGroup", typeof(bool), typeof(RadioButton), new PropertyMetadata(false, new PropertyChangedCallback(OnActivateRadioButtonGroupChanged)));
 
        private static void OnActivateRadioButtonGroupChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            RadioButton rb = d as RadioButton;
 
            if (rb == null || String.IsNullOrEmpty(rb.GroupName))
            {
                throw new Exception("Object is not a RadioButton or GroupName is not defined.");
            }
 
            RadioButtonGroup rbg;
 
            if (System.Convert.ToBoolean(e.NewValue))
            {
                if (!RadioButtonExtension.RadioButtonGroups.ContainsKey(rb.GroupName))
                {
                    rbg = new RadioButtonGroup();
                    RadioButtonExtension.RadioButtonGroups.Add(rb.GroupName, rbg);
                    Application.Current.Resources.Add(rb.GroupName, rbg);
                    rbg.Add(rb);
                }
                else
                {
                    rbg = RadioButtonExtension.RadioButtonGroups[rb.GroupName];
                    rbg.Add(rb);
                }
                RadioButtonExtension.SetRadioButtonGroup(rb, rbg);
            }
            else
            {
                if (RadioButtonExtension.RadioButtonGroups.ContainsKey(rb.GroupName))
                {
                    rbg = RadioButtonExtension.RadioButtonGroups[rb.GroupName];
                    rbg.Remove(rb);
                    RadioButtonExtension.SetRadioButtonGroup(rb, null);
                }
            }
 
        }
 
        #endregion
    }
}

Des comportements que vous pourrez glisser directement sur des instances de RadioButton ou un conteneur en contenant.

public class RadioButtonGroupBehavior : Behavior
{
	public RadioButtonGroupBehavior()
	{
 
	}
 
	protected override void OnAttached()
	{
		base.OnAttached();
 
        	if (AssociatedObject is Panel)
        	{
            		AssociatedObject.Loaded += new RoutedEventHandler(AssociatedObject_Loaded);
        	}
       		else if (AssociatedObject is RadioButton)
        	{
           		RadioButtonExtension.SetActivateRadioButtonGroup(AssociatedObject as RadioButton, true);
        	}
	}
 
	void AssociatedObject_Loaded(object sender, RoutedEventArgs e)
	{
		foreach (UIElement b in (sender as Panel).Children)
		{
			if (b as RadioButton != null)
				RadioButtonExtension.SetActivateRadioButtonGroup(b as RadioButton, true);
		}
	}
 
	protected override void OnDetaching()
	{
		base.OnDetaching();
 
        	if (AssociatedObject is Panel)
        	{
            		AssociatedObject.Loaded -= AssociatedObject_Loaded; 
 
            		foreach (RadioButton b in (AssociatedObject as Panel).Children)
            		{
                		RadioButtonExtension.SetActivateRadioButtonGroup(b, false);
            		}
        	}
        	else if (AssociatedObject is RadioButton)
        	{
           		 RadioButtonExtension.SetActivateRadioButtonGroup(AssociatedObject as RadioButton, false);
        	}
	}
 
}

Une méthode d'extension pour les instances de RadioButton qui facilite la récupération du RadioButtonGroup associé.

public static partial class RadioButtonExtension
{
    #region Extension Method GetRadioButtonGroup
    ///
    /// Allow to get the RadioButtonGroup associated to a RadioButton
    ///
    ///
 
    ///
    public static RadioButtonGroup GetRadioButtonGroup(this RadioButton radioButton)
    {
        RadioButtonGroup rbg = null;
 
        if (RadioButtonExtension.RadioButtonGroups.ContainsKey(radioButton.GroupName))
        {
            rbg = RadioButtonExtension.RadioButtonGroups[radioButton.GroupName];
        }
 
        return rbg;
    }
    #endregion
}

Regart.net diffuse le thème Fleur des salines sur FlashXpress.net en version anglaise ou française. Pour ceux qui aiment bien les beaux thèmes wordpress sobres et efficaces, je vous le recommande chaudement. Celui-ci embarque une Galerie photo en home page (made in Silverlight).

Cette galerie repose sur le plugin wordpress du même nom, vous pouvez la télécharger ici. Son principale avantage et de récupérer les images uploader via l'admin wordpress dans votre post.En voici un exemple montrant des capture du thème en question.

Si vous souhaitez apprendre à configurer ce thème, j'ai réalisé une petite vidéo muette de 3-4 minutes très pratique que vous pouvez voir sur la WebTv de tweened.org ici.

Pour info, ce thème a été utilisé pour le site www.fleurdessalines.fr réalisé par Regart.net.

Pour les besoins d'une production récente, j'ai du concevoir un contrôle de progression circulaire nommé PieProgressBar. Ce dernier hérite de la classe RangeBase et bénéficie à ce titre de toutes les capacités inhérentes à ce type de contrôle. Il se comporte au final comme n'importe quel contrôle de type ProgressBar avec quelques petites choses en plus. La petite difficulté fut de créer dynamiquement le camembert de progression via C#. Contrairement à WPF, Silverlight ne permet pas de surcharger de méthode permettant de créer de nouveaux genres de Shape. Autrement dit, même si Shape est une classe abstraite, il ne sert à rien d'en hériter car la méthode de conception du tracé ne peut être surchargée.
L'autre technique consiste à utiliser le "Path mini language" qui permet de créer des figures géométriques en XAML. J'ai du utiliser 3 segments dont un ArcSegment afin de réaliser ce contrôle. comme je ne pouvais pas créer de primitive Pie pour le graphiste sous Blend, il a fallu ruser... La technique consiste a créer dynamiquement le camembert lors de l'assignation d'une partie de contrôle (ControlPart). En interne, les propriétés de remplissage du tracé généré, sont liées aux propriétés du contrôle via une simple liaison de données créées cote C#.
Vous pouvez en voir des exemplaires ci-dessous et télécharger la librairie tweenedcontrols ici.

Une fois la dll référencée, vous pouvez instancier des contrôle PieProgressBar dans Blend via le panneau Assets comme montré ci-dessous :

Ce composant va être sans doute inclu comme d'autres dans le projet CodePlex SLExtensions que Thierry Bouquain met à jour en ce moment et que je salue au passage