C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Applications/Client Plugins/Event Handlers Plugin/Forms/EventHandlerManagerForm.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.Web.Services.Protocols;
using System.Windows.Forms;
using Mcs.Epm.MicrosoftProject.mpFx.Client.Plugins.EventHandlersPlugin.Controls;
using Mcs.Epm.MicrosoftProject.mpFx.Client.Plugins.EventHandlersPlugin.Properties;
using Mcs.Epm.MicrosoftProject.mpFx.Client.Shared;
using Mcs.Epm.MicrosoftProject.mpFx.EventsWebService;

namespace Mcs.Epm.MicrosoftProject.mpFx.Client.Plugins.EventHandlersPlugin.Forms
{
    /// <summary>
    /// Implements the main user interface for the Event Handler Manager plugin
    /// </summary>
    public partial class EventHandlerManagerForm : Form
    {
        #region Instance Data

        private readonly EventHandlerPlugIn _EventHandlerPlugIn;
        private EventHandlersDataSet _EventHandlersDataSet;
        private AddEventHandlerControl _AddControl;

        #endregion

        #region Constructors

        public EventHandlerManagerForm(EventHandlerPlugIn eventHandlerPlugIn)
        {
            InitializeComponent();

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

            _EventHandlerPlugIn = eventHandlerPlugIn;

            detailsViewToolStripMenuItem.Checked = Settings.Default.DetailsVisible;

            mainSplitContainer.Panel2Collapsed = !Settings.Default.StatusMessagesVisible;
        }

        #endregion

        #region Private Methods

        private void LoadEventHandlerInformation()
        {
            _EventHandlerPlugIn.DoOnStatusChanged(new OnStatusChangedArgs("Loading event handler information.."));

            treeView.Nodes.Clear();
            treeView.BeginUpdate();

            try
            {
                _EventHandlersDataSet = _EventHandlerPlugIn.ProjectServer.Events.Read();
            }
            catch (SoapException exception)
            {
                MessageBox.Show(this,
                                Errors.ProcessMSProjectErrors(exception),
                                Resources.PluginTitle,
                                MessageBoxButtons.OK,
                                MessageBoxIcon.Error);                

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

            string currentGroup = string.Empty;
            TreeNode currentNode = null;

            //  The following code processes each PSIEventID name, using capitalization to 
            //  determine the groups of events
            foreach (string eventName in Enum.GetNames(typeof(PSEventID)))
            {
                string thisGroup = string.Empty;

                foreach (char c in eventName)
                {
                    if (char.IsUpper(c))
                    {
                        if (thisGroup.Length > 0)
                        {
                            break;
                        }
                    }

                    thisGroup = thisGroup + c;
                }

                if (currentGroup == string.Empty || currentGroup != thisGroup)
                {
                    currentNode = null;

                    foreach (TreeNode node in treeView.Nodes)
                    {
                        if (node.Text == thisGroup)
                        {
                            currentNode = node;
                            break;
                        }
                    }

                    if (currentNode == null)
                    {
                        if (!thisGroup.StartsWith("Deprecated"))
                        {
                            currentNode = treeView.Nodes.Add(thisGroup);
                            currentNode.ImageKey = "folder.png";
                            currentNode.SelectedImageKey = "folder_edit.png";
                        }
                    }

                    currentGroup = thisGroup;
                }

                if (currentNode != null)
                {
                    AddEvent(eventName, thisGroup, currentNode);
                }

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

            treeView.EndUpdate();
        }

        private void AddEvent(string name, string thisGroup, TreeNode currentNode)
        {
            string eventName = name.Replace(thisGroup, "");

            TreeNode eventNode = currentNode.Nodes.Add(eventName);

            PSEventID thisEvent = (PSEventID)Enum.Parse(typeof(PSEventID), name);

            bool isRegisteredEvent = false;
            int count = 0;

            if (_EventHandlersDataSet != null)
            {
                foreach (EventHandlersDataSet.EventHandlersRow eventHandler in _EventHandlersDataSet.EventHandlers)
                {
                    if (eventHandler.EventId == (int)thisEvent)
                    {
                        isRegisteredEvent = true;
                        count++;
                    }
                }                
            }

            if (isRegisteredEvent)
            {
                if (count > 1)
                {
                    eventNode.ImageKey = "shape_group.png";
                    eventNode.SelectedImageKey = "shape_group.png";
                }
                else
                {
                    eventNode.ImageKey = "shape_handles.png";
                    eventNode.SelectedImageKey = "shape_handles.png";
                }
            }
            else
            {
                eventNode.ImageKey = "bullet_blue.png";
                eventNode.SelectedImageKey = "bullet_blue.png";
            }

            eventNode.Tag = thisEvent;
        }

        private void LoadEventDetail(PSEventID psEventID)
        {
            eventsDetailsTabControl.TabPages.Clear();
            eventsDetailsTabControl.BringToFront();

            foreach (EventHandlersDataSet.EventHandlersRow eventHandler in _EventHandlersDataSet.EventHandlers)
            {
                if (eventHandler.EventId == (int)psEventID)
                {
                    TabPage tabPage = new TabPage(eventHandler.AssemblyName.Substring(0, eventHandler.AssemblyName.IndexOf(",")));

                    EventsDetailsControl control = new EventsDetailsControl(eventHandler);

                    control.Dock = DockStyle.Fill;

                    tabPage.Controls.Add(control);

                    eventsDetailsTabControl.TabPages.Add(tabPage);
                }
            }
        }

        private void UnloadAddEventHandlerControl()
        {
            if (_AddControl != null)
            {
                mainSplitContainer.Panel2.Controls.Remove(_AddControl);
                _AddControl.Dispose();
            }
        }

        #endregion

        #region Event Handlers

        private void detailsViewToolStripMenuItem_Click(object sender, EventArgs e)
        {
            mainSplitContainer.Panel2Collapsed = !detailsViewToolStripMenuItem.Checked;
        }

        private void EventHandlerManagerForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            Settings.Default.StatusMessagesVisible = !mainSplitContainer.Panel2Collapsed;
            Settings.Default.Save();

            UnloadAddEventHandlerControl();
        }

        private void EventHandlerManagerForm_Shown(object sender, EventArgs e)
        {
            Cursor = Cursors.WaitCursor;

            LoadEventHandlerInformation();

            Cursor = Cursors.Default;
        }

        private void treeView_AfterSelect(object sender, TreeViewEventArgs e)
        {
            removeToolStripButton.Enabled = e.Node.ImageKey != "bullet_blue.png";

            if (e.Node.Tag == null || !removeToolStripButton.Enabled)
            {
                noEventsLabel.BringToFront();
                return;
            }

            PSEventID selectedEvent = (PSEventID)e.Node.Tag;

            LoadEventDetail(selectedEvent);
        }

        private void addToolStripButton_Click(object sender, EventArgs e)
        {
            _AddControl = new AddEventHandlerControl(_EventHandlerPlugIn);

            _AddControl.OnCancelClick += addControl_OnCancelClick;
            _AddControl.OnOkClick += _AddControl_OnOkClick;

            _AddControl.Dock = DockStyle.Fill;

            mainSplitContainer.Panel2.Controls.Add(_AddControl);

            _AddControl.BringToFront();
        }

        private void _AddControl_OnOkClick(object sender, EventArgs e)
        {
            UnloadAddEventHandlerControl();
        }

        void addControl_OnCancelClick(object sender, EventArgs e)
        {
            UnloadAddEventHandlerControl();
        }

        #endregion
    }
}

---