O mecanismo de funcionamento do Quadro de Diálogo

Dicas sobre ObjectDCL...

Moderador: Moderadores

Responder
Avatar do usuário
ronaldoalmeida
Bronze 2/3
Bronze 2/3
Mensagens: 200
Registrado em: Qui 07 Out 2004 12:00:00 am
Localização: Florianópolis-SC

O mecanismo de funcionamento do Quadro de Diálogo

Mensagem por ronaldoalmeida » Seg 18 Out 2004 8:51:34 pm

Mecanismo de funcionamento do Quadro de Diálogo

Num programa de Quadros de Diálogo(ver abaixo) pode-se definir 4 fases: Definição, Preparação, Execução e Restabelecimento.

Definição
Esta fase involve:
1 . Carregamento do quadro de diálogo
Carregar o arquivo DCL na memória (se já não estiver carregado) com um chamado a load_dialog. No caso, o arquivo se chama exemplo.dcl.
2. Selecionar um determinado Quadro de Diálogo do arquivo e exibi-lo chamando new_dialog. No caso, o quadro tem o mesmo nome do arquivo: exemplo.

Preparação
Muitas vezes é necessário inicializar o quadro de diálogo setando os valores dos elementos (tiles) , listas e imagens. As funções típicamente usadas são set_tile e mode_tile para valores e status de elemento; start_list, add_list e end_list para list_boxes ou popup_list e funções de dimensão de imagem com start_image, vector_image , fill_image, slide_image e end_image para imagens. Finalmente pode se usar client_data para associar um dados de aplicação especifico com o quadro de diálogo e seus componentes.
Estas funções devem ficar depois de new_dialog.
No exemplo , as expressões (mode_tile "botao" 1) e (set_tile "editbox" "legal") são de inicialização. Salienta-se que estas funções não precisam necessáriamente vir antes das funções de execução (action_tile..). Elas são executadas automáticamente após a exibição sem a intervenção do usuário. Observar que a expressão (mode_tile "botao" 1) antes de new_dialog não tem nenhum sentido, está errado!

Execução
Nesta fase é chamado start_dialog para assumir o controle do quadro de diálogo afim de possibilitar ao usuário entrar com dados.
Para se definir qual ação a ser tomada quando se seleciona um elemento(tile) do quadro deve-se associar uma expressão ao elemento por intermédio da função action_tile. Isto é conhecido como expressão de ação. Refere-se a`expressão lisp entre aspas:
(action_tile "editbox" "(salva $key $value $reason)")
(action_tile "botao" "(tecla_me)")
(action_tile "accept" "(done_dialog 1)")
(action_tile ”key” “(setq val (get_tile \“key\”))”)

Dentro destas expressões pode-se:
Usar get_tile ou get_attr para acessar o valor do elemento. Get_tile retorna o valor correntemente executado do elemento baseado na entrada do usuário. Usar variáveis próprias de action_tile: $key, $value, etc.
As expressões de ação devem ser definidas entre new_dialog e start_dialog.
O fluxo do programa sempre pára em start_dialog. Só prossegue se o usuário teclar uma tecla de sáida para fechar o quadro principal ou abrir outra tela (mensagem).
O start_dialog assume o controle. É como start_dialog tivesse um loop interno que roda cada expressão de ação verificando permanentemente os dados de entrada do usuário.
As funções de usuário entre aspas (salva e tecla_me) se denominam funções de retorno de chamada -callback functions. Elas constituem resposta da expressão de ação , isto é, o usuário clicou um elemento e consequentemente uma função fez alguma coisa.
Existe 2 maneiras de definir ações além da função action_tile. Pode-se definir uma ação default para todo o quadro de diálogo quando se chama new_dialog, e pode-se definir uma ação usando o atributo action do elemento do quadro.
É importante observar durante a elaboração do programa que as ações no quadro em exibição somente serão válidas e de valores utilizáveis posteriormente se o usuário sair do quadro clicando OK! O programador deve distinguir as variáveis locais temporárias e internas, das variáveis globais permanente e externas.

Restabelecimento
Enquanto estiver na fase de Execução o operador não pode selecionar pontos ou desenhar na tela. A fase de Restabelecimento é onde este tipos de entrada são manipuladas. Depois desta fase às vezes é necessário retornar para a fase Preparação e Execução de novo. Quando a fase de Restabelecimento está fechando o diálogo unload_dialog pode ser usado para remover o arquivo DCL da memória.
No exemplo, ao se executar a função tecla-me a expressão (done_dialog 2) fecha o quadro e possibilita seu restabelecimento.

// Arquivo: EXEMPLO.DCL
exemplo : dialog {
label = "teste exemplo";
:edit_box {
key = "editbox";
label = "Tecla um botao";
}
:button {
key = "botao";
label = "Tecla me";
}
:button {
label = "OK";
key = "accept";
is_default = true;
}
}

exemplo.bmp

;;Arquivo exemplo.lsp

(defun tecla_me()
(alert "O botao tecla-me foi pressionado")
(done_dialog 2))

(defun salva(key value reason)
(setq out (open "exemplo.txt" "w"))
(write-line (strcat key " " value " " (itoa reason)) out)
(close out)
(mode_tile "botao" 0))

(defun c:exemplo()
(setq id (load_dialog "exemplo"))
(mode_tile "botao" 1)
(setq flag T)
(while flag
(new_dialog "exemplo" id)
(action_tile "editbox" "(salva $key $value $reason)")
(mode_tile "botao" 1)
(action_tile "botao" "(tecla_me)")
;(action_tile "accept" "(done_dialog 1)")
(set_tile "editbox" "legal")
(setq OK (start_dialog))
(if (= ok 1)
(setq flag nil)))
;(unload_dialog 1)
)

Avatar do usuário
lotah
Concreto
Concreto
Mensagens: 49
Registrado em: Sáb 15 Mai 2004 12:00:00 am

Mensagem por lotah » Seg 18 Out 2004 10:35:51 pm

Já imprimi...
:lol:

Vamos ver se agora aprendo...heheeh

[]'s
Diego, nascido em General Câmara, filho de Francisco, neto de Osvaldo

Avatar do usuário
hugopaulo
Master
Master
Mensagens: 1873
Registrado em: Dom 29 Fev 2004 12:00:00 am

Mensagem por hugopaulo » Ter 19 Out 2004 12:51:11 am

Ao Lotah e ao Ronaldo Almeida e a Todos

Queria colocar só um adendo, pois o Ronaldo escreveu um "Manual" quase completo.

Existem formas e formas de se fazer programas. A maneira mais abordada e q tem dado melhores reultados incluindo o de manutenibilidade e aperfeiçoamento é o da estruturação das rotinas. No exemplo do Ronaldo por exemplo é mais adequado ao funcionamento que se agrupem todas as "ações" em bloco de preferência antes do start_dialog. Outra mais adequada é colocar variáveis relacionadas com as "keys" do DCL e fazer as entradas com ela.

Atenção q ninguém suponha ou queira entender q a forma do Ronaldo Almeida programar é "errada" ou está errada. Apenas é um modo de fazer sem as estruturações padronizadas. Se o resultado dá certo e não se conhecem a fundo as estruturas tudo bem. O resultado correto é o importante. Não adianta estruturar e apresentar tudo errado ou sem estrutura e errado tb. Bom senso acima de tudo.

Agora, apenas acostumem-se a documentar. Facilita até para vcs q não precisam ficar pensando o que faz aquela linha. :wink:

Um Abraço.
hugopaulo
AutoLISP Não É LISP ==> VISUAL LISP não é Linguagem

Avatar do usuário
ronaldoalmeida
Bronze 2/3
Bronze 2/3
Mensagens: 200
Registrado em: Qui 07 Out 2004 12:00:00 am
Localização: Florianópolis-SC

Mensagem por ronaldoalmeida » Ter 19 Out 2004 8:26:05 am

Quando se faz um quadro de diálogo muito grande se torna inevitável dividir as funções por assunto senão fica um emaranhado. O trecho de um programa é mostrado a seguir onde se definem as funções das etapas do processo (inicialização, execução, restabelecimento) e as expressões do action-tile estão em funções separadas.
;;...................

(defun quociente(dividendo divisor / quoc)
(if (and divisor (= (atof divisor) 0.0))
(progn
(alert "Não é permitido o valor 0")
(setq quoc nil))
(progn
(setq quoc (rtos (/ (atof dividendo) (atof divisor))))
(set_tile "quociente" quoc)
(mode_tile "mensagem" 0)
(mode_tile "catavento" 0)))
quoc) ;; retorna string

;;......................

(defun inicialização()
(mode_tile "dividendo" 2)
(mode_tile "catavento" 1)
(mode_tile "mensagem" 1))

(defun execução(id / quoc)
(action_tile "dividendo" "(setq dividendo $value)")
(action_tile "divisor" "(setq divisor $value)
(setq quoc (quociente dividendo divisor))")
(action_tile "mensagem" "(mensagem id)")
(action_tile "catavento" "(done_dialog 3)")
quoc)


(defun restabelecimento(status id faz dividendo divisor quociente / lcálculo)
(cond
((= status 0)
(setq faz nil))
((= status 1)
(setq lcálculo (list dividendo divisor quociente))
(setq faz nil))
;((= status 2) (mensagem id))
((= status 3) (catavento)))
(list faz lcálculo))

(defun malfeito( / faz dividendo divisor res quoc status lres)
(setq faz T)
(setq id (load_dialog "malfeito"))
(while faz
(new_dialog "malfeito" id)
(inicialização)
(setq quoc (execução id))
(setq status (start_dialog))
(setq lres (restabelecimento status id faz dividendo divisor quoc))
(setq faz (car lres)))
(term_dialog)
(last lres))

Avatar do usuário
hugopaulo
Master
Master
Mensagens: 1873
Registrado em: Dom 29 Fev 2004 12:00:00 am

Mensagem por hugopaulo » Ter 19 Out 2004 9:28:08 pm

Ronaldo Almeida

Ponderei sobre a sua explicação e ainda assim por questôes de estruturas a q estou mais acostumado, pessoalmente, prefiro manter o agrupamento justamente para não ficar um emaranhado ( coisas iguais separadas ). Na hora de corrigir ou aperfeiçoar tenho tudo a mão não importando o tamanho ou quantos assuntos tenham o quadro de diálogo. O segredo ? Documentar sempre, indepente de quantas action_tile se tenham...continuo enfatizando q é mais adequado sem querer sequer dizer q o restante está errado. Mas preferências não se discutem, mesmo q se sejam para o bem...Uns documentam sempre...outros se sentem melhor fazendo na "linha direta". Se é para o bem, tudo bem, mas documentem...as rotinas são feitas para uso de outras pessoas a maior parte das vezes. É muito boa prática e aqui não entra o "achismo".

Um Abraço...
hugopaulo
AutoLISP Não É LISP ==> VISUAL LISP não é Linguagem

Avatar do usuário
ronaldoalmeida
Bronze 2/3
Bronze 2/3
Mensagens: 200
Registrado em: Qui 07 Out 2004 12:00:00 am
Localização: Florianópolis-SC

Mensagem por ronaldoalmeida » Qua 20 Out 2004 2:26:37 pm

Respeito seu pto de vista.
Eu, eventualmente escrevo um comentario.É muito raro.Me preocupo com os titulos das funções e parâmetros: dividendo , divisor , quociente .
Eu sou a unica pessoa que conheço que insiste em declarar um procedimento em VBA na forma da linguagem Ada: uso sempre ByVal e ByRef nos parâmetros do procedimento para saber quem entra ou quem sai.
ronaldo

Responder