Esempio n. 1
0
 public SylAction(string name, SylConfig inSylConf, int inButNr, CharFormatting inPrevCF)
     : base(name)
 {
     type    = SylActionType.clearBut;
     sylConf = inSylConf;
     butNr   = inButNr;
     prevCF  = inPrevCF;
 }
Esempio n. 2
0
 public SylAction(string name, SylConfig inSylConf,
                  ExceptionMots inPrevExcMots, ExceptionMots inNewExcMots)
     : base(name)
 {
     type        = SylActionType.exceptMots;
     sylConf     = inSylConf;
     prevExcMots = inPrevExcMots;
     newExcMots  = inNewExcMots;
 }
Esempio n. 3
0
 public SylAction(string name, SylConfig inSylConf,
                  int inPrevNrPieds, int inNewNrPieds)
     : base(name)
 {
     type        = SylActionType.nbrePieds;
     sylConf     = inSylConf;
     prevNrPieds = inPrevNrPieds;
     newNrPieds  = inNewNrPieds;
 }
Esempio n. 4
0
 public SylAction(string name, SylConfig inSylConf,
                  SylConfig.Mode inPrevMode, SylConfig.Mode inNewMode)
     : base(name)
 {
     type     = SylActionType.mode;
     sylConf  = inSylConf;
     prevMode = inPrevMode;
     newMode  = inNewMode;
 }
Esempio n. 5
0
 /// <summary>
 /// Crée une action de modification d'un booléen - "doubleCons", "marquerMuettes" ou
 /// "dierese"
 /// </summary>
 /// <param name="name">le nom de l'action.</param>
 /// <param name="inType">Le type de l'action. "doubleCons", "marquerMuettes" ou
 /// "dierese"</param>
 /// <param name="inSylConf">La <see cref="SylConfig"/> sur laquelle l'action agit.</param>
 /// <param name="inPrevVal">La valeur du booléen avant l'action.</param>
 /// <param name="inNewVal">La valeur du booléen après l'action.</param>
 public SylAction(string name, SylActionType inType, SylConfig inSylConf,
                  bool inPrevVal, bool inNewVal)
     : base(name)
 {
     type        = inType;
     sylConf     = inSylConf;
     prevBoolVal = inPrevVal;
     newBoolVal  = inNewVal;
 }
Esempio n. 6
0
 public SylAction(string name, SylConfig inSylConf, int inButNr, int inPrevNrSetBut,
                  CharFormatting inPrevCF, CharFormatting inNewCF)
     : base(name)
 {
     type             = SylActionType.sylBut;
     sylConf          = inSylConf;
     prevNrSetButtons = inPrevNrSetBut;
     butNr            = inButNr;
     prevCF           = inPrevCF;
     newCF            = inNewCF;
 }
Esempio n. 7
0
        // ---------------------------------------------- Methods ----------------------------------

        /// <summary>
        /// Crée une config par défaut pour les différents membres.
        /// </summary>
        private void InitCtor()
        {
            logger.ConditionalDebug("InitCtor");
            pBDQ     = new PBDQConfig();
            sylConf  = new SylConfig();
            unsetBeh = new UnsetBehConf();
            colors   = new Dictionary <PhonConfType, ColConfWin>(2);
            colors[PhonConfType.muettes]  = new ColConfWin(PhonConfType.muettes);
            colors[PhonConfType.phonemes] = new ColConfWin(PhonConfType.phonemes);
            _duoConf   = null;
            _arcConf   = new ArcConfig();
            _ponctConf = new PonctConfig();
        }
Esempio n. 8
0
        /// <summary>
        /// Calcule les syllabes avec la <see cref="Config"/> donnée. La liste 'syls' est remplie.
        /// </summary>
        /// <param name="forceDierese">Indique s'il faut forcer la diérèse. Si <c>true</c> les
        /// 'i' suivis de voyelle comme dans 'hier' sont considérés comme une syllabe à part:
        /// 'hi-er'. Si <c>false</c> 'hier' correspond à une seule syllabe.</param>
        public void ComputeSyls(bool forceDierese = false)
        {
            logger.ConditionalTrace(ConfigBase.cultF, "ComputeAndColorSyls {0}", GetWord());
            SylInW    siw;
            int       i, j;
            SylConfig sylConfig = theConf.sylConf;

            // Algorithme de Marie-Pierre
            syls = new List <SylInW>((Last - First) / 2);

            // créons une syllabe pour chaque phonème
            for (i = 0; i < phons.Count; i++)
            {
                syls.Add(new SylInW(phons[i]));
            }

            logger.ConditionalTrace("Etape 1 {0} --> {1}, {2}", GetWord(), Syllabes(), GetPhonSyllabes());

            if (syls.Count > 1)
            {
                // Si le décodage est standard dupliquer les phonèmes qui comportent des consonnes doubles
                if (sylConfig.DoubleConsStd)
                {
                    for (i = 0; i < syls.Count; i++)
                    {
                        if (syls[i].EstConsonneRedoublee())
                        {
                            siw = new SylInW(syls[i]);
                            syls[i].ReduitADerniereLettre();
                            siw.ReduitAPremiereLettre();
                            syls.Insert(i, siw);
                        }
                    }
                }
                logger.ConditionalTrace("Etape 2 {0} --> {1}, {2}", GetWord(), Syllabes(), GetPhonSyllabes());

                // Il y a une série de cas spéciaux où deux sons ne forment qu'une syllabe
                // par exemple [bkptgdfv][lR] ou [y][i] ou [u]([i]|[e_tilda]|[o_tilda])
                // (la notation est un peu libre :-)
                for (i = 0; i < syls.Count - 1; i++)
                {
                    if (FusionnerSyllabes(syls, i, i + 1, forceDierese))
                    {
                        // mixer les deux phonèmes puis raccourcir la chaîne
                        syls[i].AbsorbeSuivant(syls[i + 1]);
                        syls.RemoveAt(i + 1);
                        logger.ConditionalTrace("Etape 3-{0} {1} --> {2}, {3}", i, GetWord(), Syllabes(), GetPhonSyllabes());
                        i--; // faire en sorte que la prochaine itération considère le nouveau
                             // phonème fusionné et son successeur
                    }
                }

                // construire les syllabes par association de phonèmes consonnes et voyelles
                // Les syllabes sont constituées de tout ce qui précède un phonème voyelle
                // jusqu'à la syllabe précédente ou le début du mot.
                // De plus si le phonème voyelle est suivi de deux consonnes, la première fait
                // partie de la première syllabe.

                i = 0;
                j = 0; // début de la syllabe
                while (i < syls.Count)
                {
                    logger.ConditionalTrace("Etape fusion consonnes et voyelles i:{0}, j:{1} {2} --> {3}, {4}"
                                            , i, j, GetWord(), Syllabes(), GetPhonSyllabes());
                    if (syls[i].EstVoyelle(forceDierese))
                    {
                        // fusionner les syllabes de j à i
                        for (int k = 0; k < (i - j); k++)
                        {
                            syls[j].AbsorbeSuivant(syls[j + 1]);
                            syls.RemoveAt(j + 1);
                        }
                        i = j;
                        j++;
                        logger.ConditionalTrace("Etape 4A i:{0}, j:{1} {2} --> {3}, {4}",
                                                i, j, GetWord(), Syllabes(), GetPhonSyllabes());

                        // si les deux lettres qui suivent sont des consonnes, la première fait partie de la syllabe que nous venons de créer
                        // A condition qu'elles ne soient pas toutes les deux dans la même syllabe.
                        if (j < syls.Count)
                        {
                            int pos = syls[j].First; // position de la lettre suivante dans le texte sous-jacent
                            if (syls[j].Last == syls[j].First &&
                                pos < this.Last &&
                                EstConsonne(GetChar(pos)) &&
                                EstConsonne(GetChar(pos + 1)))
                            {
                                syls[j - 1].EtendDroite(1);
                                if (!syls[j].ReduitGauche(1))
                                {
                                    syls.RemoveAt(j);
                                }
                            }
                        }
                        logger.ConditionalTrace("Etape 4B i:{0}, j:{1} {2} --> {3}, {4}",
                                                i, j, GetWord(), Syllabes(), GetPhonSyllabes());
                    }
                    i++;
                } // while

                logger.ConditionalTrace("Etape 5 i:{0}, j:{1} {2} --> {3}, {4}",
                                        i, j, GetWord(), Syllabes(), GetPhonSyllabes());

                // précaution de base : si pas de syllabes reconnues, on concatène simplement les phonèmes
                if (j == 0)
                {
                    // le mot ne comprend pas de voyelles --> une seule syllabe
                    syls.Clear();
                    siw = new SylInW(this, this.First, this.Last, Phonemes.firstPhon);
                    syls.Add(siw);
                    logger.ConditionalTrace("Etape 6A i:{0}, j:{1} {2} --> {3}, {4}",
                                            i, j, GetWord(), Syllabes(), GetPhonSyllabes());
                }
                else
                {
                    // il ne doit rester à la fin que les lettres muettes ou des consonnes qu'on ajoute à la dernière syllabe
                    while (j < syls.Count)
                    {
                        syls[j - 1].AbsorbeSuivant(syls[j]);
                        syls.RemoveAt(j);
                        j++;
                    }
                    logger.ConditionalTrace("Etape 6B i:{0}, j:{1} {2} --> {3}, {4}",
                                            i, j, GetWord(), Syllabes(), GetPhonSyllabes());
                }
                // ###############################################################################
                // # Traitement spécial de de la dernière syllabe dans les modes oral et poésie. #
                // ###############################################################################

                if ((syls.Count > 1) && (syls[syls.Count - 1].P == Phonemes.q_caduc))
                {
                    // s'il y a plus d'une syllabe, il y a aussi plus d'un phonème
                    if (sylConfig.mode == SylConfig.Mode.oral)
                    {
                        // si nous sommes en mode oral, les e caducs des dernières syllabes
                        // doivent être concaténés avec la syllabe précédente
                        syls[syls.Count - 2].AbsorbeSuivant(syls[syls.Count - 1]);
                        syls.RemoveAt(syls.Count - 1);
                        logger.ConditionalTrace("Etape 7A {0} --> {1}, {2}",
                                                GetWord(), Syllabes(), GetPhonSyllabes());
                    }
                    else if (sylConfig.mode == SylConfig.Mode.poesie)
                    {
                        logger.ConditionalTrace("Mode poésie. Syllabes avant le traitement: {0}",
                                                Syllabes());
                        // voir http://mamiehiou.over-blog.com/article-versification-comment-compter-les-pieds-syllabes-d-un-vers-97149081.html
                        // dont nous nous inspirons ici. Il faut toutefois noter que quand le
                        // "e" ne compte pas pour un pied, nous le relions simplement avec la
                        // syllabe précédente, ce qui n'est pas tout à fait correct au niveau
                        // de la prononciation.

                        // En gros on peut dire que si le mot suivant commence par une voyelle
                        // (ou équivalent), le e-caduc ne se prononce pas, sauf s'il y a une laison.
                        // Si le mot suivant commence par une consonne (ou équivalent) le e-caduc
                        // se prononce.

                        string txt = T.ToLowerString();
                        string wrd = ToLowerString();
                        ComportementMotSuivant cms = ComportementMotSuivant.undef;

                        int startNextWord = Last + 1;
                        // cherchons le début du prochain mot (ou la fin de ligne...)
                        while (startNextWord < txt.Length &&
                               (txt[startNextWord] == ' ' ||
                                txt[startNextWord] == '\t' ||
                                txt[startNextWord] == ',' || // la virgule n'empêche pas l'influence du mot suivant.
                                txt[startNextWord] == '!' || // ça pourrait dépendre des situations...
                                txt[startNextWord] == '?' || // ça pourrait dépendre des situations...
                                txt[startNextWord] == '.' || // ça pourrait dépendre des situations...
                                txt[startNextWord] == '"' ||
                                txt[startNextWord] == '«' ||
                                txt[startNextWord] == '»' ||
                                txt[startNextWord] == '“' ||
                                txt[startNextWord] == '”' ||
                                txt[startNextWord] == '‘' ||
                                txt[startNextWord] == '’' ||
                                txt[startNextWord] == '-' ||
                                txt[startNextWord] == '—' ||
                                txt[startNextWord] == ';' ||
                                txt[startNextWord] == ':' // ça pourrait dépendre des situations...
                               ))
                        {
                            startNextWord++;
                        }

                        // cherchons la fin du mot suivant
                        int endNextWord = startNextWord;
                        while (endNextWord < txt.Length &&
                               (EstConsonne(txt[endNextWord]) || EstVoyelle(txt[endNextWord])))
                        {
                            endNextWord++;
                        }
                        // startNextWord est l'index du début du mot suivant. S'il y a des
                        // lettres, endNextWord est celui de la lettre qui suit le mot.
                        // S'il n'y a pas de lettres, endNextWord == startNextWord
                        string nextWord = null;
                        if (endNextWord > startNextWord)
                        {
                            nextWord = txt.Substring(startNextWord, endNextWord - startNextWord);
                            logger.ConditionalTrace("nextWord: {0}", nextWord);
                        }

                        if (startNextWord < txt.Length)
                        {
                            // il peut y avoir un mot suivant.
                            if (Disjonction(nextWord))
                            {
                                cms = ComportementMotSuivant.consonne;
                            }
                            else if (Liaison(nextWord))
                            {
                                cms = ComportementMotSuivant.voyelle;
                            }
                            else if (txt[startNextWord] == 'y')
                            {
                                // Le cas normal est que le y se comporte comme une consonne
                                // et le e-caduc forme une syllabe). Les exceptions sont
                                // interceptées par "Liaison"
                                cms = ComportementMotSuivant.consonne;
                            }
                            else if (TextEl.EstVoyelle(txt[startNextWord]))
                            {
                                cms = ComportementMotSuivant.voyelle;
                            }
                            else if (txt[startNextWord] == 'h')
                            {
                                // Le 'h' mérite un dictionnaire à lui tout seul
                                if (HAspire(nextWord))
                                {
                                    cms = ComportementMotSuivant.consonne;
                                }
                                else
                                {
                                    // h muet
                                    cms = ComportementMotSuivant.voyelle;
                                }
                            }
                            else if (TextEl.EstConsonne(txt[startNextWord]))
                            {
                                cms = ComportementMotSuivant.consonne;
                            }
                            else
                            {
                                // Il ne s'agit pas d'un lettre. Donc soit de la ponctuation,
                                // une fin de ligne ou autre chose... On traite ce cas comme
                                // une fin de vers.
                                cms = ComportementMotSuivant.fin;
                            }
                        }
                        else
                        {
                            // C'est la fin du texte.
                            cms = ComportementMotSuivant.fin;
                        }
                        logger.ConditionalTrace("cms: {0}", cms.ToString());
                        switch (cms)
                        {
                        case ComportementMotSuivant.consonne:
                            // la syllabe est prononcée, on la laisse.
                            break;

                        case ComportementMotSuivant.voyelle:
                            if (wrd[wrd.Length - 1] == 's' || wrd[wrd.Length - 1] == 't')
                            {
                                // il y a une liaison, la syllabe se prononce.
                                // L'existence d'un eliaison est probablement plus compliquée
                                // à identifier (il y certainement une foule d'exceptions)
                                // :-) Commençons quand même comme ça...
                            }
                            else
                            {
                                // la syllabe ne se prononce pas.
                                syls[syls.Count - 2].AbsorbeSuivant(syls[syls.Count - 1]);
                                syls.RemoveAt(syls.Count - 1);
                            }
                            break;

                        case ComportementMotSuivant.fin:
                            // la syllabe ne se prononce pas.
                            syls[syls.Count - 2].AbsorbeSuivant(syls[syls.Count - 1]);
                            syls.RemoveAt(syls.Count - 1);
                            break;

                        default:
                            logger.Error("ComportementMotSuivant {0} non traité", cms);
                            break;
                        }
                        logger.ConditionalTrace("Etape 7A {0} --> {1}, {2}",
                                                GetWord(), Syllabes(), GetPhonSyllabes());
                    }
                }
            } // if (syls.Count > 1)

            logger.ConditionalTrace("Résultat {0} --> {1}, {2}",
                                    GetWord(), Syllabes(), GetPhonSyllabes());
        }