Through the Interface

Stripping formatting from AutoCAD tables pasted from Excel using .NET

I’m back in San Rafael after a tiring – but very rewarding – two days down in Santa Cruz. I’ve decided to rattle out a quick post – inspired by this recent comment – before heading out for dinner, so I hope my brain isn’t playing tricks on me when it says the code’s good enough to post. Please do let me know if you see anything wrong with it.

Here’s the question:

Kean, I am wondering how to do this on table objects. When importing a table from excel as pasting special ACAD objects, you can reset the table overrides, but this does not reset the cell content. You manually have to go through each cell to reset the formatting of the content. I have written an app that iterates through the selected table's rows/columns and gets the content in an attempt to use the text editor to reset the content of each cell. However, the texteditor.create only allows for MTEXT in which the table content is not MTEXT. I've looked on your other blog posts on tables and don't see a way to do this. Please help if you can. Thanks. Steve

When we run the PASTESPEC command – with some Excel data in the clipboard – and choose to insert “AutoCAD entities”, we get an AutoCAD table containing formatted text that shows up as black:

If we look at the contents of a particular cell, we see it has embedded formatting codes, such as this: "{\\fCalibri|b0|i0|c0;\\c0;A"

To remove this formatting, I adopted the technique suggested by Tony Tanzillo in an earlier comment on that post – and that I’ve looked at in some depth in this other post – to get at each cell’s unformatted contents. The code uses an MText object to strip off the formatting rather than the MText editor.

Here’s the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

 

namespace TableFormatting

{

  public class Commands

  {

    [CommandMethod("STF")]

    public static void StripTableFormatting()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      // Ask the user to select a table

 

      var peo = new PromptEntityOptions("\nSelect table");

      peo.SetRejectMessage("\nMust be a table.");

      peo.AddAllowedClass(typeof(Table), false);

      peo.AllowNone = false;

      var per = ed.GetEntity(peo);

      if (per.Status != PromptStatus.OK)

        return;

 

      var tabId = per.ObjectId;

 

      using (var tr = doc.TransactionManager.StartTransaction())

      {

        // Open the table for write

 

        var tab = tr.GetObject(tabId, OpenMode.ForWrite) as Table;

        if (tab == null)

          return;

 

        // Start by clearing any style overrides

 

        tab.Cells.ClearStyleOverrides();

 

        // We'll use an MText object to strip embedded formatting

 

        using (var mt = new MText())

        {

          for (int r = 0; r < tab.Rows.Count; r++)

          {

            for (int c = 0; c < tab.Columns.Count; c++)

            {

              // Get the cell and its contents

 

              var cell = tab.Cells[r, c];

              mt.Contents = cell.TextString;

 

              // Explode the text fragments

 

              mt.ExplodeFragments(

                (a, b) =>

                {

                  if (a != null)

                  {

                    // Assuming we have a fragment, use its text

                    // to set the cell contents

 

                    cell.TextString = a.Text;

                  }

                  return MTextFragmentCallbackStatus.Continue;

                }

              );

            }

          }

        }

        tr.Commit();

      }

    }

  }

}

Sure enough, we can run the STF command and select our table to strip away its formatting:

Handling protocol changes to AutoCAD’s table in .NET

This question came up, from our friends over at The Swamp:

I have been re-building some old code  in VS2010 using the 2012 ObjectARX SDK and came across some
     'blablabla is obsolete: use thingy instead' warnings.

The code still compiles and runs fine but I want to start thinking about the future.

a few examples will follow, please add any others you come across.

[…]

The next was to do with the Table Class
i.e.  Autodesk.AutoCAD.DatabaseServices.Table

In fact, there are a myriad of obsolete warnings in the Table class  ... some of them appear to have no documented resolution, some appear to not work using the suggested resolution.

As Kerry said, further down the thread, he felt it was time to “phone a friend”, which I assume (or hope) means me (although he did email rather than phone me :-). In looking into this, I had some help from Stephen Preston (who pointed me at some information previously provided by Philippe Leefsma and Balaji Ramamoorthy, which helped a great deal).

Let’s focus on the changes to the Table protocol that now (and I’m not sure when exactly it changed – perhaps in AutoCAD 2009?) results in warnings in posts such as this one.

To illustrate some of the main changes in the Table API, I’ve created some C# code that creates two identical tables, one using the old approach and one using the newer, non-deprecated protocol:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.Runtime;

using System;

 

namespace TableCreation

{

  public class Commands

  {

    [CommandMethod("TWOTABLES")]

    public void CreateTwoTables()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

 

      Transaction tr =

        doc.TransactionManager.StartTransaction();

 

      using (tr)

      {

        // Set some constants that we'll use to create our tables

 

        const int numRows = 7;

        const int numCols = 5;

        const double rowHeight = 3;

        const double colWidth = 3;

        const double horMarg = 0.5;

        const double verMarg = 0.8;

        const double txtHeight = 1;

 

        // We'll add our tables to the current space

 

        BlockTableRecord btr =

          (BlockTableRecord)tr.GetObject(

            db.CurrentSpaceId,

            OpenMode.ForWrite

          );

 

        // We'll use scoping to let us use the same variable

        // name(s) for both tables we're creating

 

        {

          // Create a table with the old protocol

 

          Table tb = new Table();

          tb.TableStyle = db.Tablestyle;

 

          // Resize the table, adding rows and columns

 

          tb.NumRows = numRows;

          tb.NumColumns = numCols;

 

          // Set the column width and row height

 

          tb.SetColumnWidth(colWidth);

          tb.SetRowHeight(rowHeight);

 

          // Set the horizontal and vertical margins

 

          tb.HorizontalCellMargin = horMarg;

          tb.VerticalCellMargin = verMarg;

 

          // Make sure the header and title rows are visible

 

          tb.IsHeaderSuppressed = false;

          tb.IsTitleSuppressed = false;

 

          // Set the title string

 

          tb.SetTextString(0, 0, "Old Table");

 

          // Set the text height for the full table: value of 7

          // is bit-encoded Data (1), Title (2) and Header (4)

 

          tb.SetTextHeight(txtHeight, 7);

 

          // Populate the contents of the header and data sections

 

          int n = 0;

          for (int i = 1; i < numRows; i++)

          {

            for (int j = 0; j < numCols; j++)

            {

              // Contents is A-E for the header an 0-n for the data

 

              string contents =

                (i == 1 ?

                  Convert.ToChar(

                    Convert.ToInt16('A') + j

                  ).ToString() :

                  n++.ToString()

                );

 

              tb.SetTextString(i, j, contents);

            }

          }

 

          tb.GenerateLayout();

 

          btr.AppendEntity(tb);

          tr.AddNewlyCreatedDBObject(tb, true);

        }

 

        {

          // Create a table with the new protocol

 

          Table tb = new Table();

          tb.TableStyle = db.Tablestyle;

 

          // Set the height and width of the initial row and

          // column belonging by default to the blank Table

 

          tb.Rows[0].Height = rowHeight;

          tb.Columns[0].Width = colWidth;

 

          // Add the remaining rows and columns

 

          tb.InsertRows(1, rowHeight, numRows - 1);

          tb.InsertColumns(1, colWidth, numCols - 1);

 

          // To query the number of rows and columns...

          //

          // int nRows = tb.Rows.Count;

          // int nCols = tb.Columns.Count;

 

          // To "suppress" the title and header, find the row

          // with a style of "Title" or "Header" and set it to ""

 

          tb.Cells[0, -1].Style = "Title";

          tb.Cells[1, -1].Style = "Header";

 

          // Add the contents of the Title cell

 

          Cell tc = tb.Cells[0, 0];

 

          tc.Contents.Add();

          tc.Contents[0].TextHeight = txtHeight;

          tc.Contents[0].TextString = "New Table";

 

          // Populate the contents of the header and data sections

 

          int n = 0;

          for (int i = 1; i < numRows; i++)

          {

            for (int j = 0; j < numCols; j++)

            {

              // Contents is A-E for the header an 0-n for the data

 

              string contents =

                (i == 1 ?

                  Convert.ToChar(

                    Convert.ToInt16('A') + j

                  ).ToString() :

                  n++.ToString()

                );

 

              Cell c = tb.Cells[i, j];

 

              // Set the text contents of the cell

 

              c.Contents.Add();

              c.Contents[0].TextHeight = txtHeight;             

              c.Contents[0].TextString = contents;

 

              // Set the horizontal margins

 

              c.Borders.Left.Margin = horMarg;

              c.Borders.Right.Margin = horMarg;

 

              // Set the vertical margins

 

              c.Borders.Top.Margin = verMarg;

              c.Borders.Bottom.Margin = verMarg;

            }

          }

 

          // We'll separate this table from the first one

 

          tb.Position = new Point3d(20, 0, 0);

 

          tb.GenerateLayout();

 

          btr.AppendEntity(tb);

          tr.AddNewlyCreatedDBObject(tb, true);

        }

 

        tr.Commit();

      }

    }

  }

}

Before we take a look at  the changes needed to the first code to get the second, let’s see the warnings generated by the first code section when we build the project in Visual Studio (I’ve removed the Autodesk.AutoCAD.DatabaseServices. namespace prefix from each of the following lines):

'Table.NumRows' is obsolete: 'Use Table.Rows.Count instead.'

'Table.NumColumns' is obsolete: 'Use Table.Columns.Count instead.'

'Table.HorizontalCellMargin' is obsolete: 'Use Table.Cells[row, column].HorizontalLine.Margin instead.'

'Table.VerticalCellMargin' is obsolete: 'Use Table.Cells[row, column].VerticalLine.Margin instead.'

'Table.IsHeaderSuppressed' is obsolete: 'Use Cell functionality instead.'

'Table.IsTitleSuppressed' is obsolete: 'Use Cell functionality instead.'

'Table.SetTextString(int, int, string)' is obsolete: 'Use Table.Cells[row,column].TextString instead.'

'Table.SetTextHeight(double, int)' is obsolete: 'Use Cell functionality instead.'

'Table.SetTextString(int, int, string)' is obsolete: 'Use Table.Cells[row,column].TextString instead.'

The first warnings, related to the changing the size of the table, are straightforward enough to fix (when querying, it’s possible to follow the advice to use Table.Rows.Count and Table.Columns.Count: when resizing the table, we need to use the appropriate methods to insert/delete rows/columns at the right place, which actually makes more sense than arbitrarily setting the number of rows and columns to new values.

The second set of warnings, which cover setting the cell margins, are a little trickier to address (the suggestion to use the HorizontalLine and VerticalLine properties is misleading). Yes, you need to set the appropriate property for a specific cell, but the way you access the property is a little different – you need to use the Borders property to get access to the appropriate margin.

The good news is that there’s much finer control now possible: you can set left/right/top/bottom margins rather than having to live with equal margins in horizontal and vertical directions.

Next we have the third set of warnings, which relate to suppression of the title and header rows. These are also at the Cell level, but are also a bit tricky to get access to. You need to get the Cells for the row (passing in the row number and -1, for the column) and get/set the Style property. This string property should contain “Title” for title rows and “Header” for header rows. If you want to suppress the title – the equivalent of Table.IsTitleSuppressed = true), you can search through for the row containing “Title” in its Style property, and set it to the empty string (“”). And the equivalent operation for the header row.

Finally, we have the methods to set the size and contents of the text string for a cell. For this, you need to add a new item to the Contents collection for a cell, and from that you can set the text string and its height, as before.

Just to show that we have similar tables – at least with the properties I’ve assigned: there may be things I’ve missed when passing in different values for text sizes, margins, etc. – here are the results of running the TWOTABLES command:

Copying rows between AutoCAD tables using .NET

Thanks to Marat Mirgaleev, a member of our DevTech team based in Moscow, for the code that inspired this post.

The code in this post implements the simple case of taking the last two rows of one table and copying them into the same relative position in another table. If the destination table is smaller, it gets expanded, as do the individual rows  and columns.

Other than that, there’s not much to it. I have tried to structure the code to make it easy to adapt to more “challenging” tasks, such as taking an arbitrary, rectangular selection of cells and copying them across to another table (even a new one). This gets more into the selection side of things – and may even involve a combination of sub-entity selection and transient graphics, we’ll see – it should certainly be fun. :-)

Here’s the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

 

namespace TableCopying

{

  public class Commands

  {

    [CommandMethod("CRBT")]

    public static void CopyRowsBetweenTables()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Editor ed = doc.Editor;

 

      try

      {

        // Ask the user to select the two tables

 

        PromptEntityOptions peo =

          new PromptEntityOptions("\nSelect source table");

        peo.SetRejectMessage("\nMust be a table.");

        peo.AddAllowedClass(typeof(Table), false);

        peo.AllowNone = false;

        PromptEntityResult per = ed.GetEntity(peo);

        if (per.Status != PromptStatus.OK)

          return;

 

        ObjectId srcId = per.ObjectId;

 

        peo.Message = "\nSelect destination table";

        per = ed.GetEntity(peo);

        if (per.Status != PromptStatus.OK)

          return;

 

        ObjectId destId = per.ObjectId;

 

        Transaction tr =

          doc.TransactionManager.StartTransaction();

        using (tr)

        {

          // Open the tables: one for read, one for write

 

          Table srcTab =

            tr.GetObject(srcId, OpenMode.ForRead) as Table;

          Table destTab =

            tr.GetObject(destId, OpenMode.ForWrite) as Table;

 

          if (srcTab == null || destTab == null)

            return;

 

          // Make sure the destination table has enough rows...

 

          if (destTab.Rows.Count < srcTab.Rows.Count)

          {

            destTab.InsertRows(

              destTab.Rows.Count,

              5, // An arbitrary row height

              srcTab.Rows.Count - destTab.Rows.Count

            );

          }

 

          // ... and columns

 

          if (destTab.Columns.Count < srcTab.Columns.Count)

          {

            destTab.InsertColumns(

              destTab.Columns.Count,

              25, // An arbitrary column width

              srcTab.Columns.Count - destTab.Columns.Count

            );

          }

 

          // Copy the last two rows from the source table to

          // the destination table

 

          int nRows = 2, // Number of rows to copy

              nCols = srcTab.Columns.Count, // and columns

 

              // Source column and row numbers

 

              srcFirstCol = 0,

              srcLastCol = nCols - 1,

              srcLastRow = srcTab.Rows.Count - 1,

              srcFirstRow = srcLastRow - nRows + 1,

 

              // Destination column and row numbers

              // (for now the same as the source ones)

 

              destFirstCol = srcFirstCol,

              destFirstRow = srcFirstRow,

              destLastCol = srcLastCol,

              destLastRow = srcLastRow;

 

          destTab.CopyFrom(

            srcTab,

            TableCopyOptions.FillTarget,

            CellRange.Create(

              srcTab,

              srcFirstRow, srcFirstCol,

              srcLastRow, srcLastCol

            ),

            CellRange.Create(

              destTab,

              destFirstRow, destFirstCol,

              destLastRow, destLastCol

            )

          );

 

          destTab.GenerateLayout();

 

          // Make sure the columns of data we copied

          // across have the same width as the source

 

          for (int i = 0; i < nCols; i++)

          {

            if (

              destTab.Columns[destFirstCol + i].Width <

                srcTab.Columns[srcFirstCol + i].Width

            )

            {

              destTab.Columns[destFirstCol + i].Width =

                srcTab.Columns[srcFirstCol + i].Width;

            }

          }

 

          // Do the same for the row heights

 

          for (int r = 0; r < nRows; r++)

          {

            if (

              destTab.Rows[destFirstRow + r].Height <

                srcTab.Rows[srcFirstRow + r].Height

            )

            {

              destTab.Rows[destFirstRow + r].Height =

                srcTab.Rows[srcFirstRow + r].Height;

            }

 

            // And match the cell styles, etc.

 

            for (int c = 0; c < nCols; c++)

            {

              CellRange srcCell =

                srcTab.Cells[

                  srcFirstRow + r, srcFirstCol + c

                ];

              CellRange destCell =

                destTab.Cells[

                  destFirstRow + r, destFirstCol + c

                ];

              if (srcCell.Style != null)

                destCell.Style = srcCell.Style;

              if (srcCell.TextHeight > 0)

                destCell.TextHeight = srcCell.TextHeight;

              if (srcCell.TextStyleId != null)

                destCell.TextStyleId = srcCell.TextStyleId;

              if (srcCell.Alignment != null)

                destCell.Alignment = srcCell.Alignment;

            }

          }

          tr.Commit();

        }

      }

      catch (Autodesk.AutoCAD.Runtime.Exception ex)

      {

        ed.WriteMessage("\nException: {0}", ex.Message);

      }

    }

  }

}

Let’s see what happens when we use our CRBT (CopyRowsBetweenTables) command to select and copy contents from these source tables from the “Mechanical Samples\Mechanical - Text and Tables.dwg” sample drawing…

… into the destination tables next to them (which you can see as dots in the above image – they are at a relatively very small scale):

I was initially confused as to why the CRBT command only copied one row from the left-most table: it took me some time to figure out that the bottom two rows of that table are actually merged. So the code is indeed working as expected.

More fun with AutoCAD tables and their styles using .NET

In this previous post we saw some code to create a table style and apply it to a new table inside an AutoCAD drawing. While responding to a comment on the post, I realised that the table didn't display properly using my example: the first column heading was being taken as the table title and the rest of the column headings were lost - the headings in the table were actually taken from the first row of data. I suppose that serves me right for having chosen such eye-catching (and distracting) colours. :-)

The following C# code addresses this by adding some information to our array of table contents, and using that for the table title. It also does a little more to customize the display of our table by applying chunky lineweights (and yet more garish colours) to the table's grid-lines.

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Colors;

 

namespace TableAndStyleCreation

{

  public class Commands

  {

    [CommandMethod("CTWS")]

    static public void CreateTableWithStyleAndWhatStyle()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

 

      PromptPointResult pr =

        ed.GetPoint("\nEnter table insertion point: ");

      if (pr.Status == PromptStatus.OK)

      {

        Transaction tr =

          doc.TransactionManager.StartTransaction();

        using (tr)

        {

          // First let us create our custom style,

          //  if it doesn't exist

 

          const string styleName = "Garish Table Style";

          ObjectId tsId = ObjectId.Null;

 

          DBDictionary sd =

            (DBDictionary)tr.GetObject(

              db.TableStyleDictionaryId,

              OpenMode.ForRead

            );

 

          // Use the style if it already exists

 

          if (sd.Contains(styleName))

          {

            tsId = sd.GetAt(styleName);

          }

          else

          {

            // Otherwise we have to create it

 

            TableStyle ts = new TableStyle();

 

            // Make the header area red

 

            ts.SetBackgroundColor(

              Color.FromColorIndex(ColorMethod.ByAci, 1),

              (int)(RowType.TitleRow |

                    RowType.HeaderRow)

            );

 

            // And the data area yellow

 

            ts.SetBackgroundColor(

              Color.FromColorIndex(ColorMethod.ByAci, 2),

              (int)RowType.DataRow

            );

 

            // With magenta text everywhere (yeuch :-)

 

            ts.SetColor(

              Color.FromColorIndex(ColorMethod.ByAci, 6),

              (int)(RowType.TitleRow |

                    RowType.HeaderRow |

                    RowType.DataRow)

            );

 

            // And now with cyan outer grid-lines

 

            ts.SetGridColor(

              Color.FromColorIndex(ColorMethod.ByAci, 4),

              (int)GridLineType.OuterGridLines,

              (int)(RowType.TitleRow |

                    RowType.HeaderRow |

                    RowType.DataRow)

            );

 

            // And bright green inner grid-lines

 

            ts.SetGridColor(

              Color.FromColorIndex(ColorMethod.ByAci, 3),

              (int)GridLineType.InnerGridLines,

              (int)(RowType.TitleRow |

                    RowType.HeaderRow |

                    RowType.DataRow)

            );

 

            // And we'll make the grid-lines nice and chunky

 

            ts.SetGridLineWeight(

              LineWeight.LineWeight211,

              (int)GridLineType.AllGridLines,

              (int)(RowType.TitleRow |

                    RowType.HeaderRow |

                    RowType.DataRow)

            );

 

            // Add our table style to the dictionary

            //  and to the transaction

 

            tsId = ts.PostTableStyleToDatabase(db, styleName);

            tr.AddNewlyCreatedDBObject(ts, true);

          }

 

          BlockTable bt =

            (BlockTable)tr.GetObject(

              doc.Database.BlockTableId,

              OpenMode.ForRead

            );

 

          Table tb = new Table();

 

          tb.NumRows = 6;

          tb.NumColumns = 3;

          tb.SetRowHeight(3);

          tb.SetColumnWidth(15);

          tb.Position = pr.Value;

 

          // Use our table style

 

          if (tsId == ObjectId.Null)

            // This should not happen, unless the

            //  above logic changes

            tb.TableStyle = db.Tablestyle;

          else

            tb.TableStyle = tsId;

 

          // Create a 2-dimensional array

          // of our table contents

 

          string[,] str = new string[6, 3];

          str[0, 0] = "Material Properties Table";

          str[1, 0] = "Part No.";

          str[1, 1] = "Name";

          str[1, 2] = "Material";

          str[2, 0] = "1876-1";

          str[2, 1] = "Flange";

          str[2, 2] = "Perspex";

          str[3, 0] = "0985-4";

          str[3, 1] = "Bolt";

          str[3, 2] = "Steel";

          str[4, 0] = "3476-K";

          str[4, 1] = "Tile";

          str[4, 2] = "Ceramic";

          str[5, 0] = "8734-3";

          str[5, 1] = "Kean";

          str[5, 2] = "Mostly water";

 

          // Use a nested loop to add and format each cell

 

          for (int i = 0; i < 6; i++)

          {

            if (i == 0)

            {

              // This is for the title

 

              tb.SetTextHeight(0, 0, 1);

              tb.SetTextString(0, 0, str[0, 0]);

              tb.SetAlignment(0, 0, CellAlignment.MiddleCenter);

            }

            else

            {

              // These are the header and data rows

 

              for (int j = 0; j < 3; j++)

              {

                tb.SetTextHeight(i, j, 1);

                tb.SetTextString(i, j, str[i, j]);

                tb.SetAlignment(i, j, CellAlignment.MiddleCenter);

              }

            }

          }

          tb.GenerateLayout();

 

          BlockTableRecord btr =

            (BlockTableRecord)tr.GetObject(

              bt[BlockTableRecord.ModelSpace],

              OpenMode.ForWrite

            );

          btr.AppendEntity(tb);

          tr.AddNewlyCreatedDBObject(tb, true);

          tr.Commit();

        }

      }

    }

  }

}

One other minor enhancement: I made use of the TableStyle.PostTableStyleToDatabase() method to add the style to the appropriate location in the Database (we previously edited the TableStyleDictionary directly to achieve this).

Here's what happens when we run the CTWS command (making sure that we have adjusted the display settings to use lineweights):

And here's the updated style in AutoCAD's TableStyle dialog:

That's better. At least in that it does what was expected of it, even if it's not winning any design awards. :-)

Update

Roland Feletic pointed out that this code - while it still builds for AutoCAD 2011 - causes some "obsolete property/method" compiler warnings. I've provided an updated version of the code below, with the previous lines commented out for comparison:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Colors;

 

namespace TableAndStyleCreation

{

  public class Commands

  {

    [CommandMethod("CTWS")]

    static public void CreateTableWithStyleAndWhatStyle()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

 

      PromptPointResult pr =

        ed.GetPoint("\nEnter table insertion point: ");

      if (pr.Status == PromptStatus.OK)

      {

        Transaction tr =

          doc.TransactionManager.StartTransaction();

        using (tr)

        {

          // First let us create our custom style,

          //  if it doesn't exist

 

          const string styleName = "Garish Table Style";

          ObjectId tsId = ObjectId.Null;

 

          DBDictionary sd =

            (DBDictionary)tr.GetObject(

              db.TableStyleDictionaryId,

              OpenMode.ForRead

            );

 

          // Use the style if it already exists

 

          if (sd.Contains(styleName))

          {

            tsId = sd.GetAt(styleName);

          }

          else

          {

            // Otherwise we have to create it

 

            TableStyle ts = new TableStyle();

 

            // Make the header area red

 

            ts.SetBackgroundColor(

              Color.FromColorIndex(ColorMethod.ByAci, 1),

              (int)(RowType.TitleRow |

                    RowType.HeaderRow)

            );

 

            // And the data area yellow

 

            ts.SetBackgroundColor(

              Color.FromColorIndex(ColorMethod.ByAci, 2),

              (int)RowType.DataRow

            );

 

            // With magenta text everywhere (yeuch :-)

 

            ts.SetColor(

              Color.FromColorIndex(ColorMethod.ByAci, 6),

              (int)(RowType.TitleRow |

                    RowType.HeaderRow |

                    RowType.DataRow)

            );

 

            // And now with cyan outer grid-lines

 

            ts.SetGridColor(

              Color.FromColorIndex(ColorMethod.ByAci, 4),

              (int)GridLineType.OuterGridLines,

              (int)(RowType.TitleRow |

                    RowType.HeaderRow |

                    RowType.DataRow)

            );

 

            // And bright green inner grid-lines

 

            ts.SetGridColor(

              Color.FromColorIndex(ColorMethod.ByAci, 3),

              (int)GridLineType.InnerGridLines,

              (int)(RowType.TitleRow |

                    RowType.HeaderRow |

                    RowType.DataRow)

            );

 

            // And we'll make the grid-lines nice and chunky

 

            ts.SetGridLineWeight(

              LineWeight.LineWeight211,

              (int)GridLineType.AllGridLines,

              (int)(RowType.TitleRow |

                    RowType.HeaderRow |

                    RowType.DataRow)

            );

 

            // Add our table style to the dictionary

            //  and to the transaction

 

            tsId = ts.PostTableStyleToDatabase(db, styleName);

            tr.AddNewlyCreatedDBObject(ts, true);

          }

 

          BlockTable bt =

            (BlockTable)tr.GetObject(

              doc.Database.BlockTableId,

              OpenMode.ForRead

            );

 

          Table tb = new Table();

 

          tb.InsertRows(0, 3, 6);

          tb.InsertColumns(0, 15, 3);

 

          /*

          tb.NumRows = 6;

          tb.NumColumns = 3;

          tb.SetRowHeight(3);

          tb.SetColumnWidth(15);

          tb.Position = pr.Value;

          */

 

          // Use our table style

 

          if (tsId == ObjectId.Null)

            // This should not happen, unless the

            //  above logic changes

            tb.TableStyle = db.Tablestyle;

          else

            tb.TableStyle = tsId;

 

          // Create a 2-dimensional array

          // of our table contents

 

          string[,] str = new string[6, 3];

          str[0, 0] = "Material Properties Table";

          str[1, 0] = "Part No.";

          str[1, 1] = "Name";

          str[1, 2] = "Material";

          str[2, 0] = "1876-1";

          str[2, 1] = "Flange";

          str[2, 2] = "Perspex";

          str[3, 0] = "0985-4";

          str[3, 1] = "Bolt";

          str[3, 2] = "Steel";

          str[4, 0] = "3476-K";

          str[4, 1] = "Tile";

          str[4, 2] = "Ceramic";

          str[5, 0] = "8734-3";

          str[5, 1] = "Kean";

          str[5, 2] = "Mostly water";

 

          // Use a nested loop to add and format each cell

 

          for (int i = 0; i < 6; i++)

          {

            if (i == 0)

            {

              // This is for the title

 

              tb.Cells[0, 0].TextHeight = 1;

              tb.Cells[0, 0].TextString = str[0, 0];

              tb.Cells[0, 0].Alignment =

                CellAlignment.MiddleCenter;

 

              //tb.SetTextHeight(0, 0, 1);

              //tb.SetTextString(0, 0, str[0, 0]);

              //tb.SetAlignment(0, 0, CellAlignment.MiddleCenter);

            }

            else

            {

              // These are the header and data rows

 

              for (int j = 0; j < 3; j++)

              {

                tb.Cells[i, j].TextHeight = 1;

                tb.Cells[i, j].TextString = str[i, j];

                tb.Cells[i, j].Alignment =

                  CellAlignment.MiddleCenter;

 

                //tb.SetTextHeight(i, j, 1);

                //tb.SetTextString(i, j, str[i, j]);

                //tb.SetAlignment(i, j, CellAlignment.MiddleCenter);

              }

            }

          }

          tb.GenerateLayout();

 

          BlockTableRecord btr =

            (BlockTableRecord)tr.GetObject(

              bt[BlockTableRecord.ModelSpace],

              OpenMode.ForWrite

            );

          btr.AppendEntity(tb);

          tr.AddNewlyCreatedDBObject(tb, true);

          tr.Commit();

        }

      }

    }

  }

}

Many thanks, Roland! :-)

Creating a custom AutoCAD table style using .NET

The question of how to define a new table style programmatically has come up a couple of times over the last week or so, so this post shows how to approach this. I've used the code from this previous post as a basis for this post's.

The important thing to know is that TableStyle objects are stored in a special dictionary, which can be accessed via a Database's TableStyleDictionaryId property. This ObjectId property allows you to access the dictionary, from which you can query the contents, determine whether your style exists and add a new one if it doesn't. The code to specify the colour and formatting of the table style is reasonably straightforward.

Here's some C# code to define a new "Garish Table Style" with a red header/title area, yellow data area and magenta text throughout (better put on your sunglasses before running it... :-):

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Colors;

namespace TableAndStyleCreation

{

  public class Commands

  {

    [CommandMethod("CTWS")]

    static public void CreateTableWithStyle()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      PromptPointResult pr =

        ed.GetPoint("\nEnter table insertion point: ");

      if (pr.Status == PromptStatus.OK)

      {

        Transaction tr =

          doc.TransactionManager.StartTransaction();

        using (tr)

        {

          // First let us create our custom style,

          //  if it doesn't exist

          const string styleName = "Garish Table Style";

          ObjectId tsId = ObjectId.Null;

          DBDictionary sd =

            (DBDictionary)tr.GetObject(

              db.TableStyleDictionaryId,

              OpenMode.ForRead

            );

          // Use the style if it already exists

          if (sd.Contains(styleName))

          {

            tsId = sd.GetAt(styleName);

          }

          else

          {

            // Otherwise we have to create it

            TableStyle ts = new TableStyle();

            // Make the header area red

            ts.SetBackgroundColor(

              Color.FromColorIndex(ColorMethod.ByAci, 1),

              (int)(RowType.HeaderRow | RowType.TitleRow)

            );

            // And the data area yellow

            ts.SetBackgroundColor(

              Color.FromColorIndex(ColorMethod.ByAci, 2),

              (int)RowType.DataRow

            );

            // With magenta text everywhere (yeuch :-)

            ts.SetColor(

              Color.FromColorIndex(ColorMethod.ByAci, 6),

              (int)(RowType.HeaderRow |

                    RowType.TitleRow |

                    RowType.DataRow)

            );

            // Add our table style to the dictionary

            //  and to the transaction

            sd.UpgradeOpen();

            tsId = sd.SetAt(styleName, ts);

            tr.AddNewlyCreatedDBObject(ts, true);

            sd.DowngradeOpen();

          }

          BlockTable bt =

            (BlockTable)tr.GetObject(

              doc.Database.BlockTableId,

              OpenMode.ForRead

            );

          Table tb = new Table();

          // Use our table style

          if (tsId == ObjectId.Null)

            // This should not happen, unless the

            //  above logic changes

            tb.TableStyle = db.Tablestyle;

          else

            tb.TableStyle = tsId;

          tb.NumRows = 5;

          tb.NumColumns = 3;

          tb.SetRowHeight(3);

          tb.SetColumnWidth(15);

          tb.Position = pr.Value;

          // Create a 2-dimensional array

          // of our table contents

          string[,] str = new string[5, 4];

          str[0, 0] = "Part No.";

          str[0, 1] = "Name ";

          str[0, 2] = "Material ";

          str[1, 0] = "1876-1";

          str[1, 1] = "Flange";

          str[1, 2] = "Perspex";

          str[2, 0] = "0985-4";

          str[2, 1] = "Bolt";

          str[2, 2] = "Steel";

          str[3, 0] = "3476-K";

          str[3, 1] = "Tile";

          str[3, 2] = "Ceramic";

          str[4, 0] = "8734-3";

          str[4, 1] = "Kean";

          str[4, 2] = "Mostly water";

          // Use a nested loop to add and format each cell

          for (int i = 0; i < 5; i++)

          {

            for (int j = 0; j < 3; j++)

            {

              tb.SetTextHeight(i, j, 1);

              tb.SetTextString(i, j, str[i, j]);

              tb.SetAlignment(i, j, CellAlignment.MiddleCenter);

            }

          }

          tb.GenerateLayout();

          BlockTableRecord btr =

            (BlockTableRecord)tr.GetObject(

              bt[BlockTableRecord.ModelSpace],

              OpenMode.ForWrite

            );

          btr.AppendEntity(tb);

          tr.AddNewlyCreatedDBObject(tb, true);

          tr.Commit();

        }

      }

    }

  }

}

Here's what happens when we load the module and run the CTWS command, selecting a location for our "garish" table:

And if we launch AutoCAD's TABLESTYLE command we can see our custom style in the list:

Update

A further post on this topic has now been published.

Updating an Excel spreadsheet from a linked AutoCAD table using .NET

In the last post we saw some code to update an AutoCAD table linked to an Excel spreadsheet. In this post we go the other way, updating an Excel spreadsheet from a linked AutoCAD table.

Here's the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Windows;

namespace LinkToExcel

{

  public class Commands

  {

    [CommandMethod("T2S")]

    static public void UpdateSpreadsheetFromTable()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      PromptEntityOptions opt =

        new PromptEntityOptions(

          "\nSelect table with spreadsheet to update: "

        );

      opt.SetRejectMessage(

        "\nEntity is not a table."

      );

      opt.AddAllowedClass(typeof(Table), false);

      PromptEntityResult per =

        ed.GetEntity(opt);

      if (per.Status != PromptStatus.OK)

        return;

      Transaction tr =

        db.TransactionManager.StartTransaction();

      using (tr)

      {

        try

        {

          DBObject obj =

            tr.GetObject(

              per.ObjectId,

              OpenMode.ForRead

            );

          Table tb = (Table)obj;

          // It should always be a table

          // but we'll check, just in case

          if (tb != null)

          {

            // The table must be open for write

            tb.UpgradeOpen();

            // Update the data link from the table

            tb.UpdateDataLink(

              UpdateDirection.DataToSource,

              UpdateOption.ForceFullSourceUpdate

            );

            // And the spreadsheet from the data link

            ObjectId dlId = tb.GetDataLink(0, 0);

            DataLink dl =

              (DataLink)tr.GetObject(

                dlId,

                OpenMode.ForWrite

              );

            dl.Update(

              UpdateDirection.DataToSource,

              UpdateOption.ForceFullSourceUpdate

            );

          }

          tr.Commit();

          ed.WriteMessage(

            "\nUpdated the spreadsheet from the table."

          );

        }

        catch (Exception ex)

        {

          ed.WriteMessage(

            "\nException: {0}",

            ex.Message

          );

        }

      }

    }

  }

}

Tables with linked spreadsheets are locked by default and display this glyph when you hover over them: . Before you run the code you will need to unlock the table by right-clicking the cell(s) you wish to edit:

One point to note is that the code will work even if the spreadsheet is open in Excel, but the contents will not be updated automatically - you have to close and reopen the file to see the results. And you will probably see this dialog come up twice:

For the best (most logical) results, the T2S command should really be run when the spreadsheet is not open in Excel. I expect it's possible to determine whether a spreadsheet is open in Excel from using standard file access functions in .NET (requesting exclusive access, to see whether it's possible to get it), but that's being left as an exercise for the reader (or for another day, at least :-).

For your convenience, here's a source file containing the code from the last three posts (command implementations for TFS, S2T and T2S).

Updating an AutoCAD table linked to an Excel spreadsheet using .NET

Thanks to Viru Aithal, from DevTech India, for providing the code for this post (I converted the C# code below from some C++ he had sent to a developer).

In the last post we showed how to create a table linked to an Excel spreadsheet using .NET in AutoCAD 2008. AutoCAD does a great job of looking for changes in the Excel spreadsheet, and asking whether you want to update the linked table:

There may be times, however, when you want to force the update programmatically, whether from the spreadsheet to the table ot vice-versa. In this post we'll show the code to update the table from the spreadsheet, and in the next post we'll see some code to update the spreadsheet from the table (should it have been unlocked and edited).

Here's the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

namespace LinkToExcel

{

  public class Commands

  {

    [CommandMethod("S2T")]

    static public void UpdateTableFromSpreadsheet()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      PromptEntityOptions opt =

        new PromptEntityOptions(

          "\nSelect table to update: "

        );

      opt.SetRejectMessage(

        "\nEntity is not a table."

      );

      opt.AddAllowedClass(typeof(Table), false);

      PromptEntityResult per =

        ed.GetEntity(opt);

      if (per.Status != PromptStatus.OK)

        return;

      Transaction tr =

        db.TransactionManager.StartTransaction();

      using (tr)

      {

        try

        {

          DBObject obj =

            tr.GetObject(

              per.ObjectId,

              OpenMode.ForRead

            );

          Table tb = (Table)obj;

          // It should always be a table

          // but we'll check, just in case

          if (tb != null)

          {

            // The table must be open for write

            tb.UpgradeOpen();

            // Update the data link from the spreadsheet

            ObjectId dlId = tb.GetDataLink(0, 0);

            DataLink dl =

              (DataLink)tr.GetObject(

                dlId,

                OpenMode.ForWrite

              );

            dl.Update(

              UpdateDirection.SourceToData,

              UpdateOption.None

            );

            // And the table from the data link

            tb.UpdateDataLink(

              UpdateDirection.SourceToData,

              UpdateOption.None

            );

          }

          tr.Commit();

          ed.WriteMessage(

            "\nUpdated the table from the spreadsheet."

          );

        }

        catch (Exception ex)

        {

          ed.WriteMessage(

            "\nException: {0}",

            ex.Message

          );

        }

      }

    }

  }

}

When you run the S2T (for Spreadsheet-to-Table) command, you will be prompted to select a table. The code retrieves the link information from the table and then requests the data link to pull down new data from the spreadsheet before updating the table. Next time we'll look at the code for T2S...

Creating an AutoCAD table linked to an Excel spreadsheet using .NET

In the last post I promised to tackle this issue, and so here we are again. :-)

Note: the code in this post relies on enhanced table functionality introduced in AutoCAD 2008, so please don't get frustrated trying to make this work in previous versions.

The following C# code follows on from yesterday's, taking the spreadsheet selected by the user and linking it to a newly-created table in the active AutoCAD drawing. I haven't bothered with line numbering in the below code, as it follows on almost exactly from the code shown last time (aside from renaming the namespace, the command and the function, as well as adding a string constant at the top of the function implementation).

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Runtime;

using Autodesk.AutoCAD.Windows;

namespace LinkToExcel

{

  public class Commands

  {

    [CommandMethod("TFS")]

    static public void TableFromSpreadsheet()

    {

      // Hardcoding the string

      // Could also select for it

      const string dlName =

        "Import table from Excel demo";

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      OpenFileDialog ofd =

        new OpenFileDialog(

          "Select Excel spreadsheet to link",

          null,

          "xls; xlsx",

          "ExcelFileToLink",

          OpenFileDialog.OpenFileDialogFlags.

            DoNotTransferRemoteFiles

        );

      System.Windows.Forms.DialogResult dr =

        ofd.ShowDialog();

      if (dr != System.Windows.Forms.DialogResult.OK)

        return;

      ed.WriteMessage(

        "\nFile selected was \"{0}\".",

        ofd.Filename

      );

      PromptPointResult ppr =

        ed.GetPoint(

          "\nEnter table insertion point: "

        );

      if (ppr.Status != PromptStatus.OK)

        return;

      // Remove the Data Link, if it exists already

      DataLinkManager dlm = db.DataLinkManager;

      ObjectId dlId = dlm.GetDataLink(dlName);

      if (dlId != ObjectId.Null)

      {

        dlm.RemoveDataLink(dlId);

      }

      // Create and add the Data Link

      DataLink dl = new DataLink();

      dl.DataAdapterId = "AcExcel";

      dl.Name = dlName;

      dl.Description =

        "Excel fun with Through the Interface";

      dl.ConnectionString = ofd.Filename;

      dl.DataLinkOption =

        DataLinkOption.PersistCache;

      dl.UpdateOption |=

        (int)UpdateOption.AllowSourceUpdate;

      dlId = dlm.AddDataLink(dl);

      Transaction tr =

        doc.TransactionManager.StartTransaction();

      using (tr)

      {

        tr.AddNewlyCreatedDBObject(dl, true);

        BlockTable bt =

          (BlockTable)tr.GetObject(

            db.BlockTableId,

            OpenMode.ForRead

          );

        Table tb = new Table();

        tb.TableStyle = db.Tablestyle;

        tb.Position = ppr.Value;

        tb.SetDataLink(0, 0, dlId, true);

        tb.GenerateLayout();

        BlockTableRecord btr =

          (BlockTableRecord)tr.GetObject(

            db.CurrentSpaceId,

            OpenMode.ForWrite

          );

        btr.AppendEntity(tb);

        tr.AddNewlyCreatedDBObject(tb, true);

        tr.Commit();

      }

      // Force a regen to display the table

      ed.Regen();

    }

  }

}

Here's what happens when you run the TFS command and select your favourite XLS for linking (I used mass-balance.xls from AutoCAD 2008's Sample\Mechanical Sample folder):

At this stage I haven't focused at all on formating - this is just coming in "as is", without any adjustment of cell alignments, column widths or row heights.

I chose to hardcode the name of the Data Link we use for the spreadsheet. You can run the DATALINK command to check on it, after the command has executed:

 

It doesn't seem to be an issue if you repeat the command and bring in a different spreadsheet using the same link - the link appears to continue (although I haven't performed exhaustive testing). If it does prove to be a problem it should be simple enough to create a unique Data Link per spreadsheet imported (or even per time the command is run).

Creating a table of block attributes in AutoCAD using .NET - Part 2

In the last post we looked at some code to create a table of attribute values for a particular block. In this post we'll extend that code and show how to use a formula to create a total of those values.

Below is the C# code. I've numbered the lines, and those in red are new since the last post. The complete source file can be downloaded here.

Firstly, a quick breakdown of the changes:

• Lines 60-81 deal with user input, and the forcing of the decision to "embed" rather than "link", if we're performing the total (table formulae do not work with fields, even if they have numeric results, so we're forced to create the table with the current value, rather than a field pointing to the attribute reference)
• Line 134 and subsequently lines 159-166 declare and set a variable indicating for which column we're going to provide a total
• Lines 169-181 deal with the exceptional case that we don't find the specified attribute definition
• Lines 310-336 create our additional row, and insert the total in the appropriate cell. We're using a formula such as this: %<\AcExpr (Sum(A2:A4)) \f "%lu2%pr2">%
  • The \f flag specifies we want a numeric value with 2 decimal places - these codes are not documented, but you can find them out by using the FIELD command, as described in this previous post
• Line 343 performs a regen, to update the value of our field

And now for the code:

    1 using Autodesk.AutoCAD.ApplicationServices;

    2 using Autodesk.AutoCAD.DatabaseServices;

    3 using Autodesk.AutoCAD.EditorInput;

    4 using Autodesk.AutoCAD.Geometry;

    5 using Autodesk.AutoCAD.Runtime;

    6 using System.Collections.Specialized;

    7 using System;

    8

    9 namespace TableCreation

   10 {

   11   public class Commands

   12   {

   13     // Set up some formatting constants

   14     // for the table

   15

   16     const double colWidth = 15.0;

   17     const double rowHeight = 3.0;

   18     const double textHeight = 1.0;

   19     const CellAlignment cellAlign =

   20       CellAlignment.MiddleCenter;

   21

   22     // Helper function to set text height

   23     // and alignment of specific cells,

   24     // as well as inserting the text

   25

   26     static public void SetCellText(

   27       Table tb,

   28       int row,

   29       int col,

   30       string value

   31     )

   32     {

   33       tb.SetAlignment(row, col, cellAlign);

   34       tb.SetTextHeight(row, col, textHeight);

   35       tb.SetTextString(row, col, value);

   36     }

   37

   38     [CommandMethod("BAT")]

   39     static public void BlockAttributeTable()

   40     {

   41       Document doc =

   42         Application.DocumentManager.MdiActiveDocument;

   43       Database db = doc.Database;

   44       Editor ed = doc.Editor;

   45

   46       // Ask for the name of the block to find

   47

   48       PromptStringOptions opt =

   49         new PromptStringOptions(

   50           "\nEnter name of block to list: "

   51         );

   52       PromptResult pr = ed.GetString(opt);

   53

   54       if (pr.Status == PromptStatus.OK)

   55       {

   56         string blockToFind =

   57           pr.StringResult.ToUpper();

   58         bool embed = false;

   59

   60         // And the attribute to provide total for

   61

   62         opt.Message =

   63           "\nEnter name of column to total <\"\">: ";

   64         pr = ed.GetString(opt);

   65

   66         if (pr.Status == PromptStatus.None ||

   67             pr.Status == PromptStatus.OK)

   68         {

   69           string columnToTotal =

   70               pr.StringResult.ToUpper();

   71

   72           if (columnToTotal != "")

   73           {

   74             // If a column has been chosen, we need

   75             // to embed the attribute values

   76             // as otherwise the "sum" formula will fail

   77

   78             embed = true;

   79           }

   80           else

   81           {

   82             // Ask whether to embed or link

   83

   84             PromptKeywordOptions pko =

   85               new PromptKeywordOptions(

   86                 "\nEmbed or link the attribute values: "

   87               );

   88

   89             pko.AllowNone = true;

   90             pko.Keywords.Add("Embed");

   91             pko.Keywords.Add("Link");

   92             pko.Keywords.Default = "Embed";

   93             PromptResult pkr =

   94               ed.GetKeywords(pko);

   95

   96             if (pkr.Status == PromptStatus.None ||

   97                 pkr.Status == PromptStatus.OK)

   98             {

   99               if (pkr.Status == PromptStatus.None ||

  100                   pkr.StringResult == "Embed")

  101                 embed = true;

  102               else

  103                 embed = false;

  104             }

  105           }

  106

  107           Transaction tr =

  108             doc.TransactionManager.StartTransaction();

  109           using (tr)

  110           {

  111             // Let's check the block exists

  112

  113             BlockTable bt =

  114               (BlockTable)tr.GetObject(

  115                 doc.Database.BlockTableId,

  116                 OpenMode.ForRead

  117               );

  118

  119             if (!bt.Has(blockToFind))

  120             {

  121               ed.WriteMessage(

  122                 "\nBlock "

  123                 + blockToFind

  124                 + " does not exist."

  125               );             

  126             }

  127             else

  128             {

  129               // And go through looking for

  130               // attribute definitions

  131

  132               StringCollection colNames =

  133                 new StringCollection();

  134               int colToTotalIdx = -1;

  135

  136               BlockTableRecord bd =

  137                 (BlockTableRecord)tr.GetObject(

  138                   bt[blockToFind],

  139                   OpenMode.ForRead

  140                 );

  141               foreach (ObjectId adId in bd)

  142               {

  143                 DBObject adObj =

  144                   tr.GetObject(

  145                     adId,

  146                     OpenMode.ForRead

  147                   );

  148

  149                 // For each attribute definition we find...

  150

  151                 AttributeDefinition ad =

  152                   adObj as AttributeDefinition;

  153                 if (ad != null)

  154                 {

  155                   // ... we add its name to the list

  156

  157                   colNames.Add(ad.Tag);

  158

  159                   if (ad.Tag.ToUpper() == columnToTotal)

  160                   {

  161                     // Save the index of the column

  162                     // we want to total

  163

  164                     colToTotalIdx =

  165                       colNames.Count - 1;

  166                   }

  167                 }

  168               }

  169               // If we didn't find the attribute to be totalled

  170               // then simply ignore the request and continue

  171

  172               if (columnToTotal != "" && colToTotalIdx < 0)

  173               {

  174                 ed.WriteMessage(

  175                   "\nAttribute definition for "

  176                   + columnToTotal

  177                   + " not found in "

  178                   + blockToFind

  179                   + ". Total will not be added to the table."

  180                 );

  181               }

  182               if (colNames.Count == 0)

  183               {

  184                 ed.WriteMessage(

  185                   "\nThe block "

  186                   + blockToFind

  187                   + " contains no attribute definitions."                  

  188                 );

  189               }

  190               else

  191               {

  192                 // Ask the user for the insertion point

  193                 // and then create the table

  194

  195                 PromptPointResult ppr =

  196                   ed.GetPoint(

  197                     "\nEnter table insertion point: "

  198                   );

  199

  200                 if (ppr.Status == PromptStatus.OK)

  201                 {

  202                   Table tb = new Table();

  203                   tb.TableStyle = db.Tablestyle;

  204                   tb.NumRows = 1;

  205                   tb.NumColumns = colNames.Count;

  206                   tb.SetRowHeight(rowHeight);

  207                   tb.SetColumnWidth(colWidth);

  208                   tb.Position = ppr.Value;

  209

  210                   // Let's add our column headings

  211

  212                   for (int i = 0; i < colNames.Count; i++)

  213                   {

  214                     SetCellText(tb, 0, i, colNames[i]);

  215                   }

  216

  217                   // Now let's search for instances of

  218                   // our block in the modelspace

  219

  220                   BlockTableRecord ms =

  221                     (BlockTableRecord)tr.GetObject(

  222                       bt[BlockTableRecord.ModelSpace],

  223                       OpenMode.ForRead

  224                     );

  225

  226                   int rowNum = 1;

  227                   foreach (ObjectId objId in ms)

  228                   {

  229                     DBObject obj =

  230                       tr.GetObject(

  231                         objId,

  232                         OpenMode.ForRead

  233                       );

  234                     BlockReference br =

  235                       obj as BlockReference;

  236                     if (br != null)

  237                     {

  238                       BlockTableRecord btr =

  239                         (BlockTableRecord)tr.GetObject(

  240                           br.BlockTableRecord,

  241                           OpenMode.ForRead

  242                         );

  243                       using (btr)

  244                       {

  245                         if (btr.Name.ToUpper() == blockToFind)

  246                         {

  247                           // We have found one of our blocks,

  248                           // so add a row for it in the table

  249

  250                           tb.InsertRows(

  251                               rowNum,

  252                               rowHeight,

  253                               1

  254                           );

  255

  256                           // Assume that the attribute refs

  257                           // follow the same order as the

  258                           // attribute defs in the block

  259

  260                           int attNum = 0;

  261                           foreach (

  262                             ObjectId arId in

  263                             br.AttributeCollection

  264                           )

  265                           {

  266                             DBObject arObj =

  267                               tr.GetObject(

  268                                 arId,

  269                                 OpenMode.ForRead

  270                               );

  271                             AttributeReference ar =

  272                               arObj as AttributeReference;

  273                             if (ar != null)

  274                             {

  275                               // Embed or link the values

  276

  277                               string strCell;

  278                               if (embed)

  279                               {

  280                                 strCell = ar.TextString;

  281                               }

  282                               else

  283                               {

  284                                 string strArId =

  285                                   arId.ToString();

  286                                 strArId =

  287                                   strArId.Trim(

  288                                     new char[] { '(', ')' }

  289                                   );

  290                                 strCell =

  291                                   "%<\\AcObjProp Object("

  292                                     + "%<\\_ObjId "

  293                                     + strArId

  294                                     + ">%).TextString>%";

  295                               }

  296                               SetCellText(

  297                                 tb,

  298                                 rowNum,

  299                                 attNum,

  300                                 strCell

  301                               );

  302                             }

  303                             attNum++;

  304                           }

  305                           rowNum++;

  306                         }

  307                       }

  308                     }

  309                   }

  310

  311                   // Now let's add a row for our total

  312

  313                   if (colToTotalIdx >= 0)

  314                   {

  315                     tb.InsertRows(rowNum, rowHeight, 1);

  316                     char colLetter =

  317                       Convert.ToChar(

  318                         (Convert.ToInt32(

  319                           'A') + colToTotalIdx

  320                         )

  321                       );

  322

  323                     // Add a formula to sum the column

  324

  325                     SetCellText(

  326                       tb,

  327                       rowNum,

  328                       colToTotalIdx,

  329                       "%<\\AcExpr (Sum("

  330                         + colLetter

  331                         + "2:"

  332                         + colLetter

  333                         + rowNum.ToString()

  334                         + ")) \\f  \"%lu2%pr2\">%"

  335                     );

  336                   }

  337                   tb.GenerateLayout();

  338

  339                   ms.UpgradeOpen();

  340                   ms.AppendEntity(tb);

  341                   tr.AddNewlyCreatedDBObject(tb, true);

  342                   tr.Commit();

  343                   ed.Regen();

  344                 }

  345               }

  346             }

  347           }

  348         }

  349       }

  350     }

  351   }

  352 }

Here's what happens when you run the updated BAT command against the data I used last time:

Creating a table of block attributes in AutoCAD using .NET - Part 1

This post was inspired by suggestions from a few different people (you know who you are! :-). I'm going to take it in two parts: this post will focus on creating a table automatically that lists the values of attribute references included in block references in the modelspace that point to a particular block table record selected by the user. Phew. The next post will add some functionality to create a "total" of one of the columns in the table we create, by using a table formula that performs a sum of the appropriate cells.

The below code is actually quite similar in behaviour to the Table sample on the ObjectARX SDK and also the EATTEXT command inside AutoCAD - both of which will help you create tables from block attributes. I wrote this code in AutoCAD 2007 (and it should work just fine in 2008, also). I haven't tested against prior versions.

One item of note is the ability to either embed or link the data placed in the table. "Embedding" means we just take a copy of the attribute values and place them as plain text in the cells; "linking" means we use a field to create a reference from the cell to the attribute's value (using the technique shown in the previous post).

The code is quite lengthy, but I've done my best to comment it to make it more clear what's going on. Here's the C# code:

using Autodesk.AutoCAD.ApplicationServices;

using Autodesk.AutoCAD.DatabaseServices;

using Autodesk.AutoCAD.EditorInput;

using Autodesk.AutoCAD.Geometry;

using Autodesk.AutoCAD.Runtime;

using System.Collections.Specialized;

using System;

namespace TableCreation

{

  public class Commands

  {

    // Set up some formatting constants

    // for the table

    const double colWidth = 15.0;

    const double rowHeight = 3.0;

    const double textHeight = 1.0;

    const CellAlignment cellAlign =

      CellAlignment.MiddleCenter;

    // Helper function to set text height

    // and alignment of specific cells,

    // as well as inserting the text

    static public void SetCellText(

      Table tb,

      int row,

      int col,

      string value

    )

    {

      tb.SetAlignment(row, col, cellAlign);

      tb.SetTextHeight(row, col, textHeight);

      tb.SetTextString(row, col, value);

    }

    [CommandMethod("BAT")]

    static public void BlockAttributeTable()

    {

      Document doc =

        Application.DocumentManager.MdiActiveDocument;

      Database db = doc.Database;

      Editor ed = doc.Editor;

      // Ask for the name of the block to find

      PromptStringOptions opt =

        new PromptStringOptions(

          "\nEnter name of block to list: "

        );

      PromptResult pr = ed.GetString(opt);

      if (pr.Status == PromptStatus.OK)

      {

        string blockToFind =

          pr.StringResult.ToUpper();

        bool embed = false;

        // Ask whether to embed or link the data

        PromptKeywordOptions pko =

          new PromptKeywordOptions(

            "\nEmbed or link the attribute values: "

          );

        pko.AllowNone = true;

        pko.Keywords.Add("Embed");

        pko.Keywords.Add("Link");

        pko.Keywords.Default = "Embed";

        PromptResult pkr =

          ed.GetKeywords(pko);

        if (pkr.Status == PromptStatus.None ||

            pkr.Status == PromptStatus.OK)

        {

          if (pkr.Status == PromptStatus.None ||

              pkr.StringResult == "Embed")

            embed = true;

          else

            embed = false;

        }

        Transaction tr =

          doc.TransactionManager.StartTransaction();

        using (tr)

        {

          // Let's check the block exists

          BlockTable bt =

            (BlockTable)tr.GetObject(

              doc.Database.BlockTableId,

              OpenMode.ForRead

            );

          if (!bt.Has(blockToFind))

          {

            ed.WriteMessage(

              "\nBlock "

              + blockToFind

              + " does not exist."

            );

          }

          else

          {

            // And go through looking for

            // attribute definitions

            StringCollection colNames =

              new StringCollection();

            BlockTableRecord bd =

              (BlockTableRecord)tr.GetObject(

                bt[blockToFind],

                OpenMode.ForRead

              );

            foreach (ObjectId adId in bd)

            {

              DBObject adObj =

                tr.GetObject(

                  adId,

                  OpenMode.ForRead

                );

              // For each attribute definition we find...

              AttributeDefinition ad =

                adObj as AttributeDefinition;

              if (ad != null)

              {

                // ... we add its name to the list

                colNames.Add(ad.Tag);

              }

            }

            if (colNames.Count == 0)

            {

              ed.WriteMessage(

                "\nThe block "

                + blockToFind

                + " contains no attribute definitions."

              );

            }

            else

            {

              // Ask the user for the insertion point

              // and then create the table

              PromptPointResult ppr =

                ed.GetPoint(

                  "\nEnter table insertion point: "

                );

              if (ppr.Status == PromptStatus.OK)

              {

                Table tb = new Table();

                tb.TableStyle = db.Tablestyle;

                tb.NumRows = 1;

                tb.NumColumns = colNames.Count;

                tb.SetRowHeight(rowHeight);

                tb.SetColumnWidth(colWidth);

                tb.Position = ppr.Value;

                // Let's add our column headings

                for (int i = 0; i < colNames.Count; i++)

                {

                  SetCellText(tb, 0, i, colNames[i]);

                }

                // Now let's search for instances of

                // our block in the modelspace

                BlockTableRecord ms =

                  (BlockTableRecord)tr.GetObject(

                    bt[BlockTableRecord.ModelSpace],

                    OpenMode.ForRead

                  );

                int rowNum = 1;

                foreach (ObjectId objId in ms)

                {

                  DBObject obj =

                    tr.GetObject(

                      objId,

                      OpenMode.ForRead

                    );

                  BlockReference br =

                    obj as BlockReference;

                  if (br != null)

                  {

                    BlockTableRecord btr =

                      (BlockTableRecord)tr.GetObject(

                        br.BlockTableRecord,

                        OpenMode.ForRead

                      );

                    using (btr)

                    {

                      if (btr.Name.ToUpper() == blockToFind)

                      {

                        // We have found one of our blocks,

                        // so add a row for it in the table

                        tb.InsertRows(

                          rowNum,

                          rowHeight,

                          1

                        );

                        // Assume that the attribute refs

                        // follow the same order as the

                        // attribute defs in the block

                        int attNum = 0;

                        foreach (

                          ObjectId arId in

                          br.AttributeCollection

                        )

                        {

                          DBObject arObj =

                            tr.GetObject(

                              arId,

                              OpenMode.ForRead

                            );

                          AttributeReference ar =

                            arObj as AttributeReference;

                          if (ar != null)

                          {

                            // Embed or link the values

                            string strCell;

                            if (embed)

                            {

                              strCell = ar.TextString;

                            }

                            else

                            {

                              string strArId =

                                arId.ToString();

                              strArId =

                                strArId.Trim(

                                  new char[] { '(', ')' }

                                );

                              strCell =

                                "%<\\AcObjProp Object("

                                  + "%<\\_ObjId "

                                  + strArId

                                  + ">%).TextString>%";

                            }

                            SetCellText(

                              tb,

                              rowNum,

                              attNum,

                              strCell

                            );

                          }

                          attNum++;

                        }

                        rowNum++;

                      }

                    }

                  }

                }

                tb.GenerateLayout();

                ms.UpgradeOpen();

                ms.AppendEntity(tb);

                tr.AddNewlyCreatedDBObject(tb, true);

                tr.Commit();

              }

            }

          }

        }

      }

    }

  }

}

To test the code, I created a block called "DATA" containing attribute definitions for NAME, PARTNUM, MATERIAL and COST. I then created blocks corresponding to the data we had previously hard-coded.

Here's what happens when I used the BAT command on this data to create two tables - the top with "embedded" values, the bottom with them "linked":

In the next post we'll add a "Total" row at the bottom of the table, and use a formula to calculate the sum of a particular column (the logical one being COST, as it's numerical).