Google Desktop
 Premiers pas - Gadgets de la barre latérale Google Desktop



Télécharger le kit de développement (SDK)
Forum des développeurs
Toute documentation supplémentaire est actuellement disponible en anglais uniquement

Envoyer des gadgets

Présentation du kit de développement (SDK)
Blog de Desktop

Sommaire


Introduction

L'API Google Gadgets de Google Desktop inclut des objets et des méthodes qui permettent de développer des gadgets (anciennement appelés plugins) pour la barre latérale codés en JavaScript ou VBScript, par exemple. Ce document décrit la procédure de développement des gadgets à l'aide de cette API et du Concepteur de gadgets Google Desktop. Le Concepteur est un environnement de développement intégré grâce auquel vous pouvez créer l'interface utilisateur de votre gadget en faisant glisser des composants que vous déposez à l'endroit souhaité. Il vous permet aussi de tester votre gadget en dehors de la barre latérale.

Ce document ne couvre pas les aspects sans rapport avec les gadgets ou ne faisant pas appel à un script de l'API Google Desktop, par exemple les API Index, Requête, Action ou Événement (Toute documentation supplémentaire est actuellement disponible en anglais uniquement). Pour obtenir des informations détaillées sur ces API, cliquez sur leur nom dans la phrase précédente.

Un gadget Google Desktop reposant sur un script se compose des éléments suivants :

  • un fichier XML gadget.gmanifest contenant des métadonnées sur le gadget ;
  • un fichier main.xml définissant la vue principale de votre gadget. Par vue, on entend l'interface utilisateur et les objets qui constituent l'intégralité d'un volet visible de votre gadget ;
  • au besoin, un fichier options.xml définissant la vue des options de votre gadget ;
  • tout fichier JavaScript ou VBScript contenant le code nécessaire pour assurer la mise en œuvre des fonctionnalités du gadget ;
  • tout fichier image nécessaire au fonctionnement du gadget, comme par exemple les fichiers pour les éléments de l'interface utilisateur (boutons, cases à cocher, etc.), les images qui s'affichent dans le gadget ou les icônes associées à votre gadget ;
  • au besoin, les différents dossiers et fichiers nécessaires aux interfaces localisées que vous avez définie pour votre gadget.

Une fois l'écriture de ces fichiers terminée dans le Concepteur, celui-ci les compresse en un seul fichier nommé gadget_name.gg, où .gg signifie Google Gadget. Si vous n'utilisez pas le Concepteur, vous devez compresser ensemble ces fichiers et renommer le fichier créé en l'affectant du suffixe .gg.

Pour distribuer votre gadget, il suffit de rendre disponible le fichier .gg via http://desktop.google.com/pluginsubmit?hl=fr ou par d'autres moyens.

Lorsqu'un utilisateur installe un gadget à partir d'un fichier .gg, l'application Google Desktop se charge de le décompresser, de l'installer et d'en assurer l'inscription, à l'aide des informations contenues dans le fichier gadget.gmanifest.

Les versions de Google Desktop antérieures à 4.0 ne savent pas comment gérer les fichiers .gg. L'utilisation de gadgets ayant un fichier .gg n'est pas possible si votre version de Google Desktop est antérieure à la version 4.0. Vous pouvez toutefois convertir les anciens plugins en gadgets Google Desktop 4.0 en créant les fichiers .xml et .gmanifest nécessaires et en procédant à quelques modifications mineures au niveau du code.

La procédure complète de développement et de distribution d'un gadget de la barre latérale faisant appel à un script, à l'aide du Concepteur de gadget Google Desktop, est la suivante :

  1. Lancez le Concepteur de gadgets Google Desktop à partir du fichier designer.exe disponible dans le kit de développement logiciel (SDK) de Google Desktop.
  2. Cliquez sur Fichier -> Nouveau projet.
  3. Double-cliquez sur l'option Paramètres du projet dans le volet Fichier pour afficher la boîte de dialogue Paramètres du projet. Renseignez les champs. Le Concepteur crée votre fichier gadget.gmanifest à partir de ces informations.
  4. Faites glisser et déposez les éléments d'interface qui composent l'interface utilisateur de votre gadget dans le volet Visualisation du Concepteur.
  5. Ajoutez au projet les fichiers image de l'interface utilisateur de votre choix, par exemple une image de bouton différente. Pour ce faire, utilisez un navigateur de fichiers externe, comme l'Explorateur Windows. Ajoutez les fichiers appropriés au dossier du projet ou remplacez le contenu des fichiers existants.
  6. Sélectionnez chaque élément de l'interface utilisateur, l'un après l'autre, et définissez leurs événements et leurs propriétés pour votre gadget. Utilisez le raccourci clavier Ctrl-S pour enregistrer votre travail.
  7. Vous pouvez éventuellement cliquer sur Projet -> Ajouter des options d'affichage pour ajouter une vue d'options telle qu'elle est définie dans le fichier options.xml de votre gadget. Répétez les étapes 4 à 6 pour la vue d'options.
  8. Ouvrez le fichier main.js (ou si vous préférez, créez et ouvrez un autre fichier de script) et définissez les fonctions appelées par les événements de l'élément de votre interface utilisateur. Utilisez le raccourci clavier Ctrl-S pour enregistrer votre travail.
  9. Testez votre gadget :
    1. Cliquez sur l'onglet Aperçu, en haut de la fenêtre, pour afficher votre gadget parfaitement fonctionnel dans le volet Visualisation.
    2. Cliquez sur Affichage -> Console de débogage pour ouvrir la fenêtre Console de débogage. Modifiez les paramètres de cette fenêtre afin qu'elle affiche les messages de votre choix et réglez la taille de la fenêtre Concepteur afin de pouvoir consulter à l'écran à la fois le volet Visualisation et la fenêtre Console de débogage dans leur intégralité.
    3. Testez votre gadget en tentant d'utiliser ses fonctionnalités.
    4. Si une erreur se produit, vérifiez le code ou l'interface utilisateur (y compris ses propriétés) et apportez les corrections nécessaires. Enregistrez vos modifications, puis cliquez sur Affichage -> Actualiser pour réinitialiser l'état du gadget. Relancez le test et recommencez cette procédure jusqu'à ce que vous puissiez utiliser votre gadget sans problème.
    5. Si aucune erreur n'est observée, cliquez sur Affichage -> Actualiser pour réinitialiser l'état du gadget. Continuez d'exécuter des tests jusqu'à ce votre gadget fonctionne correctement.
  10. Cliquez sur Projet -> Compiler l'ensemble afin de compresser tous les fichiers de votre projet et de les insérer dans un fichier Project_name.gg.
  11. Distribuez votre gadget en envoyant le fichier .gg à http://desktop.google.com/pluginsubmit?hl=fr

N'oubliez pas d'enregistrer régulièrement votre travail à l'aide du raccourci clavier Ctrl-S ou en cliquant sur Fichier -> Enregistrer, en particulier avant de lancer le test de votre gadget.

Il est important de comprendre que le Concepteur ne dispose d'aucune méthode propre pour ajouter des fichiers à un projet, son dossier ou ses sous-dossiers. Cliquez sur Fichier -> Nouveau projet pour créer un certain nombre de fichiers à cet endroit, tels qu'ils s'affichent au départ dans le volet Fichier. Notez toutefois qu'il est impossible d'ajouter ou de supprimer des fichiers dans le dossier du gadget à partir du Concepteur.

Pour ajouter ou supprimer des fichiers dans le dossier de projet, utilisez un outil de navigation externe de fichiers, par exemple l'Explorateur Windows. Vous devez également suivre cette procédure pour modifier le contenu des fichiers créés par le Concepteur de gadgets, tels que plugin_large.gif, qui contient la plus grande icône associée à votre gadget.


Mise en route

Pour lancer le Concepteur de gadgets Google Desktop, exécutez le fichier designer.exe qui se trouve dans le kit de développement (SDK) de Google Desktop. Au départ, le Concepteur se présente comme l'image présentée à droite.

Aspect initial du Concepteur

Dans le Concepteur, vos gadgets sont appelés Projets. Par conséquent, pour démarrer la création d'un gadget :

  1. Accédez au menu Fichier et cliquez sur l'élément Nouveau projet.
  2. Une boîte de dialogue identique à celle figurant sur la droite de cette page s'affiche.
  3. Entrez le nom de votre gadget dans le champ Nom du fichier en bas de la fenêtre.
  4. Cliquez sur le bouton Enregistrer.

Boîte de dialogue du nom du nouveau projet

À présent que le gadget est doté d'un nom, le Concepteur crée un dossier pour votre projet, ainsi que plusieurs fichiers et sous-dossiers (décrits dans la section Volet Fichier et fichiers) pour vous aider à démarrer. À ce stade, la fenêtre du Concepteur se présente telle que représentée sur la droite de cette page.

Fenêtre du Concepteur

Boîte de dialogue Paramètres du projet et fichier gadget.gmanifest

Pour afficher la boîte de dialogue Paramètres du projet, double-cliquez sur Paramètres du projet dans le volet Fichier. Dans cette boîte de dialogue, entrez les informations de base sur votre gadget qui sont utilisées par le Concepteur pour écrire son fichier gadget.gmanifest.

Boîte de dialogue Paramètres du projet

Fichier gadget.gmanifest

Le fichier obligatoire gadget.gmanifest sert à spécifier, au format XML, les métadonnées décrivant votre gadget, ainsi que les composants qui doivent être installés avant la création du gadget. Vous pouvez indiquer la plupart de son contenu via la boîte de dialogue Paramètres du projet et le modifier manuellement.

Le fichier "manifest" se compose d'un élément <gadget>, doté d'un paramètre minimumGoogleDesktopVersion présentant la valeur de la version la plus ancienne de Google Desktop qui est capable d'exécuter ce gadget. Il comprend un élément obligatoire <about> et un élément facultatif <install>.

L'élément <about> peut inclure ces sous-éléments :

  • <id> : CLSID du gadget. Obligatoire
  • <name> : nom de votre gadget. Obligatoire.
  • <description> : brève description des fonctions du gadget. Obligatoire.
  • <version> : numéro de la version du gadget.
  • <author> : nom de l'auteur du gadget. Obligatoire.
  • <authorEmail> : adresse e-mail du développeur.
  • <authorWebsite> : URL de votre site Web.
  • <copyright> : notice de droit d'auteur.
  • <aboutText> : texte qui s'affiche dans la boîte de dialogue À propos du gadget.
  • <smallIcon> : icône de 12 x 12 pixels qui s'affiche dans la barre de titre de votre gadget.
  • <icon> : icône de 32 x 32 pixels qui s'affiche dans la boîte de dialogue À propos de votre gadget et dans l'interface utilisateur des alertes (si elle est prise en charge par votre gadget).
  • <eventAPI> : si cet élément est inclus (aucune valeur ne doit être ajoutée ; <eventAPI /> convient parfaitement), le gadget peut utiliser l'API Événement Google Desktop. L'inscription est gérée automatiquement.
  • <displayAPI usersNotifier="true"/> : lorsque usersNotifier est affecté de la valeur true, les notifications de l'interface utilisateur de la barre latérale sont activées. L'inscription est gérée automatiquement.
  • <queryAPI allowModifyIndex="true"/> : lorsque allowModifyIndex est affecté de la valeur true, le gadget peut utiliser l'API Requête et les notifications de l'index. L'inscription est gérée automatiquement.

Vous devez inclure, avec leurs valeurs, les éléments <id>, <name> et <description>. Nous vous conseillons également d'inclure, avec leurs valeurs, les éléments <version>, <author>, <authorEmail>, <authorWebsite>, <copyright>, <aboutText>, <smallIcon> et <icon>. Il est possible de trouver des exemples de l'ensemble d'éléments ci-dessus, dépourvus de toute valeur, par exemple <authorEmail></authorEmail>. Cette solution est acceptable, mais elle n'est pas recommandée.

Exemple d'un fichier gadget.gmanifest pour un gadget Horloge numérique :



<gadget minimumGoogleDesktopVersion="4.2006.505.0">
  <about>
    <id>5EBA73D8-8A97-47de-A373-2BCBDCA3D539</id>

    <version>1.0.0.0</version>
    <author>Google</author>
    <authorEmail></authorEmail>
    <authorWebsite>http://desktop.google.com/plugins.html</authorWebsite>

    <copyright>Copyright (c) 2006 Google Inc.</copyright>
    <description>Consultez l'heure en un coup d'œil sur une horloge numérique</description>
    <aboutText>&strAboutText</aboutText>
    <smallIcon>gadget_small.gif</smallIcon>

    <icon>gadget_large.gif</icon>
  </about>
</gadget>

Dans l'élément <gadget>, outre l'élément obligatoire <about>, vous pouvez disposer d'un élément facultatif <install> incluant n'importe quel composant de package, par exemple, des polices, devant être installé préalablement à la création du gadget. Exemple :


<install>
  <font src="mcfont.ttf"/>
</install>

Volet Fichier et fichiers

Le volet Fichier affiche les répertoires et les fichiers qui seront compressés dans le fichier gadget_name.gg utilisé pour distribuer votre gadget. Le répertoire de niveau supérieur porte le nom que vous avez donné au gadget dans la boîte de dialogue Paramètres du projet. Il contient au départ deux répertoires et cinq fichiers.

  • Répertoire 1033 : 1033 est l'identifiant de langue pour l'anglais (États-Unis). Ce répertoire contient le fichier strings.xml où vous et le Concepteur stockez la version anglaise (États-Unis) de toutes les chaînes utilisées dans l'interface utilisateur de votre gadget. Pour plus d'informations et pour savoir comment représenter d'autres langues, consultez la section Internationalisation de ce document.
  • Paramètres du projet : double-cliquez sur ce lien pour afficher la boîte de dialogue Paramètres du projet.
  • main.js : fichier JavaScript par défaut dans lequel vous pouvez définir des fonctions assurant la mise en œuvre du comportement de votre gadget et la gestion des événements. Double-cliquez sur ce fichier pour l'ouvrir dans le volet Visualisation et le modifier, ainsi que pour ajouter un onglet qui s'affichera dans la partie supérieure du volet Visualisation. Une fois le fichier modifié, cliquez sur Fichier -> Enregistrer ou utilisez le raccourci clavier Ctrl+S pour enregistrer vos modifications.
  • main.xml : fichier XML qui définit la vue/présentation de l'interface utilisateur de votre gadget. En double-cliquant sur cette entrée, vous activez l'onglet main.xml dans la partie supérieure du volet Visualisation, dans lequel s'affiche également le contenu du fichier main.xml. Au fur et à mesure que vous placez les éléments de l'interface utilisateur dans la vue principale du volet Visualisation et que vous définissez leurs propriétés, le contenu de ce fichier est automatiquement modifié en conséquence. Il est toutefois impossible de modifier directement ce fichier à partir du volet Visualisation. Pour le modifier, vous devez utiliser un éditeur de fichiers externe comme Emacs, vim, Bloc-notes, etc.
  • plugin_large.gif : fichier contenant la grande icône associée à votre gadget. Il convient de remplacer ce fichier par un autre portant le même nom et contenant une icône appropriée de grande taille (32 x 32 pixels) pour votre gadget.
  • plugin_small.gif : fichier contenant la petite icône associée à votre gadget. Il convient de remplacer ce fichier par un autre portant le même nom et contenant une icône appropriée de petite taille (12 x 12 pixels) pour votre gadget.
  • Répertoire stock_images : contient les fichiers images pré-chargés du composant d'interface utilisateur, par exemple, les boutons et les cases à cocher. Vous pouvez les remplacer par vos propres fichiers images ou les modifier afin d'intégrer vos images dans leur contenu.

Remarque : Pour ajouter, supprimer ou remplacer des données dans des fichiers répertoriés dans le volet Fichier, utilisez un navigateur de fichiers externe au Concepteur, par exemple l'Explorateur Windows. Le volet Fichier doit être considéré comme un mode d'affichage du contenu du dossier de votre gadget et non comme un outil susceptible de vous permettre d'agir sur ce contenu.

Volet Fichier

Volet Visualisation

La zone d'affichage centrale se compose au départ d'un carré blanc inséré au centre d'un espace gris. Ce carré blanc reflète l'apparence du gadget et représente l'objet view dans son intégralité, c'est-à-dire le fichier XML qui définit l'aspect global du gadget. Lorsque vous lancez le Concepteur et que vous n'avez pas encore défini les éléments de l'interface utilisateur pour le gadget, le volet Visualisation est vide (comme dans la capture d'écran à droite de cette page). Une fois que vous avez ajouté du contenu dans le carré blanc, vous pouvez modifier les propriétés de l'objet view, notamment sa taille.

Volet Visualisation

Onglets

Il existe au départ quatre onglets autour de la zone centrale du volet Visualisation de la fenêtre, deux en haut et deux en bas. Nous avons déjà détaillé la procédure à suivre pour ajouter un onglet main.js en haut de la fenêtre, en ouvrant le fichier à partir du volet Fichier. Nous détaillerons ultérieurement d'autres procédures pour ajouter ou supprimer des onglets en haut de la fenêtre.

  • Onglets en haut de la fenêtre :
    • main.xml : lorsqu'il est sélectionné, le Concepteur affiche le contenu du fichier main.xml de votre gadget dans le volet Visualisation. En fonction de l'onglet du bas de la fenêtre qui est sélectionné, il affiche l'interface utilisateur du gadget telle qu'elle est définie par le contenu XML ou le code XML lui-même.
    • Aperçu : affiche l'interface utilisateur de votre gadget et exécute tout script ou toute fonction associé aux éléments de l'interface utilisateur. Cette option permet en fait d'exécuter et de tester votre gadget à l'extérieur de la barre latérale et de Google Desktop. Par conséquent, si votre gadget inclut, par exemple, un bouton qui, lorsqu'il est actionné, exécute une fonction qui modifie la couleur d'arrière-plan du gadget en utilisant la tonalité suivante du spectre de couleurs, vous pouvez, si vous êtes en mode Aperçu, appuyer sur ce bouton afin de modifier la couleur d'arrière-plan du gadget (dans la mesure où la fonction a été correctement écrite). Notez que les onglets du bas de la fenêtre disparaissent lorsque le mode Aperçu est activé.
  • Onglets du bas de la fenêtre :
    • Concepteur : affiche l'interface utilisateur du gadget concerné.
    • Source : affiche le code XML qui définit l'interface utilisateur du gadget.
Onglets

Écriture des fichiers XML de la fenêtre de visualisation

Le Concepteur permet de faire glisser et de déposer les éléments de l'interface utilisateur, ainsi que de définir leurs propriétés dans une vue principale ou dans une vue d'options. Une fois que vous avez terminé cette opération, le Concepteur effectue automatiquement la mise à jour du fichier XML (le fichier main.xml ou le fichier options.xml) qui décrit cette vue en particulier. Cette mise à jour inclut l'ajout ou la suppression d'éléments XML, la définition des valeurs de propriétés, etc.

Vous pouvez aussi accéder à ces fichiers XML et les modifier manuellement. Par conséquent, avant de vous présenter la procédure à suivre pour glisser-déposer des objets et définir leurs propriétés avec le Concepteur, examinons le format des fichiers XML.

La section API ci-dessous répertorie les propriétés, les méthodes et les événements des éléments que vous pouvez définir dans un gadget, ainsi que les vues (par "vue", il faut comprendre l'apparence générale d'un volet). Ces éléments permettent de spécifier, dans les fichiers de la fenêtre XML, le comportement, le format et les composants de l'interface utilisateur du gadget. La vue principale du gadget est définie par l'élément <view> dans le fichier main.xml que le Concepteur génère automatiquement lorsque vous créez un nouveau projet. Si votre gadget comprend une vue Options, vous devez aussi inclure un fichier options.xml, qui permet de définir un autre élément <view>. La définition de <view> inclut des éléments XML qui définissent les objets de l'interface utilisateur composant cette vue. Par exemple, un fichier main.xml peut contenir les éléments suivants :

<view width="200" height="200">

<button image="button.png" overImage="button_over.png"
downImage="button_down.png" onclick="button_clicked()"/>

</view>

Ce fichier définit une vue de 200 x 200 pixels contenant un bouton. En définissant les propriétés de l'objet bouton approprié, vous pouvez également inclure des images différentes en fonction de l'état du bouton : normal, survol du curseur de la souris ou déplacement du curseur de la souris vers le bas. Lorsqu'un utilisateur clique sur le bouton, il appelle la fonction button_clicked() (définie ailleurs) via l'événement onclick de l'objet bouton.

Pour définir une propriété dans le fichier XML, ajoutez le bloc propriété="valeur" à un élément. Vous pouvez spécifier une scriptlet d'événement au format XML en ajoutant le bloc événement="script" à un élément. Comme avec le langage DHTML, vous pouvez manipuler les éléments à l'aide d'un script une fois qu'ils ont été créés… à condition qu'ils soient dotés d'une propriété name. Exemple :

<button name="sample_button" ... />

Lorsqu'un élément comporte un nom, les scripts peuvent y accéder et le manipuler, et appeler n'importe quelle méthode qui lui est associée :

sample_button.property = "nouvelle valeur";
sample_button.event = "nouveau script";
sample_button.method();

Vous pouvez aussi utiliser les fonctions de script (définies ailleurs) dans votre groupe de fichiers .gg, y compris dans les fichiers dédiés .js ou .vbs (notamment la fonction button_clicked() utilisée dans l'exemple de bouton ci-dessus). Vous pouvez aussi inclure des fonctions prédéfinies dans la définition de <view>. Exemple :


<view width="200" height="200" onopen="view_onopen()">
 <script language="jscript"><!--
  function view_onopen()
  {
    foo( "bar()", 1000 );
  }

  function bar()
  {
    x = 2 + 2;
  }

 --></script>

 <div background="#FFFFFF" width="200" height="200"/>
</view>

Seul un objet contentArea peut être défini au sein de l'objet view. Pour plus d'informations sur l'objet contentArea, consultez la section relative à l'API.


Gestion des événements des gadgets

Le modèle d'événements d'un gadget est similaire à celui du DHTML. La section relative à l'API ci-dessous répertorie les événements associés à certains objets, en particulier les objets view et basicElement, ainsi qu'une partie de leurs objets descendants. Pour indiquer la manière dont un événement doit être géré pour l'un de ces objets, insérez l'événement dans la définition XML de l'objet en précisant ce qu'il convient de faire lorsqu'il se produit. Par exemple, pour indiquer ce qui doit se passer lorsqu'un objet view présente un événement onmouseover, vous devez écrire :

<view onmouseover="action_à_effectuer_lorsque_le_curseur_survole_l'objet;"/>

... où action_à_effectuer_lorsque_le_curseur_survole_l'objet constitue le morceau d'un script, tout comme alert('mouse over!'), ou l'appel d'une fonction insérée dans un bloc de script, comme view_onmouseover().

Tout comme pour le DHTML, les événements et leurs gestionnaires ne disposent d'aucun argument. À la place, le script utilise l'objet view.event pour obtenir des informations sur l'événement. Comme seul un élément à la fois peut être déclenché, l'objet event d'une vue contient les informations relatives à l'événement sur le point d'être déclenché.

La propriété event.returnValue peut être utilisée pour définir une valeur de renvoi. Tout comme pour le DHTML, il s'agit d'une valeur booléenne, qui détermine si c'est le comportement par défaut de l'événement qui est exécuté. Exemple :

event.returnValue = false; // désactive le comportement par défaut
event.returnValue = true; // active le comportement par défaut
// aucune valeur de renvoi n'est spécifiée, le comportement par défaut est activé

En particulier, la propriété event.returnValue peut soit :

  • view.event.returnValue = false; //désactiver le comportement par défaut associé à l'événement de la vue
  • view.event.returnValue = true; //activer le comportement par défaut associé à l'événement de la vue

Exemple :


    <edit onkeypress="edit_onkeypress()"/>
    function edit_onkeypress()
    {
     if( event.keyCode == 'j' ) event.returnValue = false;
    }
    

Chaque fois que vous appuyez sur une touche lorsque la commande se trouve au sein de cet objet édition, la fonction edit_onkeypress() est appelée. Si la touche sur laquelle vous appuyez est j, alors, comme la propriété event.returnValue est définie sur false, l'événement et sa valeur de renvoi habituelle sont supprimés. Dès lors, le résultat est le même que si vous n'aviez pas appuyé sur la touche j. En réalité, cet élément <edit> ne vous permet pas d'entrer la lettre "j".


Gestion des événements de l'objet Pre-4.0

L'ensemble des objets du gadget actuel inclut des objets provenant de l'objet Pre-4.0. Certains d'entre eux, en particulier googleTalk et ContentItem, exploitent un modèle de gestion des événements différent de celui décrit ci-dessus. Dans la section relative à l'API ci-dessous, ce sont les Gestionnaires d'événement qui sont associés, et non seulement les Événements.

Pour ces objets Pre-4.0, vous devez définir une fonction de gestionnaire pour un événement afin de pouvoir le gérer. Ces fonctions de gestionnaire peuvent être définies uniquement au sein des blocs JavaScript ou VBScript ; en aucun cas dans les définitions XML comme les objets 4.0.

Les gestionnaires d'événements s'exécutent en mode écriture seule. Vous pouvez uniquement leur attribuer une fonction. Si vous ne définissez pas un gestionnaire en particulier, l'action par défaut de ce dernier est alors déclenchée en réponse à l'événement qui lui est associé. Vous trouverez dans la section relative à l'API une signature de prototype pour chaque gestionnaire d'événement. La fonction que vous attribuez à un gestionnaire d'événement donné doit correspondre à la signature de son prototype.

Examinons à présent les différents éléments pertinents de l'exemple de code Options & Menu afin de voir comment fonctionne un gestionnaire d'événement.


    // les propriétés du gadget sont définies, identiques à celles de l'exemple "Bonjour à tous".
    // ...
    // Associez l'événement onAddCustomMenuItems de l'objet du gadget à
    // une fonction définie dans le script.
    plugin.onAddCustomMenuItems = AddCustomMenuItems;  // gestionnaire pour ajouter des éléments de menu    

    // ...

    function AddCustomMenuItems(menu) {
      // Ajoutez les différentes présentations d'élément en tant qu'éléments
			// de menu et vérifiez celle qui est actuellement sélectionnée
      var itemLayout = options.GetValue("item_layout");
      for (var i = 0; i < menuItems.length; ++i) {
        if (i == itemLayout) {
          menu.AddItem(menuItems[i], gddMenuItemFlagChecked, MenuItemClicked);
        } else {
          menu.AddItem(menuItems[i], 0, MenuItemClicked);
        }
      }    
    }

    // ...
   

Dans ce cas, nous attribuons la fonction AddCustomMenuItems à l'événement onAddCustomMenuItems de l'objet plugin. Notez que la valeur affectée se compose uniquement du nom de la fonction, et non de la signature complète du paramètre. Cet événement se déclenche lorsque la barre latérale démarre le menu du gadget avant de l'afficher.

Le prototype indiqué pour la fonction AddCustomMenuItems est AddCustomMenuItems(menu). Par conséquent, la fonction que nous devons attribuer ne peut comporter, elle aussi, qu'un seul argument, un objet menu.


Présentation des objets

Dans cette section, nous allons examiner les différents objets, en axant les observations sur leur utilité et la manière dont ils sont associés.

    Objet gadget

L'objet gadget dispose de deux sous-objets, utilisés pour des objectifs très différents au niveau global du gadget.

  • Les méthodes gadget.debug facilitent la mise au point en affichant la chaîne de caractères de votre choix dans la console de débogage lorsqu'elle est lancée en mode débogage.

    Pour lancer le mode débogage, décompressez votre gadget et, à partir du fichier dans lequel vous l'avez décompressé, double-cliquez sur le fichier gadget.gmanifest. Vous pouvez ainsi développer votre gadget sans avoir à le compresser chaque fois que vous voulez le tester.

    Les messages de débogage n'apparaissent dans la console de débogage que lorsque le gadget est lancé depuis un dossier (en cliquant sur le fichier gadget.gmanifest). Aucun message ne s'affiche lorsque vous lancez le gadget à partir d'un fichier .gg. Ces messages apparaissent dans la console de débogage du Concepteur ou dans le fichier gdpconsole.exe fourni avec le kit de développement Google Desktop (SDK).

  • Les méthodes gadget.storage que l'on utilise avec les fichiers composant l'ensemble général du gadget. Ces méthodes permettent d'extraire ou d'ouvrir un fichier contenu dans le groupe de fichiers. Le nom du fichier de l'objet de stockage peut être doté de l'un des arguments suivants :
    • "foo.xml" recherche le fichier foo.xml dans le dossier racine du fichier .gg. S'il ne le trouve pas, il poursuit alors ses recherches dans les dossiers de localisation (par exemple, 1033\foo.xml).
    • "subfolder\foo.xml" recherche le fichier foo.xml dans le dossier subfolder du fichier .gg. S'il ne le trouve pas, il poursuit alors ses recherches dans le dossier subfolder des dossiers de localisation (par exemple, 1033\subfolder\foo.xml).
    • "c:\bar.xml" recherche le fichier bar.xml sur le lecteur c:\. Vous devez indiquer le chemin d'accès complet.

    L'objet view

Vous devez définir un objet view pour chaque volet que compte votre gadget. Chaque objet doit être inséré dans un fichier .XML distinct. Le Concepteur génère automatiquement un fichier main.xml doté d'un objet view lorsque vous créez un projet. Il peut aussi créer un fichier options.xml comportant son propre objet view.

Les méthodes et les propriétés de l'objet view permettent de définir et d'accéder au comportement général d'un volet d'affichage. Elles renferment les éléments de l'interface utilisateur qui composent l'apparence et la taille du volet. Elles indiquent si le volet peut être redimensionné par l'utilisateur, présentent les temporisateurs qui contrôlent l'exécution des scripts, l'ajout ou la suppression des éléments de l'interface utilisateur et affichent les boîtes de dialogue des messages et de confirmation.

Les événements de l'objet view déclenchent et exécutent une fonction en fonction de différentes actions du bouton de la souris, des touches, du redimensionnement, des modifications des valeurs des propriétés ou du curseur. Une fonction est également exécutée lorsque cette vue est ouverte en premier lieu.

    Objets de l'interface utilisateur et objet basicElement

basicElement est l'objet parent des différents éléments de l'interface utilisateur qui composent l'affichage visuel d'une vue donnée. L'objet basicElement lui-même ne fait jamais l'objet d'une instanciation. Il fournit juste un ensemble de propriétés et d'événements communs aux objets de l'interface utilisateur descendants.

Les propriétés indiquent la taille et l'emplacement de l'élément, son nom, son degré de visibilité et d'opacité, ainsi que d'autres propriétés générales de l'élément de l'interface utilisateur.

Les événements sont ceux qui sont en général associés à un objet de l'interface utilisateur : les actions impliquant des clics de souris ou la molette de défilement, l'utilisation de la fonction glisser-déposer sur l'élément, la réception ou la perte du focus clavier, les touches et le mouvement du curseur.

Vous pouvez définir les descendants suivants de l'objet basicElement :

  • button : propriétés spécifiques permettant de définir différentes images pour le bouton en fonction de ses différents états.
  • checkbox : propriétés spécifiques permettant de définir différentes images pour la case à cocher en fonction de ses différents états, ainsi que de déterminer si la case à cocher a été activée ou non. Un événement se déclenche lorsque la valeur de la case est modifiée (cochée/décochée).
  • objet : un contrôle ActiveX intégré sans fenêtre. Utilisé principalement dans le cadre de l'intégration de Windows Media Player.
  • div : utilisé pour définir les images ou les couleurs d'arrière-plan d'un élément.
  • edit : propriétés spécifiques permettant de contrôler l'apparence du contenu de son texte et de définir ou d'extraire le contenu de son texte. Un événement se déclenche lorsque le contenu est modifié.
  • img : propriétés spécifiques permettant de définir l'image à afficher et d'obtenir ses dimensions originales. Cet objet dispose aussi d'une méthode de redimensionnement des images.
  • label : propriétés spécifiques permettant de contrôler l'apparence du texte du libellé, ainsi que sa position/son alignement.
  • a : objet "link" doté de propriétés spécifiques permettant de contrôler l'apparence du lien et son URL.
  • progressBar : propriétés spécifique permettant de contrôler l'apparence de la barre de progression et de ses composants, ainsi qu'un événement qui se déclenche lorsque la valeur est modifiée.

Il convient aussi de mentionner l'objet elements qui joue le rôle de conteneur des objets descendants de l'objet basicElement.

    Objet options

Cet objet permet de stocker les options et leurs valeurs sous la forme d'un dictionnaire/d'une carte standard. Pour définir une valeur, choisissez l'une des deux solutions suivantes :
options("touche") = "valeur";
options.item("touche") = "valeur";

Comme c'est le cas pour tous les dictionnaires, vous pouvez ajouter des éléments de deux manières différentes :
options("touche") = "valeur"; // Ajoutez ou remplacez la valeur actuelle.
options.add("touche", "valeur"); // Ajoutez une valeur. Si elle existe déjà, ne faites rien.

La propriété defaultValue permet aux touches de renvoyer leur valeur par défaut si aucune valeur n'est associée à celles-ci dans le dictionnaire. Il n'est donc pas nécessaire de vérifier si une valeur existe pour cette touche. Exemple :

options.defaultValue("couleur") = "rouge" ;

Le dictionnaire renvoie à présent "rouge" chaque fois que la propriété "couleur" est demandée. La propriété "couleur" n'existe en fait pas dans le dictionnaire. Exemple :

options.defaultValue("couleur") = "rouge" ;
options("couleur") = "bleu";
debug.trace(options("couleur")); // "bleu" s'affiche
options.remove("couleur") ;
debug.trace(options("couleur")); // "rouge" s'affiche (valeur par défaut)
options("texture") = "bosselée" ;
debug.trace(options("texture")); // "bosselée" s'affiche
options.remove("texture");
debug.trace(options("texture")); // "" s'affiche (car aucune valeur par défaut n'est définie)

    Les objets Pre-4.0 (googleTalk, friend, ContentItem, menu,

Quatre objets, googleTalk, friend, ContentItem et menu, relevant du modèle de développement Pre-4.0 sont inclus dans le modèle de développement de la version 4.0. Remarque : Lorsque vous utilisez les gestionnaires d'événements de googleTalk ou de menu dans votre code, vous devez utiliser le modèle de gestion des événements Pre-4.0. En outre, à la différence d'autres éléments de l'interface utilisateur, notez que ces objets ne descendent pas de l'objet basicElement.

Pour plus d'informations sur l'utilisation des objets googleTalk et friend dans le cadre de l'écriture de gadgets capables de communiquer avec des gadgets exécutés sur d'autres ordinateurs, consultez la documentation relative à l'API de communication de la barre latérale de Google Desktop (Toute documentation supplémentaire est actuellement disponible en anglais uniquement).

Les objets menu et leurs méthodes permettent de construire un menu à plusieurs éléments pour votre gadget. Vous pouvez notamment associer des fonctions de gestionnaire au clic d'un utilisateur sur l'élément d'un menu.

Les objets ContentItem sont échangés entre des gadgets exécutés sur différents ordinateurs. Ils peuvent composer les éléments de l'interface utilisateur contenus dans un objet contentArea .

DetailsView est une fonctionnalité de l'interface utilisateur qui permet à un gadget d'afficher des informations supplémentaires dans une fenêtre ou un gadget séparé, à l'extérieur de la barre latérale. Les gadgets qui utilisent cette fonctionnalité peuvent également recevoir des notifications et des événements de la Vue détaillée.

Espace de nom des objets structure

L'espace de nom de l'objet structure présente les API qui remplissent les espaces vides générés par Windows Scripting Host et qui sont utiles dans le cadre de la mise en œuvre du gadget. Notez que les objets structure.* ne descendent pas de l'objet basicElement et qu'ils ne s'affichent pas dans les définitions de l'objet de l'interface utilisateur XML du gadget. L'objet structure s'apparente essentiellement à un espace de nom de type .NET des objets utilisés pour demander des informations système. Ces informations sont alors exploitées par les scripts appelés par les événements dans le cadre des objets de l'interface utilisateur définis au format XML.

Les objets structure, ainsi que leurs propriétés et méthodes vous permettent :

  • d'afficher les boîtes de dialogue Ouvrir le fichier ;
  • de télécharger les fichiers image ;
  • de connaître l'emplacement actuel du curseur ;
  • d'obtenir des informations sur l'utilisation et la capacité de la mémoire du système ;
  • d'obtenir des informations sur la connexion et les ressources d'accès sans fil du système ;
  • de régler et de surveiller les compteurs qui contrôlent l'exécution du code des scripts ;
  • d'obtenir des informations sur les sources d'alimentation et les niveaux des batteries (le niveau total et le niveau de charge) ;
  • d'obtenir des informations sur le processeur du système ;
  • d'obtenir les dimensions de l'écran du système.

Enfin, il existe deux autres objets définis qui sont utilisés uniquement pour les types au sein de l'espace de nom structure :

  • point : représente un point, doté des propriétés des coordonnées x et y.
  • size : représente la taille d'un objet et inclut les propriétés spécifiant la largeur et la hauteur.

Pour illustrer la manière dont vous pouvez utiliser les objets structure, écrivons un gadget simple visant à indiquer le niveau de charge de la batterie d'un ordinateur portable.


<view width="200" height="200" onopen="view_onopen()">
 <script language="jscript"><!--
  function view_onopen()
  {
    setInterval( "update_battery()", 1000 );
  }

  function update_battery()
  {
    percent_used.innerText = system.power.percentRemaining + "%";
  }

 --></script>

 <div background="#FFFFFF" width="200" height="200"/>

 <label name="percent_used" align="center" valign="middle">0%</label>
</view>

Nous avons défini une vue de 200 x 200 pixels comportant deux éléments :

  • un objet <div> doté d'un arrière-plan de couleur blanche
  • un objet <label> intitulé percent_used qui démarre à 0 %.

Lorsque le gadget est chargé, l'événement view::onopen se déclenche et appelle la fonction view_onopen(). Cette fonction définit un intervalle de sorte que l'élément update_battery() soit appelé une fois par seconde. L'élément update_battery() utilise l'objet et les propriétés de l'élément system.power.percentRemaining du nom de l'espace de l'objet structure pour mettre à jour innerText au sein de l'élément percent_used.

Notez qu'il n'est pas obligatoire d'insérer l'objet structure. avant l'élément system.power.percentRemaining. C'est vous qui décidez.


Faire glisser-déplacer des objets de l'interface utilisateur

Faire glisser-déplacer des icônes de l'interface utilisateur

Cette fonctionnalité permet de définir au départ l'interface utilisateur du gadget dans le Concepteur. Il suffit de cliquer avec la souris sur l'un de ces huit éléments de l'interface utilisateur et de le faire glisser-déplacer au niveau de l'emplacement, dans la zone d'affichage blanche, où vous voulez qu'il apparaisse dans votre gadget. Relâchez le bouton de la souris. Cet élément de l'interface utilisateur est à présent dans le gadget et il correspond à l'élément d'interface utilisateur qui est actuellement sélectionné. À l'instar de l'élément d'interface utilisateur, ses propriétés, ainsi que les valeurs de ces dernières apparaissent dans le volet Propriétés sur le côté droit. Il suffit de cliquer sur un objet de l'interface utilisateur dans la zone d'affichage pour qu'il devienne l'objet d'interface utilisateur sélectionné à l'écran.

Les objets de l'interface utilisateur incluent tous les événements, propriétés et méthodes décrits dans la section relative à l'API. Notez que les objets qui s'affichent dans cette section proviennent tous de l'objet basicElement. Par conséquent, c'est ici que vous trouverez la description d'une propriété ou d'un événement qui n'est pas spécifié pour les objets individuels. L'interface utilisateur se compose des huit éléments suivants :

  • Div : cet élément permet de définir la couleur d'arrière-plan d'un élément de l'interface utilisateur ou du gadget. Il offre également un point d'accueil pour insérer ou supprimer de manière automatique les éléments de l'interface utilisateur du bloc le contenant.
  • Image : indique l'image à afficher dans la vue.
  • Button : objet "bouton de commande".
  • Edit : indique une zone où l'utilisateur du gadget peut modifier le contenu du texte.
  • Check : objet "case à cocher".
  • Link : définit un lien HTML.
  • Text Label : objet "libellé de texte défini".
  • Content : objet de contenance contentArea. Consultez la section relative à l'API pour plus d'informations sur son utilisation.

Il est impossible de glisser-déposer les éléments de l'interface utilisateur progressbar et object, en tant qu'éléments du Concepteur. Toutefois, ils peuvent être définis dans le code XML. Remarque : le Concepteur ne vous permet pas de modifier directement le fichier XML de votre gadget. Vous devez utiliser un éditeur de texte externe.


Volet Éléments

Lorsque le volet Visualisation affiche un ou plusieurs éléments de l'interface utilisateur, sélectionnez celui de votre choix en :

  • cliquant une fois dessus dans le volet Visualisation, ou
  • cliquant sur son nom dans le volet Éléments.

Lorsqu'un objet est d'abord inséré dans le volet Visualisation, il apparaît sous la forme d'un enfant de l'élément view dans le volet Éléments. Il ne peut alors utiliser que son type comme identifiant. Par conséquent, si vous sélectionnez deux fois l'élément Button dans le volet Visualisation, le volet Éléments affiche deux éléments, qui sont désignés par button. Si vous dotez un élément d'un nom, par exemple Bouton1 il s'affichera dans le volet Éléments sous la forme de button (Bouton1).

Notez que la seule manière d'accéder aux événements et aux propriétés de l'objet view dans le Concepteur est de cliquer sur l'entrée view dans le volet Éléments.

Volet Éléments

Volet Propriétés

Le volet Propriétés affiche les propriétés (ainsi que les valeurs dont elles sont dotées) de l'objet de l'interface utilisateur actuellement sélectionné. C'est le seul endroit où vous pouvez modifier la valeur des propriétés d'un objet et les fonctions associées à leurs événements.

Pour modifier la valeur d'une propriété, cliquez sur son nom ou sa valeur. Les options en entrée dépendent du type de la propriété.

  • S'il s'agit d'une propriété booléenne, la valeur est modifiée et présente un petit menu déroulant avec les valeurs true et false. Cliquez sur la valeur que vous voulez conférer à cette propriété.
  • S'il s'agit d'une propriété comportant une valeur texte ou une valeur numérique, il suffit de saisir la nouvelle valeur dans le champ de la valeur et d'appuyer sur la touche Entrée.
  • Certaines valeurs de propriétés, telles que mask ou la valeur background de div, peuvent correspondre à une chaîne de caractères ou à un fichier. Pour ce type de propriété, un petit cadre doté de 3 points apparaît. Si vous cliquez sur ce cadre, une fenêtre de navigation Ouvrir un fichier s'affiche. Si vous préférez utiliser à la place une valeur de chaîne, il suffit de la saisir dans le champ de valeur et d'appuyer sur la touche Entrée.

Le cas échéant, l'affichage change afin de refléter la nouvelle valeur de la propriété de l'objet de l'interface utilisateur.

Notez que certaines propriétés, comme cursor, disposent d'un ensemble défini et limité de valeurs autorisées. Le Concepteur ne vérifie pas si la valeur que vous avez entrée fait partie de l'ensemble des valeurs autorisées pour la propriété visée. Toutefois, lorsque vous essayez d'afficher votre vue, une erreur se produit.

Notez également que l'objet général view, auquel on accède en le sélectionnant dans le volet Éléments, dispose de son propre ensemble de propriétés et d'événements. Si, par exemple, vous voulez modifier la taille de la vue, cliquez sur view dans le volet Éléments. Ensuite, modifiez les valeurs height et/ou width dans le volet Propriétés.

Pour les événements, il suffit de saisir dans leur champ de valeur, le nom d'une fonction définie dans un fichier de script inclus dans le gadget. Par exemple, pour l'événement onOpen de l'objet view, entrez view_onOpen(), qui est une valeur définie dans la fonction main.js , dans son champ de valeur.

Volet Propriétés

Volet Scripts

Ce volet affiche les fichiers de script utilisés par le gadget dans le fichier XML actuellement à l'écran. Ces fichiers seront compressés avec les fichiers image et XML de l'interface utilisateur une fois la conception de votre gadget terminée. Par défaut, il contient d'abord uniquement un fichier main.js. Mais vous pouvez ajouter d'autres fichiers de script et/ou supprimer le fichier main.js.

Pour ajouter un fichier de script au volet Scripts, cliquez sur l'icône représentant une feuille de papier (la plus à gauche des trois icônes). Elle ouvre un navigateur de fichiers défini pour afficher uniquement les fichiers de script, à partir du dossier de votre gadget. Recherchez le fichier de script à ajouter et cliquez sur Ouvrir. Notez que le fichier de script doit déjà exister avant de pouvoir l'ajouter ici. De la même manière que lorsque vous cliquez sur Fichier -> commandes, le fichier de script est copié dans le dossier du projet et le Concepteur l'affiche dans le volet Fichier. Il permet aussi d'ajouter une ligne <script src="filename" /> dans n'importe quel fichier XML du gadget actuellement actif au sein du volet Visualisation. Par conséquent, si par exemple, le fichier main.xml est actif, la ligne <script src="filename"/> est ajoutée uniquement au fichier main.xml, et non au fichier options.xml.

Dans le volet Scripts, une fois que vous avez sélectionné l'un des fichiers de script en cliquant dessus, vous pouvez :

  • ouvrir le fichier pour le modifier en cliquant sur l'icône du milieu permettant d'ouvrir un fichier. Un nouvel onglet qui arbore le nom du fichier apparaît ainsi en haut du volet. Cliquez sur ce nouvel onglet pour transformer le volet Visualisation en un volet de modification pour le contenu du fichier.
  • supprimer le fichier dans le volet Scripts en cliquant sur la croix (X), à droite. Notez que le script est supprimé immédiatement sans qu'aucune boîte de dialogue de confirmation ne s'affiche à l'écran. Par ailleurs, le fichier du script est toujours présent dans le volet Fichier et il sera compressé comme un élément du gadget à moins que vous ne le supprimiez du dossier du gadget à l'aide d'un outil de navigation externe de fichiers.

Il est important de comprendre que le volet Scripts n'affiche pas les fichiers de script stockés dans le dossier du projet, mais bien les scripts utilisés dans le fichier XML permettant de définir la vue, actuellement à l'écran.

Si vous observez le fichier main.xml juste après sa création, en cliquant sur Fichier ->Nouveau projet, vous remarquerez qu'il comporte une ligne <script src="main.js" /> dans son élément <view>. Le fichier main.js est aussi bien répertorié dans le volet Scripts, que dans le volet Fichier.

Si vous supprimez le fichier main.js du volet Script, la ligne <script src="main.js" /> disparaît de l'élément <view>. La vue de votre gadget ne disposera alors plus d'aucune information sur les fonctions définies dans le fichier. Le fichier lui-même est toujours présent dans le dossier du projet. Si vous voulez le supprimer, faites appel à un outil de navigation de fichiers externe, sinon il sera compressé dans le fichier .gg avec les autres fichiers du projet.

Enfin, notez que lors de la création d'un projet, le fichier main.xml contient automatiquement, par défaut, la ligne <script src="main.js" /> et le fichier main.js contient une définition pour la fonction view_onOpen() que le fichier main.xml utilise. Si vous supprimez le fichier main.js du volet Scripts sans fournir aucune définition d'une fonction de substitution ou sans réécrire le fichier main.xml, avec pour conséquence que la ligne view_onOpen() ne puisse plus être utilisée, un message d'erreur apparaît.

Volet Scripts

Commandes du menu

Le haut de la fenêtre du Concepteur comprend cinq commandes. Chacune d'elle propose un menu déroulant : Fichier, Édition, Affichage, Projet et Aide. Nous allons étudier ces commandes de manière détaillée.

Commandes de menus

      Commandes du menu Fichier

Le menu Fichier dispose de sept commandes :

  • Nouveau projet : ouvre une boîte de dialogue Enregistrer sous qui permet d'indiquer l'emplacement du dossier du nouveau projet et son nom. Cliquez sur OK, le nouveau projet apparaît dans la fenêtre Concepteur. Remarque : Si un projet est déjà affiché dans la fenêtre Concepteur, aucune invite n'apparaît à l'écran pour vous demander de l'enregistrer avant d'ouvrir un nouveau projet. Cette commande dispose d'un raccourci clavier : Ctrl-Maj-N.
  • Ouvrir un projet : ouvre une boîte de dialogue Ouvrir le dossier. Vous êtes invité à rechercher le dossier d'un projet existant. Cliquez sur OK une fois que vous avez sélectionné celui de votre choix. Si le dossier sélectionné ne contient pas de fichier main.xml, un message d'erreur s'affiche dans une fenêtre popup et l'opération est abandonnée. Dans le cas contraire, le projet sélectionné s'ouvre dans la fenêtre du Concepteur. Cette commande dispose d'un raccourci clavier : Ctrl-Maj-O.
  • Fermer le projet : permet de fermer le projet en cours. La fenêtre du Concepteur est alors vide (seules les commandes du menu en haut de la fenêtre restent affichées). Notez qu'aucune invite n'apparaît à l'écran pour vous demander d'enregistrer le projet qui est ouvert. Cette commande ne dispose d'aucun raccourci clavier.
  • Ouvrir : permet d'ouvrir un navigateur de fichiers défini pour afficher les fichiers XML. Si vous sélectionnez et ouvrez l'un de ces fichiers, un nouvel onglet arborant le nom de ce fichier apparaît en haut de la fenêtre. En outre, si vous sélectionnez le nouvel onglet, le contenu du fichier s'affiche dans le volet Visualisation. Notez que ce nouveau fichier n'est pas ajouté au dossier de votre gadget tel qu'il apparaît dans le volet Fichier, puisque ce fichier ne se trouve pas dans le dossier du projet. Pour ajouter un fichier dans le dossier de projet, utilisez un outil de navigation externe de fichiers, par exemple l'Explorateur Windows. Cette commande dispose d'un raccourci clavier : Ctrl+O.
  • Enregistrer : permet d'enregistrer n'importe quel fichier de gadget ouvert. Vous devez effectuer cette opération chaque fois que vous modifier un fichier ou les propriétés d'un objet de l'interface utilisateur. Cette commande dispose d'un raccourci clavier : Ctrl+S.
  • Fermer : permet de fermer immédiatement le fichier actuellement à l'écran, dans le volet Visualisation et de supprimer l'onglet du fichier. Le fichier est, lui, toujours présent dans le volet Fichier. Cette commande dispose d'un raccourci clavier : Ctrl+F4.
  • Quitter : une fenêtre popup s'affiche afin de vous demander si vous voulez enregistrer les modifications apportées au fichier main.xml. Une fois que vous avez cliqué sur Oui ou sur Non, la fenêtre du Concepteur de gadget se ferme. Cette commande dispose d'un raccourci clavier : Alt+F4.

Il convient aussi de signaler que les projets récents apparaissent dans une section du menu juste au-dessus de la commande Quitter. Si vous cliquez sur un projet récent, il s'ouvre dans la fenêtre du Concepteur.

Commandes du menu Fichier

      Commandes du menu Édition

Le menu Édition dispose de six commandes :

  • Annuler : permet d'annuler l'action que vous avez effectuée dans le Concepteur, par exemple, modifier la valeur d'une propriété, déplacer un objet de l'interface utilisateur, créer un objet, etc. Lorsque vous annulez une action, vous pouvez aussi annuler toutes celles qui la précèdent. Cette commande dispose d'un raccourci clavier : Ctrl+Z.
  • Rétablir : cette option apparaît grisée sauf si vous venez juste d'annuler une action. Si vous décidez finalement de ne pas annuler votre dernière action, cliquez sur cette option. Si vous avez annulé plusieurs actions, vous pouvez cliquer plusieurs fois sur l'option Rétablir afin de rétablir l'état du Concepteur. Cette commande dispose d'un raccourci clavier : Ctrl+Y.
  • Couper : permet d'effectuer les opérations de découpe standard, dans le cadre des éléments de l'interface utilisateur au sein du volet Visualisation. Cette commande dispose d'un raccourci clavier : Ctrl+x.
  • Copier : permet d'effectuer les opérations de copie standard, dans le cadre des éléments de l'interface utilisateur au sein du volet Visualisation. Notez que lorsque vous copiez un objet de l'interface utilisateur, le système effectue une copie exacte, en incluant notamment toutes les valeurs de propriété. Si vous copiez, par exemple, un bouton intitulé Bouton2, la copie inclura aussi la valeur Bouton2) pour la propriété de son nom. Ces deux boutons apparaîtront de manière identique dans le volet Éléments. Cette commande dispose d'un raccourci clavier : Ctrl+c.
  • Coller : permet d'effectuer les opérations de collage standard, dans le cadre des éléments de l'interface utilisateur au sein du volet Visualisation. Cette commande dispose d'un raccourci clavier : Ctrl+v.
  • Supprimer : permet d'effectuer les opérations de suppression standard, dans le cadre des éléments de l'interface utilisateur au sein du volet Visualisation. Cette commande dispose d'un raccourci clavier : Suppr.

Commandes du menu Édition

      Commandes du menu Affichage

Le menu Affichage dispose de cinq commandes :

  • Actualiser : permet d'actualiser les différents objets et volets dans la fenêtre du Concepteur. Plus important encore, cette option permet de réinitialiser la valeur des propriétés et des variables générales du gadget, de sorte que n'importe quel code "scope" général puisse être exécuté depuis le début. Cette option permet en fait de réinitialiser le gadget, ce qui peut se révéler très utile lorsque vous le testez. Cette commande dispose d'un raccourci clavier : F5.
  • Onglet suivant : permet de passer à l'onglet qui se trouve à droite de l'onglet actuellement sélectionné (haut de la fenêtre). Si c'est le dernier onglet qui est actuellement sélectionné, le système repasse alors au premier onglet. Cette commande dispose d'un raccourci clavier : Ctrl+TAB.
  • Onglet précédent : permet de passer à l'onglet qui se trouve à gauche de l'onglet actuellement sélectionné. Si c'est le premier onglet qui est actuellement sélectionné, le système repasse alors au dernier onglet. Cette commande dispose d'un raccourci clavier : Ctrl+Maj+TAB.
  • Console de débogage : permet d'ouvrir une console de débogage au bas de la fenêtre du Concepteur. Celle-ci occupe alors l'espace précédemment utilisé par le contenu habituel de la fenêtre. Vous pouvez redimensionner la fenêtre afin de restaurer le format des autres informations. En fonction de la case à cocher qui est activée, un message de débogage, d'information, d'avertissement et/ou d'erreur dans le cadre de l'aperçu/exécution de votre gadget, s'affiche dans cette zone. Vous pouvez également décider si les messages doivent inclure ou non le moment où ils doivent se produire. Pour masquer la Console de débogage, cliquez une nouvelle fois sur l'élément du menu Console de débogage.
  • Fenêtre d'aperçu : permet de modifier le volet Visualisation de sorte qu'il affiche votre gadget en mode exécution, afin que vous puissiez tester l'interface utilisateur et la voir fonctionner. Vous pouvez aussi cliquer sur l'onglet en haut de la fenêtre Aperçu.

Commandes du menu Affichage

      Commandes du menu Projet

Le menu Projet dispose de trois commandes :

  • Paramètres : permet d'afficher la boîte de dialogue Paramètres du projet. Cette commande dispose d'un raccourci clavier : F3.
  • Ajouter des options d'affichage : permet d'ajouter un fichier options.xml au projet et un onglet options.xml en haut de la fenêtre. La commande Ajouter des options d'affichage est alors grisée car vous ne pouvez définir qu'un seul fichier options.xml par projet. Une fois que vous avez cliqué sur cette commande, vous devez créer et tester la vue "options", ainsi que son interface utilisateur, de la même manière que pour la vue principale.
  • Compiler l'ensemble : permet de compresser les fichiers de votre gadget et de les insérer dans un fichier Project_Name.gg afin de pouvoir le distribuer. Cette commande dispose d'un raccourci clavier : F7.

Commandes du menu Projet

      Commandes du menu Aide

Le menu Aide dispose de deux commandes :

  • Guide utilisateur : permet d'ouvrir ce document dans une fenêtre de navigateur.
  • À propos/font> : affiche une fenêtre popup présentant des informations limitées sur le Concepteur.

Commandes du menu Aide


Communication entre les gadgets de la barre latérale

Les gadgets de la barre latérale peuvent communiquer avec des gadgets de la barre latérale sur d'autres ordinateurs, si les conditions suivantes sont respectées :

  • Les gadgets doivent être identiques. Un gadget Jeu de Morpion peut communiquer avec un autre gadget Jeu de Morpion mais il ne peut pas communiquer avec un gadget Bloc-notes ou vice-versa.
  • Tous les utilisateurs de ces gadgets pour lesquels une communication est établie doivent être connectés à Google Talk.

Google Talk sert de support de communication pour les gadgets de la barre latérale. Lorsqu'un utilisateur est connecté à Google Talk, un gadget peut obtenir la liste des amis Google Talk de ce dernier qui sont actuellement en ligne. Une fois cette liste obtenue, un gadget peut envoyer et recevoir des données émanant du même gadget qui est exécuté sur l'ordinateur d'un ami en ligne. Si cet ami n'a pas installé la barre latérale, le gadget peut alors lui envoyer à la place un message texte.

En ajoutant une fonctionnalité de communication à un gadget faisant appel à un script, vous utilisez la variable globale GoogleTalk à la fois pour envoyer des données et pour définir la fonction de gestionnaire appelée lorsque le gadget reçoit des données.

La première étape dans le cadre de l'envoi des données vise à référencer la propriété friends de GoogleTalk. Vous obtenez alors un tableau des objets friend qui se compose de vos amis Google Talk en ligne.

Un objet friend est doté de cinq propriétés :

  • name : le nom qui s'affiche dans Google Talk.
  • user_id: l'ID utilisateur Google Talk, transmis en tant que paramètre du destinataire des données/du message aux méthodes d'envoi des données/du message.
  • email_address : l'adresse e-mail d'un ami.
  • has_sidebar : l'indicateur booléen qui signale si l'ami concerné a installé une barre latérale. Cette propriété doit être activée avant tout essai d'envoi de données vers une barre latérale qui n'existe peut-être pas.
  • status : disponibilité Google Talk de l'ami concerné : En ligne (0), Inactif (1) Ne pas déranger (2).

Une fois que le script dispose du tableau de vos amis Google Talk, il leur envoie les données via l'une de ces deux méthodes :

  • SendTalkData (friend_id, données) : envoie la chaîne de données (longueur maximale des caractères : 2 Ko) à l'ami identifié par la barre latérale de friend_id. Plus précisément, cette méthode envoie la chaîne au même gadget qui se trouve dans la barre latérale de l'ami depuis laquelle l'appel de la méthode a été lancé.
  • SendTalkText(friend_id, message) : envoie un message texte (d'un poids maximum de 2 Ko) à l'utilisateur de Google Talk à l'aide defriend_id. Cette méthode est, en général, utilisée lorsque votre ami n'a pas installé la barre latérale.

Pour recevoir des données, vous devez associer une fonction capable de gérer celles-ci avec le gestionnaire de fonction onReceiveTalkData de GoogleTalk. La signature de la fonction doit ressembler à ceci : name(friend_object, data_string). Cette fonction sera appelée chaque fois que votre gadget reçoit des données. Par conséquent, rédigez-la de sorte qu'elle puisse traiter tout message qu'un autre gadget est susceptible d'envoyer.

Les gadgets faisant appel à un script qui utilisent l'API de communication ne doivent pas exécuter les données qu'ils reçoivent, en appelant, par exemple, la fonction eval(). Il s'agit là d'un problème sérieux car un utilisateur peu scrupuleux peut modifier le gadget et envoyer un script qui sera exécuté sur l'ordinateur d'un ami. Ce script sera alors exécuté dans le cadre de privilèges au niveau local et il aura donc accès aux ressources et aux fichiers locaux. Afin d'éviter tout risque de ce type, les appels eval() sont vérifiés afin de s'assurer qu'ils n'examinent pas les données reçues.

Pour obtenir un exemple de communication entre gadgets, consultez l'exemple de code du Jeu de Morpion dans le kit de développement (SDK).



Consignes relatives à l'interface utilisateur et sa convivialité

Lors de la conception de votre gadget, ne perdez pas de vue les principes généraux suivants :

  • Créez des gadgets simples, clairs et faciles à utiliser.

    La zone allouée à la barre latérale est limitée. Par conséquent, utilisez uniquement l'espace dont vous avez réellement besoin pour afficher vos informations. Les palettes de couleurs simples offrent un affichage plus clair et réduisent tout risque de conflit esthétique avec les autres gadgets.

  • Testez la facilité d'utilisation du gadget lors de son développement.

    Faites tester votre gadget par d'autres utilisateurs lorsque vous développez ses fonctionnalités. Remaniez les aspects de l'interface utilisateur qui vous semblent complexes ou difficiles à exploiter. Veillez, en particulier, à ce que le contenu du menu Aide soit parfaitement clair, utile et exhaustif.

Les utilisateurs s'attendent à ce que les interactions avec les gadgets de la barre latérale soient cohérentes d'un gadget à l'autre. Les sections suivantes visent à présenter les différentes actions et signaux visuels communs pour tous les gadgets de la barre latérale.



      Conception générale

Votre gadget doit fournir un maximum d'alternatives au niveau des actions et des informations. Plus précisément :

  • il doit proposer une alternative clavier et souris aux commandes du gadget, notamment un raccourci clavier pour chaque commande du menu ;
  • il doit prendre en charge les info-bulles ;
  • il doit disposer, le cas échéant, d'un panneau Vue détaillée, ainsi que d'un menu contextuel des actions disponibles, accessible à l'aide du bouton droit de la souris.



      Entrée souris

Comme les utilisateurs interagissent avec la plupart des gadgets via la souris, l'interface utilisateur associée à l'entrée souris doit offrir un niveau de cohérence particulièrement élevé au sein de la barre latérale afin d'éviter toute confusion. Les signaux visuels suivants indiquent à l'utilisateur le type de clic que les trois catégories principales d'élément de panneau prennent en charge.

  • Éléments : permet d' afficher le contenu principal du gadget, par exemple les articles dans un gadget "actualités".
    • Simple clic : pour sélectionner un élément et ouvrir sa vue détaillée.
    • Double clic : pour ouvrir l'élément dans une nouvelle fenêtre d'application et le sélectionner aussi dans la barre latérale.
    • Survol du curseur : pour mettre en évidence l'élément de manière temporaire.

  • Applications pratiques (widgets) : elles effectuent une action lorsqu'on clique dessus. Citons, par exemple, les boutons, les cases à cocher, les étoiles, etc.
    • Clic simple uniquement ! Les double-clics servent à ouvrir les éléments.
    • Les états survol du curseur et clic de souris sont différents par rapport à l'état "normal".
    • Leur aspect doit indiquer qu'il est possible de cliquer dessus, comme lorsqu'on utilise une illustration avec des effets d'ombrage en 3D.
    • Tout texte utilisé également comme une application pratique (widget) doit pour se différentier d'un texte normal, respecter ces deux conditions :
      • il doit afficher une icône à côté du texte sur lequel il est possible de cliquer (voir l'exemple du bouton "Supprimer" ci-dessous) ;
      • son état "survol du curseur" doit refléter le fait qu'il est possible de cliquer dessus ou il doit revêtir l'aspect d'un bouton.
    • Les applications pratiques (widgets) ne constituent pas des éléments ou des parties d'élément. Le fait de cliquer sur une application pratique n'ouvre pas la vue détaillée d'un élément.
    • Conférez la même présentation de bouton à travers la barre latérale en utilisant la méthode DrawItemBackground (définie avec différents indicateurs) dans le cadre de votre texte et de vos illustrations.
    • Exemples d'applications pratiques :
        état normal survol du curseur clic de souris
      case à cocher
      (gadget tâche à effectuer)
      case à cocher normale souris sur la case à cocher clic sur la case à cocher
      bouton "Supprimer"
      (vue détaillée)
      bouton souris sur le bouton clic sur le bouton
  • Indicateurs d'états : icônes ou illustrations associées à des informations secondaires.
    • S'ils font partie d'un élément, ils héritent de tous les comportements de la souris de l'élément.
    • L'illustration ne se modifie pas au passage de la souris ou lors d'un clic de la souris car il est en général impossible de cliquer dessus.
    • Exemples d'états (lune associée aux résultats "après Bourse", activité du réseau, nuages pour la météo) :



Affichage

      Illustrations et icônes

  • Vous devez fournir une icône pour votre gadget dans deux formats différents. Cette icône doit être compréhensible pour tous et cohérente avec les fonctionnalités du gadget.

    • 12 x 12 pixels : elle apparaît dans la barre des titres du gadget.

    • 32 x 32 pixels : elle s'affiche dans la boîte de dialogue à propos du gadget et dans l'interface utilisateur des Alertes (si elle est prise en charge par votre gadget).

  • Les icônes dans le gadget doivent présenter un format de 12 x 12 pixels. Utilisez une forme et une palette de couleurs simples, en raison de leur petite taille. Les utilisateurs pourront aussi identifier le gadget plus rapidement.

  • Les icônes suivantes (format 12 x 12 pixels) sont utilisées dans l'ensemble par défaut des gadgets de la barre latérale. Le style de vos icônes doit être identique à celles-ci. Elles présentent une forme arrondie et la plupart se composent d'une seule couleur qui se décline en différentes nuances. L'image est une représentation plate des éléments en deux dimensions au sein du gadget. Le bord de chaque icône présente une épaisseur de 1 pixel, dans une nuance de sa couleur principale.


      Couleurs


  • Utilisez les couleurs avec modération. Si une nuance de gris peut convenir, optez pour cette solution.

  • N'utilisez pas de couleurs trop lumineuses, ou des combinaisons qui offrent un contraste très élevé ou très faible. Veillez à ne pas proposer une association de couleurs susceptible de générer une fatigue oculaire du lecteur. Exemple : l'image de gauche illustre une bonne utilisation des couleurs, tandis que celle de droite est plus difficile à lire.

  • N'exploitez pas les couleurs pour mettre en exergue des différences, les utilisateurs daltoniens seraient alors gênés dans l'interprétation de vos illustrations. Cet exemple illustre l'orientation des variations de cours à la fois par la couleur (rouge/bleu) et par le texte (+/-).


      Texte

  • La taille de la police et la police du système indiquées par l'utilisateur sont aussi utilisées par la barre latérale pour afficher son texte.

  • Le texte normal s'affiche en noir, tandis que le texte moins important apparaît en bleu marine [#224499 ou RVB (34, 68, 153)] ou en gris [#666666 ou RVB (102, 102, 102)].

  • Évitez tout texte en gras, si cela est possible, car il se démarquerait de manière excessive par rapport au reste de la barre latérale.


Mise en forme et présentation
Les gadgets de la barre latérale peuvent s'afficher sous quatre vues différentes : ordinaire, réduite, développée et détaillée.
  • Vue ordinaire : apparence normale.

    Si vous disposez d'une liste d'éléments, par exemple, des extraits du Web, vous pouvez utiliser le format de liste fourni par l'API. Si vous affichez uniquement un élément, par exemple une photo, utilisez le format de liste à un élément. Un simple coup d'œil au contenu de cette vue doit permettre d'identifier clairement la finalité de votre gadget.

    Souvenez-vous que vous pouvez afficher plus ou moins d'informations en fonction de la largeur de votre barre latérale. Évitez au maximum les barres de défilement et proposez à la place la vue développée d'un élément.

    Essayez de représenter clairement et visuellement le type d'élément qu'il constitue. Par exemple, les éléments de fichier doivent être accompagnés de l'icône "type de fichier". Les résumés d'un corps de texte volumineux, par exemple, les e-mails ou les pages Web, doivent afficher le titre dans la première ligne ainsi que la date et la source de l'élément.

    vue ordinaire du gadget

  • Vue réduite : affichage de la barre de titre uniquement.

    Normalement, la barre de titre affiche simplement l'icône et le titre de votre gadget. À la place du titre, vous pouvez aussi opter pour l'affichage l'un après l'autre des éléments du gadget, sous une forme abrégée, par exemple vos actions et leur cours.

    vue réduite du gadget

  • Vue développée : vue développée au maximum qui s'affiche à côté de la barre latérale.

    En général, elle est utilisée pour afficher la liste complète de tous les éléments du gadget. Elle est dotée d'une barre de défilement verticale si de nombreux éléments doivent être affichés.

    vue développée du gadget

  • Vue détaillée : présente les détails d'un élément donné du gadget.

    Cette vue peut être lancée depuis les vues normales et développées d'un gadget en cliquant une fois sur un élément. Elle permet d'afficher toutes les informations disponibles le concernant.

    Le fait de cliquer sur le titre d'un élément lance ce dernier dans une application pertinente, par exemple, l'ouverture d'une page Web dans un navigateur.

    vue détaillée d'un élémentvue détaillée d'un élément

Internationalisation

Vous devez développer votre gadget de sorte que son texte et ses libellés puissent apparaître dans différentes langues, même si vous n'êtes pas en mesure de fournir un texte dans une autre langue. À terme, une autre personne se proposera peut-être de le faire à votre place. Vous pouvez aussi fournir des images, des présentations ou même des scripts différents en fonction de la langue de l'utilisateur.

Examinons tout d'abord les langues. Pour prendre en charge plusieurs langues, toutes les chaînes propre à une langue qui seront visibles dans l'interface utilisateur de votre gadget doivent être insérées dans un fichier intitulé strings.xml, qui est lui-même inclus dans un sous-répertoire qui porte le nom de l'identifiant de langue approprié. Ce fichier contient des variables pour les chaînes de caractères dans une langue donnée. Dans le code et la définition de votre gadget, utilisez ces variables à la place des chaînes de langue. Par exemple, le fichier français strings.xml de l'expression "Bonjour à tous" se compose comme suit :


<strings>

  <strTitle>"Bonjour à tous !"</strTitle> 
  <strHello>"Bonjour à tous !"</strHello> 
  <strSnippet>Informations relatives à l'élément.</strSnippet> 
  <strAboutText>
	"Bonjour à tous !" plugin. La notice de copyright doit être insérée ici. Une description
	plus précise doit être ajoutée ici
	</strAboutText> 
  <strDescription>Dit "Bonjour à tous !"</strDescription> 
  </strings>

    

Par conséquent, vous devez définir, dans le code de script du gadget "Bonjour à tous", une propriété caption pour le titre "Bonjour à tous !" de la manière suivante :
view.caption = strTitle;
Vous devez définir, dans vos fichiers XML ou .gmanifest, le texte de la rubrique "À propos", de la manière suivante :
<aboutText>&strAboutText</aboutText>

Notez que, dans le code, vous utilisez uniquement le nom de l'élément du fichier strings.xml. Dans les fichiers XML, vous devez faire précéder le nom de l'élément par le symbole &.

Si vous écrivez votre gadget de sorte qu'il dispose des versions anglaise et française, vos fichiers doivent être insérés dans l'arborescence suivante :


  <GD dir>/Plugins/YourGadget
                     |
                     |---- gadget.js
                     |
                     |---- gadget.gif
                     |
                     |---- 1033 (Identifiant de langue pour l'anglais (États-Unis).)
                     |      |
                     |      `-- strings.xml
                     |
                     `---- 1036 (Identifiant de langue pour le français.)
                            |
                            `-- strings.xml
     

La barre latérale recherche d'abord un répertoire doté du même identifiant de langue que le système actuel. S'il en existe un, il charge le fichier strings.xml de ce répertoire. S'il ne trouve pas ce fichier, il charge par défaut le fichier strings.xml du répertoire 1033 (anglais (États-Unis)), s'il existe.

De même, vous pouvez désormais ajouter des images, des marquages, des scripts, etc. dans les dossiers de localisation et dans la barre latérale pour essayer de les charger à l'aide des règles décrites ci-dessus. Par conséquent, si vous avez, par exemple, un gadget qui nécessite l'emploi d'une image différente en fonction de la langue locale, insérez :
<img src="some_image.png"/>

La barre latérale essaiera d'abord de charger some_image.png. Ensuite, si la langue de votre système est le français, il recherchera le répertoire de localisation français (1036\some_image.png) avant d'identifier finalement le répertoire anglais (1033\some_image.png).

Vous pouvez choisir d'insérer du contenu dans un répertoire de localisation à la place du répertoire principal, notamment :

  • main.xml : si vous souhaitez disposer d'une présentation différente pour chaque langue.
  • options.xml : si vous souhaitez disposer d'une présentation différente pour chaque langue.
  • anything.js : si vous souhaitez disposer d'un script différent pour chaque langue.

Pour créer un gadget prenant en charge le comportement par défaut dans la plupart des cas sauf dans le cadre de certaines langues, vous pouvez :

  • insérer le fichier gadget.xml dans le dossier racine du fichier gadget.gg ;
  • placer le reste du contenu dans le dossier 1033\ du fichier gadget.gg.
  • placer le contenu qui doit être remplacé pour les langues spécifiques dans le dossier de langue spécifique ;

Cliquez sur ce lien pour consulter la liste de tous les numéros d'identification de langue.


API


Les objets

Cette section décrit les différents objets faisant appel à un script dans l'API Google Gadgets, ainsi que les propriétés, méthodes et événements qui leur sont associés. Notez que la plupart des objets héritent des propriétés, des méthodes et des événements de l'objet basicElement.

En outre, lorsqu'on dit d'une méthode qu'elle renvoie un élément, cela signifie qu'elle renvoie un élément fourni dans la définition XML du gadget, qui descend de l'objet basicElement.

gadget.debug
Présente les API utiles dans le cadre du développement et du débogage des gadgets. Pour lancer le mode débogage, décompressez votre gadget et, à partir du fichier dans lequel vous l'avez décompressé, double-cliquez sur le fichier gadget.gmanifest.
Méthodes
Nom et arguments Description Valeur renvoyée
error(message chaîne) Lorsque le gadget est exécuté en mode de débogage, la méthode affiche la chaîne de caractères du message dans la console de débogage sous la forme d'une erreur. nulle
trace(message chaîne) Lorsque le gadget est exécuté en mode de débogage, la méthode affiche la chaîne de caractères du message dans la console de débogage. nulle
warning(message chaîne) Lorsque le gadget est exécuté en mode de débogage, la méthode affiche la chaîne de caractères du message dans la console de débogage sous la forme d'un avertissement. nulle


gadget.storage
Permet d'accéder au contenu du package du gadget.
Méthodes
Nom et arguments Description Valeur renvoyée
extract(filename chaîne) Extrait un fichier du package du gadget vers le dossier "Temp" et renvoie le chemin d'accès complet menant au fichier extrait. chaîne de caractères
openStream(filename chaîne) Ouvre un fichier du package du gadget et renvoie le contenu sous la forme d'un flux. flux
openText(filename chaîne) Permet d'ouvrir un fichier du package du gadget et de renvoyer le contenu sous la forme d'une chaîne de caractères. chaîne de caractères


view
Remarque : À la différence de ses objets enfants/de contenu, l'objet view n'hérite pas de l'objet basicElement.
Vous devez définir un objet view, dans un fichier séparé, pour l'interface utilisateur de chaque volet de votre gadget.
Propriétés
Nom Description Type Lecture/écriture
caption Titre de cette vue. Par défaut, il s'affiche lorsqu'un gadget est en mode développé/flottant mais il ne s'affiche pas lorsque le gadget est dans la barre latérale. Reportez-vous également à la propriété showCaptionAlways. chaîne de caractères Lecture - écriture
children Renvoie une collection qui contient les enfants immédiats de l'élément "view". Ces enfants descendent tous de l'objet basicElement. Accessible uniquement via des scripts, et non à partir des définitions XML. éléments Lecture seule
event La manière dont l'objet event est présenté aux scripts pour les gestionnaires d'événements. événement Lu
height Définit ou renvoie la hauteur de cette vue (en pixels). nombre entier Lecture - écriture
width définit ou renvoie la largeur de cette vue (en pixels). nombre entier Lecture - écriture
resizable Lorsque la valeur est définie sur true, l'utilisateur peut redimensionner la vue. booléen Lecture - écriture
showCaptionAlways Lorsque la valeur est définie sur true, la barre latérale affiche toujours le titre (tel qu'il apparaît dans la propriété caption) pour cette vue. Par défaut, ou si cette valeur est définie sur false, le titre ne s'affiche pas lorsque le gadget est inclus dans la barre latérale ou qu'il est exécuté en mode développé ou flottant. booléen Lecture - écriture
Méthodes
Nom et arguments Description Valeur renvoyée
void alert(message chaîne) Affiche une zone de message contenant la chaîne de caractères du message. nulle
element appendElement(chaîne xml) Analyse la définition de l'élément fourni, au format XML, et ajoute cet élément de sorte qu'il s'apparente au dernier enfant de cette vue. Le nouvel élément.
integer beginAnimation(script chaîne, startValue nombre entier, endValue nombre entier, duration nombre entier) Lance le temporisateur d'une animation. Le temporisateur fonctionne pour duration exprimée en millisecondes. Le script est exécuté régulièrement au cours de cette période en présentant une valeur comprise entre la valeur de départ "StartValue" et la valeur de fin "EndValue". Un identifiant qui peut être utilisé pour interrompre l'animation.
Remarque : Le nombre de fois que la fonction "Callback" est appelée dépend des performances et de l'état de charge actuel du système. Sa vitesse peut atteindre jusqu'à 100 images par seconde.
void cancelAnimation(Token nombre entier) Interrompt l'animation qui s'affiche actuellement. Le jeton correspond à l'identifiant renvoyé par beginAnimation. nulle
void clearInterval(Token nombre entier) Annule un intervalle ou un délai d'attente. nulle
boolean confirm(message chaîne) Affiche une zone de confirmation contenant la chaîne de caractères du message. Renvoie la valeur true si vous appuyez sur OK. Dans le cas contraire, c'est la valeur false qui est renvoyée. booléen
element insertElement(chaîne xml, élément InsertBefore) Analyse la chaîne XML fournie et insère l'élément immédiatement avant l'élément InsertBefore. Le nouvel élément.
void removeElement(élément Item) Supprime l'élément visé. nulle
void resizeBy(width nombre entier, height nombre entier) Modifie la taille de la vue par les valeurs précisées pour la largeur et la hauteur, sur la base de la largeur et de la hauteur de la vue à l'écran. Ces valeurs sont exprimées en pixels. nulle
void resizeTo(width nombre entier, height nombre entier) Modifie la taille de la vue pour obtenir les valeurs précisées pour la largeur et la hauteur (en pixels). nulle
integer setTimeout(Script chaîne, Duration nombre entier) Crée un temporisateur destiné à être lancé une seule fois. Le script est exécuté une fois, au terme de la durée (millisecondes). Un jeton qui peut être utilisé pour annuler le délai d'attente.
integer setInterval (Script chaîne, Duration nombre entier) <