DelphiFATEC - Programação

1
DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO
Borland
Delphi
1
PROGRAMAO | ANLISE, PROJETO E DESENVOLVIMENTO DE SISTEMAS
FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

As Faculdades de Tecnologia do Estado de So Paulo (FATEC) so instituies pblicas de ensino superior pertencentes ao Centro Estadual de Educao Tecnolgica Paula Souza (CEETEPS), autarquia de regime especial vinculada e associada, por fora de lei estadual, Universidade Estadual Paulista Jlio de Mesquita Filho (UNESP). As FATEC's oferecem Cursos Superiores de Tecnologia em diversas reas do conhecimento, com exceo as unidades de So Caetano do Sul, Ourinhos, Carapicuba e Americana que oferecem as opes de Bacharelado e Licenciatura no curso de Anlise de Sistemas e Tecnologia da Informao
HISTRICO
O marco inicial da trajetria da FATEC-SP foi a fundao, em 1969, do Centro Estadual de Educao Tecnolgica de So Paulo pelo ento Governador do estado Abreu Sodr, que tinha por objetivo a formao de tcnicos de nvel superior para atender a crescente demanda de profissionais de nvel universitrio. O CEETEPS foi instalado na praa Coronel Fernando Prestes no centro da capital paulista, utilizando o antigo campus da Escola Politcnica da USP. Os cursos ministrados pela FATEC-SP so os mais antigos, tendo sido ministrados ininterruptamente desde de 1969. Naquele ano, foi fundada na cidade de Sorocaba a Faculdade de Tecnologia de Sorocaba, tambm com os mesmos objetivos. No ano de 1970, foram criados os Cursos Superiores de Tecnologia em Construo Civil, nas modalidades: Edifcios, Obras Hidrulicas e Movimento de Terra e Pavimentao, bem como os Cursos Superiores de Tecnologia em Mecnica, nas modalidades: Ofcinas e Desenhista/Projetista. Em 1973, por meio de decreto estadual, o Centro passou a ser denominado Centro Estadual de Educao Tecnolgica Paula Souza e seus cursos passavam a constituir a Faculdade de Tecnologia de So Paulo. Dessa forma, o CEETEPS se tornou o mantenedor de duas FATECs, uma na cidade de So Paulo e a outra em Sorocaba. Em 1974, foi criado o curso superior de Tecnologia em Processamento de Dados. Em 1976, o governo estadual, reuniu todos os seus estabelecimentos isolados de ensino superior por meio de lei, para constituir a Universidade Estadual Paulista Jlio de Mesquita Filho - UNESP. Como o CEETEPS no era uma instituio de ensino e sim o mantenedor de duas unidades universitrias, a lei que criou a UNESP estabeleceu que o CEETEPS integraria o conjunto universitrio da nova universidade na condio de autarquia de regime especial, vinculado e associado ela.
2
CURSO: TECNOLOGIA EM PROCESSAMENTO DE DADOS

Perfil Profissional do Tecnlogo em Processamento de Dados Atuando nas reas de Anlise de Sistemas, capaz de desenvolver e administrar projetos de Sistemas de Informao. Conhece caractersticas de equipamentos, estando apto a fazer estudos de necessidades e viabilidade tcnico-econmica de equipamentos e Sistemas de Informao. Conhece administrao de empresas, podendo vir a ser analista de organizao ou mesmo assumir todos os nveis de chefias na rea de Informtica. Pode dedicar-se ao ensino e pesquisa, dentro do seu campo profissional. Conhece linguagens de programao comerciais e cientficas, podendo realizar manuteno de sistemas de computadores e, ainda, como analista de software, pesquisar a otimizao e aplicao de sistemas. Pode atuar no dimensionamento, implantao e gerncia de redes de teleprocessamento. Conhece estruturas de dados e pesquisas a arquivos, estando habilitado a atuar em reas de Administrao de Dados e Administrao de Banco de Dados.
3
NDICE
FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO .................................................................... 2 HISTRICO ................................................................................................................................................ 2 CURSO: TECNOLOGIA EM PROCESSAMENTO DE DADOS .......................................................................... 3 NDICE.................................................................................................................................................... 4 CAPTULO 01 - O AMBIENTE DE DESENVOLVIMENTO DO DELPHI ......................................................... 10 1.1. 1.2. 1.3. 1.4. 1.5. 1.6. 1.7. 1.8. 1.9. A JANELA PRINCIPAL ........................................................................................................................ 10 A PALETA DE COMPONENTES ............................................................................................................. 11 A BARRA DE FERRAMENTAS ............................................................................................................... 11 A BARRA DE MENUS E OS MENUS DE ATALHO ....................................................................................... 12 OS FORMULRIOS ........................................................................................................................... 13 O EDITOR DE CDIGO ...................................................................................................................... 13 O CODE EXPLORER .......................................................................................................................... 14 O OBJECT INSPECTOR ....................................................................................................................... 15 NAVEGANDO PELO AMBIENTE ............................................................................................................ 15
CAPTULO 02 - A ESTRUTURA DE UM APLICATIVO NO DELPHI ............................................................. 17 2.1. FORMULRIOS E UNITS ..................................................................................................................... 17 2.2. TRABALHANDO COM PROJETOS .......................................................................................................... 17 2.3. O QUE O ARQUIVO DE PROJETO ........................................................................................................ 17 2.4. VISUALIZANDO E ENTENDENDO O ARQUIVO DE PROJETO .......................................................................... 18 2.5. ALTERANDO O ARQUIVO DE PROJETO ................................................................................................... 19 2.6. USANDO O PROJECT MANAGER.......................................................................................................... 19 2.7. USANDO PROJECT GROUPS ............................................................................................................... 20 2.8. SALVANDO UM PROJECT GROUP......................................................................................................... 21 2.9. ADICIONANDO E REMOVENDO PROJETOS EM UM PROJECT GROUP ............................................................ 21 2.10. ATIVANDO UM PROJETO................................................................................................................ 22 2.11. COMPILANDO E EXECUTANDO PROJETOS .......................................................................................... 22 2.12. VERIFICANDO APENAS A SINTAXE .................................................................................................... 22 2.13. COMPILANDO PROJETOS ............................................................................................................... 22 2.14. COMPILANDO PROJECT GROUPS..................................................................................................... 23 2.15. MOSTRANDO INFORMAES SOBRE A COMPILAO ........................................................................... 23 2.16. EXECUTANDO O APLICATIVO GERADO ............................................................................................... 23 2.17. ARQUIVOS GERADOS PELO DELPHI .................................................................................................. 24 2.17.1. Arquivos .DFM .................................................................................................................... 24 2.17.2. Arquivos .DCU ..................................................................................................................... 24 2.17.3. Arquivos .RES, .DOF e .CFG ................................................................................................. 25 CAPTULO 03 - COMPONENTES: CONCEITOS BSICOS .......................................................................... 26 3.1. 3.2. 3.3. 3.4. 3.5. 3.6. 3.7. 3.8. 3.9. 3.10. 3.11. 3.12. TIPOS DE COMPONENTES................................................................................................................... 26 COMPONENTES VISUAIS .................................................................................................................... 26 PROPRIEDADES................................................................................................................................ 26 ALTERANDO PROPRIEDADES EM TEMPO DE DESENVOLVIMENTO ................................................................ 26 ALTERANDO PROPRIEDADES EM TEMPO DE EXECUO............................................................................. 29 EVENTOS ....................................................................................................................................... 29 ASSOCIANDO CDIGO A UM EVENTO ................................................................................................... 29 APAGANDO EVENTOS ....................................................................................................................... 30 MTODOS ...................................................................................................................................... 30 ADICIONANDO COMPONENTES A UM FORMULRIO ............................................................................ 31 MANIPULANDO COMPONENTES ...................................................................................................... 32 SELECIONANDO E REDIMENSIONANDO COMPONENTES ........................................................................ 32
4
3.13. 3.14. 3.15. 3.16. 3.17.
DUPLICANDO E TRANSFERINDO COMPONENTES.................................................................................. 34 ALINHANDO, TRAVANDO E SOBREPONDO COMPONENTES .................................................................... 34 ALINHANDO PELA GRADE............................................................................................................... 36 TRAVANDO COMPONENTES ........................................................................................................... 36 CONTROLANDO A SOBREPOSIO DE COMPONENTES .......................................................................... 37
CAPTULO 04 - FORMULRIOS E CAIXAS DE DILOGO ......................................................................... 38 4.1. 4.2. 4.3. 4.4. 4.5. 4.6. 4.7. 4.8. 4.9. 4.10. 4.11. 4.12. 4.13. 4.14. 4.15. 4.16. 4.17. 4.18. ADICIONANDO FORMULRIOS ............................................................................................................ 38 ESPECIFICANDO O FORMULRIO PRINCIPAL ........................................................................................... 39 LIGANDO FORMULRIOS ................................................................................................................... 39 PROPRIEDADES DOS FORMULRIOS ..................................................................................................... 41 EVENTOS DOS FORMULRIOS ............................................................................................................. 43 MTODOS DOS FORMULRIOS............................................................................................................ 43 MOSTRANDO FORMULRIOS .............................................................................................................. 44 A PROPRIEDADE MODALRESULT ......................................................................................................... 45 USANDO O TECLADO COM FORMULRIOS ............................................................................................. 45 ALTERANDO A ORDEM DE TABULAO ............................................................................................. 45 EVITANDO QUE UM COMPONENTE RECEBA O FOCO............................................................................. 46 CONTROLANDO A CRIAO DOS FORMULRIOS .................................................................................. 46 IMPRIMINDO FORMULRIOS .......................................................................................................... 48 CAIXAS DE DILOGO PREDEFINIDAS.................................................................................................. 48 MESSAGE BOXES (CAIXAS DE MENSAGEM) ....................................................................................... 49 USANDO O COMANDO SHOWMESSAGE ........................................................................................... 49 USANDO A COMANDO MESSAGEDLG............................................................................................... 49 USANDO A FUNO INPUTBOX....................................................................................................... 51
CAPTULO 05 - TRABALHANDO COM MENUS ....................................................................................... 53 5.1. 5.2. 5.3. 5.4. 5.5. 5.6. 5.7. 5.8. 5.9. 5.10. ADICIONANDO MENUS E ABRINDO O MENU DESIGNER ............................................................................ 53 CONSTRUINDO MENUS PRINCIPAIS ...................................................................................................... 53 INSERINDO, MOVENDO E APAGANDO COMANDOS .................................................................................. 54 ADICIONANDO SEPARADORES ............................................................................................................. 55 DEFININDO "TECLAS DE ACELERAO" E TECLAS DE ATALHO ..................................................................... 55 CRIANDO SUBMENUS........................................................................................................................ 56 CONSTRUINDO MENUS POPUP............................................................................................................ 57 ASSOCIANDO CDIGO AOS COMANDOS DE UM MENU ............................................................................. 57 PROPRIEDADES IMPORTANTES DOS MENUS E COMANDOS ........................................................................ 57 TRABALHANDO COM VRIOS MENUS ............................................................................................... 58
CAPTULO 06 - COMPONENTES VISUAIS COMUNS ............................................................................... 59 6.1. PROPRIEDADES COMUNS ................................................................................................................... 59 6.2. EVENTOS COMUNS........................................................................................................................... 61 6.3. COMPONENTE BUTTON .................................................................................................................... 61 6.3.1. Propriedades ....................................................................................................................... 61 6.3.2. Eventos ............................................................................................................................... 61 6.4. COMPONENTE EDIT.......................................................................................................................... 62 6.4.1. Propriedades ....................................................................................................................... 62 6.4.2. Eventos ............................................................................................................................... 63 6.5. COMPONENTE LABEL........................................................................................................................ 63 6.5.1. Propriedades ....................................................................................................................... 63 6.5.2. Eventos ............................................................................................................................... 63 6.6. COMPONENTE MEMO ...................................................................................................................... 63 6.6.1. Propriedades ....................................................................................................................... 64 6.6.2. A propriedade Lines ............................................................................................................ 65 6.6.3. Eventos ............................................................................................................................... 66 6.7. COMPONENTE LISTBOX .................................................................................................................... 66 6.7.1. Propriedades ....................................................................................................................... 67 6.7.2. Eventos ............................................................................................................................... 67
5
6.8. COMPONENTE COMBOBOX ............................................................................................................... 68 6.8.1. Propriedades ....................................................................................................................... 68 6.8.2. Eventos ............................................................................................................................... 69 6.9. COMPONENTE CHECKBOX ................................................................................................................. 69 6.9.1. Propriedades ....................................................................................................................... 69 6.9.2 Eventos ............................................................................................................................... 69 6.10. COMPONENTE RADIOBUTTON ....................................................................................................... 70 6.11. COMPONENTE RADIOGROUP ......................................................................................................... 70 6.12. COMPONENTE GROUPBOX ............................................................................................................ 71 6.13. COMPONENTE PANEL ................................................................................................................... 71 6.14. COMPONENTE BITBTN.................................................................................................................. 72 CAPTULO 07 - A LINGUAGEM OBJECT PASCAL..................................................................................... 74 7.1. USANDO O COMANDO DE ATRIBUIO ................................................................................................. 74 7.2. ENTENDENDO IDENTIFICADORES ......................................................................................................... 74 7.3. DECLARANDO VARIVEIS ................................................................................................................... 75 7.4. TIPOS DE VARIVEIS ......................................................................................................................... 76 7.5. DECLARANDO CONSTANTES ............................................................................................................... 76 7.6. TIPOS ESTRUTURADOS ...................................................................................................................... 77 7.7. TIPOS ENUMERADOS ........................................................................................................................ 77 7.8. TIPOS DE INTERVALO (SUBRANGE) ...................................................................................................... 78 7.9. ARRAYS ......................................................................................................................................... 79 7.10. ARRAYS MULTIDIMENSIONAIS......................................................................................................... 80 7.11. STRINGS .................................................................................................................................... 80 7.12. REGISTROS (RECORDS) ................................................................................................................. 81 7.13. CONTROLE DE FLUXO .................................................................................................................... 82 7.14. USANDO BLOCOS ......................................................................................................................... 82 7.15. IF-THEN-ELSE .............................................................................................................................. 83 7.16. USANDO ELSE ............................................................................................................................. 83 7.17. USANDO BLOCOS COM O COMANDO IF............................................................................................. 83 7.18. ANINHANDO COMANDOS IF ........................................................................................................... 84 7.19. A ESTRUTURA CASE ...................................................................................................................... 85 7.20. USANDO LOOPS........................................................................................................................... 86 7.21. O LOOP FOR ............................................................................................................................... 86 7.22. O LOOP WHILE ............................................................................................................................ 88 7.23. O LOOP REPEAT ........................................................................................................................... 89 7.24. O COMANDO BREAK ..................................................................................................................... 90 7.25. O COMANDO CONTINUE................................................................................................................ 91 7.26. PROCEDURES E FUNCTIONS............................................................................................................ 91 7.27. SINTAXE DAS PROCEDURES E FUNCTIONS .......................................................................................... 92 7.28. ENTENDENDO PARMETROS .......................................................................................................... 93 7.29. DEFININDO O VALOR DE RETORNO DE UMA FUNCTION......................................................................... 93 7.30. CHAMANDO PROCEDURES E FUNCTIONS ........................................................................................... 94 7.31. ONDE CRIAR PROCEDURES E FUNCTIONS ........................................................................................... 94 7.32. TRABALHANDO COM EXCEES ...................................................................................................... 95 7.33. ENTENDENDO O CDIGO DAS UNITS ................................................................................................ 97 7.34. A ESTRUTURA BSICA DE UMA UNIT ................................................................................................ 97 7.34.1. Parte Interface .................................................................................................................... 98 7.34.2. Parte Implementation......................................................................................................... 98 7.34.3. Parte Initialization .............................................................................................................. 98 7.34.4. Parte finalization ................................................................................................................ 99 7.35. ROTINAS TEIS ............................................................................................................................ 99 7.36. ROTINAS PARA MANIPULAO DE STRINGS........................................................................................ 99 7.37. FUNES DE CONVERSO DE TIPO ................................................................................................. 100 CAPTULO 08 - O EDITOR DE CDIGO ................................................................................................. 101 8.1. VISUALIZANDO ARQUIVOS ............................................................................................................... 101
6
8.2. TCNICAS DE NAVEGAO ............................................................................................................... 103 8.3. USANDO BOOKMARKS .................................................................................................................... 103 8.4. USANDO O RECURSO CODE BROWSER................................................................................................ 104 8.5. LOCALIZANDO E SUBSTITUINDO......................................................................................................... 105 8.6. LOCALIZANDO TEXTOS NO ARQUIVO ATUAL ......................................................................................... 105 8.7. LOCALIZANDO TEXTOS EM VRIOS ARQUIVOS ...................................................................................... 106 8.8. OUTRAS TCNICAS PARA LOCALIZAO ............................................................................................... 107 8.9. SUBSTITUINDO TEXTOS ................................................................................................................... 107 8.10. CONFIGURANDO O EDITOR DE CDIGO .......................................................................................... 108 8.11. OPES IMPORTANTES DA PGINA DISPLAY .................................................................................... 109 8.12. OPES IMPORTANTES DA PGINA COLORS .................................................................................... 109 8.13. USANDO OS RECURSOS CODE INSIGHT ........................................................................................... 111 8.13.1. Code Completion............................................................................................................... 111 8.13.2. Code Parameters .............................................................................................................. 111 8.13.3. Code Templates ................................................................................................................ 112 8.14. CONFIGURANDO OS RECURSOS DO CODE INSIGHT ............................................................................ 114 CAPTULO 09 - O DEPURADOR INTEGRADO ....................................................................................... 116 9.1. 9.2. 9.3. 9.4. 9.5. 9.6. 9.7. 9.8. 9.9. 9.10. 9.11. 9.12. 9.13. 9.14. ERROS E TIPOS DE ERROS ................................................................................................................. 116 UTILIDADES DO DEPURADOR............................................................................................................ 116 EXECUTANDO UM PROGRAMA AT A POSIO DO CURSOR ..................................................................... 117 EXECUTANDO UM PROGRAMA LINHA POR LINHA .................................................................................. 118 O COMANDO TRACE INTO ............................................................................................................... 118 O COMANDO STEP OVER ................................................................................................................ 118 USANDO OS DOIS COMANDOS .......................................................................................................... 119 INTERROMPENDO A EXECUO ......................................................................................................... 119 USANDO BREAKPOINTS ................................................................................................................... 119 DEFININDO BREAKPOINTS ............................................................................................................ 120 MOSTRANDO OS BREAKPOINTS DEFINIDOS ...................................................................................... 120 VERIFICANDO VARIVEIS E EXPRESSES .......................................................................................... 121 TRABALHANDO COM WATCHES .................................................................................................... 121 AVALIANDO E MODIFICANDO EXPRESSES....................................................................................... 122
CAPTULO 10 - TRABALHANDO COM BANCOS DE DADOS NO DELPHI: UMA VISO GERAL ................ 124 10.1. 10.2. 10.3. 10.4. 10.5. 10.6. 10.7. 10.8. 10.9. 10.10. 10.11. 10.12. A ARQUITETURA DE ACESSO A BANCOS DE DADOS............................................................................. 124 COMPONENTES BSICOS ............................................................................................................. 125 A PGINA DATA ACCESS ............................................................................................................. 125 A PGINA DATA CONTROLS ......................................................................................................... 126 ACESSANDO BANCOS DE DADOS: UMA INTRODUO ......................................................................... 127 UM EXEMPLO TPICO .................................................................................................................. 127 USANDO O DATABASE DESKTOP................................................................................................... 128 DEFININDO UM ALIAS ................................................................................................................. 129 ALTERANDO O DIRETRIO DE TRABALHO......................................................................................... 131 CRIANDO TABELAS ..................................................................................................................... 131 ADICIONANDO DADOS A UMA TABELA ............................................................................................ 133 ALTERANDO A ESTRUTURA DE UMA TABELA ..................................................................................... 134
CAPTULO 11 - TRABALHANDO COM DATASETS ................................................................................. 136 11.1. 11.2. 11.3. 11.4. 11.5. 11.6. 11.7. 11.8. 11.9. ABRINDO E FECHANDO DATASETS ................................................................................................. 136 ESTADOS DE UM DATASET........................................................................................................... 136 NAVEGANDO EM UM DATASET .................................................................................................... 137 MODIFICANDO DATASETS ........................................................................................................... 140 MODIFICANDO CAMPOS.............................................................................................................. 140 ADICIONANDO REGISTROS ........................................................................................................... 141 APAGANDO REGISTROS ............................................................................................................... 142 CONFIRMANDO E CANCELANDO MUDANAS.................................................................................... 142 INSERINDO E MODIFICANDO REGISTROS INTEIROS ............................................................................ 143
7
11.10. 11.11. 11.12. 11.13. 11.14. 11.15.
LOCALIZANDO REGISTROS COM LOCATE.......................................................................................... 145 FILTRANDO DATASETS ................................................................................................................ 146 USANDO FILTER E FILTERED ......................................................................................................... 147 USANDO O EVENTO ONFILTERRECORD........................................................................................... 147 EVENTOS DOS DATASETS ............................................................................................................ 147 CONTROLANDO A ATUALIZAO DE COMPONENTES .......................................................................... 148
CAPTULO 12 - COMPONENTES DATASOURCE E TABLE ...................................................................... 150 12.1. 12.2. 12.3. 12.4. 12.5. 12.6. 12.7. USANDO O COMPONENTE DATASOURCE ........................................................................................ 150 PROPRIEDADES DO COMPONENTE DATASOURCE .............................................................................. 150 EVENTOS DO COMPONENTE DATASOURCE ...................................................................................... 150 USANDO O COMPONENTE TABLE .................................................................................................. 151 CONECTANDO-SE A UMA TABELA DE BANCO DE DADOS...................................................................... 151 CONTROLANDO O ACESSO A UMA TABELA ....................................................................................... 151 TRABALHANDO COM RANGES....................................................................................................... 152
CAPTULO 13 - COMPONENTES TFIELD ............................................................................................... 154 13.1. 13.2. 13.3. 13.4. 13.5. CRIANDO CAMPOS PERSISTENTES .................................................................................................. 154 TIPOS DE CAMPOS PERSISTENTES................................................................................................... 156 CAMPOS CALCULADOS ................................................................................................................ 157 CAMPOS LOOKUP ...................................................................................................................... 159 PROPRIEDADES DOS COMPONENTES TFIELD .................................................................................... 161
CAPTULO 14 - O COMPONENTE BATCHMOVE ................................................................................... 162 14.1. 14.2. 14.3. 14.4. CONFIGURAO BSICA .............................................................................................................. 162 MODOS DE OPERAO ............................................................................................................... 163 EXECUTANDO A OPERAO DE TRANSFERNCIA................................................................................ 163 LIDANDO COM ERROS NA TRANSFERNCIA ...................................................................................... 164
CAPTULO 15 - COMPONENTES DATA CONTROLS ............................................................................... 166 15.1. 15.2. 15.3. 15.4. 15.5. 15.6. 15.7. 15.8. 15.9. 15.10. 15.11. 15.12. PROPRIEDADES DATASOURCE E DATAFIELD .................................................................................... 166 OUTRAS PROPRIEDADES E RECURSOS COMUNS................................................................................. 166 COMPONENTE DBEDIT ............................................................................................................... 167 COMPONENTE DBTEXT .............................................................................................................. 167 COMPONENTE DBMEMO ........................................................................................................... 167 COMPONENTE DBCHECKBOX ...................................................................................................... 168 COMPONENTE DBRADIOGROUP .................................................................................................. 168 COMPONENTE DBIMAGE ............................................................................................................ 169 COMPONENTES DBLISTBOX E DCOMBOBOX .................................................................................. 169 COMPONENTES DBLOOKUPLIST E DBLOOKUPCOMBO ..................................................................... 170 COMPONENTE DBNAVIGATOR ..................................................................................................... 170 COMPONENTE DBGRID .............................................................................................................. 172
CAPTULO 16 - O COMPONENTE QUERY ............................................................................................. 174 16.1. 16.2. 16.3. 16.4. CONFIGURANDO UM COMPONENTE QUERY .................................................................................... 174 ESPECIFICANDO A CONSULTA SQL A SER EXECUTADA ........................................................................ 174 TRABALHANDO COM PARMETROS................................................................................................ 176 EXECUTANDO CONSULTAS ........................................................................................................... 177
CAPTULO 17 - A LINGUAGEM LOCAL SQL .......................................................................................... 178 17.1. 17.2. 17.3. 17.4. 17.5. 17.6. 17.7. AS DUAS PARTES DE SQL............................................................................................................. 178 O COMANDO SELECT ................................................................................................................ 179 USANDO IN E BETWEEN ........................................................................................................... 180 USANDO LIKE E CARACTERES "CURINGA" ....................................................................................... 180 USANDO FUNES DE AGREGAO ............................................................................................... 181 O COMANDO INSERT ................................................................................................................ 181 O COMANDO UPDATE .............................................................................................................. 182
8
17.8. 17.9. 17.10. 17.11. 17.12. 17.13. 17.14.
O COMANDO DELETE................................................................................................................ 182 A LINGUAGEM DE DEFINIO DE DADOS ......................................................................................... 182 O COMANDO CREATE TABLE .................................................................................................... 182 O COMANDO ALTER TABLE ....................................................................................................... 183 O COMANDO DROP TABLE ....................................................................................................... 184 O COMANDO CREATE INDEX .................................................................................................... 184 O COMANDO DROP INDEX ....................................................................................................... 184
CAPTULO 18 - COMPONENTES QUICKREPORT ................................................................................... 185 18.1. 18.2. 18.3. 18.4. 18.5. 18.6. 18.7. 18.8. 18.9. 18.10. 18.11. 18.12. CRIANDO UM RELATRIO SIMPLES ................................................................................................. 185 O COMPONENTE QUICKREP ........................................................................................................ 188 BANDAS E TIPOS DE BANDAS ........................................................................................................ 188 ALTERANDO A FORMATAO GERAL DO RELATRIO .......................................................................... 190 PROPRIEDADES COMUNS A TODAS AS BANDAS ................................................................................. 191 OUTROS COMPONENTES IMPORTANTES.......................................................................................... 191 O COMPONENTE QRLABEL.......................................................................................................... 191 O COMPONENTE QRDBTEXT ...................................................................................................... 192 O COMPONENTE QRSYSDATA ..................................................................................................... 192 O COMPONENTE QREXPR........................................................................................................... 192 CRIANDO RELATRIOS COM AGRUPAMENTO ................................................................................... 193 IMPRIMINDO E PRE-VISUALIZANDO RELATRIOS ............................................................................... 195
9
10
CAPTULO 01 - O AMBIENTE DE DESENVOLVIMENTO DO DELPHI

O Delphi oferece um ambiente visual de desenvolvimento rico e verstil. Os que nunca usaram outro ambiente visual de desenvolvimento como o Delphi (Visual Basic, Visual C++, PowerBuilder, etc.) podem estranhar inicialmente a organizao visual do ambiente. Diferentemente de aplicativos comuns, como o Word e o Excel da Microsoft, o Delphi no uma aplicativo MDI (com uma janela principal capaz de conter vrias janelas secundrias). O ambiente do Delphi composto por vrias janelas independentes que podem ser sobrepostas e reorganizadas livremente na tela.
O ambiente de desenvolvimento do Delphi Neste captulo, apresentaremos as partes principais do ambiente de desenvolvimento do Delphi.
1.1.
A Janela Principal
Na Janela Principal, localizada na parte de cima da tela, esto a Barra de Menus, a Paleta de Componentes e a Barra de Ferramentas (todas descritas a seguir). A janela principal uma janela comum, apesar de ter uma aparncia diferente do normal. Portanto possvel minimizla, maximiz-la e mov-la normalmente. Minimizar a janela principal, minimiza todas as outras janelas do Delphi no necessrio minimizar ou fechar cada uma das outras janelas
10
11
primeiro. Quando a janela principal do Delphi fechada, naturalmente, todo o ambiente (o Delphi inteiro) fechado.
1.2.
A Paleta de Componentes
A paleta de componentes uma das partes mais utilizadas do Delphi. a partir dessa paleta que se pode escolher componentes e adicion-los a formulrios. A paleta de componentes dividida em vrias pginas. Cada pgina contm um conjunto de componentes relacionados. As pginas mais usadas so a Standard (com componentes bsicos, como botes e caixas de texto), Additional (com alguns componentes especiais), e as pginas Data Access e Data Controls (para acesso e manipulao de bancos de dados). Essas pginas so ilustradas a seguir. Para passar de uma pgina para outra, clique na "aba" correspondente, na parte de cima da paleta de componentes.
1.3.
A Barra de Ferramentas
A Barra de Ferramentas oferece acesso rpido aos comandos mais comuns do Delphi, como criar formulrios, abrir e salvar arquivos, ou compilar e executar aplicativos. A barra de ferramentas pode ser configurada de vrias formas. Pode-se, por exemplo, adicionar botes para comandos chamados freqentemente, retirar botes da barra ou reorden-los. A barra de ferramentas formada por vrias partes que podem ser reorganizadas livremente. Para esconder/mostrar uma dessas partes, clique com o boto direito em qualquer local dentro da barra e desative/ative a opo correspondente (veja a figura abaixo).
11
12
Mostrando/escondendo partes da barra de ferramentas
Para adicionar um boto, clique na barra com o boto direito e escolha o comando Customize. Na caixa de dilogo que aparece, clique na aba "Commands". Aqui so mostrados todos os comandos do Delphi. Para criar um boto para um comando, arraste o comando para a barra.
Adicionando botes barra de ferramentas
Ainda com a caixa de dilogo "Customize" aberta, voc pode alterar a ordem dos botes arrastando-os para outras posies da barra. Para remover um boto, simplesmente arraste-o para fora da barra de ferramentas. Finalmente, para fazer com que partes da barra de ferramentas voltem sua configurao original (a mesma logo depois da instalao do Delphi), chame o comando Customize, clique na aba "Toolbar", selecione a parte que deseja alterar e clique no boto "Reset".
1.4.
A Barra de Menus e os Menus de atalho
Na barra de menus esto todos os comandos que podem ser chamados no Delphi. A barra de menus usada, normalmente, apenas para comandos pouco comuns. Os comandos mais comuns (como salvar um arquivo ou compilar um projeto, por exemplo), podem ser chamados mais rapidamente usando teclas de atalho, ou usando os botes da barra de ferramentas.
12
13
Os menus de atalho (chamados com o boto direito do mouse) so muito usados no Delphi. H menus de atalho associados a praticamente todas as partes do ambiente de desenvolvimento.
1.5.
Os Formulrios
Os formulrios (e o cdigo associado a eles, as Units) constituem o corao de um aplicativo no Delphi. Quando voc entra no Delphi, ou cria um novo projeto, um formulrio vazio criado automaticamente. Os formulrios so as partes visveis de um aplicativo no Delphi. Neles so inseridos componentes como botes, listas, etc. Formulrios podem ser usados com muitas funes diferentes em um aplicativo. Um formulrio pode, por exemplo, ser desde a janela principal at uma pequena caixa de mensagem.
1.6.
O Editor de Cdigo
A todo formulrio, associado um programa chamado de Unit, no Delphi que controla como os componentes dos formulrios reagem s aes do usurio (os eventos). As Units so exibidas no Editor de Cdigo (Code Editor). O Editor de Cdigo pode mostrar vrias Units ao mesmo tempo. Pode-se mudar de uma Unit para outra, usando-se as abas na parte de cima da janela (veja a figura). Veremos detalhes sobre o Editor de Cdigo mais adiante.
13
14
O Editor de Cdigo e o Code Explorer
1.7.
O Code Explorer
O Code Explorer, introduzido no Delphi 4, permite a navegao rpida entre partes de uma Unit aberta no Editor de Cdigo. O Code Explorer geralmente posicionado esquerda do Editor de Cdigo (veja a figura anterior). Nele exibido um diagrama hierrquico, com todas as variveis, mtodos, tipos, classes e propriedades definidas na Unit. Para navegar para um item especfico do cdigo da Unit (a definio de um mtodo ou varivel, por exemplo), simplesmente clique duas vezes no nome do item. O Code Explorer pode ser usado tambm para renomear itens, ou para adicionar novos itens. Para renomear um item, clique no nome do item com o boto direito e escolha o comando "Rename". Para adicionar um novo item clique com o boto direito em um item de mesmo tipo e escolha o comando "New". Para esconder o Code Explorer, clique no pequeno "x" no seu canto direito. Para voltar a exibilo, use o comando View | Code explorer ou pressione CTRL+SHIFT+E. A combinao CTRL+SHIFT+E tambm pode ser usada para alternar entre o Code Explorer e o Editor de Cdigo. DICA: Como padro, o Code Explorer exibido sempre que o Delphi inicializado, ou quando um projeto aberto. Para que o Delphi no exiba o Code Explorer automaticamente, chame o comando Edit|Environment options, mude para a pgina "Explorer" e desative a opo "Automatically show Explorer".
14
15
1.8.
O Object Inspector
O Object Inspector (traduo literal: "Inspetor de objetos") usado para definir propriedades e eventos para os componentes. As listas de propriedades e eventos exibidas no Object Inspector mudam de acordo com o componente selecionado. Outra funo importante do Object Inspector selecionar componentes por nome. Uma lista com o nome e o tipo de todos os componentes do formulrio ativo so exibidos na parte de cima do Object Inspector. Para selecionar um componente, basta escolher seu nome nessa lista. Para exibir/esconder o Object Inspector, use o comando View|Object Inspector, ou pressione F11. Veremos como usar o Object inspector em detalhe, mais adiante no curso.
1.9.
Navegando pelo ambiente
Durante o desenvolvimento de um aplicativo no Delphi, so criadas muitas janelas. O Delphi oferece vrios recursos para navegar entre essas janelas. Veja os mais importantes a seguir. Para alternar entre um formulrio e a Unit associada, realize uma das seguintes aes: Pressione F12, ou Escolha o comando View | Toggle Form /Unit, ou Clique no boto Toggle Form/Unit na barra de ferramentas (veja figura a seguir).
Para mostrar o Object Inspector ou traz-lo para a frente das outras janelas: Pressione F11, ou Escolha o comando View | Object Inspector. Para trazer uma janela que no est visvel para a frente:
1. Escolha o comando View | Window List
15
16
1. Clique duas vezes no nome da janela. Para exibir uma lista das Units no projeto e exibir uma delas no Editor de Cdigo: Escolha o comando View | Units (ou pressione CTRL+F12) e clique duas vezes no nome da Unit para exibi-la (veja a figura).
Para exibir uma lista dos formulrios no projeto e exibir um deles: Escolha o comando View | Forms (ou pressione SHIFT+F12) e clique duas vezes no nome do formulrio.
16
17
CAPTULO 02 - A ESTRUTURA DE UM APLICATIVO NO DELPHI

2.1. Formulrios e Units
Toda a parte visual e toda a interao com o usurio de um aplicativo criado no Delphi baseada nos formulrios. Para cada formulrio adicionado a um aplicativo, o Delphi cria uma Unit associada. Uma Unit (traduo literal: "Unidade") um programa completo em Object Pascal, a linguagem de programao usada no Delphi. As Units contm as declaraes (o nome e o tipo) de cada componente no formulrio, e o cdigo para os eventos definidos para esses componentes. NOTA* Apesar de ser comum criar aplicativos que s tenham Units associadas a formulrios, pode-se criar Units independentes, com cdigo que compartilhado por vrios formulrios, ou at vrios aplicativos. Boa parte do cdigo das Units gerado e mantido automaticamente pelo Delphi. Quando um componente adicionado, por exemplo, o Delphi acrescenta a sua declarao ao cdigo da Unit. Quando um componente removido, sua declarao removida tambm. Na maioria das vezes no se deve alterar diretamente o cdigo gerado pelo Delphi. O cdigo gerado pode ser alterado indiretamente, usando o Object Inspector e comandos de menu, ou manipulando os componentes diretamente no formulrio.
2.2.
Trabalhando com Projetos
Projeto o nome dado pelo Delphi ao conjunto de todos os formulrios, Units e outros objetos, usados na criao de um aplicativo. Em outras palavras, um projeto o cdigo fonte usado para gerar um aplicativo no Delphi.
2.3.
O que o arquivo de projeto
Para cada projeto, o Delphi mantm um arquivo de projeto. O arquivo de projeto um arquivo texto comum escrito em Object Pascal, que contm informaes sobre todas as partes de um projeto. Um arquivo de projeto criado automaticamente quando o Delphi inicializado, ou quando um novo projeto criado. Para cada projeto, por maior que seja, h apenas um arquivo de projeto. Quando voc compila um projeto no Delphi, o arquivo de projeto o primeiro a ser compilado. A partir dele, o Delphi sabe exatamente quais formulrios, Units e outros objetos devem ser compilados tambm, para gerar o arquivo final do aplicativo (em geral, um arquivo executvel). Outra funo importante do arquivo de projeto controlar a ordem de criao dos formulrios, como veremos depois.
17
18
2.4.
Visualizando e entendendo o arquivo de projeto
O arquivo de projeto no mostrado automaticamente no Editor de Cdigo. Para visualizar o arquivo de projeto do projeto atual, use o comando Project | View Source.
A ilustrao mostra o arquivo de projeto mnimo, aquele que criado junto com um novo projeto "vazio". Na barra de ttulo, na extremidade de cima da janela do Editor de Cdigo, mostrado o nome do arquivo de projeto. O nome mostrado na ilustrao ("Project1.dpr") gerado automaticamente pelo Delphi. A extenso .DPR vem de Delphi Project. (os prximos nomes gerados, caso sejam criados outros projetos, so "Project2.dpr", "Project3.dpr", e assim por diante). Lembre-se de alterar o nome do arquivo de projeto para um nome mais sugestivo na hora de salvar. A primeira linha do arquivo de projeto contm o nome do projeto. Este o nome que identifica o projeto para o Delphi, e geralmente o nome do arquivo, retirada a extenso. A palavra "program" usada para manter compatibilidade com verses anteriores do Turbo Pascal (o precursor do Delphi). Claramente, o uso da palavra "project" seria mais adequado no Delphi. A segunda linha: "Uses..." (chamada de clusula uses) indica quais Units so usadas pelo projeto. Aqui esto referenciados todos os formulrios usados no projeto e suas Units correspondentes, alm de Units que no esto associadas a nenhum formulrio. Na figura indicado o uso de uma nica Unit, com o nome Unit1. A palavra-chave in usada para indicar o arquivo que contm o cdigo da Unit ("Unit1.pas"). Logo em seguida, entre chaves, indicado o nome do formulrio associado Unit (no caso, Form1). NOTA: Os nomes dados s Units e formulrios so os mesmos nomes dos arquivos correspondentes. Por exemplo, se uma Unit for salva com o nome "CadastroProduto.pas", esta Unit ser identificada pelo nome "CadastroProduto" no Delphi. No entanto, se forem usados
18
19
espaos no nome do arquivo, ou se houver letras acentuadas, os nomes no sero iguais. Espaos e letras acentuadas so simplesmente retirados (sem avisos) do nome do arquivo. Se, por exemplo, voc chamou um formulrio de "Relatrio de preos.pas", o nome gerado pelo Delphi ser "Relatriodepreos". Evite, portanto, usar acentos ou espaos nos nomes dos seus arquivos. Voltando ao arquivo de projeto, a linha {$R ...} indica o arquivo de recursos (Resource file) que est associado ao projeto. Esta linha nunca deve ser removida sem ela seu aplicativo no ser compilado corretamente. O arquivo de recursos contm o cone do aplicativo, alm de outras informaes importantes. Este arquivo gerado automaticamente pelo Delphi e raramente precisa ser alterado manualmente. NOTA: as chaves indicam comentrios no Delphi. A nica exceo o caso descrito acima. Uma chave seguida por um cifro ( {$ ) indica o incio de uma diretiva de compilao - um comando especial para o compilador. Diretivas de compilao so um recurso avanado do Delphi que raramente usado diretamente pelo programador. A ltima parte do arquivo de projeto o bloco principal, delimitado pelas palavras-chave begin e end. A primeira linha dentro do bloco principal, Application.Initialize realiza as tarefas de inicializao do aplicativo, como carregar ou ler arquivos de inicializao. O comando Application.CreateForm cria um formulrio na memria, deixando-o pronto para a exibio na tela. Finalmente, o ltimo comando do bloco principal, Application.Run executa o aplicativo.
2.5.
Alterando o arquivo de projeto
A no ser em casos especiais, o arquivo de projeto no deve ser alterado manualmente. Ele atualizado automaticamente pelo Delphi quando so feitas alteraes no projeto (quando um formulrio adicionado, por exemplo). As alteraes no arquivo de projeto, quando necessrias, devem ser feitas atravs do Project Manager, ou usando o comando Project | Options. H um grande nmero de detalhes e opes que podem ser definidas.
2.6.
Usando o Project Manager
O Project Manager (Gerenciador de Projetos) uma ferramenta til que d acesso a todos os formulrios e Units de um projeto. O uso do Project Manager especialmente importante para projetos complexos, com muitas Units e formulrios. Para exibir o Project Manager, use o comando View | Project Manager. A ilustrao a seguir mostra o Project Manager para um projeto de tamanho mdio.
19
20
Na parte esquerda da janela do Project Manager, so exibidas as Units que fazem parte do projeto. As Units so agrupadas com os formulrios a elas associados. Para exibir o nome do formulrio associado a uma Unit, simplesmente clique no "+" ao lado do nome da Unit. Na parte direita do Project Manager, mostrado o path das Units (arquivos .PAS) e dos arquivos de descrio dos formulrios (arquivos .DFM). No exemplo ilustrado, a primeira Unit ("UnAuxiliares") no est associada a um formulrio e portanto aparece de forma diferente na listagem. O primeiro item da listagem ("Supermarkt") o nome do Project Group ao qual pertence o projeto (veremos como trabalhar com Project Groups mais adiante). Uma das funes mais importantes do Project Manager a navegao entre os arquivos de um projeto. Para mostrar o cdigo de uma Unit no Editor de Cdigo, ou para exibir um formulrio, clique no seu nome duas vezes.
2.7.
Usando Project Groups
O Delphi 4 introduziu os Project Groups (Grupos de Projetos), que permitem trabalhar com vrios projetos ao mesmo tempo. Os Project Groups so teis para aplicativos complexos, com vrios arquivos executveis, ou com vrias DLLs (bibliotecas de funes). Os Project Groups facilitam a compilao e a depurao de conjuntos de projetos relacionados. Cdigo de um projeto, por exemplo, pode ser copiado facilmente para outro projeto do mesmo Project Group.
20
21
Um Project Group com trs projetos, exibido no Project Manager
2.8.
Salvando um Project Group
Para cada Project Group, o Delphi mantm um arquivo com a extenso .BPG. Este arquivo, no entanto, s escrito no disco quando salvo explicitamente pelo programador. Para salvar o arquivo do Project Group, abra o Project Manager (View | Project Manager), clique com o boto direito no nome do Project Group (o primeiro nome exibido) e escolha o comando Save Project Group. NOTA: Se voc usar o comando File | Save all para salvar todos os arquivos de um projeto, o arquivo do Project Group ser salvo tambm.
2.9.
Adicionando e removendo projetos em um Project Group
Pode-se adicionar novos projetos, ou projetos j existentes a um Project Group. Para adicionar um novo projeto, use o comando Project | Add New Project. Este comando abre a caixa de dilogo New Items, onde pode ser escolhido o tipo de projeto. Para adicionar um projeto existente, use o comando Project | Add Existing Project e escolha o projeto a ser adicionado (arquivo .DPR). Para remover um projeto de um Project Group, necessrio usar o Project Manager (no h comando de menu para isso). No Project Manager, simplesmente clique no nome do projeto a ser removido e pressione DELETE. Outra maneira usar o boto Remove da barra de ferramentas do Project Manager. Note que um projeto no apagado quando removido de um Project Group. Vale notar, tambm, que um mesmo projeto pode fazer parte de vrios Project Groups diferentes.
21
22
2.10. Ativando um projeto

Um Project Group pode conter vrios projetos, mas apenas um deles pode estar ativo. O projeto ativo aquele que compilado ou executado com os comandos do menu Project, ou com as teclas de atalho (veja a seguir). O projeto ativo aparece em negrito no Project Manager. Para ativar um projeto, clique no seu nome duas vezes, ou use o boto Activate da barra de ferramentas do Project Manager.
2.11. Compilando e executando projetos

Pode-se compilar e executar um projeto a qualquer momento durante o desenvolvimento (contanto que no haja erros no cdigo, claro). H vrias maneiras de compilar um projeto no Delphi. A execuo tambm pode ser realizada de vrias formas.
2.12. Verificando apenas a sintaxe

possvel verificar se os arquivos de um projeto contm erros de sintaxe. Esse procedimento muito rpido, porque o Delphi no precisa gerar um arquivo final. Para verificar a sintaxe de todos os arquivos do projeto atual: Escolha o comando Project | Syntax Check [nome do projeto] O Delphi verifica a sintaxe e mostra os erros resultantes em uma nova janela. Se no houver erros, volta ao estado anterior. No exibida nenhuma mensagem.
2.13. Compilando projetos

A compilao, alm de verificar a sintaxe dos programas, gera o cdigo executvel do aplicativo. H dois comandos para realizar a compilao no Delphi: Compile e Build, ambos no menu Project. O comando Project | Compile [nome do projeto] compila somente os arquivos do projeto que foram alterados desde a ltima compilao. O comando Project | Build [nome do projeto] compila todos os arquivos do projeto, alterados ou no.
Os comandos de compilao (para um projeto chamado "Editor")
22
23
O comandos Compile e Build realizam a compilao do projeto ativo. Para compilar outro projeto do mesmo Project Group, necessrio antes ativar o projeto, usando o Project Manager.
2.14. Compilando Project Groups

possvel compilar todos os projetos de um Project Group. Para isso, use os comandos Project | Compile All Projects e Project | Build All Projects. Esses dois comandos funcionam de forma semelhante aos comandos Project | Compile e Project | Build, com a diferena de que compilam todos os projetos do Project Group, e no apenas o projeto ativo.
2.15. Mostrando informaes sobre a compilao

Como o compilador do Delphi muito rpido, por padro no so exibidas informaes sobre o andamento da compilao. Essas informaes esto disponveis, no entanto, e podem ser mostradas durante a compilao. Para isso, escolha o comando Tools | Environment Options, mude para a pgina "Preferences", e ative a opo "Show Compiler Progress". Pode-se tambm, exibir as informaes sobre a compilao, a qualquer momento (depois da primeira compilao). Para isso, use o comando Project | Information for [nome do projeto].
Exemplo de informaes de compilao para um projeto
2.16. Executando o aplicativo gerado

Depois de compilar um projeto, voc pode executar o aplicativo gerado de dentro do Delphi, para test-lo. Voc pode tambm executar o aplicativo de fora do Delphi, usando o Explorer do Windows, por exemplo. A vantagem de executar o aplicativo de dentro do Delphi, que o Delphi capaz de identificar e interceptar os erros que ocorrerem durante a execuo do aplicativo. Para executar o aplicativo ativo a partir do Delphi: Escolha o comando Run | Run, ou pressione F9.
23
24
Se o projeto tiver sido alterado depois da ltima compilao, o Delphi compila novamente o projeto. Se forem encontrados erros, eles so exibidos na parte de baixo do Editor de Cdigo, e o aplicativo no executado.
2.17. Arquivos gerados pelo Delphi

Um projeto no Delphi constitudo de arquivos de vrios tipos. Nas sees anteriores, mencionamos dois dos mais importantes: o arquivo de projeto (extenso .DPR) e as Units (extenso .PAS). Outros arquivos muito importantes gerados so os arquivos de descrio de formulrio (extenso .DFM). Os arquivos .DPR, .PAS e .DFM constituem o verdadeiro "cdigo fonte" do programa e so (geralmente) os nicos arquivos imprescindveis para a gerao do aplicativo final. Vrios outros arquivos so gerados na primeira compilao do projeto, como os arquivos .RES, .CFG e .DOF.
2.17.1. Arquivos .DFM Arquivos .DFM (arquivos de descrio de formulrio) so criados para cada formulrio. O Delphi usa o mesmo nome da Unit associada, acrescentando apenas a extenso .DFM. Os arquivos .DFM contm informaes detalhadas sobre o formulrio e seus componentes. So armazenados em um formato binrio, legvel apenas a partir do Delphi, mas podem ser facilmente convertidos para arquivos texto e exibidos no Editor de Cdigo. Para mostrar o arquivo DFM associado a um formulrio: Clique no formulrio com o boto direito e escolha o comando View as Text. O arquivo exibido dentro do Editor de Cdigo. Para voltar viso normal do formulrio: Clique com o boto direito dentro do Editor de Cdigo (em cima do texto do arquivo DFM) e escolha o comando View as Form.
2.17.2. Arquivos .DCU Quando um projeto compilado no Delphi, os arquivos .DFM dos formulrios e as units (arquivos .PAS) so processados e transformados em arquivos compilados intermedirios, com a extenso .DCU (de "Delphi Compiled Unit"). Estes arquivos so gravados em formato binrio e no podem (nem devem) ser abertos diretamente. Os arquivos DCU tornam mais rpidas a compilao e a linkagem de aplicativos no Delphi.
24
25
2.17.3. Arquivos .RES, .DOF e .CFG Os arquivos .RES, so gerados automaticamente pelo Delphi. Esses arquivos contm, por exemplo, o cone do aplicativo, imagens, cursores e outros recursos relacionados ao Windows. A alterao e o uso direto dos arquivos .RES est alm do escopo deste curso bsico. Os arquivos .DOF e .CFG, tambm gerados automaticamente, so usados para manter informaes sobre opes do compilador e do linkeditor. Esses arquivos so alterados indiretamente usando o comando Project | Options. Os arquivos .DOF e .CFG nunca devem ser alterados diretamente.
25
26
CAPTULO 03 - COMPONENTES: CONCEITOS BSICOS

Os componentes so a parte mais importante da maioria dos aplicativos criados no Delphi. O Delphi oferece uma grande quantidade de componentes. Componentes podem ser usados para construir aplicativos completos rapidamente, algumas vezes com poucos cliques do mouse.
3.1.
Tipos de componentes
Componentes podem ser divididos em dois tipos bsicos: componentes no-visuais e componentes visuais (controles).
3.2.
Componentes visuais
Os componentes visuais, ou controles, so componentes com os quais o usurio pode interagir diretamente. Exemplos de controles so botes, caixas de texto, barras de rolagem, etc. Os componentes visuais tm a mesma aparncia em tempo de desenvolvimento e em tempo de execuo (salvo raras excees).
3.3.
Propriedades
Cada componente no Delphi apresenta um conjunto de propriedades que determinam o comportamento e a aparncia do componente. Propriedades podem ser definidas durante o desenvolvimento, ou alteradas durante o tempo de execuo.
3.4.
Alterando propriedades em tempo de desenvolvimento
As propriedades de um componente que podem ser alteradas em tempo de desenvolvimento so listadas na parte esquerda do Object Inspector. Na parte direita do Object Inspector, so listados os valores para cada propriedade. H vrios tipos de propriedades no Delphi. As propriedades mais comuns so as com valores numricos ou strings. Para alterar esse tipo de propriedade, simplesmente digite um novo valor ou string, ao lado do nome da propriedade.
Propriedade numricas e de strings
26
27
Algumas propriedades so restritas a uma lista de valores. As mais simples destas so as propriedade booleanas, com apenas os valores "True" ou "False" permitidos. Algumas propriedades permitem a escolha a partir de listas extensas. Para escolher um valor para uma propriedade desse tipo, simplesmente clique ao lado do nome da propriedade no Object Inspector, e escolha uma das opes da lista exibida (veja a figura a seguir).
Uma propriedade com uma lista de opes DICA: para propriedades com listas de valores, pode-se clicar duas vezes ao lado da propriedade, para exibir o prximo valor da lista. Esse recurso especialmente til para propriedades com poucos valores possveis, como as propriedades booleanas. Outro tipo de propriedade a propriedade composta. Propriedades compostas, contm vrias subpropriedades. Os valores das subpropriedades determinam o valor final da propriedade composta. As propriedades compostas aparecem no Object Inspector precedidas de um sinal "+" (quando no expandidas). Para definir estes valores para uma propriedade composta, primeiro clique duas vezes no nome da propriedade para abrir sua lista de subpropriedades. Em seguida altere os valores das subpropriedades desejadas. As subpropriedades podem ser de qualquer tipo (inclusive compostas).
27
28
Exemplos de propriedades e subpropriedades compostas Para algumas propriedades complexas, com muitas combinaes de valores possveis, o Delphi oferece editores de propriedades (property editors). Os editores de propriedades so comuns para propriedades compostas (como a propriedade Font, ilustrada acima). Nesse caso, o editor de propriedades simplesmente outra forma de alterar a propriedade, aumentando a convenincia para o programador. Para outras propriedades mais complexas, no entanto, os editores de propriedades so a nica opo. Propriedades que podem ser alteradas com um editor de propriedades aparecem com reticncias, quando so selecionados no Object Inspector. Para abrir o editor de propriedades, basta clicar nas reticncias, ou clicar duas vezes ao lado da propriedade. O editor de propriedades varia muito dependendo do tipo de propriedade. Veja um exemplo comum (para um componente Memo) na figura a seguir.
Clique nas reticncias
para exibir o editor de propriedades para a propriedade selecionada
DICA: pode-se alterar propriedades de vrios componentes ao mesmo tempo. Quando vrios componentes so selecionados em um formulrio, o Object Inspector mostra as propriedades comuns a todos eles. Se uma propriedade for alterada com vrios componentes selecionados, todos esses componentes passaro a ter o mesmo valor para a propriedade alterada.
28
29
3.5.
Alterando propriedades em tempo de execuo
As propriedades de um componente podem tambm ser alteradas em tempo de execuo. Essas alteraes devem ser feitas usando programao. H algumas propriedades que s podem ser alteradas usando programao. Essas propriedades no so listadas no Object Inspector e portanto s esto acessveis a partir de programas. Alterar uma propriedade de um componente usando programao simples. O seguinte trecho de cdigo altera o ttulo de um formulrio chamado "Form1" para "Principal" e depois desabilita um boto chamado "Button1", alterando sua propriedade Enabled para False. Form1.Caption := Principal; Button1.Enabled := False; Comandos desse tipo so os comandos mais simples e mais usados no Delphi. So chamados de atribuies (como em outras linguagens de programao). Nesse caso, o lado esquerdo da atribuio define o componente e a propriedade que ser alterada (separados por pontos). No lado direito especificado o valor. Note que o smbolo para a atribuio de Object Pascal diferente da maioria das outras linguagens (:=).
3.6.
Eventos
Os eventos determinam a parte dinmica de um aplicativo. Eles definem como o aplicativo reage s aes do usurio (ou de outros componentes). Cada componente oferece um conjunto de eventos especficos. Para cada evento, pode-se associar um trecho de cdigo que executado quando o evento acontece. O cdigo para os eventos de todos os componentes em um formulrio armazenado na Unit associada ao formulrio.
3.7.
Associando cdigo a um evento
Os eventos disponveis para um componente so listados na pgina Events do Object Inspector. Para muitos componentes, a lista de eventos extensa. No entanto, somente poucos eventos so usados com frequncia.
H trs formas bsicas para adicionar eventos a um componente:

Clicar duas vezes no componente: isso altera o evento padro do componente. O evento padro geralmente o mais usado. Para o componente Button, por exemplo, o evento padro OnClick, que ocorre quando o boto clicado. O Delphi mostra o Editor de Cdigo, j com um "esqueleto" do cdigo para o evento. Veja um exemplo desse esqueleto: procedure TForm1.Button1Click(Sender: TObject); begin | end;
29
30
Entre o begin e o end digitado o cdigo a ser executado quando o usurio clica no boto (o Delphi j posiciona o cursor nesse local automaticamente). No exemplo a seguir, dois comandos foram adicionados para o evento. Esses sero os comandos executados quando o componente chamado "Button1" for clicado uma vez. procedure TForm1.Button1Click(Sender: TObject); begin Form1.Caption := Principal; Button1.Enabled := False; end; A maneira descrita aqui funciona somente para os eventos padro dos componentes. Para adicionar cdigo para qualquer outro evento, deve-se realizar uma das aes descritas a seguir. Clicar duas vezes ao lado do evento desejado (no Object Inspector): mostra o cdigo para o evento no Editor de Cdigo. A partir da, pode-se proceder como antes para digitar o cdigo associado ao evento. Escolher um procedimento j definido para um evento: clique do lado direito do nome do evento, no Object Inspector e escolha o nome do procedimento da lista que aparece. Faa isso quando for necessrio associar o mesmo cdigo a eventos de componentes diferentes. (Se ainda no houver nenhum cdigo definido para eventos no formulrio, a lista aparece vazia).
3.8.
Apagando eventos
Pode-se apagar eventos definidos para um componente, para corrigir um erro no desenvolvimento por exemplo. Um evento pode ser apagado em "dois nveis". O evento pode ser simplesmente desligado de um componente, permanecendo ligado a outros componentes, ou pode ser removido inteiramente do cdigo. Para desligar um evento de um componente, selecione o componente e clique no lado do evento a ser removido, no Object Inspector. Isso seleciona o nome do evento. Em seguida, apague (pressione DELETE e depois ENTER). Para remover um evento inteiramente do cdigo, apague todo o cdigo dentro do evento, deixando apenas o cdigo gerado automaticamente pelo Delphi (a primeira linha, o begin e o end). Em seguida, salve o arquivo, ou compile o projeto. O Delphi remove o evento e todas as ligaes a esse evento.
3.9.
Mtodos
Mtodos (basicamente) so operaes oferecidas por componentes do Delphi. Os mtodos de um componente, acessveis somente atravs de programao, so usados para ler ou alterar propriedades de um componente, ou para realizar tarefas especiais. Para ver a lista de mtodos oferecidos por um componente, voc precisa usar o recurso de ajuda do Delphi (os mtodos no so listados no Object Inspector). Para isso, selecione o
30
31
componente no formulrio e pressione F1. Em seguida clique na opo Methods, na parte de cima da janela de ajuda. (Note que alguns componentes no oferecem nenhum mtodo).
3.10. Adicionando componentes a um formulrio

H vrias tcnicas para adicionar componentes a um formulrio. Apresentamos todas elas a seguir. Para adicionar um componente a um local especfico do formulrio:
1. Escolha o componente a ser adicionado, na paleta de componentes (mude para a pgina da paleta que contm o componente, se necessrio). 1. Clique no formulrio, no local onde deseja adicionar o componente. O componente adicionado no local clicado. Para adicionar um componente ao centro do formulrio: Na paleta de componentes, clique duas vezes no componente. Se j houver outros componentes no formulrio, outros componentes adicionados usando esse mtodo so colocados um pouco abaixo e direita do ltimos adicionados. Isso garante que os componentes no "desapaream" uns por trs outros. Para adicionar vrias cpias de um mesmo componente:
1. Na paleta de componentes, clique no componente segurando a tecla SHIFT. 1. Clique no formulrio (vrias vezes) nos locais desejados. No necessrio selecionar novamente o componente, antes de cada clique. 2. Quando terminar, clique novamente no componente (na paleta de componentes) para desativ-lo. Para definir o tamanho de um componente no momento em que adicionado:
1. Na paleta de componentes, clique no componente. 1. No formulrio, arraste para definir o tamanho desejado para o componente. Para adicionar um componente sem usar a paleta de componentes
1. Chame o comando View | Component List. Uma caixa com todos os componentes disponveis, listados em ordem alfabtica exeibida (veja a figura).
31
32
2. Clique duas vezes no nome do componente, ou selecione o componente e clique no boto "Add to form". 3. Repita a operao para cada componente que deseja adicionar. Ao final, feche a caixa.
3.11. Manipulando componentes

O Delphi oferece vrias tcnicas para a organizao precisa de componentes em um formulrio. Vejas as mais importantes dessas tcnicas a seguir.
3.12. Selecionando e redimensionando componentes

Para fazer alteraes em um componente, necessrio primeiro selecion-lo. Veja as maneiras mais comuns. Para selecionar um nico componente em um formulrio, realize uma das seguintes operaes: Clique no componente Clique em uma rea vazia do formulrio e em seguida use TAB para alternar para o componente Selecione o nome do componente na lista localizada na parte de cima do Object Inspector (veja a ilustrao a seguir).
32
33
Na parte de cima do Object Inspector so listados os nomes de todos os componentes no formulrio.
Selecione um componente da lista para selecion-lo no formulrio
Para selecionar vrios componentes, um de cada vez: Segure a tecla SHIFT e clique em cada um dos componentes. Para selecionar vrios componentes em uma mesma rea: Clique em uma rea vazia do formulrio prxima aos componentes e arraste. Um retngulo pontilhado exibido enquanto voc arrasta (veja a figura abaixo). Todos os componentes que estiverem dentro deste retngulo, ou parcialmente dentro dele, sero selecionados.
Se os componentes estiverem dentro de um GroupBox ou de um Panel mantenha a tecla CTRL enquanto arrasta. (Caso contrrio, o GroupBox ou Panel movido). Para selecionar todos os componentes em um formulrio: Use o comando Edit | Select All. Para redimensionar (alterar o tamanho de) um nico componente: Selecione o componente e arraste uma das alas (pequenos quadrados) que aparecem em volta dele. Para redimensionar vrios componentes ao mesmo tempo:
1. Selecione os componentes e escolha o comando Edit | Size (ou clique em um dos componentes com o boto direito e escolha o comando Size).
1. Na caixa de dilogo exibida (figura acima), defina as novas dimenses para os componentes. As opes disponveis so explicadas a seguir. (Note que as opes so as mesmas para as duas dimenses).
33
34
No change
"Nenhuma mudana": escolha essa opo para alterar somente a outra dimenso. "Reduzir para o menor": reduz o tamanho de todos os componentes selecionados para o tamanho do menor componente selecionado. "Aumentar para o maior": aumenta o tamanho de todos os componentes, para o tamanho do maior componente selecionado. "Largura": Especifique aqui a largura em pixels de todos os componentes selecionados. "Altura": A altura de todos os componentes selecionados.
Shrink to smallest
Grow do largest
Width
Height
3.13. Duplicando e transferindo componentes

No Delphi, no h um comando que permita duplicar um componente diretamente. Para fazer isso, necessrio usar os comandos Copy, Cut e Paste do menu Edit, ou as teclas de atalho correspondentes. Quando um componente duplicado dessa maneira, a cpia resultante mantm as mesmas propriedades que o componente original e continua associada aos mesmos eventos. A nica diferena entre a cpia e o original a sua propriedade Name, que mudada automaticamente pelo Delphi quando o componente copiado. (Dois componentes no podem ter o mesmo nome em um formulrio). Para duplicar um ou mais componentes em um formulrio:
1. Selecione os componentes e escolha o comando Edit | Copy (ou pressione CTRL+C). 1. Clique em um local vazio do formulrio e escolha o comando Edit | Paste (CTRL + V). Os componentes so copiados e so posicionados ligeiramente abaixo e direita dos componentes originais Pode-se tambm usar os comandos do menu Edit para transferir componentes de um formulrio para outro, ou para dentro de um componente de agrupamento (como um GroupBox, ou Panel). Para transferir componentes:
1. Selecione os componentes e escolha o comando Edit | Cut (ou pressione CTRL+X). 1. Para mover os componentes para outro formulrio clique no formulrio. Para mov-los para dentro de um componente de agrupamento (GroupBox, Panel, etc.) clique dentro desse componente. 2. Escolha o comando Edit | Paste (CTRL+V).
3.14. Alinhando, travando e sobrepondo componentes

Para manter um visual uniforme e organizado nos seus formulrios, muitas vezes necessrio alinhar componentes um pelo outro. Voc pode alinhar componentes de trs maneiras bsicas no Delphi:
34
35
Usando a Alignment palette (Paleta de alinhamento) Usando a caixa de dilogo Align, ou Alinhando pela grade (grid).
Para alinhar componentes com a Alignment palete
1. Selecione os componentes a serem alinhados 1. Escolha o comando View | Alignment palette para exibir a seguinte janela:
Essa paleta uma "barra de ferramentas flutuante". Voc pode mov-la para qualquer local na tela. 2. Clique no boto apropriado na paleta. Os botes da paleta so descritos na tabela abaixo: Alinhar pelo lado esquerdo dos componentes Alinhar pelo topo dos componentes Alinhar pelos centros dos componentes, horizontalmente Alinhar pelos centros dos componentes, verticalmente Alinhar pelo centro do formulrio, horizontalmente Alinhar pelo centro do formulrio, verticalmente. Espaar igualmente, na horizontal Espaar igualmente, na vertical
Alinhar pelo lado direito dos componentes Alinhar pela base dos componentes
Para alinhar componentes com a caixa de dilogo Alignment:
1. Selecione os componentes. 1. Clique com o boto direito em cima de um dos componentes selecionados e escolha o comando Align. Ou escolha o comando Edit | Align. 2. Na caixa Alignment (figura abaixo), defina as opes de alinhamento desejadas e clique em OK. As opes so equivalentes s apresentadas na Alignment palette.
35
36
3.15. Alinhando pela grade

Os pontos mostrados em um formulrio, durante o tempo de desenvolvimento, so a grade (grid) do formulrio. A grade "atrai" componentes para posies predefinidas, facilitando o alinhamento. Voc pode desativar a grade, ou alterar seu espaamento. Uma grade com um espaamento menor permite o alinhamento mais preciso (e mais flexvel) dos componentes.
Exibio da grade com dois valores para o espaamento
Para alterar o espaamento da grade ou desativ-la:
1. Escolha o comando Tools | Evironment options.

1. Para alterar o espaamento da grade, na pgina Preferences, altere os valores das opes Grid size X (espaamento horizontal) e Grid size Y (espaamento vertical). Para desativar a grade, desligue a opo Snap to grid.
Voc pode tambm esconder a grade, sem desativ-la. Para isso, desligue a opo Display grid.
3.16. Travando componentes

Depois de organizar e alinhar os componentes, voc pode trav-los, para evitar que sejam desalinhados acidentalmente. Para travar a posio dos componentes: Escolha a comando Edit | Lock controls.
36
37
Isso trava a posio dos componentes em todos os formulrios do projeto. Alm disso, novos componentes adicionados ficam travados tambm (o que no muito prtico!). Para destravar a posio dos componentes, escolha o comando Edit | Lock controls novamente.
3.17. Controlando a sobreposio de componentes

Componentes podem ser sobrepostos em um formulrio. Pode-se alterar a ordem de sobreposio, trazendo um componente para frente ou enviando-o para trs. A ordem de sobreposio padro a ordem em que os componentes so adicionados ao formulrio. Os componentes adicionados mais recentemente so colocados "por cima" dos mais antigos. Para trazer um componente para frente ou mandar um componente para trs:
1. Selecione o componente e clique nele com o boto direito do mouse. 1. Escolha o comando Bring to front (Trazer para frente) ou Send to back (Mandar para trs). NOTA: componentes grficos, como os componentes Label, Speedbutton e Bevel, no podem ser colocados na frente de componentes "ajanelados" (a maioria dos demais).
37
38
CAPTULO 04 - FORMULRIOS E CAIXAS DE DILOGO

Uma interface com o usurio no Delphi geralmente composta por um formulrio principal e vrios outros formulrios, como caixas de dilogo, janelas secundrias, etc. Neste captulo, veremos vrias maneiras para criar novos formulrios e como organiz-los e conect-los. Veremos tambm como definir a ordem em que os formulrios so criados e como usar as caixas de dilogos predefinidas do Delphi.
4.1.
Adicionando formulrios
H vrias maneiras de adicionar um formulrio vazio a um projeto no Delphi. Veja as mais importantes: Escolha o comando File | New form. Na barra de ferramentas, clique no boto chamado New form (veja abaixo):
Escolha o comando File | New e, na pgina "New", clique duas vezes no cone "Form":
38
39
4.2.
Especificando o formulrio principal
Todo aplicativo criado no Delphi deve ter um de seus formulrios definidos como formulrio principal. O formulrio principal o formulrio que criado e exibido primeiro no aplicativo. esse formulrio, geralmente, o que contm a barra de menus, barras de ferramentas e outros componentes importantes que so usados por vrios formulrios secundrios. Como padro, o Delphi define o primeiro formulrio adicionado como o formulrio principal, mas isso pode ser alterado facilmente. Para definir um formulrio como o formulrio principal:
1. Escolha o comando Project | Options. 1. Na pgina "Forms", escolha o formulrio da lista ao lado de "Main form" (veja figura).
DICA: durante o desenvolvimento, voc pode tornar o formulrio com que est trabalhando no formulrio principal. Isso garante que o formulrio seja o primeiro a ser exibido, facilitando na hora dos testes.
4.3.
Ligando formulrios
No trabalho com vrios formulrios, muitas vezes ser necessrio ligar formulrios para que o cdigo de um formulrio possa ter acesso aos componentes do outro. Quando se usa uma caixa de dilogo para a entrada de informaes, por exemplo, deve ser possvel verificar os valores entrados na caixa a partir do formulrio principal. Para isso, necessrio ligar o formulrio principal caixa de dilogo.
39
40
Voc cria uma ligao entre formulrios adicionando referncias aos formulrios nas clusulas uses das Units. Essas referncias podem ser adicionadas manualmente, ou atravs de um comando de menu (o que geralmente mais fcil).
Para ligar um formulrio a outro formulrio:
1. Selecione o formulrio que precisa se referir ao outro formulrio.

1. Escolha o comando File | Use unit e escolha o formulrio a ser referenciado (veja a figura a seguir).
Quando voc liga um formulrio a outro, o Delphi acrescenta o nome da Unit do outro formulrio clusula uses do formulrio ativo. Na figura, por exemplo, a Unit chamada "UnCadastroGames" foi escolhida. O Delphi altera o cdigo para o seguinte:
unit UnControleEstoque; interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs; type TControleEstoque = class(TForm) end; var ControleEstoque: TControleEstoque; implementation uses UnCadastroGames; {$R *.DFM}
40
41
end.
4.4.
Propriedades dos formulrios
Alm das propriedades que todos os componentes apresentam, como Height e Width, os formulrios apresentam vrias propriedades exclusivas, que permitem alterar sua aparncia e seu comportamento. Veja a seguir descries dessas propriedades. Propriedade ActiveControl Descrio Esta propriedade determina qual controle recebe o foco quando o formulrio mostrado. Quando o usurio clica em uma rea vazia no formulrio, o controle definido aqui que recebe o foco. O texto exibido da barra de ttulo do formulrio. A altura e a largura totais do formulrio, em pixels,.
Caption Height, Width ClientHeight
A distncia (em pixels) entre a parte interna da borda de baixo do formulrio at sua barra de ttulo. A distncia horizontal (em pixels) entre as partes internas das bordas esquerda e direita do formulrio. Os controles que so exibidos na Barra de ttulo do formulrio. Voc pode definir quatro opes para BorderIcons: biSystemMenu: mostra o Menu de Controle (tambm chamado "Menu de Sistema"). BiMinimize: mostra o boto minimizar no formulrio. BiMaximize: mostra o boto maximizar no formulrio. biHelp: boto de ajuda (interrogao). S aparece se biMaximize ou biMinimize estiver em False. Esse boto usado para exibir a pgina de ajuda definida para o formulrio (se houver).
ClientWidth
BorderIcons
BorderStyle
Define a aparncia das bordas do formulrio e se o formulrio pode ser redimensionado ou no. As seguintes opes esto disponveis: bsDialog: o. Mostra somente o boto Fechar. O formulrio no pode ser redimensionado. Este o padro para as caixas de dilogo. bsSingle: O formulrio no pode ser redimensionado e mostrado com bordas com linhas simples. bsNone:. O formulrio no pode ser redimensionado sem bordas. bsSizeable: (opo padro). O formulrio pode ser
41
42
redimensionado e mostrado com bordas. bsToolWindow: como bsSingle, mas o formulrio mostrado com um barra de ttulo mais estreita. Essa opo pode ser usada para criar "barras de ferramentas flutuantes", por exemplo. O formulrio no pode ser redimensionado. bsSizeToolWin: como bsToolWindow, mas o formulrio pode ser redimensionado.
BorderStyle = bsSizeable BorderStyle = bsSizeToolWin Position Determina a posio e o tamanho do formulrio em tempo de execuo. As opes para Position so as seguintes: poDesigned: a posio e o tamanho do formulrio so os mesmos definidos em tempo de desenvolvimento. (Esta a opo padro). poDefault a posio e o tamanho do formulrio so determinados pelo Windows. O Delphi no controla nem o tamanho nem a posio. poDefaultPosOnly: somente a posio do formulrio definida pelo Windows. O tamanho o que foi definido em tempo de desenvolvimento. poDefaultSizeOnly: somente o tamanho definido pelo Windows. A posio a que foi definida em tempo de desenvolvimento. poScreenCenter: o tamanho do formulrio mantido igual ao definido em tempo de desenvolvimento, mas a posio no centro da tela. Se vrios monitores estiverem sendo usados (no Windows 98), a posio pode ser ajustada para que o formulrio caiba inteiro em um dos monitores. poDesktopCenter: semelhante opo poScreenCenter, mas a posio no do formulrio no ajustada para aplicativos que usam vrios monitores. WindowState Determina como o formulrio ser exibido inicialmente no aplicativo (minimizado, maximizado ou restaurado). Opes: wsNormal: mostra o formulrio com tamanho normal (nem maximizado nem minimizado).
42
43
wsMaximized: mostra o formulrio maximizado. wsMinimized: mostra o formulrio minimizado.
4.5.
Eventos dos formulrios
H dezenas de eventos para os formulrios. Muitos deles so usados apenas raramente. A seguir apresentamos os eventos mais usados. Evento OnCreate Descrio Chamado quando o formulrio criado (automaticamente ou manualmente). Este evento muito usado para realizar a inicializao de variveis ou outras operaes que devem ser realizadas logo no incio da execuo (como a conexo a bancos de dados, por exemplo). Chamado quando o formulrio mostrado na tela (geralmente usando Show ou ShowModal). Ocorre quando o formulrio fechado pelo usurio, ou usando o comando Close. Este evento pode ser usado para liberar variveis, ou fechar tabelas de bancos de dados, por exemplo. nota: o evento OnCloseQuery (se existir) chamado antes do evento OnClose, para verificar se o formulrio realmente pode ser fechado. OnCloseQuery Este evento chamado, logo depois do comando Close, ou quando o usurio tenta fechar o formulrio (clicando no X por exemplo). Esse evento pode ser usado, por exemplo, para solicitar uma confirmao antes de fechar o formulrio. O parmetro CanClose do evento determina se o formulrio ser fechado ou no. Altere este parmetro para False, dentro do cdigo do evento, para evitar o fechamento do formulrio. Se CanClose no for alterado, ou tiver o valor True no final do cdigo do evento, o formulrio fechado e o evento OnClose chamado.
OnShow OnClose
4.6.
Mtodos dos formulrios
Veja a seguir uma descrio dos mtodos mais comumente usados para os formulrios. Mtodo Close Descrio O mtodo Close fecha o formulrio. Se o formulrio for o principal o aplicativo encerrado.
43
44
FocusControl
Use FocusControl (Nome_do_Componente) para mover o foco para o componente especificado no formulrio. (O componente com foco aquele que pode ser escolhido diretamente com o teclado). Mostra o formulrio na tela. A execuo do aplicativo continua (no bloqueada). Mostra o formulrio na tela, mas bloqueia a execuo do aplicativo at que o formulrio seja fechado.
Show ShowModal
4.7.
Mostrando formulrios
Formulrios podem ser mostrados de forma modal (usando o mtodo ShowModal) ou de forma no-modal (usando Show). Quando um formulrio mostrado usando ShowModal, a execuo do aplicativo interrompida e s continua quando o usurio fecha o formulrio (cancelando ou confirmando as opes escolhidas, por exemplo). ShowModal o mtodo mais usado para as caixas de dilogo, formulrios usados para solicitar informaes do usurio, mostrar resultados, ou para pedir confirmaes para aes realizadas. Quando um formulrio mostrado usando o mtodo Show, a execuo do aplicativo no interrompida. Isso permite que o usurio realize outras operaes no aplicativo, mesmo enquanto o formulrio est sendo exibido. O trecho de cdigo a seguir ilustra o uso dos mtodo Show e ShowModal, para um formulrio chamado "Caixa".
procedure TForm1.BtModalClick(Sender: TObject); begin Caixa.ShowModal; {aqui, o cdigo pra de ser executado, at que o usurio feche o formulrio} ... end; procedure TForm1.BtNaoModalClick(Sender: TObject); begin Caixa.Show; {aqui, o cdigo continua a ser executado, mesmo antes do formulrio ser fechado}
44
45
... end;
4.8.
A propriedade ModalResult
Quando se mostra formulrios de forma modal (usando ShowModal), pode-se alterar a propriedade ModalResult de botes no formulrio para que eles realizem automaticamente aes comuns. Pode-se, por exemplo, adicionar um componente Button ao formulrio e alterar sua propriedade ModalResult para mrClose. Isso faz com que o formulrio seja fechado quando o componente Button clicado. O mtodo ShowModal retorna o valor definido na propriedade ModalResult. Esse recurso pode ser usado para fazer decises de acordo com o que foi escolhido no formulrio, como mostra o trecho de cdigo abaixo: ... Resultado := CaixaConfirmacao.ShowModal; if Resultado = mrOK then {fazer alguma coisa} if Resultado = mrCancel then {fazer outra coisa} ...
4.9.
Usando o teclado com formulrios
A maioria dos aplicativos para Windows permite o uso do teclado para a navegao entre componentes de um formulrio. As teclas mais comuns de navegao so a tecla TAB e as setas do teclado.
4.10. Alterando a ordem de tabulao

A ordem de tabulao a ordem em que os componentes de um formulrio recebem o foco (tornam-se ativos) quando pressionada a tecla TAB. O componente que est com o foco pode ser alterado, ou ativado com o teclado. Pode-se, por exemplo, usar a tecla TAB para mover o foco para um boto no formulrio e depois pressionar ENTER, o que equivale a clicar no boto. NOTA: alguns componentes no podem receber o foco no se pode usar a tecla TAB para chegar at eles com o teclado. Os componentes Label e SpeedButton so os exemplos mais comuns. A ordem de tabulao pode ser definida de vrias maneiras no Delphi. A maneira mais direta alterar a propriedade TabOrder para cada componente. O valor de TabOrder deve ser um valor
45
46
inteiro e no deve haver valores duplicados no mesmo formulrio (o Delphi no permite). Por exemplo, para que um componente seja o segundo a receber o foco quando o usurio pressiona a tecla TAB, faa TabOrder = 1 (a contagem de TabOrder comea de zero). H outra maneira de alterar a ordem de tabulao. Faa o seguinte: clique com o boto direito em uma rea vazia do formulrio e escolha o comando Tab Order. Na caixa que aparece, so listados todos os componentes que podem receber foco do formulrio. So listados o nome e o tipo de cada componente na ordem de tabulao atual (veja a ilustrao a seguir).
Para alterar a ordem de tabulao de um componente, selecione o componente da lista e use as setas para cima ou para baixo. NOTA: a ordem de tabulao s tem efeito em tempo de execuo. Em tempo de desenvolvimento, a ordem de tabulao depende somente da ordem em que os componentes foram adicionados. Para testar a ordem de tabulao, voc precisa executar o aplicativo.
4.11. Evitando que um componente receba o foco

Muitas vezes, no necessrio que todos os componentes em um formulrio sejam capazes de receber o foco (usando a tecla TAB). Alguns componentes, como os componentes Panel e GroupBox geralmente no precisam receber foco. Para evitar que um componente receba o foco: Altere sua propriedade TabStop ("Parada de tabulao") para False.
4.12. Controlando a criao dos formulrios

Quando voc adiciona formulrios a um aplicativo, o Delphi faz com que todos esses formulrios sejam criados na memria do computador, assim que o aplicativo executado. Essa a configurao padro, mas voc pode fazer com que formulrios no sejam criados
46
47
automaticamente (para poupar memria, por exemplo, ou para reduzir o tempo de inicializao do aplicativo). Outros casos em que melhor no criar um formulrio automaticamente quando esse formulrio no usado com frequncia, ou consome muitos recursos da mquina (acessando um banco de dados, por exemplo). Alm de definir se um formulrio deve ser criado ou no, voc pode definir a ordem em que os formulrios so criados. Para especificar quais formulrios devem ser criados em tempo de execuo:
1. Escolha o comando Project | Options e mude para a pgina "Forms". Os nomes de todos os formulrios no projeto so exibidos na lista "Auto-create forms". Os nomes dos formulrios disponveis, mas que no sero criados automaticamente, aparecem na lista "Available forms".
1. Na lista da esquerda selecione os formulrios que voc no deseja que sejam criados durante a execuo. Em seguida, clique no boto > . Voc pode tambm clicar no boto >> para mover todos os formulrios para a segunda lista. 2. Para alterar a ordem em que os formulrios so criados (somente para a lista da esquerda), arraste o nome do formulrio para outra posio da lista. NOTA: as mudanas descritas alteram tambm o arquivo de projeto. As linhas com os comandos Application.CreateForm() dos formulrios colocados na segunda lista ("Available Forms") so removidas do arquivo de projeto. A ordem dos comandos tambm alterada de acordo com a ordem definida na caixa Project Options (ilustrao anterior).
47
48
Quando um formulrio movido para a lista "Available Forms", ele no mais criado automaticamente quando o aplicativo inicializado. Para exibir o formulrio, voc deve antes cri-lo na memria. Uma maneira simples de fazer isso atravs do mesmo comando gerado automaticamente pelo Delphi, Application.CreateForm. O exemplo a seguir usa esse comando para criar um formulrio (chamado "FrmProdutos") antes de mostr-lo.
procedure TFrmPrincipal.ProdutosClick(Sender: TObject); begin Application.CreateForm(TFrmProdutos, FrmProdutos); FrmProdutos.ShowModal; end;
4.13. Imprimindo formulrios

Algumas vezes til imprimir os formulrios de um aplicativo, para manter um controle organizado dos formulrios que j esto prontos, por exemplo. Para imprimir um formulrio:
1. Selecione o formulrio e escolha o comando File | Print. A seguinte caixa exibida.
1. Escolha uma das opes da caixa e clique em OK. As opes so descritas a seguir: Proportional ("Proporcional") Ajusta o formulrio proporcionalmente ao valor da propriedade PixelsPerInch do formulrio. O valor inicial dessa propriedade depende da resoluo atual e calculada quando o Delphi carregado. ("Imprimir para caber na pgina") Ajusta o tamanho do formulrio para que ocupe o maior espao possvel da pgina. ("Sem ajuste de tamanho") Imprime o formulrio com o mesmo tamanho que mostrado na tela.
Print to fit page
No scaling
4.14. Caixas de dilogo predefinidas

O Delphi oferece vrios comandos para a exibio de caixas de dilogo comuns, como caixas de mensagem (Message Boxes) e caixas de entrada (Input Boxes). Esses comandos permitem que aplicativos com recursos simples de entrada e sada sejam criados rapidamente.
48
49
4.15. Message Boxes (Caixas de Mensagem)

As caixas de mensagem so usadas para exibir resultados, erros, ou avisos para o usurio. Elas so caixas modais (bloqueiam a execuo do programa quando so exibidas). H dois comandos para mostrar caixas de mensagem no Delphi. O mais simples ShowMessage, que mostra apenas uma mensagem e um boto OK. J o comando MessageDlg oferece mais opes, como smbolos e ttulos diferentes.
4.16. Usando o comando ShowMessage

Use o comando ShowMessage para mostrar uma mensagem simples para o usurio. A mensagem exibida em uma pequena caixa, com um boto OK. A caixa fechada quando o boto OK clicado. No exemplo abaixo, uma caixa de mensagem exibida quando o boto Button1 recebe um clique: procedure TForm1.Button1Click(Sender: TObject); begin ShowMessage('Este comando no pode ser usado no momento.'); end; A caixa de mensagem exibida a seguinte:
Como padro, exibido o nome do projeto na barra de ttulo da caixa de mensagem.
4.17. Usando a comando MessageDlg

O comando MessageDlg mostra uma caixa de mensagem que pode conter smbolos especiais, botes adicionais e outros elementos. O comando tem vrios parmetros que devem ser especificados. Veja a sintaxe do comando MessageDlg: MessageDlg(<Mensagem>,<Tipo da Caixa>,<Botes>,<Nmero de ajuda>); <Mensagem> um trecho de texto entre aspas simples, como para o comando ShowMessage. <Tipo da Caixa> determina o smbolo que ser exibido na parte esquerda da caixa. Os cinco tipos disponveis so ilustrados a seguir, alm do comando usado para exibir cada tipo de caixa.
49
50
mtInformation
MessageDlg('Mensagem de informao, mtInformation, mbOKCancel, 0);
mtWarning
MessageDlg('Mensagem de aviso, mtWarning, mbOKCancel, 0);
mtError
MessageDlg('Mensagem de erro', mtError, mbOKCancel, 0);
mtConfirmation
MessageDlg('Mensagem de confirmao', mtConfirmation, mbOKCancel, 0);
mtCustom
MessageDlg('Outra mensagem', mtCustom, mbOKCancel, 0)
Note que os ttulos das caixas de mensagem so sempre o nome do tipo da caixa, com exceo da opo mtCustom que exibe o nome do projeto como ttulo (e no mostra smbolo especial). Infelizmente, os ttulos so sempre em ingls. No h como especificar outros ttulos para as caixas usando o comando MessageDlg. O terceiro parmetro <Botes> usado para definir o conjunto de botes que ser exibido na parte de baixo da caixa de mensagem. H alguns conjuntos de botes predefinidos. Um deles foi usado nos exemplos anteriores: mbOKCancel, que mostra os botes OK e Cancel. Os conjuntos predefinidos so resumidos a seguir:
mbYesNoCancel
Mostra os botes Yes, No e Cancel.
50
51
mbAbortRetryIgnore mbOKCancel
Mostra os botes Abort, Retry e Cancel Mostra os botes OK e Cancel.
Pode-se tambm adicionar botes especficos, listando o nome dos botes entre colchetes. Os botes disponveis so:
mbYes, mbNo,, mbOK, mbCancel, mbHelp, mbAbort, mbRetry, mbIgnore, mbAll

Por exemplo, para mostrar uma caixa de mensagem de aviso com os botes, Yes, No, Ignore e Help, use um comando como o seguinte (a caixa mostrada logo depois): MessageDlg(Houve um erro de leitura no disco. Deseja interromper a execuo do aplicativo?, mtWarning, [mbYes, mbNo, mbIgnore, mbHelp], 0);
4.18. Usando a funo InputBox

Para a entrada de informaes simples, voc pode usar a funo InputBox. Essa funo mostra um caixa simples com um campo para a entrada (um componente Edit) de dados e os botes OK e Cancelar. InputBox retorna um String com o texto digitado pelo usurio. A funo InputBox recebe trs parmetros: InputBox(<Ttulo da Caixa>, <Texto do prompt>, <Texto padro>); <Ttulo da Caixa> define o texto que exibido na barra de ttulo da caixa. <Texto do prompt> o texto exibido na parte interna da caixa. <Texto Padro> o texto padro exibido dentro do campo de entrada. Este texto aparece inicialmente selecionado. Para no mostrar um texto padro use um string vazio (). Veja um exemplo a seguir: InputBox('Escolha de pas', 'Digite o nome do pas:', 'Brasil');
51
52
Para recuperar o que foi digitado na InputBox, use uma varivel para armazenar o valor. No exemplo a seguir, usada uma varivel NomeDoPais, do tipo String:
procedure TForm1.Button1Click(Sender: TObject); var NomeDoPais: String; begin NomeDoPais := InputBox('Escolha de pas', 'Digite o nome do pas:', 'Brasil'); ShowMessage('Nome do pas escolhido: ' + NomeDoPais); end;
O exemplo l um nome de pas, usando a funo InputBox, e exibe esse nome em uma caixa de mensagem.
52
53
CAPTULO 05 - TRABALHANDO COM MENUS

Os Menus so parte importante da maioria dos aplicativos para Windows. Com os recursos do Menu Designer do Delphi, possvel criar menus completos rapidamente, com comandos, teclas de atalho, separadores e outras opes. Dois tipos bsicos de menus podem ser criados: menus principais e menus popup.
5.1.
Adicionando menus e abrindo o Menu Designer
Menus no Delphi so criados usando os componentes MainMenu e PopupMenu. Estes so os primeiros componentes da pgina Standard da paleta de componentes (veja a figura abaixo).
Os componentes de menus Os dois componentes de menus so exibidos como cones no formulrio. a partir desses cones que so construdos os menus principais e popup, usando o Menu Designer, uma ferramenta especfica para a criao de menus. Para mostrar o Menu Designer para um componente de MainMenu ou PopupMenu, faa o seguinte: Clique duas vezes no componente de menu, ou Clique com o boto direito no componente de menu e escolher o comando Menu Designer.
O Delphi abre o Menu Designer dentro de uma janela separada.
5.2.
Construindo menus principais
Menus principais so os menus que aparecem no topo das janela principal do aplicativo. Para criar um menu principal em um formulrio, adicione um componente MainMenu e clique no componente duas vezes para mostrar o Menu Designer. A seqncia de figuras a seguir ilustra o procedimento bsico para a construo de um menu principal.
53
54
O Menu Designer aberto com o primeiro menu selecionado. Digite um ttulo para o menu. O texto digitado aparece na propriedade Caption, no Object Inspector.
Depois de digitar um ttulo, pressione ENTER. O posio do primeiro comando do menu selecionada. Agora digite o texto para o comando.
Pressione ENTER outra vez para passar para o prximo comando. Continue digitando os comandos da mesma maneira.
Para passar para o prximo ttulo de menu, pressione a seta para direita no teclado. Voc pode tambm clicar no prximo ttulo.
Digite o novo ttulo e pressione ENTER. Continue da mesma forma para adicionar os outros comandos.
Depois de fechar o Menu Designer, voc j pode visualizar o menu no formulrio, mesmo em tempo de desenvolvimento.
5.3.
Inserindo, movendo e apagando comandos
Depois de criar um menu, voc pode alter-lo facilmente com o Menu Designer. Voc pode inserir, apagar, ou remover comandos, por exemplo. Clique duas vezes no componente MainMenu para abrir o Menu Designer e siga os passos a seguir para cada operao. Para inserir um novo comando: Mova o cursor (a barra azul) para o comando antes da posio que deseja para o novo comando. Pressione a tecla INSERT (ou Ins). Um novo comando vazio criado logo depois do cursor. Basta digitar o texto para o comando. Para apagar um comando: Mova o cursor para o comando e pressione DELETE (ou Del). Se houver um submenu associado ao comando, este submenu tambm apagado. Para apagar um menu inteiro: Mova o cursor para o ttulo do menu e pressione DELETE. Todos os comandos (e submenus) do menu so apagados.
54
55
Para mover um comando para outra posio: Arraste o comando para outra posio. Voc pode mover o comando para outra posio do mesmo menu, ou para dentro de outro menu (ou submenu). Se o comando movido contiver um submenu, o submenu movido junto com o comando.
5.4.
Adicionando separadores
Os separadores so usados para organizar menus extensos, agrupando comandos relacionados. Um separador aparece como uma linha horizontal entre os comandos do menu. Para adicionar um separador a um menu: No Menu Designer, digite um hfen( - ) em vez de um nome para o comando e pressione ENTER. O Delphi acrescenta um linha horizontal (o separador) ao menu. O espao ocupado pelo separador menor quando o aplicativo executado, como mostra a figura abaixo.
Um separador em tempo de desenvolvimento
e em tempo de execuo.
5.5.
Definindo "teclas de acelerao" e teclas de atalho
Para que comandos de menus possam ser escolhidos rapidamente usando o teclado, o Delphi permite que sejam definidas teclas de acelerao e teclas de atalho. As teclas de acelerao so as letras que aparecem sublinhadas nos menus. Um comando ou ttulo de menu com uma tecla de acelerao pode ser escolhido, pelo teclado, usando ALT com a tecla definida. Para definir teclas de acelerao para um ttulo de menu ou comando, digite um "&" dentro de sua propriedade Caption, antes do caractere a ser definido como tecla de acelerao. Na figura a seguir, a letra "E" do menu "Editar" foi definida como tecla de acelerao. Note que o "E" aparece sublinhado no menu. Assim, possvel escolher o menu com o teclado, usando ALT + E.
55
56
Definindo uma tecla de acelerao As teclas de atalho so usadas para escolher comandos de menu rapidamente, sem a necessidade de abrir os menus. As teclas de atalho so, na verdade, combinaes de teclas, como CTRL+C, CTRL+SHIFT+1, etc. Para definir teclas de atalho para um comando de menu, selecione o menu e altere a propriedade Shortcut. Pode-se escolher um item da lista ou digitar uma combinao diretamente. As teclas de atalho aparecem ao lado dos comandos, nos menus.
5.6.
Criando submenus
Os submenus so simplesmente "menus dentro de menus". O procedimento para criar um submenu explicado na ilustrao abaixo:
Para adicionar um submenu a um comando, selecione o comando e pressione CTRL + Seta da Direita.
Digite o primeiro comando do submenu e pressione ENTER.
Continue digitando os novos comando seguidos por ENTER. Para voltar ao menu principal, use ESC.
56
57
5.7.
Construindo menus popup
As tcnicas usadas para a construo de menus popup so praticamente as mesmas que as usadas para os menus principais. O procedimento at mais simples, pois um menu popup formado por apenas um conjunto de comandos (e submenus). Os menus popup podem ser associados a muitos tipos de componentes, inclusive Buttons, Memos e formulrios. Para associar um menu popup a um componente, voc deve adicionar um componente PopupMenu ao formulrio que contm o componente. Depois, basta alterar a propriedade PopupMenu do componente para o nome do componente PopupMenu adicionado. Para construir um menu popup (adicionar itens e submenus) proceda da mesma maneira que para os menus principais Clique duas vezes no componente PopupMenu para abrir o Menu Designer. Em seguida, digite o nome de cada comando, seguido de ENTER. Para acrescentar outras opes como separadores ou teclas de atalho use as mesmas tcnicas descritas anteriormente. A figura abaixo mostra um exemplo de um menu popup no Menu Designer:
Um menu popup no Menu Designer
5.8.
Associando cdigo aos comandos de um menu
Para associar cdigo a um comando de menu (ou de submenu), d um duplo clique no comando, no Menu Designer. Isso gera o cdigo para o evento OnClick do comando. Neste evento, digite o cdigo a ser executado quando o comando for escolhido no aplicativo. Note que os comandos de menus, assim como os prprios menus, so tratados como componentes no Delphi. Eles possuem propriedades e eventos, como os outros componentes comuns.
5.9.
Propriedades importantes dos menus e comandos
Muitas das propriedades dos menus so definidas indiretamente, atravs do Menu Designer, mas h algumas propriedade que s podem ser alteradas diretamente com o Object Inspector. A seguir so descritas algumas propriedades importantes dos menus e dos comandos de menus. Para alterar essas propriedades, primeiro selecione um menu, submenu, ou comando de menu no Menu Designer. Propriedade Descrio
57
58
Caption
Caption determina o texto que aparece no ttulo ou comando de um menu. Checked usado para comandos que podem estar ligados ou desligados (opes). Quando Checked = True, exibido uma pequeno v do lado esquerdo do comando. Altere Default para True para tornar o comando selecionado no comando padro do menu. O comando padro aparece em negrito no menu e o comando escolhido quando se clica duas vezes no ttulo do menu. (Este um recurso disponvel, mas pouco usado no Windows). Altere Enabled para ativa ou desativar o comando. Um menu desativado (Enabled = False) aparece acinzentado em tempo de execuo e no pode ser escolhido. Esta propriedade usada geralmente alterada somente em tempo de execuo, para desativar ou ativar um comando, dependendo do que est sendo feito pelo usurio. RadioItem semelhante Checked, mas mostra um pequeno crculo no lado esquerdo do comando. Comandos do mesmo grupo com RadioItem = True so mutuamente exclusivos: quando um comando do grupo ligado, todos os outros so desligados. As teclas de atalho usadas para executar o comando diretamente pelo teclado. Altere Visible para exibir ou esconder um comando ou menu. Para esconder, faa Visible = False.
Checked
Default
Enabled
RadioItem
Shortcut
Visible
5.10. Trabalhando com vrios menus

Um formulrio pode conter vrios menus, inclusive vrios menus principais. O Menu Designer permite passar de um menu para outro em um formulrio, rapidamente. Para passar para um menu para outro, dentro do Menu Designer: Clique com o boto direito e escolha o comando Select Menu para exibir a lista de menus do formulrio. Depois clique duas vezes em um item da lista.
Apesar de ser possvel acrescentar vrios menus principais (componentes MainMenu) a um formulrio, somente um menu principal pode estar ativo de cada vez. O menu principal usado em um formulrio determinado pela propriedade Menu do formulrio. Essa propriedade pode ser alterada durante a execuo do aplicativo. Por exemplo, a linha de cdigo abaixo, FormPrincipal.Menu := MainMenu2 altera o menu principal do formulrio "FormPrincipal" para o menu "MainMenu2".
58
59
CAPTULO 06 - COMPONENTES VISUAIS COMUNS

Os componentes visuais, tambm chamados de controles, so usados para a interao direta com o usurio. Neste captulo, veremos detalhes sobre os componentes visuais mais importantes e mais comumente usados
6.1.
Propriedades comuns
Os componentes visuais possuem vrias propriedades comuns entre si. Descrevemos a seguir as mais importantes dessas propriedades. (Algumas propriedades descritas no esto disponveis para todos os componentes). NOTA: de agora em diante chamaremos os componentes visuais de apenas "componentes".
Propriedade Align Descrio Align determina o alinhamento do componente em relao ao formulrio (ou a outro componente em que esteja contido). Opes: alNone: sem alinhamento especfico. alTop/alBottom: alinhamento pelo topo/base do componente pai. A largura do componente se torna a mesma do componente pai. alLeft/alRight: alinhamento pela esquerda/direita do componente pai. A altura do componente se torna a mesma do componente pai. alClient: alinhamento pela rea cliente do componente pai. A rea cliente para um formulrio, por exemplo, toda a rea do formulrio menos a barra de ttulo, as bordas e as barras de rolagem. Color Color determina a cor da parte interna do componente. As cores disponveis dividem-se em cores predefinidas, que no dependem do sistema, e cores do sistema, que dependem da configurao definida no Painel de Controle do Windows. As cores predefinidas aparecem no incio da lista. Elas so apresentadas na tabela a seguir. Azul piscina Verde escuro Vinho Roxo escuro Azul-cinza Preto clFuchsia clLime clNavy clRed clWhite clBlue Roxo claro Verde limo Azul marinho Vermelho Branco Azul puro clGray clLtGray clOlive clSilver clYellow Cinza escuro Cinza claro Verde oliva Cinza mdio Amarelo
clAqua clGreen clMaroon clPurple clTeal clBlack
As cores predefinidas do Delphi

Constraints Esta propriedade determina as dimenses mnimas e mximas permitidas para o componente. Constraints composta pelas seguintes subpropriedades: MinHeight, MaxHeight : as alturas mnima e mxima, em pixels. MinWidth, MaxWidth: as larguras mnima e mxima em pixels. Cursor Use esta opo para definir o tipo de cursor exibido, quando o mouse colocado sobre o controle. A opo crDefault usa o cursor padro do Windows (geralmente crArrow). A opo crNone faz com que no seja mostrado um cursor. Os outros tipos de cursores so mostrados a seguir.
crArrow
crCross
crlIBeam
59
60
crSize
crNESW
crNS
crNWSE
crWE
crUpArrow
crHourGlass
crDrag
crNoDrop
crHSplit
crVSplit
crMultiDrag
crSQLWait
crNo
crAppStart
crHelp Tipos de cursores

Propriedade Enabled
crHandPoint
Descrio Altere Enabled para False para desativar o componente. Um componente desativado no permite interao com o usurio (ele pra de funcionar). Para um componente Edit, por exemplo, o texto aparece mais claro e no pode ser editado. Para um componente Button, o texto se torna acizentado e o componente no aceita mais cliques. NOTA: alguns componentes (como Buttons) s aparecem desativados em tempo de execuo.
Enabled = True Font
Enabled = False A fonte utilizada no controle. Essa propriedade uma propriedade composta compo pode ser alterada no Object Inspector, ou usando a caixa de fonte padro do Windows (clicando nas reticncias). Determinam a altura e a largura do componente, em pixels. Defina aqui um texto para a "Dica" que ser exibida quando o cursor do mouse pra sobre o controle por um momento. Para que a dica realmente aparea, voc deve alterar a propriedade ShowHint para True. Left determina a distncia, em pixels, do lado esquerdo do formulrio borda esquerda do componente. Top semelhante, mas para a distncia vertical. O nome que identifica o componente, tanto no Object Inspector como em todos os programas. Defina aqui um menu popup para o componente. Habilita a exibio de "dicas" para o componente. nte. Se esta for True, o texto definido na propriedade Hint exibido em um pequena caixa amarela (a "dica"), quando o ponteiro do mouse deixado por alguns momentos sobre o controle. TabOrder define a ordem de tabulao do componente. O valor de TabOrder s faz sentido se a propriedade TabStop estiver definida como True. (Veja mais sobre a ordem de tabulao no captulo "Formulrios e Caixas de Dilogo"). Um nmero inteiro, sem significado especfico, que pode ser usado como identificador do componente. Pode-se se usar a propriedade Tag (traduo:
Height, Width Hint
Left, Top Name PopupMenu ShowHint
TabOrder, TabStop
Tag
60
61
"etiqueta", "identificao") em estruturas case, por exemplo (veja o captulo sobre Object Pascal para mais sobre a estrutura case). Visible Determina se o componente est visvel ou no. Para esconder um componente, defina esta propriedade como False. O valor padro (visvel) True. Esta propriedade normalmente s alterada (e s tem efeito) em tempo de execuo.
6.2.
Eventos comuns
Alguns eventos so comuns maioria dos componentes visuais. Veja detalhes sobres os mais importantes desses eventos a seguir.
Evento OnClick OnDblClick OnEnter
Descrio Este o evento mais usado para quase todos os componentes. O evento OnClick, ocorre quando o componente recebe um clique, com o boto esquerdo (boto padro) do mouse. O evento OnDblClick ocorre quando o componente recebe um clique duplo, tambm com o boto esquerdo (boto padro) do mouse. OnEnter chamado quando o componente recebe o foco. Um componente recebe o foco quando ativado de alguma maneira usando o mouse (com um ou mais cliques), ou usando o teclado (com a tecla TAB e as teclas de direo). OnExit chamado quando um componente perde o foco. Um componente perde o foco, quando outro componente recebe o foco (somente um componente pode estar com o foco em um formulrio). OnKeyPress ocorre quando uma tecla pressionada e soltada. O componente que "recebe" o evento o que est com o foco. A tecla especificada no parmetro Key (do tipo Char) do evento.
OnExit OnKeyPress
6.3.
Componente Button
O componente Button , um dos componentes mais comuns em aplicativos para Windows.
Exemplos de componentes Button 6.3.1. Propriedades
Veja a seguir as propriedades importantes do componente Button. Propriedade

Caption Cancel Default
Descrio
Caption determina o texto exibido no boto. Altere Cancel para True para que o boto seja ativado com a tecla ESC. Altere Default para True, para que o boto seja ativado com a tecla ENTER.
6.3.2.
Eventos
O evento mais importante, e de longe o mais usado, para o componente Button o evento OnClick, que ocorre quando o boto clicado uma vez. OnClick o evento padro para esse componente.
61
62
6.4.
Componente Edit
O componente Edit permite a entrada (e a exibio) de textos e valores. Esse Esse componente suporta apenas uma linha de texto. Para textos com mais de uma linha, use o componente Memo, descrito em seguida.
Exemplos de componentes Edit 6.4.1. Propriedades
Seguem descries das propriedades mais importantes do componente Edit. Propriedade

AutoSelect AutoSize CharCase
Descrio
Seleciona automaticamente todo o texto no Edit quando o componente recebe o foco no formulrio. Ajusta a altura do Edit automaticamente (no caso de mudanas de fonte ou tamanho, por exemplo). Somente a altura, mas no a largura, ajustada. Controla a "caixa" (maisculas e minsculas) do texto digitado no Edit. So trs as opes disponveis: ecNormal: (padro) permite digitar textos de qualquer maneira (maisculas e minsculas em qualquer ordem). ecLowerCase: restringe todo o texto a minsculas. Todo o texto transformado para minsculas, mesmo se o usurio usar as teclas SHIFT e CAPS LOCK. ecUpperCase: tem efeito semelhante ao de ecLowerCase, mas restringindo o texto para maisculas
MaxLength
Defina aqui a Quantidade mxima de caracteres que podem ser digitados dentro do Edit. MaxLength ideal para limitar o tamanho da entrada para valores ou textos com tamanhos fixos, como telefones e cdigos. O valor zero (o padro) no impe limites. Define ne o caractere exibido no componente quando o texto digitado (normalmente asteriscos so utilizados). Tudo o que digitado substitudo pelo caractere especificado em PasswordChar. O padro '#0' que faz com que o texto digitado aparea normalmente. Altere ReadOnly para True para no permitir que o usurio altere o contedo do Edit. A opo False a opo padro, que permite a alterao normal do texto. SelStart a posio do primeiro caractere selecionado no Edit, ou a posio do cursor, se no houver texto selecionado. SelLength o nmero de caracteres selecionados. SelText o texto selecionado no Edit. Voc pode ler os valores de SelStart ou SelLength para determinar o trecho selecionado no Edit, ou alter-los los para selecionar um trecho diferente. SelText pode ser usado para substituir o trecho selecionado por outro trecho de texto.
PasswordChar
ReadOnly SelStart, SelLength, SelText
62
63
6.4.2.
Eventos
Alm dos eventos comuns, como OnClick e OnDblClick, o componente Edit oferece o evento OnChange. O evento OnChange ocorre quando o texto no Edit alterado. OnChange o evento padro para o componente Edit.
6.5.
Componente Label
O componente Label usado, geralmente, para identificar componentes em um formulrio. O texto de um Label alterado atravs da sua propriedade Caption. 6.5.1. Propriedades
A seguir, so descritas as propriedades mais importantes do componente Label. Propriedade

Alignment AutoSize FocusControl
Descrio
O alinhamento do texto do Label em relao rea que lhe foi reservada Determina se o Label deve ter seu tamanho ajustado automaticamente ou no, quando o comprimento do seu texto (valor da propriedade Caption) alterado. O componente ao qual o Label est associado. Quando o usurio pressiona a tecla de atalho definida para o Label, o componente recebe o foco. (Labels no podem receber o foco). Para definir uma tecla de atalho para um Label, acrescente um caractere "&" dentro da propriedade Caption, como em "Pro&duto", ou "&Abrir".
Layout
Layout determina o alinhamento vertical do texto do Label em relao rea reservada para ele. Opes: tlTop/tlCenter/tlBottom: alinham o texto do Label pelo topo/centro/base da rea reservada.
WordWrap
Determina se o texto do Label quebrado em vrias linhas quando no h espao suficiente para exibi-lo em uma linha s. Use True, para permitir as quebras de linhas e False para evit-las.
6.5.2.
Eventos
Os eventos de um Label so raramente utilizados. Algumas vezes, os eventos OnClick e OnDblClick so utilizados para realizar alguma operao especial no componente associado ao Label.
6.6.
Componente Memo
O componente Memo uma extenso do componente Edit que permite a edio de vrias linhas de texto. Ele apresenta todas as propriedades do componente Edit e mais algumas especficas para permitir o trabalho com trechos extensos de texto.
63
64
Exemplos de componentes Memo
6.6.1.
Propriedades
Veja a seguir detalhes sobre as mais importantes propriedades (exclusivas) do componente Memo. Para as propriedades comuns ao componente Edit veja a seo sobre esse componente. Propriedade
Lines
Descrio
A propriedade Lines determina o texto exibido no Memo. Clique duas vezes ao lado dessa propriedade no Object Inspector (ou clique nas reticncias) para exibir a janela "String list editor" (ilustrao a seguir). Digite o texto normalmente na janela. Pode-se usar ENTER, TAB e vrias outras teclas comuns de edio. (Veja mais sobre a propriedade Lines a seguir).
O String list editor Alignment Define como alinhado o texto dentro do componente Memo. So trs as opes disponveis: taLeftJustify (alinhar esquerda), taCenter (alinhar pelo centro), e taRightJustify (alinhar pela direita). Determina quais barras de rolagem so exibidas para o Memo. A opo padro ssNone, que no exibe nenhuma das duas barras de rolagem. As opes restantes so:
ScrollBars
64
65
ssVertical: mostra somente a barra de rolagem vertical, do lado direito. ssHorizontal: mostra somente a barra de rolagem horizontal, na parte de baixo. ssBoth: mostra as duas barras de rolagem, direita e abaixo do Memo. WantReturns Altere WantReturns para True para permitir que os usurios criem novas linhas dentro do Memo, usando a tecla ENTER (ou RETURN). Defina WantReturns como False, para passar a digitao da tecla ENTER para o formulrio. Por exemplo, se um formulrio tem um boto padro que ativado com a tecla ENTER (Default = True), e a propriedade WantReturns est definida como False, o boto padro escolhido no inserida um nova linha no texto. NOTA: mesmo com WantReturns em False, pode-se digitar novas linhas no Memo, usando CTRL+ENTER. WantTabs Esta propriedade semelhante a WantReturns (acima), s que para a tecla TAB. Se WantTabs estiver em False, os TABs digitados vo para o formulrio, passando o foco para outros componentes (da forma usual). J se WantTabs estiver em True, os TABs vo para dentro do Memo. Caracteres de tabulao so inseridos na posio do cursor. NOTA: mesmo com WantTabs em False, pode-se digitar TABs em um Memo usando CTRL+TAB. WordWrap Determina se as linhas de texto dentro do Memo so quebradas automaticamente ou no. O valor True ativa a quebra automtica de linhas.
6.6.2.
A propriedade Lines
A propriedade Lines, que determina o contedo do componente Memo, do tipo TStrings, um conjunto indexado de strings. Vrios outros componentes, como o ListBox e o ComboBox tambm usam propriedades deste tipo. Propriedades do tipo TStrings podem ser manipuladas de vrias maneiras. Pode-se, por exemplo adicionar ou remover linhas, verificar ou alterar a linha com um determinado ndice, ou apagar todas as linhas. Para adicionar linhas, use o mtodo Add ou Append, como em: Memo1.Lines.Add(Uma linha) ou Memo1.Lines.Append(Outra linha) A diferena entre Add e Append que Add retorna um valor: o ndice da linha adicionada. Append no retorna um valor. Para remover linhas, use o mtodo Delete (ndice). O exemplo a seguir apaga as primeiras cinco linhas de um componente Memo. (Note que a propriedade Lines indexada a partir de zero.) procedure TFormTesteMemo.BtApagarClick(Sender: TObject); var I: Integer; begin
65
66
for I := 0 to 4 do Memo1.Lines.Delete(I); end; Para remover todas as linhas, use o mtodo Clear, como em Memo1.Lines.Clear. Outra maneira mais simples usar o mtodo Clear do Memo, como em Memo1.Clear. As duas maneiras so completamente equivalentes. Para ler/alterar uma linha especfica, use a propriedade Lines seguida pelo ndice da linha, entre colchetes. Memo1.Lines[9] retorna a dcima linha, por exemplo. No exemplo a seguir, as linhas de um Memoso copiadas, na ordem ordem inversa, para outro (a propriedade Count retorna o nmero de linhas). procedure TFormTesteMemo.BtInvLinhasClick(Sender: TObject); var I: Integer; begin for I := Memo1.Lines.Count-1 Memo1.Lines.Count downto 0 do Memo2.Lines.Add(Memo1.Lines[I]); end; 6.6.3. Eventos
Os eventos tos mais importantes do componente Memo so os mesmos do componente Edit e tm o mesmo significado. O evento OnChange acontece quando o texto do Memo alterado. O evento OnClick ocorre quando o usurio clica em qualquer local do interior do Memo.
6.7.
Componente ListBox
O componente ListBox exibe uma lista de itens que podem ser escolhidos com um clique do mouse. Os itens exibidos so definidos alterando a propriedade Items.
Exemplos de componentes ListBox
66
67
6.7.1.
Propriedades
As propriedades mais importantes do componente ListBox so descritas a seguir. Propriedade

Items Columns MultiSelect, ExtendedSelect
Descrio
A propriedade Items determina os itens exibidos no ListBox. Items exatamente equivalente propriedade Lines do componente Memo. Determina o numero de colunas do ListBox. Se o nmero de colunas for maior que um, os itens do ListBox so dispostos em colunas e exibida uma barra de rolagem horizontal. A propriedade ExtendedSelect usada em associao com a propriedade MultiSelect para permitir a seleo de vrios itens no ListBox. Quando ambas MultiSelect e ExtendedSelect esto em True, vrios itens podem ser selecionados na lista usando as teclas CTRL (para selecionar itens no-contguos) e SHIFT (para selecionar uma sequncia de itens). Se ExtendedSelected estiver em False (com MultiSelect em True) possvel selecionar vrios itens (basta clicar), mas as teclas CTRL e SHIFT no funcionam. Finalmente, se MultiSelect estiver em False, o valor de ExtendedSelect no importa, pois somente um item pode ser selecionado na lista.
IntegralHeight
Se IntegralHeight for definida como True, o ltimo item da lista s ser exibido se couber inteiramente na parte de baixo da lista (no aparecendo cortado). Com IntegralHeight em False, o ltimo item mostrado mesmo que aparea cortado no final da lista. Defina Sorted como True para que os itens do ListBox sejam ordenados alfabeticamente (ou numericamente). False lista as opes na ordem em que foram adicionadas. Leia ItemIndex (em tempo de execuo) para determinar o ndice do item selecionado no ListBox. O primeiro item do ListBox tem ndice zero. Se mais de um item estiver selecionado, o ndice do primeiro item selecionado retornado. Se nenhum item estiver selecionado ItemIndex retorna -1. Leia TopIndex (tambm em tempo de execuo) para determinar o ndice do primeiro item visvel no ListBox. Altere o valor de TopIndex, para definir o primeiro item exibido no ListBox.
Sorted ItemIndex, TopIndex
SelCount Selected
SelCount retorna o nmero de itens selecionados no ListBox. A propriedade Selected um array de valores booleanos, com elementos para todos os itens do ListBox. O seguinte cdigo l os valores em Selected para copiar todos os itens selecionados em um ListBox para um componente Memo: procedure TForm1.BtMoverClick(Sender: TObject); var I: Integer; begin for I := 0 to ListBox1.Items.Count-1 do if ListBox1.Selected[I] then Memo1.Lines.Add(ListBox1.Items[I]); end;
6.7.2.
Eventos
O evento OnClick para um ListBox chamado quando um item da lista selecionado com o mouse.
67
68
O evento OnDblClick chamado quando um item do ListBox clicado duas vezes. Esse evento geralmente usado para realizar aes imediatas, como adicionar o item selecionado a outro componente, por exemplo.
6.8.
Componente ComboBox
O componente ComboBox uma combinao de um componente Edit com um componente ListBox. O ComboBox mostra uma lista de opes (o ListBox) e uma rea onde se pode digitar livremente (o Edit).
Exemplos de componentes ComboBox 6.8.1. Propriedades
O componente ComboBox apresenta quase todas as propriedades dos componentes ListBox e Edit. Vejas as mais importantes propriedades a seguir. Propriedade
DropDownCount ItemIndex, TopIndex Items MaxLength MultiSelect, ExtendedSelect, SelCount, Selected Sorted Style
Descrio
Determina o nmero de itens listados (o padro 8) Leia ItemIndex para determinar o ndice do item selecionado no ComboBox. Leia/altere TopIndex para determinar/alterar o primeiro item exibido na lista de opes (parte de baixo do ComboBox). Os itens listados na parte de baixo no ComboBox. Esta propriedade do tipo TStrings e idntica propriedade Lines do Memo e propriedade Items do ListBox. O nmero mximo de caracteres que pode ser digitado na parte de cima do ComboBox (a rea de digitao). Se MaxLength for zero (o valor padro), o nmero ilimitado. Estas propriedades, usadas para a seleo de mltiplos itens, so idnticas s de mesmo nome para o componente ListBox (veja a seo sobre este componente). Altere Sorted para True para que os itens do ComboBox sejam ordenados alfabeticamente. Esta uma das propriedades mais importantes. Ela determina a aparncia e o comportamento (o estilo) do ComboBox. As opes seguintes so as mais usadas: csDropDown: com esta opo, o ComboBox permite que seja escolhido um valor da lista ou que seja digitado um valor na parte de cima. csDropDownList: com esta opo, a parte de cima da caixa no pode ser alterada. O usurio fica restrito somente s opes da lista. csSimple: uma opo usada nas caixas "Abrir" e "Salvar" da maioria dos aplicativos para Windows. Aqui a lista de opes sempre exibida (o nmero de itens exibidos depende do tamanho do ComboBox). Para essa opo, enquanto voc digita na parte de cima, a lista se ajusta automaticamente, fazendo o item mais prximo do que est sendo digitado passar a ser a primeira da lista.
68
69
csDropDown Text O texto na parte de cima do ComboBox.
csDropDownList
csSimple
6.8.2.
Eventos
O evento OnChange chamado quando o texto na parte de cima da lista alterado. O evento OnClick chamado quando o usurio clica em algum item da lista.
6.9.
Componente CheckBox
O componente CheckBox usado para permitir a escolha de opes no mutuamente exclusivas (vrias opes podem ser escolhidas ao mesmo tempo). Para cada CheckBox h um ttulo associado. Um CheckBox pode estar em trs estados: marcado (checked), desmarcado (unchecked), ou acizentado (grayed).
6.9.1.
Propriedades
As propriedades mais importantes do componente CheckBox so descritas a seguir. Propriedade

Alignment Caption AllowGrayed O alinhamento do ttulo do CheckBox. O ttulo que identifica o CheckBox. Altere AllowGrayed para True para permitir mais um estado para o CheckBox: o estado acinzentado. O significado desse estado depende do aplicativo. Ele pode, por exemplo, indicar que uma opo est em um estado intermedirio: nem ligada nem desligada. O estado inicial do CheckBox. True marca o CheckBox; False desmarca. Use State para alterar ou ler o estado do CheckBox. Os trs estados possveis so cbUnchecked (desmarcado), cbChecked (marcado) e cbGrayed (acinzentado). A opo cbGrayed s tem efeito se a propriedade AllowGrayed for True. Veja abaixo a aparncia de um CheckBox para cada um dos trs estados:
Descrio
Checked State
cbUnchecked cbChecked cbGrayed
6.9.2
Eventos
O evento OnClick o evento mais usado para o componente CheckBox. O evento OnClick ocorre quando o CheckBox recebe um clique. Um clique tambm automaticamente marca (ou desmarca) o CheckBox. NOTA: voc no precisa usar o evento OnClick para verificar se um CheckBox est marcado ou no. Para isso, verifique a propriedade Checked.
69
70
6.10. Componente RadioButton

O componente RadioButton usado geralmente para a escolha entre opes mutuamente exclusivas (uma opo cancela a outra). Um RadioButton s pode estar em dois estados: ligado ou desligado. Altere a propriedade Checked do boto para True para lig-lo lig e para False para deslig-lo.
Exemplos de RadioButtons As propriedades do componente RadioButton so praticamente as mesmas que para o componente CheckBox. Os eventos do componente RadioButton so exatamente os mesmos que os do componente CheckBox. Como para o componente CheckBox, o evento mais usado o evento OnClick. O componente RadioGroup (descrito (descrito a seguir) geralmente usado em vez do componente RadioButton.
6.11. Componente RadioGroup

O componente RadioGroup uma verso especial do componente GroupBox (descrito a seguir), que s pode conter RadioButtons. Para adicionar RadioButtons, altere re a propriedade Items (da mesma forma que para os componentes ListBox e ComboBox). Para organizar os RadioButtons em mais de uma coluna, altere a propriedade Columns. A propriedade ItemIndex determina qual RadioButton est selecionado.
Exemplos de RadioGroups Os RadioButtons dentro de um RadioGroup no podem ser alterados diretamente. Para alterar os ttulos dos RadioButtons, ou apagar ou acrescentar RadioButtons, altere a propriedade
70
71
Items. Para alterar o espaamento entre cada RadioButton, aumente ou diminua o tamanho do RadioGroup. O espaamento ajustado automaticamente. OnClick o evento mais usado para RadioGroups. Dentro do cdigo para o evento OnClick, verifique a propriedade ItemIndex para determinar qual RadioButton foi selecionado.
6.12. Componente GroupBox

O componente GroupBox muito til para a organizao de formulrios complexos. Componentes adicionados a um GroupBox passam a fazer parte do GroupBox. Se o GroupBox for movido ou apagado, os componentes contidos nele so movidos ou apagados apaga tambm.
Exemplo de GroupBox
Para adicionar um componente a um GroupBox, simplesmente clique dentro do GroupBox ao adicionar o componente. Depois de adicionado a um GroupBox, um componente s pode ser movido para fora dele usando os comandos Cut e Paste. Para alterar o ttulo de um GroupBox, altere sua propriedade Caption. Se voc apagar todo o texto dessa propriedade, a caixa de grupo se transforma apenas em um contorno retangular (isso usado com frequncia). O Delphi oferece vrios eventos para os componentes GroupBox, mas estes so raramente usados. Para lidar com eventos dos componentes dentro de um GroupBox, use os eventos desses componentes.
6.13. Componente Panel

O componente Panel usado, como o GroupBox, para agrupar componentes relacionados. relaciona Uma vantagem do Panel em relao ao GroupBox a sua versatilidade, principalmente nos seus recursos visuais. A maioria das propriedades do componente Panel afetam aparncia do componente no formulrio. Veja a seguir as propriedades usadas com mais freqncia. fr
71
72
Propriedade
Alignment BevelInner
Descrio
Determina o alinhamento do texto do Panel (se houver). O texto determinado pela propriedade Caption. Especifica a maneira como a parte interna do Panel exibida. A opo bvLowered faz com que a parte e interna parea "abaixada". bvRaised tem o efeito contrrio (aparncia levantada). A opo bvNone (a opo padro) retira o efeito tridimensional da parte interna do Panel.
BevelInner = bsRaised BevelInner = bsLowered BevelOuter BevelWidth Idntico propriedade propri BevelInner, s que para a parte externa do Panell. A intensidade do efeito tridimensional (veja as figuras).
BevelWidth = 1 BevelWidth = 5 BevelWidth = 10 BorderStyle BorderWidth Caption Determina se exibida ou no uma moldura em volta do Panel. A distncia entre os efeitos tridimensionais interno e externo. S tem efeito quando a propriedade BevelInner tem o valor bvLowered ou bvRaised. O texto exibido dentro do Panel.
6.14. Componente BitBtn

O componente BitBtn uma verso vers especializada do componente Button, com a capacidade de exibir imagens e realizar algumas aes comuns. Este componente muito usado para a criao de caixas de dilogo. H vrios tipos predefinidos de componentes BitBtn. Para escolher o tipo do BitBtn, altere a propriedade Kind. A aparncia do boto (a imagem e o texto que aparecem nele), bem como a ao realizada, dependem do valor escolhido para a propriedade Kind. Os tipos mais comuns de BitBtns so ilustrados a seguir. Valor de Kind Aparncia do Valor de Kind Aparncia do
72
73
BitBtn bkAbort bkCancel bkClose bkIgnore bkNo bkOK bkRetry bkYes
BitBtn
73
74
CAPTULO 07 - A LINGUAGEM OBJECT PASCAL

A linguagem Object Pascal a linguagem por trs de quase todas as partes de um aplicativo no Delphi. Os arquivos de projeto e as Units, como j vimos, so escritos em Object Pascal. O cdigo usado para criar os componentes predefinidos do Delphi tambm praticamente todo nessa linguagem. Nos captulos anteriores usamos vrias vezes pequenas partes da linguagem Object Pascal (dentro do cdigo para os eventos, por exemplo). Neste captulo veremos como usar recursos mais avanados da linguagem e como criar programas que no dependam somente da interface com o usurio.
7.1.
Usando o comando de atribuio
O comando de atribuio um dos mais usados em muitas linguagem de programao. O comando de atribuio usado para a alterar valores de variveis e propriedades no Delphi. J mostramos vrios exemplos que usam atribuio. Aqui est mais um: procedure TForm1.Button1Click(Sender: TObject); begin Edit1.Color := clRed; Edit1.Text := 'Novo texto'; Memo1.ReadOnly := True; end; O comando de atribuio, como se v formado por duas partes, a parte esquerda um nome de uma varivel ou de uma propriedade; a parte direita o novo valor que ser atribudo varivel ou propriedade. Esse valor pode ser outra varivel ou propriedade, uma constante, ou outra expresso. Os tipos dos dois lados devem ser os mesmos, ou pelo menos compatveis; caso contrrio, o Delphi gera erros na compilao.
7.2.
Entendendo identificadores
Identificadores (Identifiers) so os nomes que identificam os elementos de um programa em Object Pascal. Exemplos de identificadores so nomes de variveis, constantes, procedures, functions e componentes. Em Object Pascal todos os identificadores usados devem ser declarados. Quando voc declara um identificador, voc est definindo um tipo para ele (como inteiro, String, etc.). Um identificador deve seguir as seguintes regras bsicas: Um identificador pode ter at 63 caracteres. Qualquer caractere que passe desse limite ignorado pelo compilador do Delphi. Identificadores devem comear sempre com letras, ou com o caractere de sublinhado (_). Um identificador no pode comear com um nmero. Os outros caracteres de um identificador (do segundo em diante) podem ser letras, nmeros ou sublinhados. Nenhum outro caractere permitido.
74
75
Um identificador no pode ser uma palavra reservada da linguagem Object Pascal (como begin, if ou end, por exemplo).
7.3.
Declarando variveis
A declarao de uma varivel define o nome e o tipo da varivel. Declaraes de variveis devem ser precedidas pela palavra-chave palavra var. As declaraes, junto com a palavra-chave palavra var constituem o chamado bloco var. Declaraes devem em ser agrupadas no incio do programa, ou no incio de uma procedure ou function (antes da palavra-chave chave begin). O programa (trivial) abaixo mostra um exemplo de declarao de variveis. So declaradas trs variveis inteiras (X, Y e Soma). Assume-se que h dois componentes Edit no formulrio, onde so digitados os dois valores a serem somados. As funes StrToInt e IntToStr convertem o tipo de String para o Integer (Inteiro) e de Integer para String, respectivamente. Um caixa de mensagem exibida no final, l, com o resultado da soma. procedure TForm1.Button1Click(Sender: TObject); var X,Y: Integer; Soma: Integer; begin X := StrToInt(Edit1.Text); Y := StrToInt(Edit2.Text); Soma := X + Y; ShowMessage('Soma = ' + IntToStr(Soma)); end; Se as variveis desse programa rama no fossem declaradas, os seguintes erros seriam mostrados na compilao (na parte de baixo do Editor de Cdigo):
Portanto, lembre-se se sempre de declarar todas as variveis usadas nos seus programas!
75
76
7.4.
Tipos de variveis
O tipo declarado para uma varivel define o conjunto de valores permitidos para aquela varivel. H uma grande quantidade de tipos disponveis em Object Pascal. H vrios tipos muito parecidos entre si, que so usados apenas para manter compatibilidade com verses anteriores da linguagem Pascal. Abaixo listamos os tipos mais comumente usados. Tipo Integer Descrio Nmeros inteiros (sem parte fracionria) que podem variar de -2.147.483.647 at 2.147.483.647. Nmeros reais de alta preciso, com at 16 dgitos significativos. Usado para nmeros muito grandes ou muito precisos. Podem -324 308 variar de 5.0 x 10 at 1.7 x 10 . Nmeros reais de alta preciso. Idntico a Double. Nmeros reais de alta preciso, com quatro casas decimais. O tipo ideal para valores monetrios (use este tipo em vez de Double, para esses valores). Uma varivel com esse tipo pode variar de 922337203685477.5808 at 922337203685477.5807 (mais de 900 trilhes). Valores booleanos s podem ter valores True (verdadeiro) ou False (falso). Caracteres ANSI (padro) Cadeias de caracteres com tamanhos que podem variar dinamicamente. Strings podem ter tamanho praticamente ilimitado. Tamanho 4 bytes
Double
8 bytes
Real Currency
8 bytes 8 bytes
Boolean
1 byte
Char String
1 byte Varivel
7.5.
Declarando constantes
Constantes so usadas em programas para armazenar valores aue no podem (ou no devem) ser alterados em um programa. Declaraes de constantes devem ser precedidas pela palavra-chave const. As declaraes das constantes, junto com a palavra-chave const constituem o chamado bloco const. Ao contrrio das variveis, as constantes devem ter seus valores definidos logo na declarao. Alm disso, os tipos das constantes no so definidos explicitamente. Eles so deduzidos pelo Delphi, de acordo com o valor definido para cada constante. Veja alguns exemplos: const Altura = 100; Largura = 200; VelocidadeMaxima = 225.17; Titulo = Ecossistemas;
76
77
Aqui, as constantes "Altura" e "Largura" so armazenadas com "VelocidadeMaxima" com tipo Real (ou Double) e "Titulo" com tipo String.
tipo
Integer,
Note como usado o smbolo "=" para definir os valores para as constantes e no o smbolo de atribuio: ":=".
7.6.
Tipos estruturados
Pode-se criar novos tipos em Object Pascal, baseando-se nos tipos predefinidos. Tipos criados a partir dos tipos bsicos so chamados Tipos Estruturados. O exemplo mais comum de tipo estruturado o Array, uma seqncia de valores de mesmo tipo. A linguagem Object Pascal permite tambm criar Tipos enumerados, Registros e vrios outros.
7.7.
Tipos enumerados
A declarao de um tipo enumerado lista diretamente todos os valores que uma varivel pode conter. Voc define novos tipos usando a palavra-chave type, que deve ser colocada antes das definies dos tipos (tal como var e const). O bloco type deve ser posicionado antes dos blocos var e const. Veja alguns exemplos: type TDiaUtil = (Segunda, Terca, Quarta, Quinta, Sexta); TFabricante = (Chevrolet, Ford, Volkswagen); TSexo = (Masculino, Feminino); Depois de definir os novos tipos, voc pode us-los normalmente nas declaraes das variveis, como se fossem tipos predefinidos. Veja exemplos de declaraes que usam os tipos definidos acima: var DiaInicial, DiaFinal: TDiaUtil; Fab: TFabricante; Sexo: TSexo;
Nesse caso, por exemplo, a varivel Fab s pode ter trs valores diferentes. Qualquer valor diferente de "Chevrolet", "Ford", ou "Volkswagen" no permitido. Voc atribui valores a uma varivel de tipo enumerado normalmente. Veja alguns exemplos:
Fab := Ford; Sexo := Masculino; DiaDaSemana := Terca; Note como no so usadas aspas para os valores. Isso acontece porque os valores de um tipo enumerado so armazenados como valores inteiros, na seqncia em que so definidos (comeando a partir de zero). Para o tipo TFabricante, por exemplo, temos Ford = 0,
77
78
Chevrolet = 1 e Volkswagen = 2. O uso de tipos enumerados em vez de inteiros pode tornar um programa muito mais legvel.
7.8.
Tipos de intervalo (Subrange)
Os tipos de intervalo so seqncias de valores dos tipos Boolean, Char, Integer, ou de tipos enumerados. Tipos de intervalo so teis quando necessrio limitar uma varivel a um intervalo contnuo de valores, com/ de 1 a 100, ou de "A" a "Z". Veja a seguir exemplos de definies de tipos de intervalo: type TGraus = 0..360; THoraValida = 0..23; TMaiuscula = A..Z; var Hora: THoraValida; Angulo: TGraus; No exemplo, a varivel "hora" s pode estar entre 0 e 23 e a varivel "angulo" deve estar entre 0 e 360. Quando uma varivel e definida com um tipo de intervalo, o Delphi verifica, durante a compilao, as alteraes nesta varivel e gera erros de compilao quando os limites do intervalo so violados. O seguinte exemplo gera um erro de compilao, na linha destacada. procedure TFormTesteRange.Button1Click(Sender: TObject); type TGrau = 0..360; var Temp: TGrau; begin for Temp := 0 to 720 do {Erro de compilao!} begin ... {cdigo omitido} end; end; A mensagem de erro gerada "Constant expression violates subrange bounds", indicando que os limites do intervalo foram violados (a varivel Temp passaria do limite, 360, no loop for).
78
79
No caso anterior, o Delphi pde detectar o erro, porque foram usados valores constantes para a varivel. Quando so usadas expresses mais complexas (clculos por exemplo), o Delphi s pode detectar o erro em tempo de execuo. O exemplo a seguir passaria na compilao, mas a linha destacada geraria uma exceo do tipo ERangeError (Temp receberia o valor 400, maior que o mximo permitido pelo tipo Tgrau: 360). procedure TFormTesteRange.Button2Click(Sender: TObject); type TGrau = 0..360; var Temp: TGrau; begin Temp := 200; Temp := Temp*2; {Erro de execuo!} ShowMessage(IntToStr(Temp)); end; NOTA: O comportamento padro do Delphi no verificar erros de intervalo em tempo de execuo (como o erro do exemplo anterior). Para que o Delphi realmente verifique se as variveis esto dentro dos limites, escolha o comando Project | Options, mude para a pgina Compiler e ative a opo Range Checking.
7.9.
Arrays
Os Arrays so usados com freqncia, praticamente em qualquer programa. Arrays so seqncias indexadas de valores do mesmo tipo. Veja alguns exemplos de declaraes de arrays: var Nomes: array[1..100] of String; Salarios: array[1..50] of Real; Aqui, a varivel "Nomes" uma seqncia de 100 Strings e "Salarios" uma seqncia de 50 valores do tipo Real. Os elementos de um array so indexados: para acessar um valor de um array, digite o nome do array, seguido do ndice entre colchetes. Por exemplo: Nomes[32]. O ndice pode ser qualquer expresso que tenha como resultado um valor inteiro. O exemplo a seguir declara um array "quadrados" com 100 inteiros e depois preenche esse array com os quadrados dos nmeros de -50 a 250: procedure TForm1.Button1Click(Sender: TObject);
79
80
var I: Integer; Quadrados: array[1..100] of Integer; begin for I := -50 to 250 do Quadrados[I] := I*I; end;
7.10. Arrays multidimensionais

Arrays multidimensionais so simplesmente "arrays de arrays". Os arrays que vimos at agora tm apenas uma dimenso. Arrays com duas dimenses (bidimensionais) so usados para armazenar tabelas de valores. Pode-se tambm definir arrays de 3 ou mais dimenses, mas estes so pouco usados e ocupam muita memria. Veja exemplos de definies de arrays multidimensionais: var TabelaGrafico: array[1..100, 1..100] of Double ModeloEdificio: array[1..500, 1..500, 1..500] of Integer; O nmero de elementos de um array multidimensional o resultado da multiplicao de todas as suas dimenses. O array "TabelaGrafico", no exemplo, tem 100x100=10.000 elementos, e o array "ModeloEdificio" tem 500x500x500 = 125 milhes de elementos. Para acessar um elemento de um array multidimensional, so usados vrios ndices (um para cada dimenso), separados por vrgulas. Por exemplo: TabelaGrafico[56,78] ModeloEdificio[150,115,82]
7.11. Strings
Strings em Object Pascal so armazenados internamente como arrays de caracteres (arrays do tipo Char). H dois tipos de Strings em Object Pascal: Strings longos e Strings curtos. Strings longos tm o comprimento praticamente ilimitado (2 GigaBytes). Eles so declarados usando somente a palavra-chave string. String curtos tm o comprimento limitado em 255 caracteres. Para declarar um String curto, use a palavra-chave string seguida pelo tamanho desejado, entre colchetes. Veja a seguir exemplos de declaraes dos dois tipos de Strings: var Nome: String[30]; {um String curto com no mximo 30 caracteres}
80
81
Texto: String; {um String longo} Como um String um array de caracteres, pode-se acessar cada caractere do String individualmente, usando ndices. Por exemplo, Nome[5] retorna o quinto caractere do String "Nome" (os caracteres so indexados a partir de 1).
7.12. Registros (Records)

Os registros so conjuntos de variveis de tipos diferentes. Um registro pode ser manipulado como um nico elemento e definido usando a palavra-chave record (registro em ingls). Veja um exemplo que define um registro para armazenar dados sobre produtos. type TProduto = record Codigo: String[12]; Descricao: String[50]; Preco: Currency; Fornecedor: String[50]; Quantidade: Integer; end; Depois de definir um registro, voc pode declarar uma varivel com o novo tipo de registro ou at definir um array com o novo tipo, como no exemplo abaixo: var Produto: TProduto; Estoque: array[1..500] of TProduto; Os elementos de um registro so chamados de campos. Os campos do registro "TProduto" definido acima, por exemplo, so Codigo, Descricao, Preco, Fornecedor e Quantidade. Para acessar um campo de uma varivel do tipo registro, use o nome da varivel seguido por um ponto e o nome do campo O trecho de cdigo abaixo, por exemplo, define valores para cada um dos campos da varivel produto: Produto.Preco := 259,95; Produto.Codigo := 005-002x;
81
82
Produto.Fornecedor := Eletrosul; Produto.Descricao := Liquidificado industrial Walita 2001; Produto.Quantidade := 8; Para evitar a repetio do nome do registro em casos como este, pode-se usar o comando with: with produto do begin Preco := 259,95; Codigo := 005-002x; Fornecedor := Eletrosul; Descricao := Liquidificado industrial Walita 2001; Quantidade := 8; end;
7.13. Controle de fluxo

Os programas mostrados at aqui no fazem nada alm de definir novos tipos, declarar variveis e alter-las. Para que programas realmente "faam alguma coisa", eles devem ser capazes de tomar decises de acordo com as entradas do usurio, ou repetir comandos, at que uma certa condio seja satisfeita. So essas operaes que constituem o controle de fluxo de um programa.
7.14. Usando blocos

Um bloco um conjunto de comandos delimitado pelas palavras chave begin e end. J usamos blocos vrias vezes nos exemplos mostrados at aqui . No arquivo de projeto, por exemplo, um bloco contm o cdigo principal do projeto (onde, entre outras coisas, so criados os formulrios do aplicativo). Todo programa em Object Pascal deve ter pelo menos um bloco: o bloco principal. Quando voc precisa executar ou no um conjunto de comandos dependendo de uma condio, voc deve usar blocos para delimitar esses conjuntos. Outro uso importante de blocos para a repetio de um conjunto de comandos vrias vezes, como nos loops for, while e repeat, que veremos a seguir. Blocos podem ser aninhados, isto pode haver blocos dentro de blocos. Isso til em estruturas complexas, como ifs dentro de ifs, ou loops dentro de loops. A estruturao em blocos da linguagem Object Pascal uma de suas caractersticas mais elegantes e poderosas.
82
83
7.15. If-then-else
O comando mais usado para fazer decises simples o comando if. O comando if verifica uma condio e executa um comando ou bloco de comandos somente se a condio for verdadeira. O comando if sempre usado com a palavra-chave then. H vrias maneiras de usar o comando if. Veja a mais simples a seguir: if condio then comando; Aqui a condio qualquer expresso que tenha valor booleano (True ou False). Condies so geralmente comparaes, como a > b, x = 1, total <= 1000, etc. Pode-se tambm usar o valor de uma propriedade como condio. O exemplo abaixo, ativa um boto (chamado "Button2") somente se ele estiver desativado (com Enabled=False). Caso contrrio, nada acontece. if Button2.Enabled = False then Button2.Enabled = True; H tambm vrias funes predefinidas que retornam valores booleanos e que tambm podem ser usadas como condies.
7.16. Usando else

Um comando if pode tambm apresentar uma segunda parte, delimitada pela palavra-chave else. O comando da segunda parte (depois de else) executado quando a condio falsa. O exemplo a seguir mostra uma mensagem diferente dependendo do valor da varivel "x": if x > limite then ShowMessage(Limite ultrapassado!); else ShowMessage(Sem problemas.);
7.17. Usando blocos com o comando if

A verso simples do comando if usada nos exemplos acima tem uso muito limitado. Na maioria das vezes, necessrio executar mais de um comando se uma certa condio for verdadeira. Para isso voc deve usar blocos de comandos. Veja um exemplo completo: procedure TForm1.Button1Click(Sender: TObject); var Dividendo, Divisor, Resultado: Real; begin Dividendo := StrToFloat(Edit1.Text); Divisor := StrToFloat(Edit2.Text);
83
84
if Divisor = 0 then begin Color := clRed; ShowMessage('Divisor invlido'); end else begin Color := clSilver; Resultado := Dividendo/Divisor; ShowMessage('Resultado = ' + FloatToStr(Resultado)); end; end; Note os dois blocos de comandos: um para o if-then e outro para o else. O programa calcula a diviso de dois valores do tipo Real (lidos a partir de dois componente Edit). Se o divisor for zero, o primeiro bloco do if executado: o formulrio muda para vermelho e uma mensagem exibida. Se o divisor no for zero, o segundo bloco (depois do else) executado, mudando a cor do formulrio para cinza. As funes StrToFloat e FloatToStr convertem de Strings para nmeros reais e de nmeros reais para Strings, respectivamente. Note como o end depois do primeiro bloco no seguido de ponto-e-vrgula (;). Essa uma regra obrigatria da linguagem Object Pascal: um end antes de um else nunca deve ser seguido por ";". Somente o ltimo end do comando if deve terminar com ponto-e-vrgula.
7.18. Aninhando comandos if

Muitas vezes, um programa deve decidir entre mais de duas opes. Para isso, pode-se usar comandos if aninhados (um if dentro de outro). Veja um exemplo: procedure TForm1.Button1Click(Sender: TObject); var Nota: Real; begin Nota := StrToFloat(Edit1.Text); if nota < 5.0 then ShowMessage('Reprovado por mdia') else
84
85
if (Nota >= 5.0) and (Nota < 7.0) then ShowMessage('Aprovado na final') else if Nota > 8.5 then ShowMessage('Aprovado com excelncia') else ShowMessage('Aprovado simplesmente') end; O exemplo l uma nota digitada pelo usurio e mostra uma mensagem que varia de acordo com o valor da nota. Acompanhe o fluxo do programa: se a nota for menor que 5, a primeira mensagem exibida; caso contrrio (qualquer valor maior ou igual a 5), o programa checa a segunda condio: se a nota estiver entre 5 e 7, a segunda mensagem exibida. Se no, o programa verifica se a nota maior que 8.5 e, se for, mostra a terceira mensagem. A mensagem depois do ltimo else s exibida se nenhuma das condies anteriores for verdadeira (isso acontece se a nota estiver entre 7 e 8.5). NOTA: no programa acima foi usada a palavra chave and para criar uma condio mais complexa. H mais duas palavras-chaves semelhantes: or e not. Pode-se usar qualquer combinao de not, and e or para criar novas condies. Lembre-se, entretanto de usar parnteses para agrupar as condies. Os parnteses usados no programa anterior, por exemplo, so todos obrigatrios.
7.19. A estrutura case

Quando necessrio decidir entre muitas opes em um programa, a estrutura case da linguagem Object Pascal em geral mais clara e mais rpida que uma seqncia de ifs aninhados. Uma estrutura case s pode ser usada com valores ordinais (inteiros, caracteres, tipos de intervalo e tipos enumerados). Na estrutura case uma varivel comparada com vrios valores (ou grupos de valores) e o comando (ou bloco de comandos) correspondente executado. Veja a seguir um exemplo simples, que mostra mensagens diferentes, de acordo com o nmero entrado em um Edit. procedure TForm1.Button1Click(Sender: TObject); var Numero: Integer; begin Numero := StrToInt(Edit1.Text); case Numero of 1, 2, 3, 5, 7 :
85
86
begin ShowMessage('Nmero primo menor que 10'); Color := clBlue; end; 4, 6, 8: ShowMessage('Nmero par menor que dez'); 9: ShowMessage('Nmero mpar menor que dez'); 10..1000: ShowMessage('Nmero entre 10 e 1000'); else ShowMessage('Outro nmero'); end; // final do case end; // final da procedure Uma estrutura case deve ser terminada com end e pode ter uma parte opcional else. Os comandos depois do else s so executados se a varivel no for igual a nenhum dos valores especificados (se no houver a parte else, a estrutura case pulada inteiramente). No exemplo acima, a mensagem "Outro nmero" s mostrada se o valor da varivel "numero" for maior que 1000 ou menor que 1.
7.20. Usando loops

Os loops ("laos") so estruturas usadas para repetir vrias vezes sequncias de comandos. H trs tipos de loops em Object Pascal. O loop for usado para realizar um nmero fixo de repeties. Os loops while e repeat repetem um bloco de comandos at que uma condio se torne falsa ou verdadeira, respectivamente.
7.21. O loop for

O loop for o mais rpido e mais compacto dos trs tipos de loops. Esse loop usa um contador, uma varivel inteira que aumentada (incrementada) automaticamente cada vez que o loop executado. O nmero de repeties do loop for fixo. Ele depende somente do valor inicial e do valor final do contador, que so definidos no incio do loop. Veja um exemplo: procedure TForm1.Button1Click(Sender: TObject); var I: Integer; Numero: Integer; begin Numero := StrToInt(Edit1.Text);
86
87
for I := 1 to 50 do ListBox1.Items.Add(IntToStr(Numero*I)); end; Este programa mostra os primeiros 50 mltiplos do nmero digitado em um Edit. Os mltiplos so adicionados a um ListBox. O loop for usado aqui contm um nico comando. Por isso no necessrio usar begin e end. O exemplo a seguir mais complexo. Nele so usados loops for aninhados para multiplicar 100 valores por 20 taxas diferentes, gerando uma tabela um array bidimensional com o "cruzamento" de todos os valores e taxas. calculado tambm o total dos valores da tabela gerada. Vrios outros loops for simples so usados. Note que uma mesma varivel pode ser usada vrias vezes em loops for diferentes. procedure TForm1.Button1Click(Sender: TObject); var i,j: Integer; ValorInicial, Total: Currency; Taxas: array[1..20] of Double; Valores: array[1..100] of Currency; Tabela: array[1..20, 1..100] of Currency; begin ValorInicial := StrToFloat(Edit1.Text); {Calcular taxas} for i:= 1 to 20 do Taxas[i] := i/100; {Calcular valores} for i:= 1 to 100 do Valores[i] := ValorInicial + i*100; {Multiplicar valores por taxas e somar resultados} Total := 0; for i:= 1 to 100 do for j := 1 to 20 do begin
87
88
Tabela[i][j] := Valores[i]*Taxas[j]; Total := Total + Tabela[i][j]; end; end;
7.22. O loop while

O loop while um loop mais verstil que o for, embora um pouco mais complexo. O loop while repete um comando, ou um bloco de comandos, at que a condio especificada se torne falsa. O nmero de repeties no preestabelecido como no loop for. No exemplo a seguir, o valor digitado em um Edit lido, convertido e colocado em uma varivel "x". Em seguida, subtrado 10 do valor de "x" e adicionado o resultado (convertido em um string) a um ListBox, repetindo o processo at que "x" seja menor ou igual a 0.
procedure TForm1.Button1Click(Sender: TObject); var x: Integer; begin x := StrToInt(Edit1.Text); {Ler valor inicial para x} ListBox1.Items.Clear; {Limpar a lista de valores} while x > 0 do begin x := x - 10; ListBox1.Items.Add(IntToStr(x)); end; end; No loop while, a condio testada no incio de cada repetio. Quando a condio falsa, o programa sai do loop e executa o comando imediatamente depois. Se a condio testada for verdadeira, o loop executado novamente. Note que possvel que os comandos de um loop while no sejam executados nenhuma vez. Isso acontece quando a condio falsa j na entrada do loop. No programa acima, por exemplo, um valor inicial negativo para a varivel "x" faria com que o while fosse pulado inteiramente na primeira vez. Outra caracterstica importante do loop while, que a condio usada no loop deve se tornar falsa em algum momento. Caso contrrio, o loop executado para sempre. O programa entra em um "loop infinito". Veja uma exemplo de um loop infinito com while: x:= 1; while x > 0 do x := x + 1; Aqui, a condio x > 0 nunca se tornar falsa (x ser sempre maior que zero), e o programa ficar preso para sempre dentro do while.
88
89
Esse um erro cometido com freqncia, principalmente em loops while com condies mais complexas. Tenha cuidado, portanto, de alterar pelo menos uma das variveis envolvidas na condio, dentro do while.
7.23. O loop repeat

O loop repeat uma verso "invertida" do loop while. Nele, a condio verificada somente no final do loop. Isso faz com que o loop seja sempre executado, pelo menos uma vez. A condio do loop repeat aparece no final, ao lado da palavra-chave until ("at"). Alm disso, devido estrutura simples do loop repeat, os comandos do loop no precisam ser delimitados por begin e end. Veja um exemplo: procedure TForm1.Button1Click(Sender: TObject); var Entrada: String; Valor: Integer; begin repeat Entrada:= (InputBox('', 'Entre com um nmero de 1 a 100','')); Valor:= StrToInt(entrada); until (Valor >= 1) and (Valor <= 100); ShowMessage('Entrada aceita.'); end; O cdigo mostra uma InputBox vrias vezes, at que a entrada seja vlida (entre 1 e 100). Note que a InputBox exibida pelo menos uma vez, pois usado um loop repeat. Se while tivesse sido usado em vez de repeat, o cdigo seria mais longo e menos elegante: procedure TForm1.Button1Click(Sender: TObject); var Valor: Integer; Entrada: string; begin Entrada:=InputBox('','Entre com um nmero de 1 a 100',''); Valor := StrToInt(entrada); while (Valor < 1) or (Valor > 100) do
89
90
begin Entrada := InputBox('','Entre com um nmero de 1 a 100',''); Valor := StrToInt(Entrada); end; ShowMessage('Entrada aceita.'); end; Este cdigo tem exatamente o mesmo efeito que o anterior. Mas note que a condio usada no loop while o oposto da condio do loop repeat. Alm disso, h uma repetio das linhas de cdigo que lem a entrada. Isso necessrio porque a varivel "valor" testada no incio do loop e precisa ser inicializada primeiro. Na verdade, qualquer programa que use repeat pode ser convertido em um programa usando while, fazendo-se mudanas semelhantes s mostradas aqui. O loop repeat apenas uma convenincia, que pode algumas vezes tornar o cdigo mais simples.
7.24. O comando break

O comando break usado para sair imediatamente de um loop (while, for ou repeat). Veja um exemplo simples: var A,B: array[1..1000] of Integer; i: Integer; ... for i:= 1 to 1000 do if A[i] <> B[i] then break; if i = 1000 then ShowMessage('Todos os elementos so iguais') else ShowMessage('O elemento com ndice ' + IntToStr(i) + ' diferente'); ... O exemplo compara os elementos de dois arrays A e B, de 1000 elementos cada um (o clculo para os valores dos arrays no mostrado). Quando encontrada a primeira diferena nos arrays, o comando break interrompe o loop for imediatamente e os outros elementos dos arrays no so checados. Se todos os elementos forem iguais, o valor da varivel i no final do loop ser 1000 e a primeira mensagem mostrada. Se o loop for quebrado antes de terminar,
90
91
com o comando break, o valor de i ser menor que 1000 e a segunda mensagem ser mostrada.
7.25. O comando continue

O comando continue usado dentro de loops para forar a prxima execuo do loop. Quando o comando continue encontrado, o programa volta imediatamente para ou incio do loop e os comandos depois de continue no so executados. Veja um exemplo que adiciona todos os valores diferentes de zero de um array a um ListBox. var A: array[1..100] of Integer; i: Integer; ... for i:= 1 to 100 do begin if A[i] = 0 then continue ListBox1.Items.Add(IntToStr(i)); end; Quando o elemento A[i] do array for zero, o comando continue faz com que o loop seja repetido imediatamente (voltando para o comeo do loop). Com isso, o segundo comando dentro do loop s executado quando A[i] diferente de zero.
7.26. Procedures e Functions

As procedures (procedimentos) e functions (funes) so os blocos bsicos dos programas criados em Object Pascal. Procedures e functions so blocos independentes de cdigo, que podem ser chamados vrias vezes, em vrios pontos de um programa. Procedures e functions so s vezes chamadas de rotinas. A diferena entre procedures e functions simples: functions retornam um valor; procedures no. O exemplo mais comum de procedure no Delphi o cdigo gerado para os eventos de um componente. Todos os eventos so procedures. Veja mais um exemplo de um evento:
procedure TFormCadastro.BtCadastrarClick(Sender: TObject); begin if (EditNome.Text='') or (EditSobrenome.Text='') then ShowMessage('Campos no podem ser vazios') else begin
91
92
... ShowMessage('Sucesso no cadastro.'); end; end; Uma procedure ou function pode ter zero ou mais parmetros. No caso dos eventos, o parmetro mais comum o parmetro "Sender", que indica o componente que gerou o evento.
7.27. Sintaxe das procedures e functions

A sintaxe para uma procedure a seguinte: procedure nome da procedure (param1, param2, ...:tipo1; param1,...:tipo2; ...); type {definies de tipos} var {declaraes de variveis } const {definies de constantes} begin { corpo } end; Para functions, a sintaxe praticamente idntica. A nica diferena que o tipo do valor retornado deve ser especificado no final da primeira linha. function nome da function (param1, param2, ...:tipo1; param1,...:tipo2; ...): tipo de retorno; type {definies de tipos} var {declaraes de variveis } const {definies de constantes} begin
92
93
{corpo} end; A primeira linha, chamada de cabealho, deve sempre terminar com ";". Os parmetros, se existirem, devem ter seus tipos especificados e devem ser separados por vrgulas. Parmetros do mesmo tipo podem ser agrupados; esses grupos devem ser separados por ";". Depois do cabealho, vm os blocos de declarao type, var e const (no necessariamente nessa ordem). Todos estes so opcionais, pois a procedure ou functions pode no precisar de nenhuma varivel alm das especificadas nos seus parmetros. Em seguida, vem o bloco principal (ou corpo) da procedure, delimitado por begin e end. neste bloco que fica o cdigo executvel da procedure.
7.28. Entendendo parmetros

Os parmetros so variveis passadas para as procedures e functions (rotinas). Os parmetros de uma rotina so opcionais. So comuns rotinas (principalmente procedures) sem nenhum parmetro. Quando so usados parmetros, estes podem ser passados por valor ou por referncia. A forma como os parmetros so passados definida no cabealho da rotina. Quando uma varivel passada por valor, a rotina recebe apenas um cpia da varivel. A varivel passada se comporta como uma varivel local. Alteraes realizadas na varivel no tm efeito depois da rotina terminar (ou retornar). A passagem por valor o tipo padro de passagem de parmetros na linguagem Object Pascal. Quando uma varivel passada por referncia, a rotina recebe uma referncia varivel passada ou, em outras palavras, a prpria varivel. Com esse tipo de passagem de parmetros, a rotina pode alterar diretamente a varivel passada. Para especificar a passagem por referncia, use a palavra-chave var antes do nome do parmetro, no cabealho da rotina. Veja um exemplo que usa os dois tipos de passagem de parmetros: procedure Descontar(Taxa: Real; var Preco: Currency); begin Preco := Preco - Preco*(Taxa/100); end; Esta procedure recebe dois parmetros: Taxa e Preco. O parmetro Taxa passado por valor. O valor de Taxa pode ser alterado dentro da procedure, mas as alteraes no tero efeito depois de a procedure retornar. O parmetro Preco passado por referncia (usando-se a palavra var antes do parmetro). Preco alterado dentro da procedure e essa alterao permanente.
7.29. Definindo o valor de retorno de uma function

O valor retornado por uma function pode ser definido de duas maneiras: atribuindo um valor para o nome da function, ou alterando a varivel especial Result. As duas funes a seguir so exatamente equivalentes:
93
94
function Dobro1(Numero: Integer): Integer; begin Dobro := Numero*2; end;
function Dobro2(Numero: Integer): Integer; begin Result := Numero*2; end;
7.30. Chamando procedures e functions

Depois de definir uma procedure ou function, voc pode cham-la diretamente no seu cdigo, em qualquer lugar da Unit em que foi definida. Para chamar uma procedure ou function, basta especificar o seu nome e valores para seus parmetros (se houver). O seguinte trecho de cdigo mostra como chamar a procedure Descontar (definida acima) para realizar um desconto de 10% sobre um preo p. (O valor de p no final ser 450.0). ... p := 500.0; Descontar(10, p); ...
7.31. Onde criar procedures e functions

H regras para o posicionamento das procedures no cdigo: as procedures devem ser colocadas somente depois da parte implementation da Unit (veja a seguir), depois das declaraes das variveis globais. O exemplo a seguir usa a procedure Descontar e uma variao da function Dobrar, dos exemplos anteriores. Os valores de cem preos, armazenados no array Precos, so alterados no evento OnClick do componente Button1. (O programa, apesar de completo, foi mantido deliberadamente simples, para ilustrar melhor os conceitos envolvidos). {Cdigo inicial da Unit} ... implementation
94
95
var Precos: array[1..100] of Currency; procedure Descontar(Taxa: Double; var Preco: Currency); begin Valor := Preco - Preco*(taxa/100); end; function Dobrar(Preco: Currency): Currency begin Result := Preco*2; end; procedure TForm1.Button1Click(Sender: TObject); var i: Integer; begin // Descontar em 25% os primeiros 20 produtos... for i := 1 to 20 do Descontar(25, Precos[i]); //...descontar em 50% os prximos 30... for i := 21 to 50 do Descontar(50, Precos[i]); //...e dobrar o preo dos 50 produtos restantes for i := 51 to 100 do Precos[i]:= Dobrar(Precos[i]); end; end.
7.32. Trabalhando com Excees

As excees so um mecanismo poderoso para lidar com erros nos seus programas. O uso de excees permite uma separao entre o cdigo normal de um programa e o cdigo usado para lidar com erros que podem surgir.
95
96
Quando ocorre um erro em um programa, o Delphi levanta uma exceo. Se uma exceo que foi levantada no for tratada, o programa interrompido e mostrada uma caixa de dilogo com uma descrio da exceo. Uma exceo no-tratada pode causar danos aos seus dados, deixar o programa em uma situao instvel, ou at levar o programa a "travar". Para evitar que isso acontea, voc deve tratar as excees, protegendo blocos de cdigo que contenham comandos que possam causar erros. Para proteger um bloco de cdigo cerque-o com as palavras-chave try e end. Dentro de um bloco protegido, pode-se usar as comandos except ou finally, para tratar as excees. H dois de tipos blocos protegidos: try {comandos que podem levantar excees } except {comandos executados quando uma exceo levantada} end;
try {comandos que podem levantar excees } finally {comandos sempre executados, havendo excees ou no} end; O primeiro tipo de bloco protegido chamado de bloco try-except. O segundo, de bloco tryfinally. No bloco try-except, os "comandos protegidos" ficam entre as palavras-chave try e except. Quando uma exceo ocorre em um desses comandos, o programa pula imediatamente para o primeiro comando depois de except. No caso do bloco try-finally, os comandos depois de finally so executados sempre (mesmo quando excees no so levantadas). Pode-se usar esses comandos para realizar operaes de "limpeza", como destruir componentes que no so mais necessrios, por exemplo. H vrios tipos de excees. Veja a seguir um exemplo que trata a exceo EDivByZero, gerada quando feita uma diviso por zero (o divisor aqui o valor contido no componente Edit1). Assume-se que os valores dos arrays resultado e valores foram declarados e inicializados antes. procedure TForm1.Button1Click(Sender: TObject); var Divisor: Real; begin
96
97
Divisor:= StrToFloat(Edit1.Text); for i:= 1 to 50 do try Resultado[i] := Valores[i]/Divisor; except on EDivByZero do Resultado[i] := 0; end; end; Note o uso da palavra-chave on dentro do bloco except. On usada para especificar o tipo de exceo a ser tratado. Um bloco except pode lidar com vrios tipos de exceo, definindo-se um bloco on [tipo de exceo] do [comandos] para cada tipo. Na tabela abaixo, listamos alguns tipos comuns de excees: Tipo de exceo EDivByZero EZeroDivide EConvertError EInOutError EDatabaseError EDBEngineError Quando ocorre Quando se tenta dividir um inteiro por zero. Quando se tenta dividir um nmero real (de ponto flutuante) por zero. Quando feita uma converso ilegal de tipos. Quando h um erro de entrada ou sada. Quando ocorre um erro geral de banco de dados. Quando h um erro no BDE (Borland Database Engine).
7.33. Entendendo o cdigo das Units

As Units contm praticamente todo o cdigo de um aplicativo no Delphi. As Units geralmente so associadas a formulrios, mas podem ser criadas de forma totalmente independente. Nesta seo veremos detalhes sobre cada parte de uma Unit.
7.34. A estrutura bsica de uma Unit

Todas as Units tm a mesma estrutura bsica:
unit <nome da unit> interface
97
98
uses <lista de Units> implementation uses <lista de Units> {cdigo para os procedures e functions} initialization {opcional} {cdigo para inicializao} finalization {opcional} {codigo para finalizao} end. A primeira linha da Unit identifica o nome da Unit (que deve ser um identificador vlido na linguagem Object Pascal). Veja a seguir descries sobre cada uma das partes. 7.34.1. Parte Interface A parte interface comea com a palavra interface e termina imediatamente antes da palavrachave implementation. Esta parte contm a definio de todos os tipos, constantes, variveis, procedures e funnctions que devem ser "visveis" (ou acessveis) para outras Units que se referenciem a esta. Somente o que estiver definido na parte interface pode ser acessado por outras Units. A primeira clusula uses geralmente adicionadas (predefinidas). rara a clusula uses. Para se implementation. fica dentro da parte interface. As Units listadas nessa clusula so pelo prprio Delphi, para fazer referncia a Units do sistema necessidade de adicionar manualmente nomes de Units a essa referenciar a outras Units, altera-se a clasula uses na parte
7.34.2. Parte Implementation A parte implementation contm todo o cdigo das procedures e functions da Unit. Esta parte pode conter tambm declaraes de variveis e constantes, mas estas s sero "visveis" pelo cdigo desta Unit. Nenhuma outra Unit pode ter acesso s variveis e constantes declaradas aqui. A parte implementation contm a segunda clusula uses. As Units listadas nessa clusula so geralmente adicionadas pelo programador, manualmente, ou usando o comando File | Use unit. 7.34.3. Parte Initialization A parte initialization opcional. Voc pode usar a parte initialization para declarar e inicializar variveis, por exemplo. O cdigo nesta parte executado antes de qualquer outro cdigo na Unit. Se um aplicativo tiver vrias Units, a parte initialization (se houver) de cada Unit executada antes de qualquer outro cdigo na Unit.
98
99
7.34.4. Parte finalization A parte finalization tambm opcional. O cdigo nessa parte executado logo antes do trmino do aplicativo. Essa parte geralmente usada para realizar "operaes de limpeza", como recuperar memria e outros recursos, ao final da execuo do aplicativo.
7.35. Rotinas teis

Nas sees a seguir, apresentaremos algumas rotinas (functions e procedures) teis na programao em Object Pascal.
7.36. Rotinas para manipulao de strings

A manipulao de strings uma tarefa muito comum em programao. A seguir, listamos as principais rotinas de manipulao de strings oferecidas pelo Delphi. (As rotinas cujos nomes comeam com "Ansi" so capazes de lidar com caracteres acentuados e, portanto, so muito teis para strings em portugus). Funo AnsiCompareStr(S1, S2: string): Integer AnsiCompareText(S1, S2: string): Integer Descrio A funo AnsiCompareStr compara S1 to S2, levando em conta maisculas e minsculas. A funo retorna um valor menor que zero se S1<S2, zero se S1=S2, ou um valor maior que 0 se S1>S2. A funo AnsiCompareText semelhante, mas ignora masculas e minsculas. AnsiLowerCase(S: string): string A funo AnsiLowerCase retorna o string S convertido para minsculas (inclusive para letras acentuadas). A funo AnsiUpperCase retorna o string S convertido para maisculas (inclusive para letras acentuadas). A funo AnsiPos retorna um inteiro com a posio do string Substr no string S. Se Substr no for encontrado, a funo retorna 0. A funo Copy retorna um string contendo Comp caracteres, comeando com S[Indice].
AnsiUpperCase(S: string): string
AnsiPos(Substr: string; S: string): Integer
Copy(S:string; Indice,Comp: Integer): string
Delete(var S: string; Indice, Comp: Integer) A procedure Delete remove o substring com Comp caracteres do string S, comeando com S[Index]. O string resultante retornado na varivel S. Length(S: string): Integer Trim(S: string): string A funo Length retorna o nmero de caracteres no string S. A funo Trim remove espaos esquerda e direita do string S.
99
100
7.37. Funes de converso de tipo

A linguagem Object Pascal especialmente exigente com relao aos tipos usados em expresses, e nas chamadas de procedures e functions. Se o tipo usado no for compatvel com o tipo esperado, gerado um erro de compilao. Funes de converso de tipo devem ser usadas para converter valores para os tipos adequados. As principais funes de converso de tipo so listadas na tabela a seguir. Se uma converso for ilegal, essas funes levantam a exceo EconvertError. Funo StrToCurr StrToDate StrToDateTime StrToFloat StrToInt StrToTime IntToStr CurrToStr DateToStr TimeToStr DateTimeToStr Tipo de origem String String String String String String Integer Currency TDate TTime TDateTime Tipo de destino Currency TDate TDateTime Real Integer TTime String String String String String
100
101
CAPTULO 08 - O Editor de Cdigo

O Editor de Cdigo (Code Editor) o editor padro do Delphi. Neste captulo, veremos como configurar e usar os recursos desse verstil editor.
8.1.
Visualizando arquivos
Cada arquivo aberto no Editor de Cdigo tem seu ttulo exibido em uma "aba" no topo da janela do editor. Pode-se alternar de um arquivo aberto para outro facilmente, clicando na aba correspondente. A janela do Editor de Cdigo mostrada abaixo, com vrios arquivos abertos. mostrado tambm o menu de atalho do Editor de Cdigo, que contm vrios comandos teis. Para abrir esse menu de atalho, clique com o boto direito na parte interna (parte do texto) do Editor de Cdigo.
Pode-se tambm usar o teclado para passar de um arquivo para outro. Use CTRL+TAB para mover para o prximo arquivo (na ordem das abas) e CTRL+SHIFT+TAB para mover para o arquivo anterior. Alm das Units e outros arquivos internos do Delphi, o Editor de Cdigo capaz de abrir qualquer arquivo texto, at outros escritos em outras linguagens. (Mas nesse caso, claro, o arquivo no significar nada para o Delphi e no poder ser compilado, ou alterado automaticamente). H vrias maneiras para abrir arquivos no Editor de cdigo. J conhecemos algumas, mas todas as maneiras so descritas aqui brevemente, por convenincia. Para abrir ou visualizar um arquivo no Editor de Cdigo, realize uma das seguintes operaes:
101
102
Escolha o comando File | Open para abrir um arquivo existente. Os arquivos padro especificados so as Units (.PAS) e os arquivos de projeto (.DPR). Se for necessrio abrir outro tipo de arquivo, especifique seu tipo em "Arquivos do tipo".
Clique com o boto direito em cima do nome de um arquivo (dentro do Editor de Cdigo) e escolha o comando Open File at Cursor ("Abrir arquivo na posio do cursor"). Esse comando til para cdigo que trabalha diretamente com arquivos. Voc pode us-lo para verificar se o arquivo realmente existe com o nome e local indicado no cdigo. O nome do arquivo deve estar especificado com o caminho (path) completo; caso contrrio, o Delphi pode no conseguir encontr-lo.
Para visualizar o cdigo associado a um formulrio (a Unit associada), selecione o formulrio e pressione F12. Pressione F12 novamente para voltar ao formulrio. Para visualizar o arquivo de projeto escolha o comando View | Project Source. O Editor de cdigo cria mais uma pgina para mostrar o arquivo de projeto (no aberta uma nova janela).
A seguir, listamos algumas outras operaes bsicas que podem ser realizadas no Editor de cdigo. Para fechar um arquivo no Editor de Cdigo:
1. Mude para a pgina do arquivo e clique dentro dela com o boto direito. 1. Escolha o comando Close Page. H tambm um atalho para isso: CTRL + F4. Se o arquivo no tiver sido salvo, o Delphi mostra uma caixa de confirmao. Note que no possvel fechar uma pgina simplesmente clicando na sua aba com o boto direito. Para fechar uma pgina no Editor de Cdigo, voc deve mostr-la primeiro. Para abrir uma nova janela para um mesmo arquivo: Mude para a pgina do arquivo, clique com o boto direito e escolha o comando New Edit Window. criada um nova janela com uma cpia do arquivo. As duas janelas (a original e a cpia) so sincronizadas. Alteraes em uma janela afetam a outra tambm. Esse comando til quando necessrio visualizar ou trabalhar com partes diferentes de um mesmo arquivo. Para proteger o texto de um arquivo contra alteraes: Mude para a pgina que contm o arquivo, clique com o boto direito e escolha o comando Read Only. Isso faz com que o arquivo se torne "Somente leitura", no permitindo alteraes acidentais. Para desproteger o arquivo, escolha o mesmo comando novamente. Para exibir uma janela de mensagens na parte de baixo do Editor de Cdigo: Clique com o boto direito em qualquer local de dentro do Editor de Cdigo e escolha o comando Message View.
102
103
Essa janela exibida durante a compilao para exibir mensagens de erro ou avisos. Para esconder a janela de mensagens:
Clique no pequeno "x" no canto esquerdo superior da janela de mensagens (veja figura).
8.2.
Tcnicas de navegao
H algumas tcnicas que tornam mais rpido o trabalho com vrias Units relacionadas, ou com Units extensas no Editor de Cdigo. Veja as mais importantes dessas tcnicas a seguir:
8.3.
Usando Bookmarks
Voc pode marcar linhas do cdigo com bookmarks, para depois retornar a essas linhas rapidamente, usando o teclado ou comandos de menu. Pode-se definir at dez bookmarks para cada Unit. Linhas com um bookmark definido aparecem com o nmero do bookmark (dentro de um quadrado verde) na margem esquerda do Editor de Cdigo (veja figura).
O Editor de Cdigo com dois bookmarks definidos Veja como realizar as operaes bsicas com bookmarks: Para definir um bookmark para uma linha de cdigo Coloque o cursor na linha e pressione CTRL+SHIFT+nmero, com nmero entre 0 e 9 (como CTRL+SHIFT+0 ou CTRL+SHIFT+5).
103
104
(Se j houver um bookmark com o mesmo nmero definido, ele movido para a linha atual) Para pular para um linha com um bookmark definido Pressione CTRL+nmero, onde nmero o nmero do bookmark para onde voc deseja pular. (Se no houver um bookmark com este nmero, nada acontece). Para remover um bookmark Mova o cursor para a linha com o bookmark e pressione CTRL+SHIFT+nmero, onde nmero deve ser o nmero do bookmark a ser removido. (Se for usado um nmero diferente, um novo bookmark definido "por cima" do anterior). NOTA: pode-se definir bookmarks tambm usando comandos do menu de atalho do Editor de cdigo. Clique com o boto direito dentro do editor e use os comandos Toggle Bookmarks e Goto bookmarks.
8.4.
Usando o recurso Code Browser
O recurso Code Browser permite navegar rapidamente entre vrios arquivos relacionados. Voc pode, por exemplo, abrir o arquivo que tenha a definio de uma procedure ou function, com apenas um clique do mouse. Para usar esse recurso, no Editor de Cdigo, pressione e mantenha pressionada a tecla CTRL e mova o cursor. Quando o cursor apontar para uma parte "navegvel" do cdigo, como o nome de uma Unit ou formulrio, essa parte aparece sublinhada em azul, como um link na Internet (veja a figura).
Clique na parte sublinhada para exibir o trecho de cdigo relacionado. Se o cdigo estiver em outro arquivo (e o Delphi puder encontr-lo), o arquivo automaticamente aberto no Editor de Cdigo. Se a parte sublinhada for uma varivel ou nome de componente, o Delphi move o cursor para a declarao da varivel ou componente.
104
105
Quando voc navega para vrios arquivos ou locais diferentes, so ativados os controles no canto superior direito da janela de Editor de Cdigo (veja figura).
Os controles de navegao do Editor de Cdigo Use a seta para a esquerda para pular para o ltimo local visitado e a seta para a direita para o prximo (a seta para a direita s ativada se a seta para a esquerda for usada ao menos uma vez). O funcionamento semelhante aos botes "Back" e "Forward" dos browsers para a Internet. Voc tambm pode pular para um local visitado clicando ao lado das setas, e escolhendo um local a partir da lista exibida.
8.5.
Localizando e substituindo
O Delphi oferece um conjunto de recursos poderosos para a localizao e a substituio de trechos de cdigo em seus programas.
8.6.
Localizando textos no arquivo atual
O Delphi oferece todas as opes comuns para localizao de textos. Voc define o texto a ser localizado e vrias outras opes usando o comando Search | Find, que exibe a seguinte caixa de dilogo:
Para localizar um trecho de texto no arquivo atual, digite o trecho em "Text to find", defina as opes necessrias e escolha OK. As opes so explicadas a seguir.
105
106
Ative essa opo Case sensitive Whole words only
Para obter o seguinte efeito: O Delphi diferencia entre maisculas e minsculas na localizao. A palavra especificada s localizada se ela aparecer "inteira" no texto (com espaos antes e depois). A palavra no pode ser parte de outra. (H vrios outros caracteres especiais consulte o Help) O Delphi permite que sejam usados caracteres especiais para especificar o texto a ser localizado. Um asterisco (*) vale por qualquer nmero de caracteres; um ponto (.) vale por um nico caractere, por exemplo. A localizao feita da posio do cursor para a frente. A localizao feita da posio do cursor para trs. A localizao feita em todo o arquivo, na direo especificada. A localizao restrita rea selecionada. Se nada estiver selecionado, ocorre um erro no Delphi! A localizao feita a partir do cursor. A localizao feita na rea selecionada, ou em todo o documento (se a opo Global estiver marcada)
Regular expressions
Forward Backward Global Selected text
From cursor Entire scope
8.7.
Localizando textos em vrios arquivos
possvel localizar textos em vrios arquivos, at em arquivos que no esto abertos no Editor de Cdigo. Para localizar textos em vrios arquivos, escolha o comando Search | Find in files, ou escolha a pgina Find in files da caixa de dilogo Find (veja a seo anterior). A seguinte caixa exibida:
Aqui, da mesma forma que para o comando Search | Find, voc digita o texto a ser procurado e escolhe as opes necessrias. As opes na rea "Options" da caixa so idnticas s descritas anteriormente. Na rea "Where", voc especifica em quais arquivos o texto ser procurado:
106
107
Opo Search all files in project Search all open files Search in directories
Descrio Procura em todos os arquivos do projeto, estejam eles abertos ou no.
Procura em todos os arquivos abertos no Editor de cdigo. Procura o texto no diretrio especificado na parte de baixo da d caixa de dilogo. No exemplo ilustrado a seguir, o texto ser procurado nos arquivos com extenso .pas e que estejam no diretrio c:\MyProjects, ou em subdiretrios deste.
8.8.
Outras tcnicas para localizao

Depois de localizar um trecho de texto, com os comandos descritos, voc pode localiz-lo lo novamente sem usar comandos de menu. Use o comando Search | Search again, ou pressione F3 para localizar as prximas ocorrncias do texto. Com o comando Search | Incremental Search, o Delphi localiza o texto text a medida que voc digita. Depois de escolher esse comando, o texto digitado aparece na barra de status, na parte de baixo do Editor de Cdigo:
Se o texto que est sendo digitado for encontrado, o texto selecionado no arquivo. Continue digitando at localizar exatamente o texto desejado. Para parar a localizao, pressione ENTER, ou qualquer seta do teclado.
8.9.
Substituindo textos
Muitas vezes necessrio substituir palavras ou trechos de texto em um arquivo (para corrigir o nome de uma varivel que que aparece vrias vezes, por exemplo). O Delphi permite fazer substituies apenas em um arquivo de cada vez. Para substituir um trecho de texto por outro, use o comando Search | Replace. Especifique o texto a ser localizado na primeira caixa ("Text to find") ") e o texto que ser usado para substitu-lo substitu lo na segunda caixa( "Replace with").
107
108
A opo Prompt on replace faz com que cada substituio seja confirmada. Desative-a para que o Delphi no mostre confirmaes. Para substituir todas as ocorrncias do texto especificado, clique no boto Replace All.
8.10. Configurando o Editor de Cdigo

O Editor de Cdigo pode ser configurado para se adaptar melhor sua maneira de programar, ou a costumes antigos que foram adquiridos com a experincia de programao. H uma quantidade enorme de opes que podem ser alteradas para o Editor de Cdigo. Veremos aqui as mais importantes e teis.
108
109
Configurao do Editor de Cdigo: pgina Display. Para configurar o Editor de Cdigo, clique dentro da janela do Editor com o boto direito e escolha Properties. A caixa de dilogo Environment Options, com apenas quatro pginas de opes, exibida. A primeira pgina Editor usada para configuraes avanadas do editor. So opes pouco usadas. As prximas duas pginas Display e Colors apresentam vrias opes teis que afetam a aparncia e os recursos de edio do Editor de Cdigo. A pgina Code Insight usada para configurar os recursos "Code Insight", de auxlio programao, que veremos na prxima seo.
8.11. Opes importantes da pgina Display

Na pgina Display, voc define a aparncia e a organizao da tela do Editor de Cdigo, alterando as seguintes opes: Opo Create backup file Descrio Ative essa opo para criar sempre arquivos de backup quando um arquivo salvo a partir do Editor de Cdigo. Ative essa opo para que o Editor de Cdigo ocupe toda a rea da tela, quando sua janela maximizada. Se essa opo estiver desativada (o padro), a janela do Editor de Cdigo no sobrepe a janela principal do Delphi. Exibe ou no a linha da margem do lado direito do Editor de Cdigo. Determina a distncia da margem direita, em caracteres. Exibe ou no a faixa cinza na parte esquerda do Editor de Cdigo. Determina a largura da faixa cinza, em caracteres. A fonte usada no Editor. As fontes que voc pode escolher esto restritas a somente fontes monoespaadas fontes nas quais todos os caracteres ocupam a mesma largura. Size o tamanho da fonte, em pontos.
Zoom to full screen
Visible right margin Right Margin Visible Gutter Gutter Width Editor Font / Size
8.12. Opes importantes da pgina Colors

Na pgina Colors, voc define as cores usadas para o efeito de Syntax highlighting. o efeito de Syntax Highlighting que faz a palavras mudarem de cor ou de estilo durante a digitao do cdigo. Este efeito altera as cores de elementos de programas, dependendo da funo ou significado desses elementos (exemplos de elementos so comentrios, palavraschave, constantes, variveis, etc.). Cada elemento pode ser mostrado com duas cores: a cor de frente (Foreground) e a cor de fundo (Background). Voc pode tambm escolher entre vrios padres de cores predefinidos.
109
110
Configurao do Editor de Cdigo: pgina Colors Para alterar as opes de Syntax Highlighting para um elemento:
1. Na lista "Element", escolha o elemento para o qual deseja alterar a cor. Por exemplo, para alterar a cor dos comentrios, escolha o elemento "Comments" na lista. 1. Na paleta de cores, para alterar a cor de frente, clique com na cor com o boto esquerdo (aparecem as letras "FG" dentro do quadrado de cor correspondente); para alterar a cor de fundo, clique com o boto direito (aparecem as letras "BG" dentro do quadrado de cor). Veja um exemplo na seguinte figura:
Para desfazer uma mudana de cor, escolha uma das opes Foreground ou Background, na rea "Use defaults for". Isso faz com que o elemento selecionado volte para a cor normal.
110
111
2. Caso necessrio, defina atributos (Negrito, Itlico, ou Sublinhado) para o texto do elemento, em "Text attributes". As mudanas que voc faz para cada elemento so mostradas em um exemplo de programa, na parte de baixo da caixa de dilogo.
8.13. Usando os recursos Code Insight

Os recursos Code Insight facilitam muito a preparao de programas no Delphi. H trs muito teis: Code Completion, Code Parameters e Code Templates. 8.13.1. Code Completion Esse recurso mostra, durante a digitao do cdigo, uma lista de propriedades, precedures e functions. A lista exibida depende do que est sendo digitado no momento. No exemplo abaixo, a palavra "Application" acaba de ser digitada, seguida de um ponto:
Assim que o ponto digitado, o Delphi verifica o tipo de objeto digitado e exibe a lista automaticamente (depois de alguns momentos). Pode-se tambm pressionar CTRL + Barra de Espaos para mostrar a lista imediatamente. Voc pode escolher um item da lista com o teclado ou o mouse, ou continuar digitando normalmente. (Na figura acima, a procedure CreateForm foi escolhida). Com isso, o Delphi insere o item escolhido depois do ponto e fecha a lista de opes. 8.13.2. Code Parameters O recurso de Code Parameters ("Parmetros do Cdigo") mostra a posio e os tipos de parmetros definidos para uma procedure ou function (que tenha parmetros!). As informaes sobre os parmetros so exibidos em uma pequena caixa amarela, abaixo da linha que est sendo digitada (veja a figura abaixo).
111
112
As informaes continuam sendo exibidas at que os parnteses da procedure/function sejam fechados. Alm disso, enquanto os parmetros so digitados, o Delphi reala (em negrito) o parmetro atual. Veja um exemplo na figura a seguir, com o primeiro parmetro j digitado:
8.13.3. Code Templates Os Code Templates ("Modelos de Cdigo") so "esqueletos" de comandos comuns que podem ser inseridos no cdigo rapidamente, atravs da digitao de uma palavra ou cdigo. O Delphi j define vrios Code Templates para trechos comuns de programas, como estruturas if-then-else, declaraes de arrays, etc. Para inserir um code template, digite o seu nome e pressione CTRL + J. O Delphi insere o template e move o cursor automaticamente para a posio onde se deve comear a digitar (veja as figuras a seguir).
112
113
Digite o nome do template e pressione CTRL+J
o cdigo inserido e o cursor colocado na posio apropriada.
Veja a seguir alguns exemplos de code templates predefinidos do Delphi (as barras verticais no cdigo indicam a posio onde colocado o cursor, quando o code template inserido). Este nome cases substitudo por
Este nome
whileb
while | do begin end;
substitudo por
case | of :; :; end;
forb
for | := to do begin end;
fors
for | := to do
function
function |(): ; begin end;
ife
if | then begin end else
procedure
procedure |(); begin end;
trye
try | except end;
113
114
8.14. Configurando os recursos do Code Insight

possvel desativar ou ativar cada um dos recursos do Code Insight, ou alterar opes gerais para esses recursos. Para isso, escolha o comando Tools | Evironment Options e mude para pgina Code Insight, ilustrada a seguir:
Pode-se ativar ou desativar cada recurso Code Insight na parte de cima da caixa, alm de alterar o tempo de espera para que os recursos sejam ativados durante a digitao. Para alterar o tempo de espera, mova a pequena barra abaixo de "Delay". Pode-se tambm definir novos Code Templates ou alterar os j existentes. Os procedimentos abaixo devem ser realizados a partir da pgina Code Insight ilustrada anteriormente. Para definir um novo Code Template:
1. Clique no boto Add. Na caixa que aparece, digite um nome para o code template e uma descrio para ele:
1. Clique em OK para fechar a caixa de dilogo e digite o cdigo para o code template na rea de baixo (ao lado de "Code"). Digite uma barra vertical ( | ) para indicar a posio
114
115
onde o cursor deve ser colocado quando o cdigo inserido. (Veja um exemplo na figura a seguir).
2. Clique em OK para salvar o code template. Agora voc pode us-lo da mesma forma que os code templates predefinidos. Para alterar um code template: Selecione o nome do code template na lista de code templates e altere o cdigo na parte de baixo da caixa (ao lado de "Code"). Para apagar um template: Selecione o nome do code template e clique no boto Delete.
115
116
CAPTULO 09 - O DEPURADOR INTEGRADO

O Depurador Integrado (Integrated Debugger) do Delphi uma ferramenta que facilita a verificao e a correo dos erros em seus programas. Com o depurador, voc pode, por exemplo, executar programas passo-a-passo e verificar o valor de variveis e expresses durante a execuo.
9.1.
Erros e tipos de erros
H dois tipos de erros bsicos que podem ocorrer (e quase sempre ocorrem) durante o desenvolvimento de um aplicativo: erros de compilao e erros de execuo. Os erros de compilao aparecem durante a compilao do aplicativo no Delphi. Os erros de compilao so geralmente causados por erros de sintaxe, ou erros de tipos. Esses erros, geralmente so os mais fceis (ou menos difceis) de corrigir. Muitas vezes esses erros so causados por simples erros de digitao. Um erro de compilao fcil de corrigir porque o compilador mostra exatamente a linha em que o erro ocorreu e s vezes at sugere uma maneira de corrigi-lo. Os erros de execuo ocorrem durante a execuo do aplicativo. Estes so bem mais difceis de corrigir. Como os aplicativos do Delphi so compilados, o cdigo que executado convertido antes em cdigo binrio. O cdigo binrio puro no guarda ligao direta com as linhas do cdigo fonte (o cdigo nas Units) o cdigo binrio s reconhece posies de memria. Por isso, quando ocorre um erro em tempo de execuo, no mostrada a linha onde ocorreu o erro, mas sim a posio de memria (um nmero em hexadecimal!) Veja um exemplo de uma mensagem de erro de execuo:
A mensagem ilustrada foi causada por um erro comum: tentar mostrar um formulrio que ainda no foi criado em memria. Mas outras mensagens de erros de execuo tm geralmente o mesmo formato. A mensagem comea com o nome do arquivo executvel onde ocorreu o erro, o nome da exceo que foi levantada, e as posies de memria onde os erros aconteceram. A no ser para os programadores do tipo "escovador de bits", esse tipo de mensagem no ajuda muito a identificar o erro. Mesmo que se reconhea o tipo de erro que aconteceu (a partir do nome da exceo), no h como saber diretamente onde o erro ocorreu no programa. nesse ponto que entra o Depurador Integrado do Delphi.
9.2.
Utilidades do Depurador
Quando voc executa um aplicativo no Delphi, ele executado automaticamente dentro do depurador. Quando ocorre um erro de execuo no aplicativo, o depurador interrompe o
116
117
programa e assume o controle. O depurador consegue "assumir o controle" mesmo se houver um erro grave (como um erro de hardware). Nesse caso extremo, o depurador no pode ajudar muito, mas ele pelo menos evita que os erros travem o computador ou o coloquem em um estado instvel. O depurador mais til, entretanto, quando os erros so causados pelo prprio cdigo do aplicativo e no por razes externas. Quando h erros de lgica em seus programas, por exemplo, o Depurador (alm da sua experincia) a sua nica ajuda para detect-los. NOTA: Erros de lgica so problemas na estrutura ou lgica de um programa que fazem com que o programa no execute como esperado. Um erro de lgica comum , por exemplo, usar uma condio incorreta em um loop while o repeat: o programa pode ficar preso dentro do loop para sempre. Erros de lgica, claramente, no podem ser indicados pelo compilador.
9.3.
Executando um programa at a posio do cursor
No Editor de Cdigo, voc pode posicionar o cursor em qualquer linha de um programa e executar o programa at aquela linha. Esse recurso especialmente til para programas extensos. Voc pode executar rapidamente uma parte do programa para depois se concentrar na parte "suspeita", que contm os erros. Para executar um programa at a posio do cursor:
1. No Editor de Cdigo, posicione o cursor na linha at onde o programa deve ser executado. 1. Realize uma das aes a seguir: Escolha o comando Run | Run to Cursor Clique com o boto direito no Editor de Cdigo e escolha o comando Debug e depois Run to Cursor. Pressione F4 O Delphi executa normalmente todas as linhas do programa at a linha anterior linha do cursor. Depois o depurador interrompe a execuo e assume o controle, realando a prxima linha a ser executada (a linha do cursor). A prxima linha a ser executada chamada ponto de execuo. O ponto de execuo realado em azul, no Editor de Cdigo. exibida tambm uma pequena seta do lado esquerdo da linha. A ilustrao abaixo mostra o ponto de execuo logo depois de um programa ser executado com o comando Run to cursor.
117
118
NOTA: voc pode mostrar o ponto de execuo no Editor de Cdigo, se ele no estiver aparecendo por alguma razo, usando o comando Run | Show execution point.
9.4.
Executando um programa linha por linha
Um programa pode ser executado linha por linha no Delphi, para que se possa, por exemplo, entender a execuo em detalhe, ou verificar precisamente onde os erros esto acontecendo. O depurador do Delphi oferece dois comandos para executar um programa linha por linha: Trace Into e Step Over.
9.5.
O comando Trace Into
O comando Trace Into executa uma linha de um programa de cada vez. Se a linha a ser executada for uma chamada a uma rotina (function ou procedure), o cdigo da rotina executado tambm, linha por linha. Em outras palavras, o comando Trace Into, "entra" nas procedures e functions. Para usar o comando Trace Into, realize uma das seguintes operaes: Escolha o comando Run | Trace Into Pressione F7 Clique no boto Trace Into na barra de ferramentas (figura a seguir).
O boto Trace Into
9.6.
O comando Step Over
O comando Step Over tambm executa os comandos de um programa, uma linha de cada vez. Mas, ao contrrio do comando Trace Into, ele no "entra" no cdigo das procedures e
118
119
functions. Estas so executadas diretamente, em um nico passo, e o ponto de execuo movido para a linha depois da chamada funo. Voc pode usar o comando Step Over para "pular" o cdigo de uma funo que no precisa ter seu cdigo testado linha por linha. Isso pode tornar a depurao muito mais rpida. Para usar o comando Trace Into, realize uma das seguintes operaes: Escolha o comando Run | Step Over Pressione F8 Clique no boto Step over na barra de ferramentas (veja a figura).
9.7.
Usando os dois comandos
Para programas complexos, voc geralmente vai precisar usar os dois comandos, Trace Into e Step Over, alternadamente. Se, durante a depurao, voc achar necessrio "entrar" no cdigo de uma procedure ou function, use o comando Trace Into. Para pular o cdigo da procedure ou function, executando-a rapidamente use o comando Step Over. Voc pode usar um comando ou o outro na ordem que desejar.
9.8.
Interrompendo a execuo
Muitas vezes durante a depurao, necessrio interromper a execuo do aplicativo. Isso pode ser necessrio, por exemplo, quando se passa do erro que estava sendo procurado, ou quando o programa fica em uma situao instvel, por conta de uma alguma exceo que ocorreu. Para interromper o programa que est sendo executado: Escolha o comando Run | Program reset, ou Pressione CTRL+F2
Na verdade, o comando Program reset faz mais que interromper o programa. Ele extremamente poderoso e pode ser usado para lhe tirar das situaes mais difceis. Se o programa travar, devido a um erro de hardware, por exemplo, o comando Program reset consegue "matar" o programa e fazer tudo voltar ao normal. So muito raros os casos em que um erro em um programa faz o prprio Delphi travar irreversivelmente. O comando Program reset fecha todos os arquivos abertos pelo seu programa, libera todos os recursos que estejam sendo usados e limpa o valor de todas as variveis.
9.9.
Usando Breakpoints
Voc usa breakpoints ("pontos de parada") para que o depurador pare em pontos especficos de um programa. Vrios breakpoints podem ser definidos no mesmo programa. Com isso, voc pode fazer a execuo parar em partes "delicadas" ou complexas de um programa e depois executar essas partes linha por linha.
119
120
9.10. Definindo breakpoints

Os breakpoints ("pontos de parada") permitem forar a parada da execuo em linhas especficas de um programa. Pode-se definir breakpoints para vrias linhas de um mesmo programa, desde que estas sejam linhas executveis (no se pode definir breakpoints para linhas de comentrios, por exemplo). Veja como definir um breakpoint: Para definir um breakpoint em uma linha de cdigo: Clique na faixa cinza do Editor de Cdigo, ao lado da linha, ou Mova o cursor para a linha de cdigo e pressione F5. A linha realada em vermelho e aparece um pequeno crculo do lado esquerdo da linha (veja a figura).
Breakpoints definidos no Editor de Cdigo Quando encontra um breakpoint, o Delphi pra imediatamente o programa e mostra a linha onde parou a linha do breakpoint no Editor de Cdigo. Pode-se ento continuar executando o programa passo-a-passo, com F7 ou F8, ou continuar a execuo at o final do programa (ou at o prximo breakpoint), usando F9.
9.11. Mostrando os breakpoints definidos

Durante a depurao de um programa extenso, o nmero de breakpoints definidos pode crescer muito. Para facilitar o trabalho com breakpoints, voc pode mostrar uma janela com a lista de todos os breakpoints definidos. Para mostrar todos os breakpoints definidos em um aplicativo: Escolha o comando View | Debug Windows > Breakpoints.
120
121
A janela exibe o nome do arquivo que contm cada breakpoint, o nmero da linha do breakpoint e outras informaes mais avanadas. A partir desta janela, voc pode pular diretamente para qualquer breakpoint definido, clicando duas vezes no nome do breakpoint. Voc pode tambm desativar um breakpoint temporariamente, ou apag-lo de forma permanente. Voc pode tambm apagar todos os breakpoints de uma vez. Note, no entanto, que um breakpoint desativado pode ser reativado, mas que no possvel voltar atrs depois de apagar um breakpoint. Para desativar/reativar um breakpoint: No Editor de Cdigo, clique com o boto direito do lado esquerdo do breakpoint e escolha o comando Enabled. Para apagar um breakpoint: No Editor de Cdigo, clique no breakpoint e pressione F5, ou Clique do lado esquerdo do breakpoint (na faixa cinza do Editor de Cdigo). Para apagar/desativar/ativar todos os breakpoints:
Abra a lista de breakpoints (View | Debug Windows > Breakpoints) e clique com o boto direito dentro da janela exibida, mas fora da lista de breakpoints (veja a figura a seguir).
Escolha o comando Delete All para apagar todos os breakpoints, ou Disable All para desativar todos os breakpoints, ou Enable All para ativar todos os breakpoints.
9.12. Verificando variveis e expresses

A execuo linha por linha de um programa pode no ser suficiente para descobrir a causa de um erro. s vezes necessrio verificar o valor de variveis ou expresses durante a execuo do programa. O Delphi oferece vrios recursos para realizar essas tarefas.
9.13. Trabalhando com Watches

Watches ("sentinelas") so usados para monitorar os valores de uma varivel ou expresso, durante a execuo de um aplicativo no Delphi. Os watches definidos so atualizados automaticamente durante a execuo.
121
122
Para definir um watch:
1. No Editor de Cdigo, selecione a varivel ou expresso cujo valor deseja monitorar (este ser o watch). 1. Clique com o boto direito em cima do trecho selecionado e escolha o comando Debug > Add Watch at Cursor no menu de atalho que aparece. O Delphi cria o watch e mostra a lista de watches definidos:
Para visualizar a lista de watches definidos: Escolha o comando View | Watch. O Delphi exibe a janela Watch List (ilustrao anterior) com os nomes e os valores de cada watch.
9.14. Avaliando e modificando expresses

A caixa de dilogo Evaluate/Modify permite avaliar expresses e alterar variveis, durante a depurao. Para avaliar e modificar expresses:
1. Escolha o comando Run | Evaluate/ Modify 2. O Delphi mostra a seguinte caixa de dilogo:
1. Para avaliar uma expresso, digite a expresso a ser avaliada em "Expression". A expresso deve ser formada por constantes, ou por variveis acessveis no momento. Em seguida clique no boto OK. O valor da expresso mostrado em "Result".
122
123
2. Para modificar o valor de uma varivel durante a execuo, especifique o nome da varivel em "Expression", especifique um valor em "New value", e clique no boto Modify. No possvel modificar uma expresso com mais de uma varivel.
123
124
CAPTULO 10 - TRABALHANDO COM BANCOS DE DADOS NO DELPHI: UMA VISO GERAL

O Delphi oferece recursos poderosos para a criao de aplicativos com acesso a bancos de dados. Aplicativos criados no Delphi podem ter acesso a dezenas de tipos de bancos de dados, locais ou remotos. Para os bancos de dados mais populares, como Oracle, Sybase, DB2, Access, etc., o Delphi oferece acesso nativo. Toda a comunicao entre o Delphi e esses SGBDs feita internamente no ambiente do Delphi. O acesso nativo geralmente muito mais rpido. Para bancos de dados menos populares, o Delphi oferece acesso via ODBC (Open Database Connectivity). Praticamente todos os bancos de dados profissionais so compatveis com a tecnologia ODBC. Um banco de dados compatvel com ODBC oferece drivers ODBC que podem ser instalados no Windows. Com o driver ODBC correspondente instalado, um banco de dados pode ser acessado facilmente a partir do Delphi (o acesso bem mais lento que o acesso nativo, no entanto).
10.1. A arquitetura de acesso a bancos de dados

Todo o acesso a bancos de dados a partir de um aplicativo Delphi, sejam esses bancos remotos ou no, feito atravs do BDE (Borland Database Engine). O BDE uma interface padro que gerencia a parte tcnica por trs do acesso e manipulao de bancos de dados. Alm disso, o BDE uniformiza a comunicao entre o aplicativos e os bancos de dados podese usar os mesmos componentes e comandos para acessar um banco de dados Oracle, ou um banco Paradox, por exemplo. Os bancos locais, como Paradox e dBase so acessados diretamente pelo BDE. J os bancos remotos SQL, como Oracle e Sybase, precisam tambm do driver SQL Links, instalado automaticamente com o Delphi Client/Server. esse driver que garante a uniformizao do acesso a bancos de dados SQL, gerando consultas SQL automaticamente, no dialeto de SQL usado pelo banco. Com o driver SQL Links, possvel trabalhar com bancos SQL da mesma forma que com bancos locais.
124
125
A arquitetura de acesso a bancos de dados no Delphi
10.2. Componentes bsicos

H dezenas de componentes no Delphi para o trabalho com bancos de dados. So duas pginas da paletas de componentes exclusivamente dedicadas a bancos de dados: as pginas Data Access e Data Controls.
10.3. A Pgina Data Access

A pgina Data Access contm os componentes usados para realizar a conexo aos bancos de dados e acessar suas informaes. Os componentes mais importantes, e de longe os mais usados, so os trs primeiros: DataSource, Table e Query.
A pgina Data Access H tambm vrios outros componentes avanados usados, por exemplo, para a criao de aplicativos cliente/servidor. Esses componentes so vistos no curso de Delphi avanado. Veja a seguir uma descrio breve dos componentes mais importantes da pgina Data Access (para os fins desse curso bsico).
125
126
Componente
Descrio Funciona como um intermedirio entre os componentes os componentes Table e Query e os componentes da paleta Data Controls. Usado para realizar o acesso a tabelas de um banco de dados.
DataSource
Table Usado para realizar o acesso a tabelas geradas por consultas SQL (queries). Usado para mover grandes quantidades de dados de uma tabela para outra, para copiar tabelas inteiras, ou para converter tabelas de um tipo para outro.
Query
BatchMove
10.4. A pgina Data Controls

A pgina Data Controls contm componentes que podem ser ligados diretamente a campos e tabelas de um banco de dados. Muitos desses componentes so apenas verses mais poderosas dos componentes na pgina Standard.
A pgina Data Controls Os componentes DBEdit e DBMemo, por exemplo so equivalentes aos componentes Edit e Memo, mas com o recurso adicional de acesso a bancos de dados. Veja a seguir uma descrio breve dos componentes mais importantes da pgina Data Controls. Componente Descrio Exibe dados em formato de tabela. Este componente usado geralmente para exibir os dados de um componente Table ou Query. Usado para navegar os registros de uma tabela, permitindo que dados sejam apagados, inseridos ou alterados. Exibe o texto de um campo de forma no-editvel. Semelhante a um componente Label. Exibe o texto de um campo e permite edit-lo. Semelhante a um componente Edit. Exibe o texto de um campo com vrias linhas de texto (do tipo "BLOB" ou "Memo"). Semelhante a um componente Memo. Exibe imagens armazenadas em um campo do tipo BLOB, ou "Image".
DBGrid
DBNavigator
DBText
DBEdit
DBMemo
DBImage
126
127
DBListBox
Exibe uma lista de itens a partir da qual, pode ser escolhido um valor para um campo. Semelhante ao componente ListBox. Semelhante ao componente DBListBox, mas permite a digitao direta de um valor, alm da escolha de um item listado. Semelhante ao componente ComboBox. Exibe um CheckBox que pode ser usado para exibir ou alterar o valor de um campo booleano. Exibe um conjunto de valores mutuamente exclusivos para um campo. Exibe uma lista de itens extrada de outra tabela relacionada. Somente elementos da lista podem ser escolhidos. Tem a mesma aparncia e o mesmo funcionamento bsico do componente ListBox. Exibe uma lista de itens extrada de outra tabela relacionada. Pode-se digitar um valor diretamente. Tem a mesma aparncia e o mesmo funcionamento bsico do componente ComboBox.
DBComboBox
DBCheckBox
DBRadioGroup
DBLookupListBox
DBLookUpComboBox
10.5. Acessando bancos de dados: uma introduo

O acesso a bancos de dados a partir de um aplicativo no Delphi baseado em trs componentes bsicos: DataSource, Table e Query. Os trs so componentes no-visuais. Eles no so exibidos durante a execuo. Apenas controlam a conexo com o banco de dados e o processamento dos dados. A conexo com um banco de dados geralmente feita atravs de um componente Table ou Query. Esses componentes so tipos de DataSets. Os DataSets so conjuntos de dados armazenados em formato de tabela (em linhas e colunas). Veremos mais sobre DataSets no prximo captulo. Ambos os componentes Table e Query tm as propriedades DatabaseName, que indica o banco de dados associado ao componente. Um componente Table ligado a uma tabela de um banco de dados atravs de sua propriedade TableName. Um componente Query contm o texto de uma query em SQL. Essa query pode ser executada, gerando uma nova tabela de dados (temporria) como resultado. O componente DataSource usado como um intermedirio obrigatrio entre os componentes Data Controls em um formulrio, e os dados de um componente Table ou Query. A propriedade DataSet de um componente DataSource usada para realizar a ligao entre os componentes. A maioria dos componentes da pgina Data Controls apresenta a propriedade DataSource, onde especificado o componente DataSource a ser conectado ao componente. Os dados exibidos nos componentes Data Controls so lidos a partir do componente DataSource especificado.
10.6. Um exemplo tpico

Veremos agora como criar um formulrio bsico com acesso a bancos de dados. No exemplo, usaremos um componente Table para realizar a conexo com uma tabela de um banco de
127
128
dados. Os dados sero exibidos em um componente DBGrid. (O componente DBGrid mostra os dados em um DataSet em formato de tabela). Para criar um formulrio simples com acesso a dados:
1. Em um novo formulrio, adicione um componente Table e um componente DataSource, ambos localizados na pgina Data Access da paleta de componentes do Delphi. 2. Adicione tambm um componente DBGrid, da pgina Data Controls. 3. Altere a propriedade DatabaseName do componente Table para o nome do banco de dados a ser acessado. Altere tambm a propriedade TableName para a tabela do banco de dados cujos dados voc deseja exibir. (No nosso exemplo, escolhemos o banco de dados DBDEMOS e a tabela Country, que contm informaes sobre os pases do continente americano.) 4. Altere a propriedade DataSet do componente DataSource para o nome do componente Table ("Table1" o nome padro). 5. Altere a propriedade DataSource do componente DBGrid para o nome do componente DataSource ("DataSource1" o nome padro). 6. Para visualizar os dados imediatamente no componente DBGrid, altere a propriedade Active do componente Table para True. Veja a aparncia final do formulrio, no exemplo:
10.7. Usando o DataBase Desktop

O DataBase Desktop um aplicativo independente que instalado junto com o Delphi. Ele pode ser acessado diretamente, atravs do menu Iniciar, ou mesmo de dentro do Delphi. Com o Database Desktop voc pode criar tabelas de bancos de dados do tipo Paradox/dBASE. Essas tabelas so muito teis para a criao de aplicativos com bancos de dados pequenos ou mdios, usados por um ou poucos computadores. Outra funo importante do DataBase Desktop a definio de "Aliases". Para entrar no Database Desktop, realize uma das seguintes operaes: De fora do Delphi, clique no boto Iniciar e escolha Programas > Borland Delphi 4 > DataBase Desktop. De dentro do Delphi, escolha o comando Tools | DataBase Desktop.
128
129
10.8. Definindo um Alias

Antes de definir as tabelas de um banco de dados, voc deve definir o local onde os arquivos do banco de dados sero armazenados. Esse local identificado por um nome, chamado Alias. Os Aliases so usados dentro do Delphi como um tipo de "apelido" para um banco de dados. Definir um Alias oferece vrias vantagens: No necessrio digitar o caminho completo (drive e diretrio) do banco de dados. Basta digitar o nome do Alias. Pode-se alterar o diretrio associado a uma Alias sem a necessidade de alterar o cdigo do aplicativo. Com a mudana, todos os componentes que se referem ao Alias passam a apontar para o novo diretrio. Por exemplo, voc pode usar um diretrio temporrio (digamos, C:\DADOS) para armazenar suas tabelas durante o desenvolvimento e usar outro diretrio quando o aplicativo instalado no computador do cliente (digamos, D:\SISTEMA\DADOS). Se um Alias tiver sido definido na hora do desenvolvimento, basta alterar o diretrio do Alias na hora da instalao. O cdigo do aplicativo no precisa ser alterado (nem recompilado). Para criar um Alias:
1. Escolha o comando Tools | Alias Manager. O DataBase Desktop exibe a seguinte caixa:
1. Clique no boto New e digite um nome para o Alias, em "Database Alias". Em "Driver Type", escolha o tipo do Driver. O tipo do driver geralmente identificado pelo nome do banco de dados (como Oracle, Access, Informix, etc). O tipo Standard o tipo padro. Ele usado para acessar bancos Paradox e dBase.
129
130
Quando voc escolhe um tipo diferente de Standard, novos campos aparecem na caixa de dilogo. A maioria desse campos tm valores padro que podem ser usados como esto. Algumas vezes, entretanto, necessrio alterar os valores desses novos campos. Consulte a documentao do banco de dados que voc est usando (ou o Help do Delphi) para verificar quais mudanas so necessrias. 2. Na rea "Path" digite o diretrio para o Alias. O diretrio deve ser um diretrio existente (crie um novo diretrio antes de criar o Alias, caso necessrio). 3. Clique em OK para confirmar a criao do Alias. (Ou clique no boto Keep New para continuar criando outros Aliases). exibida a seguinte caixa de dilogo de confirmao:
Os novos Alias (pblicos) criados so armazenados no arquivo IDAPI32.CFG, no local indicado na caixa. A caixa de dilogo apenas confirma essa operao. Na maioria dos casos, basta clicar no boto Sim para confirmar. Depois de criar um Alias, ele se torna disponvel nas propriedades DatabaseName de vrios componentes, tais como Table, Query e Database. Para alterar um Alias:
1. Escolha o comando Tools | Alias Manager. 1. Na parte de cima da caixa, escolha o Alias a ser alterado (figura abaixo).
130
131
2. Faa as alteraes necessrias e clique em OK. 3. Na caixa de dilogo que aparece, confirme as alteraes clicando novamente em OK.
10.9. Alterando o diretrio de trabalho

recomendvel definir um diretrio de trabalho (working directory) durante o trabalho com o DataBase Desktop. Todos os arquivos criados no DataBase Desktop (como tabelas e ndices) so armazenados nesse diretrio de trabalho. O diretrio de trabalho deve ser, geralmente, o Alias do banco de dados com que se est trabalhando no momento. Para alterar o diretrio de trabalho:
1. Escolha o comando File | Working directory.
1. Na caixa de dilogo exibida, digite um caminho completo, ou escolha um Alias na parte de baixo da caixa.
10.10.
Criando tabelas
O DataBase Desktop permite que sejam criadas tabelas de vrios tipos de bancos de dados. Voc cria uma tabela primeiro definindo a sua estrutura. A estrutura de uma tabela , basicamente, o nome, o tamanho e o tipo de cada campo da tabela. Para criar uma tabela:
1. Escolha o comando File | New > Table. A seguinte caixa de dilogo exibida:
131
132
1. Escolha o tipo da tabela e clique em OK para comear a definir a estrutura. Os prximos passos assumem que foi escolhido o tipo de tabela Paradox 7 (o tipo mais comum de tabela definido com o DataBase Desktop). 2. H quatro colunas que devem ser preenchidas. Preencha cada coluna como descrito a seguir: Field Name: o nome do campo. Type: o tipo do campo (se inteiro, monetrio, booleano, etc.) Pressione a barra de espaos com o cursor nessa coluna e escolha um tipo com as setas, ou com o mouse. Size: o tamanho do campo (em dgitos ou caracteres). O tamanho deve ser um valor entre 1 e 255. Essa coluna no pode ser alterada para alguns tipos (ela fica vazia, nesses casos). Key: um asterisco (*) nessa coluna determina se o campo ou no uma chave. Pressione a barra de espaos para mostrar ou esconder o asterisco. Vrios campos podem ser chaves ao mesmo tempo (formando uma chave composta). Use as setas do teclado, TAB ou ENTER para mover o cursor (quando possvel), ou use o mouse.
Definindo a estrutura de uma tabela
132
133
4. Depois de definir o tipo e o tamanho de cada campo, clique no boto Save As para salvar a nova tabela no disco. mostrada um caixa do tipo "Salvar como" onde voc deve digitar o nome do arquivo a ser salvo. A tabela salva no diretrio de trabalho (veja a seo anterior).
10.11.
Adicionando dados a uma tabela
Uma vez criadas as tabelas de um banco de dados, voc pode preench-las com dados dentro do prprio Database Desktop. (Esse recurso geralmente usado somente para adicionar alguns dados de amostra, pois os dados so normalmente adicionados a partir dos aplicativos). Para adicionar dados a uma tabela (ou alterar dados):
1. Escolha o comando File | Open > Table. 1. Na caixa que aparece, escolha a tabela a ser alterada. Os arquivos exibidos na caixa so os do diretrio de trabalho. Escolha um Alias na parte de baixo para mostrar arquivos de outro diretrio. 2. A tabela aberta e exibida em uma janela. Se a tabela contiver dados, estes so exibidos tambm. (Na figura a seguir, mostrada uma pequena tabela no Database Desktop, com trs campos e alguns dados j digitados).
3. Quando a tabela exibida, seus dados so inicialmente protegidos contra alteraes. Para fazer alteraes ou adicionar novos dados, escolha o comando Table | View Data, ou pressione F9.
133
134
4. Faa as alteraes ou digite novos dados normalmente. Use o mouse, a tecla TAB, ou as setas do teclado para mover o cursor e depois digite os valores desejados. 5. As alteraes so salvas automaticamente a cada registro (linha da tabela) digitado. Para terminar a edio dos dados, simplesmente feche a janela onde exibida a tabela.
10.12.
Alterando a estrutura de uma tabela
Algumas vezes, necessrio adicionar campos ou retirar campos de uma tabela, alterando sua estrutura. Voc pode fazer isso facilmente no DataBase Desktop. Para alterar a estrutura de uma tabela:
1. Se a tabela no estiver aberta, use o comando File | Open > Table para abri-la. 1. Escolha o comando Table | Restructure. A caixa de dilogo com a estrutura da tabela exibida (figura a seguir).
2. Pode-se adicionar ou retirar campos da tabela, ou alterar o nome, o tamanho ou o tipo de campos j existentes. Pode haver perdas nesse processo. Veja o que pode acontecer: Se um campo for retirado, todos os dados contidos naqueles campos so apagados permanentemente. Se o tamanho de um campo for reduzido, valores com comprimento maior que o novo tamanho sero cortados. Clique no boto Save para salvar as alteraes. Se houver algum perigo de perdas de dados, exibida um caixa de aviso como a seguinte:
134
135
1. A caixa ilustrada pode ser exibida vrias vezes, uma vez para cada campo com problemas. Geralmente, basta clicar em OK para confirmar as alteraes na estrutura da tabela.
135
136
CAPTULO 11 - TRABALHANDO COM DATASETS

Um DataSet um conjunto de dados organizado em forma de tabela (em linhas e colunas). As colunas so os campos e as linhas so os registros. Todo o acesso a bancos de dados no Delphi feito atravs de DataSets. Os componentes Table e Query so os tipos principais de DataSets. Neste captulo, veremos as propriedades, eventos e mtodos dos DataSets. Tudo que veremos aqui vale para os componentes Table e Query.
11.1. Abrindo e fechando DataSets

Para alterar ou ler os dados em uma DataSet, voc deve primeiro abrir o DataSet. Para abrir um DataSet, realize uma das seguintes operaes: Altere a propriedade Active do DataSet para True. Isso pode ser feito em tempo de desenvolvimento no Object Inspector, ou em tempo de execuo. O seguinte comando abre o componente chamado "Table1": Table1.Active := True; Use o mtodo Open no DataSet, como abaixo: Query1.Open; Quando um DataSet aberto os dados conectados a ele so lidos e exibidos automaticamente (se houver componentes onde os dados possam ser exibidos, claro). No exemplo do captulo anterior, abrimos um componente Table em um formulrio para que os dados fossem exibidos imediatamente em um componente DBGrid. Voc deve sempre fechar um DataSet depois de us-lo, para liberar recursos do sistema. Para fechar um DataSet, realize uma das seguintes operaes: Altere a propriedade Active do DataSet para False. Use o mtodo Close no DataSet, como em Table1.Close
11.2. Estados de um DataSet

Um DataSet pode estar em vrios estados diferentes. O estado de um DataSet determina o que pode ser feito (ou est sendo feito) com o DataSet. O valor da propriedade State de um DataSet determina o seu estado atual. Veja a seguir uma descrio breve dos estados mais importantes em que pode estar um DataSet. Estado (valor de State) dsInactive
Significado O Dataset est fechado. Seus dados no esto disponveis (no podem ser lidos nem alterados). O Dataset est aberto. Seus dados podem ser visualizados, mas no podem ser alterados. Este o estado padro de um DataSet.
dsBrowse
136
137
dsEdit dsInsert
O DataSet est aberto. O registro atual pode ser modificado. O DataSet est aberto. Um novo registro acaba de ser inserido.
O estado dsBrowse o estado padro. Quando um DataSet aberto, ele colocado automaticamente neste estado. Vrios mtodos de um DataSet podem ser usados para alterar o seu estado. Na ilustrao a seguir, so mostrados os quatro estados mais importantes e os mtodos que podem ser usados para passar de um estado para outro.
Estados de um DataSet Para usar um dos mtodos da ilustrao, simplesmente use o nome do DataSet seguido pelo nome do mtodo. O trecho de cdigo abaixo, por exemplo, altera cinco vezes o estado de um componente Table. procedure TForm1.Button1Click(Sender: TObject); begin Table1.Open; // O estado muda para dsBrowse ... Table1.Edit; //... muda para dsEdit... Table1.Insert; //... muda novamente para dsInsert ... Table1.Post; //... volta a dsBrowse ... Table1.Close; //... e finalmente muda para dsInactive end;
11.3. Navegando em um DataSet

Os DataSets teriam pouca utilidade se no fosse possvel percorrer e consultar (navegar) os seus registros. H vrios mtodos e propriedades teis para a navegao de DataSets.
137
138
Para permitir a navegao de seus registros, todo DataSet contm um cursor que indica o registro atual (ou linha atual) do DataSet. no registro atual que so feitas alteraes, ou onde so inseridos (ou removidos) registros. Todos os mtodos de navegao alteram a posio do cursor. Veja uma descrio breve desses mtodos na tabela a seguir: Mtodo First Last Next Descrio Move o cursor para o primeiro registro do DataSet. Move o cursor para o ltimo registro do DataSet. Move o cursor para o prximo registro do DataSet (imediatamente depois do registro atual). Se o cursor j estiver no ltimo registro, nada acontece. Move o cursor para o registro anterior do DataSet (imediatamente antes do registro atual). Se o cursor j estiver no primeiro registro, nada acontece. Move o cursor o nmero de registros especificado em num. Um valor positivo move o cursor para frente; um valor negativo move-o para trs. Por exemplo, Table1.moveBy(-10) move o cursor 10 registros para trs na tabela Table1. Se o nmero de registros especificado for maior do que o nmero que se pode mover, o cursor movido para o primeiro ou o ltimo registro, dependendo da direo do movimento. Alm dos mtodos descritos acima, h duas propriedades que indicam se o cursor chegou ao final ou ao incio de um DataSet: BOF e EOF. Propriedade BOF Descrio BOF alterado para True quando o cursor est no primeiro registro do DataSet. BOF a abreviao de Begin of File "Incio do Arquivo". Quando o cursor estiver em qualquer registro que no seja o primeiro do DataSet, o valor de BOF False. EOF EOF alterado para True quando o cursor est no ltimo registro do DataSet. EOF a abreviao de End of File "Final do Arquivo". Quando o cursor estiver em qualquer registro que no seja o ltimo do DataSet, o valor de EOF False. Veja a seguir dois exemplos que usam os mtodos e propriedades vistas acima. O primeiro exemplo percorre uma query "Query1" do primeiro registro at o ltimo, somando todos os valores no campo "Quantidade". FieldValues[NomeDoCampo] usado para obter o valor de cada campo. Uma mensagem com o valor total mostrada no final. procedure TForm1.Button1Click(Sender: TObject); var Total: Double;
Prior
MoveBy(num)
138
139
begin Query1.Open; {Abrir a Query}
Query1.First; {Mover para o primeiro registro}

Total := 0; while not (Query1.EOF) do begin Total := Total + Query1['Quantidade']; Query1.Next; {Mover para o prximo registro} end; ShowMessage('Quantidade total: '+ FloatToStr(Total)); Query1.Close {Fechar a Query} end; Este segundo exemplo percorre os registros do componente Table "Table1" do ltimo at o primeiro, calculando o valor total do estoque: a soma de todos os preos multiplicados pelas quantidades dos produtos. O exemplo semelhante ao anterior, a no ser pela ordem inversa e o uso de um componente Table em vez de um Query. Note que obviamente a ordem inversa no obrigatria. Ela foi usada somente para ilustrar BOF e os mtodos Last e Prior. procedure TForm1.Button2Click(Sender: TObject); var Valor: Currency; begin Table1.Last; {Mover para o ltimo registro} Valor := 0; while not (Table1.BOF) do begin Valor := Valor + Table1['Quantidade'] * Table1['Preco']; Table1.Prior; {Mover para o registro anterior} end; ShowMessage('Valor do estoque: '+ FloatToStr(Valor)); end;
139
140
11.4. Modificando Datasets

Pode-se alterar um DataSet diretamente, modificando valores campo a campo, ou adicionando e removendo registros inteiros. Os seguintes mtodos permitem fazer essas alteraes: Mtodo Edit Descrio Coloca o DataSet no estado dsEdit. Isto permite a alterao dos valores do registro atual. Muitos componentes chamam esse mtodo implicitamente para permitir a alterao direta dos valores de um DataSet. O componente DBGrid, por exemplo, entra no estado dsEdit usando o mtodo Edit, quando se d um duplo clique em um dos registros. Adiciona um registro vazio ao final do DataSet. O estado do DataSet muda para dsInsert. Adiciona um registro vazio na posio atual do cursor. O estado do DataSet muda para dsInsert (como para o mtodo Append). Tenta enviar o novo registro ou o registro alterado para o banco de dados. Se tudo correr bem, o DataSet colocado no estado dsBrowse. Caso contrrio, o estado do DataSet no alterado. O comando Post um tipo de confirmao da ltima entrada. Muitos componentes chamam Post automaticamente (quando se passa de um registro para outro em um DBGrid, por exemplo). Cancel Cancela a ltima operao (uma alterao em um registro, por exemplo) e coloca o DataSet no estado dsBrowse. Apaga o registro atual e coloca o DataSet no estado dsBrowse.
Append
Insert
Post
Delete
11.5. Modificando campos

O valor de um campo do registro atual de um DataSet pode ser alterado de vrias maneiras: Especificando o nome do campo diretamente: Tabela[Preco] := 54.43; Usando a propriedade FieldValues: Tabela.FieldValues[Preco] := 54.43; Usando o mtodo FieldByName e propriedades de converso: Tabela.FieldByName(Preco).AsCurrency := 54.43; Para que seja possvel alterar os valores dos campos, o DataSet deve estar no estado dsEdit ou dsInsert (use Edit, Insert ou Append para coloc-lo em um desses estados). Depois de realizar as alteraes, voc deve confirm-las, usando o mtodo Post. Veja um exemplo que usa FieldValues:
140
141
procedure TForm1.Button1Click(Sender: TObject); var NovaDesc: String; begin NovoNome := Edit1.Text; with TabProdutos do begin Edit; //Preparar para alterao FieldValues['Descricao'] := NovaDesc; Post; //Confirmar alterao end; end; No exemplo, o campo "Descricao" do registro atual do componente Table "TabProdutos" alterado para o valor digitado no componente Edit1. O mtodo Edit usado para colocar a tabela no estado dsEdit, antes de fazer a alterao. O mtodo Post, confirma a alterao, tornando-a permanente.
11.6. Adicionando registros

Os mtodos Insert e Append so usados para adicionar novos registros a um DataSet. Insert adiciona um registro vazio na posio atual do cursor; Append adiciona um registro vazio depois do ltimo registro do DataSet. Os dois mtodos colocam o DataSet no estado dsInsert. NOTA: Para tabelas indexadas do tipo Paradox e dBASE, os comandos Insert e Append tm o mesmo efeito. Eles adicionam um novo registro na posio determinada pelo ndice da tabela. O exemplo a seguir insere um novo registro depois do dcimo registro da tabela. Moveby(10) move o cursor 10 registros adiante; Insert insere o novo registro na posio do cursor. Em seguida, valores so definidos para os campos "Descricao", "Preco" e "Quantidade" e as alteraes so confirmadas com Post. procedure TForm1.Button1Click(Sender: TObject); begin with TabProdutos do begin
141
142
First; MoveBy(10); Insert; FieldByName(Codigo).AsInteger := 78; FieldByName(Descricao).AsString := Televiso ToNaBoa; FieldByName(Preco).AsCurrency := 754.00; FieldByName(Quantidade).AsInteger := 24; Post; end; end;
11.7. Apagando registros

Pode-se apagar registros inteiros rapidamente, com o mtodo Delete. Delete apaga o registro atual, sem confirmaes, e coloca o DataSet no estado dsBrowse. O registro imediatamente depois do registro apagado se torna o registro atual.
11.8. Confirmando e cancelando mudanas

Depois de inserir um registro, ou modificar os valores dos seus campos, voc pode usar o mtodo Post para tornar as mudanas permanentes, ou usar o comando Cancel para cancelar essas mudanas. Post chamado automaticamente, quando o cursor movido para outro registro, usando os mtodos First, Last, Prior, Next, ou MoveBy. Os mtodos Insert e Append tambm chamam o mtodo Post, tornando permanentes as mudanas que haviam sido feitas antes do registro ser adicionado. Durante a alterao de um registro, ou logo depois da insero de um novo registro, possvel desfazer alteraes recentes, usando o mtodo Cancel. Na maioria dos componentes Data Controls, o mtodo Cancel chamado automaticamente quando o usurio pressiona a tecla ESC, durante a edio de um campo. Quando o mtodo Cancel chamado, os valores dos campos do registro atual revertem para os valores antes da alterao. No caso em que um novo registro acabou de ser inserido, o mtodo Cancel remove o novo registro. O exemplo abaixo adiciona um novo registro a uma tabela com quatro campos (chamada "TabProdutos"). Os valores inseridos so lidos a partir de quatro Edits. As mudanas s tm efeito, entretanto, depois da confirmao do usurio (feita com a funo MessageDlg). Se o usurio confirmar a alterao, usado o mtodo Post para enviar os dados ao banco de dados; se no, o mtodo Cancel cancela todas as mudanas. procedure TForm1.Button1Click(Sender: TObject); var NovoCodigo: Integer;
142
143
NovaDescricao: String; NovoPreco: Currency; NovaQuant: Integer; begin // L os valores nos quatro Edits NovoCodigo := StrToInt(EditCodigo.Text); NovaDescricao := EditDescricao.Text; NovoPreco := StrToCurr(EditPreco.Text); NovaQuant := StrToInt(EditQuant.Text); with TabProdutos do begin Open; // Abre a tabela, colocando-a no estado dsBrowse Append; // Cria um novo registro no final (estado dsInsert) // Altera os valores de cada campo FieldValues['Codigo'] := NovoCodigo; FieldValues['Descricao'] := NovaDescricao; FieldValues['Preco'] := NovoPreco; FieldValues['Quantidade'] := NovaQuant; // Confirma as alteraes if MessageDlg('Confirma alterao?', mtConfirmation, mbYesNoCancel,0) = mrYes then Post else Cancel; end; end;
11.9. Inserindo e Modificando registros inteiros

H trs mtodos que permitem inserir ou alterar registros inteiros: InsertRecord, AppendRecord e SetFields.
143
144
Mtodo InsertRecord( [valor1, valor2, ...] )
Descrio Insere um novo registro, na posio atual do cursor, com os valores especificados. A lista de valores deve estar entre colchetes e os valores devem ser separados por vrgulas. Pode-se usar nil para especificar um valor nulo (vazio) para um ou mais campos. A ordem em que os valores so especificados deve ser a ordem dos campos no DataSet. Se o nmero de valores especificados for menor que o nmero de campos na tabela, o restante dos campos do novo registro so preenchidos com nil. O mtodo InsertRecord chama Post implicitamente no final.
AppendRecord( [valor1, valor2, ...] )
Idntico ao mtodo InsertRecord, mas o registro adicionado ao final do DataSet. Se o DataSet for uma tabela indexada, os mtodos AppendRecord e InsertRecord tm exatamente o mesmo efeito a posio do registro adicionado depende do ndice da tabela. O mtodo AppendRecord tambm chama Post implicitamente, tornando as alteraes permanentes. Altera os valores dos campos correspondentes do registro atual. O DataSet deve estar no estado dsEdit para que SetFields possa ser usado (use o mtodo Edit). Para alterar apenas alguns campos do registro atual, use nil como argumento para cada campo que no deseja alterar. O mtodo Post no chamado implicitamente por SetFields. Deve-se chamar Post depois do mtodo para tornar as alteraes permanentes.
SetFields( [valor1, valor2, ...] )
O exemplo a seguir usa o mtodo InsertRecord para inserir um novo registro na tabela TabProdutos (esta tabela tem os campos Codigo, Descricao, Preco e Quantidade). O exemplo altera somente os dois primeiros campos (usando os valores lidos) e o ltimo campo, assumindo uma quantidade fixa de 12 para este. Para o terceiro campo (o preo) especificado como nil. Isso deixa o campo vazio (ou inalterado). Em seguida, o programa pergunta se o campo Preco deve ser preenchido ou no. Caso positivo, usado o mtodo SetFields para alterar somente o preo do registro atual (note como nil usado para todos os outros campos). procedure TForm1.Button1Click(Sender: TObject); var NovoCodigo: Integer; NovaDescricao: String;
144
145
NovoPreco: Currency; begin NovoCodigo := StrToInt(EditCodigo.Text); NovaDescricao := EditDescricao.Text; with TabProdutos do begin Open; //Insere um novo registro InsertRecord([NovoCodigo, NovaDescricao, nil, 12]); // Confirma a entrada do preco if MessageDlg('Entrar com preo agora?', mtConfirmation, [mbYes, mbNo], 0) = mrYes then //Realiza a alteracao do preco (o campo estava vazio) begin NovoPreco := StrToCurr(InputBox('','Digite o preo','')); Edit; //Coloca o Table no estado dsEdit (essencial) SetFields([nil, nil, NovoPreco, nil]); //Altera o preco Post; //Confirma a alterao end; end; end;
11.10.
Localizando registros com Locate
O mtodo Locate maneira mais verstil e mais rpida de localizar registros em um DataSet. Como argumentos do mtodo Locate, voc especifica o nome dos campos a serem consultados, o valor desejado para cada campo especificado e um conjunto de opes de localizao (que pode ser vazio). Veja a seguir um exemplo de uma chamada ao mtodo Locate: TabClientes.Locate('Nome;Sobrenome', VarArrayOf(['Maria', 'S']),[loPartialKey]); O exemplo localiza o primeiro registro da tabela TabClientes, com nome "Maria" e sobrenome comeando com "S".
145
146
O primeiro parmetro de Locate uma lista de campos separados por ponto-e-vrgula, entre aspas simples. O segundo parmetro um array especial que deve ser construdo com o comando VarArrayOf (para o caso de uma pesquisa em mais de um campo). Os valores aqui devem "casar" com os campos especificados no primeiro parmetro. O terceiro parmetro especifica opes de procura. H duas opes de procura disponveis para o mtodo Locate: loPartialKey Permite que os valores de procura especificados no segundo parmetro sejam parciais (parte de um nome, por exemplo). Faz com que Locate ignore maisculas e minsculas. Com essa opo "maria", "Maria" e "MARIA" so considerados iguais, por exemplo.
loCaseInsensitive
Se houver algum registro que case com os valores especificados, o mtodo Locate retorna True e move o cursor para aquele registro. Se nenhum registro for encontrado, Locate retorna False. Se a localizao for baseada em apenas um campo, a sintaxe de Locate mais simples. Veja um exemplo, que localiza o cliente com cdigo igual a 100. TabClientes.Locate('Codigo', 100, []); Agora veja um exemplo que l os valores em dois componentes Edit ("EditNome" e "EditSobrenome") e localiza o primeiro registro que casa com esses valores, mostrando uma mensagem com o resultado da localizao.
procedure TForm1.Button1Click(Sender: TObject); var NomeProc, SobrenomeProc: String; //Valores procurados Achou: Boolean; //Resultado da pesquisa begin NomeProc := EditNome.Text; SobrenomeProc := EditSobrenome.Text; Achou := TabFunc.Locate('Nome;Sobrenome', VarArrayOf([NomeProc,SobrenomeProc]), [loPartialKey, loCaseInsensitive]); if Achou then ShowMessage('Registro encontrado.') else ShowMessage('Registro no encontrado.'); end;
11.11.
Filtrando DataSets
Algumas vezes necessrio exibir apenas um subconjunto dos registros de uma DataSet que atendam a alguma condio. Isso pode ser feito usando uma consulta SQL, ou aplicando um filtro. As consultas SQL so mais poderosas, mas tambm bem mais complexas. Elas sero vistas mais adiante. Os filtros so mais simples e podem ser aplicados diretamente a um componente Table, ou a um componente Query (e a outros DataSets).
146
147
Filtros podem ser definidos de duas maneiras: usando as propriedades Filter e Filtered, ou usando o evento OnFilterRecord.
11.12.
Usando Filter e Filtered
Para filtrar um DataSet, defina uma condio para a propriedade Filter e altere a propriedade Filtered para True. Isso pode ser feito em tempo de desenvolvimento ou em tempo de execuo. A condio na propriedade Filter deve especificar uma expresso lgica, com os nomes dos campos entre aspas simples. Veja alguns exemplos de condies: Estado = PE; Quantidade < 100; Resposta <> False (Salario > 10000) AND (Salario <= 50000) (Estado = RJ) OR (Estado = SP)
Se o DataSet estiver aberto (propriedade Active = True), a filtragem dos registros feita imediatamente, mesmo em tempo de desenvolvimento. Somente os registros para os quais a condio verdadeira so mostrados. Para componentes que acessam uma tabela filtrada, como se outros registros no existissem.
11.13.
Usando o evento OnFilterRecord
Usando o evento OnFilterRecord, voc pode definir filtros muito mais elaborados, usando os recursos da linguagem Object Pascal. O evento OnFilterRecord recebe o parmetro booleano Accept cujo valor, no final do cdigo do evento, determina se o registro ser exibido ("aceito") ou no. Uma referncia ao DataSet que est sendo filtrado tambm passada como parmetro. Para cada registro no DataSet, o evento OnFilterRecord chamado e o parmetro Accept verificado. Se Accept for True (o valor padro) o registro exibido; se Accept for False, o registro no exibido (ele filtrado). Veja um exemplo: procedure TForm1.TabProdutosFilterRecord(DataSet: TDataSet; var Accept: Boolean); begin if DataSet['Descricao'] >= 'M' then if DataSet['Preco'] * DataSet['Quantidade'] < 2000.00 then Accept := True; end;
11.14.
Eventos dos DataSets
Os DataSets oferecem vrios eventos que podem ser usados para verificar e validar mudanas antes de se tornarem permanentes. H eventos associados a todo os mtodos mais importantes, como Open, Close, Insert e Edit. Para a maioria desses mtodos h dois eventos:
147
148
um que ocorre antes de o mtodo ser chamado (prefixo "Before"), e outro que ocorre depois (prefixo "After"). Veja uma descrio breve de cada um desses eventos: Estes eventos... BeforeOpen, AfterOpen BeforeClose, AfterClose BeforeInsert, AfterInsert BeforeEdit, AfterEdit BeforeCancel, AfterCancel ...ocorrem: Antes e depois de o DataSet ser aberto. Antes e depois de o DataSet ser fechado. Antes e depois de o DataSet entrar no estado dsInsert. Antes e depois do DataSet entrar no estado dsEdit. Antes e depois do comando Cancel ser chamado (implicitamente ou explicitamente). Antes e depois de as mudanas em um DataSet serem enviados para o Banco de Dados (comando Post). Antes e depois de um registro ser apagado. Quando um novo registro adicionado. Usado geralmente para definir valores padro para alguns campos. Quando os campos calculados do DataSet so calculados.
BeforePost, AfterPost
BeforeDelete, AfterDelete OnNewRecord
OnCalcFields
11.15.
Controlando a atualizao de componentes
Componentes associados a dados de um banco de dados, como o DBGrid e a maioria dos outros componentes Data Controls, so atualizados automaticamente quando o cursor movido de um registro para outro. Muitas vezes, essa atualizao no desejada como, por exemplo, quando o programa faz uma pesquisa em uma tabela, ou faz atualizaes em vrios registros. A atualizao dos componentes pode ser desabilitada temporariamente usando o mtodo DisableControls e depois reabilitada com EnableControls. Geralmente, esses mtodos so usados em um bloco try-finally para que os componentes sejam reabilitados mesmo se ocorrer uma exceo no processamento do DataSet. Veja a seguir um exemplo que usa esse dois mtodos. O exemplo aumenta, em 8%, o salrio de todos os funcionrios cadastrados no Table "TabFuncionarios". Os componentes associados ao Table so desabilitados antes do processamento da tabela e so reabilitados no final, na parte finally, mesmo se houver excees durante o processamento.
procedure TForm1.Button1Click(Sender: TObject); begin with TabFuncionarios do begin try
148
149
Open; Edit; DisableControls; //Desabilitar atualizao while not EOF do begin FieldValues['Salario'] := FieldValues['Salario']*1.08; Next; end; finally EnableControls; //Habilitar atualizao end; end; end; H mais um mtodo relacionado atualizao de componentes: o mtodo Refresh. Esse mtodo fora a atualizao dos componentes, fazendo com que os dados sejam buscados novamente no banco de dados. Refresh til quando so feitas alteraes no registro atual por outro usurio, por exemplo. Uma chamada a Refresh garante que os dados exibidos so os mais atuais.
149
150
CAPTULO 12 - COMPONENTES DATASOURCE E TABLE

12.1. Usando o componente DataSource
O componente DataSource funciona como um "canal de comunicao" entre DataSets e os componentes DataControls. Todo DataSet (Table, Query, etc.) deve ser associado a um componente DataSource para que seus dados possam ser exibidos em componentes Data Controls.
12.2. Propriedades do componente DataSource

O componente DataSource um componente simples, com apenas cinco propriedades, duas das quais (Name e Tag) so comuns a todos os componentes do Delphi. Veja uma descrio das outras trs: Propriedade AutoEdit Descrio Determina se o DataSet ligado ao DataSource entra no estado dsEdit automaticamente quando o usurio clica no componente associado (um DBGrid, por exemplo). Lembre-se que um DataSet no estado dsEdit pode ter seus registros alterados. O padro para essa propriedade True. Se for especificado o valor False, o DataSet deve ser colocado no estado dsEdit explicitamente, usando o mtodo Edit, para que seja possvel fazer alteraes nele. DataSet Enabled Contm o nome do DataSet associado ao DataSource. Determina se o DataSource est ou no ativo (True = ativo). Quando Enabled = False (desativado) todos os componentes ligados ao DataSource aparecem vazios (no exibem dados).
12.3. Eventos do componente DataSource

H apenas trs eventos para o componente DataSource: Evento OnDataChange Descrio Este evento ocorre quando o cursor do DataSet movido para outro registro, depois de alteraes no DataSet. Isso acontece, por exemplo, quando os mtodos First, Last, Next ou Prior so chamados. Voc pode usar esse evento para sincronizar os dados exibidos com os dados de um banco de dados (no caso em que componentes comuns so usados para exibir dados, por exemplo). OnStateChange Este evento ocorre quando o estado do DataSet associado ao DataSource alterado. Ocorre imediatamente antes de uma atualizao no DataSet associado depois de um comando Post, mas antes dos dados serem realmente
OnUpdateData
150
151
atualizados. O evento ocorre mesmo se o comando Post for chamado implicitamente por outro comando ou outro componente.
12.4. Usando o componente Table

Um componente Table contm todas as informaes de uma tabela de um banco de dados. Vimos anteriormente que um componente Table um DataSet, portanto j conhecemos vrios mtodos e propriedades desse componente. Na verdade, por ser o tipo de DataSet mais comum, o componente Table foi o componente usado na maioria dos exemplos do captulo anterior. Neste captulo veremos mais detalhes sobre algumas propriedades e mtodos j conhecidos. Veremos tambm como usar vrios recursos que so exclusivos dos componentes Table.
12.5. Conectando-se a uma tabela de banco de dados

No captulo "Trabalhando com bancos de dados no Delphi: uma viso geral", vimos um exemplo completo onde conectamos uma componente Table a um banco de dados e exibimos o seu contedo em um componente DBGrid. Veja aquele captulo para um descrio passo-apasso sobre como realizar a conexo com um banco de dados. O procedimento para a conexo precisa alterar trs propriedades do componente Table. Veja a seguir uma descrio de cada uma dessas propriedades. Propriedade Active Descrio Active determina se a tabela est aberta ou no. Esta propriedade pode ser alterada em tempo de desenvolvimento para que os registros da tabela sejam exibidos, mesmo antes da execuo do aplicativo. A propriedade Active deve estar em False para que seja possvel alterar vrias propriedades da tabela, inclusive as propriedades DatabaseName e TableName. Quando estas duas propriedades so alteradas, o Delphi altera automaticamente Active para False. DatabaseName DatabaseName o nome do banco de dados que contm a tabela associada. O nome especificado aqui geralmente um Alias definido no DataBase Desktop. Para tabelas locais, como as dos bancos Paradox e dBASE, pode-se tambm especificar o diretrio onde as tabelas do banco de dados esto localizadas. TableName TableName o nome da tabela do banco qual o componente Table est associado. Quando a propriedade DatabaseName definida primeiro, as tabelas do banco de dados so listadas automaticamente para essa propriedade.
12.6. Controlando o acesso a uma tabela

Para alguns bancos de dados, principalmente os que usam SQL, h um controle rgido sobre a leitura e a escrita dos registros de uma tabela. H trs propriedades do componentes Table
151
152
que permitem verificar permisses ou controlar o acesso s tabelas de um banco de dados. Veja a seguir uma descrio dessas propriedades:
Propriedade CanModify
Descrio Esta uma propriedade somente leitura que indica se a tabela associada ao componente Table pode ser alterada ou no. Voc pode verificar o valor de CanModify para se certificar que os dados da tabela podem ser alterados. Determina se o usurio pode visualizar e alterar os dados da tabela, ou apenas visualizar esses dados. O valor de ReadOnly controlado pelo aplicativo e no pelo banco de dados, como acontece para a propriedade CanModify. Voc pode alterar a propriedade ReadOnly para True (o padro False) para exibir os dados em uma tabela sem, no entanto, permitir alteraes do usurio.
ReadOnly
Exclusive
Esta propriedade usada apenas para tabelas Paradox, dBASE ou FoxPro. Altere-a para True para que apenas um usurio de cada vez tenha acesso tabela. Se o valor de Exclusive for False, ser permitido o acesso tabela por vrios usurios ao mesmo tempo.
12.7. Trabalhando com Ranges

Algumas vezes, especialmente quando se est trabalhando com tabelas extensas, til restringir os registros exibidos a apenas um subconjunto dos registros de uma tabela. Uma maneira para fazer isso atravs de filtros, como vimos no captulo sobre DataSets. Outra maneira usando Ranges, um recurso exclusivo dos componentes Table. Os Ranges definem um valor inicial e um valor final para um ou mais campos de uma tabela. Para tabelas Paradox e dBASE, o campos usados devem se indexados. Para tabelas SQL (Oracle, SQL Server, Sybase, etc.) pode-se usar quaisquer campos para os Ranges. A maneira mais simples e direta para se definir um Range usando o mtodo SetRange. Este mtodo tem como argumentos duas listas de valores: os valores iniciais e os valores finais do Range. Os valores devem ser listados na ordem dos campos da tabela e devem ser colocados entre colchetes ( [ ] ). Use a palavra-chave nil para omitir campos do incio da tabela. Veja um exemplo do uso de SetRange, para uma tabela cujo primeiro campo um cdigo de quatro dgitos:
TabProdutos.SetRange(['0005'], ['0025']);
152
153
O comando restringe os registros da tabela a apenas aqueles com cdigos entre "0005" e "0025". Para cancelar um Range depois de us-lo, use o mtodo CancelRange, como em:
TabProdutos.CancelRange;
153
154
CAPTULO 13 - COMPONENTES TFIELD

Quando voc associa um DataSet a uma tabela de um banco de dados e abre o DataSet, o Delphi cria automaticamente campos dinmicos, um para cada campo da tabela. Os campos dinmicos so criados na memria do computador, temporariamente, quando o DataSet aberto e destrudos quando o DataSet fechado. O tipo dos campos dinmicos, as suas propriedades, e a ordem em que eles so exibidos dependem somente das tabelas s quais esses campos esto associados. Para que se tenha mais controle sobre os campos de um DataSet, o Delphi oferece os componentes TField. Componentes TField podem estar associados a um campo de um DataSet, ou podem ser novos campos, derivados de consultas ou clculos. Os componentes TField no podem ser adicionados diretamente a um formulrio. Eles fazem parte de um DataSet. Os campos definidos pelos componentes TField so tambm chamados de campos persistentes. Isso porque eles "persistem" durante a execuo do aplicativo e no so destrudos cada vez que o DataSet fechado (como acontece com os campos dinmicos). Com os componentes TField, voc pode controlar quais campos so exibidos, o tipo e a formatao de cada campo e vrias outras propriedades. Voc pode tambm criar campos calculados e campos lookup. Esses dois tipos de campos so, talvez, a principal razo para a existncia dos componentes TField.
13.1. Criando campos persistentes

Os componentes TField, ou campos persistentes, s podem ser criados dentro de DataSets. Na maioria das vezes, os campos persistentes so associados aos campos de uma tabela j existente, portanto o DataSet deve estar ligado a um banco de dados antes da criao dos campos. Como os DataSets mais usados so os componentes Table, usaremos esse componentes como base para os exemplos do restante dessa seo. Os procedimentos apresentados a seguir, no entanto, valem tambm para outros tipos de DataSets, como o componente Query, por exemplo. Para criar campos persistentes para um componente Table:
1. Clique duas vezes no componente Table, para exibir o Fields Editor (veja ilustrao a
seguir).
154
155
O Fields Editor a partir do Fields Editor que so feitas todas as operaes com campos persistentes. 1. Clique com o boto direito dentro do Fields Editor e escolha o comando Add Fields. Voc pode tambm usar o comando Add all Fields para criar campos persistentes para todos os campos do DataSet, rapidamente (neste caso, o passo 3 no necessrio). Uma janela com todos os campos da tabela exibida:
2.
Todos os campos so inicialmente selecionados. Clique em um campo para selecionar somente ele e use CTRL ou SHIFT para selecionar vrios campos. Depois clique em OK para criar um campo persistente para cada campo selecionado. O Fields Editor exibido novamente, agora com os novos campos criados:
155
156
Os campos criados dessa maneira substituem os campos dinmicos criados pelo Delphi. No pode haver campos dinmicos e persistentes em um mesmo DataSet. Se, por exemplo, voc criar apenas alguns campos persistentes (e no todos os disponveis), somente esses campos sero mostrados nos componentes ligados ao DataSet. A ordem em que os campos exibidos nos componentes ligados ao DataSet a ordem em que eles so listados no Fields Editor. Essa ordem pode ser alterada arrastando os nomes dos campos dentro do Fields Editor. Pode-se tambm apagar campos usando DELETE, ou adicionar novos campos usando o comando Add Fields novamente.
13.2. Tipos de campos persistentes

Quando voc cria campos persistentes para um DataSet, o Delphi adiciona, ao cdigo da Unit que contm o DataSet, declaraes para cada componente TField associado. Veja as declaraes geradas para o exemplo anterior (destacadas em negrito).
unit Unit1; ... type TForm1 = class(TForm) TabEmp: TTable; TabEmpEmpNo: TIntegerField; TabEmpLastName: TStringField; TabEmpFirstName: TStringField; TabEmpPhoneExt: TStringField; TabEmpHireDate: TDateTimeField;
156
157
TabEmpSalary: TFloatField; end; ... TIntegerField, TStringField, TDateTimeField e TFloatField so tipos de componentes TField. Esses tipos so definidos automaticamente pelo Delphi, dependendo dos campos associados no banco de dados. Por exemplo, um campo do tipo "Integer" em uma tabela Paradox, gera um componente do tipo TIntegerField; um campo do tipo "Alpha" gera um componente do tipo TStringField, e assim por diante. Veja uma lista dos tipos mais importantes de componentes TField: Tipo de TField TBooleanField TBlobField TCurrencyField TDateField TDateTimeField TFloatField TIntegerField TMemoField TStringField TTimeField Valores que podem ser armazenados Valores booleanos (True ou False) Dados binrios (figuras, por exemplo). Nmeros reais. Compatvel com tipo Currency. Datas. Compatvel com tipo TDate. Datas e horas. Compatvel com o tipo TDateTime Nmeros reais. Compatvel com tipos Float, Real e Double. Nmeros inteiros. Compatvel com tipo Integer. Textos longos. Compatvel com tipo String. Strings pequenos (limitados a 8192 bytes). Horas. Compatvel com tipo TTime.
Os componentes TField (de vrios tipos) podem ser manipulados diretamente no cdigo. Eles possuem propriedades e eventos como os outros componentes. A diferena que eles so componentes internos, que no aparecem diretamente nos formulrios. Isso algumas vezes assusta o programador iniciante, que est acostumado a trabalhar visualmente com os componentes. H vrios outros componentes desse tipo no Delphi, mas eles so apenas usados para programao avanada.
13.3. Campos calculados

Os campos calculados exibem valores que so calculados durante a execuo do aplicativo. Os clculos so geralmente baseados em valores de outros campos, mas podem tambm ser completamente independentes (o que raro). Para criar um campo calculado para um DataSet:
1. Abra o Fields Editor para o DataSet. (Clique duas vezes no DataSet.)

1. Dentro do Fields Editor, clique com o boto direito e escolha o comando New Field.
157
158
O Delphi exibe a caixa de dilogo New Field, onde se pode definir vrias opes para o novo campo (veja ilustrao a seguir). 2. Digite um nome para o campo na rea "Name". Este o nome pelo qual o componente ser identificado no Fields Editor. Enquanto o nome digitado, o nome na rea "Component" atualizado automaticamente. Este nome , por padro, o nome do DataSet que contm o campo, seguido pelo nome definido na rea "Name".
3.
Defina um tipo para o campo. O tipo deve ser compatvel com os valores usados para o clculo do campo. Depois clique em OK para criar o campo.
O Delphi adiciona o nome do campo lista de campos no Editor de Cdigo e acrescenta uma linha Unit do formulrio, declarando um componente para o novo campo. O exemplo de cdigo a seguir mostra (em negrito) a linha acrescentada. Note que o nome do componente o nome que o Delphi define em "Component", na hora da criao do campo. ... type TForm1 = class(TForm) TabEmp: TTable; TabEmpEmpNo: TIntegerField; TabEmpLastName: TStringField; TabEmpFirstName: TStringField; TabEmpPhoneExt: TStringField; TabEmpHireDate: TDateTimeField; TabEmpSalary: TFloatField;
158
159
TabEmpNomeCompleto: TStringField; end; ... Assim que criado, um campo calculado contm apenas valores nulos. Para realizar os clculos necessrios para o campo, voc deve digitar cdigo para o evento OnCalcFields do DataSet que contm o campo. Esse cdigo deve calcular um valor para o campo. Veja um exemplo que "calcula" o nome completo de cada funcionrio (concatenando o primeiro e ltimo nomes). procedure TForm1.TabEmpCalcFields(DataSet: TDataSet); begin DataSet['NomeCompleto'] := DataSet['FirstName'] + DataSet['LastName']; end; Voc pode definir vrios campos calculados para um DataSet. O valor de todos os campos calculados deve ser calculado sempre dentro do cdigo para evento OnCalcFields do DataSet. No exemplo a seguir, o realizado o clculo de dois campos calculados e uma tabela de funcionrios (chamada "TabFunc"): um para o salrio anual e outro para o endereo completo. procedure TForm1.TabFuncCalcFields(DataSet: TDataSet); begin DataSet[SalarioAnual]:= DataSet[SalarioMensal]*12; DataSet[EndCompleto]:= DataSet[Rua] + ', ' + DataSet[Numero] + ', ' + DataSet[Bairro]; end;
13.4. Campos lookup

Os campos lookup so campos especiais, usados para localizar automaticamente valores em um segundo DataSet, baseando-se em "valores-chave" de um primeiro DataSet. Por exemplo, suponha que o seu aplicativo use uma tabela Produtos com campos para o cdigo e a descrio de cada produto, e outra tabela Pedidos, com campos para o cdigo do produto, e a quantidade e a data do pedido. Nesse caso, voc poderia definir um campo lookup na tabela Pedidos para mostrar a descrio do produto, baseando-se no cdigo do produto. O campo lookup buscaria a descrio na tabela Produtos e a mostraria na tabela Pedidos (o cdigo do produto poderia at ser escondido).
159
160
Para criar um campo lookup em um DataSet:
1. Clique duas vezes no DataSet para exibir o Fields Editor. 1. Dentro do Fields Editor, clique com o boto direito e escolha o comando New Field: 2. Digite um nome para o novo campo em "Name" e defina um tipo para o campo em "Type". 3. Para "Field Type", escolha "Lookup" 4. Em "Lookup definition", defina valores para as opes descritas a seguir: Opo Dataset Key Fields Descrio O DataSet de onde sero buscados os valores para o campo lookup. Os campos chave que sero usados como base para realizar a busca. Estes so campos do DataSet que contm o campo lookup. Geralmente usado apenas um campo aqui. Escolha um campo da lista ou digite diretamente o nome do campo. Para usar mais de um campo chave, separe os nomes dos campos com ponto-evrgula. Lookup Keys Os campos do DataSet que sero comparados com os campos especificados em Key Fields. Estes campos pertencem ao DataSet que contm os valores a serem buscados pelo campo lookup. O campo a ser retornado pela busca. O valor desse campo o valor exibido no campo lookup.
Result Field
A ilustrao abaixo mostra a definio de um campo lookup que exibe a descrio de um produto, baseando-se no seu cdigo. O campo lookup "casa" o campo CodProduto da tabela Pedidos com o campo Codigo da tabela Produtos, retornando a descrio do produto.
160
161
13.5. Propriedades dos componentes TField

Uma das maiores vantagens dos componentes TField (campos persistentes) sobre os campos dinmicos (criados automaticamente pelo Delphi) o fato de que voc pode alterar as propriedades dos campos TField. Veja as propriedades mais teis dos campos TField na tabela a seguir: Propriedade Alignment DefaultExpression Descrio Determina o alinhamento do valor exibido no campo. Defina aqui um valor padro para o campo. O valor pode ser qualquer expresso vlida em SQL, mas que no se refira a nomes de campos. O valor deve ser especificado entre aspas simples, a no ser que seja formado apenas por dgitos. O ttulo mostrado para o campo em componentes como o DBGrid. Determina se o campo pode ou no ser alterado. Quando um campo criado, ReadOnly definido de acordo com o campo da tabela de banco de dados associado a ele. Voc pode alterar ReadOnly para True para proteger um campo contra alteraes, mesmo se o campo correspondente no banco de dados no estiver protegido. NOTA: Em um componente DBGrid, pressionar TAB pula os campos que tm a propriedade ReadOnly = True. Required O valor de Required definido automaticamente pelo Delphi quando um campo criado. Essa propriedade determina se o campo pode ou no ser nulo. Faa Required = True para proibir valores nulos para um campo. Altere essa propriedade para False para esconder o campo em um DBGrid. O valor padro True. Essa propriedade muito til quando se usa campos calculados em uma tabela. Voc pode esconder os campos que foram usados para os clculos, mostrando apenas os campos com os resultados, por exemplo. H vrias outras propriedades importantes que no foram citadas aqui. Muitas delas so definidas automaticamente quando um campo criado e raramente precisam ser alteradas. Outras so tratadas no curso avanado.
DisplayLabel ReadOnly
Visible
161
162
CAPTULO 14 - O COMPONENTE BATCHMOVE

O componente BatchMove usado para realizar transferncias de grandes quantidades de dados de uma tabela de banco de dados para outra. Com esse componente, pode-se copiar tabelas inteiras, ou criar novas tabelas com uma nica linha de cdigo (ou at em tempo de desenvolvimento). Um dos usos mais comuns do componente BatchMove para mover tabelas, ou partes de tabelas, de um banco de dados local, como Paradox, para um banco de dados SQL remoto (como Oracle, SQL Server, etc.) A converso dos valores, tipos e estrutura das tabelas realizada automaticamente pelo componente. Outra utilidade do componente BatchMove copiar dados entre uma tabela e outra de um mesmo banco de dados. Pode-se fazer isso, por exemplo, para criar uma tabela formada por registros de outra tabela que satisfaam um condio especificada.
14.1. Configurao bsica

Para realizar uma transferncia de dados com o componente BatchMove, voc deve definir quais so as tabelas de origem e de destino e o mapeamento que ser feito entre os campos de cada tabela. Veja uma descrio das propriedades que precisam ser alteradas: Propriedade Destination Source Mappings Descrio O nome da tabela de destino, para onde sero transferidos os dados. O nome da tabela de origem, de onde sero extrados os dados.
Define o mapeamento entre os campos da tabela de origem e de destino. Se as duas tabelas tm campos com nomes iguais, no necessrio alterar essa propriedade. Se os nomes forem diferentes, no entanto, voc deve indicar aqui quais so os campos correspondentes em cada tabela. Clique duas vezes na rea do valor de Mappings e digite uma linha para cada par de campos a serem "casados". Para campos com o mesmo nome, simplesmente digite o nome em comum. Para cada linha, use: Campo da tabela de destino = Campo da tabela de origem Veja um exemplo:
Codigo Descricao Quant = Quantidade Valor = Preco Aqui os campos Codigo e Descricao tm os mesmos nomes nas duas tabelas. J o
162
163
campo Quant na tabela de destino corresponde ao campo Quantidade na tabela de origem. O mesmo acontece com os campos Valor e Preco. RecordCount O nmero de registros que sero transferidos de uma tabela para outra. Se RecordCount for zero, todos os registros so transferidos.
14.2. Modos de operao

A transferncia de dados com um componente BatchMove pode ser realizada de vrias maneiras, usando modos de operao diferentes. Pode-se criar acrescentar, copiar, atualizar, ou apagar dados. A propriedade Mode do componente BatchMove define qual a operao realizada. Veja os valores que essa propriedade pode assumir. Valor de Mode batAppend Efeito na transferncia Adiciona os registros da tabela de origem no final de tabela de destino. A tabela de destino deve existir. (Esta a opo padro). Substitui os registros da tabela de destino pelos que "casam" com os registros da tabela de origem. O "casamento" feito baseado nos ndices (geralmente as chaves primrias) das tabelas. Registros que no casam so adicionados ao final da tabela de destino. As duas tabelas envolvidas devem existir. Cria uma nova tabela com a mesma estrutura e dados da tabela de origem. Se j existir um tabela com o mesmo nome, ela substituda. Apaga os registros da tabela de destino que "casam" com os da tabela de origem. As tabelas devem conter um ndice para permitir o "casamento". Substitui os registros da tabela de destino pelos que "casam" com os da tabela de origem. Registros que no casam no so transferidos (note a diferena de batAppendUpdate).
batAppendUpdate
batCopy
batDelete
batUpdate
14.3. Executando a operao de transferncia

A transferncia de dados com um componente BatchMove pode ser realizada em tempo de desenvolvimento ou em tempo de execuo. Em tempo de execuo, use o mtodo Execute do componente BatchMove, como em:
BatchMove1.Execute;
Em tempo de desenvolvimento, faa o seguinte:
Clique no componente BatchMove com o boto direito e escolha o comando Execute.
Veja um exemplo simples que usa um componente BatchMove para transferir todos os registros de uma tabela chamada Produtos para outra chamada ProdutosNovos.
procedure TForm1.Button1Click(Sender: TObject); begin
163
164
TabProdutos.Open; TabProdutosNovos.Open; with BatchMove1 do begin Source := TabProdutos; Destination := TabProdutosNovos; Mode := batAppendUpdate; Execute; end; TabProdutos.Close; TabProdutosNovos.Close; end; Vrias propriedades do componente BatchMove so definidas diretamente no exemplo, mas lembre-se que todas essas propriedades poderiam tambm ser definidas em tempo de desenvolvimento (veja a tabela de propriedades na pgina anterior).
14.4. Lidando com erros na transferncia

Uma operao de transferncia de dados entre tabelas pode causar muitos erros, principalmente quando a quantidade de dados a ser transferida grande, ou quando h muitas diferenas entre as tabelas de origem e de destino. Erros que podem ocorrer so violaes de chave (quando um registro adicionado contm a mesma chave que um registro existente) e erros de converso (os tipos dos campos no so compatveis). O componente BatchMove pode criar novas tabelas durante a transferncia, para permitir um controle maior sobre os registros que foram transferidos e sobre os registros que causaram problemas. Trs tabelas (do tipo Paradox) podem ser criadas. As trs tabelas contm (respectivamente): Registros alterados durante a transferncia. Registros que no puderam ser transferidos, devido a violaes de chave ou restries de integridade. Registros que tiveram campos cortados, devido converso dos tipos de cada campo, ou a campos com do mesmo tipo, mas com tamanhos diferentes.
A criao e a manipulao dessas tabelas controlada pelas seguintes propriedades do componente BatchMove: Propriedade ChangedTableName Descrio O nome da tabela que conter todos os registros alterados na transferncia. A tabela criada automaticamente pelo Delphi. Deixe essa propriedade vazia para no criar essa tabela.
164
165
ChangedCount
(Acessvel somente atravs de programao) Retorna o nmero de registros na tabela especificada em ChangedTableName. O nome da tabela onde sero armazenados todos os registros que no puderam ser transferidos por causa de violaes de chave ou de integridade. A tabela criada automaticamente pelo Delphi. Deixe essa propriedade vazia, para evitar que a tabela seja criada (Acessvel somente atravs de programao). Retorna o nmero de registros na tabela especificada em KeyViolTableName. O nome da tabela onde sero armazenados todos os registros que tiveram campos cortados na transferncia. Um campo cortado, quando o campo de destino menor que o campo de origem (o valor original no cabe). A tabela criada automaticamente pelo Delphi. Deixe essa propriedade vazia para no criar essa tabela. (Acessvel somente atravs de programao) Retorna o nmero de registros na tabela especificada em ProblemTableName.
KeyViolTableName
KeyViolCount
ProblemTableName
ProblemCount
165
166
CAPTULO 15 - COMPONENTES DATA CONTROLS

Os componentes da pgina Data Controls, da paleta de componentes do Delphi, permitem acessar e alterar dados em um banco de dados diretamente. J vimos uma introduo breve sobre esses componentes e j usamos um deles nos exemplos anteriores: o componente DBGrid. Neste captulo, veremos detalhes sobre como funcionam e como usar os mais importantes componentes Data Controls. Todos os componentes Data Controls tm a capacidade de exibir e alterar dados de um banco de dados. Muitas das tarefas necessrias para a leitura e a manipulao de dados so realizadas automaticamente por esses componentes. Algumas vezes, um aplicativo inteiro com acesso a bancos de dados pode ser desenvolvido usando componentes Data Controls, sem a necessidade de manipular dados diretamente com programao
15.1. Propriedades DataSource e DataField

H dois tipos bsicos de componentes Data Controls: os que acessam campos de uma DataSet, como os componentes DBEdit e DBText, e os que acessam registros inteiros de um DataSet, como o componente DBGrid. Os componentes que acessam os dados de um DataSet campo a campo tm duas propriedades importantes em comum: DataSource e DataField. A propriedade DataSource determina o DataSource ao qual o componente est conectado. Este DataSource deve estar conectado a um componente Table ou Query (um DataSet), para que possa ter acesso ao banco. A propriedade DataField indica o campo ao qual o componente est associado. Este um dos campos do DataSet conectado ao DataSource. Os componentes DBGrid e DBNavigator acessam dados registro por registro, e no campo por campo, como os outros componentes Data Controls. Portanto, esses componentes no apresentam a propriedade DataField (eles no esto associados a um campo especfico).
15.2. Outras propriedades e recursos comuns

A maioria dos componentes Data Controls tm componentes correspondentes na pgina Standard da paleta de componentes. Por exemplo, o componente DBEdit corresponde ao componente Edit, e o componente DBText corresponde ao componente Label. Na verdade, vrios dos componentes Data Controls so apenas verses com acesso a bancos de dados dos componentes da pgina Standard. Por isso, a maioria das propriedades desses componentes so as mesmas, como aquelas que determinam a cor, o alinhamento, as dimenses, etc. Muitos eventos e mtodos tambm so os mesmos. Nas sees a seguir, veremos apenas as propriedades e eventos relevantes para o trabalho com bancos de dados (alm de algumas outras propriedades essenciais). Veja os captulos sobre os componentes comuns para mais detalhes sobre as outras propriedades e eventos.
166
167
15.3. Componente DBEdit

O componente DBEdit a verso com acesso a banco de dados do componente Edit. Voc pode us-lo para exibir ou alterar o valor de um campo de um banco de dados diretamente. Veja algumas propriedades importantes desse componente. Propriedade Text Descrio (Acessvel somente atravs de programao). Como o valor exibido nesse componente vem de um campo, no possvel alterar a propriedade Text em tempo de desenvolvimento, para definir um valor inicial a ser exibido. A propriedade Text, entretanto, pode ser lida e alterada em tempo de execuo. Quando o valor de Text alterado, o campo associado no banco de dados alterado tambm. Determina se o valor exibido pode ou no ser alterado pelo usurio. Altere ReadOnly para True para no permitir alteraes. O nmero mximo de caracteres que pode ser digitado dentro do DBEdit. Use essa propriedade para trabalhar com campos de tamanho fixo, como os usados para cdigos, por exemplo.
ReadOnly
MaxLength
15.4. Componente DBText

O componente DBText corresponde ao componente Label. Esse componente usado para exibir valores que no devem (nem podem) ser alterados. Use este componente para indicar que os campos so apenas para exibio. No h como alterar o que exibido no componente DBText diretamente, nem com programao. (O componente no apresenta a propriedade Caption). O que exibido no componente depende exclusivamente do campo associado no banco de dados, definido pelas propriedades DataSource e DataField.
15.5. Componente DBMemo

Este componente semelhante ao componente Memo. Ele usado para exibir trechos longos de texto, como os armazenados em campos do tipo "MEMO" dos bancos de dados. H algumas novas propriedades interessantes: Propriedade AutoDisplay Descrio Define se o texto do campo associado exibido imediatamente ou no. Se AutoDisplay for False, o texto s ser exibido quando o usurio clicar duas vezes no componente. Isso torna o aplicativo mais rpido, especialmente quando os textos a serem exibidos so muito extensos O valor padro True, que faz com o que texto seja exibido automaticamente, quando o usurio passa de um registro para outro. Determina se o texto exibido no componente pode ser alterado ou no pelo usurio.
ReadOnly
167
168
15.6. Componente DBCheckBox

O componente DBCheckBox uma verso especial, com acesso a bancos de dados, do componente CheckBox. Esse componente geralmente ligado a um campo do tipo booleano, mas tambm pode ser ligado a outros tipos de campos com dois valores possveis, como "Sim/No", "Ligado/Desligado", etc. Os valores associados aos estados do DBCheckBox so definidos pelas propriedades ValueChecked e ValueUnchecked: Propriedade ValueChecked Descrio Os valores que correspondem ao DBCheckBox quando ele est marcado. Pode-se especificar um nico valor, ou uma lista de valores separados por ponto-e-vrgulas, como "Sim; Verdadeiro; True". Se o valor do campo associado for um dos valores especificados na lista, o componente DBCheckBox aparece marcado. Se o campo associado for um campo booleano, um valor True marca, e um valor False desmarca o DBCheckBox. Isso acontece mesmo se os valores True e False no forem especificados nas propriedades ValueChecked e ValueUnchecked. ValueUnchecked Os valores que correspondem ao DBCheckBox quando ele est desmarcado. Como para a propriedade anterior, pode-se especificar um nico valor, ou uma lista de valores, como por exemplo: "No; False; Falso".
NOTA: se o valor do campo associado ao DBCheckBox no for nem True, nem False, nem um valor das propriedades ValueChecked ou ValueUnchecked, o componente aparece acinzentado (nem marcado, nem desmarcado).
15.7. Componente DBRadioGroup

Esse componente semelhante ao componente RadioGroup. Ele usado para listar opes que so mutuamente exclusivas (somente uma pode ser escolhida). Uma caracterstica interessante desse componente que o ttulo exibido ao lado dos RadioButtons no precisa ser o mesmo valor que lido ou armazenado no campo associado. A propriedade Items define os ttulos que so exibidos e Values define os valores associados a cada ttulo. Propriedade Caption Descrio O texto que aparece na parte de cima do DBRadioGroup. Usado para identificar o grupo de opes. Os itens exibidos ao lado de cada RadioButton. Clique duas vezes ao lado dessa propriedade para definir a lista de itens digite um item para cada linha. (Apenas disponvel atravs de programao). Retorna o ndice do RadioButton que est selecionado no momento. O ndice um nmero inteiro. Zero corresponde ao primeiro RadioButton. Os valores associados aos itens exibidos. Os valores especificados so os valores que so lidos ou escritos no campo associado. Clique duas vezes ao lado da propriedade para definir a lista de valores. A ordem dos valores determina a associao com os itens especificados na propriedade Items.
Items
ItemIndex
Values
168
169
Se Values for deixada vazia vazia, os valores lidos e armazenados so os especificados na propriedade Items (os mesmos que aparecem na tela). Value (Apenas disponvel atravs de programao). O valor correspondente ao RadioButton que est selecionado.
15.8. Componente DBImage

Este componente usado para exibir imagens armazenadas em campos do do tipo BLOB (Binary Large OBject). Veja as propriedades mais importantes do componente DBImage: Propriedade AutoDisplay Descrio Se AutoDisplay for True (o valor padro), a imagem atualizada automaticamente quando o campo associado alterado. Se AutoDisplay for False, a imagem s atualizada (recarregada) quando o usurio clicar duas vezes no componente DBImage. BorderStyle determina se exibida uma linha em volta da imagem. O valor bsNone no mostra um linha; bsSingle exibe uma linha fina. Se Center for True (o padro), a imagem exibida centralizada no componente. Se Center for False, a imagem exibida no canto esquerdo superior do componente. Altere QuickDraw para True para que imagens com 256 cores ou mais sejam exibidas mais rapidamente, mas com perda de qualidade. Altere QuickDraw para False para obter uma maior qualidade de exibio, mas com perda de velocidade. Determina se a imagem ser ou no "esticada" para preencher todo o espao do componente DBImage. Se Stretch for True, a imagem esticada (o que geralmente causa distores e perda de qualidade); se Stretch for False, o tamanho da imagem no alterado.
BorderStyle
Center
QuickDraw
Stretch
15.9. Componentes DBListBox e DComboBox

Os componentes DBListBox e DBComboBox so as verses com acesso a bancos de dados dos componente ListBox e ComboBox, respectivamente. Os valores listados nesses componentes devem ser adicionados diretamente, alterando a propriedade Items. Os valores no so trazidos do campo associado no banco de dados (isso no seria prtico para tabelas com centenas ou milhares de valores diferentes, por exemplo). Propriedade Items Descrio Items determina os itens exibidos. Esses itens podem ser adicionados manualmente, em tempo de desenvolvimento, ou em tempo de execuo. A propriedade Items do tipo TStrings. Isso significa que voc pode usar os mtodos Add e Append para adicionar itens, e Delete para apagar itens (veja detalhes sobre o tipo TStrings na seo sobre o componente Memo, no captulo "Componentes Visuais Comuns". (Somente para o componente DBComboBox). Determina o
Style
169
170
comportamento e a aparncia do componente DBComboBox. As opes so idnticas s do componente ComboBox elas so descritas em detalhe no seo sobre este componente.
15.10.
Componentes DBLookupList e DBLookupCombo
Estes dois componentes so semelhantes, na sua aparncia, aos componentes DBListBox e DBComboBox, mas oferecem vrios recursos a mais. Os dois componentes trabalham com dois DataSets e no um como acontece com a maioria maioria dos outros componentes Data Controls. O comportamento dos componentes DBLookupList e DBLookupCombo parecido com o dos campos lookup, que vimos no captulo sobre componentes TField. Eles "casam" dois campos especificados em DataSets diferentes e exibem exi um valor resultante. Um componente DBLookupList ou DBLookupCombo pode ser ligado a um campo lookup. Nesse caso, basta definir as propriedades DataSource e DataField apropriadamente, para associar o campo lookup ao componente. O componente "reconhece" que que o campo o do tipo lookup realiza as buscas automaticamente, exibindo os resultados. Os componentes DBLookupList e DBLookupCombo, no entanto, so geralmente ligados a campos comuns. Eles tm a capacidade de fazer a busca dos valores automaticamente, sem a necessidade de usar campos lookup predefinidos. Para isso, necessrio lig-los lig a campos de dois DataSets diferentes. Para configurar componentes DBLookupList ou DBLookupCombo:
1. Na propriedade DataSource, escolha o DataSource a ser diretamente ligado ligad ao componente. Os dados desse DataSource so os dados que sero alterados pelo componente. Na propriedade DataField, escolha o campo que ser alterado. 1. Na propriedade ListSource defina o DataSet de onde sero lidos os valores, de acordo com o valor do campo ampo especificado em DataField. Na propriedade ListField defina o campo de onde os valores sero lidos. Os valores lidos a partir do campo definido em ListField so os valores exibidos no componente. 2. Finalmente, altere a propriedade KeyField para o campo que ser comparado com o campo definido em DataField. Isso termina a configurao. Quando os DataSets so ativados, o valor do campo DataField (do primeiro DataSet) lido e comparado com os valores no campo KeyField (do segundo DataSet). O valor retornado retornad o valor do campo ListField (do segundo DataSet).
15.11.
Componente DBNavigator
O componente DBNavigator permite realizar uma serie de operaes comuns em registros de um DataSet, como navegao, insero e deleo. Um componente DBNavigator ligado a um DataSet atravs de um componente DataSource (como os outros componentes Data Controls), mas o acesso feito registro por registro e no campo por campo. comum usar um componente DBNavigator em associao com um componente DBGrid para a navegao dos d dados em um DataSet.
170
171
O componente DBNavigator composto de um conjunto de botes. Cada boto executa um dos mtodos do DataSet, como First, Last, Prior, Next, Post, Edit, etc. Tudo que pode ser feito com DBNavigator pode ser feito atravs de programao, programao, usando esses mtodos diretamente. O DBNavigator apenas uma maneira simples e rpida de oferecer recursos para a navegao e alterao de um DataSet para o usurio, sem a necessidade de programao. Veja a seguir os mtodos associados a cada boto do DBNavigator:
First Post
Delete Last
Prior Cancel
Edit Insert
Next Refresh
H vrias propriedades importantes para o componente DBNavigator. Com elas, voc pode escolher quais os botes so exibidos no componente (VisibleButtons), e controlar ntrolar a aparncia de "Dicas" para cada boto (Hints e Showhint). Propriedade ConfirmDelete Descrio Se ConfirmDelete for True, uma caixa de confirmao exibida quando o boto "Delete" clicado. Caso contrrio, o registro atual apagado sem confirmaes. confirma Especifique aqui o DataSource ao qual o DBNavigator est ligado. Determina se os botes do DBNavigator so exibidos com efeito tridimensional, ou no. Se Flat for True, o efeito tridimensional no exibido e o componente se torna semelhante emelhante s barras de ferramentas do Office 97. Altere Hint para definir as "dicas" que aparecem para cada boto no DBNavigator. Clique duas vezes ao lado da propriedade e digite uma linha de texto para cada dica. As dicas s sero mostradas mostra se a propriedade ShowHint for True. Se Hints for deixada vazia e ShowHint for True, as dicas exibidas so os prprios nomes dos botes (em ingls). VisibleButtons Especifique aqui quais botes do DBNavigator voc deseja exibir. Esta propriedade muito muito importante, pois na maioria das vezes o DBNavigator oferece mais botes do que necessrio. Para definir os botes a serem exibidos, clique duas vezes no nome da propriedade para abrir um lista de subpropriedades. mostrada uma subpropriedade para cada boto que pode ser exibido (veja a figura ao lado). Para esconder um boto, altere a propriedade correspondente para False. Para exibir um boto altere a propriedade correspondente para True.
DataSource Flat
Hints, ShowHint
171
172
15.12.
Componente DBGrid
O componente DBGrid um dos componentes mais usados para trabalhar com os dados de um DataSet. Da mesma forma que para o componente DBNavigator, o componente DBGrid trabalha com dados registro por registro. Veja um exemplo de um DBGrid em ao:
Um DBGrid formado por linhas, colunas e clulas. Cada clula contm um valor de um campo de um DataSet. Como padro, o DBGrid mostra tambm o nome de cada coluna e indica o registro atual, atravs de um pequeno tringulo no lado esquerdo. A propriedade mais usada no componente DBGrid a propriedade Options, que contm vrias opes que podem ser ligadas (valor True) ou desligadas (valor False). Veja a seguir o significado das opes mais importantes: Opo dgEditing dgAlwaysShowEditor Efeito quando ligada Permite que o usurio altere dados dentro do DBGrid. Faz com que o DBGrid esteja sempre pronto para realizar alteraes (no estado dsEdit). Faz com que ttulos sejam exibidos no topo de cada coluna. Exibe o indicador do registro atual (um pequeno tringulo no lado esquerdo do DBGrid). Permite que colunas sejam movidas ou redimensionadas. Exibe linhas entre as colunas do DBGrid. Exibe linhas entre as linhas do DBGrid. Permite que o usurio use TAB e SHIFT+TAB para passar de uma clula do DBGrid para outra. Permite que o usurio selecione linhas inteiras no DBGrid. Faz com que a clula ou linha selecionada permanea selecionada, mesmo quando o DBGrid no est com o foco. Faz com que uma caixa de confirmao aparea, quando o usurio usa CTRL+DELETE para apagar um registro. Faz com que um novo registro inserido no DBGrid no seja enviado para o banco de dados, a no ser que o registro tenha sido alterado (no esteja vazio).
dgTitles dgIndicator
dgColumnResize dgColLins dgRowLines dgTabs
dgRowSelect dgAlwaysShowSelection
dgConfirmDelete
dgCancelOnExit
172
173
dgMultiSelect
Permite que mais de uma linha no DBGrid possa ser selecionada ao mesmo tempo.
173
174
CAPTULO 16 - O COMPONENTE QUERY

Neste captulo, veremos como usar o componente Query para realizar consultas SQL em bancos de dados. O componente Query permite realizar consultas SQL em qualquer tipo de banco de dados suportado pelo Delphi, desde em bancos locais Paradox e dBASE at bancos SQL, como Oracle ou SQL Server. Um componente Query contm o texto de uma consulta SQL e a especificao dos parmetros usados na consulta. O componente Query se encarrega da execuo da consulta SQL e do processamento dos dados retornados pelo banco de dados, para a consulta.
16.1. Configurando um componente Query

O componente Query, como o componente Table, um tipo de DataSet. Portanto, muitas das propriedades e mtodos que vimos no captulo sobre DataSets tambm se aplicam ao componente Query. Veja os passos bsicos necessrios para usar e configurar um componente Query em um formulrio: 1. Adicione um componente Query ao formulrio. 1. Altere a propriedade DatabaseName para o Alias do banco de dados a ser utilizado. 2. Na propriedade SQL, especifique a consulta SQL que a ser executada pelo componente. 3. Adicione um componente DataSource ao formulrio e altere a sua propriedade DataSet para o nome do componente Query. 4. Para exibir os resultados gerados pelo componente Query, adicione um componente DBGrid, ou outro componente com acesso a dados. Altere a propriedade DataSource desse componente para o nome do componente DataSource que voc acabou de adicionar. 5. Para executar a consulta SQL, altere a propriedade Active do componente Query para True. Se tudo correr bem, os resultados da consulta SQL so exibidos imediatamente no DBGrid (ou outro componente com acesso a dados).
16.2. Especificando a consulta SQL a ser executada

A consulta SQL de um componente Query armazenada na sua propriedade SQL. A propriedade SQL uma lista de strings (do tipo TStrings), contendo as linhas da consulta SQL. Quando um componente Query executado, todas as linhas da propriedade SQL co concatenadas em uma s e enviadas ao banco de dados. Os resultados da consulta SQL podem, ento, ser acessados atravs do componente Query. Pode-se especificar dois tipos de consultas SQL: consultas estticas e consultas dinmicas. As consultas estticas no podem ser alteradas em tempo de execuo. Se os dados do banco de dados no forem alterados entre uma execuo e outra da consulta, os dados retornados sero os mesmos. As consultas dinmicas, tambm chamadas de consultas parametrizadas, podem ser alteradas durante a execuo do aplicativo. Consulta dinmicas contm parmetros. Os parmetros podem ser alterados diretamente no cdigo, ou em tempo de desenvolvimento.
174
175
Para especificar uma consulta esttica (sem parmetros): Em tempo de desenvolvimento, na propriedade SQL do componente Query, digite a consulta SQL a ser executada. Para alterar o valor da propriedade SQL, clique duas vezes ao lado dessa propriedade no Object Inspector e digite o comando SQL na janela que aparece (veja a figura abaixo).
Em tempo de execuo, altere a propriedade SQL diretamente, usando os mtodos Add, Append, Clear, etc. (a propriedade SQL do tipo TStrings).
O exemplo a seguir l o texto em um componente Edit e cria a consulta SQL no cdigo, baseando-se no texto lido. chr(39) retorna o caractere "aspas simples" (39 o cdigo ASCII desse caractere). A consulta executada alterando-se a propriedade Active do Query para True. procedure TForm1.Button1Click(Sender: TObject); var Continente: String; begin Continente := Edit1.Text; Query1.SQL.Clear; Query1.SQL.Add('SELECT Name, Capital FROM Country ' + 'WHERE Continent = ' + chr(39) + Continente + chr(39)+ 'ORDER BY Name'); Query1.Active := True; end; Para especificar uma consulta dinmica (parametrizada): Faa o mesmo que para as consulta estticas, mas em vez de especificar valores fixos na consulta, especifique parmetros, identificadores antecedidos por dois pontos ( : ). Veja um exemplo:
175
176
No exemplo, so definidos dois parmetros: quant e val.
16.3. Trabalhando com parmetros

Quando voc define parmetros na consulta SQL de um componente Query, o Delphi l e registra automaticamente os parmetros definidos. Antes de executar a consulta parametrizada, no entanto, voc deve configurar os parmetros, definindo o tipo e (possivelmente) um valor inicial para cada parmetro.
Para configurar os parmetros de um componente Query:
1. Selecione o componente Query e clique duas vezes ao lado da propriedade Params, no Object Inspector. Isso mostra o Editor de Parmetros (figura abaixo)
O Editor de Parmetros 2. Para cada parmetro definido, clique no parmetro e altere as propriedades DataType e Value, usando o Object Inspector. A propriedade DataType determina o tipo (Real, Integer, etc.) do parmetro. DataType deve ser obrigatoriamente alterada. 3. Para confirmar as alteraes, feche a janela do Editor de Parmetros. A propriedade Value de um parmetro pode ser alterada para definir um valor inicial para um parmetro, em tempo de desenvolvimento. Mas o mais comum alterar os valores dos
176
177
parmetros usando programao. A maneira mais simples usando o mtodo ParamByName do componente Query. Para alterar os parmetros de uma query em tempo de execuo: Use o mtodo ParamByName(nome do parmetro). Use as propriedades de converso AsString, AsInteger, AsFloat, etc. para converter valores na hora de atribu-los aos parmetros. Veja um exemplo: procedure TForm1.Button1Click(Sender: TObject); begin with Query1 do begin Close; ParamByName('val').AsCurrency := StrToCurr(Edit1.Text); ParamByName('quant').AsInteger := StrToInt(Edit2.Text); Open; end; end; end; O exemplo l dois valores digitados em componentes Edit e atribui esses valores aos parmetros val e quant (veja o exemplo da seo anterior). Em seguida a consulta SQL executada usando o mtodo Open do componente Query.
16.4. Executando consultas

Um componente Query deve ser "executado" para que sua consulta SQL seja executada. Quando voc executa um componente Query, o Delphi interpreta o seu comando SQL, substitui os parmetros pelos valores especificados e disponibiliza os dados resultantes da consulta. Nos exemplos anteriores, usamos o mtodo Open (ou a propriedade Active) do componente Query para executar consultas SQL. Open, no entanto, s pode ser usado para consultas com o comando SELECT. As consultas SQL que no retornam dados, como as que usam os comandos INSERT, UPDATE, DELETE, etc. devem ser executadas usando o mtodo ExecSQL, como em Query1.ExecSQL;
177
178
CAPTULO 17 - A LINGUAGEM LOCAL SQL

A linguagem Local SQL um subconjunto da linguagem SQL padro (SQL 92 ANSI). SQL uma linguagem universal usada na grande maioria dos bancos de dados relacionais. A linguagem Local SQL contm os comandos mais bsicos da linguagem SQL e compatvel tambm com os bancos locais, do tipo Paradox e dBASE, alm dos bancos de dados SQL mais poderosos, como Oracle e SQL Server. A linguagem Local SQL suficiente para realizar a maioria das consultas SQL necessrias em um banco de dados. NOTA: como Local SQL um subconjunto da linguagem SQL, usaremos apenas "SQL" de agora em diante.
17.1. As duas partes de SQL

A linguagem SQL se divide em duas partes independentes (chamadas tambm de linguagens): uma linguagem de manipulao de dados, usada para consultar e alterar os dados de bancos de dados, e uma linguagem de definio de dados, usada para alterar a estrutura dos bancos. A linguagem de manipulao de dados constituda pelos seguintes comandos principais: Comando SELECT Funo Usado para recuperar dados de uma ou mais tabelas, baseando-se em condies especificadas. O comando SELECT usado para realizar muitas operaes diferentes e muito poderoso. Usado para adicionar dados a uma tabela. Usado para atualizar (modificar) dados existentes em uma tabela. Usado para apagar registros de uma tabela.
INSERT UPDATE DELETE
A linguagem de definio de dados constituda pelos seguintes comandos principais: Comando CREATE TABLE ALTER TABLE DROP TABLE CREATE INDEX DROP INDEX Funo Criar uma tabela. Alterar a estrutura de uma tabela. Destruir uma tabela (remov-la do banco de dados). Criar um ndice para uma tabela. Remover um ndice para uma tabela.
178
179
17.2. O comando SELECT

O comando SELECT o mais poderoso e mais complexo dos comandos da linguagem SQL. Esse comando usado para recuperar dados de uma ou mais tabelas. Os dados recuperados dependem das condies definidas no comando SELECT. A forma bsica para o comando SELECT a seguinte:
SELECT [campos retornados] FROM [tabelas consultadas] WHERE [condio] ORDER BY [campos de ordenao] GROUP BY [campos de agrupamento]
Veja o que significa cada parte do comando: Parte do comando SELECT campos retornados Descrio
Os nomes dos campos a serem retornados. Se um asterisco (*) for especificado, todos os campos das tabelas so retornados. Os campos devem pertencer a uma das tabelas especificadas em tabelas consultadas. As tabelas de onde sero extrados os dados. Uma condio que restringe os valores que so retornados. A condio pode usar os operadores booleanos comuns de Object Pascal, como <, >, <>, =, AND, OR, NOT, entre outros. Os campos usados como base para a ordenao dos valores retornados. O primeiro campo especificado tem prioridade. Os outros campos so usados como "critrios de desempate". Os campos usados para agrupar campos quando so usadas funes de agregao como COUNT, SUM e AVG.
tabelas consultadas condio
campos de ordenao
campos de agrupamento
Veja agora alguns exemplos do uso do comando SELECT: Este comando... SELECT * FROM Produtos Retorna... Todos os valores de todos os campos da tabela Produtos (a tabela inteira). Todos os nomes e os preos da tabela Produtos (mas nenhum outro campo). O Nome e o Preo de todos os produtos com Preo maior que 100.00. O Cdigo e o Preo de todos os produtos com Quantidade maior que 12. Note que os campos na parte WHERE no precisam estar na parte
SELECT Nome, Preco FROM Produtos
SELECT Nome, Preco FROM Produtos WHERE Preco > 100.00 SELECT Codigo, Preco FROM Produtos WHERE Quantidade > 12
179
180
SELECT. SELECT Nome, Quantidade FROM Produtos WHERE Preco > 100.00 AND Preco < 500.00 SELECT Nome FROM Produtos WHERE Quantidade <> 0 ORDER BY Nome SELECT * FROM Pedidos, Produtos WHERE Pedidos.CodProduto = Produtos.Codigo O Nome e a Quantidade de todos os produtos com Preo entre 100 e 500. Somente o Nome dos produtos com Quantidade diferente de zero, ordenados pelo Nome do produto. Todos os campos de ambas as tabelas Pedidos e Produtos, "casados" por cdigo. ( feita uma juno das duas tabelas, baseada nos campos Codigo e CodProduto). O Nome e o valor total dos produtos (Preo vezes Quantidade), agrupados por cdigo de produto. (Se houver um produto com o mesmo cdigo em vrios pedidos, o valor de todos os produtos pedidos somado o produto s aparece uma vez nos dados resultantes).
SELECT Nome, SUM(Preco*Quantidade) FROM Pedidos, Produtos WHERE Pedidos.CodProduto = Produtos.Codigo GROUP BY Nome, Codigo
17.3. Usando IN e BETWEEN

O comando IN usado em condies para determinar se um valor pertence a um conjunto especificado. O exemplo a seguir retorna o nome e o preo de todos os produtos com quantidades que estejam no conjunto {100, 200, 300, 400, 500}: SELECT Nome Preco FROM Produtos WHERE Quantidade IN (100, 200, 300, 400, 500) O comando BETWEEN tambm usado em condies, junto com a palavra AND, para determinar se um valor est dentro de um intervalo especificado. Veja dois exemplos: SELECT Nome, Quantidade FROM Produtos WHERE Preco BETWEEN 100 AND 1000 SELECT * FROM Pedidos WHERE Codigo BETWEEN 0001 AND 0100
17.4. Usando LIKE e caracteres "curinga"

Os comando LIKE usado em condies, junto com os caracteres % e _ , para fazer "casamentos" parciais. O caractere % vale por um ou mais caracteres (como o * do DOS); o caractere _ vale por exatamente um caractere (semelhante ao ? do DOS). Veja um exemplo: SELECT * FROM Produtos WHERE Nome LIKE Micro% Este exemplo retorna todos os produtos com o nome comeando com "Micro".
180
181
17.5. Usando funes de agregao

As funes de agregao so usadas para realizar clculos simples nos valores de um campo, como somas, mdias e contagens. So cinco as funes de agregao: Funo SUM AVG MIN MAX COUNT Retorna... A soma de todos os valores numricos em um campo. A mdia de todos os valores no nulos em um campo. O valor mnimo em um campo. O valor mximo em um campo. O nmero de valores em um campo, ou o nmero total de registros retornados.
Veja alguns exemplos do uso de funes de agregao: Comando SQL SELECT AVG(Preco) FROM Produtos SELECT COUNT(*) FROM Produtos WHERE Preco < 100.00 SELECT SUM(Preco*Quantidade) FROM Produtos Retorna Retorna a mdia do preo de todos os produtos. Retorna o nmero de produtos com preo abaixo de 100.00. Um nico valor retornado. Retorna a soma da multiplicao do Preco e da Quantidade de todos os produtos. Um nico valor retornado.
17.6. O comando INSERT

O comando INSERT usado para inserir novos registros (com dados) em tabelas. Este comando usado da seguinte forma: INSERT INTO Nome da tabela (Campo1, Campo2, ...) VALUES (Valor1, Valor2, ...)
Alguns exemplos: Comando INSERT INTO Clientes (Nome, Sobrenome) VALUES (Leonardo, Galvo) Efeito / Comentrio Insere um novo registro na tabela Clientes com Nome = "Leonardo" e Sobrenome = "Galvo". Os outros campos do registro ficam vazios
181
182
(nulos), se isso for permitido. INSERT INTO Produtos VALUES ('0079','Arno 100',500,100,'12/10/97') Insere um novo registro na tabela Produtos, preenchendo todos os valores do registro (Codigo, Nome, Valor, Quantidade e Data de entrada). Note que os campos no precisam ser especificados nesse caso.
17.7. O comando UPDATE

O comando UPDATE usado para atualizar (modificar) registros em uma tabela. Esse comando usado da seguinte forma: UPDATE Nome da Tabela SET Campo = Valor WHERE Condio Exemplos: Comando UPDATE Paises SET Capital = Bratislava WHERE Pais = Eslovquia UPDATE Produtos SET Preco = Preco * 0.8 Efeito / Comentrio Altera a capital do Pas "Eslovquia" para "Bratislava" (todas as ocorrncias). Reduz o preo de todos os produtos da tabela Produtos para 80% do preo anterior.
17.8. O comando DELETE

O comando DELETE usado para apagar registros inteiros de uma tabela, que satisfaam uma condio especificada. DELETE FROM Nome da tabela WHERE Condio O seguinte exemplo, apaga todos os registros da tabela Produtos, que tm o campo Quantidade = 0: DELETE FROM Produtos WHERE Quantidade = 0
17.9. A linguagem de definio de dados 17.10. O comando CREATE TABLE
Usado para criar tabelas. Com esse comando, voc especifica o nome da tabela a ser criada e o nome e o tipo de cada campo da nova tabela: CREATE TABLE Nome da Tabela ( Campo1 TIPO1
182
183
Campo2 TIPO2 ... PRIMARY KEY (CampoChave) ) A parte PRIMARY KEY define a chave primria da tabela. Veja um exemplo do uso do comando CREATE TABLE: CREATE TABLE Jogadores ( Nome CHAR[40], Sobrenome CHAR[60], DataNasc DATE, Clube: CHAR[40], PRIMARY KEY (Sobrenome) ) Para criar uma tabela do tipo Paradox ou dBASE adicione .DB ou .DBF ao final do nome da tabela e coloque o nome entre aspas, como no exemplo a seguir: CREATE TABLE "Clientes.db" ( Codigo: INTEGER; Nome CHAR[30], Cidade CHAR[40], )
17.11.
O comando ALTER TABLE
O comando ALTER TABLE usado para alterar a estrutura de uma tabela existente. H duas verses para esse comando, uma para adicionar campos e outra para remov-los. ALTER TABLE Nome da tabela ADD NovoCampo1 Tipo1, ADD NovoCampo2 Tipo2, ... (Adiciona os campos especificados depois de ADD). ALTER TABLE Nome da tabela DROP Campo1, DROP Campo2, ... (Remove os campos especificados depois de DROP) Veja alguns exemplos que usam o comando ALTER TABLE:
183
184
Comando ALTER TABLE Produtos ADD DataExpiracao DATE, ADD Fornecedor CHAR[60] ALTER TABLE Jogadores DROP DataNasc
Efeito Adiciona dois campos (colunas) tabela Produtos: "DataExpiracao" e "Fornecedor".
Remove o campo "DataNasc" da tabela Jogadores.
17.12.
O comando DROP TABLE
O comando DROP TABLE usado para remover tabelas inteiras de um banco de dados (A palavra "Drop" significa "Deixar cair", ou "Abandonar"). O uso desse comando simples: DROP TABLE Nome da tabela
17.13.
O comando CREATE INDEX
O comando CREATE INDEX usado para criar ndices em tabelas. A estrutura do comando a a seguinte: CREATE INDEX Nome do ndice ON Nome da tabela (Campo1, Campo2, ...) Para tabelas dBASE essa a nica maneira de criar ndices. Para tabelas Paradox esse comando s pode ser usado para a criao de ndices secundrios. O ndice primrio de uma tabela Paradox o campo definido na parte "PRIMARY KEY" do comando CREATE TABLE.
17.14.
O comando DROP INDEX
Usado para remover ndices em uma tabela. Pode ser usado de duas formas: DROP INDEX Nome da tabela.Nome do ndice (Remove da tabela o ndice especificado) DROP INDEX Nome da tabela.PRIMARY (Remove da tabela o ndice primrio - para tabelas Paradox)
184
185
CAPTULO 18 - COMPONENTES QUICKREPORT

O Delphi oferece o conjunto de componentes QuickReport, para a criao de relatrios para impresso, baseados em bancos de dados. Os "componentes QuickReport", como os chamaremos, esto localizados na pgina QReport da paleta de componentes.
Os componentes QuickReport Relatrios criados com os componentes QuickReport so baseados em bandas. Nas bandas podem ser adicionados componentes imprimveis, como ttulos de coluna, valores de campos de uma tabela, nmeros de pginas e outros. H mais de dez tipos de bandas diferentes. Cada tipo de banda se comporta de forma distinta. Algumas bandas, por exemplo, se repetem em todas as pginas, outras so exibidas apenas uma vez no relatrio. H tambm bandas "inteligentes" que oferecem recursos para o agrupamento de dados, por exemplo. Como a maioria dos componentes QuickReport so imprimveis, so oferecidos vrios recursos para a formatao detalhada e o posicionamento preciso dos componentes. No restante deste captulo veremos como criar dois tipos de relatrios comuns: listagens e relatrios com agrupamento. Veremos tambm detalhes sobre os componentes QuickReport mais importantes.
18.1. Criando um relatrio simples

Apresentamos a seguir os passos necessrios para a criao um relatrio simples, que lista os registros de uma tabela ou query. Para criar um relatrio simples (do tipo "Listagem"):
1. Crie um novo formulrio e adicione a ele um componente QuickRep. 1. Ligue o componente QuickRep a um DataSet (Table ou Query), alterando a sua propriedade DataSet. (Voc pode adicionar um Table ou Query ao formulrio do relatrio)
185
186
2. Defina as bandas que devem ser exibidas no relatrio (propriedade Bands). As trs bandas mais importantes so "Title", "Column Header" e "Detail". Altere as propriedades Bands.HasTitle, Bands.HasColumnHeader e Bands.HasDetail para True para adicionar estas bandas ao relatrio. (Veja a figura abaixo).
2. Na banda "Title", adicione um componente QRLabel e altere sua propriedade Caption para o ttulo do relatrio. Altere tambm a propriedade Font para destacar o ttulo.
3. Na banda "Column Header", adicione componentes QRLabel para os ttulos das colunas que deseja exibir no relatrio. Altere a propriedade Caption, como antes, para definir o texto a ser exibido no componente.
186
187
(A banda "ColumnHeader" repetida a cada nova pgina, logo depois do ttulo do relatrio).
4. Na banda "Detail", adicione componentes QRDBText para cada campo do DataSet a ser exibido no relatrio. (A banda "Detail" a mais importante do relatrio. Esta banda repetida para cada registro do DataSet ligado ao componente QuickRep). 5. Ligue cada componente QRDBText aos campos adequados, alterando suas propriedades DataSet e DataField. Por exemplo, para exibir o campo "Descricao" de uma tabela chamada "TabProdutos", altere DataSet para "TabProdutos" e DataField para "Descricao". Quando um componente QRDBText ligado a um campo de um DataSet, o nome do campo passa a ser exibido dentro do componente (veja a figura a seguir).
6. Aplique os formatos necessrios aos componentes e s bandas. Use a propriedade Frame para definir linhas de contorno, e a propriedade Font para definir tipos, estilos e cores de fonte. 7. Para visualizar o relatrio em tempo de desenvolvimento, clique com o boto direito no componente QuickRep e escolha o comando "Preview". mostrada a janela "Print preview", com uma pr-visualizao do relatrio:
187
188
18.2. O Componente QuickRep

O componente QuickRep o componente mais importante em um relatrio. Este componente deve ser adicionado a um formulrio vazio e ligado a um DataSet (Table ou Query). O DataSet pode ser adicionado ao mesmo formulrio do relatrio, ou colocado em um DataModule separado. O formulrio onde adicionado o componente QuickRep passa a ser apenas um "recipiente" para o relatrio esse formulrio no deve ser exibido diretamente. Para exibir ou imprimir um relatrio, so usados os mtodos Preview e Print, do componente QuickRep, como veremos adiante.
18.3. Bandas e tipos de bandas

Com a propriedade Bands do componente QuickRep, pode-se adicionar ou remover os seis tipos de bandas mais usados. Para adicionar uma banda, clique duas vezes na propriedade Bands, no Object Inspector, e altere para True a propriedade "Has..." correspondente ao tipo de banda desejado (veja a figura a seguir).
188
189
Segue uma descrio dos seis tipos de bandas que podem ser adicionados usando a propriedade Bands: Banda ColumnHeader Descrio A banda ColumnHeader usada para os ttulos das colunas do relatrio. Nesta banda geralmente colocado texto esttico como nomes de campos usando o componente QRLabel. Esta banda se repete em todas as pginas do formulrio, logo abaixo da banda Title. A banda Detail ("Detalhe") o "corao" do relatrio. Esta banda repetida para cada registro. Nesta banda, so colocados componentes com acesso a dados, principalmente os componentes QRDBText. A banda PageFooter ("Rodap") posicionada na extremidade de baixo de cada pgina do relatrio (exceto, possivelmente, na ltima). Nesta banda podem ser colocados, por exemplo, o nmero da pgina, a data ou a hora. Para que a banda PageFooter no aparea na ltima pgina do relatrio, altere para False a propriedade Options.LastPageFooter do componente QuickRep. PageHeader A banda PageHeader ("Cabealho") posicionada na extremidade de cima de cada pgina do relatrio (exceto, possivelmente, na primeira pgina). Pode-se colocar nessa banda, por exemplo, o ttulo do relatrio, a data, ou outras informaes relevantes, que devem ser repetidas em todas as pginas. Para que a banda PageHeader no aparea na primeira pgina do relatrio, altere para False a propriedade Options.FirstPageHeader do componente QuickRep. Summary A banda Summary ("Resumo") usada geralmente para exibir dados agregados, como somas, mdias, ou contagens. Esta banda exibida logo depois da ltima banda Detail (com os dados do ltimo registro). Para realizar os clculos necessrios nessa banda, so usados componentes QRExpr. A banda Title ("Ttulo") usada para exibir o ttulo do relatrio. Esta banda aparece apenas uma vez, na primeira pgina, e posicionada logo depois do cabealho da pgina (se este existir).
Detail
PageFooter
Title
189
190
18.4. Alterando a formatao geral do relatrio

O componente QuickRep oferece muitas opes de formatao, que podem ser alteradas atravs do Object Inspector (propriedades Bands, Font, Frame e Page), ou usando o comando Report Settings disponvel no menu de atalho do componente. Clique com o boto direito no componente QuickRep e escolha o comando Report Settings (ou clique duas vezes no componente) para exibir a seguinte a caixa de dilogo ilustrada a seguir. Veja o que pode ser alterado em cada seo desta caixa: Na seo Paper size, voc pode alterar o tipo e o tamanho do papel, e a orientao (retrato ou paisagem). Na seo Margins, as margens das pginas, em milmetros (ou em outra unidade, especificada na seo Other), podem ser alteradas com preciso. O nmero de colunas e o espaamento entre colunas do relatrio tambm podem ser alterados.
Na seo Other, pode-se a alterar a fonte e o tamanho de fonte usados como padro no formulrio. A fonte e o tamanho escolhidos aqui tm efeito sobre todos os componentes do relatrio, exceto aqueles que tiveram suas fontes alteradas diretamente. A unidade de medida usada no relatrio tambm pode ser alterada a unidade escolhida determina como so medidas vrias propriedades dos componentes do formulrio, como a largura e a altura, por exemplo. Na seo Page Frame, pode-se definir bordas para as pginas do relatrio. Bordas acima, abaixo, esquerda ou direita, e com vrias cores e espessuras podem ser definidas. (A cor e a espessura valem para todas as bordas). Na ltima seo, Bands, possvel acrescentar ou remover bandas do relatrio (ativando ou desativando as opes correspondentes). Pode-se tambm ajustar precisamente a altura de cada banda.
190
191
18.5. Propriedades comuns a todas as bandas

H vrias propriedades comuns a todas as bandas, como as que determinam a altura da banda ou linhas de contorno. Para alterar as propriedades de uma banda, deve-se primeiro selecionla (normalmente) com um clique. Veja a seguir uma descrio das propriedade mais importantes. Propriedade ForceNewPage ForceNewColumn Descrio Altere a propriedade ForceNewPage para True, para que seja iniciada uma nova pgina cada vez que a banda selecionada impressa. Altere a propriedade ForceNewColumn para True, para que seja iniciada uma nova coluna cada vez que a banda selecionada impressa. (Aplicvel somente em relatrios com mais de uma coluna). A propriedade Height determina a altura da banda, na unidade de medida atual. Essa propriedade pode ser alterada de forma interativa no relatrio clique na banda e arraste os pequenos quadrados que aparecem acima e abaixo da banda. A propriedade Frame determina a exibio de bordas em volta da banda de vrios formatos e cores, em volta das pginas do relatrio. As opes so bastante intuitivas: Color: A cor das bordas. (Se aplica a todas as quatro bordas). DrawBottom, DrawLeft, DrawRight, DrawTop: Determinam quais bordas sero exibidas abaixo, esquerda, direita e acima, respectivamente. Style: o estilo da linha das bordas (slido, tracejado, pontilhado, etc.) Width: a espessura das bordas. (Se aplica a todas as quatro bordas).
Height
Frame
18.6. Outros componentes importantes

Veremos agora mais alguns detalhes importantes sobre os quatro componentes mais usados em relatrios: QRLabel, QRDBText, QRSysData e QRExpr.
18.7. O Componente QRLabel

O componente QRLabel usado para textos estticos, como ttulos ou nomes de campos. A propriedade Caption determina o texto que ser exibido no componente. A propriedade Font define as opes de fonte (fonte, estilo, tamanho e cor). Trs propriedades relacionadas determinam o tamanho e a organizao do texto exibido no componente QRLabel. AutoSize faz com que o QRLabel altere sua largura automaticamente, de acordo com o comprimento do texto. AutoStretch faz com que a altura do componente seja ajustada automaticamente (para textos com mais de uma linha). WordWrap faz com que textos longos sejam quebrados em vrias linhas. O efeito dessas trs propriedades s vezes depende do valor das outras duas. AutoStretch, por exemplo, s faz sentido quando WordWrap for True. O alinhamento de um componente QRLabel pode ser alterado usando as propriedade Alignment e AlignToBand. Alignment altera o alinhamento com relao ao tamanho do componente, da forma usual: taLeftJustify alinha pela esquerda, taRightJustify pela direita, e taCenter pelo centro. A propriedade AlignToBand faz com que o alinhamento seja feito em
191
192
relao banda. Se AlignToBand for True e Alignment for taRightJustify, por exemplo, o QRLabel ser alinhado pela extremidade direita da banda.
18.8. O Componente QRDBText

O componente QRDBText uma verso, com acesso a bancos de dados, do componente QRLabel. Praticamente todas as propriedades do componente QRLabel se aplicam tambm ao componente QRDBText. Alm dessas, h mais duas propriedades importantes: DataSet e DataField. A propriedade DataSet determina o Table ou Query ligado ao componente QRDBText. A propriedade DataField determina o campo da Table ou Query, cujo contedo exibido no componente. Note que diferentemente dos componentes Data Controls (como o DBText e o DBEdit), o acesso a dados realizado diretamente e no atravs de um componente DataSource.
18.9. O Componente QRSysData

O componente QRSysData usado para exibir informaes teis, como a data, a hora, ou o ttulo do relatrio. Este componente muito semelhante ao componente QRLabel as propriedades de formatao, por exemplo, so as mesmas. A propriedade Data determina a informao exibida no componente. Veja alguns valores que podem ser atribudos propriedade Data: Altere Data para... qrsDate, qrsTime, qrsDateTime qrsPageNumber qrsReportTitle Para mostrar... A data, a hora, ou a data e hora atuais, respectivamente. O nmero da pgina. O ttulo do relatrio (extrado da propriedade ReportTitle do componente QuickRep).
18.10.
O Componente QRExpr
Com o componente QRExpr, possvel realizar clculos, ou outras operaes no relatrio. Podem ser calculados totais ou mdias de um campo, por exemplo. A propriedade Expression determina a operao realizada. A sintaxe das expresses segue uma sintaxe parecida com a da linguagem SQL. Veja algumas expresses vlidas:
Preco*Quantidade SUM(Preco) MIN(TabEstoque.Quantidade) MAX(TabProdutos.Preco) AVERAGE(Preco*Quantidade) IF(Preco = 0, 'Em estoque', 'Fora de estoque')
A propriedade Expression pode ser alterada diretamente, ou atravs do "Expression Wizard" (clique duas vezes ao lado do nome da propriedade para abri este "Wizard"). Os componentes QRExpr so freqentemente colocados em bandas do tipo "Summary", para realizar clculos agregados, como somas ou mdias, mas podem ser colocados em qualquer tipo de banda.
192
193
18.11.
Criando relatrios com agrupamento
Relatrios com agrupamento so muito comuns, na maioria dos aplicativos com acesso a bancos de dados. Exemplos desse tipo de relatrio so "Funcionrios por loja", "Professores por departamento", "Mdico por especializao", etc. Os relatrios com agrupamento so criados com os mesmos componentes apresentados nas sees anteriores. Apenas um novo componente necessrio: um tipo de banda especial chamado QRGroup. Veremos como criar um relatrio com agrupamento atravs de um exemplo, um relatrio (em um aplicativo de controle de estoque) que lista o estoque agrupado por loja. Usaremos um componente Query para obter os dados necessrios e para garantir a ordenao correta (por loja). Faa o seguinte:
1. Crie um novo formulrio e adicione a ele um componente QuickRep. 1. Adicione uma banda "Detail", usando a propriedade Bands do componente QuickRep. Adicione tambm uma banda QRGroup, a partir da paleta de componentes.
2. Adicione um componente Query e altere a propriedade SQL para a seguinte consulta SQL:
SELECT Nome, Descricao, Quantidade, Preco, Preco*Quantidade AS Total FROM Lojas, Estoque, Produtos WHERE Lojas.Codigo = Estoque.CodLoja AND Produtos.Codigo = Estoque.CodProduto ORDER BY Nome
Veja a estrutura das tabelas usadas na consulta:
193
194
5. Altere para True a propriedade Active do componente Query. Isso permite testar o relatrio em tempo de desenvolvimento, usando o comando Preview. 6. Ligue o componente QuickRep Qu ao componente Query (propriedade DataSet). 7. Na banda "Group Header" (o componente QRGroup) adicione componentes QRLabel, como na ilustrao a seguir:
8. Na banda "Detail", adicione componentes QRDBText para cada um dos campos a serem listados. Ligue cada um dos componentes Query (alterando a propriedade DataSet) e altere as suas propriedades DataField para os nomes dos campos. 9. Na banda "Group Header", ao lado de "Loja", adicione outro QRDBText e ligue-o ao campo "Nome" da Query (o nome da loja). Altere Altere tambm a propriedade Frame.DrawBottom da banda para True e a propriedade Width para 2. A ilustrao a seguir mostra os resultados das mudanas.
10. Para realizar o agrupamento automtico, altere a propriedade Expression da banda "Group Header" para "Nome" "Nome" (sem as aspas). Isso faz com que os dados sejam agrupados por loja. 11. Finalmente, para testar o relatrio, clique nele com o boto direito e escolha o comando Preview. A ilustrao a seguir mostra o relatrio gerado, com alguns dados de amostra:
194
195
18.12.
Imprimindo e pre-visualizando relatrios
At agora vimos apenas como exibir relatrios em tempo de desenvolvimento, usando o comando Preview. Relatrios podem ser tambm exibidos e o que mais importante impressos, em tempo de execuo. tudo muito simples. Para pre-visualizar um relatrio em tempo de execuo, use o mtodo Preview do componente QuickRep do relatrio. Esse comando, claramente deve ser chamado a partir de um comando de menu, ou de algum outro componente, em um formulrio separado (lembre-se que o formulrio que contm o relatrio no deve ser exibido). O cdigo a seguir mostra a pre-visualizao do relatrio em um formulrio chamado "RelVendas": procedure TFormRelatorios.BtPreviaClick(Sender: TObject); begin RelVendas.QuickRep1.Preview; end;
195
196
Note que foi usado o nome padro do componente QuickRep ("QuickRep1"). Recomenda-se, no entanto que se d um nome mais sugestivo a esse componente ("Relatorio", por exemplo). Para imprimir um relatrio, use o mtodo Print do componente QuickRep do relatrio, como no seguinte cdigo: procedure TFormPrincipal.RelatorioVendas1Click(Sender: TObject); begin RelVendas.QuickRep1.Print; end;
196

DelphiFATEC - Programação

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

DelphiFATEC - Programação

Enviado por

Direitos autorais:

Formatos disponíveis

1

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

CURSO: TECNOLOGIA EM PROCESSAMENTO DE DADOS

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

3.13. 3.14. 3.15. 3.16. 3.17.

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

11.10. 11.11. 11.12. 11.13. 11.14. 11.15.

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

17.8. 17.9. 17.10. 17.11. 17.12. 17.13. 17.14.

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

CAPTULO 01 - O AMBIENTE DE DESENVOLVIMENTO DO DELPHI

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

Mostrando/escondendo partes da barra de ferramentas

Adicionando botes barra de ferramentas

A Barra de Menus e os Menus de atalho

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

O Editor de Cdigo e o Code Explorer

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

Navegando pelo ambiente

1. Escolha o comando View | Window List

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

CAPTULO 02 - A ESTRUTURA DE UM APLICATIVO NO DELPHI

Trabalhando com Projetos

O que o arquivo de projeto

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

Visualizando e entendendo o arquivo de projeto

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

Alterando o arquivo de projeto

Usando o Project Manager

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

Usando Project Groups

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

Um Project Group com trs projetos, exibido no Project Manager

Salvando um Project Group

Adicionando e removendo projetos em um Project Group

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

2.10. Ativando um projeto

2.11. Compilando e executando projetos

2.12. Verificando apenas a sintaxe

2.13. Compilando projetos

Os comandos de compilao (para um projeto chamado "Editor")

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

2.14. Compilando Project Groups

2.15. Mostrando informaes sobre a compilao

Exemplo de informaes de compilao para um projeto

2.16. Executando o aplicativo gerado

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

2.17. Arquivos gerados pelo Delphi

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO

CAPTULO 03 - COMPONENTES: CONCEITOS BSICOS

Alterando propriedades em tempo de desenvolvimento

Propriedade numricas e de strings

DELPHI | FATEC FACULDADE DE TECNOLOGIA DO ESTADO DE SO PAULO