public override void Reset()
{
logger.ConditionalDebug("Reset");
UndoFactory.StartRecording("Réinitialiser config");
pBDQ.Reset();
foreach (ColConfWin ccf in colors.Values)
{
ccf.Reset();
}
sylConf.Reset();
sylConf.ResetExceptionMots();
unsetBeh.Reset();
arcConf.Reset();
ponctConf.Reset();
if (isSubConfig)
{
ResetSubConfig(subConfNr);
}
else
{
_duoConf?.Reset(); // on ne fait le reset que si la duoConf existe
SetConfigName(DefaultConfigName);
}
UndoFactory.EndRecording();
}
/// <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>
/// Efface le bouton MajDeb.
/// </summary>
public void ClearMajDeb()
{
UndoFactory.StartRecording("Efface maj");
MajDebCF = CharFormatting.NeutralCF;
MajDebCB = false;
UndoFactory.EndRecording();
}
// -------------------------------------- Private Static Methods -------------------------------------------------------
/// <summary>
/// Charge la <c>Config</c> sauvegardée dans le fichier donné par <paramref name="fileName"/>.
/// </summary>
/// <param name="fileName">Le nom du fichier.</param>
/// <param name="errMsg">Le message d'erreur si le fichier n'a pas pu être chargé, sinon "".</param>
/// <returns>La <c>Config</c> chargée ou <c>null</c> en cas d'erreur.</returns>
private static Config LoadConfigFile(string fileName, out string errMsg)
{
UndoFactory.DisableUndoRegistration();
Config toReturn = null;
Stream stream = null;
errMsg = "";
try
{
IFormatter formatter = new BinaryFormatter();
stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
toReturn = (Config)formatter.Deserialize(stream);
stream.Close();
toReturn.PostLoadInitOptionalFields();
logger.Info("Config File \'{0}\' loaded.", fileName);
}
catch (Exception e) // when (e is IOException || e is SerializationException || e is UnauthorizedAccessException)
{
logger.Error("Impossible de lire la config dans le fichier \'{0}\'. Erreur: {1}. StackTrace: {2}",
fileName, e.Message, e.StackTrace);
errMsg = e.Message;
if (stream != null)
{
stream.Dispose();
}
}
UndoFactory.EnableUndoRegistration();
return(toReturn);
}
/// <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;
}
// -------------------------------------------------------------------------------------------------------------------
// -------------------------------------------------- Methods -------------------------------------------------------
// -------------------------------------------------------------------------------------------------------------------
/// <summary>
/// Crée un <see cref="UnsetBehConf"/> avec une configuration par défaut (celle obtenue
/// après <see cref="Reset"/>.
/// </summary>
public UnsetBehConf()
{
UndoFactory.DisableUndoRegistration();
act = new bool[(int)Ucbx.last];
Reset();
UndoFactory.EnableUndoRegistration();
}
/// <summary>
/// Efface le CharFormatting pour la famille de signes indiquée. La checkbox correspondante
/// est également mise à <c>false</c>.
/// </summary>
/// <param name="ponctS">La famille de signes à effacer.</param>
public void ClearPonct(string ponctS)
{
Ponctuation p = PonctInT.Ponct4String(ponctS);
UndoFactory.StartRecording("ClearPonct");
SetCF(p, CharFormatting.NeutralCF);
SetCB(p, false);
UndoFactory.EndRecording();
}
public override void Reset()
{
logger.ConditionalDebug("DuoConfig");
UndoFactory.StartRecording("Réinitialiser duo");
subConfig1.Reset();
subConfig2.Reset();
InitFields();
UndoFactory.EndRecording();
}
/// <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 override void Redo()
{
UndoFactory.StartRecording(Name);
for (int i = 0; i < actList.Count; i++)
{
actList[i].Redo();
}
UndoFactory.EndRecording();
}
/// <summary>
/// Initialise les champs (membres) <c>alternance</c> et <c>colorisFunction</c> à leur valeur
/// par défaut.
/// </summary>
/// <remarks>Est placé dans une méthode séparée pour qu'il n'y ait qu'un endroit où ces valeurs
/// par défaut sont définies.</remarks>
private void InitFields()
{
logger.ConditionalDebug("InitFields");
UndoFactory.StartRecording("Réinitialise les champs duo.");
alternance = Alternance.mots;
colorisFunction = ColorisFunction.syllabes;
nbreAlt = 1;
UndoFactory.EndRecording();
}
/// <summary>
/// Créée une "subconfig" pour la <c>Config</c> <paramref name="mother"/>.
/// </summary>
/// <param name="mother">La <c>Config</c> pour laquelle une "subconfig" doit être créée.</param>
/// <param name="daughterNr">Le numéro de la config. Valeurs possibles, 1 ou 2. </param>
public Config(int daughterNr)
{
logger.ConditionalDebug("Config(Config), daughterNr: {0}", daughterNr);
UndoFactory.DisableUndoRegistration();
isSubConfig = true;
subConfNr = daughterNr;
InitCtor();
ResetSubConfig(subConfNr);
UndoFactory.EnableUndoRegistration();
}
/// <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>
/// Crée une <c>Config</c> par défaut.
/// </summary>
public Config()
{
logger.ConditionalDebug("Config()");
UndoFactory.DisableUndoRegistration();
isSubConfig = false;
subConfNr = 0;
InitCtor();
SetConfigName(DefaultConfigName);
UndoFactory.EnableUndoRegistration();
}
// ----------------------------------------------------------------------------------------
// ------------------------------------ Public Methods -----------------------------------
// ----------------------------------------------------------------------------------------
public PonctConfig()
{
UndoFactory.DisableUndoRegistration();
for (Ponctuation p = Ponctuation.firstP + 1; p < Ponctuation.lastP; p++)
{
charFormats[p] = CharFormatting.NeutralCF;
checkBoxes[p] = false;
}
Reset();
UndoFactory.EnableUndoRegistration();
}
/// <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>
/// 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>
/// 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);
}
}
public void SetCB(Ponctuation p, bool toCB)
{
logger.ConditionalDebug("SetCF {0} to {1}", p.ToString(), toCB);
if (toCB != GetCB(p))
{
UndoFactory.StartRecording("Contrôle ponctuation");
SetCBwoState(p, toCB);
MasterState = State.off;
UndoFactory.EndRecording();
}
}
/// <summary>
/// Efface le maître. Désactive tout formatage des signes.
/// </summary>
public void ClearMaster()
{
UndoFactory.StartRecording("Efface maître");
MasterCF = CharFormatting.NeutralCF;
MasterState = State.off;
for (Ponctuation p = Ponctuation.firstP + 1; p < Ponctuation.lastP; p++)
{
checkBoxes[p] = false;
OnPonctCBModified(p);
}
UndoFactory.EndRecording();
}
private int _nbreAlt = 1; // pour mettre une base aux séries d'annulation
// ------------------------------------------ Methods -------------------------------------------------
/// <summary>
/// Construit un DuoConfig avec une configuration par défaut.
/// </summary>
public DuoConfig()
{
logger.ConditionalDebug("DuoConfig");
UndoFactory.DisableUndoRegistration();
subConfig1 = new Config(1);
subConfig1.ConfigReplacedEvent += SubConfig1Replaced;
subConfig2 = new Config(2);
subConfig2.ConfigReplacedEvent += SubConfig2Replaced;
InitFields();
UndoFactory.EnableUndoRegistration();
}
// -------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------- Public Methods ----------------------------------------------------
// -------------------------------------------------------------------------------------------------------------------
public ArcConfig()
{
UndoFactory.DisableUndoRegistration();
arcButtons = new ArcButtonConf[NrArcButtons];
for (int i = 0; i < NrArcButtons; i++)
{
arcButtons[i].buttonClickable = false;
arcButtons[i].cf = CharFormatting.NeutralCF;
}
arcButtons[0].buttonClickable = true;
nrSetArcButtons = 0;
Reset();
UndoFactory.EnableUndoRegistration();
}
// ------------------------------------------------- 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));
}
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();
}
/// <inheritdoc/>
public override void Reset()
{
UndoFactory.StartRecording("Réinitialiser lettres");
SetMarkAsBlackTo(false);
UpdateLetter(0, 'b', ColConfWin.coloredCF[(int)PredefCol.red]);
UpdateLetter(1, 'p', ColConfWin.coloredCF[(int)PredefCol.darkGreen]);
UpdateLetter(2, 'd', ColConfWin.coloredCF[(int)PredefCol.pureBlue]);
UpdateLetter(3, 'q', ColConfWin.coloredCF[(int)PredefCol.brown]);
UpdateLetter(4, inactiveLetter, defaultCF);
UpdateLetter(5, inactiveLetter, defaultCF);
UpdateLetter(6, inactiveLetter, defaultCF);
UpdateLetter(7, inactiveLetter, defaultCF);
UndoFactory.EndRecording();
}
/// <summary>
/// Réinitialise à la configuration par défaut (bleu foncé)
/// </summary>
public override void Reset()
{
UndoFactory.StartRecording("Réinitialiser arcs");
for (int i = nrSetArcButtons - 1; i >= 1; i--)
{
ClearButton(i);
}
SetArcButtonCol(0, ColConfWin.predefinedColors[(int)PredefCol.darkBlue]);
ResetCounter();
Hauteur = 45;
Ecartement = 80;
Epaisseur = 0.75f;
Decalage = 0.0f;
UndoFactory.EndRecording();
}
private ExceptionMots _excMots; // null si aucune exception n'a jamais été créée.
// -------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------- Public Methods ----------------------------------------------------
// -------------------------------------------------------------------------------------------------------------------
public SylConfig()
{
UndoFactory.DisableUndoRegistration();
sylButtons = new SylButtonConf[NrButtons];
for (int i = 0; i < NrButtons; i++)
{
sylButtons[i].buttonClickable = false;
sylButtons[i].cf = CharFormatting.NeutralCF;
}
sylButtons[0].buttonClickable = true;
nrSetButtons = 0;
_excMots = null;
Reset();
UndoFactory.EnableUndoRegistration();
}
/// <summary>
/// Réinitialise à la configuration par défaut (rouge et noir)
/// </summary>
public override void Reset()
{
UndoFactory.StartRecording("Réinitialiser syllabes");
for (int i = nrSetButtons - 1; i >= 2; i--)
{
ClearButton(i);
}
SetSylButtonCF(0, ColConfWin.coloredCF[(int)PredefCol.pureBlue]);
SetSylButtonCF(1, ColConfWin.coloredCF[(int)PredefCol.red]);
ResetCounter();
DoubleConsStd = true; // mode std de LireCouleur
mode = Mode.ecrit;
marquerMuettes = true;
chercherDierese = true;
nbrPieds = 0; // Par défaut, mode automatique.
UndoFactory.EndRecording();
}
} // 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);
}
}
}
}