/// <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>
/// Crée le <see cref="FormattedTextEl"/> correspondant au <c>TextEl</c> <c>this</c> et
/// au <see cref="CharFormatting"/> <paramref name="cf"/>. Ajoute le <c>FormattedTextEl</c>
/// à la liste des <c>FormattedTextEl</c> du texte.
/// </summary>
/// <param name="cf">Le <see cref="CharFormatting"/> à utiliser pour ce <c>TextEl</c></param>
protected void SetCharFormat(CharFormatting cf)
{
if (Last >= First)
{
FormattedTextEl fte = new FormattedTextEl(this, cf);
T.AddFTE(fte);
}
}
public SylAction(string name, SylConfig inSylConf, int inButNr, CharFormatting inPrevCF)
: base(name)
{
type = SylActionType.clearBut;
sylConf = inSylConf;
butNr = inButNr;
prevCF = inPrevCF;
}
/// <summary>
/// Réinitialise à la configuration par défaut
/// </summary>
public override void Reset()
{
logger.ConditionalDebug("Reset");
UndoFactory.StartRecording("Réinitialiser ponctuation");
MasterCF = new CharFormatting(ColConfWin.coloredCF[(int)PredefCol.pinky], true, false, false);
MajDebCF = MasterCF;
MajDebCB = false;
UndoFactory.EndRecording();
}
public bool Equals(CharFormatting cf)
{
// If parameter is null, return false.
if (Object.ReferenceEquals(cf, null))
{
return(false);
}
// Optimization for a common success case.
if (Object.ReferenceEquals(this, cf))
{
return(true);
}
// If run-time types are not exactly the same, return false.
if (this.GetType() != cf.GetType())
{
return(false);
}
// Return true if the fields match.
// Note that the base class is not invoked because it is
// System.Object, which defines Equals as reference equality.
bool toReturn = (
bold == cf.bold &&
italic == cf.italic &&
underline == cf.underline &&
caps == cf.caps &&
changeColor == cf.changeColor &&
changeHilight == cf.changeHilight &&
changeFontSize == changeFontSize &&
contour == cf.contour &&
serif == cf.serif &&
drawArc == cf.drawArc &&
removeArcs == cf.removeArcs
);
if (changeColor)
{
toReturn = toReturn && color == cf.color;
}
if (changeHilight)
{
toReturn = toReturn && hilightColor == cf.hilightColor;
}
if (changeFontSize)
{
toReturn = toReturn && percIncrFontSize == cf.percIncrFontSize;
}
if (drawArc)
{
toReturn = toReturn && arcColor == cf.arcColor;
}
return(toReturn);
}
/// <summary>
/// Définit le <see cref="CharFormatting"/> pour la famille de signes donnée et met
/// également la Checkbox corrspondante à <c>true</c>.
/// </summary>
/// <param name="ponctS">La famille de signes visée.</param>
/// <param name="toCF">Le nouveau <see cref="CharFormatting"/>.</param>
public void SetCFandCB(string ponctS, CharFormatting toCF)
{
logger.ConditionalDebug("SetCFandCB {0} toCF: {1}", ponctS, toCF.ToString());
Ponctuation p = PonctInT.Ponct4String(ponctS);
UndoFactory.StartRecording("SetCFandCB");
SetCF(p, toCF);
SetCB(p, true);
UndoFactory.EndRecording();
}
/// <summary>
/// Permet de mettre le CF pour une famille de ponctuation à la valeur souhaitée.
/// </summary>
/// <param name="p">La famille de ponctuation.</param>
/// <param name="toCF">Le nouveau <see cref="CharFormatting"/>.</param>
public void SetCF(Ponctuation p, CharFormatting toCF)
{
logger.ConditionalDebug("SetCF {0} to {1}", p.ToString(), toCF.ToString());
if (toCF != GetCF(p))
{
UndoFactory.StartRecording("Format ponctuation");
SetCFwoState(p, toCF);
MasterState = State.off;
UndoFactory.EndRecording();
}
}
/// <summary>
/// <see cref="CharFormatting"/> pour la lettre <paramref name="c"/>.
/// </summary>
/// <param name="c">La lettre pour laquelle on cherche le <see cref="CharFormatting"/></param>
/// <returns>Le <see cref="CharFormatting"/> recherché. Si aucun <c>CharFormatting</c>
/// n'est géré pour <c>c</c>, retourne le <c>CharFormatting</c> à appliquer pour
/// les autres lettres. Celui-ci dépend du flag <see cref="markAsBlack"/>; ls sera soit
/// neutre ou impliquera un formattage noir.</returns>
public CharFormatting GetCfForPBDQLetter(char c)
{
logger.ConditionalDebug("GetCfForPBDQLetter bouton with letter {0}", c);
CharFormatting toReturn = null;
if (!bpdqCF.TryGetValue(c, out toReturn))
{
toReturn = defaultCF;
}
return(toReturn);
}
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;
}
/// <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);
}
}
/// <summary>
/// Retourne le <see cref="CharFormatting"/> à utiliser en alternance suivant la configuration actuelle.
/// Assure de passer à travers les différents <c>CharFormatting</c> voulus.
/// </summary>
/// <remarks>
/// Si aucun bouton n'a été défini, retourne le <c>CharFormatting</c> neutre.
/// </remarks>
/// <returns>Le <see cref="CharFormatting"/> à utiliser pour un formatage alterné.</returns>
public CharFormatting NextCF()
{
CharFormatting toReturn = sylButtons[counter].cf;
if (nrSetButtons > 0)
{
counter = (counter + 1) % nrSetButtons;
}
else
{
counter = 0;
}
return(toReturn);
}
private CharFormatting defaultCF; // the CF that is returned for a non selected letter.
// -------------------------------------------------------------------------------------------------------------------
// -------------------------------------------------- Methods -------------------------------------------------------
// -------------------------------------------------------------------------------------------------------------------
/// <summary>
/// Crée un <c>PBDQConfig</c>. <see cref="Reset"/> est appliqué.
/// </summary>
public PBDQConfig()
{
UndoFactory.DisableUndoRegistration();
bpdqCF = new Dictionary <char, CharFormatting>(nrButtons);
selLetters = new char[nrButtons];
for (int i = 0; i < nrButtons; i++)
{
selLetters[i] = inactiveLetter;
}
markAsBlack = false;
defaultCF = CharFormatting.NeutralCF;
Reset();
UndoFactory.EnableUndoRegistration();
}
public PBDQAction(string name, PBDQConfig inPBDQConf, bool inPrevMarkAsBlack, bool inNewMarkAsBlack)
: base(name)
{
type = "markAsBlack";
pbdqConf = inPBDQConf;
prevMarkAsBlack = inPrevMarkAsBlack;
newMarkAsBlack = inNewMarkAsBlack;
// Pour éviter les champs non initialisés.
buttonNr = 0;
prevCF = CharFormatting.NeutralCF;
newCF = CharFormatting.NeutralCF;
prevLetter = PBDQConfig.inactiveLetter;
newLetter = PBDQConfig.inactiveLetter;
}
/// <summary>
/// Action de mise à jour d'un bouton, y.c. une lettre - "letterAndCF"
/// </summary>
/// <param name="name">Nom de l'action</param>
/// <param name="inPBDQConf">La <see cref="PBDQConfig"/> sur laquelle se déroule l'action.
/// </param>
/// <param name="inButtonNr">Le bouton de l'action.</param>
/// <param name="inPrevLetter">La lettre précédente.</param>
/// <param name="inNewLetter">La nouvelle lettre pour le bouton.</param>
/// <param name="inPrevCF">La configuration précédente pour le bouton.</param>
/// <param name="inNewCF">La nouvelle configuration pour le bouton.</param>
public PBDQAction(string name, PBDQConfig inPBDQConf, int inButtonNr,
char inPrevLetter, char inNewLetter, CharFormatting inPrevCF, CharFormatting inNewCF)
: base(name)
{
type = "leterAndCF";
pbdqConf = inPBDQConf;
buttonNr = inButtonNr;
prevCF = inPrevCF;
newCF = inNewCF;
prevLetter = inPrevLetter;
newLetter = inNewLetter;
// Pour éviter les champs non initialisés.
prevMarkAsBlack = false;
newMarkAsBlack = false;
}
public PonctAction(string name,
PonctConfig pc,
string inType,
Ponctuation inP,
CharFormatting inPrevCF,
CharFormatting inNewCF)
: base(name)
{
ponctConf = pc;
type = inType;
prevCF = inPrevCF;
newCF = inNewCF;
p = inP;
// pour ne rien avoir de non défini:
prevCB = false;
newCB = false;
}
public PonctAction(string name,
PonctConfig pc,
string inType,
Ponctuation inP,
bool inPrevCB,
bool inNewCB)
: base(name)
{
ponctConf = pc;
type = inType;
prevCB = inPrevCB;
newCB = inNewCB;
p = inP;
// pour ne rien avoir de non défini:
prevCF = null;
newCF = null;
}
/// <summary>
/// Crée une "action" pour une modification de la règle "ill".
/// </summary>
/// <remarks>Il s'agit d'une action de type "ill".</remarks>
/// <param name="name">Le nom de l'action.</param>
/// <param name="inCcw">Le <see cref="ColConfWin"/> auquel l'action se rapporte.</param>
/// <param name="inPrevIllRule">La valeur précédente de la règle "ill"
/// (avant l'action).</param>
/// <param name="inNewIllRule">La nouvelle valeur de la règle "ill"
/// (après l'action).</param>
public ColPhonAct(string name, ColConfWin inCcw,
ColConfWin.IllRule inPrevIllRule, ColConfWin.IllRule inNewIllRule)
: base(name)
{
type = "ill";
ccw = inCcw;
prevIllRule = inPrevIllRule;
newIllRule = inNewIllRule;
// pour éviter les membres non définis
son = null;
prevCF = null;
newCF = null;
prevCB = false;
newCB = false;
prevDefBeh = ColConfWin.DefBeh.undefined;
newDefBeh = ColConfWin.DefBeh.undefined;
}
/// <summary>
/// Crée une "action" pour une modification de la checkbox d'un son.
/// </summary>
/// <remarks>Il s'agit d'une action de type "sonCB".</remarks>
/// <param name="name">Le nom de l'action.</param>
/// <param name="inCcw">Le <see cref="ColConfWin"/> auquel l'action se rapporte.</param>
/// <param name="inSon">Le son sur lequel porte l'action.</param>
/// <param name="inPrevCB">La valeur précédente de la checkbox (avant l'action).</param>
/// <param name="inNewCB">La nouvelle valeur de la checkbox (après l'action).</param>
public ColPhonAct(string name, ColConfWin inCcw, string inSon,
bool inPrevCB, bool inNewCB)
: base(name)
{
type = "sonCB";
ccw = inCcw;
son = inSon;
prevCB = inPrevCB;
newCB = inNewCB;
// pour éviter les membres non définis
prevCF = null;
newCF = null;
prevIllRule = ColConfWin.IllRule.undefined;
newIllRule = ColConfWin.IllRule.undefined;
prevDefBeh = ColConfWin.DefBeh.undefined;
newDefBeh = ColConfWin.DefBeh.undefined;
}
/// <summary>
/// Crée une "action" pour une modification du formatage d'un son.
/// </summary>
/// <remarks>Il s'agit d'une action de type "sonCF".</remarks>
/// <param name="name">Le nom de l'action.</param>
/// <param name="inCcw">Le <see cref="ColConfWin"/> auquel l'action se rapporte.</param>
/// <param name="inSon">Le son sur lequel porte l'action.</param>
/// <param name="inPrevCF">La valeur précédente de formatage (avant l'action).</param>
/// <param name="inNewCF">La nouvelle valeur de formatage (après l'action).</param>
public ColPhonAct(string name, ColConfWin inCcw, string inSon,
CharFormatting inPrevCF, CharFormatting inNewCF)
: base(name)
{
type = "sonCF";
ccw = inCcw;
son = inSon;
prevCF = inPrevCF;
newCF = inNewCF;
// pour éviter les membres non définis
prevCB = false;
newCB = false;
prevIllRule = ColConfWin.IllRule.undefined;
newIllRule = ColConfWin.IllRule.undefined;
prevDefBeh = ColConfWin.DefBeh.undefined;
newDefBeh = ColConfWin.DefBeh.undefined;
}
} // 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;
}
}
public PonctAction(string name,
PonctConfig pc,
string inType,
PonctConfig.State inPrevMasterState,
PonctConfig.State inNewMasterState)
: base(name)
{
ponctConf = pc;
type = inType;
prevMasterState = inPrevMasterState;
newMasterState = inNewMasterState;
// pour ne rien avoir de non défini:
prevCF = null;;
newCF = null;
p = Ponctuation.firstP;
prevCB = false;
newCB = false;
}
/// <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>
/// Crée un <c>CharFormatting</c> comme une copie de <c>cfToCopy</c> et en mettant <c>color</c> à
/// <c>inColor</c> et en forçant <c>changeCOlor</c> à <c>true</c>.
/// </summary>
/// <param name="cfToCopy">Le <c>CharFormatting</c> qui doit être recopié. Non null.</param>
/// <param name="inColor">La nouvelle couleur.</param>
public CharFormatting(
CharFormatting cfToCopy,
RGB inColor
)
{
bold = cfToCopy.bold;
italic = cfToCopy.italic;
underline = cfToCopy.underline;
caps = cfToCopy.caps;
changeColor = true;
color = inColor;
changeHilight = cfToCopy.changeHilight;
hilightColor = cfToCopy.hilightColor;
contour = cfToCopy.contour;
serif = cfToCopy.serif;
changeFontSize = cfToCopy.changeFontSize;
percIncrFontSize = cfToCopy.percIncrFontSize;
drawArc = cfToCopy.drawArc;
arcColor = cfToCopy.arcColor;
}
} // constructor
/// <summary>
/// Crée un <c>CharFormatting</c> comme une copie de <c>cfToCopy</c> avec trois aspects qui peuvent
/// changer: <c>bold</c>, <c>italic</c> et <c>underline</c>.
/// </summary>
/// <param name="cfToCopy">Le <c>CharFormatting</c> qui doit être recopié.</param>
/// <param name="inBold">La nouvelle valeur de <c>bold</c>.</param>
/// <param name="inItalic">La nouvelle valeur de <c>italic</c>.</param>
/// <param name="inUnderline">La nouvelle valeur de <c>underline</c>.</param>
public CharFormatting(
CharFormatting cfToCopy,
bool inBold,
bool inItalic,
bool inUnderline
)
{
bold = inBold;
italic = inItalic;
underline = inUnderline;
caps = cfToCopy.caps;
changeColor = cfToCopy.changeColor;
color = cfToCopy.color;
changeHilight = cfToCopy.changeHilight;
hilightColor = cfToCopy.hilightColor;
contour = cfToCopy.contour;
serif = cfToCopy.serif;
changeFontSize = cfToCopy.changeFontSize;
percIncrFontSize = cfToCopy.percIncrFontSize;
drawArc = cfToCopy.drawArc;
arcColor = cfToCopy.arcColor;
}
public static void Init()
{
neutralArcsCol = new RGB(255, 255, 254);
NeutralCF = new CharFormatting();
BlackCF = new CharFormatting(new RGB(0, 0, 0));
}
/// <summary>
/// Définit un nouveau <c>CharFormatting</c> pour le bouton indiqué.
/// </summary>
/// <param name="butNrTxt">Le numéro du boutton.</param>
/// <param name="inCf">Le nouveau <c>CharFormatting</c> pour le bouton.</param>
public void SetSylButtonCF(string butNrTxt, CharFormatting inCf)
{
SetSylButtonCF(int.Parse(butNrTxt), inCf);
}
public void SetCF(string ponct, CharFormatting toCF) => SetCF(PonctInT.Ponct4String(ponct), toCF);
/// <summary> /// Est utilisé par <c>CharFormatForm</c> qui réclame une fonction (delegate) avec /// cette signature. /// </summary> /// <param name="dummy">N'est pas utilisé.</param> /// <param name="cf">Le <see cref="CharFormatting"/> auquel <c>MajDebCF</c> doit être /// mis.</param> public void SetMajDebCF(string dummy, CharFormatting cf) => MajDebCF = cf;
/// <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
