// ****************************************************************************************
// * STATIC *
// ****************************************************************************************
/// <summary>
/// Permet de comparer des <c>textEl</c> pour, le cas échéant, les remettre dans l'ordre.
/// N'a un sens que pour des éléments se rapportant au même <see cref="TheText"/>
/// </summary>
/// <param name="te1"></param>
/// <param name="te2"></param>
/// <returns></returns>
public static int CompareTextElByPosition(TextEl te1, TextEl te2)
{
Debug.Assert(te1.T == te2.T); // sinon ça n'a pas de sens.
int toReturn = 0;
if (te1.First < te2.First)
{
toReturn = -1;
}
else if (te1.First > te2.First)
{
toReturn = 1;
}
return(toReturn);
}
/// <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());
}
protected TextEl(TextEl te)
{
T = te.T;
First = te.First;
Last = te.Last;
}
public FormattedTextEl(TextEl te, CharFormatting inCf)
: base(te)
{
cf = inCf;
}
