delphi passo a passo
TRANSCRIPT
Programação Delphi
Passo a passo
Autor: Tecgº Miguel Andrade
Revisão: Tecgº Rafael Andrade
Kimidia® 2007
www.miguelandrade.co.nr
ATENÇÃO!
Se pagou por este livro foi roubado! Download gratu ito em:
www.miguelandrade.co.nr
Indíce
História: ........................................................................................................................... 4 Descrição: ....................................................................................................................... 4 Aplicabilidades: .............................................................................................................. 5 Requerimentos do sistema: ......................................................................................... 5 Instalando o Delphi gratuito(Turbo Delphi Explorer for Win32 development):..... 6 Inicializando o Turbo Delphi pela primeira vez: ........................................................ 9 Conhecendo o Turbo Delphi: ..................................................................................... 10 Primeio programa: ....................................................................................................... 13 Estrutura do Project Source “Codigo fonte do projeto que gerencia as units e formulários”. .................................................................................................................. 18 Estrutura da Unit .......................................................................................................... 19 Fundamentos do Object Pascal: ............................................................................... 20 Variáveis:....................................................................................................................... 20 Constantes:................................................................................................................... 22 Arrays: ........................................................................................................................... 22 Records: ........................................................................................................................ 24 Pointers: ........................................................................................................................ 24 Operadores: .................................................................................................................. 25 With-do: ......................................................................................................................... 27 Procedure:..................................................................................................................... 27 Function:........................................................................................................................ 28 Comentários ................................................................................................................. 29 Funções de conversão(mais utilizadas):.................................................................. 30 Instruções condicionais: ............................................................................................. 32 Instruções de laço:....................................................................................................... 35 Classes e objetos: ....................................................................................................... 39 Criando um programa simples (Bloco de notas): ...................................................41 Eventos de uma aplicação: ........................................................................................ 57 StringList: ...................................................................................................................... 64 Criando um Media Player Simples:........................................................................... 65 Utilizando Imagens: ..................................................................................................... 67 Utilizando o XP Manifest: ........................................................................................... 68 Exemplo Simples de Cliente/Servidor: ..................................................................... 69
História:
Os desenvolvedores do compilador buscavam uma ferramenta que fosse capaz
de acessar o banco de dados Oracle, o nome delphi foi inspirado na cidade de
Delfos, pois nessa cidade era o único lugar onde se podia consultar o oráculo
de Delfos, e então surgiu o equívoco, "a única maneira de acessar o oráculo é
usando o Delphi".
Descrição:
Turbo Delphi é uma IDE integrada de desenvolvimento desenvolvida pela
Borland, esta versão é voltada para estudantes, profissionais individuais e para
aqueles que programam por hobby, ele utiliza a Linguagem Delphi, que é um
“dialeto” do Pascal.
Ele possui duas versões disponíveis, uma que gera aplicativos nativos para
aplicações Win32(Turbo Delphi for Windows), e uma que gera códigos em
bytes para o Framework .Net CLR. Cada versão vem em duas edições, a
edição Free Explorer e a edição Professional. A Edição Profissional permite
extensões e customizações para a IDE.
Neste livro apenas a versão “Free Explorer” será abordada.
Aplicabilidades:
O Delphi é muito utilizado no desenvolvimento de aplicações desktop,
aplicações multicamadas e cliente/servidor, compatível com os bancos de
dados mais conhecidos do mercado. Ele pode ser usado para desenvolver
aplicações de linguagem de alto nível como de baixo nível. Um exemplo de
software conhecido que foi desenvolvido em Delphi é o Skype.
Requerimentos do sistema:
• Intel Pentium III/M 1.4 GHz, ou Pentium IV 1.4 GHz mínimo
(Intel Pentium III/M 1.4 GHz+, ou Pentium IV 2GHz+ recomendado)
• Microsoft Windows Server™ 2003 (SP1)
• Microsoft Windows XP Professional (SP2)
• Microsoft Windows XP Professional (SP1)
• Windows 2000 Professional (SP4)
• Windows 2000 Server (SP4)
• 512 MB RAM (1 GB+ recomendado)
• 600 MB de espaço disponível no HD para o Delphi
• 750 MB de espaço disponível no HD para pré-requisitos (incluindo
Microsoft. NET Framework e SDK)
• SVGA ou monitor de alta resolução (XGA recomendado)
• Mouse ou outro dispositivo apontador
Instalando o Delphi gratuito(Turbo Delphi Explorer for Win32
development):
O site http://turboexplorer.com/downloads oferece tudo que é necessário para a
instalação correta do Turbo Delphi.
Pré-requisitos (O que você precisa instalar):
Microsoft.NET 1.1 runtime and SDK,
J# run-time
InternetExplorer 6.01
MSXML
Depois de instalados os pré-requisitos (~230MB) você pode fazer download e
instalar o Turbo Delphi.
Dê um clique duplo sobre o arquivo que você fez download, em seguida
escolha a pasta de destino dos arquivos de instalação.
Depois dê um clique duplo no arquivo Install.exe e logo em seguida clique em
Install Borland Turbo Delphi.
Activation File(Arquivo de ativação do Turbo Delphi ):
Para que possamos rodar o Turbo Delphi temos que adquirir um Activation File
no site da CodeGear para o produto.
http://www.codegear.com/downloads/free/turbo
OBS: A Borland criou a CodeGear para ser uma subsidiária que será
responável pelo Delphi e outros produtos.
Depois faça login, caso não possua um nome de usuário registre-se
gratuitamente.
Depois disso você receberá o “Activation File” por e-mail.
Salve o arquivo de texto em anexo regXXX.txt na sua pasta raiz do usuário
Windows 95/98 (single-user): C:\Windows
Windows 95/98 (multi-user): C:\Windows\Profiles\<username>
Windows NT: C:\WINNT\Profiles\<username>
Windows 2000/XP: C:\Documents and Settings\<username>
Inicializando o Turbo Delphi pela primeira vez:
Splash Screen(Tela de apresentação) do Turbo Delphi:
Welcome Page:
Você pode usá-la para criar um novo projeto, abrir um projeto existente, entrar
na ajuda, etc.
Conhecendo o Turbo Delphi:
1. Menus e Barra de ferramentas (Toolbars)
2. Editor de código (Code Editor), Form Designer, Welcome Page
3. Seção de estrutura (Structure View )
4. Inspetor de objetos (Object Inspector)
5. Organizador de projeto (Project Manager), Model View, Data Explorer
6. Paleta de ferramentas (Tool Palette)
Structure section
Com esta “seção de estrutura” você pode selecionar hierarquicamente os
componentes e controles.
Object Inspector
O “Inspetor de objetos” serve para selecionar os componentes e mudar as suas
propriedades.
Project Manager
O “Gerenciador de projeto” você pode gerenciar os arquivos do projeto, você
pode adicionar arquivos, remover, renomear.
Tool Palete
A “Palheta de Ferramentas” serve para você selecionar os componentes que
irão ser inseridos no formulário de sua aplicação.
Primeiro programa:
Objetivo: Criar uma aplicação Win32 que possui um f ormulário com um
botão, ao clicarmos no botão receberemos uma simple s mensagem.
Depois de inicializar o Turbo Delphi clique no menu File/New/VCL Forms
Application – Delphi for Win32.
O Form1 é o formulário de nossa aplicação, clique no Button que esta
localizado na Tool Palete na primeira guia “Standard” e depois clique no
formulário, assim você notará que um botão foi criado em nosso formulário.
OBS: Você pode redimensionar os componentes visuais que insere no
formulário segurando a tecla “Shift” do teclado e depois usando as teclas de
posição “Esquerda, direita, para cima e para baixo”. Para mover os
componentes com precisão segure a tecla “Ctrl” e depois as teclas de posição
citadas acima.
Para que possamos ir para a nosso “code viewer” dê um clique duplo sobre o
botão, você poderia fazer o mesmo indo no Object Inspector e clicando em
“Events” e selecionando o evento OnClick.
Depois de estarmos com o code editor ativado vamos inserir nossa primeira
linha de código entre os blocos begin e end do evento do botão. Veja:
Com o simples comando ShowMessage(‘Olá mundo!’);
Para ver o programa em funcionamento pressione a tecla F9 do seu teclado e
solte, ou ainda se preferir clique no menu principal Run/Run.
Teste clicando no botão e veja o resultado, para retornar ao modo de edição
feche o programa clicando no “X” do nosso formulário.
Para salvar o código fonte do nosso primeiro programa clique no menu
File/Save All.
Selecione a pasta em que deseja armazenar o código fonte e depois clique em
Salvar.
Na pasta em que você selecionou para salvar os arquivos vamos destacar os
principais:
.PAS Arquivo Pascal: o código-fonte de uma unidade Pascal, ou uma unidade
relacionada a um formulário ou uma unidade independente.
.DPR Arquivo Delphi Project. (Contém código-fonte em Pascal).
.DFM Delphi Form File: um arquivo binário (na versão 5 pode ser convertido
para texto) com a descrição das propriedades de um formulário e dos
componentes que ele contém.
.DCU Delphi Compiled Unit: o resultado da compilação de um arquivo Pascal.
.CFG Arquivo de configuração com opções de projeto. Semelhante aos
arquivos DOF.
.DOF Delphi Option File: um arquivo de texto com as configurações atuais para
as opções de projeto.
.DSK Arquivo de Desktop: contém informações sobre a posição das janelas do
Delphi, os arquivos abertos no editor e outros ajustes da área de trabalho.
Estrutura do Project Source “Codigo fonte do projet o que
gerencia as units e formulários”:
Quando você salva o seu projeto em uma pasta é gerado o “Project Source”,
ele é responsável pelo gerenciamento do fonte, units, forms, etc.
Vamos ver sua estrutura:
program Project1; -> A primeira declaração do Project Source é o nome
interno do aplicativo.
Uses -> Na cláusula uses fica a lista de units usadas.
Forms,
Unit1 in 'Unit1.pas' {Form1};
{$R *.res} -> Arquivo que é salvo como o nome interno do aplicativo + extensão
.res, este arquivo armazena informações binárias, resources, etc.
begin
Application.Initialize; -> Procedure que chama a inicialização da aplicação.
Application.CreateForm(TForm1, Form1); -> Procedure que chama a criação
do formulário na memória.
Application.Run; -> Procedure que chama execução da aplicação.
end.
Estrutura da Unit:
Unit ela é responsável pelo código fonte de seu formulário, vamos ver a sua
estrutura.
unit Unit1; -> A primeira declaração de uma unit é seu identificador, que é igual
ao nome do arquivo.
interface -> Seção interface, onde ficam declarações que podem ser usadas
por outras Units.
Uses -> Na cláusula uses fica a Lista de Units usadas.
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs;
Type -> Na cláusula type fica a definição de tipos, aqui temos a declaração da
classe do Form.
TForm1 = class (TForm)
private
{ Private declarations }
public
{ Public declarations }
end;
var -> Na cláusula var são declaradas as variáveis, aqui temos a declaração da
instância do Form.
Form1: TForm1;
Implementation -> Na seção implementation ficam as definições dos métodos.
{$R *.dfm}
end. -> Toda Unit termina com um end a partir de onde qualquer texto é
ignorado.
Fundamentos do Object Pascal:
Vamos comentar alguns dos conceitos básicos de programação orientada a
objetos:
Variáveis:
O tipo de uma variável determina que tipo de valor a mesma poderá armazenar
e receber, as variáveis devem ser declaradas antes de usada para realizarmos
a declaração utilzamos a palavra var, esta declaração pode ser feita em uma
unit”unidade”, procedure, function ou uma variável global.
Tipos de variáveis(mais usadas):
String: Pode armazenar qualquer palavra ou parágrafo com ou sem espaço.
Integer: Valor inteiro que varie entre -2.147.483.647 até 2.147.483.647.
Real: Igual ao tipo Inteiro, mas pode usar separador decimal e notação
científica.
Char: Um único caractere ASCII.
PChar: String terminada em nulo (#0), usada geralmente nas funções da API
do Windows
Boolean: Representa dois valores que podem ser: true (verdadeiro) ou false
(falso).
OBS: Para inserirmos uma valor em uma variável utilizamos o := “dois pontos
igual”.
Olhe:
A variável string recebe o valor “palavra”.
Constantes:
São declaradas na seção const, podem ser usadas como variáveis, mas não
podem ser alteradas, na declaração de uma constante o tipo não é
especificado.
Veja:
Arrays:
Array é uma forma de se utilizar variáveis com múltiplos valores assim como
uma tabela.
Veja:
Pa inserirmos valores nesta array usamos o seu índice veja:
teste[0] := ‘palavra1’;
teste[1] := ‘palavra2’;
OBS: Caso necessitarmos utilizar uma array com um índice variado podemos
utilizar uma array dinâmica.
Como na screenshot acima temos a variável “teste3” que não foi especificado o
seu índice de valores, para setarmos o valor temos que usar o comando
SetLength. Veja:
Var
teste3: array of string;
begin
SetLength(teste3, contador+1);//lembrando que o valor “contador” que foi
utilizado neste caso é apenas para armazenar o novo índice da array.
end;
Records:
O record é um recurso em que se pode utilizar vários valores com diferentes
tipos de dados.
Pointers:
Pointer é um tipo de dado que aponta um endereço de memória.
Veja:
A variável “valor1” recebe o número inteiro 2 a variável ponteiro recebe o
endereço de memória da variável “valor1”, depois a variável “valor2” recebe o
endereço de memória do ponteiro, logo a variável “valor2” possui agora o
mesmo valor que a variável “valor1”.
Operadores:
Os operadores são usados em expressões, Veja na lista:
Operadores Unários
@ Endereço
not Não booleano ou bit voltado para não
Operadores Multiplicativos e de direção de Bit
* Multiplicação ou interseção de conjuntos
/ Divisão de Real
div Divisão de Inteiro
mod Resto de divisão de Inteiros
as TypeCast seguro quanto ao tipo (RTTI)
and E booleano ou bit voltado para e
shl Deslocamento de bits à esquerda
shr Deslocamento de bits à direita
Operadores Aditivos
+ Adição ou união de conjuntos
- Subtração ou diferença de conjuntos
or Ou booleano ou bit voltado para ou
xor Ou exclusivo booleano ou bit voltado para ou exclusivo
Operadores Relacionais
= Igual
<> Diferente
< Menor
> Maoir
<= Menor ou igual
>= Maior ou igual
in Pertinência a conjuntos
is Compatibilidade de tipos (RTTI)
With-do:
O comando with serve para que seja simplificado a edição de um componente
por exemplo.
Veja:
No caso a edição das propriedades fica mais fácil com esse comando, não é
necessário reescrever o nome do componente várias vezes, isto simplifica e
agiliza a programação em alguns casos.
Procedure:
Uma procedure nada mais é que um procedimento que é executado
possuindo parâmetros ou não. Você pode declarar uma procedure de várias
formas. Com uma procedure você agiliza e “perde” menos tempo, você pode
escreve-la uma vez e usá-la várias vezes.
Veja um exemplo muit simples de procedure :
Veja um exemplo ou pouco mais complexo:
Neste caso temos um parâmetro na procedure teste, uma variável inteira que
recebe um pequeno cálculo no momento de execução.
Function:
Uma função ao contrário da procedure necessita sempre retornar um valor.
Esse valor pode ser dos mais diversos tipos, string, integer, boolean, etc.
Veja o exemplo:
Neste exemplo a variável resultado recebe o resultado da função.
Comentários
Existem 3 estilos de comentário no Delphi, como mostrado abaixo.
(* Comentário do Pascal Padrão *)
{ Comentário do Turbo Pascal }
// Comentário de linha do C++
Cuidado com as diretivas de compilação, pois elas são delimitadas por chaves
e podem ser confundidas com comentários. A diretiva de compilação mostrada
abaixo é incluída em todas as Units de Forms.
{$R*.DFM}
Funções de conversão(mais utilizadas):
As funções de conversão são utilizadas quando precisamos converter valores.
StrToInt: Converte um string em um inteiro, levantando uma exceção (erro)
caso o string não represente um inteiro válido.
Ex:
Veja a screenshot:
Neste caso a variável “a” recebe o valor string que está contido no Edit1,
depois a variável “b” recebe o valor que é retornado da rotina de conversão
StrToInt . No caso a variável ‘b” agora armazena um valor inteiro que foi
convertido do Edit1.
IntToStr: Converte um número em um string.
Trunc: Converte um valor real em um inteiro, truncando a parte decimal.
Round: Converte um real em um inteiro, arredondando a parte decimal.
Chr: Converte um número ordinal em um caractere ANSI.
StrToFolat: Converte um string e, um valor de ponto flutuante.
FloatToStr: Converte um valor de ponto flutuante para sua representação
string usando formatação padrão.
Instruções condicionais:
Instruções If:
Esta instrução condicional é bem básica e muita utilizada
Ex:
If condição then
Bloco de instrução
Como foi mostrado na screenshot acima if “se” a propriedade Text do Edit1 for
igual a string ‘Edit1’ then”então”
OBS: Se você não colocar o begin e o end quando for usar a instrução if e
then ela só terá validade para as três primeiras linhas, mas se utilizar o begin
e o end poderá usar uma grande quantidade de linhas de comando.
Uma outra forma de utilizar a instrução condicional if e then é usando o else
como o próprio nome já diz “se” condição for igual “então” faça isso “senão”
faça aquilo.
Observe a screenshot:
OBS: Lembrando que devemos não adicionar o; “ponto e vírgula” no ultimo
end antes do else.
Instrução Case:
Se necessitarmos de uma grande quantidade de verificações é mais prático
usar a instrução case .
Observe a screenshot:
A Instrução case nesse caso é muito mais prática, caso necessitarmos
adcionar mais de uma linha de comando em uma das instruções basta
iniciarmos um bloco de comando com o begin e end
Veja:
Insto é muito importante, pois em alguns casos necessitamos de mais de uma
linha de comando.
Instruções de laço:
Laço for
A instrução for do pascal é semelhante as das outras linguagens, mas não é
muito flexível, não é possível estabelecer incrementos diferentes de um,
embora seja possível contar para cima e para baixo.
Veja a screenshot:
Quando clicamos no Button1 o programa vai mostrar a caixa de mensagem
exibindo a mensagem de 0 a 5. Se quisermos fazer de forma decrescente
devemos utilizar no lugar do to o comando downto.
Veja como seria:
Neste caso vamos receber a caixa de mensagem exibindo a mensagem com
os números de forma decrescente de 5 até 0.
Instruções while e until
A diferença entre os laços while-do e repeat-until é que o código da instrução
repeat é sempre executado ao menos uma vez.
Veja:
Agora com o repeat:
OBS: Em qualquer um dos laços mostrados podemos usar o procedimento
Break para cancelar a repetição e sair do laço, podemos também forçar a
próxima iteração com o procedimento Continue.
I := 1;
while true do
begin
Inc(I);
if I < 10000000 then
Continue;
ShowMessage('Chegamos a dez milhões');
Break;
end;
Classes e objetos:
Uma classe é uma definição, com a qual se descreve os membros e
características que terão os objetos. Um objeto é uma cópia, também
chamada instância, de uma classe.
Quando uma classe é derivada de outra (chamada classe base, classe pai ou
classe mãe), ela herda os campos, propriedades e métodos da classe base.
O Delphi possui uma classe chamada TObject da qual todas as demais
classes se derivam, ou seja, todas as classes são derivadas de TObject ou de
classes derivadas de TObject. Quando você deriva uma classe de TObject ,
não é preciso declarar explicitamente a classe base pois o Delphi assume
TObject como default.
Um objeto é uma instância de uma classe, isto é, depois de definirmos uma
classe podemos declarar e utilizar objetos desta classe, da mesma forma que
podemos declarar e usar uma variável composta (um registro, por exemplo)
depois que o tivermos definido.
Veja o exemplo:
As classes sempre são inseridas depois da seção type.Geralmente as classes recebem um valor “T” antes do nome da classe, porém nada impede de não colocar. No caso a classe foi declarada com uma variável pública chamada “Valor” com o tipo string.
Quando desejamos utilizar a classe devemos cria-la na memória. Note que na screenshot acima declaramos uma instância chamada “Teste” para a classe “TTest”. Veja: procedure TForm1.FormCreate(Sender: TObject); begin Teste := TTest.Create; //instância da classe TTest é criada na memória Teste.Valor := 'teste'; //variável da instância da classe recebe valor string ‘teste’ ShowMessage(Teste.Valor); //caixa de diálogo mostra valor armazenado Teste.Free; //libera instância da memória end;
Criando um programa simples (Bloco de notas):
Inicie um novo projeto:
File/New/VCL Forms Application – Delphi for Win32
Agora começaremos a inserir os componentes necessários para a criação do
nosso bloco de notas. Vamos inserir um componente “MainMenu” localizado na
guia Standard, seguidos dos componentes Memo.
Veja:
Agora mude a propriedade do componente Memo1 para alClient
Com esta propriedade o Memo1 vai se “esticar” para todo o formulário
Olhe:
Agora vamos criar o Menu do nosso bloco de notas:
Dê um clique duplo sobre o componente MainMenu1 e note que o editor de
menus apareceu:
Note que por padrão o primeiro espaço do menu já está selecionando se você
digitar um texto esse texto entrará na propriedade Caption do Object Inspector
que está associado ao MainMenu1.
Na figura acima o texto inserido foi “Arquivo” que corresponde ao primeiro item
do menu, logo em seguida pressione a tecla enter e solte assim você notará
que mais um item foi criado e ele está aguardando que você escreva o nome.
Olhe como o menu ficou depois da inserção de 4 itens.
OBS: A linha é correspondende ao caracter “-“ hífen.
Agora vamos inserir o primeiro evento ao nosso bloco de notas, dê um clique
duplo ainda com o editor de menus aberto sobre o subitem “Sair”.
Após isso o nosso editor de códigos aparece com o primeiro evento de nossa
aplicação.
Olhe:
No caso o comando correspondente ao de fechar o nosso formulário é o
comando close.
Rode o programa e teste o resultado, se o resultado do evento for igual ao
retorno do Delphi no modo de edição tudo está correto.
Vamos adicionar agora um componente que será responsável por uma caixa
de dialogo para abrir o arquivo.
Vá até a guia “Dialogs” e depois clique sobre o OpenDialog e depois clique no
formulário. Note que o componente OpenDialog1 está em seleção, se não
estiver clique sobre ele, vá até o object inspector e vá até a propriedade Filter e
clique no botão com reticências. Preencha o filtro de arquivos da forma que
desejar.
Olhe a screenshot:
Vamos até o menu selecione o item “abrir” e dê um duplo clique para inserir o
evento, agora vamos digitar o seguinte comando:
If OpenDialog1.Execute then //condição checando se a opendialog foi aberta
begin
Memo1.Lines.Clear; //limpa conteúdo do memo para receber o texto a ser
carregado
Memo1.Lines.LoadFromFile(OpenDialog1.Filename) //carrega o arquivo de
texto selecionado para o memo
end;
Rode o programa clique no menu e veja o resultado, se tudo der certo o
arquivo de texto será carregado para o memo.
Vamos agora no mesmo esquema criar o evento para salvar textos, adicione o
componente SaveDialog que está localizada na guia Dialogs, altere o filtro da
mesma forma(propriedade filter) no object inspector. Dê um clique duplo no
menu e dê um clique duplo no item salvar para criar o evento para salvar:
If SaveDialog1.Execute then //condição checando se a opendialog foi aberta
begin
Memo1.Lines.Clear; //limpa conteúdo do memo para receber o texto a ser
carregado
Memo1.Lines.SaveToFile(OpenDialog1.Filename) //salva o conteúdo do memo
para o arquivo de texto
end;
Agora vamos inserir um novo formulário ao programa que servirá janela de
sobre, para isso clique em File/New/Form – Delphi for Win32
Note que um novo formulário foi criado. Vamos voltar ao primeiro formulário,
para isso clique no menu View/Forms e selecione o Form1(primeiro formulário).
Olhe:
Agora selecione o primeiro formulário e depois clique em “Ok”.
Crie o item Ajuda no editor de menus e depois crie um subitem Sobre
Dê um clique duplo sobre o subitem “Sobre” com isso o evento OnClick será
criado, para que possamos chamar o segundo formulário neste evento do
menu devemos primeiro “relacionar a unit” do segundo formulário com a do
primeiro, para isso clique em File/Use Unit...
Agora selecione a unit
Depois disso dentro do evento OnClick do subitem “sobre” adicione o comando
show que será responsável pela exibição do formulário.
Se você desejar que enquanto o formulário 2 (“Form2) que não se possa alterar
entre os formulários basta utilizar o comando Form2.ShowModal;
Adicione no Form2 3 componentes Label que estão localizados na guia
Standard necessários para informar o nome do programa, criador, e versão, e
logo em seguida adicione um componente Button.
Para mudar o valor do texto dos componentes selecione o label desejado e
altere sua propriedade caption no object inspector. Mude o label do button para
“Ok”.
Olhe:
Agora adicione no Button no evento OnClick o comando close, Pois assim
quando o programa estiver em execução e o usuário clicar no menu
ajuda/sobre e clicar e quando o formulário sobre “Form2” estiver sendo
mostrado ele poderá fechar o formulário.
OBS: Alguns detalhes impotantes para dar um aspecto mais profissional para o
programa é cuidar de alguns detalhes do programa, tais como o caption do
Formulário, o ícone, o nome na barra de tarefas, o posicionamento do
formulário, etc. Para mudar o caption do formulário basta usar a propriedade do
object inspector, para mudar o ícone do programa vá em Project/Options/
Olhe:
e depois clique em application:
Depois de ter clicado em application basta você digitar no campo “Title” o nome
que irá aparecer na barra de tarefas quando o programa estiver em execução,
no botão “Load Icon...” você pode escolher qual será o ícone de sua aplicação
você só irá precisar escolher o arquivo qualquer com a extensão”. ICO”.
Depois de ter feito as mudanças que desejar clique em Ok para confirmar as
alterações.
Para mudar o posicionamento do formulário basta você mudar a propriedade
do formulário chamada position.
Olhe:
Olhe agora o formulário depois das mudanças:
O Ícone foi alterado, o caption, e o título na barra de ferramentas.
Eventos de uma aplicação:
Vamos criar agora um programa exemplo para demonstrar a utilização dos
diversos eventos que os componentes possuem.
Crie uma nova aplicação e adicione os seguintes componentes:
2 Edit, 1 Memo e 2 Button
Olhe:
Agora selecione o Form1 pela palheta Structure, e depois pelo Object Inspector
clique em Events
Repare que o Form1 possui uma grande diversidade de eventos, vamos a uma
breve análise dos eventos mais usados:
OnActivate: Quando o formulário é ativado, ou seja quando a janela de nosso
programa está com a “barra azul” cinza e quando recebe o focus do mouse e
passa a estar ativa.
OnClick: Quando o formulário recebe um clique do mouse.
OnClose: Quando o formulário e fechado.
OnCreate: Quando o formulário é criado na memória.
OnDestroy: Quando o formulário é destruído da memória.
OnResize: Quando o formulário é redimensionado, ou seja quando alteramos o
tamanho da janela com o mouse.
OnShow: Quando o formulário é mostrado pela primeira vez, logo depois que
ele é criado na memória.
Se você deseja analisar os eventos para entender melhor adicione o comando
ShowMessage(‘Olá mundo’); entre o begin e o end dos eventos citados e veja
o resultado.
OBS: Vale apena ressaltar que cada componente pode possuir determinado
evento, cada componente pode ser totalmente distinto de outro ou não.
Vamos adicionar no Button1 de nossa aplicação no evento OnClick uma função
da unit “windows” chamada WinExec para mostrar como se executa um
aplicativo externo.
Veja a screenshot para que possamos comentar:
Neste exemplo de código temos uma função chamada WinExec.
OBS: Caso deseje descobrir onde esta função está armazenada, segure a
tecla “Ctrl” e depois clique sobre a mesma, e assim o Delphi mostrará em qual
a unit ele está armazenada.
Olhe o resultado:
Em certas ocasiões necessita-se utilizar funções que estão armazenadas em
units que não vem declaradas por padrão, neste caso basta adicionar a unit
que deseja usar na cláusula unit do formulário. Veja:
No caso onde está escrito “NomeDaUnit” basta você inserir o nome da unit,
pois neste caso a unit “NomeDaUnit” não existe e é meramente ilustrativo.
Vamos voltar agora a comentar sobre os parâmetros da função que estamos
estudando a WinExec.
Olhe:
WinExec(PChar(‘notepad.exe’), SW_SHOW);
No caso o valor PChar é utilizado para converter uma string para o valor PChar
que contém um valor nulo no final da string, este valor é muito utilizado em
chamdas da WinAPI.
Vale apena lembrar que o programa notepad.exe está localizado na pasta do
sistema e com isso não é necessário adicionar todo o caminho em que o
arquivo está localizado.
Se por exemplo quiséssemos executar um aplicativo que estivesse localizado
na nossa mesma pasta do aplicado poderíamos utilizar a propriedade chamada
ExeName junto com a função ExtractFilePath, observe como seria:
WinExec(PChar(ExtractFilePath(Application.ExeName) + ‘teste.exe’),
SW_SHOW);
Ou ainda para exemplificarmos melhor poderíamos substituir a string ‘teste.exe’
pelo valor Text do nosso Edit1, pois assim poderíamos digitar qualquer valor,
ou seja qualquer aplicativo que estivesse dentro da nossa pasta.
Veja:
WinExec(PChar(ExtractFilePath(Application.ExeName) + Edit1.Text),
SW_SHOW);
Olhe uma breve descrição sobre os parâmetros de execução da janela mais
utilizados:
SW_HIDE: Esconde a janela e mostra outra janela.
SW_MAXIMIZE: Maximiza a janela especificada.
SW_MINIMIZE: Minimiza a janela especificada, e ativa a próxima das janelas.
SW_SHOW: Ativa a janela e mostra no tamanho atual e posição.
Vamos adicionar agora o evento OnClick ao Button2
begin
Memo1.Lines.Add(Edit2.Text);
end;
No caso agora vamos inserir ao evento OnChange do componente Memo1 o
seguinte comando:
ShowMessage('Valor adicionado');
Ou seja, quando o usuário clicar sobre o botão será adicionado a linha de texto
que estiver digitado no Edit2, e ao componente receber a notificação do evento
OnChange o usuário receberá uma caixa de mensagem.
Olhe como ficou:
StringList:
Uma classe muito interessante que possuímos para utilização é a StringList,
com ela podemos manipular strings em lista.
Para criar esta classe basta declara-la onde quiser, depois crie-a no evento
desejado. Olhe:
procedure TForm1.Button1Click(Sender: TObject);
var
Teste: TStringList;
begin
Teste := TStringList.Create; //cria instância da classe na memória
Teste.Add('oioioi') //adiciona uma string
Teste.SaveToFile('teste.txt'); //salva conteúdo adicionado em arquivo de texto
Teste.Free; //libera instância da memória
end;
OBS: No final utilizamos a procedure Free para liberar a instância da classe
porém poderíamos utilizar também a procedure Destroy, a diferença entre as
procedures Free e Destroy é que a procedure Free testa se a instância já foi
liberada já a procedure Destroy tenta destruir a instância sem testar se o
mesmo já foi destruído.
Criando um Media Player Simples:
Para iniciarmos o desenvolvimento do nosso media player simples vamos
primeiro inserir os componentes ao formulário, adicione 1 Label, 1 Button, 1
componente chamado Media Player localizado na gui System e para
terminarmos essa etapa adicione um componente OpenDialog localizado a
guia Dialogs:
Veja como ficou:
Vamos adicionar ao evento OnClick do Button1 os seguintes comandos:
procedure TForm1.Button1Click(Sender: TObject);
begin
if OpenDialog1.Execute then // se a caixa de diálogo for executada então
begin
MediaPlayer1.Close; //fecha o media player caso ja estivesse aberto
MediaPlayer1.FileName := OpenDialog1.FileName; //media player recebe o
valor que o OpenDialog “capturou”
Label2.Caption := OpenDialog1.FileName; //label recebe o valor contido na
caixa de dialogo
MediaPlayer1.Open; //abre o arquivo especificado pelo nome
end;
end;
OBS: Lembre-se de adicionar o filtro corretamente na caixa de dialogo
OpenDialog como fizemos no exemplo do bloco de notas.
Utilizando Imagens:
Vamos desenvolver uma pequena aplicação para explicar algo sobre
manipulação de arquivos de imagem. Inicie uma nova aplicação, e em seguida
adicione os seguintes componentes ao formulário, 1 Button e 1 componente
Image localizado na guia Aditional.
Olhe como ficou:
Adicione ao evento OnClick do Button1 os seguintes comandos:
procedure TForm1.Button1Click(Sender: TObject);
var
Bmp: TBitmap; //instância declarada da classe bitmap
begin
Bmp := TBitmap.Create; //cria instância na memória
Bmp.LoadFromFile('C:\WINDOWS\Pescaria.bmp'); //carrega o arquivo bitmap
para a instância da classe bitmap
Image1.Picture.Bitmap := Bmp; //componente Image1 recebe a imagem
contida da instância da classe bitmap
Bmp.Free; //libera a instância da memória
end;
Utilizando o XP Manifest:
Um recurso muito interessante que foi adicionado desde a versão 7 do Delphi é
o XP Manifest um componente de simples utilização que dá um aspecto mais
agradável ao usuário, pois ele manifesta a skin do Windows XP. Para que ele
funcione basta adicioná-lo ao formulário de sua aplicação, este componente
fica localizado na guia Win32.
Olhe o antes:
Olhe o depois:
Exemplo Simples de Cliente/Servidor:
Para a inicialização do estudo cliente e servidor iremos utilizar os componentes
ClientSocket e ServerSocket da palheta Internet estes componentes foram
introduzidos na versão 4, estes componentes trabalham com o protocolo TCP e
note que estes componentes não acompanham mais o Delphi e foram
removidos desde a versão 6, atualmente o Dephi possui uma gama de
componentes para Internet da Indy porém os componentes citados aqui são de
fácil entendimento para o usuário iniciante.
Para ativa-los vá até o menu do delphi component Install Packages, e depois
clique em Add.
Olhe a screenshot:
Depois de ter clicado sobre o botão “Add” selecione o arquivo que fica
localizado na pasta “c:\Arquivos de
programas\Borland\BDS\4.0\Bin\dclsockets100.bpl”.
Depois clique em “Ok”, se tudo ocorreu corretamente dois novos componentes
apareceram na guia internet o ClientSocket e ServerSocket.
Olhe:
Vamos inicialmente criar o programa servidor, para iniciarmos o processo
adicione o componente ServerSocket ao formulário, vamos precisar de 2
Buttons e 1 componente Memo.
Olhe como ficou:
Vamos inserir os eventos ao programa:
No Button 1 no evento OnClick adicione os seguintes comandos:
procedure TForm1.Button1Click(Sender: TObject);
begin
ServerSocket1.Port := 9090; //porta que sera utilizada para a conexão com os
clientes
ServerSocket1.Active := True;//inicia o processo de “escuta” para receber
conexões
end;
No Button 2 coloque o seguinte comando:
procedure TForm1.Button2Click(Sender: TObject);
begin
ServerSocket1.Active := False;
end;
Agora o no evento OnClientRead do ServerSocket1 adicione os seguintes
comandos para receber as informações enviadas pelos clientes:
procedure TForm1.ServerSocket1ClientRead(Sender: TObject;
Socket: TCustomWinSocket);
var
Buffer: String; //variável string declarada para armazenar as palavras enviadas
pelos clientes
begin
Buffer := Socket.ReceiveText; //variável Buffer recebe o valor contido no
“soquete” de conexão
Memo1.Lines.Add(Buffer); //o conteúdo contido na variável Buffer é
adicionado ao Memo1
end;
Após isso temos o programa Servidor pronto para ser testado.
OBS: Caso queira conectar-se ao servidor que você acabou de criar clique no
menu iniciar/Executar e digite “cmd” ou “command.com” feito isso digite no MS-
DOS “telnet”
Em seguida digite “open” agora digite “127.0.0.1 9090“ que é correspondente
ao host localhost ou seja o ip que é atribuído a máquina desconectada, o 9090
é correspondente a porta que está em escuta pelo servidor.
Caso estivesse usando esse servidor pela internet com acesso discado você
utilizaria o ip de sua conexão, caso esteja conectado a internet por rede você
poderia utilizar o ip do servidor físico de sua rede porém o mesmo necessitaria
estar configurado para redirecionar as portas.
Olhe o programa telnet conectado ao servidor:
Você poderia também utilizar um cliente(Telnet, SSH, etc) muito famoso
chamado PuTTY que pode ser obtido pela internet no site http://www.putty.nl.
Olhe:
Vamos agora desenvolver com o Delphi o cliente para este servidor:
Inicie uma nova aplicação, vamos adicionar ao formulário em “branco” os
componentes, 3 Buttons, 2 Edits e um Memo.
Um desses buttons será utilizado para inciar a conexão, um para encerrar a
conexão e outro para enviar as “palavras” strings. Um dos edits será usado
para armazenar temporariamente os textos que serão enviados o outro será
utilizado para armazenar o IP do servidor. O memo será utilizado para mostrar
os textos que foram enviados. O componente ClientSocket será utilizado para
estabelecer a conexão com o servidor.
Olhe como ficou o formulário da aplicação:
Vamos adicionar ao button com o caption “Conectar” o Button1 ao evento
OnClick os seguintes comandos:
procedure TForm1.Button1Click(Sender: TObject);
begin
ClientSocket1.Port := 9090; //porta que o “soquete” cliente irá se conectar
ClientSocket1.Address := Edit2.Text; //endereço ip da máquina “remota” do
servidor
ClientSocket1.Open; //conecta ao servidor
end;
agora ao button com o caption alterado para Desconectar o Button2 vamos
adicionar o seguinte comando ao evento OnClick:
procedure TForm1.Button2Click(Sender: TObject);
begin
ClientSocket1.Close; //desconecta soquete da conexão com o servidor
end;
Ao button com o caption Enviar o Button3 vamos adicionar os seguintes
comandos ao seu evento OnClick:
procedure TForm1.Button3Click(Sender: TObject);
begin
ClientSocket1.Socket.SendText(Edit1.Text); //envia string contida no edit1
Edit1.Text := ''; //esvazia string do edit1
Edit1.SetFocus; //poe foco sobre o edit1
end;
Com isso já podemos testar a aplicação cliente junto com o servidor que
desenvolvemos anteriormente.
Olhe:
OBS: Repare na screenshot acima utilizamos a mesma máquina para rodar as
duas aplicações, no caso nada impediria de o cliente ou o servidor estar em
outra máquina conectada a internet ou rede, de modo que o ip seja trocado na
aplicação cliente.