Universo Games
Ola , Convidado



Você ainda não e cadastrado então cadastre-se e veja todas as atualizações no mundo rpg!!!
Universo Games

Suporte e Desenvolvimento só no Universo Games
 
InícioInício  PortalPortal  EventosEventos  PublicaçõesPublicações  Registrar-seRegistrar-se  Conectar-seConectar-se  
Ola Convidado, Seja Bem vindo a equipe lhe deseja boa sorte no seu projeto!

Compartilhe | 
 

 Curso Delphi

Ir em baixo 
AutorMensagem
Lucas Roberto
Administrador
Administrador
avatar

Mensagens : 709

MensagemAssunto: Curso Delphi   Sab 18 Jun 2011, 10:18

Curso de Delphi


1. Introdução


Programar em Windows sempre foi algo extremamente complicado e acessível apenas a programadores dispostos a investir muito tempo e fosfato na leitura de pilhas de livros, intermináveis testes e análise de programas exemplos que mais confundem do que explicam. Mas porque é tão difícil fazer programas para Windows? Para começar, o Windows usa o conceito de GUI (Graphics User Interface), que embora seja muito familiar para usuários do Unix, é novidade para usuários do DOS. O uso de um sistema GUI implica em aprender vários conceitos que são estranhos ao usuário de um sistema baseado em texto como o DOS. Para complicar um pouco mais, o Windows é um sistema multi-tarefa, e as aplicações são orientadas a eventos, o que implica em aprender um novo estilo de programação. Finalmente, o programador tinha que ter alguma familiaridade com as centenas de funções oferecidas pela API do Windows. Por tudo isso, programação em Windows é um assunto que costuma provocar arrepios nos programadores.
Felizmente as linguagens visuais chegaram para mudar esta situação. Foi só com elas que o Windows consegui cumprir sua promessa de ser um sistema amigável e fácil de usar também para os programadores, que sempre tiveram que pagar a conta da facilidade de uso para o usuário.
Entre as linguagens visuais que surgiram, nenhuma veio tão completa e acabada quanto o Delphi. O Delphi vem com um compilador capaz de gerar código diretamente executável pelo Windows, proporcionando uma velocidade de execução de 5 a 20 vezes maior que as linguagens interpretadas. Além disso, vem também com um gerenciador de banco de dados completo e um gerador de relatórios. O tempo de desenvolvimento de qualquer sistema é reduzido a uma fração do tempo que seria necessário usando outras linguagens e o resultado é sempre muito melhor. É por isso que o Delphi fez tanto sucesso no mundo inteiro

2. Conceitos básicos

Programação em Windows: Janelas e eventos


Existem muitas diferenças entre a programação em DOS e a programação em Windows. Vejamos a principal: Quando programamos em DOS, nosso programa é responsável pelo fluxo de processamento. Temos que definir claramente não só que instruções, mas também em que ordem devem ser executadas. Em Windows não é bem assim. Nosso programa não controla o fluxo de processamento, ele responde e trata eventos que ocorrem no sistema. Existem muitos eventos que podem ocorrer, sendo que os principais são aqueles gerados pelo usuário através do mouse e do teclado. A coisa acontece mais ou menos assim: O usuário clica o mouse e o Windows verifica que aplicação estava debaixo do mouse no momento em que foi clicado. Em seguida ele manda uma mensagem para a aplicação informando que ocorreu um clique e as coordenadas do cursor do mouse na tela no momento do clique. A aplicação então responde à mensagem executando uma função de acordo com a posição do mouse na tela. É claro que o Delphi toma conta do serviço mais pesado e facilita muito as coisas para o programador. Detalhes como as coodenadas da tela em que ocorreu o clique, embora estejam disponíveis, dificilmente são necessários nos programas.

Programação Orientada a Objeto (POO)

Embora não seja objetivo deste curso ensinar POO, uma breve introdução é necessária, já que o Delphi é essencialmente orientado a objeto.
De maneira prática, podemos pensar no objeto sendo uma estrutura que agrupa dados e funções para manipular estes dados. Como as funções são sempre “íntimas” dos dados, o sistema todo funciona de maneira mais segura e confiável. Além disso, a POO utiliza conceitos como encapsulamento e herança que facilitam muito programação e manutenção dos programas.
Neste ponto é oportuno citar que os dados de um objeto costumam ser chamados de variáveis de instância e as funçoes de métodos. As variáveis de instância definem as propriedades (as vezes chamada de atributos) do objeto e os métodos definem seu comportamento.

Encapsulamento - Como as variáveis e métodos estão na mesma estrutura, pode-se pensar em variáveis e métodos privados, ou seja, dados e funções que só podem ser manipulados pelas funções que estão dentro da estrutura. Desta maneira é possível formar uma camada protetora nos dados e evitar atribuições desastradas que comprometeriam o funcionamento do programa. Os defensores mais ortodoxos da POO dizem que todos os dados de um objeto deveriam ser privados e o número de funções públicas deve ser o menor possível, mas isso nem sempre é viável ou prático. O Delphi implementa este conceito e oferece dados/funções publicas (public) e privadas (private). Outra consequência do encapsulamento é que os objetos podem ser “caixas pretas”. Não é necessário (teoricamente) conhecer detalhes de funcionamento de um objeto para usá-lo, basta enviar as mensagens apropriadas que ele responde com a ação desejada.
Classes - A classe representa um tipo ou categoria de objetos, o modelo a partir do qual um objeto pode ser construído. É a estrutura propriamente dita, que define os dados e métodos daquela classe de objetos. O objeto em si, é uma instância da classe. Na programação estruturada podemos fazer uma analogia com os tipos e variáveis, onde a classe equivale ao tipo e o objeto à variavel desse tipo.
Herança - É a capacidade que uma classe de objetos tem de herdar variáveis e métodos de outra classe. Esta capacidade permite que o código já escrito seja reutilizado de maneira muito mais eficiente e simples do que na programação estruturada. Um programa orientado a objeto costuma implementar verdadeiras árvores genealógicas de classes, com vários níveis de herança.
Para programar no nível do designer (veja adiante o que significa) não é necessário um conhecimento profundo de POO. Mas é preciso conhecer pelo menos a sintaxe. Todas as aplicações para Windows, precisam de pelo menos uma janela, que no Delphi é chamada de Form. Cada form (assim como todos os objetos visuais) tem um objeto associado a ele e sua representação visual, que vemos na tela. Todos os componentes que incluímos no form, passam a fazer parte do objeto que define o form. Exemplo: Se colocarmos um botão no form, a classe deste form será modificada para incluir este botão. Os eventos e métodos deste form, também estão na classe. Assim, supondo que o form se chame Form1 (nome default), para por exemplo desativar o botão que incluímos (de nome Buttom1) escreveríamos:
Código:
Form1.Buttom1.Enabled := false;
Note como o Buttom1 faz parte da estrutura que define o form. Mas se quisermos ativar método RePaint (Repintar) do form faríamos:
Código:
Form1.Repaint;
Veja que Repaint, não é uma variável, tecnicamente é uma procedure, mas fazemos referência a ela como parte da estrutura Form1. Pode parecer confuso no início, mas facilita muito a programação.

3. O ambiente do Delphi

O Delphi oferece dois níveis de programação distintos. Existe o nível do que o manual chama de designer, que se utiliza dos recursos de programação visual e aproveita componentes prontos, e o nível do component writer, que escreve os componentes para o designer utilizar nas aplicações. Podemos dizer que o component writer programa em um nível mais baixo e o designer em um nível mais alto. Para este curso, consideraremos a programação no nível do designer.
Quando ativamos o Delphi, a tela inicial é parecida com a figura 1. Na janela superior, temos a barra do menú principal do Delphi, à esquerda a SpeedBar, com as opções mais comuns e à direita a paleta de componentes. Estes componentes são a base da programação visual e é onde o designer vai buscar recursos para sua aplicação.
Abaixo da SpeedBar, está a janela do Object Inspector, que permite visualizar e modificar as propriedades e eventos de todos os componentes. É também largamente utilizado pelo designer. Abaixo da paleta ficam a janela de código-fonte e as janelas que estão sendo construídas.

Primeiro contato

Para iniciarmos poderíamos criar a versão Delphi do famoso “Hello Word”, mas vamos partir para alguma coisa um pouco mais interessante e aproveitar para apresentar uma propriedade que pode ser útil no futuro. Como os programas em Windows são orientados a eventos é comum desativar opções de menús e botões, até que o usuário ative as opções que o sistema precisa para inicializar. Neste primeiro programa, vamos criar uma espécie de gangorra eletrônica. Mas antes de começar, vejamos o que está acontecendo no Delphi.
Se a tela está parecida com a figura 1, então não há nenhum projeto selecionado e o Delphi tomou a liberdade de criar um novo projeto para você, chamando-o de Project1. Um projeto é a coleção de arquivos necessários para compilar o sistema. Como toda aplicação precisa de pelo menos um form (Form1), ele também foi criado. Finalmente, todo form tem uma Unit correspondente que é mostrada no Editor de Código (Unit1).
Não há problema em utilizar esse projeto inicial que é oferecido pelo Delphi, mas é uma boa idéia renomear e salvar o projeto o quanto antes. Se você não escolher outro diretório, o projeto será salvo no diretório do Delphi e não é aconselhável salvar todos os seus projetos no mesmo diretório. Portanto vamos começar este programa criando um novo diretório para ele. Após isso, vamos seguir os seguintes passos:
1. Selecione a página Standard na paleta de componentes e clique no componente Buttom. A seguir clique no form. Um botão deve aparecer no form. Coloque mais dois botões.
2. Alinhe na horizontal os dois primeiros e coloque o terceiro logo abaixo dos dois. Se quizer um alinhamento exato, use a opção Edit/Align... do menú. Para marcar mais de um componente, deixe o Shift pressionado enquanto clica os componentes. Brinque um pouco com o tamanho dos botões e do form.
3. Clique o primeiro botão para selecioná-lo, a seguir procure no Object Inspector a propriedade Caption. Mude a string para “ON”. Para o segundo botão a string é “OFF” e para o terceiro “Close”. Para o segundo botão, mude a propriedade Enabled para False.
4. Neste ponto é uma boa idéia renomear e salvar o projeto. Escolha a opção File/Save project as...Selecione o diretório criado para o projeto e use o nome Main.pas para a unit1 e Gangorra para o projeto.
5. Clique a área pontilhada do form e em seguida ache a propriedade Caption no OI. Mude a string para “Gangorra”. Aproveite e mude a propriedade Name para “fmMain”.
6. Dê um clique duplo sobre o primeiro botão. A janela de código será ativada já com a função correspondente ao evento OnClick criada e posicionada sob o cursor. Digite o seguinte código:
Código:
Button1.Caption := ‘OFF’;
   Button1.Enabled := False;
   Button2.Caption := ‘ON’;
   Button2.Enabled := True;
7. Selecione a janela do form e faça o mesmo com o segundo botão, mas o código fica invertido:
Código:
Button2.Caption := ‘OFF’;
   Button2.Enabled := False;
   Button1.Caption := ‘ON’;
   Button1.Enabled := True;
8. Finalmente para o terceiro botão o código é simplesmente:
Código:
Close;
9. Já podemos executar o programa pressionando F9.
O que está acontecendo:O evento OnClick ocorre sempre que clicamos o mouse sobre um componente. O Delphi se encarrega de determinar qual é o componente que deve responder ao evento e direciona o evento para ele. Neste caso, usamos este evento para ativar/desativar botões manipulando a propriedade Enabled, que determina se o componente está ativo ou não. Quando o componente está inativo, ele não responde aos eventos. Também usamos a propriedade Caption para mudar a mensagem que aparece nos botões. Finalmente usamos o método Close do form para fechar a aplicação.

Algumas Propriedades mais utilizadas:
Name:
É comum a todos os componentes da paleta. O Delphi nomeia automaticamente todos os componentes que são incluídos no form (inclusive o proprio form). Usa o nome da classe do componente mais um número sequencial. O nome atribuído pelo Delphi pode ser mantido, mas é aconselhável renomear os componentes que serão referidos no programa. Por exemplo, no programa da Gangorra, Button1 e Button2 deveriam ser renomeados, já que é feita referência a eles no código fonte, já para o Button3 não há necessidade por que não há referência a ele. Quando voce renomeia um componente, o Delphi atualiza automaticamente todo o código gerado pelo Delphi, o que inclui o cabeçário da Unit, os eventos do componente e as propriedades de outros componentes que fazem referência ao componente renomeado, mas não atualiza o código gerado por você. Exemplo: se renomearmos agora o Button1, o Delphi atualizará o cabeçário da unit, o nome dos eventos de Button1, mas você terá que atualizar as referências que você fez ao Button1 com o novo nome. Aliás esta é uma regra geral no Delphi: ele nunca modifica automaticamente o código gerado pelo programador, mesmo que esteja em comentário.

Caption: Todos os componentes que podem apresentar um rótulo tem esta propriedade. Armazena a string que será mostrada quando o componente for desenhado.

Left e Top: Esquerda e Topo. Armazenam a posição do componente em relação ao form ou painel que o contém. Movendo o componente, estas propriedades se atualizam automaticamente, e alterando estas propriedades, o componente é movido.

Height e Width: Altura e comprimento do componente. Idem acima.

Font: Permite selecionar tamanho e tipo da fonte que será usada para escrever o texto no componente.
Color: Cor do componente. Existe uma lista de cores padrão usadas pelo Windows e pelo Delphi, mas é possível definir qualquer cor através de seus componentes RGB.

TabOrder: Ordem do componente no Form ou painel. Quando há vários componentes selecionáveis no Form ou painel, a tecla Tab permite navegar entre os componentes. Esta propriedade define a ordem em que os componentes são selecionados quando o usuário tecla Tab.

Hint: (Dica) Este é um recurso muito útil e fácil de usar. Permite que apareça um texto de ajuda quando o usuário posiciona o cursor do mouse sobre um componente. Todos os componentes podem ter Hint. Na propriedade Hint, voce deve digitar a frase que deve aparecer. Veja a propriedade abaixo.

ShowHint: Ativa o hint para o componente. Se estiver desligado, o hint não é mostrado.

Alguns Eventos básicos:

OnClick: É gerado cada vez que o botão esquerdo do mouse é pressionado e solto. O evento só ocorre quando o usuário libera o botão. O Delphi já direciona o evento para o componente que está debaixo do cursor do mouse.
OnDblClick: Gerado quando é feito um duplo clique no botão esquerdo.
OnKeyPress: Gerado quando o usuário pressiona (e libera) uma tecla no teclado.
OnEnter: Gerado quando o foco de atenção do Windows “cai” sobre o componente. Exemplo: Suponha uma tela de entrada de dados, onde vários campos devem ser digitados. Quando a tela é apresentada, o foco, ou o cursor de texto, está sobre o primeiro campo. Depois de digitar o campo, o usuário pressiona Tab para passar para o campo seguinte. Veja que o que passa para o campo seguinte é a atenção da aplicação e do Windows. Essa atenção é chamada de foco, ou focus em inglês. Este evento é gerado assim que o componente recebe o foco, antes de executar qualquer código do componente.
OnExit: Gerado imediatamente antes de o foco deixar o componente.
OnResize: Gerado quando o tamanho do componente é alterado. É usado principalmente em forms e painéis.
OnChange: Gerado quando o valor do componente muda. Só é aplicado em componentes que permitem edição de seu conteúdo.



_______________________________________________________________________________________________________


[Você precisa estar registrado e conectado para ver esta imagem.]
Voltar ao Topo Ir em baixo
http://universogamesmmo.forumeiros.com
Lucas Roberto
Administrador
Administrador
avatar

Mensagens : 709

MensagemAssunto: Re: Curso Delphi   Sab 18 Jun 2011, 10:25

Alguns métodos úteis

Show: Desenha o componente. Se for uma janela (form) ela é desenhada e ativada.
Close: Fechar. Aplicado geralmente em forms e arquivos. Quando utilizado no form principal, encerra a aplicação.
Repaint: Repintar. Redesenha o componente ou form.
Refresh: Tem o mesmo efeito que o Repaint, mas antes de desenhar, apaga o componente. Quando aplicado em arquivos, faz com que o buffer do arquivo seja recarregado.
Create: Aloca memória para criar um componente ou form, dinâmicamente.
Free: Libera a memória alocada com o Create.

4. Uma aplicação mais sofisticada

A partir de agora, passaremos a desenvolver um aplicação que vai usar os recursos básicos para a maioria das aplicações. Conforme vamos incrementando a aplicação, veremos os principais conceitos da programação em Delphi. A aplicação é um mini sistema de pedidos. O sistema manterá cadastros de clientes e produtos e será capaz de gerar e armazenar os pedidos dos clientes.

Menús
Como primeiro passo, cuidaremos do sistema de menús. O componente do menú é o primeiro na página Standard da paleta de componentes. Coloque o menú no form. O ícone apareceu mas ainda não há nenhuma barra de menú. Para entrar no editor do menú é necessário um duplo clique no ícone no form. Note que quando o editor é ativado o Object Inspector passa a mostrar as propriedades e eventos dos itens de menú. Selecione a propriedade Caption e digite Arquivo. O menú passa a mostrar agora uma opção para Arquivo e um retângulo pontilhado ao lado. Clique no retângulo, selecione a propriedade Caption e digite Cadastros. Repita a operação e coloque mais um ítem para Ajuda.
Neste ponto já temos o que num sistema DOS chamaríamos de menú principal. As opções que aparecem horizontalmente na barra de menu, normalmente ativam sub-menús que oferecem mais opções, e estas eventualmente podem abrir mais sub-menus, num leque que pode crescer bastante, se necessário. Para criar um sub-menu do menú principal, basta clicar na opção desejada e utilizar o retângulo que aparece abaixo da opção. Crie agora os seguintes sub-menús:
Para Arquivo: Sair
Para Cadastro: Clientes, Produtos e Pedidos
Para Ajuda: Sobre o sistema...
Podemos associar letras a opções do menú. Nesse caso a letra aparece sublinhada no menú e o menú principal é ativado quando o usuário tecla ALT + . Só é preciso tomar cuidado para escolher letras diferentes para cada opção no mesmo nível. Exemplo: no primeiro nível temos as opções Arquivo, Cadastro e Ajuda. Poderíamos escolher a letra A para Arquivo e a letra C para Cadastro, mas a opção Ajuda não podería estar tambem associada à letra A, o mais aconselhavel seria escolher a letra J. Para selecionar uma letra, basta acrescentar o símbolo & (e comercial) antes da letra na propriedade Caption.

Para criar sub-menús em sub-menús, selecione a opção que será a raiz e pressione CTRL + Seta Direita. Crie as opções Cadastro e Listagem no cadastro de Clientes e no de Produtos. No cadastro de Pedidos crie três opçoes: Cadastro, Impressão e Listagem. O menú completo fica assim:

Arquivo
Sair
Cadastros
Clientes
Cadastro
Listagem
Produtos
Cadastro
Listagem
Pedidos
Cadastro
Impressão
Listagem
Ajuda
Sobre o sistema...

Antes de fechar definitivamente o editor de menús, temos ainda outra tarefa. Note que a opção Cadastro apararece em 3 sub-menús. Em cada um deles, o ítem de menú para Cadastro deve receber um nome diferente do Delphi, e ele resolve o problema chamando estes ítens de Cadastro1, Cadastro2 e Cadastro3. Apenas para deixar o código fonte mais claro e legível, poderíamos renomear estes ítens para mnCadCli, mnCadProd e mnCadPed. O prefixo mn indica que é um ítem de menú. É um bom hábito colocar prefixos assim nos nomes dos componentes, porque facilita muito a leitura do código fonte. Para fixar melhor este hábito, renomeie também as opções de Listagem.
Agora já podemos fechar o editor de menús, dando um clique duplo no botão que aparece à esquerda da barra de título da janela. Falta agora criar o código para cada opção do menú. A maioria das opções, deixaremos para codificar mais adiante, de imediato vamos apenas codificar a opção de saída do sistema. Já com o editor de menús fechado, selecione a opção Arquivo/Sair no form da aplicação e escreva Close;. Nossa aplicação agora já tem como fechar.
Painéis

Embora não pareça, o painel (Panel) é um componente extremamente útil e poderoso. Sua aparência é de uma placa metálica e ele funciona como uma sub-janela. Todos os componentes que são colocados sobre um painel, passam a “pertencer” ao painel. Se o painel for movido dentro da janela, os componentes sobre ele se movem junto. Com os painéis é possivel dividir facilmente a janela em regiões e distribuir melhor os componentes. O Delphi também utiliza largamente os painéis de maneira puramente estética, como moldura de grades e imagens.
Em nossa aplicação usaremos um painel para criar uma barra de botões que permita entrar mais rapidamente nos cadastros. Primeiro diminua um pouco a altura da janela. Coloque um painel no form e apague a string que está na propriedade Caption. Aumente um pouco o tamanho vertical dele e em seguida, ajuste a propriedade Align para alTop. O painel agora está configurado para ficar sempre no topo da janela. O tamanho horizontal dele será sempre igual ao espaço interno da janela, mesmo quando a janela muda de tamanho e o tamanho vertical pode ser ajustado à gosto.
A propriedade Align tem as seguintes opções de alinhamento:
alTop: alinha no topo da janela (ou painel)
alBotton: alinha embaixo (rodapé)
alLeft: alinha à esquerda
alRight: alinha à direita
alClient: Faz o painel ocupar todo o espaço disponível da janela ou painel
alNone: Não faz nenhum alinhamento.
Neste painel colocaremos 4 botões, tres à direita e um à esquerda, como na figura 2. Mas desta vez usaremos o botão BitBtn que está na página Aditional na paleta de componentes.

BitBtn
A diferença entre o BitBtn e o Button é que o primeiro permite incluir um ícone (é chamado de glyph) no botão. Veja como todos os botões que o Delphi usa para cancelar uma operação tem um X vermelho no botão. Esse X é um glyph.
Marque todos os botões e altere as propriedades Heigth para 60, Width para 80 e Layout para blGlyphTop. Agora desmarque os botões porque as próximas alterações precisam ser feitas individualmente no botões.
No Caption do primeiro, escreva Clientes, no segundo Produtos e no terceiro Pedidos. Antes de alterar o Caption do quarto, vamos alterar a propriedade Kind para bkCancel. Veja que o Caption dele agora é Cancel e apareceu o X vermelho citado antes. Agora sim podemos mudar Caption do quarto botão para Fechar.
Dê um clique duplo na prop. Glyph do primeiro botão. Aparece a janela Picture Editor, clique o botão Load. A seguir selecione o diretório C:\Delphi\Images\Buttons. Digite (ou selecione) Picture.Bmp e pressione Ok. Para o segundo botão, selecione o glyph Gears.Bmp e para o terceiro Npadwrit.Bmp

_______________________________________________________________________________________________________


[Você precisa estar registrado e conectado para ver esta imagem.]
Voltar ao Topo Ir em baixo
http://universogamesmmo.forumeiros.com
 
Curso Delphi
Voltar ao Topo 
Página 1 de 1
 Tópicos similares
-
» [Codigo][Delphi] Apagar arquivos/pastas
» [Delphi][Dica] Tirar um Print Screen da tela a cada 5 segundos
» [Dica][Delphi] Desabilitar/Habilitar componentes de um form pela sua classe

Permissão deste fórum:Você não pode responder aos tópicos neste fórum
Universo Games :: Centro de Aprendizagem :: Programação :: Borland Delphi-
Ir para: