C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Libraries/Mcs.Epm.MicrosoftProject.mpFx.WinForms/EditNewGraphicalIndicatorForm.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.Diagnostics;
using System.Windows.Forms;

namespace Mcs.Epm.MicrosoftProject.mpFx.WinForms
{
    /// <summary>
    /// Implements a user interface for creating a new graphical indicator
    /// </summary>
    public partial class EditNewGraphicalIndicatorForm : Form
    {
        #region Private Constants

        private const int VALUES_COLUMN_INDEX = 1;
        private const int IMAGES_INDEX_COLUMN_INDEX = 2;
        private const int IMAGES_COLUMN_INDEX = 3;
        private const int TESTS_COLUMN_INDEX = 0;

        #endregion

        #region Instance Data

        private readonly GraphicalIndicator _indicator;

        #endregion

        #region Public Properties

        public bool ShowValuesInToolTips
        {
            get { return showValuesInTooltipsCheckbox.Checked; }
        }

        public string ProjectSummaryCriteriaString
        {
            get { return _indicator.GetCriteriaString(GraphicalIndicator.CriteriaFor.ProjectSummary); }
        }

        public string SummaryTaskCriteriaString
        {
            get { return _indicator.GetCriteriaString(GraphicalIndicator.CriteriaFor.Summary); }
        }

        public string NonSummaryCriteriaString
        {
            get { return _indicator.GetCriteriaString(GraphicalIndicator.CriteriaFor.NonSummaryRows); }
        }

        #endregion

        #region Constructor

        public EditNewGraphicalIndicatorForm(GraphicalIndicator indicator)
        {
            InitializeComponent();

            _indicator = indicator;

            DataGridViewComboBoxColumn imagesIndexColumn = (graphicalIndicatorGridView.Columns[IMAGES_INDEX_COLUMN_INDEX] as DataGridViewComboBoxColumn);

            Debug.Assert(imagesIndexColumn != null);

            for (int i = 1; i < GraphicalIndicator.MAX_IMAGE_INDEX; i++)
            {
                imagesIndexColumn.Items.Add(i.ToString());
            }

            DataGridViewComboBoxColumn testsColumn = (graphicalIndicatorGridView.Columns[TESTS_COLUMN_INDEX] as DataGridViewComboBoxColumn);

            Debug.Assert(testsColumn != null);

            foreach (string test in _indicator.TestsDisplayNames)
            {
                testsColumn.Items.Add(test);
            }

            if (Parent == null)
            {
                CenterToScreen();
            }
            else
            {
                CenterToParent();
            }

            criteriaForList.SelectedIndex = 0;
        }

        #endregion

        #region Private Methods

        private void LoadCriteriaFor(GraphicalIndicator.CriteriaFor criteriaFor)
        {
            int count;

            graphicalIndicatorGridView.Rows.Clear();

            switch (criteriaFor)
            {
                case GraphicalIndicator.CriteriaFor.NonSummaryRows:
                    count = _indicator.NonSummaryCriteriaCount;
                    break;
                case GraphicalIndicator.CriteriaFor.ProjectSummary:
                    count = _indicator.ProjectSummaryCriteriaCount;
                    break;
                case GraphicalIndicator.CriteriaFor.Summary:
                    count = _indicator.SummaryCriteriaCount;
                    break;
                default:
                    throw new ArgumentOutOfRangeException("criteriaFor");
            }

            for (int counter = 0; counter < count; counter++)
            {
                GraphicalIndicator.Criteria criteria = _indicator.GetCriteria(criteriaFor, counter);

                graphicalIndicatorGridView.Rows.Add(criteria.Test, criteria.Value, criteria.ImageIndex.ToString(), imageList.Images[criteria.ImageIndex - 1]);
            }

            if (graphicalIndicatorGridView.Rows.Count == GraphicalIndicator.MAX_NUMBER_OF_CRITERIA)
            {
                graphicalIndicatorGridView.AllowUserToAddRows = false;
            }
        }

        private bool SaveCriteriaFor(GraphicalIndicator.CriteriaFor criteriaFor)
        {
            _indicator.ClearCriteria(criteriaFor);

            foreach (DataGridViewRow test in graphicalIndicatorGridView.Rows)
            {
                if (test.IsNewRow != true)
                {
                    try
                    {
                        if (test.Cells[0].Value == null)
                        {
                            MessageBox.Show("Please enter a test.");
                            graphicalIndicatorGridView.CurrentCell = test.Cells[TESTS_COLUMN_INDEX];
                            return false;
                        }

                        string testString = test.Cells[TESTS_COLUMN_INDEX].Value.ToString();

                        if (test.Cells[1].Value == null)
                        {
                            MessageBox.Show("Please enter a value.");
                            graphicalIndicatorGridView.CurrentCell = test.Cells[VALUES_COLUMN_INDEX];
                            return false;
                        }

                        string valueString = test.Cells[VALUES_COLUMN_INDEX].Value.ToString();

                        if (test.Cells[IMAGES_INDEX_COLUMN_INDEX].Value == null)
                        {
                            MessageBox.Show("Please select an image.");
                            graphicalIndicatorGridView.CurrentCell = test.Cells[IMAGES_INDEX_COLUMN_INDEX];
                            return false;
                        }

                        int imageIndex = Convert.ToInt32(test.Cells[IMAGES_INDEX_COLUMN_INDEX].Value);

                        _indicator.AddCriteria(criteriaFor, new GraphicalIndicator.Criteria(imageIndex, valueString, testString, _indicator.GetCount(criteriaFor)));
                    }
                    catch (Exception exception)
                    {
                        MessageBox.Show(exception.Message,
                                        "Test",
                                        MessageBoxButtons.OK,
                                        MessageBoxIcon.Information);
                        return false;
                    }
                }
            }

            return true;
        }

        private GraphicalIndicator.CriteriaFor GetSelectedCriteriaFor()
        {
            GraphicalIndicator.CriteriaFor criteriaFor = GraphicalIndicator.CriteriaFor.None;

            switch (criteriaForList.SelectedIndex)
            {
                case 0: //  Non-summary rows
                    criteriaFor = GraphicalIndicator.CriteriaFor.NonSummaryRows;
                    break;
                case 1: //  Project summary
                    criteriaFor = GraphicalIndicator.CriteriaFor.ProjectSummary;
                    break;

                case 2: //Summary rows
                    criteriaFor = GraphicalIndicator.CriteriaFor.Summary;
                    break;
            }
            return criteriaFor;
        }

        private void UpdateIndicatorImage(int imageIndex)
        {
            if (graphicalIndicatorGridView.CurrentCell.ColumnIndex == TESTS_COLUMN_INDEX)
            {
                return;
            }

            if (graphicalIndicatorGridView.CurrentRow != null)
            {
                DataGridViewImageCell imageCell = (graphicalIndicatorGridView.CurrentRow.Cells[IMAGES_COLUMN_INDEX] as DataGridViewImageCell);

                Debug.Assert(imageCell != null);

                imageCell.Value = imageList.Images[imageIndex];
            }
        }

        #endregion

        #region Event Handlers

        private void graphicalIndicatorGridView_EditingControlShowing(object sender,
                                                                      DataGridViewEditingControlShowingEventArgs e)
        {
            if (graphicalIndicatorGridView.CurrentRow == null)
            {
                return;
            }

            ComboBox comboBox = e.Control as ComboBox;

            if (comboBox == null || graphicalIndicatorGridView.CurrentCell.ColumnIndex == TESTS_COLUMN_INDEX)
            {
                return;
            }

            comboBox.SelectedIndexChanged += comboBox_SelectedIndexChanged;
        }

        private void comboBox_SelectedIndexChanged(object sender,
                                                   EventArgs e)
        {
            UpdateIndicatorImage(((ComboBox) sender).SelectedIndex);
        }

        private void okButton_Click(object sender,
                                    EventArgs e)
        {
            if (SaveCriteriaFor(GetSelectedCriteriaFor()))
            {
                DialogResult = DialogResult.OK;
                Close();
            }
        }

        private void criteriaForList_SelectedIndexChanged(object sender,
                                                          EventArgs e)
        {
            LoadCriteriaFor(GetSelectedCriteriaFor());
        }

        private void graphicalIndicatorGridView_UserAddedRow(object sender,
                                                             DataGridViewRowEventArgs e)
        {
            if (graphicalIndicatorGridView.Rows.Count - 1 > GraphicalIndicator.MAX_NUMBER_OF_CRITERIA)
            {
                graphicalIndicatorGridView.CancelEdit();
            }
        }

        private void criteriaForList_Enter(object sender,
                                           EventArgs e)
        {
            if (!SaveCriteriaFor(GetSelectedCriteriaFor()))
            {
                graphicalIndicatorGridView.Focus();
                graphicalIndicatorGridView.Select();
            }
        }

        private void graphicalIndicatorGridView_RowLeave(object sender,
                                                         DataGridViewCellEventArgs e)
        {
            if (graphicalIndicatorGridView.Rows.Count >= GraphicalIndicator.MAX_NUMBER_OF_CRITERIA)
            {
                graphicalIndicatorGridView.AllowUserToAddRows = false;
            }
            else
            {
                graphicalIndicatorGridView.AllowUserToAddRows = true;
            }
        }

        private void graphicalIndicatorGridView_RowsRemoved(object sender,
                                                            DataGridViewRowsRemovedEventArgs e)
        {
            if (graphicalIndicatorGridView.Rows.Count < GraphicalIndicator.MAX_NUMBER_OF_CRITERIA)
            {
                graphicalIndicatorGridView.AllowUserToAddRows = true;
            }
        }

        #endregion
    }
}

---