Techdays 2011 : Session Surface

by Nicolas Calvi 14. janvier 2011 18:15

Un petit mot pour vous signaler que j'animerais une session aux Techdays 2011 à Paris.

INTERFACES NATURELLES : RETOUR D'EXPÉRIENCE DÉVELOPPEUR/DESIGNER POUR DES
APPLICATIONS TACTILES ESTHÉTIQUES, FONCTIONNELLES ET UTILES

Au cours de cette session, à l'aube de la sortie de la table Surface V2, un développeur et un designer vous feront un retour d'expérience sur un projet réalisé sur la table tactile Microsoft Surface. La réalisation d'un projet sur des interfaces naturelles amène à changer nos méthodologies de travail pour intégrer peu à peu des métiers et des compétences indispensables à la réalisation d'applications esthétiques, fonctionnelles et utiles. Ils mettront en avant les interactions entre ces deux mondes et montreront comment s'organise le processus projet lorsqu'on intègre d'autres métiers.

Elle se réroulera le mardi 8 février 2011 de 16h00 à 17h00. 

Microsoft Surface V2 : Des infos !!!

by Nicolas Calvi 6. janvier 2011 15:59

C'est au CES que les premières informations tombent pour Microsoft Surface V2.

Du haut de ses 12 cm de hauteur, la nouvelle table embarquera un combo AMD pour le processeur et la carte graphique. Cette nouvelle version sera moins chère nous dit-on et aura un écran plus grand, mais ce qui est intéressant c’est qu’elle est prévu pour fonctionner à la vertical, comme à l’horizontal.

On apprend aussi que la détection des contacts sera une détection « Infrarouge  par pixel » qui permet à chaque pixel de la table d’être un capteur infrarouge, on comprend tout de suite que les possibilités de reconnaissance sont extraordinaire comme le montre la vidéo du CES ou une feuille de papier avec marqué « I CAN SEE » est posé sur la surface, le retour de la détection est juste à l’image exacte de ce qui est posé.

Plus puissante, plus jolie et moins chère que sa soeur, ce sera je pense un produit phare d’ici 2 ans.

Vous pouvez consulter la vidéo du CES pour plus d’information.

Meilleurs voeux 2011

by Nicolas Calvi 6. janvier 2011 12:53

Tout d’abord je vous souhaite mesmeilleurs vœux pour l’année 2011, année qui commence en fanfare pour moi.

En effet,  je viens d'être nominé MVP Surface, c'est uneréelle surprise et je voudrais remercier Microsoft pour leur confiance. L’année2011 sera d’ailleurs riche en actualité Microsoft Surface avec la sortie de la MicrosoftSurface V2, je serais bien sûr là pour vous faire découvrir tout ça !

MVP

Dependency Property : Trucs et astuces

by Nicolas Calvi 19. octobre 2010 12:06
Lors des développements en WPF on a souvent besoin d'écrire des propriétés de dépendances pour nos objets. En dehors de la déclaration simple de notre propriété, il y a quelques éléments qui méritent d'être connue. Dans l'exemple qui va suivre, je vais écrire une propriété de dépendance appelée "MaProp", qui sera un Int32 et qui ne peut prendre des valeurs que de 1 à 100.
  
1 - Déclaration de la propriété
 
Il faut bien évidement déclarer sa propriété, dans Visual Studio il y un a snipet pour ça : propdp.
 
public static readonly DependencyProperty MaPropProperty = DependencyProperty.Register("MaProp", typeof(int), typeof(MaClasse), new UIPropertyMetadata(1));
 
Dans les conventions de nommage, on ajoute toujours "Property" sur l'a déclaration statique, ensuite pour initialiser celle-ci, on peut donner une valeur par défaut dans le dernier paramètre, ici 1.
 
2 - Déclaration de l'accesseur
 
Il faut maintenant créer l'accesseur pour cette propriété, ici rien de bien difficile, on doit simplement utiliser le GetValue(DependencyProperty) et le SetValue(DependencyProperty, object). Ces deux fonctions ne font que récupérer ou inscrire des informations dans le dictionnaire de ressource de l'objet, c'est dans celui-ci que les valeurs des propriétés de dépendance sont stockées.
public int MaProp
{
  get
  {
    return ((int)this.GetValue(MaClasse.MaProp));
  }
  set
  {
    this.SetValue(MaProp.MaProp, value);
  }
}
Il est très fortement recommander de ne mettre aucun autre code que celui-ci sur sa propriété. Pour exécuter du code à son changement ou contrôler la valeur, ce sont les deux points suivants.
  
3 - Faire un traitement après modification
 
Pour exécuter du code après un changement de valeur, il est possible de rajouter un Callback dans le constructeur du paramètre UIPropertyMetadata() dans la déclaration statique de la propriété. Ce Callback est de type PropertyChangedCallback. Voici un exemple de déclaration pour cette méthode.
public class MaClasse 
{   
  // Déclaration de la propriété   
  public static readonly DependencyProperty MaPropProperty = DependencyProperty.Register("MaProp", typeof(int), typeof(MaClasse), new UIPropertyMetadata(1, new PropertyChangedCallback(MaClasse.OnMaPropChanged)));    

  // Déclaration de la fonction statique de Callback   
  private static void OnMaPropChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)   
  {    
    // Appel a la fonction interne de modification     
    ((MaClasse)sender).OnMaPropChanged(e.OldValue, e.NewValue);  
  }    
  
  // Déclaration de la fonction interne de modification  
  protected virtual void OnMaPropChanged(int old, int new)   
  {    
     // Votre code ici   
  } 
}
Il est recommandé de déclarer la fonction statique de Callback en privée et la fonction de modification interne en protégée virtuel, ceci permet si on hérite de votre classe, de pouvoir intercepter le changement de valeur de la propriété.
 
4 - Tester la valeur avant modification
Dans notre exemple, on veut pouvoir borner la valeur entre 1 et 100, le premier mécanisme est déjà de l'initialiser dans cet interval, mais il est possible aussi avant l'affectation, de tester la valeur, ceci se passe comme pour le point 3, une fonction de Callback nous permet de la tester, elle s'appelle CoerceValueCallback(). Elle fonctionne comme le PropertyChangedCallback, voici un exemple pour cette méthode
 
public class MaClasse 
{       
  // Déclaration de la propriété       
  public static readonly DependencyProperty MaPropProperty = DependencyProperty.Register("MaProp", typeof(int), typeof(MaClasse), new UIPropertyMetadata(1, new PropertyChangedCallback(MaClasse.OnMaPropChanged), new CoerceValueCallback(MaClasse.CoerceMaProp)));      

  // Déclaration de la fonction statique de Callback  
  private static void OnMaPropChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)  
  {    
    // Appel a la fonction interne de modification    
    ((MaClasse)sender).OnMaPropChanged(e.OldValue, e.NewValue);  
  }    

  // Déclaration de la fonction statique de coerce  
  private static object CoerceMaProp(DependencyObject d, object baseValue)  
  {    
    return(((MaClasse)sender).CoerceMaProp((int)baseValue));  
  }    

  // Déclaration de la fonction interne de modification  
  protected virtual void OnMaPropChanged(int old, int new)  
  {    
    // Votre code ici  
  }    

  // Déclaration de la fonction interne de coerce  
  protected virtual object CoerceMaProp(int value)  
  {    
    // On teste la valeur    
    if (value < 1)      
      return(1);    
    else if (value > 100)      
      return(100);          

    return(value);  
  } 
}
On peut ainsi tester la valeur dans le coerce et la remettre dans un interval souhaité avant son affectation, ce qui déclenchera ensuite le PropertyChangedCallback avec la bonne valeur.

Projet CodePlex : Surface 2D Engine

by Nicolas Calvi 18. octobre 2010 14:57

Je vous présente mon deuxième projet CodePlex, un moteur 2D pour XNA 3.1 et Microsoft Surface. Il contient un moteur pour facilement faire des projets XNA sous Microsoft Surface, beaucoup de choses ont été abstraite pour vous simplifier la tâche. Vous avez les sources, c'est libre de droit, j'attend vos retours avec impatience, enjoy :)

Ca se télécharge ici : http://blacksurface2dengine.codeplex.com/