tbf/WorkflowConfigurator/UserControls/OverviewOfProcessesCtrl.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Windows.Forms;
using log4net;
using Common;
using SharedDatabase.Entities;
using SharedDatabase.Forms;
using WorkflowConfigurator.Resources;
using NHibernate;

namespace WorkflowConfigurator.UserControls
{
    public partial class OverviewOfProcessesCtrl : UserControl
    {
        static readonly ILog log = LogManager.GetLogger(typeof(OverviewOfProcessesCtrl));

        MainWnd parent;
        IList<Process> allProcesses;

        /// <summary>
        /// Default constructor used by designer only.
        /// </summary>
        private OverviewOfProcessesCtrl()
        {
            InitializeComponent();
        }

        /// <summary>
        /// Constructor used in runtime, the control is created and added to the tab page dunamically by code.
        /// </summary>
        /// <param name="parent">Parent</param>
        public OverviewOfProcessesCtrl(MainWnd parent)
            : this()
        {
            this.parent = parent;
            Dock = DockStyle.Fill;

            allProcesses = new List<Process>();

            editProcessCtrl.OverviewCtrl = this;
        }

        private void OverviewOfProcessesCtrl_Load(object sender, EventArgs e)
        {
            if (parent != null)
            {
                Localize();

                Settings2UI();

                ((Form)parent).Closing += new CancelEventHandler(ParentClosing);

                allProcesses = SharedDatabase.TracingDB.Session.QueryOver<Process>().OrderBy(x => x.Name).Asc.List(); ;
                RedrawLeftPane(RedrawType.FromScratch, null);
                editProcessCtrl.UpdateProcess(null, Reason.OpenProcess, allProcesses);
            }
        }

        private void settingsButton_Click(object sender, EventArgs e)
        {
            GID[] rqrdMmbrshp = Program.SettingsAccessLevel;
            ///
            if (CurrentUser.IsMemberOf(rqrdMmbrshp) ||
                new LoginDlg(rqrdMmbrshp, null).ShowDialog() == DialogResult.OK)
            {
                MainWnd.PrintTitle(false);
                new Forms.SettingsDlg().ShowDialog();       /// Logged in => Show settings dialog
            }
        }

        private void allListBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            /// TODO: Check whether the process really changed

            int selectedIx = allListBox.SelectedIndex;
            Process selectedProcess = (selectedIx >= 0) ? (allListBox.Items[selectedIx] as Process) : null;

            if (selectedProcess != editProcessCtrl.Process)
            {
                switch (editProcessCtrl.FinishEditing())
                {
                    case EditFinishedInfo.Cancel:
                        /// Continue editing, redraw left pane so that the previously selected item is selected again
                        RedrawLeftPane(RedrawType.FromScratch, editProcessCtrl.Process);
                        break;

                    case EditFinishedInfo.DataChanged:
                        /// Left pane might have been changed => redraw it
                        editProcessCtrl.UpdateProcess(selectedProcess, Reason.OpenProcess, allProcesses);
                        RedrawLeftPane(RedrawType.FromScratch, selectedProcess);
                        break;

                    default:
                        editProcessCtrl.UpdateProcess(selectedProcess, Reason.OpenProcess, allProcesses);
                        break;
                }
            }
        }

        private void checkBox6_CheckedChanged(object sender, EventArgs e) { AnyFilterChanged(); }
        private void checkBox7_CheckedChanged(object sender, EventArgs e) { AnyFilterChanged(); }
        private void checkBox8_CheckedChanged(object sender, EventArgs e) { AnyFilterChanged(); }
        private void checkBox9_CheckedChanged(object sender, EventArgs e) { AnyFilterChanged(); }
        private void nameContainsTextBox_TextChanged(object sender, EventArgs e) { AnyFilterChanged(); }

        void AnyFilterChanged()
        {
            RedrawLeftPane(RedrawType.FromScratch, editProcessCtrl.Process);
        }

        void ParentClosing(object sender, CancelEventArgs e)
        {
            if (editProcessCtrl.FinishEditing() == EditFinishedInfo.Cancel)
            {
                e.Cancel = true;
                return;
            }

            UI2Settings();
        }


        /// <summary>
        /// Redraw a list of processes selected by filters.
        /// </summary>
        /// <param name="fromScratch"></param>
        public void RedrawLeftPane(RedrawType redrawType, Process selectedProcess)
        {
            int count;

            if (redrawType == RedrawType.FromScratch)
            {
                allListBox.Items.Clear();
                count = 0;
                foreach (var process in allProcesses)
                {
                    if (IsProcessEnabled(process))
                    {
                        allListBox.Items.Add(process);
                        if ((selectedProcess != null) && (selectedProcess == process))
                        {
                            allListBox.SetSelected(count, true);
                        }
                        count++;
                    }
                }
            }
            else
            {
                /// Not supported now
                count = allListBox.Items.Count;
            }

            allProcessesLabel.Text = string.Format("{0} ({1})", Strings.Workflows, count);
        }

        #region Helper functions

        void Localize()
        {
            settingsButton.Text = Strings.Settings;
            newButton.Text = Strings.New_workflow;
            copyButton.Text = Strings.Copy_workflow;

            filterGroupBox.Text = Strings.Filter;
            checkBox6.Text = Strings.In_preparation;
            checkBox7.Text = Strings.Testing;
            checkBox8.Text = Strings.Released;
            checkBox9.Text = Strings.Deactivated;
            nameContainsGroupBox.Text = Strings.Name_contains + ':';

            allProcessesLabel.Text = Strings.Workflows;
        }

        /// <summary>
        /// Set UI properties (determining the window position, etc) to values obtained from local settings
        /// </summary>
        void Settings2UI()
        {
            try
            {
                LocalSettings ls = Program.LocalSettings;
                ///
                checkBox6.Checked = ls.OverviewCB6;
                checkBox7.Checked = ls.OverviewCB7;
                checkBox8.Checked = ls.OverviewCB8;
                checkBox9.Checked = ls.OverviewCB9;
                nameContainsTextBox.Text = ls.OverviewNameContains;
                rootSplitContainer.SplitterDistance = Math.Max(rootSplitContainer.Panel1MinSize,
                                                      Math.Min(rootSplitContainer.Width - rootSplitContainer.Panel2MinSize,
                                                      (ls.SplDst2 > 0) ? Convert.ToInt32(ls.SplDst1 * Width) : 400));

                editProcessCtrl.Settings2UI();
            }
            catch (Exception exc)
            {
                log.ErrorFormat("Cannot restore settings: {0}", exc.Message);
            }
        }

        /// <summary>
        /// Retrieve UI properties and save them to local settings
        /// </summary>
        void UI2Settings()
        {
            LocalSettings ls = Program.LocalSettings;
            ///
            ls.OverviewCB6 = checkBox6.Checked;
            ls.OverviewCB7 = checkBox7.Checked;
            ls.OverviewCB8 = checkBox8.Checked;
            ls.OverviewCB9 = checkBox9.Checked;
            ls.OverviewNameContains = nameContainsTextBox.Text;
            ls.SplDst1 = (float)rootSplitContainer.SplitterDistance / (float)Width;

            editProcessCtrl.UI2Settings();
        }

        /// <summary>
        /// Determines whether a process is enabled for display based on process.ReleaseStatus,
        /// process.Name and a combination of process.SubClass and checked states of checkBoxes.
        /// </summary>
        /// <param name="process">Process</param>
        /// <returns>true when enabled</returns>
        bool IsProcessEnabled(Process process)
        {
            /// Display a newly created process even if it would be hidden by the filter
            if (process.Id == 0)
            {
                return true;
            }

            if (!string.IsNullOrEmpty(nameContainsTextBox.Text))
            {
                /// Hide processes that do not contain a search pattern (in case there is any search patrtern)
                if (!process.Name.Contains(nameContainsTextBox.Text)) return false;
            }

            return ((process.ReleaseStatus == SharedDatabase.ReleaseStatus.In_preparation && checkBox6.Checked) ||
                    (process.ReleaseStatus == SharedDatabase.ReleaseStatus.ToBeApproved && checkBox7.Checked) ||
                    ((process.ReleaseStatus == SharedDatabase.ReleaseStatus.Released ||
                      process.ReleaseStatus == SharedDatabase.ReleaseStatus.ReleasedActive) && checkBox8.Checked) ||
                    (process.ReleaseStatus == SharedDatabase.ReleaseStatus.Deactivated && checkBox9.Checked));
        }

        #endregion

        /// <summary>
        /// Find an unused process name.
        /// </summary>
        /// <returns></returns>
        public string NewProcessName(string rootName)
        {
            int nameId = 1;
            string newName;

            bool nameIsUsed;
            do
            {
                newName = string.Format("{0} {1}", rootName, nameId++);
                nameIsUsed = false;
                foreach (var t in allProcesses)
                {
                    if (t.Name.Equals(newName))
                    {
                        nameIsUsed = true;
                        break;
                    }
                }

            }
            while (nameIsUsed);

            return newName;
        }


        private void newButton_Click(object sender, EventArgs e)
        {
            GID[] rqrdMmbrshp = EditProcessCtrl.UnlockAccessLevel;
            ///
            if (CurrentUser.IsMemberOf(rqrdMmbrshp) ||
                new LoginDlg(rqrdMmbrshp, null).ShowDialog() == DialogResult.OK)
            {
                MainWnd.PrintTitle(false);

                if (editProcessCtrl.FinishEditing() == EditFinishedInfo.Cancel) return;

                Process newProcess = new Process(NewProcessName(Strings.Workflow));
                newProcess.CreatedBy = CurrentUser.UserName();
                allProcesses.Add(newProcess);
                editProcessCtrl.UpdateProcess(newProcess, Reason.NewProcess, allProcesses);
                RedrawLeftPane(RedrawType.FromScratch, newProcess);         /// By this the new process will be selected
            }
        }

        private void copyButton_Click(object sender, EventArgs e)
        {
            MainWnd.PrintTitle(false);

            if ((editProcessCtrl.Process == null) || (editProcessCtrl.FinishEditing() == EditFinishedInfo.Cancel)) return;

            Process processCopy = editProcessCtrl.Process.Clone(NewProcessName(string.Format("{0} - {1}", editProcessCtrl.Process.Name, Strings.copy)), CurrentUser.UserName());
            allProcesses.Add(processCopy);
            editProcessCtrl.UpdateProcess(processCopy, Reason.CopyProcess, allProcesses);
            RedrawLeftPane(RedrawType.FromScratch, processCopy);    /// By this the copied process will be selected
        }

        private void wizardButton_Click(object sender, EventArgs e)
        {
            MainWnd.PrintTitle(false);

            if ((editProcessCtrl.Process == null) || (editProcessCtrl.FinishEditing() == EditFinishedInfo.Cancel)) return;

            Process processFromTemplate = editProcessCtrl.Process.Clone(NewProcessName(string.Format(Strings.Workflow_from_template_0, editProcessCtrl.Process.Name)), CurrentUser.UserName());
            allProcesses.Add(processFromTemplate);
            editProcessCtrl.UpdateProcess(processFromTemplate, Reason.CopyProcess, allProcesses);
            RedrawLeftPane(RedrawType.FromScratch, processFromTemplate);    /// By this the process created from a template will be selected

            editProcessCtrl.ImportPartsUsingTemplate();
        }
    }
}