// -------------------------------------- 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);
}
// -------------------------------------------------------------------------------------------------------------------
// -------------------------------------------------- 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>
/// 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>
/// 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();
}
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();
}
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 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();
}
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>
/// <para>
/// Donne la confiuration qui correspond à la fenêtre <c>win</c>. Mémorise les infos pour
/// que l'évènement de fermeture du document <c>doc</c> soit traité correctement. Voir
/// <see cref="DocClosed(object)"/>.
/// </para>
/// <para>
/// Si une configuration a été sauvegardée à la fin de la session de travail précédente,
/// c'est elle qui est chargée. Dans le cas contraire, ou si le chargement échoue, une
/// nouvelle <see cref="Config"/> est créée avec des valeurs par défaut.
/// </para>
/// </summary>
/// <param name="win">La fenêtre pour laquelle on veut une <see cref="Config"/>.</param>
/// <param name="doc">Le document attaché à la fenêtre. </param>
/// <param name="errMsg">OUT: En cas de problème lors du chargement de la configuration de
/// la dernière session, ce paramètre contient le message pour l'utilisateur. <c>null</c>
/// si tout s'est bien passé.</param>
/// <returns>La <c>Config</c> pour la fenêtre.</returns>
/// <example>
/// Il est vivement conseillé de tester la valeur de <c>errMsg</c> et le cas échéant de
/// présenter le message à l'utilisateur. Par exemple, dans une application
/// <c>Windows.Forms</c> on peut utiliser <c>MessageBox</c> comme ci-dessous.
/// <code>
/// using System.Windows.Forms;
///
/// string errMsg;
/// Config conf = Config.GetConfigFor(theWin, theDoc, out errMsg));
/// if (!string.IsNullOrEmpty(errMsg))
/// MessageBox.Show(errMsg, ConfigBase.ColorizationName, MessageBoxButtons.OK, MessageBoxIcon.Error);
/// </code>
/// </example>
public static Config GetConfigFor(Object win, Object doc, out string errMsg)
// returns the Config associated with the Object win, normally the active window.
// if there is none, a new one with the defauilt config is created.
{
logger.ConditionalDebug("GetConfigFor");
UndoFactory.DisableUndoRegistration();
Config toReturn;
errMsg = null;
if (!theConfs.TryGetValue(win, out toReturn))
{
// it is a new window
// Does a default file configuration exist?
if (File.Exists(DefaultConfFile))
{
string eM;
toReturn = LoadConfigFile(DefaultConfFile, out eM);
if (toReturn == null)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Ouuuups! Une erreur s'est produite en chargeant la configuration de votre dernière session. Désolé!");
sb.AppendLine("La configuration par défaut est chargée à la place.");
sb.Append("Message du système: ");
sb.AppendLine(eM);
errMsg = sb.ToString();
logger.Warn("Error MessageBox displayed.");
toReturn = new Config(); // essayons de sauver les meubles.
logger.ConditionalDebug("New Config created.");
}
}
else
{
// create a new config
toReturn = new Config();
logger.ConditionalDebug("New Config created.");
}
UpdateWindowsLists(win, doc, toReturn);
}
UndoFactory.EnableUndoRegistration();
return(toReturn);
}