/// <summary>
/// Permet d'ajouter un nouveau mot dans une langue
/// </summary>
/// <param name="sender">Composant qui a envoyé l'événemenet</param>
/// <param name="e">Information sur l'événement</param>
private void btn_ajout_mot_Click(object sender, EventArgs e)
{
Mot nouveauMot = new Mot(); // Nouveau mot
int indexNouveauMot = 0; // Index du nouveau mot dans la liste
try
{
// Obtient les informations du nouveau mot
nouveauMot.Nom = tb_nom_mot.Text;
nouveauMot.Definition = tb_definition_mot.Text;
nouveauMot.Langue = cb_langues.Text;
// Crée le nouveau mot
nouveauMot.IdUnique = gestVoc.CreerMot(nouveauMot);
// Ajoute le nouveau mot dans la liste
indexNouveauMot = lb_mots.Items.Add(nouveauMot);
// Sélectionne le mot ajouté
lb_mots.SelectedIndex = indexNouveauMot;
}
catch (Exception exc)
{
// Affiche un message d'erreur
MessageBox.Show(exc.Message, "Erreur!", MessageBoxButtons.OK);
}
}
/// <summary>
/// Permet d'obtenir le noeud d'un mot de n'importe quelle langue
/// </summary>
/// <param name="motCherche">Mot recherché</param>
/// <returns>Noeud du mot recherché</returns>
private XmlNode _ChercherNoeudMot(Mot motCherche)
{
XmlNodeList listeNoeudsMot = null; // Liste de noeuds mot contenu dans le fichier XML
XmlNode noeudMotTrouve = null; // Noeud du mot trouvé
string abrLangue = null; // Contient l'abréviation de la langue
int idUniqueMot = 0; // Id unique d'un mot
// Obtient l'abréviation de la langue
abrLangue = ObtenirAbreviationLangue(motCherche.Langue);
// Obtient la liste des mots à partir du fichier XML
listeNoeudsMot = fichierXml.SelectNodes("/vocaquiz/mot");
// Recherche le mot dans le fichier XML
foreach (XmlNode noeudMot in listeNoeudsMot)
{
// Obtient l'id
idUniqueMot = int.Parse(noeudMot.Attributes["id"].Value);
// Vérifie l'id du mot
if (idUniqueMot == motCherche.IdUnique)
{
// Sauvegarde le noeud
noeudMotTrouve = noeudMot;
}
}
// Retourne le noeud du mot
return(noeudMotTrouve);
}
/// <summary>
/// Permet de modifier le mot sélectionné
/// </summary>
/// <param name="sender">Composant qui a envoyé l'événemenet</param>
/// <param name="e">Information sur l'événement</param>
private void btn_modif_mot_Click(object sender, EventArgs e)
{
Mot motAModifier = null; // Mot devant être modifié
Mot motModifie = null; // Mot avec les informations modifiées
int indexSelectionne = 0; // Index de la sélection
// Obtient le mot à modifier
motAModifier = (Mot)lb_mots.SelectedItem;
// Créé le mot modifié avec les nouvelles informations
motModifie = new Mot();
motModifie.IdUnique = motAModifier.IdUnique;
motModifie.Nom = tb_nom_mot.Text;
motModifie.Definition = tb_definition_mot.Text;
motModifie.Langue = motAModifier.Langue;
// Enlève le mot de la liste
lb_mots.Items.Remove(motAModifier);
// Modifie le mot dans le fichier XML
motModifie = gestVoc.ModifierMot(motAModifier, motModifie);
// Ajoute le mot modifié dans la liste
indexSelectionne = lb_mots.Items.Add(motModifie);
// Sélectionne le mot
lb_mots.SelectedIndex = indexSelectionne;
}
/// <summary>
/// Permet d'obtenir la traduction d'un mot dans une langue
/// </summary>
/// <param name="motATraduire">Mot à traduire</param>
/// <param name="langueTraduction">Langue dans laquelle traduire</param>
/// <returns>Traduction du mot dans la langue souhaitée</returns>
public override Mot ObtenirTraduction(Mot motATraduire, string langueTraduction)
{
DataRow ligneMotTraductions = null; // Ligne de données d'un mot contenant toutes ses traductions
Mot traduction = null; // Mot contenant la traduction
string abrLangue = null; // Abréviation de la langue d'origine
string abrLangueTrad = null; // Abréviation de la langue de traduction
string commande = null; // Commande SQL à exécuter
// Obtient l'abréviation de la langue
abrLangue = ObtenirAbreviationLangue(motATraduire.Langue);
// Obtient l'abréviation de la langue de traduction
abrLangueTrad = ObtenirAbreviationLangue(langueTraduction);
// Met en forme la commande SQL
commande = "VO_id = " + motATraduire.IdUnique;
// Obtient toutes les traductions du mots
ligneMotTraductions = voc.Select(commande)[0];
// Crée un nouveau mot et insère la traduction si elle existe
if (!(ligneMotTraductions["VO_" + abrLangueTrad + "_nom"] is DBNull) && (ligneMotTraductions != null))
{
// Créer un nouveau mot contenant la traduction
traduction = new Mot();
traduction.IdUnique = (int)motATraduire.IdUnique;
traduction.Nom = (string)ligneMotTraductions["VO_" + abrLangueTrad + "_nom"];
traduction.Langue = langueTraduction;
traduction.Definition = (string)ligneMotTraductions["VO_" + abrLangueTrad + "_desc"];
}
// Retourne la traduction trouvée
return(traduction);
}
/// <summary>
/// Permet de modifier la traduction sélectionnée
/// </summary>
/// <param name="sender">Composant qui a envoyé l'événemenet</param>
/// <param name="e">Information sur l'événement</param>
private void btn_modif_trad_Click(object sender, EventArgs e)
{
Mot tradAModifier = null; // Traduction devant être modifié
Mot tradModifie = null; // Traduction avec les informations modifiées
int indexSelectionne = 0; // Index de la sélection
// Obtient le mot à modifier
tradAModifier = (Mot)lb_traductions.SelectedItem;
// Créé le mot modifié avec les nouvelles informations
tradModifie = new Mot();
tradModifie.IdUnique = tradAModifier.IdUnique;
tradModifie.Nom = tb_nom_trad.Text;
tradModifie.Definition = tb_definition_trad.Text;
tradModifie.Langue = cb_langues_trad.Text;
// Enlève le mot de la liste
lb_traductions.Items.Remove(tradAModifier);
// Modifie le mot dans le fichier XML
tradModifie = gestVoc.ModifierMot(tradAModifier, tradModifie);
// Ajoute le mot modifié dans la liste
indexSelectionne = lb_traductions.Items.Add(tradModifie);
// Sélectionne le mot
lb_traductions.SelectedIndex = indexSelectionne;
}
/// <summary>
/// Permet de supprimer une traduction
/// </summary>
/// <param name="traductionASupp">Traduction à supprimer</param>
public override void EffacerTraduction(Mot traductionASupp)
{
XmlNode noeudNom = null; // Noeud du nom
XmlNode noeudDef = null; // Noeud de la définition
XmlNode noeudMot = null; // Noeud du mot à supprimer
string abrLangueTrad = null; // Abréviation de la langue de traduction
// Vérifie que la traduction à supprimer est correct
if (traductionASupp == null || traductionASupp.Nom == "" || traductionASupp.Langue == "")
{
throw new Exception("Impossible de supprimer une traduction!");
}
// Cherche le noeud du mot à supprimer
noeudMot = _ChercherNoeudMot(traductionASupp);
// Obtient l'abréviation de la langue de traduction
abrLangueTrad = ObtenirAbreviationLangue(traductionASupp.Langue);
// Efface le nom et la définition du mot
noeudNom = noeudMot.SelectSingleNode(abrLangueTrad + "/nom");
noeudDef = noeudMot.SelectSingleNode(abrLangueTrad + "/definition");
noeudNom.InnerText = "";
noeudDef.InnerText = "";
}
/// <summary>
/// Permet de supprimer une traduction
/// </summary>
/// <param name="traductionASupp">Traduction à supprimer</param>
public override void EffacerTraduction(Mot traductionASupp)
{
DataRow ligneMotTradEffacee = null; // Ligne de données d'un mot contenant la traduction à effacer
string abrLangueTraduction = null; // Abréviation de la langue de traduction
string colonne_nom = null; // Nom de la colonne contenant le mot
string colonne_desc = null; // Nom de la colonne contenant la desciption
// Vérifie que la traduction à supprimer est correct
if (traductionASupp == null || traductionASupp.Nom == "" || traductionASupp.Langue == "")
{
throw new Exception("Impossible de supprimer une traduction!");
}
// Obtient l'abréviation de la langue
abrLangueTraduction = ObtenirAbreviationLangue(traductionASupp.Langue);
// Définit les noms des colonnes
colonne_nom = "VO_" + abrLangueTraduction + "_nom";
colonne_desc = "VO_" + abrLangueTraduction + "_desc";
// Recherche la traduction à effacer
ligneMotTradEffacee = voc.Select("VO_id = " + traductionASupp.IdUnique)[0];
// Efface la traduction
ligneMotTradEffacee[colonne_nom] = null;
ligneMotTradEffacee[colonne_desc] = null;
}
/// <summary>
/// Permet d'obtenir la traduction d'un mot dans une langue
/// </summary>
/// <param name="motATraduire">Mot à traduire</param>
/// <param name="langueTraduction">Langue dans laquelle traduire</param>
/// <returns>Traduction du mot dans la langue souhaitée</returns>
public override Mot ObtenirTraduction(Mot motATraduire, string langueTraduction)
{
XmlNodeList listeNoeudsTrad = null; // Liste de traductions dans le fichier Xml
XmlNode noeudMot = null; // Noeud du mot à traduire
string abrLangue = null; // Contient l'abréviation de la langue
string abrLangueTraduction = null; // Contient l'abréviation de la langue dans laquelle traduire
Mot traduction = new Mot(); // Mot traduit
// Obtient l'abréviation de la langue
abrLangue = ObtenirAbreviationLangue(motATraduire.Langue);
// Obtient l'abréviation de la langue de traduction
abrLangueTraduction = ObtenirAbreviationLangue(langueTraduction);
// Obtient la liste des traductions à partir du fichier XML
listeNoeudsTrad = fichierXml.SelectNodes("/vocaquiz/mot");
// Cherche le noeud du mot
noeudMot = _ChercherNoeudMot(motATraduire);
// Obtient la traduction
traduction.IdUnique = int.Parse(noeudMot.Attributes["id"].Value);
traduction.Nom = noeudMot.SelectSingleNode(abrLangueTraduction + "/nom").InnerText;
traduction.Definition = noeudMot.SelectSingleNode(abrLangueTraduction + "/definition").InnerText;
traduction.Langue = langueTraduction;
// Retourne la traduction du mot
return(traduction);
}
/// <summary>
/// Permet d'obtenir tous les mots d'une langue
/// </summary>
/// <param name="langue">Langue des mots à obtenir</param>
/// <returns>Liste de mots d'une langue</returns>
public override List <Mot> ObtenirTousMotsDansUneLangue(string langue)
{
XmlNodeList listeNoeudsMot = null; // Liste des noeuds de mots
XmlNode noeudNom = null; // Noeud du nom d'un mot
XmlNode noeudDef = null; // Noeud de la définition d'un mot
List <Mot> listeMots = new List <Mot>(); // Liste de mots dans une seule langue
Mot motAjoute = null; // Mot à ajouter dans la liste
string abrLangue = null; // Abréviation de la langue
int idUnique = 0; // Id unique du mot
// Obtient l'abréviation de la langue
abrLangue = ObtenirAbreviationLangue(langue);
// Obtient la liste des noeuds "Mot"
listeNoeudsMot = fichierXml.SelectNodes("/vocaquiz/mot");
// Cherche les mots dans la langue voulue
foreach (XmlNode noeudMot in listeNoeudsMot)
{
// Obtient l'id, le nom et la définition
idUnique = int.Parse(noeudMot.Attributes["id"].Value);
noeudNom = noeudMot.SelectSingleNode(abrLangue + "/nom");
noeudDef = noeudMot.SelectSingleNode(abrLangue + "/definition");
// Ajoute le mot dans la liste
motAjoute = new Mot(idUnique, noeudNom.InnerText, noeudDef.InnerText, langue);
listeMots.Add(motAjoute);
}
// Retourne la liste des mots d'une langue
return(listeMots);
}
/// <summary>
/// Permet de vérifier la traduction d'un mot
/// </summary>
/// <param name="repTraduction">Réponse donnée par l'utilisateur</param>
/// <returns>Résultat de la vérification</returns>
public bool VerifierTraduction(string repTraduction)
{
bool repCorrecte = false; // Indique si la traduction est correcte
// Obtient la traduction réelle du mot
traduction = gestVoc.ObtenirTraduction(motTeste, langueTrad);
// Vérifie que la traduction est correcte
repCorrecte = repTraduction == traduction.Nom;
// Incérmente le nombre de réponses
cptReponses++;
// Incrémente le nombre de réponses correctes ou fausses
if (repCorrecte)
{
nbreRepCorrectes++;
}
else
{
nbreRepFausses++;
}
// Retourne la résultat de la vérification
return(repCorrecte);
}
/// <summary>
/// Permet de supprimer le mot et ses traductions
/// </summary>
/// <param name="sender">Composant qui a envoyé l'événemenet</param>
/// <param name="e">Information sur l'événement</param>
private void btn_supp_mot_Click(object sender, EventArgs e)
{
Mot motASupp = null; // Mot à supprimer
try
{
// Obtient le mot de la liste
motASupp = (Mot)lb_mots.SelectedItem;
// Sélectionne le mot en dessus
if (lb_traductions.SelectedIndex > 0)
{
lb_traductions.SelectedIndex--;
}
else
{
lb_traductions.SelectedIndex = -1;
}
// Supprime le mot de la liste
lb_mots.Items.Remove(motASupp);
// Supprime le mot dans le gestionnaire
gestVoc.SupprimerMot(motASupp);
// Efface les informations du mot
tb_nom_mot.Text = "";
tb_definition_mot.Text = "";
}
catch (Exception exc)
{
// Affiche un message d'erreur
MessageBox.Show(exc.Message, "Erreur!", MessageBoxButtons.OK);
}
}
/// <summary>
/// Permet d'ajouter une traduction à un mot dans une autre langue
/// </summary>
/// <param name="motATraduire">Mot qui doit être traduit</param>
/// <param name="Traduction">Traduction du mot</param>
public override void AjouterTraduction(Mot motATraduire, Mot traduction)
{
XmlNode noeudMot = null; // Noeud du mot auquel il faut ajouter une traduction
XmlNode noeudNom = null; // Noeud du nom du mot
XmlNode noeudDef = null; // Noeud de la définition du mot
string abrNouvLangue = null; // Abréviation de la nouvelle langue
int idUnique = 0; // Id de du mot traduit
// Vérifie que le mot à traduire est valide
if (motATraduire == null || motATraduire.Nom == "" || motATraduire.Langue == "")
{
throw new Exception("Impossible d'ajouter une traduction!");
}
// Vérifie que la traduction est valide
if (traduction == null || traduction.Nom == "" || traduction.Langue == "")
{
throw new Exception("Impossible d'ajouter une traduction!");
}
// Vérifie que soit bien une traduction
if (traduction.Langue == motATraduire.Langue)
{
throw new Exception("Cette traduction n'est pas valide!");
}
// Cherche le noeud du mot à traduire
noeudMot = _ChercherNoeudMot(motATraduire);
// Obtient l'abréviation de la langue dans laquelle traduire
abrNouvLangue = ObtenirAbreviationLangue(traduction.Langue);
// Obtient les noeuds du nom et de la description pour la traduction
idUnique = int.Parse(noeudMot.Attributes["id"].Value);
noeudNom = noeudMot.SelectSingleNode(abrNouvLangue + "/nom");
noeudDef = noeudMot.SelectSingleNode(abrNouvLangue + "/definition");
// Insère les données de traduction
noeudNom.InnerText = traduction.Nom;
noeudDef.InnerText = traduction.Definition;
/*
* // Créer un noeud pour la nouvelle traduction
* noeudNouvLangue = fichierXml.CreateNode(XmlNodeType.Element, abrNouvLangue, "");
*
* // Créer les noeuds du nom et de la définition
* noeudNom = fichierXml.CreateNode(XmlNodeType.Element, "nom", "");
* noeudDef = fichierXml.CreateNode(XmlNodeType.Element, "definition", "");
*
* // Attache le nom et la définition avec la langue
* noeudNouvLangue.AppendChild(noeudNom);
* noeudNouvLangue.AppendChild(noeudDef);
*
* // Attache la nouvelle traduction
* noeudMot.AppendChild(noeudNouvLangue);
*/
}
/// <summary>
/// Permet de passer au mot suivant
/// </summary>
/// <param name="sender">Composant qui a envoyé l'événemenet</param>
/// <param name="e">Information sur l'événement</param>
private void btn_suivant_Click(object sender, EventArgs e)
{
string tradUtil = tb_traduction.Text; // Traduction de l'utilisateur
Mot motTeste = quiz.MotTeste; // Mot testé
// Efface le contenu dans les composants de réponse
tb_traduction.Text = "";
tb_trad_def.Text = "";
// Selon le mode, modifie la barre de progression
// et la condition de fin de la séquence
if (quiz.Mode == QuizMode.NORMAL)
{
// Met à jour la barre de progression
pb_chrono_rep.Value = quiz.CptReponses;
// Modifie les boutons accessibles
btn_verifier.Visible = true;
btn_suivant.Visible = false;
// Remet la couleur initiale à la boite de texte
tb_traduction.BackColor = Color.White;
// Choisit un nouveau mot à traduire et l'affiche
if (quiz.CptReponses != quiz.NombreMots)
{
ChoisirAfficherMot();
}
else
{
// Affiche le pourcentage de réussite
lbl_pourcentReussite.Text = "Pourcentage de réussite :" + quiz.CalculerPourcentageRepJustes().ToString() + "%";
// Débloque la configuration
pnl_config.Enabled = true;
// Bloque le quiz
pnl_quiz.Enabled = false;
}
}
else if (quiz.Mode == QuizMode.CHRONO)
{
// Vérifie la traduction de l'utilisateur
quiz.VerifierTraduction(tradUtil);
// Affiche le nombre de réponses justes ou fausses
lbl_repCorrectes.Text = "Réponses correctes : " + quiz.NbreRepCorrectes;
lbl_repFausses.Text = "Réponses fausses : " + quiz.NbreRepFausses;
// Incrémente le nombre de mots pour le calcul du pourcentage de réussite
quiz.NombreMots++;
// Affiche un nouveau mot à traduire
ChoisirAfficherMot();
}
}
/// <summary>
/// Permet d'obtenir et d'afficher un mot avec sa définition
/// </summary>
/// <returns>Mot choisi aléatoirement</returns>
private void ChoisirAfficherMot()
{
Mot motTeste = null; // Mot testé
// Choisit un mot de manière aléatoire
quiz.ChoisirMotAleatoire();
motTeste = quiz.MotTeste;
// Affiche le mot et sa définition
tb_mot.Text = motTeste.Nom;
tb_mot_def.Text = motTeste.Definition;
}
/// <summary>
/// Permet d'obtenir un mot aléatoire
/// </summary>
/// <returns>Mot choisi aléatoirement</returns>
public void ChoisirMotAleatoire()
{
int indexGenere = 0; // Index généré
int nombreMotsListe = 0; // Nombre de mots contenu dans la liste
// Obtient le nombre de mots contenu dans la liste
nombreMotsListe = listeMotsLangueOrigine.Count;
// Génère un index aléatoire
indexGenere = genAlea.Next(0, nombreMotsListe);
// Obtient le mot à traduire
motTeste = listeMotsLangueOrigine[indexGenere];
}
/// <summary>
/// Permet de modifier les caractéristiques d'un mot ou d'une traduction
/// </summary>
/// <param name="motAModifier">Mot à modifier</param>
/// <param name="motModifie">Mot avec les caractéristiques modifiées</param>
/// <returns>Mot modifié</returns>
public override Mot ModifierMot(Mot motAModifier, Mot motModifie)
{
DataRow ligneMotModifie = null; // Ligne de données contenant le mot et ses traductions à modifier
string colonne_nom = null; // Nom de la colonne contenant le mot
string colonne_desc = null; // Nom de la colonne contenant la desciption
string abrAncienneLangue = null; // Abréviation d'ancienne langue
string abrNouvelleLangue = null; // Abréviation de la nouvelle langue
// Vérifie que le mot à modifier est valide
if (motAModifier == null || motAModifier.Nom == "" || motAModifier.Langue == "")
{
throw new Exception("Impossible de modifier le mot!");
}
// Vérifie que le mot modifié est valide
if (motModifie == null || motModifie.Nom == "" || motModifie.Langue == "")
{
throw new Exception("Impossible de modifier le mot!");
}
// Ajoute l'id au mot modifié
motModifie.IdUnique = motAModifier.IdUnique;
// Obtient les abrévations des langues
abrAncienneLangue = ObtenirAbreviationLangue(motAModifier.Langue);
abrNouvelleLangue = ObtenirAbreviationLangue(motModifie.Langue);
// Recherche le mot à modifier à l'aide de l'id
ligneMotModifie = voc.Select("VO_id =" + motAModifier.IdUnique)[0];
// Définit les noms des colonnes pour l'ancienne langue
colonne_nom = "VO_" + abrAncienneLangue + "_nom";
colonne_desc = "VO_" + abrAncienneLangue + "_desc";
// Efface le mot dans l'ancienne langue
ligneMotModifie[colonne_nom] = null;
ligneMotModifie[colonne_desc] = null;
// Définit les noms des colonnes pour la nouvelle langue
colonne_nom = "VO_" + abrNouvelleLangue + "_nom";
colonne_desc = "VO_" + abrNouvelleLangue + "_desc";
// Remet le mot dans la nouvelle langue
ligneMotModifie[colonne_nom] = motModifie.Nom;
ligneMotModifie[colonne_desc] = motModifie.Definition;
// Retourne le mot modifié
return(motModifie);
}
/// <summary>
/// Permet d'obtenir la liste de mots ayant des traductions
/// </summary>
/// <param name="langue">Langue d'origine</param>
/// <param name="langueTrad">Langue de traduction</param>
/// <returns>Liste de mots dans la langue d'origine ayant des traductions</returns>
public override List <Mot> ObtenirMotsAvecTraductionsExistantes(string langue, string langueTraduction)
{
XmlNodeList listeNoeudsTrad = null; // Liste de traductions dans le fichier Xml
string nomMotLangue; // Nom du mot dans la langue d'origine
string nomMotLangueTrad; // Nom du mot dans la langue de traduction
string abrLangue = null; // Contient l'abréviation de la langue
string abrLangueTraduction = null; // Contient l'abréviation de la langue dans laquelle traduire
List <Mot> listeMotsValides; // Contient les mots qui ont une traduction pour les deux langues
Mot motValide; // Mot ayant une traduction pour les deux langues
// Obtient l'abréviation de la langue
abrLangue = ObtenirAbreviationLangue(langue);
// Obtient l'abréviation de la langue de traduction
abrLangueTraduction = ObtenirAbreviationLangue(langueTraduction);
// Obtient la liste des traductions à partir du fichier XML
listeNoeudsTrad = fichierXml.SelectNodes("/vocaquiz/mot");
// Crée une liste de mots dans la langue d'origine ayant des traductions pour la langue de traduction choisie
listeMotsValides = new List <Mot>();
// Ajoute les mots valides dans la liste
foreach (XmlNode noeudMot in listeNoeudsTrad)
{
// Obtient le nom du mot dans la langue d'origine
nomMotLangue = noeudMot.SelectSingleNode(abrLangue + "/nom").InnerText;
// Obtient le nom du mot dans la langue de traduction
nomMotLangueTrad = noeudMot.SelectSingleNode(abrLangueTraduction + "/nom").InnerText;
// Vérifie que les mots sont valides
if (nomMotLangue != "" && nomMotLangueTrad != "")
{
// Ajoute les informations du mot dans un objet "Mot"
motValide = new Mot();
motValide.IdUnique = int.Parse(noeudMot.Attributes["id"].Value);
motValide.Nom = noeudMot.SelectSingleNode(abrLangue + "/nom").InnerText;
motValide.Definition = noeudMot.SelectSingleNode(abrLangue + "/definition").InnerText;
motValide.Langue = langue;
// Ajoute l'objet dans la liste
listeMotsValides.Add(motValide);
}
}
// Retourne la liste de mots dans la langue d'origine ayant des traductions pour la langue de traduction
return(listeMotsValides);
}
/// <summary>
/// Permet de modifier les caractéristiques d'un mot ou d'une traduction
/// </summary>
/// <param name="motAModifier">Mot à modifier</param>
/// <param name="motModifie">Mot avec les caractéristiques modifiées</param>
/// <returns>Mot modifié</returns>
public override Mot ModifierMot(Mot motAModifier, Mot motModifie)
{
XmlNode noeudMotAModifier = null; // Noeud du mot à modifier
XmlNode noeudNom = null; // Noeud du nom du mot
XmlNode noeudDef = null; // Noeud de la définition du mot
string abrAncienneLangue = null; // Abréviation d'ancienne langue
string abrNouvelleLangue = null; // Abréviation de la nouvelle langue
// Vérifie que le mot à modifier est valide
if (motAModifier == null || motAModifier.Nom == "" || motAModifier.Langue == "")
{
throw new Exception("Impossible de modifier le mot!");
}
// Vérifie que le mot modifié est valide
if (motModifie == null || motModifie.Nom == "" || motModifie.Langue == "")
{
throw new Exception("Impossible de modifier le mot!");
}
// Cherche le noeud du mot à modifier
noeudMotAModifier = _ChercherNoeudMot(motAModifier);
// Ajoute l'id
motModifie.IdUnique = motAModifier.IdUnique;
// Obtient les abrévations des langues
abrAncienneLangue = ObtenirAbreviationLangue(motAModifier.Langue);
abrNouvelleLangue = ObtenirAbreviationLangue(motModifie.Langue);
// Efface le mot dans l'ancienne langue
noeudNom = noeudMotAModifier.SelectSingleNode(abrAncienneLangue + "/nom");
noeudDef = noeudMotAModifier.SelectSingleNode(abrAncienneLangue + "/definition");
noeudNom.InnerText = "";
noeudDef.InnerText = "";
// Remet le mot dans la nouvelle langue
noeudNom = noeudMotAModifier.SelectSingleNode(abrNouvelleLangue + "/nom");
noeudDef = noeudMotAModifier.SelectSingleNode(abrNouvelleLangue + "/definition");
noeudNom.InnerText = motModifie.Nom;
noeudDef.InnerText = motModifie.Definition;
// Sauvegarde le fichier
//SauvegarderVoc();
// Retourne le mot modifié
return(motModifie);
}
/// <summary>
/// Permet d'afficher les informations d'une traduction
/// </summary>
/// <param name="sender">Composant qui a envoyé l'événemenet</param>
/// <param name="e">Information sur l'événement</param>
private void lb_traductions_SelectedIndexChanged(object sender, EventArgs e)
{
Mot traduction = null; // Traduction sélectionnée dans la liste
// Vérifie que l'index est valide
if (lb_traductions.SelectedIndex != -1)
{
// Obtient la traduction dans la liste
traduction = (Mot)lb_traductions.SelectedItem;
// Affiche les informations de la traduction
tb_nom_trad.Text = traduction.Nom;
tb_definition_trad.Text = traduction.Definition;
cb_langues_trad.Text = traduction.Langue;
}
}
/// <summary>
/// Permet d'obtenir toutes les traductions d'un mot dans une langue
/// </summary>
/// <param name="mot">Mot à traduire</param>
/// <param name="langue">Langue du mot</param>
/// <returns>Liste des traductions pour le mot</returns>
public override List <Mot> ObtenirToutesTraductions(Mot motATraduire)
{
List <Mot> listeTraductions = null; // Liste de traductions pour le mot
DataRow ligneMotTraductions = null; // Ligne de données d'un mot contenant toute les traductions
Mot traduction = null; // Mot contenant une des traductions
string abrLangue = null; // Abréviation de la langue
string abrLangueTrad = null; // Abréviation de la langue de traduction
string commande = null; // Commande SQL à exécuter
// Obtient l'abréviation de la langue
abrLangue = ObtenirAbreviationLangue(motATraduire.Langue);
// Met en forme la commande SQL
commande = "VO_id = " + motATraduire.IdUnique;
// Obtient toutes les traductions du mot
ligneMotTraductions = voc.Select(commande)[0];
// Crée la liste de traductions
listeTraductions = new List <Mot>();
// Obtient chaque traduction et l'ajoute dans la liste
foreach (string langue in listeLangues)
{
// Obtient l'abréviation de la langue de traduction
abrLangueTrad = ObtenirAbreviationLangue(langue);
// Vérifie que la traduction existe et qu'elle soit différente de la langue à traduire
if (!(ligneMotTraductions["VO_" + abrLangueTrad + "_nom"] is DBNull) && (langue != motATraduire.Langue))
{
// Crée un nouveau mot contenant la traduction
traduction = new Mot();
traduction.IdUnique = (int)motATraduire.IdUnique;
traduction.Nom = (string)ligneMotTraductions["VO_" + abrLangueTrad + "_nom"];
traduction.Langue = langue;
traduction.Definition = (string)ligneMotTraductions["VO_" + abrLangueTrad + "_desc"];
// Ajoute la traduction dans la liste
listeTraductions.Add(traduction);
}
}
// Retourne la liste des traductions
return(listeTraductions);
}
/// <summary>
/// Permet de supprimer un mot (Toutes traductions comprises)
/// </summary>
/// <param name="motASupp">Mot à supprimer</param>
public override void SupprimerMot(Mot motASupp)
{
XmlNode noeudRacine = null; // Noeud de la racine
XmlNode noeudMot = null; // Noeud du mot à supprimer
// Vérifie que le mot à supprimer est correct
if (motASupp == null || motASupp.Nom == "" || motASupp.Langue == "")
{
throw new Exception("Impossible de supprimer!");
}
// Cherche le noeud du mot à supprimer
noeudMot = _ChercherNoeudMot(motASupp);
// Supprime le noeud dans le fichier XML
noeudRacine = fichierXml.SelectSingleNode("/vocaquiz");
noeudRacine.RemoveChild(noeudMot);
}
/// <summary>
/// Permet d'ajouter une traduction à un mot dans une autre langue
/// </summary>
/// <param name="motATraduire">Mot qui doit être traduit</param>
/// <param name="Traduction">Traduction du mot</param>
public override void AjouterTraduction(Mot motATraduire, Mot traduction)
{
DataRow ligneMotNouvelleTrad = null; // Ligne de données d'un mot recevant la nouvelle traduction
string abrLangueTraduction = null; // Abréviation de la langue de traduction
string colonne_nom = null; // Nom de la colonne contenant le mot
string colonne_desc = null; // Nom de la colonne contenant la desciption
// Vérifie que le mot à traduire est valide
if (motATraduire == null || motATraduire.Nom == "" || motATraduire.Langue == "")
{
throw new Exception("Impossible d'ajouter une traduction!");
}
// Vérifie que la traduction est valide
if (traduction == null || traduction.Nom == "" || traduction.Langue == "")
{
throw new Exception("Impossible d'ajouter une traduction!");
}
// Vérifie que soit bien une traduction
if (traduction.Langue == motATraduire.Langue)
{
throw new Exception("Cette traduction n'est pas valide!");
}
// Vérifie que la traduction n'existe pas déjà
/*if (ChercherNoeudMot(traduction) != null)
* throw new Exception("Cette traduction existe déjà!");*/
// Obtient l'abréviation de la langue
abrLangueTraduction = ObtenirAbreviationLangue(traduction.Langue);
// Définit les noms des colonnes
colonne_nom = "VO_" + abrLangueTraduction + "_nom";
colonne_desc = "VO_" + abrLangueTraduction + "_desc";
// Recherche la ligne contenant le mot devant être traduit
ligneMotNouvelleTrad = voc.Select("VO_id = " + motATraduire.IdUnique)[0];
// Insère les informations de traductions
ligneMotNouvelleTrad[colonne_nom] = traduction.Nom;
ligneMotNouvelleTrad[colonne_desc] = traduction.Definition;
}
/// <summary>
/// Permet d'ajouter un nouveau mot dans une langue
/// </summary>
/// <param name="nouveauMot">Mot à ajouter</param>
/// <returns>Id unique du mot</returns>
public override int CreerMot(Mot nouveauMot)
{
DataRow ligneMotAjoute = null; // Ligne de données contenant le mot et ses traductions à ajouter
string abrLangue = null; // Abréviation de la langue du mot
string colonne_nom = null; // Nom de la colonne contenant le mot
string colonne_desc = null; // Nom de la colonne contenant la desciption
int idUnique = 0; // Id unique généré
// Vérifie que le mot reçu est valide
if (nouveauMot == null || nouveauMot.Nom == "" || nouveauMot.Langue == "")
{
throw new Exception("Impossible de créer le mot!");
}
// Obtient l'abréviation de la langue
abrLangue = ObtenirAbreviationLangue(nouveauMot.Langue);
// Définit les noms des colonnes
colonne_nom = "VO_" + abrLangue + "_nom";
colonne_desc = "VO_" + abrLangue + "_desc";
// Ajoute un nouveau mot dans la base de données locale (en mémoire)
ligneMotAjoute = voc.NewRow();
ligneMotAjoute[colonne_nom] = nouveauMot.Nom;
ligneMotAjoute[colonne_desc] = nouveauMot.Definition;
voc.Rows.Add(ligneMotAjoute);
// Obtient l'id
idUnique = (int)ligneMotAjoute["VO_id"];
// Met en forme la commande d'ajout
/*commandeAjout = "INSERT INTO " + nomTable + " (" + colonne_nom + ", " + colonne_desc + ") ";
* commandeAjout += "VALUES ('" + nouveauMot.Nom + "', '" + nouveauMot.Definition + "')";
*
* // Créer une nouvelle commande pour l'insertion
* bdAdaptateur.InsertCommand = bdConnexion.CreateCommand();
* bdAdaptateur.InsertCommand.CommandText = commandeAjout;*/
// Retourne l'id du nouveau mot
return(idUnique);
}
/// <summary>
/// Permet de supprimer un mot (Toutes traductions comprises)
/// </summary>
/// <param name="motASupp">Mot à supprimer</param>
public override void SupprimerMot(Mot motASupp)
{
DataRow ligneMotSupprime = null; // Ligne de données contenant le mot et ses traductions devant être supprimés
// Vérifie que le mot à supprimer est correct
if (motASupp == null || motASupp.Nom == "" || motASupp.Langue == "")
{
throw new Exception("Impossible de supprimer!");
}
// Recherche la ligne à supprimer
ligneMotSupprime = voc.Select("VO_id = " + motASupp.IdUnique)[0];
// Supprime la ligne
ligneMotSupprime.Delete();
// FONCTIONNE PAS AVEC REMOVE !
// Supprime la ligne de la base de données
//voc.Rows.Remove(ligneMotSupprime);
}
/// <summary>
/// Permet d'obtenir toutes les traductions d'un mot d'une langue
/// </summary>
/// <param name="mot">Mot à traduire</param>
/// <param name="langue">Langue du mot</param>
/// <returns>Liste des traductions pour le mot</returns>
public override List <Mot> ObtenirToutesTraductions(Mot motATraduire)
{
XmlNodeList listeNoeudsTrad = null; // Liste de traduction dans le fichier Xml
XmlNode noeudMot = null; // Noeud du mot à traduire dans toutes les langues possibles
string abrLangue = null; // Contient l'abréviation de la langue
string abrLangueTraduction = null; // Contient l'abréviation de la langue dans laquelle traduire
List <Mot> listeTraductions = new List <Mot>(); // Contient toutes les traductions du mot
Mot traduction = null; // Mot traduit
// Obtient l'abréviation de la langue
abrLangue = ObtenirAbreviationLangue(motATraduire.Langue);
// Obtient la liste des traductions à partir du fichier XML
listeNoeudsTrad = fichierXml.SelectNodes("/vocaquiz/mot");
// Cherche le noeud du mot
noeudMot = _ChercherNoeudMot(motATraduire);
// Obtient les traductions
foreach (string langue in listeLangues)
{
if (langue != motATraduire.Langue)
{
// Obtient l'abréviation de la langue de traduction
abrLangueTraduction = ObtenirAbreviationLangue(langue);
// Crée un nouveau mot contenant la traduction
traduction = new Mot();
traduction.IdUnique = int.Parse(noeudMot.Attributes["id"].Value);
traduction.Nom = noeudMot.SelectSingleNode(abrLangueTraduction + "/nom").InnerText;
traduction.Definition = noeudMot.SelectSingleNode(abrLangueTraduction + "/definition").InnerText;
traduction.Langue = langue;
// Ajoute la traduction dans la liste
listeTraductions.Add(traduction);
}
}
// Retourne les traductions du mot
return(listeTraductions);
}
/// <summary>
/// Permet d'obtenir un mot par l'index
/// </summary>
/// <param name="index">Index d'une liste</param>
/// <param name="langue">Langue du mot</param>
/// <returns>Mot correspondant à l'index</returns>
public override Mot ChercherMotParIndex(int index, string langue)
{
XmlNode noeudMot = null; // Noeud du mot trouvé à l'aide de l'index
Mot motTrouve = null; // Mot trouvé
string abrLangue = null; // Abréviation de la langue
// Obtient l'abréviation de la langue
abrLangue = ObtenirAbreviationLangue(langue);
// Obtient le noeud du mot à l'index mentionné
noeudMot = fichierXml.SelectNodes("/vocaquiz/mot")[index];
// Insère les informations du mot trouvé
motTrouve = new Mot();
motTrouve.IdUnique = int.Parse(noeudMot.Attributes["id"].Value);
motTrouve.Nom = noeudMot.SelectSingleNode(abrLangue + "/nom").InnerText;
motTrouve.Definition = noeudMot.SelectSingleNode(abrLangue + "/definition").InnerText;
motTrouve.Langue = langue;
// Retourne le mot trouvé
return(motTrouve);
} /// <summary>
/// <summary>
/// Permet d'obtenir la liste de mots ayant des traductions
/// </summary>
/// <param name="langue">Langue d'origine</param>
/// <param name="langueTrad">Langue de traduction</param>
/// <returns>Liste de mots ayant des traductions pour la langue de traduction</returns>
public override List <Mot> ObtenirMotsAvecTraductionsExistantes(string langue, string langueTraduction)
{
DataRow[] lignesMotsTraductions = null; // Lignes de données contenant les mots et traductions valides
string abrLangue = null; // Contient l'abréviation de la langue
string abrLangueTraduction = null; // Contient l'abréviation de la langue dans laquelle traduire
string commande = null; // Commande SQL à exécuter
List <Mot> listeMotsValides = null; // Contient les mots qui ont une traduction pour la langue choisie
Mot motValide = null; // Mot ayant une traduction pour la langue choisie
// Obtient l'abréviation de la langue
abrLangue = ObtenirAbreviationLangue(langue);
// Obtient l'abréviation de la langue de traduction
abrLangueTraduction = ObtenirAbreviationLangue(langueTraduction);
// Obtient la table des mots et traductions valides
commande = "VO_" + abrLangue + "_nom IS NOT NULL AND VO_" + abrLangueTraduction + "_nom IS NOT NULL";
lignesMotsTraductions = voc.Select(commande);
// Crée une liste de mots dans la langue d'origine ayant des traductions pour la langue de traduction choisie
listeMotsValides = new List <Mot>();
// Insère les informations dans des objets "Mot"
foreach (DataRow ligneMotTrad in lignesMotsTraductions)
{
// Créé un nouvel objet "Mot" et insére les informations
motValide = new Mot();
motValide.IdUnique = (int)ligneMotTrad["VO_id"];
motValide.Nom = (string)ligneMotTrad["VO_" + abrLangue + "_nom"];
motValide.Definition = (string)ligneMotTrad["VO_" + abrLangue + "_desc"];
motValide.Langue = langue;
// Ajoute le mot dans la liste
listeMotsValides.Add(motValide);
}
// Retourne la liste de mots dans la langue d'origine ayant des traductions pour la langue de traduction
return(listeMotsValides);
}
/// <summary>
/// Permet d'obtenir un mot par l'index
/// </summary>
/// <param name="index">Index d'une liste</param>
/// <param name="langue">Langue du mot</param>
/// <returns>Mot correspondant à l'index</returns>
public override Mot ChercherMotParIndex(int index, string langue)
{
DataRow ligneTraductions = null; // Ligne de données contenant toutes les traductions
Mot motTrouve = null; // Mot trouvé avec l'index donné
string abrLangue = null; // Abréviation de la langue
string commande = null; // Commande à exécuter
// Obtient l'abréviation de la langue
abrLangue = ObtenirAbreviationLangue(langue);
// Met en forme la commande
commande = "VO_id = " + index;
// Obtient toutes les traductions
ligneTraductions = voc.Select(commande)[0];
// Créer un nouveau mot et insère la traduction si elle existe
if (!(ligneTraductions["VO_" + abrLangue + "_nom"] is DBNull))
{
// Créer un nouveau mot contenant la traduction
motTrouve = new Mot();
motTrouve.IdUnique = index;
motTrouve.Nom = (string)ligneTraductions["VO_" + abrLangue + "_nom"];
motTrouve.Langue = langue;
// Ajoute la définition si elle existe
if (ligneTraductions["VO_" + abrLangue + "_desc"] is DBNull)
{
motTrouve.Definition = "";
}
else
{
motTrouve.Definition = (string)ligneTraductions["VO_" + abrLangue + "_desc"];
}
}
// Retourne le mot trouvé
return(motTrouve);
}
/// <summary>
/// Permet d'obtenir tous les mots d'une langue
/// </summary>
/// <param name="langue">Langue des mots à obtenir</param>
/// <returns>Liste de mots dans une langue</returns>
public override List <Mot> ObtenirTousMotsDansUneLangue(string langue)
{
List <Mot> listeMotsUneLangue = null; // Liste de mots dans une langue
DataRow[] lignesMot = null; // Lignes de données contenant des mots dans la langue voulue
Mot motTrouve = null; // Mot trouvé dans la langue voulue
string abrLangue = null; // Abréviation de la langue
string commande = null; // Commande SQL à exécuter
// Obtient l'abréviation de la langue
abrLangue = ObtenirAbreviationLangue(langue);
// Met en forme la commande SQL
commande = "VO_" + abrLangue + "_nom IS NOT NULL";
// Obtient les lignes correspondant à la requête
lignesMot = voc.Select(commande);
// Crée la liste de mots
listeMotsUneLangue = new List <Mot>();
// Insère les données dans des objets "Mots"
foreach (DataRow ligneMot in lignesMot)
{
// Créer un nouveau mot et insère les données
motTrouve = new Mot();
motTrouve.IdUnique = (int)ligneMot["VO_id"];
motTrouve.Nom = (string)ligneMot["VO_" + abrLangue + "_nom"];
motTrouve.Langue = langue;
motTrouve.Definition = (string)ligneMot["VO_" + abrLangue + "_desc"];
// Ajoute dans la liste le mot
listeMotsUneLangue.Add(motTrouve);
}
// Retourne la liste de mots d'une langue
return(listeMotsUneLangue);
}
/// <summary>
/// Permet de supprimer une traduction
/// </summary>
/// <param name="sender">Composant qui a envoyé l'événemenet</param>
/// <param name="e">Information sur l'événement</param>
private void btn_supp_trad_Click(object sender, EventArgs e)
{
Mot traductionASupp = null; // Traduction à supprimer
try
{
// Obtient le mot de la liste
traductionASupp = (Mot)lb_traductions.SelectedItem;
// Sélectionne le mot en dessus
if (lb_traductions.SelectedIndex > 0)
{
lb_traductions.SelectedIndex--;
}
else
{
lb_traductions.SelectedIndex = -1;
}
// Supprime le mot de la liste
lb_traductions.Items.Remove(traductionASupp);
// Efface la traduction dans le fichier XML
gestVoc.EffacerTraduction(traductionASupp);
// Efface les informations affichée
tb_nom_trad.Text = "";
tb_definition_trad.Text = "";
cb_langues_trad.Text = "";
}
catch (Exception exc)
{
// Affiche un message d'erreur
MessageBox.Show(exc.Message, "Erreur!", MessageBoxButtons.OK);
}
}