четверг, 5 июня 2014 г.

Табличные стили в AutoCAD

В заметке показан пример создания и детальной настройки базового табличного стиля. Затем, на его основе создан производный табличный стиль к которому применён пользовательский шаблон таблиц (так же созданный нами в коде). После создания и настройки табличных стилей, в коде продемонстрированы примеры создания таблиц на основе обозначенных выше стилей.

В результате работы кода будут созданы два табличных стиля:


В составе базового стиля создаётся дополнительный набор стилей ячеек и происходит подробная настройка каждой опции стиля:


На основе базового стиля создаётся производный стиль и к нему применяется шаблон:


В коде так же определены две команды (CreateTable и CreateTable2), при помощи которых создаются таблицы на основе созданных нами табличных стилей. При запуске этих команд необходимые стили создаются автоматически, если они ещё отсутствуют в базе данных чертежа. Помимо этого, в коде определено две команды, создающие наши стили: BaseTableStyle и TableStyleWithTemplate.


В коде каждая изменяемая нами опция настроек помечена комментарием, содержащим наименование этой опции в англоязычной версии AutoCAD.

   1:  /* TableStyleSample.cs
   2:   * AutoCAD 2009-2015
   3:   * © Андрей Бушман, 2014  
   4:   * Пример создания табличных стилей (с шаблоном и
   5:   * без), а так же таблиц, использующих эти стили.
   6:   * 
   7:   * Команды, определённые в данном коде: 
   8:   * - CreateTable - создать таблицу на основе 
   9:   *    базового табличного стиля.
  10:   *    
  11:   * - CreateTable2 - создать таблицу на основе 
  12:   *    шаблонного табличного стиля.
  13:   *    
  14:   * - BaseTableStyle - создать базовый табличный 
  15:   *    стиль.
  16:   *    
  17:   * - TableStyleWithTemplate - создать табличный 
  18:   *    стиль на основе шаблона таблицы.
  19:   */
  20:  using System;
  21:  using System.Collections.Generic;
  22:  using System.Linq;
  23:  using System.Text;
  24:  using System.Reflection;
  25:   
  26:  #if AUTOCAD
  27:  using cad = Autodesk.AutoCAD.ApplicationServices
  28:  .Application;
  29:  using Ap = Autodesk.AutoCAD.ApplicationServices;
  30:  using Db = Autodesk.AutoCAD.DatabaseServices;
  31:  using Ed = Autodesk.AutoCAD.EditorInput;
  32:  using Rt = Autodesk.AutoCAD.Runtime;
  33:  using Gm = Autodesk.AutoCAD.Geometry;
  34:  using Clr = Autodesk.AutoCAD.Colors;
  35:  using Wn = Autodesk.AutoCAD.Windows;
  36:  using Hs = Autodesk.AutoCAD.DatabaseServices
  37:  .HostApplicationServices;
  38:  using Us = Autodesk.AutoCAD.DatabaseServices
  39:  .SymbolUtilityServices;
  40:  using Int = Autodesk.AutoCAD.Interop;
  41:  using Com = Autodesk.AutoCAD.Interop.Common;
  42:  #endif // #if AUTOCAD
  43:   
  44:  [assembly: Rt.CommandClass(typeof(
  45:    Bushman.CAD.Samples.Styles.TableStyleSample))]
  46:   
  47:  namespace Bushman.CAD.Samples.Styles {
  48:   
  49:    public class TableStyleSample {
  50:      // Наименование группы команд
  51:      const String group = "Samples";
  52:      const String textStyleName = "Текст таблиц";
  53:      const String tableStyleName = "Базовый";
  54:      const String tableStyle2Name =
  55:        "Спецификация металла";
  56:   
  57:      [Rt.CommandMethod(group, "BaseTableStyle",
  58:        Rt.CommandFlags.Modal)]
  59:      public void BaseTableStyle_Command() {
  60:        Ap.Document doc = cad.DocumentManager
  61:          .MdiActiveDocument;
  62:        if(doc == null)
  63:          return;
  64:        Db.Database db = doc.Database;
  65:        Ed.Editor ed = doc.Editor;
  66:        using(doc.LockDocument()) {
  67:          Int.AcadDocument activeDocument =
  68:            default(Int.AcadDocument);
  69:  #if !NEWER_THAN_AUTOCAD_2009
  70:          activeDocument = (Int.AcadDocument)cad
  71:            .DocumentManager.MdiActiveDocument
  72:            .AcadDocument;
  73:  #else
  74:          activeDocument = (Int.AcadDocument)
  75:            Ap.DocumentExtension.GetAcadDocument(
  76:            cad.DocumentManager.MdiActiveDocument);
  77:  #endif
  78:          using(Db.Transaction tr =
  79:            db.TransactionManager.StartTransaction(
  80:            )) {
  81:   
  82:            // Создаём новый текстовый стиль, 
  83:            // который будем использовать в нашем
  84:            // табличном стиле         
  85:            Db.TextStyleTable tst = tr.GetObject(
  86:              db.TextStyleTableId, Db.OpenMode
  87:              .ForWrite) as Db.TextStyleTable;
  88:            Db.ObjectId textStyleId = Db.ObjectId
  89:              .Null;
  90:   
  91:            if(tst.Has(textStyleName)) {
  92:              textStyleId = tst[textStyleName];
  93:            }
  94:            else {
  95:              Db.TextStyleTableRecord textStyle =
  96:                new Db.TextStyleTableRecord();
  97:              textStyle.Name = textStyleName;
  98:              // ttf или, к примеру, shx файл.
  99:              textStyle.FileName = "Arial.ttf";
 100:              textStyle.XScale = 0.75;
 101:              tst.Add(textStyle);
 102:              tr.AddNewlyCreatedDBObject(textStyle,
 103:                true);
 104:              textStyleId = textStyle.ObjectId;
 105:            }
 106:   
 107:            Db.DBDictionary tableStylesDictionary =
 108:              tr.GetObject(
 109:                db.TableStyleDictionaryId,
 110:                Db.OpenMode.ForWrite) as
 111:                Db.DBDictionary;
 112:   
 113:            Db.TableStyle tableStyle;
 114:            Db.ObjectId tableStyleId = Db.ObjectId
 115:              .Null;
 116:   
 117:            // Если табличный стиль с таким именем 
 118:            // уже существует, то завершаем работу 
 119:            // метода.
 120:            if(tableStylesDictionary.Contains(
 121:              tableStyleName)) {
 122:              return;
 123:            }
 124:            // Если нужный нам табличный стиль 
 125:            // отсутствует, то создаём его.
 126:            else {
 127:              tableStyle = new Db.TableStyle();
 128:              tableStyleId = tableStylesDictionary
 129:                .SetAt(tableStyleName, tableStyle);
 130:              tr.AddNewlyCreatedDBObject(
 131:                tableStyle, true);
 132:            }
 133:   
 134:            // Некоторые операции будут выполняться 
 135:            // через COM, т.к. некоторые настройки 
 136:            // автору этого кода удалось выполнить 
 137:            // только через COM.
 138:  #if !NEWER_THAN_AUTOCAD_2009
 139:            Com.IAcadTableStyle2 customTableStyle =
 140:              (Com.IAcadTableStyle2)tableStyle
 141:              .AcadObject;
 142:  #else
 143:            Com.IAcadTableStyle customTableStyle =
 144:              (Com.IAcadTableStyle)tableStyle
 145:              .AcadObject;
 146:  #endif
 147:            // Табличный стиль создан. Теперь нужно
 148:            // выполнить его настройку. Свойство 
 149:            // Table direction в диалоговом окне 
 150:            // Modify Table Style.
 151:            customTableStyle.FlowDirection =
 152:              Com.AcTableDirection
 153:              .acTableTopToBottom;
 154:   
 155:            // Примечание к нашему табличному стилю
 156:            tableStyle.Description =
 157:              "Этот табличный стиль создан " +
 158:              "программно.";
 159:   
 160:            // Большинство настроек табличного 
 161:            // стиля хранятся в настройках стилей 
 162:            // ячеек (Cell styles). Каждый стиль 
 163:            // ячеек содержит настройки, которые в 
 164:            // диалоговом окне Modify Table Style 
 165:            // отображаются на вкладках General, 
 166:            // Text и Borders. 
 167:   
 168:            // Работа с пользовательскими стилями 
 169:            // ячеек выполняется через COM API:
 170:            CreateCustomCellStyles(tableStyle,
 171:              textStyleId, db.ContinuousLinetype);
 172:            // Работа со встроенными стилями ячеек 
 173:            // возможна как через COM API, так и 
 174:            // через .NET API:
 175:            InitializeEmbededCellStyles(tableStyle,
 176:              textStyleId);
 177:            tr.Commit();
 178:          }
 179:        }
 180:      }
 181:   
 182:      [Rt.CommandMethod(group,
 183:        "TableStyleWithTemplate",
 184:        Rt.CommandFlags.Modal)]
 185:      public void TableStyleWithTemplate_Command() {
 186:        Ap.Document doc = cad.DocumentManager
 187:          .MdiActiveDocument;
 188:        if(doc == null)
 189:          return;
 190:        Db.Database db = doc.Database;
 191:        Ed.Editor ed = doc.Editor;
 192:        using(doc.LockDocument()) {
 193:          Int.AcadDocument activeDocument =
 194:            default(Int.AcadDocument);
 195:  #if !NEWER_THAN_AUTOCAD_2009
 196:          activeDocument = (Int.AcadDocument)
 197:            cad.DocumentManager.MdiActiveDocument
 198:            .AcadDocument;
 199:  #else
 200:          activeDocument = (Int.AcadDocument)
 201:            Ap.DocumentExtension.GetAcadDocument(
 202:            cad.DocumentManager.MdiActiveDocument);
 203:  #endif
 204:          using(Db.Transaction tr =
 205:            db.TransactionManager.StartTransaction(
 206:            )) {
 207:            Db.DBDictionary tableStylesDictionary =
 208:              tr.GetObject(
 209:              db.TableStyleDictionaryId,
 210:              Db.OpenMode.ForWrite) as
 211:              Db.DBDictionary;
 212:   
 213:            Db.TableStyle tableStyle = null;
 214:            Db.ObjectId tableStyleId =
 215:              Db.ObjectId.Null;
 216:   
 217:            // Если целевой табличный стиль уже 
 218:            // существует, то завершаем работу 
 219:            // метода
 220:            if(tableStylesDictionary.Contains(
 221:              tableStyle2Name)) {
 222:              return;
 223:            }
 224:   
 225:            // Если базовый табличный стиль с таким 
 226:            // именем отсутствует, то создаём его
 227:            if(!tableStylesDictionary.Contains(
 228:              tableStyleName)) {
 229:              BaseTableStyle_Command();
 230:            }
 231:            tableStyleId = tableStylesDictionary
 232:              .GetAt(tableStyleName);
 233:            tableStyle = tr.GetObject(tableStyleId,
 234:              Db.OpenMode.ForWrite) as
 235:              Db.TableStyle;
 236:   
 237:  #if !NEWER_THAN_AUTOCAD_2009
 238:            Com.IAcadTableStyle2 customTableStyle =
 239:              (Com.IAcadTableStyle2)tableStyle
 240:              .AcadObject;
 241:  #else
 242:            Com.IAcadTableStyle customTableStyle =
 243:              (Com.IAcadTableStyle)tableStyle
 244:              .AcadObject;
 245:  #endif
 246:            // Теперь посмотрим, как табличному 
 247:            // стилю назначать в качестве шаблона 
 248:            // некоторую таблицу. Т.е. как 
 249:            // программно сделать то, что делает 
 250:            // пользователь при помощи кнопки 
 251:            // "select table to start from"
 252:            // в диалоговом окне "Modify Table 
 253:            // Style".
 254:   
 255:            // Шаг 1: Сначала создаём таблицу, 
 256:            // которая должна применяться в 
 257:            // качестве шаблона.
 258:            Db.Table table = new Db.Table();
 259:            table.SetDatabaseDefaults();
 260:            table.TableStyle = tableStyleId;
 261:            table.Position = new Gm.Point3d(0, 0, 0
 262:              );
 263:            const Int32 columnsCount = 8;
 264:            const Int32 rowsCount = 11;
 265:            table.SetSize(columnsCount, rowsCount);
 266:            table.Height = 15;
 267:            table.Width = 20;
 268:            table.ColorIndex = 5;
 269:   
 270:            // Заполняем таблицу...
 271:            String[,] str = new String[
 272:              columnsCount, rowsCount];
 273:            // Для начала инициализируем всё 
 274:            // пустыми значениями, дабы массив в
 275:            // дальнейшем можно было обрабатывать в 
 276:            // цикле
 277:            for(Int32 i = 0; i < columnsCount; i++) {
 278:              for(int j = 0; j < rowsCount; j++) {
 279:                str[i, j] = String.Empty;
 280:              }
 281:            }
 282:   
 283:            // Теперь заполняем конкретные, 
 284:            // интересующие нас ячейки
 285:            str[0, 0] = "Спецификация металла";
 286:            str[1, 0] = "Марка";
 287:            str[1, 1] = "Поз.";
 288:            str[1, 2] = "Наименование";
 289:            str[1, 3] = "Сечение";
 290:            str[1, 5] = "Длина";
 291:            str[1, 6] = "Кол.";
 292:            str[1, 7] = "Масса, кг";
 293:            str[2, 7] = "ед.";
 294:            str[2, 8] = "общ.";
 295:            str[1, 9] = "Материал";
 296:            str[1, 10] = "Приме- чание";
 297:            str[2, 3] = "t";
 298:            str[2, 4] = @"\A1;{A, см\H0.7x;\S2^;}";
 299:   
 300:            for(int i = 0; i < columnsCount; i++) {
 301:              for(int j = 0; j < rowsCount; j++) {
 302:  #if !NEWER_THAN_AUTOCAD_2009
 303:                table.SetColumnWidth(j, 60);
 304:                table.SetTextHeight(i, j, 5);
 305:                table.SetTextString(i, j, str[i, j]
 306:                );
 307:                table.SetAlignment(i, j, 
 308:                Db.CellAlignment.MiddleCenter);
 309:  #else
 310:                // Так можно назначить высоту 
 311:                // текста в конкретной ячейке:
 312:                // table.Cells[i, j].TextHeight = 
 313:                // 5;
 314:   
 315:                // Назначаем значение конкретной 
 316:                // ячейке
 317:                table.Cells[i, j].SetValue(str[
 318:                  i, j],
 319:                  Db.ParseOption.ParseOptionNone);
 320:                // Так можно выровнять содержимое 
 321:                // конкретной ячейки
 322:                // table.Cells[i, j].Alignment = 
 323:                // Db.CellAlignment.MiddleCenter;
 324:  #endif
 325:              }
 326:  #if !NEWER_THAN_AUTOCAD_2009
 327:              table.SetRowHeight(i, 10.0);
 328:   
 329:              table.SetColumnWidth(0, 10);
 330:              table.SetColumnWidth(1, 10);
 331:              table.SetColumnWidth(2, 50);
 332:              table.SetColumnWidth(3, 10);
 333:              table.SetColumnWidth(4, 10);
 334:              table.SetColumnWidth(5, 10);
 335:              table.SetColumnWidth(6, 10);
 336:              table.SetColumnWidth(7, 15);
 337:              table.SetColumnWidth(8, 15);
 338:              table.SetColumnWidth(9, 25);
 339:              table.SetColumnWidth(10, 15);
 340:  #else
 341:              // При желании можно назначать 
 342:              // настройки строкам или столбцам:
 343:              // Наименование таблицы
 344:              // table.Rows[0].TextHeight = 5;
 345:              //Заголовок
 346:              // table.Rows[1].TextHeight = 3.5;
 347:              // table.Rows[2].TextHeight = 3.5;
 348:              // однако предпочтительней 
 349:              // пользоваться настройками стилей 
 350:              // ячеек.
 351:   
 352:              table.Rows[i].Height = 8;
 353:              table.Columns[0].Width = 10;
 354:              table.Columns[1].Width = 10;
 355:              table.Columns[2].Width = 50;
 356:              table.Columns[3].Width = 10;
 357:              table.Columns[4].Width = 10;
 358:              table.Columns[5].Width = 15;
 359:              table.Columns[6].Width = 10;
 360:              table.Columns[7].Width = 15;
 361:              table.Columns[8].Width = 15;
 362:              table.Columns[9].Width = 25;
 363:              table.Columns[10].Width = 15;
 364:  #endif
 365:            }
 366:   
 367:  #if !NEWER_THAN_AUTOCAD_2009
 368:            // Автору кода не удалось найти способ 
 369:            // назначить стиль ячеек строкам, а не 
 370:            // ячейкам для AutoCAD 2009. 
 371:   
 372:            // Автору кода не удалось найти способ 
 373:            // задать выравнивание столбцам для 
 374:            // AutoCAD 2009 
 375:   
 376:            // Дополнительные настройки следует 
 377:            // выполнять после того, как ячейкам, 
 378:            // строкам и столбцам будут назначены 
 379:            // нужные стили. Иначе все изменения 
 380:            // будут переопределены настройками 
 381:            // стилей ячеек.
 382:            // Например, назначаем поворот 
 383:            // содержимого некоторых ячеек в 
 384:            // заголовке таблицы:
 385:            table.SetTextRotation(1, 0, 
 386:              Db.RotationAngle.Degrees090);
 387:            table.SetTextRotation(1, 1, 
 388:              Db.RotationAngle.Degrees090);
 389:  #else
 390:            // Назначаем выравнивание столбцам
 391:            for(Int32 i = 0; i < columnsCount; i++) {
 392:              table.Columns[i].Alignment =
 393:                Db.CellAlignment.MiddleCenter;
 394:            }
 395:   
 396:            // Назначаем выравнивание строкам 
 397:            // (наименованию таблицы и заголовку)
 398:            for(Int32 i = 0; i < 3; i++) {
 399:              table.Rows[i].Alignment =
 400:                Db.CellAlignment.MiddleCenter;
 401:              if(i == 0)
 402:                table.Rows[i].Style = "_TITLE";
 403:              else
 404:                table.Rows[i].Style = "_HEADER";
 405:            }
 406:            // Дополнительные настройки следует 
 407:            // выполнять после того, как
 408:            // ячейкам, строкам и столбцам будут 
 409:            // назначены нужные стили. 
 410:            // Иначе все изменения будут 
 411:            // переопределены настройками стилей 
 412:            // ячеек. Например, назначаем поворот 
 413:            // содержимого некоторых ячеек в 
 414:            // заголовке таблицы:
 415:            table.Cells[1, 0].Contents[0].Rotation
 416:              = 90.0 * Math.PI / 180;
 417:            table.Cells[1, 1].Contents[0].Rotation
 418:              = 90.0 * Math.PI / 180;
 419:  #endif
 420:   
 421:  #if !NEWER_THAN_AUTOCAD_2009
 422:            Db.CellRange rng = new Db.CellRange(2, 
 423:              0, 3, 1);
 424:   
 425:            // Вертикальное объединение ячеек
 426:            Db.CellRange rngMark = new Db.CellRange
 427:              (1, 0, 2, 0);
 428:            Db.CellRange rngPos = new Db.CellRange
 429:              (1, 1, 2, 1);
 430:            Db.CellRange rngName = new Db.CellRange
 431:              (1, 2, 2, 2);
 432:            Db.CellRange rngCount = 
 433:              new Db.CellRange(1, 6, 2, 6);
 434:            Db.CellRange rngMaterial = 
 435:              new Db.CellRange(1, 9, 2, 9);
 436:            Db.CellRange rngDescript = 
 437:              new Db.CellRange(1, 10, 2, 10);
 438:   
 439:            // Горизонтальное объединение ячеек
 440:            Db.CellRange rngSection = 
 441:              new Db.CellRange(1, 3, 1, 4);
 442:            Db.CellRange rngArea = 
 443:              new Db.CellRange(2, 4, 2, 5);
 444:            Db.CellRange rngMass = 
 445:              new Db.CellRange(1, 7, 1, 8);
 446:   
 447:   
 448:  #else
 449:            // Вертикальное объединение ячеек
 450:            Db.CellRange rngMark = Db.CellRange
 451:              .Create(table, 1, 0, 2, 0);
 452:            Db.CellRange rngPos = Db.CellRange
 453:              .Create(table, 1, 1, 2, 1);
 454:            Db.CellRange rngName = Db.CellRange
 455:              .Create(table, 1, 2, 2, 2);
 456:            Db.CellRange rngCount = Db.CellRange
 457:              .Create(table, 1, 6, 2, 6);
 458:            Db.CellRange rngMaterial = Db.CellRange
 459:              .Create(table, 1, 9, 2, 9);
 460:            Db.CellRange rngDescript = Db.CellRange
 461:              .Create(table, 1, 10, 2, 10);
 462:   
 463:            // Горизонтальное объединение ячеек
 464:            Db.CellRange rngSection = Db.CellRange
 465:              .Create(table, 1, 3, 1, 4);
 466:            Db.CellRange rngArea = Db.CellRange
 467:              .Create(table, 2, 4, 2, 5);
 468:            Db.CellRange rngMass = Db.CellRange
 469:              .Create(table, 1, 7, 1, 8);
 470:  #endif
 471:   
 472:            table.MergeCells(rngMark);
 473:            table.MergeCells(rngPos);
 474:            table.MergeCells(rngName);
 475:            table.MergeCells(rngCount);
 476:            table.MergeCells(rngMaterial);
 477:            table.MergeCells(rngDescript);
 478:            table.MergeCells(rngSection);
 479:            table.MergeCells(rngArea);
 480:            table.MergeCells(rngMass);
 481:   
 482:            table.GenerateLayout();
 483:   
 484:            // Шаг 2: Назначаем созданную нами выше 
 485:            // таблицу, шаблоном для табличного 
 486:            // стиля
 487:            Db.TableStyle tableStyle2 =
 488:              new Db.TableStyle();
 489:            tableStyle2.CopyFrom(tableStyle);
 490:   
 491:            Db.ObjectId tableStyle2Id =
 492:              tableStylesDictionary.SetAt(
 493:              tableStyle2Name, tableStyle2);
 494:            tr.AddNewlyCreatedDBObject(tableStyle2,
 495:              true);
 496:   
 497:            Db.TableTemplate template =
 498:              new Db.TableTemplate(
 499:                table, Db.TableCopyOptions
 500:                .TableCopyColumnWidth |
 501:                Db.TableCopyOptions
 502:                .TableCopyRowHeight |
 503:                Db.TableCopyOptions
 504:                .ConvertFormatToOverrides);
 505:            db.AddDBObject(template);
 506:            tr.AddNewlyCreatedDBObject(template,
 507:              true);
 508:   
 509:  #if NEWER_THAN_AUTOCAD_2009
 510:            tableStyle2.Template =
 511:              template.ObjectId;
 512:  #else
 513:            Com.IAcadTableStyle2 customTableStyle2 
 514:            = (Com.IAcadTableStyle2)tableStyle2
 515:            .AcadObject;
 516:  #if PLATFORM_X86
 517:            customTableStyle2.TemplateId = template
 518:            .ObjectId.OldIdPtr.ToInt32();
 519:  #else
 520:            customTableStyle2.TemplateId = template
 521:            .ObjectId.OldIdPtr.ToInt64();
 522:  #endif // #if PLATFORM_X86
 523:  #endif // #if NEWER_THAN_AUTOCAD_2009
 524:            tr.Commit();
 525:          }
 526:        }
 527:      }
 528:   
 529:      /// <summary>
 530:      /// В пространстве модели создать таблицу на 
 531:      /// основе табличного стиля "Базовый". Точка 
 532:      /// вставки таблицы: 0,0,0.
 533:      /// </summary>
 534:      [Rt.CommandMethod(group, "CreateTable",
 535:        Rt.CommandFlags.Modal)]
 536:      public void CreateTable() {
 537:        Ap.Document doc = cad.DocumentManager
 538:          .MdiActiveDocument;
 539:        if(doc == null)
 540:          return;
 541:        Db.Database db = doc.Database;
 542:        using(doc.LockDocument()) {
 543:          using(Db.Transaction tr =
 544:            db.TransactionManager.StartTransaction(
 545:            )) {
 546:            Db.DBDictionary dict = tr.GetObject(
 547:              db.TableStyleDictionaryId,
 548:              Db.OpenMode.ForRead) as
 549:              Db.DBDictionary;
 550:            if(!dict.Contains(tableStyle2Name))
 551:              TableStyleWithTemplate_Command();
 552:            Db.TableStyle ts = tr.GetObject(dict
 553:              .GetAt(tableStyleName),
 554:              Db.OpenMode.ForRead) as Db.TableStyle
 555:              ;
 556:            // Включим отображение толщин линий, 
 557:            // дабы увидеть результат нашей работы
 558:            cad.SetSystemVariable("LWDISPLAY", 1);
 559:            // Создаём новую таблицу, на основе 
 560:            // созданного нами стиля.
 561:            Db.Table tableInstance = new Db.Table()
 562:              ;
 563:            tableInstance.SetDatabaseDefaults();
 564:            tableInstance.TableStyle = ts.ObjectId;
 565:            tableInstance.SetSize(10, 5);
 566:            tableInstance.GenerateLayout();
 567:            tableInstance.Position =
 568:              new Gm.Point3d(0, 0, 0);
 569:            Db.BlockTable bt = tr.GetObject(
 570:              db.BlockTableId, Db.OpenMode.ForRead)
 571:                as Db.BlockTable;
 572:            Db.BlockTableRecord modelSpace =
 573:              tr.GetObject(bt[
 574:              Db.BlockTableRecord.ModelSpace],
 575:              Db.OpenMode.ForWrite) as
 576:              Db.BlockTableRecord;
 577:            modelSpace.AppendEntity(tableInstance);
 578:            tr.AddNewlyCreatedDBObject(
 579:              tableInstance, true);
 580:            tr.Commit();
 581:          }
 582:        }
 583:        Object acadObject = cad.AcadApplication;
 584:        acadObject.GetType().InvokeMember(
 585:          "ZoomExtents", BindingFlags.InvokeMethod,
 586:          null, acadObject, null);
 587:      }
 588:   
 589:      /// <summary>
 590:      /// В пространстве модели создать таблицу на 
 591:      /// основе шаблона, указанного в табличном 
 592:      /// стиле "Спецификация металла". Точка 
 593:      /// вставки таблицы: 50,0,0.
 594:      /// </summary>
 595:      [Rt.CommandMethod(group, "CreateTable2",
 596:        Rt.CommandFlags.Modal)]
 597:      public void CreateTable2() {
 598:        Ap.Document doc = cad.DocumentManager
 599:          .MdiActiveDocument;
 600:        if(doc == null)
 601:          return;
 602:        Db.Database db = doc.Database;
 603:        using(doc.LockDocument()) {
 604:          using(Db.Transaction tr =
 605:            db.TransactionManager.StartTransaction(
 606:            )) {
 607:            Db.DBDictionary dict = tr.GetObject(
 608:              db.TableStyleDictionaryId,
 609:              Db.OpenMode.ForRead) as
 610:              Db.DBDictionary;
 611:            if(!dict.Contains(tableStyle2Name))
 612:              TableStyleWithTemplate_Command();
 613:            Db.TableStyle ts = tr.GetObject(dict
 614:              .GetAt(tableStyle2Name),
 615:              Db.OpenMode.ForRead) as Db.TableStyle
 616:              ;
 617:            Db.TableTemplate template =
 618:              tr.GetObject(ts.Template,
 619:              Db.OpenMode.ForRead) as
 620:              Db.TableTemplate;
 621:            // Включим отображение толщин линий, 
 622:            // дабы увидеть результат нашей работы
 623:            cad.SetSystemVariable("LWDISPLAY", 1);
 624:            // Создаём новую таблицу, на основе 
 625:            // созданного нами шаблона.
 626:            Db.Table tableInstance = new Db.Table()
 627:              ;
 628:            tableInstance.CopyFrom(template,
 629:              Db.TableCopyOptions.FillTarget);
 630:            tableInstance.GenerateLayout();
 631:            tableInstance.Position =
 632:              new Gm.Point3d(50, 0, 0);
 633:            Db.BlockTable bt = tr.GetObject(
 634:              db.BlockTableId, Db.OpenMode.ForRead)
 635:                as Db.BlockTable;
 636:            Db.BlockTableRecord modelSpace =
 637:              tr.GetObject(bt[
 638:              Db.BlockTableRecord.ModelSpace],
 639:              Db.OpenMode.ForWrite) as
 640:              Db.BlockTableRecord;
 641:            modelSpace.AppendEntity(tableInstance);
 642:            tr.AddNewlyCreatedDBObject(
 643:              tableInstance, true);
 644:            tr.Commit();
 645:          }
 646:        }
 647:        Object acadObject = cad.AcadApplication;
 648:        acadObject.GetType().InvokeMember(
 649:          "ZoomExtents", BindingFlags.InvokeMethod,
 650:          null, acadObject, null);
 651:      }
 652:   
 653:      /// <summary>
 654:      /// Настройка встроенных стилей ячеек. 
 655:      /// Встроенными являются стили: _TITLE, 
 656:      /// _HEADER и _DATA.
 657:      /// </summary>
 658:      /// <param name="tableStyle">Табличный стиль, 
 659:      /// подлежащий редактированию.
 660:      /// </param>
 661:      /// <param name="textStyleId">Идентификатор 
 662:      /// текстового стиля, который 
 663:      /// должен использоваться в создаваемых 
 664:      /// стилях ячеек.</param>
 665:      private void InitializeEmbededCellStyles(
 666:        Db.TableStyle tableStyle,
 667:        Db.ObjectId textStyleId) {
 668:        Db.Database db = tableStyle.Database;
 669:        // Некоторые операции будут выполняться 
 670:        // через COM, т.к. некоторые 
 671:        // настройки автору этого кода удалось 
 672:        // выполнить только через COM.
 673:  #if !NEWER_THAN_AUTOCAD_2009
 674:        Com.IAcadTableStyle2 customTableStyle =
 675:          (Com.IAcadTableStyle2)tableStyle
 676:          .AcadObject;
 677:  #else
 678:        Com.IAcadTableStyle customTableStyle =
 679:          (Com.IAcadTableStyle)tableStyle
 680:          .AcadObject;
 681:  #endif
 682:   
 683:        // Большинство настроек табличного стиля 
 684:        // хранятся в настройках стилей ячеек (Cell
 685:        // styles). Каждый стиль ячеек содержит 
 686:        // настройки, которые в диалоговом окне 
 687:        // Modify Table Style отображаются на 
 688:        // вкладках General, Text и Borders.      
 689:   
 690:        //*****************************************
 691:   
 692:        // 1. ВКЛАДКА "GENERAL" ДИАЛОГОВОГО ОКНА 
 693:        // "MODIFY TABLE STYLE":
 694:   
 695:        // В интересующем нас стиле ячеек, 
 696:        // устанавливем цвет фона ячеек (если это 
 697:        // нам нужно). Автор кода не нашёл способа 
 698:        // установить цвет фона для 
 699:        // пользовательских стилей ячеек. Есть 
 700:        // возможность устанавливать фон ячеек для 
 701:        // встроенных стилей Title, Header и Data:          
 702:        String strColor = String.Format(
 703:          "Autocad.AcCmColor.{0}", cad.Version
 704:          .Major);
 705:        Com.AcadAcCmColor color = (
 706:          (Int.AcadApplication)cad.AcadApplication)
 707:            .GetInterfaceObject(strColor) as
 708:            Com.AcadAcCmColor;
 709:        color.SetRGB(250, 0, 0);
 710:   
 711:        // Однако установить и получить фон мы 
 712:        // можем и посредством .NET API:
 713:        // tableStyle.SetBackgroundColor(Clr.Color
 714:        // .FromColorIndex(Clr.ColorMethod
 715:        // .Foreground, 31), (Int32)Db.RowType
 716:        // .DataRow);
 717:   
 718:        // Убираем фон
 719:        tableStyle.SetBackgroundColorNone(true,
 720:          (Int32)Db.RowType.DataRow);
 721:   
 722:        // Получаем фон через .NET API:
 723:        //Clr.Color dataBgColor = tableStyle
 724:        // .BackgroundColor(Db.RowType.DataRow);
 725:   
 726:        // Назначить выравнивание в стиле ячеек 
 727:        // через .NET API
 728:        tableStyle.SetAlignment(
 729:          Db.CellAlignment.TopLeft,
 730:          (Int32)Db.RowType.DataRow);
 731:   
 732:        // Получить выравнивание в стиле ячеек 
 733:        // через .NET API
 734:        // Db.CellAlignment _datAlignment = 
 735:        // tableStyle.Alignment(Db.RowType.DataRow)
 736:        // ;
 737:   
 738:        // Опция 'Format' (кнопка с тремя точками)
 739:        // Если нажать на эту кнопку, то откроется 
 740:        // диалоговое окно "Table Cell Format".
 741:        // Значением 'format' является строковое 
 742:        // значение. Простейший способ получения 
 743:        // этого значения следующий:
 744:        // 1. Установите в диалоговом окне 
 745:        // "Table Cell Format" нужный формат 
 746:        // вручную.
 747:        // 2. Посмотрите значение сгенерированной 
 748:        // строки, воспользовавшись методом 
 749:        // GetFormat2 (см. код ниже). 
 750:   
 751:        // Устанавливаем формат стиля ячеек через 
 752:        // .NET API
 753:        tableStyle.SetFormat("%lu2%pr3%ps[,%]",
 754:          Db.RowType.DataRow);
 755:   
 756:        // Получаем формат стиля ячеек через .NET 
 757:        // API
 758:        // String datFormat = tableStyle.Format(
 759:        // Db.RowType.DataRow);
 760:   
 761:        // Устанавливаем тип данных и единиц 
 762:        // измерения через .NET API
 763:        tableStyle.SetDataType(Db.DataType.Double,
 764:          Db.UnitType.Distance, Db.RowType.DataRow)
 765:          ;
 766:        // Получаем тип данных и единиц измерения 
 767:        // через .NET API
 768:        // Db.DataType _dataType = tableStyle
 769:        // .DataType(Db.RowType.DataRow);
 770:        // Db.UnitType _unitType = tableStyle
 771:        // .UnitType(Db.RowType.DataRow);
 772:   
 773:        // Устанавливаем значения опцииям 
 774:        // 'horizontal margins' и 'vertical 
 775:        // margins'
 776:   
 777:        // Встроенные стили ячеек имеют имена: 
 778:        // _TITLE, _HEADER, _DATA.
 779:        String name = "_HEADER";
 780:  #if !NEWER_THAN_AUTOCAD_2009
 781:        // Мне не удалось получить и назначить 
 782:        // значения опциям 'horizontal 
 783:        // margins' и 'vertical margins' в AutoCAD 
 784:        // 2009 ни через .NET API, ни через COM API
 785:  #else
 786:        tableStyle.SetMargin(Db.CellMargins.Left,
 787:          1.0, name);
 788:        tableStyle.SetMargin(Db.CellMargins.Top,
 789:          1.0, name);
 790:   
 791:        // Получить значения опций 'horizontal 
 792:        // margins' и 'vertical margins'
 793:        // можно так:
 794:        // Double _leftMargin = tableStyle.Margin(
 795:        // Db.CellMargins.Left, name);
 796:        // Double _topMargin = tableStyle.Margin(
 797:        // Db.CellMargins.Top, name);
 798:  #endif
 799:        // Устанавливаем значение свойства 'Merge 
 800:        // cells on row/column creation' через COM 
 801:        // API
 802:        customTableStyle.EnableMergeAll(name, false
 803:          );
 804:   
 805:        // Получаем значение свойства 'Merge cells
 806:        // on row/column creation' через COM API
 807:        // Boolean isMergedCells = customTableStyle
 808:        // .GetIsMergeAllEnabled(name);
 809:   
 810:        //*****************************************
 811:   
 812:        //2. ВКЛАДКА 'TEXT' ДИАЛОГОВОГО ОКНА 
 813:        // "MODIFY TABLE STYLE":
 814:   
 815:        // Получение через COM API текстового 
 816:        // стиля, назначенного стилю ячеек 
 817:        // Db.ObjectId _textStyleId = 
 818:        // new Db.ObjectId(new IntPtr(
 819:        // customTableStyle.GetTextStyleId(name)));
 820:   
 821:        // Назначение текстового стиля стилю ячеек 
 822:        // через .NET API
 823:        tableStyle.SetTextStyle(textStyleId,
 824:          (Int32)Db.RowType.TitleRow);
 825:        tableStyle.SetTextStyle(textStyleId,
 826:          (Int32)Db.RowType.HeaderRow);
 827:        tableStyle.SetTextStyle(textStyleId,
 828:          (Int32)Db.RowType.DataRow);
 829:        // Получение через .NET API текстового 
 830:        // стиля, назначенного стилю ячеек 
 831:        // Db.ObjectId _dataRowTextStyleId = 
 832:        // tableStyle.TextStyle(Db.RowType.DataRow)
 833:        // ;
 834:   
 835:        // Назначение высоты текста через .NET API          
 836:        tableStyle.SetTextHeight(5,
 837:          (Int32)Db.RowType.TitleRow); // TITLE
 838:        tableStyle.SetTextHeight(3.5,
 839:          (Int32)Db.RowType.HeaderRow); // HEADER
 840:        tableStyle.SetTextHeight(3.5,
 841:          (Int32)Db.RowType.DataRow); // DATA
 842:   
 843:        // Получение высоты текста через .NET API
 844:        // Double _dataRowTextHeight = tableStyle
 845:        // .TextHeight(Db.RowType.DataRow);
 846:   
 847:        // Назначение цвета тексту через .NET API      
 848:        Autodesk.AutoCAD.Colors.Color colTitleText
 849:          = Clr.Color.FromColorIndex(
 850:           Clr.ColorMethod.ByColor, 10);
 851:        Autodesk.AutoCAD.Colors.Color colHdText =
 852:          Clr.Color.FromColorIndex(
 853:            Clr.ColorMethod.ByColor, 210);
 854:        Autodesk.AutoCAD.Colors.Color colDataText =
 855:          Clr.Color.FromColorIndex(
 856:           Clr.ColorMethod.ByColor, 10);
 857:   
 858:        tableStyle.SetColor(colTitleText,
 859:          (Int32)Db.RowType.TitleRow);
 860:        tableStyle.SetColor(colHdText,
 861:          (Int32)Db.RowType.HeaderRow);
 862:        tableStyle.SetColor(colDataText,
 863:          (Int32)Db.RowType.DataRow);
 864:   
 865:        // Получение цвета текста через .NET API
 866:        // Clr.Color _textColor2 = tableStyle
 867:        // .Color(Db.RowType.DataRow);
 868:   
 869:        // Назначение угла наклона текста через COM 
 870:        // API
 871:        Double angle = 0; // значение в градусах
 872:        // Градусы необходимо преобразовывать в 
 873:        // радианы
 874:        customTableStyle.SetRotation(name, angle *
 875:          Math.PI / 180);
 876:   
 877:        // Получение угла наклона текста через COM 
 878:        // API
 879:        // Double _angle = customTableStyle
 880:        // .GetRotation(name) * 180.0 / Math.PI;
 881:   
 882:        //*****************************************
 883:   
 884:        // ВКЛАДКА 'BORDERS' ДИАЛОГОВОГО ОКНА 
 885:        // "MODIFY TABLE STYLE":
 886:   
 887:        // Назначение толщин линий границам ячеек 
 888:        // через .NET API
 889:        tableStyle.SetGridLineWeight(Db.LineWeight
 890:          .LineWeight050,
 891:            (Int32)Db.GridLineType.VerticalInside,
 892:            (Int32)Db.RowType.DataRow);
 893:   
 894:        tableStyle.SetGridLineWeight(Db.LineWeight
 895:          .LineWeight018,
 896:            (Int32)Db.GridLineType.HorizontalInside
 897:            , (Int32)Db.RowType.DataRow);
 898:   
 899:        tableStyle.SetGridLineWeight(Db.LineWeight
 900:          .LineWeight050,
 901:            (Int32)Db.GridLineType.OuterGridLines,
 902:            (Int32)Db.RowType.DataRow);
 903:   
 904:        tableStyle.SetGridLineWeight(Db.LineWeight
 905:          .LineWeight050,
 906:            (Int32)Db.GridLineType.AllGridLines,
 907:            (Int32)Db.RowType.HeaderRow);
 908:   
 909:        // Получение толщин линий границам ячеек 
 910:        // через .NET API
 911:        // Db.LineWeight _dataRowLineWeight = 
 912:        //  tableStyle.GridLineWeight(
 913:        //    Db.GridLineType.HorizontalTop, 
 914:        //    Db.RowType.DataRow);
 915:   
 916:        // Получаем идентификатор типа линии, 
 917:        // которая будет использоваться при 
 918:        // прорисовке контура ячеек, использующих 
 919:        // созданный нами стиль ячеек.
 920:        Db.ObjectId linetypeId =
 921:          db.ContinuousLinetype;
 922:   
 923:  #if !NEWER_THAN_AUTOCAD_2009
 924:        // Мне не удалось получить, либо назначить 
 925:        // значение GridLinetype стилю ячеек в 
 926:        // AutoCAD 2009 ни через .NET API, ни через
 927:        // COM API.
 928:  #else
 929:        // Назначаем стилю ячеек нужный тип линии 
 930:        // через .NET API
 931:        tableStyle.SetGridLinetype(linetypeId,
 932:          Db.GridLineType.AllGridLines, name);
 933:   
 934:        // Получаем стиль ячеек нужного нам типа 
 935:        // линии через .NET API
 936:        // Db.GridLineStyle _linestyle = tableStyle
 937:        //  .GridLineStyle(
 938:        // Db.GridLineType.AllGridLines, name);
 939:  #endif
 940:        Autodesk.AutoCAD.Colors.Color
 941:          outerLinesColor =
 942:          Clr.Color.FromColorIndex(
 943:            Clr.ColorMethod.ByColor, 90);
 944:        // Назначаем цвет линиям сетки нашего стиля 
 945:        // ячеек через .NET API
 946:        tableStyle.SetGridColor(outerLinesColor,
 947:          (Int32)(Db.GridLineType.OuterGridLines |
 948:          Db.GridLineType.VerticalGridLines),
 949:          (Int32)Db.RowType.DataRow);
 950:   
 951:        tableStyle.SetGridColor(outerLinesColor,
 952:          (Int32)(Db.GridLineType.AllGridLines),
 953:          (Int32)Db.RowType.HeaderRow);
 954:   
 955:        Autodesk.AutoCAD.Colors.Color
 956:          horInsideLinesColor =
 957:          Clr.Color.FromColorIndex(
 958:          Clr.ColorMethod.ByColor, 130);
 959:   
 960:        tableStyle.SetGridColor(
 961:          horInsideLinesColor,
 962:          (Int32)(Db.GridLineType
 963:          .HorizontalInside), (Int32)Db.RowType
 964:          .DataRow);
 965:   
 966:        // Получаем цвет линий сетки нашего стиля 
 967:        // ячеек через .NET API
 968:        // tableStyle.GridColor((Db.GridLineType
 969:        // .HorizontalInside | Db.GridLineType
 970:        // .VerticalLeft), Db.RowType.DataRow);
 971:   
 972:        // Установка значения опции 'Double line'
 973:  #if !NEWER_THAN_AUTOCAD_2009
 974:        // Мне не удалось получить или назначить в 
 975:        // AutoCAD 2009 значение опции 'Double 
 976:        // line' ни через COM API, ни через .NET 
 977:        // API.
 978:   
 979:        // Мне не удалось получить или назначить в 
 980:        // AutoCAD 2009 значение опции 'Spacing' ни 
 981:        // через COM API, ни через .NET API.            
 982:  #else
 983:        // Установка значения опции 'Double line' 
 984:        // через .NET API
 985:        tableStyle.SetGridLineStyle(
 986:          Db.GridLineStyle.Single,
 987:          Db.GridLineType.AllGridLines, name);
 988:   
 989:        // Получение значения опции 'Double line' 
 990:        // через .NET API
 991:        // Db.GridLineStyle _dataGridLinetypeStyle 
 992:        // = tableStyle.GridLineStyle(
 993:        //    Db.GridLineType.AllGridLines, name);
 994:   
 995:        // Установка значения опции 'Spacing' через
 996:        // .NET API
 997:        tableStyle.SetGridDoubleLineSpacing(3,
 998:          Db.GridLineType.AllGridLines, name);
 999:   
1000:        // Получение значения опции 'Spacing' через
1001:        // .NET API
1002:        // Double _spacing = tableStyle
1003:        // .GridDoubleLineSpacing(
1004:        //  Db.GridLineType.AllGridLines, name);
1005:  #endif
1006:      }
1007:   
1008:      /// <summary>
1009:      /// Создать и настроить дополнительный набор 
1010:      /// стилей ячеек: Группа, Формула и Итого, 
1011:      /// помимо встроенных стилей _TITLE, _HEADER 
1012:      /// и _DATA.
1013:      /// </summary>
1014:      /// <param name="tableStyle">Табличный стиль, 
1015:      /// подлежащий редактированию.
1016:      /// </param>
1017:      /// <param name="textStyleId">Идентификатор 
1018:      /// текстового стиля, который 
1019:      /// должен использоваться в создаваемых 
1020:      /// стилях ячеек.</param>
1021:      /// <param name="linetypeId">Идентификатор 
1022:      /// типа линии, которая должна
1023:      /// использоваться в создаваемых стилях ячеек
1024:      /// </param>
1025:      private void CreateCustomCellStyles(
1026:        Db.TableStyle tableStyle, Db.ObjectId
1027:        textStyleId, Db.ObjectId linetypeId) {
1028:  #if !NEWER_THAN_AUTOCAD_2009
1029:        Com.IAcadTableStyle2 customTableStyle =
1030:          (Com.IAcadTableStyle2)tableStyle
1031:          .AcadObject;
1032:  #else
1033:        Com.IAcadTableStyle customTableStyle =
1034:          (Com.IAcadTableStyle)tableStyle
1035:          .AcadObject;
1036:  #endif
1037:   
1038:        // Имена дополнительных стилей ячеек, 
1039:        // которые мы создадим
1040:        String[] names = new String[] { "Группа", 
1041:          "Формула", "Итого" };
1042:   
1043:        foreach(String name in names) {
1044:          customTableStyle.CreateCellStyle(name);
1045:          //***************************************
1046:   
1047:          // 1. ВКЛАДКА "GENERAL" ДИАЛОГОВОГО ОКНА 
1048:          // "MODIFY TABLE STYLE":
1049:   
1050:          // Установить цвет фона пользовательского 
1051:          // стиля ячеек (опция "Fill color" в 
1052:          // настройках табличного стиля) можно 
1053:          // через COM API. Сначала нужно создать 
1054:          // цвет:
1055:          String strColor = String.Format(
1056:            "Autocad.AcCmColor.{0}",
1057:            cad.Version.Major);
1058:          Com.AcadAcCmColor color = (
1059:            (Int.AcadApplication)cad
1060:            .AcadApplication)
1061:              .GetInterfaceObject(strColor) as
1062:              Com.AcadAcCmColor;
1063:          color.SetRGB(149, 203, 149);
1064:   
1065:          // Теперь пользовательскому стилю ячеек 
1066:          // можно, посредством COM API, установить
1067:          // фон:
1068:          // customTableStyle.SetBackgroundColor2(
1069:          // name, color);
1070:   
1071:          // Сбросить ранее установленный фон можно 
1072:          // следующим образом
1073:          //Int32 cellClass = customTableStyle
1074:          // .GetCellClass(name);
1075:          //Boolean result = false;
1076:          //customTableStyle
1077:          // .SetBackgroundColorNone(cellClass, ref
1078:          // result);
1079:   
1080:          // Получить цвет фона пользовательского 
1081:          // стиля ячеек можно так же посредством 
1082:          // COM API:
1083:          // color = customTableStyle
1084:          // .GetBackgroundColor2(name);
1085:   
1086:          // Назначаем выравнивание             
1087:          customTableStyle.SetAlignment2(name,
1088:            name == "Группа" ?
1089:            Com.AcCellAlignment.acMiddleLeft :
1090:            Com.AcCellAlignment.acMiddleCenter);
1091:   
1092:          // Получить выравнивание в стиле ячеек 
1093:          // через COM API
1094:          // Com.AcCellAlignment alignment = 
1095:          // customTableStyle.GetAlignment2(name);
1096:   
1097:          // Опция 'Format' (кнопка с тремя точками
1098:          // ). Если нажать на эту кнопку, то 
1099:          // откроется диалоговое окно "Table Cell 
1100:          // Format". Значением 'format' является 
1101:          // строковое значение. Простейший способ 
1102:          // получения этого значения следующий:
1103:          // 1. Установите в диалоговом окне "Table 
1104:          // Cell Format" нужный формат вручную.
1105:          // 2. Посмотрите значение сгенерированной 
1106:          // строки, воспользовавшись методом 
1107:          // GetFormat2 (см. код ниже).                
1108:   
1109:          // String _format = null;
1110:          // Устанавливаем нужный нам формат стиля 
1111:          // ячеек через COM API
1112:          customTableStyle.SetFormat2(name,
1113:            "%au0%pr3");
1114:          // Получаем формат стиля ячеек через COM 
1115:          // API
1116:          // customTableStyle.GetFormat2(name, out
1117:          // _format);
1118:   
1119:          // Устанавливем тип данных и единиц 
1120:          // измерения через COM API
1121:          customTableStyle.SetDataType2(name,
1122:            Com.AcValueDataType.acDouble,
1123:            Com.AcValueUnitType.acUnitArea);
1124:          // Получаем тип данных и единиц измерения 
1125:          // через COM API
1126:          // Com.AcValueDataType valueDataType;
1127:          // Com.AcValueUnitType unitType;
1128:          // customTableStyle.GetDataType2(name, 
1129:          // out valueDataType, out unitType);
1130:   
1131:          // Устанавливаем значения опцииям 
1132:          // 'horizontal margins' и 'vertical 
1133:          // margins'
1134:  #if !NEWER_THAN_AUTOCAD_2009
1135:          // Автору кода не удалось получить и 
1136:          // назначить значения опциям 'horizontal
1137:          // margins' и 'vertical margins' в 
1138:          // AutoCAD 2009 ни через .NET API, ни 
1139:          // через COM API.
1140:  #else
1141:   
1142:          tableStyle.SetMargin(Db.CellMargins.Left,
1143:            1, name);
1144:          tableStyle.SetMargin(Db.CellMargins.Top,
1145:            1, name);
1146:   
1147:          // Получить значения опций 'horizontal 
1148:          // margins' и 'vertical margins'
1149:          // можно так:
1150:          // Double _leftMargin = tableStyle
1151:          // .Margin(Db.CellMargins.Left, name);
1152:          // Double _topMargin = tableStyle
1153:          // .Margin(Db.CellMargins.Top, name);
1154:  #endif
1155:          // Устанавливаем значение свойства 'Merge
1156:          // cells on row/column creation' через 
1157:          // COM API
1158:          customTableStyle.EnableMergeAll(name,
1159:            name == "Группа" ? true : false);
1160:          // Получаем значение свойства 'Merge 
1161:          // cells on row/column creation'  через 
1162:          // COM API
1163:          // Boolean isMergedCells = 
1164:          // customTableStyle.GetIsMergeAllEnabled(
1165:          // name);
1166:   
1167:          //***************************************
1168:   
1169:          //2. ВКЛАДКА 'TEXT' ДИАЛОГОВОГО ОКНА 
1170:          // "MODIFY TABLE STYLE":
1171:   
1172:          // Назначение текстового стиля стилю 
1173:          // ячеек через COM API
1174:  #if PLATFORM_X86
1175:          customTableStyle.SetTextStyleId(name,
1176:            textStyleId.OldIdPtr.ToInt32());
1177:  #else
1178:          customTableStyle.SetTextStyleId(name, 
1179:            textStyleId.OldIdPtr.ToInt64());
1180:  #endif
1181:   
1182:          // Получение через COM API текстового 
1183:          // стиля, назначенного стилю ячеек
1184:          // Db.ObjectId _textStyleId = 
1185:          // new Db.ObjectId(new IntPtr(
1186:          // customTableStyle.GetTextStyleId(name))
1187:          // );
1188:   
1189:          // Назначение высоты текста через COM API
1190:          customTableStyle.SetTextHeight2(name,
1191:            name == "Формула" ? 3.5 : 5);
1192:          // Получение высоты текста через COM API
1193:          // Double _textHeight = customTableStyle
1194:          // .GetTextHeight2(name);
1195:   
1196:          // Назначение цвета тексту через COM API
1197:          switch(name) {
1198:            case "Группа":
1199:              color.SetRGB(0, 63, 255);
1200:              break;
1201:            case "Формула":
1202:              color.SetRGB(255, 0, 0);
1203:              break;
1204:            case "Итого":
1205:              color.SetRGB(0, 153, 0);
1206:              break;
1207:            default:
1208:              break;
1209:          }
1210:          customTableStyle.SetColor2(name, color);
1211:          // Получение цвета текста через COM API
1212:          // Com.AcadAcCmColor _textColor = 
1213:          // customTableStyle.GetColor2(name);
1214:   
1215:          // Назначение угла наклона текста через 
1216:          // COM API
1217:          Double angle = 0; // значение в градусах
1218:          // Градусы необходимо преобразовывать в 
1219:          // радианы
1220:          customTableStyle.SetRotation(name, angle
1221:            * Math.PI / 180);
1222:          // Получение угла наклона текста через 
1223:          // COM API
1224:          // Double _angle = customTableStyle
1225:          // .GetRotation(name) * 180.0 / Math.PI;
1226:   
1227:          //***************************************
1228:   
1229:          // ВКЛАДКА 'BORDERS' ДИАЛОГОВОГО ОКНА 
1230:          // "MODIFY TABLE STYLE":
1231:   
1232:          // Назначение толщин линий границам ячеек
1233:          // через COM API
1234:          customTableStyle.SetGridLineWeight2(name,
1235:            Com.AcGridLineType.acHorzTop |
1236:            Com.AcGridLineType.acHorzBottom |
1237:          Com.AcGridLineType.acVertLeft |
1238:          Com.AcGridLineType.acVertRight,
1239:          Com.ACAD_LWEIGHT.acLnWt050);
1240:   
1241:          customTableStyle.SetGridLineWeight2(name,
1242:            Com.AcGridLineType.acVertInside,
1243:            Com.ACAD_LWEIGHT.acLnWt018);
1244:   
1245:          customTableStyle.SetGridLineWeight2(name,
1246:            Com.AcGridLineType.acHorzInside |
1247:            Com.AcGridLineType.acVertInside,
1248:            Com.ACAD_LWEIGHT.acLnWt018);
1249:   
1250:          // Получение толщин линий границам ячеек 
1251:          // через COM API
1252:          // Com.ACAD_LWEIGHT _lineWeight = 
1253:          // customTableStyle.GetGridLineWeight2(
1254:          //  name, Com.AcGridLineType.acHorzTop);
1255:   
1256:  #if !NEWER_THAN_AUTOCAD_2009
1257:          // Автору кода не удалось получить, либо 
1258:          // назначить значение GridLinetype стилю
1259:          // ячеек в AutoCAD 2009 ни через .NET 
1260:          // API, ни через COM API.
1261:  #else
1262:          // Назначаем стилю ячеек нужный тип линии
1263:          // через .NET API
1264:          tableStyle.SetGridLinetype(linetypeId,
1265:            Db.GridLineType.AllGridLines,
1266:            name);
1267:          // Получаем стиль ячеек нужного нам типа 
1268:          // линии через .NET API
1269:          // Db.GridLineStyle _linestyle = 
1270:          // tableStyle.GridLineStyle(
1271:          //  Db.GridLineType.AllGridLines, name);
1272:  #endif
1273:          // Назначаем цвет линиям сетки нашего 
1274:          // стиля ячеек через COM API
1275:          color.SetRGB(70, 158, 250);
1276:   
1277:          customTableStyle.SetGridColor2(name,
1278:            Com.AcGridLineType.acHorzTop |
1279:            Com.AcGridLineType.acHorzBottom |
1280:          Com.AcGridLineType.acVertLeft |
1281:          Com.AcGridLineType.acVertRight,
1282:            color);
1283:   
1284:          color.SetRGB(175, 39, 65);
1285:          customTableStyle.SetGridColor2(name,
1286:            Com.AcGridLineType.acHorzInside |
1287:            Com.AcGridLineType.acVertInside, color)
1288:            ;
1289:   
1290:          // Получаем цвет линий сетки нашего стиля 
1291:          // ячеек через COM API
1292:          // Com.AcadAcCmColor _Clror = 
1293:          // customTableStyle.GetGridColor2(
1294:          //  name, Com.AcGridLineType.acHorzTop);
1295:   
1296:          // Установка значения опции 'Double line'
1297:  #if !NEWER_THAN_AUTOCAD_2009
1298:          // Автору кода не удалось получить или 
1299:          // назначить в AutoCAD 2009 значение 
1300:          // опции 'Double line' ни через COM API, 
1301:          // ни через .NET API.
1302:   
1303:          // Мне не удалось получить или назначить 
1304:          // в AutoCAD 2009 значение опции 'Spacing'
1305:          // ни через COM API, ни через .NET API. 
1306:  #else
1307:          // Установка значения опции 'Double line'
1308:          // через .NET API
1309:          tableStyle.SetGridLineStyle(
1310:            Db.GridLineStyle.Single,
1311:            Db.GridLineType.AllGridLines, name);
1312:          // Получение значения опции 'Double line'
1313:          // через .NET API
1314:          //Db.GridLineStyle _dataGridLinetypeStyle
1315:          // = tableStyle.GridLineStyle(
1316:          // Db.GridLineType.AllGridLines, name);
1317:   
1318:          // Установка значения опции 'Spacing' 
1319:          // через .NET API
1320:          tableStyle.SetGridDoubleLineSpacing(1,
1321:            Db.GridLineType.AllGridLines, name);
1322:          // Получение значения опции 'Spacing' 
1323:          // через .NET API
1324:          // Double _spacing = tableStyle
1325:          // .GridDoubleLineSpacing(
1326:          // Db.GridLineType.AllGridLines, name);
1327:  #endif
1328:        }
1329:      }
1330:    }
1331:  }


Комментариев нет: