Conférence sur les nouvelles interfaces tactiles

Aucun commentaire

    Bonjour à tous,
    Microsoft et certains de ces partenaires organisent un nouvel après-midi du développement au menu : Design et nouvelles interfaces naturelles. C'est après les fêtes et c'est gratuit, si vous vous posez des questions ou êtes curieux à propos du développement d'interfaces tactiles, vous trouverez pas mal de réponse durant ces conférences.

    9 Janvier 2012 – 14h00 – 18h00 - Campus Microsoft Issy Les Moulineaux - A partir de 18h00 : Bière Pizza Party !
    Au programme de ce nouvel Après-midi du dev :

    · Les nouvelles interactions digitales et naturelles
    o Dick Lantim - Sensorit
    · Gérer et développer une application tactile
    o Nicolas Calvi et Johanna Rowe - Winvise
    · Application Blend : Le pipeline de création et de réalisation. Revue de la conception et de la mise en production d'une application WPF depuis son maquettage (Sketchflow) jusqu'à sa réalisation (Blend)
    o Michel Rousseau - Bewise
    · Réaliser des présentations efficaces en utilisant la norme METRO
    o David Catuhe - Microsoft

    Pour vous inscrire c'est ici

    Bookmark and Share

    Surface 2 final sdk release

    Aucun commentaire

      Voici une première bonne nouvelle pour tous les concepteurs d'applications Surface, vous pouvez désormais télécharger le SDK Surface 2 en version finale.

      L'autre bonne nouvelle : ce SDK remplace le précédent Windows Touch beta SDK, il n'est donc plus nécessaire d'installer deux plateformes différentes. Que vous soyez dans l’environnement Windows 7 ou Surface, la conception d'applications tactiles devient moins chronophage. Par exemple, bon nombres de contrôles sont fournis par défaut et il ne sera plus nécessaire de tous les re-développer. Du coup, un certain nombre d'ajustements a été réalisé pour supporter les différents types de hardware. Pour ma part, le premier test que je vais faire consiste à tester les performances sur les tablettes tactiles Windows 7. Le sdk beta était assez lourd et peu performant sur les tablettes tactiles, cela a-t-il évolué ?

      Voici, dans les grandes lignes, les améliorations apportées :

      • Possibilité de définir les spécificités du matériel hardware :
        • Modification de la résolution
        • Définition du nombre de points de contact simultanés
        • Activation de la détection d'objets tag
        • Activation de la détection de blob
        • Activation de la récupération de la bounding box de contact
        • Activation de la récupération de l'orientation
        • Définition de la surface de contact allouée.
      • Les contrôles Surface bénéficie via l'héritage des contrôles WPF standard, des événements souris, stylus ou tactiles. Cela est très pratique lorsque l'on développe en environnement desktop Window 7.
      • Simplification de l'arbre visuel et logique des contrôles pour faciliter le personnalisation.
      • Les événements de type gesture, comme Tap, ne sont plus implémentés directement dans la classe SurfaceControl mais sont dorénavant attachés. Le concept d'évènement attaché existe depuis .Net 3 mais c'est une utilisation vraiment pertinente que nous propose Microsoft.
      • La classe UserControl est enrichie par défaut avec les nouveaux événements et gestionnaires de capture tactiles, la classe SurfaceUserControl est donc supprimée.
      • Le simulateur Surface a été énormément enrichi avec notament le support de l'orientation.

      Il y aurait encore beaucoup à dire, le mieux est de tester directement en développant des applications...

      Bookmark and Share

      Home Connection – Conférence Designer Interactif

      Aucun commentaire

        La conférence Smart World aura lieu le 28 juin à paris. Elle est organisée par CCM en partenariat avec l'association professionelle "Les Designers Interactifs".

        L'objectif en deux mots : expliquer, comprendre et anticiper la révolution des usages dans l'environnement domestique. Les nouveaux objets intelligents du quotidien et les nouvelles interfaces eXtremes (XUI) seront donc à l'honneur.

        Accédez au site dédié pour plus de précision.

        Bookmark and Share

        SketchFlow for Windows Phone 7

        Aucun commentaire


          C'est la bonne nouvelle de la journée, un nouveau projet sur CodePlex permet de prototyper des application Windows Phone 7 via SketchFlow. Il vous faudra toutefois acquérir la licence Expression Studio Ultimate ou Visual Studio 2010 ultimate. Cela peut paraître assez gadget mais bien au contraire gérer une navigation à la fois simple, efficace et directe peut se révéler un vrai défi sur mobile. L'ensemble des composants sont fournis, des behaviors vous permettent comme au sein de projets SketchFlow standards, de prototyper la navigation ou encore les fonctionnalités WP7 telles que ainsi que les notifications toast. Les boutons HardWare Back et Search, ainsi que l'écran de démarrage WP7, sont également fournis, cela vous permettra de simuler les comportements d'une vrai application. Mais alors, la question qui revient, à quoi sert-il de passer par un prototype ? la réponse est encore la même, la facilité d'utilisation de SketchFlow et la rapidité de construction des interfaces et de la navigation vous permettront de tester de nombreux scénarii utilisateur avant d'entrer dans une phase de production pure et dure. On gagnera forcément du temps...

          Bookmark and Share

          ForceColumnBoundary AttachedProperty

          Aucun commentaire


            J'ai récemment eu besoin d'un Datagrid avec lignes dépliables, c'est une demande classique de nos clients et des éditeurs comme Telerik propose cette fonctionnalité en standard. Toutefois les clients ne souhaite pas toujours dépenser 1000$ de licence. Du coup, je suis parti d'une ListBox que j'ai configuré pour qu'elle prenne la forme d'un Datagrid, déplier une ligne se révèle assez simple dans ce cas. Pourtant je suis tombé sur un bug du Panel Grid auquel je ne m'attendais pas vraiment. Chaque colonne de ma grille au sein de mon ItemTemplate possède une valeur relative, chacune d'entre elles possède un FrameworkElement dans le cas présent un TextBlock.

            Toutefois lorsque le contenu d'un TextBlock (par exemple) au sein d'une colonne est trop important, cela décale chaque colonne, du coup on perd l'effet Datagrid. Ce comportement du Layout est illogique si l'on considère qu'en mode Stretch horizontal, chaque TextBlock ne devrait pas dépasser la largeur de la colonne dans laquelle il se trouve. Le résultat est affiché ci-dessous.

            Pour remédier à cela, j'ai codé une propriété attachée qui force chaque élément au sein d'une colonne à respecter les limites de cette dernière. Le code est relativement simple :

            class FrameworkElementExtension
            {
             
                private static Dictionary<frameworkelement , GridLength> FrameworkElementToGridLength = new Dictionary</frameworkelement><frameworkelement , GridLength>();
             
                public static bool GetForceColumnBoundary(DependencyObject obj)
                {
                    return (bool)obj.GetValue(ForceColumnBoundaryProperty);
                }
             
                public static void SetForceColumnBoundary(DependencyObject obj, bool value)
                {
             
                        obj.SetValue(ForceColumnBoundaryProperty, value);
                }
             
                // Using a DependencyProperty as the backing store for EnsureColumnBoundary.  This enables animation, styling, binding, etc...
                public static readonly DependencyProperty ForceColumnBoundaryProperty =
                    DependencyProperty.RegisterAttached("ForceColumnBoundary", typeof(bool), typeof(FrameworkElement), new PropertyMetadata(new PropertyChangedCallback(OnEnsureColumnBoundary)));
             
                private static void OnEnsureColumnBoundary(DependencyObject d, DependencyPropertyChangedEventArgs e)
                {
             
                    bool b = System.Convert.ToBoolean(e.NewValue);
             
                    FrameworkElement fe = d as FrameworkElement;
             
                    if (fe == null)
                    {
                        return;
                    }
             
                    Grid g = fe.Parent as Grid;
             
                    ColumnDefinition cd = g.ColumnDefinitions[Grid.GetColumn(fe)];
             
                    if (g == null || cd == null || DesignerProperties.GetIsInDesignMode(fe))
                    {
                        return;
                    }
             
                    if (b)
                    {
                        if (!FrameworkElementToGridLength.ContainsKey(fe))
                        {
                            FrameworkElementToGridLength.Add(fe, cd.Width);
             
                            g.SizeChanged -= new SizeChangedEventHandler(g_SizeChanged);
                            g.SizeChanged += new SizeChangedEventHandler(g_SizeChanged);
                        }
                    }
                    else
                    {
                        FrameworkElementToGridLength.Remove(fe);
             
                        g.SizeChanged -= new SizeChangedEventHandler(g_SizeChanged);
                    }
                }
             
                static void g_SizeChanged(object sender, SizeChangedEventArgs e)
                {
                    Grid g = sender as Grid;
             
                    foreach (FrameworkElement fe in g.Children)
                    {
                        bool b = GetForceColumnBoundary(fe);
             
                        if (b)
                        {
                            GridLength gl = FrameworkElementToGridLength[fe];
             
                            ColumnDefinition cd = g.ColumnDefinitions[Grid.GetColumn(fe)];
             
                            cd.Width = gl;
             
                            fe.Width = gl.Value*g.ActualWidth;
                        }
                    }
                }
            }
            </frameworkelement>

            Le résultat est immédiat et fonctionne qu'elle soit le type de colonne dans votre DataGrid.

            Il suffit d'appliquer la propriété attachée à l'objet que vous souhaitez contraindre dans votre grille de cette manière :

            Text="{Binding Client}" TextWrapping="Wrap" Grid.Column="1"  
            		local:FrameworkElementExtension.ForceColumnBoundary="True"
            Bookmark and Share

            Team Blog Post preparing MIX

            3 commentaires

              L'avenir est en marche, ce post est important si vous suivez l'actualité Silverlight. Concrètement ce n'est pas un effet Bob Muglia que l'on a mais plutôt une réflexion arrivée à maturation qui nous est délivrée par Scott Guthrie et ses collègues. Ils débattent de la place actuelle et future des plugins comme Flash et Silverlight dans un monde HTML5. Silverlight a de beaux jours devant lui, si certains développeurs rêvaient du "tout Silverlight", ils seront déçus. Le HTML5 arrive et prendra une part significative des futurs développements webs. Toutefois, tous les scénarii avancés resteront dans le giron Silverlight. Le livecycle est plus court, plus réactif et les fonctionnalités sont beaucoup plus riches que celles proposées par le HTML5. En attendant, la future problématique concerne le tooling. Microsoft ne peut simplement pas ignorer la nouvelle version du langage HTML et proposera sans doute des outils pour répondre au besoin d'outil de conception dédié au web pur et dur... c'est ce que l'article évoque en partie, bonne lecture...

              Bookmark and Share

              Grid extension [Extension]

              Aucun commentaire

                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.

                Install Microsoft Silverlight

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

                Bookmark and Share

                ClipToBound Behavior [Extension]

                Aucun commentaire

                  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;
                   
                          }
                      }
                  Bookmark and Share

                  RangedSlider [Custom Control]

                  Aucun commentaire


                    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.

                    Get Microsoft Silverlight

                    Voici une exemple.

                    Install Microsoft Silverlight


                    Vous pouvez télécharger le projet ici.

                    Bookmark and Share

                    Yet Another FlipControl [Custom Control]

                    2 commentaires


                      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.

                      Install Microsoft Silverlight

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

                      Bookmark and Share

                      Next Page »