Searched for : slextensions

SLMedia et Smooth Streaming

Comme les français ont put le voir avec Roland Garros, le Smooth Streaming permet de diffuser des flux de grande qualité qui vont s’adapter à la connexion et à la puissance de la machine et de pouvoir faire du timeshifting (contrôle du direct) sur les emissions live.

Smooth Streaming c’est quoi ?

Le smooth streaming n’est pas un format de compression de video. C’est une technologie de diffusion qui permet de découper la vidéo et le son en morceaux de 2 secondes et diffuser le tout par http. La vidéo étant encodé en plusieurs niveau de qualité, nous obtenons des échantillons de différents poids qui vont être mis à disposition sur un serveur web.
La partie client web (silverlight) va récupérer ces différents paquets et les mettre bout à bout pour reconstituer le flux vidéo. L’application silverlight récupérera le paquet de poids correspondant au mieux à la qualité de la connexion à internet.
Pour la partie diffusion en live, un ou plusieurs encodeur envoyent au serveur web ces paquets de 2 secondes au fur et à mesure qu’ils sont reçu de la source et encodés.
Pour silverlight 2, la vidéo est au format VLC1 et nous devrions avoir droit au H264 avec silverlight 3.
Le découpage en paquets et la diffusion au format HTTP permettent de tirer partie des différents Cache HTTP qui existent sur internet.

Côté serveur

La diffusion des flux smooth streaming nécessitent des composants côté serveur. Actuellement, IIS7 est la seule plateforme supportant la diffusion de ce format. Deux versions existent. La première vous permet de diffuser des vidéos préenregistrées au format smooth streaming et la deuxième encore en beta permet la diffusion de flux live.

Côté client

Silverlight est actuellement le seul moyen de lire de la vidéo en Smooth Streaming. Des exemples existent pour Silverlight 2 et Silverlight 3.

Encodeur

Pour encoder des vidéos préenregistrées, vous devrez passer par Microsoft Expression Encoder SP1. Pour les flux live, des encodeurs hardwares sont en cours de développement. Pour Roland Garros, c’est la société Inlet qui les a fourni. Vous pouvez cependant simuler un flux live à partir d’une vidéo préencodée en Smooth Streaming. Allez sur le site officiel et téléchargez le starter kit. Vous trouverez 2 exécutables PushEncoder32.exe et PushEncoder64.exe qui poussent votre vidéo préencodée sur le point de distribution live.

SLMedia

La librairie de décodage du flux smoothstreaming (Microsoft.Web.Media.SmoothStreaming.dll) est récupérable dans le player d’exemple silverlight du starter kit.

Pour cet exemple, je vais réutiliser le VideoPlayer d’un précédent billet.
L’assignation d’une vidéo à un MediaElement ne se fait pas de la même manière que la video soit du smooth streaming ou non. Pour gérer ceci, la notion de VideoSourceAdapter et VideoAdapter a été ajoutée à SLExtensions. Le VideoSourceAdapter va instancier la bonne source en fonction de l’url de la vidéo. La première chose à faire dans le projet est de référencer le projet SLMedia.SmoothStreaming et d’initialiser le SmoothStreamingVideoSourceAdapter. Il suffit de rajouter la ligne ci-dessous au constructeur de la classe App.xaml.cs.

            SLMedia.SmoothStreaming.SmoothStreamingVideoSourceAdapter.Initialize();

Ensuite, changez le binding sur le source du MediaElement et l’url de la video.

        <MediaElement x:Name="mediaelement"

                    slvideo:VideoSourceAdapter.Source="{Binding Path=CurrentItem.SourceUri}"

                    slvideo:VideoController.MediaElement="{StaticResource controller}"

                    IsMuted="{Binding Path=IsMuted}"

                    Volume="{Binding Path=Volume}"

                    AutoPlay="{Binding Path=AutoPlay}"   

                    />

 

 

            controller.Playlist.Add("http://localhost/live.isml/Manifest");

Attention, le chemin d’accès au Manifest est sensible au crossdomain. Pensez à autoriser votre player à accéder à la video si le player n’est pas dans le même domaine (crossdomain.xml)

Poussez votre video en live  PushEncoder64.exe http://localhost/live.isml "Big Buck Bunny.ism" et lancez votre player. Vous devriez voir la video. Si vous voulez un contenu préencodé, téléchargez la video Big Buck Bunny ici.

Par défaut, la lecture du flux commence toujours au début de la vidéo qui a été encodée. Si vous voulez rejoindre le direct, vous pouvez appeler la fonction GoToLive du VideoAdapter ou créer un mediaitem de type LiveVideoItem et lui assigner sa propriété JoinLive.

        void Page_Loaded(object sender, RoutedEventArgs e)

        {

            controller.Playlist.Add(new LiveVideoItem

            {

                Source = "http://localhost/live.isml/Manifest",

                JoinLive = true

            });

            controller.Next();

        }


la timeline pour le Live Smooth Streaming

Pour les événements live, les informations de position ne démarrent pas forcément à 0. Il faut changer la déclaration des bindings du slider pour tenir compte des propriétés Start et LivePosition.

            <slec:Slider Maximum="{Binding Path=VideoAdapter.LivePosition, Converter={StaticResource timeSpanConverter}}"

                        Minimum="{Binding Path=VideoAdapter.Start, Converter={StaticResource timeSpanConverter}}"

                        MoveValue="{Binding Converter={StaticResource timeSpanConverter}, Mode=TwoWay, Path=Position}"

                        Width="200" Margin="20,0,0,0"

                        />

Quelle représentation pour la timeline

  1. Un slider simple

Ce contrôle est utilisé dans le majorité des players vidéos disponible sur internet. Il se prête bien pour des vidéos de taille connues et relativement petites. Dans le cas de diffusion de flux live, la taille du slider ne représente pas toujours la même durée. Au bout d’une heure d’émission, amener le slider au milieu reculera d’une demi heure alors qu’au bout d’une journée on reculera d’une demi journée.

image

  1. Un “slider inversé”

Le marqueur au milieu indique la position de lecture. La barre orange indique la durée de la vidéo. Cette barre grandit au fur et à mesure que le flux live est émis. Quand l’utilisateur regarde en live, la barre orange s’agrandit vers la gauche et rien ne dépasse à droite du marqueur.
Si l’utilisateur met en pause, le barre s’agrandit à droite du marqueur montrant qu’on est plus en live et indique la durée du décalage par rapport au live.
Quand la lecture reprend, la barre regrandit à gauche.

Contrairement au slider simple, ce type de contrôle permet d’avoir une échelle de temps constante tout au long de la diffusion. Lorsqu’on déplace la timeline, c’est la barre orange qui se déplace, le marqueur reste toujours au milieu. Peut être un peu déroutant au départ, un utilisateur en comprendra vite la logique

image

  1. Un slider sur une ligne de temps

C’est ce qui a été utilisé pour Roland Garros, une barre de temps représente la journée entière. La taille du slider grandit au fur et à mesure du live. Le slider garde une échelle constante mais est quasi invisible au départ. Le principe de déplacement du curseur est préservé.

image

N’oubliez pas de télécharger les sources de SLMedia sur le site de slextensions.

#    Comments [0] |

SLMedia le player Photo / Video de SLExtensions

Les librairies SLMedia regroupent tout ce qu'il vous faut pour gérer vos galeries photos et vidéo. Ces librairies sont séparées en plusieurs dlls gérant chacune un type de média.

  • SLMedia.Core : Librairie centrale prenant en charge les fonctions communes.
  • SLMedia.Picture : Librairie vous permettant de réaliser des slideshows d’images.
  • SLMedia.Deepzoom : Librairie vous permettant d’afficher des galeries deepzoom de vos images.
  • SLMedia.Video : Librairie gérant les galeries vidéos.
  • SLMedia.SmoothStreaming : Gestion des vidéos en Smooth Streaming

Création d’un player video avec SLMedia

La réalisation d’un player avec SLMedia repose sur les concepts de Binding et de Behavior. Les Bindings vont vous servir à lier les informations provenant du controller (ici un VideoController) et les différents éléments graphiques qui vont vous permettre d’afficher et d’agir sur votre vidéo.

MediaController

Cette classe appartenant à SLMedia.Core sert de base au VideoController. Elle regroupe les fonctionnalités communes aux différents controllers.

  • Gestion de la playlist (Next, Previous, IsPlaying, SelectedItem)
  • Gestion du fullscreen (IsFullscreen)
  • Gestion des progressions pour les slideshow / videos (Position, Duration)
  • Etc..

VideoController

Cette classe hérite du MediaController et lui rajoute des fonctions spécifiques pour la vidéo.

  • MediaElement
  • Buffering
  • Support de différentes source par les VideoAdapter

Etape 1 : Affichage d’une video de la playlist

Dans votre page xaml, référencez le namespace correspondant à SLMedia.Video et ajouter le VideoController aux ressources.

<UserControl x:Class="VideoPlayer1.Page"

   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   xmlns:slvideo="clr-namespace:SLMedia.Video;assembly=SLMedia.Video"

   >

    <UserControl.Resources>

        <slvideo:VideoController x:Name="controller" />

    </UserControl.Resources>

Ensuite posez un MediaElement et associez sa source avec la propriété CurrentItem de notre controller. Le CurrentItem sera du type IMediaItem et possèdera donc une propriété SourceUri contenant l’url de la vidéo à afficher.

    <Grid x:Name="LayoutRoot" DataContext="{Binding Source={StaticResource controller}}" >

        <MediaElement x:Name="mediaelement"

                    Source="{Binding Path=CurrentItem.SourceUri}"

                    />

    </Grid>

Il ne reste plus qu’à renseigner un nouvel item dans la playlist et de le sélectionner pour que la video se lancer.

using SLMedia.Video;

using SLMedia.Core;

 

namespace VideoPlayer1

{

    public partial class Page : UserControl

    {

        public Page()

        {

            InitializeComponent();

            controller = (VideoController)Resources["controller"];

 

            this.Loaded += new RoutedEventHandler(Page_Loaded);

        }

 

        void Page_Loaded(object sender, RoutedEventArgs e)

        {

            controller.Playlist.Add("http://labs.ucaya.com/lake.wmv");

            controller.Next();

        }

    }

}

Pour rendre complétement opérationnel notre videocontroller, nous devons lui indiquer quel est le MediaElement qui affiche la vidéo. De cette manière il pourra récupérer les états de lecture, de progression et de buffering. Nous allons également lier quelques propriétés supplémentaires qui nous permettrons de tout contrôler depuis le VideoController.

        <MediaElement x:Name="mediaelement"

                    Source="{Binding Path=CurrentItem.SourceUri}"

                    slvideo:VideoController.MediaElement="{StaticResource controller}"

                    IsMuted="{Binding Path=IsMuted}"

                    Volume="{Binding Path=Volume}"

                    AutoPlay="{Binding Path=AutoPlay}"   

                    />

Etape 2 : Lecture / Pause

L’état lecture / pause est géré dans notre controller par la propriété IsPlaying. Un binding entre une checkbox et cette propriété permetra de contrôler facilement l’état de lecture.

        <StackPanel Orientation="Horizontal" VerticalAlignment="Bottom" Background="#50000000" Margin="30">

            <CheckBox IsChecked="{Binding Path=IsPlaying, Mode=TwoWay}" />

        </StackPanel>

Etape 3 : Position / Durée

Un slider Bindé sur les propriétés Duration et Position fera l’affaire. Les propriétés Duration et Position étant du type TimeSpan, nous allons utiliser un IValueConverter pour transformer la valeur en Double.

<UserControl x:Class="VideoPlayer1.Page"

   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   xmlns:slvideo="clr-namespace:SLMedia.Video;assembly=SLMedia.Video"

   xmlns:slec="clr-namespace:SLExtensions.Controls;assembly=SLExtensions.Controls"

   xmlns:sled="clr-namespace:SLExtensions.Data;assembly=SLExtensions.Data"

   Foreground="White"

    >

    <UserControl.Resources>

        <slvideo:VideoController x:Name="controller" />

        <sled:TimeSpanConverter x:Name="timeSpanConverter"/>

    </UserControl.Resources>

    <Grid x:Name="LayoutRoot" DataContext="{Binding Source={StaticResource controller}}">

        <MediaElement x:Name="mediaelement"

                    Source="{Binding Path=CurrentItem.SourceUri}"

                    slvideo:VideoController.MediaElement="{StaticResource controller}"

                    IsMuted="{Binding Path=IsMuted}"

                    Volume="{Binding Path=Volume}"

                    AutoPlay="{Binding Path=AutoPlay}"   

                    />

        <StackPanel Orientation="Horizontal" VerticalAlignment="Bottom" Background="#50000000" Margin="30">

            <CheckBox IsChecked="{Binding Path=IsPlaying, Mode=TwoWay}" />

            <slec:Slider Maximum="{Binding Converter={StaticResource timeSpanConverter}, Path=Duration}"

                        MoveValue="{Binding Converter={StaticResource timeSpanConverter}, Mode=TwoWay, Path=Position}"

                        Width="200" Margin="20,0,0,0"

                        />

            <TextBlock Text="{Binding Converter={StaticResource timeSpanConverter}, Path=Position}"

                    Margin="20,0,0,0"/>

            <TextBlock Text=" / " />

            <TextBlock Text="{Binding Converter={StaticResource timeSpanConverter}, Path=Duration}" />

        </StackPanel>

    </Grid>

</UserControl>

Si vous utilisez le slider de base de silverlight, vous noterez des problèmes lorsque vous déplacez le curseur. Pendant que vous déplacez le curseur, la propriété Value peut être remise à jour par le binding et le curseur donne l’impression de sauter.

Etape 4 : Volume

De même que pour la position, nous allons utiliser un slider pour le volume et une checkbox pour le mute

            <CheckBox IsChecked="{Binding Path=IsMuted, Mode=TwoWay}" Margin="20,0,0,0"/>

            <Slider Maximum="1" SmallChange="0.1" LargeChange="0.1"

                   Value="{Binding Path=Volume, Mode=TwoWay}" Width="50" />

Etape 5 : Buffering - Downloading

Encore du binding

            <TextBlock Text="Buffering:" />

            <TextBlock Text="{Binding Path=BufferingProgress, Mode=TwoWay, Converter={StaticResource strConverter}, ConverterParameter='{0:p}'}" />

            <Slider Maximum="1"

                   Value="{Binding Path=BufferingProgress, Mode=TwoWay}" Width="50" IsHitTestVisible="False" Margin="5,0,0,0"/>

 

            <TextBlock Text="Downloading:" Margin="20,0,0,0"/>

            <TextBlock Text="{Binding Path=DownloadProgress, Mode=TwoWay, Converter={StaticResource strConverter}, ConverterParameter='{0:p}'}" />

            <Slider Maximum="1"

                   Value="{Binding Path=DownloadProgress, Mode=TwoWay}" Width="50" IsHitTestVisible="False"

                   Margin="5,0,0,0"/>

Etape 6 : Gestion des états visuels

Le VideoController centralise les propriétés de notre player video. Il est possible de changer l’état visuel de nos contrôles en fonction des propriétés du VideoController. Nous allons utiliser le behaviors fournis par SLExtensions pour mapper ces propriétés à nos VisualStates.

<UserControl x:Class="VideoPlayer1.Page"

   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   xmlns:slvideo="clr-namespace:SLMedia.Video;assembly=SLMedia.Video"

   xmlns:slec="clr-namespace:SLExtensions.Controls;assembly=SLExtensions.Controls"

   xmlns:sled="clr-namespace:SLExtensions.Data;assembly=SLExtensions.Data"

 

   xmlns:inter="clr-namespace:Microsoft.Expression.Interactivity;assembly=Microsoft.Expression.Interactivity"

   xmlns:slint="clr-namespace:SLExtensions.Interactivity;assembly=SLExtensions.Interactivity"

 

   xmlns:vsm="clr-namespace:System.Windows;assembly=System.Windows"

 

   Foreground="White"

    >

    <UserControl.Resources>

        <slvideo:VideoController x:Name="controller" />

        <sled:TimeSpanConverter x:Name="timeSpanConverter"/>

        <sled:StringFormatConverter x:Name="strConverter"/>

    </UserControl.Resources>

    <Grid x:Name="LayoutRoot" DataContext="{Binding Source={StaticResource controller}}">

        <vsm:VisualStateManager.VisualStateGroups>

            <vsm:VisualStateGroup x:Name="PlayingStates">

                <vsm:VisualStateGroup.Transitions>

                    <vsm:VisualTransition GeneratedDuration="00:00:00.3000000"/>

                </vsm:VisualStateGroup.Transitions>

                <vsm:VisualState x:Name="Playing">

                    <Storyboard>

                        <ColorAnimationUsingKeyFrames BeginTime="00:00:00" Duration="00:00:00.0010000" Storyboard.TargetName="stackPanel" Storyboard.TargetProperty="(Panel.Background).(SolidColorBrush.Color)">

                            <SplineColorKeyFrame KeyTime="00:00:00" Value="#5039FF00"/>

                        </ColorAnimationUsingKeyFrames>

                    </Storyboard>

                </vsm:VisualState>

                <vsm:VisualState x:Name="Paused">

                    <Storyboard>

                        <ColorAnimationUsingKeyFrames BeginTime="00:00:00" Duration="00:00:00.0010000" Storyboard.TargetName="stackPanel" Storyboard.TargetProperty="(Panel.Background).(SolidColorBrush.Color)">

                            <SplineColorKeyFrame KeyTime="00:00:00" Value="#50D56700"/>

                        </ColorAnimationUsingKeyFrames>

                    </Storyboard>

                </vsm:VisualState>

            </vsm:VisualStateGroup>

        </vsm:VisualStateManager.VisualStateGroups>

        <inter:Interaction.Behaviors>

            <slint:MapState Source="{StaticResource controller}" Property="IsPlaying" >

                <slint:MapStateMapping StateName="Playing" Value="true"/>

                <slint:MapStateMapping StateName="Paused" Value="false"/>

            </slint:MapState>

        </inter:Interaction.Behaviors>

 

        <MediaElement x:Name="mediaelement"

                    Source="{Binding Path=CurrentItem.SourceUri}"

                    slvideo:VideoController.MediaElement="{StaticResource controller}"

                    IsMuted="{Binding Path=IsMuted}"

                    Volume="{Binding Path=Volume}"

                    AutoPlay="{Binding Path=AutoPlay}"   

                    />

        <StackPanel Orientation="Horizontal" VerticalAlignment="Bottom" Background="#50000000" Margin="30" x:Name="stackPanel">

            <CheckBox IsChecked="{Binding Path=IsPlaying, Mode=TwoWay}" />

            <slec:Slider Maximum="{Binding Converter={StaticResource timeSpanConverter}, Path=Duration}"

                        MoveValue="{Binding Converter={StaticResource timeSpanConverter}, Mode=TwoWay, Path=Position}"

                        Width="200" Margin="20,0,0,0"

                        />

            <TextBlock Text="{Binding Converter={StaticResource timeSpanConverter}, Path=Position}"

                    Margin="20,0,0,0"/>

            <TextBlock Text=" / " />

            <TextBlock Text="{Binding Converter={StaticResource timeSpanConverter}, Path=Duration}" />

 

            <CheckBox IsChecked="{Binding Path=IsMuted, Mode=TwoWay}" Margin="20,0,0,0"/>

            <Slider Maximum="1" SmallChange="0.1" LargeChange="0.1"

                   Value="{Binding Path=Volume, Mode=TwoWay}" Width="50" />

 

            <TextBlock Text="Buffering:" />

            <TextBlock Text="{Binding Path=BufferingProgress, Mode=TwoWay, Converter={StaticResource strConverter}, ConverterParameter='{0:p}'}" />

            <Slider Maximum="1"

                   Value="{Binding Path=BufferingProgress, Mode=TwoWay}" Width="50" IsHitTestVisible="False" Margin="5,0,0,0"/>

 

            <TextBlock Text="Downloading:" Margin="20,0,0,0"/>

            <TextBlock Text="{Binding Path=DownloadProgress, Mode=TwoWay, Converter={StaticResource strConverter}, ConverterParameter='{0:p}'}" />

            <Slider Maximum="1"

                   Value="{Binding Path=DownloadProgress, Mode=TwoWay}" Width="50" IsHitTestVisible="False"

                   Margin="5,0,0,0"/>

 

            <CheckBox IsChecked="{Binding Path=IsFullscreen, Mode=TwoWay}" Margin="20,0,0,0" Content="Fullscreen" Foreground="White"/>

 

        </StackPanel>

    </Grid>

</UserControl>

#    Comments [0] |

Gestion de la mémoire sous Silverlight / .Net

On m’a interrogé récemment sur la libération de la mémoire des objets en silverlight. Je vais essayer de synthétiser ici ce que j’ai répondu.

Silverlight réagi exactement de la même manière que le framework .Net. La mémoire est gérée par un garbage collector (ramasse-miettes) qui libère les allocations mémoires des objets une fois qu’ils ne sont plus référencés. 

L’application de test

Voila le principe de mon application de test. Au clic sur un bouton, mon application ajoute un usercontrol dans l’arbre visuel et au clic sur un autre bouton, je l’enlève. La seule référence vers mon contrôle est faite par l’arbre graphique. Dans le constructeur de mon usercontrol, j’incrémente un compteur qui m’indique le nombre d’instances en cours et dans le destructeur je le décrémente. Ce compteur est affiché par binding dans l’interface graphique.

Petite parenthèse pour le fonctionnement de l’application, la destruction des objets ne se passe pas dans le thread graphique, pour que la mise a jour du binding fonctionne, je lève l’événement PropertyChanged de AppController par le SynchronizationContext récupéré du thread graphique.

Contrôle sans références

image

A l’ajout de mon usercontrol, on note bien l’incrémentation du compteur.

image

Je clic sur le bouton Remove et je vois que mon compteur est toujours à 1. Le garbage collector ne passe pas tout de suite. Il y a un algorithme qui détermine quand le garbage collector doit passer sur les objets. Pour le besoin de mon application, je vais forcer l’appel au garbage collector au clic sur le bouton Force GC. Il faut noter que c’est une mauvaise pratique que de vouloir appeler soit même de garbage collector. GC.Collect() ne doit être appelée que si vous en avez réellement l’utilité. Un appel trop fréquent peut dégrader les performances de votre application.

image

Le clic sur Force GC ramène bien le compte de référence à 0.

Contrôle s’abonnant à un événement

Comme je vous le précisait dans le fonctionnement de mon application, je ne maintient aucune référence vers mes usercontrol, je n’ai théoriquement rien qui va empêcher le garbage collector de passer. Cependant le contrôle lui même peut faire qu’il ne sera pas libéré. Ici ma classe AppController fourni un événement auquel mes contrôles peuvent s’abonner. MyControl2 va s’abonner à cet événement. Au clic sur le bouton Raise Test event, vous verez que la couleur du usercontrol change.

image

Si vous ajoutez le usercontrol MyControl2, que vous l’enlevez et que vous forcez le garbage collector, vous verrez que l’instance ne se libère pas. Que se passe-t-il ?
Lorsque le contrôle s’est abonné à l’événement de AppController, il a créé un EventHandler (une référence vers une fonction) et l’a ajouté à la liste des fonctions à appeler lorsque l’événement est levé. Un événement n’est rien d’autre qu’une liste de références qui pointe vers les fonctions à appeler. Pour que notre contrôle se libère, il faut donc supprimer cette référence. Un clic sur Clear Test event list demande à AppController de vider sa liste d’événement, un clic sur Force GC remettra les compteurs à 0.

IDisposable

Une bonne pratique pour gérer la libération de ressources internes et le désabonnement d’évenement est d’implémenter l’interface IDisposable. Cette interface vous demande d’implémenter la fonction Dispose dans laquelle vous pouvez remettre à null les références externes, vous désabonnez d’événements, etc…
Le usercontrol MyControl3 implémente cette interface. Lorsque le bouton Remove First Item est cliqué, mon application vérifie si le contrôle à enlever implémente IDisposable et l’appel le cas échéant.

image

Les clics successifs sur Add MyControl3, Remove First Item et Force GC incrémentent et décrémentent bien notre compteur de références.

WeakReference et proxy d’événement

Si vous ne maitrisez pas la logique d’ajout suppression des contrôles, vous ne pouvez pas toujours appeler la IDisposable.Dispose. (A noter que ce n’est pas parce qu’un contrôle n’est plus dans l’arbre d’affichage qu’il faut nécessairement le disposer. Un tabcontrol ajoute et enlève chaque tab de l’abre graphique.)

La classe WeakReference permet de maintenir une référence “qui ne compte pas” du point de vue du garbage collector. La propriété Target de la WeakReference vaut null quand le garbage collector est passé et renvoi l’instance de l’objet sinon.

Ici pour gérer notre abonnement à l’événement, nous allons utiliser ces WeakReference pour pouvoir quand même être libéré. La fonction à appeler en retour de l’événement est : MyControl4.Instance_TestEvent. Cette fonction est privée. WeakListener est une classe interne à MyControl4 et va donc pouvoir appeler cette fonction privée. C’est WeakListener.Instance_TestEvent que nous allons abonner à l’événement de AppController. Lors de l’appel de l’événement, elle va vérifier que sa WeakReference vers MyControl4 est toujours valide, si tel est le cas, cette fonction va transmettre l’appel vers la fonction MyControl4.Instance_TestEvent, sinon elle se désabonne de l’appelant et pourra donc aussi être collecté par le garbage collector.

    public partial class MyControl4 : UserControl

    {

 

        private class WeakListener

        {

            public WeakListener(MyControl4 target)

            {

                weakReference = new WeakReference(target);

            }

 

            private readonly WeakReference weakReference;

 

            public void Instance_TestEvent(object sender, EventArgs e)

            {

                MyControl4 ctrl = (MyControl4)weakReference.Target;

 

                if (ctrl != null)

                {

                    ctrl.Instance_TestEvent(sender, e);

                }

                else

                {

                    ((AppController)sender).TestEvent -= this.Instance_TestEvent;

                }

            }

        }

 

        void Instance_TestEvent(object sender, EventArgs e)

        {

            this.LayoutRoot.Background = new SolidColorBrush(GetRandomColor());

        }

 

       

    }

image

Un clic sur Add MyControl4, Remove et Force GC vous donnera un compte de référence de MyControl4 à 0. Il faut noter qu’à ce stade, MyControl4 a été libéré mais le WeakListener est toujours présent en mémoire. Sa libération ne sera effectué que lorsque l’événement sera appelé, la classe s’autodésabonnera toute seule de l’événement et pourra est collectée.

WeakEventList

J’ai ajouté dans slextensions une WeakEventList permettant de gérer une liste d’événements basés sur des WeakReference. A la place de stocker les événements par le processus standard de .Net, nous créons une liste de WeakReference directement sur les delegates abonnés.

Voila la déclaration de l’événement de ma class AppController.

        private WeakEventList<EventArgs> weakTestEvent;

 

        private event EventHandler<EventArgs> testEvent;

        public event EventHandler<EventArgs> TestEvent

        {

            add

            {

                if(UseWeakEvent)

                {

                    weakTestEvent.Event += value;

                }

                else

                {

                    testEvent += value;                   

                }

            }

            remove

            {

                if (UseWeakEvent)

                {

                    weakTestEvent.Event -= value;

                }

                else

                {

                    testEvent -= value;

                }

            }

        }

image

En cochant la case UseWeakEvent et en reproduisant le cas qui posait problème au début de ce post ( Add MyControl2, Remove, Force GC), on voit que la référence est bien libérée.

Vous trouvez plusieurs autres manières de créer des “weakevent” sur internet. Celle-ci est la seule qui marche en silverlight pour des appels à des fonctions privées. De nombreuses utilisent la réflexion pour pouvoir accéder à la fonction finale à appeler par l’événement, ceci n’est pas permit en silverlight si la déclaration est privée. Le mode MediumTrust de silverlight nous en empêche.

#    Comments [7] |

Silverlight Extensions et Silverlight Contrib

Comme nous vous le disions dans un précédent post et comme vous avez pu le voir sur les sites respectifs des deux projets, les 2 projets sont en cours de fusion. Le nom du projet résultant de cette fusion a été publié par Page Brooks sur un son blog. Un vote était organisé et c’est le nom silverlight extensions qui a remporté la majorité des voix. Retrouvez le post de Page Brooks

image[1] 

En attendant que la fusion avance, n’oubliez pas d’aller sur le site web des deux projets. slextensions et silverlight contrib

#    Comments [0] |

Utilisation des behaviors pour localiser une application silverlight ou WPF

Il y a quelques temps déjà, j’ai ajouté à slextensions une classe permettant de localiser simplement une application à partir d’attachedproperty. La mode étant aux behaviors, j’ai rajouté une classe permettant cette localisation à la branche SL3 de slextensions. Cette classe possède 4 propriétés :

  • Key : la clé de la ressource provenant de votre ResourceManager
  • PropertyName : Le nom de la propriété à localiser
  • ResourceManagerKey : La clé avec laquelle retrouver le ResourceManager dans les ressources de l’application
  • ConvertXaml : Si la resource contient du Xaml, permet d’instancier ce xaml par le XamlReader.

L’utilisation est très simple voici un exemple de localisation d’un texte

            <TextBlock  >

                <i:Interaction.Behaviors>

                    <SLExtensions_Interactivity:Localize Key="WelcomeMessage" PropertyName="Text" ResourceManagerKey="MyResource" />

                </i:Interaction.Behaviors>

            </TextBlock>

et d’un ContentControl

            <ContentControl Height="121" Width="244" Canvas.Left="25" Canvas.Top="206" >

                <i:Interaction.Behaviors>

                    <SLExtensions_Interactivity:Localize Key="Welcome" PropertyName="Content" ResourceManagerKey="MyResource" ConvertXaml="True"/>

                </i:Interaction.Behaviors>

            </ContentControl>

Le code de la classe :

using System;

using System.Linq;

using System.Net;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Documents;

using System.Windows.Ink;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Shapes;

using Microsoft.Expression.Interactivity;

using System.Resources;

using System.Globalization;

using System.Windows.Markup;

using SLExtensions.Globalization;

 

namespace SLExtensions.Interactivity

{

    public class Localize : Behavior<FrameworkElement>

    {

 

        private string key;

 

        public string Key

        {

            get

            {

                return this.key;

            }

 

            set

            {

                if (this.key != value)

                {

                    this.key = value;

                    Refresh();

                }

            }

        }

 

        private bool convertXaml;

 

        public bool ConvertXaml

        {

            get

            {

                return this.convertXaml;

            }

 

            set

            {

                if (this.convertXaml != value)

                {

                    this.convertXaml = value;

                    Refresh();

                }

            }

        }

 

 

        private DependencyProperty dependencyProperty;

 

        private string propertyName;

 

        public string PropertyName

        {

            get

            {

                return this.propertyName;

            }

 

            set

            {

                if (this.propertyName != value)

                {

                    this.propertyName = value;

                    this.dependencyProperty = null;

                    Refresh();

                }

            }

        }

 

        private string resourceManagerKey;

 

        public string ResourceManagerKey

        {

            get

            {

                return this.resourceManagerKey;

            }

 

            set

            {

                if (this.resourceManagerKey != value)

                {

                    this.resourceManagerKey = value;

                }

            }

        }

 

        private void Refresh()

        {

            if (AssociatedObject == null

                || string.IsNullOrEmpty(propertyName)

                || string.IsNullOrEmpty(Key)

                || string.IsNullOrEmpty(ResourceManagerKey))

                return;

 

            if (dependencyProperty == null)

            {

                Type t = AssociatedObject.GetType();

                var field = t.GetField(propertyName + "Property", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);

                if (field != null)

                {

                    dependencyProperty = field.GetValue(null) as DependencyProperty;

                }

            }

 

            if (dependencyProperty != null

                && Application.Current != null)

            {

                ResourceManager resourceManager = null;

                var obj = Application.Current.Resources[ResourceManagerKey];

                if (obj is ResourceLoader)

                {

                    resourceManager = ((ResourceLoader)obj).GetResourceManager();

                }

                else

                {

                    resourceManager = obj as ResourceManager;

                }

 

                var resourceValue = resourceManager.GetObject(Key, CultureInfo.CurrentCulture);

                if (convertXaml && resourceValue is string)

                {                   

                    resourceValue = XamlReader.Load((string)resourceValue);

                }

                AssociatedObject.SetValue(dependencyProperty, resourceValue);

            }

        }

 

        protected override void OnAttached()

        {

            Refresh();

            base.OnAttached();

        }

 

        protected override void OnDetaching()

        {

            base.OnDetaching();

        }

    }

}

#    Comments [0] |

Les behavior en Silverlight 3 - MapState behavior

Exemple

Les behaviors introduits par blend 3 servent à étendre les fonctionnalités d’un contrôle à l’aide d’une nouvel élément que l’on peut poser graphiquement dans l’interface de blend. L’ajout de comportement n’est pas nouveau, c’est utilisé dans de nombreux projets (par exemple, la navigation deepzoom de slextensions est géré de cette manière), mais ici, l’intégration à blend est plutôt pratique et permet à un intégrateur de gérer du comportement sans écrire de code.

La classe MapState me permet de mapper l’état d’une propriété d’un contrôleur à un VisualState posé sur mon contrôle.

Ma classe contrôleur de test n’a rien de particulier. Voici sa définition.

    public class ApplicationController : INotifyPropertyChanged

    {

 

        #region INotifyPropertyChanged Members

 

        public event PropertyChangedEventHandler PropertyChanged;

 

        protected void OnPropertyChanged(string propertyName)

        {

            if (PropertyChanged != null)

            {

                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

            }

        }

 

        #endregion

 

        private TestStates state;

        public TestStates State

        {

            get { return state; }

            set

            {

                if (state != value)

                {

                    state = value;

                    OnPropertyChanged(StatePropertyName);

                }

            }

        }

 

        public const string StatePropertyName = "State";

 

    }

J’instancie ce contrôleur en l’injectant dans les ressources de l’application

<Application xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

            x:Class="TestBehavior.App"

            xmlns:controllers="clr-namespace:TestBehavior.Controllers"

            >

    <Application.Resources>

        <controllers:ApplicationController x:Key="appController" />

    </Application.Resources>

</Application>

Je rajoute les références qui vont bien à mon projet

image

Je peux maintenant rajoute mon behavior à l’aide de blend

image

Je remplie le mapping et la source de mon behavior avec blend

image

Le morceau de code qui change l’état du contrôleur.

        private void Button_Click(object sender, RoutedEventArgs e)

        {

            ApplicationController appController = Application.Current.Resources["appController"] as ApplicationController;

            appController.State = (TestStates) ((1 + (int)appController.State) % 3);

        }

Le code

Ma classe MapState hérite d’une classe ancêtre Behavior que vous trouverez dans l’assembly Microsoft.Expression.Interactivity.dll qui se trouve dans le dossier Libraries/Silverlight de Blend 3.

J’ai déclaré une propriété Source qui me sert à récupérer l’objet métier qui va me donner mon état et une propriété Property me donnant le nom de la propriété d’état. Ma source doit bien sur implémenter INotifyPropertyChanged pour que MapState soit notifiée du changement de propriété.
J’ai également une collection de MapStateMapping qui me fournisse un couple Valeur / VisualState.
Au changement de valeur sur ma source, je n’ai plus qu’à comparer par rapport aux valeurs de mapping est à déclancher le visualstate sur mon élément associé.

Le code complet de la classe :

namespace SLExtensions.Interactivity

{

    [ContentProperty("Mappings")]

    public class MapState : Behavior<FrameworkElement>

    {

        public MapState()

        {

            Mappings = new List<MapStateMapping>();

        }

 

        #region Source

 

        private PropertyInfo propertyInfo = null;

 

        public object Source

        {

            get

            {

                return (object)GetValue(SourceProperty);

            }

 

            set

            {

                SetValue(SourceProperty, value);

            }

        }

 

        /// <summary>

        /// Source depedency property.

        /// </summary>

        public static readonly DependencyProperty SourceProperty =

            DependencyProperty.Register(

                "Source",

                typeof(object),

                typeof(MapState),

                new PropertyMetadata((d, e) => ((MapState)d).OnSourceChanged((object)e.OldValue, (object)e.NewValue)));

 

        /// <summary>

        /// handles the SourceProperty changes.

        /// </summary>

        /// <param name="oldValue">The old value.</param>

        /// <param name="newValue">The new value.</param>

        private void OnSourceChanged(object oldValue, object newValue)

        {

            propertyInfo = null;

            INotifyPropertyChanged notifyingObject = oldValue as INotifyPropertyChanged;

            if (notifyingObject != null)

            {

                notifyingObject.PropertyChanged -= new PropertyChangedEventHandler(notifyingObject_PropertyChanged);

            }

            notifyingObject = newValue as INotifyPropertyChanged;

            if (notifyingObject != null)

            {

                notifyingObject.PropertyChanged += new PropertyChangedEventHandler(notifyingObject_PropertyChanged);

            }

            if (newValue != null && !string.IsNullOrEmpty(Property))

            {

                propertyInfo = newValue.GetType().GetProperty(Property);

            }

            RefreshState();

        }

 

        #endregion Source

 

        #region Property

 

        public string Property

        {

            get

            {

                return (string)GetValue(PropertyProperty);

            }

 

            set

            {

                SetValue(PropertyProperty, value);

            }

        }

 

        /// <summary>

        /// Property depedency property.

        /// </summary>

        public static readonly DependencyProperty PropertyProperty =

            DependencyProperty.Register(

                "Property",

                typeof(string),

                typeof(MapState),

                new PropertyMetadata((d, e) => ((MapState)d).OnPropertyChanged((string)e.OldValue, (string)e.NewValue)));

 

        /// <summary>

        /// handles the PropertyProperty changes.

        /// </summary>

        /// <param name="oldValue">The old value.</param>

        /// <param name="newValue">The new value.</param>

        private void OnPropertyChanged(string oldValue, string newValue)

        {

            if (Source == null)

                propertyInfo = null;

            else

                propertyInfo = Source.GetType().GetProperty(newValue);

 

            RefreshState();

        }

 

        #endregion Property

 

        public List<MapStateMapping> Mappings { get; private set; }

 

 

 

        void notifyingObject_PropertyChanged(object sender, PropertyChangedEventArgs e)

        {

            if(e.PropertyName == Property)

                RefreshState();

        }

 

        private void RefreshState()

        {

            // Do not refresh at desing time

            if (!HtmlPage.IsEnabled)

                return;

 

            if (Source != null && propertyInfo != null )

            {

                object propValue = propertyInfo.GetValue(Source, null);

 

                if (propValue == null)

                {

                    var nullMappings = from m in Mappings

                                       where m.Value == null

                                       || ((m.Value is string) && string.Empty.Equals(m.Value))

                                       select m.StateName;

 

                    try

                    {

                        SLExtensions.Controls.Animation.VisualState.GoToState(AssociatedObject, UseTransitions, nullMappings.ToArray());

                    }

                    catch

                    {

                    }

                }

                else

                {

                    MapStateMapping mapping = null;

                    foreach (var item in Mappings)

                    {

                        var value = item.Value;

                        if (value != null)

                        {

                            if (object.Equals(value, propValue))

                            {

                                mapping = item;

                                break;

                            }

 

                            if (propValue is IConvertible && value is IConvertible)

                            {

                                try

                                {

                                    var val2 = Convert.ChangeType(propValue, value.GetType(), CultureInfo.InvariantCulture);

                                    if (object.Equals(val2, value))

                                    {

                                        mapping = item;

                                        break;

                                    }

                                }

                                catch

                                {

                                }

 

                                try

                                {

                                    var val2 = Convert.ChangeType(value, propValue.GetType(), CultureInfo.InvariantCulture);

                                    if (object.Equals(val2, propValue))

                                    {

                                        mapping = item;

                                        break;

                                    }

                                }

                                catch

                                {

                                }

                            }

                        }

                    }

 

                    if (mapping != null)

                    {

                        try

                        {

                            SLExtensions.Controls.Animation.VisualState.GoToState(AssociatedObject, UseTransitions, mapping.StateName);

                        }

                        catch

                        {

                        }

                    }

                }

            }

        }

 

        /// <summary>

        ///

        /// </summary>

        public static readonly DependencyProperty UseTransitionsProperty = DependencyProperty.Register("UseTransitions", typeof(bool), typeof(MapState), new PropertyMetadata(true));

 

        /// <summary>

        /// True if transitions should be used for the state change.

        /// </summary>

        public bool UseTransitions

        {

            get { return (bool)this.GetValue(MapState.UseTransitionsProperty); }

            set { this.SetValue(MapState.UseTransitionsProperty, value); }

        }

 

        /// <summary>

        /// Hooks up necessary handlers for the state changes.

        /// </summary>

        protected override void OnAttached()

        {

            base.OnAttached();

 

            FrameworkElement element = this.AssociatedObject;

            if (element != null)

            {

                element.Loaded += new RoutedEventHandler(element_Loaded);

 

                RefreshState();

            }

            else

            {

                Dispatcher.BeginInvoke(delegate

                {

                    this.OnAttached();

                });

            }

        }

 

        void element_Loaded(object sender, RoutedEventArgs e)

        {

            RefreshState();

        }

    }

}

Les sources

En attendant de publier tout ça sur slextensions, vous pouvez télécharger le projet ici: 
Vous pouvez retrouver d’autres behavior sur le site de la gallery expression : http://gallery.expression.microsoft.com/

#    Comments [0] |

Silverlight Contrib et Silverlight Extensions fusionnent

logo-slExt-ContrNous sommes fières d’annoncer aujourd’hui la fusion de Silverlight Contrib et Silverlight Extensions en un seul et unique projet ! Nous pensons que cette fusion apportera beaucoup de bénéfic es à la communauté. Cette combinaison permettra aux développeurs d’avoir un point unique pour rechercher des contrôles à intégrer dans leurs applications ainsi que pour en soumettre de nouveaux. Cette action réduira le temps passé dans chaque projet pour vous fournir des fonctionnalités équivalentes et nous permettra d’accélérer la cadence des releases.

Pendant la phase de consolidation du code, nous vous encourageons à nous soumettre vos retours ou problèmes à chaque projets. Nous fusionnerons les informations des deux projets lorsque le site commun sera ouvert et le nom final déterminé.

Quel nom allons-nous garder ? Cette décision vous appartient ! Vos votes détermineront le plus populaire. Assurez-vous que votre préférence soit prise en compte, votez ! Les votes seront acceptés jusqu’au 29 mars 2009 23:00 (GMT+1)

Nous vous tiendrons informé des évolutions sur chacun des blogs des 2 projets Silverlight Contrib et Silverlight Extensions.

Retrouvez ce post sur le site de Silverlight Contrib

Les équipes de slextensions et silverlight contrib.

#    Comments [0] |

SLExtensions Converters – AlternateBackgroundConverter

Le projet SLExtensions commence à être assez conséquent. Je vais essayer de poster un peu plus régulièrement sur ce qu’il contient et compléter les exemples. Je commence donc cette série d’article par un des nombreux converter contenu dans le projet.

L’AlternateBackgroundConverter retourne un brush différent chaque fois que le converter est appelé.
Ce converter nécessite que la propriété ConverterParameter soit spécifiée lors du binding.
Le ConverterParameter peut être soit une string contenant une liste de couleurs séparées par des espaces soit une référence à un objet AlternateBackgroundConverterParameter.

  • Lorsqu’une string est passée, les couleurs peuvent être spécifiées au format argb sous forme hexadécimale (#RRGGBB ou #AARRGGBB) ou être un des nom de propriété existant dans la classe Colors (White, Red, Yellow, etc…)
  • Lorsqu’un AlternateBackgroundConverterParameter est passé, vous pouvez spécifier n’importe quel type de brush, SolidBrush, GradientBrush, VideoBrush, ImageBrush

 

<UserControl x:Class="SLExtensions.Showcase.PageAlternateConverter"

   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   xmlns:sled="clr-namespace:SLExtensions.Data;assembly=SLExtensions"

   xmlns:scControllers="clr-namespace:SLExtensions.Showcase.Controllers;assembly=SLExtensions.Showcase"

  >

    <UserControl.Resources>

 

        <sled:AlternateBrushConverter x:Key="alternateConverter" />

 

        <sled:AlternateBrushConverterParameter x:Key="alternateParameter" >

            <sled:AlternateBrushConverterParameter.Brushes>

                <SolidColorBrush Color="White"/>

                <LinearGradientBrush StartPoint="0.45666,0.185989" EndPoint="1.22116,0.185989">

                    <LinearGradientBrush.RelativeTransform>

                        <TransformGroup>

                            <SkewTransform CenterX="0.45666" CenterY="0.185989" AngleX="0.135522" AngleY="0"/>

                            <RotateTransform CenterX="0.45666" CenterY="0.185989" Angle="82.8625"/>

                        </TransformGroup>

                    </LinearGradientBrush.RelativeTransform>

                    <GradientStop Color="#80FFFFFF" Offset="0"/>

                    <GradientStop Color="#808C8A8C" Offset="0.62345"/>

                    <GradientStop Color="#8019161A" Offset="1"/>

                </LinearGradientBrush>

                <SolidColorBrush Color="Gainsboro"/>

                <SolidColorBrush Color="#FFDD22"/>

            </sled:AlternateBrushConverterParameter.Brushes>

        </sled:AlternateBrushConverterParameter>

    </UserControl.Resources>

    <StackPanel x:Name="LayoutRoot" Background="White" >

        <TextBlock Text="Alternating brush converter"/>

        <ItemsControl ItemsSource="ABCDEFGH">

            <ItemsControl.ItemTemplate>

                <DataTemplate>

                    <Grid Background="{Binding Path='', Converter={StaticResource alternateConverter}, ConverterParameter={StaticResource alternateParameter}}">

                        <TextBlock Text="{Binding}" />   

                    </Grid>

                </DataTemplate>

            </ItemsControl.ItemTemplate>

        </ItemsControl>

 

        <ItemsControl ItemsSource="ABCDEFGH" Margin="0,40,0,0">

            <ItemsControl.ItemTemplate>

                <DataTemplate>

                    <Grid Background="{Binding Path='', Converter={StaticResource alternateConverter}, ConverterParameter='White Gray #FFDD22'}">

                        <TextBlock Text="{Binding}" />

                    </Grid>

                </DataTemplate>

            </ItemsControl.ItemTemplate>

        </ItemsControl>

    </StackPanel>

</UserControl>

#    Comments [0] |

Projet Silverlight "Being the Big Boss"

Depuis le 8 décembre la version 1 de www.beingthebigboss.com est en ligne !

 

Il s’agit d’un jeu de simulation économique et d’entreprise, à “But récréatif et pédagogique : Mettez vous dans la peau d'un PDG d'une multinationale et construisez un empire reconnu et respecté !”.

Being the Big Boss est réalisé pour la partie client en Silverlight 2. Pour la partie serveur SQL Server 2008, LinqToEntities et WCF pour la communication Client/Serveur.

Quelques infos supplémentaires :

- Côté Silverlight il s’appuie sur la librairie SLExtensions ;-)

- Le modèle UML a été créé avec ArgoUML

- La génération du mapping est réalisé avec EF.Wizard

Pour vous donner un avant goût :

#    Comments [0] |

Captcha en Silverlight

Encore un nouveau venu dans SLExtensions. Voici un contrôle de captcha qui se branche sur le service gratuit www.recaptcha.net.

Le principe

recaptcha-api-diagram 

  1. 1 L’utilisateur télécharge l’application silverlight qui contient le contrôle de captcha.
  2. 2 Le contrôle de captcha récupère une image plus une clé de cryptage du serveur d’image de www.recaptcha.net.
  3. 3 Le contrôle de captcha renvoie au serveur web (par POST, Get, Webservice, comme vous voulez), la clé de cryptage optenue auprès de www.recaptcha.net ainsi que les mots saisis par l’utilisateur.
  4. 4 Le serveur web fait un appel au serveur www.recaptcha.net en passant les données venues de l’utilisateur (mots + clé) plus une clé privée. Le serveur reCaptcha valide ou non le captcha. Le serveur fait ensuite (ou non) son traitement.
  5. 5 Retour vers l’utilisateur pour l’informer du résultat.

Le contrôle

<UserControl x:Class="SLExtensions.Showcase.PageRecaptcha"

   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   xmlns:slec="clr-namespace:SLExtensions.Controls;assembly=SLExtensions.Controls"

   Width="400" Height="300">

    <StackPanel x:Name="LayoutRoot" Background="White">

        <slec:ReCaptcha x:Name="captcha" PublicKey="6LesLAMAAAAAACjPBtyjD80bwTowvEQrslT8bJvT" HorizontalAlignment="Center" VerticalAlignment="Center" >

            <slec:ReCaptcha.Verifier>

                <slec:ReCaptchaHttpPostVerifier Url="/VerifyCaptcha.aspx" Success="ReCaptchaHttpPostVerifier_Success" Failed="ReCaptchaHttpPostVerifier_Failed"/>

            </slec:ReCaptcha.Verifier>

        </slec:ReCaptcha>

    </StackPanel>

</UserControl>

Pour utiliser le contrôle, vous devez fournir un objet qui implémente l’interface IReCaptchaVerifier. C’est lui qui va se charger de faire l’appel au webservice vers votre serveur. Dans SLExtensions, j’ai ajouté une classe d’exemple qui fait un POST http des informations ainsi que la page aspx qui valide les informations auprès de recaptcha.

#    Comments [0] |

DeepZoom facile

J’ai rajouté dans le projet SLExtensions une librairie permattant de gérer facilement vos galleries DeepZoom. Il rajoute grâce aux méthodes d’extensions des fonctions utiles comme le positionnement automatique de votre collection, la gestion de la roulette de la souris, le glisser du deepzoom, le zoom sur une image de la collection, etc…

<UserControl x:Class="SLExtensions.Showcase.PageDeepZoom"

   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   xmlns:sledz="clr-namespace:SLExtensions.DeepZoom;assembly=SLExtensions.DeepZoom"

   >

    <Grid x:Name="LayoutRoot" Background="White">

        <Grid.RowDefinitions>

            <RowDefinition Height="Auto"/>

            <RowDefinition/>

        </Grid.RowDefinitions>

 

        <StackPanel Orientation="Horizontal">

            <Button Content="Next" Click="Next_Click"/>

            <Button Content="Previous" Click="Previous_Click"/>

            <Button Content="All" Click="All_Click"/>

        </StackPanel>

 

        <MultiScaleImage x:Name="msi" Source="http://labs.ucaya.com/dznantes/dzc_output.xml"

                        Grid.Row="1"

                        sledz:DZExtensions.ArrangeOnFirstMotionFinished="True"

                        sledz:DZExtensions.IsMousePanEnabled="True"

                        sledz:DZExtensions.IsMouseWheelEnabled="True"/>

    </Grid>

</UserControl>

L’activation de la gestion de la souris ainsi que le positionnement automatique des images se fait par des AttachedProperty à déclarer sur le contrôle MultiScaleImage.
Dans cet exemple, j’ai rajouté 3 bouttons permettant de faire un simple slideshow des images deepzoom. Ils exécutent des fontions d’extensions disponibles dans le namespace SLExtensions.DeepZoom.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Net;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Shapes;

using SLExtensions.DeepZoom;

 

namespace SLExtensions.Showcase

{

    public partial class PageDeepZoom : UserControl

    {

        public PageDeepZoom()

        {

            InitializeComponent();

        }

 

        private int collectionIndex = -1;

 

        private void Next_Click(object sender, RoutedEventArgs e)

        {

            DZContext context = msi.EnsureContext();

            collectionIndex = (collectionIndex + 1) % context.ImagesToShow.Count;

            msi.ZoomFullAndCenterImage(collectionIndex);

        }

 

        private void Previous_Click(object sender, RoutedEventArgs e)

        {

            DZContext context = msi.EnsureContext();

            collectionIndex = (collectionIndex + context.ImagesToShow.Count - 1) % context.ImagesToShow.Count;

            msi.ZoomFullAndCenterImage(collectionIndex);

        }

 

        private void All_Click(object sender, RoutedEventArgs e)

        {

            msi.ZoomCenter();

        }

    }

}

#    Comments [1] |

Silverlight FlowLayout animé

J’ai porté un exemple du Kevin's WPF Bag-o-Tricks dans SLExtensions.
Voici un petit exemple d’utilisation.

        <ItemsControl Grid.Row="1" ItemsSource="azertyuiopsdfghjklazertyuiopsdfghjklazertyuiopsdfghjklazertyuiopsdfghjklazertyuiopsdfgh” >

            <ItemsControl.ItemsPanel>

                <ItemsPanelTemplate>

                    <slec:AnimatingTilePanel />

                ItemsPanelTemplate>

            ItemsControl.ItemsPanel>

        ItemsControl>

div>
#    Comments [0] |

Silverlight DockPanel

SLExtensions ajoute maintenant un DockPanel à la liste de ses contrôles.

        <slec:DockPanel Grid.Row="1" LastChildFill="True">

            <Button Content="Top" slec:DockPanel.Dock="Top" Height="60" />

            <Button Content="Left" slec:DockPanel.Dock="Left" Width="60" />

            <Button Content="Right" slec:DockPanel.Dock="Right" Width="60" />

            <Button Content="Bottom" slec:DockPanel.Dock="Bottom" Height="60" />

            <Button Content="Fill" />

        slec:DockPanel>

div>
#    Comments [0] |

France Télévision

playerinfo France Télévision sort son “player info”. Il permet de revoir les journaux de toutes les chaines du groupe France Télévision. Vous pourrez maintenant regarder le journal de votre région même si vous êtes en déplacement à l’autre bout du monde. Ucaya a participé à la réalisation de ce player. Il est développé en Silverlight 2 et utilise la librairie SLExtensions.

#    Comments [0] |

Animer des propriétés non animables par Storyboard

Le moteur d'animation de silverlight ne permet d'animer que certains types de propriétés : des couleurs, des doubles et des points. Il n'est a priori pas simple d'animer une propriété comme Margin. En rusant un peu, on se rend compte qu'il est tout à fait possible de le faire. L'idée est de passer par une classe intermédiaire qui possède une propriété simple et de faire la conversion vers le type Thickness utilisé pour représenté une Margin. Afin de facilité l'utilisation de cette classe depuis le Xaml, elle hérite de Panel et peut donc être posée dans n'importe quel conteneur. Voici donc un petit exemple que vous retrouverez bien sur dans le projet SLExtensions.

La classe wrapper

namespace SLExtensions.Controls.Animation

{

    ...

 

    public class MarginWrapper : Panel

    {

        public MarginWrapper()

        {

            // Hide this control. It's just a wrapper and does not need to be shown in the GUI

            this.Visibility = Visibility.Collapsed;

            this.Loaded += new RoutedEventHandler(MarginWrapper_Loaded);

        }

 

        void MarginWrapper_Loaded(object sender, RoutedEventArgs e)

        {

            EnsureElement();

        }

 

        public string ElementName { get; set; }

 

        private FrameworkElement element;

 

        private void EnsureElement()

        {

            if (element == null)

            {

                element = this.FindName(ElementName) as FrameworkElement;

                if (element != null)

                {

                    Thickness margin = element.Margin;

                    if (margin != null)

                    {

                        MarginLeft = margin.Left;

                        MarginTop = margin.Top;

                        MarginRight = margin.Right;

                        MarginBottom = margin.Bottom;

                    }

                }

            }

        }

 

        #region MarginLeft

 

        public double MarginLeft

        {

            get

            {

                return (double)GetValue(MarginLeftProperty);

            }

 

            set

            {

                SetValue(MarginLeftProperty, value);

            }

        }

 

        /// <summary>

        /// MarginLeft depedency property.

        /// </summary>

        public static readonly DependencyProperty MarginLeftProperty =

            DependencyProperty.Register(

                "MarginLeft",

                typeof(double),

                typeof(MarginWrapper),

                new PropertyMetadata((d, e) => ((MarginWrapper)d).OnMarginLeftChanged((double)e.OldValue, (double)e.NewValue)));

 

        /// <summary>

        /// handles the MarginLeftProperty changes.

        /// </summary>

        /// <param name="oldValue">The old value.</param>

        /// <param name="newValue">The new value.</param>

        private void OnMarginLeftChanged(double oldValue, double newValue)

        {

            EnsureElement();

            if (element != null)

            {

                Thickness margin = element.Margin;

                if (margin == null)

                    margin = new Thickness();

 

                margin.Left = newValue;

                element.Margin = margin;

            }

        }

 

        #endregion MarginLeft

 

...

 

    }

}

Un exemple de Xaml

<UserControl x:Class="SLExtensions.Showcase.PageAnimation"

   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   xmlns:anim="clr-namespace:SLExtensions.Controls.Animation;assembly=SLExtensions.Controls"

   xmlns:slei="clr-namespace:SLExtensions.Input;assembly=SLExtensions"

   >

    <UserControl.Resources>

        <Storyboard x:Name="anim1">

            <DoubleAnimation Storyboard.TargetName="marginWrapper1" Storyboard.TargetProperty="MarginLeft" To="150" Duration="0:00:03"/>

        </Storyboard>

    </UserControl.Resources>

    <StackPanel x:Name="LayoutRoot" Background="White">

        <StackPanel Orientation="Horizontal">

            <Button Content="Start" slei:CommandService.Command="BeginStoryboard" slei:CommandService.CommandParameter="anim1" />

            <Button Content="Stop" slei:CommandService.Command="StopStoryboard" slei:CommandService.CommandParameter="anim1"/>

                <Grid Width="400" Height="100">

                    <anim:MarginWrapper x:Name="marginWrapper1" ElementName="rect1" />

                    <Rectangle x:Name="rect1" Fill="Red" Width="50" Height="50" VerticalAlignment="Top" HorizontalAlignment="Left" Margin="50,0,0,0" />

                </Grid>

            </StackPanel>

    </StackPanel>

</UserControl>

#    Comments [0] |

Silverlight Extensions

Vous trouverez les exemples de code que je poste sur ce blog dans un projet nommé SLExtensions qui est disponible sur CodePlex. En plus des exemples de codes, vous trouverez quelques contrôles silverlight comme un TreeView ou un StackPanel virtualisé. Un mini showcase est visible ici : http://labs.ucaya.com/slextensions

#    Comments [0] |

Unload des contrôles en Silverlight

Il est parfois nécessaire d'être notifié lorsqu'un contrôle n'est plus dans l'arbre graphique de silverlight. Il n'existe pas à l'heure actuelle (c'est à dire dans la beta 2) d'événement unload, cependant, l'événement LayoutUpdated est levé sur les contrôles lorsqu'ils sont enlevés de leur parent. Voici un petit exemple de code. Notez au passage l'utilisation des méthodes d'extension.

namespace SLExtensions

{

    using System;

    using System.Text;

    using System.Windows;

    using System.Windows.Browser;

    using System.Windows.Controls;

    using System.Windows.Documents;

    using System.Windows.Ink;

    using System.Windows.Input;

    using System.Windows.Interop;

    using System.Windows.Media;

    using System.Windows.Media.Animation;

    using System.Windows.Shapes;

    using System.Collections.Generic;

 

    /// <summary>

    /// Method extensions for SLExtension framework

    /// </summary>

    public static class SLExtension

    {

       ...

 

        /// <summary>

        /// Determines whether an element is in the visual tree of the current application.

        /// </summary>

        /// <param name="element">The element.</param>

        /// <returns>

        ///    <c>true</c> if element paramter is in visual tree otherwise, <c>false</c>.

        /// </returns>

        public static bool IsInVisualTree(this FrameworkElement element)

        {

            return IsInVisualTree(element, Application.Current.RootVisual as FrameworkElement);

        }

 

        /// <summary>

        /// Determines whether an element is in the visual tree of a given ancestor.

        /// </summary>

        /// <param name="element">The element.</param>

        /// <param name="ancestor">The ancestor.</param>

        /// <returns>

        ///    <c>true</c> if element paramter is in visual tree otherwise, <c>false</c>.

        /// </returns>

        public static bool IsInVisualTree(this FrameworkElement element, FrameworkElement ancestor)

        {

            FrameworkElement fe = element;

            while (fe != null)

            {

                if (fe == ancestor)

                    return true;

                fe = fe.Parent as FrameworkElement;

            }

            return false;

        }

 

       ...

    }

}

 

<UserControl x:Class="SLExtensions.Showcase.IsInVisualTree"

   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   Width="400" Height="300">

    <Grid x:Name="LayoutRoot" Background="White">

        <Rectangle x:Name="rect" Fill="Cornsilk" LayoutUpdated="rect_LayoutUpdated" />       

        <Button Content="Remove rect" Height="40" VerticalAlignment="Bottom" HorizontalAlignment="Center" Width="100" Click="Button_Click" />

    </Grid>

</UserControl>

 

using SLExtensions;

 

namespace SLExtensions.Showcase

{

    public partial class IsInVisualTree : UserControl

    {

        public IsInVisualTree()

        {

            InitializeComponent();

        }

 

        private void Button_Click(object sender, RoutedEventArgs e)

        {

            LayoutRoot.Children.Remove(rect);

        }

 

        private void rect_LayoutUpdated(object sender, EventArgs e)

        {

            if (!rect.IsInVisualTree())

            {

                // Handle unload behavior

            }

        }

    }

}

xcvcx

#    Comments [0] |

Silverlight Command pattern et AttachedProperty

Les AttachedProperty

Ce type de propriété permet d'enrichir les propriétés existantes d'un objet. Ce sont des propriétés qui n'ont pas forcément de sens au niveau du contrôle lui-même, mais qui en ont au vu d'un contexte externe. Les AttachedProperty les plus connues sont Canvas.Left, Canvas.Top, Grid.Column et Grid.Row. Vous remarquerez que la propriété colonne n'a aucun sens sur un contrôle en dehors du contexte de la grille.

Ces AttachedProperty nous permettent d'étendre le comportement de nos contrôles. Nikhilk nous donne un exemple d'implémentation d'un framework de comportement sur son blog.

Le Command pattern

Ce pattern a pour but de séparer le comportement de la partie IHM. L'idée est de ne plus s'attacher directement aux événements des contrôles et de passer par un objet Command qui va faire la liaison entre le comportement et la saisie des utilisateurs.
Vous trouverez une bonne description du pattern Command en WPF sur le site de microsoft. Cette séparation permet de pouvoir déclencher l'action depuis l'IHM mais aussi depuis d'autres classes métiers.

Le code

La classe centrale est CommandService. Elle défini les AttachedProperty, c'est elle qui devra être référencée dans le xaml pour relier un contrôle à une commande.

<UserControl  xmlns="http://schemas.microsoft.com/client/2007"

   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   xmlns:sle="clr-namespace:SLExtensions.Input;assembly=SLExtensions"

...

        <Button Content="Open" Width="50" Height="30"

                      sle:CommandService.Command="Open"

                      sle:CommandService.CommandParameter="{Binding OpenFileInfo, Source={StaticResource controller}}" />

 

...

</UserControl>

Dans cet exemple, le bouton "Open" est bindé à la commande Open. On passe en paramètre à la commande un object OpenFileInfo qui est stocké sur le contrôleur de la page. Il sert à passer les paramètres d'exécution de la commande.

Du coté métier, le contrôleur de la page s'attache à l'événement Executed de la commande

...

 TestCommands.OpenCommand.Executed += new ExecutedEventHandler(OpenCommand_Executed);

...

void OpenCommand_Executed(object sender, ExecutedEventArgs e)

{

    OpenFileDialogInfo info = e.Parameter as OpenFileDialogInfo;

    if (info != null)

    {

        using (OpenFileDialog ofd = new OpenFileDialog())

        {

            ofd.EnableMultipleSelection = info.EnableMultipleSelection;

            ofd.Filter = info.Filter;

            ofd.ShowDialog();

        }

    }

}

 

Téléchargements Sources

#    Comments [0] |

Le data binding en Silverlight

Le data binding est une des fonctionnalités les plus puissantes de Silverlight et WPF. Il n'est plus nécessaire de passer du temps à faire du code pour la synchronisation des données. Cela contribue à la séparation de la partie visuelle de la partie métier.

Fonctionnement

En beta 1, le data binding est implémenté sur tout les objets qui héritent de FrameworkElement. Les propriétés de ce contrôle peuvent être liées à un objet source spécifiée lors du binding ou être liées au contexte de binding en cours. Le binding en cours est stockée par la propriété DataContext.

  • Exemple 1:

    1 <UserControl x:Class="Ucaya.SilverlightTest.Page"

    2    xmlns="http://schemas.microsoft.com/client/2007"

    3    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    4    xmlns:sys="clr-namespace:System;assembly=mscorlib"

    5    Width="400" Height="300">

    6     <UserControl.Resources>

    7         <sys:String x:Name="src">Binding source</sys:String>

    8     </UserControl.Resources>

    9     <StackPanel x:Name="LayoutRoot" Background="White">   

   10         <TextBlock x:Name="tb1" Text="{Binding Source={StaticResource src}}"/>

   11         <TextBlock x:Name="tb2" Text="{Binding Length, Source={StaticResource src}}"/>

   12     </StackPanel>

   13 </UserControl>

Ici, le TextBlock tb1 a sa propriété Text bindée à l'objet src qui se trouve dans les ressources. N'ayant pas spécifié de chemin dans la binding, c'est l'objet lui même qui est lié.
Le TextBlock tb2 est lié à la propriété Length de la source.

  • Exemple 2:

    1 <UserControl x:Class="Ucaya.SilverlightTest.Page"

    2    xmlns="http://schemas.microsoft.com/client/2007"

    3    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    4    xmlns:sys="clr-namespace:System;assembly=mscorlib"

    5    Width="400" Height="300">

    6     <UserControl.Resources>

    7         <sys:String x:Name="src">Binding source</sys:String>

    8     </UserControl.Resources>

    9     <Grid x:Name="LayoutRoot" Background="White">

   10         <ListBox x:Name="lb" ItemsSource="{Binding Source={StaticResource src}}">

   11             <ListBox.ItemTemplate>

   12                 <DataTemplate>

   13                     <TextBlock x:Name="tb" Text="{Binding }"/>

   14                 </DataTemplate>

   15             </ListBox.ItemTemplate>

   16         </ListBox>       

   17     </Grid>

   18 </UserControl>

La ListBox est bindée de la même manière que dans l'exemple 1. La string étant énumérable, la ListBox instancie un ItemTemplate par valeur de l'énumération.
Le TextBlock à sa propriété Text bindée au contexte de binding en cours fourni par la ListBox. Comme dans l'exemple 1, n'ayant pas fourni de chemin de binding, c'est directement la source du binding qui est liée.

Modes de binding

La synchronisation des valeurs peut se faire de différente manière.

OneTime

La donnée est recopiée de la source vers le contrôle une seule fois lorsque le binding est créé.

OneWay

La donnée est mise à jour dans le sens source vers contrôle à chaque fois que la valeur de la source change. Pour que le binding soit notifié du changement, l'objet source du binding doit implémenter l'interface INotifyPropertyChanged pour les propriétés et INotifyCollectionChanged pour les collections.

TwoWay

La donnée est mise à jour dans le sens source vers contrôle à chaque fois que la valeur de la source change (sous réserve de l'implémentation de INotifyPropertyChanged ou INotifyCollectionChanged) et dans le sens contrôle vers source quand la valeur du contrôle change.

Conversion des données

Il arrive que les données sources ne puissent être converties directement entre les propriétés d'un contrôle et les valeurs de la source. C'est là qu'interviennent les classes de conversion. Elles permettent par exemple de convertir un string en Uri, un string en ImageSource ou encore de formatter un double en string avec 2 nombres après la virgule. Ces convertisseurs sont des classes qui implémentent l'interface IValueConverter.

  • Exemple

Implémentation d'un convertisseur effectuant un string.Format. Affiche une valeur en pourcentage.

Xaml:

 

<UserControl x:Class="Ucaya.SilverlightTest.Page"

   xmlns="http://schemas.microsoft.com/client/2007"

   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

   xmlns:sys="clr-namespace:System;assembly=mscorlib"

   xmlns:sle="clr-namespace:SLExtensions.Data;assembly=SLExtensions"

   Width="400" Height="300">

    <UserControl.Resources>

        <sys:Double x:Key="src">0.333333</sys:Double>

        <sle:StringFormatConverter x:Key="formater"/>

        <sys:String x:Key="formatString">{0:p}</sys:String>

    </UserControl.Resources>

    <StackPanel x:Name="LayoutRoot" Background="White">   

        <TextBlock x:Name="tb1"

                  Text="{Binding Converter={StaticResource formater}, ConverterParameter={StaticResource formatString}, Source={StaticResource src}}"/>

    </StackPanel>

</UserControl>

Convertisseur:

// <copyright file="StringFormatConverter.cs" company="SLExtensions.Controls">

// Distributed under Microsoft Public License (Ms-PL)

// </copyright>

 

namespace SLExtensions.Data

{

    using System;

    using System.Windows;

    using System.Windows.Controls;

    using System.Windows.Documents;

    using System.Windows.Ink;

    using System.Windows.Input;

    using System.Windows.Media;

    using System.Windows.Media.Animation;

    using System.Windows.Shapes;

    using System.Windows.Data;

 

    /// <summary>

    /// Convert data to string objects as it passes through the binding engine.

    /// </summary>

    public class StringFormatConverter : IValueConverter

    {

        /// <summary>

        /// Default string format syntax

        /// </summary>

        private const string DefaultStringFormat = "{0}";

 

        #region IValueConverter Members

 

        /// <summary>

        /// Convert source data to string before passing it to the target for display in the UI.

        /// </summary>

        /// <param name="value">The source data being passed to the target.</param>

        /// <param name="targetType">The <see cref="T:System.Type"/> of data expected by the target dependency property.</param>

        /// <param name="parameter">An optional parameter to be used in the converter logic.</param>

        /// <param name="culture">The culture of the conversion.</param>

        /// <returns>

        /// The value to be passed to the target dependency property.

        /// </returns>

        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

        {

            if (targetType != typeof(string))

            {

                throw new ArgumentException(Resource.StringFormatConverterExceptionInvalidTargetType);

            }

 

            if (value == null)

            {

                return string.Empty;

            }

 

            string format = (parameter as string) ?? DefaultStringFormat;

            return string.Format(format, value);

        }

 

        /// <summary>

        /// This convertion is not supported

        /// </summary>

        /// <param name="value">The target data being passed to the source.</param>

        /// <param name="targetType">The <see cref="T:System.Type"/> of data expected by the source object.</param>

        /// <param name="parameter">An optional parameter to be used in the converter logic.</param>

        /// <param name="culture">The culture of the conversion.</param>

        /// <returns>

        /// The value to be passed to the source object.

        /// </returns>

        object IValueConverter.ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

        {

            throw new NotSupportedException();

        }

 

        #endregion

    }

}

#    Comments [0] |