예제 #1
0
        RemoveNeighborlessVerticesFromGraph
        (
            IGraph oGraph
        )
        {
            Debug.Assert(oGraph != null);
            AssertValid();

            IVertexCollection oVertices             = oGraph.Vertices;
            List <IVertex>    oNeighborlessVertices = new List <IVertex>();

            foreach (IVertex oVertex in oVertices)
            {
                Boolean bIsNeighborless = true;

                foreach (IEdge oIncidentEdge in oVertex.IncidentEdges)
                {
                    if (oIncidentEdge.GetAdjacentVertex(oVertex) != oVertex)
                    {
                        bIsNeighborless = false;
                        break;
                    }
                }

                if (bIsNeighborless)
                {
                    oNeighborlessVertices.Add(oVertex);
                }
            }

            foreach (IVertex oNeighborlessVertex in oNeighborlessVertices)
            {
                oVertices.Remove(oNeighborlessVertex);
            }

            return(oNeighborlessVertices);
        }
예제 #2
0
        ReadVertexTable
        (
            ListObject oVertexTable,
            ReadWorkbookContext oReadWorkbookContext,
            IGraph oGraph,
            out Boolean bLayoutOrderSet,
            out Boolean bToolTipSet
        )
        {
            Debug.Assert(oVertexTable != null);
            Debug.Assert(oReadWorkbookContext != null);
            Debug.Assert(oGraph != null);
            AssertValid();

            bLayoutOrderSet = bToolTipSet = false;

            if (GetTableColumnIndex(oVertexTable,
                                    VertexTableColumnNames.VertexName, false) == NoSuchColumn)
            {
                // Nothing can be done without vertex names.

                return;
            }

            Boolean bReadAllEdgeAndVertexColumns =
                oReadWorkbookContext.ReadAllEdgeAndVertexColumns;

            if (oReadWorkbookContext.FillIDColumns)
            {
                FillIDColumn(oVertexTable);
            }

            // Get the names of all the column pairs that are used to add custom
            // menu items to the vertex context menu in the graph.

            TableColumnAdder oTableColumnAdder = new TableColumnAdder();

            ICollection <KeyValuePair <String, String> > aoCustomMenuItemPairNames =
                oTableColumnAdder.GetColumnPairNames(oVertexTable,
                                                     VertexTableColumnNames.CustomMenuItemTextBase,
                                                     VertexTableColumnNames.CustomMenuItemActionBase);

            IVertexCollection oVertices = oGraph.Vertices;

            Dictionary <String, IVertex> oVertexNameDictionary =
                oReadWorkbookContext.VertexNameDictionary;

            Dictionary <Int32, IIdentityProvider> oEdgeRowIDDictionary =
                oReadWorkbookContext.EdgeRowIDDictionary;

            BooleanConverter oBooleanConverter =
                oReadWorkbookContext.BooleanConverter;

            VertexVisibilityConverter oVertexVisibilityConverter =
                new VertexVisibilityConverter();

            VertexLabelPositionConverter oVertexLabelPositionConverter =
                new VertexLabelPositionConverter();

            ExcelTableReader oExcelTableReader =
                new ExcelTableReader(oVertexTable);

            HashSet <String> oColumnNamesToExclude = new HashSet <String>(
                new String[] {
                VertexTableColumnNames.VertexName
            });

            foreach (ExcelTableReader.ExcelTableRow oRow in
                     oExcelTableReader.GetRows())
            {
                // Get the name of the vertex.

                String sVertexName;

                if (!oRow.TryGetNonEmptyStringFromCell(
                        VertexTableColumnNames.VertexName, out sVertexName))
                {
                    continue;
                }

                // If the vertex was added to the graph as part of an edge,
                // retrieve the vertex.

                IVertex oVertex;

                if (!oVertexNameDictionary.TryGetValue(sVertexName, out oVertex))
                {
                    oVertex = null;
                }

                // Assume a default visibility.

                Visibility eVisibility = Visibility.ShowIfInAnEdge;
                String     sVisibility;

                if (oRow.TryGetNonEmptyStringFromCell(
                        CommonTableColumnNames.Visibility, out sVisibility))
                {
                    if (!oVertexVisibilityConverter.TryWorkbookToGraph(
                            sVisibility, out eVisibility))
                    {
                        OnInvalidVisibility(oRow);
                    }
                }

                switch (eVisibility)
                {
                case Visibility.ShowIfInAnEdge:

                    // If the vertex is part of an edge, show it using the
                    // specified vertex attributes.  Otherwise, skip the vertex
                    // row.

                    if (oVertex == null)
                    {
                        continue;
                    }

                    break;

                case Visibility.Skip:

                    // Skip the vertex row and any edge rows that include the
                    // vertex.  Do not read them into the graph.

                    if (oVertex != null)
                    {
                        // Remove the vertex and its incident edges from the
                        // graph and dictionaries.

                        foreach (IEdge oIncidentEdge in oVertex.IncidentEdges)
                        {
                            if (oIncidentEdge.Tag is Int32)
                            {
                                oEdgeRowIDDictionary.Remove(
                                    (Int32)oIncidentEdge.Tag);
                            }
                        }

                        oVertexNameDictionary.Remove(sVertexName);

                        oVertices.Remove(oVertex);

                        // (The vertex doesn't get added to
                        // ReadWorkbookContext.VertexIDDictionary until after
                        // this switch statement, so it doesn't need to be
                        // removed from that dictionary.)
                    }

                    continue;

                case Visibility.Hide:

                    // If the vertex is part of an edge, hide it and its
                    // incident edges.  Otherwise, skip the vertex row.

                    if (oVertex == null)
                    {
                        continue;
                    }

                    // Hide the vertex and its incident edges.

                    oVertex.SetValue(ReservedMetadataKeys.Visibility,
                                     VisibilityKeyValue.Hidden);

                    foreach (IEdge oIncidentEdge in oVertex.IncidentEdges)
                    {
                        oIncidentEdge.SetValue(ReservedMetadataKeys.Visibility,
                                               VisibilityKeyValue.Hidden);
                    }

                    break;

                case Visibility.Show:

                    // Show the vertex using the specified attributes
                    // regardless of whether it is part of an edge.

                    if (oVertex == null)
                    {
                        oVertex = CreateVertex(sVertexName, oVertices,
                                               oVertexNameDictionary);
                    }

                    break;

                default:

                    Debug.Assert(false);
                    break;
                }

                Debug.Assert(oVertex != null);

                // If there is an ID column, add the vertex to the vertex ID
                // dictionary and set the vertex's Tag to the ID.

                AddToRowIDDictionary(oRow, oVertex,
                                     oReadWorkbookContext.VertexRowIDDictionary);

                if (bReadAllEdgeAndVertexColumns)
                {
                    // All columns except the vertex name should be read and stored
                    // as metadata on the vertex.

                    ReadAllColumns(oExcelTableReader, oRow, oVertex,
                                   oColumnNamesToExclude);

                    continue;
                }

                // Layout order.

                if (ReadLayoutOrder(oRow, oVertex))
                {
                    bLayoutOrderSet = true;
                }

                // Location and Locked.

                if (!oReadWorkbookContext.IgnoreVertexLocations)
                {
                    Boolean bLocationSpecified = false;

                    bLocationSpecified = ReadLocation(oRow,
                                                      oReadWorkbookContext.VertexLocationConverter, oVertex);

                    ReadLocked(oRow, oBooleanConverter, bLocationSpecified,
                               oVertex);
                }

                // Polar coordinates.

                ReadPolarCoordinates(oRow, oVertex);

                // Marked.

                ReadMarked(oRow, oBooleanConverter, oVertex);

                // Custom menu items.

                if (aoCustomMenuItemPairNames.Count > 0)
                {
                    ReadCustomMenuItems(oRow, aoCustomMenuItemPairNames, oVertex);
                }

                // Alpha.

                ReadAlpha(oRow, oVertex);

                // Tooltip.

                if (ReadCellAndSetMetadata(oRow, VertexTableColumnNames.ToolTip,
                                           oVertex, ReservedMetadataKeys.VertexToolTip))
                {
                    bToolTipSet = true;
                }

                // Label.

                if (oReadWorkbookContext.ReadVertexLabels)
                {
                    ReadCellAndSetMetadata(oRow, VertexTableColumnNames.Label,
                                           oVertex, ReservedMetadataKeys.PerVertexLabel);
                }

                // Label fill color.

                ReadColor(oRow, VertexTableColumnNames.LabelFillColor, oVertex,
                          ReservedMetadataKeys.PerVertexLabelFillColor,
                          oReadWorkbookContext.ColorConverter2);

                // Label position.

                ReadLabelPosition(oRow, oVertexLabelPositionConverter, oVertex);

                // Radius.

                Nullable <Single> oRadiusWorkbook = new Nullable <Single>();

                oRadiusWorkbook = ReadRadius(oRow,
                                             oReadWorkbookContext.VertexRadiusConverter, oVertex);

                // Shape.

                VertexShape eVertexShape;

                if (!ReadShape(oRow, oVertex, out eVertexShape))
                {
                    eVertexShape = oReadWorkbookContext.DefaultVertexShape;
                }

                // Label font size.

                if (eVertexShape == VertexShape.Label && oRadiusWorkbook.HasValue)
                {
                    // The vertex radius is used to specify font size when the
                    // shape is Label.

                    oVertex.SetValue(ReservedMetadataKeys.PerVertexLabelFontSize,
                                     oReadWorkbookContext.VertexRadiusConverter.
                                     WorkbookToLabelFontSize(oRadiusWorkbook.Value));
                }

                // Image URI.

                if (eVertexShape == VertexShape.Image &&
                    oReadWorkbookContext.ReadVertexImages)
                {
                    ReadImageUri(oRow, oVertex,
                                 oReadWorkbookContext.VertexRadiusConverter,

                                 oRadiusWorkbook.HasValue ? oRadiusWorkbook :
                                 oReadWorkbookContext.DefaultVertexImageSize
                                 );
                }

                // Color

                ReadColor(oRow, VertexTableColumnNames.Color, oVertex,
                          ReservedMetadataKeys.PerColor,
                          oReadWorkbookContext.ColorConverter2);
            }

            if (bReadAllEdgeAndVertexColumns)
            {
                // Store the vertex column names on the graph.

                oGraph.SetValue(ReservedMetadataKeys.AllVertexMetadataKeys,
                                FilterColumnNames(oExcelTableReader, oColumnNamesToExclude));
            }
        }