Пример #1
0
        /// <summary>
        /// Permet de mettre à jour les activités en fonction de si elles sont passées ou non
        /// </summary>
        public void mettreAJourActiviteEnCours()
        {
            TimeMartien heureActuelle = TimeMartien.calculerJours(debutMission);

            for (int k = 1; k <= journeeActuelle.getNumero(); ++k)
            {
                Journee j = journeesMission[k];

                for (int i = 0; i < heures.Count; ++i)
                {
                    if (heures[i].Tag.ToString().Equals(heureActuelle.getHeures().ToString()) && journeeActuelle.getNumero() == k)
                    {
                        j.trouverActivite(heureActuelle, ((heureActuelle.getHeures() == 0 && heureActuelle.getMinutes() == 0) ? true : false)).activiteEnCours();
                    }
                    else if (int.Parse(heures[i].Tag.ToString()) < heureActuelle.getHeures() || journeeActuelle.getNumero() != k)
                    {
                        foreach (Activite a in j.getActivites())
                        {
                            TimeMartien tm = new TimeMartien(0, int.Parse(heures[i].Tag.ToString()), 0, 0);

                            if ((a.getHeureFin() < heureActuelle || journeeActuelle.getNumero() != k))
                            {
                                a.activitePassee();
                            }

                            if ((j.getNumero() > journeeActuelle.getNumero()) || (j.getNumero() == journeeActuelle.getNumero() && a.getHeureFin().getHeures() == 0 && a.getHeureFin().getMinutes() == 0))
                            {
                                a.activiteAVenir();
                            }
                        }
                    }
                }
            }
        }
Пример #2
0
        /// <summary>
        /// Permet de trouver une activité dans la journée en fonction d'une heure de début
        /// </summary>
        /// <param name="heure">Une heure</param>
        /// <returns>L'activité se passant à l'heure donnée</returns>
        public Activite trouverActivite(TimeMartien tm, bool debut)
        {
            if (tm != null)
            {
                if (!debut && tm.getHeures() == 0 && tm.getMinutes() == 0 && tm.getSecondes() == 0)
                {
                    tm = new TimeMartien(0, 24, 39, 58);
                }

                foreach (Activite a in listeActivites)
                {
                    if (a.getHeureFin().getHeures() == 0 && a.getHeureFin().getMinutes() == 0 && a.getHeureFin().getSecondes() == 0)
                    {
                        a.setHeureFin(new TimeMartien(0, 24, 39, 59));
                    }

                    if (a.getHeureDebut() <= tm && a.getHeureFin() > tm)
                    {
                        if (a.getHeureFin().getHeures() == 24 && a.getHeureFin().getMinutes() == 39 && a.getHeureFin().getSecondes() == 59)
                        {
                            a.setHeureFin(new TimeMartien(0, 24, 40, 00));
                        }
                        return(a);
                    }
                }
            }

            return(null);
        }
Пример #3
0
        /// <summary>
        /// Surcharge de l'opérateur +
        /// </summary>
        /// <param name="t1">TimeMartien à additionner</param>
        /// <param name="t2">Addition avec TimeMartien</param>
        /// <returns>Résultat addition</returns>
        public static TimeMartien operator +(TimeMartien t1, TimeMartien t2)
        {
            TimeMartien tR = new TimeMartien(0, t1.heure, t1.minute, t1.seconde);

            tR.ajouterTemps(t2);

            return(tR);
        }
Пример #4
0
        /// <summary>
        /// Surcharge de l'opérateur -
        /// </summary>
        /// <param name="t1">TimeMartien à soustraire</param>
        /// <param name="t2">Soustraction avec TimeMartien</param>
        /// <returns>Résultat soustraction</returns>
        public static TimeMartien operator -(TimeMartien t1, TimeMartien t2)
        {
            TimeMartien tR = new TimeMartien(t1.jours, t1.heure, t1.minute, t1.seconde);

            tR.retirerTemps(t2);

            return(tR);
        }
Пример #5
0
        /// <summary>
        /// Constructeur paramétré
        /// </summary>
        /// <param name="dt">Début de la mission</param>
        /// <param name="chargement">Chargement des données par XML ?</param>
        public CalendrierMission(DateTime dt, bool chargement)
        {
            InitializeComponent();

            debutMission = dt;

            periode             = 1;
            journeeSelectionnee = 1;

            panels         = new Dictionary <int, Panel>();
            icones         = new Dictionary <int, PictureBox>();
            iconesActivite = new Dictionary <int, PictureBox>();
            numeros        = new Dictionary <int, Label>();
            heures         = new Dictionary <int, Label>();
            domaines       = new List <Domaine>();
            astronautes    = new List <Astronaute>();

            initialiserDomaines();

            if (!chargement)
            {
                Astronaute a = new Astronaute("Baudry", "Patrick", 69);
                astronauteSelectionne = a;
                astronautes.Add(a);

                journeesMission = astronauteSelectionne.getJourneesMission();

                initialisationInterface();

                TimeMartien nb      = TimeMartien.calculerJours(debutMission);
                int         numJour = nb.getJours() + 1;

                if (numJour > 500)
                {
                    numJour = 500;
                }

                foreach (Astronaute astro in astronautes)
                {
                    astro.creerEdT(numJour);
                    astroList.Items.Add(astro);
                }

                journeeActuelle = journeesMission[numJour];

                changerPeriode(periode);
                verificationChangementPeriode();
                mettreAJourHeures();
                miseAJourEdt(journeesMission[journeeSelectionnee]);

                descriptionTexte.Text  = journeesMission[journeeSelectionnee].getDescription();
                astroList.SelectedItem = astronauteSelectionne;
                mettreAJourActiviteEnCours();
            }
        }
Пример #6
0
 /// <summary>
 /// Constructeur par copie
 /// </summary>
 /// <param name="a">Une activité</param>
 public Activite(Activite a)
 {
     typeActivite = a.typeActivite;
     description  = a.description;
     etat         = a.etat;
     heureDebut   = a.heureDebut;
     heureFin     = a.heureFin;
     saveFichier  = new List <Activite>();
     lieu         = a.lieu;
     numero       = ++nbActivite;
 }
Пример #7
0
 /// <summary>
 /// Constructeur paramétré
 /// </summary>
 /// <param name="typeActivite">Type de l'Activite</param>
 /// <param name="description">Description de l'Activite</param>
 /// <param name="deb">Date de début de l'Activite</param>
 /// <param name="fin">Date de fin de l'Activite</param>
 /// <param name="lieu">Lieu de l'Activite</param>
 public Activite(TypeActivite typeActivite, String description, TimeMartien deb, TimeMartien fin, Lieu lieu)
 {
     this.typeActivite = typeActivite;
     this.description  = description;
     etat            = new Futur();
     this.heureDebut = deb;
     this.heureFin   = fin;
     saveFichier     = new List <Activite>();
     this.lieu       = lieu;
     numero          = ++nbActivite;
 }
Пример #8
0
        /// <summary>
        /// Permet d'ajouter un astronaute
        /// </summary>
        /// <param name="sender">Objet source</param>
        /// <param name="e">Evènement</param>
        private void ajoutAstro_Click(object sender, EventArgs e)
        {
            TimeMartien nb      = TimeMartien.calculerJours(debutMission);
            int         numJour = nb.getJours() + 1;

            if (numJour > 500)
            {
                numJour = 500;
            }

            NouveauAstronaute na = new NouveauAstronaute(astronautes, astroList, numJour);

            na.Show();
        }
Пример #9
0
        /// <summary>
        /// Permet de calculer le nombre de jours passés depuis le DateTime spécifié (en temps martien)
        /// </summary>
        /// <param name="dateDepart">Un DateTime</param>
        /// <returns>Le nombre de jours écoulés depuis la date spécifiée, en temps martien</returns>
        public static TimeMartien calculerJours(DateTime dateDepart)
        {
            DateTime dt = DateTime.Now;

            if (dt >= dateDepart)
            {
                long     ticks = dt.Ticks - dateDepart.Ticks;
                TimeSpan ts    = new TimeSpan(ticks);

                TimeMartien tm = new TimeMartien(0, 0, 0, (int)Math.Truncate(ts.TotalSeconds));

                return(tm);
            }
            else
            {
                return(new TimeMartien(0, 0, 0, 0));
            }
        }
Пример #10
0
        /// <summary>
        /// Permet de savoir quand deux TimeMartien sont égaux
        /// </summary>
        /// <param name="obj">Un TimeMartien</param>
        /// <returns>Vrai si les deux TImeMartien sont égaux, faux sinon</returns>
        public override bool Equals(object obj)
        {
            TimeMartien t2 = obj as TimeMartien;

            if (t2 != null)
            {
                if (this.getHeures() == t2.getHeures())
                {
                    if (this.getMinutes() == t2.getMinutes())
                    {
                        if (this.getSecondes() == t2.getSecondes())
                        {
                            return(true);
                        }
                    }
                }
            }
            return(false);
        }
Пример #11
0
        /// <summary>
        /// Permet de trouver des activités dans la journée en fonction d'une heure de début
        /// </summary>
        /// <param name="heure">Une heure</param>
        /// <returns>Les activités se passant dans l'heure donnée</returns>
        public List <Activite> trouverActivites(int heureD)
        {
            int heureF = heureD + 1;

            if (heureF > 24)
            {
                heureF -= 25;
            }

            List <Activite> acts = new List <Activite>();

            foreach (Activite a in listeActivites)
            {
                if (TimeMartien.sePasseDansPeriode(a.getHeureDebut(), a.getHeureFin(), new TimeMartien(heureD), new TimeMartien(heureF)))
                {
                    acts.Add(a);
                }
            }

            return(acts);
        }
Пример #12
0
        /// <summary>
        /// Permet de mettre à jour les jours en fonction de s'ils sont passés ou non
        /// </summary>
        /// <param name="sender">Objet source</param>
        /// <param name="e">Evènement</param>
        private void timerJour_Tick(object sender, EventArgs e)
        {
            TimeMartien nb = TimeMartien.calculerJours(debutMission);

            int numJour = nb.getJours() + 1;

            if (numJour > 500)
            {
                numJour = 500;
            }

            for (int i = 1; i < numJour; ++i)
            {
                journeesMission[i].journeePassee();
            }
            journeeActuelle = journeesMission[numJour];
            journeesMission[numJour].journeeEnCours();

            changerPeriode(periode);
            verificationChangementPeriode();
            mettreAJourHeures();
            miseAJourEdt(journeesMission[journeeSelectionnee]);
        }
Пример #13
0
        /// <summary>
        /// Permet de savoir si une activité se passe dans la période donnée
        /// </summary>
        /// <param name="debutActivite">Début de l'activité</param>
        /// <param name="finActivite">Fin de l'activité</param>
        /// <param name="heureDebut">Début de la période</param>
        /// <param name="heureFin">Fin de la période</param>
        /// <returns>Vrai si l'activité se passe dans la période, faux sinon</returns>
        public static bool sePasseDansPeriode(TimeMartien debutActivite, TimeMartien finActivite, TimeMartien heureDebut, TimeMartien heureFin)
        {
            if (finActivite.getHeures() == 0 && finActivite.getMinutes() == 0 && finActivite.getSecondes() == 0)
            {
                finActivite = new TimeMartien(0, 24, 39, 59);
            }

            if (heureFin.getHeures() == 0 && heureFin.getMinutes() == 0 && heureFin.getSecondes() == 0)
            {
                heureFin = new TimeMartien(0, 24, 39, 59);
            }

            bool dINFd = (debutActivite <= heureDebut);
            bool dSUPd = (debutActivite >= heureDebut);
            bool fINFf = (finActivite <= heureFin);
            bool fSUPf = (finActivite >= heureFin);
            bool dINFf = (debutActivite < heureFin || debutActivite.getJours() < heureFin.getJours());
            bool fSUPd = (finActivite > heureDebut || finActivite.getJours() > heureDebut.getJours());

            if (dINFd && fSUPf && dINFf && fSUPd)
            {
                return(true);
            }
            else if (dSUPd && fINFf && dINFf && fSUPd)
            {
                return(true);
            }
            else if (dSUPd && fSUPf && dINFf && fSUPd)
            {
                return(true);
            }
            else if (dINFd && fINFf && dINFf && fSUPd)
            {
                return(true);
            }
            return(false);
        }
Пример #14
0
        /// <summary>
        /// Permet de créer les données par défaut, et d'ouvrir le menu "principal" de l'application
        /// </summary>
        /// <param name="sender">Objet source</param>
        /// <param name="e">Evènement</param>
        private void button1_Click(object sender, EventArgs e)
        {
            DateTime picker = dateTimePicker1.Value;
            DateTime dt     = new DateTime(picker.Year, picker.Month, picker.Day, (int)heures.Value, (int)minutes.Value, 0);

            if (dt > DateTime.Now)
            {
                erreurDate.Visible = true;
                erreurDate.Text    = "La date de début de mission ne peut pas être supérieure à la date actuelle";
                return;
            }

            if (TimeMartien.calculerJours(dt).getJours() > 500)
            {
                erreurDate.Visible = true;
                erreurDate.Text    = "La durée de la mission dépasse les 500 jours...";
                return;
            }

            CalendrierMission cm = new CalendrierMission(dt, false);

            cm.Show();
            this.cacherFenetre();
        }
Пример #15
0
 /// <summary>
 /// Permet de définir l'heure de fin de l'activité
 /// </summary>
 /// <param name="tm">Un TimeMartien</param>
 public void setHeureFin(TimeMartien tm)
 {
     this.heureFin = tm;
 }
Пример #16
0
 /// <summary>
 /// Permet de définir l'heure de début de l'activité
 /// </summary>
 /// <param name="tm">Un TimeMartien</param>
 public void setHeureDebut(TimeMartien tm)
 {
     this.heureDebut = tm;
 }
Пример #17
0
 /// <summary>
 /// Permet de mettre à jour les heures terrestre et martienne
 /// </summary>
 public void mettreAJourHeures()
 {
     terre.Text = DateTime.Now.ToLocalTime().ToString();
     mars.Text  = TimeMartien.calculerJours(debutMission).ToString();
 }
Пример #18
0
        /// <summary>
        /// Constructeur paramétré
        /// </summary>
        /// <param name="j">Une journée</param>
        /// <param name="a">Une activité la journée</param>
        /// <param name="cm">L'interface graphique CalendrierMission</param>
        /// <param name="dh">L'interface graphique DetailHeure</param>
        public ModificationActivite(Journee j, Activite a, CalendrierMission cm, DetailHeure dh)
        {
            if (a.getHeureFin().getHeures() == 24 && a.getHeureFin().getMinutes() == 39)
            {
                a.setHeureFin(new TimeMartien(0));
            }

            InitializeComponent();
            this.dh = dh;

            if (finHeure.Value == 0 && finMinute.Value == 0)
            {
                finHeure.Value  = 24;
                finMinute.Value = 40;
            }

            debutHeure.Maximum = finHeure.Value;

            lieu = new Lieu(0, 0);

            activiteAModifier = a;
            journeeAModifier  = j;
            this.cm           = cm;

            debutHeure.Value = activiteAModifier.getHeureDebut().getHeures();
            finHeure.Value   = activiteAModifier.getHeureFin().getHeures();

            debutMinute.Value = activiteAModifier.getHeureDebut().getMinutes();
            finMinute.Value   = activiteAModifier.getHeureFin().getMinutes();

            debutHeure.Minimum = debutHeure.Value;
            finHeure.Maximum   = (finHeure.Value == 0) ? 24 : finHeure.Value;

            finHeure.Minimum = (finHeure.Value == 0) ? 0 : debutHeure.Value;

            remplirTreeView();

            descriptionTB.Text = a.getDescription();

            if (a.isActiviteExterieure())
            {
                exterieurRadio.Checked = true;

                if (a.isExploration())
                {
                    explorationRadio.Checked = true;
                    scaphandreRadio.Checked  = (((ExplorationExterieure)a).nomTransport().Equals("Scaphandre")) ? true : false;
                    vehiculeRadio.Checked    = !scaphandreRadio.Checked;
                }
                else
                {
                    experienceRadio.Checked = true;
                    scaphandreRadio.Checked = (((ExperienceExterieure)a).nomTransport().Equals("Scaphandre")) ? true : false;
                    vehiculeRadio.Checked   = !scaphandreRadio.Checked;
                }
            }
            else
            {
                interieurRadio.Checked = true;
            }

            foreach (TreeNode tn in treeView.Nodes)
            {
                foreach (TreeNode tnn in tn.Nodes)
                {
                    if (tnn.Text.Equals(a.getNom()))
                    {
                        treeView.SelectedNode = tnn;
                    }
                }
            }

            lieuTB.Text = activiteAModifier.getLieu().ToString();

            debutHeure.Maximum = finHeure.Maximum;

            heureDebutStatic = new TimeMartien(0, (int)debutHeure.Value, (int)debutMinute.Value, 0);
            heureFinStatic   = new TimeMartien(0, (int)finHeure.Value, (int)finMinute.Value, 0);
        }
Пример #19
0
        /// <summary>
        /// Permet de procéder aux modifications
        /// </summary>
        /// <param name="sender">Objet source</param>
        /// <param name="e">Evènement</param>
        private void ok_Click(object sender, EventArgs e)
        {
            TimeMartien d = new TimeMartien(0, (int)debutHeure.Value, (int)debutMinute.Value, 0);
            TimeMartien f = new TimeMartien(0, (int)finHeure.Value, (int)finMinute.Value, 0);

            if (d < f || (d > f && f.Equals(new TimeMartien(0))))
            {
                String type = treeView.SelectedNode.Text;
                journeeAModifier.supprimerActivite(activiteAModifier);

                try
                {
                    lieu = new Lieu(int.Parse(lieuTB.Text.Split(';')[0]), int.Parse(lieuTB.Text.Split(';')[1]));
                }
                catch
                {
                    lieu = new Lieu(0, 0);
                }

                Activite a;

                if (exterieurRadio.Checked)
                {
                    ITransport transport;

                    if (vehiculeRadio.Checked)
                    {
                        transport = new Vehicule();
                    }
                    else
                    {
                        transport = new Scaphandre();
                    }

                    if (explorationRadio.Checked)
                    {
                        a = new ExplorationExterieure(new TypeActivite(type), descriptionTB.Text, new TimeMartien(0, (int)debutHeure.Value, (int)debutMinute.Value, 0), new TimeMartien(0, (int)finHeure.Value, (int)finMinute.Value, 0), lieu, transport);
                    }
                    else
                    {
                        a = new ExperienceExterieure(new TypeActivite(type), descriptionTB.Text, new TimeMartien(0, (int)debutHeure.Value, (int)debutMinute.Value, 0), new TimeMartien(0, (int)finHeure.Value, (int)finMinute.Value, 0), lieu, transport);
                    }
                }
                else
                {
                    a = new Activite(new TypeActivite(type), descriptionTB.Text, new TimeMartien(0, (int)debutHeure.Value, (int)debutMinute.Value, 0), new TimeMartien(0, (int)finHeure.Value, (int)finMinute.Value, 0), new Lieu(0, 0));
                }

                if (a.getDuree().getTotalMinutes() > 0)
                {
                    if (a.getHeureFin().getHeures() == 0 && a.getHeureFin().getMinutes() == 0 && a.getHeureFin().getSecondes() == 0)
                    {
                        a.setHeureFin(new TimeMartien(0, 24, 39, 59));
                    }

                    /* Découpage activité */
                    if (activiteAModifier.getHeureFin().getHeures() == 0 && activiteAModifier.getHeureFin().getMinutes() == 0 && activiteAModifier.getHeureFin().getSecondes() == 0)
                    {
                        activiteAModifier.setHeureFin(new TimeMartien(0, 24, 39, 59));
                    }

                    if (activiteAModifier.getDuree().getTotalMinutes() == 10 || activiteAModifier.getDuree().getTotalMinutes() == 9)
                    {
                        journeeAModifier.ajouterActivite(a);
                    }
                    else if (activiteAModifier.getDuree().getTotalMinutes() == 20 || activiteAModifier.getDuree().getTotalMinutes() == 19)
                    {
                        if (activiteAModifier.getHeureDebut() < a.getHeureDebut())
                        {
                            activiteAModifier.setHeureFin(new TimeMartien(0, (int)debutHeure.Value, (int)debutMinute.Value, 0));
                        }
                        else
                        {
                            activiteAModifier.setHeureDebut(new TimeMartien(0, (int)finHeure.Value, (int)finMinute.Value, 0));
                        }

                        journeeAModifier.ajouterActivite(a);
                        journeeAModifier.ajouterActivite(activiteAModifier);
                    }
                    else if (activiteAModifier.getDuree().getTotalMinutes() > 20)
                    {
                        if (activiteAModifier.getHeureDebut() < a.getHeureDebut() &&
                            activiteAModifier.getHeureFin() > a.getHeureFin())
                        {
                            Activite copie = (activiteAModifier.isActiviteExterieure()) ? null : new Activite(activiteAModifier);

                            if (copie == null && activiteAModifier.isExploration())
                            {
                                copie = new ExplorationExterieure((ExplorationExterieure)activiteAModifier);
                            }
                            else if (copie == null)
                            {
                                copie = new ExperienceExterieure((ExperienceExterieure)activiteAModifier);
                            }

                            activiteAModifier.setHeureFin(new TimeMartien(0, (int)debutHeure.Value, (int)debutMinute.Value, 0));
                            copie.setHeureDebut(new TimeMartien(0, (int)finHeure.Value, (int)finMinute.Value, 0));

                            journeeAModifier.ajouterActivite(copie);
                            journeeAModifier.ajouterActivite(activiteAModifier);
                        }
                        else if (activiteAModifier.getHeureDebut() < a.getHeureDebut() &&
                                 activiteAModifier.getHeureFin() == a.getHeureFin())
                        {
                            activiteAModifier.setHeureFin(new TimeMartien(0, (int)debutHeure.Value, (int)debutMinute.Value, 0));
                            journeeAModifier.ajouterActivite(activiteAModifier);
                        }
                        else if (activiteAModifier.getHeureDebut() == a.getHeureDebut() &&
                                 activiteAModifier.getHeureFin() > a.getHeureFin())
                        {
                            activiteAModifier.setHeureDebut(new TimeMartien(0, (int)finHeure.Value, (int)finMinute.Value, 0));
                            journeeAModifier.ajouterActivite(activiteAModifier);
                        }

                        journeeAModifier.ajouterActivite(a);
                    }

                    if (a.getHeureFin().getHeures() == 24 && a.getHeureFin().getMinutes() == 39 && a.getHeureFin().getSecondes() == 59)
                    {
                        a.setHeureFin(new TimeMartien(0));
                    }

                    cm.miseAJourEdt(journeeAModifier);
                    dh.Close();
                    cm.ouvrirDernierDetailHeure();
                    fermerFenetre();
                }
                else
                {
                    errDuree.Text    = "La durée de l'activité doit être d'au moins 10 minutes";
                    errDuree.Visible = true;
                }
            }
            else
            {
                errDuree.Text    = "La date de début doit être inférieure à la date de fin";
                errDuree.Visible = true;
            }
        }
Пример #20
0
 /// <summary>
 /// Constructeur paramétré
 /// </summary>
 /// <param name="typeActivite">Type de l'Activite</param>
 /// <param name="description">Description de l'Activite</param>
 /// <param name="debut">Date de début de l'Activite</param>
 /// <param name="fin">Date de fin de l'Activite</param>
 /// <param name="lieu">Lieu de l'Activite</param>
 public ExperienceExterieure(TypeActivite typeActivite, String description, TimeMartien debut, TimeMartien fin, Lieu lieu)
     : this(typeActivite, description, debut, fin, lieu, new Scaphandre())
 {
 }
Пример #21
0
 /// <summary>
 /// Permet d'ajouter du temps au TimeMartien
 /// </summary>
 /// <param name="tm">Un TimeMartien</param>
 public void ajouterTemps(TimeMartien tm)
 {
     ajouterTemps(tm.jours, tm.heure, tm.minute, tm.seconde);
 }
Пример #22
0
 /// <summary>
 /// Constructeur paramétré
 /// </summary>
 /// <param name="typeActivite">Type de l'Activite</param>
 /// <param name="description">Description de l'Activite</param>
 /// <param name="debut">Date de début de l'Activite</param>
 /// <param name="fin">Date de fin de l'Activite</param>
 /// <param name="lieu">Lieu de l'Activite</param>
 /// <param name="transport">Moyen de transport pour l'Activite</param>
 public ExplorationExterieure(TypeActivite typeActivite, String description, TimeMartien debut, TimeMartien fin, Lieu lieu, ITransport transport)
     : base(typeActivite, description, debut, fin, lieu)
 {
     this.transport = transport;
 }
Пример #23
0
        /// <summary>
        /// Permet de charger les données depuis un fichier XML
        /// </summary>
        /// <param name="marsOMatic">Le fichier XML Mars-o-Matic</param>
        /// <param name="activitesRefs">Le fichier XML ActivitesRefs associé au fichier précédent</param>
        private void chargerXml(String marsOMatic, String activitesRefs)
        {
            XmlDocument mars = new XmlDocument();

            mars.Load(marsOMatic);
            XmlDocument acts = new XmlDocument();

            acts.Load(activitesRefs);

            Dictionary <int, Activite> activitesBase = new Dictionary <int, Activite>();

            int nbElements = int.Parse(mars.SelectSingleNode("Donnees").SelectSingleNode("NbElements").InnerText);

            Progression p = new Progression(nbElements);

            p.Show();

            /* Chargement données des activités de base */
            XmlNodeList activites = acts.GetElementsByTagName("Activite");

            foreach (XmlNode n in activites)
            {
                Activite a;

                int          num         = int.Parse(n.SelectSingleNode("Numero").InnerText);
                bool         exterieure  = bool.Parse(n.SelectSingleNode("Exterieure").InnerText);
                bool         exploration = bool.Parse(n.SelectSingleNode("Exploration").InnerText);
                TypeActivite ta          = new TypeActivite(n.SelectSingleNode("TypeActivite").SelectSingleNode("Nom").InnerText);

                if (exterieure)
                {
                    if (exploration)
                    {
                        a = new ExplorationExterieure(ta, "", null, null, null, null);
                    }
                    else
                    {
                        a = new ExperienceExterieure(ta, "", null, null, null, null);
                    }
                }
                else
                {
                    a = new Activite(ta);
                }

                activitesBase.Add(num, a);

                p.incrementer();
            }

            /* Chargement données */
            int jour     = int.Parse(mars.SelectSingleNode("Donnees").SelectSingleNode("DebutMission").SelectSingleNode("Jour").InnerText);
            int mois     = int.Parse(mars.SelectSingleNode("Donnees").SelectSingleNode("DebutMission").SelectSingleNode("Mois").InnerText);
            int annee    = int.Parse(mars.SelectSingleNode("Donnees").SelectSingleNode("DebutMission").SelectSingleNode("Annee").InnerText);
            int heures   = int.Parse(mars.SelectSingleNode("Donnees").SelectSingleNode("DebutMission").SelectSingleNode("Heures").InnerText);
            int minutes  = int.Parse(mars.SelectSingleNode("Donnees").SelectSingleNode("DebutMission").SelectSingleNode("Minutes").InnerText);
            int secondes = int.Parse(mars.SelectSingleNode("Donnees").SelectSingleNode("DebutMission").SelectSingleNode("Secondes").InnerText);

            this.debutMission = new DateTime(annee, mois, jour, heures, minutes, secondes);

            TimeMartien nb      = TimeMartien.calculerJours(debutMission);
            int         numJour = nb.getJours() + 1;

            if (numJour > 500)
            {
                numJour = 500;
            }

            XmlNodeList astronautesNodes = mars.GetElementsByTagName("Astronaute");

            foreach (XmlNode n in astronautesNodes)
            {
                String nom    = n.SelectSingleNode("Nom").InnerText;
                String prenom = n.SelectSingleNode("Prenom").InnerText;
                int    age    = int.Parse(n.SelectSingleNode("Age").InnerText);

                Astronaute a = new Astronaute(nom, prenom, age);

                Dictionary <int, Journee> joursMission = new Dictionary <int, Journee>();
                a.setJourneesMission(joursMission);

                astronautes.Add(a);
                a.getJourneesMission().Clear();
                astroList.Items.Add(a); // Ajout dans la liste => interface

                XmlNodeList missionNode = n.SelectSingleNode("JourneesMission").SelectNodes("Journee");

                foreach (XmlNode nn in missionNode)
                {
                    int    num         = int.Parse(nn.SelectSingleNode("Numero").InnerText);
                    String etat        = nn.SelectSingleNode("Etat").InnerText;
                    IEtat  etatJournee = new Passe();

                    if (etat.Equals("EnCours"))
                    {
                        etatJournee = new EnCours();
                    }
                    else if (etat.Equals("Futur"))
                    {
                        etatJournee = new Futur();
                    }

                    String rapport = nn.SelectSingleNode("Rapport").InnerText;

                    Journee j = new Journee(num, rapport, etatJournee, false);
                    j.getActivites().Clear();
                    joursMission.Add(num, j);

                    XmlNodeList activitesNode = nn.SelectSingleNode("Activites").SelectNodes("Activite");

                    foreach (XmlNode nnn in activitesNode)
                    {
                        int        numA         = int.Parse(nnn.SelectSingleNode("Numero").InnerText);
                        String     transport    = nnn.SelectSingleNode("Transport").InnerText;
                        ITransport transportAct = null;

                        if (transport.Equals("Scaphandre"))
                        {
                            transportAct = new Scaphandre();
                        }
                        else if (transport.Equals("Vehicule"))
                        {
                            transportAct = new Vehicule();
                        }

                        String description = nnn.SelectSingleNode("Description").InnerText;
                        etat = nnn.SelectSingleNode("Etat").InnerText;
                        IEtat etatAct = new Passe();

                        if (etat.Equals("EnCours"))
                        {
                            etatAct = new EnCours();
                        }
                        else if (etat.Equals("Futur"))
                        {
                            etatAct = new Futur();
                        }

                        int mD = int.Parse(nnn.SelectSingleNode("HeureDebut").InnerText);

                        int mF = int.Parse(nnn.SelectSingleNode("HeureFin").InnerText);

                        String xy = nnn.SelectSingleNode("XY").InnerText;
                        int    x  = int.Parse(xy.Split(',')[0]);
                        int    y  = int.Parse(xy.Split(',')[1]);

                        Lieu l = new Lieu(x, y);

                        Activite aBase = activitesBase[numA];
                        Activite act;

                        if (aBase.isActiviteExterieure())
                        {
                            if (aBase.isExperience())
                            {
                                act = new ExperienceExterieure(aBase.getTypeActivite(), description, new TimeMartien(0, 0, mD, 0), new TimeMartien(0, 0, mF, 0), l, transportAct);
                            }
                            else
                            {
                                act = new ExplorationExterieure(aBase.getTypeActivite(), description, new TimeMartien(0, 0, mD, 0), new TimeMartien(0, 0, mF, 0), l, transportAct);
                            }
                        }
                        else
                        {
                            act = new Activite(aBase.getTypeActivite(), description, new TimeMartien(0, 0, mD, 0), new TimeMartien(0, 0, mF, 0), l);
                        }


                        act.setDescription(description);

                        act.setEtat(etatAct);

                        j.ajouterActivite(act);

                        p.incrementer();
                    }
                    p.incrementer();
                }
                p.incrementer();
            }

            initialisationInterface();

            astronauteSelectionne = astronautes[0];
            journeesMission       = astronauteSelectionne.getJourneesMission();
            journeeActuelle       = journeesMission[numJour];

            modificationJourneeActuelle(numJour);

            changerPeriode(periode);
            verificationChangementPeriode();
            mettreAJourHeures();
            miseAJourEdt(journeesMission[journeeSelectionnee]);

            descriptionTexte.Text  = journeesMission[journeeSelectionnee].getDescription();
            astroList.SelectedItem = astronauteSelectionne;

            p.fermerFenetre();
        }