C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Applications/Client Plugins/Project Plugin/Forms/BrowserForm.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.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Forms;
using Mcs.Epm.MicrosoftProject.mpFx.Client.Plugins.ProjectPlugin.Properties;
using Mcs.Epm.MicrosoftProject.mpFx.Client.Shared;
using Mcs.Epm.MicrosoftProject.mpFx.ProjectsWebService;
using Microsoft.Office.Interop.MSProject;
using Application = Microsoft.Office.Interop.MSProject.Application;
using Exception=System.Exception;
using View=System.Windows.Forms.View;

namespace Mcs.Epm.MicrosoftProject.mpFx.Client.Plugins.ProjectPlugin.Forms
{
    /// <summary>
    /// Implements the Project browser
    /// </summary>
    public partial class BrowserForm : Form
    {
        #region Constants

        private const int DEFAULT_RETRY_COUNT = 15;
        private const int DEFAULT_WAIT_TIME = 2000;

        #endregion

        #region Instance Data

        private readonly ProjectPlugin _Parent;
        private Application _Winproj;

        #endregion

        #region Constructors

        public BrowserForm(ProjectPlugin parent)
        {
            InitializeComponent();

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

            _Parent = parent;

            projectsListView.View = Settings.Default.LastViewBrowser;
        }

        #endregion

        #region Private Methods

        private void LoadProjects()
        {
            _Parent.DoOnStatusChanged(new OnStatusChangedArgs("Loading Projects..."));

            foreach (Guid projectGuid in _Parent.ProjectServer.Projects)
            {
                EnterpriseProject project = _Parent.ProjectServer.Projects[projectGuid];

                _Parent.DoOnStatusChanged(new OnStatusChangedArgs(Tools.Format("Loading {0}...", project.Name)));

                ListViewItem item = new ListViewItem(project.Name, 0);

                using (ProjectDataSet projectDataSet = _Parent.ProjectServer.Projects[projectGuid].StandardInformation)
                {
                    LoadProjectProperties(project, projectDataSet, item);
                }

                _Parent.DoOnStatusChanged(new OnStatusChangedArgs(string.Empty));

                projectsListView.Items.Add(item);
            }
        }

        private void LoadProjectProperties(EnterpriseProject project, ProjectDataSet projectDataSet, ListViewItem item)
        {
            if (projectDataSet.Project.Count == 1)
            {
                ProjectDataSet.ProjectRow projectData = projectDataSet.Project[0];

                item.Tag = project.ProjectGuid;

                item.SubItems.Add(projectData.PROJ_INFO_START_DATE.ToString());

                string value = "Unknown";

                if (!projectData.IsProjectOwnerIDNull())
                {
                    value = GetNameFromResGuid(projectData.ProjectOwnerID);
                }

                item.SubItems.Add(value);

                value = "Not checked out";

                if (!projectData.IsPROJ_CHECKOUTBYNull())
                {
                    value = GetNameFromResGuid(projectData.PROJ_CHECKOUTBY);
                }

                item.SubItems.Add(value);
            }
        }

        private void LoadProjectDetails(Guid guid)
        {
            resourcesListView.Items.Clear();
            basicInfoDataViewGrid.Rows.Clear();

            using (ProjectDataSet projectDataSet = _Parent.ProjectServer.Projects[guid].StandardInformation)
            {
                if (projectDataSet.Project.Count == 1)
                {
                    ProjectDataSet.ProjectRow projectData = projectDataSet.Project[0];

                    PopulateGrid(projectData, basicInfoDataViewGrid);
                }
            }
            if (tabControl.SelectedTab == resourcesTabPage)
            {
                LoadProjectTeam(guid);
            }
        }

        private static void PopulateGrid(DataRow projectData, DataGridView grid)
        {
            foreach (DataColumn column in projectData.Table.Columns)
            {
                if (!projectData.IsNull(column))
                {
                    string valueString = projectData[column].ToString();
                    grid.Rows.Add(column.ColumnName, valueString);
                }
            }
        }

        private void LoadProjectTeam(Guid guid)
        {
            resourcesListView.Items.Clear();
            resourcesListView.Columns.Clear();
            resourcesListView.Columns.Add("RES_NAME");

            using (ProjectTeamDataSet projectTeamDataSet = _Parent.ProjectServer.Projects.ReadTeam(guid, false))
            {
                if (projectTeamDataSet.ProjectTeam.Rows.Count > 0)
                {
                    foreach (DataColumn column in projectTeamDataSet.Tables[0].Columns)
                    {
                        resourcesListView.Columns.Add(column.ColumnName);
                    }

                    foreach (ProjectTeamDataSet.ProjectTeamRow teamMember in projectTeamDataSet.ProjectTeam.Rows)
                    {
                        ListViewItem teamMemberItem = new ListViewItem();
                        teamMemberItem.Text = teamMember.RES_NAME;

                        foreach (DataColumn column in teamMember.Table.Columns)
                        {
                            string valueString = string.Empty;

                            if (!teamMember.IsNull(column))
                            {
                                valueString = teamMember[column].ToString();
                            }

                            teamMemberItem.SubItems.Add(valueString);
                        }

                        resourcesListView.Items.Add(teamMemberItem);
                    }
                }
            }
        }

        private string GetNameFromResGuid(Guid resGuid)
        {
            EnterpriseResource resource = _Parent.ProjectServer.Resources[resGuid];

            if (resource != null && !string.IsNullOrEmpty(resource.Name))
            {
                return resource.Name;
            }

            return string.Empty;
        }

        private void OpenSelectdProjectInWinProj()
        {
            Process[] processes = Process.GetProcessesByName("winproj");

            bool success = false;

            if (processes.Length == 0)
            {
                //  No WinProj in the proclist.  Cook one up.
                ProcessStartInfo startupInfo = new ProcessStartInfo
                                                   {
                                                       FileName = "winproj.exe",
                                                       Arguments = string.Format(" /s {0}", _Parent.ProjectServer.Site)
                                                   };
                try
                {
                    Process.Start(startupInfo);
                    Thread.Sleep(DEFAULT_WAIT_TIME);
                }
                catch (Win32Exception exception)
                {
                    MessageBox.Show(this,
                                    exception.Message,
                                    _Parent.Name,
                                    MessageBoxButtons.OK,
                                    MessageBoxIcon.Error);
                    return;
                }
            }

            for (int i = 0; i < DEFAULT_RETRY_COUNT; i++)
            {
                //  If an instance of WinProj was created above, we are waiting for the user to login, 
                //  during which time the call below will generate RPC_E_CALL_REJECTED exceptions 
                try
                {
                    _Winproj = new Application();

                    _Winproj.Visible = true;
                    //  Okay, we have an instance of WinProj and we can talk to it.
                    break;

                }
                catch (COMException exception)
                {
                    Debug.WriteLine(exception.Message);

                    //  Free the automation object so the ref count doesn't explode
                    FreeWinProj();

                    Thread.Sleep(DEFAULT_WAIT_TIME);
                }
            }

            if (_Winproj != null)
            {
                //  We may have an automation object that was previously speaking to me, but it appears 
                //  that calls will be rejected for a few more seconds after we squeaked through in the first loop above.

                Exception exception;

                for (int i = 0; i < DEFAULT_RETRY_COUNT; i++)
                {
                    try
                    {
                        success = _Winproj.Profiles.ActiveProfile.Server.Equals(_Parent.ProjectServer.Site.ToString(),
                                                                                StringComparison.CurrentCultureIgnoreCase);
                        //  We finally have determined whether the two urls match
                        break;
                    }
                    catch (COMException e)
                    {
                        exception = e;
                    }
                    catch (InvalidCastException e)
                    {
                        exception = e;
                    }

                    if (exception.Message.Contains("not available"))
                    {
                        //  The RCW got disconnected from the automation object, so it is likely the user 
                        //  closed project.  Bail...
                        break;
                    }
                    Debug.WriteLine(exception.Message);
                    Thread.Sleep(DEFAULT_WAIT_TIME);
                }
            }

            //  We can test to see if we should open the project
            if (_Winproj != null && success)
            {
                _Winproj.FileOpenEx(@"<>\" + projectsListView.SelectedItems[0].Text,
                                    false,
                                    Type.Missing,
                                    Type.Missing,
                                    Type.Missing,
                                    Type.Missing,
                                    Type.Missing,
                                    Type.Missing,
                                    Type.Missing,
                                    Type.Missing,
                                    Type.Missing,
                                    PjPoolOpen.pjDoNotOpenPool,
                                    Type.Missing,
                                    Type.Missing,
                                    Type.Missing,
                                    Type.Missing,
                                    Type.Missing);
            }
            else
            {
                MessageBox.Show(this,
                                "You may be logged onto a different instance of Project Server.  Please close Project and try again.",
                                _Parent.Name,
                                MessageBoxButtons.OK,
                                MessageBoxIcon.Error);
            }
        }

        private void FreeWinProj()
        {
            if (_Winproj != null)
            {
                Marshal.FinalReleaseComObject(_Winproj);
                _Winproj = null;
            }
        }

        #endregion

        #region Event Handlers

        private void detailsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            iconsToolStripMenuItem.Checked = !detailsToolStripMenuItem.Checked;

            if (detailsToolStripMenuItem.Checked)
            {
                projectsListView.View = View.Details;
            }
        }

        private void iconsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            detailsToolStripMenuItem.Checked = !iconsToolStripMenuItem.Checked;

            if (iconsToolStripMenuItem.Checked)
            {
                projectsListView.View = View.SmallIcon;
            }
        }

        private void BrowserForm_Shown(object sender, EventArgs e)
        {
            Cursor = Cursors.WaitCursor;
            LoadProjects();
            Cursor = Cursors.Default;
        }
        
        private void BrowserForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            Settings.Default.LastViewBrowser = projectsListView.View;
            Settings.Default.Save();
        }

        private void projectsListView_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (!splitContainer.Panel2Collapsed && projectsListView.SelectedItems.Count > 0)
            {
                Cursor = Cursors.WaitCursor;
                LoadProjectDetails(new Guid(projectsListView.SelectedItems[0].Tag.ToString()));
                Cursor = Cursors.Default;
            }
            openInWinPojToolStripButton.Enabled = projectsListView.SelectedItems.Count > 0;
        }

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

            if (!splitContainer.Panel2Collapsed && projectsListView.SelectedItems.Count > 0)
            {
                Cursor = Cursors.WaitCursor;
                LoadProjectDetails(new Guid(projectsListView.SelectedItems[0].Tag.ToString()));
                Cursor = Cursors.Default;
            }
        }

        private void tabControl_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (!splitContainer.Panel2Collapsed && projectsListView.SelectedItems.Count > 0 && resourcesListView.Items.Count == 0)
            {
                Cursor = Cursors.WaitCursor;
                LoadProjectTeam(new Guid(projectsListView.SelectedItems[0].Tag.ToString()));
                Cursor = Cursors.Default;
            }
        }

        private void openInWinPojToolStripButton_Click(object sender, EventArgs e)
        {
            Cursor = Cursors.WaitCursor;
            OpenSelectdProjectInWinProj();
            Cursor = Cursors.Default;
        }

        #endregion

    }
}

---