예제 #1
0
        private static Drawing.Size GetSize(IVisio.Page page)
        {
            var query      = new ShapeSheet.Queries.Query();
            var col_height = query.AddCell(ShapeSheet.SRCConstants.PageHeight, "PageHeight");
            var col_width  = query.AddCell(ShapeSheet.SRCConstants.PageWidth, "PageWidth");

            var    page_surface = new ShapeSheetSurface(page.PageSheet);
            var    results      = query.GetResults <double>(page_surface);
            double height       = results.Cells[col_height];
            double width        = results.Cells[col_width];
            var    s            = new Drawing.Size(width, height);

            return(s);
        }
예제 #2
0
        /// <summary>
        /// Returns all the directed,connected pairs of shapes in the  page
        /// </summary>
        /// <param name="page"></param>
        /// <param name="flag"></param>
        /// <returns></returns>
        public static List <ConnectorEdge> GetDirectedEdges(
            IVisio.Page page,
            ConnectorHandling flag)
        {
            if (page == null)
            {
                throw new System.ArgumentNullException(nameof(page));
            }

            var edges = ConnectionAnalyzer.GetDirectedEdgesRaw(page);

            if (flag.DirectionSource == DirectionSource.UseConnectionOrder)
            {
                return(edges);
            }

            // At this point we know we need to analyze the connetor arrows to produce the correct results

            var connnector_ids = edges.Select(e => e.Connector.ID).ToList();

            // Get the arrows for each connector
            var src_beginarrow = ShapeSheet.SRCConstants.BeginArrow;
            var src_endarrow   = ShapeSheet.SRCConstants.EndArrow;

            var query          = new ShapeSheet.Queries.Query();
            var col_beginarrow = query.AddCell(src_beginarrow, "BeginArrow");
            var col_endarrow   = query.AddCell(src_endarrow, "EndArrow");

            var surface     = new ShapeSheetSurface(page);
            var arrow_table = query.GetResults <int>(surface, connnector_ids);

            var directed_edges = new List <ConnectorEdge>();

            int connector_index = 0;

            foreach (var e in edges)
            {
                int beginarrow = arrow_table[connector_index].Cells[col_beginarrow];
                int endarrow   = arrow_table[connector_index].Cells[col_endarrow];

                if ((beginarrow < 1) && (endarrow < 1))
                {
                    // the line has no arrows
                    if (flag.NoArrowsHandling == NoArrowsHandling.TreatEdgeAsBidirectional)
                    {
                        // in this case treat the connector as pointing in both directions
                        var de1 = new ConnectorEdge(e.Connector, e.To, e.From);
                        var de2 = new ConnectorEdge(e.Connector, e.From, e.To);
                        directed_edges.Add(de1);
                        directed_edges.Add(de2);
                    }
                    else if (flag.NoArrowsHandling == NoArrowsHandling.ExcludeEdge)
                    {
                        // in this case ignore the connector completely
                    }
                    else
                    {
                        throw new System.ArgumentOutOfRangeException(nameof(flag));
                    }
                }
                else
                {
                    // The connector has either a from-arrow, a to-arrow, or both

                    // handle if it has a from arrow
                    if (beginarrow > 0)
                    {
                        var de = new ConnectorEdge(e.Connector, e.To, e.From);
                        directed_edges.Add(de);
                    }

                    // handle if it has a to arrow
                    if (endarrow > 0)
                    {
                        var de = new ConnectorEdge(e.Connector, e.From, e.To);
                        directed_edges.Add(de);
                    }
                }

                connector_index++;
            }

            return(directed_edges);
        }