/// <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