private SettingManager() {
     this.alertType = AlertType.LatestOnly;
     this.alertAfterDate = DateTime.MinValue;
     this.svnUserName = "";
     this.svnPassword = "";
     this.listOfTrackingTarget = new List<TrackingTargetEntity>();
 }

 public AlertMsg(AlertType alertType, string title, string body)
     : base(typeof(AlertViewModel))
 {
     AlertType = alertType;
     Title = title;
     Body = body;
 }

 public Alert(AlertType type, AlertDirection direction, int? trigger, string queue)
 {
     Type = type;
     Direction = direction;
     Trigger = trigger;
     Queue = queue;
 }

        public static SetAlert Set(string message, string strongMessage, AlertType typeOfAlert)
        {
            SetAlert alert = new SetAlert();

            alert.Message = message;
            alert.StrongMessage = strongMessage;

            switch (typeOfAlert)
            {
                case AlertType.Success:
                    alert.TypeOfAlert = "alert-success";
                    break;

                case AlertType.Danger:
                    alert.TypeOfAlert = "alert-danger";
                    break;

                case AlertType.Info:
                    alert.TypeOfAlert = "alert-info";
                    break;

                case AlertType.Warning:
                    alert.TypeOfAlert = "alert-warning";
                    break;
            }

            return alert;
        }

        public void ShowAlert(AlertType type, string message)
        {
            HtmlGenericControl h4AlertHeading = (HtmlGenericControl)(this.Master).FindControl("h4AlertHeading");
            Label lblErrorMessage = (Label)(this.Master).FindControl("lblErrorMessage");
            Panel pnlAlert = (Panel)(this.Master).FindControl("pnlAlert");

            h4AlertHeading.Visible = false;
            lblErrorMessage.Text = message;
            switch (type)
            {
                case AlertType.Error:
                    pnlAlert.CssClass = BootstrapStyleConstant.AlertError;
                    break;
                case AlertType.Information:
                    pnlAlert.CssClass = BootstrapStyleConstant.AlertInfo;
                    break;
                case AlertType.Success:
                    pnlAlert.CssClass = BootstrapStyleConstant.AlertSuccess;
                    break;
                default:
                    pnlAlert.CssClass = BootstrapStyleConstant.AlertWarning;
                    break;
            }

            pnlAlert.Visible = true;
        }

        /// <summary>
        /// Creates a list of AlertModels with a single item.
        /// </summary>
        /// <param name="type">The alert type.</param>
        /// <param name="message">The message.</param>
        /// <returns>A single item list of an AlertModel.</returns>
        public static List<AlertModel> CreateSingle(AlertType type, string message)
        {
            Guard.NotNull(() => type);
            Guard.NotNullOrEmpty(() => message);

            return new List<AlertModel> { new AlertModel(type, message) };
        }

 public void Add(String message, AlertType alerttype)
 {
     if (frm != null)
     {
         frm.AddAlert(message, alerttype, scriptname);
     }                
 }

        public static MvcHtmlString GetAlerts(this HtmlHelper helper, AlertType alertType, AlertLocation alertLocation)
        {
            var alertData = helper.ViewContext.TempData.InitializeAlertData();

            List<string> messages = alertData[alertLocation][alertType];
            if (messages.Count > 0)
            {
                var outerBuilder = new TagBuilder("div");
                outerBuilder.AddCssClass("container-fluid");
                foreach (var message in messages)
                {
                    var builder = new TagBuilder("div");
                    builder.AddCssClass("alert");
                    builder.AddCssClass("in");
                    builder.AddCssClass("fade");
                    builder.AddCssClass(alertType.GetDescription());

                    builder.SetInnerText(message);

                    var closeButton = new TagBuilder("a");
                    closeButton.AddCssClass("close");
                    closeButton.MergeAttribute("data-dismiss", "alert");
                    closeButton.MergeAttribute("href", "#");
                    closeButton.InnerHtml += "&times;";

                    builder.InnerHtml += closeButton.ToString(TagRenderMode.Normal);

                    outerBuilder.InnerHtml += builder.ToString(TagRenderMode.Normal);
                }
                return outerBuilder.ToString(TagRenderMode.Normal).ToMvcHtmlString();
            }

            return string.Empty.ToMvcHtmlString();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AlertModel" /> class.
        /// </summary>
        /// <param name="type">The type of the alert.</param>
        /// <param name="message">The message.</param>
        public AlertModel(AlertType type, string message)
        {
            Guard.NotNull(() => type);
            Guard.NotNullOrEmpty(() => message);

            this.Type = type;
            this.Message = message;
        }

 /// <summary>
 /// Create an alert box of the specified type
 /// </summary>
 /// <param name="html">The current HtmlHelper instance</param>
 /// <param name="message">The message to show</param>
 /// <param name="alertType">The type of alert to show.</param>
 public static MvcHtmlString Alert(this HtmlHelper html, string message, AlertType alertType)
 {
     var div = new TagBuilder("div");
     div.AddCssClass("alert-box");
     div.AddCssClass(alertType.GetStringValue());
     div.InnerHtml = message;
     div.InnerHtml += "<a href=\"#\" class=\"close\">&times;</a>";
     return new MvcHtmlString(div.ToString(TagRenderMode.Normal));
 }

        private static void AddMessage(TempDataDictionary tempData, AlertType type, string message,
            AlertLocation location)
        {
            var alertData = tempData.InitializeAlertData();

            alertData[location][type].Add(message);

            tempData["AlertData"] = alertData;
        }

        /// <summary>
        ///     Adds an alert of the specified type with the specified message
        /// </summary>
        /// <param name="controller">
        ///     The <see cref="Controller"/> to use to add the alert
        /// </param>
        /// <param name="type">
        ///     The <see cref="AlertType"/> for the alert
        /// </param>
        /// <param name="message">
        ///     The message for the alert
        /// </param>
        public static void AddAlert(
            this Controller controller, AlertType type, string message)
        {
            List<AlertMessage> alerts = controller.TempData[ALERT_MESSAGE_KEY] as List<AlertMessage> ??
                new List<AlertMessage>();

            alerts.Add(new AlertMessage() { Type = type, Message = message});
            controller.TempData["AlertMessages"] = alerts;
        }

			public MessageBoxForm (IWin32Window owner, string text, string caption,
					       MessageBoxButtons buttons, MessageBoxIcon icon,
					       bool displayHelpButton)
			{
				show_help = displayHelpButton;

				switch (icon) {
					case MessageBoxIcon.None: {
						icon_image = null;
						alert_type = AlertType.Default;
						break;
					}

					case MessageBoxIcon.Error: {		// Same as MessageBoxIcon.Hand and MessageBoxIcon.Stop
						icon_image = SystemIcons.Error;
						alert_type = AlertType.Error;
						break;
					}

					case MessageBoxIcon.Question: {
 						icon_image = SystemIcons.Question;
						alert_type = AlertType.Question;
						break;
					}

					case MessageBoxIcon.Asterisk: {		// Same as MessageBoxIcon.Information
						icon_image = SystemIcons.Information;
						alert_type = AlertType.Information;
						break;
					}

					case MessageBoxIcon.Warning: {		// Same as MessageBoxIcon.Exclamation:
						icon_image = SystemIcons.Warning;
						alert_type = AlertType.Warning;
						break;
					}
				}

				msgbox_text = text;
				msgbox_buttons = buttons;
				msgbox_default = MessageBoxDefaultButton.Button1;

				if (owner != null) {
					Owner = Control.FromHandle(owner.Handle).FindForm();
				} else {
					if (Application.MWFThread.Current.Context != null) {
						Owner = Application.MWFThread.Current.Context.MainForm;
					}
				}
				this.Text = caption;
				this.ControlBox = true;
				this.MinimizeBox = false;
				this.MaximizeBox = false;
				this.ShowInTaskbar = (Owner == null);
				this.FormBorderStyle = FormBorderStyle.FixedDialog;
			}

 public Alarm(string name, AlertType alertType, bool playSound, bool focusClient, bool pauseBot, bool disconnect)
 {
     this._name = name;
     this._alertType = alertType;
     this._playSound = playSound;
     this._focusClient = focusClient;
     this._pauseBot = pauseBot;
     this._disconnect = disconnect;
     this._buttonVisibility = Visibility.Hidden;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="HighlightModel" /> class.
        /// </summary>
        /// <param name="style">The row style.</param>
        /// <param name="partition">The items partition.</param>
        /// <param name="row">The items row key.</param>
        public HighlightModel(AlertType style, string partition, string row)
        {
            Guard.NotNull(() => style);
            Guard.NotNullOrEmpty(() => row);
            Guard.NotNullOrEmpty(() => partition);

            this.Style = style;
            this.Partition = partition;
            this.Row = row;
        }

        private static void AddMessageToTempData(ControllerBase controller, AlertType type, string title, string message)
        {
            var alertMessage = new AlertMessage
            {
                Title = title,
                Message = message,
                CssClass = type.CssClass
            };

            controller.TempData["alert"] = alertMessage.AsJson();
        }

        public static MvcHtmlString Alert(this HtmlHelper html, string shortTitle, string message, AlertType alertType)
        {
            var div = new TagBuilder("div");
            var alertTypeCSS = string.Format("alert-{0}", alertType.ToString().ToLower());
            div.AddCssClass("alert");
            div.AddCssClass(alertTypeCSS);

            var a = new TagBuilder("a");
            a.AddCssClass("close");
            a.Attributes.Add("data-dismiss", "alert");
            a.InnerHtml = "×";

            div.InnerHtml = string.Format("{0}<strong>{1} </strong>{2}", a.ToString(), shortTitle, message);
            return new MvcHtmlString(div.ToString());
        }

        public static void SetAlert(
            this NancyContext context,
            string message,
            AlertType? type = null)
        {
            var hash = MD5(message);

            context.Request.Session[String.Concat("alert-", hash)] = new Alert
            {
                Message = message,
                Type = type ?? AlertType.NotSpecified
            };

            context.Items["alert-hash"] = hash;
        }

        public static ICollection<Alert> GetAlerts(this TempDataDictionary tempData, AlertType? type = null)
        {
            if (!tempData.ContainsKey(AlertsKey))
            {
                tempData[AlertsKey] = new List<Alert>();
            }

            var alerts = (ICollection<Alert>)tempData[AlertsKey];

            if (type.HasValue)
            {
                alerts = alerts.Where(a => a.Type == type.Value).ToList();
            }

            return alerts;
        }

        private static string convertTypeToString(AlertType a)
        {
            switch (a)
            {
                case AlertType.Danger:
                    return "danger";
                case AlertType.Warning:
                    return "warning";
                case AlertType.Info:
                    return "info";
                case AlertType.Success:
                    return "success";
            }

            return "";
        }