CtlExpressG.cs

// Name:        CtlExpressG.cs
// Description: EXPRESS-G diagram editor
// Author:      Tim Chipman
// Origination: Work performed for BuildingSmart by Constructivity.com LLC.
// Copyright:   (c) 2014 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.Format.PNG;
using IfcDoc.Schema.DOC;
using IfcDoc.Schema;

namespace IfcDoc
{
    public partial class CtlExpressG : ScrollableControl
    {
        Image m_image;
        DocSchema m_schema;
        DocObject m_selection;
        DocObject m_highlight;
        DocLine m_lineselection;
        DocLine m_linehighlight;
        Dictionary<string, DocObject> m_map;
        bool m_scrollselection;
        bool m_mousedown;
        ResizeHandle m_handle;
        Point m_ptDown;
        Point m_ptMove;
        Dictionary<DocObject, PointF> m_pointmap; // store previous coordinates of objects being moved to avoid round-off issues
        SizeF m_selectionsize; // size of selection when mouse down
        ToolMode m_toolmode;
        DiagramFormat m_diagramformat;
        List<DocDefinition> m_multiselect;

        public const int PageX = 600;
        public const int PageY = 888;
        public const float Factor = 0.375f;

        public event EventHandler SelectionChanged;
        public event EventHandler LinkOperation;

        public CtlExpressG()
        {
            InitializeComponent();

            this.DoubleBuffered = true;
            this.ResizeRedraw = true;
            this.AutoScrollMinSize = new Size(PageX, PageY);
            this.AutoScroll = true;
            this.HorizontalScroll.LargeChange = PageX;
            this.VerticalScroll.LargeChange = PageY;

            this.m_scrollselection = true;
            this.m_pointmap = new Dictionary<DocObject, PointF>();
            this.m_multiselect = new List<DocDefinition>();
        }

        public void Redraw()
        {
            if (this.m_image != null)
            {
                this.m_image.Dispose();
                this.m_image = null;
            }

            this.Invalidate();
        }

        public Dictionary<string, DocObject> Map
        {
            get
            {
                return this.m_map;   
            }
            set
            {
                this.m_map = value;
            }
        }

        public DocSchema Schema
        {
            get
            {
                return this.m_schema;
            }
            set
            {
                this.m_schema = value;
                this.m_selection = null;
                this.m_highlight = null;

                this.Redraw();
            }
        }

        public DocObject Highlight
        {
            get
            {
                return this.m_highlight;
            }
        }

        public DocObject Selection
        {
            get
            {
                return this.m_selection;
            }
            set
            {
                if (this.m_selection == value)
                    return;

                this.m_selection = value;

                // auto-scroll to page
                if (this.m_scrollselection && !this.m_mousedown)
                {
                    DocDefinition docDef = null;
                    if(this.m_selection is DocDefinition)
                    {
                        docDef = (DocDefinition)this.m_selection;
                    }
                    else if(this.m_selection is DocAttribute)
                    {
                        // find the enclosing definition
                        DocAttribute attr =(DocAttribute)this.m_selection;
                        foreach(DocEntity docEnt in this.m_schema.Entities)
                        {
                            if(docEnt.Attributes.Contains(attr))
                            {
                                docDef = docEnt;
                                break;
                            }
                        }
                    }

                    if (docDef != null)
                    {
                        if (docDef.DiagramNumber != 0 && this.m_schema.DiagramPagesHorz != 0)
                        {
                            int pageY = (docDef.DiagramNumber - 1) / this.m_schema.DiagramPagesHorz;
                            int pageX = (docDef.DiagramNumber - 1) % this.m_schema.DiagramPagesHorz;

                            // also scroll vertically if not visible
                            int incY = 0;
                            if (docDef.DiagramRectangle.Y > this.ClientSize.Height)
                            {
                                incY = (int)(docDef.DiagramRectangle.Y * CtlExpressG.Factor) - (pageY * PageY);
                            }

                            this.AutoScrollPosition = new Point(pageX * PageX, pageY * PageY + incY);
                        }
                    }
                }

                this.Invalidate();

                if (this.SelectionChanged != null)
                {
                    this.SelectionChanged(this, EventArgs.Empty);
                }
            }
        }

        public List<DocDefinition> Multiselection
        {
            get
            {
                return this.m_multiselect;
            }
        }

        public Point Marker
        {
            get
            {
                return this.m_ptDown;
            }
        }

        /// <summary>
        /// Indicates whether view will be automatically scrolled when the selection changes.
        /// </summary>
        public bool ScrollToSelection
        {
            get
            {
                return this.m_scrollselection;
            }
            set
            {
                this.m_scrollselection = value;
            }
        }

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

        public DiagramFormat Format
        {
            get
            {
                return this.m_diagramformat;
            }
            set
            {
                this.m_diagramformat = value;
                this.Redraw();
            }
        }

        protected override void OnPaint(PaintEventArgs pe)
        {
            if (this.m_image == null && this.m_schema != null && this.m_map != null)
            {
                this.m_image = FormatPNG.CreateSchemaDiagram(this.m_schema, this.m_map, this.m_diagramformat);
                this.AutoScrollMinSize = new Size(this.m_image.Width, this.m_image.Height);
            }

            if(this.m_image != null)
            {
                Graphics g = pe.Graphics;
                g.TranslateTransform(this.AutoScrollPosition.X, this.AutoScrollPosition.Y);
                g.DrawImage(this.m_image, Point.Empty);

                using (Pen pen = new Pen(Color.Maroon, 5.0f))
                {
                    foreach (DocDefinition docDef in this.m_multiselect)
                    {
                        DrawObjectBorder(g, docDef, pen);
                    }
                }

                if (this.m_selection != null)
                {
                    using (Pen pen = new Pen(Color.Red, 5.0f))
                    {
                        if (this.m_lineselection != null)
                        {
                            DrawObjectBorder(g, this.m_lineselection, pen);
                        }
                        else
                        {
                            DrawObjectBorder(g, this.m_selection, pen);
                        }
                    }
                }

                if(this.m_highlight != null)
                {
                    using (Pen pen = new Pen(Color.Orange, 3.0f))
                    {
                        if (this.m_linehighlight != null)
                        {
                            DrawObjectBorder(g, this.m_linehighlight, pen);
                        }
                        else
                        {
                            DrawObjectBorder(g, this.m_highlight, pen);
                        }
                    }
                }

                g.TranslateTransform(-this.AutoScrollPosition.X, -this.AutoScrollPosition.Y);

                // draw link line
                if(this.m_mousedown && this.m_toolmode == ToolMode.Link)
                {
                    g.DrawLine(Pens.Red, this.m_ptDown, this.m_ptMove);
                }

                if (this.m_mousedown && this.m_toolmode == ToolMode.Move && this.m_selection == null)
                {
                    // draw selection box
                    Rectangle rc = CreateNormalizedRectangle(this.m_ptDown, this.m_ptMove);
                    g.DrawRectangle(Pens.Red, rc);
                }
                else if (this.m_selection == null && this.m_toolmode == ToolMode.Move)
                {
                    // draw insertion point
                    int rad = 16;
                    g.DrawLine(Pens.Red, this.m_ptDown.X - rad, this.m_ptDown.Y, this.m_ptDown.X + rad, this.m_ptDown.Y);
                    g.DrawLine(Pens.Red, this.m_ptDown.X, this.m_ptDown.Y - rad, this.m_ptDown.X, this.m_ptDown.Y + rad);
                }
            }
        }

        private static Rectangle CreateNormalizedRectangle(Point p1, Point p2)
        {
            Rectangle rc = new Rectangle();
            if (p1.X < p2.X)
            {
                rc.X = p1.X;
                rc.Width = p2.X - p1.X;
            }
            else
            {
                rc.X = p2.X;
                rc.Width = p1.X - p2.X;
            }
            if (p1.Y < p2.Y)
            {
                rc.Y = p1.Y;
                rc.Height = p2.Y - p1.Y;
            }
            else
            {
                rc.Y = p2.Y;
                rc.Height = p1.Y - p2.Y;
            }
            return rc;
        }

        private void DrawObjectBorder(Graphics g, SEntity obj, Pen pen)
        {
            if (obj is DocDefinition && ((DocDefinition)obj).DiagramRectangle != null)
            {
                DocRectangle docRect = ((DocDefinition)obj).DiagramRectangle;

                Rectangle rc = new Rectangle(
                    (int)(docRect.X * Factor),
                    (int)(docRect.Y * Factor),
                    (int)(docRect.Width * Factor),
                    (int)(docRect.Height * Factor));
                rc.Inflate(-2, -2);

                g.DrawRectangle(pen, rc);
            }
            else if (obj is DocAttribute)
            {
                DocAttribute docAttr = (DocAttribute)obj;
                if (docAttr.DiagramLine != null)
                {
                    for (int i = 0; i < docAttr.DiagramLine.Count - 1; i++)
                    {
                        g.DrawLine(pen,
                            new Point((int)(docAttr.DiagramLine[i].X * Factor), (int)(docAttr.DiagramLine[i].Y * Factor)),
                            new Point((int)(docAttr.DiagramLine[i + 1].X * Factor), (int)(docAttr.DiagramLine[i + 1].Y * Factor)));
                    }
                }
            }
            else if(obj is DocLine)
            {
                // tree point
                DocLine docLine = (DocLine)obj;
                DocPoint docPoint = docLine.DiagramLine[docLine.DiagramLine.Count - 1];
                Rectangle rc = new Rectangle((int)(docPoint.X * Factor), (int)(docPoint.Y * Factor), 0, 0);
                rc.Inflate(6, 6);
                g.DrawEllipse(pen, rc);
            }
        }

        private void CtlExpressG_MouseDown(object sender, MouseEventArgs e)
        {
            if (e.Button != System.Windows.Forms.MouseButtons.Left)
                return;

            bool multi = ((System.Windows.Forms.Control.ModifierKeys & Keys.Control) == Keys.Control);

            this.m_mousedown = true;
            this.m_ptDown = e.Location;

            this.Selection = this.Pick(e.Location, out this.m_lineselection, out this.m_handle);
            if (this.Selection == null && !multi)
            {
                this.m_multiselect.Clear();
                this.m_pointmap.Clear();
            }

            UpdateCursor(this.m_handle);

            if (this.m_selection is DocDefinition)
            {
                DocDefinition docDef = (DocDefinition)this.Selection;
                if (!m_pointmap.ContainsKey(docDef))
                {
                    m_pointmap.Add(docDef, new PointF((float)docDef.DiagramRectangle.X, (float)docDef.DiagramRectangle.Y));
                }
                m_selectionsize = new SizeF((float)docDef.DiagramRectangle.Width, (float)docDef.DiagramRectangle.Height);
            }

            if (multi && this.Selection is DocDefinition)
            {
                DocDefinition docDef = (DocDefinition)this.Selection;
                if(!this.m_multiselect.Contains(docDef))
                {
                    this.m_multiselect.Add(docDef);
                }
            }

            this.Invalidate();
        }

        /// <summary>
        /// Updates any connected geometry to match definition
        /// </summary>
        /// <param name="docDef"></param>
        public void LayoutDefinition(DocDefinition selection)
        {
            // then traverse all dependencies on selection
            if (selection is DocEntity)
            {
                DocEntity docEntity = (DocEntity)selection;
                foreach (DocAttribute docAttr in docEntity.Attributes)
                {
                    LayoutLine(docEntity, docAttr.Definition, docAttr.DiagramLine);
                    if (docAttr.DiagramLabel != null)
                    {
                        if (docAttr.DiagramLine[2].Y > docAttr.DiagramLine[0].Y)
                        {
                            docAttr.DiagramLabel.X = docAttr.DiagramLine[0].X;
                            docAttr.DiagramLabel.Y = docAttr.DiagramLine[0].Y + 20.0;
                        }
                        else
                        {
                            docAttr.DiagramLabel.X = docAttr.DiagramLine[0].X;
                            docAttr.DiagramLabel.Y = docAttr.DiagramLine[0].Y - 20.0;
                        }
                    }
                }

                foreach (DocLine docLine in docEntity.Tree)
                {
                    LayoutTree(docEntity, docLine);
                }
            }
            else if (selection is DocDefinitionRef)
            {
                DocDefinitionRef docRef = (DocDefinitionRef)selection;
                foreach (DocLine docLine in docRef.Tree)
                {
                    LayoutTree(docRef, docLine);
                }
            }
            else if (selection is DocDefined)
            {
                DocDefined docDef = (DocDefined)selection;
                LayoutLine(docDef, docDef.Definition, docDef.DiagramLine);
            }
            else if (selection is DocSelect)
            {
                DocSelect docSelect = (DocSelect)selection;
                foreach (DocLine docLine in docSelect.Tree)
                {
                    LayoutTree(docSelect, docLine);
                }
            }
            else if (selection is DocPageTarget)
            {
                DocPageTarget docTarget = (DocPageTarget)selection;
                LayoutLine(docTarget.Definition, docTarget, docTarget.DiagramLine);
                docTarget.DiagramLine.Reverse();
            }

            foreach (DocPageTarget docPageTarget in this.m_schema.PageTargets)
            {
                if (docPageTarget.Definition == selection)
                {
                    LayoutLine(docPageTarget.Definition, docPageTarget, docPageTarget.DiagramLine);
                    docPageTarget.DiagramLine.Reverse();
                }
            }

            foreach(DocSchemaRef docSchemaRef in this.m_schema.SchemaRefs)
            {
                foreach(DocDefinitionRef docDefRef in docSchemaRef.Definitions)
                {
                    if(docDefRef.Name.Equals("IfcRelAssociates"))
                    {
                        this.ToString();
                    }

                    foreach (DocLine docLine in docDefRef.Tree)
                    {
                        if (docLine.Definition == selection)
                        {
                            LayoutLine(docDefRef, docLine.Definition, docLine.DiagramLine);
                        }
                        else
                        {
                            foreach (DocLine docSub in docLine.Tree)
                            {
                                if (docSub.Definition == selection)
                                {
                                    LayoutNode(docLine, docSub);
                                }
                            }
                        }
                    }
                }
            }

            foreach (DocEntity docEntity in this.m_schema.Entities)
            {
                // if there multile attributes refer to the same definition, then space evenly
                int count = 0;
                foreach (DocAttribute docAttr in docEntity.Attributes)
                {
                    if (docAttr.Definition == selection)
                    {
                        count++;
                    }
                }

                int each = 0;
                foreach (DocAttribute docAttr in docEntity.Attributes)
                {
                    if (docAttr.Definition == selection)
                    {
                        LayoutLine(docEntity, docAttr.Definition, docAttr.DiagramLine);
                        if(count > 1 && docAttr.DiagramLine.Count == 3)
                        {
                            each++;
                            docAttr.DiagramLine[0].Y = selection.DiagramRectangle.Y + (selection.DiagramRectangle.Height * (double)each / (double)(count+1));
                            docAttr.DiagramLine[1].Y = selection.DiagramRectangle.Y + (selection.DiagramRectangle.Height * (double)each / (double)(count+1));
                            docAttr.DiagramLine[2].Y = selection.DiagramRectangle.Y + (selection.DiagramRectangle.Height * (double)each / (double)(count+1));
                        }

                        if (docAttr.DiagramLabel == null)
                        {
                            docAttr.DiagramLabel = new DocRectangle();
                        }

                        if (docAttr.DiagramLine[2].Y > docAttr.DiagramLine[0].Y)
                        {
                            docAttr.DiagramLabel.X = docAttr.DiagramLine[0].X;
                            docAttr.DiagramLabel.Y = docAttr.DiagramLine[0].Y + 20.0;
                        }
                        else
                        {
                            docAttr.DiagramLabel.X = docAttr.DiagramLine[0].X;
                            docAttr.DiagramLabel.Y = docAttr.DiagramLine[0].Y - 20.0;
                        }
                    }
                }

                foreach(DocLine docLine in docEntity.Tree)
                {
                    // workaround to fix-up broken data (due to bug in previous import from Visual Express -- no longer occurs with new files)
#if false
                    if (docLine.Definition == null && selection is DocEntity && ((DocEntity)selection).BaseDefinition == docEntity.Name)
                    {
                        docLine.Definition = selection;
                        System.Diagnostics.Debug.WriteLine("CtlExpressG::LayoutDefinition -- fixed up null reference to subtype");
                    }
#endif
                    if (docLine.Definition == selection)
                    {
                        LayoutLine(docEntity, docLine.Definition, docLine.DiagramLine);
                    }
                    else
                    {
                        foreach (DocLine docSub in docLine.Tree)
                        {
                            if (docSub.Definition == selection)
                            {
                                LayoutNode(docLine, docSub);
                            }
                        }
                    }
                }
            }

            foreach (DocType docType in this.m_schema.Types)
            {
                if (docType is DocDefined)
                {
                    DocDefined docDef = (DocDefined)docType;
                    if (docDef.Definition == selection)
                    {
                        LayoutLine(docDef, docDef.Definition, docDef.DiagramLine);
                    }
                }
                else if (docType is DocSelect)
                {
                    DocSelect docSel = (DocSelect)docType;
                    foreach (DocLine docLine in docSel.Tree)
                    {
                        if(docLine.Definition == selection)
                        {
                            LayoutLine(docSel, selection, docLine.DiagramLine);
                        }
                        
                        foreach(DocLine docSub in docLine.Tree)
                        {
                            if(docSub.Definition == selection)
                            {
                                LayoutNode(docLine, docSub);
                            }
                        }
                    }
                }
            }

            // recalculate page extents and resize/repaginate if necessary
            double cx = 0.0;
            double cy = 0.0;
            foreach (DocType docDef in this.m_schema.Types)
            {
                ExpandExtents(docDef.DiagramRectangle, ref cx, ref cy);
            }
            foreach (DocEntity docDef in this.m_schema.Entities)
            {
                ExpandExtents(docDef.DiagramRectangle, ref cx, ref cy);
            }
            foreach (DocPrimitive docDef in this.m_schema.Primitives)
            {
                ExpandExtents(docDef.DiagramRectangle, ref cx, ref cy);
            }
            foreach (DocPageTarget docDef in this.m_schema.PageTargets)
            {
                ExpandExtents(docDef.DiagramRectangle, ref cx, ref cy);
                foreach (DocPageSource docSource in docDef.Sources)
                {
                    ExpandExtents(docSource.DiagramRectangle, ref cx, ref cy);
                }
            }
            foreach (DocSchemaRef docRef in this.m_schema.SchemaRefs)
            {
                foreach (DocDefinitionRef docDef in docRef.Definitions)
                {
                    ExpandExtents(docDef.DiagramRectangle, ref cx, ref cy);
                }
            }
            foreach (DocComment docDef in this.m_schema.Comments)
            {
                ExpandExtents(docDef.DiagramRectangle, ref cx, ref cy);
            }
            this.m_schema.DiagramPagesHorz = 1 + (int)Math.Floor(cx * Factor / PageX);
            this.m_schema.DiagramPagesVert = 1 + (int)Math.Floor(cy * Factor / PageY);

            int px = (int)(selection.DiagramRectangle.X * Factor / CtlExpressG.PageX);
            int py = (int)(selection.DiagramRectangle.Y * Factor / CtlExpressG.PageY);
            int page = 1 + py * this.m_schema.DiagramPagesHorz + px;
            selection.DiagramNumber = page;
        }

        private void MoveObject(DocDefinition docSelection, float dx, float dy)
        {
            if (this.m_pointmap.ContainsKey(docSelection))
            {
                PointF ptSelection = this.m_pointmap[docSelection];

                if ((this.m_handle & ResizeHandle.North) != 0)
                {
                    double yTail = docSelection.DiagramRectangle.Y + docSelection.DiagramRectangle.Height;
                    docSelection.DiagramRectangle.Y = ptSelection.Y + dy / Factor;
                    docSelection.DiagramRectangle.Height = yTail - docSelection.DiagramRectangle.Y;
                }
                else if ((this.m_handle & ResizeHandle.South) != 0)
                {
                    docSelection.DiagramRectangle.Height = m_selectionsize.Height + dy / Factor;
                }

                if ((this.m_handle & ResizeHandle.West) != 0)
                {
                    double xTail = docSelection.DiagramRectangle.X + docSelection.DiagramRectangle.Width;
                    docSelection.DiagramRectangle.X = ptSelection.X + dx / Factor;
                    docSelection.DiagramRectangle.Width = xTail - docSelection.DiagramRectangle.X;
                }
                else if ((this.m_handle & ResizeHandle.East) != 0)
                {
                    docSelection.DiagramRectangle.Width = m_selectionsize.Width + dx / Factor;
                }

                if (this.m_handle == ResizeHandle.Move)
                {
                    docSelection.DiagramRectangle.X = ptSelection.X + dx / Factor;
                    docSelection.DiagramRectangle.Y = ptSelection.Y + dy / Factor;

                    if(docSelection.DiagramRectangle.X < 0)
                    {
                        docSelection.DiagramRectangle.X = 0;
                    }
                    if (docSelection.DiagramRectangle.Y < 0)
                    {
                        docSelection.DiagramRectangle.Y = 0;
                    }
                }
                else
                {
                    if (docSelection.DiagramRectangle.Width < 64)
                    {
                        docSelection.DiagramRectangle.Width = 64;
                    }
                    if (docSelection.DiagramRectangle.Height < 64)
                    {
                        docSelection.DiagramRectangle.Height = 64;
                    }
                }

                LayoutDefinition(docSelection);
            }
        }

        private void CtlExpressG_MouseMove(object sender, MouseEventArgs e)
        {
            this.m_ptMove = e.Location;

            if (this.m_mousedown && this.m_toolmode == ToolMode.Move)
            {
                UpdateCursor(this.m_handle);

                Point ptLocation = e.Location;
                if (ptLocation.X < 0)
                    ptLocation.X = 0;
                if (ptLocation.Y < 0)
                    ptLocation.Y = 0;

                if (this.m_lineselection != null && this.m_selection is DocDefinition)
                {
                    // moving tree node
                    DocPoint docPoint = m_lineselection.DiagramLine[m_lineselection.DiagramLine.Count - 1];
                    docPoint.X = (ptLocation.X - this.AutoScrollPosition.X) / Factor;
                    docPoint.Y = (ptLocation.Y - this.AutoScrollPosition.Y) / Factor;

                    // layout the owning element
                    LayoutDefinition((DocDefinition)this.m_selection);

                    // layout lines to all subtypes
                    foreach (DocLine docSub in this.m_lineselection.Tree)
                    {
                        LayoutNode(this.m_lineselection, docSub);
                    }

                    this.Redraw();
                }
                else if (this.m_selection is DocDefinition)
                {
                    float dx = (float)(ptLocation.X - this.m_ptDown.X);
                    float dy = (float)(ptLocation.Y - this.m_ptDown.Y);


                    // move or resize the object...
                    DocDefinition docSelection = (DocDefinition)this.m_selection;
                    MoveObject(docSelection, dx, dy);
                    foreach(DocDefinition docDef in this.m_multiselect)
                    {
                        if (docDef != docSelection)
                        {
                            MoveObject(docDef, dx, dy);
                        }
                    }
                    this.Redraw();
                }
                else if(this.m_selection == null)
                {
                    // draw box and highlight multiple within region
                    this.m_multiselect.Clear();
                    Rectangle rc = CreateNormalizedRectangle(this.m_ptDown, this.m_ptMove);
                    foreach(DocEntity docEntity in this.m_schema.Entities)
                    {
                        SelectWithinRectangle(docEntity, rc);
                    }
                    foreach (DocType docType in this.m_schema.Types)
                    {
                        SelectWithinRectangle(docType, rc);
                    }
                    foreach (DocPrimitive docType in this.m_schema.Primitives)
                    {
                        SelectWithinRectangle(docType, rc);
                    }
                    foreach (DocPageTarget docTarget in this.m_schema.PageTargets)
                    {
                        SelectWithinRectangle(docTarget, rc);
                        foreach(DocPageSource docSource in docTarget.Sources)
                        {
                            SelectWithinRectangle(docSource, rc);
                        }
                    }
                    foreach(DocSchemaRef docSchemaRef in this.m_schema.SchemaRefs)
                    {
                        foreach(DocDefinitionRef docRef in docSchemaRef.Definitions)
                        {
                            SelectWithinRectangle(docRef, rc);
                        }
                    }
                    // don't select comments

                    this.Invalidate();
                }
            }
            else
            {
                ResizeHandle handle = ResizeHandle.None;
                DocObject highlight = this.Pick(e.Location, out this.m_linehighlight, out handle);
                if (this.m_highlight != highlight)
                {
                    this.m_highlight = highlight;
                    this.Invalidate();
                }

                if (this.m_mousedown && this.m_toolmode == ToolMode.Link)
                {
                    this.Invalidate();
                }

                UpdateCursor(handle);
            }
        }

        private void SelectWithinRectangle(DocDefinition def, Rectangle rc)
        {
            if (def.DiagramRectangle == null)
                return;

            Rectangle rcObject = new Rectangle(
                (int)(def.DiagramRectangle.X * Factor) + this.AutoScrollPosition.X,
                (int)(def.DiagramRectangle.Y * Factor) + this.AutoScrollPosition.Y,
                (int)(def.DiagramRectangle.Width * Factor),
                (int)(def.DiagramRectangle.Height * Factor));

            if(rc.IntersectsWith(rcObject))
            {
                this.m_multiselect.Add(def);
                if (!this.m_pointmap.ContainsKey(def))
                {
                    m_pointmap.Add(def, new PointF((float)def.DiagramRectangle.X, (float)def.DiagramRectangle.Y));
                }
            }
        }

        private void UpdateCursor(ResizeHandle handle)
        {
            switch(this.m_toolmode)
            {
                case ToolMode.Select:
                    this.Cursor = Cursors.Default;
                    break;

                case ToolMode.Move:
                    switch (handle)
                    {
                        case ResizeHandle.North | ResizeHandle.East:
                        case ResizeHandle.South | ResizeHandle.West:
                            this.Cursor = Cursors.SizeNESW;
                            break;

                        case ResizeHandle.North | ResizeHandle.West:
                        case ResizeHandle.South | ResizeHandle.East:
                            this.Cursor = Cursors.SizeNWSE;
                            break;

                        case ResizeHandle.West:
                        case ResizeHandle.East:
                            this.Cursor = Cursors.SizeWE;
                            break;

                        case ResizeHandle.North:
                        case ResizeHandle.South:
                            this.Cursor = Cursors.SizeNS;
                            break;

                        case ResizeHandle.Move:
                            this.Cursor = Cursors.SizeAll;
                            break;

                        default:
                            this.Cursor = Cursors.Default;
                            break;
                    }
                    break;

                case ToolMode.Link:
                    switch (handle)
                    {
                        case ResizeHandle.Move: // body -- attribute
                            this.Cursor = Cursors.Cross;
                            break;

                        case ResizeHandle.None:
                            this.Cursor = Cursors.No;
                            break;

                        default: // along edge -- inheritance
                            this.Cursor = Cursors.UpArrow;
                            break;
                    }
                    break;
            }
        }

        private static void ExpandExtents(DocRectangle docRect, ref double cx, ref double cy)
        {
            if (docRect == null)
                return;

            if (docRect.X + docRect.Width > cx)
                cx = docRect.X + docRect.Width;

            if (docRect.Y + docRect.Height > cy)
                cy = docRect.Y + docRect.Height;
        }

        /// <summary>
        /// Updates layout of node end of tree, adjusting tree segment as necessary
        /// </summary>
        /// <param name="docLine"></param>
        /// <param name="docDef"></param>
        public static void LayoutNode(DocLine docTree, DocLine docLine)
        {
            DocDefinition docDef = docLine.Definition;

            if(docLine.DiagramLine.Count >= 2)
            {
                while (docLine.DiagramLine.Count < 3)
                {
                    docLine.DiagramLine.Insert(1, new DocPoint());
                }

                // shortcut: make up a rectangle for the line -- don't use constructor as that will allocate as object to be serialized within current project
                DocRectangle fakeRectangle = (DocRectangle)System.Runtime.Serialization.FormatterServices.GetUninitializedObject(typeof(DocRectangle));
                fakeRectangle.X = docTree.DiagramLine[docTree.DiagramLine.Count - 1].X;
                fakeRectangle.Y = docTree.DiagramLine[docTree.DiagramLine.Count - 1].Y;
                fakeRectangle.Width = 0;
                fakeRectangle.Height = 0;

                LayoutLine(fakeRectangle, docDef.DiagramRectangle, docLine.DiagramLine[0], docLine.DiagramLine[1], docLine.DiagramLine[2]);
            }
        }

        /// <summary>
        /// Updates layout of parent end of tree
        /// </summary>
        /// <param name="defA"></param>
        /// <param name="docLine"></param>
        public static void LayoutTree(DocDefinition defA, DocLine docLine)
        {
            if(docLine.Definition != null)
            {
                LayoutLine(defA, docLine.Definition, docLine.DiagramLine);
            }
            else if(docLine.DiagramLine.Count >= 2)
            {
                while (docLine.DiagramLine.Count < 3)
                {
                    docLine.DiagramLine.Insert(1, new DocPoint());
                }

                // shortcut: make up a rectangle for the line -- don't use constructor as that will allocate as object to be serialized within current project
                DocRectangle fakeRectangle = (DocRectangle)System.Runtime.Serialization.FormatterServices.GetUninitializedObject(typeof(DocRectangle));
                fakeRectangle.X = docLine.DiagramLine[docLine.DiagramLine.Count-1].X;
                fakeRectangle.Y = docLine.DiagramLine[docLine.DiagramLine.Count - 1].Y;
                fakeRectangle.Width = 0;
                fakeRectangle.Height = 0;

                LayoutLine(defA.DiagramRectangle, fakeRectangle, docLine.DiagramLine[0], docLine.DiagramLine[1], docLine.DiagramLine[2]);
            }
        }

        public static void LayoutLine(DocDefinition defA, DocDefinition defB, List<DocPoint> list)
        {
            if (list == null)
                return;

            while (list.Count > 3)
            {
                list[list.Count - 1].Delete();
                list.RemoveAt(list.Count - 1);
            }
            while (list.Count < 3)
            {
                list.Add(new DocPoint());
            }
            DocPoint ptA = list[0];
            DocPoint ptM = list[1];
            DocPoint ptB = list[2];

            DocRectangle rB = null;
            if(defB != null)
            {
                rB = defB.DiagramRectangle;
            }

            LayoutLine(defA.DiagramRectangle, rB, ptA, ptM, ptB);
        }

        /// <summary>
        /// Lays out points for connectors using straight segments where possible, falling back on elbows if below
        /// </summary>
        /// <param name="rcA">The source rectangle</param>
        /// <param name="rcB">The target rectangle - optional; if null then only the first point is resized</param>
        /// <param name="ptA">The source point, which is positioned along the perimeter of the source rectangle.</param>
        /// <param name="ptM">The elbow point, which may be the same as the source point (if none), or different if an elbow is needed.</param>
        /// <param name="ptB">The target point, which is positioned at the midpoint of one of the four edges of the target rectangle.</param>
        private static void LayoutLine(DocRectangle rcA, DocRectangle rcB, DocPoint ptA, DocPoint ptM, DocPoint ptB)
        {
            if (rcA == null || rcB == null)
                return;

            if (rcB.X > rcA.X + rcA.Width)
            {
                // to right
                ptB.X = rcB.X;
                ptB.Y = rcB.Y + rcB.Height / 2;
                ptA.X = rcA.X + rcA.Width;
                ptA.Y = ptB.Y;
                ptM.X = ptA.X;
                ptM.Y = ptA.Y;
                if (ptA.Y > rcA.Y + rcA.Height)
                {
                    // below
                    ptA.Y = rcA.Y + rcA.Height;
                }
                else if (ptA.Y < rcA.Y)
                {
                    // above
                    ptA.Y = rcA.Y;
                }
            }
            else if (rcB.X + rcB.Width < rcA.X)
            {
                // to left 
                ptB.X = rcB.X + rcB.Width;
                ptB.Y = rcB.Y + rcB.Height / 2;
                ptA.X = rcA.X;
                ptA.Y = ptB.Y;
                ptM.X = ptA.X;
                ptM.Y = ptA.Y;
                if (ptA.Y > rcA.Y + rcA.Height)
                {
                    // below
                    ptA.Y = rcA.Y + rcA.Height;
                }
                else if (ptA.Y < rcA.Y)
                {
                    // above
                    ptA.Y = rcA.Y;
                }
            }
            else if (rcB.Y > rcA.Y + rcA.Height)
            {
                // to down 
                ptB.X = rcB.X + rcB.Width / 2;
                ptB.Y = rcB.Y;
                ptA.X = ptB.X;
                ptA.Y = rcA.Y + rcA.Height;
                ptM.X = ptA.X;
                ptM.Y = ptA.Y;
                if (ptA.X > rcA.X + rcA.Width)
                {
                    // right
                    ptA.X = rcA.X + rcA.Width;
                }
                else if (ptA.X < rcA.X)
                {
                    // left
                    ptA.X = rcA.X;
                }
            }
            else if (rcB.Y + rcB.Height < rcA.Y)
            {
                // to up
                ptB.X = rcB.X + rcB.Width / 2;
                ptB.Y = rcB.Y + rcB.Height;
                ptA.X = ptB.X;
                ptA.Y = rcA.Y;
                ptM.X = ptA.X;
                ptM.Y = ptA.Y;
                if (ptA.X > rcA.X + rcA.Width)
                {
                    // right
                    ptA.X = rcA.X + rcA.Width;
                }
                else if (ptA.X < rcA.X)
                {
                    // left
                    ptA.X = rcA.X;
                }
            }
        }

        private void CtlExpressG_MouseUp(object sender, MouseEventArgs e)
        {
            if (e.Button != System.Windows.Forms.MouseButtons.Left)
                return;

            this.m_mousedown = false;

            if(this.m_selection == null && this.m_toolmode == ToolMode.Move && this.m_multiselect.Count > 0)
            {
                this.m_selection = this.m_multiselect[0];

                if(this.SelectionChanged != null)
                {
                    this.SelectionChanged(this, EventArgs.Empty);
                }
            }

            if (this.m_selection != null && this.m_highlight != null && this.m_toolmode == ToolMode.Link)
            {
                if (this.LinkOperation != null)
                {
                    // special case for linking entities for subtypes
                    EventArgs args = EventArgs.Empty;
                    if(this.Cursor == Cursors.UpArrow && (this.m_selection is DocEntity || this.m_selection is DocDefinitionRef) && this.m_highlight is DocEntity)
                    {
                        //... also need to determine if referenced type is an entity
                        args = null;
                    }
                    this.LinkOperation(this, args);
                }

                this.Redraw();
            }

            this.m_pointmap.Clear();
            foreach(DocDefinition docDef in this.m_multiselect)
            {
                this.m_pointmap.Add(docDef, new PointF((float)docDef.DiagramRectangle.X, (float)docDef.DiagramRectangle.Y));
            }
            this.Invalidate();
        }

        private static bool HitTest(DocRectangle docRect, Point pt, out ResizeHandle handle)
        {
            handle = ResizeHandle.None;

            if (docRect == null)
                return false;

            Rectangle rc = new Rectangle(
                (int)(docRect.X * Factor),
                (int)(docRect.Y * Factor),
                (int)(docRect.Width * Factor),
                (int)(docRect.Height * Factor));

            bool contains = rc.Contains(pt);
            if(contains)
            {
                int W = pt.X - rc.Left;
                int N = pt.Y - rc.Top;
                int S = rc.Bottom - pt.Y;
                int E = rc.Right - pt.X;

                int rad = 5;
                if(E < rad)
                {
                    handle |= ResizeHandle.East;
                }
                else if (W < rad)
                {
                    handle |= ResizeHandle.West;
                }
                if(S < rad)
                {
                    handle |= ResizeHandle.South;
                }
                else if (N < rad)
                {
                    handle |= ResizeHandle.North;
                }

                if (handle == ResizeHandle.None)
                    handle = ResizeHandle.Move;
            }
            return contains;
        }

        /// <summary>
        /// Finds object at absolute point (regardless of scroll position or page)
        /// </summary>
        /// <param name="pt"></param>
        /// <returns></returns>
        private DocObject Pick(Point pt, out DocLine line, out ResizeHandle handle)
        {
            line = null;
            handle = ResizeHandle.None;

            if (this.m_schema == null)
                return null;

            pt.X -= this.AutoScrollPosition.X;
            pt.Y -= this.AutoScrollPosition.Y;

            PointF ptFloat = new PointF(pt.X, pt.Y);

            // pick in reverse order
            for (int iType = this.m_schema.Entities.Count - 1; iType >= 0; iType--)
            {
                DocEntity docType = this.m_schema.Entities[iType];

                if (HitTest(docType.DiagramRectangle, pt, out handle))
                    return docType;

                foreach (DocAttribute docAttr in docType.Attributes)
                {
                    if (docAttr.DiagramLine != null)
                    {
                        for (int i = 0; i < docAttr.DiagramLine.Count - 1; i++)
                        {
                            PointF ptA = new PointF((float)(docAttr.DiagramLine[i].X * Factor), (float)docAttr.DiagramLine[i].Y * Factor);
                            PointF ptB = new PointF((float)(docAttr.DiagramLine[i + 1].X * Factor), (float)docAttr.DiagramLine[i + 1].Y * Factor);

                            PointF ptClosest = new PointF();
                            double distance = FindDistanceToSegment(ptFloat, ptA, ptB, out ptClosest);
                            if (distance < 3.0)
                            {
                                return docAttr;
                            }
                        }
                    }
                }

                foreach (DocLine docLine in docType.Tree)
                {
                    if (docLine.DiagramLine.Count > 0)
                    {
                        DocPoint docPoint = docLine.DiagramLine[docLine.DiagramLine.Count - 1];
                        PointF ptA = new PointF((float)(docPoint.X * Factor), (float)docPoint.Y * Factor);
                        if (Math.Abs(ptFloat.X - ptA.X) < 4 && Math.Abs(ptFloat.Y - ptA.Y) <= 5)
                        {
                            line = docLine;
                            handle = ResizeHandle.Move;
                            return docType;
                        }
                    }
                }
            }

            for (int iType = this.m_schema.Types.Count - 1; iType >= 0; iType--)
            {
                DocType docType = this.m_schema.Types[iType];

                if (HitTest(docType.DiagramRectangle, pt, out handle))
                    return docType;

                if (docType is DocSelect)
                {
                    DocSelect docSel = (DocSelect)docType;
                    foreach (DocLine docLine in docSel.Tree)
                    {
                        DocPoint docPoint = docLine.DiagramLine[docLine.DiagramLine.Count - 1];
                        PointF ptA = new PointF((float)(docPoint.X * Factor), (float)docPoint.Y * Factor);
                        if (Math.Abs(ptFloat.X - ptA.X) < 4 && Math.Abs(ptFloat.Y - ptA.Y) <= 5)
                        {
                            handle = ResizeHandle.Move;
                            line = docLine;
                            return docType;
                        }
                    }
                }
            }

            foreach (DocComment docType in this.m_schema.Comments)
            {
                if (HitTest(docType.DiagramRectangle, pt, out handle))
                    return docType;
            }

            foreach (DocPageTarget docType in this.m_schema.PageTargets)
            {
                if (HitTest(docType.DiagramRectangle, pt, out handle))
                    return docType;

                foreach(DocPageSource docSource in docType.Sources)
                {
                    if (HitTest(docSource.DiagramRectangle, pt, out handle))
                        return docSource;
                }
            }

            foreach (DocPrimitive docType in this.m_schema.Primitives)
            {
                if (HitTest(docType.DiagramRectangle, pt, out handle))
                    return docType;
            }

            foreach (DocSchemaRef docSchemaRef in this.m_schema.SchemaRefs)
            {
                foreach (DocDefinitionRef docType in docSchemaRef.Definitions)
                {
                    if (HitTest(docType.DiagramRectangle, pt, out handle))
                        return docType;

                    foreach (DocLine docLine in docType.Tree)
                    {
                        DocPoint docPoint = docLine.DiagramLine[docLine.DiagramLine.Count - 1];
                        PointF ptA = new PointF((float)(docPoint.X * Factor), (float)docPoint.Y * Factor);
                        if (Math.Abs(ptFloat.X - ptA.X) < 4 && Math.Abs(ptFloat.Y - ptA.Y) <= 5)
                        {
                            handle = ResizeHandle.Move;
                            line = docLine;
                            return docType;
                        }
                    }
                }
            }

            return null;
        }

        // Calculate the distance between
        // point pt and the segment p1 --> p2.
        private double FindDistanceToSegment(PointF pt, PointF p1, PointF p2, out PointF closest)
        {
            float dx = p2.X - p1.X; 
            float dy = p2.Y - p1.Y; 
            if ((dx == 0) && (dy == 0))
            {        
                // It's a point not a line segment.        
                closest = p1; 
                dx = pt.X - p1.X; 
                dy = pt.Y - p1.Y; 
                return Math.Sqrt(dx * dx + dy * dy);
            }
            // Calculate the t that minimizes the distance.    
            float t = ((pt.X - p1.X) * dx + (pt.Y - p1.Y) * dy) / (dx * dx + dy * dy);
            
            // See if this represents one of the segment's    // end points or a point in the middle.    
            if (t < 0) 
            {
                closest = new PointF(p1.X, p1.Y); 
                dx = pt.X - p1.X; dy = pt.Y - p1.Y; 
            }
            else if (t > 1) 
            {
                closest = new PointF(p2.X, p2.Y); 
                dx = pt.X - p2.X; 
                dy = pt.Y - p2.Y; }
            else 
            { 
                closest = new PointF(p1.X + t * dx, p1.Y + t * dy); 
                dx = pt.X - closest.X; 
                dy = pt.Y - closest.Y; 
            }
            return Math.Sqrt(dx * dx + dy * dy);
        }

        private void CtlExpressG_DragEnter(object sender, DragEventArgs e)
        {
            DocEntity docEnt = e.Data.GetData(typeof(DocEntity)) as DocEntity;
            if (docEnt != null)
            {
                e.Effect = DragDropEffects.Move;
            }
        }

        private void CtlExpressG_DragOver(object sender, DragEventArgs e)
        {
            Point clientPoint = this.PointToClient(new Point(e.X, e.Y));
            double X = (clientPoint.X - this.AutoScrollPosition.X) / Factor;
            double Y = (clientPoint.Y - this.AutoScrollPosition.Y) / Factor;

            DocDefinition docDef = e.Data.GetData(typeof(DocEntity)) as DocEntity;
            if (docDef == null)
            {
                docDef = e.Data.GetData(typeof(DocType)) as DocType;
            }

            if (docDef != null)
            {
                e.Effect = DragDropEffects.Move;

                if(docDef.DiagramRectangle == null)
                {
                    docDef.DiagramRectangle = new DocRectangle();
                }

                docDef.DiagramRectangle.X = X;
                docDef.DiagramRectangle.Y = Y;

                if (docDef.DiagramRectangle.Width <= 0.0 || docDef.DiagramRectangle.Height <= 0.0)
                {
                    docDef.DiagramRectangle.Width = 400.0;
                    docDef.DiagramRectangle.Height = 100.0;// +50.0 * docEnt.Attributes.Count;
                }

                this.Redraw();
            }
        }

        private void CtlExpressG_DragDrop(object sender, DragEventArgs e)
        {
            DocEntity docEnt = e.Data.GetData(typeof(DocEntity)) as DocEntity;
            if (docEnt != null)
            {
                e.Effect = DragDropEffects.Move;

                if (!String.IsNullOrEmpty(docEnt.BaseDefinition))
                {
                    DocObject docBase = null;
                    if (this.m_map.TryGetValue(docEnt.BaseDefinition, out docBase))
                    {
                        if (docBase is DocEntity)
                        {
                            DocEntity docEntBase = (DocEntity)docBase;
                            //...docEntBase.
                        }
                    }
                }

                foreach (DocAttribute docAttr in docEnt.Attributes)
                {
                    //111docAttr.
                }
            }

        }
    }

    [Flags]
    public enum ResizeHandle
    {
        None = 0,
        
        North = 1,
        West = 2,
        South = 4,
        East = 8,

        Move = 16,
    }

    public enum ToolMode
    {
        Select = 0,
        Move = 1,
        Link = 2,
    }

}