 |
| | | |
Tutorial
Primeiros Passos com Kylix (continuação)
Aprofundando um pouco na programação
Kylix, mostramos como combinar os elementos fornecidos por esta ferramenta,
de modo a criar programas funcionais com um mínimo de esforço de programação
Embora à primeira vista a programação
em Kylix pare-ça muito simples, esta aparência é devida ao conjunto de
componentes incorporado a ele. Estes componentes encapsulam tanta
funcionalidade que, às vezes, não é necessário codificar nada: tudo já está
embutido nos componentes usados - a simples configuração de propriedades é
suficiente para elaborar um programa funcional.
Internamente, os componentes escondem
uma complexidade muito grande. A CLX (pronuncia-se CLICKS), biblioteca de
componentes multiplataformas, é baseada na biblioteca de componentes Qt. Os
projetistas da Borland a escreveram de maneira que ficasse semelhante à
VCL, a biblioteca de componentes do Delphi. Além disso, qualquer um pode
expandir a biblioteca de componentes, escrevendo os próprios, usando o
Kylix. Isso é tão comum que existem milhares de componentes disponíveis
para o Delphi (já começam a aparecer componentes para o Kylix, é só uma
questão de tempo), em grande parte gratuitos e com código aberto.
Na realidade, o que queremos dizer é
que a programação em Kylix é simples porque por trás dela existe uma
biblioteca de componentes que permite reutilizar o código com pouco esforço.
Para exemplificar o poder dos
componentes do Kylix, vamos criar um relógio digital. Você deve iniciar uma
nova aplicação, usando a opção do menu File->New Application. Isto fecha
o projeto atual e abre um novo, contendo uma Form e sua unit associada. Se
você usar a tecla F12 para alternar para o editor de código, poderá ver
mais uma característica do Kylix: a orientação a objetos. O Kylix, e seu
irmão mais velho, o Delphi, são orientados a objetos desde a primeira
versão, implementando os recursos de hereditariedade, polimorfismo e
encapsulamento. As linhas:
type
TForm1 = class(TForm)
indicam o seguinte: estamos querendo
definir um novo tipo, com nome TForm1, derivado da classe TForm. Devido à
hereditariedade, não é necessário reprogramar o comportamento da classe
TForm básica: a classe TForm1 herda as propriedades da classe pai e permite
que implementemos novas, personalizando-as para nosso uso.
Pressionando F12 novamente, voltamos
para a Form e podemos continuar nosso programa, inserindo um componente
LCDNumber, que está na guia Additional da paleta de componentes (Figura 1).
Esta operação é feita com um clique no ícone do componente, na paleta e, em
seguida, um clique na Form. O novo componente é posi-cionado onde o botão
do mouse foi clicado.
O componente LCDNumber é semelhante aos
visores digitais, com números formados por oito leds. No Object Inspector,
você pode configurar as propriedades dos componentes, dando o formato que
deseja. Quando você altera alguma propriedade, a representação visual se
altera simultaneamente. Por exemplo, alterando a propriedade Value,
digitando o número 1234 faz que este número seja mostrado no visor (Figura
2). Podemos também alterar a aparência dos dígitos, mudando a propriedade
SegmentStyle. Neste caso, não há o que digitar: você deve selecionar uma
das opções disponíveis na combobox em frente do nome da propriedade. Cada
propriedade tem uma característica diferente de edição e um editor próprio:
em algumas, deve-se digitar algo, em outras, as opções são selecionadas
numa com-bobox, e outras abrem caixas de diálogo para seleção das
informações.
Alteraremos duas propriedades neste
componente:
• Digits, que indica o número de
dígitos que serão mostrados, para 8 (dois para as horas, dois para os
minutos, dois para os segundos e dois para os separadores de horas e de
minutos).
• Align, que determina o
alinhamento do componente em relação ao componente que o contém, no caso a
Form. Esta propriedade deve ser configurada para alClient e, desta maneira,
o visor toma todo o espaço disponível da Form. Quando você aumenta ou
diminui a Form, o componente aumenta ou diminui de tamanho com ela.
Para seu espanto (ou não, afinal isto é
o que toda ferramenta de desenvolvimento deveria oferecer), nosso programa
está praticamente terminado. Ou, pelo, menos, a parte visual está
finalizada. Você deve ter algo como a Figura 2. Como queremos montar um
relógio, devemos ter algo para alimentar constantemente a hora.
Os desenvolvedores acostumados à
criação convencional de programas irão dizer: “isto é muito fácil, basta
criar um novo processo, que execute em segundo plano e, a cada segundo,
alimente o relógio”. Sem dúvida, esta é uma das soluções possíveis, mas não
podemos nos esquecer de que a programação em modo gráfico permite que o
programa seja interrompido quando ocorre algum evento.
O Kylix possui um componente chamado
TTimer, na guia Additional, que é semelhante a um alarme: programa-se o
intervalo em que se quer ser despertado e, quando o tempo deste intervalo
se esgota, o evento OnTimer é disparado. É justamente isto que queremos:
programamos seu intervalo para 1 segundo e, a cada segundo, o evento será
ativado e poderemos atualizar a hora, no visor.
Na guia System selecione o componente
TTimer, e o coloque na Form. É o que chamamos de componente não-visual.
Embora o seu ícone seja mostrado em tempo de projeto, quando o programa for
executado, ele desaparecerá. A sua propriedade Interval já deve estar
configurada para 1000, o valor que queremos: como o intervalo de despertar
é indicado em milissegundos, este valor indica 1 segundo. Vá para a guia
Events, no Object Inspector e dê um clique duplo na frente do evento
OnTimer. O Kylix cria um manipulador para o evento OnTimer e abre o editor
de código no local correto, onde podemos digitar o seguinte (digitar apenas
o que está em negrito, o restante é preenchido automaticamente pelo Kylix):
procedure TForm1.Timer1Timer(Sender:
TObject);
begin
LCDNumber1.Value := TimeToStr(Time);
end;
Com isto, atribuímos a hora atual,
convertida para uma string, ao valor do componente LCDNumber. Ao fazer uma
operação simples como essa, o componente se encarrega de mudar os dígitos
no visor e apresentar a nova hora.
O programa está pronto. Salve-o e
execute-o. Você deverá obter algo como mostrado na Figura 3. Note que, à
medida que aumenta ou diminui a janela, o relógio também aumenta ou diminui
simultaneamente.
Agora, vamos ver um pouco mais da
funcionalidade embutida nos componentes do Kylix, criando um programa para
visualizar imagens. Crie um novo projeto, com a opção de menu File->New
Application. Abre-se um novo projeto com uma nova Form. Digite na
propriedade Caption, no Object Inspector, o título que será mostrado na
janela do nosso programa: Visualizador de Imagens RdL. À medida que
você vai digitando, o título na janela modifica-se simultaneamente.
Insira um componente TImage, da guia
Additional. Este componente permite visualizar imagens gráficas na janela.
Adicione também um componente TOpenDialog, da guia Dialogs. Este componente
encapsula a caixa de diálogo de abertura de arquivo. Com seu método
Execute, chamamos a caixa de diálogo e, na propriedade FileName, podemos
recuperar o nome do arquivo selecionado.
Coloque um componente TMainMenu, da
guia Standard, na Form. Este é outro componente não-visual, que representa
um menu principal da janela. Ao dar um clique duplo sobre ele, abre-se o
editor de menus, mostrado na Figura 4.
Aí você deve colocar as opções do menu.
No menu principal, digite a palavra &Arquivo. Ao pressionar a
tecla Enter, a nova opção é mostrada na janela, com o A sublinhado. O &
comercial indica a tecla de atalho para ati-vação do menu. Abaixo deste
menu principal, digite a opção &Abre e, em seguida, coloque um se-parador,
digitando apenas o hífen (-). Finalmente, digite a opção Sai&r.
Você deve estar com uma janela como a da Figura 5.
Dê um clique duplo na opção Abre, para
criar um manipulador para o evento OnClick, ativado quando esta opção de
menu é clicada, digitando o seguinte:
procedure TForm1.Abre1Click(Sender:
TObject);
begin
// configura o filtro da caixa de
diálogo para
// os tipos de arquivos gráficos
disponíveis
OpenDialog1.Filter :=
GraphicFilter(TGraphic);
if OpenDialog1.Execute then
// se o usuário clicou Ok, carrega
o arquivo
Image1.Picture.LoadFromFile(OpenDialog1.FileName);
end;
Este código atribui o retorno da função
GraphicFilter ao filtro da caixa de diálogo, mostrado na combobox inferior,
onde são mostradas as extensões dos arquivos. Em seguida, chama o método
Execute para abrir a caixa de diálogo. Se o usuário clicar Ok, o método
retornará True e o arquivo é carregado, usando o método LoadFromFile.
Dê um clique duplo na opção Sair, no
editor de menus, para editar o manipulador que será executado quando esta
opção for selecionada, digitando o seguinte, no editor de código:
procedure TForm1.Sair1Click(Sender:
TObject);
begin
Close;
end;
O programa está pronto. alve-o e
execute-o. A Figura 6 mostra o programa com uma imagem carregada.
Como você pôde ver, os componentes do
Kylix escondem muita funcionalidade: com uma linha, você mostra uma caixa
de diálogo, que seleciona o arquivo a ser aberto e, com outra linha,
carrega e mostra este arquivo, que pode ter qualquer um dos diversos
formatos gráficos suportados. A partir do momento em que você passa a
combinar a facilidade de utilização dos componentes com o seu código, passa
também a poder desenvolver excelentes aplicativos, robustos e desenvolvidos
em pouco tempo.
Notas:
• Você pode criar um programa em Kylix
e recompilá-lo no Delphi 6 sem alterações. Uma aplicação CLX do Delphi 6
também pode ser recompilada no Kylix sem alterações.
• Caso os componentes do Kylix não
façam exatamente o que você deseja, você pode criar seus próprios,
adicionando-os à paleta de componentes.
• Quando você seleciona um evento no
Object Inspector e dá um clique duplo, ele cria um novo manipulador para
esse evento.
• O manipulador tem o nome do
componente, seguido do nome de evento, sem o On, ex: evento OnTimer do
componente Timer1, o nome do evento é Timer1Timer.
• O manipulador do evento é um método
da Form.
• O Kylix cria uma declaração deste
novo método na declaração da Form e um corpo, na seção implementation, para
que você possa digitar o código que será executado quando o evento for
disparado.
Legendas:
Figura 2 - Relógio digital em tempo de
projeto
Figura 1 Guia Additional da paleta de
componentes
Figura 3 - Relógio digital em
execução Visualizando Imagens
Figura 4 - Editor de menus
Figura 5 - Editor de menus completo
Figura 6 - Visualizador de imagens em
tempo de execução
• Você não precisa criar manipuladores
para todos os eventos de um componente, só aqueles que deseja fazer uma
operação especial.
| | | |
|
|
|
|
