ntro.ca

        • Contrats de classe
        • Liens utiles
        • Calendrier
        • Calendrier groupe 2
        • Calendrier groupes 1, 3
        • Structure du cours
        • Évaluations
        • Matériel à se procurer
        • Les profs
          • Marc-Olivier Tremblay
          • Mathieu Bergeron
        • Module 1.1: installation + trier des cartes
        • Module 1.2: rappels POO
        • Module 1.3: tableau d'objets
        • Examen 1
        • Module 2.1: données JSON
        • Module 2.2: données en Java
        • Module 2.3: récursivité
        • Examen 2
        • Module 3.1: structure générique
        • Module 3.2: efficacité (1)
        • Module 3.3: efficacité (2)
        • Examen 3
        • Module 4.1: liste naïve
        • Module 4.2: liste par tableau
        • Module 4.3: liste chaînée
        • Examen 4
        • Module 5.1: mappage naïf
        • Module 5.2: mappage par hachage
        • Module 5.3: mappage par arbre
        • Examen 5
        • Équipes
          • Horaire groupe 1
          • Horaire groupe 2
          • Horaire groupe 3
          • Groupe 1
          • Groupe 2
          • Groupe 3
        • Projets vedettes 2022
        • Projets vedettes 2023
        • Projets vedettes 2024
        • Projets vedettes 2025
        • Survol
        • Structure
        • Calendrier
        • Calendrier des séances
        • Évaluations
        • Exemples de jeu
        • Exemples de pages
        • Réponses à vos questions
        • Module 1: créer le projet
        • Module 2: concevoir l'application
        • Module 3: vues NtroFx
        • Module 4: modèle et navigation
        • Module 5: ajouter le dorsal, modifier le modèle
        • Module 7: améliorer l'affichage
        • Module 8: jeu en 2d
        • Module 9: client/serveur
        • Module 10: plusieurs instances du même modèle
        • TP1
        • Examen 1
        • TP2
        • Examen 2
        • Projet de fin de session
        • Calendrier
        • Structure du cours
        • Évaluations
        • Contrat de classe
        • Le prof
        • 01: Windows et Word
          • Astuces et raccourcis
        • 02: Word
        • 03: Word
          • Exercice Word: insertion d'éléments spéciaux
          • Exercice Word: tableaux
        • 04: Word
          • Exercice Word: références
          • TP01: Word (15%)
        • 05: PowerPoint
          • TP02: PowerPoint (10%)
        • 06: Examen Word (20%)
        • 07: Excel
        • 08: Excel
        • 09: Excel
          • TP03: Excel (15%)
        • 10: Excel
        • 11: Examen Excel (20%)
        • 12: Access
        • 13: Access
        • 14: Access
        • 15: Examen Access
      • Sondage H2023 (dept. info)
      • Vision H2023 (dept. info)
      • P1) exercices interactifs de lecture
      • P2) transition Excel vers Python
        • Atelier 2: un exemple
      • Jquery
      • Jquery Ui
      • Point de vue sur l'IA
    Plusieurs files d'attente
    • Plusieurs files d’attente (une par region)
      • Les régions et les noms de région traduits
      • Ajouter une tâche du Dorsal pour initialiser les régions
      • Avec la Session, mémoriser et observer la région courante
      • Ajouter un EvtChangerRegion
      • Ajouter une tâche pour changer de région
      • Afficher les régions dans un ComboBox
      • S’assurer d’afficher la région courante (même au premier affichage)

    Plusieurs files d’attente (une par region) #

    Les régions et les noms de région traduits #

    1. Dans le paquet pong.commun.enums, ajouter Region

      public enum Region {
      
          AFRIQUE, ASIE, AMERIQUE, EUROPE;
      
      }
      
    2. Pour traduire les régions, ajouter les variables suivantes à fr.properties

      AMERIQUE=Amérique
      AFRIQUE=Afrique
      ASIE=Asie
      EUROPE=Europe
      
    3. Ajouter les variables suivantes à en.properties

      AMERIQUE=Americas
      AFRIQUE=Africa
      ASIE=Asia
      EUROPE=Europe
      

    Ajouter une tâche du Dorsal pour initialiser les régions #

    1. Le ModeleFileAttente mémorise maintenant la région et l’utilise pour les id de rendez-vous

      public class ModeleFileAttente implements Model, WatchJson, WriteObjectGraph {
      
          // ...
      
      
          // ajouter
          private Region region = null;
      
          // ...
      
      
          // ajouter
          public void initialiserRegion(Region region) {
              this.region = region;
          }
      
          // ...
      
      
          // modifier cette méthode
          private String genererIdRendezVous() {
              String idRendezVous = String.valueOf(prochainIdRendezVous);
              prochainIdRendezVous++;
      
              // ajouter
              if(region != null) {
                  idRendezVous = region.name() + "¤" + idRendezVous;
              }
      
              return idRendezVous;
          }
      
    2. Dans pong.commun.messages, ajouter MsgInitialiserFileAttente

      public class MsgInitialiserFileAttente extends Message<MsgInitialiserFileAttente> {
      
          private Region region;
      
          public MsgInitialiserFileAttente setRegion(Region region) {
              this.region = region;
      
              return this;
          }
      
          public MsgInitialiserFileAttente() {
          }
      
          public void appliquerA(ModeleFileAttente fileAttente) {
              fileAttente.initialiserRegion(region);
          }
      }
      
    3. Déclarer le message dans Declarations

      public class Declarations {
      
      	public static void declarerMessages(MessageRegistrar registrar) {
      
      		// ...
      
      		// ajouter
      		registrar.registerMessage(MsgInitialiserFileAttente.class);
      	}
      
      	// ...
      
    4. Dans pong.dorsal.taches.ModifierFileAttente, ajouter

      public class ModifierFileAttente {
      
          public static void creerTaches(BackendTasks tasks) {
      
              tasks.taskGroup("ModifierFileAttente")
      
                   .waitsFor(model(ModeleFileAttente.class))
      
                   .contains(subTasks -> {
      
                       // ajouter
                       initialiser(subTasks);
      
                       // ...
      
                   });
          }
      
          // ...
      
          // ajouter
          private static void initialiser(BackendTasks subTasks) {
              subTasks.task("initialiser")
      
                   .waitsFor(model(ModeleFileAttente.class))
      
                   .waitsFor(message(MsgInitialiserFileAttente.class))
      
                   .executes(inputs -> {
      
                       MsgInitialiserFileAttente msgInitialiserFileAttente = inputs.get(message(MsgInitialiserFileAttente.class));
                       ModeleFileAttente         fileAttente               = inputs.get(model(ModeleFileAttente.class));
      
                       msgInitialiserFileAttente.appliquerA(fileAttente);
                   });
          }
      
    5. Dans pong.dorsal.taches, ajouter Initialisation

      public class Initialisation {
      
          public static void creerTaches(BackendTasks tasks) {
      
              tasks.taskGroup("Initialisation")
      
                   .contains(subTasks -> {
      
                       initialiserFilesAttentes(subTasks);
      
                   });
          }
      
          private static void initialiserFilesAttentes(BackendTasks subTasks) {
      
              subTasks.task("initialiserFilesAttentes")
      
                   .executes(inputs -> {
      
                       for(Region region : Region.values()) {
      
                           Ntro.newMessage(MsgInitialiserFileAttente.class)
                               .setModelSelection(ModeleFileAttente.class, region.name())
                               .setRegion(region)
                               .send();
                       }
                   });
          }
      }
      
    6. S’assurer d’appeler Initialisation.creerTaches dans le Dorsal

      public class DorsalPong extends LocalBackendNtro {
      
          @Override
          public void createTasks(BackendTasks tasks) {
      
              // ajouter
              Initialisation.creerTaches(tasks);
      
              // ...
      
          }
      }
      
    7. Exécuter et vérifier que la tâche s’exécute

      $ sh gradlew pong
      
      # doit afficher
      [TASK] initialiserFilesAttentes
      [...]
      [TASK] initialiser (4)
      
    8. Vérifier les fichiers .json

      _storage
      ├── models
      │   ├── ModeleFileAttente
      │   │   ├── AFRIQUE.json
      │   │   ├── AMERIQUE.json
      │   │   ├── ASIE.json
      │   │   └── EUROPE.json
      
    9. Vérifier le contenu de AFRIQUE.json

      {
        "_C": "ModeleFileAttente",
        "prochainIdRendezVous": 0,
        "region": "AFRIQUE",
        "rendezVousDansOrdre": []
      }
      
    10. Vérifier le graphe du dorsal

    Avec la Session, mémoriser et observer la région courante #

    1. Ajouter le code suivant dans SessionPong

      public class SessionPong extends Session<SessionPong> {
      
          // ...
      
          // ajouter
          private Region                regionCourante      = Region.AMERIQUE;
      
          // ...
      
          // ajouter
          public SessionPong() {
              super();
              observerRegionCourante();
          }
      
          // ...
      
      
          // ajouter
          public SessionPong memoriserRegionCourante(Region region) {
              this.regionCourante = region;
      
      
              return this;
          }
      
          // ajouter
          public SessionPong observerRegionCourante() {
              this.setModelSelection(ModeleFileAttente.class, regionCourante.name());
      
              return this;
          }
      

    Ajouter un EvtChangerRegion #

    1. Dans pong.frontal.evenements, ajouter

      public class EvtChangerRegion extends Event {
      
          private Region region;
      
          public EvtChangerRegion setRegion(Region region) {
              this.region = region;
      
              return this;
          }
      
          public void appliquerA(SessionPong session) {
      
              session.memoriserRegionCourante(region)
                     .observerRegionCourante();
          }
      }
      
    2. Déclarer l’événement dans le Frontal:

      public class FrontalPong implements FrontendFx {
      
          // ...
      
          @Override
          public void registerEvents(EventRegistrar registrar) {
              // ...
      
              // ajouter
              registrar.registerEvent(EvtChangerRegion.class);
          }
      
      

    Ajouter une tâche pour changer de région #

    1. Dans AfficherFileAttente, ajouter la tâche suivante

      public class AfficherFileAttente {
      
          public static void creerTaches(FrontendTasks tasks) {
      
              tasks.taskGroup("AfficherFileAttente")
      
                   .waitsFor("afficherVueFileAttente")
      
                   .contains(subTasks -> {
      
                       // ...
      
                       // ajouter
                       changerRegion(subTasks);
      
                   });
          }
      
          // ...
      
          // ajouter
          private static void changerRegion(FrontendTasks subTasks) {
      
              subTasks.task("changerRegion")
      
                      .waitsFor(event(EvtChangerRegion.class))
      
                      .executes(inputs -> {
      
                          SessionPong      session          = Ntro.session();
                          EvtChangerRegion evtChangerRegion = inputs.get(event(EvtChangerRegion.class));
      
                          evtChangerRegion.appliquerA(session);
      
                    });
          }
      

    Afficher les régions dans un ComboBox #

    1. Dans file_attente.fxml, ajouter un ComboBox pour afficher les régions

          <!-- ajouter un HBox autour du boutonSInscrire -->
          <HBox styleClass="conteneur">
      
              <!-- boutonSInscrire ici -->
      
              <!-- petit espace -->
              <Pane styleClass="petit-espace-horizontal"/>
      
              <!-- ajouter -->
              <ComboBox fx:id="comboRegion" >
              </ComboBox>
      
          </HBox>
      
    2. Dans VueFileAttente, récupérer et initialiser le ComboBox

      public class VueFileAttente extends ViewFx {
      
          // ...
      
          @FXML
          private ComboBox<String> comboRegion; // ajouter
      
          // ajouter
          private Map<Region,String> nomRegionParRegion = new HashMap<>();
          private Map<String,Region> regionParNomRegion = new HashMap<>();
      
          // ...
      
          @Override
          public void initialize() {
      
              // ...
      
              // ajouter
              Ntro.assertNotNull(comboRegion);
      
              // ajouter
              initialiserRegions();
      
              // ajouter
              initialiserComboRegion();
          }
      
          // ...
      
          // ajouter
          private void initialiserRegions() {
              for(Region region : Region.values()) {
                  String nomRegion = resources().getString(region.name());
                  nomRegionParRegion.put(region, nomRegion);
                  regionParNomRegion.put(nomRegion, region);
              }
          }
      
          // ajouter
          private void initialiserComboRegion() {
              comboRegion.setFocusTraversable(false);
      
              for(Region region : Region.values()) {
                  comboRegion.getItems().add(nomRegionParRegion.get(region));
              }
      
              comboRegion.setOnAction(evtFx -> actionComboRegion());
      
          }
      
          // ajouter
          private void actionComboRegion() {
      
              String nomRegion = comboRegion.getSelectionModel().getSelectedItem();
      
              Region region = regionParNomRegion.get(nomRegion);
      
              if(region != null) {
      
                  Ntro.newEvent(EvtChangerRegion.class)
                      .setRegion(region)
                      .trigger();
              }
          }
      
    3. En français

    4. En anglais

    S’assurer d’afficher la région courante (même au premier affichage) #

    1. Créer les méthodes pour afficher la région courante

      public class SessionPong extends Session<SessionPong> {
      
          // ...
      
          // ajouter
          public SessionPong afficherRegionCourante(VueFileAttente vueFileAttente) {
      
              vueFileAttente.afficherRegionCourante(regionCourante.name());
      
              return this;
          }
      
      public class VueFileAttente extends ViewFx {
      
          // ...
      
      
      
          // ajouter
          public void afficherRegionCourante(String idRegion) {
              Region region = null;
      
              if(idRegion != null) {
                  region = Region.valueOf(idRegion);
              }
      
              if(region == null) {
      
                  comboRegion.getSelectionModel().clearSelection();
      
              }else {
      
                  comboRegion.getSelectionModel().select(nomRegionParRegion.get(region));
      
              }
          }
      
    2. Ajouter le code suivant dans la tâche pour afficher la file d’attente

          // modifier cette méthode
          private static void afficherFileAttente(FrontendTasks tasks) {
      
              tasks.task("afficherFileAttente")
      
                   .waitsFor(modified(ModeleFileAttente.class))
      
                   .waitsFor(created(VueFileAttente.class))
      
                   .executes(inputs -> {
      
                       // ajouter
                       SessionPong                 session        = Ntro.session();
      
                       VueFileAttente              vueFileAttente = inputs.get(created(VueFileAttente.class));
                       Modified<ModeleFileAttente> fileAttente    = inputs.get(modified(ModeleFileAttente.class));
      
                       fileAttente.currentValue().afficherSur(vueFileAttente);
      
                       // ajouter
                       session.afficherRegionCourante(vueFileAttente);
                   });
          }
      
    Creative Commons License Creative Commons Attribution Creative Commons ShareAlike
    • Plusieurs files d’attente (une par region)
      • Les régions et les noms de région traduits
      • Ajouter une tâche du Dorsal pour initialiser les régions
      • Avec la Session, mémoriser et observer la région courante
      • Ajouter un EvtChangerRegion
      • Ajouter une tâche pour changer de région
      • Afficher les régions dans un ComboBox
      • S’assurer d’afficher la région courante (même au premier affichage)