Une nouvelle fenêtre et son ajout sur une scene

Dans ce tutoriel, on va partir sur un plugin simple que j'ai créé vite fait, afin de montrer comment créer une nouvelle fenêtre et de l'ajouter sur une scene.

Voici le code javascript :

Code:

//=============================================================================
// HorlogeTitle.js
//=============================================================================

/*:
 * @plugindesc Plugin permettant d'afficher une horloge sur l'écran titre
 * @author Tonyryu
 *
 * @param Position
 * @desc Position de la fenêtre (1 : haut gauche, 2 : haut droite)
 * @default 1
 *
 *
 * @help Rien de bien méchant pour commencer, création d'une nouvelle fenêtre et surcharge de la Scene_Title.
 */
 
 (function() {

    var parameters = PluginManager.parameters('HorlogeTitle');
    var position = Number(parameters['Position'] || 1);

    /**********************************************************************
    *----------------------------------------------------------------------
    * Création d'une nouvelle "classe" Window_Horloge
    *  hérite de la classe Window_Base
    *----------------------------------------------------------------------
    **********************************************************************/
    function Window_Horloge() {
        this.initialize.apply(this, arguments);
    }

    Window_Horloge.prototype = Object.create(Window_Base.prototype);
    Window_Horloge.prototype.constructor = Window_Horloge;
    
    /**********************************************************************
    * Méthode : initialize
    * Fonction : Initialisation de la "classe" Window_Horloge
    * Params : --
    **********************************************************************/
    Window_Horloge.prototype.initialize = function() {
        var width = this.windowWidth();
        var height = this.windowHeight();
        var x = 0;
        if(position === 2)
          var x = Graphics.boxWidth - width;
        
        Window_Base.prototype.initialize.call(this, x, 0, width, height);

        this._heure = this.value();
        this.refresh();
    };

    /**********************************************************************
    * Méthode : windowWidth
    * Fonction : Retourne la largeur de la fenêtre
    * Params : --
    **********************************************************************/
    Window_Horloge.prototype.windowWidth = function() {
        return 180;
    };

    /**********************************************************************
    * Méthode : windowHeight
    * Fonction : Retourne la hauteur de la fenêtre
    * Params : --
    **********************************************************************/
    Window_Horloge.prototype.windowHeight = function() {
        return this.fittingHeight(1);
    };
    
    /**********************************************************************
    * Méthode : refresh
    * Fonction : permet de construire l'affichage de l'heure
    * Params : --
    **********************************************************************/
    Window_Horloge.prototype.refresh = function() {
        var x = this.textPadding();
        var width = this.contents.width - this.textPadding() * 2;
        this.contents.clear();
        this.drawText(this._heure, x, 0, width);
    };
    
    /**********************************************************************
    * Méthode : update
    * Fonction : Vérifie si l'heure a changé pour éventuellement rafraichir
    * Params : --
    **********************************************************************/
    Window_Horloge.prototype.update = function() {
        Window_Base.prototype.update.call(this);
        var heure = this.value();
        if(heure !== this._heure){
            this.refresh();
            this._heure = heure;
        }
    }

    /**********************************************************************
    * Méthode : value
    * Fonction : Construit la chaine d'heure à afficher
    * Params : --
    **********************************************************************/
    Window_Horloge.prototype.value = function() {
        var value = '';
        var date = new Date;
        var hour = date.getHours();
        if(hour < 10)
            value = '0';
        value += hour + ':';
        var minutes = date.getMinutes();
        if(minutes < 10)
            value += '0';
        value += minutes + ':';
        var seconds = date.getSeconds();
        if(seconds < 10)
            value += '0';
        value += seconds;

        return value;
    };
    

    /**********************************************************************
    *----------------------------------------------------------------------
    * Modification de la "classe" Scene_Title
    *----------------------------------------------------------------------
    **********************************************************************/
    /**********************************************************************
    * Méthode : create (surcharge)
    * Fonction : Ajoute l'appel à la création de la fenêtre h
    * Params : --
    **********************************************************************/
    var _Scene_Title_create = Scene_Title.prototype.create;
    Scene_Title.prototype.create = function() {
        _Scene_Title_create.call(this);
        this.createHorlogeWindow();
    }
    
    /**********************************************************************
    * Méthode : createHorlogeWindow
    * Fonction : ajout de la fenêtre Window_Horloge sur Scene_Title
    * Params : --
    **********************************************************************/
    Scene_Title.prototype.createHorlogeWindow = function() {
        this._horlogeWindow = new Window_Horloge();
        this.addWindow(this._horlogeWindow);
    }
    
})();


Pour l'entête du plugin, tout est déjà dit ici : https://rpgmakervx.1fr1.net/t19009-creer-son-propre-plugin

Et maintenant, entrons directement dans le vif du sujet, la création d'une nouvelle "classe". Pourquoi je met classe entre guillemets?? Alors, il faut savoir que cette notion en JavaScript, est pour le moins ambigu.

Pour les extraits de code, j'ai utilisé des citations, afins de pouvoir coloriser certains bout de code, donc on perd les indentations, mais c'est pas trop grave, car les bout de code sont cours.

Donc pour créer un nouveau modèle de fenêtre, voila comment cela s'écrit :

function Window_Horloge() {
   this.initialize.apply(this, arguments);
}

Et pour réaliser l'héritage :

Window_Horloge.prototype = Object.create(Window_Base.prototype);
Window_Horloge.prototype.constructor = Window_Horloge;

Je pourrais vous expliquer en détail chaque instruction, mais il est fort probable que je vous perde en route, et je ne pense pas que ce soit judicieux. Mais, si vous êtes curieux, vous trouverez nombres de sites dédiés au javascript qui répondront à vos questions.

Donc en rouge, le nom de la classe que l'on a créé, et en orange, la classe dont on hérite

Mais c'est quoi this??? ce mot clef fait référence à soit même... Comment ça, c'est pas plus clair??!! En bref, je suis une fonction d'un objet, this, fait référence à cette objet, et permet d'accéder aux autres variables de cette objet, des fonctions sont considérées comme telle.

un prototype de fonction sur notre modèle (une méthode de classe) doit obligatoirement être définit, car à l'instanciation, il sera obligatoirement appelé. C'est initialize :

Window_Horloge.prototype.initialize = function() {
 var width = this.windowWidth();
 var height = this.windowHeight();
 var x = 0;
 if(position === 2)
   var x = Graphics.boxWidth - width;
       
 Window_Base.prototype.initialize.call(this, x, 0, width, height);

 this._heure = this.value();
 this.refresh();
};

Petite explication des couleurs :
- rouge : d'autres méthodes de notre classe Window_Horloge
- orange : une propriété de classe, le '_' devant le nom est une convention pour les reconnaître.
- violet : un appel à une méthode de la classe mère, on utilise cette syntaxe, car la fonction initialize existe déjà sur notre this (classe Window_Horloge), il faut éviter de s'appeler soit même.
- gras bleu : appel d'une fonction du "module" Graphics (qui est en fait un Singleton, (un objet static), non instantiable, etc...) boxWidth retourne la largeur de la fenêtre de jeu

En gros, ça réalise toutes les actions d'initialisation de la fenêtre. Si le paramètre de position vaut 2, alors la position x de la fenêtre est calée sur le bord droite de la fenêtre de jeu.

Méthode windowWidth:

Window_Horloge.prototype.windowWidth = function() {
 return 180;
};

Pas grand chose à dire, ça retourne la valeur 180

Méthode windowHeight:

Window_Horloge.prototype.windowHeight = function() {
 return this.fittingHeight(1);
};

Retourne la valeur qui est elle même retournée par la fonction fittingHeight, fourni par la classe parente. Cette fonction retourne une dimension correspondant à la hauteur d'une ligne d'écriture, fois le nombre passé en paramètre.

Méthode refresh:

Window_Horloge.prototype.refresh = function() {
 var x = this.textPadding();
 var width = this.contents.width - this.textPadding() * 2;
 this.contents.clear();
 this.drawText(this._heure, x, 0, width);
};

Par convention, la méthode refresh permet de réaliser le contenu affiché dans la fenêtre. Quelques explications sur les fonctions utilisées :
- this.textPadding : retourne le padding (décalage) du texte, définit dans Window_Base, retourne 6 par défaut.
- this.contents.width : contents est le contenu affiché (en gros le tableau de pixel), width la largeur.
- this.contents.clear : efface le contenu
- this.drawText : écrit un texte sur le contenu

Méthode update:

Window_Horloge.prototype.update = function() {
 Window_Base.prototype.update.call(this);
 var heure = this.value();
 if(heure !== this._heure){
   this.refresh();
   this._heure = heure;
 }
}

Il y a quelque chose de très important à savoir sur la fonction update, c'est qu'elle est appelée automatiquement à chaque cycle par le SceneManager. Du coup, j'y ai ajouté la vérification du changement d'heure pour rafraichir le contenu de la fenêtre en cas de changement. Attention, et j'insiste très fortement sur cette notion, il est très important de ne pas rafraichir le contenu d'une fenêtre à chaque cycle, car c'est très consommateur en ressource.
On appel également la méthode update de la classe mère au début.

Méthode value :

Window_Horloge.prototype.value = function() {
 var value = '';
 var date = new Date;
 var hour = date.getHours();
 if(hour < 10)
   value = '0';
 value += hour + ':';
 var minutes = date.getMinutes();
 if(minutes < 10)
   value += '0';
 value += minutes + ':';
 var seconds = date.getSeconds();
 if(seconds < 10)
   value += '0';
 value += seconds;

 return value;
};

Cette fonction retourne l'heure actuelle formatée de cette manière : HH:MIN:SEC. Pour se faire, on utilise une classe standard Javascript : Date : http://www.w3schools.com/jsref/jsref_obj_date.asp


Voila, la nouvelle fenêtre est complètement créée, il faut maintenant l'ajouter à une scene. Le plus simple et le plus rapidement visible, c'est directement sur la Scene_Title.

Pour ce faire, il faut surcharger une méthode de la classe Scene_Title, create pour être précis, afin de la remplacer pour pouvoir la rappeler. Hummm, ce n'est pas très clair, avec le code, ce sera limpide :

var _Scene_Title_create = Scene_Title.prototype.create;
 Scene_Title.prototype.create = function() {
 _Scene_Title_create.call(this);
 this.createHorlogeWindow();
}

La création de la variable _Scene_Title_create permet de sauvegarder le point d'entrée de la méthode create de Scene_Title, on peut la nommer comme on veut, mais il faut essayer de garder un nom correspondant au nom d'origine de la méthode sauvegardée, sinon ça devient compliqué de s'y retrouver.
Du coup, dans la méthode create que l'on recré, et bien on appel la méthode sauvegardée pour conserver le fonctionnement original de la méthode create de Scene_Title, et on ajoute un appel à une nouvelle méthode que l'on va ajouter dans la classe Scene_Title

Méthode createHorlogeWindow:

Scene_Title.prototype.createHorlogeWindow = function() {
 this._horlogeWindow = new Window_Horloge();
this.addWindow(this._horlogeWindow);
}

Cette méthode permet de créer une instance de notre classe Window_Horloge via new et de stocker cette instance dans une variable de classe this._horlogeWindow. Ensuite on ajoute cette instance, dans le gestionnaire de fenêtre de la scene, via addWindow.



Voila qui termine l'explication. J'ai essayé d'être le plus clair possible afin d'aborder des notions plus ou moins complexes, tout en ajoutant une fonctionnalité relativement simple. Donc si vous n'avez pas compris certaine chose, ou même si des experts JavaScript veulent me corriger sur des points que je ne maitrise pas, n'hésitez pas à laisser des commentaires.

Imaginons que tu supprime la surcharge que tu cree avec "create", la fenetr ne s'afficherai pas!

Pourait tu l'appeler et la suprimer via un event avec la parti de code que a ajouter dans ton dernier sujet?

Si oui j'aimerai que tu explique comment dans le detail dans un prochain tuto car je seche sur l'ajout de commande!

Yeah it's me! The NOOB!

Oui c'est possible, mais pas en supprimant la surcharge de la fonction create de Scene_Title. Car il faut que la fenêtre soit connu de la scene pour pouvoir en gérer l'affichage.

Les fenêtres ont une propriété 'visible', qui est un booléen, vrai la fenêtre est visible, et faux, c'est le contraire.

Sauf que les événements sont géré sur la Scene_Map, et du coup, ba, on ne peux pas apliquer cette solution pour changer sa visibilité.

donc on doit cree une variable avec la valeur visible = false
pour que la fenetre ne s'affiche pas de base!
appeler la visibilité si besoin!

mais comment?
LighNox me donne des cours! un GRAND MERCI a lui !
j'ai appris grace a lui a cree une fenetre et y afficher des info!
mais je ne sait pas comment la cree sans quel sois visible!

se serai cool de donner un exemple concret et detaillé!
Apres je peu comprendre ue ca t'embete! si c le cas je ferai autrement
mais j'apprend bien mieu avec une mise en situation plutot qu'aec un exposé!
j'ai regarder les scripts itembook et enemybook mais il me depasse pour le moment
car bien trop complexe!

en tout cas merci pour tes tuto meme s il sont hors de ma portév pour le moment!

T'en fait pas, ça ne m'embête pas.

visible est déjà une propriété de Window, il n'y a pas besoin de l'ajouter, si tu veux que ta fenêtre ne soit pas visible de base, il faut simplement, mettre dans son initialize :

this.visible = false;

Tiens un bout de code très simple, toujours sur Scene_Title, cela permet d'afficher une fenêtre toute simple, lors de l'appui sur le bouton de la souris.

Code:

//=============================================================================
// TestWindowVisible.js
//=============================================================================

/*:
 * @plugindesc Plugin permettant de tester simplement la visibilité d'une fenêtre
 * @author Tonyryu
 *

 * @help
 */
 
 (function() {


    /**********************************************************************
    *----------------------------------------------------------------------
    * Création d'une nouvelle "classe" Window_Test
    *  hérite de la classe Window_Base
    *----------------------------------------------------------------------
    **********************************************************************/
    function Window_Test() {
        this.initialize.apply(this, arguments);
    }

    Window_Test.prototype = Object.create(Window_Base.prototype);
    Window_Test.prototype.constructor = Window_Test;
    
    /**********************************************************************
    * Méthode : initialize
    * Fonction : Initialisation de la "classe" Window_Test
    * Params : --
    **********************************************************************/
    Window_Test.prototype.initialize = function() {
        Window_Base.prototype.initialize.call(this, 0, 0, 100, 100);
        this.visible = false;
    };

    
    /**********************************************************************
    * Méthode : update
    * Fonction : Vérifie si le bouton de la souris est pressé
    * Params : --
    **********************************************************************/
    Window_Test.prototype.update = function() {
        Window_Base.prototype.update.call(this);
        this.visible = TouchInput.isPressed();
    };

    /**********************************************************************
    *----------------------------------------------------------------------
    * Modification de la "classe" Scene_Title
    *----------------------------------------------------------------------
    **********************************************************************/
    /**********************************************************************
    * Méthode : create (surcharge)
    * Fonction : Ajoute l'appel à la création de la fenêtre h
    * Params : --
    **********************************************************************/
    var _Scene_Title_create = Scene_Title.prototype.create;
    Scene_Title.prototype.create = function() {
        _Scene_Title_create.call(this);
        this.createTestWindow();
    };
    
    /**********************************************************************
    * Méthode : createHorlogeWindow
    * Fonction : ajout de la fenêtre Window_Horloge sur Scene_Title
    * Params : --
    **********************************************************************/
    Scene_Title.prototype.createTestWindow = function() {
        this._testWindow = new Window_Test();
        this.addWindow(this._testWindow);
    };
    
})();

Onikowai a écrit:LighNox me donne des cours! un GRAND MERCI a lui !

Il ne faut en rien exagérer x), je t'ai re-détaillé les bases de la création d'un plugin, je n'ai rien fait d'extraordinaire ^^, mais merci ^^.

Et désolé pour le show et le hide de la window j'avais pas encore regarder et aujourd'hui je n'étais pas la de la journée ^^

Je viens de tester ce petit morceau de script sur mon scène Title c'est de suite plus clair expliqué comme ça.

Juste une question comment ça se passe si je veux afficher l'horloge sur ma scene Map vu qu'elle n'est pas gérée de la même manière je ne vois pas trop comment m'y prendre pour que l'horloge reste affichée.

Tout dépend de quel bout de script tu fais allusion, celui expliqué pas à pas dans le premier post, ou celui juste au dessus en réponse à Onikawai?

Scene_Map a beaucoup de chose à gérer, et ajouter une fenêtre peut s'avérer tendu, mais dans mon topic sur l'utilisation de mes GUIs, la première partie est justement l'ajout d'une fenêtre sur Scene_Map. Essai de voir les 2 en parallèle.

Ah oui je vais faire ça je me suis dis je vais commencer avec le petit tuto de l'horloge avant de me lancer dans le hard

Pour l'instant en suivant le tutoriel sur tes Gui je n'arrive pas à afficher quoi que se soit sur ma map mais je cherche je cherche si j'y arrive pas je posterai dans le bon topic.

Encore merci pour tes tuto

Si tu commences a taper dans le dur avec JavaScript pour ton projet sous MV, je ne peux que te conseiller d'installer :
- NetBeans : https://netbeans.org/downloads/ la version HTML5, Javascript
- Chrome
- Le connecteur Netbeans sur Chrome

Et se sera beaucoup plus simple

C'est bon je suis sous Netbeans + Chrome c'est vraiment extra.

Voici le rendu de mon Hud avec ton script ça donne exactement ce que je voulais et c'est très simple à utiliser une fois avoir compris comment ça tourne.



J'ai juste une petite question, y a t'il aussi moyen d'afficher une image au passage de la souris sur un des boutons ?

Code:

(function() {

  function Window_HUD() {
    this.initialize.apply(this, arguments);
  }

  Window_HUD.prototype = Object.create(Window_Gui.prototype);
  Window_HUD.prototype.constructor = Window_HUD;

  Window_HUD.prototype.initialize = function() {
    Window_Gui.prototype.initialize.call(this, 0, 0, Graphics.width, Graphics.height);
    this.padding = 0;
    this.opacity = 0;
    this.active = true;
    this.addGui('guiFondHud', new Gui_Base({x:0, y:0, width:1366, height:768, imageUrl:'img/pictures/hud/fond.png'}));
    this.addGui('guiButtonMenu1', new Gui_Button({x:424, y:10, width:40, height:40, imageUrl:'img/pictures/hud/boutonstatut.png'}));
    this.addGui('guiButtonMenu2', new Gui_Button({x:469, y:10, width:40, height:40, imageUrl:'img/pictures/hud/boutoninventaire.png'}));
    this.addGui('guiButtonMenu3', new Gui_Button({x:514, y:10, width:40, height:40, imageUrl:'img/pictures/hud/boutongrimoire.png'}));
    this.addGui('guiButtonMenu4', new Gui_Button({x:559, y:10, width:40, height:40, imageUrl:'img/pictures/hud/boutonequip.png'}));
    this.addGui('guiButtonMenu5', new Gui_Button({x:770, y:10, width:40, height:40, imageUrl:'img/pictures/hud/boutonquete.png'}));
    this.addGui('guiButtonMenu6', new Gui_Button({x:815, y:10, width:40, height:40, imageUrl:'img/pictures/hud/boutonmetier.png'}));
    this.addGui('guiButtonMenu7', new Gui_Button({x:860, y:10, width:40, height:40, imageUrl:'img/pictures/hud/boutonhf.png'}));
    this.addGui('guiButtonMenu8', new Gui_Button({x:905, y:10, width:40, height:40, imageUrl:'img/pictures/hud/boutontalent.png'}));
    this.addGui('guiButtonMenu9', new Gui_Button({x:664, y:51, width:40, height:33, imageUrl:'img/pictures/hud/boutonend.png'}));
    http://this.addGui('guistatut', new Gui_Base({x:0, y:0, width:140, height:45, imageUrl:'img/pictures/hud/statut.png'}));
  };

  var _Scene_Map_createSpriteset = Scene_Map.prototype.createSpriteset;
  Scene_Map.prototype.createSpriteset = function() {
    _Scene_Map_createSpriteset.call(this);
    this.createWindowHud();
  };

  Scene_Map.prototype.createWindowHud = function() {
    this._onHud = false;
    this._hudWindow = new Window_HUD();
    this._hudWindow.setHandlerGui('guiFondHud', 'onrollover', this.setOnHud.bind(this, true));
    this._hudWindow.setHandlerGui('guiFondHud', 'onrollout', this.setOnHud.bind(this, false));
    this._hudWindow.setHandlerGui('guiButtonMenu1', 'onclick', this.clickBtnMenu1.bind(this));
    this._hudWindow.setHandlerGui('guiButtonMenu1', 'onrollover', this.OverStatut.bind(this));
    this._hudWindow.setHandlerGui('guiButtonMenu2', 'onclick', this.clickBtnMenu2.bind(this));
    this._hudWindow.setHandlerGui('guiButtonMenu3', 'onclick', this.clickBtnMenu3.bind(this));
    this._hudWindow.setHandlerGui('guiButtonMenu4', 'onclick', this.clickBtnMenu4.bind(this));
    this._hudWindow.setHandlerGui('guiButtonMenu5', 'onclick', this.clickBtnMenu5.bind(this));
    this._hudWindow.setHandlerGui('guiButtonMenu6', 'onclick', this.clickBtnMenu6.bind(this));
    this._hudWindow.setHandlerGui('guiButtonMenu7', 'onclick', this.clickBtnMenu7.bind(this));
    this._hudWindow.setHandlerGui('guiButtonMenu8', 'onclick', this.clickBtnMenu8.bind(this));
    this._hudWindow.setHandlerGui('guiButtonMenu9', 'onclick', this.clickBtnMenu9.bind(this));
    this.addChild(this._hudWindow);
  };
 
  var _Scene_Map_isMapTouchOk = Scene_Map.prototype.isMapTouchOk;
  Scene_Map.prototype.isMapTouchOk = function() {
    return !this._onHud && _Scene_Map_isMapTouchOk.call(this);
  };
 
  Scene_Map.prototype.setOnHud = function(pOnHud) {
    this._onHud  = pOnHud;
  };
 
  Scene_Map.prototype.clickBtnMenu1 = function() {
    SceneManager.push(Scene_Status);
  };
 
  Scene_Map.prototype.OverStatut = function() {
   
  };
 
  Scene_Map.prototype.clickBtnMenu2 = function() {
    SceneManager.push(Scene_Item);
  };
 
  Scene_Map.prototype.clickBtnMenu3 = function() {
    SceneManager.push(Scene_Skill);
  };
 
  Scene_Map.prototype.clickBtnMenu4 = function() {
    SceneManager.push(Scene_Equip);
 
  };
 
  Scene_Map.prototype.clickBtnMenu5 = function() {
    SceneManager.push(Scene_Quest);
  };
 
  Scene_Map.prototype.clickBtnMenu6 = function() {
  //métiers
  };
 
  Scene_Map.prototype.clickBtnMenu7 = function() {
  //Hauts faits 
  };
 
  Scene_Map.prototype.clickBtnMenu8 = function() {
  //Talent 
  };
 
  Scene_Map.prototype.clickBtnMenu9 = function() {
    SceneManager.push(Scene_GameEnd);
  };
})();

oui, tu ajoutes un Gui_Base avec dans ses options la propriété visible:false, et l'image que tu souhaite, et tu change sa visibilité et sa position via des fonctions attachées aux événements onrollover et onrollout des boutons :

this._hudWindow.getGui('guiImageSurBouton').setOptions({visible:true, x:30, y:40});

J'ai reçu de l'aide de Light hier soir via Teamviewer pour améliorer mon script de base.

Notamment en modifiant les ouverture des différents menus via des "case".

Du coup il a cherché un bon bout de temps pour faire ce que je voulais, on y est presque arrivé.

Merci pour l'explication, ca va bien m'aider.

oui dans la fonction onRollover et onRollout il faut que je fasse en sorte de changer la bonne image sur le bon bouton, rien de bien méchant ^^

Bon grace à Liht mon soucis est résolu

Tony je pense qu'il y a une erreur à la ligne 507 de ton plugin onfocusin -> onfocusout

D'ailleurs à quoi servent ces deux fonctions ?

Bien vue, je corrige de suite.

Ce sont des événements qui sont déclenchés en cas de gain ou perte de focus sur le champs, mais ça n'était pas géré jusqu'à ce soir. On pourra passer d'un composant à l'autre via la touche pagedown, donc prendre le focus l'un après l'autre.

A force d'étudier j'arrive même à débug ton plugin je deviens bon ....


Ok merci pour l'info.

Juste une petite question : Est il possible, via tes gui, d'afficher par exemple" la "window horloge" de ton autre tuto ?

Histoire que je me casse pas la tête pour rien

oui, via un gui_base, dans lequel tu fais un setOptions pour y changer le texte quant c'est nécessaire (heure qui change) dans l'update de la fenêtre, idem que le tuto avec l'horloge

Ok merci je vais voir ce que je peux faire.

Et promis je vais plus me tromper de topic à l'avenir... (je viens de m'en rendre compte... Horloge -> Gui.)