Programando em Clarion .NЕТ

3URJUDPDQGRHP&ODULRQ1(7
-XOLR&pVDU3HGURVR
6HXSULPHLURSURJUDPDHP&ODULRQ1(7
O Clarion.NET foi criado para auxiliá-lo na criação de aplicações que se
utilizam do .NET Framework usando uma ferramenta RAD (Rapid Applicat ion
Developm ent ) que você j á conhece há m uit o t em po. Est e capít ulo é um a
int rodução ao am bient e int egrado de desenvolvim ent o do Clarion.NET, o
que cham am os de I DE, e dem onst ra um a aplicação m uit o sim ples de
console, o fam oso “ ALO MUNDO” .
,QLFLDQGR
Na
IDE,
selecione
$UTXLYR, 1RYR, 6ROXomR.
(sim a IDE do Clarion.NET
está em português), se o
seu Windows for em
português).
Uma caixa de diálogo,
1RYR3URMHWR, semelhante
à figura ao lado será
apresentada. Na árvore 7LSRV GH 3URMHWRV (Categorias), escolha a opção
&ODULRQ1HW e expanda o nó da árvore. Escolha agora a opção $SOLFDo}HV
:LQGRZV No painel 0RGHORV que fica no painel da direita são mostrados 4
itens: %LEOLRWHFD GH &ODVVHV, %LEOLRWHFD GH &RQWUROHV, $SOLFDomR :LQGRZV
e $SOLFDomR&RQVROH. Clique em $SOLFDomR&RQVROH e entre um nome para o
seu programa. Você pode escolher uma localização para o seu projeto, ou
deixar o padrão no campo /RFDOL]DomR.
Nosso projeto foi chamado de ALOMUNDO. Depois, é só clicar no botão
&ULDU e o seguinte módulo-fonte é mostrado.
!~
~ Criado em Clarion
~ Autor: Julio César Pedroso
~ Em: 05 de março de 2008.
~!
352*5$0
1$0(63$&((ALOMUNDO)
0$3
1
3URJUDPDQGRHP&ODULRQ1(7
(1'
-XOLR&pVDU3HGURVR
&2'(
System.Console.:ULWH/LQH(
+HOOR:RUOG
)
System.Console.5HDG.H\()
Alteramos o texto (‘Hello World’) gerado, para (‘Alo Mundo’)
As primeiras linhas exibidas em cor verde no nosso exemplo mostram a nova
sintaxe para blocos de comentário.
Para comentar apenas a linha atual use o til ~ , mas para criar um bloco de
comentário no código, utilize !~ no início do bloco e ~! no final do bloco.
Para quem já conhece Clarion, a sentença PROGRAM não é nova, mas
o que vem a seguir sim, a diretiva NAMESPACE.
NAMESPACE é uma forma de agrupar o seu código e reduzir a possibilidade
de colisão de nomes.
Se você não especificar um NAMESPACE o compilador
automaticamente irá gerar um para você usando o mesmo nome do projeto,
concatenado com a expressão NS. No nosso exemplo se não fosse
especificado um NAMESPACE seria gerado um ALOMUNDONS.
As sentenças MAP e END, que se seguem, são velhas conhecidas dos
programadores Clarion. Da mesma forma a sentença CODE, que todos nós já
estamos acostumados a usar.
Em seguida, logo após o CODE, você tem o seu primeiro contato com a
livraria Framework. São duas linhas
System.Console.:ULWH/LQH(
$OR0XQGR
)
System.Console.5HDG.H\()
System é um Namespace, Console é uma classe contida no Namespace
System enquanto que Writeline e Readkey são métodos desta classe. Fica
claro que ‘Alo Mundo’ é o argumento do método WriteLine.
'LFDSDUDTXHPHVWiFRPHoDQGR
2V QDPHVSDFHV IRUQHFHP XP HVTXHPD OyJLFR GH QRPHDomR TXH
SHUPLWHPDGLFLRQDUVREXP~QLFRJUXSRRVWLSRVGHGDGRVUHODFLRQDGRV
0XLWR VHPHOKDQWH DRV ³SDFRWHV´ GD OLQJXDJHP -DYD 2 1(7 )UDPHZRUN
XVD XP HVTXHPD GH QRPHDomR KLHUiUTXLFD SDUD DJUXSDU RV WLSRV HP
FDWHJRULDV OyJLFDV GH IXQFLRQDOLGDGH UHODFLRQDGD WDLV FRPR DFHVVR GH
GDGRV *8, UHODWyULRV HWF $V IHUUDPHQWDV GH SURMHWR SRGHP XVDU
QDPHVSDFHVSDUDIDFLOLWDUDRVGHVHQYROYHGRUHVDQDYHJDomRHRVWLSRVGH
UHIHUrQFLD QR FyGLJR 1R 1(7 )UDPHZRUN XPD QDPHVSDFH p XPD
FRQYHQLrQFLD GH QRPHDomR HP WHPSR GH SURMHWR OyJLFD QD TXDO XP
DVVHPEO\ HVWDEHOHFH R HVFRSR GR QRPH SDUD RV WLSRV HP WHPSR GH
H[HFXomR 2V QDPHVSDFHV WDPEpP DMXGDP R &/5 QD VHOHomR GR
DVVHPEO\ FRUUHWR D VHU FDUUHJDGR TXDQGR SRU H[HPSOR YiULRV
DVVHPEOLHVSRVVXHPRPHVPRQRPH
3RU H[HPSOR TXDQGR YRFr TXHU DFHVVDU XPD FODVVH ORFDOL]DGD QR
1(7 )UDPHZRUN XWLOL]D R QRPH FRPSOHWR TXH LQFOXL R QDPHVSDFH 1D
UHIHUrQFLD 6\VWHP'DWD'DWDVHW D SDUWHFRUUHVSRQGHQWHDR QDPHVSDFHp
6\VWHP'DWDHQTXDQWRDSDUWHFRUUHVSRQGHQWHDRQRPHGRWLSRp'DWDVHW
$ 0LFURVRIW DGRWRX XP SDGUmR QR TXDO WRGRV RV QDPHVSDFHV
GLVSRQLELOL]DGRVSRUHODLQLFLDPFRP6\VWHPRX0LFURVRIW
&RPRRVQDPHVSDFHVIRUQHFHPRHVFRSRSDUDVHXVWLSRVRSDGUmR
p DJUXSDU RV WLSRV FRP IXQFLRQDOLGDGH UHODFLRQDGD HP QDPHVSDFHV
2
3URJUDPDQGRHP&ODULRQ1(7
-XOLR&pVDU3HGURVR
VHSDUDGRV 6\VWHP'DWD 6\VWHP;PO 6\VWHP&ROOHFWFLRQV 6\VWHP:HE
6\VWHP1HW 6\VWHP7UKHDGLQJ H 6\VWHP6HFXULW\ VmR yWLPRV H[HPSORV
GH FULDomR GH QDPHVSDFHV FRP DJUXSDPHQWRV OyJLFRV (OHV HVWmR
ORFDOL]DGRV QD %DVH&ODVV/LEUDU\ TXH D 0LFURVRIW IRUQHFH FRPR SDUWH GR
1(7)UDPHZRUN
Pressione &WUO) para compilar e executar nossa aplicação. Você pode
utilizar o botão X na Barra de Ferramentas.
Observe a seguir o resultado da compilação. Você escreveu o seu primeiro
código usando o novo Clarion.NET .
'LFDVSDUDTXHPHVWiFRPHoDQGR
8PIUDPHZRUNRXDUFDERXoRpXPDHVWUXWXUDGHVXSRUWHGHILQLGDHPTXH
XP RXWUR SURMHWR GH VRIWZDUH SRGH VHU RUJDQL]DGR H GHVHQYROYLGR 8P
IUDPHZRUN SRGH LQFOXLU SURJUDPDV GH VXSRUWH ELEOLRWHFDV GH FyGLJR
OLQJXDJHQVGHVFULSWRXWURVVRIWZDUHVSDUDDMXGDUDGHVHQYROYHUHMXQWDU
GLIHUHQWHVFRPSRQHQWHVGHXPSURMHWRGHVRIWZDUH
)UDPHZRUNV VmR SURMHWDGRV FRP D LQWHQomR GH IDFLOLWDU R
GHVHQYROYLPHQWR GH VRIWZDUH KDELOLWDQGR GHVLJQHUV H SURJUDPDGRUHV D
JDVWDUHP PDLV WHPSR GHWHUPLQDQGR DV H[LJrQFLDV GR VRIWZDUH GR TXH
FRPGHWDOKHVGHEDL[RQtYHOGRVLVWHPD
$ORPXQGRFRPIRUPXOiULRV:LQGRZVZLQIRUPV
Vamos introduzir novas técnicas de programação, criando uma
aplicação Alo mundo, só que agora com janelas.
Na
IDE
selecione
1RYR , 6ROXomR.
À exemplo do nosso
programa anterior, a
caixa 1RYR 3URMHWR
será mostrada. Na
árvore que aparece do lado esquerdo clique sobre o nó &ODULRQ1HW e em
seguida selecione $SOLFDo}HV:LQGRZV.
3
3URJUDPDQGRHP&ODULRQ1(7
-XOLR&pVDU3HGURVR
No painel do lado direito, na área são apresentados quatro ícones
representativos de aplicações. Escolha $SOLFDomR:LQGRZV.
No campo 1RPH, na parte debaixo da tela, vamos definir um nome para o
nosso projeto. Achei
bastante “sugestivo” o
nome
:LQ$OR0XQGR,
indicando
ser
um
programa Alo Mundo, só
que usando Win Forms.
No campo localização,
deixe
como
está,
adotando
o
local
escolhido pelo Clarion,
mas é claro que, se você
quiser, pode mudar o
nome e a localização
para a pasta que bem
entender.
Em seguida, pressione o
botão &ULDU. Em pouco
tempo o Clarion irá gerar
um novo projeto com as
seguintes linhas de código:
Na minha geração aparece uma linha
${StandardHeader.Clarion#}
Eu retiro esta linha, por que me dá um erro de compilação.
Tive que retirar “isso” de todas as janelas geradas. Ainda preciso descobrir o
porque dessa linha.
As demais linhas, as que restam são as seguintes:
!~
~ Criado em Clarion
~ Autor: Julio César Pedroso
~ Em: 05 de março de 2008.
~!
352*5$0
1$0(63$&((WinAloMundo)
86,1*(System)
86,1*(System.Drawing)
86,1*(System.Windows.Forms)
&2'(
!Estas funções são usadas para habilitar os efeitos visuais
do Windows XP para a aplicação.
Application.(QDEOH9LVXDO6W\OHV()
Application.6HW&RPSDWLEOH7H[W5HQGHULQJ'HIDXOW(IDOVH)
Application.5XQ(1(:0DLQ)RUP())
Adicionei as linhas de comentário no início e fiz a tradução do comentário que
se refere aos estilos visuais do Windows XP.
Vamos comentar o código gerado, de acordo com a documentação da
Soft Velocity.
4
3URJUDPDQGRHP&ODULRQ1(7
-XOLR&pVDU3HGURVR
No nosso primeiro contato com o Clarion NET explicamos alguma coisa
sobre 1$0(63$&(. Após o NAMESPACE temos 86,1*.
86,1* referencia outros assemblies no .NET Framework. Pense nele como um
novo INCLUDE para as aplicações Clarion#
'LFDVSDUDTXHPHVWiFRPHoDQGR
2 XVLQJ DWHQGH D OLEHUDomR GH UHFXUVRV QmR JHUHQFLDGRV 2 REMHWR TXH
VHUi LQVWDQFLDGR QR FRPDQGR ³XVLQJ´ p OLEHUDGR DXWRPDWLFDPHQWH RX
VHMD p FKDPDGR R ³'LVSRVH´ GHVWH REMHWR GH IRUPD WRWDOPHQWH
DXWRPiWLFDGRFRQWUiULRYRFrWHULDTXHID]HULVVRPDQXDOPHQWH
1XQFDVHHVTXHoDGH6(035(XVDUR³XVLQJ´TXDQGRHVWLYHUWUDEDOKDQGR
FRPUHFXUVRVQmRJHUHQFLDGRV
No nosso pequeno exemplo, três namespaces do 6\VWHP são
referenciados.
O namespace 6\VWHP contém as classes fundamentais e as classes
básicas que definem os valores usados comumente e tipos de dados de
referencia, eventos e manipuladores de eventos, interfaces, atributos e
processamentos de exceção. Este namespace é o básico do básico para todas
as aplicações Clarion#. Note que os namespaces estão sendo chamados por
86,1*, após um namespace WinAloMundo, que é a nossa aplicação.
O namespace 6\VWHP'UDZLQJ dá acesso a livraria da Interface GDI+ e
as suas funcionalidades gráficas básicas.
3RU LVVR VH YRFr TXLVHU TXDOTXHU FRLVD YLVXDO HP VXD DSOLFDomR YRFr
SUHFLVDLQFOXLUHVWHQDPHVSDFHQRVHXSURJUDPD.
O último USING referencia o namespace 6\VWHP:LQGRZV)RUPV
Todos os elementos visuais e dados relacionados estão contidos neste
namespace, incluindo o suporte à controles, menus, data binding (atribuição de
um controle a um elemento de dado específico), e muito mais. Abaixo seguem
um link que será memorizado por você muito rapidamente.
ht t p: / / m sdn2.m icrosoft .com / en- us/ librar y/ syst em .aspx
Neste link está toda a documentação disponibilizada pela Microsoft para todos
os namespaces contidos em 6\VWHP.
'LFDVSDUDTXHPHVWiFRPHoDQGR
2'DWD%LQGLQJSHUPLWHOLJDUSURSULHGDGHVGHXPREMHWRDGLYHUVRVWLSRV
GH IRQWHV GH GDGRV SURYHQLHQWHV WDQWR GR SUySULR SURJUDPD FRPR QR
FDVRGHSURSULHGDGHVGHRXWURVREMHWRVTXDQWRGHGDGRVH[WHUQRVFRPR
DUTXLYRV;0/RXWDEHODVGHEDQFRVGHGDGRV
(VWD OLJDomRp IHLWDVHP TXHVHMD QHFHVViULD DFULDomR GHFyGLJR H SRGH
VHU XQLGLUHFLRQDO RQGH DSHQDV D SURSULHGDGH GR REMHWR p DOWHUDGD RX
ELGLUHFLRQDORQGHDDOWHUDomRGDSURSULHGDGHDOWHUDDIRQWHGHGDGRV
8P H[HPSOR GH 'DWD %LQGLQJ SRGH VHU D OLJDomR GD SURSULHGDGH 7H[W GH
XPD 7H[W%R[ D XP FDPSR GH XPD WDEHOD GH XP EDQFR GH GDGRV 2
FRQWH~GRGD7H[W%R[pLQLFLDOL]DGRFRPRFRQWH~GRGRFDPSRHTXDQGR
DOWHUDPRVRYDORUGD7H[W%R[HVWDDOWHUDomRpSURSDJDGDSDUDREDQFRGH
GDGRV
Voltando às sentenças do nosso código temos:
$SSOLFDWLRQ(QDEOH9LVXDO6W\OHV
A que método esta linha está fazendo referência.
5
3URJUDPDQGRHP&ODULRQ1(7
-XOLR&pVDU3HGURVR
Isto é muito interessante! Mova o ponteiro do seu mouse para a primeira linha
de código, abaixo da sentença CODE, e observará que aparecerá um balão
explicativo (tooltip).
Grande! Isto significa que a classe $SSOLFDWLRQ faz parte do namespace
6\VWHP:LQGRZV)RUPV
A ajuda do MSDN para a classe Application diz eu o propósito desta é
providenciar “métodos estáticos e propriedades para gerenciar uma aplicação,
tais como métodos para iniciar e parar uma aplicação, para processar as
mensagens de Janelas e as propriedades para recuperar informações sobre
uma aplicação”.
Se parar o mouse sobre EnableVisualStyles() será apresentado o tooltip
referente a este método da classe.
O próximo método, 6HW&RPSDWLEOH7H[W5HQGHULQJ'HIDXOW é usado para
configurar todos os controles visuais da nova livraria GDI+ . Este método foi
adicionado posteriormente, no release do .NET Framework, de maneira que é
possível que você não tenha um tooltip para este método.
Finalmente, vemos uma chamada para o método 5XQ.
$SSOLFDWLRQ5XQ1(:0DLQ)RUP
Quem é usuário Clarion e trabalha com o template ABC, deve lembrar
desta linha de código:
$EUHDMDQHODHLQLFLDR/RRSGR$FFHSW
*OREDO5HVSRQVH 7KLV:LQGRZ5XQ
O método Run do .NET também é usado iniciar um programa. De acordo
com o MSDN, o formato do método Run mostrado acima, inicia com o envio de
um laço “message” na thread corrente e faz com que o formulário especificado
(Form Principal) seja visível.
Quando criamos o nosso projeto, o gerenciador de modelos gerou
alguns arquivos, que vamos ver mais de perto agora. Mas, onde posso ver
estes arquivos?
Na IDE do Clarion# abra o
9LVXDOL]DGRU GH 3URMHWRV, se ainda não
estiver aberto, O 9LVXDOL]DGRU GH
3URMHWRV pode ser aberto rapidamente
pressionando <Control Alt L> ou
simplesmente selecionando 9LVXDOL]DU !
3URMHWRV a partir do menu da IDE. A
árvore de projetos, para a nossa solução
é mostrada, semelhante à figura ao lado.
O nível mais alto identifica o nome da
nossa Solução. Imagine uma solução
como uma coleção de projetos. Na
6
3URJUDPDQGRHP&ODULRQ1(7
-XOLR&pVDU3HGURVR
maioria das vezes, o número de projetos em uma Solução é 1 (um), mas em
projetos multi assemblies, este número pode mudar.
O próximo identificador na árvore de projetos é o nosso projeto
WinAloMundo.
Logo abaixo, nós vemos as Referências do Projeto, e vemos que o
Gerenciador de Modelos adicionou um certo número de referências do 6\VWHP
que são usadas por este projeto. Estas referências são códigos source em
Clarion# . Todos estes arquivos possuem a extensão .CLN (de Clarion .NET) e
novamente foram gerados pelo Gerenciador de Modelos (se é que posso
chamá-lo assim, a versão em inglês chama isto de “Quick Start”).
2DUTXLYR$VVHPEO\,QIRFOQ
Este arquivo é comum em todas as
plataformas
de
desenvolvimento.NET e inclui uma
grande variedade de atributos
assemblies, tais como: número da
versão, chaves de nomes de
arquivos fortes, títulos assemblies
e cultura. Embora você possa
colocar
esses
atributos
em
qualquer lugar do seu código fonte, o convencional, em programação .NET, é
colocar todos eles em um arquivo AssemblyInfo, de forma que você tenha um
lugar centralizado e específico para eles. O convencional também é HYLWDU
FRORFDUFyGLJRDGLFLRQDOno arquivo AssemblyInfo. Em quase todos os casos,
deixa-se este arquivo sozinho.
2DUTXLYR0DLQFOQ
Vimos acima este arquivo. Este é o module do programa Clarion#, e
contém apenas alguns poucos itens/comandos, necessários para iniciar a
aplicação.
2DUTXLYR0DLQ)RUPFOQ
O objetivo deste capítulo é justamente dar uma introdução aos
Winforms. Este arquivo também é automaticamente gerado pelo Gerenciador
de Modelos (quick start), Da mesma forma que o arquivo AssemblyInfo,
constitui um padrão na indústria de desenvolvimento .NET, é usado para
armazenar a janela principal de sua aplicação.
Junto com o source MainForm é gerado um arquivo de Designer
(0DLQ)RUP'HVLJQHU). Nele são armazenados todos os componentes de janela
e as classes que são automaticamente geradas pela pelo :LQ)RUP'HVLJQHU.
Da mesma forma que no arquivo AssemblyInfo, evite colocar códigos
adicionais neste arquivo, mantendo o “sozinho”, na medida do possível.
Dadas estas explicações, vamos completar o nosso “Programa”.
$EULQGRDMDQHOD0DLQ)RUP
Na janela do 9LVXDOL]DGRU GH 3URMHWRV, faça um duplo clique sobre a
entrada 0DLQ)RUPFOQ, na árvore de projetos. Por default, na IDE, a abertura do
7
3URJUDPDQGRHP&ODULRQ1(7
-XOLR&pVDU3HGURVR
source deste arquivo, automaticamente inicia o )RUPDWDGRU GH -DQHODV na
realidade muito mais que isso, trata-se de um ³'HVHQKDGRUGH)RUPXOiULRV´.
A qualquer momento você pode alternar entre o modo source e o modo
desenho, clicando nas tabs que ficam do lado inferior
esquerdo do módulo., Veja na figura abaixo a janela com
o form designer ativo, mostrando o nosso formulário
principal, onde poderemos adicionar alguns componentes.
$GLFLRQDQGRXPERWmRQDMDQHOD
Bem, acho que a maioria dos programadores Clarion sabe colocar um
botão em uma janela. Mas tratamos aqui de um
ambiente novo, o Clarion#. Eu prefiro aprender
desde a base, começando pelas coisas simples até
chegar às mais complexas.
Entretanto, como era de se esperar, colocar
um botão em um formulário do Clarion# é muito
simples.
Inicialmente vamos ativar uma caixa de
ferramentas (Toolbox) como janela flutuante, no
lado esquerdo da nossa área de desenho. A partir
do menu, escolha 9LVXDOL]DU!7RROER[. Quem já
trabalhou com o Visual Stúdio 2005 já percebeu
que “tem tudo a ver”. O Atalho para chamar esta
caixa de ferramentas é a seqüência <Control Alt
X>. A caixa de ferramentas é divida em seções. Na
seção :LQGRZV )RUPV, escolha o controle Button,
clicando sobre ele com o mouse. Em seguida
arraste o botão para a janela do formulário, posicionando-o no lugar desejado e
liberando o ponteiro do mouse. O botão se fixará no lugar desejado. Uma vez
8
3URJUDPDQGRHP&ODULRQ1(7
-XOLR&pVDU3HGURVR
que o botão esteja posicionado no lugar desejado, você pode redimensioná-lo
arrastando o mouse sobre os pontinhos que ficam em volta do
botão (alças de redimensionamento). Você também pode mudar
o botão de posição clicando com o botão esquerdo do mouse
sobre ele, e arrastando para o lugar desejado.
Para alterar qualquer uma das propriedades do botão, clique sobre ele para
que fique selecionado e pressione a tecla <Control F4>. Naturalmente, como
na grande maioria dos ambientes de desenvolvimento Windows, se você clicar
com o botão direito do mouse sobre o botão, a caixa de propriedades também
é apresentada.
Como você pode ver, existem muitas propriedades associadas com o
botão, mas nesta altura, a que queremos é aquela que muda o texto do botão.
Localize a propriedade 7H[W e substitua o texto “button 1” pelo texto “Dar um
alo e sair”. Sei que você está “doido”
para escrever algum código, afinal, até
agora as coisas foram todas na base do
“automático”, mas, você é programador
e seu negócio é codificar. Então vamos lá! Vamos adicionar alguma
funcionalidade ao botão via código.
Faça um duplo clique com o botão esquerdo do mouse sobre o botão.
Automaticamente será gerado um evento 0DLQ)RUP%XWWRQB&OLFN. É claro
que agora estamos trabalhando com um objeto button, com eventos,
propriedades e métodos. Se o seu objetivo é trabalhar com o Clarion#, vá se
acostumando com isso. Mais ou menos como se fosse um embed das versões
anteriores do Clarion.
Na realidade o nosso código vai exibir uma mensagem na tela, e em
seguida o formulário será fechado. Como a nossa “aplicação” possui apenas
um formulário, significa que a aplicação será fechada.
9
3URJUDPDQGRHP&ODULRQ1(7
-XOLR&pVDU3HGURVR
Vamos ao nosso código.
Como a nossa “aplicação” é uma aplicação Win32, vamos usar o
comando Message para apresentar “alguma coisa na tela”.
Logo abaixo do &RGH, entre as seguintes linhas de programação:
0HVVDJHµ$OR0XQGRGHVGHXPD-DQHOD&ODULRQ¶
6(/)&ORVH
Mais nada. NÃO TEM PONTO, NEM PONTO E VÍRGULA, NEM END.
Só isso.
Observou a figura?
Mas assim fica muito fácil!
Fica sim. Finalmente o Clarion tem esse recurso nativamente. Fazia
muito tempo que eu queria este recurso no meu editor de códigos. Eu até tinha,
mas não tinha a performance e a praticidade do que é apresentado pelo
Clarion#.
Elogios à parte, veja a imagem do código final.
Observou a numeração das linhas, a organização estruturada do
código? Emprestado do Sharp Develop, mas o que interessa é que está aí. Na
verdade a Soft Velocity licenciou o Sharp Develop para adicionar ao código do
Clarion#.
A sentença Self.Close() , é um método construtor da classe
6\VWHP:LQGRZV)RUPV)RUP e uma
vez que o nosso form 0DLQ)RUP é
derivado dela, isso é tudo o que
precisamos para fechar a janela.
Pessoal que é fã do Legacy.
Vamos aprender as Classes ABC. Vai
ajudar muito!
Na figura ao lado, nossa aplicação
depois que foi compilada e executada.
Para compilar, clique em %XLOG, no
botão X ou pressione a seqüência
<Control F5>. Quando o usuário clica no botão 2. a
janela é fechada, como qualquer outra
janela de mensagem.
10
3URJUDPDQGRHP&ODULRQ1(7
([WHQV}HVGRV$UTXLYRV&ODULRQ1(7
-XOLR&pVDU3HGURVR
Apresentamos um pequeno manual de referência sobre as extensões
dos arquivos do Clarion .NET.
$UTXLYRVFRPH[WHQVmRFOQ
São os arquivos que contém os fontes do código de qualquer aplicação
Clarion#. Algo como os arquivos .clw do Clarion 16 bit.
$UTXLYRVFRPDH[WHQVmRGHVLJQHUFOQ
São arquivos associados aos arquivos .cln que contém uma janela do
tipo WinForm ou uma janela do tipo CompactForm (para aplicações PDA, smart
phone, pocket pc, tablet pc, etc...).
Qualquer controle que você adiciona ao seu form é GHFODUDGR para este
arquivo pelo 'HVLJQHU. Por padrão você não deve editar este arquivo, pois
modificações ou inclusões mal formadas podem impedir que você possa
recarregar este arquivo para o 'HVLJQHU. Resumindo, se você mexer neste
arquivo e fizer o que chamamos de “barbeiragem”, já era. Vai ter que refazer o
arquivo pelo 'HVLJQHU.
$UTXLYRVFRPDH[WHQVmRUHV[
Traduzimos como um arquivo de recursos da aplicação. Quando você
adiciona imagens, ícones, semelhantes, o 'HVLJQHU cria este arquivo para
armazená-las.
É natural que possamos editar estes arquivos e “adicionar recursos” a
ele como parte da nossa estratégia de desenvolvimento.
Quando executamos um duplo clique sobre um arquivo com a extensão
.resx será aberto um (GLWRU GH 5HFXUVRV, para que você possa editar um
arquivo existente, adicionar novos recursos, alterar os existentes, ou excluir
recursos.
$UTXLYRVFRPDH[WHQVmRFQSURM
Identifica os arquivos de projeto das aplicações Clarion .NET.
$UTXLYRVFRPDH[WHQVmRVOQ
Identifica um arquivo de soluções. Em Clarion.NET uma solução pode
conter um ou mais projetos.
11