public SylAction(string name, SylConfig inSylConf, int inButNr, CharFormatting inPrevCF)
: base(name)
{
type = SylActionType.clearBut;
sylConf = inSylConf;
butNr = inButNr;
prevCF = inPrevCF;
}
public SylAction(string name, SylConfig inSylConf,
ExceptionMots inPrevExcMots, ExceptionMots inNewExcMots)
: base(name)
{
type = SylActionType.exceptMots;
sylConf = inSylConf;
prevExcMots = inPrevExcMots;
newExcMots = inNewExcMots;
}
public SylAction(string name, SylConfig inSylConf,
int inPrevNrPieds, int inNewNrPieds)
: base(name)
{
type = SylActionType.nbrePieds;
sylConf = inSylConf;
prevNrPieds = inPrevNrPieds;
newNrPieds = inNewNrPieds;
}
public SylAction(string name, SylConfig inSylConf,
SylConfig.Mode inPrevMode, SylConfig.Mode inNewMode)
: base(name)
{
type = SylActionType.mode;
sylConf = inSylConf;
prevMode = inPrevMode;
newMode = inNewMode;
}
/// <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;
}
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;
}
// ---------------------------------------------- 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();
}
/// <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());
}