Delphi 7 - Programacao inicial

INDICE Paradigmas da Programação ............................................................................................................................... 3 Tipos Simples Si mples.................................................. .............................................................................................................. ............................................................ .......................................... 8 Tipos Enumerados ..................................................... ........................................................... ................................. 9 Tipo Set ........................................................... ............................................................ .......................................... 9 Tipos com Editor de Propriedades ........................................................................................................................ 9 Manipulando Eventos ........................................................................................................................................... 9 PROJETO EM DELPHI ......................................................................................................................................... 13 CONVENÇÃO DE NOMEAÇÃO ......................................................................................................................... 17 COMPONENTES .................................................................................................................................................... 26 Propriedades ........................................................ ............................................................ ........................................ 27 Métodos................................................................................................................................................................... 28 Métodos................................................................................................................................................................... 29 Propriedades ........................................................ ............................................................ ........................................ 29 Propriedades ........................................................ ............................................................ ........................................ 30 Crie um formulário for mulário conforme lay-out la y-out abaixo ........................................................ .................................................. 31 A opção Apaga Tudo só poderá ocorrer após confirmação do usuário ................................................................... 31 Propriedades ........................................................ ............................................................ ........................................ 32 Métodos................................................................................................................................................................... 32 Propriedades ........................................................ ............................................................ ........................................ 32 Propriedades ........................................................ ............................................................ ........................................ 33 Métodos................................................................................................................................................................... 34 Propriedades ........................................................ ............................................................ ........................................ 34 Métodos................................................................................................................................................................... 34 Propriedades ........................................................ ............................................................ ........................................ 36 Métodos................................................................................................................................................................... 36 Propriedades ........................................................ ............................................................ ........................................ 36 CHAMADA DE FORMS ........................................................................................................................................ 51 COMPONENTES (VCL) ......................................................................................................................................... 51 TRATAMENTO DE EXCEÇÕES ........................................................................................................................ 65 UM POUCO MAIS SOBRE COMPONENTES (VCL) ..................................................................................... 71 Opções................................................................................................................................................................. 72 Valor ................................................................................................................................................................... 72 Significado .......................................................................................................................................................... 72 Principais Eventos ..................................................... ........................................................... ............................... 72 Evento ................................................................................................................................................................. 72 Descrição......................................................... ............................................................ ........................................ 72 Principais Métodos .................................................... ........................................................... ............................... 73 Métodos............................................................................................................................................................... 73 Descrição......................................................... ............................................................ ........................................ 73 Principais Propriedades ....................................................... ........................................................... ..................... 73 Propriedade ......................................................................................................................................................... 73 Descrição......................................................... ............................................................ ........................................ 73 Opções................................................................................................................................................................. 73 Valor ................................................................................................................................................................... 73 Significado .......................................................................................................................................................... 73 Principais Eventos ..................................................... ........................................................... ............................... 73 Evento ................................................................................................................................................................. 73 Descrição......................................................... ............................................................ ........................................ 73 Principais Métodos .................................................... ........................................................... ............................... 74 Métodos............................................................................................................................................................... 74 Descrição......................................................... ............................................................ ........................................ 74 Principais Propriedades ....................................................... ........................................................... ..................... 74 Propriedade ......................................................................................................................................................... 74 Descrição......................................................... ............................................................ ........................................ 74 Opções................................................................................................................................................................. 74 Valor ................................................................................................................................................................... 74

COLÉGIO DA IMACULADA – CURSO TÉCNICO EM INFORMÁTICA Prof. Tales Cabral – [email protected]

Significado .......................................................................................................................................................... 74 Principais Eventos ..................................................... ........................................................... ............................... 75 Evento ................................................................................................................................................................. 75 Descrição......................................................... ............................................................ ........................................ 75 Principais Métodos .................................................... ........................................................... ............................... 75 Métodos............................................................................................................................................................... 75 Descrição......................................................... ............................................................ ........................................ 75 UM POUCO MAIS SOBRE COMPONENTES (VCL) ..................................................................................... 75 Images ..................................................................................................................................................................... 81 StateImages ............................................................................................................................................................. 81 Items.......................................................... ............................................................ .................................................. 81 ShowButtons ........................................................................................................................................................... 81 ShowLines........................................................... ............................................................ ........................................ 81 ShowRoot.................................................. .............................................................................................................. ............................................................ .................................................. 81 ReadOnly ................................................................................................................................................................ 81 Eventos ................................................................................................................................................................... 81 OnEditing .................................................. .............................................................................................................. ............................................................ .................................................. 81 OnEdited ................................................................................................................................................................. 81 Apêndice A - A Linguagem Object Object Pascal..................................................................................................... 83 Apêndice B - DICAS ............................................................................................................................................ 86 Apêndice C - INTRODUÇÃO À ORIENTAÇÃO A OBJETOS ..................................................................... 91 REFERÊNCIA BIBLIOGRÁFICA ........................................................................................................................... 93

2


Significado .......................................................................................................................................................... 74 Principais Eventos ..................................................... ........................................................... ............................... 75 Evento ................................................................................................................................................................. 75 Descrição......................................................... ............................................................ ........................................ 75 Principais Métodos .................................................... ........................................................... ............................... 75 Métodos............................................................................................................................................................... 75 Descrição......................................................... ............................................................ ........................................ 75 UM POUCO MAIS SOBRE COMPONENTES (VCL) ..................................................................................... 75 Images ..................................................................................................................................................................... 81 StateImages ............................................................................................................................................................. 81 Items.......................................................... ............................................................ .................................................. 81 ShowButtons ........................................................................................................................................................... 81 ShowLines........................................................... ............................................................ ........................................ 81 ShowRoot.................................................. .............................................................................................................. ............................................................ .................................................. 81 ReadOnly ................................................................................................................................................................ 81 Eventos ................................................................................................................................................................... 81 OnEditing .................................................. .............................................................................................................. ............................................................ .................................................. 81 OnEdited ................................................................................................................................................................. 81 Apêndice A - A Linguagem Object Object Pascal..................................................................................................... 83 Apêndice B - DICAS ............................................................................................................................................ 86 Apêndice C - INTRODUÇÃO À ORIENTAÇÃO A OBJETOS ..................................................................... 91 REFERÊNCIA BIBLIOGRÁFICA ........................................................................................................................... 93

2


Paradigmas da Programação "Paradigma é uma forma de pensar e perceber o mundo real e determina o que escolhemos como significativo e o que descartamos ao compreender ou descrever o que existe ou ocorre no mundo em torno de nós". A mudança de paradigma é uma oportunidade de encontrar novas interpretações para antigas questões, bem como, para rever soluções tidas como definitivas.

Introdução Antes de começarmos seria interessante ressaltar que aprender a ser um bom desenvolvedor envolve mais do que aprender a sintaxe de uma linguagem de programação em particular, isto porque existem muitos outros aspectos do campo do software, que têm pouca conexão com o ato em si de escrever código. Se você pode está pensando: "Ora, vamos, eu só quero aprender Delphi", deveria também pensar que a questão aqui é que, se você pretende desenvolver programas ou sistemas por dinheiro ou para manter-se num emprego, e tem clientes ou chefes esperando que seu software: Saia funcionando da caixa, Seja feito a tempo, Seja livre de erros e Seja barato, Então, vamos ter que começar por aqui mesmo, comentando sobre problemas como a crise de software; o ciclo de vida e a engenharia de software porque apenas talento artístico indisciplinado (intuição) não resolve. Devemos nos lembrar que o objetivo mais direto do desenvolvimento de software é fazer o produto final satisfazer a especificação dos requisitos. Precisamos portanto, dividir isso em algo mais tratável. Algum grupo menor ou mais preciso de objetivos que sejam mais alcançáveis e fáceis de lembrar. Lembre-se de que se tem algo que é sempre permanente é a mudança. Conforme sabemos, uma aplicação passará a maior parte de seu ciclo de vida na fase de manutenção. Então, é importante termos um conjunto de objetivos que transceda a mudança. Entre outros, os quatro objetivos geralmente excluídos da engenharia de software são a capacidade de modificação, eficiência, confiabilidade e inteligibilidade. inteligibilidad e. Devemos também destacar a ergonomia.

Programação Procedimental (estruturada) A maior parte dos programadores está acostumada a escrever código que é executado de forma sequencial. Tais programas possuem inicio, meio e fim bem definidos. Tipicamente, estes programas possuem telas de entradas de dados de algum tipo de processamento com estes

3


dados de forma sequencial. Esta forma de se programar é dita procedimental. A figura 1 ilustra a sequencialidade encontrada em programas que seguem tal paradigma.

Início

Entrada de Dados

Processamento

Fim

Esta forma de programar é uma consequência direta dos sistemas computacionais disponíveis no passado. Estes sistemas eram compostos por uma CPU responsável pelo processamento (mestre) e uma série de periféricos (escravos), responsáveis pela entrada e saída de dados. O custo da CPU era nitidamente superior ao de qualquer periférico e até mesmo ao custo do trabalho de quem lidava com estes computadores. Consequentemente, todos os sistemas davam prioridade máxima ao processamento, em relação à entrada e saída de dados. Os programas desenvolvidos visavam normalmente a solução de problemas de natureza científica, que naturalmente requisitavam mais recursos de CPU do que de entrada e saída de dados. A popularização dos computadores modificou este quadro: as aplicações comerciais típicas dos dias de hoje exigem uma atenção maior dos programadores (e dos sistemas computacionais) para a entrada e saída de dados. A hierarquia rígida imposta pela estrutura de menus e a sequencialidade com que os formulários são preenchidos pelo usuário impõem limitações sérias na qualidade da interação do usuário com o computador na programação procedimental. Um exemplo não baseado em eventos (programação sequencial) Program Verif_Nome; Var Nome : String; Begin Write ('Digite um nome: '); Readln (Nome); If Nome = 'Ze Silva' then writeln ('Nome bem original cara') else writeln ('O que poderia dizer'); End.

4


Note que o fluxo do programa é bem definido. Primeiramente ele pergunta o nome do usuário. Agora, você pode esperar que o usuário introduza seu nome, e não precisa se preocupar com nenhuma outra entrada ou ação que ocorra no ambiente. Depois que o nome é informado, uma instrução if define o que o programa deve fazer em seguida e o programa termina. A lógica deste programa linear é direta e sequencial. O modelo baseado em eventos não pode utilizar controle de fluxo do início até o fim, pois o aplicativo deve manipular todas as ações ou eventos possíveis

Programação Orientada a Eventos Um aplicativo baseado em eventos, na verdade, não faz nada - a não ser que ocorra um evento. É isso mesmo, ele não tem um início ou final lógico. Ele simplesmente precisa saber como responde aos diferentes tipos de eventos. Isto não quer dizer que você não pode ter um evento que ocorra quando o programa começa ou quando vai se fechar; entretanto, você precisa pensar sobre seu modelo de programação de modo diferente. No exemplo anterior, você sabia exatamente que ações o usuário executaria - digitar um nome. Contudo, pense em aplicativo processador de textos baseado no Windows. Não há meios de saber se o usuário digitará uma frase, escolherá uma opção no menu ou dará um clique em um botão, na barra de atalho. Independentemente da ação que o usuário executa, o aplicativo precisa ser consistente o suficiente para responder ao evento. A idéia básica por trás da programação dirigida a eventos é que alguns eventos determinam o fluxo do aplicativo. Um programa gasta a maior parte de seu tempo aguardando eventos e tem código que responde a diversos deles (nem todos, já que normalmente um programa ignora eventos nos quais não tem interesse). Por exemplo, quando o usuário dá um clique em um dos botões do mouse, ocorre um evento. É enviada uma mensagem descrevendo esse evento para a janela que está sob o cursor do mouse no momento. A aplicação intercepta a mensagem e chama o método associado ao evento correspondente. Quando o metodo termina, o programa retorna a um estado de espera. Como a explanação acima demonstra, eventos são serializados; cada evento é manipulado somente após o anterior ter sido completado. Quando uma aplicação está executando código de resposta ao evento (ou seja, não está aguardando um evento), outros eventos para essa aplicação devem aguardar em uma fila reservada de multitarefa gerenciada através de um manipulador de eventos. Ações

Sistema

Eventos

Loop de Tratamento dos Eventos

5


O avanço da tecnologia barateou o custo dos sistemas computacionais e introduziu recursos gráficos para a interação com os usuários (GUI- Graphic User Interface).

Uma aplicação que se utiliza de interface gráfica, permite que o usuário decida a seqüência mais apropriada de interação. Esta abordagem muda completamente a forma de se construir programas. As interfaces gráficas introduziram assim uma forma completamente nova de se programar. Nesta abordagem, uma aplicação constitui-se de um loop para tratamento de eventos e de procedimentos associados a eventos específicos. Toda vez que ocorre um determinado evento, o seu procedimento equivalente é executado. Eventos acontecem em decorrência da interação do usuário com o sistema, gerados pelo sistema operacional ou ainda gerados na própria aplicação. Exemplos de eventos: mover o mouse, pressionar uma tecla, selecionar um ítem de menu, setar o foco para um determinado controle, etc. A cada ação do usuário corresponde um ou mais eventos “enviados” para a aplicação. Estes eventos devem ser identificados e tratados de maneira adequada pelo programa. Esta abordagem é conhecida como programação orientada a eventos. As interfaces gráficas tornaram a interação dos usuários com as aplicações bastante atraentes. Em compensação, introduziram uma complexidade enorme do ponto de vista de programação. Para se ter uma idéia, o código em linguagem C no windows para escrever na tela “Alô mundo” possui cerca de 100 linhas. Se acrescentarmos a isto o fato de que 80% do código escrito para uma aplicação é consumido na elaboraçào de interface, fica difícil de massificar a programação em ambientes de interface gráfica. Felizmente, o paradigma da orientação a objetos consegue esconder do programador a maior parte da complexidade da programação nestes ambientes.

IDE (Integrated Development Environment) O ambiente integrado de desenvolvimento do Delphi é composto de várias ‘partes’ compondo um conjunto integrado de ‘janelas’ que interagem entre si.

6


Vamos abordar cada uma separadamente:

O FORM DESIGN Form é o termo utilizado para representar as janelas do Windows que compõem uma aplicação. Os forms servem como base para o posicionamento dos componentes, que são responsáveis pela interação entre usuário e máquina. Para selecionarmos o form devemos clicar (uma vez) em sua área interna ou na object inspector, e não simplesmente em seu título. As características iniciais do form como tamanho, botões (minimizar, maximizar, fechar, controle) e ícone podem (e serão) ser modificadas através de recursos que veremos adiante.

A BARRA DE MENU PRINCIPAL Como todo programa padrão Windows, há uma janela onde estão situados os menus da aplicação, a barra que contem os menus também agrupa outras partes.

COMPONENT PALETTE (PALETA DE COMPONENTES) Aplicativos orientados a objetos trabalham com elementos que denominamos componentes. No Delphi, os componentes encontram-se em uma paleta com várias guias.

Pode-se configurar a ordenação das guias clicando com o botão direito do mouse sobre qualquer componente e clicar na opção Properties.

7


OBJECT INSPECTOR (INSPETOR DE OBJETOS) Uma das ‘partes’ mais importantes da orientação a objeto é a possibilidade de definir características personalizadas aos componentes. No Delphi, utilizamos a janela object inspector para realizar esta tarefa. Há uma caixa de listagem1 que permite a escolha de qual componente deverá ser selecionado. Duas guias: Properties – Define as propriedades

e

valores do Objeto selecionado. Events – Define quais os eventos serão

manipulados pelo desenvolvedor. Algumas propriedades trazem opções diferenciadas para alteração. Por exemplo: Caption – Permite a inserção de uma

string de caracteres. Color – Permite a inserção de um dos valores pré-definidos pré-definidos na caixa de listagem. BorderIcons – Toda propriedade que possui o sinal de + tem a característica de subpropriedades . Deve-se clicar no sinal de + para expandir e no sinal de – para ocultar.

mostrar

Icon – Exibe um botão de reticências (...) que dará origem a uma caixa de diálogo.

Os nomes definidos como valores das propriedades na object inspector serão os nomes usados na construção do código em Object Pascal. Na parte superior da janela há uma caixa de listagem que permite a seleção de componentes já inseridos no formulário. Duas guias (Properties e Events ) separam as listas de propriedades e eventos. As propriedades são definidas através de tipos. Podemos citar no exemplo com o objeto form:

Tipos Simples São tipos String ou valores numéricos definidos ao digitar um valor na frente da propriedade. Exemplo: Name, Caption, Height e Width entre outros. 1

Componente ComboBox. 8


Tipos Enumerados São tipos definidos por uma quantidade limitada de opções que devem ser previamente selecionadas, não simplesmente definidas pelo usuário. Exemplo: Cursor, BorderStyle e WindowState entre outros.

Tipo Set Algumas propriedades podem conter múltiplos valores. Um exemplo é a propriedade BorderIcons com o sinal + indicando subpropriedades.

Tipos com Editor de Propriedades As propriedades que são acompanhadas de um ícone de reticências (...) indicam que uma janela de diálogo irá auxiliar na escolha de seu(s) valor(es). Exemplo: Icon.

Manipulando Eventos A guia Events permite o desenvolvedor definir um handler2 em Object Pascal para um determinado evento que pode ser disparado pelo usuário ou pelo sistema. Um evento é uma ação disparada dentro de uma aplicação orientada a Objeto. Podemos citar as ocorrências dos principais eventos que são disponibilizados na maioria dos componentes em Delphi: Evento

OnClick OnDblClick OnEnter OnExit OnKeyPress 2

Ocorrência

Quando o usuário clicar uma vez com o botão esquerdo do mouse sobre o componente. Quando o usuário dá um duplo clique no componente co mponente com o botão esquerdo do mouse. Quando o componente recebe o foco. Quando o componente perde o foco. Quando pressiona uma única tecla de caractere.

Manipulador de evento 9


Observe a construção do procedimento criado pelo próprio Delphi: procedure TForm1.Button1Click(Sender: TObject);

begin end;

CODE EDITOR O editor de código é responsável por receber todas as declarações criadas pelo Delphi e handlers criados pelo desenvolvedor. E no ambiente Code Editor que implementamos o algoritmo na linguagem Object Pascal. 3

Code Editor

Name do form

que define uma nova classe

Code Explorer

Na janela do editor pode haver uma outra janela denominada Code Explorer . É a parte esquerda da janela, onde podemos ter uma orientação sobre os objetos, procedimentos, funções e classes utilizadas na aplicação. Para desligar o code explorer clique no pequeno X ao lado da guia do code editor , para visualiza-lo clique com o botão direito dentro do editor e escolha View Explorer ou pelo teclado Ctrl+Shift+E. Uma característica muito importante do Code Explorer é que quando inserirmos componentes no form, a sua declaração é feita pelo Delphi de maneira automática.

3

Manipulador de eventos. 10


Podemos considerar também o seguinte fato: ‘Tudo o que o Delphi escrever, é problema dele’. Agora, ‘Tudo o que você escrever é problema seu’.

Problema no sentido de atualização de código, como veremos adiante. Quando alteramos o nome do objeto, deve-se utilizar o mesmo nome nas rotinas implementadas. Agora, o que o Delphi declarou, ele se encarrega de atualizar. Pode-se personalizar o Editor através do menu Tools | Editor Options.

CODE INSIGHT Um recurso que vai facilitar nossa vida no momento de desenvolvimento de código é o Code Insight do Code Editor do Delphi., Ele atua como um ajudante de complemento junto ao código do desenvolvedor. Por exemplo, ao digitar o nome de um objeto seguido de ponto (.) abre-se uma listagem de métodos e propriedades que podem ser utilizadas neste objeto. Esta lista pode ser ordenada por nome, clicando com o botão direito dentro da listagem.

11


No momento de chamada de procedimentos ou métodos:

Para forçar o code insight em determinada situação, utiliza-se: Ctrl + Barra de Espaço - Para complemento de objetos; seus métodos e • propriedades. Ctrl + Shift + Barra de Espaço – Para complemento de parâmetros. •

Prática 1 - Vamos realizar um pequeno exemplo no Delphi para resultar na execução abaixo:

Siga os seguintes passos: 1. Defina para o Formulário no Object Inspector: Caption: Pô, que emoção cara Name: Form1 2. Insira um botão no formulário (Ver Guia Standard na Barra de Ferramentas) 3. Defina para o Botao no Object Inspector: Caption: Olá Pessoal Name: Btn_Ola 4. Dê um click duplo no botão e aparecerá no editor de código:

12


procedure TForm1.Btn_OlaClick(Sender: TObject); begin end; 5. Digite o seguinte comando entre o begin / end; MessageDlg('Olá Pessoal', mtInformation, [mbok], 0); 6. Execute a aplicação (Run). 7. Observe o código gerado Responda: O que ocorrerá se clicarmos no formulário?

PROJETO EM DELPHI O conceito de projeto em Delphi é baseado em um conjunto de arquivos necessários para gerar uma aplicação. Vamos destacar os principais arquivos: Extensão

.PAS .DPR

.DFM

Tipo e descrição

Criação

Arquivo Pascal: o código-fonte de uma unidade Pascal, ou uma unidade relacionada a um formulário ou uma unidade independente. Arquivo Delphi Project. (Contém código-fonte em Pascal.) 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. Delphi Compiled Unit: o resultado da compilação de um arquivo Pascal.

Desenvolvimento

Sim.

Desenvolvimento

Sim.

Desenvolvimento

Sim. Todo formulário é armazenado em um arquivo PAS e em um arquivo DFM.

Compilação

Arquivos de bitmap, ícone e cursor: arquivos padrão do Windows usados para armazenar imagens de bitmap.

Desenvolvimento: Image Editor

Apenas se o código-fonte não estiver disponível. Os arquivos DCU para as unidades que você escreve são um passo intermediário; portanto, eles tornam a compilação mais rápida. Normalmente não, mas eles podem ser necessários em tempo de execução e para edição adicional. Necessário apenas se opções de compilação especiais foram configuradas. Exigido apenas se opções

.DCU

.BMP, .ICO, .CUR

.CFG .DOF

Necessário para compilar?

Arquivo de configuração com opções de Desenvolvimento projeto. Semelhante aos arquivos DOF. Delphi Option File: um arquivo de texto Desenvolvimento

13


.DSK

com as configurações atuais para as opções de projeto. 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. Aquivo executável: o aplicativo Windows que você produziu.

Desenvolvimento

Compilação: Ligação (linking)

.EXE Backup do arquivo Pascal

.~PA

.TODO

Desenvolvimento

Pode ser ativado ou desativado através do Menu Tools – Editor Options - guia display – Item: Create backup file. Arquivo da lista to-do, contendo os itens Desenvolvimento relacionados ao projeto inteiro.

de compilação especiais foram configuradas. Não. Você deve excluí-lo se copiar o projeto em um novo diretório. Não. Esse é o arquivo que você vai distribuir. Ele inclui todas as unidades compiladas, formulários e recursos. Não. Esse arquivo é gerado automaticamente pelo Delphi, quando você salva uma nova versão do código-fonte. Não. Esse arquivo contém notas para os programadores.

O Delphi possui um mecanismo de gerência de arquivos de projeto informando os principais arquivos e seu path. Clique em View – Project Manager

A figura acima é um exemplo de um projeto inicial, ainda não salvo. O diretório padrão para criação dos arquivos é projects, obviamente devemos definir na gravação pasta e nomes de arquivos mais específicos.

.PAS E .DPR Para visualizarmos o código fonte da unidade (.PAS) em Delphi basta selecionarmos o code editor (F12). Para visualizarmos o código fonte no arquivo de projeto (.DPR) basta selecionarmos o menu Project – View Source. O arquivo de projeto é exibido em uma guia no code editor . Para fechar a guia basta clicar com o botão direito e escolher close page.

Unidades

14


Existem três tipos de unidades: unidades associadas aos formulários (as mais comuns), arquivos de unidade usados para armazenar funções e procedures, e arquivos de unidade usados para construir componentes. Vamos ver una unidade básica associada a um formulário: Unit Unit1; Interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs; Type Tform1 = class(Tform) procedure FormCreate(Sender: Tobject); private {Declarações privativas} public {Declarações públicas} end; var Form1: Tform1; implementation {$R *.DFM} procedure TForm1.FormCreate(Sender: Tobject); begin end; end.

15


O código acima, junto com o código de arquivo de projeto, é tudo de que precisa no Delphi para criar um executável que abre uma janela. Ele não fará muita coisa nesse ponto, mas é um programa Windows funcional, na sua forma mais simples. Veja os nomes na cláusula uses, do código acima. Trata-se dos nomes de outras unidades. Se você decidisse escrever várias funções e procedures úteis, poderia criar sua unidade, colocar todo seu trabalho útil nela e compilá-la para uso futuro. Vamos ver as partes que constitui a unidade: Cabeçalho da unidade - Um cabeçalho de unidade identifica o código como uma unit e é seguido pelo nome. Interface - Marca o início da parte unit interface, que é usada para declarar variáveis, tipos, procedures, etc. A parte interface determina o que nessa unidade está disponível para outras unidades e partes do programa. A parte interface termina com o início da parte implementation. Uses - A cláusula uses informa ao compilador quais bibliotecas de funções e procedures precisam ser compiladas no executável final. O Delphi coloca, automaticamente, várias delas lá para você. Type - A seção de declaração type é usada para a criação de tipos definidos pelo usuário. Esses tipos pode, então, ser usados para definir variáveis. Especificadores de visibilidade vêm após a cláusula type na parte da interface. Os seguintes especificadores são usados para controlar como os objetos aparecem para outros programas e objetos: Private - As declarações nessa seção são tratadas como públicas dentro do módulo, mas serão desconhecidas e não acessíveis fora da unidade. Public - As declarações nessa seção são visíveis e acessíveis fora da unidade. Var - Usado para declara varáveis e variáveis de objeto. Em uma unidade de formulário, var é usado na parte de interface (o Delphi coloca essa declaração para você) para declarar o formulário como uma instância do objeto Tform. Var também é usado para declarar variáveis na parte de implementação, assim como em procedures e funções. Implementation - É onde todas as funções e procedures que foram declaradas na parte interface serão realmente colocadas. Todas as declarações feitas aqui são privativas da unidade (não disponíveis para as outras unidades). {$R *.DFM) - Em uma unidade de formulário. O Delphi insere essa entrada para você. Ela liga o formulário ao seu arquivo.dfm. Não remova isso de seu programa, ou você terá problemas. O bloco de código a seguir é executado quando seu formulário é criado. Você deve colocar aqui, todo o código de inicialização que precise ser executado quando o formulário começar a ser carregado. Para criar essa procedure, use o Object Inspector para ver o menu Events do formulário e, depois, dê um click duplo no evento OnCreate. End. - É o end final, significa o final de sua unidade. É importante manter os cabeçalhos, as cláusulas, etc no lugar correto. O Delphi cuida muito bem disso para você, pois ele cria a unidade e o código à medida que são feitas alterações no formulário. Você simplesmente insere seu código na seção correta, conforme for necessário.

16


OPÇÕES DE PROJETO O Delphi permite a configuração de vários itens do sistema através do menu Project – Options.

Forms • •

Main form - Nesta guia permite a escolha do formulário principal da aplicação. Available form - Os formulários available (disponíveis) em caso de criação em tempo de execução.

Application •

• •

Title - Define um nome para a sua aplicação diferente do nome do arquivo de projeto (.DPR). Help file – Define o nome do arquivo de Help (.HLP) associado à aplicação. Icon – Define o ícone utilizado no arquivo executável. (.EXE)

Compiler •

Estas opções permitem especificar uma compilação personalizada , ou seja, cada projeto pode ser compilado com uma característica.

Linker •

Estas opções incluem informações para a depuração.

Directories/Conditionals •

Nesta guia pode-se configurar o diretório de saída para os arquivos gerados pela aplicação.

Version Info •

Estas informações podem ser visualizadas no Windows através do menu rápido do mouse no arquivo executável.

Packages •

Os packages permitem um controle de distribuição através de DLL’s básicas externas ao executável entre outros recursos.

CONVENÇÃO DE NOMEAÇÃO

17


A propriedade mais importante de um componente é a propriedade Name. É ela que define o nome interno com relação ao código escrito em Object Pascal. Para organizar e facilitar o processo de desenvolvimento/manutenção do sistema, grande parte dos desenvolvedores adota uma nomenclatura para tornar o código mais legível possível. O Delphi adota como nomenclatura padrão o nome da classe da qual o componente é instanciado e um número crescente de acordo com o número de ocorrência deste componente no form. Exemplo: Button1, Button2, etc... são componentes instanciados da classe TButton . Não é obrigatória a utilização da convenção de nomes utilizados nesta apostila, mas é muito importante fazer uso de uma convenção mais clara possível.

Exemplo: Nome gerado pelo Delphi

Button1 Edit1 Label1

Objetivo

Sair da aplicação Receber nome do usuário Indicar componente Edit

Convenção

BtnSair EdtNome LblNome

A Lista de Units A janela de lista de units permite que você alterne entre as units que fazem parte do projeto ativo, sem que elas tenham de estar todas abertas no editor de código. Caso você selecione uma unit que não esteja aberta, o Delphi a abrirá e mostrará no Code Editor.

Figura 31 – A Lista de Units

A lista de units pode ser ativada através do menu View, opção Units... , ou através do primeiro ícone inferior da SpeedBar ou através da combinação das teclas .

A Lista de Forms

18


A janela de lista de forms permite, de forma análoga à de lista de units, que você alterne entre os forms que fazem parte do projeto ativo, sem que eles tenham de estar todos abertos. Caso você selecione um form que não esteja aberto, o Delphi o abrirá e mostrará para edição no Form Designer .

A lista de forms pode ser ativada através do menu View, opção Forms..., ou através do segundo ícone inferior da SpeedBar ou através da combinação das teclas .

A Lista de Janelas A janela de lista de janelas do ambiente, embora menos utilizada do que as de lista de units e forms, apresenta uma forma rápida de encontrar-se uma janela, que esteja escondida atrás de muitas outras.

A lista de janelas pode ser ativada através do menu View, opção Window List..., ou através da combinação das teclas <0>.

Prática 2 - Exercício de Gerenciamento de Projetos 1. Finalidade: Demonstração das diversas forma de Gerenciamento de Projetos 2. Roteiro:

a. Crie uma pasta Aulas Delphi e dentro desta outra Gerencia de Projeto

19


b. Inicialize o Delphi c. Insira um Label com Caption 'Formulário 1' d. Salve o projeto com Projeto_1 e a unidade com Unit_1. Através de: Opção File Save All do Menu File Opção File Project AS do Menu File 4º ícone superior do Speed Bar (SB) (Projeto) 3º ícone superior do Speed Bar (SB) (Unidade) e. Observe o código de Unit_1 f. Insira novo formulário ao Projeto Opção New do Menu File Opção New Form do Menu File 4º ícone inferior do SB g. Salve a unidade com Unit_2 h. Insira novo formulário ao Projeto utilizando opção diferente da 1ª. i. Salve a unidade com Unit_3 Observe que as unidades podem ser selecionadas pelas guias, que ou o clique no 3º ícone inferior do SB alterna entre unidade e formulário ou utilizando o 1º ou 2º ícone inferior do SB.. j. Salve todo o Projeto k. Remova a Unit_2 do Projeto Botão Remove da Opção Project Manager do Menu View No Project Manager, botão direito sobre o nome do projeto ou unit, opção Remove File ... Opção Remove from Project do Menu Project 7º ícone superior do SB l. Adicione a Unit_2 ao Projeto No Project Manager, clicar com botão direito sobre o nome do projeto, opção Add ... Opção Add to Project do Menu Project 6º ícone superior do SB m. Observando o código do Projeto Opção View Source do Menu Project - Observe seu nome na Guia de Units (para fechar utilize botão direito do mouse - Opção Close Page) n. Atente para a cláusula uses e seu código (begin ... end.) Qual o formulário que será criado quando a aplicação for executada? p. Execute a aplicação e vamos conferir qual o formulário criado. q. Feche a aplicação

20


r. Alterando o formulário principal do Projeto Opção Options do Menu Project, observando o nome do formulário da ListBox Main Form s. Altere o nome do formulário principal para Unit_2 t. Observe o código do Projeto e execute-o u. Torne a Unit_2 disponível v. Observe o código do projeto O que ele nos informa?

w. Feche a Aplicação x. Abra novamente a aplicação e observe quantos forms são trazidos para você inicialmente Para ativar os forms que deseja trabalhar, utilize o 2º ícone inferior do SB ou View Project Manager, selecione o form, clique com botão direito e escolha a opção Open.

Modularização É muito indicado que você modularize o seu projeto. Isto implica também em não misturar funcionalidades diferentes na mesma unit. Como assim? Você não deve colocar strings nem valores constantes diretamente no código. Isto aumenta o trabalho quando for necessário alterar determinado valor. Teremos que procurar em todos os módulos para saber onde fazemos referência àquele valor. E cuidado para não confundir com uma mesma constante que possua, por coincidência, o mesmo valor que a que estamos procurando. Para resolver este problema, você deve criar constantes e atribuir valores a estas constantes. Mas não defina estas constantes em qualquer unit. Crie uma unit que irá abrigar somente a definição das constantes do projeto. Você pode nomear esta unit com qualquer nome, exceto Const.Pas, porque const é uma palavra reservada.

Diretórios Via de regra, é aconselhado utilizar um diretório para cada projeto Delphi. Isto porque facilita bastante a identificação dos vários arquivos. Um dos pontos mais importantes de um projeto é saber quais arquivos são necessários para uma compilação completa (build). Quando temos mais de uma aplicação por diretório, esta identificação passa a ser um problema. Exemplo: C:\Sistema C:\Sistema\Doc C:\Sistema\Dados C:\Sistema\Dll C:\Sistema\Icones

21


Não perca este objetivo de vista: projeto e organização são os requisitos mais importantes para um bom desenvolvimento. Para aprendermos a depurar um programa, defina uma aplicação conforme o form e código abaixo:

unit Unit1; interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; type TForm1 = class(TForm) Button1: TButton; Edit1: TEdit; Edit2: TEdit; Label1: TLabel; procedure Button1Click(Sender: TObject); private { Private declarations } procedure SomaNum; public { Public declarations } end; var Form1: TForm1; implementation {$R *.DFM} procedure TForm1.SomaNum; var Value1, Value2, Total : integer; begin Value1 := StrToInt (Edit1.text); Value1 := StrToInt (Edit2.text); Label1.Caption := IntToStr(Value1 + Value2); end; procedure TForm1.Button1Click(Sender: TObject); begin

22


SomaNum; end; end.

Agora, execute o programa, introduza dois números pequenos, pressione o botão Ok e observe que o resultado está incorreto. Para descobrir por que, vamos usar o depurador para percorrer o código e ver o que aconteceu.

Definindo um Ponto de Quebra (BreakPoint) Um ponto de quebra permitirá que o programa seja executado normalmente, até encontrá-lo, e então o depurador parará na linha em esse ponto foi definido, sem executá-la. Para definir um ponto de quebra, dê um duplo clique na mediamiz (a área cinza à esquerda do código no editor) ao lado da linha para a qual você quer definir o ponto de quebra, ou então tecle na desejada. Na realidade, esses procedimentos ativam e desativam pontos de quebra.

O editor de código mostrando a mediatriz com um ponto de quebra assinalado

Execute o programa. digite 4 e 5 e depois pressione o botão Ok. O editor deve aparecer, mostrando a posição em que o ponto de quebra foi definido, conforme figura 27. Agora o ponto de quebra tem uma marca verde na mediamiz, mostrando que você parou neste ponto, e uma seta verde apontando para a direita aparece na mediamiz, mostrando sua posiçao no código. Esta linha ainda não foi executada, ou seja, a seta verde aponta para a próxima linha de execução.

23


O editor de código no modo debug, mostrando o programa interrompido em um ponto de quebra

Você pode definir pontos de quebra especiais que interromperão a execução apenas se certas condições ocorrerem ou em uma passagem por um loop em particular. Isto pode ser muito útil, se seu código falha somente em certas condições ou no meio de um loop muito grande. Para definir condições ou contagem de passagem, você usa a opção de menu Run | Add Breakpoint para acessar a caixa de diálogo Edit Breakpoint.

Opções de Depuração O menu Run do Delphi contém algumas opções de depuração adicionais, que têm toques de tecla de atalho correspondentes: Opção Run (F9) Step Over (F8) Trace Into (F7) Trace to Next Source Line (Shift F7) Runt to Cursor (F4) Show Execution Point Program Reset (Ctrk F2)

Significado Compila e executa iu, no modo depurador, continua a executar a partir desse ponto. Executa cada linha do código, mas não entra nas chamadas de funções e procedures. Permite que o depurador siga o código de uma chamada de função ou procedure. Segue até a próxima linha executável. Executa até a posição corrente do cursor, na janela do editor Coloca o cursor no ponto de execução corrente. Finaliza a execução do programa

Como examinar valores variáveis com Sentinelas Existem duas maneiras de examinar o valor armazenado em variáveis: usando sentinelas e usando o novo recurso ToolTip Expression Evaluation (que já foi discutido anteriormente). Uma sentinela permite que você especifique nomes de variável que deseja monitorar e apresentar seus valores numa pequena janela. Para inserir uma sentinela, você pode pressionar ou selecionar Run | Add Watch para acessar a caixa de diálogo Watch Properties, conforme a figura. Em uma sentinela, você pode especificar nomes de variável e expressões como Valor1 + Valor2 ou StrToInt(Valor1).

24


A caixa de diálogo Watch Properties

A janela Watch List

Na caixa de diálogo Watch Properties, digite Value1 na caixa de texto Expression. Isto cria a janela Watch List, onde as variáveis controladas e seus valores correntes serão apresentados, como na figura. Se a variável ainda não foi criada ou atribuída, várias mensagens serão apresentadas, indicando o status da variável em que o valor normalmente estaria. A mensagem pode indicar Process not accessible , o que significa que o código que cria essas variáveis não foi iniciado ou que ele terminou e as variáveis foram retiradas da memória. Você também poderia ver a mensagem Inaccessible here due to optimation , que normalmente significa que a variável ainda não foi atribuída. Quando as linhas de código que tratam da variável que você atribuiu uma sentinela são executadas, o valor é apresentado na janela Watch List.

COMENTÁRIOS Os comentários no código fonte são importantes e podem ser feitos através dos seguintes símbolos: //Comentário de linha { Comentário de bloco } (*Comentário de bloco *)

25


COMPONENTES Agora definiremos resumidamente os principais componentes do Delphi, bem como as suas principais propriedades e eventos. Logicamente, este material não se constitui num manual dos componentes do Delphi, mas sim visa introduzir o programador nos recursos disponíveis. Antes de iniciarmos as discussões sobre os componentes, iremos nos ater à explicação de algumas peculiaridades das propriedades dos componentes. O primeiro ponto a ser observado, está no fato de que algumas propriedades só são acessíveis em tempo de execução. Quando acontecer tal fato, chamaremos atenção a esse respeito. Finalmente, existem propriedades onde o Delphi incorpora um construtor de valores. Para estes casos, aparece um botão com reticências no canto da coluna valor, do Object Inspector, isto quando a propriedade é selecionada. Para abrir o construtor de valores basta um clique neste botão, ou um duplo clique na propriedade. É bom lembrar que ao criarmos uma aplicação, um dos detalhes mais importantes que devem ser considerados é a interface com o usuário. Porque se ela for feia ou difícil de ser entendida será mal usada e isto é a linha que divide o sucesso do fracasso no ramo de software. O que se segue é uma referência dos componentes de interface mais utilizados. Vamos considerar alguns objetos e suas principais propriedades, métodos e eventos.

Principais Eventos Os eventos recaem em três categorias: de Mouse, de teclado, ou de Sistema. A maioria dos componentes possui um evento padrão. Para verificar isso dê um duplo clique sobre o componente no formulário.Os três eventos padrão são OnChange, OnClick e OnCreate, nesta ordem. Se um componente não responder a nenhum deles, significa que ele não possui evento padrão. Verificação: Dê um duplo clique na área do formulário e terá seu evento padrão, depois faça o mesmo no Label. Insira um Edit e dê um duplo clique. Evento OnChange OnClick OnDblClick OnEnter OnExit OnMouseDown OnMouseMove OnMouseUp OnKeyDown OnKeyPress OnKeyUp OnDragDrop OnDragOver OnEndDrag OnStartDrag

Descrição Acontece quando o objeto ou seus dados mudam Clique simples do mouse sobre o componente ou Enter no componente Duplo clique do mouse sobre o componente Ocorre quando o componente recebe foco Ocorre quando o componente perde foco O botão do mouse é pressionado sobre o componente O ponteiro do mouse passa sobre o componente O botão do mouse é liberado sobre o componente Uma tecla é pressionada. É enviado para o componente com o foco de entrada. Uma tecla de caractere é pressionada. Idem Uma tecla é liberada. Idem O componente está sendo arrastado e é solto num local permitido O componente está sendo arrastado e passa sobre outro componente O componente está sendo arrastado e é solto num local permitido ou não Acontece quando o usuário começa a arrastar; é enviado para o componente que originou a operação de arrasto.

26


Principais Métodos Método BringToFront CanFocus Create Destroy Focused Free Hide SetFocus SendToBack Show Clear

Descrição Coloca o componente na frente dos outros Determina se o controle pode receber o foco Cria uma instância do componente Destrói a instância. Na verdade, deve-se utilizar o Free Retorna se o foco está sobre o componente Destrói a instância e desaloca a memória Torna o controle invisível Faz com que o controle receba o foco Coloca o componente atrás dos outros Torna o controle visível Limpa o conteúdo do componente

Objeto – Form (Formulário) Paleta – Standart Importância: É o principal componente container pois permite posicionar os demais componentes em si mesmo. É literalmente a implementação do conceito de ‘janelas’ do sistema operacional Windows.

Propriedades ActiveControl Align AutoScroll AutoSize BorderIcons BorderStyle

BorderWidth Caption ClientHeight / ClientWidth Color Cursor DefaultMonitor Enabled Font FormStyle

Permite definir qual o primeiro componente a receber foco assim que o formulário é criado. Altera o alinhamento e preenchimento do objeto. Permite habilitar as barras de rolagem. Determina se o controle será automaticamente redimensionado. Determina os ícones a serem exibidos na barra de título do formulário. Define o estilo da borda do formulário. bsDialog – Borda não redimensionável, comum em caixa de diálogo bsSingle – Borda simples e redimensionável. bsNone – Borda invisível, não redimensionável, sem botões de controle. bsSizeable – Borda padrão redimensionável. Define a espessura da borda. Indica o rótulo exibido para o componente. Define a altura e largura da área cliente. Define a cor de fundo de um componente. Indica a imagem exibida pelo ponteiro do mouse quando este ficar sobre o objeto. Associa o form a um monitor específico em uma aplicação que utiliza vários monitores. Define se o componente está habilitado ou não. Permite controlar os atributos do texto exibido em um componente. Determina o estilo do formulário. fsNormal – Definição padrão do formulário. fsMDIChild – O formulário será uma janela-filha de uma aplicação MDI.

27


Height HelpContext HelpFile Hint HorzScrollBar Icon KeyPreview Left Menu Name PopupMenu Position ShowHint Tag Top VertScrollBar Visible Width WindowMenu WindowState

fsMDIForm – O formulário será o formulário-pai de uma aplicação MDI. fsStayOnTop – O formulário permanece sobre todos os outros formulários do projeto, exceto aqueles que também têm a propriedade FormStyle igual a fsStayOnTop. Define a altura do objeto. Define o tópico do arquivo help que será exibido ao pressionar a tecla F1. Define um arquivo de help específico. Permite exibir um texto de auxílio no momento em que o ponteiro do mouse permanece sobre o controle. Define o comportamento de uma barra de rolagem horizontal. Define o ícone que será usado pelo formulário. Define se o formulário deve ou não responder a um pressionamento de tecla, através do evento OnKeyPress, por exemplo. Define a coordenada da extremidade esquerda de um componente. Permite escolher entre mais de um componente MainMenu. Define o nome interno que identifica o componente dentro da aplicação. Define o componente PopupMenu a ser utilizado pelo objeto. Permite definir o tamanho e posição de um formulário no momento em que ele aparece na sua aplicação. Define se a string de auxílio deve ou não ser exibida quando o usuário mantém o ponteiro do mouse sobre um controle. A propriedade Tag é uma variável do tipo Longint que o Delphi coloca à disposição do usuário, que pode atribuir o significado mais conveniente. Define a coordenada da extremidade superior de um componente. Define o comportamento de uma barra de rolagem vertical. Define se o componente aparece ou não na tela. Define a largura do objeto. Permite definir qual o menu responsável por manipular as janelas-filhas de uma aplicação MDI. Define o estado de exibição de um formulário.

Métodos Show ShowModal Close

Exibe o formulário de manipulação não-modal. Exibe o formulário de manipulação modal. Permite fechar o formulário.

Objeto – Button1 (Botão) Paleta – Standart Importância: É um dos objetos mais utilizados para confirmar e disparar rotinas associadas.

Propriedades Action Anchors

Referencia uma ação definida em um objeto TActionList. Permite manter a posição relativa do objeto ao objeto ‘parente’ quando este é redimencionado.

28


Associa o evento OnClick do objeto ao pressionamento da tecla Esc.

Cancel Associa ao evento OnClick do objeto ao pressionamento da tecla Enter.

Default ModalResult Parent... TabOrder TabStop

Propriedade utilizada para encerrar a execução de um formulário Modal quando selecionado um valor diferente de mrNone. As propriedades Parent permitem que o componente receba a mesma formatação do objeto proprietário. Define a ordem na passagem de foco no momento de pressionamento da tecla TAB. Define se o foco pára no componente.

Métodos SetFocus

Envia o foco do windows para o componente.

Objeto – Edit (Caixa de edição) Paleta – Standart Importância: Um dos principais componentes para a entrada de dados do usuário do sistema.

Propriedades AutoSelect

Define se o texto exibido pelo controle será selecionado quando este receber o foco da aplicação. AutoSize Para componentes TEdit a propriedade determina se a altura do controle será redimensionada quando o tamanho da fonte for alterado. BorderStyle Determina o tipo da borda do componente. CharCase Determina o se tipo da fonte será maiúscula, minúscula ou normal. HideSelection Define se o texto perde a seleção ao perder o foco. Maxlength Define um limite para a inserção de caracteres. PassoftwareordCh Define qual caractere será usado para ocultar o texto inserido no componente. ar Permite manipular os caracteres inseridos no componente pelo usuário.

Text Métodos Clear SetFocus

Limpa o conteúdo da propriedade text. Envia o foco do windows para o componente.

Exercício

29


Confeccione um formulário conforme esquema abaixo:

Funcionalidade: 1. As caixas de edição e os rótulos só ficarão habilitados se ‘Delphi’ for digitado na 1ª caixa 2. O botão Ok só ficará habilitado se o texto das últimas caixas forem iguais e diferentes de branco. Altere as seguintes props do formulário: Ctl3D = False, BorderStyle = bsDialog, Height = 225, Width = 280 e Position = poCenter Faça com que as teclas ou finalize a aplicação. Faça as três caixas de edição ficarem sem texto e que para cada caractere digitado um @ seja exibido. Faça com o acesso mnemônico aos rótulos ative a caixa de edição correspondente. Defina o evento para fechamento do formulário através do clique nos botões Desabilite o botão Ok, os dois últimos rótulos e as duas últimas caixas de edição.

Objeto – Label (Rótulo de orientação) Paleta – Standart Importância: Orientar o usuário à escolha de componentes bem como sua utilização.

Propriedades Alignment AutoSize

FocusControl

Define o alinhamento da string na área do componente. Para componentes TDBText e TLabel, esta propriedade define se o controle será automaticamente redimensionado para acomodar o texto. Define qual o componente receberá foco quando o usuário selecionar a combinação de teclas aceleradoras (atalho) se existir.

Layout ShowAccelChar

Define o alinhamento vertical do texto na área do componente. Define se o caracter ‘&’ será um literal ou tecla de aceleradora (atalho). 30


Transparent WordWrap

Define se o fundo do componente será ‘transparente’ ou não. Define se o texto poderá utilizar o ‘retorno automático’ em caso de ultrapassar a largura definida e se a propriedade AutoSize estiver falsa.

Objeto – Memo (Memorando) Paleta – Standart Importância: Permite o usuário entrar com dados do tipo TStrings, compara-se à funcionalidade do software bloco de notas.

Exercício: Crie um formulário conforme lay-out abaixo Para as opções de Adiciona na Posição e Apaga Linha, a Caixa de Edição Linha, deve ser preeenchida com um valor menor que a da Caixa de Edição Total de Linhas A opção Apaga Tudo só poderá ocorrer após confirmação do usuário Antes de Carregar e Salvar Arquivo , verificar se o nome do arquivo foi fornecido na Caixa de Edição Arquivo A Caixa de Edição Total de Linhas deverá se alterar obviamente toda vez toda vez que o conteúdo do memo for alterado e o seu valor não pode ser alterado pelo usuário

31


Propriedades Lines MaxLength ReadOnly ScrollBars WantReturns WantTabs

Propriedade do tipo TStrings que contém as linhas de texto do componente. Define o limite máximo de caracteres no componente em sua propriedade Lines. Define se o componente é do tipo somente leitura. Define se o componente pode trabalhar com barras de rolagem. Define se a tecla ENTER será utiliza para ‘quebra de linha’.

Define a tecla Tab como tabulação ou mudança de foco. Caso falso podese utilizar CTRL+TAB para produzir o efeito desejado.

Métodos LoadFromFile SaveToFile

Permite ‘carregar’ um arquivo para a propriedade Lines. Permite salvar o conteúdo da propriedade Lines em um arquivo especificado.

Objeto – CheckBox (Caixa de verificação) Paleta – Standart Importância: Permite verificar opções boolenas pré-definidas ou re-definidas pelo usuário.

Propriedades AllowGrayed

Define caso verdadeiro, três estados possíveis para o checkbox: checked (ligado), unchecked (desligado) e grayed (parcial). Caso falso, dois estados: checked (ligado) e unchecked (desligado). Define se o componente está ligado ou não, caso tenha apenas dois estados.

Checked State

Permite definir três estados se AllowGrayed for verdadeiro.

Exercício

Confeccionar uma aplicação conforme lay-out abaixo. Defina o codigo inicialmente prevendo que os CheckBoxs tenham a prop. AllowGrayed = False e execute. Depois defina o código com essa prop. = True Funcionalidade: Ao se marcar um item, adicionar 1 na Caixa de Edição Total de Itens assinalados. E ao se desmarcar um, decrementar o valor desta Caixa.

32


Objeto – RadioButton (Botão de ‘radio’) Paleta – Standart Importância: Permite escolher entre um grupo, pelo menos uma opção.

Propriedades Define se o componente está ligado ou desligado.

Checked

Exercício Confeccionar uma aplicação conforme lay-out abaixo. Insira primeiro o GroupBox e depois os botões de rádio. Observe que é interessante definir acessos mnemônicos para os botões. Funcionalidade: Para “Nada a Fazer”, tire a marca do botão assinaloado e para “O que Fazer” exiba como mensagem o Caption do botão assinalado.

33


Objeto – ListBox (Caixa de listagem) Paleta – Standart Importância: Permite o usuário entrar ou manipular uma lista de dados.

Propriedades Define uma lista de Strings que aparece no componente.

Items MultiSelect Sorted

Permite selecionar vários itens (Strings) no componente. Define se a lista de Strings será ordenada ou não.

Métodos Clear LoadFromFile SaveToFile

Permite limpar o conteúdo da propriedade Items. Permite ‘carregar’ um arquvo para a propriedade Items. Permite salvar o conteúdo da propriedade Items para um arquivo.

Objeto – ComboBox1 (Caixa de listagem em formato de cortina) Paleta – Standart Importância: Permite o usuário entrar ou manipular uma lista de dados.


Items Sorted

Define se os dados serão ordenados. Define o texto atual da Combobox.

Text



34


Exemplo: Insira uma ComboBox num formulário limpo e defina as propriedades: Sorted = True, Style = csSimple (redimensione a caixa para poder ver parte dela) No evento OnKeyPress, defina If key = # 13 then // Se teclou Begin if (ComboBox1.Text <> ‘’) and (ComboBox1.Items.IndexOf(Combox1.Text) < 0) then // não duplic. ComboBox1.Items.Add(ComboBox1.Text); ComboBox1.Text := ‘’; Key := #0; End; Assim, toda vez que o for teclado, a digitação realizada será inserida na ComboBox.

Exercício:



Utilizando a figura abaixo, produzir um aplicação que apresente a seguinte funcionalidade: pressionamento do botão Adicionar, aciona o nome escrito na caixa de texto na ComboBox.



pressionamento do botão Nova, habilita o botão Adicionar, seta o foco da aplicação na Caixa de texto, desabilita o botão Nova e Excluir.



pressionamento do botão Limpar, limpa o conteúdo da Caixa de Texto e todos os elementos da ComboBox.



pressionamento do botão Fechar encerra a aplicação.



No evento click da ComboBox os botões Nova e Excluir ficam habilitados e Adicionar desabilitado.

35


Objeto – ComboBox1 (Caixa de listagem em formato de cortina) Paleta – Standart Importância: Permite o usuário entrar ou manipular uma lista de dados.


Items Sorted

Define se os dados serão ordenados. Define o texto atual da Combobox.

Text



Objeto – GroupBox (Caixa de agrupamento) Paleta – Standart Importância: Permite agrupar componentes e estabelecer um título na propriedade Caption.

Propriedades Align Caption

Pemite definir um alinhamento no objeto proprietário. Define o texto informativo na parte superior do componente.

Objeto RadioGroup (Grupo de botões ‘radio’)

36


Paleta – Standart Importância: Permite estabelecer um grupo de botões de radio e manipula-los pela propriedade ItemIndex.

Propriedades Items ItemIndex Columns

Define os itens disponíveis ao usuário. Define qual dos itens está selecionado. Define o número de colunas para organização dos componentes.

Exercício 1: Utilizando-se da interface mostrada na figura abaixo, produzir uma aplicação que apresente a seguinte funcionalidade:  O Clique no botão OK deverá incrementar a quantidade de votos de cada equipe e a quantidade de entrevistados dos dois sexos.  Sexo é um RadioGroup e as demais caixas GroupBox

Exercício –2: Defina uma aplicação para conforme o lay-out abaixo. Linguagem e Verbo são GroupBox Adjetivo é um RadioGroup Em tempo de projeto ative um botão de cada agrupamento

37


Alterar o conteúdo da Caixa de Edição Frase quando qualquer uma das Caixas for alterada.

Objeto – Panel (Painel) Paleta – Standart Importância: Permite agrupar outros objetos e estabelecer um efeito visual nas aplicações.

Propriedades

Align Bevel... BorderStyle

Define o alinhamento do componente em relação ao seu proprietário. Define a característica das bordas (interna e externa) bem como sua espessura. Define o tipo da borda.

Exercício Utilizando uma Panel como Barra de Status para exibição de Dicas Flutuantes

Insira um Panel no formulário limpo e defina as propriedades: Align = alBottom Alignment = ta LeftJustify BevelInner = bvLowered Caption = (nenhum) 38


Manipulador para o evento OnClick do Panel digite: Panel1.Caption := Application.Hint Vá no Object Inspector e exclua a conexão do Panel com esse manipulador. Através do menu Search | Replace, troque as ocorrências Panel1Click para DoShowHint.

No manipulador de evento OnCreate do formulário, digite: Application.OnHint := DoShowHint; Insira alguns componentes no formulário e defina dicas através da prop. Hint. Seja criativo. Execute Observe que sempre que o cursor estiver sobre um dos componentes, a dica aparecerá na Barra de status. Poderá ocorrer algum problema se a dica da Barra de status for muito grande e o componente também utiliza dica instantânea (showHint = True), que geralmente é curta. Para resolver isso, selecione um componente e na prop. Hint defina “dica instantânea” | “dica flutuante”. Assim, quando o cursor passar sobre o componente, o texto da dica instantânea será exibida próximo ao mesmo e o texto da dica flutuante, na linha de status.

Objetos – MainMenu e PopupMenu (Menu principal e Menu rápido) Paleta – Standart Importância: Define os Menus utilizados pelo usuário pelo botão esquerdo (MainMenu) ou pelo botão direito (PopupMenu) do Mouse.

Propriedades Items Images

Define um novo item de Menu. Define um objeto do tipo ‘ImageList’.

39


O objeto MainMenu permite a construção de sub-menus através de seu construtor clicando no item com o botão direito e escolhendo a opção Create submenu. Pode-se também excluir ou incluir items aleatoriamente através do botão direito no item desejado. Para criar um separador de menus, utilize o operador de subtração (‘-‘) e confirme com a tecla Enter.

Diferentes pápeis dos itens de menu Independentemente da posição deles na estrutura dos menus, há três tipos fundamentais de itens de menu: Comandos: São itens de menu usado para dar um comando, para executar uma ação. Eles não oferecem nenhuma pista visual. Definidores de Estado: São itens de menu usados para alternar uma opção entre ligado e desligado, para mudar o estado de um elemento em particular. Quando há dois estados, estes comandos usualmente têm uma marca de verificação à esquerda se estiverem ativos. Neste caso, selecionar o comando produz a ação oposta. Itens de Diálogo: São itens de menu que fazem com que uma caixa de diálogo apareça. A real diferença entre estes e os outros itens de menu é que o usuário terá condições de explorar os possíveis efeitos da caixa de diálogo correspondente e de finalmente abortá-los através do botão Cancelar da caixa. Esses comandos devem ter uma pista visual, que consiste em três pontos após o texto. Isto não é obrigatório do ponto de vista técnico, mas é tão comum que você não deve ignorar esta diretriz.

Mudando itens de menu em tempo de execução A estrutura de um menu pode mudar numa série de maneiras, mas as mais importantes se aplicam a itens individuais. Como por exemplo, quando um comando de menu não pode ou não deve ser selecionado (Prop. Enabled), usualmente ele assume a cor cinza. Neste caso o usuário não tem a chance de usar esse comando. Outra mudança visual é o uso da marca de verificação (Prop. Checked), que pode ser substituída por duas legendas diferente (Prop. Caption) para os dois estados do item, como por exemplo: Exibir Lista e Ocultar Lista.

Editando um menu com o Menu Designer (MD) O Delphi possui em editor especial de menus, o Menu Designer. Para invocar esta ferramenta, coloque um componente de menu num formulário e dê um clique duplo sobre ele ou na sua propriedade Items ou dê um clique com o botão direito do mouse sobre ele e escolha essa opção. Não se preocupe demasiadamente com a posição do componente de menu do formulário, uma vez que isso não afetará o resultado; o menu é colocado apropriadamente abaixo da Barra de Título do formulário.

40


Observação: Para ser mais preciso, o formulário exibe, abaixo de sua legenda, o menu indicado em sua propriedade Menu, a qual é definida por padrão tão logo você insira o primeiro componente de menu principal do formulário. Se o formulário tiver mais de um componente de menu principal, esta propriedade deve ser definida manualmente e pode ser mudada tanto em tempo de projeto como em tempo de execução. Para criar o seu menu dentro do Menu Designer basta escrever o texto dos comandos. Para se criar menus suspensos de segundo nível dê um clique com botão direito do mouse sobre o item desejado e selecione o comando Create Submenu ou pressione simultaneamente <→ >. Você também pode utilizar as teclas e para inserir e deletar itens de menu respectivamente e as setas de direção para navegar entre os itens de menu. Para adicionar um separador ao menu suspenso, simplesmente insira um hífen como texto do comando, sendo que o separador não responde ao evento OnClick.

Atalhos de Menu Uma característica comum dos itens de menu é que eles contêm uma letra sublinhada, pode ser a 1ª ou uma letra do meio. E ao pressionar + letra, ativa menu suspenso correspondente. Obviamente, cada elemento da barra de menus deve ter uma letra sublinhado diferente. O mesmo é verdadeiro para os itens de menu de um menu suspenso específico. Para determinar a letra sublinhada, simples coloque & antes dela na definição do item. Os itens de menu podem ter também teclas de atalho (p.e. ). Para associar uma tecla de atalho a uma item de menu (menus suspensos as possui) selecione um valor para a propriedade ShortCut do item através das combinações padrões.

Mudando Itens de Menu Três propriedades são usadas para modificar um item de menu. Usamos a propriedade Checked para adicionar ou remover uma marca de verificação dentro do item de menu. A propriedade Enabled pode é usada para dar a cor cinza a um item de menu a fim de que ele não possa ser selecionado pelo usuário. A última é a Caption, o texto do item de menu. Uma quarta operação com item de menu seria a sua remoção ou torná-lo invisível. Isso é facilmente realizado mudando-se o valor da prop. Visible para False. Sugere-se que você evite esta operação, pois o usuário pode confundir-se. É preferível desabilitá-lo temporariamente.

Associando Eventos a Itens de Menu A associação de um evento a um item de menu é fita semelhante à associação de um evento a qualquer componente. A única diferença é que ele não é visto como um componente, logo devemos selecioná-lo utilizando caixa de seleção do Obj Inspector ou utilizarmos o MD.

Exercício -1 1. Insira um Label no formulário e limpe sua legenda 41


2. Insira um MainMenu com 1 Menu suspenso e este com 3 itens de menu quaisquer. 3. Construa o código para que cada vez que selecionarmos um item de menu, a legenda do label receba a sua descrição 4. Execute a aplicação e depois remova os compoentes inseridos no formulário

Exercício –2: Confeccione a estrutura de Menu conforme layouts abaixo, observando os nomes dos menus suspensos e dos itens de menu. Para obtermos uma janela com melhor aparência altere a prop Color do formulário para clBtnShadow

Viajar Praias Ctrl P Montanhas Florestas 4 Casa da Vovó Regressar

Namorar Comer Cinema Aquilo Boite Sofá E Mais Aquilo Junto com Sogra No ..

Estudar Bye Bye Cobol Sobre Assuntos Espec. Religião

Menus Pop-Up ou SpeedMenus ( com o botão direito do mouse) (Standard) No Windows é comum ver aplicações que possuem menus locais especiais que você ativa dando um clique com o botão direito do mouse. O menu que é exibido - um menu pop-up em termos do Windows - usualmente depende da posição do clique do mouse. Estes menus tendem a ser fáceis de usar, uma vez que agrupam somente os poucos comandos relacionados ao elemento que está atualmente selecionado. Para adicionar menus pop-up na sua aplicação, execute algumas operações simples: 1. Insira um componente PopUpMenu no formulário 2. Adicione alguns itens de menu ao componente 3. Associe o componente à propriedade PopUpMenu do componente desejado 4. E obviamente, adicionar manipuladores de eventos para o OnClick dos itens de menu

Observações: A propriedade AutoPop = True faz o menu aparecer através do clique do botão direito sobre o componente. A propriedade Alignment determina onde o menu se abrirá. A parte superior do menu será a da posição do cursor do mouse, mas o alinhamento poderá ser à esquerda ou à direita ou no no centro do componente, dependendo do valor definido nesta propriedade. O PopUp Menu não deve ter submenus, pois por conveniência, eles devem ser rápidos e não possuem teclas de acesso mnemômico (Alt + letra).

42


Podem ter tecla de atalho (propriedade ShortCut). Mas atenção: Mesmo que menu não esteja associado a nenhum componente e também não esteja exibido, as teclas de atalho estarão disponíveis. Neste caso, para não acessar um item com este recurso, devemos desabilitálo. Um componente de menu suspenso recebe o evento OnPopUp antes que ele seja exibido. É a chance que temos de realizar qualquer preparação em seus itens, como desativar, ajustar marcas de verificação, etc...

ScrollBar (Standard) Paleta – Standart O componente ScrollBar serve como barra de rolamento vertical ou horizontal para seleção e/ou variação de um parâmetro.

O usuário pode modificar o valor representado pelo scrollbar de duas formas: clicando nas setas de incremento/decremento ou diretamente na barra. A primeira ação faz com que o valor representado sofra uma modificação menor (SmallChange) enquanto a segunda gera uma maior ( LargeChange LargeChange). Os limites inferior e superior da faixa de valores válidos para a ScrollBar são dados por Min e Max respectivamente. Estes limites representam o valor quando o cursor da barra estiver em cima ou à esquerda (Min) ou em baixo ou à direita (Max). O controle provê fácil e eficiente navegação por longa lista de itens ou grande quantidade de informação que não podem ser totalmente visualizadas nas suas áreas de exibição. Pode também ser usado como entrada de dados ou como mostrador de informações (valores numéricos).

Principais Propriedades Propriedade Kind LargeChange Max Min Position SmallChange

Descrição Define a direção da barra de rolagem Indica a variação da rolagem feita sem o uso das setas de movimentação Maior valor do ScrollBar Menor valor do ScrollBar Indica a posição atual do srollbar Indica a variação da rolagem feita com o uso das setas de movimentação

43


Principais Eventos Evento OnChange

Descrição Disparado quando o conteúdo da propriedade position é alterado pelo usuário, e ocorre imediatamente após o OnScroll Ocorre quando é feita a rolagem do ScrollBar

OnScroll

Principais Métodos Métodos SetParams

Descrição Modifica os valores das propriedades Position, Min e Max de uma só vez

FUNÇÕES DE CONVERSÃO E MANIPULAÇÃO Vamos quebrar nosso estudo sobre os componentes do delphi para falarmos sobre Casting e Conversões de tipos , pois estas funções serão importantes para futuras esplicações e atividades. Como já sabemos, não podemos atribuir uma variável à outra de um tipo diferente. Caso precise fazer isso, há duas opções. A primeira é casting e a segunda é utilizar uma função de conversão de tipos. Função

Objetivo

Chr

Converte um número ordinal em um caractere ANSI

Ord

Converte um valor do tipo ordinal em um número que indica sua ordem

Round

Converte um valor real em um valor inteiro, arrendondando seu valor

Trunc

Converte um valor real em um valor inteiro, truncando seu valor

Int

Retorna a parte inteira do argumento de valor de ponto flutuante

IntToStr

Converte um número em uma string

IntToHex

Converte um número em uma string com sua representação em hexadec.

StrToInt

Converte uma string em um número, levando uma execeção se a string não representa um número inteiro válido

StrCopy

Copia uma string estilo Pascal em uma string terminada em nulo

FloatToDecimal

Converte um valor de ponto flutuante em registro incluindo sua representação decimal (expoente, dígito, sinal)

FloatToStr

Converte um valor de ponto flutuante para sua representação string usando representação padrão

FloatToStrF

Converte um valor de ponto flutuante para sua representação string usando a formatação especificada

StrToFloat

Converte uma string Pascal em um valor de ponto flutuante

TextToFloat

Converte uma string terminada em nulo em um valor de ponto flutuante

DateToStr(Date: TdateTime)

Converte um dado TDateTime em String.

DateTimeToStr(DateTime:

Converte um dado TDateTime em String.

44


TDateTime) StrToDate (const S: String)

Converte um dado String em tipo TDateTime.

StrToDateTime(const S: String)

Converte um dado String em tipo TDateTime

FormatFloat(const Format: string; Value: Extended): string

Permite formatar um tipo ponto flutuante retornando uma string. Edit2.Text := FormatFloat('###,###.00',soma); Sendo soma uma variável real.

EXEMPLOS: Armazenar a data e hora atuais em uma variável Var InicioAtual : TDateTime; Begin Atual := Now;

Exibir a data e a hora na legenda de Labels Label1.Caption := DateToStr(Atual); Label2.Caption := TimeToStr(Atual);

O tipo TDateTime é internamente manipulado como tipo Ponto Flutuante.

PROCEDURES E FUNÇÕES Procedimentos e funções são blocos de código (rotinas) em Object Pascal que podem ou não receber parâmetros (valores) para processamento. Uma vez definida a rotina pode-se ativa-la de diversas partes do programa através de seu nome. A grande diferença entre as formas de definição destas rotinas (se procedimentos ou funções) está no fato de que: • Procedimento – NÃO retorna valor. • Função – Retorna valor.

DECLARAÇÃO E ATIVAÇÃO DE PROCEDIMENTO Podemos declarar um procedimento da seguinte maneira maneira: Dentro da cláusula private ou public, defina a declaração do procedimento: procedure Soma(X, Y: String);

Com o cursor posicionado na mesma linha, pressione: CTRL+SHIFT+C e perceba que o próprio Delphi realiza a construção do procedimento dentro da cláusula implementation.

45


Esse recurso é chamado Class Completion. Nossa tarefa é apenas definir o código a ser realizado pelo procedimento. procedure TForm1.Soma(X, Y: String); begin Label1.Caption := FloatToStr(StrToFloat(X)+StrToFloat(Y));

end;

Supondo a existência de dois componentes Edit , um componente Button e um componente Label, este código pode ser ativado da seguinte forma: procedure TForm1.Button1Click(Sender: TObject); begin Soma(Edit1.Text, Edit2.Text);

end;

DECLARAÇÃO E ATIVAÇÃO DE FUNÇÕES A construção de funções tem o mesmo raciocínio diferindo na característica de retorno da função. Podemos declarar um procedimento da seguinte maneira maneira: Dentro da cláusula private ou public, defina a declaração da função: function Subtrai(X, Y: String): String;

Observe que agora, depois dos parâmetros há um tipo de definição de retorno da função (String). Pode-se utilizar a mesma dica de construção do procedimento, na linha da declaração tecle CTRL+SHIFT+C (Class Completion) e perceba que o próprio Delphi realiza a construção da função dentro da cláusula implementation. Nossa tarefa é apenas definir o código a ser realizado pela função. function TForm1.Subtrai(X, Y: String): String; begin result := FloatToStr(StrToFloat(X)-StrToFloat(Y));

end;

A palavra reservada result é o recurso usado pela Object Pascal para estabelecer o retorno da rotina. Não se deve declarar esta variável, ela é declarada no momento da utilização da função. Supondo a existência de dois componentes Edit , ‘um’ componente Button e um componente Label, esta função pode ser ativada da seguinte forma: function TForm1.Button2Click(Sender: TObject); begin Label1.Caption := Subtrai(Edit1.Text, Edit2.Text);

end;

Neste caso, o Label recebe o result de subtrai, ou seja, a subtração dos dados passados nos parâmetros.

46


DECLARAÇÕES CRIADAS AUTOMATICAMENTE PELO DELPHI Se você é um bom observador, percebeu que o Delphi também gera as declarações e seus respectivos procedimentos quando você deseja manipular um determinado evento.

CAIXAS DE DIÁLOGO Podemos utilizar alguns tipos de caixas de diálogo pré-definidas pelo Delphi facilitando em muito o desenvolvimento pela ferramenta:

ShowMessage

A caixa de diálogo ShowMessage é declarada internamente pelo Delphi desta forma: procedure ShowMessage(const Msg: string);

Onde o parâmetro Msg é um dado String. Exemplo: ShowMessage(‘Um texto ou propriedade string será exibida.’);

MessageDlg

A caixa de diálogo MessageDlg é declarada internamente pelo Delphi desta forma: function MessageDlg(const Msg: string; DlgType: TMsgDlgType; Buttons: TMsgDlgButtons; HelpCtx: Longint): Word;

Onde: const Msg: string

É uma constante string ou propriedade deste tipo. mtWarning Contém um ícone exclamação amarelo.

mtError Contém um ícone vermelho de ‘parada’.

DlgType: TmsgDlgType

mtInformation Contém um ícone ‘i’ azul.

mtConfirmation

Contém uma interrogação verde.

mtCustom Não contém BitMap.

Buttons: TMsgDlgButtons HelpCtx: Longint

mbYes mbNo mbOK mbCancel mbAbort mbRetry mbIgnore mbAll mbNoToAll mbYesToAll mbHelp Define um número para o help de contexto. Por padrão, zero ‘0’.

47


O retorno da função é o tipo do botão como mr Desta maneira pode-se fazer testes lógicos como no exemplo: if MessageDlg(‘Deseja sair?’, mtConfirmation, [mbYes, mbNo], 0)=mrYes

then

Application.MessageBox

Uma outra caixa de diálogo é o método MessageBox do objeto Application. Esta função está definida da seguinte maneira: function MessageBox(const Text, Caption: PChar; Flags: Longint): Integer;

Onde: const Text Caption: PChar

Flags

É uma constante string ou propriedade deste tipo. Define uma string para o título da janela. Define os botões, ícones e a possibilidade de focar um determinado botão. Os valores para botões são: MB_ABORTRETRYIGNORE, MB_OK, MB_OKCANCEL, MB_RETRYCANCEL, MB_YESNO, MB_YESNOCANCEL Os valores para os ícones são: MB_ICONEXCLAMATION, MB_ICONWARNING, MB_ICONINFORMATION, MB_ICONASTERISK, MB_ICONQUESTION, MB_ICONSTOP, MB_ICONERROR, MB_ICONHAND Os valores para a definição do botão default pode ser: MB_DEFBUTTON1, MB_DEFBUTTON2, MB_DEFBUTTON3, MB_DEFBUTTON4

O retorno da função é o tipo do botão como

id (IDABORT IDCANCEL IDIGNORE IDNO IDOK IDRETRY IDYES)

Desta maneira pode-se fazer testes lógicos como no exemplo: if Application.MessageBox('Texto','Título',MB_YESNOCANCEL MB_ICONINFORMATION + MB_DEFBUTTON2) = IdYes then

+

48


CAIXAS DE ENTRADA Podemos obter dados do usuário através de caixas de diálogo pré-defindas. InputBox

A função InputBox retorna um tipo String, que é dado digitado pelo usuário na sua utilização. Sua definição interna é a seguinte: function InputBox(const ACaption, APrompt, ADefault: string): string;

Onde: const ACaption APrompt ADefault

Define o título da janela Define um rótulo para orientação dentro da caixa. Define um valor default para a caixa.

Exemplo: InputBox('Título da janela','Descrição','Valor Padrão')

InputQuery

A função InputQuery retorna um tipo Booleano, o dado digitado pelo usuário será colocado em uma variável do tipo string previamente declarada. Sua definição interna é a seguinte: function InputQuery(const ACaption, APrompt: string; var Value: string): Boolean;

Exemplo: if InputQuery('Título', 'Descrição', aux) and (aux <> '') then

49


Neste exemplo acima, a janela só retornará verdade se houver algum valor digitado e o usuário clicar no botão OK, caso contrário o retorno será falso.

Exemplo

Vamos examinar uma unit e exemplicar os principais conceitos: type TForm1 = class(TForm) Button1: TButton; Edit1: TEdit; Edit2: TEdit; Label1: TLabel; procedure Button1Click(Sender: TObject); function Soma(X, Y: String): Integer; // definida pelo desenvolvedor

private { Private declarations } aux: Integer; // variável privada

public { Public declarations } frase: String; //variável pública end;

var Form1: TForm1;

implementation {$R *.DFM}

const MAX = 50; // definição de constante procedure TForm1.Button1Click(Sender: TObject); var titulo: String; // variavel local i: Integer;

begin if (Edit1.Text <> '') and (Edit2.Text <> '') then //atribui à variavel private - aux o retorno da função soma aux := Soma(Edit1.Text,Edit2.Text); titulo := 'Curso de Delphi'; //atribui à variàvel local frase := titulo+' – Versão 5'; //atribui à variavel public Form1.Caption := frase; //atribui à propriedade Caption do form ShowMessage('A soma dos valores é: '+IntToStr(Aux)); for i:=0 to MAX do Label1.Caption := IntToStr(i); end;

function TForm1.Soma(X, Y: String): Integer;

50


begin result := StrToInt(X)+StrToInt(Y);

end; end.

CHAMADA DE FORMS Uma característica importante da apresentação dos formulários em uma aplicação, é o fato de ser apresentado como MODAL ou NÃO-MODAL. Há dois métodos para executar a visualização, mas antes vamos entender como isso funciona. •

•

MODAL – O foco fica preso no formulário e não é liberado para outro form até que ele seja fechado. O usuário pode ativar outra aplicação do Windows, mas não poderá trabalhar em outra janela daquele programa cuja janela foi aberta como modal (até que seja fechada). NÃO MODAL – O foco pode ser transferido para outra janela sem que esta precise ser fechada.

Entendido este conceito, os métodos que o Delphi utiliza para apresentar os forms são: Show para apresentar forms NÃO-MODAIS, ou ShowModal para apresentar forms MODAIS.

COMPONENTES (VCL) Objeto – BitBtn (Botão com figuras opcionais)

Paleta – Additional Importância: Permite inserir figuras para uma melhor orientação do usuário, além de funções pré-definidas.

Propriedades

Glyph Kind

Define um Bitmap para o componente. (Arquivo com extensão .BMP) Define o tipo de Bitmap exibido pelo usuário. bkCustom Bitmap definido pelo usuário.

bkOk

Botão OK padrão, com uma marca de verificação na cor verde e propriedade Default igual a True.

bkCancel

Botão Cancel padrão, com um “x” na cor vermelha e propriedade Cancel igual a True.

bkYes

51


Botão Yes padrão, com uma marca de verificação na cor verde e propriedade Default igual a True.

bkNo

Botão No padrão, com uma marca vermelha representando um círculo cortado e propriedade Cancel igual a True.

bkHelp Botão de auxílio padrão, com uma interrogação na cor cyan. Quando o usuário clica sobre o botão, uma tela de auxílio deve ser exibida (baseada no código do desenvolvedor). bkClose Botão Close padrão, com o desenho de uma porta. Quando o usuário clica sobre o botão, o formulário a que ele pertence se fecha.

bkAbort

Botão Abort padrão, com um “x” na cor vermelha e propriedade Cancel igual a True.

bkRetry

Botão Retry padrão, com uma seta circular verde.

bkIgnore Botão ignore padrão, com o desenho de um homem verde se afastando.

bkAll

ModalResult

Botão All padrão, com uma marca de verificação dupla na cor verde e propriedade default igual a True. Permite encerrar a execução de um formulário Modal quando o seu valor for diferente de mrNone.

Objeto MaskEdit – (Caixa de edição com máscara)

Paleta – Additional Importância: Permite estabelecer uma máscara para a entrada de dados no componente. Pode ser considerado literalmente um componente ‘Edit com máscara’.

Propriedades CharCase Define o tipo dos caracteres. Permite definir uma máscara para entrada de dados. EditMask PassoftwareordC Define um caracter para ocultar a entrada de dados. har

A máscara definida na propriedade EditMask irá restringir os caracteres que o usuário pode entrar numa caixa de edição, isto evita que os usuários entrem com caracteres inválidos ou com formatos de dados indesejados para um determinado valor. Máscara de Telefone: !$9999$999-9999;1;_ A máscara é formada por três partes: a 1ª é a máscara propriamente dita, a 2ª consiste num caractere que define se os caracteres ou a máscara devem ser salvos como parte dos dados, a 3ª define o caractere usado para representar espaços em branco na máscara. Lista dos caracteres utilizados numa máscara 52


Caractere ! > < \ L l A a C c 0 9 # : / ; _ <>

Significado na Máscara Se um ! aparecer na máscara, caracteres em branco não são armazenados como dados Marca o início do bloco que deve ser convertido em letras maiúsculas, para fechar esse bloco esperase o caractere < Marca o início do bloco que deve ser convertido em letras minúsculas, para fechar esse bloco esperase o caractere > Define um caractere literal, ou seja, o caractere que segue a barra invertida \ é utilizado como caractere especial, fixo, que pode ser salvo como parte integrante do valor ou não. Requer a entrada de caractere alfabético (A-Z, a-z) nesta posição Permite a entrada de caractere alfabético (A-Z, a-z) nesta posição, mas não requer Requer a entrada de caractere alfanumérico (A-Z, a-z, 0-9) nesta posição Permite entrada caractere alfanumérico (A-Z, a-z, 0-9) nesta posição, não requer Requer um caractere qualquer nesta posição Permite um caractere qualquer nesta posição, mas não requer Requer um caractere numérico (0-9) nesta posição Permite um caractere numérico (0-9) nesta posição, mas não requer Permite um caractere numérico, um símbolo + ou -, mas não requer Usado como separador em dados horários. Se outro caractere separador é definido nos atributos internacionais do Painel de Controle do seu Sistema, este caractere será usado ao invés dos dois pontos Separador de dia, mês e ano. Idem com relação Painel de Controle Usado para separar as três partes que formam a máscara Insere espaço em branco automaticamente no texto Define que as letras maiúsculas e minúsculas serão armazenadas como digitadas

Objeto – SpeedButton (Botão para barra de ícones)

Paleta – Additional Importância: Permite ao usuário manipular os botões individuais ou através do conceito de grupo.

Propriedades Glyph GroupIndex AllowAllUp

Flat Down

Define um Bitmap para o componente. Permite agrupar um conjunto de SpeedButtons quando ao serem selecionados, tiverem a propriedade diferente de zero. Permite que o componente possa ter o relevo suspenso ao ser clicado. Só pode ser utilizado junto ao conceito de agrupamento. Define um efeito visual interessante. Permite determinar qual componente foi pressionado. Só pode ser utilizado junto ao conceito de agrupamento.

Exemplo:

53


Objeto – Image (Imagem)

Paleta – Additional Importância: Permite inserir uma figura para uso geral na aplicação.

Propriedades AutoSize Picture Stretch

Permite alterar o tamanho do componente baseado no tamanho da figura. Define a figura a ser exibida. Permite alterar o tamanho da figura baseado no tamanho do componente.

Métodos LoadFromFile

Permite ‘carregar’ um arquivo de figura na propriedade Picture.

Para trabalhar com imagens jpg, é necessário acrescentar na cláusula uses da interface a biblioteca jpeg.

Possibilita a exibição de uma figura (Bmp) Propriedade Picture Center Strech AutoSize

Significado Definição da figura do tipo BMP, ICO, WMF ou EMF Centraliza a figura em relação ao Quadro (objeto) Se True, adequa o tamanho da imagem com relação ao objeto Se True, adequa o tamanho do objeto com relação a imagem Contrário da propriedade Strech

Exercício

54


Nosso exercício irá utilizar 3 formulários que serão exibidos na ordem acima: 1º Tela de Splash, 2º Formulário de Senha e 3º o Formulário Principal da Aplicação 1. Comece uma nova aplicação

55


2. Altere tamanho do formulário, seu nome para Frm_Princ e deverá ser exibido no centro da tela. 1. Insira mais formulário, altere suas propriedades para que seja exibido maximizado, sem borda e com o nome de Splash. 2. Insira um Image nesse formulário e altere as propriedades Picture, Strech = True e Align = alClient 5. Em Project Options defina o Splash como disponível. 6. Altere o arquivo .DPR conforme codificação em negrito abaixo e execute Application.Initialize; Splash := Tsplash.Create(Application); Splash.Show; Splash.Refresh; Application.CreateForm(TFrm_Princ, Frm_Princ); Splash.Release; // Se nao desejar mais ele no fundo Application.Run; 7. Observe que o Splash não fica na tela e logo o formulário principal é exibido. Na prática teríamos a exibição do Splash, a execução de rotinas de inicialização da aplicação que demandaria algum tempo e quando estas terminassem, o Splash deveria ser apagado e exibido o formulário principal.

Como não temos rotinas de inicialização, vamos então, criar um freio, que no exercício seria a exibição do formulário de Senha. 8. Para inserir o formulário de Senha: Menu File, opção New, Guia Dialog e escolha Passoftwareord Dialog 9. Altere os componentes deste formulário para que fique igual ao exibido acima, com o nome de Frm_Senha e o defina como disponível em Project Options. 10. Insira o código abaixo no arquivo .DPR depois do comando Splash.Refresh: Frm_Senha := TFrm_Senha.Create(Application); Frm_Senha.ShowModal; Frm_Senha.Release; 11. Grave e execute a aplicação StringGrid (Additional)

Utilizado para exibição e edição de uma tabela de strings. A sua apresentação é similar a uma planilha. É organizada em linhas e colunas, tendo como elemento básico as células (cells). 56


Propriedade

Descrição Célula que está selecionada Número da coluna da célula selecionada Número da linha da célula selecionada Número de colunas (default = 5) Número de linhas (default = 5) Número de colunas fixas Número de linhas fixas Largura padrão das colunas Altura padrão das linhas Vetor que define a largura das colunas Vetor que define a altura das linhas Largura da linha da Grid

Cells

Col Row ColCount RowCount FixedCols FixedRows DefaultColWidth DefaultRowHeight ColWidths RowHeight GridLineWidth

Referência a uma célula:

nome da grid.Cells[número da coluna, número da linha]    

StringGrid não permite ordenação Não permite centralizar os conteúdos nas células Pode-se alterar a largura das colunas, também com: ColWidths[0] := valor (1ª col) Pode-se alterar a altura das linhas, também com: RowHeights[0] := valor (1ª linha)

O StringGrid tem uma propriedade chamada Options, do tipo Set, que permite a configuração de diversas opções, inclusive a permissão ou não de edição de células. Valor

goFixedVerLine goFixedHorzLine goVerLine goHorzLine goDrawFocusSelected goRowSizing goColSizing goRowMoving goColMoving goEditing goTabs goRowSelect goAlwaysShowEditor goThumbTracking

Descrição Exibe linhas verticais em colunas fixas Exibe linhas horizontais em colunas fixas Exibe linhas verticais Exibe linhas horizontais Exibe a célula selecionada em cor de seleção Permite a mudança de tamanho da linha Permite a mudança de tamanho das colunas (arrastando as células das linhas fixas) Permite a movimentação de linhas (arrastando as células das colunas fixas) Permite a movimentação de colunas (arrastando as células das linhas fixas) Permite a edição do texto das células não fixas Permite o uso da tecla TAB para a navegação entre as células Seleciona uma linha inteira ao invés da célula corrente Sempre exibe o editor (somente válido se goEditing) Ao usar as scrollbars, o conteúdo é rolado em tempo real

Máscaras de Edição

É possível utilizarmos máscaras de edição para controlar a edição do texto de uma célula. Para tal, precisamos associar código ao evento OnGetEditMask da seguinte forma: procedure TForm1.StringGrid1GetEditMask(Sender: TObject; ACol, ARow: Integer; var Value: String); begin 57


if Acol = 1 then Value := '##/##/##'; end; Os caracteres usados para definir as máscaras de edição são os mesmos do componente TMaskEdit .

Exercício 1 - Inserindo valores na Grid: 1. Insira no formulário: um StringGrid, 3 Edits, 3 Labels e um botão "Inserir" 2. No evento OnClick do botão inserir o texto do 3º Edit nas posições especificadas nos outros dois edits 3. Criticar os valores informados da linha e coluna

Exercício 2 - Inserindo Títulos na Coluna e na Linha Fixa: 1. Insira os títulos para colunas: Seg, Ter, Qua, Qui 2. Insira os títulos para as linhas: 8:00, 9:00, 10:00, 11:00

Exercício 3 - Recuperando um valor da Grid 1. Insira um Edit e um botão "Recuperar" 2. No evento OnClick do botão fazer o Edit receber o valor da célula selecionada

Exercício 4 - Uma pequena Aplicação: 1. Insira um StringGrid com 3 colunas e 2 linhas, 3 edits, 3 Labels e um botão "Inserir" 2. Defina "Nome", "Telefone" e "E-mail" para os Labels e Colunas 3. No Evento OnClick do botão inserir os conteúdos dos edits no StringGrid 4. Realizar as devidas críticas e controles para perfeita funcionalidade. Objeto - PageControl

58


Paleta – Win32 Importância: Permite definir guias para agrupar os demais componentes. Cada guia representa um componente TabSheet do tipo TTabSheet, uma espécie de ‘sub-objeto’ do PageControl.

Propriedades ActivePage

Permite determinar qual a guia foi selecionada pelo usuário.

Para criar novas páginas, clique com o botão direito no componente PageControl e escolha New Page.

Objeto – OpenDialog (Caixa de diálogo para abertura de arquivos)

Paleta – Dialogs Importância: Permite utilizar uma caixa de diálogo pronta com recursos padronizados pelo sistema operacional.

Propriedades DefaultExt FileName Filter FilterIndex InitialDir Options Title

Especifica a extensão a ser adicionada ao nome de um arquivo quando o usuário digita o nome de um arquivo sem a sua extensão. Define o arquivo selecionado no componente. Permite definir as máscaras de filtro de arquivo a serem exibidas. Define o filtro default a ser exibido na lista drop-down que define os tipos de arquivos selecionáveis. Define o diretório default quando a caixa de diálogo é aberta. Neste componente, options define uma série de valores booleanos. Define o título da caixa de diálogo.

Os componentes da paleta dialogs são executados através do método execute. Este método é uma função que retorna um valor booleano, assim para exibir uma caixa de diálogo, podemos escrever: if OpenDialog1.Execute then

Se o usuário escolher algum arquivo e confirmar a caixa, execute retorna verdadeiro, caso contrário, falso. Objeto – RichEdit (Texto com formatação)

59


Paleta – Win32 Importância: Permite formatar o texto (Negrito, Itálico, Sublinhado, Fontes, etc...) para a leitura de outros editores compatíveis com o padrão RTF.

Propriedades Lines WantReturns WantTabs WordWrap

Define o texto exibido no componente. Define a tecla Enter como quebra de linha. Define a tecla Tab como tabulação ou mudança de foco. Caso falso pode-se utilizar CTRL+TAB para produzir o efeito desejado. Define a quebra de linha automática de texto.


Permite limpar o conteúdo do componente. Permite ‘carregar’ um arquivo para a propriedade Lines. Permite salvar o conteúdo da propriedade Lines em um arquivo.

Objeto – ProgressBar (Barra de progresso)

Paleta – Win32

Importância: Permitir ao usuário ter um acompanhamento de uma rotina demorada.

60


Propriedades Max Min Orientation Position Step

Permite definir o valor máximo para a faixa de valores no componente. Permite definir o valor mínimo para a faixa de valores no componente. Define se o componente deverá ser vertical ou horizontal. Define a posição corrente do controle no componente. Define o incremento usado na variação do valor da propriedade position.

Objeto – Gauge (Barra de progresso)

Paleta – Samples Importância: Permitir ao usuário ter um acompanhamento de uma rotina demorada.

Propriedades Kind Progress

Permite definir aparências diferenciadas no componente. Define a posição corrente do controle no componente.

Objeto – Animate (Animações)

Paleta – Win32 Importância: Permite exibir um ‘filme’ .AVI para ilustrar tarefas (rotinas) em andamento.

Propriedades CommonAVI Active Repetitions

Define o AVI a ser exibido. Liga e desliga a exibição do AVI. Define um número inteiro correspondente ao número de repetições. Zero define repetições indefinidas.

Objeto – DateTimePicker (Data e hora através de uma Combobox)

Paleta – Win32

Importância: Permite ao usuário escolher uma data através de um componente que possui um importante impacto visual e facilidade operacional.

61


Propriedades CalColors Date DateFormat DateMode Kind MaxDate MinDate

Define as cores do calendário. Define a data selecionada no componente. Define o formato da apresentação da data. Define o estilo da caixa de listagem. Define se o componente deve trabalhar com data ou hora. Define uma data máxima para uma faixa de valores. Define uma data mínima para uma faixa de valores.

Objeto – MonthCalendar (Calendário mensal)

Paleta - Win32 Importância: Permite ao usuário escolher uma data através de um componente que possui um importante impacto visual e facilidade operacional.

Propriedades Date FirstDayOfWeek WeekNumbers

Define a data selecionada no componente. Define qual o primeiro dia da semana. Permite numerar as semanas.

Objeto – StatusBar (Barra de status)

Paleta – Win32 Importância: Um dos principais componentes de informações sobre operações gerais no sistema.

Propriedades AutoHint SimplePanel SimpleText Panels

Permite exibir o hint do componente automaticamente na barra de status. Se não houver painéis, a barra deve ter a propriedade SimplePanel ligada. Define que a barra de status será sem divisões. Define o texto a ser exibido pela barra de status. Permite a criação e edição de painéis na barra de status. A propriedade SimplePanel deve estar desligada. Pode-se também dar um duplo clique na barra de status.

Ao utilizar a propriedade AutoHint, pode-se definir o hint dos objetos com duas strings separadas por pipe (‘|’). 62


A primeira string será utilizada como hint local, a segunda como hint na barra de status.

Inserindo dicas no StatusBar Para obter esse efeito, são necessárias duas etapas: 1. Inserir componentes no formulário e definir uma ou duas dicas através da propriedade Hint. 2. Escrever o código para evento OnHint do componente ApplicationEvents

Praticando: 1. Insira alguns componentes no formulário e defina a prop. Hint dos mesmos. Já vimos que a dica instantânea do componente pode ser = ou <> do StatusBar. 2. Insira o componente ApplicationEvents 3. Defina o código abaixo no seu evento OnHint: procedure Tform1.ApplicationEvents1Hint (Sender : TObject); begin Statusbar1.Panels[0].Text := Application.Hint; end; Inserindo Data e Hora no StatusBar

Você utilizar as funções que manipulam data e hora no Object Pascal. Mesmo utilizando essas funções devemos nos planejar como e quando a data e a hora serão atualizadas para serem exibidas. A forma mais fácil para realizar tal controle é inserir no formulário um componente Timer (paleta System) e configurar sua prop. Interval (Default = 1000 milissegundos = 1 segundo) que é a frequência do intervalo de tempo das ocorrências do evento OnTimer do comp. Timer. Logo, o código desse evento deve recuperar a data e/ou a hora do sistema e depois exibí-las no StatusBar. procedure TForm1.Timer1Timer (Sender : TObject);

{ variáveis que receberão Data e hora do Sistema } var Data_Hora : TDateTime; // Tipo float que armazenará a data + a hora Data_Sys : TDate; Data_Hora : TTime; begin {Recuperando a data e a hora do sistema} Data_Hora := Now; Data_Sys := Date; Hora_Sys := Time;

{Exibindo Data e Hora }

63


StatusBar1.Panels[0].Text := DateToStr(Data_Hora); StatusBar1.Panels[1].Text := TimeToStr(Data_Hora);

{Outra forma de exibição StatusBar1.Panels[0].Text := DateToStr(Data_Sys); StatusBar1.Panels[1].Text := TimeToStr(Hora_Sys); } {Outra forma de exibição StatusBar1.Panels[0].Text := DateToStr(Date); // Não necessário criar variáveis StatusBar1.Panels[1].Text := TimeToStr(Time); end;

Observação: Se o intervalo for grande (p. ex. 60000 = 1 minuto) para aparecer logo a data e a hora nos SubPaineis, ative o evento acima dentro do evento OnCreate do formulário ou, se possível, compartilhe este evento com ele. Se configurarmos a prop. Enabled do componente Time em False, o seu evento OnTimer não ocorrerá.

Dica: Sempre que você usar um StatusBar, preencha o resto do formulário com uma caixa de rolagem (ScrollBox da paleta Additional) e defina a sua prop. Align para alClient. Caso contrário, se o usuário diminuir o formulário o bastante para que as barras de rolagem apareção, estas se misturarão com o StatusBar. Objeto – ToolBar (Barra de ícones)

Paleta – Win32 Importância: Permite criar barras de ícones de maneira rápida e simples.

Propriedades Flat Images HotImages ShowCaptions

Define um efeito visual com relevo através do mouse nos botões. Permite definir um objeto do tipo ImageList . Permite definir um objeto do tipo ImageList a ser usado no momento em que o mouse passa (ou clica) sobre o componente. Permite exibir a propriedade caption dos botões.

Para adicionar botões ou separadores na ToolBar, clique com o botão direito sobre o componente e escolha New Button ou New Separator.

64


Inserindo BitMaps nos botões

1. Acrescentar no formulário um ou mais componentes ImageList 2. Obviamente carregar os bitmaps no ImageList 3. Associar o ImageList com a prop. Images do ToolBar. Por padrão, as imagens serão atribuídas aos botões na ordem em que elas aparecem, mas você pode mudar isso facilmente, configurando a prop. ImageIndex para cada botão do ToolBar. Pode-se preparar mais componentes ImageList para condições especiais dos botões, e atribuir a elas as propriedades (DisabledImages ou Images) e HotImages para cada botão do ToolBar. O primeiro grupo é usado para os botões desabilitados, o segundo para o botões quando pressionados. Esse último grupo de imagens usualmente é mais vivo, ou seja, deve possuir as imagens mais vivas que o seu correspondente desabilitado. Para que as imagens vivas sejam exibidas quando da passagem do cursor do mouse sobre os botões, defina a propriedade Flat = True, fazendo também os botões terem aparência plana. Obviamente, associe uma ImageList à propriedade HotImages. Não se esqueça de definir dicas instantâneas para os botões. Se você definir a propriedade ShowHint = True (Default = False) daToolBar, a propriedade ShowHint dos botões também será ajustada para True.

TRATAMENTO DE EXCEÇÕES Quando criamos e executamos nossos programas, estamos sujeitos à situações de erros em tempo de execução , a isto denominamos exceção . As exceções devem ser tratadas de maneira a não permitir: Travar a aplicação • Emitir mensagens ‘técnicas’ ao usuário leigo • Deixar o SO instável •

Quando uma exceção ocorre, o fluxo de controle é automaticamente transferido para blocos de código denominados handlers(Manipulador de evento) . de exceções, definidos através de comandos específicos do Object Pascal. No Object Pascal, uma exceção é uma classe. A definição de exceções como classes permite agrupar exceções correlatas. Esse agrupamento é feito através da própria hierarquia de classes, de modo que podemos ter várias classes dependentes de uma única. 65


O que ativa o mecanismo de tratamento de erros através de exceções é o uso da unit SysUtils . Ela permite detectar os erros e convertê-los em exceções. A idéia das exceções é tornar os programas mais consistentes ao adicionar a capacidade de tratar erros durante a execução (runtime). Um programa pode sobreviver a tais erros ou terminar de forma suave, permitindo que o usuário salve dados antes de sair. Em tempo de execução, o Delphi lança exceções quando algo estiver errado. Se seu código for escrito corretamente, poderá reconhecer o problema e tentar resolvê-lo; caso contrário, a exceção será passada para o código chamador, e assim por diante. Eventualmente, se nenhuma parte de seu código tratar da exceção, o Delphi tratará dela, exibindo uma mensagem de erro padrão e tentanto continuar o programa. O Delphi traz um grande número de exceções predefinidas – pertencentes a RTL (RunTime Library) - que são largamente utilizadas pela VCL. As exceções pertencem a classe Exception do Delphi

O COMANDO TRY-EXCEPT Podemos tratar as exceções através do comando try-except . Sua sintaxe: try

except

end; //finaliza o bloco

Os comandos a serem executados são tratados seqüencialmente na ordem em que foram criados, caso não haja alguma exceção o bloco de exceção é ignorado. O programa prossegue normalmente obedecendo aos eventos provocados pelo usuário. Caso ocorra alguma exceção, o fluxo de controle é desviado para o bloco de exceção. É importante lembrar que podemos inserir qualquer comando, inclusive fazer chamadas a procedimentos e funções que por sua vez, podem chamar outros procedimentos e funções. O bloco de exceção pode ser definido através de uma construção genérica, exemplo: try Abre(Arq); while not Fim(Arq) do processa(Arq);

except Showmessage (‘Houve um erro inesperado.’); end; //bloco try

No exemplo acima tratamos os erros com uma mensagem genérica dentro de um um bloco try-except.

66


A CONSTRUÇÃO ON-DO try Abre(Arq);

while not Fim(Arq) do processa(Arq);

except on EInOutError do //erro de entrada e saída begin Showmessage(‘Problemas...’); Fecha(Arq);

end; on EdivByZero do //erro de divisão de nº inteiro por zero Showmessage(‘Erro ao dividir por zero’);

on EconvertError do //erro de conversão de tipos Showmessage(‘Erro de conversão de tipos de dados’); end; //bloco try

Podemos ainda definir utilizando a cláusula on-do com um handler genérico usando else, da seguinte forma: try Processa;

except on Exceção1 do Trata1; on Exceção2 do Trata2; else TrataOutras; end;

Os principais tipos de exceção da RTL ( RunTime Library) do DELPHI, a serem tratadas nos blocos on ... do são: Nome EaccessViolation EconvertError EdivByZero EinOutError EintOverFlow EinvalidCast EinvalidOp EinvalidPointer EoutOfMemory EoverFlow ErangeError EstackOverflow

Descrição Ocorre quando se tenta acessar uma região de memória inválida (ex: tentar atribuir valor a um ponteiro cujo conteúdo é nil). ocorre quando se tenta converter um string em um valor numérico (ex: utilizar a função StrToInt em uma letra). ocorre na divisão de um número inteiro por zero. ocorre numa operação incorreta de I/O (ex: abrir um arquivo que não existe). ocorre quando o resultado de um cálculo excedeu a capacidade do registrador alocado para ele (para variáveis inteiras). ocorre quando se tenta realizar uma operação inválida com o operador as (ex: tentar usar um Sender com uma classe que não corresponde a seu tipo). ocorre quando se detecta uma operação incorreta de ponto flutuante. ocorre quando se executa uma operação invalida com um ponteiro (ex: tentar liberar um ponteiro duas vezes). ocorre quando se tenta alocar memória mas já não existe mais espaço suficiente. ocorre quando o resultado de um cálculo excedeu a capacidade do registrador alocado para ele (para variáveis de ponto flutuante). ocorre quando uma expressão excede os limites para a qual foi definida (ex: tentar atribuir 11 ao índice de um vetor que pode ir no máximo até 10). ocorre quando o sistema não tem mais como alocar espaço de memória na

67


Eunderflow

EzeroDivide

Stack. ocorre quando o resultado de um cálculo é pequeno demais para ser representado como ponto flutuante. ocorre quando se tenta dividir um valor de ponto flutuante por zero.

O COMANDO TRY-FINALLY Há um outro comando cuja sintaxe começa com try. Este controle de finalização nos permite lidar de forma estruturada com as situações em que alocamos algum tipo de recurso e, haja o que houver , precisamos depois liberá-lo.

try

finally

end;

O comando funciona da seguinte forma: os comandos especificados após o Try são executados seqüencialmente. Se não ocorrer nenhuma exceção, os comandos especificados após finally são executados, e o programa prossegue com a execução normal, com o comando seguinte ao try-finally . Porém, se houver alguma exceção – qualquer uma – durante a execução da lista de comandos do try, o trecho após o finally é executado e, no final, a exceção é reativada. Em resumo: Os comandos do bloco finally sempre são executados, haja ou não alguma exceção durante a execução dos comandos especificados após o try.

BLOCOS TRY ANINHADOS Exemplo: 1

2

Try abrir arquivo algumas operações fechar arquivo except ...

abrir arquivo Try algumas operações finally fechar arquivo

Observamos que no quadro 1 se em “algumas operações” ocorrer uma exceção, o arquivo não será fechado. Logo, devemos utilizar a solução do quadro 2, pois nessa codificação, o arquivo será fechado, independentemente da ocorrência da exceção. Entretanto, se observarmos melhor, a solução do quadro 2 é que ela não trata a exceção. Como regra temos que um bloco try pode ser seguido por uma instrução except ou finally, mas não por ambas simultaneamente. A solução típica é utilizar os dois blocos try aninhados. Dê ao interno uma instrução finally e dê ao externo uma instrução except, ou viceversa, conforme a situação exigir. 68


Podemos mesclar as duas maneiras, conforme o código abaixo: var i,j : real; begin try try i := strtofloat(edit1.text); j := strtofloat(edit2.text); edit3.text := floattostr(i/j); except on exception do showmessage('Ocorreu uma exceção'); end; finally showmessage('alguma instrucao'); end; end;

Outro Exemplo: procedure TForm1.Button1Click(Sender: Tobject); var i, aux:integer; begin aux := 500;

try

{inicio do bloco try-finally. Screen controla uma serie de recursos do sistema operacional neste exemplo, muda-se a aparencia do cursor para ampulheta} Screen.Cursor := crHourGlass; try//inicio do bloco try-except for i:=0 to aux do

begin Edit1.Text := IntToStr(i); Application.ProcessMessages; {O método ProcessMessages é necessário para forçar que as mensagens do windows sejam processadas, desenhando o numero no Edit. Sem ele, apenas o valor final seria visto.}

end; except Showmessage('Ocorreu um erro.');

end;//fim do bloco try-except finally Screen.Cursor := crDefault;

end;//fim do bloco try-finally end; //fim da procedure

CLASSE EXCEPTION A classe Exception também possui o objeto E, que recebe o valor do objeto exceção passado pela instrução raise

Observe o código abaixo: Begin Try Resultado := A div B; Except On EDivByZero do

69


Begin Resulatdo := 0; MessageDlg(‘Divisão por zero corrigida’, mtError, [mbok], 0); End; On E: Exception do Begin Resultado := 0; MessageDlg(E.Message, mtError, [mbok], 0); End; End; End;

TRATAMENTO DE EXCEÇÕES DE FORMA GLOBAL Há no Delphi um objeto chamado Application criado sem a decisão do desenvolvedor em todo o projeto. Este objeto representa a applicação como um todo e possui um evento muito importante: OnException . Este evento permite manipular as exceções em um nível global, podemos afirmar que os tratamentos de erro através do comando try são tratamento locais. A partir da versão 7 do Delphi, os eventos deste objeto estão disponível na paleta Additional, nas versões anteriores este objeto era manipulado apenas no Code Editor tendo o desenvolvedor o trabalho de declarar os procedimentos desejados. Como o objeto tem como finalidade generalizar e centralizar tratamentos, deve haver um único objeto na aplicação. Paleta – Additional Importância: Permite a manipulação de exceções em um nível global para toda a aplicação.

A utilização do evento OnException pode ser criado da seguinte forma, utilização um if na variável E (que recebe o erro atual) tomando uma decisão na condição verdadeira: procedure TForm1.ApplicationEvents1Exception(Sender: TObject; E: Exception);

begin if E is EConvertError then ShowMessage('Erro de conversão de dados.');

end;

Neste exemplo acima, em qualquer lugar do programa (e não apenas em uma determinada rotina) que venha a levantar um erro do tipo EConvertError, uma mensagem genérica será exibida. Este objeto deve estar inserido ou no formulário principal ou no formulário especial denominado Data Module como veremos adiante.

70


TRATAMENTO DE EXCEÇÕES SILENCIOSAS Podemos utilizar o comando Abort para gerar exceções silenciosas, ou seja, sem nenhuma mensagem. try Form1.Caption := FloatToStr(StrToFloat(Edit1.Text) / StrToFloat(Edit2.Text));

except on EZeroDivide do begin Beep; ShowMessage('Divisão por zero');

end; on EInvalidOp do ShowMessage('Operação inválida'); else Abort;

end;

UM POUCO MAIS SOBRE COMPONENTES (VCL) A Paleta Dialog OpenDialog e SaveDialog

Os Componentes OpenDialog e SaveDialog exibe uma caixa de diálogo padrão do Windows para selecionar, abrir e salvar arquivos. A caixa de diálogo não aparece até que seja executado o método Execute. Quando o usuário clica para Abrir ou salvar o arquivo, a caixa de diálogo fecha e são armazenados em uma lista, nas propriedades do componente, os nomes e caminhos de arquivos selecionados. Propriedade DefaultExt FileEditStyle FileName Files Filter FilterIndex HistoryList InitialDir Options Title

Descrição Especifica uma extensão, padrão, de arquivo que é juntada automaticamente ao nome de arquivo digitado na área do nome do arquivo na caixa de dialogo. Determina o estilo da caixa de diálogo de seleção do arquivo. (Obsoleto.) FileEditStyle é mantido para compatibilidade com versões mais velhas de Delphi. Devolve o nome e o caminho do diretório completo do arquivo mais recentemente selecionado. Vetor que contem o nome e o caminho completo de todos os arquivos selecionados. Fornece uma lista drop-down para preencher com extensões de arquivos que serviram de filtro nas seleções do arquivos. Ex: OpenDialog1.Filter := 'Arquivos de Texto (*.txt)|*.TXT' Determina qual o tipo de arquivo será o padrão na lista da propriedade Filter anterior. Mantém uma lista de arquivos previamente selecionados. (Obsoleto.) HistoryList é mantido para compatibilidade com versões mais velhas de Delphi. Determina o diretório atual quando a caixa de diálogo abre. Se esta opção estiver vazia o Opendialog sempre vai abrir no diretório do programa ou no último diretório utilizado. Define características da caixa de diálogo. Na tabela abaixo estão discriminadas todas as opções. Texto que fica na barra de título da caixa de diálogo.

71


Opções Valor ofAllowMultiSelect ofCreatePrompt ofExtensionDifferent ofFileMustExist ofHideReadOnly ofNoChangeDir ofNoDereferenceLinks ofNoLongNames ofNoNetworkButton ofNoReadOnlyReturn ofNoTestFileCreate ofNoValidate ofOldStyleDialog ofOverWritePrompt ofPathMustExist ofReadOnly ofShareAware ofShowHelp

Significado Permite que o usuário selecione mais de um arquivo na caixa de diálogo. Gera uma mensagem de advertência se o usuário tentar selecionar um arquivo inexistente e pergunta se quer criar um arquivo novo com o nome especificado. Esta tag muda em tempo de execução sempre que o nome do arquivo selecionado tem uma extensão que difere de DefaultExt. Gera uma mensagem de erro se o usuário tenta selecionar um arquivo inexistente. Remove o checkbox de confirmação para somente leitura Depois que o usuário clica OK, reajusta o diretório corrente para o que estava antes da caixa de diálogo ser aberta. Opção para reconhecer um arquivo de atalho de Windows, como um atalho ou como um arquivo qualquer. Mostra apenas arquivos com 8.3 caracteres. Remove o botão de Rede da caixa de diálogo. Gera uma mensagem de erro se o usuário tenta selecionar um arquivo somente de leitura. Desabilita o teste de proteção de arquivo em rede e disco inacessíveis. Só se aplica quando o usuário tenta salvar um arquivo em um diretório de rede compartilhado. Permite seleção de nomes de arquivo com caracteres inválidos. Cria o estilo do Windows 3.1 para caixa de diálogo. Gera uma mensagem de advertência se o usuário tentar selecionar um nome de arquivo que já está em uso e pergunta se quer sobrescrever o arquivo existente. (Use com TsaveDialog e TSavePictureDialog.) Gera uma mensagem de erro se o usuário tentar selecionar um nome de rquivo que inexistente. Seleciona como padrão o ComboBox habilitado pela opção ofHideReadOnly. Ignora erros compartilhados e permite selecionar arquivos até mesmo quando acontecem violações de compartilhando. Exibições um botão de Ajuda na caixa de diálogo.

OBS: Todas as opções são marcadas como falso. Principais Eventos Evento OnClose OnShow OnFolderChange OnSelectionChange

OnTypeChange

Descrição Ocorre quando a caixa de diálogo é encerrada. Ocorre quando a caixa de diálogo é iniciada. Ocorre quando um diretório é aberto ou é fechado na caixa de diálogo. Ocorre quando nomes de arquivo exibidos no diálogo é mudado, isto é, o evento de OnSelectionChange acontece quando o usuário faz algo que mude a lista exibida no diálogo. Isto pode incluir: selecionando um filtro novo, selecionando um diretório novo, ou criando uma pasta nova. Ocorre acontece quando o usuário seleciona um filtro novo de arquivo no ComboBox de Tipo na caixa de diálogo.

72


Principais Métodos Métodos Execute

Descrição Abre a caixa de diálogo do OpenDialog e devolve true quando o usuário seleciona um arquivo dar um Clique para abrir o arquivo. Se o usuário clicar Cancele retorna False.

ColorDialog

O Componente TColorDialog exibe uma caixa de diálogo padrão do Windows para selecionar cores. A caixa de diálogo não aparece até que seja executado o método Execute. Quando o usuário seleciona uma cor e clica o OK, a caixa de diálogo fecha e a cor selecionada é armazenada na propriedade de Cor. Principais Propriedades Propriedade Color CustomColors

Options

Descrição Retorna a cor selecionada. A cor padrão é clBlack. Quando o usuário seleciona uma cor na caixa de diálogo e clica o OK, a cor selecionada se torna o valor da propriedade de Cor. Determina quais cores personalizada iniciam na caixa de diálogo. Cada cor personalizada é representada com uma string na forma ColorX=HexValue. Por exemplo, a seguinte string determina a primeira cor personalizada: ColorA=808022 Pode personalizar até 16 cores (ColorA até ColorP). Define características da caixa de diálogo. Na tabela abaixo estão discriminadas todas as opções.

Opções Valor cdFullOpen cdPreventFullOpen cdShowHelp cdSolidColor cdAnyColor

Significado Exibe as opções de personalizar cores quando a caixa de diálogo e aberta. Desabilita o botão que Define a personalização de cores na caixa de diálogo, de forma que o usuário não pode definir cores novas. Adiciona um botão de Ajuda na caixa de diálogo. Direciona o Windows a usar a cor sólida mais próxima da cor escolhido. Permite que o usuário selecione cores não-sólidas.

OBS: Todas as opções são marcadas como falso. Principais Eventos Evento OnClose OnShow

Descrição Ocorre quando a caixa de diálogo é encerrada. Ocorre quando a caixa de diálogo é iniciada.

73




PrintDialog

O Componente TPrintDialog exibe uma caixa de diálogo padrão do Windows para enviar trabalhos para uma impressora. O caixa de diálogo de impressão é modal e não aparece até que seja chamada pelo método Execute. Principais Propriedades Propriedade Collate Copies FromPage MaxPage

MinPage Options PrintRange

PrintToFile ToPage

Descrição Indica se o Checkbox Collate na caixa de dialogo está selecionada. Indica as cópias de número selecionadas na caixa diálogo de Impressão. Indica a página na qual o trabalho de impressão vai começar. Determina o maior número de páginas que usuário pode imprimir. Se o usuário tenta entrar com um número maior que MaxPage, uma mensagem de erro aparece. OBS: O usuário só pode especificar o número de página se a opção poPageNums estiver em True. Determina o menor número de páginas que usuário pode imprimir. Inverso do anterior. Define características da caixa de diálogo. Na tabela abaixo estão discriminadas todas as opções. Define qual o intervalo de impressão ficará selecionado como padrão na caixa de diálogo. Podem assumir três valores: prAllPages ( O RadioButton “Todos” fica selecionado), prSelection (O RadioButton “Seleção” fica selecionado), prPageNums (O RadioButton “Páginas” fica selecionado). Seleciona o CheckBox ‘impressão para arquivo’ na caixa de diálogo como padrão. Indica a página na qual o trabalho de impressão termina.

Opções Valor PoDisablePrintToFile PoHelp PoPageNums PoPrintToFile PoSelection PoWarning

Significado Desabilita (fica cinzento) o CheckBox “Imp. em arquivo”. (Aplicável somente a opção poPrintToFile for verdadeira). Exibe um botão de Ajuda na caixa de diálogo. Pode não aparecer em algumas versões do Windows 95. Habilita o RadioButtom que permite que usuário especifique um intervalo de páginas. Exibe o CheckBox “Imp em arquivo” na caixa no diálogo. Habilita o RadioButtom que permite que usuário especifique imprimir uma seleção. Gera uma mensagem de advertência se o usuário tentar enviar um trabalho a uma impressora desinstalada.

OBS: Todas as opções são marcadas como falso.

74


Principais Eventos Evento OnClose OnShow

Descrição Ocorre quando a caixa de diálogo é encerrada. Ocorre quando a caixa de diálogo é iniciada.



UM POUCO MAIS SOBRE COMPONENTES (VCL) Objeto – Timer (Temporizador)

Paleta – System Importância: Permite a execução de rotinas em loop, em um intervalo pré-definido.

Propriedades Enabled Interval

Permite ‘ligar’ o timer, ou seja, ele entra em um loop executando o evento OnTimer até que seja atribuído falso ou terminada a aplicação. Define em milisegundos o intevalo de repetição do evento OnTimer.

Objeto – FileListBox (Caixa de listagem de arquivos)

Paleta – Win 3.1 Importância: Permite determinado diretório.

listar

arquivos

de

Propriedades

75


FileEdit FileName Mask

Define uma caixa de edição (TEdit) que exibirá o arquivo atualmente selecionado. Define o nome do arquivo selecionado. Válido em tempo de execução. Define máscaras de filtro (separadas por ponto e vírgula) para a exibição dos arquivos.

Objeto – DirectoryListBox (Caixa de listagem de diretórios)

Paleta: Win 3.1 Importância: Permite listar os diretórios do drive desejado.

Propriedades DirLabel FileList

Permite exibir o diretório corrente com a propriedade Caption de um componente do tipo TLabel. Permite a conexão com um componente TFileListBox.

Objeto - DriveComboBox (Caixa de listagem de drives)

Paleta: Win 3.1

Importância: Permite listar disponíveis no computador.

Propriedades DirList

os

drives

Permite a conexão com um componente TDirectoryListBox.

Objeto – FilterComboBox (Caixa de listagem de filtros)

Paleta: Win 3.1

Importância: Permite estabelecer filtros para visualização de arquivos.

Propriedades FileList Filter

Permite a conexão com um componente TFileListBox. Permite definir as máscaras de filtro de arquivo a serem exibidas.

76


Gauge

Paleta: Samples Utilizado para dar idéia do progresso na execução de uma tarefa. Importância:

Propriedades MinValue MaxValue Progress BackColor ForeColor Kind ShowText

Significado

Valor mínimo Valor máximo Valor atual Cor da área não preenchida Cor da área preenchida Tipo da figura (barra horizontal ou vertical, círculo, etc) Define se o valor em percentagem será exibido

TrackBar

Paleta: Win32 Importância: Componente utilizado para a seleção de valores inteiros dentro de uma faixa

Propriedades Orientation Min Max Position TickStyle TickMarks

Significado

Orientação vertical ou horizontal Valor mínimo Valor máximo Posição corrente Estilo de exibição das marcações Aparência do indicador

77


PageSize LineSize SelStart SelEnd

Determina o incremento que deve ser dado quando as teclas PgUp e PGDn forem pressionadas Determina o incremento que deve ser dado quando as setas forem pressionadas Posição de início do preenchimento Posição de término do preenchimento

CheckListBox

Paleta: Additional Importância: Possui toda a funcionalidade do ListBox exibindo ao lado do item uma CheckBox. Este componente é bastante útil quando queremos exibir uma lista extensa de CheckBoxs e o espaço para fazê-lo é escasso. Muito encontrado em programas de SetUp.

Propriedades

Significado

Checked[n] State[n] AllowGrayed

Retorna true se o item n estiver selecionado Retorna o estado do item n : [cvUnchecked, cbChecked, cbGrayed] Permite ou não a existência de itens com estado indeterminado. Default = False

Eventos

Descrição

OnClickChecked

Quando um item é marcado ou desmarcado

ListView (Win32)

Paleta: Additional

Importância: Componente que permite exibir de várias maneiras uma lista de itens.

Propriedades ViewStyle

LargeImages SmallImages Items

Significado

Determina se os itens devem ser apresentados em colunas com cabeçalhos e sub-itens, verticalmente ou horizontalmente, com ícones grandes ou pequenos Lista de Imagens (TImagesList) contendo a bitmap’s a serem exibidos e somente é usada quando a propriedade ViewStyle é vsIcon Lista de Imagens (TImagesList) contendo a bitmap’s a serem exibidos e somente é usada quando a propriedade ViewStyle é vsSmallIcon Items a serem exibidos

78


Columns ShowColumnHeaders ColumnClick IconOptions

SortedType

Selected

Cabeçalhos das colunas da Lista Exibe os cabeçalhos das colunas Indica se os cabeçalhos das colunas terão a aparência de botões Opções de exibição dos ícones quando ViewStyle for vsIcon ou vsSmallIcons Arrangement alinhado no topo ou esquerda do ListView AutoArrange os ícones são alinhados automaticamente WrapText a propriedade caption será quebrada nsNone não é ordenado nsData os iten são ordenados dados são alterados nsText os itens são ordenados quando o Caption é alterada. nsBoth a ordenação e feita em ambos os casos Item selecionado. Podemos acessar o conteúdo selecionado através de Select.Captiont;

Pode ser utilizado com o Imagelist

ImageList

Paleta: Win32 Importância: O componente ImageList permite que trabalhemos com listas de imagens em bitmap e a apresenta quando solicitado, sendo um componente não visual.

Ele é extremamente útil, mas quase todo a sua operação depende de outros componentes. Por exemplo, as diversas imagens que aparecem em componentes de visualização em lista ou em árvore ou numa ToolBar estão em listas de imagens.

Para se definir a lista de imagens devemos selecionar o componente e emitirmos um duplo clique para que seja exibido o Editor da lista de imagens ou usarmos o botão direito e selecionarmos a opção ImageList editor, que apresenta o seguinte diáologo: A opção Add é utilizada para acrescentar uma imagem na lista A opção Delete remove a imagem selecionada da lista A opção Clear limpa toda a lista

79


Se a imagem estiver armazenada, uma figura habilitada e outra desabilitada quando da inclusão na lista, o Editor pergunta, caixa abaixo, se deseja a separação. Observe que a imagem de índice 0 e 1, foram seperadas e a de índice 2 não.

A opção Crop faz com a imagem Habilitada/Desabilitada fique junta quando se responde Não na caixa acima. A opção Strech faz com a imagem Habilitada/Desabilitada fique separada quando se responde Não na caixa acima. Os bitmaps da lista são sempre retangulares, mesmo que contenham imagens em formas irregulares. A lista de imagem tem o recurso de tratar o fundo como se fosse transparente. Se você definir a propriedade bkColor de uma lista com uma cor específica, você desativa o recurso de desenho transparente. Como exemplo do TreeView, visualização de dados em árvores, temos o Explorer que exibe a estrutura hierárquica dos diretórios de um disco, com um pequeno ícone à esquerda para diferenciar discos rígidos de diretórios, estes de drive e CD e assim por diante. O componente de visualização em árvore pode representar qualquer tipo de dados que possua um arranjo hierárquico, como um organograma de uma empresa.

Propriedades

Significado

80


Images StateImages Items

Lista de Imagens que contém os bitmaps que representam os próprios ícones, como as imagens dos discos no Explorer Lista de Imagens especiais que indicam que um item encontra-se num estado específico. Estado este que o programador define. Geralmente através de um ImageList e Caixa de Edição StateIndex do TreeView Items Editor. Permite a edição dos nós da árvore. Possui um conjunto de métodos como Add, AddChild, AddFirst que também permite a inclusão de nós na árvore. Cada nó é considerado um objeto do tipo TTreeNode. As principais propriedades dos nós são: ImageIndex – informa qual imagem da lista de imagens representa o nó. SelectIndex – qual imagem da lista será exibida se o nó for selecionado. StateIndex – da mesma forma, é um índice da StateImages. Se for <> -1, a imagem será exibida à esquerda da imagem normal.

ShowButtons ShowLines ShowRoot ReadOnly

Default = True, exibe os botões + ou – para expandir/fechar ramos Default = True, exibe as linhas conectando os nós. Default = True, exibe o nó da raiz Default = False, possibilita a edição dos ramos da árvore

Eventos OnEditing OnEdited

Significado Se ReadOnly = False, ocorre quando o usuário edita o ramo da árvore Ocorre quando o usuário termina a edição

Animate

Paleta: Win32 Importância: Componente capaz de exibir um AVI, o qual representa um formato de arquivo multimídia com imagens e sons, mas este componente apenas exibe as imagens.

Propriedades

Active AutoSize Center FileName FrameCount Repetitions

Significado

Indica se a animação esta sendo exibida ou não Ajusta automaticamente o tamanho do componente ao tamanho da imagem Centraliza a animação Nome do arquivo AVi Número de Frames da animação Número de repetições quando a animação for executada. O valor zero indica repetições indefinidas

DateTimePicket

81


Paleta: Win32 Importância: Componente que permite a seleção visual de datas ou horas

Propriedades

Time Date DateMode DateFormat Kind ShowCheckbox Check

Significado

Hora selecionada Data Selecionada A forma como a data poderá ser selecionada [dmComboBox, dmUpDown] Formato da Data [dfShort, dfLong] Seleciona o componente para Data ou Hora [dtkDate, dtkTime] Exibe um CheckBox Indica se o CheckBox esta selecionado

82


Apêndice A - A Linguagem Object Pascal Características Object Pascal é uma linguagem orientada a objetos não pura, mas híbrida, por possuir características de programação não só visual mas também escrita. Para os programadores que já conhecem técnicas de estruturas de programação como o C, Basic, Pascal entre outras linguagens, a Object Pascal providência uma migração de forma natural oferecendo um produto de maior complexidade. Ela força a você executar passos lógicos, isto torna mais fácil o desenvolvimento no ambiente Windows de aplicações livres ou que utilizam banco de dados cliente/servidor e possui todo o poder de um código totalmente compilável. Além disso possibilita a criação e a reutilização (vantagem de re-uso tão sonhado com a OO) de objetos e bibliotecas dinâmicas (DLL - Dymanic Link Libraries). Object Pascal contém todo o conceito da OO, incluindo encapsulamento, herança e polimorfismo. Algumas extensões foram incluídas para facilitar o uso de conceitos como propriedades particulares e públicas, e tipos de informações em modo run-time, manuseamento de exceções, e referências de classes.

EXPRESSÕES LÓGICAS São expressões que retornam valor booleano (falso ou verdadeiro). Operador

not and or xor

Operação

Negação E lógico OU lógico OU EXCLUSIVO lógico

O operador not é unário, por exemplo: if not (X > Z) then Devemos usar parênteses ao compararmos expressões lógicas, por exemplo: if (X > Z) or (W > Y) then

COMANDO IF O comando condicional if pode ser composto de uma ou mais condições de processamento, por exemplo: •

if (A > B) then B := B + 1; // ou INC(B);

•

if (A > B) then B := B + 1

else A := A - 1; // ou DEC(A);

83


•

if (A > B) then begin B := B + 1; X := B + A;

end else begin A := A - 1; Y := Y + B; end;

No último exemplo para representar um bloco de comandos em caso verdadeiro ou falso, utiliza-se dos delimitadores begin e end . O comando if - then-else é considerado como único, portanto, não há ponto e vírgula (‘;’)antes da palavra reservada else.

COMANDO CASE O comando case..of oferece uma alternativa para comandos if - then-else com um ‘grande’ número de testes. Por exemplo: case Key of ‘A’..‘z’: Label1.Caption := ‘Letras’; ‘0’..‘9’: Label1.Caption := ‘Números’; ‘+’, ‘-’, ‘*’, ‘/’: Label1.Caption := ‘Operador’

else Label1.Caption := ‘Caracter especial’; end; //fim do case

COMANDO REPEAT O comando repeat..until é uma opção para estruturas de repetição. A grande diferença com o comando while é o fato do comando repeat ser executado pelo menos uma vez. repeat X := X + 1; INC(Z,3); //equivale a Z := Z + 3; DEC(AUX,2); until X >= 200;

COMANDO WHILE O comando while..do também permite a construção de estruturas de repetição, com diferença de não executar o laço no início do teste lógico. while X <= 200 do begin X := X + 1; INC(Z,3); DEC(AUX,2);

84


end;

COMANDO FOR O comando for..do estabelece uma estrutura de repetição considerando um controle inicial e final. Pode ser construído de maneira crescente ou decrescente. for i:=0 to 500 do Label1.Caption := IntToStr(i);

for i:=500 downto 100 do begin Label1.Caption := IntToStr(i); Edit1.Caption := IntToStr(i); end;

COMANDO BREAK O comando break é usado para alterar o fluxo normal de comandos de repetição, o controle é desviado para o comando seguinte ao comando repetitivo. frase := Edit1.Text; for i:=1 to length(frase) do

begin if frase[I] = 'A' then

break; aux := aux + frase[I];

end; Label1.caption := aux; //Label1 recebe o conteudo de frase até a letra ‘A’

COMANDO WITH O comando with..do é usado para abreviar a referência a campos de registro, ou a métodos, e propriedades de um objeto. begin Form1.Caption := ‘Senac’; Form1.Color := ClBlue; Form1.Top := 95;

end;

//Equivalente à: with Form1 do

begin Caption := ‘Senac’; Color := ClBlue; Top := 95;

end;

85


Apêndice B - DICAS CRIAR UM HOTLINK Podemos criar um link para a Internet dentro do Delphi através da função ShellExecute. Supondo que a propriedade Caption de um label seja um endereço web válido (http://www.fulanodetal.com.br) podemos inserir em seu evento OnClick o seguinte código: ShellExecute(Handle, 'open', pchar(Label1.Caption), nil, '',SOFTWARE_SHOWNORMAL);

É necessário incluir a biblioteca ShellAPI na cláusula uses da Inteface.

ENVIAR UM MAIL Podemos utilizar a função ShellExecute para abrir o programa de mail do usuário e preparar seu envio. ShellExecute(Handle, ‘’,SOFTWARE_SHOWNORMAL);

‘open’,

‘mailto:[email protected]’,

nil,

Caso queira colocar um subject padrão na construção do e-mail utilize a palavra subject da seguinte forma: ShellExecute(Handle, ‘open’, ‘mailto:[email protected] ?subject=Pergunta’, nil, ‘’,SOFTWARE_SHOWNORMAL);


EXECUTANDO UM PROGRAMA DE ACORDO COM A EXTENSÃO DE UM ARQUIVO ShellExecute é um função API comparada a um ‘canivete suiço’, vamos utilizá-la novamente para chamar um programa através da extensão do arquivo passado como parâmetro. Os parâmetros de ShellExecute são 6:  Um manipulador de janela, que é o pai do processo disparado.  Uma ação a executar, que pode ser “open”, para abrir, “print”, para imprimir, ou “explore”, para abrir uma janela do Explorer no diretório desejado.  Um ponteiro (tipo Pchar em Delphi) para o nome do programa ou diretório.  Parâmetros para a aplicação.  Diretório inicial.  Modo de abertura do programa Exemplo: ShellExecute(Handle, ‘open’, ‘exemplo.doc’, nil, nil, SOFTWARE_SHOWNORMAL);

86



DATAS As datas são um tipo de dados TDateTime, internamente são armazenadas como números de ponto flutuante (Double). A parte inteira indica a data, em número de dias, contados a partir de 30/12/1899 e a fracionária, as horas. Pelo fato de serem armazenadas como Double, pode-se subtrair, somar e estabelecer comparações. Por exemplo: var DataIni, DataFim : TDateTime; Dif : Single;

begin Dif := DataFim – DataIni; //diferença em dias entre as datas DataIni := DataIni+10; //acrescenta + 10 dias na data

end;

Para saber a hora de determinada data, multiplica-se a parte fracionária por 24: Frac(DataIni) * 24;

Podemos ainda comparar as datas com os operadores ‘<’ e ‘>’. Caso não seja necessário a comparação com a hora, basta converter a data para um inteiro e efetuar a comparação: if Trunc(Data1) < Trunc(Data2) then

A formatação de data pode ser feita através da função FormatDateTime. function

FormatDateTime(const

Format:

string;

DateTime:

TDateTime):

string;

Exemplo: Label1.Caption := FormatDateTime('dddd, d "de" mmmm "de" yyyy', date);

SAIR DE UMA APLICAÇÃO método

O Delphi fornece diferentes métodos para sair de uma aplicação. O ideal é utilizar o Close.

Porém, há casos em que Close não atenderia à necessidade do desenvolvedor, nestes casos pode-se chamar Halt ou Application.Terminate. Halt é um procedimento do Pascal e provoca o término da aplicação, não se importando com arquivos abertos. Já o método Terminate do objeto Application obriga o fechamento de todos os arquivos abertos e a destruição de todas a forms criadas.

REDUZINDO TESTES IF A expressão: if A = 10 then B := True

87


else B := False;

Pode ser reduzida a apenas uma linha: B := A = 10;

A = 10 é uma operação boleana, que retorna True se A é igual a 10 e False caso contrário. Neste caso estamos atribuindo à variável B o resultado da comparação, TRUE ou FALSE.

HINTS COM DUAS OU MAIS LINHAS A object inspector permite Hint com apenas uma linha. Para gerar Hints com mais linhas pode-se em tempo de execução configurar a propriedade Hint da seguinte forma: Edit1.Hint := ‘Primeira linha do hint’#13‘segunda linha do hint’;

Pode-se também em tempo de projeto clicar na form com o botão direito e escolher a opção ‘View as Text’, procurar o objeto e a hint desejada e alterá-la: Hint := ‘Primeira linha do hint’#13‘segunda linha do hint’;

Para voltar ao Form clique com o botão direito e escolha ‘View as Form’.

SUBSTITUIR A TECLA TAB POR ENTER NA MUDANÇA DE FOCO   

Setar a propriedade KeyPreview da Form para True Setar a propriedade Default de todos os botões da Form para False Criar um evento OnKeyPress para a Form como este:

procedure TForm1.FormKeyPress(Sender: TObject; var Key: Char); begin if (Key = #13) and not (Activecontrol is TMemo) then begin //desabilita o processamento posterior da tecla key := #0; //simula o envio da tecla tab Perform(WM_NEXTDLGCTL,0,0);

end; end;

ÍCONES O Delphi possui um conjunto de ícones e imagens em uma pasta padrão: C:\Arquivos de programas\Arquivos comuns\Borland Shared\Images

88


EXECUTAR UM PROGRAMA Para executar um programa use a API WinExec. WinExec(‘calc.exe’, SOFTWARE_SHOWNORMAL);

LINKS Alguns links interessantes: Nacionais

http://www.clubedelphi.com.br/ http://www.delphibrasil.eti.br/ http://clubedodelphi.com.br http://www.inprise.com.br/

DISPARANDO SONS DO SISTEMA (MULTIMÍDIA) Para utilizar os sons do sistema, utilize a função PlaySound. PlaySound(pChar('SYSTEMSTART'),0,SND_ASYNC);

Outros sons: SYSTEMSTART SYSTEMEXIT SYSTEMHAND SYSTEMASTERISK SYSTEMQUESTION SYSTEMEXCLAMATION SYSTEMWELCOME SYSTEMDEFAULT É necessário incluir as biblioteca

mmsystem

na cláusula uses da Inteface

GARANTINDO UMA INSTÂNCIA DO APLICATIVO Para que seu aplicativo não seja executado várias vezes, utilize o seguinte código no arquivo de projeto (DPR). A função FindWindow procura se há outra tela da classe passada como parâmetro, se houver, traz para frente e não cria a aplicação novamente. program Project1; uses Forms,Windows,

89


Unit1 in 'Unit1.pas' {Form1}; {$R *.RES}

begin if FindWindow('TForm1','Form1') <> 0 then SetForegroundWindow(FindWindow('TForm1','Form1'))

else begin Application.Initialize; Application.CreateForm(TForm1, Form1); Application.Run;

end; end.

É necessário incluir a biblioteca windows na cláusula uses do arquivo DPR.

PERMITIR APENAS NÚMEROS EM UM TEDIT procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char); begin if ((Key in ['0'..'9'] = False) and (Word(Key) <> VK_BACK)) then Key := #0;

end;

90


Apêndice C - INTRODUÇÃO À ORIENTAÇÃO A OBJETOS Mais do que popular, a orientação a objetos é uma metodologia que ganhou espaço no mercado, e ao que tudo indica, veio para ficar. Vamos abordar alguns conceitos importantes para o inicio do estudo da ferramenta Delphi, seria importante que na sua vida profissional você possa aprofundar-se mais nestes e outros conceitos que pelo enfoque, não serão abordados. Uma referencia bibliográfica no final da apostila irá ajuda-lo(a) a encontrar mais informações a respeito. Independente da ferramenta (Delphi, C++Builder, PowerBuilder, entre outras), a orientação a objetos é uma teoria da década de 70 que veio ser implementada com grande destaque nas ferramentas visuais. Essa técnica é baseada no conceito de classes. Classe é um ‘tipo abstrado de dados’, ou seja, um novo tipo criado pelo ‘desenvolvedor’ que pode conter métodos e propriedades . É como compararmos um tipo classe com um tipo record . Com o tipo classe é possível implementar um conjunto de recursos OO4, sendo um dos principais chamado herança, que é uma poderosa maneira de reaproveitamento de código. Considerando simplesmente a título de exemplo vamos criar a classe base TSerVivo com as seguintes características e tipos de dados: • • •

Tamanho : Single Cor : String Forma(Obeso, Magro) : String

e que pode possuir as seguintes ações: Alimentar • Respirar •

Um exemplo de herança seria criar as classes TSerHumano e TAnimais como descendente de TSerVivo, desta forma, a classe descendente herda todas as características e ações criadas na classe ascendente podendo acrescentar particularidades à sua estrutura, exemplo: TSerHumano • • • • • •

   

Tamanho : Single Cor : String Forma : String

Vestimenta : String CorCabelo: String Sexo : Char Alimentar Respirar

Falar Caminhar

TAnimais • • • • •

  

Tamanho : Single Cor : String Forma : String

NºPatas : Integer Cauda : Boolean Alimentar Respirar

EmitirSom

91


Os objetos são variáveis do tipo classe, onde as características são consideradas propriedades, e as rotinas chamadas pelos objetos são denominadas métodos. As ações disparadas pelo usuário ou pelo sistema no componente serão chamados eventos. Eles são de extrema importância pois definem quando um conjunto de comandos será executado. Ainda exemplificando, podemos utilizar as propriedades atribuindo valores de acordo com o tipo de dados definido (não estamos considerando a sintaxe completa em Object Pascal) e utilizar os métodos apenas chamando o nome da rotina. Edileumar,Jorgina Cachorro

: TSerHumano; : TAnimais;

begin Edileumar.Tamanho := 1.70; Edileumar.Forma := ‘Magro’; Edileumar.Sexo := ‘M’; Jorgina.Tamanho := 1.60; Jorgina.Sexo := ‘F’; Jorgina.CorCabelo := ‘Castanhos’; Edileumar.Falar; Jorgina.Caminhar; Cachorro.Tamanho := 0.60; Cachorro.Cauda := True; Cachorro.Alimentar;

end;

Observe que as propriedades recebem valores e os métodos executam rotinas (procedimentos ou funções) sobre o objeto que o invocou. Alguns métodos podem receber parâmetros. O que acontece no Delphi é que existe uma gigantesca estrutura de classes onde TObject é a classe base das demais classes. Apesar de não ser necessário manipular este recurso diretamente, é importante saber seu funcionamento básico. Você verá as declarações de classe dentro do Delphi como abaixo, um formulário com dois componentes (objetos) button e um componente edit será declarado assim: type TForm1 = class(TForm) Button1: TButton; Button2: TButton; Edit1: TEdit;

private { Private declarations }

public { Public declarations }

end;

Essa introdução vem apenas ilustrar os principais conceitos: Propriedades, eventos e métodos, sendo amplamente utilizados durante o curso. A herança é um recurso importante implementado na OO, não sendo o único, obviamente. Polimorfismo, encapsulamento entre outros, são conceitos que a principio você não precisa saber para manipular a ferramenta (Delphi), mas em um futuro próximo será muito importante. 92

Delphi 7 - Programacao inicial

Recommend Documents