CtlCheckGrid.cs

﻿// Name:        CtlCheckGrid.cs
// Description: Checkbox grid
// Author:      Tim Chipman
// Origination: Work performed for BuildingSmart by Constructivity.com LLC.
// Copyright:   (c) 2013 BuildingSmart International Ltd.
// License:     http://www.buildingsmart-tech.org/legal

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

using IfcDoc;
using IfcDoc.Schema.DOC;

namespace IfcDoc
{
	public partial class CtlCheckGrid : ScrollableControl
	{
		ICheckGrid m_datasource;
		ToolMode m_toolmode;
		object m_selection;

		const int CX = 12;
		const int CY = 12;

		const int SX = 200;
		const int SY = 200;

		public CtlCheckGrid()
		{
			InitializeComponent();

			this.DoubleBuffered = true;
			this.ResizeRedraw = true;
			this.AutoScroll = true;
		}

		public ICheckGrid CheckGridSource
		{
			get
			{
				return this.m_datasource;
			}
			set
			{
				this.m_datasource = value;
				if (this.m_datasource != null)
				{
					this.AutoScrollMinSize = new Size(SX + CX * this.m_datasource.GetColumnCount(), SY + CY * this.m_datasource.GetRowCount());
				}
				this.Invalidate();
			}
		}

		public ToolMode Mode
		{
			get
			{
				return this.m_toolmode;
			}
			set
			{
				this.m_toolmode = value;
			}
		}

		public object Selection
		{
			get
			{
				return this.m_selection;
			}
			set
			{
				this.m_selection = value;
				if (this.SelectionChanged != null)
				{
					this.SelectionChanged(this, EventArgs.Empty);
				}
			}
		}

		public event EventHandler SelectionChanged;

		protected override void OnPaint(PaintEventArgs pe)
		{
			base.OnPaint(pe);

			if (this.m_datasource == null)
				return;

			Graphics g = pe.Graphics;
			g.TranslateTransform(this.AutoScrollPosition.X, this.AutoScrollPosition.Y);

			// draw column header
			for (int iCol = 0; iCol < this.m_datasource.GetColumnCount(); iCol++)
			{
				object col = this.m_datasource.GetColumn(iCol);
				g.DrawRectangle(Pens.Black, SX + iCol * CX, 0, CY, this.AutoScrollMinSize.Height);
				g.DrawString(col.ToString(), this.Font, Brushes.Black, SX + iCol * CX - 2, 0, new System.Drawing.StringFormat(StringFormatFlags.DirectionVertical));
			}

			for (int iRow = 0; iRow < this.m_datasource.GetRowCount(); iRow++)
			{
				object row = this.m_datasource.GetRow(iRow);

				// draw row header
				g.DrawRectangle(Pens.Black, 0, SY + iRow * CY, this.AutoScrollMinSize.Width, CY);
				g.DrawString(row.ToString(), this.Font, Brushes.Black, 0, SY + iRow * CY);

				for (int iCol = 0; iCol < this.m_datasource.GetColumnCount(); iCol++)
				{
					object col = this.m_datasource.GetColumn(iCol);

					// draw cell
					CellValue val = this.m_datasource.GetCell(iRow, iCol);
					Brush brush = Brushes.Gray; // incompatible
					switch (val)
					{
						case CellValue.None:
							brush = Brushes.LightGray;
							break;

						case CellValue.Mandatory:
							brush = Brushes.LightGreen;
							break;

						case CellValue.Recommended:
							brush = Brushes.Blue;
							break;

						case CellValue.NotRelevant:
							brush = Brushes.White;
							break;

						case CellValue.NotRecommended:
							brush = Brushes.Yellow;
							break;

						case CellValue.Excluded:
							brush = Brushes.Red;
							break;
					}
					g.FillRectangle(brush, new Rectangle(SX + iCol * CX + 1, SY + iRow * CY + 1, CX - 1, CY - 1));

#if false
                    if (val != CellValue.Unavailable)
                    {
                        g.FillRectangle(Brushes.White, new Rectangle(SX + iCol * CX + 1, SY + iRow * CY + 1, CX-1, CY-1));
                        if (val == CellValue.Optional || val == CellValue.Required)
                        {
                            g.DrawLine(Pens.Black, SX + iCol * CX, SY + (iRow + 1) * CY, SX + (iCol + 1) * CX, SY + iRow * CY);
                        }
                        if (val == CellValue.Required)
                        {
                            g.DrawLine(Pens.Black, SX + iCol * CX, SY + iRow * CY, SX + (iCol + 1) * CX, SY + (iRow + 1) * CY);
                        }
                    }
                    else
                    {
                        g.FillRectangle(Brushes.DarkGray, new Rectangle(SX + iCol * CX + 1, SY + iRow * CY + 1, CX - 1, CY - 1));
                    }
#endif
				}
			}
		}

		private object Pick(int x, int y)
		{
			if (this.m_datasource == null)
				return null;

			int iCol = (x - SX) / CX;
			int iRow = (y - SY) / CY;

			if (x < SX && iRow >= 0 && iRow < this.m_datasource.GetRowCount())
			{
				// clicking on row
				return this.m_datasource.GetRow(iRow);
			}
			else if (y < SY && iCol >= 0 && iCol < this.m_datasource.GetColumnCount())
			{
				// clicking on column
				return this.m_datasource.GetColumn(iCol);
			}
			else if (iCol >= 0 && iRow >= 0 && iCol < this.m_datasource.GetColumnCount() && iRow < this.m_datasource.GetRowCount())
			{
				return this.m_datasource.GetObject(iRow, iCol);
			}

			return null;
		}

		private void CtlCheckGrid_MouseClick(object sender, MouseEventArgs e)
		{
			if (this.m_datasource == null)
				return;

			Point pt = e.Location;
			pt.X -= this.AutoScrollPosition.X;
			pt.Y -= this.AutoScrollPosition.Y;

			if (this.Mode == IfcDoc.ToolMode.Select)
			{
				this.Selection = this.Pick(pt.X, pt.Y);
				return;
			}

			int iCol = (pt.X - SX) / CX;
			int iRow = (pt.Y - SY) / CY;
			if (iCol < 0 || iRow < 0)
				return;

			CellValue oldval = this.m_datasource.GetCell(iRow, iCol);
			if (oldval == CellValue.Unavailable)
				return;
			CellValue newval = oldval;
			switch (oldval)
			{

				case CellValue.None:
					newval = CellValue.Recommended;
					break;

				case CellValue.Recommended:
					newval = CellValue.Mandatory;
					break;

				case CellValue.Mandatory:
					newval = CellValue.None;
					break;

				default:
					newval = CellValue.Mandatory;
					break;
			}
			this.m_datasource.SetCell(iRow, iCol, newval);

			this.Invalidate(false);
		}

		private void CtlCheckGrid_MouseMove(object sender, MouseEventArgs e)
		{
			if (this.m_datasource == null)
				return;

			Point pt = e.Location;
			pt.X -= this.AutoScrollPosition.X;
			pt.Y -= this.AutoScrollPosition.Y;

			switch (this.Mode)
			{
				case ToolMode.Select:
					{
						object link = this.Pick(pt.X, pt.Y);
						if (link != null)
						{
							this.Cursor = Cursors.Hand;
						}
						else
						{
							this.Cursor = Cursors.Default;
						}
					}
					break;

				case IfcDoc.ToolMode.Move:
				case IfcDoc.ToolMode.Link:
					{
						int iCol = (pt.X - SX) / CX;
						int iRow = (pt.Y - SY) / CY;
						if (iCol >= 0 && iCol < this.m_datasource.GetColumnCount() &&
							iRow >= 0 && iRow < this.m_datasource.GetRowCount())
						{
							CellValue cell = this.m_datasource.GetCell(iRow, iCol);
							if (cell != CellValue.Unavailable)
							{
								this.Cursor = Cursors.UpArrow;
							}
							else
							{
								this.Cursor = Cursors.No;
							}
						}
						else
						{
							this.Cursor = Cursors.Default;
						}
					}
					break;
			}
		}
	}


	public interface ICheckGrid
	{
		/// <summary>
		/// Returns object for column, where ToString() is shown as text; NULL if no more columns.
		/// </summary>
		/// <param name="col"></param>
		/// <returns></returns>
		object GetColumn(int col);

		/// <summary>
		/// Returns object for row, where ToString() is shown as text; NULL if no more rows.
		/// </summary>
		/// <param name="row"></param>
		/// <returns></returns>
		object GetRow(int row);

		/// <summary>
		/// Returns object at cell.
		/// </summary>
		/// <param name="row"></param>
		/// <param name="col"></param>
		/// <returns></returns>
		object GetObject(int row, int col);

		/// <summary>
		/// Returns value for cell.
		/// </summary>
		/// <param name="row"></param>
		/// <param name="col"></param>
		/// <returns></returns>
		CellValue GetCell(int row, int col);

		/// <summary>
		/// Sets value for cell.
		/// </summary>
		/// <param name="row"></param>
		/// <param name="col"></param>
		/// <param name="val"></param>
		void SetCell(int row, int col, CellValue val);

		int GetColumnCount();

		int GetRowCount();
	}

	public enum CellValue
	{
		/// <summary>
		/// Black -- entry is not possible (not compatible)
		/// </summary>
		Unavailable = -1,

		/// <summary>
		/// Grey -- entry is possible but not defined
		/// </summary>
		None = 0,

		/// <summary>
		/// Green indicator
		/// </summary>
		Mandatory = 1,

		/// <summary>
		/// Blue indicator
		/// </summary>
		Recommended = 2,

		/// <summary>
		/// White indicator - entry defined
		/// </summary>
		NotRelevant = 3,

		/// <summary>
		/// Yellow indicator
		/// </summary>
		NotRecommended = 4,

		/// <summary>
		/// Red indicator
		/// </summary>
		Excluded = 5,
	}

	/// <summary>
	/// Shows entities for each row, exchanges for each column
	/// </summary>
	public class CheckGridConcept : ICheckGrid
	{
		DocTemplateDefinition m_template;
		DocModelView m_view;
		DocProject m_project;

		public CheckGridConcept(DocTemplateDefinition docTemplate, DocModelView docView, DocProject docProject)
		{
			this.m_template = docTemplate;
			this.m_view = docView;
			this.m_project = docProject;
		}

		public int GetColumnCount()
		{
			if (this.m_view == null)
				return 0;

			return this.m_view.Exchanges.Count;
		}

		public int GetRowCount()
		{
			if (this.m_view == null)
				return 0;

			return this.m_view.ConceptRoots.Count;
		}

		public object GetColumn(int col)
		{
			if (col >= 0 && col < this.m_view.Exchanges.Count)
			{
				return this.m_view.Exchanges[col];
			}

			return null;
		}

		public object GetRow(int row)
		{
			if (row >= 0 && row < this.m_view.ConceptRoots.Count)
			{
				return this.m_view.ConceptRoots[row];
			}

			return null;
		}

		public object GetObject(int row, int col)
		{
			DocConceptRoot docRoot = this.m_view.ConceptRoots[row];
			DocExchangeDefinition docExchange = this.m_view.Exchanges[col];

			foreach (DocTemplateUsage docUsage in docRoot.Concepts)
			{
				if (docUsage.Definition == this.m_template)
				{
					foreach (DocExchangeItem docEx in docUsage.Exchanges)
					{
						if (docEx.Exchange == docExchange && docEx.Applicability == DocExchangeApplicabilityEnum.Export)
						{
							return docEx;
						}
					}

					return null;
				}
			}

			return null;
		}

		public CellValue GetCell(int row, int col)
		{
			DocConceptRoot docRoot = this.m_view.ConceptRoots[row];
			DocExchangeDefinition docExchange = this.m_view.Exchanges[col];

			foreach (DocTemplateUsage docUsage in docRoot.Concepts)
			{
				if (docUsage.Definition == this.m_template)
				{
					foreach (DocExchangeItem docEx in docUsage.Exchanges)
					{
						if (docEx.Exchange == docExchange && docEx.Applicability == DocExchangeApplicabilityEnum.Export)
						{
							switch (docEx.Requirement)
							{
								case DocExchangeRequirementEnum.Mandatory:
									return CellValue.Mandatory;

								case DocExchangeRequirementEnum.Optional:
									return CellValue.Recommended;

								case DocExchangeRequirementEnum.NotRelevant:
									return CellValue.NotRelevant;

								case DocExchangeRequirementEnum.NotRecommended:
									return CellValue.NotRecommended;

								case DocExchangeRequirementEnum.Excluded:
									return CellValue.Excluded;
							}
						}
					}

					return CellValue.NotRelevant;
				}
			}

			return CellValue.None;
		}

		public void SetCell(int row, int col, CellValue val)
		{
			DocConceptRoot docRoot = this.m_view.ConceptRoots[row];
			DocExchangeDefinition docExchange = this.m_view.Exchanges[col];

			DocTemplateUsage docUsage = null;
			foreach (DocTemplateUsage eachUsage in docRoot.Concepts)
			{
				if (eachUsage.Definition == this.m_template)
				{
					docUsage = eachUsage;
					break;
				}
			}

			if (docUsage == null)
			{
				docUsage = new DocTemplateUsage();
				docRoot.Concepts.Add(docUsage);
				docUsage.Definition = this.m_template;
			}

			DocExchangeRequirementEnum req = DocExchangeRequirementEnum.NotRelevant;
			switch (val)
			{
				case CellValue.Mandatory:
					req = DocExchangeRequirementEnum.Mandatory;
					break;

				case CellValue.Recommended:
					req = DocExchangeRequirementEnum.Optional;
					break;
			}
			docUsage.RegisterExchange(docExchange, req);
		}

	}

	/// <summary>
	/// Shows concepts for each row, exchanges for each column
	/// </summary>
	public class CheckGridEntity : ICheckGrid
	{
		DocConceptRoot m_root;
		DocModelView m_view;
		DocProject m_project;
		List<DocTemplateDefinition> m_listTemplate;

		public CheckGridEntity(DocConceptRoot docRoot, DocModelView docView, DocProject docProject)
		{
			this.m_root = docRoot;
			this.m_view = docView;
			this.m_project = docProject;
			this.m_listTemplate = new List<DocTemplateDefinition>();

			List<DocTemplateDefinition> listTemplate = docProject.GetTemplateList();

			//... filter out templates to only those that apply to entity...

			foreach (DocTemplateDefinition docTemplate in listTemplate)
			{
				if (docTemplate.Rules != null && docTemplate.Rules.Count > 0) // don't include abstract/organizational templates
				{
					bool include = false;

					// check for inheritance                
					DocObject docApplicableEntity = docProject.GetDefinition(docTemplate.Type) as DocEntity;

					if (docTemplate.Type != null && docApplicableEntity is DocEntity)
					{
						// check for inheritance
						DocEntity docBase = docRoot.ApplicableEntity;
						while (docBase != null)
						{
							if (docBase == docApplicableEntity)
							{
								include = true;
								break;
							}

							if (docBase.BaseDefinition == null)
								break;

							docBase = docProject.GetDefinition(docBase.BaseDefinition) as DocEntity;
						}
					}

					if (include)
					{
						this.m_listTemplate.Add(docTemplate);
					}
				}
			}

		}

		public int GetColumnCount()
		{
			if (this.m_view != null)
			{
				return this.m_view.Exchanges.Count;
			}

			return 0;
		}

		public int GetRowCount()
		{
			return this.m_listTemplate.Count;
		}

		public object GetColumn(int col)
		{
			if (col >= 0 && col < this.m_view.Exchanges.Count)
			{
				return this.m_view.Exchanges[col];
			}

			return null;
		}

		public object GetRow(int row)
		{
			if (row >= 0 && row < this.m_listTemplate.Count)
			{
				return this.m_listTemplate[row];
			}

			return null;
		}

		public object GetObject(int row, int col)
		{
			if (row < 0 || row >= this.m_listTemplate.Count)
				return null;

			if (col < 0 || col >= this.m_view.Exchanges.Count)
				return null;

			DocTemplateDefinition docTemplate = this.m_listTemplate[row];
			DocExchangeDefinition docExchange = this.m_view.Exchanges[col];

			foreach (DocTemplateUsage docUsage in this.m_root.Concepts)
			{
				if (docUsage.Definition == docTemplate)
				{
					foreach (DocExchangeItem docItem in docUsage.Exchanges)
					{
						if (docItem.Exchange == docExchange && docItem.Applicability == DocExchangeApplicabilityEnum.Export)
						{
							return docItem;
						}
					}
				}
			}

			return CellValue.None;
		}

		public CellValue GetCell(int row, int col)
		{
			if (row < 0 || row >= this.m_listTemplate.Count)
				return CellValue.Unavailable;

			if (col < 0 || col >= this.m_view.Exchanges.Count)
				return CellValue.Unavailable;

			DocTemplateDefinition docTemplate = this.m_listTemplate[row];
			DocExchangeDefinition docExchange = this.m_view.Exchanges[col];

			foreach (DocTemplateUsage docUsage in this.m_root.Concepts)
			{
				if (docUsage.Definition == docTemplate)
				{
					foreach (DocExchangeItem docItem in docUsage.Exchanges)
					{
						if (docItem.Exchange == docExchange && docItem.Applicability == DocExchangeApplicabilityEnum.Export)
						{
							switch (docItem.Requirement)
							{
								case DocExchangeRequirementEnum.Mandatory:
									return CellValue.Mandatory;

								case DocExchangeRequirementEnum.Optional:
									return CellValue.Recommended;

								default:
									return CellValue.None;
							}
						}
					}
				}
			}

			return CellValue.None;
		}

		public void SetCell(int row, int col, CellValue val)
		{
			DocTemplateDefinition docTemplate = this.m_listTemplate[row];
			DocExchangeDefinition docExchange = this.m_view.Exchanges[col];

			DocTemplateUsage docUsage = null;
			foreach (DocTemplateUsage eachUsage in this.m_root.Concepts)
			{
				if (eachUsage.Definition == docTemplate)
				{
					docUsage = eachUsage;
					break;
				}
			}

			if (docUsage == null)
			{
				docUsage = new DocTemplateUsage();
				this.m_root.Concepts.Add(docUsage);
				docUsage.Definition = docTemplate;
			}

			DocExchangeRequirementEnum req = DocExchangeRequirementEnum.NotRelevant;
			switch (val)
			{
				case CellValue.Mandatory:
					req = DocExchangeRequirementEnum.Mandatory;
					break;

				case CellValue.Recommended:
					req = DocExchangeRequirementEnum.Optional;
					break;
			}
			docUsage.RegisterExchange(docExchange, req);
		}
	}

	/// <summary>
	/// Shows entities for each row, concepts for each column
	/// </summary>
	public class CheckGridExchange : ICheckGrid
	{
		DocProject m_project;
		DocModelView m_view;
		DocExchangeDefinition m_exchange;

		List<DocTemplateDefinition> m_listTemplate;

		public CheckGridExchange(DocExchangeDefinition docExchange, DocModelView docView, DocProject docProject)
		{
			this.m_project = docProject;
			this.m_view = docView;
			this.m_exchange = docExchange;
			this.m_listTemplate = docProject.GetTemplateList();

			// filter out template list to only those that are currently used
			for (int i = this.m_listTemplate.Count - 1; i >= 0; i--)
			{
				bool used = false;
				foreach (DocConceptRoot docRoot in this.m_view.ConceptRoots)
				{
					foreach (DocTemplateUsage docUsage in docRoot.Concepts)
					{
						if (docUsage.Definition == this.m_listTemplate[i])
						{
							used = true;
							break;
						}
					}
				}

				if (!used)
				{
					this.m_listTemplate.RemoveAt(i);
				}
			}
		}

		public int GetColumnCount()
		{
			return this.m_listTemplate.Count;
		}

		public int GetRowCount()
		{
			return this.m_view.ConceptRoots.Count;
		}

		public object GetColumn(int col)
		{
			if (col >= 0 && col < this.m_listTemplate.Count)
			{
				return this.m_listTemplate[col];
			}

			return null;
		}

		public object GetRow(int row)
		{
			if (row >= 0 && row < this.m_view.ConceptRoots.Count)
			{
				return this.m_view.ConceptRoots[row];
			}

			return null;
		}

		public object GetObject(int row, int col)
		{
			if (col >= this.m_listTemplate.Count || row >= this.m_view.ConceptRoots.Count)
				return null;

			DocTemplateDefinition docTemplate = this.m_listTemplate[col];
			DocConceptRoot docRoot = this.m_view.ConceptRoots[row];

			foreach (DocTemplateUsage docUsage in docRoot.Concepts)
			{
				if (docUsage.Definition == docTemplate)
				{
					foreach (DocExchangeItem docExchangeItem in docUsage.Exchanges)
					{
						if (docExchangeItem.Exchange == this.m_exchange && docExchangeItem.Applicability == DocExchangeApplicabilityEnum.Export)
						{
							return docUsage;
						}
					}
				}
			}

			return null;
		}

		public CellValue GetCell(int row, int col)
		{
			if (col >= this.m_listTemplate.Count || row >= this.m_view.ConceptRoots.Count)
				return CellValue.Unavailable;

			DocTemplateDefinition docTemplate = this.m_listTemplate[col];
			DocConceptRoot docRoot = this.m_view.ConceptRoots[row];

			// return Unavailable if template is incompatible with root
			bool applicable = false;
			DocDefinition docDef = this.m_project.GetDefinition(docTemplate.Type);
			DocEntity docEnt = docRoot.ApplicableEntity;
			while (docEnt != null)
			{
				if (docEnt == docDef)
				{
					applicable = true;
					break;
				}

				docEnt = this.m_project.GetDefinition(docEnt.BaseDefinition) as DocEntity;
			}

			if (!applicable)
			{
				return CellValue.Unavailable;
			}

			foreach (DocTemplateUsage docUsage in docRoot.Concepts)
			{
				if (docUsage.Definition == docTemplate)
				{
					foreach (DocExchangeItem docExchangeItem in docUsage.Exchanges)
					{
						if (docExchangeItem.Exchange == this.m_exchange && docExchangeItem.Applicability == DocExchangeApplicabilityEnum.Export)
						{
							switch (docExchangeItem.Requirement)
							{
								case DocExchangeRequirementEnum.Mandatory:
									return CellValue.Mandatory;

								case DocExchangeRequirementEnum.Optional:
									return CellValue.Recommended;

								case DocExchangeRequirementEnum.NotRelevant:
									return CellValue.NotRelevant;

								case DocExchangeRequirementEnum.NotRecommended:
									return CellValue.NotRecommended;

								case DocExchangeRequirementEnum.Excluded:
									return CellValue.Excluded;
							}
						}
					}

					return CellValue.NotRelevant;
				}
			}

			return CellValue.None;
		}

		public void SetCell(int row, int col, CellValue val)
		{
			DocTemplateDefinition docTemplate = this.m_listTemplate[col];
			DocConceptRoot docRoot = this.m_view.ConceptRoots[row];

			DocTemplateUsage docConcept = null;
			foreach (DocTemplateUsage docUsage in docRoot.Concepts)
			{
				if (docUsage.Definition == docTemplate)
				{
					docConcept = docUsage;
					break;
				}
			}

			if (docConcept == null)
			{
				docConcept = new DocTemplateUsage();
				docRoot.Concepts.Add(docConcept);
				docConcept.Definition = docTemplate;
			}

			DocExchangeRequirementEnum req = DocExchangeRequirementEnum.NotRelevant;
			switch (val)
			{
				case CellValue.Mandatory:
					req = DocExchangeRequirementEnum.Mandatory;
					break;

				case CellValue.Recommended:
					req = DocExchangeRequirementEnum.Optional;
					break;
			}
			docConcept.RegisterExchange(this.m_exchange, req);
		}
	}
}