Esempio n. 1
0
        ReadWorkbook
        (
            Microsoft.Office.Interop.Excel.Workbook oWorkbook
        )
        {
            Debug.Assert(oWorkbook != null);

            WorkbookReader oWorkbookReader = new WorkbookReader();

            ReadWorkbookContext oReadWorkbookContext = new ReadWorkbookContext();

            // Read all columns in the vertex worksheet and store the cell values
            // as metadata on the graph's vertices.

            oReadWorkbookContext.ReadAllEdgeAndVertexColumns = true;

            // GroupsToGraphMetricColumnsConverter.Convert() copies the ID column
            // on the vertex worksheet to the group-vertex worksheet, so make sure
            // that the vertex ID column is filled in.

            oReadWorkbookContext.FillIDColumns = true;

            return(oWorkbookReader.ReadWorkbook(oWorkbook,
                                                oReadWorkbookContext));
        }
        ReadWorkbook
        (
            Microsoft.Office.Interop.Excel.Workbook oWorkbook,
            GraphMetricUserSettings oGraphMetricUserSettings
        )
        {
            Debug.Assert(oWorkbook != null);
            Debug.Assert(oGraphMetricUserSettings != null);
            AssertValid();

            ReadWorkbookContext oReadWorkbookContext = new ReadWorkbookContext();

            oReadWorkbookContext.FillIDColumns           = true;
            oReadWorkbookContext.PopulateVertexWorksheet = true;

            if ((oGraphMetricUserSettings.GraphMetricsToCalculate &
                 GraphMetrics.GroupMetrics) != 0)
            {
                oReadWorkbookContext.ReadGroups        = true;
                oReadWorkbookContext.SaveGroupVertices = true;
            }

            WorkbookReader oWorkbookReader = new WorkbookReader();

            return(oWorkbookReader.ReadWorkbook(
                       oWorkbook, oReadWorkbookContext));
        }
Esempio n. 3
0
        ReadWorksheet
        (
            Microsoft.Office.Interop.Excel.Workbook workbook,
            ReadWorkbookContext readWorkbookContext,
            IGraph graph
        )
        {
            Debug.Assert(workbook != null);
            Debug.Assert(readWorkbookContext != null);
            Debug.Assert(graph != null);
            AssertValid();

            // Get the required table that contains edge data, then add the edges
            // and vertices in the table to the graph.

            ListObject oEdgeTable = GetEdgeTable(workbook);

            // The code that reads the table can handle hidden rows, but not hidden
            // columns.  Temporarily show all hidden columns in the table.

            ExcelHiddenColumns oHiddenColumns =
                ExcelColumnHider.ShowHiddenColumns(oEdgeTable);

            try
            {
                ReadEdgeTable(oEdgeTable, readWorkbookContext, graph);
            }
            finally
            {
                ExcelColumnHider.RestoreHiddenColumns(oEdgeTable, oHiddenColumns);
            }
        }
Esempio n. 4
0
        ReadGroupTables
        (
            ListObject oGroupTable,
            ListObject oGroupVertexTable,
            ReadWorkbookContext oReadWorkbookContext,
            IGraph oGraph
        )
        {
            Debug.Assert(oGroupTable != null);
            Debug.Assert(oGroupVertexTable != null);
            Debug.Assert(oReadWorkbookContext != null);
            Debug.Assert(oGraph != null);
            AssertValid();

            // If a required column is missing, do nothing.

            ListColumn oColumn;

            if (
                !ExcelUtil.TryGetTableColumn(oGroupTable,
                                             GroupTableColumnNames.Name, out oColumn)
                ||
                !ExcelUtil.TryGetTableColumn(oGroupTable,
                                             GroupTableColumnNames.VertexColor, out oColumn)
                ||
                !ExcelUtil.TryGetTableColumn(oGroupTable,
                                             GroupTableColumnNames.VertexShape, out oColumn)
                ||
                !ExcelUtil.TryGetTableColumn(oGroupVertexTable,
                                             GroupVertexTableColumnNames.GroupName, out oColumn)
                ||
                !ExcelUtil.TryGetTableColumn(oGroupVertexTable,
                                             GroupVertexTableColumnNames.VertexName, out oColumn)
                )
            {
                return;
            }

            // Create a dictionary from the group table.  The key is the group name
            // and the value is a GroupInformation object for the group.

            Dictionary <String, GroupInformation> oGroupNameDictionary =
                ReadGroupTable(oGroupTable, oReadWorkbookContext);

            // Read the group vertex table and set the color and shape of each
            // group vertex in the graph.

            ReadGroupVertexTable(oGroupVertexTable, oReadWorkbookContext,
                                 oGroupNameDictionary, oGraph);

            // Save the group information on the graph.

            Debug.Assert(oGroupNameDictionary.Values is
                         ICollection <GroupInformation>);

            oGraph.SetValue(ReservedMetadataKeys.GroupInformation,
                            oGroupNameDictionary.Values);
        }
Esempio n. 5
0
        ReadWorkbook
        (
            Microsoft.Office.Interop.Excel.Workbook workbook,
            ReadWorkbookContext readWorkbookContext
        )
        {
            Debug.Assert(readWorkbookContext != null);
            Debug.Assert(workbook != null);
            AssertValid();

            IGraph oGraph = null;

            // Turn off screen updating, for two reasons:
            //
            // 1. Reading the workbook can involve writing to edge and vertex ID
            //    columns, which can be slow when updating is turned on.
            //
            // 2. Any hidden columns get temporarily shown as each worksheet is
            //    read.

            Application oApplication       = workbook.Application;
            Boolean     bOldScreenUpdating = oApplication.ScreenUpdating;

            oApplication.ScreenUpdating = false;

            try
            {
                oGraph = ReadWorkbookInternal(workbook, readWorkbookContext);
            }
            catch (WorkbookFormatException oWorkbookFormatException)
            {
                Range oRangeToSelect = oWorkbookFormatException.RangeToSelect;

                if (oRangeToSelect != null)
                {
                    // The user may have hidden the column group containing the
                    // error.  Make sure the column is visible.

                    oRangeToSelect.EntireColumn.Hidden = false;
                }

                throw oWorkbookFormatException;
            }
            finally
            {
                oApplication.ScreenUpdating = bOldScreenUpdating;
            }

            return(oGraph);
        }
Esempio n. 6
0
        ReadClusterTables
        (
            ListObject oClusterTable,
            ListObject oClusterVertexTable,
            ReadWorkbookContext oReadWorkbookContext,
            IGraph oGraph
        )
        {
            Debug.Assert(oClusterTable != null);
            Debug.Assert(oClusterVertexTable != null);
            Debug.Assert(oReadWorkbookContext != null);
            Debug.Assert(oGraph != null);
            AssertValid();

            // If a required column is missing, do nothing.

            ListColumn oColumn;

            if (
                !ExcelUtil.TryGetTableColumn(oClusterTable,
                                             ClusterTableColumnNames.Name, out oColumn)
                ||
                !ExcelUtil.TryGetTableColumn(oClusterTable,
                                             ClusterTableColumnNames.VertexColor, out oColumn)
                ||
                !ExcelUtil.TryGetTableColumn(oClusterTable,
                                             ClusterTableColumnNames.VertexShape, out oColumn)
                ||
                !ExcelUtil.TryGetTableColumn(oClusterVertexTable,
                                             ClusterVertexTableColumnNames.ClusterName, out oColumn)
                ||
                !ExcelUtil.TryGetTableColumn(oClusterVertexTable,
                                             ClusterVertexTableColumnNames.VertexName, out oColumn)
                )
            {
                return;
            }

            // Create a dictionary from the cluster table.  The key is the cluster
            // name and the value is a ClusterInformation object for the cluster.

            Dictionary <String, ClusterInformation> oClusterNameDictionary =
                ReadClusterTable(oClusterTable, oReadWorkbookContext);

            // Read the cluster vertex table and add the cluster vertex information
            // to the graph.

            ReadClusterVertexTable(oClusterVertexTable, oClusterNameDictionary,
                                   oReadWorkbookContext.VertexNameDictionary, oGraph);
        }
Esempio n. 7
0
        ReadWorksheet
        (
            Microsoft.Office.Interop.Excel.Workbook workbook,
            ReadWorkbookContext readWorkbookContext,
            IGraph graph
        )
        {
            Debug.Assert(workbook != null);
            Debug.Assert(readWorkbookContext != null);
            Debug.Assert(graph != null);
            AssertValid();

            // Attempt to get the optional tables that contain group data.

            ListObject oGroupTable, oGroupVertexTable;

            if (
                ExcelUtil.TryGetTable(workbook, WorksheetNames.Groups,
                                      TableNames.Groups, out oGroupTable)
                &&
                ExcelUtil.TryGetTable(workbook, WorksheetNames.GroupVertices,
                                      TableNames.GroupVertices, out oGroupVertexTable)
                )
            {
                // The code that reads the tables can handle hidden rows, but not
                // hidden columns.  Temporarily show all hidden columns in the
                // table.

                ExcelHiddenColumns oHiddenGroupColumns =
                    ExcelColumnHider.ShowHiddenColumns(oGroupTable);

                ExcelHiddenColumns oHiddenGroupVertexColumns =
                    ExcelColumnHider.ShowHiddenColumns(oGroupVertexTable);

                try
                {
                    ReadGroupTables(oGroupTable, oGroupVertexTable,
                                    readWorkbookContext, graph);
                }
                finally
                {
                    ExcelColumnHider.RestoreHiddenColumns(oGroupTable,
                                                          oHiddenGroupColumns);

                    ExcelColumnHider.RestoreHiddenColumns(oGroupVertexTable,
                                                          oHiddenGroupVertexColumns);
                }
            }
        }
        ReadWorkbook
        (
            Microsoft.Office.Interop.Excel.Workbook oWorkbook
        )
        {
            Debug.Assert(oWorkbook != null);
            AssertValid();

            ReadWorkbookContext oReadWorkbookContext = new ReadWorkbookContext();

            WorkbookReader oWorkbookReader = new WorkbookReader();

            // Convert the workbook contents to a Graph object.

            return(oWorkbookReader.ReadWorkbook(
                       oWorkbook, oReadWorkbookContext));
        }
Esempio n. 9
0
        ReadWorksheet
        (
            Microsoft.Office.Interop.Excel.Workbook workbook,
            ReadWorkbookContext readWorkbookContext,
            IGraph graph
        )
        {
            Debug.Assert(workbook != null);
            Debug.Assert(readWorkbookContext != null);
            Debug.Assert(graph != null);
            AssertValid();

            Nullable <Color> oBackColor = this.BackColor;

            if (oBackColor.HasValue)
            {
                graph.SetValue(ReservedMetadataKeys.GraphBackColor,
                               oBackColor.Value);

                // (Note that if there is no per-workbook background color, the
                // GraphDrawer.BackColor property will be used instead.)
            }

            String sBackgroundImageUri = this.BackgroundImageUri;

            if (!String.IsNullOrEmpty(sBackgroundImageUri))
            {
                System.Windows.Media.ImageSource oImage = (new WpfImageUtil()).
                                                          GetImageSynchronousIgnoreDpi(sBackgroundImageUri);

                graph.SetValue(ReservedMetadataKeys.GraphBackgroundImage, oImage);

                // (Note that if there is no per-workbook background image, no
                // background image will be drawn.)
            }
        }
        //*************************************************************************
        //  Method: ReadClusterTables()
        //
        /// <summary>
        /// Reads the cluster tables and add the contents to a graph.
        /// </summary>
        ///
        /// <param name="oClusterTable">
        /// Table that contains the cluster data.
        /// </param>
        ///
        /// <param name="oClusterVertexTable">
        /// Table that contains the cluster vertex data.
        /// </param>
        ///
        /// <param name="oReadWorkbookContext">
        /// Provides access to objects needed for converting an Excel workbook to a
        /// NodeXL graph.
        /// </param>
        ///
        /// <param name="oGraph">
        /// Graph to add cluster data to.
        /// </param>
        //*************************************************************************
        protected void ReadClusterTables(
            ListObject oClusterTable,
            ListObject oClusterVertexTable,
            ReadWorkbookContext oReadWorkbookContext,
            IGraph oGraph
            )
        {
            Debug.Assert(oClusterTable != null);
            Debug.Assert(oClusterVertexTable != null);
            Debug.Assert(oReadWorkbookContext != null);
            Debug.Assert(oGraph != null);
            AssertValid();

            // If a required column is missing, do nothing.

            ListColumn oColumn;

            if (
            !ExcelUtil.TryGetTableColumn(oClusterTable,
                ClusterTableColumnNames.Name, out oColumn)
            ||
            !ExcelUtil.TryGetTableColumn(oClusterTable,
                ClusterTableColumnNames.VertexColor, out oColumn)
            ||
            !ExcelUtil.TryGetTableColumn(oClusterTable,
                ClusterTableColumnNames.VertexShape, out oColumn)
            ||
            !ExcelUtil.TryGetTableColumn(oClusterVertexTable,
                ClusterVertexTableColumnNames.ClusterName, out oColumn)
            ||
            !ExcelUtil.TryGetTableColumn(oClusterVertexTable,
                ClusterVertexTableColumnNames.VertexName, out oColumn)
            )
            {
            return;
            }

            // Create a dictionary from the cluster table.  The key is the cluster
            // name and the value is a ClusterInformation object for the cluster.

            Dictionary<String, ClusterInformation> oClusterNameDictionary =
            ReadClusterTable(oClusterTable, oReadWorkbookContext);

            // Read the cluster vertex table and add the cluster vertex information
            // to the graph.

            ReadClusterVertexTable(oClusterVertexTable, oClusterNameDictionary,
            oReadWorkbookContext.VertexNameDictionary, oGraph);
        }
Esempio n. 11
0
        ReadClusterTable
        (
            ListObject oClusterTable,
            ReadWorkbookContext oReadWorkbookContext
        )
        {
            Debug.Assert(oClusterTable != null);
            Debug.Assert(oReadWorkbookContext != null);
            AssertValid();

            Dictionary <String, ClusterInformation> oClusterNameDictionary =
                new Dictionary <String, ClusterInformation>();

            ColorConverter2 oColorConverter2 =
                oReadWorkbookContext.ColorConverter2;

            ExcelTableReader oExcelTableReader =
                new ExcelTableReader(oClusterTable);

            foreach (ExcelTableReader.ExcelTableRow oRow in
                     oExcelTableReader.GetRows())
            {
                // Get the cluster information.

                String      sClusterName;
                Color       oVertexColor;
                VertexShape eVertexShape;

                if (
                    !oRow.TryGetNonEmptyStringFromCell(
                        ClusterTableColumnNames.Name, out sClusterName)
                    ||
                    !TryGetColor(oRow, ClusterTableColumnNames.VertexColor,
                                 oColorConverter2, out oVertexColor)
                    ||
                    !TryGetVertexShape(oRow, ClusterTableColumnNames.VertexShape,
                                       out eVertexShape)
                    )
                {
                    continue;
                }

                // Add the cluster information to the dictionary.

                ClusterInformation oClusterInformation =
                    new ClusterInformation();

                oClusterInformation.VertexColor = oVertexColor;
                oClusterInformation.VertexShape = eVertexShape;

                try
                {
                    oClusterNameDictionary.Add(
                        sClusterName, oClusterInformation);
                }
                catch (ArgumentException)
                {
                    Range oInvalidCell = oRow.GetRangeForCell(
                        ClusterTableColumnNames.Name);

                    OnWorkbookFormatError(String.Format(

                                              "The cell {0} contains a duplicate cluster name.  There"
                                              + " can't be two rows with the same cluster name."
                                              ,
                                              ExcelUtil.GetRangeAddress(oInvalidCell)
                                              ),

                                          oInvalidCell
                                          );
                }
            }

            return(oClusterNameDictionary);
        }
        //*************************************************************************
        //  Method: ReadClusterTable()
        //
        /// <summary>
        /// Reads the cluster table.
        /// </summary>
        ///
        /// <param name="oClusterTable">
        /// The cluster table.
        /// </param>
        ///
        /// <param name="oReadWorkbookContext">
        /// Provides access to objects needed for converting an Excel workbook to a
        /// NodeXL graph.
        /// </param>
        ///
        /// <returns>
        /// A dictionary.  The key is the cluster name and the value is a
        /// ClusterInformation object for the cluster.
        /// </returns>
        //*************************************************************************
        protected Dictionary<String, ClusterInformation> ReadClusterTable(
            ListObject oClusterTable,
            ReadWorkbookContext oReadWorkbookContext
            )
        {
            Debug.Assert(oClusterTable != null);
            Debug.Assert(oReadWorkbookContext != null);
            AssertValid();

            Dictionary<String, ClusterInformation> oClusterNameDictionary =
            new Dictionary<String, ClusterInformation>();

            ColorConverter2 oColorConverter2 =
            oReadWorkbookContext.ColorConverter2;

            ExcelTableReader oExcelTableReader =
            new ExcelTableReader(oClusterTable);

            foreach ( ExcelTableReader.ExcelTableRow oRow in
            oExcelTableReader.GetRows() )
            {
            // Get the cluster information.

            String sClusterName;
            Color oVertexColor;
            VertexShape eVertexShape;

            if (
                !oRow.TryGetNonEmptyStringFromCell(
                    ClusterTableColumnNames.Name, out sClusterName)
                ||
                !TryGetColor(oRow, ClusterTableColumnNames.VertexColor,
                    oColorConverter2, out oVertexColor)
                ||
                !TryGetVertexShape(oRow, ClusterTableColumnNames.VertexShape,
                    out eVertexShape)
                )
            {
                continue;
            }

            // Add the cluster information to the dictionary.

            ClusterInformation oClusterInformation =
                new ClusterInformation();

            oClusterInformation.VertexColor = oVertexColor;
            oClusterInformation.VertexShape = eVertexShape;

            try
            {
                oClusterNameDictionary.Add(
                    sClusterName, oClusterInformation);
            }
            catch (ArgumentException)
            {
                Range oInvalidCell = oRow.GetRangeForCell(
                    ClusterTableColumnNames.Name);

                OnWorkbookFormatError( String.Format(

                    "The cell {0} contains a duplicate cluster name.  There"
                    + " can't be two rows with the same cluster name."
                    ,
                    ExcelUtil.GetRangeAddress(oInvalidCell)
                    ),

                    oInvalidCell
                );
            }
            }

            return (oClusterNameDictionary);
        }
 public void SetUp()
 {
     m_oReadWorkbookContext = new ReadWorkbookContext();
 }
Esempio n. 14
0
        //*************************************************************************
        //  Method: ReadWorkbook()
        //
        /// <summary>
        /// Creates a NodeXL graph from the contents of an Excel workbook.
        /// </summary>
        ///
        /// <param name="workbook">
        /// Workbook containing the graph data.
        /// </param>
        ///
        /// <param name="readWorkbookContext">
        /// Provides access to objects needed for converting an Excel workbook to a
        /// NodeXL graph.
        /// </param>
        ///
        /// <returns>
        /// A new graph.
        /// </returns>
        ///
        /// <remarks>
        /// If <paramref name="workbook" /> contains valid graph data, a new <see
        /// cref="IGraph" /> is created from the workbook contents and returned.
        /// Otherwise, a <see cref="WorkbookFormatException" /> is thrown.
        /// </remarks>
        //*************************************************************************
        public IGraph ReadWorkbook(
            Microsoft.Office.Interop.Excel.Workbook workbook,
            ReadWorkbookContext readWorkbookContext
            )
        {
            Debug.Assert(readWorkbookContext != null);
            Debug.Assert(workbook != null);
            AssertValid();

            IGraph oGraph = null;

            // Turn off screen updating, for two reasons:
            //
            // 1. Reading the workbook can involve writing to edge and vertex ID
            //    columns, which can be slow when updating is turned on.
            //
            // 2. Any hidden columns get temporarily shown as each worksheet is
            //    read.

            Application oApplication = workbook.Application;
            Boolean bOldScreenUpdating = oApplication.ScreenUpdating;
            oApplication.ScreenUpdating = false;

            try
            {
            oGraph = ReadWorkbookInternal(workbook, readWorkbookContext);
            }
            catch (WorkbookFormatException oWorkbookFormatException)
            {
            Range oRangeToSelect = oWorkbookFormatException.RangeToSelect;

            if (oRangeToSelect != null)
            {
                // The user may have hidden the column group containing the
                // error.  Make sure the column is visible.

                oRangeToSelect.EntireColumn.Hidden = false;
            }

            throw oWorkbookFormatException;
            }
            finally
            {
            oApplication.ScreenUpdating = bOldScreenUpdating;
            }

            return (oGraph);
        }
Esempio n. 15
0
        ReadGroupVertexTable
        (
            ListObject oGroupVertexTable,
            ReadWorkbookContext oReadWorkbookContext,
            Dictionary <String, GroupInformation> oGroupNameDictionary,
            IGraph oGraph
        )
        {
            Debug.Assert(oGroupVertexTable != null);
            Debug.Assert(oReadWorkbookContext != null);
            Debug.Assert(oGroupNameDictionary != null);
            Debug.Assert(oGraph != null);
            AssertValid();

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

            ExcelTableReader oExcelTableReader =
                new ExcelTableReader(oGroupVertexTable);

            foreach (ExcelTableReader.ExcelTableRow oRow in
                     oExcelTableReader.GetRows())
            {
                // Get the group vertex information from the row.

                String sGroupName, sVertexName;

                if (
                    !oRow.TryGetNonEmptyStringFromCell(
                        GroupVertexTableColumnNames.GroupName, out sGroupName)
                    ||
                    !oRow.TryGetNonEmptyStringFromCell(
                        GroupVertexTableColumnNames.VertexName, out sVertexName)
                    )
                {
                    continue;
                }

                // Get the group information for the vertex and store the group
                // information in the vertex.

                GroupInformation oGroupInformation;
                IVertex          oVertex;

                if (
                    !oGroupNameDictionary.TryGetValue(sGroupName,
                                                      out oGroupInformation)
                    ||
                    !oVertexNameDictionary.TryGetValue(sVertexName,
                                                       out oVertex)
                    )
                {
                    continue;
                }

                oVertex.SetValue(ReservedMetadataKeys.PerColor,
                                 oGroupInformation.VertexColor);

                oVertex.SetValue(ReservedMetadataKeys.PerVertexShape,
                                 oGroupInformation.VertexShape);

                if (oReadWorkbookContext.SaveGroupVertices)
                {
                    Debug.Assert(oGroupInformation.Vertices != null);

                    oGroupInformation.Vertices.Add(oVertex);
                }
            }
        }
Esempio n. 16
0
        //*************************************************************************
        //  Method: ReadWorkbook()
        //
        /// <summary>
        /// Transfers data from the workbook to the NodeXLControl and optionally
        /// lays out the graph.
        /// </summary>
        ///
        /// <param name="bLayOutGraph">
        /// true to lay out the graph.
        /// </param>
        //*************************************************************************
        protected void ReadWorkbook(
            Boolean bLayOutGraph
            )
        {
            AssertValid();

            if (oNodeXLControl.IsLayingOutGraph)
            {
            return;
            }

            if (
            !this.NonEmptyWorkbookRead
            && this.LayoutIsNull
            && !ShowLayoutTypeIsNullNotification()
            )
            {
            return;
            }

            // This is in case another open workbook has modified the user
            // settings.

            GeneralUserSettings oGeneralUserSettings = new GeneralUserSettings();
            ApplyGeneralUserSettings(oGeneralUserSettings);
            ApplyLayoutUserSettings( new LayoutUserSettings() );

            ReadWorkbookContext oReadWorkbookContext = new ReadWorkbookContext();

            oReadWorkbookContext.IgnoreVertexLocations = false;
            oReadWorkbookContext.GraphRectangle = this.GraphRectangle;
            oReadWorkbookContext.FillIDColumns = true;
            oReadWorkbookContext.ReadGroups = m_oRibbon.ReadGroups;
            oReadWorkbookContext.ReadVertexLabels = m_oRibbon.ReadVertexLabels;
            oReadWorkbookContext.ReadEdgeLabels = m_oRibbon.ReadEdgeLabels;
            oReadWorkbookContext.ReadVertexImages = true;

            oReadWorkbookContext.DefaultVertexImageSize =
            oGeneralUserSettings.VertexImageSize;

            oReadWorkbookContext.DefaultVertexShape =
            oGeneralUserSettings.VertexShape;

            // Populate the vertex worksheet.  This isn't strictly necessary, but
            // it does enable the vertex worksheet to be updated when the user
            // edits vertex attributes in the NodeXL graph.  (If the vertex
            // worksheet is missing, vertex attributes can still be edited in the
            // graph; the edits just won't get saved in the workbook.)

            oReadWorkbookContext.PopulateVertexWorksheet = true;

            WorkbookReader oWorkbookReader = new WorkbookReader();

            m_oEdgeRowIDDictionary = null;
            m_oVertexRowIDDictionary = null;

            EnableGraphControls(false);

            try
            {
            // Read the workbook into a Graph object.

            IGraph oGraph = oWorkbookReader.ReadWorkbook(
                m_oWorkbook, oReadWorkbookContext);

            // Save the edge and vertex dictionaries that were created by
            // WorkbookReader.

            m_oEdgeRowIDDictionary = oReadWorkbookContext.EdgeRowIDDictionary;

            m_oVertexRowIDDictionary =
                oReadWorkbookContext.VertexRowIDDictionary;

            // Load the NodeXLControl with the resulting graph.

            oNodeXLControl.Graph = oGraph;

            // Collapse any groups that are supposed to be collapsed.

            CollapseOrExpandGroups(GetGroupNamesToCollapse(oGraph), true,
                false);

            // Enable tooltips only if tooltips were specified in the workbook.

            oNodeXLControl.ShowVertexToolTips = oGraph.ContainsKey(
                ReservedMetadataKeys.ToolTipSet);

            // If the dynamic filter dialog is open, read the dynamic filter
            // columns it filled in.

            if (m_oDynamicFilterDialog != null)
            {
                ReadDynamicFilterColumns(false);
                ReadFilteredAlpha(false);
            }

            oNodeXLControl.DrawGraph(bLayOutGraph);

            PerWorkbookSettings oPerWorkbookSettings =
                this.PerWorkbookSettings;

            UpdateAutoFillResultsLegend(oPerWorkbookSettings);
            UpdateDynamicFiltersLegend();
            UpdateAxes(oPerWorkbookSettings);
            }
            catch (Exception oException)
            {
            // If exceptions aren't caught here, Excel consumes them without
            // indicating that anything is wrong.  This can result in the graph
            // controls remaining disabled, among other problems.

            ErrorUtil.OnException(oException);
            }
            finally
            {
            EnableGraphControls(true);
            }

            // Change the button text to indicate that if any of the buttons is
            // clicked again, the graph will be read again.

            tsbReadWorkbook.Text = msiContextReadWorkbook.Text =
            m_oRibbon.ReadWorkbookButtonText =
            "Refresh Graph";
        }
Esempio n. 17
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));
            }
        }
Esempio n. 18
0
        //*************************************************************************
        //  Method: ReadGroupTable()
        //
        /// <summary>
        /// Reads the group table.
        /// </summary>
        ///
        /// <param name="oGroupTable">
        /// The group table.
        /// </param>
        ///
        /// <param name="oReadWorkbookContext">
        /// Provides access to objects needed for converting an Excel workbook to a
        /// NodeXL graph.
        /// </param>
        ///
        /// <returns>
        /// A dictionary.  The key is the group name and the value is a
        /// GroupInformation object for the group.
        /// </returns>
        //*************************************************************************
        protected Dictionary<String, GroupInformation> ReadGroupTable(
            ListObject oGroupTable,
            ReadWorkbookContext oReadWorkbookContext
            )
        {
            Debug.Assert(oGroupTable != null);
            Debug.Assert(oReadWorkbookContext != null);
            AssertValid();

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

            Dictionary<String, GroupInformation> oGroupNameDictionary =
            new Dictionary<String, GroupInformation>();

            ColorConverter2 oColorConverter2 =
            oReadWorkbookContext.ColorConverter2;

            BooleanConverter oBooleanConverter =
            oReadWorkbookContext.BooleanConverter;

            ExcelTableReader oExcelTableReader = new ExcelTableReader(oGroupTable);

            foreach ( ExcelTableReader.ExcelTableRow oRow in
            oExcelTableReader.GetRows() )
            {
            // Get the group information.

            String sGroupName;
            Color oVertexColor;
            VertexShape eVertexShape;

            if (
                !oRow.TryGetNonEmptyStringFromCell(GroupTableColumnNames.Name,
                    out sGroupName)
                ||
                !TryGetColor(oRow, GroupTableColumnNames.VertexColor,
                    oColorConverter2, out oVertexColor)
                ||
                !TryGetVertexShape(oRow, GroupTableColumnNames.VertexShape,
                    out eVertexShape)
                )
            {
                continue;
            }

            Boolean bCollapsed = false;
            Boolean bCollapsedCellValue;

            if (
                TryGetBoolean(oRow, GroupTableColumnNames.Collapsed,
                    oBooleanConverter, out bCollapsedCellValue)
                &&
                bCollapsedCellValue
                )
            {
                bCollapsed = true;
            }

            Int32 iRowIDAsInt32;
            Nullable<Int32> iRowID = null;

            if ( oRow.TryGetInt32FromCell(CommonTableColumnNames.ID,
                out iRowIDAsInt32) )
            {
                iRowID = iRowIDAsInt32;
            }

            GroupInformation oGroupInformation = new GroupInformation(
                sGroupName, iRowID, oVertexColor, eVertexShape, bCollapsed);

            if (oReadWorkbookContext.SaveGroupVertices)
            {
                // ReadGroupVertexTable() will save the group's vertices in
                // this LinkedList.

                oGroupInformation.Vertices = new LinkedList<IVertex>();
            }

            try
            {
                oGroupNameDictionary.Add(sGroupName, oGroupInformation);
            }
            catch (ArgumentException)
            {
                Range oInvalidCell = oRow.GetRangeForCell(
                    GroupTableColumnNames.Name);

                OnWorkbookFormatError( String.Format(

                    "The cell {0} contains a duplicate group name.  There"
                    + " can't be two rows with the same group name."
                    ,
                    ExcelUtil.GetRangeAddress(oInvalidCell)
                    ),

                    oInvalidCell
                );
            }
            }

            return (oGroupNameDictionary);
        }
Esempio n. 19
0
        ReadEdgeTable
        (
            ListObject oEdgeTable,
            ReadWorkbookContext oReadWorkbookContext,
            IGraph oGraph
        )
        {
            Debug.Assert(oEdgeTable != null);
            Debug.Assert(oReadWorkbookContext != null);
            Debug.Assert(oGraph != null);
            AssertValid();

            Boolean bReadAllEdgeAndVertexColumns =
                oReadWorkbookContext.ReadAllEdgeAndVertexColumns;

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

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

            EdgeVisibilityConverter oEdgeVisibilityConverter =
                new EdgeVisibilityConverter();

            Boolean bGraphIsDirected =
                (oGraph.Directedness == GraphDirectedness.Directed);

            ExcelTableReader  oExcelTableReader = new ExcelTableReader(oEdgeTable);
            IVertexCollection oVertices         = oGraph.Vertices;
            IEdgeCollection   oEdges            = oGraph.Edges;

            HashSet <String> oColumnNamesToExclude = new HashSet <String>(
                new String[] {
                EdgeTableColumnNames.Vertex1Name,
                EdgeTableColumnNames.Vertex2Name
            });

            foreach (ExcelTableReader.ExcelTableRow oRow in
                     oExcelTableReader.GetRows())
            {
                // Get the names of the edge's vertices.

                String sVertex1Name, sVertex2Name;

                Boolean bVertex1IsEmpty = !oRow.TryGetNonEmptyStringFromCell(
                    EdgeTableColumnNames.Vertex1Name, out sVertex1Name);

                Boolean bVertex2IsEmpty = !oRow.TryGetNonEmptyStringFromCell(
                    EdgeTableColumnNames.Vertex2Name, out sVertex2Name);

                if (bVertex1IsEmpty && bVertex2IsEmpty)
                {
                    // Skip empty rows.

                    continue;
                }

                if (bVertex1IsEmpty || bVertex2IsEmpty)
                {
                    // A half-empty row is an error.

                    OnHalfEmptyEdgeRow(oRow, bVertex1IsEmpty);
                }

                // Assume a default visibility.

                Visibility eVisibility = Visibility.Show;

                String sVisibility;

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

                if (eVisibility == Visibility.Skip)
                {
                    // Skip the edge an continue to the next edge.

                    continue;
                }

                // Create the specified vertices or retrieve them from the
                // dictionary.

                IVertex oVertex1 = VertexNameToVertex(
                    sVertex1Name, oVertices, oVertexNameDictionary);

                IVertex oVertex2 = VertexNameToVertex(
                    sVertex2Name, oVertices, oVertexNameDictionary);

                // Add an edge connecting the vertices.

                IEdge oEdge = oEdges.Add(oVertex1, oVertex2, bGraphIsDirected);

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

                AddToRowIDDictionary(oRow, oEdge,
                                     oReadWorkbookContext.EdgeRowIDDictionary);

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

                    ReadAllColumns(oExcelTableReader, oRow, oEdge,
                                   oColumnNamesToExclude);

                    continue;
                }

                if (eVisibility == Visibility.Hide)
                {
                    // Hide the edge and continue to the next edge.

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

                    continue;
                }

                // Alpha.

                Boolean bAlphaIsZero = ReadAlpha(oRow, oEdge);

                if (bAlphaIsZero)
                {
                    continue;
                }

                // Color.

                ReadColor(oRow, EdgeTableColumnNames.Color, oEdge,
                          ReservedMetadataKeys.PerColor,
                          oReadWorkbookContext.ColorConverter2);

                // Width.

                ReadWidth(oRow, oReadWorkbookContext.EdgeWidthConverter, oEdge);

                // Style.

                ReadStyle(oRow, oReadWorkbookContext.EdgeStyleConverter, oEdge);

                // Label.

                if (oReadWorkbookContext.ReadEdgeLabels)
                {
                    ReadCellAndSetMetadata(oRow, EdgeTableColumnNames.Label, oEdge,
                                           ReservedMetadataKeys.PerEdgeLabel);
                }

                // Weight.

                if (oReadWorkbookContext.ReadEdgeWeights)
                {
                    ReadEdgeWeight(oRow, oEdge);
                }
            }

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

                oGraph.SetValue(ReservedMetadataKeys.AllEdgeMetadataKeys,
                                FilterColumnNames(oExcelTableReader, oColumnNamesToExclude));
            }
        }
Esempio n. 20
0
        ReadWorkbookInternal
        (
            Microsoft.Office.Interop.Excel.Workbook workbook,
            ReadWorkbookContext readWorkbookContext
        )
        {
            Debug.Assert(readWorkbookContext != null);
            Debug.Assert(workbook != null);
            AssertValid();

            if (readWorkbookContext.PopulateVertexWorksheet)
            {
                // Create and use the object that fills in the vertex worksheet.

                VertexWorksheetPopulator oVertexWorksheetPopulator =
                    new VertexWorksheetPopulator();

                try
                {
                    oVertexWorksheetPopulator.PopulateVertexWorksheet(
                        workbook, false);
                }
                catch (WorkbookFormatException)
                {
                    // Ignore this type of error, which occurs when the vertex
                    // worksheet is missing, for example.
                }
            }

            // Create a graph with the appropriate directedness.

            PerWorkbookSettings oPerWorkbookSettings =
                new PerWorkbookSettings(workbook);

            IGraph oGraph = new Graph(oPerWorkbookSettings.GraphDirectedness);

            // Read the edge worksheet.  This adds data to oGraph,
            // ReadWorkbookContext.VertexNameDictionary, and
            // ReadWorkbookContext.EdgeIDDictionary.

            EdgeWorksheetReader oEdgeWorksheetReader = new EdgeWorksheetReader();

            oEdgeWorksheetReader.ReadWorksheet(workbook, readWorkbookContext,
                                               oGraph);

            oEdgeWorksheetReader = null;

            // Read the vertex worksheet.  This adds metadata to the vertices in
            // oGraph; adds any isolated vertices to oGraph and
            // ReadWorkbookContext.VertexNameDictionary; and removes any skipped
            // vertices (and their incident edges) from
            // ReadWorkbookContext.VertexNameDictionary,
            // ReadWorkbookContext.EdgeIDDictionary, and oGraph.

            VertexWorksheetReader oVertexWorksheetReader =
                new VertexWorksheetReader();

            oVertexWorksheetReader.ReadWorksheet(workbook, readWorkbookContext,
                                                 oGraph);

            oVertexWorksheetReader = null;

            if (readWorkbookContext.ReadAllEdgeAndVertexColumns)
            {
                // The other worksheets should be ignored.

                return(oGraph);
            }

            if (readWorkbookContext.ReadGroups)
            {
                // Read the group worksheets.  This adds metadata to the vertices
                // in oGraph and to oGraph itself.

                GroupWorksheetReader oGroupWorksheetReader =
                    new GroupWorksheetReader();

                oGroupWorksheetReader.ReadWorksheet(workbook,
                                                    readWorkbookContext, oGraph);

                oGroupWorksheetReader = null;
            }

            // Read the per-workbook settings that are stored directly on the
            // graph.

            oPerWorkbookSettings.ReadWorksheet(workbook, readWorkbookContext,
                                               oGraph);

            return(oGraph);
        }
Esempio n. 21
0
        //*************************************************************************
        //  Method: ReadWorksheet()
        //
        /// <summary>
        /// Reads per-workbook settings that are stored directly on an <see
        /// cref="IGraph" /> object.
        /// </summary>
        ///
        /// <param name="workbook">
        /// Workbook containing the graph data.
        /// </param>
        ///
        /// <param name="readWorkbookContext">
        /// Provides access to objects needed for converting an Excel workbook to a
        /// NodeXL graph.
        /// </param>
        ///
        /// <param name="graph">
        /// Graph to add data to.
        /// </param>
        //*************************************************************************
        public void ReadWorksheet(
            Microsoft.Office.Interop.Excel.Workbook workbook,
            ReadWorkbookContext readWorkbookContext,
            IGraph graph
            )
        {
            Debug.Assert(workbook != null);
            Debug.Assert(readWorkbookContext != null);
            Debug.Assert(graph != null);
            AssertValid();

            Nullable<Color> oBackColor = this.BackColor;

            if (oBackColor.HasValue)
            {
            graph.SetValue(ReservedMetadataKeys.GraphBackColor,
                oBackColor.Value);

            // (Note that if there is no per-workbook background color, the
            // GraphDrawer.BackColor property will be used instead.)
            }

            String sBackgroundImageUri = this.BackgroundImageUri;

            if ( !String.IsNullOrEmpty(sBackgroundImageUri) )
            {
            System.Windows.Media.ImageSource oImage = ( new WpfImageUtil() ).
                GetImageSynchronousIgnoreDpi(sBackgroundImageUri);

            graph.SetValue(ReservedMetadataKeys.GraphBackgroundImage, oImage);

            // (Note that if there is no per-workbook background image, no
            // background image will be drawn.)
            }
        }
Esempio n. 22
0
        //*************************************************************************
        //  Method: ExportToNewMatrixWorkbook()
        //
        /// <summary>
        /// Exports the edge table to a new workbook as an adjacency matrix.
        /// </summary>
        ///
        /// <returns>
        /// The new workbook.
        /// </returns>
        ///
        /// <remarks>
        /// If there are no rows in the edge table, or if an error occurs while
        /// exporting the rows, an <see cref="ExportWorkbookException" /> exception
        /// is thrown.
        /// </remarks>
        //*************************************************************************
        public Microsoft.Office.Interop.Excel.Workbook ExportToNewMatrixWorkbook()
        {
            AssertValid();

            // Merge duplicate edges and add an edge weight column.

            ( new DuplicateEdgeMerger() ).MergeDuplicateEdges(m_oWorkbookToExport);

            // Read the workbook, including the edge weight column.

            ReadWorkbookContext oReadWorkbookContext = new ReadWorkbookContext();
            oReadWorkbookContext.ReadEdgeWeights = true;

            IGraph oGraph = ( new WorkbookReader() ).ReadWorkbook(
            m_oWorkbookToExport, oReadWorkbookContext);

            // Get an array of non-isolated vertices.  Isolated vertices don't get
            // exported.

            List<IVertex> oNonIsolatedVertices =
            GraphUtil.GetNonIsolatedVertices(oGraph);

            Int32 iNonIsolatedVertices = oNonIsolatedVertices.Count;

            if (iNonIsolatedVertices == 0)
            {
            throw new ExportWorkbookException(
                "There are no edges to export."
                );
            }

            Workbook oNewWorkbook =
            m_oWorkbookToExport.Application.Workbooks.Add(Missing.Value);

            Worksheet oNewWorksheet = (Worksheet)oNewWorkbook.ActiveSheet;

            // Fill in row 1 and column A with the vertex names, starting at B1 and
            // A2, respectively.

            String [,] asVertexNamesForRow1 = ExcelUtil.GetSingleRow2DStringArray(
            iNonIsolatedVertices);

            String [,] asVertexNamesForColumnA =
            ExcelUtil.GetSingleColumn2DStringArray(iNonIsolatedVertices);

            for (Int32 i = 0; i < iNonIsolatedVertices; i++)
            {
            asVertexNamesForRow1[1, i + 1] = asVertexNamesForColumnA[i + 1, 1]
                = oNonIsolatedVertices[i].Name;
            }

            ExcelUtil.SetRangeValues( (Range)oNewWorksheet.Cells[1, 2],
            asVertexNamesForRow1 );

            ExcelUtil.SetRangeValues( (Range)oNewWorksheet.Cells[2, 1],
            asVertexNamesForColumnA );

            asVertexNamesForRow1 = asVertexNamesForColumnA = null;

            // Now fill in the edge weights, row by row.

            Range oFirstColumnCell = (Range)oNewWorksheet.Cells[2, 2];

            for (Int32 i = 0; i < iNonIsolatedVertices; i++)
            {
            Object [,] aoEdgeWeights = ExcelUtil.GetSingleRow2DArray(
                iNonIsolatedVertices);

            IVertex oVertexI = oNonIsolatedVertices[i];

            for (Int32 j = 0; j < iNonIsolatedVertices; j++)
            {
                aoEdgeWeights[1, j + 1] = EdgeUtil.GetEdgeWeight( oVertexI,
                    oNonIsolatedVertices[j] );
            }

            ExcelUtil.SetRangeValues(oFirstColumnCell, aoEdgeWeights);

            oFirstColumnCell = oFirstColumnCell.get_Offset(1, 0);
            }

            return (oNewWorkbook);
        }
 public void TearDown()
 {
     m_oReadWorkbookContext = null;
 }
Esempio n. 24
0
        //*************************************************************************
        //  Method: ExportToGraphMLFile()
        //
        /// <summary>
        /// Exports the edge and vertex tables to a new GraphML file.
        /// </summary>
        //*************************************************************************
        public void ExportToGraphMLFile()
        {
            AssertValid();

            if (
            !this.ExcelApplicationIsReady(true)
            ||
            !MergeIsApproved(
                "add an Edge Weight column, and export the edges and vertices"
                + " to a new GraphML file.")
            )
            {
            return;
            }

            ReadWorkbookContext oReadWorkbookContext = new ReadWorkbookContext();
            oReadWorkbookContext.ReadAllEdgeAndVertexColumns = true;

            SaveGraphMLFileDialog oSaveGraphMLFileDialog =
            new SaveGraphMLFileDialog(String.Empty, String.Empty);

            ExportToFile(oReadWorkbookContext, oSaveGraphMLFileDialog);
        }
Esempio n. 25
0
        //*************************************************************************
        //  Method: ReadGroupVertexTable()
        //
        /// <summary>
        /// Reads the group vertex table.
        /// </summary>
        ///
        /// <param name="oGroupVertexTable">
        /// The group vertex table.
        /// </param>
        ///
        /// <param name="oReadWorkbookContext">
        /// Provides access to objects needed for converting an Excel workbook to a
        /// NodeXL graph.
        /// </param>
        ///
        /// <param name="oGroupNameDictionary">
        /// The key is the group name and the value is the GroupInformation object
        /// for the group.
        /// </param>
        ///
        /// <param name="oGraph">
        /// Graph to add group data to.
        /// </param>
        //*************************************************************************
        protected void ReadGroupVertexTable(
            ListObject oGroupVertexTable,
            ReadWorkbookContext oReadWorkbookContext,
            Dictionary<String, GroupInformation> oGroupNameDictionary,
            IGraph oGraph
            )
        {
            Debug.Assert(oGroupVertexTable != null);
            Debug.Assert(oReadWorkbookContext != null);
            Debug.Assert(oGroupNameDictionary != null);
            Debug.Assert(oGraph != null);
            AssertValid();

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

            ExcelTableReader oExcelTableReader =
            new ExcelTableReader(oGroupVertexTable);

            foreach ( ExcelTableReader.ExcelTableRow oRow in
            oExcelTableReader.GetRows() )
            {
            // Get the group vertex information from the row.

            String sGroupName, sVertexName;

            if (
                !oRow.TryGetNonEmptyStringFromCell(
                    GroupVertexTableColumnNames.GroupName, out sGroupName)
                ||
                !oRow.TryGetNonEmptyStringFromCell(
                    GroupVertexTableColumnNames.VertexName, out sVertexName)
                )
            {
                continue;
            }

            // Get the group information for the vertex and store the group
            // information in the vertex.

            GroupInformation oGroupInformation;
            IVertex oVertex;

            if (
                !oGroupNameDictionary.TryGetValue(sGroupName,
                    out oGroupInformation)
                ||
                !oVertexNameDictionary.TryGetValue(sVertexName,
                    out oVertex)
                )
            {
                continue;
            }

            oVertex.SetValue(ReservedMetadataKeys.PerColor,
                oGroupInformation.VertexColor);

            oVertex.SetValue(ReservedMetadataKeys.PerVertexShape,
                oGroupInformation.VertexShape);

            if (oReadWorkbookContext.SaveGroupVertices)
            {
                Debug.Assert(oGroupInformation.Vertices != null);

                oGroupInformation.Vertices.Add(oVertex);
            }
            }
        }
Esempio n. 26
0
        ReadGroupTable
        (
            ListObject oGroupTable,
            ReadWorkbookContext oReadWorkbookContext
        )
        {
            Debug.Assert(oGroupTable != null);
            Debug.Assert(oReadWorkbookContext != null);
            AssertValid();

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

            Dictionary <String, GroupInformation> oGroupNameDictionary =
                new Dictionary <String, GroupInformation>();

            ColorConverter2 oColorConverter2 =
                oReadWorkbookContext.ColorConverter2;

            BooleanConverter oBooleanConverter =
                oReadWorkbookContext.BooleanConverter;

            ExcelTableReader oExcelTableReader = new ExcelTableReader(oGroupTable);

            foreach (ExcelTableReader.ExcelTableRow oRow in
                     oExcelTableReader.GetRows())
            {
                // Get the group information.

                String      sGroupName;
                Color       oVertexColor;
                VertexShape eVertexShape;

                if (
                    !oRow.TryGetNonEmptyStringFromCell(GroupTableColumnNames.Name,
                                                       out sGroupName)
                    ||
                    !TryGetColor(oRow, GroupTableColumnNames.VertexColor,
                                 oColorConverter2, out oVertexColor)
                    ||
                    !TryGetVertexShape(oRow, GroupTableColumnNames.VertexShape,
                                       out eVertexShape)
                    )
                {
                    continue;
                }

                Boolean bCollapsed = false;
                Boolean bCollapsedCellValue;

                if (
                    TryGetBoolean(oRow, GroupTableColumnNames.Collapsed,
                                  oBooleanConverter, out bCollapsedCellValue)
                    &&
                    bCollapsedCellValue
                    )
                {
                    bCollapsed = true;
                }

                Int32            iRowIDAsInt32;
                Nullable <Int32> iRowID = null;

                if (oRow.TryGetInt32FromCell(CommonTableColumnNames.ID,
                                             out iRowIDAsInt32))
                {
                    iRowID = iRowIDAsInt32;
                }

                GroupInformation oGroupInformation = new GroupInformation(
                    sGroupName, iRowID, oVertexColor, eVertexShape, bCollapsed);

                if (oReadWorkbookContext.SaveGroupVertices)
                {
                    // ReadGroupVertexTable() will save the group's vertices in
                    // this LinkedList.

                    oGroupInformation.Vertices = new LinkedList <IVertex>();
                }

                try
                {
                    oGroupNameDictionary.Add(sGroupName, oGroupInformation);
                }
                catch (ArgumentException)
                {
                    Range oInvalidCell = oRow.GetRangeForCell(
                        GroupTableColumnNames.Name);

                    OnWorkbookFormatError(String.Format(

                                              "The cell {0} contains a duplicate group name.  There"
                                              + " can't be two rows with the same group name."
                                              ,
                                              ExcelUtil.GetRangeAddress(oInvalidCell)
                                              ),

                                          oInvalidCell
                                          );
                }
            }

            return(oGroupNameDictionary);
        }
Esempio n. 27
0
        //*************************************************************************
        //  Method: ExportToUcinetFile()
        //
        /// <summary>
        /// Exports the edge and vertex tables to a new UCINET full matrix DL file.
        /// </summary>
        //*************************************************************************
        public void ExportToUcinetFile()
        {
            AssertValid();

            if (
            !this.ExcelApplicationIsReady(true)
            ||
            !MergeIsApproved(
                "add an Edge Weight column, and export the edges to a new"
                + " UCINET full matrix DL file.")
            )
            {
            return;
            }

            ReadWorkbookContext oReadWorkbookContext = new ReadWorkbookContext();
            oReadWorkbookContext.ReadEdgeWeights = true;

            SaveUcinetFileDialog oSaveUcinetFileDialog =
            new SaveUcinetFileDialog(String.Empty, String.Empty);

            ExportToFile(oReadWorkbookContext, oSaveUcinetFileDialog);
        }
Esempio n. 28
0
        //*************************************************************************
        //  Method: ExportToFile()
        //
        /// <summary>
        /// Merges duplicate edges and exports the edge and vertex tables to a file
        /// using a provided dialog.
        /// </summary>
        ///
        /// <param name="oReadWorkbookContext">
        /// Provides access to objects needed for converting an Excel workbook to a
        /// NodeXL graph.
        /// </param>
        ///
        /// <param name="oSaveGraphFileDialog">
        /// The dialog to use to save the graph.
        /// </param>
        //*************************************************************************
        private void ExportToFile(
            ReadWorkbookContext oReadWorkbookContext,
            SaveGraphFileDialog oSaveGraphFileDialog
            )
        {
            Debug.Assert(oReadWorkbookContext != null);
            Debug.Assert(oSaveGraphFileDialog != null);
            AssertValid();

            WorkbookReader oWorkbookReader = new WorkbookReader();

            ShowWaitCursor = true;
            this.ScreenUpdating = false;

            try
            {
            ( new DuplicateEdgeMerger() ).MergeDuplicateEdges(
                this.InnerObject);

            this.ScreenUpdating = true;

            // Read the workbook and let the user save it.

            IGraph oGraph = oWorkbookReader.ReadWorkbook(
                this.InnerObject, oReadWorkbookContext);

            oSaveGraphFileDialog.ShowDialogAndSaveGraph(oGraph);
            }
            catch (Exception oException)
            {
            this.ScreenUpdating = true;
            ErrorUtil.OnException(oException);
            }
            finally
            {
            this.ScreenUpdating = true;
            ShowWaitCursor = false;
            }
        }
Esempio n. 29
0
        //*************************************************************************
        //  Method: ReadWorkbookInternal()
        //
        /// <summary>
        /// Creates a NodeXL graph from the contents of an Excel workbook.
        /// </summary>
        ///
        /// <param name="workbook">
        /// Workbook containing the graph data.
        /// </param>
        ///
        /// <param name="readWorkbookContext">
        /// Provides access to objects needed for converting an Excel workbook to a
        /// NodeXL graph.
        /// </param>
        ///
        /// <returns>
        /// A new graph.
        /// </returns>
        ///
        /// <remarks>
        /// If <paramref name="workbook" /> contains valid graph data, a new <see
        /// cref="IGraph" /> is created from the workbook contents and returned.
        /// Otherwise, a <see cref="WorkbookFormatException" /> is thrown.
        /// </remarks>
        //*************************************************************************
        protected IGraph ReadWorkbookInternal(
            Microsoft.Office.Interop.Excel.Workbook workbook,
            ReadWorkbookContext readWorkbookContext
            )
        {
            Debug.Assert(readWorkbookContext != null);
            Debug.Assert(workbook != null);
            AssertValid();

            if (readWorkbookContext.PopulateVertexWorksheet)
            {
            // Create and use the object that fills in the vertex worksheet.

            VertexWorksheetPopulator oVertexWorksheetPopulator =
                new VertexWorksheetPopulator();

            try
            {
                oVertexWorksheetPopulator.PopulateVertexWorksheet(
                    workbook, false);
            }
            catch (WorkbookFormatException)
            {
                // Ignore this type of error, which occurs when the vertex
                // worksheet is missing, for example.
            }
            }

            // Create a graph with the appropriate directedness.

            PerWorkbookSettings oPerWorkbookSettings =
            new PerWorkbookSettings(workbook);

            IGraph oGraph = new Graph(oPerWorkbookSettings.GraphDirectedness);

            // Read the edge worksheet.  This adds data to oGraph,
            // ReadWorkbookContext.VertexNameDictionary, and
            // ReadWorkbookContext.EdgeIDDictionary.

            EdgeWorksheetReader oEdgeWorksheetReader = new EdgeWorksheetReader();

            oEdgeWorksheetReader.ReadWorksheet(workbook, readWorkbookContext,
            oGraph);

            oEdgeWorksheetReader = null;

            // Read the vertex worksheet.  This adds metadata to the vertices in
            // oGraph; adds any isolated vertices to oGraph and
            // ReadWorkbookContext.VertexNameDictionary; and removes any skipped
            // vertices (and their incident edges) from
            // ReadWorkbookContext.VertexNameDictionary,
            // ReadWorkbookContext.EdgeIDDictionary, and oGraph.

            VertexWorksheetReader oVertexWorksheetReader =
            new VertexWorksheetReader();

            oVertexWorksheetReader.ReadWorksheet(workbook, readWorkbookContext,
            oGraph);

            oVertexWorksheetReader = null;

            if (readWorkbookContext.ReadAllEdgeAndVertexColumns)
            {
            // The other worksheets should be ignored.

            return (oGraph);
            }

            if (readWorkbookContext.ReadGroups)
            {
            // Read the group worksheets.  This adds metadata to the vertices
            // in oGraph and to oGraph itself.

            GroupWorksheetReader oGroupWorksheetReader =
                new GroupWorksheetReader();

            oGroupWorksheetReader.ReadWorksheet(workbook,
                readWorkbookContext, oGraph);

            oGroupWorksheetReader = null;
            }

            // Read the per-workbook settings that are stored directly on the
            // graph.

            oPerWorkbookSettings.ReadWorksheet(workbook, readWorkbookContext,
            oGraph);

            return (oGraph);
        }
        //*************************************************************************
        //  Method: ReadWorkbook()
        //
        /// <summary>
        /// Reads a workbook into a new graph.
        /// </summary>
        ///
        /// <param name="oWorkbook">
        /// The workbook to read.
        /// </param>
        ///
        /// <returns>
        /// The new graph.
        /// </returns>
        //*************************************************************************
        protected IGraph ReadWorkbook(
            Microsoft.Office.Interop.Excel.Workbook oWorkbook
            )
        {
            Debug.Assert(oWorkbook != null);
            AssertValid();

            ReadWorkbookContext oReadWorkbookContext = new ReadWorkbookContext();

            WorkbookReader oWorkbookReader = new WorkbookReader();

            // Convert the workbook contents to a Graph object.

            return ( oWorkbookReader.ReadWorkbook(
            oWorkbook, oReadWorkbookContext) );
        }
 //*************************************************************************
 //  Constructor: ReadWorkbookContextTest()
 //
 /// <summary>
 /// Initializes a new instance of the <see
 /// cref="ReadWorkbookContextTest" /> class.
 /// </summary>
 //*************************************************************************
 public ReadWorkbookContextTest()
 {
     m_oReadWorkbookContext = null;
 }
Esempio n. 32
0
        ReadWorksheet
        (
            Microsoft.Office.Interop.Excel.Workbook workbook,
            ReadWorkbookContext readWorkbookContext,
            IGraph graph
        )
        {
            Debug.Assert(workbook != null);
            Debug.Assert(readWorkbookContext != null);
            Debug.Assert(graph != null);
            AssertValid();

            // Attempt to get the optional table that contains vertex data.

            ListObject oVertexTable;

            if (ExcelUtil.TryGetTable(workbook, WorksheetNames.Vertices,
                                      TableNames.Vertices, out oVertexTable))
            {
                // The code that reads the table can handle hidden rows, but not
                // hidden columns.  Temporarily show all hidden columns in the
                // table.

                ExcelHiddenColumns oHiddenColumns =
                    ExcelColumnHider.ShowHiddenColumns(oVertexTable);

                Boolean bLayoutOrderSet, bToolTipSet;

                try
                {
                    ReadVertexTable(oVertexTable, readWorkbookContext, graph,
                                    out bLayoutOrderSet, out bToolTipSet);
                }
                finally
                {
                    ExcelColumnHider.RestoreHiddenColumns(oVertexTable,
                                                          oHiddenColumns);
                }

                if (bLayoutOrderSet)
                {
                    // The layout order was specified for at least one vertex.
                    // The ByMetadataVertexSorter used by SortableLayoutBase
                    // requires that if layout order is set on one vertex, it must
                    // be set on all vertices.  This isn't required in the Excel
                    // template, though, so set a default layout order for each
                    // vertex that doesn't already specify one.

                    SetUnsetVertexOrders(graph);

                    // The layout order is ignored unless this key is added to the
                    // graph.

                    graph.SetValue(
                        ReservedMetadataKeys.SortableLayoutOrderSet, null);
                }

                if (bToolTipSet)
                {
                    graph.SetValue(ReservedMetadataKeys.ToolTipSet, null);
                }
            }
        }
Esempio n. 33
0
        ExportToNewMatrixWorkbook()
        {
            AssertValid();

            // Merge duplicate edges and add an edge weight column.

            (new DuplicateEdgeMerger()).MergeDuplicateEdges(m_oWorkbookToExport);

            // Read the workbook, including the edge weight column.

            ReadWorkbookContext oReadWorkbookContext = new ReadWorkbookContext();

            oReadWorkbookContext.ReadEdgeWeights = true;

            IGraph oGraph = (new WorkbookReader()).ReadWorkbook(
                m_oWorkbookToExport, oReadWorkbookContext);

            // Get an array of non-isolated vertices.  Isolated vertices don't get
            // exported.

            List <IVertex> oNonIsolatedVertices =
                GraphUtil.GetNonIsolatedVertices(oGraph);

            Int32 iNonIsolatedVertices = oNonIsolatedVertices.Count;

            if (iNonIsolatedVertices == 0)
            {
                throw new ExportWorkbookException(
                          "There are no edges to export."
                          );
            }

            Workbook oNewWorkbook =
                m_oWorkbookToExport.Application.Workbooks.Add(Missing.Value);

            Worksheet oNewWorksheet = (Worksheet)oNewWorkbook.ActiveSheet;

            // Fill in row 1 and column A with the vertex names, starting at B1 and
            // A2, respectively.

            String [,] asVertexNamesForRow1 = ExcelUtil.GetSingleRow2DStringArray(
                iNonIsolatedVertices);

            String [,] asVertexNamesForColumnA =
                ExcelUtil.GetSingleColumn2DStringArray(iNonIsolatedVertices);

            for (Int32 i = 0; i < iNonIsolatedVertices; i++)
            {
                asVertexNamesForRow1[1, i + 1]             = asVertexNamesForColumnA[i + 1, 1]
                                                           = oNonIsolatedVertices[i].Name;
            }

            ExcelUtil.SetRangeValues((Range)oNewWorksheet.Cells[1, 2],
                                     asVertexNamesForRow1);

            ExcelUtil.SetRangeValues((Range)oNewWorksheet.Cells[2, 1],
                                     asVertexNamesForColumnA);

            asVertexNamesForRow1 = asVertexNamesForColumnA = null;

            // Now fill in the edge weights, row by row.

            Range oFirstColumnCell = (Range)oNewWorksheet.Cells[2, 2];

            for (Int32 i = 0; i < iNonIsolatedVertices; i++)
            {
                Object [,] aoEdgeWeights = ExcelUtil.GetSingleRow2DArray(
                    iNonIsolatedVertices);

                IVertex oVertexI = oNonIsolatedVertices[i];

                for (Int32 j = 0; j < iNonIsolatedVertices; j++)
                {
                    aoEdgeWeights[1, j + 1] = EdgeUtil.GetEdgeWeight(oVertexI,
                                                                     oNonIsolatedVertices[j]);
                }

                ExcelUtil.SetRangeValues(oFirstColumnCell, aoEdgeWeights);

                oFirstColumnCell = oFirstColumnCell.get_Offset(1, 0);
            }

            return(oNewWorkbook);
        }
Esempio n. 34
0
        //*************************************************************************
        //  Method: ReadWorksheet()
        //
        /// <summary>
        /// Reads the group worksheets and adds the contents to a graph.
        /// </summary>
        ///
        /// <param name="workbook">
        /// Workbook containing the graph data.
        /// </param>
        ///
        /// <param name="readWorkbookContext">
        /// Provides access to objects needed for converting an Excel workbook to a
        /// NodeXL graph.
        /// </param>
        ///
        /// <param name="graph">
        /// Graph to add group data to.
        /// </param>
        ///
        /// <remarks>
        /// If the group worksheets in <paramref name="workbook" /> contain valid
        /// group data, the data is added to <paramref name="graph" />.  Otherwise,
        /// a <see cref="WorkbookFormatException" /> is thrown.
        /// </remarks>
        //*************************************************************************
        public void ReadWorksheet(
            Microsoft.Office.Interop.Excel.Workbook workbook,
            ReadWorkbookContext readWorkbookContext,
            IGraph graph
            )
        {
            Debug.Assert(workbook != null);
            Debug.Assert(readWorkbookContext != null);
            Debug.Assert(graph != null);
            AssertValid();

            // Attempt to get the optional tables that contain group data.

            ListObject oGroupTable, oGroupVertexTable;

            if (
            ExcelUtil.TryGetTable(workbook, WorksheetNames.Groups,
                TableNames.Groups, out oGroupTable)
            &&
            ExcelUtil.TryGetTable(workbook, WorksheetNames.GroupVertices,
                TableNames.GroupVertices, out oGroupVertexTable)
            )
            {
            // The code that reads the tables can handle hidden rows, but not
            // hidden columns.  Temporarily show all hidden columns in the
            // table.

            ExcelHiddenColumns oHiddenGroupColumns =
                ExcelColumnHider.ShowHiddenColumns(oGroupTable);

            ExcelHiddenColumns oHiddenGroupVertexColumns =
                ExcelColumnHider.ShowHiddenColumns(oGroupVertexTable);

            try
            {
                ReadGroupTables(oGroupTable, oGroupVertexTable,
                    readWorkbookContext, graph);
            }
            finally
            {
                ExcelColumnHider.RestoreHiddenColumns(oGroupTable,
                    oHiddenGroupColumns);

                ExcelColumnHider.RestoreHiddenColumns(oGroupVertexTable,
                    oHiddenGroupVertexColumns);
            }
            }
        }
Esempio n. 35
0
        //*************************************************************************
        //  Method: ReadVertexTable()
        //
        /// <summary>
        /// Reads the vertex table and adds the contents to a graph.
        /// </summary>
        ///
        /// <param name="oVertexTable">
        /// Table that contains the vertex data.
        /// </param>
        ///
        /// <param name="oReadWorkbookContext">
        /// Provides access to objects needed for converting an Excel workbook to a
        /// NodeXL graph.
        /// </param>
        ///
        /// <param name="oGraph">
        /// Graph to add vertices to.
        /// </param>
        ///
        /// <param name="bLayoutOrderSet">
        /// Gets set to true if a vertex layout order was specified for at least
        /// one vertex, or false otherwise.
        /// </param>
        ///
        /// <param name="bToolTipSet">
        /// Gets set to true if a tooltip was specified for at least one vertex, or
        /// false otherwise.
        /// </param>
        //*************************************************************************
        protected void 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) );
            }
        }
Esempio n. 36
0
        //*************************************************************************
        //  Method: ReadGroupTables()
        //
        /// <summary>
        /// Reads the group tables and add the contents to a graph.
        /// </summary>
        ///
        /// <param name="oGroupTable">
        /// Table that contains the group data.
        /// </param>
        ///
        /// <param name="oGroupVertexTable">
        /// Table that contains the group vertex data.
        /// </param>
        ///
        /// <param name="oReadWorkbookContext">
        /// Provides access to objects needed for converting an Excel workbook to a
        /// NodeXL graph.
        /// </param>
        ///
        /// <param name="oGraph">
        /// Graph to add group data to.
        /// </param>
        //*************************************************************************
        protected void ReadGroupTables(
            ListObject oGroupTable,
            ListObject oGroupVertexTable,
            ReadWorkbookContext oReadWorkbookContext,
            IGraph oGraph
            )
        {
            Debug.Assert(oGroupTable != null);
            Debug.Assert(oGroupVertexTable != null);
            Debug.Assert(oReadWorkbookContext != null);
            Debug.Assert(oGraph != null);
            AssertValid();

            // If a required column is missing, do nothing.

            ListColumn oColumn;

            if (
            !ExcelUtil.TryGetTableColumn(oGroupTable,
                GroupTableColumnNames.Name, out oColumn)
            ||
            !ExcelUtil.TryGetTableColumn(oGroupTable,
                GroupTableColumnNames.VertexColor, out oColumn)
            ||
            !ExcelUtil.TryGetTableColumn(oGroupTable,
                GroupTableColumnNames.VertexShape, out oColumn)
            ||
            !ExcelUtil.TryGetTableColumn(oGroupVertexTable,
                GroupVertexTableColumnNames.GroupName, out oColumn)
            ||
            !ExcelUtil.TryGetTableColumn(oGroupVertexTable,
                GroupVertexTableColumnNames.VertexName, out oColumn)
            )
            {
            return;
            }

            // Create a dictionary from the group table.  The key is the group name
            // and the value is a GroupInformation object for the group.

            Dictionary<String, GroupInformation> oGroupNameDictionary =
            ReadGroupTable(oGroupTable, oReadWorkbookContext);

            // Read the group vertex table and set the color and shape of each
            // group vertex in the graph.

            ReadGroupVertexTable(oGroupVertexTable, oReadWorkbookContext,
            oGroupNameDictionary, oGraph);

            // Save the group information on the graph.

            Debug.Assert( oGroupNameDictionary.Values is
            ICollection<GroupInformation> );

            oGraph.SetValue(ReservedMetadataKeys.GroupInformation,
            oGroupNameDictionary.Values);
        }
Esempio n. 37
0
        //*************************************************************************
        //  Method: ReadWorksheet()
        //
        /// <summary>
        /// Reads the vertex worksheet and adds the contents to a graph.
        /// </summary>
        ///
        /// <param name="workbook">
        /// Workbook containing the graph data.
        /// </param>
        ///
        /// <param name="readWorkbookContext">
        /// Provides access to objects needed for converting an Excel workbook to a
        /// NodeXL graph.
        /// </param>
        ///
        ///
        /// <param name="graph">
        /// Graph to add vertex data to.
        /// </param>
        ///
        /// <remarks>
        /// If the vertex worksheet in <paramref name="workbook" /> contains valid
        /// vertex data, the vertices in <paramref name="graph" /> are marked with
        /// metadata; any isolated vertices are added to <paramref
        /// name="graph" /> and <paramref
        /// name="readWorkbookContext" />.VertexNameDictionary; and any
        /// skipped vertices (and their incident edges) are removed from <paramref
        /// name="graph" />, <paramref
        /// name="readWorkbookContext" />.VertexNameDictionary, and
        /// <paramref name="readWorkbookContext" />.EdgeRowIDDictionary.
        /// Otherwise, a <see cref="WorkbookFormatException" /> is thrown.
        /// </remarks>
        //*************************************************************************
        public void ReadWorksheet(
            Microsoft.Office.Interop.Excel.Workbook workbook,
            ReadWorkbookContext readWorkbookContext,
            IGraph graph
            )
        {
            Debug.Assert(workbook != null);
            Debug.Assert(readWorkbookContext != null);
            Debug.Assert(graph != null);
            AssertValid();

            // Attempt to get the optional table that contains vertex data.

            ListObject oVertexTable;

            if ( ExcelUtil.TryGetTable(workbook, WorksheetNames.Vertices,
            TableNames.Vertices, out oVertexTable) )
            {
            // The code that reads the table can handle hidden rows, but not
            // hidden columns.  Temporarily show all hidden columns in the
            // table.

            ExcelHiddenColumns oHiddenColumns =
                ExcelColumnHider.ShowHiddenColumns(oVertexTable);

            Boolean bLayoutOrderSet, bToolTipSet;

            try
            {
                ReadVertexTable(oVertexTable, readWorkbookContext, graph,
                    out bLayoutOrderSet, out bToolTipSet);
            }
            finally
            {
                ExcelColumnHider.RestoreHiddenColumns(oVertexTable,
                    oHiddenColumns);
            }

            if (bLayoutOrderSet)
            {
                // The layout order was specified for at least one vertex.
                // The ByMetadataVertexSorter used by SortableLayoutBase
                // requires that if layout order is set on one vertex, it must
                // be set on all vertices.  This isn't required in the Excel
                // template, though, so set a default layout order for each
                // vertex that doesn't already specify one.

                SetUnsetVertexOrders(graph);

                // The layout order is ignored unless this key is added to the
                // graph.

                graph.SetValue(
                    ReservedMetadataKeys.SortableLayoutOrderSet, null);
            }

            if (bToolTipSet)
            {
                graph.SetValue(ReservedMetadataKeys.ToolTipSet, null);
            }
            }
        }
        //*************************************************************************
        //  Method: ReadWorkbook()
        //
        /// <summary>
        /// Reads the workbook contents into a NodeXL graph.
        /// </summary>
        ///
        /// <param name="oWorkbook">
        /// Workbook containing the graph contents.
        /// </param>
        ///
        /// <param name="oGraphMetricUserSettings">
        /// User settings for calculating graph metrics.
        /// </param>
        ///
        /// <returns>
        /// The <see cref="IGraph" /> read from the workbook.
        /// </returns>
        ///
        /// <remarks>
        /// If <paramref name="oWorkbook" /> contains valid graph data, a new <see
        /// cref="IGraph" /> is created from the workbook contents and returned.
        /// Otherwise, a <see cref="WorkbookFormatException" /> is thrown.
        /// </remarks>
        //*************************************************************************
        protected IGraph ReadWorkbook(
            Microsoft.Office.Interop.Excel.Workbook oWorkbook,
            GraphMetricUserSettings oGraphMetricUserSettings
            )
        {
            Debug.Assert(oWorkbook != null);
            Debug.Assert(oGraphMetricUserSettings != null);
            AssertValid();

            ReadWorkbookContext oReadWorkbookContext = new ReadWorkbookContext();
            oReadWorkbookContext.FillIDColumns = true;
            oReadWorkbookContext.PopulateVertexWorksheet = true;

            if ( (oGraphMetricUserSettings.GraphMetricsToCalculate &
            GraphMetrics.GroupMetrics) != 0)
            {
            oReadWorkbookContext.ReadGroups = true;
            oReadWorkbookContext.SaveGroupVertices = true;
            }

            WorkbookReader oWorkbookReader = new WorkbookReader();

            return ( oWorkbookReader.ReadWorkbook(
            oWorkbook, oReadWorkbookContext) );
        }
Esempio n. 39
0
        //*************************************************************************
        //  Method: ExportToPajekFile()
        //
        /// <summary>
        /// Exports the edge and vertex tables to a new Pajek text file.
        /// </summary>
        //*************************************************************************
        public void ExportToPajekFile()
        {
            AssertValid();

            if (
            !this.ExcelApplicationIsReady(true)
            ||
            !MergeIsApproved(
                "add an Edge Weight column, and export the edges and vertices"
                + " to a new Pajek file.")
            )
            {
            return;
            }

            ReadWorkbookContext oReadWorkbookContext = new ReadWorkbookContext();
            oReadWorkbookContext.ReadEdgeWeights = true;

            // Map any vertex coordinates stored in the workbook to an arbitrary
            // rectangle.  PajekGraphAdapter will in turn map these to Pajek
            // coordinates.

            oReadWorkbookContext.IgnoreVertexLocations = false;

            oReadWorkbookContext.GraphRectangle =
            new System.Drawing.Rectangle(0, 0, 10000, 10000);

            SavePajekFileDialog oSavePajekFileDialog =
            new SavePajekFileDialog(String.Empty, String.Empty);

            ExportToFile(oReadWorkbookContext, oSavePajekFileDialog);
        }