/// <summary>
/// Indique que le le boouton <paramref name="butNr"/> (commence à 0) doit être formatté avec
/// <paramref name="inCf"/>.
/// La fonction <c>updateSylButton</c> est appelée pour le bouton <paramref name="butNr"/> (l'événement
/// correspondant est généré...)
/// </summary>
/// <param name="butNr">Le numéro du bouton dont il faut changer le formatage.</param>
/// <param name="inCf">Le nouveau formatage.</param>
public void SetSylButtonCF(int butNr, CharFormatting inCf)
{
logger.ConditionalDebug("SylButtonModified butNr: {0}", butNr);
if (butNr > nrSetButtons)
{
logger.Fatal("Modification d'un bouton non actif butNr: {0}", butNr);
throw new ArgumentException("Modification d'un bouton non actif.", nameof(butNr));
}
UndoFactory.ExceutingAction(new SylAction("Formatage bout. syll.", this, butNr,
nrSetButtons, sylButtons[butNr].cf, inCf));
sylButtons[butNr].cf = inCf;
if (butNr == nrSetButtons)
{
nrSetButtons++;
if (nrSetButtons < NrButtons)
{
sylButtons[nrSetButtons].buttonClickable = true;
OnSylButtonModified(nrSetButtons);
}
if (inCf.changeColor == false)
{
// c'est un problème. Il faut une couleur, sinon l'expérience utilisateur n'est pas consistante.
// mettons le bouton à noir.
sylButtons[butNr].cf = new CharFormatting(inCf, ColConfWin.predefinedColors[(int)PredefCol.black]);
}
}
OnSylButtonModified(butNr);
}
/// <summary>
/// Est nécessaire dans le cas d'une annulation de la commande pour revenir à l'état
/// précédent, sans déclencher une propagation éventuellement fausse.
/// </summary>
/// <param name="cf">Le <see cref="CharFormatting"> à utiliser.</param>
public void SetMasterCFWithoutPropagation(CharFormatting cf)
{
logger.ConditionalTrace("SetMasterCFWithoutPropagation to {0}", cf?.ToString());
UndoFactory.ExceutingAction(new PonctAction("Format Maître", this, "masterCF",
Ponctuation.firstP, MasterCF, cf));
_masterCF = cf;
}
/// <summary>
/// Permet de mettre la "checkbox" pour une famille de ponctuation
/// sans que la situation du mâître soit impactée.
/// </summary>
/// <remarks>Devrait être <c>private</c>, mais doit être visible pour la gestion des
/// annulations. NE PAS UTILISER DANS UN AUTRE CONTEXTE!</remarks>
/// <param name="p">La famille de ponctuation.</param>
/// <param name="toCB">La nouvelle valeur de la checkbox.</param>
public void SetCBwoState(Ponctuation p, bool toCB)
{
logger.ConditionalTrace("SetCBwoState p: {0}, toCB: {1}", p, toCB);
if (toCB != checkBoxes[p])
{
UndoFactory.ExceutingAction(new PonctAction("Contrôle ponct.", this, "ponctCB",
p, checkBoxes[p], toCB));
checkBoxes[p] = toCB;
OnPonctCBModified(p);
}
}
/// <summary>
/// Permet de mettre le <see cref="CharFormatting"/> pour une famille de ponctuation
/// sans que la situation du mâître soit impactée.
/// </summary>
/// <remarks>Devrait être <c>private</c>, mais doit être visible pour la gestion des
/// annulations. NE PAS UTILISER DANS UN AUTRE CONTEXTE!</remarks>
/// <param name="p">La famille de ponctuation.</param>
/// <param name="toCF">Le nouveau <see cref="CharFormatting"/>.</param>
public void SetCFwoState(Ponctuation p, CharFormatting toCF)
{
logger.ConditionalTrace("SetCFwoState, p: {0}, to: {1}", p, toCF.ToString());
if (toCF != charFormats[p])
{
UndoFactory.ExceutingAction(new PonctAction("Format ponct.", this, "ponctCF",
p, charFormats[p], toCF));
charFormats[p] = toCF;
OnPonctFormattingModified(p);
}
}
// ------------------------------------------------- Events --------------------------------------------
public virtual void OnConfigReplaced(Config newConfig)
{
logger.ConditionalDebug("OnConfigReplaced");
UndoFactory.ExceutingAction(new ConfigAction("Remplacer config", this, newConfig));
EventHandler <ConfigReplacedEventArgs> eventHandler = ConfigReplacedEvent;
// il est conseillé de faire ceci pour le cas tordu où le dernier "handler" se désabonnerait entre
// le test sur null et l'évèenement. Je ne suis pas sûr que ça puisse jamais arriver ici.
// Make a temporary copy of the event to avoid possibility of
// a race condition if the last subscriber unsubscribes
// immediately after the null check and before the event is raised.
eventHandler?.Invoke(this, new ConfigReplacedEventArgs(newConfig));
}
} // UpdateLetter
/// <summary>
/// Modifie la valeur du flag <c>markAsBlack</c>.
/// </summary>
/// <param name="val">Nouvelle valeur du flag.</param>
public void SetMarkAsBlackTo(bool val)
{
if (markAsBlack != val) // on s'assure qu'il ne peut y avoir de boucle pour toujours remettre la même valeur.
{
UndoFactory.ExceutingAction(new PBDQAction("Marquer lettre noir", this, markAsBlack, val));
markAsBlack = val;
OnMarkAsBlackModified();
if (markAsBlack)
{
defaultCF = CharFormatting.BlackCF;
}
else
{
defaultCF = CharFormatting.NeutralCF;
}
bpdqCF[inactiveLetter] = defaultCF;
}
}
/// <summary>
/// N'est <c>public</c> que pour les annulations.
/// </summary>
/// <param name="flag">Le flag à modifier.</param>
/// <param name="val">La nouvelle valeur.</param>
public void SetCbuFlag(Ucbx flag, bool val)
{
logger.ConditionalDebug("SetCbuFlag flag: \'{0}\', val: {1}", flag, val);
int btuIndex = (int)flag;
if (act[btuIndex] != val) // Pour éviter un évènement si rien ne change
{
UndoFactory.ExceutingAction(new UnsetBehAction("Modifier flag avancé", this, flag, act[btuIndex], val));
act[btuIndex] = val;
OnCheckboxUnsetModified((Ucbx)btuIndex);
if (btuIndex == (int)Ucbx.all)
{
for (int i = 0; i < (int)Ucbx.all; i++)
{
act[i] = val;
OnCheckboxUnsetModified((Ucbx)i);
}
}
}
}
/// <summary>
/// Met à jour la configuration du bouton <c>buttonNr</c> avec <c>cf</c>.
/// </summary>
/// <param name="butNr">Le nr du bouton pour lequel il y a un nouveau <c>cf</c></param>
/// <param name="cf">Le nouveau <c>CharFormatting</c> pour le bouton.</param>
/// <returns><c>false</c> si la lettre du bouton en question est égale à la lettre inactive (' '). A ce
/// moment-là, rien n'est fait. <c>true</c> si la modification a été effectuée avec succès.</returns>
/// <exception cref="ArgumentException">Si <c>buttonNr</c> n'a pas une valeur entre <c>0</c> et
/// <c>nrButtons - 1</c>.</exception>
public bool UpdateLetter(int butNr, CharFormatting cf)
{
logger.ConditionalDebug("UpdateLetter bouton no {0}", butNr);
if (butNr < 0 || butNr > nrButtons - 1)
{
logger.Fatal("UpdateLetter - le bouton indiqué n'existe pas: {0}", butNr);
throw new ArgumentException("UpdateLetter - le bouton indiqué n'existe pas", nameof(butNr));
}
bool toReturn = false;
char c = selLetters[butNr];
if (c != inactiveLetter)
{
toReturn = true;
UndoFactory.ExceutingAction(new PBDQAction("Format lettre", this, butNr, bpdqCF[c], cf));
bpdqCF[c] = cf;
OnLetterButtonModifed(new LetterButtonModifiedEventArgs(butNr));
}
return(toReturn);
}
/// <summary>
/// Le bouton <paramref name="butNr"/> est effacé. N'est possible que pour le dernier bouton
/// formaté de la série.
/// </summary>
/// <exception cref="ArgumentException"> est levée si le bouton ne peut pas être effacé.</exception>
/// <param name="butNr">Le numéro du bouton à effacer.</param>
public void ClearButton(int butNr)
{
logger.ConditionalDebug("ClearButton butNr: {0}", butNr);
if ((butNr == (nrSetButtons - 1)) && (nrSetButtons > 0))
{
UndoFactory.ExceutingAction(new SylAction("Effacer bout. syll.", this, butNr, sylButtons[butNr].cf));
if (nrSetButtons < NrButtons)
{
sylButtons[nrSetButtons].buttonClickable = false;
OnSylButtonModified(nrSetButtons);
}
nrSetButtons--;
sylButtons[nrSetButtons].cf = CharFormatting.NeutralCF;
OnSylButtonModified(nrSetButtons);
}
else
{
Exception e = new ArgumentException("The Button Number cannot be cleared", "butNr");
logger.Error(e, "The Button number {0} cannot be cleared. nrSetButtons: {1}", butNr, nrSetButtons);
throw e;
}
}
/// <summary>
/// Indique que le le boouton <paramref name="butNr"/> (commence à 0) doit être formatté avec
/// <paramref name="inCol"/>.
/// La fonction <c>updateArcButton</c> est appelée pour le bouton <paramref name="butNr"/> (l'événement
/// correspondant est généré...)
/// </summary>
/// <param name="butNr">Le numéro du bouton dont il faut changer le formatage.</param>
/// <param name="inCol">Le nouveau formatage.</param>
public void SetArcButtonCol(int butNr, RGB inCol)
{
logger.ConditionalDebug("SetArcButtonCol butNr: {0}, Col: {1}", butNr, inCol);
if (butNr > nrSetArcButtons)
{
logger.Fatal("Modification d'un bouton d'arc non actif butNr: {0}", butNr);
throw new ArgumentException("Modification d'un bouton d'arc non actif.", nameof(butNr));
}
UndoFactory.ExceutingAction(new ArcAction("Couleur bouton arcs", this, butNr,
nrSetArcButtons, arcButtons[butNr].cf.arcColor, inCol));
arcButtons[butNr].cf = new CharFormatting(true, inCol);
if (butNr == nrSetArcButtons)
{
nrSetArcButtons++;
if (nrSetArcButtons < NrArcButtons)
{
arcButtons[nrSetArcButtons].buttonClickable = true;
OnArcButtonModified(nrSetArcButtons);
}
}
OnArcButtonModified(butNr);
}
/// <summary>
/// Définit le <c>configName</c>.
/// </summary>
/// <remarks>Normalement, on devrait avoir un setter et un getter pour <c>configName</c>,
/// mais je n'avais pas bien compris comment ça marche avec la sérialisation et
/// je ne veux plus toucher à ça de peur de devenir incompatible avec d'anciens fichiers de
/// sauvegarde. </remarks>
/// <remarks>N'est <c>public</c> que pour <see cref="ConfigAction"/></remarks>
/// <param name="theName">Le nouveau nom.</param>
public void SetConfigName(string theName)
{
UndoFactory.ExceutingAction(new ConfigAction("Nom de config", this, configName, theName));
configName = theName;
OnConfigNameModified();
}
/// <summary>
/// Met à jour la configuration pour le bouton <c>buttonNr</c>. Si le caractère <c>c</c> est déjà utilisé
/// pour un autre bouton, la modification est refusée et la méthode retourne <c>false</c>. Si <c>c</c> est
/// le caractère inactif ' ', le bouton est "effacé".
/// </summary>
/// <param name="butNr">Identifie le bouton à modifier par son numéro.</param>
/// <param name="c">Le caractère pour le bouton. <see cref="inactiveLetter"/> correspond
/// à un effacement du bouton.</param>
/// <param name="cf">Le nouveau <c>CharFormatting</c> pour le bouton</param>
/// <returns><c>false</c> si la lettre n'a pas pu être mise à jour, par exemple parce qu'elle est
/// déjà traitée.</returns>
/// <exception cref="ArgumentException">Si <c>buttonNr</c> n'a pas une valeur entre <c>0</c> et
/// <c>nrButtons - 1</c>.</exception>
public bool UpdateLetter(int butNr, char c, CharFormatting cf)
{
logger.ConditionalDebug("UpdateLetter buttonNr: {0}, c: \'{1}\'", butNr, c);
if (butNr < 0 || butNr > nrButtons - 1)
{
logger.Fatal("UpdateLetter - le bouton demandé n'existe pas: {0}, lettre \'{1}\'", butNr, c);
throw new ArgumentException("UpdateLetter - le bouton demandé n'existe pas", nameof(butNr));
}
bool toReturn = true;
char previousC = selLetters[butNr];
CharFormatting previousCF = CharFormatting.NeutralCF;
if (previousC != inactiveLetter)
{
previousCF = bpdqCF[previousC];
}
if (c != inactiveLetter)
{
if (previousC != c)
{
if (!bpdqCF.ContainsKey(c))
{
if (previousC != inactiveLetter)
{
bpdqCF.Remove(previousC);
}
UndoFactory.ExceutingAction(new PBDQAction("Format et car. lettre", this,
butNr, previousC, c, previousCF, cf));
bpdqCF[c] = cf;
selLetters[butNr] = c;
}
else
{
// bpdqCF.ContainsKey(c) i.e. the letter is already present
toReturn = false;
}
}
else
{
UndoFactory.ExceutingAction(new PBDQAction("Format lettre", this, butNr, previousCF, cf));
// previousC == c
bpdqCF[c] = cf;
}
}
else
{
UndoFactory.ExceutingAction(new PBDQAction("Format et car. lettre", this,
butNr, previousC, c, previousCF, cf));
// c == inactiveLetter
selLetters[butNr] = inactiveLetter; // neutral character inactiveLetter
if (previousC != inactiveLetter)
{
bpdqCF.Remove(previousC);
}
}
if (toReturn)
{
OnLetterButtonModifed(new LetterButtonModifiedEventArgs(butNr));
}
logger.ConditionalDebug("END UpdateLetter toReturn: {0}", toReturn.ToString());
return(toReturn);
} // UpdateLetter