Bibliobrol : la vue console

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using be.gaudry.observer;
using be.gaudry.bibliobrol.config;
 
namespace be.gaudry.bibliobrol.view
{
    /// <summary>
    /// Form used to display notifications throws by the model of the application.
    /// 
    /// </summary>
    public partial class ConsoleForm : Form, IObserver
    {
        public ConsoleForm()
        {
            InitializeComponent();
        }
 
        #region IObserver Members
 
        public void update(Notification n)
        {
            if (n != null)
            {
                if (n.Level.Equals(Notification.VERBOSE.internalNotification) && n.Title.Equals("display console"))
                {
                    this.Visible = n.Msg.Equals(true.ToString());
                }
            }
        }
        #endregion
 
        #region public methods
        public void consoleClear()
        {
            innerConsole.Clear(); 
        }
        public int ConsoleCount
        {
            get { return innerConsole.Count; }
        }
        #endregion
 
        #region Form events
        /// <summary>
        /// Gets some <code>Form</code> settings like Size, Location,...
        /// Restores the <code>Form</code> saved when the <code>be.gaudry.bibliobrol.view.Console</code> was previously closed.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e">An <code>System.EventArgs</code> that contains the event data</param>
        private void ConsoleForm_Load(object sender, EventArgs e)
        {
            this.Size = Properties.Settings.Default.consoleFormSize;
            this.Location = Properties.Settings.Default.consoleFormLocation;
            Config.instanceAddObserver(this);
            /*StaticObservable.notify(
                new Notification(
                    Notification.VERBOSE.debug,
                    "load settings",
                    "console settings loaded",
                    this
                    )
                );*/
        } 
        /// <summary>
        /// Saves some <code>Form</code> settings like Size, Location,...
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e">An <code>System.EventArgs</code> that contains the event data</param>
        private void ConsoleForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            Properties.Settings.Default.consoleFormSize = this.Size;
            Properties.Settings.Default.consoleFormLocation = this.Location;
            Properties.Settings.Default.Save();
            Config.instanceRemoveObserver(this);
        }
 
        #endregion
    }
}

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using be.gaudry.bibliobrol.config;
using be.gaudry.bibliobrol.view.dialogs;
using be.gaudry.observer;
using be.gaudry.view.dialogs;
using be.gaudry.view;
 
namespace be.gaudry.bibliobrol.view.utils
{
    internal delegate void UpdateDelegateHandler(Notification notification);
    public partial class Console : UserControl, be.gaudry.observer.IObserver
    {
        #region declarations
        private int lineNbr, maxLines;
        private Font fontNormal, fontAvert;
        private UpdateDelegateHandler UpdateDelegate;
 
 
        private bool buffered;
        private List<Exception> exBuffer = new List<Exception>();
        #endregion
 
        #region constructors and destructors
        public Console()
        {
            buffered = false;
            InitializeComponent();
            UpdateDelegate = new UpdateDelegateHandler(safeWrite);
            lineNbr = 0;
            maxLines = 200;
            fontNormal = new System.Drawing.Font("Microsoft Sans Serif", 8F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            fontAvert = new System.Drawing.Font(fontNormal, ((System.Drawing.FontStyle)(System.Drawing.FontStyle.Bold)));
            subscribeToObservables();
        }
        ~Console()
        {
            unsubscribeToObservables();
            Dispose(false);
        }
 
        #endregion
 
        #region IObserver Members
 
        public void update(Notification notification)
        {
            try
            {
                cleanTsStatus();
                StringBuilder str;
                switch (notification.Level)
                {
                    case Notification.VERBOSE.persistentOperation:
                        if (Config.ConsolePersistentOps)
                        {
                            consoleRTB.SelectionColor = System.Drawing.Color.Orchid;
                            write(notification);
                        }
                        break;
                    case Notification.VERBOSE.internalNotification:
                        if (Config.ConsoleDebug)
                        {
                            consoleRTB.SelectionColor = System.Drawing.Color.DarkViolet;
                            write(notification);
                        }
                        break;
                    case Notification.VERBOSE.showErrors:
                        if (exBuffer.Count > 0)
                        {
                            new ExceptionDialog(exBuffer).Show();
                            exBuffer.Clear();
                        }
                        buffered = true;
                        break;
                    case Notification.VERBOSE.showNewErrors:
                        exBuffer.Clear();
                        buffered = false;
                        break;
                    case Notification.VERBOSE.hideErrors:
                        buffered = true;
                        break;
                    case Notification.VERBOSE.advancedOperation:
                        if (Config.ConsoleAdvancedOps)
                        {
                            consoleRTB.SelectionColor = System.Drawing.Color.LightSeaGreen;
                            write(notification);
                        }
                        break;
                    case Notification.VERBOSE.basicOperation:
                        if (Config.ConsoleBasicOps)
                        {
                            consoleRTB.SelectionColor = System.Drawing.Color.ForestGreen;
                            write(notification);
                        }
                        break;
                    case Notification.VERBOSE.criticalError:
                        if (this.ParentForm is IMDIParent)
                        {
                            ((IMDIParent)this.ParentForm).setStatusMessage(
                                global::be.gaudry.bibliobrol.Properties.Resources.brolLevel4,
                                "Erreur critique : " + notification.Title,
                                notification.Msg
                                );
                        }
                        if (Config.ConsoleCriticalError)
                        {
                            consoleRTB.SelectionColor = System.Drawing.Color.Crimson;
                            consoleRTB.SelectionFont = fontAvert;
                            write(notification);
                            consoleRTB.SelectionFont = fontNormal;
                        }
                        if (Config.PopupCriticalError)
                        {
                            if (buffered)
                            {
                                exBuffer.Add(notification.NotificationException);
                            }
                            else
                            {
                                ExceptionDialog.ShowDialog(notification.NotificationException, this.ParentForm);
                            }
                            /*str = new StringBuilder(notification.Msg);
                            appendException(str, notification.NotificationException);
                            MessageBox.Show(
                                     str.ToString(),
                                     "ERREUR CRITIQUE : " + notification.Title,
                                     MessageBoxButtons.OK,
                                     MessageBoxIcon.Stop,
                                     MessageBoxDefaultButton.Button1);*/
                        }
                        break;
                    case Notification.VERBOSE.debug:
                        if (Config.ConsoleDebug)
                        {
                            consoleRTB.SelectionColor = System.Drawing.Color.DarkOrange;
                            write(notification);
                        }
                        break;
                    case Notification.VERBOSE.lowError:
                        if (Config.ConsoleLowError)
                        {
                            consoleRTB.SelectionColor = System.Drawing.Color.Crimson;
                            write(notification);
                        }
                        break;
                    case Notification.VERBOSE.error:
                        if (this.ParentForm is IMDIParent)
                        {
                            ((IMDIParent)this.ParentForm).setStatusMessage(
                            global::be.gaudry.bibliobrol.Properties.Resources.brolLevel3,
                            "Erreur : " + notification.Title,
                            notification.Msg
                            );
                        }
                        str = new StringBuilder(notification.Msg);
                        if (Config.ConsoleOpsResult)
                        {
                            consoleRTB.SelectionColor = System.Drawing.Color.Crimson;
                            consoleRTB.SelectionFont = fontAvert;
                            write(notification);
                            consoleRTB.SelectionFont = fontNormal;
                            if (notification.NotificationException != null)
                            {
                                str.Append(notification.NotificationException.Message);
                                str.Append("\n\nVous pouvez consulter la console pour un rapport détaillé de l'erreur.");
                            }
                        }
                        if (Config.PopupOpsResult)
                        {
                            if (notification.NotificationException != null)
                            {
                                if (buffered)
                                {
                                    exBuffer.Add(notification.NotificationException);
                                }
                                else
                                {
                                    ExceptionDialog.ShowDialog(notification.NotificationException, this.ParentForm);
                                }
                            }
                            else MessageBox.Show(
                                this.ParentForm,
                                str.ToString(),
                                "ERREUR : " + notification.Title,
                                MessageBoxButtons.OK,
                                MessageBoxIcon.Error,
                                MessageBoxDefaultButton.Button1
                                );
                        }
                        break;
                    case Notification.VERBOSE.opsResult:
                        if (!notification.Title.Equals(String.Empty) && this.ParentForm is IMDIParent)
                        {
                            ((IMDIParent)this.ParentForm).setStatusMessage(
                                global::be.gaudry.bibliobrol.Properties.Resources.brolLevel1,
                                notification.Title,
                                notification.Msg
                                );
                        }
                        if (Config.ConsoleOpsResult)
                        {
                            consoleRTB.SelectionColor = System.Drawing.Color.SteelBlue;
                            write(notification);
                        }
                        if (Config.PopupOpsResult)
                        {
                            MessageBox.Show(
                                notification.Msg,
                                String.Empty.Equals(notification.Title) ? "Information" : notification.Title,
                                MessageBoxButtons.OK,
                                MessageBoxIcon.Information,
                                MessageBoxDefaultButton.Button1
                                );
                        }
                        break;
                    default:
                        consoleRTB.SelectionColor = System.Drawing.Color.Black;
                        write(notification);
                        break;
                }
                if (lineNbr != 0 && (lineNbr % maxLines == 0))
                {
                    DialogResult r = MessageBox.Show(
                     this,
                     String.Format("La console contient actuellement {0} notifications.Toutes les {1} notifications il est préférable de supprimer les anciens message afin de maintenir un niveau de performances acceptable.\nDésirez-vous vider la console ?", lineNbr, maxLines),
                     "Console",
                     MessageBoxButtons.YesNo,
                     MessageBoxIcon.Exclamation,
                     MessageBoxDefaultButton.Button1);
                    if (r == DialogResult.Yes)
                    {
                        Clear();
                    }
                }
            }
            catch (Exception ex)
            {
                StringBuilder str = new StringBuilder("Tentative d'écriture dans la console depuis un autre thread : ");
                appendException(str, ex);
                System.Console.WriteLine(str.ToString());
            }
        }
 
        #endregion
 
        #region private methods
        private void cleanTsStatus()
        {
            if (this.ParentForm is IMDIParent)
            {
                ((IMDIParent)this.ParentForm).setStatusMessage(
                    global::be.gaudry.bibliobrol.Properties.Resources.brolConsole,
                    String.Format("{0} message(s) dans la console", Count),
                    ""
                    );
            }
        }
        private void subscribeToObservables()
        {
            Config.instanceAddObserver(this);
            //model
            model.dao.DAOFactory.Instance.getConfigDao().addObserver(this);
            model.dao.DAOFactory.Instance.getPersonDao().addObserver(this);
            model.dao.DAOFactory.Instance.getBrolDao().addObserver(this);
            model.dao.DAOFactory.Instance.getMediaBrolDao().addObserver(this);
            model.dao.DAOFactory.Instance.getTaskDao().addObserver(this);
            model.dao.DAOFactory.Instance.getExporterDao().addObserver(this);
            model.dao.DAOFactory.Instance.getImporterDao().addObserver(this);
            model.dao.DAOFactory.Instance.getStatsDao().addObserver(this);
            model.dao.DAOFactory.Instance.getSerieDao().addObserver(this);
            //other views
            StaticObservable.addObserver(this);
        }
        private void unsubscribeToObservables()
        {
            Config.instanceRemoveObserver(this);
            //model
            model.dao.DAOFactory.Instance.getConfigDao().removeObserver(this);
            model.dao.DAOFactory.Instance.getPersonDao().removeObserver(this);
            model.dao.DAOFactory.Instance.getBrolDao().removeObserver(this);
            model.dao.DAOFactory.Instance.getMediaBrolDao().removeObserver(this);
            model.dao.DAOFactory.Instance.getTaskDao().removeObserver(this);
            model.dao.DAOFactory.Instance.getExporterDao().removeObserver(this);
            model.dao.DAOFactory.Instance.getImporterDao().removeObserver(this);
            model.dao.DAOFactory.Instance.getStatsDao().removeObserver(this);
            model.dao.DAOFactory.Instance.getSerieDao().removeObserver(this);
            //other views
            StaticObservable.removeObserver(this);
        }
 
        private void appendException(StringBuilder str, Exception e)
        {
            if (e != null)
            {
                str.Append("\nDétails de l'erreur : \nSource : ");
                str.Append(e.Source);
                str.Append("\nException : ");
                str.Append(e.GetType().ToString());
                str.Append("\nTargetSite : ");
                str.Append(e.TargetSite);
                str.Append("\nInnerException : ");
                str.Append(e.InnerException);
                str.Append("\nStackTrace :\n");
                str.Append(e.StackTrace);
                str.Append("\n\nAide : http://www.gaudry.be/infobrol.html");
            }
        }
        private String getInfo(Notification n)
        {
            StringBuilder str = new StringBuilder("\n\n");
            str.Append(++lineNbr);
            str.Append("\t");
            str.Append(String.Empty.Equals(n.Title) ? "Sans titre" : n.Title);
            if (!String.Empty.Equals(n.Msg))
            {
                str.Append("\nMessage : ");
                str.Append(n.Msg);
            }
            str.Append("\nNiveau de notification : ");
            str.Append(Enum.GetName(typeof(Notification.VERBOSE), n.Level));
            if (n.Sender != null)
            {
                str.Append("\nEnvoyé par ");
                str.Append(n.Sender);
            }
            if (n.NotificationException != null)
            {
                appendException(str, n.NotificationException);
            }
            return str.ToString();
        }
        private void safeWrite(Notification n)
        {
            consoleRTB.AppendText(getInfo(n));
            consoleRTB.ScrollToCaret();
        }
        private void write(Notification n)
        {
            if (consoleRTB.InvokeRequired)
            {
                consoleRTB.Invoke(UpdateDelegate, n);
            }
            else
            {
                safeWrite((n));
            }
        }
        #endregion
 
        #region public methods
        /// <summary>
        /// Cleans all displayed text on the console and resets notifications counter.
        /// </summary>
        public void Clear()
        {
            consoleRTB.Clear();
            lineNbr = 0;
        }
        #endregion
 
        #region properties
        /// <summary>
        /// Number of notifications in the console
        /// </summary>
        public int Count
        {
            get { return this.lineNbr; }
        }
        #endregion
 
        /// <summary>
        /// Cleans all displayed text on the console and resets notifications counter.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void cleanConsole_Click(object sender, EventArgs e)
        {
            Clear();
        }
        /// <summary>
        /// Displays an option dialog to select verbose level of the console 
        /// (allows to select the kinds of notification to display).
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void selectVerbose_Click(object sender, EventArgs e)
        {
            SelectConsoleVerboseDialog dialog = new SelectConsoleVerboseDialog();
            dialog.ShowDialog(ParentForm);
        }
    }
}