O Poder Do ObjectARX_0

Comunidades de Usuários Autodesk Brasil

O Poder do ObjectARX ® Fernando P. Malard – ofcdesk, LLC. Este Tutorial, para usuários avançados e desenvolvedores do AutoCAD® irá apresentar uma introdução simples mas completa para criação e utilização de entidades personalizadas com a fantástica API de programação ObjectARX. Inicialmente, serão apresentados alguns conceitos básicos da programação ObjectARX. Os leitores irão aprender a criar aplicativos ObjectARX básicos utilizando o ARX Wizard. A seguir, a estrutura de dados do AutoCAD será explorada para entedermos seu funcionamento, organização e utilização dos seus objetos. No final, será apresentado um exemplo completo com uma descrição detalhada passo a passo.

Sobre o Autor:

Fernando é Engenheiro Civil especialista em AutoCAD ® e ObjectARX® desde 1996. Ele é membro da Auto Autode desk sk Deve Develo lope perr Netw Networ orkk desd desde e 1996 1996.. Ele Ele dese desenv nvol olve ve dive divers rsos os apli aplica catitivo voss para para Auto AutoCA CAD D para para Engenharia Civil, Arquitetura e GIS usando ObjectARX, .NET, SQL e Oracle ®. Fernando tem ainda grande experiência no ensino de AutoCAD, C++, MFC, COM, SQL, .NET e ObjectARX há mais de 15 anos. Atua Atualm lmen ente te cont contin inua ua util utiliz izan ando do o Obje Object ctAR ARX X em comp comple lexa xass solu soluçõ ções es ERP ERP e atua atua como como CTO CTO da ofcd ofcdes esk. k. E-mail: fernando.malard@ofcdes [email protected] k.com / [email protected] [email protected]

®

O Poder do ObjectARX

Introdução

Durante os últimos anos o AutoCAD evoluiu e se tornou uma plataforma CAD genérica e extremamente poderosa proporcionando uma revolução no CAD e na Indústria de Projetos. Essa evolução, em sua maioria, se deve à redução da lacuna existente entre as situações reais e dos projetos conceituais. Isso foi possível somente com a abertura da arquitetura do AutoCAD que foi iniciada oficialmente na versão 13. Naquele momento, a Autodesk ® decidiu disponibilizar parte do código fonte nativo do AutoCAD para desenvolvedores em uma forma de SDK (Kit de Desenvolvimento). Essa ferramenta poderosa permitiu que os desenvolvedores criassem aplicativos e soluções que usassem todo o poder do núcleo do AutoCAD. O ObjectARX , inicialmente chamado de ARX, foi introduzido oficialmente na versão 13. Depois disso, o AutoCAD evoluiu para uma interface poderosa com a versão 14 e a seguir com a versão MDI (Interface de Múltiplos Documentos) na versão 2000. Atualmente, o AutoCAD está na versão 19.0 (mais conhecida como 2013) apresentando muitas tecnologias de ponta na programação tais como a interface .NET (linguagens C# e VB.NET) além do WPF. O ObjectARX, através do C++, está no topo da lista de velocidade e performance quando comparado como outras linguagens de programação do AutoCAD. A razão é muito simples, até hoje grande parte do código do AutoCAD ainda está em C++ e provavelmente não irá mudar tão cedo. É verdade que temos hoje grande parte da API disponível através do .NET mas muita coisa realmente é apenas uma casca de acesso ao código real dentro do núcleo C++. O ObjectARX leva uma grande vantagem quando comparado às outras linguagens de programação do AutoCAD. Atualmente é a única que permite a implementação completa de Custom Entities (Entidades Personalizadas). Essa grande capacidade do ObjectARX em C++ foi intensivamente usada pela própria Autodesk para criar os outros produtos verticais no topo do AutoCAD R13. Hoje temos inúmeros produtos baseados no AutoCAD feitos pela própria Autodesk usando todo o poder proporcionado pelo ObjectARX. Podemos citar alguns produtos verticais como o AutoCAD Architecture e AutoCAD Civil. Esses dois produtos são exemplos do uso intensivo de Custom Entities para aproximar a ferramenta CAD ao cenário real da indústria. Ao invés de usarmos linhas e círculos para representarmos símbolos arquitetônicos, o AutoCAD Architecture é capaz de criar entidades específicas como janelas, portas, escadas, etc. Isso faz com que o aplicativo CAD seja muito mais adequado para sua indústria específica e que haja redução substancial de tempo de criação de projetos. Neste Tutorial, você poderá experimentar parte desse poder ao implementar uma simples Custom Entity dentro do AutoCAD. Você iniciará o aprendizado com conceitos básicos de um aplicativo ObjectARX. A seguir você aprenderá conceitos importantes sobre a estrutura de dados do AutoCAD, como seus objetos são organizados, armazenados e como manipulá-los. Finalmente, você aprenderá como criar uma simples entidade personalizada com funcionalidades básicas além de como expandi-la para uma entidade mais complexa. Nota: Nós iremos utilizar o AutoCAD 2012 , Visual Studio 2008 SP1 e ObjectARX 2010 neste Tutorial. Os módulos ObjectARX criados com o ObjectARX 2010 são binariamente compatíveis com o AutoCAD 2010, 2011 e 2012. Para o AutoCAD 2013 é necessário utilizar o Visual Studio 2010 SP1 e o ObjectARX 2013 sendo que os módulos compilados não serão compatíveis com as versões anteriores ao 2013. Estrutura de Dados do AutoCAD

A estrutura de dados do AutoCAD é bem organizada para facilitar a manipulação dos seus objetos. Para melhor entender como as coisas acontecem você pode encarar a estrutura de dados como um “banco de dados de objetos ” que recebe comandos, reage a eventos, dispara seus próprios eventos e atua como um repositório de objetos. Esse banco de dados opera sob algumas condições e regras. Algumas vezes sua manipulação é um pouco burocrática mas isso garante sua integridade e a estabilidade do aplicativo. Quando você está criando um desenho dentro do AutoCAD, você está na verdade criando, excluindo e modificando objetos no seu banco de dados. O banco de dados do AutoCAD é um conjunto

2

®


de objetos hierarquicamente organizado cuja representação é um desenho (um arquivo DWG). Se pegarmos como exemplo uma entidade simples, digamos uma LINE, ela contém todos os dados necessários para se representar graficamente. Como um aplicativo vetorial, o AutoCAD não armazena pixels entre os pontos inicial e final de uma linha. Ele apenas armazena as coordenadas dos pontos inicial e final dessa linha ( X,Y,Z). O desenho então da linha propriamente dita é feito através da equação matemática que representa uma linha desenhada na tela automaticamente através de pixels. O processo completo de criação de uma LINE não está completo apenas se especificarmos suas propriedades mas requer ainda que você especifique aonde e como esta LINE será armazenada. Dentro do banco de dados do AutoCAD existem diversos tipo de objetos do tipo containers cuja finalidade é armazenar e manter objetos . Cada container tem seus próprios procedimentos e regras para armazenar e recuperar seus objetos. Na maioria dos casos, é responsável por manter e salvar seus objetos. No exemplo da LINE ela poderia ser armazenadas num container de entidades. Esses containers de entidades são chamados de Block Table Records (BTR). Cada BTR pode armazenar diversos tipos de entidades como lines, circles, texts, blocks, etc. O diagrama da Figura 1, mostra parte da estrutura de dados do AutoCAD.

Figura 1 – Banco de dados do AutoCAD mostrando os containers

A Figura 1 que as entidades podem ser armazenadas no Model Space, Paper Space ou outros Block Table Records . Esses “outros” BTR podem ser uma página de Layout ou mesmo outro Bloco. Cada bloco inserido dentro de um desenho do AutoCAD é uma entidade Block Reference que aponta para o Bloco original que é um Block Table Record. Por isso, quando editamos um Bloco com o comando REFEDIT ele reflete em todas as cópias desse Bloco pois na prática você está editando o Bloco original. A seguir, veja um trecho de código que demonstra o processo de criação de uma entidade LINE em C++. O código irá criar uma LINE do ponto (1.0, 1.0, 0.0) até o ponto (10.0, 10.0, 0.0):

3

®


01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16

// cria dois pontos e uma linha AcGePoint3d startPt (1.0, 1.0, 0.0); AcGePoint3d endPt (10.0, 10.0, 0.0); AcDbLine * pLine = new AcDbLine (startPt, endPt); // abre o objeto container apropriado AcDbBlockTable * pBlock = NULL; AcDbDatabase * pDB = acdbHostApplicationServices()->workingDatabase(); pDB->getSymbolTable(pBlock,AcDb::kForRead); AcDbBlockTableRecord * pBTR = NULL; pBlock->getAt(ACDB_MODEL_SPACE, pBTR, AcDb::kForWrite); pBlock->close(); // agora, armazena a entidade no container AcDbObjectId Id; pBTR->appendAcDbEntity(Id, pLine); pBTR->close(); pLine->close();

O processo de criação da LINE é similar ao processo de criação das outras entidades e ele basicamente consiste dos seguintes passos: •

•

•

Primeiro Instanciamos um ponteiro para a classe da entidade (alguns construtores irão permitir e exigir que você forneça alguns parâmetros); A seguir, precisamos abrir o Block Table aonde iremos encontrar o container apropriado. Nesse exemplo nós iremos usar o container Model Space; Depois disso, nós abrimos o Model Space (um Block Table Record) e adicionamos a ele a entidade recentemente instanciada.

É muito importante notar que esse processo exige que você abra e feche cada objeto específico para ter acesso às suas propriedades e métodos. Uma vez que a entidade seja adicionada ao banco de dados ela vai receber um identificador único associado automaticamente pelo banco de dados do AutoCAD, chamado AcDbObjectId . Essa é a chave de acesso à entidade sempre que você quiser. Ele é válido e permanece inalterado somente durante a sessão de desenho do AutoCAD. Essa é apenas uma visão geral do processo para deixar claro os passos necessários para criar uma entidade simples e para demonstrar o processo de acesso aos métodos e procedimentos. A seguir você irá aprender a criar um aplicativo ObjectARX usando o Visual Studio.

Visão Geral do Aplicativo ObjectARX

O Aplicativo ObjectARX é uma DLL (Dynamic Link Library ). Isso permite com que ele seja carregado dentro do AutoCAD em tempo de execução. Esse conceito evoluiu posteriormente para o Object Enabler que foi introduzido há algum tempo. Esse conceito divide o aplicativo em duas partes. O Object Enabler é um aplicativo ObjectARX contendo apenas um conjunto de classes para objetos e entidades. Ele é chamado de ObjectDBX e é compatível com todas as soluções Autodesk construídas com a tecnologia RealDWG como os visualizadores DWG e todos os outros verticais AutoCAD. As últimas três letras do nome determinam sua finalidade: ARX ( AutoCAD Runtime Extension) e DBX (Database Extension ). Normalmente seu aplicativo será constituído por diversos módulos ARX e DBX que irão representar as seguintes funcionalidades: Interfaces : Irão conter todas as janelas, comandos, eventos e qualquer outro código relacionado às interfaces do AutoCAD. Ele será um aplicativo ObjectARX representado por uma DLL (extensão de arquivo .arx) e será compatível somente com o AutoCAD e seus verticais; Classes customizadas : Irão conter todas as classes customizadas (objetos e/ou entidades) que não requerem a presença do aplicativo AutoCAD mas apenas do RealDWG. Ele será um aplicativo

4

®


ObjectDBX representado por uma DLL (extensão de arquivo .dbx) e não poderá conter qualquer

chamada ou referência a código específico do AutoCAD. Ele poderá ser carregado dentro do AutoCAD, seus verticais e todos os aplicativos Autodesk com suporte ao ObjectDBX ; Você pode dividir seu aplicativo em diversos módulos ARX e DBX e, dependendo da complexidade, isso fará com que seu aplicativo seja muito mais organizado e escalável. Imagine que você precise trabalhar com um conjunto de clientes que pertencem ao mesmo segmento de indústria com pequenas diferenças entre seus produtos. Você poderá organizar seu aplicativo em classes para serem implementadas usando dois níveis de derivação. O primeiro nível irá implementar o que existe de comum entre os produtos dos clientes. O próximo nível irá implementar requisitos específicos de cada cliente e irá permitir que você ajuste seu aplicativo especificamente para cada demanda. A estrutura geral de uma aplicação desse tipo teria os seguintes módulos: •

MyClientBasics.dbx;

•

MyClient1.dbx, MyClient2.dbx, MyClient3.dbx, etc.

Dessa forma, você poderá usar o mesmo núcleo de código entre os clientes, e melhor, quando você consertar um problema ou adicionar uma nova funcionalidade em seus módulos base todos os clientes serão contemplados na próxima atualização. Essa é uma ótima estratégia para manter seu aplicativo organizado, atualizado e ajustado para cada indústria com suas regras de negócio específicas. Os dois módulos ARX e DBX podem ser carregados no AutoCAD usando um dos seguintes procedimentos: •

Comando ARX;

•

Arquivo acad.rx;

•

Comando APPLOAD ;

•

Método AutoLISP arxload() ou método ObjectARX acedArxLoad() ;

•

Opções de inicialização do AutoCAD: –ld ou /ld;

•

Entradas de Registro do Windows para Demand loading (carregamento automático).

Esses procedimentos podem ser usados em situações diferentes dependendo dos requisitos do seu aplicativo e dos mecanismos de distribuição e instalação.

Usando o ARXWizard – Exercício 1

O kit de desenvolvimento ObjectARX contém um plug-in do Visual Studio chamado ARXWizard . Esse plug-in ajuda você a não somente criar um aplicativo ARX ou DBX mas também auxilia muito no processo de criação das suas classes personalizadas. O instalador do ARXWizard está localizado na pasta \utils\ObjARXWiz do seu kit. Basta executar esse instalador (com o Visual Studio fechado) que ele irá criar uma nova opção de tipo de projetos dentro do Visual Studio na janela “ New Project” (dentro da categoria Visual C++) como mostrado na Figura 2.

5

®


Para criar um novo módulo ARX ou DBX, abra o Visual Studio e faça o seguinte: •

•

•

•

•

Abra o menu File > New > Project ; …

Selecione ObjectARX dentro do grupo Visual C++; Selecione o item ObjectARX/DBX/OMF Project; Especifique o nome do projeto, pasta e nome da solução; Clique OK para continuar.

Figura 2 – Janela New Project do Visual Studio

A seguir, você precisa escolher o tipo de projeto ( ARX ou DBX), suporte adicional do SDK, MFC, COM e .NET. Essas opções são descritas a seguir: Welcome

Especifique seu símbolo de desenvolvedor para ser usado como preixo para todas as classes (isso evitará conflito com outros aplicativos ObjectARX/ObjectDBX de outros usuários ou empresas). Se desejar (recomendo que sim), habilite a opção do símbolo _DEBUG que irá permitir desvios no código durante procedimentos de depuração.

Application Type

Selecione o tipo de aplicativo: ObjectARX ou ObjectDBX.

Additional SDK Support

Se desejar desenvolver um aplicativo que utilizará funcionalidades especificas ou classes do AutoCAD Architecture (OMF SDK) ou AutoCAD MAP (MAP API) habilite as opções.

6

®


MFC Support

Se o seu aplicativo utilizar a biblioteca MFC é necessário habilitar o suporte através da opção MFC support. Adicionalmente, se for também utilizar os controles AutoCAD MFC, habilite essa opção. *Somente aplicativos do tipo ARX podem utilizar os controles AutoCAD MFC.

COM Options

Se o seu aplicativo for utilizar as bibliotecas COM para cliente our servidor (ATL recomendado), escolha as opções necessárias.

.NET Support

Se planejar desenvolver um aplicativo do tipo mixed-mode, habilite esta opção. Essa opção irá adicionar suporte ao .NET Framework além do acesso às classes AutoCAD .NET de dentro do código C++.

Esse processo irá criar o conhecido “ Esqueleto do Aplicativo” que irá evitar um gasto de tempo considerável configurando tudo manualmente. Uma vez finalizado o processo de criação, A Solution do seu aplicativo será algo como apresentado na Figura 3.

Para compilar esse projeto, precisamos adicionar os caminhos do ObjectARX (pasta include e lib) nas opções do Visual Studio. Isso precisará ser feito apenas uma vez e irá valer para os próximos projetos criados na mesma máquina. Acesse o menu Tools > Options , abra a entrada VC++ Directories. Siga as instruções das Figuras 4 e 5 e a seguir clique em OK para finalizar. …

Figura 3 – Típica Solution ObjectARX

7

®


Na caixa “ Show directories for: ” selecione “Include files” e adicione duas pastas “[drive:]\ObjectARX 2010\inc” e “[drive:]\ObjectARX 2010\inc-win32” (Figura 4). Se estiver em um sistema de 64-bit, utilize a pasta “[drive:]\ObjectARX 2010\inc-x64 ”. Repita a configuração para a opção “ Reference files”.

Figura 4 – Pastas do ObjectARX para Include

*[drive:] é o seu drive local, normalmente C: ou D:

A seguir, selecione “ Library files:” na mesma caixa e adicione a nova pasta: “[drive:]\ObjectARX 2010\lib-win32”. Para sistemas de 64-bit, utilize: “[drive:]\ObjectARX 2010\lib-x64” (Figura 5).

Figura 5 – Pasta do ObjectARX para Library

Para compilar o projeto, primeiramente mude a configuração de compilação para Release. Para fazer isso, vá ao menu Build, escolha Configuration Manager , selecione Release na caixa “ Active solution configuration”. A seguir, vá ao menu Build e escolha Build Solution. Você deve obter algum resultado parecido com a tela de Output/Build a seguir (Figura 6). …

Agora basta carregar seu aplicativo dentro do AutoCAD. Abra o AutoCAD e acione o comando APPLOAD . Procure pelo arquivo ArxProject1.arx dentro da pasta ArxProject1\Release , selecione o arquivo e click em LOAD.

Figura 6 – Típica tela de resultados de um Build

8

®


Conceitos de uma Entidade Customizada

Uma vez que você aprendeu a criar um aplicativo ObjectARX /ObjectDBX podemos agora aprofundar no assunto de Custom Entities. Como uma poderosa linguagem Orientada a Objetos, o C++ aos desenvolvedores derivar classes proporcionando uma grande reutilização de código. O conceito de herança (derivação) não é um dos nossos objetivos mas podemos observar parte da hierarquia de classes do ObjectARX para entender melhor como as classes do AutoCAD são organizadas (Figura 7).

AcDbEntity AcDbCurve

e n i L b D c A

e l c r i C b D c A

e n i l y l o P b D c A

AcDbDimension

. . .

n o i s n e m i D d e n g i l A b D c A

n o i s n e m i D e t a t o R b D c A

n o i s n e m i D c r A b D c A

. . .

Y T I T N E M O T S U C R U O Y

O mesmo potencial de reutilização de classes usado nos verticais do AutoCAD está disponível através do ObjectARX. O primeiro passo para criarmos uma entidade customizada está na escolha de qual classe base iremos derivar. A seguir, é necessário escolher quais métodos sua entidade irá redefinir. Quando a classe da sua entidade for carregada dentro do AutoCAD ela será registrada na árvore dinâmica de classes do ObjectARX ficando assim disponível para utilização. A entidade customizada participará, por padrão, de várias operações e eventos disparados e coordenados pelo próprio AutoCAD.

Figura 7 – Parte da árvore de classes do ObjectARX

Como exemplo, o método subWorldDraw () é responsável pelo desenho gráfico da entidade. Esse método tem uma assinatura específica e é virtual (pode ser sobrecarregado por classes derivadas) permitindo que sua entidade tenha sua própria implementação. Uma vez que o AutoCAD precise refazer o desenho na tela ele inicia um processo de iteração no seu banco de dados chamando o método subWorldDraw () e caso retorne false, chamando o método subViewportDraw (). Certamente você está pensando: “ Como o AutoCAD sabe como chamar o método de uma classe que você criou? ”. Ele não sabe mas o que ele sabe é que sua entidade deriva de AcDbEntity aonde o método subWorldDraw () foi inicialmente definido. O mecanismo da linguagem C++ irá então, em tempo de execução, redirecionar a chamada feita pelo AutoCAD no nível AcDbEntity para o nível da instância da entidade aonde o método foi definido. O mesmo processo ocorre para todos os outros métodos virtuais. Dessa maneira, o AutoCAD abstrai todo o gerenciamento dos objetos no nível de classe base refletindo nas classes derivadas. Se sua classe não implementar algum método virtual específico, será feita uma chamada na próxima classe superiore assim sucessivamente até chegar-se no nível da classe AcDbEntity . A maior parte dos métodos da classe AcDbEntity não faz nada por padrão e portanto é necessário implementar o código específico na sua classe.

9

®


Criando uma Custom Entity – Exercício 2 – Etapa 1

Você irá aprender nesse exercício como criar uma simples entidade customizada . A simplicidade será mantida para podermos manter o foco nos conceitos básicos envolvidos. Nos próximos passos iremos aprimorar essa entidade acrescentando novas funcionalidades. O primeiro passo é dar um nome para a entidade e escolher de qual classe ela irá derivar. Lembre-se que devemos dividir nosso aplicativo em dois módulos, um ARX (interfaces) e um DBX (para as classes customizadas). Os dois projetos ficarão dentro de uma mesma Solution do Visual Studioe o módulo ARX irá depender do módulo DBX. Os nomes serão os seguintes (sem acentuação): •

Solution : Exercicio2 (o Visual Studio irá criar o arquivo Exercicio2.sln );

•

DBX: AuCustomObjects (o Visual Studio irá criar o arquivo AuCustomObjects.vcproj );

•

ARX: AuUserInterface (o Visual Studio irá criar o arquivo AuUserInterface.vcproj );

Abra o Visual Studio, vá ao menu File > New Project Abra “Other Project Types” e clique em “Visual Studio Solutions”. Selecione então o template “Blank Solution”. De o nome de Exercicio2 (pode ser em qualquer pasta do seu computador). Clique em OK …

para continuar (Figura 8).

Figura 8 – Projeto Blank Solution

Agora, botão direito na Solution; selectione Add e depois New Project , (Figura 9). A janela apresentada no Exercício1 irá aparecer. Selecione na lista o template ObjectARX e crie os módulos AuUserInterface e AuCustomObjects . Lembre-se de escolher o tipo ARX ou DBX apropriadamente. …

Figura 9 – Criando projetos na Solution

A localização de cada projeto será dentro da pasta da Solution por padrão. Não mude a localização após criar os projetos. Habilite a opção MFC em ambos os projetos (não é necessário habilitar o suporte a AutoCAD MFC). Habilite o símbolo _DEBUG . Não habilite nada relacionado ao COM ou .NET em ambos os projetos. Faça com que o projeto AuUserInterface dependa do projeto AuCustomObjects . Para fazer isso, botão direito no projeto AuUserInterface e escolha Dependencies Marque então o projeto AuCustomObjects na lista e clique em OK. …

Botão direito no projeto AuUserInterface novamente e selecione “ Set as Startup Project” (ele ficará em negrito). Agora teste a compilação da sua Solution: Vá ao menu Build > Build Solution. Você deverá obter um Build sem erros e possivelmente alguns avisos que poderemos ignorar com segurança.

10

®


O teste final dessa etapa é carregar o aplicativo dentro do AutoCAD. Lembre-se que nosso projeto AuUserInterface depende do projeto AuCustomObjects então o módulo DBX precisa ser carregado primeiro que o módulo ARX. O processo de descarregamento deve ser feito na ordem inversa, AuUserInterface primeiro e em seguida o AuCustomObjects. Tudo deverá funcionar de acordo. Nota: Você pode compilar os projetos em Debug ou Release mas é sempre recomendado carregar os dois projetos com o mesmo tipo de compilação.

Agora que temos nossos módulos DBX e ARX é hora de criar a classe da nossa entidade customizada. Nesse exemplo, nossa entidade irá derivar da classe AcDbPolyline que representa a entidade POLYLINE do AutoCAD. O motivo da escolha é que nossa entidade customizada irá se comportar quase exatamente como uma polyline mas iremos adicionar funcionalidades extras como numeração dos vértices, símbolos de direção, hachura, etc. Para adicionar essa classe customizada iremos utilizar a ferramenta Autodesk Class Explorer localizada na barra de ferramentas do ARXWizard. Podemos acioná-la pelo segundo botão conforme mostra a Fi rgura 10.

Figura 10 – Barra de ferramentas do ARXWizard

Ao clicar nesse botão, uma janela irá aparecer exibindo todas as classes dos seus projetos. Nesse momento ainda não temos nenhuma classe. Selecione o módulo DBX e então clique com o botão direito nele. Um menu pop-up será exibido. Selecione a opção “Add an ObjectDBX Custom Object” (Figura 11). Figura 11 – Janela Autodesk Class Explorer

Esse assistente tem 3 passos . O primeiro, chamado Names (Figura 12), permite especificar todas as características básicas da entidade. Primeiro, dê o nome “AuPolyline ”. Escolha como classe base a classe AcDbPolyline (note que existem diversas outras classes das quais você pode derivar). Os demais campos serão preenchidos automaticamente. Aperte Next.

Figura 12 – Custom Object Wizard - Names

Como a classe polyline foi selecionada como base você está especificando que sua entidade customizada se comportará como uma polyline exceto aonde você redefinir. Isso será feito através de métodos virtuais como mencionado anteriormente. O assistente Custom Object Wizard também irá ajudar na implementação das funcionalidades básicas. Isso é feito através do segundo passo desse assistente, página Protocols. Habilitando essas opções o assistente fica instruído de adicionar os respectivos métodos virtuais simplificando o processo de criação da classe.

11

®


Nessa página você poderá definir se entidade participará dos protocolos DWG/DWF, se ela irá implementar pontos de OSNAP, pontos de GRIP e gráficos independentes em viewports. Além disso, poderá ainda definir os protocolos genéricos de curvas. Nesse exemplo, habilitaremos apenas o protocolo DWG e todos os 3 da classe base AcDbEntity . Esses protocolos irão permitir a implementação de funcionalidades básicas (Figura 13). sua

Figura 13 – Custom Object Wizard - Protocols

O terceiro passo, chamado Advanced, permitirá a adição de notificações e funcionalidades de cópia para a entidade customizada. Nesse exemplo não utilizaremos tais funcionalidades. Existem muitas outras funcionalidades que podem ser redefinidas através de uma grande coleção de métodos virtuais mas para manter esse exemplos simples implementaremos somente essas. Clique em Finish para criar a classe da sua entidade. Lembre-se, ela será criada no módulo DBX. Se você inspecionar o painel Solution Explorer irá observar dois novos arquivos: AuPolyline.h e AuPolyline.cpp . Esses arquivos, dentro do seu módulo DBX, são responsáveis pela declaração e implementação da entidade customizada. Abra esses dois arquivos e observe o código criado. Agora iremos adicionar um comando, dentro do módulo ARX, para criar uma instância da nossa entidade customizada. Para fazer isso, no painel Solution Explorer , clique com o botão direito no projeto AuUserInterface e então em “Set as Startup Project ” (o nome do projeto ficará em negrito). Agora, clique no primeiro ícone da toolbar ARXWizard (ícone com o símbolo “ a>”). Esse botão abrirá a janela “ObjectARX Commands”. Existem duas listas nessa janela. Botão direito na primeira lista e selecione a opção New. Uma nova linha será adicionada na lista com um nome padrão de comando chamado “MyCommand1 ”. Na coluna Mode, troque de “Transparent“ para “Modal“. Clique OK. Se você abrir o arquivo acrxEntryPoint.cpp no projeto AuUserInterface irá encontrar, dentro da classe CAuUserInterfaceApp , um método chamado AuUserInterface_MyCommand1() que será acionado assim que digitar o comando MYCOMMAND1 dentro do AutoCAD. Nesse método iremos criar um código para instanciar nossa entidade AuPolyline . Lembre-se que a implementação da classe customizada está dentro do projeto DBX. Por esse motivo, precisamos adicionar (através da instrução #include) uma referência para a classe AuPolyline e seu arquivo de cabeçalho ( .H). Para fazer isso, adicione a seguinte linha no início do arquivo acrxEntryPoint.cpp no módulo ARX logo após a linha #include "resource.h" : #include "..\AuCustomObjects\AuPolyline.h"

A barra “..\” faz com que a busca seja feita uma pasta acima (voltando à pata raiz da Solution) e avançando então dentro da pasta do módulo DBX. O código a seguir irá criar uma polyline de 10 lados (fechada) e vai adicioná-la ao Model Space Block Table Record (container responsável por armazenar entidades).

12

®


01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

// - AuUserInterface._MyCommand1 command (do not rename) static void AuUserInterface_MyCommand1(void) { // Entidade AuPolyline AuPolyline * pL = new AuPolyline (); int nSides = 10; double incAngle = 2*3.141592 / nSides; // Adiciona a lista de vértices for (int i=0; iaddVertexAt(i,AcGePoint2d(10*cos(i*incAngle), 10*sin(i*incAngle))); // Fecha a Polyline pL->setClosed(Adesk::kTrue); // Abre o container apropriado AcDbBlockTable * pBT = NULL; AcDbDatabase * pDB = acdbHostApplicationServices()>workingDatabase(); pDB->getSymbolTable(pBT,AcDb::kForRead); AcDbBlockTableRecord * pBTR = NULL; pBT->getAt(ACDB_MODEL_SPACE, pBTR, AcDb::kForWrite); pBT->close(); // Agora adiciona a entidade ao container AcDbObjectId Id; pBTR->appendAcDbEntity(Id, pL); pBTR->close(); pL->close(); }

No trecho das linhas 05-07 criamos a entidade e inicializamos variáveis locais. Depois, nas linhas 9-10 adicionamos os vértices. Na linha 12 configuramos a polyline como fechada. Nas linhas 1419 abrimos o banco de dados do AutoCAD, abrimos o container Block Table e pegamos o container Model Space. Nas linhas 21-24 adicionamos a entidade e fechamos os containers e a própria entidade. Nota: Você não pode acionar o operador delete em entidades adicionadas ao banco de dados do AutoCAD. O gerenciamento da entidade foi delegado ao AutoCAD e você só precisa chamar o método close() . Se você chamar delete nesse ponteiro vai causar um erro fatal do AutoCAD.

A seguir, botão direito no projeto AuUserInterface , “Project Dependencies...“ e escolha o produto AuCustomObjects na lista. Isso irá instruir o compilar a sempre compilar primeiro o DBX e depois o ARX. Agora podemos compilar novamente o projeto (assegure que ambos os projetos estejam no mesmo modo Debug ou Release e mesma plataforma Win32 ou x64). A seguir, abra o AutoCAD, dispare o comando APPLOAD , carregue primeiro o módulo DBX e a seguir o módulo ARX (você verá duas mensagens no prompt do AutoCAD indicando o carregamento dos módulos com sucesso). Digite agora o comando “ MYCOMMAND1 ” e depois o comando ZOOM EXTENTS para visualizar a entidade criada. Se rodar o comando LIST e selecionar a entidade criada, irá observar seus dados.


Agora, depois de criarmos a entidade básica, você irá aprender como adicionar gráficos a ela. Os gráficos da entidade customizada são gerados primariamente pelo método subWorldDraw() e opcionalmente pelo método subViewportDraw() que pode gerar desenhos diferenciados por Viewport.

13

®


Como a classe base já é capaz de gerar o desenho de uma polyline nós só precisaremos adicionar os gráficos extras. Cada vértice irá receber um índice numérico e uma flecha indicando a direção de construção da polyline (Figura 14). Iremos utilizar cores diferentes para cada tipo de gráfico. O índice numérico utilizará a cor 256 que significa a cor ByLayer e as flechas utilizarão a cor 1 que representa a cor vermelho. Se você alterar a cor do layer aonde sua entidade foi criada todo o gráfico irá acompanhar a mudança exceto as flechas. Além disso, todas as flechas terão o desenho feito com preenchimento. Figura 14 – Entidade com números e flechas

Para criar esses elementos gráficos utilizaremos alguns métodos geométricos. O código a seguir mostra como podemos gerar o desenho da entidade: 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

Adesk::Boolean AuPolyline::subWorldDraw (AcGiWorldDraw *mode) { assertReadEnabled(); // Primeiro, chamamos o desenho da classe base AcDbPolyline ::subWorldDraw(mode); double szRef = 5.0; // ================================================================ // Direção e numeração dos vértices int signal = 1; double ht2 = szRef/4.0; for(int i=0; igetPointAt(i,pti); // Desenha o texto do vértice CString strNum; strNum.Format(_T("%d"),i); AcGePoint3d ptTxt = pti + (AcGeVector3d ::kXAxis*ht2) + AcGeVector3d ( ::kYAxis*ht2); mode->subEntityTraits().setColor(256); // ByLayer mode->geometry().text(ptTxt, AcGeVector3d ::kZAxis, AcGeVector3d ::kXAxis, ht2, 1.0, 0.0, strNum); // Direção da Flecha AcGePoint3d ptj; this->getPointAt(i<(numVerts()-1) ? (i+1) : 0, ptj); AcGeVector3d dir = (ptj - pti).normalize(); // Vetores perpendiculares AcGeVector3d perp = dir; AcGeVector3d perp.rotateBy(3.141592/2.0, ::kZAxis); AcGePoint3d pt1 = ptj - (dir*ht2) + (perp*(ht2/4.0)); AcGePoint3d pt2 = ptj - (dir*ht2) - (perp*(ht2/4.0)); AcGePoint3d pts[3]; pts[0] = ptj; pts[1] = pt1; pts[2] = pt2;

14

®


34 35 36 37 38 39 40 41 42

// Desenha o polígono da flecha mode->subEntityTraits().setFillType(kAcGiFillAlways); mode->subEntityTraits().setColor(1); // red mode->geometry().polygon(3,pts); mode->subEntityTraits().setFillType(kAcGiFillNever); } //------ Returning Adesk::kFalse here will force viewportDraw() call return (Adesk::kTrue); }

Na linha 03 excutamos o método de assert adequado que informa o tipo de acesso aos dados desse método. Como nada está sendo alterado apenas precisamos LER dados da entidade e por isso chamamos o método assertReadEnabled() . Na linha 05 chamamos o método de desenho da classe base que irá desenhar as linhas da polyline. Nas linhas 06-10 incializamos variáveis locais. A seguir, nas linhas 11-39 fazemos um laço de repetição em todos os vértices para desenhar nossos gráficos. Nas linhas 13-14 pegamos o ponto do vértice em questão. Nas linhas 16-20 desenhamos o texto com o método text() num ponto ligeiramente deslocado. Nas linhas 22-24 calculamos o centro ( ptj) de cada segmento e seu vetor unitário directional ( dir ). Depois, nas linhas 2633 calculamos 3 pontos para o desenho da cabeça da flecha. O vetor perp permitirá o desenho de cada lado da cabeça da flecha como mostra a Figura 15. Nas linhas 35-38 desenhamos a cabeça da flecha com a primitiva polygon() na cor vermelha e com o modo de preenchimento ligado. Finalmente, na linha 41, retornamos Adesk::kTrue para evitar uma chamada ao método subViewportDraw() . As classes com prefixo AcGe utilizadas nesse método, fazem parte da biblioteca AcGe que contém diversas classes e métodos utilitários para auxiliar nos cálculos geométricos . Isso nos ajuda muito devido a alta complexidade desses cálculos. Figura 15 – Desenho da Flecha.


Agora você irá aprender a adicionar pontos de GRIP na sua entidade. De fato, como a implementação padrão da classe AuPolyline repassa a chamada para a classe base você já deve ter notado que os pontos de GRIP estão visíveis e funcionando. O comportamento do ponto de GRIP é feito através de dois métodos. O primeiro, chamado subGetGripPoints() é responsável pela obtenção de todos os pontos de GRIP da entidade. O segundo, chamado subMoveGripPointsAt() , é responsável pela ação disparada quando cada GRIP é acionado. A ação padrão de cada GRIP é mover o vértice selecionado. Nesse exemplo nós queremos adicionar um GRIP extra posicionado no centro do polígono . Para fazer isso iremos primeiro criar um método que calcula o centro do polígono. Iremos percorrer todos os pontos somando as coordenadas e depois dividindo o resultado por numVerts() . Esse método não irá alterar dados da entidade então é recomendado que ele seja CONST utilizando apenas o método de acesso assertReadEnabled() :

15

®


01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18

AcGePoint3d AuPolyline::GetPolylineCenter() const { assertReadEnabled(); AcGePoint3d ptC,pti; double cx = 0.0, cy = 0.0, cz = 0.0; for (int i=0; igetPointAt(i,pti); cx += pti[X]; cy += pti[Y]; cz += pti[Z]; } cx = cx / numVerts(); cy = cy / numVerts(); cz = cz / numVerts(); ptC.set(cx, cy, cz); return ptC; }

Nas linhas 04-15 aplicamos a fórmula do centro e na linha 16 criamos o ponto usando cx, cy e cz como as coordenadas X, Y e Z respectivamente. Agora, precisamos alterar o funcionamento padrão dos métodos relacionados aos pontos de GRIP. Primeiro iremos definir o método subGetGripPoints() . Esse método tem 2 assinaturas mas iremos implementar somente o código para o método que contém o parâmetro AcDbGripDataPtrArray . Esse método recebe um array de ponteiros AcDbGripData . Esses objetos representam as informações do ponto de GRIP. Precisaremos informar o ponto e seus dados arbitrários( void*). Esses dados arbitrários podem ser usados posteriormente para recuperar as informações de cada ponto de GRIP permitindo que o método subMoveGripPointsAt() execute ações personalizadas. Além disso, esse método não irá alterar os dados da entidade então ele será também um método do tipo CONST chamando assertReadEnabled() . Nas linhas 09-12 intanciamos um ponteiro para AcDbGripData e guardamos um valor aleatório ( 9999 nesse caso) além do ponto calculado pelo método GetPolylineCenter() criado anteriormente. Depois, na linha 13 nós repassamos a chamada para o método da classe base AcDbPolyline para que ela possa completar com seus próprios pontos de GRIP. Esses pontos de GRIP são os vértices da polyline mencionados anteriormente: 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15

Acad::ErrorStatus AuPolyline::subGetGripPoints ( AcDbGripDataPtrArray &grips, const double curViewUnitSize, const int gripSize, const AcGeVector3d &curViewDir, const int bitflags) const { assertReadEnabled () ; AcDbGripData * gpd = new AcDbGripData (); gpd->setAppData((void*)9999); // Dados do ponto central gpd->setGripPoint(GetPolylineCenter()); grips.append(gpd); AcDbPolyline ::subGetGripPoints (grips, curViewUnitSize, gripSize, curViewDir, bitflags); return (Acad::eOk); }

O próximo passo é alterar o método subMoveGripPointsAt() de forma que quando o usuário clicar no GRIP no centro ele irá refletir uma ação específica. Nesse exemplo, nossa ação para esse GRIP será mover a polyline. O código a seguir mostra como fazer isso:

16

®


01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18

Acad::ErrorStatus AuPolyline::subMoveGripPointsAt ( const AcDbVoidPtrArray &gripAppData, const AcGeVector3d &offset, const int bitflags) { assertWriteEnabled () ; for (int g=0; gtransformBy(offset); else AcDbCurve ::subMoveGripPointsAt (gripAppData,offset,bitflags); } return (Acad::eOk); }

Dessa vez, nosso método não pode ser CONST pois iremos alterar dados da entidade. Por isso chamaremos o método assertWriteEnabled() logo no início. Na linha 07 percorremos o array AcDbVoidPtrArray (ponteiros para void) procurando pelo nosso dado ( 9999). Esse método também recebe um vetor 3D que representa o deslocamento aplicado ao GRIP. Se o GRIP modificado guardar o valor 9999 aplicaremos a transformação na polyline inteira. Faremos isso através do método transformBy() passando o vetor 3D (Figura 16). Figura 16 – Ação do GRIP central

Se o GRIP acionado não guardar o código 9999 repassaremos a chamada para a classe AcDbCurve (classe base da AcDbPolyline) que irá tratar esse ponto. O comportamento resultante ao selecionarmos um GRIP no contorno da Polyline será o esticamento/encolhimento e quando selecionarmos o GRIP do centro a entidade inteira irá mover.


Agora você irá aprender como adicionar os pontos de precisão ou pontos OSNAP . Se executar o programa até o momento irá perceber que a entidade já mostra alguns pontos de OSNAP automaticamente ( ENDPOINT e MIDPOINT ). Nesse exemplo, queremos adicionar um ponto de CENTER na nossa polyline que permitirá aos usuários selecionarem o nosso ponto central. Para implementar isso, precisaremos alterar o método subGetOsnapPoints() . Esse método tem 2 assinaturas e implementaremos apenas o método que recebe um parâmetro AcDbIntArray . Iremos então analisar o tipo de OSNAP solicitado, no caso o CENTER, retornando assim o nosso ponto central:

17

®


01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17

18

Acad::ErrorStatus AuPolyline::subGetOsnapPoints ( AcDb::OsnapMode osnapMode, int gsSelectionMark, const AcGePoint3d &pickPoint, const AcGePoint3d &lastPoint, const AcGeMatrix3d &viewXform, AcGePoint3dArray &snapPoints, AcDbIntArray &geomIds) const { assertReadEnabled () ; switch(osnapMode) { case AcDb::kOsModeCen: snapPoints.append(GetPolylineCenter()); break; } AcDbPolyline ::subGetOsnapPoints (osnapMode, return ( gsSelectionMark, pickPoint, lastPoint, viewXform, snapPoints, geomIds)) ; }

Esse método recebe um array de pontos no qual precisamos adicionar nosso ponto central sempre que o OSNAP CENTER for solicitado. Na linha 13 testamos o tipo kOsModeCen e adicionamos o ponto central ao array snapPoints (Figura 17). Mesmo tratando o OSNAP CENTER em particular o método precisa repassar a chamada para a classe base. A classe da polyline irá tratar os demais casos de OSNAP. Figura 17 – OSNAP CENTER

Nota: Essa solução de OSNAP trata apenas casos simples como CENTER, MIDPOINT e ENDPOINT. Casos de OSNAP mais complexos como INTERSECTION requer a implementação de outros métodos e procedimentos.


Muitas vezes precisamos enviar os desenhos de AutoCAD contendo nossa entidade customizada. Por padrão, quando o AutoCAD abre um desenho e encontra alguma entidade que ele não reconhece nativamente, ele protege os dados numa entidade Proxy . A entidade Proxy protege os dados do objeto evitando que usuários indesejados alterem a entidade. A entidade proxy é meramente um pacote de dados com uma representação gráfica fixa . A maioria das funcionalidade da sua entidade não estarão disponíveis pois o seu código não estará presente para implementar as funcionalidades. Se o desenho for aberto por um usuário inadvertidamente ele deverá ser informado da existência de entidades Proxy. A entidade Proxy gráficos específicos gerados através de uma chamada ao método subWorldDraw() logo antes do AutoCAD fechar o desenho. O método subWorldDraw() recebe um parâmetro, um ponteiro para AcGiWorldDraw , que dá acesso ao método regenType() que permite descobrir se a chamada ao método foi feita para fins de gerar os gráficos de Proxy. Nesse momento,

18

®


você poderá até desenhar gráficos diferentes para a sua entidade ou até um texto avisando “Meu aplicativo não está disponível“. O código a seguir mostra como tratar o desenho do Proxy: 01 02 03 04 05 06 07 08 09

// ================================================================== // PROXY if (mode->regenType() == kAcGiSaveWorldDrawForProxy) { // Desenha um texto qualquer de aviso CString strTxt = _T("AU Polyline"); AcGePoint3d ptTxt = GetPolylineCenter(); mode->geometry().text(ptTxt, AcGeVector3d ::kZAxis, AcGeVector3d ::kXAxis, szRef, 1.0, 0.0, strTxt); }

Nesse exemplo, o nosso desenho de Proxy será o desenho padrão da entidade acrescido de um texto informativo. Você poderia até colocar a URL do seu produto ou empresa. Para simplificar, criaremos esse texto iniciando no ponto central da polyline. Para entidades derivadas de AcDbPolyline ainda é necessário mais um passo para implementar o Proxy. O método saveAs() precisa ser implementado na classe para que o método subWorldDraw() possa ser acionado no momento apropriado para a geração do Proxy. Esse método pode ser declarado no arquivo .H da seguinte maneira: virtual void saveAs(AcGiWorldDraw * mode, AcDb::SaveType st);

A respectiva implementação, no arquivo .CPP será: 01 02 03 04 05 06

AcGiWorldDraw * mode, AcDb::SaveType st) void AuPolyline::saveAs( { AcDbPolyline ::saveAs (mode, st) ; if (mode->regenType() == kAcGiSaveWorldDrawForProxy) this->worldDraw(mode); }

Esse método chama incialmente a classe base e a seguir testa se o método regenType() é para geração de gráficos de Proxy. Se for verdadeiro nós executamos nosso próprio método subWorldDraw() que irá gerar o desenho da nossa classe customizada acrescido do texto de Proxy. Para testar esse comportamento, crie a nossa entidade AuPolyline e salve o desenho. Feche o AutoCAD e abra novamente o DWG salvo mas sem carregar os módulos. Uma vez que o DWG for aberto você verá um aviso de proxy contendo informações do aplicativo e classe ausentes (Figura 18).

Figura 18 – Informações de Proxy

19

®


Note que na Figura 18 o texto configurado para Proxy é exibido. Na janela de informações de Proxy, serão exibidas informações do aplicativo ausente. Essa janela permite ao usuário configurar as opções de exibição das entidades Proxy. Você também poderá configurar a exibição das entidades Proxy através do menu Tools > Options > Open and Save. Lembre-se que o módulo DBX pode ser carregado para restaurar o modo de desenho normal e por isso você pode enviar o módulo DBX juntamente com o DWG permitindo assim que outros usuários possam visualizar suas entidades com o desenho apropriado. Nesse caso você forneceria apenas as classes do seu programa não forneceria os comandos e janelas (que estão no módulo ARX). Nesse cenário os usuários serão capazes de visualizar a entidade mas sem editar pelos comandos que você criou. O AutoCAD permite algumas alterações básicas em entidades proxy como apagar, alterar o layer, alterar a color e algumas transformações gráficas. Essas operações surtirão efeito sobre os gráficos proxy através da representação gráfica que você definiu (os dados da entidade estarão preservados a não ser que o usuário apague ela do desenho). O desenvolvedor determina as opções e limitações mais adequadas para a entidade proxy. Isso é uma opção definida em tempo de compilação através de uma macro na implementação da classe da entidade ( ACRX_DXF_DEFINE_MEMBERS ). Essas opções podem ser combinadas para completar o comportamento desejado da entidade Proxy. Consulte a documentação do ObjectARX SDK para mais detalhes dos proxy flags.


Nessa etapa iremos implementar uma funcionalidade muito interessante. Imagine que você desejasse adicionar uma hachura à sua entidade. Podemos tirar vantagem da funcionalidade do ObjectARX de objetos embebidos para implementar a hachura. Existe uma classe chamada AcDbHatch que representa a entidade de hachura no AutoCAD. Essa classe pode ser usada como um objeto embebido e podemos usar seu método worldDraw() para desenhar nosso padrão de hachura. A primeira coisa que precisamos fazer é adicionar um membro do tipo AcDbHatch na classe da nossa entidade. Também criaremos um método chamado SetupHatch() que irá configurar as propriedades da hachura. Para fazer isso, abra o arquivo AuPolyline.h e adicione as seguintes linhas no final da declaração da classe: protected: AcDbHatch m_Hatch; public: void SetupHatch();

Além disso, precisamos adicionar mais 3 métodos à nossa classe para li dar com as modificações feitas pelo usuário. O primeiro método irá lidar com as transformações gráficas . Os outros 2 métodos irão dar suporte ao comando STRETCH: public: virtual Acad::ErrorStatus subTransformBy(const AcGeMatrix3d & xform); virtual Acad::ErrorStatus subGetStretchPoints( AcGePoint3dArray & stretchPoints) const;

virtual Acad::ErrorStatus subMoveStretchPointsAt( const AcDbIntArray & indices, const AcGeVector3d & offset);

20

®


Nosso objeto embebido de hachura precisa ser configurado. Para fazer isso, dentro do construtor da classe localizando no arquivo AuPolyline.cpp , o seguinte código (observe que a configuração só precisa ser feita uma vez na inicialização dos objetos dessa classe): 01 02 03 04 05 06 07 08 09 10

AuPolyline::AuPolyline () : AcDbPolyline () { AcGeVector3d m_Hatch.setNormal( ::kZAxis); m_Hatch.setElevation(this->elevation()); m_Hatch.setAssociative(true); m_Hatch.setPatternScale(1.0); m_Hatch.setPatternAngle(45.0); AcDbHatch ::kNormal); m_Hatch.setHatchStyle( AcDbHatch ::kPreDefined,_T("LINE")); m_Hatch.setPattern( }

Essa configuração irá escolher o padrão, vetor normal, elevação, escala, ângulo e estilo. Nesse exemplo esses valores são fixos mas você poderia criar uma propriedade para cada um permitindo que o usuário alterasse essas propriedades durante a execução do programa. Agora precisamos implementar o método SetupHatch() que irá construir o loop da hachura de acordo com o contorno da nossa polyline. O código é o seguinte: 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

void AuPolyline::SetupHatch() { assertWriteEnabled(); // Remove qualquer loop existente for (int l=0; lgetPointAt(i,pt2d); this->getBulgeAt(i,bulge); vertexPts.append(pt2d); vertexBulges.append(bulge); } // Fecha o loop vertexPts.append(vertexPts.first()); vertexBulges.append(vertexBulges.first()); AcDbHatch ::kDefault, vertexPts,vertexBulges); m_Hatch.appendLoop( // Atualiza o Hatch m_Hatch.evaluateHatch(); }

Nas linhas 05-06 nos asseguramos que não exista nenhum loop. Nas linhas 11-18 percorremos os vértices da polyline pegando os pontos e bulges ( um bulge é a tangente de 1/4 do ângulo incluído do arco entre o vértice selecionado e o próximo vértice). A informação obtida será armazenada em vetores

21

®


dinâmicos: AcGePoint3dArray e AcGeDoubleArray . Nas linhas 20-21 fechamos o loop da polyline para asseguramos que o contorno da hachura seja fechado. Na linha 22 adicionamos os arrays como loops da hachura. Um loop também pode representar um buraco na superfície hachurada mas nesse exemplo nosso loop é do tipo AcDbHatch::kDefault . Na linha 24 finalizamos o processo de configuração do hatch chamando o método evaluateHatch() que irá recriar a hachura baseada nas informações fornecidas. Precisamos chamar o método SetupHatch() dentro de outros métodos necessários. O primeiro lugar é no método dwgInFields() . Adicione a chamada ao método no final como mostrado a seguir: 01 02 03 04 05 06 07

Acad::ErrorStatus AuPolyline::dwgInFields (AcDbDwgFiler *pFiler) { [ linhas omitidas para simplificação ] // Configura hachura SetupHatch(); return (pFiler->filerStatus ()) ; }

A seguir, precisamos colocar outra chamada dentro do método subMoveGripPointsAt() . Quando o usuário mover algum dos pontos de GRIP precisamos recalcular o contorno da hachura. Precisaremos fazer isso somente nos casos que o GRIP selecionado for o nosso ponto central. A alteração é feita nas linhas 15-18 conforme mostrado a seguir: 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20

Acad::ErrorStatus AuPolyline::subMoveGripPointsAt ( const AcDbVoidPtrArray &gripAppData, const AcGeVector3d &offset, const int bitflags) { assertWriteEnabled () ; for (int g=0; gtransformBy(offset); else { AcDbCurve ::moveGripPointsAt(gripAppData,offset,bitflags); SetupHatch(); } } return (Acad::eOk); }

Para fazermos a entidade da hachura aparecer como parte do desenho da nossa entidade customizada precisamos chamar o método geometry()->draw() dentro do método subWorldDraw() da classe da entidade:

22

®


01 02 03 04 05 06 07 08 09

Adesk::Boolean AuPolyline::subWorldDraw (AcGiWorldDraw *mode) { [ linhas omitidas para simplificação ] // ======================================================= // HATCH mode->geometry().draw(&m_Hatch); //------ Returning Adesk::kFalse to force viewportDraw() call return (Adesk::kTrue) ; }

Finalmente, precisamos implementar o código para os 3 novos métodos que declaramos na classe da entidade. Abra o arquivo AuPolyline.cpp e adicione os métodos seguintes: 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22

// ------------------------------------------------------------------Acad::ErrorStatus AuPolyline::subTransformBy(const AcGeMatrix3d & xform) { Acad::ErrorStatus retCode = AcDbPolyline ::subTransformBy(xform); m_Hatch.transformBy(xform); return (retCode) ; } // ------------------------------------------------------------------ AcGePoint3dArray & Acad::ErrorStatus AuPolyline::subGetStretchPoints( stretchPoints) const { AcDbIntArray osnapModes,geomIds; return this->subGetGripPoints(stretchPoints,osnapModes,geomIds); } // ------------------------------------------------------------------Acad::ErrorStatus AuPolyline::subMoveStretchPointsAt( const AcDbIntArray & indices, const AcGeVector3d & offset) { Acad::ErrorStatus ret = AcDbPolyline ::subMoveGripPointsAt (indices, offset); SetupHatch(); return ret; }

O primeiro método nas linhas 02-07, subTransformBy() , é responsável por todas as transformações gráficas como MOVE, ROTATE, SCALE, etc. Primeiro repassamos a chamada para a classe e depois aplicamos a mesma transformação para a hachura. Dessa maneira ela seguirá todas as transformações aplicadas à nossa AuPolyline. Os segundo método, nas linhas 09-13, subGetStretchPoints() , é responsável por retornar os pontos que são habilitados para o stretch da entidade. Nesse caso iremos habilitar todos os vértices da nossa polyline. Podemos utilizar os mesmos pontos obtidos pelo método subGetGripPoints() pois são os mesmos que desejamos nesse momento. O último método, nas linhas 15-22, subMoveStretchPointsAt() , é responsável pela aplicação da transformação de stretch na entidade. Também podemos reutilizar o método subMoveGripPointsAt() porque ele faz exatamente o que precisamos. A seguir apenas precisamos chamar o método SetupHatch() para garantir que hachura estará atualizada como o novo contorno resultante das modificações feitas pelo comando STRETCH. Antes de testar nossa entidade, precisamos colocar uma chamada ao método SetupHatch() logo antes de fechar nossa entidade no método de criação. Abra o arquivo acrxEntryPoint.cpp , no projeto AuUserInterface , método AuUserInterface_MyCommand1() . Veja o código a seguir:

23

®


01 02 03 04 05 06

static void AuUserInterface_MyCommand1(void) { [ linhas omitidas para simplificação ] pL->SetupHatch(); pL->close(); }

Agora faça um Build na Solution. Não devem aparecer erros. Abra o AutoCAD, carregue os módulos (lembre-se, primeiro o BDX e depois o ARX). Acione o comando MYCOMMAND1 e crie uma entidade AuPolyline. Depois teste as diversas funcionalidades implementadas. Tente o comando COPY na entidade, depois MOVE, ROTATE, SCALE e até o comando MIRROR. Você pode ainda usar o comando STRETCH e acionar os pontos de GRIP para alterar a forma da entidade. Nossa entidade AuPolyline deriva de AcDbPolyline , correto? Então supostamente os comandos PEDIT deveriam funcionar com nossa entidade? SIM, funciona! Tente usar o comando PEDIT e selecione nossa entidade. Ele irá aceita-la e permitirá que você altere a AuPolyline como se ela fosse uma Polyline nativa do AutoCAD. Você pode adicionar novos vértices, remover existentes, adicionar novos segmentos e tudo mais (Figura 19). Genial, não?

Figura 19 – AuPolyline modificadas

Conclusão

Nesse curso você aprendeu como criar uma entidade customizada e adicionar algumas funcionalidades que o ObjectARX permite. Isso é apenas uma introdução . Existem muito mais coisas que você pode fazer utilizando as classes do ObjectARX e implementando coisas sofisticadas. Espero que esse curso lhe ajude a conhecer um pouco do mundo do ObjectARX . Se tiver alguma dúvida entre em contato por e-mail ou visite meu Blog através do endereço: http://arxdummies.blogspot.com/ e encontre mais informações sobre o assunto. Obrigado!

24

O Poder Do ObjectARX_0

Recommend Documents