C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Applications/Client Plugins/Queue Manager Plugin/Forms/QueueManagerForm.cs

/*  ----------------------------------------------------------------------------
 *  Microsoft Corporation
 *  ----------------------------------------------------------------------------
 *  Microsoft Project Server mpFx (mpFx)
 *  ----------------------------------------------------------------------------
 *  Author: Colby Africa
 *  ----------------------------------------------------------------------------
 *  License: http://code.msdn.microsoft.com/mpFx/Project/License.aspx
 *  ----------------------------------------------------------------------------
 */

using System;
using System.Collections.Generic;
using System.Data;
using System.Threading;
using System.Web.Services.Protocols;
using System.Windows.Forms;
using Mcs.Epm.MicrosoftProject.mpFx.Client.Plugins.QueueManagerPlugin.Controls;
using Mcs.Epm.MicrosoftProject.mpFx.Client.Plugins.QueueManagerPlugin.Properties;
using Mcs.Epm.MicrosoftProject.mpFx.Client.Plugins.QueueManagerPlugin.QueueWebService;
using Mcs.Epm.MicrosoftProject.mpFx.Client.Shared;
using Microsoft.Office.Project.Server.Library;
using SortOrder = Mcs.Epm.MicrosoftProject.mpFx.Client.Plugins.QueueManagerPlugin.QueueWebService.SortOrder;

namespace Mcs.Epm.MicrosoftProject.mpFx.Client.Plugins.QueueManagerPlugin.Forms
{
    /// <summary>
    /// Implements the main user interface for the Queue Manager plugin
    /// </summary>
    public partial class QueueManagerForm : Form
    {
        #region Structures

        public struct PROCESS_OPTIONS
        {
            public List<QueueMsgType> JobTypes;
            public List<JobState> JobStates;
            public DateTime StartDate;
            public DateTime EndDate;
            public SortColumn SortColumn;
            public SortOrder SortOrder;
            public int NumberOfItems;
            public int Interval;
        }

        #endregion

        #region Private Delegates

        private delegate void OnRowChangeEventHandler(QueueStatusDataSet.StatusRow row, bool exists);
        private delegate void OnExceptionEventHandler(object sender, Exception exception);

        #endregion

        #region Instance Data

        private readonly QueueManagerPlugin _QueueManagerPlugin;

        private QueueSystem _QueueWebService;
        private QueueStatusDataSet _LastResult;

        private ListPickerControl _JobTypesPickerControl;
        private ListPickerControl _StatusesPickerControl;
        private ListPickerControl _ColumnsPickerControl;

        private readonly ToolStripControlHost _StartDateToolStripControlHost;
        private readonly ToolStripControlHost _EndDateToolStripControlHost;
        private readonly ToolStripControlHost _StartTimeDateToolStripControlHost;
        private readonly ToolStripControlHost _EndTimeDateToolStripControlHost;

        private readonly ManualResetEvent _StopRequestEvent = new ManualResetEvent(false);
        private readonly ManualResetEvent _StoppedIndicatorEvent = new ManualResetEvent(true);

        private Thread _ReadThread;
        private PROCESS_OPTIONS _ProcessOptions;

        private readonly object _SetProcessOptionsLock;
        private readonly object _ProcessOptionsLock;

        private int _NumberOfItems;
        private string _SelectedSortOrderValue;
        private string _SelectedSortColumnValue;

        #endregion

        #region Constructors

        public QueueManagerForm(QueueManagerPlugin queueManagerPlugin)
        {
            InitializeComponent();

            if (queueManagerPlugin == null)
            {
                throw new ArgumentNullException("queueManagerPlugin");
            }

            _QueueManagerPlugin = queueManagerPlugin;

            #region Date and Time Picker Hosting

            _StartDateToolStripControlHost = new ToolStripControlHost(startDateTimePicker);
            _StartTimeDateToolStripControlHost = new ToolStripControlHost(startTimeDateTimePicker);

            toolStrip.Items.Insert(3, _StartDateToolStripControlHost);
            toolStrip.Items.Insert(4, _StartTimeDateToolStripControlHost);

            _EndDateToolStripControlHost = new ToolStripControlHost(endDateTimePicker);
            _EndTimeDateToolStripControlHost = new ToolStripControlHost(endTimeDateTimePicker);

            toolStrip.Items.Insert(6, _EndDateToolStripControlHost);
            toolStrip.Items.Insert(7, _EndTimeDateToolStripControlHost);

            startDateTimePicker.Visible = true;
            endDateTimePicker.Visible = true;
            endTimeDateTimePicker.Visible = true;
            endDateTimePicker.Visible = true;

            #endregion

            try
            {
                LoadQueueInformation();
            }
            catch (Exception exception)
            {
                MessageBox.Show(this,
                                exception.Message,
                                Resources.PluginName,
                                MessageBoxButtons.OK,
                                MessageBoxIcon.Error);

            }

            _ProcessOptionsLock = new object();
            _SetProcessOptionsLock = new object();
        }

        private void SetProcessOptions(List<QueueMsgType> jobTypes, List<JobState> jobStates, DateTime startDate, DateTime endDate, int numItems, SortColumn sortColumn, SortOrder sortOrder)
        {
            lock (_SetProcessOptionsLock)
            {
                _ProcessOptions.JobStates = jobStates;
                _ProcessOptions.JobTypes = jobTypes;
                _ProcessOptions.StartDate = startDate;
                _ProcessOptions.EndDate = endDate;
                _ProcessOptions.NumberOfItems = numItems;
                _ProcessOptions.SortColumn = sortColumn;
                _ProcessOptions.SortOrder = sortOrder;
            }
        }

        #endregion

        #region Private Methods

        private void LoadQueueInformation()
        {
            //  Create another instance of the queue system web service from the ProjectServer's instance's properties
            //  ProjectServer is not thread safe and is a shared object
            CreateQueueWebService();

            LoadSortColumns();

            LoadSortOrders();

            LoadColumns();

            LoadJobTypesPickerControl();

            LoadJobStatusesPickerControl();

        }

        private void LoadSortColumns()
        {
            foreach (string name in Enum.GetNames(typeof(SortColumn)))
            {
                if (!name.Equals("Undefined", StringComparison.CurrentCultureIgnoreCase))
                {
                    string displayName = Tools.GetDecameledString(name);
                    sortColumnToolStripComboBox.Items.Add(displayName);
                }
            }

            if (string.IsNullOrEmpty(Settings.Default.LastSortColumn))
            {
                sortColumnToolStripComboBox.Text = "Queue ID";
            }
            else
            {
                sortColumnToolStripComboBox.Text = Tools.GetDecameledString(Settings.Default.LastSortColumn);
            }
        }

        private void LoadSortOrders()
        {
            foreach (string name in Enum.GetNames(typeof(SortOrder)))
            {
                if (!name.Equals("Undefined", StringComparison.CurrentCultureIgnoreCase))
                {
                    string displayName = Tools.GetDecameledString(name);
                    sortOrderToolStripComboBox.Items.Add(displayName);
                }
            }

            if (string.IsNullOrEmpty(Settings.Default.LastSortOrder))
            {
                sortOrderToolStripComboBox.Text = "Ascending";
            }
            else
            {
                sortOrderToolStripComboBox.Text = Tools.GetDecameledString(Settings.Default.LastSortOrder);
            }
        }

        private void CreateQueueWebService()
        {
            _QueueWebService = new QueueSystem();

            _QueueWebService.Url = _QueueManagerPlugin.ProjectServer.WebServices.Queue.Url;
            _QueueWebService.UseDefaultCredentials = _QueueManagerPlugin.ProjectServer.WebServices.Queue.UseDefaultCredentials;
            _QueueWebService.Credentials = _QueueManagerPlugin.ProjectServer.WebServices.Queue.Credentials;

            _QueueWebService.ReadAllJobStatusCompleted += _QueueWebService_ReadAllJobStatusCompleted;
        }

        private void LoadJobStatusesPickerControl()
        {
            Dictionary<string, ListPickerControl.ListItem> statuses = new Dictionary<string, ListPickerControl.ListItem>();

            CreateList(Settings.Default.SelelectedCompletionStatuses.Split(','), typeof(JobState), statuses);

            _StatusesPickerControl = new ListPickerControl("Completion Statuses", statuses, true);
            _StatusesPickerControl.OnListChanged += _StatusesPickerControl_OnListChanged;
            _StatusesPickerControl.Dock = DockStyle.Fill;

            completionStatusesPanel.Controls.Add(_StatusesPickerControl);
            _StatusesPickerControl.BringToFront();
        }

        private void LoadJobTypesPickerControl()
        {
            Dictionary<string, ListPickerControl.ListItem> jobTypes = new Dictionary<string, ListPickerControl.ListItem>();

            CreateList(Settings.Default.SelectedJobTypes.Split(','), typeof(QueueMsgType), jobTypes);

            _JobTypesPickerControl = new ListPickerControl("Job Types", jobTypes, true);
            _JobTypesPickerControl.OnListChanged += _JobTypesPickerControl_OnListChanged;
            _JobTypesPickerControl.Dock = DockStyle.Fill;

            jobTypesPanel.Controls.Add(_JobTypesPickerControl);
            _JobTypesPickerControl.BringToFront();
        }

        private void LoadColumns()
        {
            List<string> list = new List<string>(Settings.Default.DisplayedColumns.Split(','));
            Dictionary<string, ListPickerControl.ListItem> columns = new Dictionary<string, ListPickerControl.ListItem>();

            using (QueueStatusDataSet queueStatusDataSet = new QueueStatusDataSet())
            {
                foreach (DataColumn column in queueStatusDataSet.Status.Columns)
                {
                    ListPickerControl.ListItem item = new ListPickerControl.ListItem();

                    item.Value = column;
                    item.Name = column.ColumnName;
                    item.DisplayName = Tools.GetDecameledString(item.Name).Replace("GUID", string.Empty);
                    item.Selected = list.Contains(item.Name);
                    item.Type = column.DataType;
                    columns.Add(item.Name, item);

                    DataGridViewTextBoxColumn gridColumn = CreateGridColumn(item);

                    gridColumn.Visible = item.Selected;
                    queueDataGridView.Columns.Add(gridColumn);
                }
            }

            _ColumnsPickerControl = new ListPickerControl("Columns", columns, true);
            _ColumnsPickerControl.OnListChanged += _ColumnsPickerControl_OnListChanged;
            _ColumnsPickerControl.OnSelectedItemAdded += _ColumnsPickerControl_OnSelectedItemAdded;
            _ColumnsPickerControl.OnSelectedItemRemoved += _ColumnsPickerControl_OnSelectedItemRemoved;
            _ColumnsPickerControl.Dock = DockStyle.Fill;

            columnsPanel.Controls.Add(_ColumnsPickerControl);
            _ColumnsPickerControl.BringToFront();
        }

        private void ReadQueue()
        {
            if (_StopRequestEvent.WaitOne(0))
            {
                _StoppedIndicatorEvent.Set();
                return;
            }

            List<ListPickerControl.ListItem> selectedJobTypes = _JobTypesPickerControl.SelectedItems;
            List<QueueMsgType> jobTypes = new List<QueueMsgType>();

            foreach (ListPickerControl.ListItem jobType in selectedJobTypes)
            {
                if ((QueueMsgType)jobType.Value != QueueMsgType.Unknown)
                {
                    jobTypes.Add((QueueMsgType)jobType.Value);
                }
            }

            List<ListPickerControl.ListItem> selectedStatuses = _StatusesPickerControl.SelectedItems;
            List<JobState> jobStates = new List<JobState>();

            foreach (ListPickerControl.ListItem status in selectedStatuses)
            {
                if ((JobState)status.Value != JobState.Unknown)
                {
                    jobStates.Add((JobState)status.Value);
                }
            }

            DateTime startDate = ToDateTime(startDateTimePicker.Value.ToShortDateString(),
                                            startTimeDateTimePicker.Value.ToLongTimeString());

            DateTime endDate = ToDateTime(endDateTimePicker.Value.ToShortDateString(),
                                          endTimeDateTimePicker.Value.ToLongTimeString());

            SortColumn sortColumn =
                (SortColumn)Enum.Parse(typeof(SortColumn), SortColumnValue);

            SortOrder sortOrder =
                (SortOrder)Enum.Parse(typeof(SortOrder), SortOrderValue);

            SetProcessOptions(jobTypes, jobStates, startDate, endDate, _NumberOfItems, sortColumn, sortOrder);

            PROCESS_OPTIONS processOptions = ProcessOptions;

            _QueueWebService.ReadAllJobStatusAsync(processOptions.JobStates.ToArray(),
                                                   processOptions.JobTypes.ToArray(),
                                                   processOptions.StartDate,
                                                   processOptions.EndDate,
                                                   processOptions.NumberOfItems,
                                                   true,
                                                   processOptions.SortColumn,
                                                   processOptions.SortOrder);
        }

        private string SortOrderValue
        {
            get
            {
                return _SelectedSortOrderValue;
            }
        }

        private string SortColumnValue
        {
            get
            {
                if (string.IsNullOrEmpty(_SelectedSortColumnValue))
                {
                    _SelectedSortColumnValue = "QueueId";

                }

                return _SelectedSortColumnValue;
            }
        }

        public PROCESS_OPTIONS ProcessOptions
        {
            get
            {
                PROCESS_OPTIONS processOptions;

                lock (_ProcessOptionsLock)
                {
                    processOptions = _ProcessOptions;
                }

                return processOptions;
            }
        }

        private static DateTime ToDateTime(string date, object time)
        {
            return Convert.ToDateTime(date + " " + time);
        }

        private void StopReadingQueue()
        {
            stopToolStripButton.Enabled = false;

            if (_ReadThread != null)
            {
                _QueueManagerPlugin.DoOnStatusChanged(new OnStatusChangedArgs("Cancelling..."));
                _StopRequestEvent.Set();

                while (!_StoppedIndicatorEvent.WaitOne(200))
                {
                    Application.DoEvents();
                }

                _QueueManagerPlugin.DoOnStatusChanged(new OnStatusChangedArgs(string.Empty));
            }

            FreeLastResult();

            startToolStripButton.Enabled = true;
            stopToolStripButton.Enabled = false;
        }

        private void ProcessResults(Exception error, QueueStatusDataSet results)
        {
            if (_LastResult == null)
            {
                foreach (QueueStatusDataSet.StatusRow statusRow in results.Status.Rows)
                {
                    Invoke(new OnRowChangeEventHandler(OnRowChange), new object[] { statusRow, false });
                }
            }
            else
            {
                bool found = false;

                foreach (QueueStatusDataSet.StatusRow row in results.Status.Rows)
                {
                    foreach (QueueStatusDataSet.StatusRow previousResultRow in _LastResult.Status.Rows)
                    {
                        if (previousResultRow.JobGUID ==
                            row.JobGUID)
                        {
                            found = true;
                            break;
                        }
                    }

                    if (found)
                    {
                        Invoke(new OnRowChangeEventHandler(OnRowChange), new object[] { row, true });
                    }
                    else
                    {
                        Invoke(new OnRowChangeEventHandler(OnRowChange), new object[] { row, false });
                    }

                    found = false;
                }
            }

            FreeLastResult();

            _LastResult = results;

            if (error != null || _StopRequestEvent.WaitOne(0))
            {
                _StoppedIndicatorEvent.Set();
                return;
            }

            PROCESS_OPTIONS processOptions = ProcessOptions;
            if (processOptions.Interval > 0)
            {
                Thread.Sleep(processOptions.Interval * 1000);
            }
            ReadQueue();
        }

        private void OnRowChange(QueueStatusDataSet.StatusRow row, bool exists)
        {
            if (exists)
            {
                UpdateQueueRow(row);
            }
            else
            {
                AddQueueRow(row);
            }
        }

        private void UpdateQueueRow(QueueStatusDataSet.StatusRow status)
        {
            foreach (DataGridViewRow row in queueDataGridView.Rows)
            {
                if (new Guid(row.Cells["JobGUID"].Value.ToString()) == status.JobGUID && (int)Enum.Parse(typeof(QueueMsgType), row.Cells["MessageType"].Value.ToString()) == status.MessageType)
                {
                    foreach (DataColumn column in status.Table.Columns)
                    {
                        row.Cells[column.ColumnName].Value = GetValue(status[column], column.ColumnName);
                    }

                    break;
                }
            }
        }

        private void FreeLastResult()
        {
            if (_LastResult != null)
            {
                _LastResult.Dispose();
                _LastResult = null;
            }
        }

        private void AddQueueRow(DataRow statusRow)
        {
            List<object> values = new List<object>();

            foreach (DataGridViewColumn column in queueDataGridView.Columns)
            {
                values.Add(GetValue(statusRow[column.Name], column.Name));

            }

            queueDataGridView.Rows.Add(values.ToArray());
        }

        private object GetValue(object value, string columnName)
        {
            string valueString = value.ToString();
            switch (columnName)
            {
                case "JobInfoGUID":
                    Guid testGuid = new Guid(valueString);
                    if (_QueueManagerPlugin.ProjectServer.Resources.ContainsKey(testGuid))
                    {
                        return _QueueManagerPlugin.ProjectServer.Resources[testGuid].Name;
                    }

                    if (_QueueManagerPlugin.ProjectServer.Projects.ContainsKey(testGuid))
                    {
                        return _QueueManagerPlugin.ProjectServer.Projects[testGuid].Name;
                    }
                    return valueString;

                case "MessageType":
                    return Enum.Parse(typeof(QueueMsgType), valueString).ToString();
                case "JobCompletionState":
                    return Enum.Parse(typeof(JobState), valueString).ToString();
                case "ErrorInfo":
                    PSClientError error = new PSClientError(valueString);
                    return Errors.FormatProjectError(error.GetAllErrors(), valueString);
                case "PercentComplete":
                    return string.Format("{0}%", valueString);
                case "ResourceGUID":
                    if (Tools.IsGuid(valueString))
                    {
                        try
                        {
                            EnterpriseResource resource =
                                _QueueManagerPlugin.ProjectServer.Resources[new Guid(valueString)];
                            if (resource != null)
                            {
                                return resource.Name;
                            }
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine(e);
                        }
                    }
                    return string.Empty;
                default:
                    return value.ToString();
            }
        }

        private static string GetSaveString(IEnumerable<ListPickerControl.ListItem> list)
        {
            string saveString = string.Empty;
            foreach (ListPickerControl.ListItem item in list)
            {
                saveString = saveString + item.Name + ",";
            }

            saveString = saveString.TrimEnd(',');

            return saveString;
        }

        private static void CreateList(IEnumerable<string> selectedList, Type enumType, IDictionary<string, ListPickerControl.ListItem> dictionary)
        {
            List<string> list = new List<string>(selectedList);

            foreach (string name in Enum.GetNames(enumType))
            {
                ListPickerControl.ListItem listItem = new ListPickerControl.ListItem();

                listItem.Value = Enum.Parse(enumType, name);
                listItem.Name = name;
                listItem.Selected = list.Contains(name);

                dictionary.Add(name, listItem);
            }
        }

        private static DataGridViewTextBoxColumn CreateGridColumn(ListPickerControl.ListItem item)
        {
            DataGridViewTextBoxColumn gridColumn = new DataGridViewTextBoxColumn();
            gridColumn.Name = item.Name;
            gridColumn.HeaderText = item.DisplayName;
            gridColumn.ValueType = item.Type;
            gridColumn.SortMode = DataGridViewColumnSortMode.Automatic;
            return gridColumn;
        }

        private static void TestIsNumeric(ToolStripItem textBox, out int result)
        {
            if (int.TryParse(textBox.Text, out result))
            {
                return;
            }

            textBox.Text = "0";

            return;
        }

        private void ResetGrid()
        {
            queueDataGridView.Rows.Clear();
            FreeLastResult();
        }

        #endregion

        #region Event Handlers

        void _ColumnsPickerControl_OnSelectedItemRemoved(object sender, OnItemChangedEventHandlerArgs args)
        {
            if (queueDataGridView.Columns[args.Item.Name] != null)
            {
                queueDataGridView.Columns[args.Item.Name].Visible = false;
            }
        }

        private void _ColumnsPickerControl_OnSelectedItemAdded(object sender, OnItemChangedEventHandlerArgs args)
        {
            if (queueDataGridView.Columns[args.Item.Name] != null)
            {
                queueDataGridView.Columns[args.Item.Name].Visible = true;
            }
        }

        void _StatusesPickerControl_OnListChanged(object sender, EventArgs e)
        {
            ResetGrid();
        }

        void _JobTypesPickerControl_OnListChanged(object sender, EventArgs e)
        {
            ResetGrid();
        }

        void _ColumnsPickerControl_OnListChanged(object sender, EventArgs e)
        {
            ResetGrid();
        }

        private void optionsToolStripButton_Click(object sender, EventArgs e)
        {
            optionsPanel.Visible = !optionsPanel.Visible;
        }

        private void hideButton_Click(object sender, EventArgs e)
        {
            optionsPanel.Visible = false;
        }

        private void QueueManagerForm_FormClosed(object sender, FormClosedEventArgs e)
        {
            _QueueWebService.CancelAsync(null);
            _QueueWebService.ReadAllJobStatusCompleted -= _QueueWebService_ReadAllJobStatusCompleted;

            List<ListPickerControl.ListItem> list = _StatusesPickerControl.SelectedItems;

            string saveString = GetSaveString(list);

            Settings.Default.SelelectedCompletionStatuses = saveString;

            list = _JobTypesPickerControl.SelectedItems;

            saveString = GetSaveString(list);

            Settings.Default.SelectedJobTypes = saveString;

            list = _ColumnsPickerControl.SelectedItems;

            saveString = GetSaveString(list);

            Settings.Default.DisplayedColumns = saveString;
            Settings.Default.LastStartDate = ProcessOptions.StartDate;
            Settings.Default.LastEndDate = ProcessOptions.EndDate;
            Settings.Default.LastNumItems = ProcessOptions.NumberOfItems;
            Settings.Default.LastSortColumn = ProcessOptions.SortColumn.ToString();
            Settings.Default.LastSortOrder = ProcessOptions.SortOrder.ToString();

            Settings.Default.Save();

            StopReadingQueue();

        }

        private void startToolStripButton_Click(object sender, EventArgs e)
        {
            FreeLastResult();
            startToolStripButton.Enabled = false;
            stopToolStripButton.Enabled = true;

            _StopRequestEvent.Reset();
            _StoppedIndicatorEvent.Reset();

            _ReadThread = new Thread(ReadQueue);
            _ReadThread.Start();
        }

        void _QueueWebService_ReadAllJobStatusCompleted(object sender, ReadAllJobStatusCompletedEventArgs e)
        {
            if (e.Cancelled)
            {
                _StoppedIndicatorEvent.Set();
            }
            else
            {
                ProcessResults(e);
            }
        }

        private void ProcessResults(ReadAllJobStatusCompletedEventArgs e)
        {
            try
            {
                ProcessResults(e.Error, e.Result);
            }
            catch (Exception exception)
            {
                _StoppedIndicatorEvent.Set();
                Invoke(new OnExceptionEventHandler(OnException), new object[] { this, exception });
            }

        }

        private void OnException(object sender, Exception exception)
        {
            if (exception is SoapException)
            {
                MessageBox.Show(null,
                                Errors.ProcessMSProjectErrors((SoapException)exception),
                                Resources.PluginName,
                                MessageBoxButtons.OK,
                                MessageBoxIcon.Error);

            }
            else if (exception.InnerException is SoapException)
            {
                MessageBox.Show(null,
                                Errors.ProcessMSProjectErrors((SoapException)exception.InnerException),
                                Resources.PluginName,
                                MessageBoxButtons.OK,
                                MessageBoxIcon.Error);

            }
            else
            {
                MessageBox.Show(null,
                                exception.Message,
                                Resources.PluginName,
                                MessageBoxButtons.OK,
                                MessageBoxIcon.Error);
            }

            StopReadingQueue();

        }

        private void stopToolStripButton_Click(object sender, EventArgs e)
        {
            StopReadingQueue();
        }

        private void intervalToolStripTextBox_Click(object sender, EventArgs e)
        {
            PROCESS_OPTIONS processOptions = ProcessOptions;

            TestIsNumeric(intervalToolStripTextBox, out processOptions.Interval);

            SetProcessOptions(processOptions);
        }

        private void SetProcessOptions(PROCESS_OPTIONS processOptions)
        {
            lock (_ProcessOptionsLock)
            {
                _ProcessOptions = processOptions;
            }
        }

        private void itemsToolStripTextBox_Click(object sender, EventArgs e)
        {
            TestIsNumeric(itemsToolStripTextBox, out _NumberOfItems);
        }

        private void sortColumnToolStripComboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            _SelectedSortColumnValue = sortColumnToolStripComboBox.Text.Replace(" ", "");
            ResetGrid();
        }

        private void sortOrderToolStripComboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            _SelectedSortOrderValue = sortOrderToolStripComboBox.Text.Replace(" ", "");
            ResetGrid();
        }

        private void itemsToolStripTextBox_TextChanged(object sender, EventArgs e)
        {
            TestIsNumeric(itemsToolStripTextBox, out _NumberOfItems);
            ResetGrid();
        }

        #endregion

    }
}

---