Fala Creactive!

XData - como manipular dados adicionais nos objetos? (Parte II)

2013-11-27T00:00:00-03:00

Olá a todos,

Essa é a segunda parte do post sobre como manipular XData no AutoCAD. Se você não tem muita certeza dos conceitos, dê uma olhada no post passado.

Na verdade, nós começamos ao avesso: primeiro aprendemos a ler, e agora que vamos aprender a escrever. A razão disso é que é um pouco mais complexo salvar do que ler, e muito dos conceitos utilizados são compartilhados por ambas as operações.

Primeiramente, devemos registrar nossa aplicação. Para isto, devemos acessar a tabela de registro de aplicações. O código abaixo registra uma aplicação com o nome que passarmos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 static void RegistrarApp(string nome)
{
    var documento = Application.DocumentManager.MdiActiveDocument;
    var banco = documento.Database;

    
    using (var transacao = documento.TransactionManager.StartTransaction())
    {
        var tabela = transacao.GetObject(banco.RegAppTableId, OpenMode.ForRead, false) as RegAppTable;

        if (tabela == null)
            return;

        if (!tabela.Has(nome))
        {
            tabela.UpgradeOpen();
            var registro = new RegAppTableRecord();
            registro.Name = nome;
            tabela.Add(registro);
            transacao.AddNewlyCreatedDBObject(registro, true);
        }
        transacao.Commit();
    }
}

Depois disso, nós precisamos salvar efetivamente a informação que desejamos (no caso, um nome para a linha). Ao código:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39 [CommandMethod("SalvarNome")]
static public void SalvarNome()
{
    var documento = Application.DocumentManager.MdiActiveDocument;
    var editor = documento.Editor;
    var nomeApp = "AppTesteXData";

    var opcoesNome = new PromptStringOptions("\nDigite um nome para a entidade: ");
    opcoesNome.AllowSpaces = true;
    var resultadoNome = editor.GetString(opcoesNome);
    if (resultadoNome.Status != PromptStatus.OK)
    {
        editor.WriteMessage("\nComando abortado.");
    }

    var opcoesSelEntidade = new PromptEntityOptions("\nSelecione uma entidade: ");
    var resultadoEntidade = editor.GetEntity(opcoesSelEntidade);

    if (resultadoEntidade.Status != PromptStatus.OK)
    {
        editor.WriteMessage("\nComando abortado.");
    }

    using (var transacao = documento.TransactionManager.StartTransaction())
    {
        DBObject objeto = transacao.GetObject(resultadoEntidade.ObjectId, OpenMode.ForWrite);
        if(objeto == null) return;
        
        RegistrarApp(nomeApp);
        var buffer = new ResultBuffer(
            new TypedValue((short)DxfCode.ExtendedDataRegAppName, nomeApp),
            new TypedValue((short)DxfCode.ExtendedDataAsciiString, resultadoNome.StringResult)
          );
        objeto.XData = buffer;
        buffer.Dispose();
        transacao.Commit();
        editor.WriteMessage("\nDados salvos com sucesso!");
    }
}

Se você tem acompanhado o blog, a única coisa que pareça novidade é a parte que adiciona o buffer. Bem, é simples de entender. Um TypedValue é uma classe do tipo chave-valor. O DxfCode é apenas um alias para facilitar a obtenção da chave que precisamos. No caso, o primeiro item do buffer é do tipo ExtendedDataRegAppName, que vai carregar o nome que registramos previamente (com o método RegistrarApp), e seu valor é uma string. O segundo item é a string que representa o nome da linha de fato, ou seja, o dado que realmente nos importa. O DxfCode é ExtendedDataAsciiString, ou seja, uma string ASCII que será salva no objeto (é importante lembrar do encoding nesse caso: nada de acentos). Depois, apenas salvamos o buffer no XData da entidade, e pronto. Temos agora o dado salvo na entidade.

Podemos conferir o resultado salvando. Digitamos o comando, selecionamos a entidade e observamos que o comando foi bem sucedido:

Pronto, agora os dados foram inseridos na nossa entidade. Você pode confiar em mim! Ou… se você não confia tanto :(, pode executar o comando de leitura que criamos no post passado:

Segue o código completo coberta na série sobre XData:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120 using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ExemploXDataAutoCAD
{
    public class Main
    {
        [CommandMethod("LerNome")]
        public static void LerNome()
        {
            var documento = Application.DocumentManager.MdiActiveDocument;
            var editor = documento.Editor;

            var opcoes = new PromptEntityOptions("\nSelecione a entidade: ");
            opcoes.SetRejectMessage("\nPor favor, selecione uma reta (Line).");
            opcoes.AddAllowedClass(typeof(Line), false);
            opcoes.AllowNone = false;

            var resultado = editor.GetEntity(opcoes);

            if (resultado.Status != PromptStatus.OK)
            {
                editor.WriteMessage("\nComando abortado.");
                return;
            }

            using (var transacao = documento.TransactionManager.StartTransaction())
            {
                var reta = transacao.GetObject(resultado.ObjectId, OpenMode.ForRead);

                var dados = reta.XData;

                if (dados == null)
                {
                    editor.WriteMessage("\nNão há dados anexados à reta.");
                }
                else
                {
                    foreach (var valor in dados)
                    {
                        editor.WriteMessage("\nTipo: {0} , Valor: {1}", valor.TypeCode.ToString(), valor.Value.ToString());
                    }
                }
            }
        }

        static void RegistrarApp(string nome)
        {
            var documento = Application.DocumentManager.MdiActiveDocument;
            var banco = documento.Database;

            
            using (var transacao = documento.TransactionManager.StartTransaction())
            {
                var tabela = transacao.GetObject(banco.RegAppTableId, OpenMode.ForRead, false) as RegAppTable;

                if (tabela == null)
                    return;

                if (!tabela.Has(nome))
                {
                    tabela.UpgradeOpen();
                    var registro = new RegAppTableRecord();
                    registro.Name = nome;
                    tabela.Add(registro);
                    transacao.AddNewlyCreatedDBObject(registro, true);
                }
                transacao.Commit();
            }
        }

        [CommandMethod("SalvarNome")]
        static public void SalvarNome()
        {
            var documento = Application.DocumentManager.MdiActiveDocument;
            var editor = documento.Editor;
            var nomeApp = "AppTesteXData";

            var opcoesNome = new PromptStringOptions("\nDigite um nome para a entidade: ");
            opcoesNome.AllowSpaces = true;
            var resultadoNome = editor.GetString(opcoesNome);
            if (resultadoNome.Status != PromptStatus.OK)
            {
                editor.WriteMessage("\nComando abortado.");
            }

            var opcoesSelEntidade = new PromptEntityOptions("\nSelecione uma entidade: ");
            var resultadoEntidade = editor.GetEntity(opcoesSelEntidade);

            if (resultadoEntidade.Status != PromptStatus.OK)
            {
                editor.WriteMessage("\nComando abortado.");
            }

            if (resultadoEntidade.ObjectId == ObjectId.Null) return;

            using (var transacao = documento.TransactionManager.StartTransaction())
            {
                DBObject objeto = transacao.GetObject(resultadoEntidade.ObjectId, OpenMode.ForWrite);
   
                RegistrarApp(nomeApp);
                var buffer = new ResultBuffer(
                    new TypedValue((short)DxfCode.ExtendedDataRegAppName, nomeApp),
                    new TypedValue((short)DxfCode.ExtendedDataAsciiString, resultadoNome.StringResult)
                  );
                objeto.XData = buffer;
                buffer.Dispose();
                transacao.Commit();
                editor.WriteMessage("\nDados salvos com sucesso!");
            }
        }
    }
}

Abraço e até a próxima!

XData - como manipular dados adicionais nos objetos? (Parte I)

2013-09-13T00:00:00-03:00

Olá a todos,

Este tópico é de importância fundamental em vários aspectos práticos do desenvolvimento para AutoCAD. Por muitas vezes, podemos nos ater apenas às informações já contidas nos objetos para manipularmos satisfatoriamente os dados. Porém, em certas ocasiões, é necessário ir além, criando novas propriedades aos objetos de acordo com nossas necessidades. Para tal feito, é necessário que utilizemos o conceito de XData.

Primeiramente, algumas informações sobre a forma. Dividi o post em duas partes, pois o conteúdo é longo. Essa primeira parte introdutória nos mostrará como ler o XData — e a segunda, como salvá-lo.

Para introduzir o conceito, vamos às apresentações formais. XData significa Extended Entity Data, ou dados de extensão da entidade. O seu nome praticamente passa toda a ideia por trás do conceito: criar uma extensão dos dados que queremos. Ou seja, se eu quero dar um nome a uma reta, utilizarei XData para salvar a string que representa o nome do objeto. É exatamente isto que iremos fazer nesse exemplo: adicionar um nome a uma reta (Line).

Um pequeno parêntese. Algumas pessoas podem se perguntar porque simplesmente não criar um bloco e nomeá-lo, ao invés de criar uma reta contendo um nome. Bem, isto não funcionaria muito bem em alguns cenários. Um bloco não tem algumas propriedades essenciais a uma gama de possíveis utilizações do AutoCAD, como propriedades geométricas que uma linha possui. E também nossa preocupação é com o exercício da API, não com aplicações práticas, apesar de eu garantir que, neste caso, a teoria se aplica a prática. Eu já necessitei criar linhas nomeadas no AutoCAD.

Continuando… o XData é um “mecanismo legado” para anexar informações adicionais às entidades. O termo “legado” está sendo empregado aqui porque existem limites inerentes ao uso do XData, por se tratar de um conceito antigo no AutoCAD. O limite global de memória é de 16 KBytes por objeto. Pode ser pouco para suas necessidades. Neste caso, é recomendado que se utilize o mecanismo de XRecords + Extension Dictionaries. Nós abordaremos o conceito em um tópico no futuro.

Agora, ao trabalho. Primeiro. vamos pensar no design do nosso código. Existirão basicamente dois métodos que serão expostos por comandos: um para ler e o outro para escrever a nossa informação. Iremos chamar esses comandos de LerNome e SalvarNome, respectivamente. Em um post passado, explicamos como criar comandos. É interessante dar uma lida, caso não saiba do que estamos falando.

Primeiro, o código de ler o XData:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38 [CommandMethod("LerNome")]
public static void LerNome()
{
    var documento = Application.DocumentManager.MdiActiveDocument;
    var editor = documento.Editor;

    var opcoes = new PromptEntityOptions("\nSelecione a entidade: ");
    opcoes.SetRejectMessage("\nPor favor, selecione uma reta (Line).");
    opcoes.AddAllowedClass(typeof(Line), false);
    opcoes.AllowNone = false;

    var resultado = editor.GetEntity(opcoes);

    if (resultado.Status != PromptStatus.OK)
    {
        editor.WriteMessage("\nComando abortado.");
        return;
    }

    using (var transacao = documento.TransactionManager.StartTransaction())
    {
        var reta = transacao.GetObject(resultado.ObjectId, OpenMode.ForRead);

        var dados = reta.XData;

        if (dados == null)
        {
            editor.WriteMessage("\nNão há dados anexados à reta.");
        }
        else
        {
            foreach (var valor in dados)
            {
                editor.WriteMessage("\nTipo: {0}, Valor: {1}", valor.TypeCode, valor.Value.ToString());
            }
        }
    }
}

Como hoje é sexta-feira 13, vamos como diria Jason: por partes.

A primeira linha de código do método criar uma variável que vai conter o documento corrente que está aberto no AutoCAD. É o ideal armazenar essa informação assim que o comando for executado, diminuindo assim as chances do documento corrente mudar durante o curso da execução do método. Se isto acontecer, é bem provável que os resultados finais esperados não serão atingidos de maneira satisfatória.

Em seguida, simplesmente criamos a variável que nos ajudará a termos acesso ao editor do AutoCAD. Esta linha não é estritamente necessária, claro: poderíamos simplesmente substituir editor por documento.Editor. É apenas para deixar claro o que estamos fazendo.

Novamente, iremos criar uma variável, que nos servirá para definir as opções do prompt do AutoCAD, já que precisamos que o usuário indique ao comando qual entidade deverá ser usada para pesquisar os dados em anexo (daí o fato do objeto ser da classe PromptEntityOptions). É como o comando Explode, por exemplo: é necessário que o usuário defina qual objeto ele quer explodir, ou seja, o argumento do comando.

As três linhas seguintes dizem respeito à configuração do prompt. No construtor, definimos a mensagem que aparecerá para o usuário: “Selecione a entidade”. Poderíamos, obviamente, mudar essa mensagem para “Selecione uma reta”. Em seguida, simplesmente dizemos qual mensagem o usuário irá visualizar caso selecione algo que não queremos. Depois, adicionamos um tipo de classe permitida como seleção (no caso, Line) e, por fim, dizemos que a seleção não pode estar vazia. Abaixo, uma screenshot da execução do comando:

Mais uma, desta vez selecionando o retângulo (entidade inválida)…:

Note que a entidade não foi aceita: a linha de comando avisa ao usuário para selecionar uma reta. O modo de seleção do AutoCAD ainda está pedindo que uma entidade seja selecionada, como destacamos.

É interessante observar que essa Line herda de DBObject, e não de um objeto de geometria. Nós já falamos sobre esse assunto anteriormente. Existem diferenças cruciais entre as duas classes, e é importante entendê-las no nosso contexto. Basicamente, a classe de geometria possui propriedades e métodos relevantes ao aspecto geométrico, enquanto o DBObject é relacionado, como o nome diz, ao banco de dados do AutoCAD. Como nós estamos interessados no XData, o que importa pra nós são as classes de dados, não as de geometria.

As próximas linhas efetivamente perguntam ao usuário qual a entidade que ele deseja selecionar, e depois analisa o resultado. Se for algo diferente de OK, cancelamos a execução do método. Nada de muito mágico aqui.

Agora é que a coisa fica interessante. Primeiro, criamos uma transação. A keyword using garante que os unmanaged resources (ou seja, recursos que o .NET não gerencia, dois quais o AutoCAD faz uso pesado) da classe sejam despeados uma vez que a execução do bloco seja finalizada. Esse comportamento só é possível porque a classe Transaction herda da interface IDisposable. Como esse assunto foge um pouco do escopo, recomendo a seguinte leitura para quem se interessar mais: http://msdn.microsoft.com/en-us/library/system.idisposable.aspx

Depois, lemos o objeto do banco de dados no modo de leitura, e verificamos o XData anexado. Basicamente, o XData é um objeto da classe ResultBuffer, que é uma coleção de elementos do tipo TypedValue, que por sua vez é uma estrutura que contém o tipo e o valor de um dado. Ufa. Percorremos esses dados e escrevemos o tipo (que é um short) e o valor (que é um object) na tela do editor. Vamos ver o resultado se clicarmos na reta desenhada:

Como ainda não salvamos nenhum dado adicional, a linha de comando avisa que não há nenhum dado anexado à reta. Simples, não?

No próximo post, iremos analisar como salvar o XData. Até breve, forte abraço e bom coding a todos!

Desenhando de maneira programática no AutoCAD: Introdução

2013-06-24T00:00:00-03:00

Às vezes é necessário, quando desenvolvemos plugins ou ferramentas para o AutoCAD, que algum desenho seja feito no documento. Vários motivos podem levar a isso: um deles é o de facilitar um trabalho repetitivo, criando um comando “macro-like” que irá facilitar a vida do usuário.

Nessa introdução, iremos desenhar uma linha (Line) no AutoCAD, mas a ideia é a mesma para qualquer entidade válida (lembrando que nada nos impede de criarmos nossas próprias entidades).

Antes de mais nada, necessitamos fazer uma pequena distinção entre objetos de geometria e objetos de banco de dados. Os objetos de geometria nos auxiliam no desenho, e os objetos de banco de dados são efetivamente salvos no Database do AutoCAD, e possuem portanto algumas propriedades a mais que não interessam à geometria pura (como XData e ObjectId, por exemplo. Iremos falar mais desses conceitos em outro tópico).

Para fins de exemplo, iremos desenhar um quadrado cujo lado será 100. Esse quadrado terá início na origem (ponto 0,0,0).

Primeiramente, vamos criar um novo projeto no Visual Studio Express, clicando em File->New Project.. (ou apertando Ctrl + Shift + N):

O projeto deve ser do tipo Class Library. Vamos dar a ele o nome de “DesenharQuadrado”:

Agora, iremos renomear o arquivo Class1.cs para AuxiliarAutoCAD.cs. Ao fazê-lo, o Visual Studio perguntará se você quer alterar o nome da classe subjacente. Responda que sim, e o nome da classe será automaticamente atualizado para refletir o nome do arquivo:

Até agora, nada difere este projeto do que um outro projeto qualquer que não é relacionado ao AutoCAD. Mas agora as coisas ficam um pouco diferentes. Vamos adicionar as referências ao ObjectARX, que é a biblioteca de classes da Autodesk que nos permite programar para os seus sistemas. No Solution Explorer, clicamos com o botão direito em References->Add Reference…

Agora, vá até o local onde você descompactou o ObjectARX e selecione os arquivos AcCoreMgd.dll, AcDbMgd.dll e AcMgd.dll. Se você ainda não baixou o ObjectARX, clique aqui. Esse é um post do nosso blog que contém informações sobre as DLLs, e também um link para fazer o download do ObjectARX 2013.

Como a nossa ideia é criar um comando para desenhar nosso quadrado, primeiro devemos criar o método que irá chamar o comando. Para isso, devemos usar o Attribute [CommandMethod], que indica que o método subsequente é um comando no AutoCAD. Primeiro, adicione o namespace Autodesk.AutoCAD.Runtime com o comando using. Depois, defina um método chamado DesenharQuadrado que não recebe argumentos e cuja assinatura é void. Depois, adicione o atributto [CommandMethod(“DesenharQuadrado”)] ao método recém-criado. Nosso código ficará assim:

1
2
3
4 [CommandMethod("DesenharQuadrado")]
public void DesenharQuadrado()
{
}

Um quadrado tem quatro vértices, e cada vértice é representado por um ponto (A,B,C e D), como na imagem abaixo:

No nosso exemplo, diremos que a origem é o ponto C, ou seja, as coordenadas do ponto C são (0,0,0). Como estabelecemos um lado de 100, então o ponto A tem coordenadas (0,100,0), o ponto B (100,100,0) e o ponto D (100,0,0). Lembrando que estamos num espaço 3D, portanto as coordenadas são X, Y e Z. Apesar de nosso quadrado não ter dimensão no sentido Z, devemos passar o argumento para o construtor da classe Point3d.

Ao código, então:

1
2
3
4 var pontoA = new Point3d(0, 100, 0);
var pontoB = new Point3d(100, 100, 0);
var pontoC = new Point3d(0, 0, 0);
var pontoD = new Point3d(100, 0, 0);

Note que temos 4 pontos criados, mas eles não são suficientes. É necessários uni-los através de quatro retas: AB, AC, BD, CD. Para tal, criamos o objeto Line, que representa a reta, e passamos os pontos de início e fim como argumentos para o construtor:

1
2
3
4 var retaAB = new Line(pontoA, pontoB);
var retaAC = new Line(pontoA, pontoC);
var retaBD = new Line(pontoB, pontoD);
var retaCD = new Line(pontoC, pontoD);

Note que, apesar de termos a geometria construída em memória, nós não a adicionamos efetivamente ao documento em momento algum. Para tal, precisamos criar uma Transaction, ou seja, uma transação junto ao banco de dados do AutoCAD, e assim inserir efetivamente os objetos nele.

Devemos agora desenhar o quadrado. A primeira medida a ser tomada agora é adicionar o namespace Autodesk.AutoCAD.ApplicationServices. Esse namespace nos fornecerá um método para acessarmos o documento corrente do AutoCAD, isto é, o documento que está aberto e ativo no programa.

Após isso, criamos a Transaction usando o método StartTransaction() do campo TransactionManager. Como a classe Transaction herda de RXObject, que herda de DisposableWrapper, que herda de IDisposable (ufa…), é possível usar a keyword “using”, que descartará o objeto ao fim do bloco (mais informações sobre a keyword using aqui: http://msdn.microsoft.com/en-us/library/yh598w02.aspx).

Dentro deste bloco, iremos invocar o método GetObject do nosso objeto de transação, que lê um objeto do banco de dados. Este método, portanto, recebe um ObjectId, e o método de abertura (ForRead, ForWrite, ForNotify - geralmente, nós usamos ou ForRead, quando queremos apenas ler o objeto, ou ForWrite quando quisermos alterar o banco de alguma forma).

Agora, nós iremos ler a tabela de blocos (BlockTable), que vai conter as retas criadas por nós. Após este passo, iremos ler o ModelSpace, e abri-lo para escrita, para que possamos inserir nossos objetos de fato:

1
2
3
4
5
6
7 var document = Application.DocumentManager.MdiActiveDocument;

using (var transaction = document.TransactionManager.StartTransaction())
{
     var blockTable = transaction.GetObject(document.Database.BlockTableId, OpenMode.ForRead) as BlockTable;
     var blockTableRecord = transaction.GetObject(blockTable[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
}

Precisamos agora adicionar as quatro retas ao modelo. Iremos usar dois métodos para tal: AppendEntity(Entity) e AddNewlyCreatedDBObject(DBObject, bool), que pertencem, respectivamente, às classes BlockTableRecord e Transaction. Após adicionamos, nós executamos a transação com o método Commit():

1
2
3
4
5
6
7
8
9
10
11
12
13 blockTableRecord.AppendEntity(retaAB);
transaction.AddNewlyCreatedDBObject(retaAB, true);

blockTableRecord.AppendEntity(retaAC);
transaction.AddNewlyCreatedDBObject(retaAC, true);

blockTableRecord.AppendEntity(retaBD);
transaction.AddNewlyCreatedDBObject(retaBD, true);

blockTableRecord.AppendEntity(retaCD);
transaction.AddNewlyCreatedDBObject(retaCD, true);

transaction.Commit();

Pronto. Agora, apenas por motivos estéticos, iremos escrever no output do AutoCAD que nosso comando teve êxito na execução. Para isto, basta executar o método WriteMessage do campo Editor do nosso documento. Abaixo, o código completo do nosso gerador de quadrados:

    using Autodesk.AutoCAD.ApplicationServices;
    using Autodesk.AutoCAD.DatabaseServices;
    using Autodesk.AutoCAD.Geometry;
    using Autodesk.AutoCAD.Runtime;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
     
    namespace DesenharQuadrado
    {
        public class AuxiliarAutoCAD
        {
            [CommandMethod("DesenharQuadrado")]
            public void DesenharQuadrado()
            {
     
                var pontoA = new Point3d(0, 100, 0);
                var pontoB = new Point3d(100, 100, 0);
                var pontoC = new Point3d(0, 0, 0);
                var pontoD = new Point3d(100, 0, 0);
     
                var retaAB = new Line(pontoA, pontoB);
                var retaAC = new Line(pontoA, pontoC);
                var retaBD = new Line(pontoB, pontoD);
                var retaCD = new Line(pontoC, pontoD);
     
                var document = Application.DocumentManager.MdiActiveDocument;
     
                using (var transaction = document.TransactionManager.StartTransaction())
                {
                    var blockTable = transaction.GetObject(document.Database.BlockTableId, OpenMode.ForRead) as BlockTable;
                    var blockTableRecord = transaction.GetObject(blockTable[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
     
                    blockTableRecord.AppendEntity(retaAB);
                    transaction.AddNewlyCreatedDBObject(retaAB, true);
     
                    blockTableRecord.AppendEntity(retaAC);
                    transaction.AddNewlyCreatedDBObject(retaAC, true);
     
                    blockTableRecord.AppendEntity(retaBD);
                    transaction.AddNewlyCreatedDBObject(retaBD, true);
     
                    blockTableRecord.AppendEntity(retaCD);
                    transaction.AddNewlyCreatedDBObject(retaCD, true);
     
                    transaction.Commit();
     
                    transaction.Commit();
                }
     
                document.Editor.WriteMessage("Comando efetuado com sucesso.");
            }
        }
    }

Agora, vamos à compilação. Uma coisa que é interessante fazer em se tratando das DLLs do ObjectArx é marcar a opção de copiar para a pasta do build como falsa (obrigado ao Augusto Gonçalves da Autodesk por me lembrar disso :D ). Para tal, basta clicar na referência da DLL e marcar a caixa de opções como a seguir:

Agora, utilizando a técnica descrita por nós anteriormente, iremos iniciar a nossa aplicação. Clique em Start , ou aperte F5, para iniciar a depuração (debug):

Lembre-se que precisamos digitar o comando netload no AutoCAD e carregarmos nossa biblioteca recém-escrita. Ela se encontra na pasta bin/Debug do projeto:

Agora, podemos executar nosso comando DesenharQuadrado dentro do AutocCAD:

E então observamos o resultado: um quadrado desenhado na origem, com lado 100:

Enfim, é isso. O post é longo pois vários conceitos novos foram abordados aqui. Mas pode-se observar que não é uma tarefa muito difícil desenhar no AutoCAD. Apesar de ser uma ferramenta de desenho bastante completa, não é possível para a Autodesk inferir todos os usos que seu aplicativo possa ter. Portanto, criar comandos como este podem facilitar bastante a vida de arquitetos e engenheiros que precisem de algo mais específico.

Abraço e até a próxima.

DLLs do AutoCAD ObjectArx

2013-05-17T00:00:00-03:00

Olá a todos.

Esse post visa tentar explicar um pouco sobre cada DLL do AutoCAD ObjectARX, que é nosso arcabouço de objetos que nos permite interagir com o programa (aliás, o ObjectARX é indispensável para o acompanhamento desse blog, se você ainda não fez, faça o download aqui).

Enfim, se olharmos os arquivos do ObjectARX (neste caso, estamos analisando especificamente a versão 2013 do Framework), na pasta \inc, temos alguns arquivos *Mgd.dll. Eles são:

AcCoreMgd.dll (esta DLL só existe a partir da versão 2013)
AcDbMdg.dll
AcMgd.dll
AcTcMgd.dll

Se visualizarmos essas DLLs com o Object Browser, veremos o seguinte:

O nome da DLL já da uma dica do que se trata. O “core”, isto é, o “coração” da API Managed do AutoCAD está contido nessa DLL. Existem alguns namespaces de interoperabilidade com o Editor, seviço de plotting, e de conexão com o Windows. Em suma, esta DLL é bastante importante e quase todos os nossos exemplos farão uso desta DLL (inclusive porque é ela que nos possibilita criar comandos com o atributo [CommandMethod]).

Esta DLL é a que trata do banco de dados do AutoCAD, bem como os componentes que vão ser inseridos nela. É outra DLL crucial: se quisermos desenhar ou obter qualquer informação sobre o desenho, necessariamente precisaremos usar a AcDbMgd. Se examinarmos os namespaces, veremos os itens Geometry, que contém as classes Point, Line, etc., usadas para criar a geometria em memória, e DatabaseServices, que contém classes também de suma importância, tais quais Drawable e DBObject. A maioria das aplicação não as utilizam, mas como iremos desenhar bastante e mostrar o desenho na tela, elas serão muito utilizadas por nós.

Outra biblioteca fundamental. Possui o namespace ApplicationServices, importante por ter, dentre outros, o DocumentManager. É com ele que iremos executar várias funções importantes relacionadas aos documentos no AutoCAD.

Por último, a biblioteca AcTcMgd. Não é uma biblioteca fundamental, e dificilmente iremos utiliza-la no blog.

Configurando o Visual Studio 2012 Express para Debugar o AutoCAD 2013

2013-04-01T00:00:00-03:00

Um aspecto primordial da programação em geral diz respeito à configuração do ambiente. No nosso caso, configurar o Visual Studio para habilitar o debug quando estivermos escrevendo plug-ins para o AutoCAD é fundamental. Para isso, vamos criar um novo projeto (lembre-se: um plug-in de AutoCAD é do tipo Class Library):

Nas versões Express do Visual Studio, não há maneira de configurar o programa que irá iniciar o Debug. Porém, há um pequeno truque para contornarmos essa situação.

Para isso, feche o Visual Studio Express e vá até a pasta do projeto:

Você deverá ver esses arquivos. Crie um novo arquivo no padrão (NomeDoProjeto).csproj.user. No nosso caso, o arquivo deverá se chamar FirstAutoCADApp.csproj.user:

Após isso, edite o arquivo que você acabou de criar usando o notepad, o Visual Studio ou qualquer outro editor de texto que você prefira. Insira o seguinte conteúdo nele:

1
2
3
4
5
6
7
8 <?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'">
    <StartAction>Program</StartAction>
    <StartProgram>C:\Program Files\Autodesk\AutoCAD 2013\acad.exe</StartProgram>
    <StartWorkingDirectory>C:\Program Files\Autodesk\AutoCAD 2013\</StartWorkingDirectory>
  </PropertyGroup>
</Project>

Lembre-se de trocar o caminho “C:\Program Files\Autodesk\AutoCAD 2013” pelo caminho onde você instalou o AutoCAD 2013. Salve o arquivo e reabra o Visual Studio Express. Agora, ao ir em DEBUG -> Start Debugging (ou simplesmente ao apertar F5) o AutoCAD abrirá, permitindo que você debugue sua aplicação.

No próximo tópico eu irei mostrar um exemplo prático disso.

Uma última observação: é possível editar essas configurações diretamente no arquivo .csproj, sem a necessidade de criar um .user, mas eu acho que criar um novo arquivo deixa o ambiente muito mais organizado. Eu não irei cobrir aqui como fazer editando diretamente o .csproj.

Boa sorte, e bom desenvolvimento a todos!