Le Kernel peut être considéré comme le chef d’orchestre des plugins. Lorsqu’il est seul, rien ne se passe, mais il est pourtant indispensable au fonctionnement du CVK car il effectue différents rôles majeurs :

• Il possède et propose le contexte (état) courant du CVK, c’est-à-dire les claviers disponibles, avec chacune de leurs touches, les commandes associées, ….
• Il découvre dynamiquement les plugins installés sur la machine
• Il gère les dépendances entres ces plugins
• Il gère la persistance de chaque plugin

1) Le contexte

Le contexte est l’état du CVK à un instant donné. C’est la représentation des claviers et tous les éléments qui les composent. Voici les éléments qui composent le contexte :

• Keyboards : Liste des claviers disponibles
• Modes : Liste des modes disponibles pour un clavier (Maj, Alt, Ctrl …)
• Zones : Liste des zones qui composent le clavier. Ce sont des zones fonctionnelles qui servent à regrouper des touches (Zone du pavé numérique, zone de flèches …)
• Keys : Liste des touches contenues dans la zone. Elles contiennent des ActualKeys
• ActualKeys : Liste des actions pour une touche dans un mode donné. Chaque touche ayant un comportement différent selon le mode, ce sont les ActualKeys qui possèdent le label et l’action à effectuer.
• Layouts : Ils représentent la disposition des touches. Pour un même clavier, il est possible d’avoir plusieurs dispositions. Par exemple, Il est possible de changer la position de certaines touches pour obtenir des claviers AZERTY et QWERTY
• LayoutZones : Groupement de KeyLayouts correspondant aux Zones du clavier
• KeyLayouts : Contient les informations relatives au positionnement de chaque touche.
• CurrentMode : Mode actuellement utilisé
• CurrentLayout : Layout actuellement utilisé
• CurrentKeyboard : Clavier actuellement utilisé

Le contexte est sauvé dans un fichier XML, il est donc possible de publier ce fichier afin de le partager avec d’autres utilisateurs. Ainsi un ergothérapeute ayant configuré un contexte spécifique à un handicape peut diffuser ce contexte aux personnes concernées.

2) Découverte des plugins

Les plugins CVK sont en réalité des assembly (Fichier .dll). Pour les installer, il suffit d’ajouter des fichiers dans le dossier « Plugins » du répertoire d’installation. C’est donc le rôle du Kernel de parcourir ces fichiers, de les identifier comme plugins puis de les charger dans l’application.

3) Gestion des dépendances

Chaque plugin à la possibilité d’utiliser d’autres plugins. CVK gère différents niveaux de dépendances entre ces plugins :

• Optional : Le plugin utilisé peut ne pas être présent
• OptionalTryStart : Le plugin utilisé peut ne pas être présent. Dans le cas où il est présent et arrêté, le Kernel essaiera de le démarrer.
• MustExist : Le plugin utilisé doit être présent même arrêté
• MustExistTryStart : Le plugin utilisé doit être présent . Dans le cas où il est présent et arrêté, le Kernel essaiera de le démarrer.
• MustExistAndRun : Le plugin utilisé doit être présent et démarré.

En fonction des dépendances, le Kernel démarre ou non chacun des plugins. Par exemple si un Plugin-A déclare avoir besoin d’un Plugin-B en MustExistAndRun et que ce Plugin-B n’est pas présent, le Plugin-A sera désactivé. Cela implique que si un autre plugin à besoin du Plugin-A il sera désactivé à son tour et ainsi de suite.

4) Gestion de la persistance

Afin de centraliser l’ensemble des données à persister, le Kernel propose à chaque plugin un dictionnaire permettant de stocker des données ce qui facilite le travail des développeurs de plugins.

Par exemple un plugin peut stocker un paramètre comme ceci :
dictionnaire[‘monParametre’] = true ;

Il peut ensuite l’utiliser comme cela :
if( (bool)dictionnaire[‘monParametre’])

De manière automatique, le paramètre « monParametre » sera persisté et rechargé par le Kernel sans aucune action du plugin.

En réalité il est possible de sauver des données sur différent éléments :

• Configuration «User», si la machine possède plusieurs comptes utilisateurs. Les plugins peuvent sauver des paramètres spécifiques à chaque utilisateur.
• Configuration « Machine», les paramètres sont communs à tous les utilisateurs d’une même machine.
• Configuration «Context», les paramètres sont sauvés dans le fichier du contexte. Si ce fichier est diffusé et utilisé sur une autre machine, les paramètres seront rechargés.
• Il est ensuite possible d’affecter des paramètres sur chaque élément du contexte. Cela permet, par exemple, d’affecter une couleur de touche à tout le clavier et d’affecter une autre couleur à une touche en particulier. Ainsi toutes les touches du clavier auront une couleur sauf celle qui a reçu le paramètre spécifique.

Episode 3 : La gestion des plugins.
Episode 4 : Les editeurs.
Episode 5 : La configuration des plugins.

Aujourd’hui, nous allons vous lister quelques raisons vous expliquant pourquoi le CVK est un outil qui va vous être utile.

Il s’agit du plugin de défilement automatique, qui permet à un utilisateur d’utiliser le CVK sans avoir de dispositif de pointage (juste un “contacteur”).

Lorsque se lance le plugin de défilement automatique, des zones de touches défilent en surbrillance. Après un premier clic, les touches se situant dans la zone en surbrillance se mettent à défiler à leur tour. Au second clic, un clic s’effectue sur la touche qui était en surbrillance et les zones se remettent à défiler.

Je vais maintenant vous présenter les options de ce plugin.

Vitesse de Défilement : Il s’agit de la vitesse de défilement (en millisecondes) des zones et des touches qui sont séléctionnées (en surbrillance). Lors de l’enregistrement de la vidéo, cette option était réglée sur 750ms, comme indiqué sur l’image au dessus.

Nombre de passage dans une zone : Permet de choisir le nombre de fois que défilent les touches dans une zone avant de sortir de celle-ci.

Durée sur la première touche : Permet de choisir la durée (en millisecondes) durant laquelle la première touche de chaque zone reste en surbrillance.

Durée d’un clic long : Permet de définir après combien de secondes un clic est considéré comme un clic long. Le clic long permet d’annuler l’action en cours. Si par exemple, vous vous trompez de zone et vous ne voulez pas attendre la fin de la ligne pour recommencer le défilement, c’est alors que vous effectuez un clic long.

Déclenchement du clic : Permet de définir si un clic s’exécute au moment de l’appuie sur le bouton ou au moment du relâchement du bouton.

Touche clavier qui simule un clic : Permet de choisir la touche du clavier qui simulera un simple clic gauche de la souris. Ainsi, vous pouvez choisir n’importe quel “capteur” pour déclancher un clic. Celà signifie qu’au lieu de cliquer sur la souris, vous pouvez aussi bien appuyer sur n’importe quel touche du clavier.

La sortie de la version 2 approchant, les articles de présentation des plugins seront de plus en plus fréquents. Restez connectés.

L’équipe CVK.

Ce semestre, l’équipe technique aura pour mission de produire une version stable du logiciel répondant aux demandes de tous nos partenaires (travail déjà bien entamé le semestre précédent). Ces développements concerneront des options destinées aux handicapés avec notamment des fonctionnalités permettant de saisir du texte simplement en cliquant ou en bougeant le curseur, ou encore un moteur de prédiction nouvelle génération proposant une liste de mots en fonction des caractères et des mots précédemment tapés. Nous vous proposerons également des options d’édition permettant la personnalisation des claviers de façon très avancée aussi bien visuellement que fonctionnellement. Bien entendu, nous vous présenterons ces fonctionnalités (et bien d’autres) plus en détails dans de prochains billets.

Concernant la communication, l’objectif est de préparer une sortie prochaine du CVK. Un nouveau site internet doit faire son apparition courant décembre et ce sera l’occasion pour nous de diffuser une première version de test du CVK. Nous allons également choisir la licence logiciel la mieux adaptée au CVK et à son architecture par plugin. Enfin, un évènement qui marquera la sortie officielle du CVK version 2 devrait avoir lieu courant 2009.

En attendant, voici une skin destiné aux enfants. La personnalisation du clavier n’a plus de limite!

Restez connectés !

L’equipe CVK

Quelle évolution du CVK depuis l’époque du premier prototype. Autant en termes de graphisme que de souplesse de l’architecture.

Voici les premières images de la beta qui sera bientot disponible.

Parmis les actions en cours nous comptons relooker le site web du CVK: CVK.fr afin de le rendre plus dynamique, plus complet et plus pratique d’utilisation.

Dans ce but nous avons étudié quelques points:

• Quels outils seront les plus utiles pour la communication entre les membres de la communauté?
• Quelle est l’architecture la plus pratique pour le site du CVK?
• Quelles formes auront nos pages web?

Pour répondre à ces différentes interrogations, le meilleur moyen reste de visiter les différentes communautés open source existantes.

Le musée de l’informatique a ouvert ses portes le 4 avril 2008 pour une exposition permanente au sommet de l’Arche et le 5 et 6 Juillet 2008, une exposition menée par des élèves de l’école In’Tech INFO retraçant l’histoire de l’informatique ouvre ses portes (lien : InformArchive ). Le CVK y tiendra une place de choix dans la partie réservée à l’accessibilité.

Au menu, démonstration du produit avec la possibilité de le tester vous-même, distribution de flyers et CD-ROM CVK, et une fresque retraçant l’histoire du CVK.

Tout le monde est donc le bienvenu à cette exposition, et ce sera l’occasion de faire parler du CVK !

PS : le musée est gratuit, mais l’accès au toit de l’Arche de la Défense est payant :

• Adultes : 9€
• Etudiants et enfants de moins de 17 ans : 7,50€
• Enfants de moins de 6 ans : Gratuit
• Handicapés : Gratuit
• Pass Famille :
  • 2 adultes + 1 enfant : 22 €
  • 2 adultes + 2 enfants : 25 €
  • 2 adultes + 3 enfants : 29 €

La principale différence est que le clavier physique est détaché de l’écran tandis qu’un clavier virtuel est quant à lui, prisonnier de cette jungle de pixels.

L’enjeu est donc de réduire ce désavantage au minimum.
Et la première difficulté que nous avons rencontré fut de rendre le CVK totalement “transparent” aux yeux du système d’exploitation. Concrètement, lorsque l’on clique sur une fenetre, celle-ci reprends le focus, devenant active. Cependant, pour un clavier virtuel, le but étant de saisir des informations dans une autre fenetre, ce mécanisme rendrait la chose impossible.

Il existe un moyen de résoudre ce problème : controler soi-meme les évenements de la souris lorsqu’ils sont sur le clavier, et les traiter nous meme, comme si le système ne savait pas que l’on avait cliqué.

Or ceci à ses limites : lorsqu’une fenetre ou un autre composant du système se trouve au dessus du clavier, (typiquement un menu, comme menu démarrer pour windows, ou des menus de barres des taches) le clic est lui aussi ignoré…

Solution !

Rendre le CVK non activable : pour ceci : on surcharge notre méthode CreateParams de la classe Windows.Form

///Message système qui définit, à la création, si la form devient active sur un click

private const int WS_EX_NOACTIVATE = 0×8000000;

///Message système qui définit, à la création, si la form peut avoir une barre de titre

private const int WS_CAPTION = 0xc00000;

/// <summary>
/// Override virtual method to have a form with Resizable borders but no
/// TitleBar and to made the form inactive when clicks are performed over its
/// </summary>
protected override CreateParams CreateParams
{
get
{
CreateParams cp = base.CreateParams;
long Style = cp.Style;
cp.Style ^= WS_CAPTION;
cp.ExStyle |= WS_EX_NOACTIVATE;
return cp;
}
}
Les paramètres de créations sont, soit soustraits ( ^= ) soit ajoutés ( |= ) sur les styles étendus ( ExStyle ) ou de bases ( Style ).

Il faut aussi penser à redéfinir la méthode WndProc de la classe Form et capter le message WM_MOVING.

En effet, lors d’un déplacement ou d’un redimensionnement, si la fenêtre n’est pas activable (comme démontré ci-dessus), nous ne verrons pas en temps réel son déplacement, mais uniquement lors du relâché du bouton.

private const int WM_MOVING = 534;

/// <summary>
/// Helper structure used to retrieve and follow the location of the form on a moving or resizing operation
/// </summary>
private struct RECT
{
public int Left;
public int Top;
public int Right;
public int Bottom;
}

/// <summary>
/// Windows.Form Methode witch processes Windows messages.
/// </summary>
protected override void WndProc( ref Message m )
{

// Listen for operating system messages.
switch (m.Msg)
{

case WM_MOVING:
RECT r;
r = (RECT)Marshal.PtrToStructure(m.LParam, typeof(RECT));
this.Location = new Point(r.Left, r.Top);
break;
}
base.WndProc(ref m);

}

Il en va de même pour le redimensionnement de la Form : capter le message WM_SIZING, afin d’avoir un redimensionnement en temps réel.

Toujours dans notre méthode WndProc :

private const int WM_SIZING = 0×0214;

//Resizing the form thanks to the border althought it is inactivated. Shows live the resizing.
case WM_SIZING:
r = ( RECT ) Marshal.PtrToStructure( m.LParam, typeof( RECT ) );

this.Size = new Size( r.Right - r.Left, r.Bottom - r.Top );

//If the left or top anchors or the top right are selected
if (
m.WParam == ( IntPtr ) WMSZ_LEFT ||
m.WParam == ( IntPtr ) WMSZ_TOP ||
m.WParam == ( IntPtr ) WMSZ_TOPLEFT ||
m.WParam == ( IntPtr ) WMSZ_BOTTOMLEFT ||
m.WParam == ( IntPtr ) WMSZ_TOPRIGHT)
{ //We also change the top left location of the form
this.Location = new Point( r.Left, r.Top );
}
Marshal.StructureToPtr( r, m.LParam, true );
break;

Voici le premier article d’une petite série qui consiste à vous présenter le fonctionnement sous-jacent du CVK (et pourquoi il est promis à un grand avenir).

Au premier coup d’œil à part plusieurs graphismes attrayants les concurrents du CVK n’ont rien à lui envier, mais regardant de plus près… le terme « Custom » prend tout son sens.

En creusant un peu, on observe plusieurs grandes parties dans notre architecture :

• Un noyau (que nous appelleront Kernel) qui contient l’intelligence utile pour générer le comportement des claviers en termes de logique.
• Un système de gestion de plugins (extensions) permettant de faire évoluer le clavier très simplement sans remettre en cause ce qui à déjà été fait.

Cela constitue la base « solide » du CVK.., seule elle ne sert à rien puisque se sont les plugins qui vont l’exploiter et la faire vivre. Nous reviendrons plus en détails sur ces deux composantes de l’application dans les prochains épisodes.

Ensuite on trouve deux parties beaucoup plus souples de l’architecture :

• Un hôte, qui se charge de créer un espace de vie pour le CVK, et qui « démarre » la machine. C’est lui qui va s’occuper d’initialiser le Kernel et de gérer la configuration.
• Et enfin, l’ensemble des plugins qui vont donner vie à notre clavier et ajouter toutes les fonctionnalités utiles.

Les premières présentations sont faites, voici une vision simple du système mis en œuvre :

Ce qu’il faut bien comprendre c’est que le Kernel n’est que la représentation logique d’un clavier : c’est-à-dire des ensembles de touches organisées réalisant des actions. Il charge les claviers à partir d’un fichier XML et met ensuite cette structure à disponibilité des plugins. Ce sont eux qui vont s’occuper de l’affichage et de l’interaction avec l’utilisateur. Ainsi il devient très simple d’injecter de nouvelles fonctionnalités et/ou de créer des environnements différents selon le contexte d’utilisation.

C’est grâce à cette architecture modulaire très souple qu’il est possible de répondre à presque tous les besoins imaginables liés à un clavier virtuel.

Episode 2 : Zoom sur le Kernel.

Episode 3 : La gestion des plugins.

Episode 4 : Les editeurs.

Episode 5 : La configuration des plugins.

A bientôt !

Exemple concrêt : l’image qui représente la Touche est la même pour les 105 touches du clavier. Le plugin de défilement automatique (qui est un autre Thread) change cette image pour la faire apparaitre comme illuminée, et ce, pour une sélection de N Touches. Lors de cette opération, il est très probable qu’une exception de type : InvalidOperatioException soit jetée. Ceci est du au fait que le Thread qui essaye d’accéder à l’image n’est pas le même que le thread qui a créé le contrôle.

Voici la méthode utilisée pour régler ce problème :

///Sets the Image by a thread-safe manner.
private void SetImageOut()
{
if ( InvokeRequired ) //Vérifie si l’appelant est un thread différent de celui qui a créé le contrôle

//Dans ce cas, on ré-appelle notre méthode SetImageOut () par le Thread à qui notre contrôle appartient
this.Invoke(new MethodInvoker(delegate() { SetImageOut(); }));

else {
//Si tout est bon, on peut appliquer notre Image au contrôle
if (this.Image == null)
this.Image = _keyNormalImage;

}