Nesta postagem, você aprenderá a criar caixas de diálogo personalizadas para rotinas LISP com DCL (Dialog Control Language). No última postagem, criamos uma caixa de diálogo básica, neste post, vamos adicionar os sinos e assobios.

ATENÇÃO: Este artigo no Blog é transcrito aqui no idioma Português-Brasil, mas pelo fato do artigo original ter sido escrito em Inglês, é possível que algumas instruções (especialmente: códigos) possam gerar conflito entre os idiomas. Sugiro consultar também os códigos de origem (no livro ou na versão em inglês deste post) para garantir que seu trabalho esteja bem resolvido.

Para uma visão geral completa dos comandos DCL para BricsCAD, você pode ver o oficial, Guia do desenvolvedor BricsCAD DCL.


Os seguintes tópicos são abordados neste artigo:


RESUMO RÁPIDO DOS METACARACTERES DCL

DCL METACHARACTER SIGNIFICADO
// (barra-barra) Indica uma linha de comentário
/* (barra asterisco) Inicia a seção de comentários
*/ (asterisco-barra) Termina a seção de comentários
: (dois pontos) Inicia uma definição de mosaico. Mosaicos predefinidos, como o espaçador, não usam os dois pontos
{ (braçadeira) Inicia o diálogo e os atributos do bloco
(espaço) Separa símbolos
= (é igual a) Define valores de atributos
“” (citação direta) Inclui atributos de texto
; (ponto e vírgula) Termina a definição do atributo. Cada atributo deve terminar com um ponto e vírgula
} (braçadeira) Termina os atributos do bloco e da caixa de diálogo

 


Definição da caixa de diálogo Iniciar

O conteúdo de cada arquivo .dcl começa com um atributo de nome. Este é o nome pelo qual a rotina LISP associada chama o código de diálogo. A função de nome se parece com isto:

nome: diálogo {

Como LISP, uma chave aberta precisa de uma chave de fechamento para sinalizar o fim de uma definição de caixa de diálogo:

}

Entre as duas chaves, você escreve todo o código que informa ao BricsCAD para ver a caixa de diálogo.

Para este tutorial, nomeie a caixa de diálogo “lastInput,” da seguinte maneira:

lastInput: dialog {

}

Os nomes DCL diferenciam maiúsculas de minúsculas, então “lastInput” não é o mesmo que “LastINPUT” ou “lastinput”.

Título da caixa de diálogo

O texto da barra de título da caixa de diálogo é especificado pelo etiqueta propriedade, como segue:

nome: diálogo {

rótulo = “Título da caixa de diálogo”;

}

Rotule esta caixa de diálogo como “Última entrada” assim:

lastInput: dialog {

rótulo = “Última entrada“;

}

O texto do título deve ser colocado entre aspas (”). A propriedade label deve terminar com um ponto e vírgula (;). E é útil recuar o código para torná-lo legível.

Botão OK

Cada caixa de diálogo precisa de um botão de saída, pelo menos um OK. (O Windows coloca um botão X padrão no
canto superior direito de cada caixa de diálogo, que também funciona para sair das caixas de diálogo feitas com DCL!)

Os botões são definidos com o botão propriedade, seguida pelas propriedades do botão entre
entre colchetes:

: botão {

}

Como as caixas de diálogo podem ter vários botões, cada botão deve ser identificado por uma propriedade
chamada de "chave". A chave é como o LISP dá instruções aos botões. Use o atributo key para identificar este botão OK como “okButton,” da seguinte maneira:

tecla = “okButton”;

O botão precisa exibir um rótulo para os usuários lerem. Este é um botão OK, então rotule-o de "OK" com o etiqueta atributo, da seguinte forma:

etiqueta = ”OK“;

Vamos colocar tudo isso junto. O código adicionado para o botão OK é mostrado aqui em color, com os atributos key, label e is_default. (Veja abaixo informações sobre o atributo padrão.) Temos um botão identificado como “okButton,” ostentando o rótulo “OK” e é definido como o bloco padrão.

lastInput: dialog {

rótulo = “Última entrada”;

: botão {

tecla = “okButton”;

rótulo = ”OK“;

is_default = true;

}

}

DICA O código DCL para o OK botão é como uma sub-rotina. O mesmo código pode ser reutilizado sempre que uma caixa de diálogo precisa de um OK botão, que fica praticamente o tempo todo. Posteriormente, você verá como criar sub-rotinas com código DCL.

O Bloco Padrão

Para tornar a vida mais fácil para os usuários, um bloco de uma caixa de diálogo é sempre transformado em default telha. Os usuários precisam apenas pressionar Entre para ativar o bloco padrão. As caixas de diálogo destacam o ladrilho padrão de alguma forma, como um contorno tracejada ou colorido. Os usuários podem pressionar Aba mover o padrão foco (bloco atualmente destacado) para outras áreas da caixa de diálogo.

Um bloco se torna o padrão com o is_default atributo, da seguinte forma:

is_default = true;


CÓDIGO LISP PARA CARREGAR E EXECUTAR CAIXAS DE DIÁLOGO

O seguinte código LISP é o que você usa para carregar, executar e sair do arquivo de definição da caixa de diálogo lastInput.dcl:

(defun C: xx ()

(setq dlg-id (load_dialog “c: \\ lastInput”))

(new_dialog “lastInput” dlg-id)

(action_tile “aceitar” “(done_dialog)”)

(start_dialog)

(unload_dialog dlg-id)

)

Para ver o que significa o código LISP, vamos desmontá-lo. A função é definida como “xx” com a função defun do LISP. Programação = depuração, então gosto de usar um nome fácil de inserir para a rotina LISP, como “xx”.

(defun C: xx ()

O arquivo lastInput.dcl é carregado com a função load_dialog. Não há necessidade de especificar a extensão “.dcl”, pois este é o único propósito desta função: carregar arquivos DCL.

  • No Windows, inclua o nome da unidade, C: \\. Lembre-se de que o LISP requer que você use \\ em vez de \ para separar os nomes das pastas.

    (setq dlg-id (load_dialog “c: \\ lastInput”))

  • No Linux, omita o nome da unidade:

    (setq dlg-id (load_dialog “lastInput”))

Os arquivos DCL podem conter mais de uma definição de caixa de diálogo e, portanto, a próxima etapa é usar a função new_dialog para informar a BricsCAD qual você deseja acessar. Nesse caso, há apenas um, “lastInput”.

(new_dialog “lastInput” dlg-id)

A caixa de diálogo contém um botão denominado “okButton,” e sua finalidade é definida por LISP - não DCL! Aqui você usa a função action_tile para atribuir uma ação ao bloco “okButton”. O objetivo do botão na vida é executar a função done_dialog que sai da caixa de diálogo. Resumindo, clique em OK para sair da caixa de diálogo. Você pode ler isso da seguinte maneira: “a ação para o bloco chamado okButton é ...”.

(action_tile “okButton” “(done_dialog)”)

Depois de todas essas preliminares, chega o grande momento. A função start_dialog abre a caixa de diálogo e espera que você clique em seu botão.

(start_dialog)

Como programadores habilidosos, descarregamos a caixa de diálogo da memória com a função unload_dialog.

(unload_dialog dlg-id)

E um último parêntese encerra a função xx.

)


Teste de código DCL

Você tem código DCL suficiente para testá-lo agora, o que permite ver como a caixa de diálogo está se desenvolvendo. Para testar o código, siga estas etapas:

  1. Abra o bloco de notas, Edição de Texto, ou outro editor de texto ASCII.
  2. Insira o código DCL que desenvolvemos anteriormente:
    bricscad de personalização de codificação dcl
    Inserindo o código DCL em um editor de texto

    Importante: Certifique-se de que este arquivo DCL e o arquivo LSP usam aspas retas que se parecem com isto: “. Se eles contiverem aspas curvas (“ou”), as rotinas falharão. LISP irá reclamar, “erro: tipo de argumento ruim; esperado ”enquanto o DCL apresentará uma caixa de diálogo reclamando, erro de sintaxe: inesperado“ ”.

  3. Salve o arquivo como lastinput.dcl. Para que a rotina LISP xx.lsp possa encontrá-lo facilmente, salve o arquivo em uma pasta de nível superior:
    • No Windows, salve o arquivo DCL na unidade C: \.
    • No Linux e Mac, salve o arquivo DCL em sua pasta de início. Por exemplo, eu loguei no Linux com o nome de usuário “ralphg,” então salvei o arquivo na pasta ralphg.
  4. Agora, abra um novo arquivo e insira o código LISP descrito no texto em caixa na seguinte página: “Código LISP para carregar e executar caixas de diálogo”.
    Inserindo o código LISP em um editor de texto
  5. Salve o arquivo como xx.lsp, também na mesma pasta do arquivo DCL
  6. Mude para BricsCAD e abra o arquivo xx.lsp em BricsCAD:
    • No Windows, use o Explorer para arrastar o arquivo xx.lsp para a janela de desenho BricsCAD. (Arrastar o arquivo é muito mais rápido do que inserir o comando AppLoad ou usar a função de carregamento LISP!)
    • No Linux, você deve usar a função de carregamento, porque os arquivos não podem ser arrastados para a versão Linux de BricsCAD. Digite o seguinte no prompt ':':

      : (carregar “xx”)

  7. Digite xx para executar a rotina, que então carrega a caixa de diálogo:

    : xx

    Observe que a caixa de diálogo aparece! Bem, deveria, se você não cometeu nenhum erro de codificação.

    caixas de diálogo personalizadas no Linux e Windows
    Esq: Caixa de diálogo no Windows 7.
    Dir: Caixa de diálogo no Linux Mint
  8. Clique OK para sair da caixa de diálogo.
    Aqui está um mapa de como o código DCL criou a caixa de diálogo:

    como o código afeta uma caixa de diálogo em BricsCAD
    A caixa de diálogo criada pelo código DCL

EXIBINDO DADOS DAS VARIÁVEIS DO SISTEMA

A estrutura básica da caixa de diálogo está pronta: o rótulo e o botão OK. Agora é hora de adicionar os dados que queremos que sejam exibidos pelas variáveis do sistema.

Os dados dos sysvars ficarão assim na caixa de diálogo:

Último ângulo: 45
Último ponto: 1,2,3
Último prompt: Linha

Eu mostro o estático texto em color. Isso nunca muda. Este texto atua como um prompt para informar aos usuários o que os números significam.

O texto preto é variável; sua exibição muda e depende do valor do sysvar associado.

O Text tile é aquele que exibe o texto nas caixas de diálogo e seu código será semelhante a este:

: texto {

rótulo = “Último ângulo:“;

chave = “lastAngle”;

}

Você é capaz de reconhecer os atributos deste bloco de texto?

Comece o texto com este bloco:

: text {

A seguir, o etiqueta atributo fornece o prompt, 'Último ângulo:'.

etiqueta = “Último ângulo:“;

A seguir, o etiqueta atributo fornece o prompt, 'Último ângulo:'.

etiqueta = “Último ângulo:“;

O tecla atributo identifica o bloco de texto como “lastAngle”.

tecla = “LastAngle”;

Finalmente, o bloco de texto é fechado com a chave.

}

DICA Os blocos de texto podem ter os seguintes atributos:

  • alinhamento
  • fixed_height
  • Largura fixa
  • altura
  • is_bold
  • tecla
  • etiqueta
  • valor
  •  largura

Adicione o código destacado ao arquivo DCL ...

código para caixas de diálogo personalizadas em BricsCAD DCL
Adicionar código DCL no editor de texto

... e então execute o xx.lsp rotina novamente. Observe que a caixa de diálogo agora exibe o texto 'Último ângulo:':

Caixa de diálogo que resulta do código DCL adicionado

A próxima etapa é exibir o valor armazenado pela variável de sistema LastAngle. Adicione um segundo bloco de texto:

: texto {

valor = “”;

chave = “lastAngleData”;

}

O valor deste bloco está inicialmente em branco porque não tem rótulo e nenhum valor. Para completar o bloco de texto, precisamos usar uma função LISP que extrai o valor do LastAngle variável de sistema e, em seguida, empurra-a para a caixa de diálogo.

O link entre o código LISP e o arquivo DCL é com o tecla, que é denominado aqui "lastAngleData". (Vou mostrar o código LISP um pouco mais tarde.) Agora o arquivo DCL se parece com isto, com o novo código mostrado em color. Você pode copiar este código e colá-lo no editor de texto.

lastInput: dialog {

rótulo = “Última entrada”;

: texto {

rótulo = “Último ângulo:“;

chave = “lastAngle”;

}

: texto {

valor = “”;

chave = “lastAngleData”;

}

: botão {

tecla = “okButton”;

rótulo = “OK”;

is_default = true;

}

}

(Se você fosse executar este código DCL agora, a caixa de diálogo não seria diferente. Ele ainda precisa de LISP para
diga a ele o valor do último ângulo. Isso vem a seguir.)

ADICIONANDO O CÓDIGO LISP COMPLEMENTAR

Escrever código DCL é sempre apenas metade do trabalho. A outra metade é escrever o código complementar em LISP. Extrair o valor de LastAngle execute estas duas etapas:

Passo 1: Usar o getvar função para acessar o valor de sysvar LastAngle e, em seguida, armazenar o valor obtido na variável lang (abreviação de "último ângulo") com o setq função, da seguinte forma:

(setq lang (getvar “LastAngle”))

Passo 2: Use a função set_tile para definir o valor de lang para o bloco “lastAngleData”:

(set_tile “LastAngleData” (rtos lang 2 2))

DICA Os blocos funcionam apenas com texto, sem números. No entanto, o valor de LastAngle é um número, então você deve convertê-lo em texto. Isso é feito com o rtos função:

(rtos lang 2 2))

Aqui, estou convertendo o número real em uma string (também conhecido como texto) usando o modo 2 (decimal) e a precisão 2 (duas casas decimais).

Com as novas linhas de código mostradas em color, o arquivo LSP agora se parece com este:

(defun C: xx ()

(setq dlg-id (load_dialog “c: \\ lastInput”))

(new_dialog “lastInput” dlg-id)

(setq lang (getvar “lastangle”))

(set_tile “lastAngleData” (rtos lang 2 2))

(action_tile “okButton” “(done_dialog)”)

(start_dialog)

(unload_dialog dlg-id)

)

Salve os arquivos .dcl e .lsp, recarregue e execute xx.lsp em BricsCAD.

A caixa de diálogo agora se parece com isto:

Caixa de diálogo informando o valor do ângulo

TEXTO DE CLUSTER

Hmmm ... os dois pedaços de texto estão empilhados um em cima do outro e isso é um problema. Eles devem ser horizontais. O texto é empilhado verticalmente porque DCL coloca ladrilhos em colunas por padrão.

A solução é forçar os dois blocos de texto a aparecerem próximos um do outro com o Linha telha:

: linha {

: texto {

rótulo = “Último ângulo:“;

chave = “lastAngle”;

}

: texto {

valor = “”;

chave = “lastAngleData”;

}

}

Modifique o arquivo DCL adicionando o ladrilho da linha e execute novamente o arquivo LISP. O resultado deve ser melhor, assim:

modificar caixas de diálogo
Texto angular formatado em uma única linha

Agora que o texto do último ângulo parece adequado, você pode copiar e colar seu código para ser usado pelas outras duas linhas e, em seguida, fazer as modificações adequadas. As alterações que você precisa fazer são mostradas abaixo em cores:

: linha {

: texto {

rótulo = “Último ponto: “;

chave = “lastPoint“;

}

: texto {

valor = “”;

chave = “últimoPontoDados";

}

}

E para o prompt final:

: linha {

: texto {

rótulo = “Último pronto: “;

chave = “últimoPrompt“;

}

: texto {

valor = “”;

chave = “últimoPromptDados";

}

}

Corrida xx.lsp fornece à caixa de diálogo todos os três prompts, mas faltam dados nos dois novos:

modificar e personalizar BricsCAD
Adicionadas linhas de informação

Fornecendo o Texto Variável

Os dados são fornecidos pelo código LISP. Aqui, veremos como lidar com coordenadas 3D e texto.

Lembre-se de que LISP retorna o valor dos pontos como uma lista de três números, assim:

(1.0000 2.0000 3.0000)

Os números representam as coordenadas x, y e z, respectivamente. Precisamos converter a lista de três números em uma string - por que tem que ser tão difícil ?! Use o seguinte código, que assume que a variável lpt contém (1,0000 2,0000 3,0000):

(car lpt)

O car função extrai a coordenada x da lista como um número real, como 1,0000. Similarmente:

(cadr lpt)

(caddr lpt)

O cadr e caddr funções extraem as coordenadas y (2.0000) ez (3.0000), respectivamente. Para converter os números reais em strings, use a função rtos, da seguinte maneira:

(rtos (carro lpt))

(rtos (quadro lpt))

(rtos (caddr lpt))

E então, para combinar as três strings individuais em uma string, use o strcat (concatenação de string), da seguinte maneira:

(strcat

(rtos (carro lpt))

(rtos (quadro lpt))

(rtos (caddr lpt))

)

Este código exibe 1.000 2.000 3.000. Seria um bom toque colocar vírgulas entre os números:

(strcat

(rtos (carro lpt)) “,”

(rtos (quadro lpt)) ","

(rtos (caddr lpt))

)

Junte as duas linhas de código e chegaremos ao LISP necessário para implantar o valor da variável de sistema LastPoint na caixa de diálogo:

(setq lpt (getvar “últimoponto“))

(set_tile “últimoPontoDados" (strcat (rtos (car lpt)) "," (rtos (cadr lpt)) "," (rtos 

(caddr lpt))))

Adicione o código ao xx.lspe execute-o em BricsCAD para ver o resultado.

Adicionando os dados do último ponto

Saindo da sala para o texto variável

Ops, os números estão cortados. O BricsCAD dimensiona a caixa de diálogo antes de o código LISP inserir os dados, portanto, ele não sabe que a caixa de diálogo precisa ser maior para acomodar as coordenadas x, y, z - que podem ter muitos caracteres de comprimento.

A solução é usar o largura atributo para cada bloco de texto, como este:

: texto {

valor = “”;

chave = “lastAngleData”;

largura = 33;

}

Quando adicionado ao arquivo DCL, o resultado é semelhante a este:

caixas de diálogo são personalizáveis em BricsCAD
Adicionando os dados do último x, y

FIXANDO A LARGURA DO BOTÃO

Ops. Agora o botão OK está muito largo. Para torná-lo mais estreito (ou seja, fixar sua largura), use o Largura fixa atributo no arquivo DCL:

Largura fixa = verdadeiro;

Ao defini-lo como verdadeiro, o botão tem a largura do rótulo.

Mais mudanças

Centralizando o botão

Ops! Agora o botão não está mais centralizado. Por padrão, o botão é justificado à esquerda. Para centralizá-lo, use o alinhamento atributo:  alinhamento = centrado;

Adicione o novo código à parte do botão do arquivo DCL ...

: botão {

tecla = “okButton”;

rótulo = “OK”;

is_default = true;

alinhamento = centrado;

largura_fixa = verdadeiro;

}

… E, em seguida, execute novamente o arquivo xx.lsp para ver se o botão OK do tamanho adequado está centralizado.

TESTANDO A CAIXA DE DIÁLOGO

É sempre uma boa ideia testar a caixa de diálogo em várias situações. Use o comando Linha
para desenhar algumas linhas. Esta ação altera os valores dos três sysvars. Execute novamente a rotina xx.lsp.
Os valores exibidos pela caixa de diálogo devem ser diferentes.

Caixa de diálogo formatada corretamente

Definindo o Comando

Até agora, você executou xx.lsp para desenvolver e testar a caixa de diálogo. Agora que está funcionando corretamente, você deve alterar o nome “xx” para um que seja mais descritivo. Renomeie o arquivo LISP como last.lsp, altere o nome da função dentro para C: último, e tornar as variáveis locais, como segue:

(defun c:último (/ dlg-id lang lpt lcmd)

(setq dlg-id (load_dialog “c: \\ lastInput”))

(new_dialog “lastInput” dlg-id)

(setq lang (getvar “lastangle”))

(set_tile “lastAngleData” (rtos lang))

(setq lpt (getvar “último ponto”))

(set_tile “lastPointData” (strcat (rtos (car lpt)) “,” (rtos (cadr lpt)) “,”

(rtos (caddr lpt))))

(setq lcmd (getvar “lastprompt”))

(set_tile “lastPromptData” lcmd)

(action_tile “okButton” “(done_dialog)”)

(start_dialog)

(unload_dialog dlg-id)

)

O arquivo DCL se parece com isto, em sua totalidade:

lastInput: dialog {

rótulo = “Última entrada”;

: linha {

: texto {

rótulo = “Último ângulo:“;

chave = “lastAngle”;

}

: texto {

valor = “”;

chave = “lastAngleData”;

largura = 33;

}

}

: linha {

: texto {

rótulo = “Último ponto:“;

chave = “último ponto”;

}

: texto {

valor = “”;

chave = “lastPointData”;

largura = 33;

}

}

: linha {

: texto {

rótulo = “Último prompt:“;

chave = “lastPrompt”;

}

: texto {

valor = “”;

chave = “lastPromptData”;

largura = 33;

}

}

: botão {

tecla = “okButton”;

rótulo = “OK”;

is_default = true;

alinhamento = centrado;

largura_fixa = verdadeiro;

}

}

Se você gostaria que este comando fosse carregado automaticamente cada vez que você iniciar BricsCAD, adicione last.lsp ao AppLoad lista de inicialização do comando.

Exemplos de blocos DCL

Com o tutorial básico atrás de você, vamos dar uma olhada em como codificar outros tipos de recursos de caixa de diálogo.

Nesta última parte desta postagem, veremos como codificar os seguintes blocos:

Lembre-se de que duas partes do código são sempre necessárias:

  1. O código DCL que especifica o layout da caixa de diálogo
  2. O código LISP que ativa a caixa de diálogo.

BOTÕES

No tutorial anterior, você codificou um botão OK que permitia sair da caixa de diálogo. Acontece que você não precisa fazer a codificação porque BricsCAD codifica vários botões e outros elementos da caixa de diálogo para você. Eles são encontrados em um arquivo chamado base.dcl que normalmente é carregado no BricsCAD automaticamente.

Os nomes dos blocos pré-construídos são:

Telha pré-construída Botão (s) exibido (s)
ok_only OK
ok_cancel OK Cancelar
ok_cancel_help OK Cancelar Ajuda
ok_cancel_help_info OK Cancelar informações de ajuda. . .
Ok_Cancel_Help_Errtile OK Cancelar Ajuda, mais espaço para mensagens de erro.

Use esses blocos pré-construídos para garantir uma aparência consistente para suas caixas de diálogo. Aqui está um exemplo de como usar esses botões em arquivos DCL:

ok_only;

É muito fácil!

Observe que o nome do bloco não possui o prefixo tradicional de dois-pontos (:), mas requer o terminador de ponto-e-vírgula (;).

DCL permite que você crie botões com rótulos feitos de texto (botão blocos) ou imagens (image_button azulejos).

Para indicar que o botão abre outra caixa de diálogo, use reticências (...), como Info….

Além dos botões de texto e imagem, as configurações podem ser alteradas com caixas de seleção (alternância blocos) e botões de rádio (botao de radio ladrilhos) conforme descrito a seguir.

Fazendo os botões funcionarem

OK e Cancelar são fáceis, pois suas funções já estão definidas. Uma coisa é preencher uma caixa de diálogo com botões; outra é fazê-los executar comandos.

Vamos ver como fazer com que os botões executem comandos. Neste tutorial, você criará uma caixa de diálogo com Enredo e Antevisão botões. A figura abaixo mostra como ficará no Linux (é semelhante no Windows).

caixas de diálogo personalizadas do Linux

O objetivo do botão Plot é executar o Enredo comando e do botão Visualizar para executar o Antevisão .

A solução fácil seria adicionar um açao atributo a cada botão para executar uma função LISP, como (comando “plot”). Mas não podemos, porque DCL não permite o altamente útil comando função a ser usada no atributo de ação!

A chave para resolver o problema é o tecla atributo. Fornece botões que identificam nomes pelos quais as funções LISP podem referenciá-los, como:

chave = “traçar”;

Então, no arquivo LISP, você usa o action_tile função para executar o comando Plot. Bem, não exatamente. Tem a mesma restrição contra o uso do comando função, então você deve abordar isso indiretamente, obtendo action_tile para se referir a um segundo Rotina LISP, como (action_tile "enredo" "(cmd-plot)”).

Mas mesmo isso não funcionará porque você precisa que sua caixa de diálogo personalizada desapareça da tela e seja substituída pela caixa de diálogo Plot. A solução é se tornar ainda mais indireto:

(action_tile “plot” “(setq nextDlg 1) (done_dialog) ”)

"enredo" - identifica o botão Plot através de sua chave, “plot”.

(setq nextDlg 1) - registra que o usuário clicou no botão Plot para processamento posterior.

(done_dialog) - fecha a caixa de diálogo.

Isso é feito duas vezes, uma de cada vez quando o usuário clica no botão Plotar ou no botão Visualizar. O código do botão Visualizar é semelhante; as alterações são mostradas em negrito:

(action_tile “antevisão”“ (Setq nextDlg 2) (done_dialog) ”)

Então, você precisa de algum código que decida o que fazer quando nextDlg for definido como 1 ou 2:

(if (= nextDlg 1) (cmd-plot))

(if (= nextDlg 2) (cmd-preview))

Quando nextDlg = 1, a seguinte sub-rotina é executada:

(defun cmd-plot ()

(comando “imprimir”)

)

Quando nextDlg = 2, a seguinte sub-rotina é executada em seu lugar:

(defun cmd-preview ()

(comando “visualizar”)

)

Com o planejamento feito, vamos examinar todo o código. Primeiro, no arquivo x.dcl, você adiciona os atributos-chave a cada botão. O código que se relaciona com o Botão de plotagem é mostrado negrito, enquanto Código relacionado à visualização é mostrado em color:

x: diálogo {label = “Plot”;

: linha {

: botão {label = “Plot”; mnemônico = “P”; chave = plot; }

: botão {label = “Preview”; mnemônico = “v”; chave = “visualização”; }

cancel_button;

} }

Em segundo lugar, no xx.lsp arquivo, você adiciona o código que executa os comandos Plotar e Visualizar.

(defun c: xx (/)

(setq dlg-id (load_dialog “c: \\ x”))

(new_dialog “x” dlg-id)

(action_tile “plot” “(setq nextDlg 1) (done_dialog)”)

(action_tile “preview” “(setq nextDlg 2) (done_dialog)”)

(start_dialog)

(unload_dialog dlg-id)

(if (= nextDlg 1) (cmd-plot))

(if (= nextDlg 2) (cmd-preview))

)

(defun cmd-plot ()

(comando “imprimir”)

)

(defun cmd-preview ()

(comando “visualizar”)

)

No Linux, lembre-se de remover “c: \\” para que a linha load_dialog se leia o seguinte:

(setq dlg-id (load_dialog “x”))

Quando a caixa de diálogo aparecer, clique em cada botão para garantir que ele execute o comando relacionado.

Caixas de seleção

Caixas de seleção permitem que você tenha uma ou mais opções ativadas. Eles contrastam com botões do rádio, que o limita a uma única escolha. As caixas de seleção são criadas pelo alternância telha.

Neste tutorial, você criará uma caixa de seleção que altera a forma dos objetos de ponto. Isso é realizado alterando o valor do PdMode variável do sistema. Sim, existe o DdPType comando que faz a mesma coisa, mas esta é uma abordagem diferente, como você verá.

A variável de sistema PdMode pode assumir estes valores:

  • 0 ponto (.)
  • 1 nada
  • 2 mais (+)
  • 3 Cruz (x)
  • 4 Linha vertical curta (|)
  • 32 Circle
  • 64 Square

Além disso, esses números podem ser combinados por adição. Por exemplo, 34 (32 + 2) adiciona um círculo (32) ao símbolo de mais (2).

Da esquerda para direita: PdMode = 32, 33 e 34.

Aqui está uma peculiaridade dos pontos a serem observados: 32 na verdade, um círculo com ponto (32 + 0), porque 0 desenha um ponto. Em comparação, 33 (32 + 1) é o círculo sozinho, porque o 1 não exibe nada!

Vamos ver como criar uma caixa de diálogo que nos permite selecionar combinações dos símbolos de mais, círculo e quadrado. Que tal uma caixa de diálogo parecida com esta ...

anatomia de uma caixa de diálogo

Aqui está o código necessário para gerar a caixa de diálogo:

x: diálogo {rótulo = “Estilo de ponto”;

: coluna {label = “Selecione um estilo de ponto:”;

: alternar {tecla = “mais”; rótulo = “Mais”; valor = “1”; }

: alternar {tecla = “círculo”; rótulo = “Círculo”; }

: alternar {tecla = “quadrado”; rótulo = “Quadrado”; }

}

ok_cancel;

}

Notar que valor = “1” ativa a opção Mais (para mostrar a marca de seleção), tornando-a o valor padrão.

Agora vamos escrever o arquivo LISP para fazer a caixa de diálogo funcionar. Algo tão simples como (action_tile “plus” “(setvar“ pdmode ”2)”) não funciona porque o usuário pode querer selecionar mais de uma opção - que é todo o ponto de alternância. Você precisa do código para passar por três etapas:

Passo 1: Leia qual (is) opção (ões) os usuários marcaram.
Passo 2: Adicione a (s) configuração (ões).
Etapa 3: Defina PdMode para mostrar o estilo de ponto desejado.

Vamos implementar:

  1. Para ler a entrada do usuário nas caixas de diálogo, use LISP's $value variável para o botão Plus:

    (action_tile “mais”“ (Setq plusVar $value) ”)

    Repita o código para os outros dois alternadores, Círculo e Quadrado:

    (action_tile “círculo”“ (Setq circleVar $value) ”)

    (action_tile “quadrado“(Setq SquareVar $value) ”)

  2. O $value variável contém apenas 1s e 0s. Mais tarde, usaremos uma tabela de pesquisa para converter os 1s e 0s nos valores esperados por PdMode. Por exemplo, se Plus for selecionado (“1”), então PdMode espera um valor de 2. A tabela de pesquisa usa a função if para corrigir os números, da seguinte maneira:

    (if (= plusVar “1”) (setq plusNum 2) (setq plusNum 0))

    Isso pode ser lido como:

    Se plusVar = 1, defina plusNum = 2;

    caso contrário, defina plusNum = 0.

    Repita o código de pesquisa para os outros dois alternadores, Círculo e Quadrado:

    (if (= squareVar “1”) (setq squareNum 64) (setq squareNum 0))

    (if (= circleVar “1”) (setq circleNum 32) (setq circleNum 0))

    DICA O valor $ recuperado por get_tile é na verdade uma string, como “1”. A variável de sistema PdMode, entretanto, espera um número inteiro. Assim, a tabela de pesquisa executa uma função secundária de conversão de strings em inteiros.

    Com os valores definidos para o que PdMode espera, some-os com a função +:

    (setq vars (+ plusNum circleNum squareNum))

  3. Para alterar o valor de PdMode, você emprega LISP's setvar função, assim:

    (setvar “Pdmode” vars)

    Aqui está todo o código LISP:

    (defun c: xx (/)

    (setq dlg-id (load_dialog “c: \\ x”))

    (new_dialog “x” dlg-id)

    ;; Obtenha os valores atuais de cada bloco de alternância:

    (setq plusVar (get_tile “plus”))

    (setq circleVar (get_tile “circle”))

    (setq squareVar (get_tile “square”))

    ;; Veja em quais opções o usuário clica:

    (action_tile “plus” “(setq plusVar $value)”)

    (action_tile “circle” “(setq circleVar $value)”)

    (action_tile “square” “(setq squareVar $value)”)

    (start_dialog)

    (unload_dialog dlg-id)

    ;; A tabela de pesquisa converte strings “0” / ”1 ″ nos inteiros corretos:

    (if (= plusVar “1”) (setq plusNum 2) (setq plusNum 0))

    (if (= circleVar “1”) (setq circleNum 32) (setq circleNum 0))

    (if (= Var quadrada “1”) (setq squareNum 64) (setq squareNum 0))

    ;; Adicione os inteiros e, em seguida, altere a variável do sistema

    (setq vars (+ plusNum circleNum squareNum))

    (setvar “pdmode” vars)

    )

Botões do rádio

Os botões de rádio são mais fáceis de codificar do que alternar, porque apenas um pode estar ativo por vez.
Neste tutorial, você criará uma caixa de diálogo que usa botões de opção para alterar o isoplano. A caixa de diálogo altera o valor da variável de sistema SnapIsoPair, que assume os seguintes valores:

  • 0 Isoplano esquerdo (padrão)
  • 1 Isoplano de topo
  • 2 Isoplano direito

Para fazer uma caixa de diálogo semelhante a esta ...

… Leva este código:

x: diálogo {rótulo = “Isoplane”;

: coluna {rótulo = “Alterar o isoplano para:”;

: radio_button {chave = “esquerda”; rótulo = “Isoplano esquerdo”; valor = “1”; }

 

: radio_button {key = “top”; rótulo = “Isoplano superior”; }

: radio_button {key = “right”; rótulo = “Isoplano direito”; }

espaçador;

}

ok_cancel;

}

Notar que valor = “1” ativa o X para a caixa de seleção ao lado de Esquerda.

Antes de prosseguir para o arquivo LISP que o acompanha, primeiro configure BricsCAD para exibir o modo isométrico:

  1. Entre em Configurações .
  2. No campo Pesquisar, digite “Snap Style”.caixas de diálogo personalizadas
  3. Na lista suspensa Tipo de Snap, selecione Snap isométrico.
  4. Clique X para descartar a caixa de diálogo.

BricsCAD está agora no modo isométrico.

Conforme você usa a caixa de diálogo descrita abaixo, o cursor muda sua orientação:

cursor no modo de snap isométrico
Da esquerda para a direita: Cursor para os isoplanos esquerdo, superior e direito.

Vamos agora nos voltar para o arquivo LISP que fará esta caixa de diálogo funcionar. É semelhante ao código usado para
alterna; a principal diferença é que os valores não são somados:

(defun c: xx (/)

(setq dlg-id (load_dialog “c: \\ x”))

(new_dialog “x” dlg-id)

;; Veja em qual botão de opção o usuário clica:

(action_tile “left” “(setq leftVar $value)”)

(action_tile “top” “(setq topVar $value)”)

(action_tile “right” “(setq rightVar $value)”)

(start_dialog)

(unload_dialog dlg-id)

;; Tabela de pesquisa:

(if (= leftVar “1”) (setq vars 0))

(if (= topVar “1”) (setq vars 1))

(if (= rightVar “1”) (setq vars 2))

;; Alterar a variável do sistema:

(setvar “snapisopair” vars)

)

Temos trapaceado um pouco porque estamos forçando a caixa de diálogo a mostrar o isoplano esquerdo como o padrão. Isto não é necessariamente verdade. Você realmente deve modificar o código DCL e LISP para fazer a caixa de diálogo mostrar inicialmente o isoplano padrão - seja esquerdo, superior ou direito.

A configuração do padrão é feita com LISP's set_tile função. Primeiro, altere o código DCL para que ele não torne mais o isoplano esquerdo o padrão: alterar valor = “1” para:

valor = “”

No código LISP, você precisa fazer o seguinte: (a) extrair o valor de SnapIsoPair com getvar, e então (b) usar set_tile como um retorno de chamada.

  1. Extraia o valor atual de SnapIsoPair com a função getvar:

    getvar “snapisopair”))

  2. Defina o botão padrão com a função set_tile:

    set_tile “left” “1”))

A leitura é a seguinte:

Se o valor de SnapIsoPair for 0 (= vars 0),

em seguida, ative o botão de opção isoplano esquerdo (set_tile “left” “1”).

Escreva um código semelhante para os outros dois botões de opção:

(if (= vars 1) (set_tile “top” “1”))

(if (= vars 2) (set_tile “right” “1”))

A outra alteração que você precisa fazer é alterar algumas das variáveis para local:

(defun c: xx (/ leftVar topVar rightVar)

Isso força as três variáveis a perderem seu valor quando a rotina LISP termina. De outra forma, rightVar mantém seu valor (é o último) e torna o isoplano direito o padrão cada vez que a caixa de diálogo é aberta.

Com essas mudanças em vigor, o código aprimorado tem esta aparência - com as alterações destacadas em negrito:

(defun c: xx (/ leftVar topVar rightVar)

(setq vars (getvar “snapisopair”))

(setq dlg-id (load_dialog “c: \\ x”))

(new_dialog “x” dlg-id)

;; Defina o botão padrão:

(if (= vars 0) (set_tile “left” “1”))

(if (= vars 1) (set_tile “top” “1”))

(if (= vars 2) (set_tile “right” “1”))

;; Veja em qual botão de opção o usuário clica:

(action_tile “left” “(setq leftVar $value)”)

(action_tile “top” “(setq topVar $value)”)

(action_tile “right” “(setq rightVar $value)”)

(start_dialog)

(unload_dialog dlg-id)

;; Tabela de pesquisa:

 (if (= leftVar “1”) (setq vars 0))

(if (= topVar “1”) (setq vars 1))

(if (= rightVar “1”) (setq vars 2))

;; Alterar a variável do sistema:

(setvar “snapisopair” vars)

)

Agora, cada vez que a caixa de diálogo é iniciada, ela exibe corretamente o isoplano padrão, como “Right”, conforme ilustrado abaixo:

CLUSTERS

Clusters ajudá-lo a combinar grupos de controles relacionados. DCL permite especificar clusters verticais, horizontais, em caixa e não em caixa. Além do que, além do mais, clusters de rádio são necessários quando você deseja ter dois botões de opção ativados ao mesmo tempo. Em todos os outros casos, os clusters são necessários apenas para fins visuais e organizacionais.

BricsCAD faz parecer que há oito ladrilhos para fazer clusters:

Coluna Linha
Boxed_Column Boxed_Row
Radio_Column Radio_Row
Boxed_Radio_Column Boxed_Radio_Row

Mas esses oito podem ser reduzidos a três, quando você leva em consideração o seguinte:

  • O coluna ladrilho geralmente não é necessário, porque BricsCAD empilha automaticamente ladrilhos verticalmente em colunas.
  • O coluna e Lin os blocos exibem uma caixa assim que você inclui um rótulo para eles.
  • Ladrilhos com rádio em seus nomes são apenas para botões de opção de agrupamento.

Colunas e Linhas

BricsCAD normalmente empilha blocos, então não coluna o ladrilho é necessário, conforme ilustrado por este código DCL:

x: dialog {

: botão {rótulo = “& Botão”; }

: botão {label = “& Click”; }

: botão {label = “& Pick”; }

ok_only;

}

(O e comercial - & - especifica o pressionamento de tecla de atalho que acessa o botão do teclado com o Alt tecla, como pressionar Alt + B.)

Para criar uma linha horizontal de ladrilhos, use o linha {} bloco, conforme mostrado em negrito abaixo:

x: dialog {

: linha {

: botão {rótulo = “& Botão”;}

: botão {label = “& Click”; }

: botão {label = “& Pick”;}

}

ok_only;

}

O encaixe da linha horizontal é invisível, então destaquei com um retângulo azul.

botões caixas de diálogo personalizadas

Porque o ok_only o azulejo está fora do linha {} lado a lado, ele está localizado fora do cluster, empilhado verticalmente abaixo da linha de três botões.

Boxed Row

Para realmente mostrar um retângulo (caixa) ao redor dos três botões, altere "linha" para boxed_row, do seguinte modo:

x: dialog {

: boxed_row {

// et cetera

}

ok_only;

}

Linha em caixa com etiqueta

Você pode adicionar texto para descrever a finalidade dos botões em caixa com o etiqueta atributo, conforme mostrado em negrito abaixo:

x: dialog {

: boxed_row {label = “Três botões”;

// et cetera

}

ok_only;

}

O curioso é que você obtém o mesmo efeito usando o boxed_row ou Lin telha. Isso mesmo: quando você adiciona um rótulo ao Lin lado a lado, o BCL adiciona automaticamente uma caixa ao redor do cluster.

Para eliminar a caixa, preceda a linha com o text tile para o título, da seguinte maneira:

x: dialog {

: text {label = “Três botões”;}

: linha {

// et cetera

}

ok_only;

}

caixa de diálogo

Ladrilhos especiais para botões de rádio

Você pode usar os blocos regulares de linha e coluna com botões de opção, exceto em um caso: quando mais de um botão de opção precisa ser ativado. Lembre-se de que apenas um botão de opção pode estar ativado (mostrado o ponto preto) por vez; BricsCAD desativa automaticamente todos os outros botões de rádio que podem estar ativados (valor = “1”).

A solução é usar dois ou mais radio_column blocos, cada um segurando um dos conjuntos de botões de opção que precisam estar ativados.

Não é recomendado usar linhas para botões de opção, porque essa configuração horizontal é psicologicamente mais difícil para os usuários.

Depurando DCL

Os erros de codificação DCL mais comuns são devidos a erros de pontuação, como omissão de um ponto e vírgula ou aspas de fechamento. Esses problemas são anunciados por caixas de diálogo de mensagem de erro, que ilustro posteriormente nesta seção.

DCL_SETTINGS

DCL contém um depurador para localizar certos erros de codificação. Para ativar o depurador, adicione o audit_level parâmetro para o início do arquivo DCL, antes do diálogo telha:

dcl_settings: defalut_dcl_settings { audit_level = 3; } x: dialog {// et cetera

O depurador opera em quatro níveis:

Nível de auditoria Significado 
0 Nenhuma depuração realizada
1 (Padrão) Verifica se há erros de DCL que podem encerrar BricsCAD, como blocos indefinidos ou definições de protótipo circular
2 Verifica se há layouts e comportamentos indesejáveis, como atributos ausentes ou valores de atributos errados
3 Verifica se há definições de atributos redundantes

MENSAGENS DE ERRO DCL

BricsCAD exibe mensagens de erro relacionadas ao DCL em caixas de diálogo. Você pode encontrar alguns dos seguintes:

Erro (s) semântico (s) em arquivo DCL

Às vezes, uma caixa de diálogo de erro sugere que você olhe para o acad.dce arquivo - o arquivo de erro DCL. O problema é que a caixa de diálogo não informa onde este arquivo está localizado. Depois de executar a Pesquisa do Windows nas unidades C: e D: do meu computador, finalmente encontrei o arquivo no D: \ documentos e configurações \ administrador \ meus documentos pasta.

O arquivo contém informações sobre erros, como:

====== Auditoria semântica DCL de c: \ x ======

Erro. O widget chamado “asdfasfads” não está definido.

Não está claro para mim por que alguns erros são exibidos diretamente nas caixas de diálogo de mensagens, enquanto outros são armazenados no acad.dce arquivo.

A caixa de diálogo não tem um botão OK nem CANCELAR

As caixas de diálogo precisam sair por meio de um OK ou Cancelar botão. No mínimo, adicione o ok_only lado a lado para o arquivo DCL. DCL foi escrito antes do Windows adicionar automaticamente o x (cancelar) para todas as caixas de diálogo e a Autodesk não conseguiu atualizar o DCL para levar esta inovação em consideração.

Erro no arquivo de diálogo “filename.dcl”, linha n

Seu arquivo DCL contém o nome de um bloco desconhecido para BricsCAD. Verifique a ortografia. Neste exemplo, ok_only foi prefixado por dois pontos (:), o que é incorreto para blocos pré-construídos.

Incorreto:: ok_only;

Correto: ok_only;

A caixa de diálogo é muito grande para caber na tela

Um bloco no arquivo DCL está criando uma caixa de diálogo que não caberia na tela do seu computador. Isso pode acontecer quando o edit_edith, largura, ou altura atributos são muito grandes.

Recursos adicionais

Há mais para aprender sobre como escrever caixas de diálogo com DCL, como por meio destes tutoriais DCL:

AfraLisp em tutoriais de esportesmais informações codificação dcl

incluindo estes tópicos:

  • Começando
  • DCL Primer - Download
  • Layout da caixa de diálogo
  • Caixas de Diálogo Passo a Passo
  • Caixas de Diálogo em Ação
  • Diálogos de aninhamento e ocultação
  • Ocultando diálogos revisitados
  • LISP Message Box
  • Caixa de entrada LISP
  • Referenciando arquivos DCL
  • Funções LISP para linguagem de controle de diálogo (DCL)
  • Sinopse Funcional de Arquivos DCL
  • Atributos DCL
  • Dados padrão da caixa de diálogo
  • Modelo DCL
  • DCL Progress Bar
  • Atributos e caixas de diálogo
  • DCL sem o arquivo DCL
  • Os tutoriais AfraLisp DCL
  • Entrando nas Caixas de Edição

Download Grátis do BricsCAD por 30 dias

Comece a usar o BricsCAD hoje

Licenças permanentes ou por aluguel, que funcionam em todos os idiomas, em todas as regiões.


  1. Introdução
  2. 55 Dicas para Usuários do BricsCAD
  3. Configurações
  4. Mudar o Ambiente
  5. Interface de Usuário Personalizada
  6. Introdução ao Diálogo Personalizar
  7. Personalizar a barra de Menus & Menus de Contexto
  8. Barras de ferramentas e ícones de botão
  9. Escrever Macros e o Código Diesel
  10. Painéis e guias da faixa de opções
  11. Atalhos de teclas, aliases e comandos do shell
  12. Botões do mouse, clique duplo e tablet
  13. Absolutamente tudo o que você precisa saber sobre o Quad
  14. Propriedades de sobreposição
  15. Áreas de trabalho e a interface do usuário
  16. Projetando Painéis de Ferramentas e Estrutura
  17. Criando tipos de linha simples e complexos
  18. Padronizar Hachuras
  19. Decodificação de formas e fontes
  20. Codificação com texto do campo
  21. Escrevendo scripts
  22. Programando com LISP (Introdução)
  23. Funções LISP
  24. Escrevendo um Programa LISP Simples
  25. 7 dicas para programação LISP
  26. Projetando Caixas de Diálogo com DCL
  27. Criação de caixas de diálogo personalizadas