Access97-VBA Koga 04-10-01

Prévia do material em texto

Microsoft© Access 97 Avançado
Telefax: (31) 3274-1222 – www.treinarinformatica.com.br
 Microsoft© Access 97 Avançado
SUMÁRIO
Reprodução proibida
1. INTRODUÇÃO ............................................................................................................... 6
EXERCÍCIOS DE FIXAÇÃO – INTRODUÇÃO .............................................................. 8
2. PROGRAMAÇÃO NO MS ACCESS 97 ........................................................................ 9
2.1. MACRO X MÓDULO..................................................................................................... 9
2.2. MÓDULOS.................................................................................................................. 11
2.3. QUANDO USAR PROGRAMAÇÃO .................................................................................. 12
2.4. MÓDULO PADRÃO ...................................................................................................... 13
2.5. MÓDULO DE CLASSE EM FORMULÁRIOS E RELATÓRIOS ................................................ 13
2.6. MÓDULO DE CLASSE .................................................................................................. 14
2.7. SEÇÃO DE DECLARAÇÕES ........................................................................................... 15
2.8. SEÇÃO DE PROCEDIMENTOS........................................................................................ 16
2.9. O EDITOR DE CÓDIGO ................................................................................................. 16
2.9.1. Cores de código ................................................................................................. 17
2.9.2. Opções de codificação........................................................................................ 18
2.9.3. Configurações da janela..................................................................................... 19
2.10. JANELAS DO EDITOR DE CÓDIGO DO ACCESS ............................................................. 19
2.10.1. Janela de Código.............................................................................................. 19
2.10.2. Janela Depurar ................................................................................................ 20
2.10.3. Janela Pesquisador de Objetos......................................................................... 23
PRÁTICA 2 – PROGRAMAÇÃO NO MS ACCESS 97.................................................. 24
EXERCÍCIO 1 – Criando um módulo padrão............................................................... 24
EXERCÍCIO 2 – Criando um módulo de classe em formulário..................................... 24
EXERCÍCIOS DE FIXAÇÃO – PROGRAMAÇÃO NO MS ACCESS 97 ...................... 26
3. PROCEDIMENTOS EM MÓDULO PADRÃO .......................................................... 28
3.1. COMPILAÇÃO DE MÓDULO.......................................................................................... 30
3.2. TESTE DE EXECUÇÃO DE PROCEDIMENTO EM MÓDULO PADRÃO ................................... 31
3.3. EXECUÇÃO PASSO-A-PASSO........................................................................................ 31
3.4. INSPEÇÃO DE VARIÁVEIS ............................................................................................ 32
3.5. PONTO DE INTERRUPÇÃO............................................................................................ 33
3.6. CHAMADA DE PROCEDIMENTOS.................................................................................. 34
3.6.1. Passagem de Argumentos ................................................................................... 35
3.6.2. Retorno de Valor ................................................................................................ 36
3.6.3. Passagem de Argumentos por Valor e por Referência ........................................ 37
PRÁTICA 3 – CRIAÇÃO DE MÓDULO PADRÃO ....................................................... 40
EXERCÍCIO 1 – Criando um procedimento para cálculo de fatorial ........................... 40
EXERCÍCIOS DE FIXAÇÃO – CRIAÇÃO DE MÓDULO PADRÃO............................ 41
4. MÓDULO DE CLASSE EM FORMULÁRIO/RELATÓRIO .................................... 42
4.1. COLEÇÕES E OBJETOS DE FORMULÁRIO/RELATÓRIO ................................................... 43
4.2. PROPRIEDADES E MÉTODOS ....................................................................................... 45
4.3. COLEÇÃO PADRÃO E PROPRIEDADE PADRÃO................................................................ 45
4.4. PROPRIEDADES DE COLEÇÃO...................................................................................... 46
 Microsoft© Access 97 Avançado
SUMÁRIO
Reprodução proibida
4.5. SEÇÕES DE FORMULÁRIO/RELATÓRIO......................................................................... 47
4.6. EVENTOS DE FORMULÁRIO ......................................................................................... 47
EXERCÍCIOS DE FIXAÇÃO – MÓDULO DE CLASSE EM
FORMULÁRIO/RELATÓRIO........................................................................................ 49
5. ELEMENTOS DE PROGRAMAÇÃO......................................................................... 50
5.1. VARIÁVEIS............................................................................................................. 50
5.1.1. Declaração......................................................................................................... 50
5.1.2. Atribuição de valores à variáveis ....................................................................... 52
5.2. CONSTANTES ........................................................................................................ 53
5.2.1. Constantes Simbólicas........................................................................................ 53
5.2.2. Constantes Intrínsecas........................................................................................ 53
5.2.3. Constantes Definidas pelo Sistema ..................................................................... 54
5.3. VETORES E MATRIZES......................................................................................... 55
5.4. TIPOS DEFINIDOS PELO USUÁRIO..................................................................... 56
5.5. ESTRUTURA DE REPETIÇÃO............................................................................... 56
5.5.1. For..Next ............................................................................................................ 56
5.5.2. Do..Loop ............................................................................................................ 57
5.5.3. While..Wend ....................................................................................................... 58
5.5.4. For Each..Next ................................................................................................... 58
5.6. ESTRUTURA CONDICIONAL ............................................................................... 59
5.6.1. If...Then...Else .................................................................................................... 59
5.6.2. Select Case......................................................................................................... 60
5.7. ENTRADA E SAÍDA DE DADOS........................................................................... 61
5.7.1. Funções do VBA para entrada e saída................................................................ 62
5.7.2. Outros dispositivos de entrada e saída ............................................................... 63
5.8. COMENTÁRIOS...................................................................................................... 64
5.9. FUNÇÕES................................................................................................................ 64
5.10. ESCOPO DE IDENTIFICADORES........................................................................ 65
5.11. OBJETO DOCMD....................................................................................................66
6. EXPRESSÕES SQL ...................................................................................................... 67
7. FORMULÁRIOS AVANÇADOS ................................................................................. 69
7.1. FORMULÁRIO DE MANUTENÇÃO DE TABELAS ............................................. 69
7.1.1. Botões de Navegação Personalizados................................................................. 69
7.2. CAIXA DE DIÁLOGO............................................................................................. 71
7.2.1. Passagem De Parâmetros Para Procedimento ................................................... 72
7.2.2. Passagem De Parâmetros Para Consulta Parametrizada ................................... 72
7.2.3. Passagem De Parâmetros Para Relatório .......................................................... 73
7.2.4. Passagem De Parâmetros Para Formulário ....................................................... 76
7.3. FORMULÁRIO DE CONSULTA............................................................................. 79
7.4. CAIXA DE MENSAGEM ........................................................................................ 83
8. ACESSO A BANCO DE DADOS ................................................................................. 85
 Microsoft© Access 97 Avançado
SUMÁRIO
Reprodução proibida
8.1. HIERARQUIA DO OBJETOS DAO ................................................................................. 85
8.2. SINTAXE PARA REFERENCIAR OBJETOS EM COLEÇÃO.................................................. 86
8.3. COLEÇÃO PADRÃO..................................................................................................... 87
8.4. REFERÊNCIA A OBJETOS POR MEIO DE VARIÁVEIS ....................................................... 87
8.5. PROPRIEDADES E MÉTODOS ....................................................................................... 88
8.6. ACESSO A BANCO DE DADOS ACCESS......................................................................... 89
8.7. ACESSO A BANCOS DE DADOS EXTERNOS................................................................... 92
8.7.1. Vinculação de Tabelas Externas......................................................................... 93
8.7.2. Abertura Direta de Tabelas Externas ................................................................. 96
9. ACESSO A ARQUIVOS E IMPRESSORA ................................................................. 99
10. TRATAMENTO DE ERRO.......................................................................................101
10.1. DESVIO PARA ROTINA DE TRATAMENTO DE ERRO .....................................................102
10.1.1. Tratar o erro e terminar o programa...............................................................102
10.1.2. Tratar o erro e voltar à execução na mesma linha do erro...............................103
10.1.3. Tratar o erro e voltar à execução na linha seguinte à linha de erro.................103
10.1.4. Tratar o erro e desviar a execução para outro rótulo. .....................................103
10.1.5. Prosseguir o programa após erro....................................................................104
10.1.6. Evento Erro.....................................................................................................105
10.2. DEPURAÇÃO DO PROGRAMA....................................................................................105
11. AUTOMAÇÃO ...........................................................................................................107
11.1. AUTOMAÇÃO COM O MICROSOFT WORD 97 .............................................................109
Hierarquia dos Objetos do Microsoft Word 97............................................................109
11.2. AUTOMAÇÃO COM O MICROSOFT EXCEL 97 ............................................................110
Hierarquia do Objetos do Microsoft Excel 97 .............................................................110
Detalhamento do Objeto Worksheets...........................................................................110
Detalhamento do Objeto Charts..................................................................................111
Detalhamento do Objeto Chartgroups.........................................................................112
11.3. AUTOMAÇÃO COM MICROSOFT PROJECT 95.............................................................117
Hierarquia dos Objetos do Microsoft Project 95 (versão 4.1) .....................................117
11.4. AUTOMAÇÃO COM SCHEDULE+ 7.0 .........................................................................119
Hierarquia dos Objetos do Schedule+ 7.0...................................................................119
11.5. REFERÊNCIA À BIBLIOTECA DE OBJETOS....................................................119
12. CHAMADA À API DO WINDOWS 95.....................................................................123
13. SEGURANÇA.............................................................................................................129
13.1. SENHA DE BANCO DE DADOS.........................................................................129
13.1.1. DEFININDO UMA SENHA PARA O BANCO DE DADOS ............................129
13.1.2. ABRINDO UM BANCO DE DADOS PROTEGIDO POR SENHA ...................130
13.1.3. REMOVENDO SENHA DE BANCO DE DADOS............................................130
13.1.4. DEFININDO SENHA POR CÓDIGO VBA......................................................131
13.1.5. ABRINDO UM BANCO DE DADOS PROTEGIDO VIA CÓDIGO VBA..........131
 Microsoft© Access 97 Avançado
SUMÁRIO
Reprodução proibida
13.1.6. ALTERANDO A SENHA VIA CÓDIGO VBA...................................................131
13.2. CRIAÇÃO DE ARQUIVO MDE...........................................................................132
13.3. CRIPTOGRAFIA DE BANCO DE DADOS..........................................................134
13.3.1. CRIANDO UM ARQUIVO CRITPTOGRAFADO ............................................135
13.3.2. REVERTENDO A CRITPTOGRAFIA..............................................................135
13.3.2. CRIPTOGRAFIA POR CÓDIGO VBA ............................................................135
13.4. SEGURANÇA EM NÍVEL DE USUÁRIO............................................................136
13.4.1. PROPRIEDADE SOBRE O BANCO DE DADOS E OBJETOS........................137
13.4.2. IMPLEMENTANDO SEGURANÇA EM NÍVEL DE USUÁRIO .......................137
13.4.2. LOGON POR CÓDIGO VBA ..........................................................................141
13.4.3. TROCA DE SENHA VIA CÓDIGO VBA..........................................................142
13.4.4. RETIRAR PEMISSÃO DE CRIAR NOVOS BANCOS DE DADOS...................143
13.4.5. RETIRAR PEMISSÃO DE CRIAR NOVAS TABELAS E CONSULTAS.............144
ANEXO A - CONVENÇÃO DE NOMES PARA DESENVOLVIMENTO DE
APLICAÇÕES COM PRODUTOS MICROSOFT ........................................................145
MICROSOFT ACCESS 97.............................................................................................146
Hierarquia dos objetos do Access ...............................................................................146
Tags para objetos da janela de banco de dados do ACCESS.......................................146
Tags para objetos controles do ACCESS.....................................................................146
Tags para variáveis do ACCESS .................................................................................147
DATA ACCESS OBJECTS - DAO ................................................................................147
Hierarquia dos objetos DAO para Microsoft Jet Workspaces......................................147
Hierarquia dos objetos DAO para ODBCDirect Workspaces......................................148
Tags para Data Access Objects - DAO........................................................................148
MICROSOFTVISUAL BASIC 5.0 ................................................................................149
Tags para controles do Visual Basic ...........................................................................149
MICROSOFT VISUAL BASIC FOR APPLICATION - VBA........................................149
Tags para variáveis do Visual Basic for Application ...................................................149
 Microsoft© Access 97 Avançado
Reprodução proibida
6
1. INTRODUÇÃO
No MS Access, você armazena dados em tabelas e recupera informações por meio de
consultas, de forma interativa diretamente na janela de Banco de Dados. Esta forma de
trabalhar exige do usuário final um alto nível de conhecimento do MS Access.
Em vez de acessar diretamente as tabelas e consultas, você pode construir uma
interface com formulários e relatórios. No curso básico, você usa inicialmente os Assistentes
e depois pode construir os formulários e relatórios manualmente no modo Estrutura. Esta
forma de criar aplicativos atende a problemas simples de cadastramento e recuperação de
dados e exige que o usuário final tenha apena um conhecimento superficial do MS Access.
Com o tempo, você sente necessidade de o aplicativo dar maior controle no tratamento
dos dados e que a interface seja mais segura e simples de usar, não exigindo que o usuário
final tenha de saber o MS Access para operar o aplicativo. Torna-se necessário então
desenvolver aplicações usando programação dentro do MS Access.
Este curso ensinará a programação do MS Access 97, utilizando a linguagem Visual
Basic for Application – VBA, para que você desenvolva aplicativos completos no MS Access.
A Microsoft dispõe de três edições da linguagem Visual Basic:
§ Visual Basic - VB
§ Visual Basic for Application – VBA
§ Visual Basic Scripting – VBScript
A primeira é a linguagem completa, feita para desenvolver aplicativos profissionais.
Ela gera um programa executável que pode ser instalado em qualquer PC com Windows
95/98, NT ou 2000, sem a necessidade de o Visual Basic estar instalado. Alguns dos recursos
que só existem no VB é a possibilidade de desenvolver aplicativos cliente/servidor que acessa
bancos de dados relacionais, como o Microsoft SQL Server ou Oracle, e a criação de
componentes ActiveX, atualmente chamados de componentes COM (Component Object
Model). A linguagem Visual Basic é suportada no software Microsoft Visual Basic.
O VBA possui alguns recursos a menos que o VB, mas a sintaxe é idêntica. O VBA é
uma linguagem embutida nos aplicativos Microsoft Office 97 (exceto o Outlook) e no
Microsoft Project 98. Não é possível gerar um programa executável. Ela é uma linguagem
interpretada que depende do Microsoft Office 97 instalado ou o Microsoft Project 98.
A linguagem Visual Basic é o recurso que integra as melhores características de cada
aplicativo do MS Office. Por meio de programação, VB, VBA ou VBScript, é possível
construir uma interface única em um único aplicativo, como por exemplo o Access, e acessar
todos os recursos especializados dos demais integrantes do pacote Office ou mesmo do Back
Office. Esta técnica é conhecida como Automação, que veremos neste curso.
O VBScript é a versão mais simples do Visual Basic usado principalmente na
confecção de páginas WEB. Ele é suportado nos seguintes produtos:
§ MS Outlook 97/98
§ MS SQL Server 7.0
 Microsoft© Access 97 Avançado
Reprodução proibida
7
§ Windows Scripting Host
§ MS Internet Explorer 3 ou superior
Vários softwares não Microsoft também suportam o VBScript para automatizar
tarefas.
 Microsoft© Access 97 Avançado
Reprodução proibida
8
EXERCÍCIOS DE FIXAÇÃO – INTRODUÇÃO
1) As edições do Visual Basic são:
a. ( ) Visual Basic Professional, Visual Basic for Application e Visual Basic for Windows
b. ( ) Visual Basic, Visual Basic for Application e Visual Basic Scripting
c. ( ) Windows Scripting Host, JavaScript e VBA
d. ( ) Windows 95, Windows 98 e Windows NT
e. ( ) MS Access 2.0, MS Access 95 e MS Access 97
2) A linguagem de programação suportada pelo MS Access 97 é:
a. ( ) Access Basic
b. ( ) VBScript
c. ( ) JavaScript
d. ( ) Visual Basic for Application
e. ( ) Visual Basic Enterprise Edition
3) A execução de código VBA em um banco de dados MS Access 97 requer:
a. ( ) A geração de um arquivo executável (.exe)
b. ( ) O MS Office instalado no computador.
c. ( ) O MS Internet Explorer 4.01 com Service Pack 1
d. ( ) O MS Office 97 Professional ou superior instalado no computador onde a aplicação
rodará.
e. ( ) O Windows NT 4.0 Server
 Microsoft© Access 97 Avançado
Reprodução proibida
9
2. PROGRAMAÇÃO NO MS ACCESS 97
2.1. Macro x Módulo
No MS Access, o termo macro designa ações pré-definidas dispostas sequencialmente.
Para não-programadores, as macros podem ser usadas para operações simples, como abrir um
formulário ou relatório, executar uma consulta ou acionar um item de menu.
A chamada de macros por botões de comando em formulários e menus fornece ao
aplicativo uma interface com certo grau de controle de navegação pelas telas e automação.
Isto também restringe o acesso do usuário a recursos críticos do MS Access, tal como alterar
a estrutura de uma tabela, e não exige do usuário um alto nível de conhecimento sobre o MS
Access.
Você pode criar botões de comando em formulários e associar macros que realizam
ações pré-definidas. Por exemplo, o botão de comando cuja legenda é Cadastrar Livros
invoca a macro Macro1. Na Macro1 existe uma ação AbrirFormulário que abre o
formulário chamado frmCadastra_Livros.
A estrutura do formulário mostra que o evento do botão cmdCadastraLivros invoca a
macro Macro1 através do evento Ao clicar.
 Microsoft© Access 97 Avançado
Reprodução proibida
10
A manutenção de aplicativos baseados em macros é difícil, pois existem objetos
distintos: o formulário e a macro. Para cada controle que possui evento associado haveria a
necessidade de uma macro. A quantidade de objetos para gerenciar tornaria difícil a
compreensão do fluxo de execução.
Além disso, as macros não oferecem um bom controle de fluxo, pois não possuem
estruturas de controle sofisticados como If..Then..Else e estruturas de repetição como Do
While.
A construção de aplicativos usando programação reduz a complexidade do fluxo
porque a ação é codificada na própria estrutura do formulário. Os eventos de cada controle
apontam para procedimentos escritos em um linguagem de programação poderosa – o Visual
Basic for Application – que permite a criação de rotinas complexas e estruturadas.
No exemplo a seguir, os dois controles invocam os procedimentos de evento
cmdConsultaAutores_Click e cmdCadastraLivros_Click. Estes controles são botões de
comando, cujas propriedades Ao clicar apontam para o código que se encontra na própria
estrutura do formulário.
 Microsoft© Access 97 Avançado
Reprodução proibida
11
A programação no MS Access 97 torna o uso de macros obsoleta, pois tudo que as
macros fazem a programação consegue fazer com maior grau de controle sobre o fluxo de
execução. Portanto, não faz sentido neste curso ensinar como se constrói macros.
2.2. Módulos
A programação no MS Access é feita nos módulos.
Um módulo é uma coleção de declarações e procedimentos armazenados
conjuntamente, formando uma unidade. As declarações são instruções que direcionam o
comportamento dos procedimentos em todo um módulo.Um procedimento é uma unidade de
código VBA que realiza uma operação específica. Por exemplo, o cálculo dos dígito
verificador do CPF é um procedimento e o cálculo do fatorial de um número é outro.
Os módulos podem estar alojados em três lugares:
§ Na guia Módulos da janela de Banco de Dados do MS Access. Nela existem dois tipos de
módulos: módulo padrão e módulo de classe.
§ Embutido em um formulário do Access. Contém módulo de classe.
§ Embutido em um relatório do Access. Contém módulo de classe.
Cada módulo na guia Módulos recebe um nome único dentro do aplicativo (no
mesmo arquivo .mdb). O nome deve seguir uma regra de nomenclatura:§ Pode conter até 64 caracteres, entre letras e números
 Microsoft© Access 97 Avançado
Reprodução proibida
12
§ Aceita espaços e caracteres especiais, exceto ponto, exclamação, acento grave, colchetes e
caracteres de controle (código ASCII de 0 a 31).
§ Aceita letras maiúsculas e minúsculas indistintamente.
§ Não pode conter espaços no início do nome
É recomendável não usar espaços nem caracteres especiais e evitar nomes muito
longos. O Anexo A sugere uma convenção de nomes a ser adotada no desenvolvimento de
aplicativos com produtos Microsoft.
Os módulos de classe em formulários e relatórios não recebem nomes, pois são
gravados juntamente com o formulário ou relatório aos quais estão relacionados.
O código de um módulo é composto por:
§ Instruções, funções e palavras-chave do VBA
§ Nomes de variáveis, constantes ou procedimentos fornecidos pelo desenvolvedor
§ Instruções e cláusulas da linguagem SQL
§ Propriedades e métodos de objetos
As instruções, funções, palavras-chave, cláusulas, propriedades e métodos são
palavras reservadas, ou seja, você não as pode usar como nome de procedimento ou nome de
variável ou constante.
2.3. Quando usar programação
No MS Access, usa-se programação em VBA:
q Para efetuar um processamento complexo, que não pode ser atendido com a utilização de
consultas, nem macros. Exemplo: O cálculo de faturamento exige ler todos os serviços
prestados em um período, computar para, cada fatura, os descontos, multas, juros,
impostos e taxas.
q Para criar funções definidas pelo usuário – UDF (User Defined Functions), por exemplo,
o cálculo dos dígitos verificadores do CGC.
q Para percorrer um registro de cada vez. As consultas de seleção e de refer6encia cruzada
retornam um conjunto de registros de uma vez só, mas ás vezes é necessário processar
cada registro, seja de uma tabela ou de uma consulta.
q Sempre que se necessitar de usar estruturas de repetição e condição complexa (do tipo Do
While e If...Then...Else).
q Para substituir macros por código VBA equivalente. As macros ficam armazenadas em
pastas de macro (a quinta guia da janela Banco de Dados), mas podem ser chamadas de
qualquer parte do Access. Ás vezes pode ficar difícil entender o emaranhado de chamadas
a elas. Os módulos, por formarem uma unidade, são mais compreensíveis, podendo ainda
ser impressas. Assim, o aplicativo pode ser construído de forma modular e concisa,
melhorando assim a sua legibilidade e documentação.
 Microsoft© Access 97 Avançado
Reprodução proibida
13
q Para manipular objetos de outros softwares, como o Word e Excel, através da automação.
q Para realizar operações de DDE (troca dinâmica de dados), como por exemplo ler uma
tela do Plenus (um emulador de terminal Unisys TB-27).
q Para efetuar transações com COMMIT e ROLLBACK.
2.4. Módulo padrão
Usa-se código em módulo padrão para criar procedimentos globais, isto é, aqueles que
serão usados por todo o aplicativo. Por exemplo, uma função para transformar um número em
extenso pode ser chamada em qualquer do aplicativo..
Os procedimentos armazenados em Módulo Padrão são do tipo Function (aquele que
retorna um valor, por exemplo o fatorial de um número) ou Sub (aquele que não retorna
valor, por exemplo, uma rotina para tratar e imprimir mensagens de erro na tela).
Uma janela de código em módulo padrão possui as características mostradas abaixo.
2.5. Módulo de classe em formulários e relatórios
Os módulos embutidos em formulário e relatórios são do tipo Módulo de Classe. São
módulos que residem na estrutura dos formulários e relatórios, assim como os objetos de
controle. Por ficarem atrás dos formulários e relatórios, são também chamados de code
 Microsoft© Access 97 Avançado
Reprodução proibida
14
behind form. Os módulos de classe em formulário e relatório contêm procedimentos de
evento, que respondem a eventos de formulário, relatório ou controle neles inseridos. No
Access 95, os módulos de classe só podem ser criados associados a formulários ou relatórios.
No Access 97, eles podem ser criados na guia de Módulos da janela de Banco de Dados.
Os procedimentos de evento em módulo de formulário respondem a eventos (tais
como o clicar do mouse) do próprio formulário, de suas seções (cabeçalho, detalhe, rodapé) e
dos controles. Os procedimentos de evento em módulo de relatório respondem a eventos do
próprio relatório e de suas seções somente.
Se se deseja que um evento em um formulário ou relatório acione um procedimento
Function ou Sub de um módulo padrão, é preciso que o procedimento de evento dentro do
módulo de formulário/relatório faça a chamada. O código abaixo é um procedimento de
evento ligado ao controle cmdOkButton que chama um procedimento Sub armazenado em
módulo padrão.
Private Sub cmdOkButton_Click()
 CalculaRateio()
End Sub
Uma janela de código em módulo de classe embutido em formulário/relatório tem as
características mostradas abaixo.
O módulo de classe em formulário ou de relatório também pode conter procedimentos
Sub ou Function.
2.6. Módulo de classe
O módulo de classe criado na guia Módulos da janela de Banco de Dados do Access
tem como objetivo implementar as classes de objetos definidas pelo desenvolvedor,
permitindo uma certa reusabilidade de código. Os formulários e relatórios são classes de
objetos pré-definidos, que possuem seus próprios métodos e propriedades. Ao construir um
módulo de classe na janela de módulo, você cria uma nova classe de objetos.
 Microsoft© Access 97 Avançado
Reprodução proibida
15
Os procedimentos Sub e Function tornam-se os métodos do novo objeto e os
procedimentos Property Let, Property Get e Property Set tornam-se as propriedades do
objeto.
A programação de classes de objetos é mais efetiva no Visual Basic, pois você pode
construir um objeto totalmente encapsulado em um arquivo DLL, EXE ou OCX e pode usá-lo
em qualquer outra linguagem que suporte a arquitetura COM (Componente Object Model).
2.7. Seção de declarações
A janela de código de módulo, seja padrão ou de classe, possui a seção de
declarações e a seção de procedimentos.
Na seção de declarações encontram-se as instruções de escopo de módulo, ou sejam,
as instruções da seção de declarações afetam todos os procedimentos daquele módulo. As
variáveis declaradas nesta seção também são de nível de módulo, o que quer dizer que todos
os procedimentos do módulo podem acessar e alterar o conteúdo destas variáveis.
Por padrão, a seção de declaração de módulo no Access vem com as instruções
Option Compare Database e Option Explicit.
A instrução Option Compare define a ordem em que os caracteres são comparados.
Se Option Compare não for definido, o padrão é Option Compare Binary, que define a
ordem de classificação de acordo com a página de código utilizado no Windows.
Tipicamente, comparação binária segue a seqüência:
A < B < E < Z < a < b < e < z < À < Ê < Ø < à < ê < ø
Com a opção Database, a comparação segue o que estiver definido nas opções do
Access (menu Ferramentas|Opções..., guia Geral, na caixa Nova Ordem de classificação do
banco de dados).
 Microsoft© Access 97 Avançado
Reprodução proibida
16
A instrução Option Explicit obriga que todas as variáveis sejam declaradas
explicitamente, ou seja, usando as instruções de declaração de variáveis (Dim, Redim,
Private, Public ou Static). É altamente recomendável que as variáveis sejam declaradas
explicitamente para que não haja conflitos de nomes de variáveis.
2.8. Seção de procedimentos
Na seção de procedimentos você escreve seus procedimentos. Os procedimentos de
um módulo padrão pode ser do tipo Sub ou Function, ou procedimentos de evento (no caso
de módulo de classe de formulário e relatório) ou procedimentos Property Let, Property Get
e Property Set (no caso de módulo de classe).
Todo procedimento deve ter um nome único em todo aplicativo e seguir as regras de
nomenclatura:
§ Podem ter até 255 caracteres.
§ Precisam começar com uma letra.
§ Podem incluir letras, números ou caracteres sublinhados (_).
§ Não podem incluir caracteresde pontuação ou espaços.
§ Não podem ser uma palavra reservada do Visual Basic.
§ Podem ser escritos com letras maiúsculas ou minúsculas,sem distinção.
Os procedimentos Sub começam com a instrução Sub, seguido do nome do
procedimento, e terminam com End Sub. Entre Sub e End Sub fica o código que realizará a
operação desejada. O procedimento Function começam com a instrução Function, seguida no
nome do procedimento, e termina com End Function.
Os procedimentos de um módulo de classe de formulários e relatórios podem ser do
tipo Sub ou Function, mas o usual é que contenham procedimentos de evento.
2.9. O editor de código
A digitação do código em VBA é feita no próprio MS Access, na janela de código de
um módulo (seja módulo padrão, módulo de classe ou módulo de classe de
formulário/relatório). Para facilitar a edição e visualização do código, o editor de código
possui opções configuráveis, na qual pode-se escolher cores, fontes, tabulação e outros
recursos.
 Microsoft© Access 97 Avançado
Reprodução proibida
17
Figura 1: Opções do editor de código do Access
2.9.1. Cores de código
Por padrão, todo o texto do código é escrito usando a fonte Courier New tamanho 10.
A cor depende do tipo do texto. A cor é definida para o primeiro plano, para o segundo plano
e para o indicador de margem. Indicador margem é um ícone que aparece na margem
esquerda (margin indicator) do código, que serve para fornecer dicas visuais durante a
edição ou execução do código.
Os valores padrão para as opções de Caixa de texto, primeiro plano, segundo plano e
indicador são:
Área de texto 1o plano 2º plano Indicador
Texto normal Preta Branca
Texto de seleção Preta Azul
Texto de erro de sintaxe Vermelha Branca
Texto de ponto de execução Preta Amarela Amarela
Texto de ponto de interrupção Branca Marron Marron
Texto de comentário Verde Branca
Texto de palavra-chave Azul Branca
Texto de identificador Preta Branca
Texto de indicador Preta Branca Azul claro
 Microsoft© Access 97 Avançado
Reprodução proibida
18
Texto de retorno de chamada Preta Branca Verde claro
Para cada valor de área de texto você pode especificar o tipo de fonte e o tamanho nas
caixas Fonte e Tamanho.
Os ícones de indicadores de margem são:
Ícone Nome do Indicador
de margem
Descrição
Ponto de interrupção Indica que você definiu um ponto de interrupção usando o
comando Ativar/desativar ponto de interrupção no menu
Depurar. Você pode ativar/desativar o ponto de interrupção
colocando o ponteiro do mouse na região do indicador de
margem e clicando nele.
Linha de execução
atual
Indica a linha de código que será executada a seguir. Você
pode arrastar esse indicador de margem para um novo local
dentro de qualquer módulo de código em execução. Caso
arraste o indicador de margem da Linha de execução atual
para uma linha ou região inválida, nada acontecerá e o
indicador retornará para o local original.
Indicador Indica o local de um indicador definido usando o comando
Alternar indicador no menu Editar.
Marcador de Pilha de
chamadas
Indica as linhas que estão atualmente na pilha de chamadas. O
indicador Marcador de pilha de chamadas aparece apenas no
modo de interrupção.
2.9.2. Opções de codificação
§ Autorecuar — Permite que você tabule até a primeira linha de código; todas as linhas
subseqüentes iniciarão nesse local da guia.
§ Verificação de sintaxe automática — Determina se o Visual Basic deve verificar
automaticamente a sintaxe correta depois que você inserir uma linha de código.
§ Solicitar declaração de variável — Determina se declarações de variável explícitas são
exigidas nos módulos. Esta seleção adiciona a instrução Option Explicit às declarações
gerais de todo módulo novo.
§ Compilar ao ser solicitado — Determina se um projeto está totalmente compilado antes
que ele seja iniciado ou se o código está compilado conforme o necessário, permitindo
que o aplicativo inicie logo.
§ Listar membros automaticamente — Exibe uma lista que contém informações que
concluiriam logicamente a instrução no ponto de inserção atual. Exemplo.
 Microsoft© Access 97 Avançado
Reprodução proibida
19
§ Informação rápida automática — Exibe informações sobre funções e seus parâmetros à
medida que você digita. Exemplo:
§ Dicas de dados automáticas — Exibe o valor da variável sobre a qual o seu cursor está
posicionado. Disponível somente no modo de interrupção. Exemplo:
§ Largura da tabulação — Define a largura da guia, que pode variar de 1 a 32 espaços; o
padrão é 4 espaços.
2.9.3. Configurações da janela
§ Visualizar módulo completo — Define o estado padrão dos novos módulos para permitir
que você observe os procedimentos na janela Código como uma lista rolável simples ou
somente um procedimento de cada vez. Não altera o modo de exibição dos módulos
atualmente abertos.
§ Separador de procedimento — Permite que você exiba ou oculte as barras separadoras que
aparecem no fim de cada procedimento na janela Código.
§ Arrastar-e-soltar edição de texto — Permite que você arraste e solte elementos dentro do
código atual e da janela Código para as janelas Imediata ou Inspeção de variáveis.
§ Janela depurar visível — Mantém a janela Depurar aberta.
§ Barra do indicador de margem — Exibe a margem de indicador.
2.10. Janelas do editor de código do Access
A parte de programação do MS Access possui apenas três janelas:
§ Janela de Código
§ Janela Depurar
§ Janela do Pesquisador de Objetos.
2.10.1. Janela de Código
A janela de código contém as seções de declaração e a seção de procedimentos e é
onde se digita o código.
 Microsoft© Access 97 Avançado
Reprodução proibida
20
A janela de código é aberta nas seguintes situações:
§ Na guia Módulos da janela de Banco de Dados clique em Novo para criar um nvo módulo
ou em Estrutura para abrir um módulo existente.
§ Na estrutura de formulário ou relatório, acione o menu Exibir|Código, ou clique no ícone
da barra de ferramentas, ou acione o construtor de código nas propriedades do objeto.
2.10.2. Janela Depurar
A janela Depurar consiste de três painéis: Imediato, Locais e Inspecionar. Para
visualizar a janela Depurar, abra um módulo e clique no ícone na barra de ferramentas.
Você também pode abrir a janela Depurar acionando o menu Exibir| Janela Depurar. Você
pode também pressionar Ctrl-G a qualquer momento dentro do Access.
 Microsoft© Access 97 Avançado
Reprodução proibida
21
Você pode alternar entre o painel Locais e o painel Inspecionar clicando na guia
Locais ou na guia Inspecionar da janela Depurar. O painel Imediato permanece visível,
independentemente de qual guia é clicada.
2.10.2.1. O Painel Locais
O painel Locais exibe uma lista de variáveis em três colunas: Expressão, Valor e Tipo.
Algumas variáveis, como tipos definidos por usuários, matrizes e objetos, podem conter
informações hierárquicas. Estas variáveis têm um botão para expandir/reduzir à esquerda dos
nomes de variável para controlar a exibição de informações hierárquicas. Quando o painel
Locais está visível, ele é atualizado automaticamente quando o modo de execução muda do
modo de execução para o modo interrupção. Isto acontece quando a execução atinge um
ponto de interrupção ou quando você começa a depurar o código.
A primeira variável da lista é uma variável especial de módulo. Para um módulo
classe, esta é a variável Me definida pelo sistema. Esta é uma referência de objeto à instância
atual da classe definida pelo módulo atual. Já que esta variável é uma referência de objeto, ela
pode ser expandida para mostrar todas as propriedades e os membros de dados da instância de
classe atual. Para módulos padrões, a primeira variável é o nome do módulo atual e também
pode ser expandida para exibir todas as variáveis no nível de módulo no módulo atual. Você
pode alterar o valor de uma variável do painel Locais, mas não pode alterar suas definições de
Expressão ou Tipo.
 Microsoft© Access 97 Avançado
Reprodução proibida
22
2.10.2.2. O Painel Inspecionar
O painel Inspecionar permite que você visualize o valor deuma expressão ou uma
variável enquanto o código estiver em execução. Para definir uma expressão de inspeção,
clique no menu Depurar|Adicionar inspeção de variáveis. O painel Inspecionar proporciona
as seguintes capacidades:
§ Expandir/reduzir informações hierárquicas.
§ Redimensionar cabeçalhos de coluna.
§ Editar valores in loco.
2.10.2.3. O Painel Imediato
No painel Imediato, você pode:
§ Executar qualquer procedimento Sub ou Function, inclusive procedimentos de evento.
§ Executar uma expressão qualquer, inclusive usando variáveis do procedimento em
execução.
§ Visualizar a saída de valores enviados pelo método Print do objeto Debug.
Para executar um procedimento definido dentro de um módulo classe a partir do
painel Imediato, você precisa qualificar o procedimento com o nome do módulo classe, a
menos que você esteja no modo de interrupção dentro daquele módulo. Se você estiver no
modo interrupção, não é necessário qualificar o procedimento pois esse módulo está
atualmente no escopo.
O exemplo seguinte, quando digitado no painel Imediato da janela Depurar, executa
um procedimento ListarNomes que está definido no módulo classe associado a um formulário
Funcionários:
Form_Funcionários.ListarNomes
O próximo exemplo executa o procedimento do evento Click para um botão de
comando chamado InformaçõesPessoais em um formulário Funcionários:
Form_Funcionários.InformaçõesPessoais_Click
Para executar uma expressão, use o sinal ? seguido da expressão desejada. Por
exemplo, o comando abaixo irá calcular o número inteiro de uma divisão.
? Int(345/7)
2.10.2.4. Outros Recursos da Janela Depurar
A nova janela Depurar proporciona automaticamente informações de status sobre seu
código. Quando nenhum código está sendo executado, a barra de status no topo da janela
Depurar mostra "<Pronto>". Uma vez iniciada a execução do código, a barra de status mostra
o nome do banco de dados atual, o módulo no qual reside o procedimento em execução, e o
nome do próprio procedimento.
 Microsoft© Access 97 Avançado
Reprodução proibida
23
Você também pode visualizar a janela Chamadas a partir da janela Depurar clicando
no botão Construir .
2.10.3. Janela Pesquisador de Objetos
A janela Pesquisador de Objetos é aberta pelo menu Exibir|Pesquisador de Objetos
ou pela tecla F2.
O Pesquisador de Objetos é uma caixa de diálogo que exibe informações sobre
objetos, propriedades, métodos e constantes do banco de dados atual e em bibliotecas de
objetos referenciados. Você pode utilizar o Pesquisador de Objeto para pesquisar um
elemento específico, visualizar suas definições, obter ajuda sobre ele ou colá-lo em um
módulo.
* * * * *
 Microsoft© Access 97 Avançado
Reprodução proibida
24
PRÁTICA 2 – PROGRAMAÇÃO NO MS ACCESS 97
EXERCÍCIO 1 – Criando um módulo padrão
Crie um módulo basDemonstracao contendo o procedimento Welcome.
1. Abra o MS Access 97.
2. Crie um banco de dados vazio chamado dbWelcome.mdb.
3. Selecione a guia Módulos na janela de Banco de Dados.
4. Clique em Novo.
5. Digite o seguinte procedimento:
Sub Welcome()
 MsgBox "Bem-vindo ao curso MS Access 97 Avançado", vbOKOnly, "Treinar"
End Sub
Perceba como o Access diferencia cores para instruções e texto de usuário e como o editor de
código fornece dicas da sintaxe da instrução MsgBox.
6. Clique no menu Arquivo|Salvar.
7. Informe o nome basDemonstracao e clique OK..
8. Posisione o cursor em qualquer parte do código.
9. Tecle F5. Será mostrada uma caixa de mensagem chamada Treinar com o texto "Bem-
vindo ao curso MS Access 97 Avançado"
10. Clique no botão OK da caixa de mensagem.
11. Feche a janela de módulo e veja o nome do módulo basDemonstracao gravado na guia
Módulos da janela de Banco de Dados.
EXERCÍCIO 2 – Criando um módulo de classe em formulário
Crie um formulário chamado frmDemonstracao.
1. Clique na guia Formulários da janela de Banco de Dados.
2. Clique em Novo.
3. Escolha Modo estrutura e clique em OK.
4. Desligue o Assistentes de controle da barra de ferramentas Caixa de ferramentas.
5. Crie um botão de comando.
6. Abra as propriedades do botão de controle e selecione a guia Todas.
7. Atribua as seguintes propriedades:
Nome: cmdOK
Legenda: &Ok
Ao clicar: [Procedimento de Evento]
 Microsoft© Access 97 Avançado
Reprodução proibida
25
8. Clique no botão do construtor de código em frente à propriedade Ao clicar. Será
aberta a janela de módulo de classe.
9. Digite o código a seguir:
Private Sub cmdOk_Click()
 MsgBox "Isto é um procedimento de evento do controle cmdOk"
End Sub
10. Feche a janela de módulo.
11. Salve o formulário como frmDemonstracao.
12. Alterne para o Modo Formulário.
13. Clique no controle Ok. Surgirá uma caixa de mensagem com o texto "Isto é um
procedimento de evento do controle cmdOk"
14. Feche o formulário.
 Microsoft© Access 97 Avançado
Reprodução proibida
26
EXERCÍCIOS DE FIXAÇÃO – PROGRAMAÇÃO NO MS ACCESS 97
1) No MS Access 97, um módulo é:
a. ( ) Um arquivo formato Microsoft Access 97.
b. ( ) Um arquivo texto com código VBA.
c. ( ) Um conjunto de declarações e procedimentos que formam uma unidade.
d. ( ) Uma subrotina que realiza uma tarefa específica, como cadastrar clientes.
e. ( ) Um algoritmo.
2) Quais os tipos de módulo existentes no MS Access 97.
a. ( ) Módulo Padrão e Módulo de Classe
b. ( ) Módulo Padrão, Módulo de Classe e Módulo em formulário/relatório.
c. ( ) Módulo Standard e Módulo Misto
d. ( ) Módulo Private e Módulo Public
e. ( ) Módulo de cadastro, Módulo de consulta e Módulo de relatório.
3) Os módulos padrão do MS Access 97 residem.
a. ( ) Na guia Módulos da janela de Banco de Dados do Access.
b. ( ) Na estrutura de formulários e relatórios.
c. ( ) Na guia Macros da janela de Banco de Dados do Access.
d. ( ) Na estrutura de tabelas ou consultas.
e. ( ) Em arquivos texto de extensão .bas.
4) Os módulos de classe do MS Access 97 residem.
a. ( ) Na guia Módulos da janela de Banco de Dados do Access.
b. ( ) Na guia Módulos da janela de Banco de Dados do Access ou na estrutura de
formulários e relatórios.
c. ( ) Na guia Macros da janela de Banco de Dados do Access.
d. ( ) Na estrutura de tabelas ou consultas.
e. ( ) Em arquivos texto de extensão .bas.
5) Os módulos de classe em formulários contém.
a. ( ) Somente procedimentos de evento.
b. ( ) Somente procedimentos Sub e Function
c. ( ) Somente procedimentos Sub e Function e procedimentos de evento
d. ( ) Declarações, procedimentos de evento e eventualmente procedimentos Sub ou
Function.
e. ( ) Procedimentos de formulário.
6) O código VBA em módulos do MS Access 97 são editados:
a. ( ) No Notepad.
b. ( ) No Visual Basic Enviroment.
c. ( ) Em janela de código do módulo dentro do próprio arquivo de banco de dados.
d. ( ) Em qualquer utilitário que edite arquivo texto.
 Microsoft© Access 97 Avançado
Reprodução proibida
27
e. ( ) No MS Word, quando este é definido como editor padrão de mensagens.
7) As janelas disponíveis na edição de módulo são:
a. ( ) Janela de código, janela Locais e janela Imediato.
b. ( ) Janela de código, janela Depurar e janela Pesquisador de objeto.
c. ( ) Janela Locais, janela Inspecionar e janela Imediato.
d. ( ) Janela estrutura, janela formulário e janela folha de dados.
e. ( ) Janela propriedades, janela métodos e janela eventos.
 Microsoft© Access 97 Avançado
Reprodução proibida
28
3. PROCEDIMENTOS EM MÓDULO PADRÃO
Procedimento é uma unidade de código VBA que contém instruções e métodos
sequencia e logicamente ordenados que ao final de algum tempo de execução realizará uma
tarefa específica, previamente planejada no algoritmo.
Por exemplo, podemos querer determinar as raízes de uma equação do segundo grau
por meio de um procedimento. Ao final, podemos ter como resultado um valor, dois valores
ou nenhum.
A equação do 2º grau possui a forma geral: ax2 + bx + c = 0
A resolução do problema consiste em receber três valores da equação do 2º grau,
normalmente chamados de a, b e c e determinar os valores dex. Os valores de x são
determinados pela fórmula de báskara, que consiste em:
2a
 4b b 2 ac
x
−±=
O algorimo para implementar a fórmula de Báskara é:
Algoritmo Baskara
Declare a, b, c, Delta, x1, x2 numérico
Leia a
Leia b
Leia c
{Calcule Delta}
Delta ← b2 – 4 x a x c
Se Delta = 0 então
x1 ← -b ÷ 2 x a
Escreva x1
SenãoSe Delta > 0 então
x1 ← (-b + Delta ) ÷ (2 x a)
x2 ← (-b - Delta ) ÷ (2 x a)
Escreva x1
Escreva x2
Senão
Escreva "Não há solução"
Fim Se
Fim algoritmo
Este algoritmo tem uma finalidade geral e portanto é adequado usar módulo padrão.
Módulos padrão são criados na guia Módulos da janela de Banco de Dados. Selecione a guia
Módulos na janela de Banco de Dados e clique no botão Novo. É aberta uma janela de código
para criação de procedimentos em módulo padrão.
Cada módulo pode conter um ou mais procedimentos do tipo Sub (procedimento sem
retorno de valor, ou simplesmente procedimento) e Function (procedimento com retorno de
valor, ou simplesmente, função).
 Microsoft© Access 97 Avançado
Reprodução proibida
29
Abaixo da seção de declarações, digite a palavra reservada Sub ou Function seguido
do nome do procedimento.
Após teclar Enter, uma seção de procedimento será criada, iniciando com a declaração
do procedimento e terminando com a palavra reservada End Sub ou End Function.
Option Compare Database
Option Explicit
Sub MeuProcedimento()
 [ instruções ]
End Sub
Function MinhaFuncao()
 [ instruções ]
End Function
Na área entre a declaração do procedimento e o seu fim você deve digitar o seu código
VBA. Comece sempre com a declaração das variáveis e constantes que serão utilizados pelo
seu código.
Criemos um primeiro código para implementar o algoritmo de Báskara.
Sub Baskara()
 Dim sngA As Single
 Dim sngB As Single
 Dim sngC As Single
 Dim dblDelta As Double
 Dim sngX1 As Single
 Dim sngX2 As Single
 sngA = InputBox("Valor de A")
 sngB = InputBox("Valor de B")
 sngC = InputBox("Valor de C")
 ' Cálculo de Delta
 dblDelta = sngB ^ 2 - 4 * sngA * sngC
 If dblDelta = 0 Then
 sngX1 = -sngB / (2 * sngA)
 MsgBox sngX1
 ElseIf dblDelta > 0 Then
 sngX1 = (-sngB + Sqr(dblDelta)) / (2 * sngA)
 sngX1 = (-sngB - Sqr(dblDelta)) / (2 * sngA)
 MsgBox sngX1
 MsgBox sngX2
 Else
 MsgBox "Não há solução"
 End If
End Sub
Os parênteses após o nome do procedimento serve para receber argumentos (também
chamado de parâmetros). Veremos a passagem e recebimento de argumentos mais adiante.
Dentro do mesmo módulo, podemos ter mais de um procedimento Sub ou Function.
Criaremos um procedimento para cálculo de fatorial de um número.
 Microsoft© Access 97 Avançado
Reprodução proibida
30
Sub Fatorial()
 Dim lngNumero As Long
 Dim dblFatorial As Double
 Dim lngContador As Long
 lngNumero = InputBox("Entre com um número")
 dblFatorial = 1
 lngContador = 2
 If lngNumero = 0 Or lngNumero = 1 Then
 MsgBox "O fatorial é 1"
 Else
 Do While lngContador <= lngNumero
 dblFatorial = dblFatorial * lngContador
 lngContador = lngContador + 1
 Loop
 MsgBox "O fatorial é " + str(dblFatorial)
 End If
End Sub
3.1. Compilação de módulo
Na maioria da linguagens de programação o termo compilação significa gerar um
arquivo executável a partir do programa fonte. Compilar no MS Access 97 significa verificar
a sintaxe das instruções e a verificação de variáveis e constantes não declaradas (caso Option
Explicit esteja ativado).
Ao terminar a digitação do código, você deve compilar o módulo. A compilação é
feita no menu Depurar|Compilar módulos carregados na janela de módulo. A compilação
abrange todos os módulos abertos (seja padrão, de classe ou de formulário/relatório) e não
somente o módulo que está sendo editado.
Se houve erro de sintaxe ou variável não declarada, uma caixa de mensagem
informará o erro e o texto onde o erro ocorreu será selecionado. Por exemplo, o código abaixo
apresentará erro, pois estamos usando uma variável não declarada.
Option Compare Database
Option Explicit
Sub Teste()
 Dim intNumero As Integer
 intNumero = intDesconto * 42
 MsgBox intNumero
End Sub 
Ao compilar, será mostrada uma caixa de diálogo com o erro “Variável não definida”.
 Microsoft© Access 97 Avançado
Reprodução proibida
31
Ao clicar OK, a janela do código onde ocorreu o erro será aberta e o local do erro
ficará marcado.
Caso não haja erros de sintaxe, verifique erros de lógica, para que o programa não
trave o computador. Se tudo estiver correto, salve o módulo e forneça um nome. A gravação
do módulo é feita pelo menu Arquivo|Salvar.
3.2. Teste de execução de procedimento em módulo padrão
Os procedimentos em módulos padrão, desde que não recebam argumentos, podem
ser executados, para fins de teste, a partir da janela de código do módulo que está sendo
editado.
Dentro de um mesmo módulo podem ser escritos vários procedimentos. Para executar
um deles, você deve posicionar o cursor em qualquer parte do procedimento desejado e teclar
F5 ou acionar o menu Executar|Ir para/continuar ou ainda teclar o ícone .
3.3. Execução passo-a-passo
Você pode executar o procedimento passo-a-passo, uma linha de cada vez, para
acompanhar o fluxo de execução, depurar eventuais erros de lógica ou visualizar o conteúdo
de variáveis.
A execução passo-a-passo é acionada pela tecla F8 ou pelo ícone na barra de
ferramentas da janela de módulo ou pelo menu Depurar|Depuração total. Durante a
execução passo-a-passo, o texto da linha de código que está sendo executada ficará na cor
definida por “Texto de ponto de execução” definido nas opções do editor de código (menu
Ferramentas|Opções, guia Módulo) e o indicador surgirá na barra Indicador de Margem.
A qualquer momento, você pode decidir pela execução total, teclando-se F5. Durante
a execução passo-a-passo você pode abortar a execução acionando o menu Executar|Fim ou
clicar no ícone na barra de ferramentas. Este ícone só está ativado se algum procedimento
estiver sendo executado. Ao editar o código, preste atenção neste ícone e lembre-se de
terminar a execução antes de fazer qualquer alteração em seu código ou na estrutura de
tabelas, consultas, formulários e relatórios.
 Microsoft© Access 97 Avançado
Reprodução proibida
32
3.4. Inspeção de variáveis
Durante a execução passo-a-passo você pode posicionar o mouse sobre uma variável e
verificar o valor nela contida naquele momento da execução.
 Microsoft© Access 97 Avançado
Reprodução proibida
33
Lembre-se que este recurso de inspeção de variáveis durante a execução do
procedimento só está disponível se a opção “Dicas de dados automáticas” estiver ativada nas
opções do editor de código.
Você pode inspecionar todas as variáveis no painel Locais da janela Depurar.
3.5. Ponto de interrupção
Para depurar uma aplicação não é necessário executar passo-a-passo todos os códigos.
Normalmente, você quer estudar algumas partes do código mais suceptíveis a falhas. Você
 Microsoft© Access 97 Avançado
Reprodução proibida
34
pode estabelecer pontos de interrupção nas linhas em que você quer começar a execução
passo-a-passo.
Para isto, vá até a linha onde se deseja interromper a execução e tecle F9 ou o ícone
na barra de ferramentas ou acione o menu Depurar|Ativar/Desativar pontos de
interrupção. O indicador de margem apresentará o ícone e o texto da linha ficará na cor
marrom em segundo plano.
Ao executar o procedimento com F5, o código será executado completamente e parará
no ponto de interrupção. A partir daí, pode-se prosseguir com F8 para execução passo-a-passo
ou F5 para continuar a execução completa. Um novo F9 na linha do ponto de interrupção
desativará o ponto de interrupção.
Os pontos de interrupção servem para testar o aplicativo. Você deve lembrar de
desativar todos os pontos de interrupção antes de salvar o módulo (ou formulário ou relatório)
para ser distribuído. Pressionando Control+Shift+F9 desativa todos os pontos deinterrupção
de todos os módulos, estejam estes salvos ou não.
3.6. Chamada de Procedimentos
Os procedimentos anteriores são duas unidades de código independentes entre si. Cada
um deles é executado ao teclar F5.
Usamos a tecla F5 apenas para testar cada um dos procedimentos. Naturalmente,
quando construir um aplicativo em Access, ele não funcionará à base de tecla F5. Haverá uma
interface gráfica, normalmente um formulário, com opções para executar os procedimentos
que você criou. Veremos em outro capítulo como chamar um procedimento a partir de um
formulário.
Agora, precisamos saber como um procedimento pode chamar outro e como eles se
relacionam.
Suponha que você escreva um procedimento para calcular a combinação de n números
tomados p a p. A fórmula da combinação é:
Cn p
n
p n p
,
!
!( )!
= −
Note que para resolver este problema é preciso calcular três fatorias. Ora, já vimos um
procedimento para calcular fatoriais. Não bastaria escrever três vezes o código dentro do
procedimento de combinação?
Não é nada produtivo ter que rescrever o mesmo algoritmo várias vezes. O que
podemos fazer é fazer com que o procedimento de combinação chame o procedimento de
fatorial todas as vezes que for necessário.
Qualquer procedimento pode chamar outro procedimento apenas colocando-se o nome
do procedimento como se fosse uma instrução do VBA.
Sub Combinacao()
 .
 Microsoft© Access 97 Avançado
Reprodução proibida
35
 .
 Fatorial
 .
End Sub
Esquematicamente, a chamada de um procedimento por outro funciona assim:
Entretanto, o procedimento Fatorial exige que um valor seja informado. No caso,
informamos o valor com a função InputBox do VBA. O procedimento Fatorial também
fornece a resposta por meio da função MsgBox. Da forma como o procedimento foi escrito
ele é um procedimento completo e independente.
Para que o procedimento de combinação possa utilizar o procedimento Fatorial, de
forma a ambos funcionarem em conjunto, devemos modificar o procedimento Fatorial.
A primeira coisa a fazer é retirar a função InputBox do procedimento Fatorial. O
número para o qual se deseja calcular o fatorial deve ser passado como um argumento.
3.6.1. Passagem de Argumentos
Os parênteses à frente do nome do procedimento servem para receber argumentos
vindos de outro procedimento que o chamou. Argumentos são variáveis que receberão
valores, constituindo-se assim a entrada de dados para o procedimento.
Sub Fatorial(lngNumero As Long)
 Dim dblFatorial As Double
 Dim lngContador As Long
 dblFatorial = 1
 lngContador = 2
 If lngNumero = 0 Or lngNumero = 1 Then
 MsgBox "O fatorial é 1"
 Else
 Do While lngContador <= lngNumero
 dblFatorial = dblFatorial * lngContador
 lngContador = lngContador + 1
 Loop
 MsgBox "O fatorial é " + str(dblFatorial)
 End If
End Sub
Para um procedimento chamar outro passando argumentos, basta escrever o seu nome
e enviar a variável ou valor à frente do nome. No caso abaixo, o procedimento Combinacao
irá chamar o procedimento Fatorial, passando o valor 4 como argumento.
 Microsoft© Access 97 Avançado
Reprodução proibida
36
Sub Combinacao()
 .
 .
 Fatorial(4)
 .
End Sub
O outro problema do procedimento Fatorial é que o resultado é escrito na tela e não
pode ser usado pelo procedimento Combinacao. Devemos, portanto, transformar o
procedimento Fatorial de Sub para Function, de forma que ele possa retornar o resultado para
o procedimento que o chamou.
3.6.2. Retorno de Valor
Somente procedimentos do tipo Function podem retornar valor para o procedimento
que o chamou.
Para retornar um valor, usa-se o próprio nome do procedimento para retornar o valor.
Como procedimento do tipo Function retornam valor, eles precisam ter um tipo definido.
Function Fatorial(lngNumero As Long) As Double
 Dim dblFatorial As Double
 Dim lngContador As Long
 dblFatorial = 1
 lngContador = 2
 If lngNumero = 0 Or lngNumero = 1 Then
 Fatorial = 1
 Else
 Do While lngContador <= lngNumero
 dblFatorial = dblFatorial * lngContador
 lngContador = lngContador + 1
 Loop
 Fatorial = dblFatorial
 End If
End Sub
Note que em Fatorial = 1, Fatorial não é uma variável e sim o nome do procedimento.
1 é o valor a ser retornado. Note também que o procedimento Fatorial, que agora é do tipo
Function, tem o mesmo tipo de dado que a variável dblFatorial.
Agora, o procedimento Combinacao pode chamar a function Fatorial e armazenar o
valor de retorna em uma de suas variáveis.
Sub Combinacao()
 Dim N As Integer
 Dim P As Integer
 Dim dblFatN As Double
 Dim dblFatP As Double
 Dim dblFatNP As Double
 Dim dblResultado As Double
 Microsoft© Access 97 Avançado
Reprodução proibida
37
 N = InputBox("Entre com o valor de N")
 P = InputBox("Entre com o valor de P")
 dblFatN = Fatorial(N)
 dblFatP = Fatorial(P)
 dblFatNP = Fatorial(N - P)
 dblResultado = dblFatN / (dblFatP * dblFatNP)
 MsgBox dblResultado
End Sub
O procedimento Combinacao é um código completo, mas dependente da existência do
procedimento Fatorial. O procedimento Combinacao pode ser executado com F5, mas o
procedimento Fatorial não pode mais, por depender da passagem de um argumento.
Como a combinação é um código de uso geral, podemos transformá-lo também em
uma função, para que outro procedimento o chame. Neste caso, são necessários dois
argumentos.
Function Combinacao(intN As Integer, intP As Integer) As Double
 Dim dblFatN As Double
 Dim dblFatP As Double
 Dim dblFatNP As Double
 dblFatN = Fatorial(intN)
 dblFatP = Fatorial(intP)
 dblFatNP = Fatorial(intN - intP)
 Combinacao = dblFatN / (dblFatP * dblFatNP)
End Sub
Podemos testar a função Combinacao chamando-a de um outro procedimento, pois,
agora que ela recebe argumentos, ela não pode mais ser executada com F5.
Sub TestaCombinacao()
 Dim N As Integer, P As Integer
 N = 3
 P = 2
 MsgBox Combinacao(N,P)
End Sub
3.6.3. Passagem de Argumentos por Valor e por Referência
Os argumentos passados de um procedimento para outro podem ser por valor ou por
referência.
A passagem por valor indica que a variável enviada e a variável definida como
argumento são duas posições de memória distintas. Elas podem até ter os mesmos nomes.
Sub Teste1()
 Dim X As Integer
 X = 10
 MsgBox X ' Será escrito 10
 Teste2(X)
 MsgBox X ' Ainda será escrito 10
End Sub
 Microsoft© Access 97 Avançado
Reprodução proibida
38
Sub Teste2(X As Integer)
 MsgBox X ' Será escrito 10
 X = 20
 MsgBox X ' Será escrito 20
End Sub
No exemplo acima, a variável X do procedimento Teste1 contém o valor 10, e é
passado como argumento para o procedimento Teste2. Em Teste2, o valor é alterado para 20,
mas esta variável não tem nada a ver com o X de Teste1. Apenas o valor de X em Teste1 foi
passado para a variável X de Teste2. Ao retornar para Teste1, a variável X continua a ter o
valor original.
Em suma, a passagem de argumentos por valor equivale a copiar o valor para outra
variável.
Na passagem por referência, as alterações na alteração do argumento afetam o
conteúdo da variável que foi passada como argumento. Na passagem por referência, o
endereço de memória é que é passado para o procedimento. Assim, ambas as variáveis são na
realidade a mesma variável, mesmo que tenham nomes distintos
Sub Teste1()
 Dim X As Integer
 X = 10
 MsgBox X ' Será escrito 10
 Teste2 X
 MsgBox X ' Será escrito 20
End Sub
Sub Teste2(ByRef G As Integer)
 MsgBox G ' Será escrito 10
 G = 20
 MsgBox G ' Será escrito 20
End Sub
As palavras-chave ByRef e ByVal definem o tipo de passagem de argumento. O
padrão no VBA é ByRef, ou seja, se você não especificar nada, assume a passagem por
referência.
Entretanto, ByVal e ByRef sozinhos não garantem que os argumentos sejam passados
por valor e pro referência, respectivamente. O modo de chamada também define o tipo de
passagem.
Se na chamada do procedimento os argumentos forem passados entre parênteses,
entãoa passagem é por valor, independentemente de ByRef e ByVal.
Sub Teste1()
 Dim X As Integer
 X = 10
 MsgBox X ' Será escrito 10
 Teste2(X) ' Os parênteses definem que a passagem é por valor
 MsgBox X ' Será escrito 10
End Sub
Sub Teste2(ByRef G As Integer)
 MsgBox G ' Será escrito 10
 Microsoft© Access 97 Avançado
Reprodução proibida
39
 G = 20
 MsgBox G ' Será escrito 20
End Sub
Se na chamada do procedimento os argumentos não forem passados entre parênteses,
então o tipo de passagem será definido por ByRef e ByVal. Lembrando que ByRef é o padrão
do VBA.
Sub Teste1()
 Dim X As Integer
 X = 10
 MsgBox X ' Será escrito 10
 Teste2 X ' O tipo de passagem dependerá de ByRef ou ByVal
 MsgBox X ' Será escrito 10
End Sub
Sub Teste2(ByVal G As Integer)
 MsgBox G ' Será escrito 10
 G = 20
 MsgBox G ' Será escrito 20
End Sub
* * * * *
 Microsoft© Access 97 Avançado
Reprodução proibida
40
PRÁTICA 3 – CRIAÇÃO DE MÓDULO PADRÃO
EXERCÍCIO 1 – Criando um procedimento para cálculo de fatorial
Crie um módulo basFatorial contendo o procedimento Fatorial.
1. Abra o MS Access 97.
2. Crie um banco de dados vazio chamado dbPratica3.mdb.
3. Selecione a guia Módulos na janela de Banco de Dados.
4. Clique em Novo.
5. Digite o seguinte procedimento:
Sub Fatorial()
 Dim lngNumero As Long
 Dim dblFatorial As Double
 Dim lngContador As Long
 lngNumero = InputBox("Entre com um número")
 dblFatorial = 1
 lngContador = 2
 If lngNumero = 0 Or lngNumero = 1 Then
 MsgBox "O fatorial é 1"
 Else
 Do While lngContador <= lngNumero
 dblFatorial = dblFatorial * lngContador
 lngContador = lngContador + 1
 Loop
 MsgBox "O fatorial é " + str(dblFatorial)
 End If
End Sub
6. Compile o módulo e verifique se há algum erro. Corrija onde for necessaário.
7. Clique no menu Arquivo|Salvar.
8. Informe o nome basFatorial e clique OK..
9. Posisione o cursor em qualquer parte do código e execute o código passo-a-passo (F8).
10. Continue com a execução até a linha If lngNumero = 0 Or lngNumero = 1
Then.
11. Posicione o cursor sobre as variáveis e inspecione seu conteúdo.
12. Abra a janela Depurar (Control+G).
13. Inspecione as variáveis no painel Locais.
14. No Painel Imediato, digite:
? 2 * 50 + lngContador
15. Feche a janela de módulo e veja o nome do módulo basFatorial gravado na guia Módulos
da janela de Banco de Dados.
 Microsoft© Access 97 Avançado
Reprodução proibida
41
EXERCÍCIOS DE FIXAÇÃO – CRIAÇÃO DE MÓDULO PADRÃO
1) No MS Access 97, compilar significa:
a. ( ) Gerar um arquivo executável.
b. ( ) Gerar um arquivo objeto.
c. ( ) Criar um conjunto de discos de instalação do aplicativo.
d. ( ) Verificar a sintaxe dos comandos e a existência de variáveis e constantes não
declaradas.
e. ( ) Resumir os comandos.
2) A compilação abrange:
a. ( ) Somente módulos padrão
b. ( ) Somente os módulos que estão sendo editados.
c. ( ) Somente os módulos de classe de formulários/relatórios
d. ( ) Todos os módulos de um banco de dados especificado na caixa de diálogo Compilar.
e. ( ) Os módulos que estão sendo editados ou todos os módulos do banco de dados atual.
3) Os módulos padrão do MS Access 97 residem.
a. ( ) Na guia Módulos da janela de Banco de Dados do Access.
b. ( ) Na estrutura de formulários e relatórios.
c. ( ) Na guia Macros da janela de Banco de Dados do Access.
d. ( ) Na estrutura de tabelas ou consultas.
e. ( ) Em arquivos texto de extensão .bas.
4) Os módulos de classe do MS Access 97 residem.
a. ( ) Na guia Módulos da janela de Banco de Dados do Access.
b. ( ) Na guia Módulos da janela de Banco de Dados do Access ou na estrutura de
formulários e relatórios.
c. ( ) Na guia Macros da janela de Banco de Dados do Access.
d. ( ) Na estrutura de tabelas ou consultas.
e. ( ) Em arquivos texto de extensão .bas.
5) O código VBA em módulos do MS Access 97 são editados:
a. ( ) No Notepad.
b. ( ) No Visual Basic Enviroment.
c. ( ) Em janela de código do módulo dentro do próprio arquivo de banco de dados.
d. ( ) Em qualquer utilitário que edite arquivo texto.
e. ( ) No MS Word, quando este é definido como editor padrão de mensagens.
 Microsoft© Access 97 Avançado
Reprodução proibida
42
4. MÓDULO DE CLASSE EM FORMULÁRIO/RELATÓRIO
Cada formulário e relatório pode conter apenas um módulo. Este módulo é do tipo
módulo de classe. Este módulo não aparece como um objeto na guia de Módulos, pois fica
embutido no formulário/relatório. Por isso, ele era chamado Code Behind Form.
Os procedimentos estão relacionados a eventos do formulário, do relatório ou dos
controles do formulário (controles de relatório não geram evento). Os procedimentos são
criados no modo estrutura do formulário/relatório. No modo estrutura, com um objeto
selecionado, por exemplo o botão de comando cmdOk, na guia Eventos da janela de
propriedades seleciona-se o evento ao qual o procedimento estará associado. O evento pode
chamar uma macro ou um procedimento em código VBA.
Escolhendo [Procedimento de evento] e clicando-se no botão do Construtor de
Código, uma janela de módulo, semelhante a uma janela de módulo padrão, irá se abrir.
O nome do procedimento é gerado automaticamente. Ele é formado pelo nome do
objeto e pelo evento, separado por um sublinhado ( _ ). Por exemplo, para o controle
cmdCancel e evento Clicar o nome do procedimento é cmdCancel_Click.
Um código comum associado ao clicar sobre o botão Cancel é o do fechamento do
formulário corrente.
Private Sub cmdCancel_Click(Cancel As Integer)
 DoCmd.Close
End Sub
 Microsoft© Access 97 Avançado
Reprodução proibida
43
O procedimento de módulo de formulário ou de relatório só é executado quando o
evento do objeto associado ao procedimento ocorrer.
Como os procedimentos de evento recebem o nome do controle e do evento, é
extremamente recomendável não usar os nomes padrão fornecido pelo Access (Texto1,
Comando2, ect). Deve-se nomear os controles com um nome significativo na guia Outra da
janela de Propriedades.
Algumas das características vistas no módulo padrão se aplicam também no módulo
de classe, dentre elas: Compilação, execução passo-a-passo, ponto de interrupção e inspeção
de variáveis.
4.1. Coleções e Objetos de Formulário/Relatório
Formulários, relatórios e controles são objetos do Access e, portanto, possuem
propriedades, métodos e eventos. As propriedades e os eventos são acessíveis no modo
estrutura do formulário/relatório, na janela de Propriedades. Alterando-se as propriedades no
modo estrutura, os valores tornam-se estáticos. Por exemplo, se se define a Legenda do
formulário como “Menu Principal”, ela só pode ser alterada novamente no modo estrutura
NOTA: Controles de relatórios não possuem eventos.
Via programação, podemos ter acesso às propriedades dos objetos. Os valores das
propriedades podem ser alterados dinamicamente, durante a execução do código. A
programação permite também que os métodos dos objetos sejam invocados, algo que não é
possível no modo estrutura.
Todos os formulários do banco de dados formam a coleção de formulários. Todos os
relatórios do banco de dados formam a coleção de relatórios. Uma coleção é um objeto que
contém objetos de um mesmo tipo. Eis as coleções do Access.
Coleção Descrição
Forms Coleção de formulários abertos
Reports Coleção de relatórios abertos
Controls Coleção de controles em formulários ou relatórios abertos
Modules Coleção de módulos padrão e módulose de classe (inclusive módulos de classe
de formulário e de relatório)
A hierarquia completa dos objetos do Access é mostrada na figura abaixo:
 Microsoft© Access 97 Avançado
Reprodução proibida
44
Por ser um objeto, cada coleção possui também propriedades e métodos.
Para referenciar um objeto específico de uma coleção, pode-se usar quatro formas
diferentes:
Coleção(número do item)
Coleção(“Nome do item”)
Coleção![Nome do item]
Coleção.Item(número do item]
A primeira e a última forma têm a desvantagem deter que saber qual o número do
item dentro da coleção. Se existem vários formulários num banco de dados, cada um deles
recebe um número sequencial, começando do zero (0). Na última forma, Item é uma
propriedade da coleção.
As duas outras formas são mais compreeensíveis e mais fáceis de usar porque já
sabemos o nome do item.
Por exemplo, para referir a um formulário específico chamado frmPedidos, use a
expressão:
Forms![frmPedidos] ou Forms(“frmPedidos”)
Para referir-se a um relatórios chamado rptLista_de_Produtos, use a expressão:
Reports![rptLista_de_Produtos] ou Reports(“rptLista_de_Produtos”)
Para referir-se a um controle chamado txtPreçoUnitário, no formulário frmPedidos,
use a expressão:
Forms![frmPedidos]![txtPreçoUnitário]
Se o código estiver sendo escrito atrás do formulário frmPedidos, não é necessário
referir-se a ele mesmo como Forms![frmPedidos], mas simplesmente como Me!. Assim, a
referência ao controle txtPreçoUnitário pode ser simplificado para Me![txtPreçoUnitário].
NOTA: O objeto Form referencia formulários abertos. Formulários fechados são
referenciados pelo objeto Document da hierarquia de objetos do DAO – Data Access Objects.
 Microsoft© Access 97 Avançado
Reprodução proibida
45
4.2. Propriedades e Métodos
Se em vez de querer acessar um controle do formulário você quiser acessar suas
propriedades ou invocar seus métodos, use a expressão:
Forms![frmPedidos].Caption
ou simplesmente
Me.Caption
Para acessar uma propriedade de um controle ou invocar um de seus métodos, use a
expressão:
Forms![frmPedidos]![txtPreçoUnitário].BackColor
ou simplemente
Me![txtPreçoUnitário].BackColor
 O caracter ! é usado para indicar que o próximo elemento é um item definido pelo
usuário e o ponto indica que o próximo elemento é uma propriedade ou método. Você pode
usar o ponto para substituir a !, se quiser. Portanto, Forms![frmPedidos] equivale a
Forms.[frmPedidos].
Ao escrever um código VBA, se a opção “Listar membros automaticamente” do editor
de código estivar acionada, será exibida uma lista das propriedades e métodos do objeto e os
controles do objeto.
Algumas propriedades são somente para leitura, isto é, você não pode alterar o seu
valor, somente recurá-lo. Por exemplo, a propriedade Name é tipicamente uma propriedade
para somente leitura, já que o nome é fornecido ao salvar a estrutura de um objeto.
Todas as propriedades visíveis na janela de propriedades na estrutura de um
formulário são acessíveis via programação. Entretanto, existem várias propriedades que são
acessíveis somente no modo programado e não podem ser acessados no modo estrtutura. Por
exemplo, a propriedade Hwnd de um formulário está disponível somente no modo
programado.
4.3. Coleção padrão e propriedade padrão
Um objeto pode conter coleções. Um objeto formulário, por exemplo, contém a
coleção Controls. À rigor, a referência a um controle de um formulário deveria ser:
Forms![frmPedidos].Controls![txtPreçoUnitário]
Método
Propriedade
Controle
 Microsoft© Access 97 Avançado
Reprodução proibida
46
Mas como a coleção Controls é a coleção padrão do objeto Form, não é necessário
mencioná-lo.
Os objetos possuem várias propriedades, mas uma delas é a propriedade padrão. Por
exemplo, o controle caixa de texto possui a propriedade Text (o conteúdo da caixa de texto)
como padrão. Assim, pode-se omitir esta propriedade.
Forms![frmPedidos]![txtPreçoUnitário].Text = 3.00
equivale a
Forms![frmPedidos]![txtPreçoUnitário] = 3.00
4.4. Propriedades de Coleção
As coleções Forms, Reports e Controls possuem apenas propriedades, mas não
métodos. As propriedades são:
Application Retorna o objeto Application, no caso, o Microsoft Access. Somente
leitura. Como o retorno é um objeto, deve ser usado como Set obj =
object.Application
Sub ApplicationProperty( )
 Dim obj As Object
Set obj = Forms.Application ' Retorna o objeto
Microsoft Access
End Sub
Count Retorna a quantidade de objetos da coleção. Somente leitura.
Sub CountProperty( )
 Dim intForms As Integer
IntForms = Forms.Count
End Sub
Item Retorna o objeto em uma determinada posição ou índice dentro da coleção.
Somente leitura.
Sub ItemProperty( )
 Dim obj As Object
Set obj = Forms.Item(0) ' Retorna o primeiro objeto
form aberto
End Sub
Parent Retorna o objeto superior. Somente leitura. Como o retorno é um objeto,
deve ser usado como Set obj = object.Parent.
Sub ApplicationProperty( )
 Dim obj As Object
Set obj = Me.Controls(”txtCodigo”).Parent ' Retorna o
objeto form atual
End Sub
 Microsoft© Access 97 Avançado
Reprodução proibida
47
4.5. Seções de Formulário/Relatório
As seções dos formulários e relatórios são objetos, da mesma forma que controles. As
seções possuem propriedades e eventos, mas não métodos.
Deve-se tomar cuidado, pois, assim como os controles, o nome destes objetos é dado
automaticamente pelo Access, entretanto, não se justifica alterá-los. Na versão em inglês, os
nomes padrão são: FormHeader, FormFooter, Detail, PageHeader e PageFooter.
As propriedades e métodos das seções podem ser acessadas via programação,
entretanto, as seções PageHeader e PageFooter de relatórios não possuem propriedades nem
eventos que possam ser acessados via programação.
4.6. Eventos de Formulário
Eis alguns dos eventos de formulário para os quais pode-se definir código:
Evento Descrição
NoAtual (OnCurrent) O evento NoAtual ocorre quando o foco é movido para um registro,
tornando-o o registro atual, ou quando o formulário é aberto ou atualizado
ou quando sua consulta é repetida.
O Microsoft Access executa a macro ou procedimento de evento Current
antes de o primeiro ou próximo registro ser exibido.
Ao executar uma macro ou procedimento de evento quando ocorre o evento
Current de um formulário, é possível exibir uma mensagem ou sincronizar
registros em um outro formulário relacionado ao registro atual. Por
exemplo, quando o registro de um cliente torna-se o atual, você pode exibir
o pedido anterior do cliente. Quando o registro de um fornecedor torna-se o
atual, é possível exibir os produtos fabricados pelo fornecedor em um
formulário Fornecedores. Você também pode efetuar cálculos com base no
registro atual ou alterar o formulário em resposta aos dados desse registro.
Se a sua macro ou procedimento de evento executar uma ação
IrParaControle ou IrParaRegistro ou o método correspondente do objeto
DoCmd em resposta a um evento Open, ocorrerá o evento Current.
O evento Current também ocorre quando você atualiza um formulário ou
repete a tabela ou consulta base do formulário — por exemplo, quando
você clica em Remover Filtro/Classificação no menu Registros ou utiliza a
ação RepetirConsulta em uma macro ou o método Requery em código do
Visual Basic.
Quando você abre um formulário pela primeira vez, os eventos ocorrem na
ordem a seguir:
Open ð Load ð Resize ð Activate ð Current
Antes de Inserir (BeforeInsert) Ocorre quando o usuário digita o primeiro caractere de um novo registro,
mas antes de realmente o registro ser gravado. A ordem dos eventos é:
BeforeInsert ð BeforeUpdate ð AfterUpdate ð AfterInsert
Após Inserir (AfterInsert) Ocorre quando o registro passa a ser um novo registro.
Antes de Atualizar
(BeforeUpdate)
Ocorre quando o usuário atualiza o registro
Após Atualizar (AfterUpdate) Ocorre quando o registro é atualizado
 Microsoft© Access 97 Avançado
Reprodução proibida
48
Ao Excluir (OnDelete) Ocorre quando o usuário tecla DEL em um ou mais registros.
Confirmar Antes de Excluir
(BeforeDelConfirm)
Ocorre antes de o registro ser efetivametne excluído, quando o MS Access
apresenta a mensagem de confirmação da exclusão
Após Confirmar Exclusão
(AfterDelConfirm)
Ocorre após a confirmação da exclusão do registro.
Ao Abrir (OnOpen) Ocorre ao abrir o formulário. A ordem dos eventos é:
Open ð Load ð Resize ð Activate ð Current
Ao Carregar (OnLoad) Ocorre após o formulário ser aberto e carregar os dados para exibição.
Ao Redimensionar (OnResize) Ocorre ao redimensionar a janela do formulário.
Ao Descarregar (OnUnload) Ocorre antes