O básico da API do AutoCAD.NET
Conteúdo Visão Geral da API do AutoCAD.NET .............................................................................. ......................................................................................... ........... 2 Componentes da API do AutoCAD.NET ............................................................... ..................................................................................... ...................... 2 Entendendo a Hierarquia dos Objetos da API do AutoCAD.NET............................................... 3 Objeto Application (Aplicação) ( Aplicação) ................................................................................................. 4 Objeto Document (Documento) ............................................................................................... 4 Objeto Database (Banco de dados do AutoCAD) ...................................................................... ...................................................................... 5 Objetos Graphs e Nongraphs (Gráficos e não graficos) ............................................................ ............................................................ 6 Objeto Collection.................................................... Collection....................................................................................................................... ................................................................... 7 Objetos Non-Native Graphical e Nongraphical (Não nativos Gráficos e não gráficos) ............. 7 Acessando a Hierarquia de Objetos .......................................................................................... .......................................................................................... 8 Objetos de Referência na Hierarquia de Objetos ................................................................. 8 Acessando o objeto Application ........................................................... ............................................................................................ ................................. 9 Coleções de Objetos(Collection Objects) .................................................................................. .................................................................................. 9 Acessando uma Collection .................................................................................................. .................................................................................................. 10 Adicionando um novo membro a um objeto de Collection ................................................ ................................................ 10 Interar um objeto através da Collection ............................................................................. ............................................................................. 11 Interar através atr avés do objeto LayerTable ......................................................................... .................................................................................. ......... 11 Apagar um membro do objeto Collection ..................................................................... ........................................................................... ...... 12 Entendendo Propriedades e Métodos .................................................................................... .................................................................................... 13 Out-of-Process versus In-Process ............................................................. ............................................................................................ ............................... 13 Definir Comandos(Commands) e funções AutoLISP ............................................................... ............................................................... 15 Definição do Command ............................................................ ....................................................................................................... ........................................... 15 Definição da função AutoLISP ............................................................................................. 16 Bibliografia ................................................................. .................................................................................................................................. ................................................................. 17
1
Visão Geral da API do AutoCAD.NET API do AutoCAD.NET permite manipular arquivos de desenho no AutoCAD e de programação com assemblies ou bibliotecas que estão expostas. Com esses objetos expostos, eles podem ser acessados por muitas linguagens de programação diferentes e a mbientes. Existem várias vantagens para a implementação de uma API .NET para AutoCAD:
O acesso programático aos desenhos do AutoCAD é aberto para muitos ambientes de programação. Antes da API .NET, os desenvolvedores foram limitados as automações do ActiveX e linguagens que se apóiam em COM, AutoLISP e C + + com ObjectARX. A integração com outras aplicações baseadas em Windows, como o Microsoft Excel e Word, é feita dramaticamente mais fácil usando um aplicativo nativo da API do .NET ou expostos a ActiveX/COM library. O .NET Framework foi projetado para sistemas operacionais de 32 bits e 64-bit. Visual Basic for Applications foi desenvolvido apenas para sistemas operacionais de 32 bits. Permite o acesso a interfaces de programação avançadas com uma curva de aprendizado menor do que aqueles para linguagens de programação mai s tradicionais, como C + +.
Os objetos são os principais construtores construto res de blocos da API do AutoCAD.NET. Cada objeto exposto representa uma parte precisa do AutoCAD, e elas são agrupadas em diferentes assemblies e namespaces. Há muitos tipos diferentes de objetos na API do AutoCAD .NET. Por exemplo:
Objetos gráficos como linhas, arcos, texto e dimensões Configurações de estilo, como camadas, tipos de linhas e estilos de dimensão Estruturas organizacionais, como layers, grupos e blocos A exibição de desenhos, como view e viewport Mesmo o desenho da aplicação AutoCAD
Componentes da API do AutoCAD.NET API do AutoCAD.NET é composto de arquivos DLL di ferentes que contêm uma grande variedade de classes, estruturas, métodos e eventos que proporcionam acesso aos objeto s em um arquivo de desenho ou o aplicativo do AutoCAD. Cada arquivo DLL define diferentes namespaces que são usados para organizar os componentes das bibliotecas com base na funcionalidade. Os três principais arquivos DLL da API AutoCAD.NET que você usa com freqüência são:
AcDbMgd.dll. Use quando estiver trabalhando com objetos em um arquivo de desenho. AcMgd.dll. Use quando estiver trabalhando com o aplicativo do AutoCAD. AcCui.dll. Use quando estiver trabalhando com arquivos de personalização.
Usando uma DLL da API do API do AutoCAD.NET Antes de classes, estruturas, métodos e eventos encontrados em uma das DLLs r elacionadas à API do AutoCAD.NET que pode ser usada, você deve fazer referência a DLL em um projeto. p rojeto. Depois que uma DLL é referenciada a um projeto, você pode utilizar os namespaces e os componentes do arquivo da DLL em seu projeto. Uma vez que a DLL da API do AutoCAD. NET é referenciada, você deve definir a propriedade Copy Local do DLL referenciada como False. A propriedade Copy Local determina se o Microsoft Visual Studio cria uma cópia do arquivo da DLL referenciada e coloca-o no mesmo diretório que o arquivo do projeto quando o assembly é construído. Uma vez que os arquivos referenciados já vêm com o AutoCAD, Au toCAD, criar
2
cópias de arquivos DLL referenciada pode causar resultados inesperados quando você carregar carr egar o seu assembly no AutoCAD.
Localização dos Arquivos DLL da API do AutoCAD.NET Os arquivos da DLL da API do AutoCAD.NET pode ser localizado em : \ Program Files programas \ AutoCAD 2010 ou como parte do SDK do AutoCAD 2010 ObjectARX que pode ser baixado em http://www.objectarx.com ou no site da Autodesk Developer Network (http://www.autodesk.com/adn http://www.autodesk.com/adn)). Após a instalação do SDK do ObjectARX, ObjectARX, os arquivos DLL podem ser ser encontrados nas subpastas incwin32-x64 e da pasta de instalação padrão. Observação: A DLLs do SDK do ObjectARX são versões simplificadas dos mesmos arquivos que vêm com
o AutoCAD, como elas não contêm dependências na interface de usuário do AutoCAD. É recomendado que você faça o download e instale o SDK do ObjectARX, e depois referencie os arquivos DLL que vêm com o SDK em vez daqueles que são encontrados no diretório de instalação do AutoCAD 2010.
Entendendo a Hierarquia dos Objetos da API do AutoCAD.NET Um objeto é o principal construtor de blocos da API do AutoCAD.NET. Cada objeto exposto representa uma parte precisa do AutoCAD. Há diferentes tipos de objetos na API do AutoCAD.NET. Alguns dos objetos representados representados na API do AutoCAD.NET são: Objetos gráficos como linhas, arcos, texto e dimensões Configurações de estilo, como camadas, tipos de linhas e estilos de dimensão Estruturas organizacionais, como layers, grupos e blocos A exibição de desenhos, como view e viewport Mesmo o desenho da aplicação AutoCAD
Os objetos são estruturados de forma hierárquica, com o objeto Application do AutoCAD na raiz. Esta estrutura hierárquica é muitas vezes referida como o modelo de objetos ( Object Model ). ). A ilustração a seguir mostra as relações básicas entre o objeto Application e uma entidade que está em um BlockTableRecord , como o Model Space. Existem muitos objetos da API do AutoCAD.NET que não estão representados aqui.
3
Objeto Application (Aplicação) O objeto Application é o objeto raiz da API do AutoCAD.NET. A partir do objeto Application, você pode acessar a janela principal princi pal bem como abrir qualquer desenho. Depois de ter o desenho, você pode acessar seus objetos. Para obter informações sobre co mo trabalhar com arquivos de desenho aberto veja o objeto Document . Por exemplo, o objeto Application tem uma propriedade DocumentManager que retorna o objeto DocumentCollection. Este objeto fornece acesso aos desenhos que estão abertos no AutoCAD, permite você criar, salvar e abrir arquivos de desenho. Outra propriedade do objeto Application fornece acesso aos dados específicos do aplicativo como InfoCenter , a janela principal e a barra de status. A propriedade MainWindow permite acessar o nome do aplicativo, tamanho, localização e visibilidade. Enquanto a maioria das propriedades do objeto Application permite acessar os objetos da API do AutoCAD.NET, existem alguns que fazem referência a objetos do AutoCAD ActiveX Automation , Essas propriedades incluem uma versão COM do objeto do aplicativo ( AcadApplication), o menu ( MenuBar ), ), grupos de menus carregados ( MenuGroups) e preferências (Preferences)
Contêiner para todos os objetos do documento (não há um objeto de documento para cada desenho que está aberto) Container para todos os objetos janela do documento (não é um objeto de janela do documento para cada objeto de documento no DocumentManager ) Contém uma referência à barra de ferramentas InfoCenter Contém uma referência ao objeto de janela do aplicativo AutoCAD Contém uma referência ao objeto COM MenuBar para a barra de menu no AutoCAD Contém uma referência ao objeto COM MenuGroups que contém o nome do grupo de personalização para cada arquivo CUIx carregado Contém uma referência ao objeto COM Preferences que lhe permite modificar muitas das configurações na Options dialog box Contém uma referência para o objeto do Publisher que é usada para a publicação de desenhos. Contém uma referência para o objeto StatusBar para a janela do aplicativo Contém uma referência para o objeto UserConfiguration que lhe permite trabalhar com o perfil gravado do usuário
Objeto Document (Documento) O objeto Document, que na verdade é um desenho do AutoC AD, é parte do objeto DocumentCollection e fornece acesso ao objeto de banco de dados que está a ssociado com o objeto Document . O objeto Database contém todos os objetos gráficos e a maior parte dos objetos não gráficos do AutoCAD. Para obter informações sobre o objeto de banco de dados, ver o objeto Database. Junto com o objeto Database, o objeto Document fornece acesso à barra de status do desenho, da janela do documento é aberto o Editor e o objeto de Transaction Manager (Gerenciador de Transações). O objeto Editor fornece acesso às funções usadas para obter entrada do usuário na forma de um ponto ou uma String digitada ou um valor numérico. O objeto Transaction Manager é usado para acessar múltiplos objetos de Database em uma única operação conhecida como uma transação. As transações podem ser aninhadas, quando você faz uma transação você pode confirmar (commit ) ou anular as alterações feitas (abort ). ). Para obter
4
informações sobre transações, veja o objeto Transaction Manager , consulte como utilizar as transações com o Transaction Manager .
Objeto Database (Banco de dados do AutoCAD) O objeto de Database contém todos os objetos gráficos e a maior parte dos objetos não gráficos do AutoCAD. Alguns dos objetos contidos n a Database são entidades (Entity ), ), tabelas de símbolos e dicionários nomeados. Entidades da Database representam objetos gráficos dentro de um desenho. Linhas, círculos, arcos, textos, hachuras e polili nhas são exemplos de entidades. Um usuário pode ver uma entidade na tela e pode manipulá-la. Você pode acessar o objeto de Database para o documento atual, o objeto Document é membro da propriedade de Database. Application.DocumentManager.MdiActiveDocument.Database
Tabelas Símbolos e Dicionários Tabelas de símbolos ( Symbol ) e objetos do dicionário fornecer acesso para objetos não gráficos (blocos, camadas, tipos de linhas, layouts, e assim por diante). Cada desenho contém um conjunto de nove tabelas de símbolos fixos, enquanto que o n úmero de dicionários em um desenho pode variar de acordo com as características e tipos de aplicações utilizadas no AutoCAD. Novas Tabelas de Símbolos não podem ser adicionadas a uma Database. Exemplos de tabelas de símbolos são tabelas tabela s de camadas ( LayerTable), que contém registros da tabela de camada e tabela de bloco (BlockTable), que contém registros de tabela de bloco (BlockTableRecord ). ). Todas as entidades gráficas (linhas, círculos, arcos e assim por diante) são de propriedade de um registro da tabela de blocos (BlockTableRecord ). ). Por padrão, cada desenho contém um BlockTableRecord para o modelo e para o Paper space. Cada layout do Paper space tem seu próprio BlockTableRecord . Para obter informações sobre como trabalhar com tabelas de símbolos, veja o Collection Objects. Um dicionário é um container de objeto que pode conter qualquer objeto do AutoCAD ou um ar mazenados na Database como um dicionário de objeto nomeado ou como XRecord . Os dicionários são armazenados um dicionário de extensão de um registro da tabela ou entidade gráfica. O objeto dicionário é chamado
5
de tabela de mestre para todos os dicionários associados com uma Database. Ao contrário de tabelas de símbolos, novos dicionários podem ser criados e adicionados ao dicionário de objetos chamado. Para obter informações sobre como trabalhar com dicionários, veja Collection Objects. Observação: Dicionários de objetos podem conter entidades de desenho.
Objetos Graphs e Nongraphs (Gráficos e não graficos) Objetos gráficos, também conhecidos como entidades, são os objetos visíveis (l inhas, círculos, imagens raster, e assim por diante) que formam um desenho. Objetos gráficos adicionados a um desenho é feito por referência ao registro correto da tabela de bloco (BlockTable), e em seguida, usando o método AppendEntity com o novo objeto para adicioná-lo ao desenho. Para modificar ou consultar objetos, obter a referência ao objeto BlockTableRecord , e então usar os métodos ou propriedades do próprio objeto. Cada objeto gráfico tem métodos que executam a maior parte da mesma funcionalidade que os comandos de edição do AutoCAD, tais como Copiar (Copy ), ), Apagar (Erase), Mover (Move), Espelho (Mirror ), ), e assim por diante. Esses objetos também tem métodos para recuperar os dados estendidos ( xdata), destacados e realçados, e define as propriedades de outra entidade. A maioria dos objetos gráficos têm algumas propriedades em comum uns com os outros, como LayerId , LinetypeId , Color , e Handle. Cada objeto gráfico também tem propriedades específicas, tais como Center , StartPoint , Radius, e FitTolerance. Objetos não gráficos são os invisíveis invisív eis (informativo) objetos que fazem parte de um d esenho, como camadas (Layers), tipos de linhas (Linetypes), estilos de dimensão ( Dimension styles ), estilos de tabela (Table styles), e assim por diante. Para criar um novo registro da tabela de símbolos, use o método Add na mesa proprietário ou usar o método SetAt para adicionar um dicionário ao dicionário objeto chamado. Para modificar ou consultar esses objetos, use os métodos ou propriedades do objeto em si. Cada objeto não gráficas tem métodos e propriedades específicas para sua finalidade, tudo tem métodos para recuperar dados estendidos ( xdata), e apagar-se.
6
Objeto Collection O AutoCAD agrupa a maioria dos objetos gráficos e não gráficos em coleções ou objetos de contêineres. Embora coleções contenham diferentes tipos de dados, eles podem ser processados utilizando técnicas similares. Cada coleção tem um método para adicionar um objeto ou obter um item de uma coleção. A maioria das coleções usa os métodos Add ou SetAt para adicionar um objeto a uma coleção. A Maioria das coleções oferecem métodos semelhantes e propriedades para torná-los fáceis de usar e aprender. A propriedade Count retorna uma contagem baseada em zero dos objetos em u ma coleção, enquanto a função Item retorna um objeto de uma coleção. Exemplos de membros da coleção na API AutoCAD.NET são:
Layer table record em Layers symbol table
Layout no dicionário ACAD_LAYOUT
Document em DocumentCollection
Attributes em uma referência de bloco(block reference)
Objetos Non-Native Graphical e Nongraphical (Não nativos Gráficos e não gráficos) A API do AutoCAD.NET é uma implementação cruzada com o ObjectARX e automatizada com ActiveX. Enquanto você pode acessar automação ActiveX do ObjectARX, A API do .NET torna o trabalho com os dois um pouco mais transparente. Ao trabalhar com objetos usando a API nativa do .NET, você pode acessar a propriedade do objeto COM equivalente. Em alguns casos, o objeto COM é a única maneira de acessar um recurso do AutoCAD AutoC AD programaticamente. Alguns exemplos de propriedades que expõem objetos COM através da API do .NET são, preferências(Preferences), barra de menus(Menubar), MenuGroups , AcadObject e AcadApplication. Observação: Quando trabalhando com objetos COM, você vai querer certificar-se de que você fez
referência à biblioteca do tipo do AutoCAD 2010. A propriedade de preferências(Preferences) do objeto Application fornecem acesso a um conjunto de objetos, cada um correspondendo a uma guia de Opções( Options dialog box ). ). Juntos, esses objetos fornecem acesso a todas as configurações de r egistro armazenados na Options dialog box . Você também pode definir e modificar variáveis do sistema que não fazem parte da Options dialog box com os métodos SetSystemVariable e GetSystemVariable do objeto Application. Para obter mais informações sobre como usar o objeto de preferências. Acessar objetos COM é útil se você estiver trabalhando com código existente que pode ter sido originalmente desenvolvido para VB ou VBA, ou até mesmo ao trabalhar com uma biblioteca de terceiros que pode funcionar com a biblioteca de automação de ActiveX da API do AutoCAD.NET. Com o objeto de preferências(Preferences), você também pode acessar os utilitários que convertem coordenadas ou definem um novo ponto com base em um â ngulo e distância, usando o objeto utilitário utili tário que pode ser acessado a partir o objeto de COM AcadApplication que é o equivalente do objeto Application da API do .NET. Observação: Quando trabalhamos com ambos API do AutoCAD.NET e automatização ActiveX, você cria
funções personalizadas que talvez precise retornar um objeto, é recomendável retornar um ObjectId em vez do próprio objeto.
7
Acessando a Hierarquia de Objetos Enquanto o Application é o objeto de raiz da API do AutoCAD.NET, você normalmente irá trabalhar com o banco de dados do desenho atual. O DocumentManager propriedade do objeto Application permite que você acesse o documento atual com a propriedade MdiActiveDocument . A partir do objeto de documento retornado pela propriedade MdiActiveDocument , você pode acessar seu banco de dados com a propriedade Database. Exemplo: C# Application.DocumentManager.MdiActiveDocument.Database.Clayer;
Objetos de Referência na Hierarquia de Objetos Quando você trabalha com a API de objetos do .NET, você pode fazer referência a alguns objetos diretamente ou através de uma variável var iável definida pelo usuário com base no objeto que você está trabalhando. Para fazer referência a um objeto diretamente, incluir o objeto na chamada da hierarquia. Por exemplo, a seguinte declaração anexa um arquivo de desenho para o banco de dados do desenho atual. Observe que a hierarquia começa com a aplicação (Application) e depois vai para o objeto de banco de dados (Database). A partir parti r do objeto de banco de dados, o método AttachXref é chamado: Exemplo: C# string strFName, strBlkName; Autodesk.AutoCAD.DatabaseServices.ObjectId objId; strFName = "c:/clients/Proj 123/grid.dwg"; strBlkName = System.IO.Path.GetFileNameWithoutExtension(strFName); objId = Application.DocumentManager.MdiActiveDocument.Database.AttachXref(strFName, strBlkName);
Para referenciar os objetos através de uma variável definida pelo usuário, definir a variável como o tipo, em seguida, defina a variável para o objeto apropriado. apropr iado. Por exemplo, o código seguinte define uma variável (acCurDb) do tipo Autodesk.AutoCAD.DatabaseServices.Database e define a variável igual ao banco de dados de corrente(Database). Exemplo: C# Autodesk.AutoCAD.DatabaseServices.Database acCurDb; acCurDb = Application.DocumentManager.MdiActiveDocument.Database;
A seguinte declaração, em seguida, anexa um arquivo a rquivo de desenho para o banco de dados usando o acCurDb variável definida pelo usuário: Exemplo: C# string strFName, strBlkName; Autodesk.AutoCAD.DatabaseServices.ObjectId objId; strFName = "c:/clients/Proj 123/grid.dwg"; strBlkName = System.IO.Path.GetFileNameWithoutExtension(strFName); objId = acCurDb.AttachXref(strFName, strBlkName);
Recuperar entidades de um Model space O exemplo a seguir retorna o objeto primeira entidade no Model space. Código semelhante pode fazer o mesmo para as entidades do Paper space. Note que todos os objetos gráficos são definidos como um objeto de entidade(Entity). Exemplo: C#
8
using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; [CommandMethod("ListEntities")] public static void ListEntities() { // Get the current document and database, and start a transaction Document acDoc = Application.DocumentManager.MdiActiveDocument; Database acCurDb = acDoc.Database; using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction()) { // Open the Block table record for read BlockTable acBlkTbl; acBlkTbl = acTrans.GetObject(acCurDb.BlockTableId, OpenMode.ForRead) as BlockTable; // Open the Block table record Model space for read BlockTableRecord acBlkTblRec; acBlkTblRec = acTrans.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForRead) as BlockTableRecord; int nCnt = 0; acDoc.Editor.WriteMessage("\nModel space objects: "); // Step through each object in Model space and // display the type of object found foreach (ObjectId acObjId in acBlkTblRec) { acDoc.Editor.WriteMessage("\n" + acObjId.ObjectClass.DxfName); nCnt = nCnt + 1; } // If no objects are found then display a message if (nCnt == 0) { acDoc.Editor.WriteMessage("\n No objects found"); } // Dispose of the transaction } }
Acessando o objeto Application O objeto Application é a raiz da hierarquia de objetos e fornece acesso à janela principal do AutoCAD. Por exemplo, a linha de código a seguir atualiza o aplicativo Exemplo: C# Autodesk.AutoCAD.ApplicationServices.Application.UpdateScreen();
Coleções de Objetos(Colle Objetos(Collection ction Objects) Uma coleção é um tipo de objeto que q ue contêm muitas instâncias de objetos similares. A seguinte lista contêm alguns dos objetos da coleção que são encontrados no AutoCAD .NET API: Block Table Record Contêm todas as entidades dentro bloco de definição específica Block Table Contêm todos os blocos no desenho Named Objects Dictionary Contêm todos os dicionários no desenho Dimension Style Table Contêm todos os estilos de dimensões no desenho Document Collection Contêm todos os desenhos abertos na sessão atual File Dependency Collection Contêm todos os itens na lista de File Dependency List Group Dictionary Contêm todos os grupos no desenho
9
Hyperlink Collection Contêm todos os hyperlinks dado de uma entidade(Entity) Layer Table Contêm todas as layers no desenho Layout Dictionary Contêm todos os layouts no desenho Linetype Table Contêm todas as linetypes no desenho MenuBar Collection Contêm todos os menus carregados e exibidos atualmente no AutoCAD. MenuGroup Collection Contêm todos os grupos de customizações carregados atualmente no
AutoCAD. Um grupo de customização representa o arqui vo CUIx carregado que pode conter menus, barra de ferramentas, abas ribbon, entre outros elementos de interface com o usuário Plot Configuration Dictionary Contêm definições nomeadas do plot no desenho Registered Application Table Contêm todas as aplicações registradas no desenho Text Style Table Contêm todos os estilos de texto no desenho UCS Table Contêm todos os sistemas de coordenadas(UCS's) no desenho View Table Contêm todas as visões(views) no desenho Viewport Table Contêm todas as viewports no desenho
Acessando uma Collection A maioria das coleções e objetos container contai ner são acessados por meio dos objetos Document ou Database. O Document e os objetos Database contém uma propriedade para acessar um ID de objeto ou o objeto para a maioria dos objetos de coleções disponíveis. Por exemplo, o código seguinte define uma variável e recupera o objeto LayersTable que representa o conjunto de camadas( Layer Tables) no desenho corrente: Exemplo: C# // Get the current document and start the Transaction Manager Database acCurDb = Application.DocumentManager.MdiActiveDocument.Database; using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction()) { // This example returns the layer table for the current database LayerTable acLyrTbl; acLyrTbl = acTrans.GetObject(acCurDb.LayerTableId, OpenMode.ForRead) as LayerTable; // Dispose of the transaction }
Adicionando um novo membro a um objeto de Collection Para adicionar um novo membro para a coleção, use o método Add . Por exemplo, o código a seguir cria uma Layer e adiciona-o à Layer table: Exemplo: C# using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; [CommandMethod("AddMyLayer")] public static void AddMyLayer() { // Get the current document and database, and start a transaction Document acDoc = Application.DocumentManager.MdiActiveDocument;
10
Database acCurDb = acDoc.Database;
using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction()) { // Returns the layer table for the current database LayerTable acLyrTbl; acLyrTbl = acTrans.GetObject(acCurDb.LayerTableId, OpenMode.ForRead) as LayerTable; // Check to see if MyLayer exists in the Layer table if (acLyrTbl.Has("MyLayer") != true) { // Open the Layer Table for write acLyrTbl.UpgradeOpen(); // Create a new layer table record and name the layer "MyLayer" LayerTableRecord acLyrTblRec = new LayerTableRecord(); acLyrTblRec.Name = "MyLayer"; // Add the new layer table record to the layer table and the transaction acLyrTbl.Add(acLyrTblRec); acTrans.AddNewlyCreatedDBObject(acLyrTblRec, true); // Commit the changes acTrans.Commit(); } // Dispose of the transaction } }
Interar um objeto através da Collection Para selecionar um membro específico de um objeto de co leção, use o item ou método GetAt . O item e o métodos GetAt requerem uma chave sob a forma de uma cadeia em que representa o nome do item. Como na maioria das coleções, o método Item está implícito, ou seja, você realmente não precisa usar o método. Como alguns objetos de coleção, você também pode usar um número de índice para especificar a localização do item dentro da coleção que você deseja recuperar. O método que pode utilizar varia com base no idioma que você está usando, bem como se você estiver trabalhando com uma tabela t abela de símbolos ou dicionário. As instruções a seguir mostram como acessar o "MyLayer" um Layer table record em Layer symbol table. Exemplo: C# acObjId = acLyrTbl["MyLayer"];
Interar através do objeto LayerTable O exemplo a seguir itera através at ravés do objeto LayerTable e exibe os nomes de todos os seus registros da Layer table records: Exemplo: C# using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; [CommandMethod("IterateLayers")] public static void IterateLayers() { // Get the current document and database, and start a transaction Document acDoc = Application.DocumentManager.MdiActiveDocument; Database acCurDb = acDoc.Database; using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction()) { // This example returns the layer table for the current database
11
LayerTable acLyrTbl; acLyrTbl = acTrans.GetObject(acCurDb.LayerTableId, OpenMode.ForRead) as LayerTable; // Step through the Layer table and print each layer name foreach (ObjectId acObjId in acLyrTbl) { LayerTableRecord acLyrTblRec; acLyrTblRec = acTrans.GetObject(acObjId, OpenMode.ForRead) as LayerTableRecord; acDoc.Editor.WriteMessage("\n" + acLyrTblRec.Name); } // Dispose of the transaction } }
Encontrar um layer table record chamado MyLayer no objeto Layer Table O exemplo a seguir verifica o objeto LayerTable para determinar se a layer chamada MyLayer existe ou não, e exibe a mensagem apropriada: Exemplo: C# using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; [CommandMethod("FindMyLayer")] public static void FindMyLayer() { // Get the current document and database, and start a transaction Document acDoc = Application.DocumentManager.MdiActiveDocument; Database acCurDb = acDoc.Database; using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction()) { // Returns the layer table for the current database LayerTable acLyrTbl; acLyrTbl = acTrans.GetObject(acCurDb.LayerTableId, OpenMode.ForRead) as LayerTable; // Check to see if MyLayer exists in the Layer table if (acLyrTbl.Has("MyLayer") != true) { acDoc.Editor.WriteMessage("\n'MyLayer' does not exist"); } else { acDoc.Editor.WriteMessage("\n'MyLayer' exists"); } // Dispose of the transaction } }
Apagar um membro do objeto Collection Membros de um objeto de coleção( Collection ) podem ser apagados usando o método Erase encontrado no objeto membro. Por exemplo, os códigos seguintes apaga a Layer MyLayer a partir do objeto LayerTable. “
”
Antes de apagar uma camada(Layer) de um desenho, você deve se certificar de que pode ser removida com segurança. Para determinar se s e uma camada ou outro objeto nomeado como um bloco ou um estilo de texto pode ser apagado, você deve usar o método de Purge. Exemplo: C# using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.ApplicationServices; using Autodesk.AutoCAD.DatabaseServices; [CommandMethod("RemoveMyLayer")] public static void RemoveMyLayer()
12
{ // Get the current document and database, and start a transaction Document acDoc = Application.DocumentManager.MdiActiveDocument; Database acCurDb = acDoc.Database; using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction()) { // Returns the layer table for the current database LayerTable acLyrTbl; acLyrTbl = acTrans.GetObject(acCurDb.LayerTableId, OpenMode.ForRead) as LayerTable; // Check to see if MyLayer exists in the Layer table if (acLyrTbl.Has("MyLayer") == true) { LayerTableRecord acLyrTblRec; acLyrTblRec = acTrans.GetObject(acLyrTbl["MyLayer"], OpenMode.ForWrite) as LayerTableRecord; try { acLyrTblRec.Erase(); acDoc.Editor.WriteMessage("\n'MyLayer' was erased"); // Commit the changes acTrans.Commit(); } catch { acDoc.Editor.WriteMessage("\n'MyLayer' could not be erased"); } } else { acDoc.Editor.WriteMessage("\n'MyLayer' does not exist"); } // Dispose of the transaction } }
Entendendo Propriedades e Métodos Cada objeto possui propriedades e métodos associados. Pr opriedades descrevem os aspectos do objeto individual, enquanto os métodos são a ções que podem ser executadas no objeto individual. Depois que um objeto é criado, você pode consultar e editar o objeto através atr avés de suas propriedades e métodos. Por exemplo, um objeto círculo tem uma propriedade Center . Esta propriedade representa um ponto no sistema coordenadas do mundo (WCS) no centro desse círculo. Para mudar o centro do círculo, ajuste simplesmente a propriedade Center a um ponto novo. O objeto do círculo tem também um método chamado GetOffsetCurves. Este método cria um objeto novo em uma distância offset especificada do círculo existente. Para ver uma lista de todas as propriedades e métodos para o objeto do círculo, consulte ao objeto do círculo na guia de referência de AutoCAD .NET ou use o Browser do o bjeto no Visual Studio® de Microsoft®.
Out-of-Process versus In-Process Quando você desenvolve uma nova aplicação, que pode ser executado dentro ou fora do processo. A API do AutoCAD.NET foi concebida para ser executado no processo, só que é diferente a partir da biblioteca de automação ActiveX que podem ser utilizado in ou -out-of-process.
Aplicativos em processo são projetados para funcionar no mesmo espaço de processo como o aplicativo host. Neste caso, um conjunto de DLL é carregado no AutoCAD que é a aplicação de acolhimento.
13
Aplicativos Out-of-process não são executados no mesmo espaço que o aplicativo apl icativo host. Estas aplicações são muitas vezes construídas como stand-alone executáveis.
Se você precisar criar uma aplicação stand-alone para conduzir o AutoCAD, o melhor é criar um aplicativo que usa os métodos CreateObject e GetObject para criar uma nova instância de um aplicativo AutoCAD ou retornar uma das instâncias que está atualmente em execução. Uma vez feita referência um AcadApplication é retornado, então você pode carregar o seu em in-process uma aplicação .NET para o AutoCAD usando o método sendCommand que é membro da propriedade ActiveDocument do AcadApplication. Como uma alternativa de executar um aplicativo. NET in-process, poderia usar a interoperabilidade COM para sua aplicação. Observação: O ProgID para aplicativos COM para o AutoCAD 2010 é AutoCAD.Application.18. Exemplo: C# using System; using System.Runtime.InteropServices; using Autodesk.AutoCAD.Interop; using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.ApplicationServices; [CommandMethod("ConnectToAcad")] public static void ConnectToAcad() { AcadApplication acAppComObj = null; const string strProgId = "AutoCAD.Application.18"; // Get a running instance of AutoCAD try { acAppComObj = (AcadApplication)Marshal.GetActiveObject(strProgId); } catch // An error occurs if no instance is running { try { // Create a new instance of AutoCAD acAppComObj = (AcadApplication)Activator.CreateInstance(Type.GetTypeFromProgID(strProgId), true); } catch { // If an instance of AutoCAD is not created then message and exit System.Windows.Forms.MessageBox.Show("Instance of 'AutoCAD.Application'" + " could not be created."); return; } } // Display the application and return the name and version acAppComObj.Visible = true; System.Windows.Forms.MessageBox.Show("Now running " + acAppComObj.Name + " version " + acAppComObj.Version); // Get the active document AcadDocument acDocComObj; acDocComObj = acAppComObj.ActiveDocument; // Optionally, load your assembly and start your command or if your assembly // is demandloaded, simply start the command of your in-process assembly. acDocComObj.SendCommand("(command " + (char)34 + "NETLOAD" + (char)34 + " " + (char)34 + "c:/myapps/mycommands.dll" + (char)34 + ") "); acDocComObj.SendCommand("MyCommand "); }
14
Definir Comandos(Commands) e funções AutoLISP Comandos e funções AutoLISP ® pode ser definido com a API do AutoCAD.NET através da utilização de dois atributos: CommandMethod e LispFunction. Você coloca um dos dois atributos atri butos antes do método a ser chamado no command ou função AutoLISP executado no AutoCAD. Os métodos utilizados para comandos não devem ser definidos com a rgumentos. No entanto, um método utilizado para definir uma função AutoLISP deve ser definido com um único argumento do tipo de objeto ResultBuffer .
Definição do Command Ao definir um comando, você pode usar o atributo CommandMethod . O atributo definido CommandMethod espera um valor de String para usar como um nome global que está sendo definido no command . Junto com um nome do command global, o atributo CommandMethod pode aceitar os seguintes valores:
Command Flags Define o comportamento do comando
Group Name nome do grupo de comando
Local Name nome do comando local, geralmente linguagem específica
Help Topic Name nome tópico da Ajuda que deve ser exibido quando F1 é pressionado
Context Menu Type Flags Define o comportamento do menu de contexto quando o
comando está ativo t ópico de ajuda que deve ser exibido Help File Name Arquivo de ajuda que contém o tópico quando o comando está ativo e F1 é pressionado
A tabela seguinte lista os sinalizadores disponíveis que podem ser utilizados para definir o comportamento de um comando. Enum Value
Descrição
ActionMacro DocReadLock Interruptible Modal NoActionRecording NoBlockEditor NoHistory NoPaperSpace NoTileMode
Command pode ser gravado com a ação do Action Recorder. Documento será lido bloqueado quando o command é invocado. Command pode ser interrompido ao pedir uma entrada do usuário Command não pode ser invocado enquanto outro command está ativo Command não pode graver uma ação no Action Recorder. Command não pode ser usado a partir do Block Editor. Command não é adicionado à lista de histórico repeat-last-command. Command não pode ser usado do Paper space. Command não pode ser usado quando o TILEMODE é definido como 1. Command não suporta desfazer marcadores. Este se destin a a commands que não modificam a database, e portanto não deve aparecer no arquivo de undo. Quando o pickfirst set ou grip set são recuperados, eles el es não são apagados. Command é executado no contexto da aplicação, em vez do contexto do documento atual. Command pode ser usado enquanto outro command está ativo. Command pode ser usando somente via nome Global. Quando o pickfirst set é recuperado, ele é desmarcado.
NoUndoMarker Redraw Session Transparent Undefined UsePickSet
A sintaxe para definir um Command A seguinte demonstração cria um atributo CommandMethod que define um comando chamado CheckForPickfirstSelection. O atributo também usa a flag UsePickSet , comando para indicar que o comando é permitido usar os objetos que estão selecionados antes que o comando seja i niciado.
15
Exemplo: C# [CommandMethod("CheckForPickfirstSelection", CommandFlags.UsePickSet)] public static void CheckForPickfirstSelection() { . . . }
Você pode especificar o uso de mais de uma flag usando o operador & em C#. [CommandMethod("CheckForPickfirstSelection", CommandFlags.UsePickSet & CommandFlags.NoBlockEditor)] public static void CheckForPickfirstSelection() { . . . }
Definição da função AutoLISP Ao definir uma função AutoLISP, você usa o atributo LispFunction. O atributo LispFunction espera um valor de String para usar o nome global da função AutoLISP que está sendo definida. Junto com um nome de função global, a estrutura LispFunction pode aceitar os seguintes valores:
u ma linguagem específica Local Name Nome da função local, geralmente de uma
Help Topic Name Nome tópico de ajuda que deve ser associado com a função AutoLISP
t ópico de ajuda que deve ser exibido Help File Name Arquivo de ajuda que contém o tópico quando o comando está ativo e F1 é pressionado
Sintaxe para definir uma função AutoLISP A seguinte demonstração cria um atributo LispFunction que define uma função AutoLISP chamado InsertDynamicBlock . Exemplo: C# [LispFunction("DisplayFullName")] public static void DisplayFullName(ResultBuffer rbArgs) { . . . }
Recuperar valores passados para uma função AutoLISP Use um Foreach loop para percorrer os valores retornados na ResultBuffer pela função AutoLISP. Um ResultBuffer é uma coleção de objetos TypedValue. A propriedade TypeCode de um objeto TypedValue pode ser usado para determinar o tipo de valor para cada valor passado para a função AutoLISP. A propriedade Value é usada para retornar o valor do objeto TypedValue. Para definir uma função AutoLISP Este exemplo de código define uma função AutoLISP chamada DisplayFullName. Enquanto o método definido no projeto .NET aceita um único valor, a função AutoLISP espera dois valores String para produzir a saída correta. Carregue o projeto .NET no AutoCAD e digite o seguinte no prompt de comando: (displayfullname "First" "Last")
O seguinte saída é exibida exibida após a execução da função AutoLISP: Name: First Last
Exemplo: C#
16
using Autodesk.AutoCAD.Runtime; using Autodesk.AutoCAD.ApplicationServices; [LispFunction("DisplayFullName")] public static void DisplayFullName(ResultBuffer rbArgs) { if (rbArgs != null) { string strVal1 = ""; string strVal2 = ""; int nCnt = 0; foreach (TypedValue rb in rbArgs) { if (rb.TypeCode == (int)Autodesk.AutoCAD.Runtime.LispDataType.Text) { switch(nCnt) { case 0: strVal1 = rb.Value.ToString(); break; case 1: strVal2 = rb.Value.ToString(); break; } nCnt = nCnt + 1; } } Application.DocumentManager.MdiActiveDocument.Editor. WriteMessage("\nName: " + strVal1 + " " + strVal2); } }
Bibliografia AutoCAD .NET Developer's Guide
17
