Escolar Documentos
Profissional Documentos
Cultura Documentos
2
2)Apresentando o Visual Basic......................................................................... 3
3)Usando Forms, objetos e controles.............................................................. 5
4)Propridades...................................................................................................... 6
5)O que são Forms(Formulários)........................................................................7
5)Métodos.......................................................................................................... ..7
6)Eventos............................................................................................................. 7
7)Controles........................................................................................................ . 8
Conhecendo melhor o formulário.................................................................. ..11
Botão de Comando..........................................................................................14
Label...............................................................................................................17
TextBox...........................................................................................................18
Option Button..................................................................................................22
Frame..............................................................................................................22
CheckBox........................................................................................................24
ListBox.............................................................................................................25
ComboBox.................................................................................................... ..30
MaskedBox......................................................................................................32
8)Contruindo um Sistema.................................................................................35
19)Menus............................................................................................................37
10)Menus Dinâmicos.........................................................................................39
11)O Código........................................................................................................40
12)Variáveis........................................................................................................41
13)Modifcadores de Acesso.............................................................................48
14)Constantes....................................................................................................49
15)Operadores...................................................................................................50
16)Comandos Condicionais e Loops..............................................................52
17)Contadores...................................................................................................58
18)SubProcedimentos......................................................................................60
19)Funções........................................................................................................62
20)Matrizes........................................................................................................63
21)Lógica de programação..............................................................................67
22)As Bibliotecas..............................................................................................68
23)Comandos, Funções e Objetos Nativos....................................................69
24)Funções Internas.........................................................................................74
Funções Numéricas........................................................................................74
Funções de String.......................................................................................... 75
Funções de Data e Hora.................................................................................78
Funções de Conversão...................................................................................81
Funções para Gerenciamento de Matrizes.....................................................83
Funções Lógicas.............................................................................................84
Funções de Disco.............................................................................................85
Funções de Escolha..........................................................................................88
Formatação de Dados.......................................................................................91
25)Banco de Dados
Criando um Banco de Dados............................................................................99
O que são tabelas?...........................................................................................100
Criando uma Tabela......................................................................................101
Criando Índices..............................................................................................106
Definindo a Chave Primária..........................................................................107
Acessando o Banco de Dados através do Visual Basic.................................108
26)Objetos de dados
Data Control...................................................................................................118
Data Grid........................................................................................................120
27)Impressão
Printer.............................................................................................................122
Crystal Reports...............................................................................................129
Noções de Linguagem SQL............................................................................145
O que é Programação ?
Se você nunca teve contato direto com programação na vida, talvez esteja se
perguntando, o que é afinal, programação. Embora talvez, você nunca tenha programado,
tudo que usamos, foi de alguma forma programado. Isso não acontece só no mundo da
informática, mas acontece também no mundo real. Por exemplo:
- Nas indústrias, já faz muito tempo que as máquinas vem sendo programadas para fazer
determinadas tarefas.
- Na sua casa, Você com certeza já programou o rádio-relógio para despertar de manhã, já
deve ter programado o vídeo-cassete e agora o DVD.
- Um automóvel, por exemplo, pode ser programado para limitar a velocidade máxima
através de um chip e para injetar mais gasolina depois que ele atingir uma velocidade X.
Como você pode ver, quase tudo a nossa volta foi de uma certea forma programado e
com a informática é assim também. OS famosos softwares que todo mundo usa (Windows,
Word, Excel, etc..) só existem por que foram programados.
Exempo de um código :
Claro, que neste exemplo estou usando comandos do Visual Basic, que talvez alguns de
vocês não conheçam. Não se preocupe em entender esse código agora. Vamos agora usar
comandos fictícios para ilustrar o que fizemos neste exempo:
Ao iniciar()
Mostrarmensagem “Hello,World”
Fim
FinalDoEvento
Não é necessário ser nenhum gênio para entender o que “msgbox” e “end” do exemplo
anterior faziam. Pois se olharmos o último exemplo , notamos que no lugar de “msgbox”
colocamos “mostrarmensagem” e no lugar do “end” usamos “fim”. O Interpretador irá ler a
primeira instrução(msgbox) e irá exibir uma mensagem dizendo:”Hello,World” e, logo após
encerrará o programa com o “End”.
O interpretador sempre segue uma ordem lógica para ler as intruções, então não podemos
colocar tudo de forma desordenada no código do programa, devemos colocar uma a uma,
2
na ordem que precisamos que ele leia primeiro. Mais tarde veremos comandos condicionais
e de laço para manipular essa execução.
Um bom programador tem que ser curioso. Deve gostar de saber como as coisas
funcionam debaixo da capô, não deve se preocupar em travar a máquina com “loops
infinitos”(se você não sabe o que é loop, veremos mais tarde) ou de qualquer outra forma.
Programação é uma arte. Envolve criatividade, análise , dedicação e muita paciência.
No momento nos limitaremos somente a usar o padrão “Standard Exe”, que é o que
usualmente usamos na maioria dos casos. Ele abrirá um projeto vazio, com os controles
nativos do Visual Basic á esquerda, um formulário e suas respectivas propriedades a direita.
3
Vejamos na figura:
Figura 1
Form(Formulário)
Esta é caixa de ferramentas onde temos Esta é caixa de propriedades, onde definimos
os controles disponíveis, Para usá-los , as propriedades do objeto selecionado
basta clicarmos e arrastarmos eles até o
Form(Formulário)
4
Usando Forms, Objetos e Controles
Objetos – Começaremos pelos Objetos já que os demais(Forms e Controles) Também se
enquadram como objetos. Devemos nos acostumar com os objetos, pois estaremos sempre
cercado deles. Qualquer Botão, Form, Relatório, Controles, entre outros se enquadram
como objetos.
Figura 1
Todos os objetos tem propriedades, eventos e métodos a eles associados. Veremos mais
tarde o que são métodos, eventos e propriedades dos objetos. No entanto o que é necessário
saber agora é o que são objetos. Vemos que objeto é tudo aquilo que contem métodos,
eventos e propriedades.
Na verdade, quase todas as janelas que vemos nos aplicativos são Forms(Formulários).
Ele serve de base para colocarmos nossos controles.
5
Na figura 1 (Exemplo anterior), vemos que existe um formulário, no nosso caso(Form1),
com controles dentro dele(Caixa de texto, Lista e Botão).
Os forms(Formulários), como qualquer objeto, possuem métodos, eventos e propriedades
a qual veremos mais tarde.
ObjetoTal.Cor=”Azul”
6
Claro, que o “ObjetoTal” e a propriedade “Cor” desse objeto são fictícios. Um Exemplo
real seria :
Text1.Text=”Exemplo”
Não se preocupe em entender o que quer dizer a propriedade “Text”, mas sim em
entender apenas como se faz para definir as propriedades em tempo de execução.
É importante ressaltar que cada objeto tem propriedades diferentes. Claro que todos tem
propriedades em comum, mas um tipo de objeto sempre terá propriedades diferentes de
outro tipo.
Métodos
Métodos são ações que agem sobre os objetos, por exempo, se temos um objeto carro,
teríamos a propriedade “Cor” semdo como Azul. Poderámos ter um método chamado
“Acelerar” e outro “Freiar”. Poderíamos também ter um método “abastecer”.
Em exempo prático seria termos um formulário chamado “Form1”. Existe um método
chamado “Show” que agem sobre formulário e outros objetos. Ele serve para exibir um
formulário. Como faríamos para exibir o nosso formulário(Form1)?
Form1.Show
Será exibido o formulário. Este é o procedimento para se aplicar os métodos. Assim como
as propriedades, cada objeto tem vários métodos diferentes. Podemos também passar
parâmetros para esses métodos. Veremos isso mais tarde
Eventos
Vamos tomar um exemplo prático. Voltaremos ao nosso exemplo do automóvel. Assim
como podemos atribuir sua propriedade cor para Azul, executar um método “Acelerar”,
podemos ter um evento
“Ao Bater”.
Um evento é gerado quando acontece algo com o objeto, por exemplo, se tivermos um
Caixa De Texto e clicarmos em cima dela o Objeto TextBox(Caixa de Texto) vai gerar um
evento chamado “Click()”. Dentro deste evento colocaríamos um bloco de código com as
instruções que queremos que o programa faça cada vez eu o usuário clicar na Caixa de
Texto. Assim como este , exitem muitos outros eventos e cada objeto tem seus eventos em
comum, assim como tem eventos próprios de cada objeto.
Veremos mais tarde detalhadamente vários tipos de eventos.
7
Nesta caixa podemos selecionar qualquer Neste outra caixa selecionamos os eventos
objeto existente no formulário correspondentes ao objeto selecionado
Os Controles
8
Esses controles que você está vendo na figura são os controles nativos do Visual Basic.
Podemos adicionar mais controles a esta Caixa de Ferramentas. Veja como :
Acesse o menu
Project e
selecione
Components
9
Irá aparecer uma lista com todos os controles disponíveis. Para que eles apareçam na nossa
Caixa de Ferramentas devemos selecion-alos nessa lista. Um controle, na verdade, é
representado por um Arquivo com extensão “OCX”. Podemos ver nessa janela que o Visual
Basic
Mostra o local onde determinado componente, ou seja , o arquivo OCX, se encontra. Se o
controle que você procura não se encontra nessa lista, basta você saber onde o arquivo
OCX dele se encontra, podendo assim adicioná-lo a lista.
10
Conhecendo melhor o Form(Formulário)
Veremos agora as principais propriedades, métodos e eventos do Form. Começremos com
as principais propriedades. São elas:
Caption – É a título do formulário que aparece no seu topo. Podemos colocar qualquer
valor nessa propriedade.
Como você pode ver, você pode optar entre 2 sistemas de cores.
O Palette e o System , sendo que o System mostra o sistema de cores do Windows, no caso
de você querer fazer uma aplicação bem padrão Windows, enquanto o Palette irá lhe
mostrar várias outras cores e você pode personalizar suas próprias cores também.
BorderStyle: Muda o tipo de borda do formulário. None: sem borda, sem barra de titulo,
sem menu de controle, sem botão maximizar e sem botão minimizar, e não pode
redimensionar a janela.
11
Fixed Single: Borda fixa. Aceita o Menu de Controle, Maximizar, Minimizar, barra de
título, mas não pode ser redimensionado.
(Default) Sizable: Borda comum. Possui o Menu de Controle, Maximizar, Minimizar,
barra de título e pode ser redimensionada.
Fixed Dialog: Muito usada para janelas que vão manter um dialogo com o usuário. Ela
pode ter Menu de controle e a barra de título, mas não terá os botões de maximizar e
Minimizar. Não pode ser redimensionada.
Fixed ToolWindow: Não possui o menu de controle, o botão Maximizar e o botão
minimizar. Também não pode ser redimensionada. Aparecerá somente a barra de título e o
botão Fechar próprio do Windows 95. Este tipo de formulário não aparece na barra de
tarefas do Windows.
Sizable ToolWindow: Não possui o menu de controle, o botão Maximizar e o botão
minimizar. Pode ser redimensionada. Aparecerá somente a barra de título e o botão Fechar
próprio do Windows 95. Este tipo de formulário não aparece na barra de tarefas do
Windows.
janela, poderá responder a eventos gerados pelo usuário, como clicar do mouse,
pressionamento de teclas, etc.
Font: Escolhe a fonte de letra padrão que será usada para todos objetos inseridos neste
formulário.
Icon: Nesta propriedade escolhemos um arquivo de ícone para associar a esse formulário.
Esse ícone é o que vai aparecer quando a janela for minimizada e no lado esquerda da barra
de título ( Menu de Controle ).
KeyPreview: determina se os eventos do teclado no formulário serão executados antes dos
eventos correspondentes aos Objetos inseridos no formulário.
MaxButton: Habilita ou não o botão de maximização.
MDIChild: Determina se a janela será uma janela filha. Ou seja, terá uma outra janela
mestre que agrupara o Form que se esta criando.
12
MinButton: Habilita ou não o botão de minimizar.
MouseIcon: Sempre que o mouse for movido em cima do formulário, o ícone associado a
esta propriedade aparecerá (desde que a propriedade MousePointer esteja customizada).
MousePointer: Nesta propriedade especificamos o tipo de ponteiro que o mouse terá
quando se mover sobre o formulário. Veja os tipos existentes:
13
Picture: Inseri uma figura em nosso formulário como papel de parede.
ShowInTaskbar: Habilita ou não a possibilidade da janela aparecer na barra de tarefas do
Windows.
Visible: Determina se quando executarmos o programa essa janela irá ficar visivel ou
invisível.
WindowState: Determina se, quando executarmos o programa, a janela irá aparecer na
tela do computador Normal, Maximizada ou Minimizada.
Bem, agora que você já conhece as principais propriedades do Form, vamos “Brincar um
pouco”.
Abra o Visual Basic e crie um projeto padrão. Você verá que por padrão o Visual Basic já
coloca um Form no projeto. Então modificaremos este Form. Altera as seguintes
propriedades:
Name = “FrmCadastro”
Caption=”Cadastro De Clientes”
BorderStyle = 1 – Fixed Single
Errado Certo
Cancel: Se esta opção for ajustada como verdadeira, o botão será associado a tecla ESC, e
sempre que pressionarmos esta tecla será como se tivéssemos apertado o botão.
14
Caption: O título que será exibido dentro do botão.
Default: Estando o botão com essa propriedade como True indica que este botão será o
Padrão da janela, e sempre que apertarmos a tecla Enter será como se tivéssemos apertado o
botão.
Enabled: Determina se o botão será habilitado para pressionamento por parte do usuário ou
não.
Font: Escolhe a fonte de letra que o Caption terá.
Name: O nome que daremos para o Objeto botão de comando.
Visible: Determina se o botão será visível para o usuário quando o programa estiver em
execução.
Style: Escolhe se o botão terá elemento gráfico em seu interior. Se escolher Style do tipo
"Graphical" o CommandButton aceitará figuras, e elas devem ser inseridas na propriedade
Picture do objeto CommandButton.
TabStop: Quando temos um formulário com diversos controles, podemos nos mover
através desses controles usando o teclado, através da tecla TAB ou através de outras teclas,
como veremos mais tarde. Quando a propriedade TabStop está desabilitada, ou seja com o
valor “False” então, ao nos movermos através dos controles o Botão será ignorado e o foco
movido ao controle seguinte.
TabIndex: o Movimento de troca de foco, que vimos na propriedade TabStop tem uma
ordem, e essa ordem é seguida pela propriedade TabIndex do botão, a qual devemos
atribuir um numero, esse número será usado como a ordem que o foco é percorrido pelos
controles, ou seja, se tivermos um controle com a propriedade TabIndex definido como 1, e
outro com a propriedade TabIndex definido como 2, o que tem o número 1, receberá o foco
primeiro do que tem o número 2 na propriedade TabIndex.
ToolTipText – A não muito usada, mas não menos importante propriedade ToolTipText,
quando não está vazia exibe uma pequena ajuda sobre o controle, quando o usuário passa o
mouse em cima do respectivo controle. O texto que aparecerá será o definido na
propriedade ToolTipText.
Botão 1:
Name = “CmdOk”
Caption = “OK”
Botão 2:
Name = “CmdCancelar”
Caption = “Cancelar”
Botão 3:
Name = “CmdSair”
Caption = “Sair”
15
Feito isso, dê um duplo click no objeto CmdOk. Você verá que ao clicar nesse botão abrirá
uma janela de código, correpondente ao evento Click() do botão. Esse evento é acionado
toda vez que o usuário clicar no botão.
Faça o mesmo processo com os demais botões. Apenas troque o texto que exiet dentro
das aspas pelo texto de sua preferência. Ao fazer esse processo com o botão “CmdSair”,
insira uma linha a mais:
Unload me
Execute o projeto e veja o que acontece. Você viu que criar a interface e fazer com que as
coisas “funcionem” não é nada difícil. Basta conhecer bem as propriedades, eventos e
métodos dos objetos.
Vamos agora conhecer os principais eventos do objeto CommandButton. Devo lembrar que
muitos desses eventos e até mesmo propriedades, dependo do caso até métodos, não são
16
exclusivo do CommandButton , ou seja, outros objetos também tem as mesmas
particularidades.
Eventos do CommandButton
A maioria dos eventos do CommandButton não são usados, por isso, vamos nos reter
apenas nos mais importantes. São eles:
Métodos
O CommandButton tem 7 métodos, mas na prática, dificilmente usamos todos. Na
verdade, usamos quase sempre apenas um deles:
SetFocus - Este método que não só é usado por CommandButtons, mas na verdade, é
usado por quase todos os controles, tem a função de passar o foco para o objeto que
quisermos. Exemplo:
CmdOk.SetFocus
O Label
Não há muito segredo para se trabalhar com Labels. O Label na verdade, não passa de
uma legenda que inserimos no Form. Sua finalidade é inserir um texto no formulário. Isto
nos será útil quando precisarmos fazer um cadastro ou coisa parecida. Vamos as suas
principais propriedades:
17
AutoSize: Com esta propriedade habilitada indicamos ao Controle para automaticamente
dimensionar seu tamanho ao tamanho do texto do label.
Note na figura que, quando o AutoSize foi passado para True, as marcas de seleção do label
foi ajustado para o tamanho do texto “label1”.
BackColor: Escolhe a cor de fundo que envolverá o label.
BackStyle: Escolhe entre o fundo Transparente ou Opaco para o label.
BorderStyle: Escolhe entre colocar uma moldura envolvendo o label ou não.
Enabled: Habilita ou desabilita o objeto. Quando esta em False fica com a cor de seu
conteúdo acinzentada.
Font: Escolhe a fonte de letra que terá o texto digitado na propriedade Caption.
ForeColor: Escolhe a cor da fonte de letra
Name: Nomeia o Objeto label. Como já foi dito é importante que todos os objetos seja
nomeado. A inicial do label é “lbl”.
Visible: Indica se o objeto será visível ou não para o usuário.
WordWrap: Quando o AutoSize esta em true, não é possível expandir o texto digitado na
propriedade Caption em outras linhas. Mas se passarmos essa propriedade WordWrap para
True isto poderá ser feito, bastando para isto dimensionarmos o label.
O TextBox
O TextBox é, com certeza, um dos controles mais importantes que você vai usar.
Formulários de cadastro, entradas de dados e até mesmo consultas necessitam que você
entre com os dados. Claro que temos outros controles disponíveis para isso, mas na maioria
dois casos, usamos o TextBox. Vamos as suas principais propriedades:
18
BackColor: Escolhe a cor de fundo da Caixa de Texto. Geralmente é branco.
BorderSytle: Tipo da borda: Fixa e simples, ou sem borda.
Enabled: Estando False o objeto não estará habilitado para interagir com o usuário.
Font: Escolhe a fonte de letra que será mostrada dentro da caixa de texto.
ForeColor: Escolhe a cor da fonte de letra.
Locked: Estando em false trava qualquer digitação na caixa de texto
MaxLength: Quantidade máxima de caracteres dentro da caixa de texto.
MultiLine: Habilita a possibilidade de se digitar mais de uma linha na caixa de texto.
Name: Nomeia o objeto TextBox. Geralmente com a inicial txt. Exemplo: Se formos usar
essa caixa de texto para que o usuário digite o nome do paciente, poderíamos abreviar
assim: txtNomePaciente.
PasswordChar: Se durante a digitação de qualquer dado na caixa de texto, quisermos que
o Visual Basic mostre outro caractere no lugar do caractere digitado, é só especificarmos
aqui qual queremos que seja mostrado. Muito usado para digitação de senhas.
ScrollBars: Estando a propriedade MultiLine habilitada, é interessante colocarmos um
ScrollBars na caixa de texto, pois ele acrescentará uma barra de rolagem que poderá ser:
rolagem que poderá ser:
1 - Horizontal
2 - Vertical
3 - Both:
Horizontal e
Vertical juntos.
Text: A propriedade Text é a mais importante deste Objeto. Todo o texto digitado pelo
usuário dentro da caixa de texto é incorporado nesta propriedade.
Eventos do TextBox
Irei citar aqui alguns dos principais eventos relacionados a caixa de texto.
Lembramos que todos os Eventos ocorre quando o usuário faz alguma ação. Por exemplo:
se ele aperta um botão aciona o Evento Click, se ele digita algo numa caixa de texto, aciona
o evento Change e KeyPress, se ele movimento o mouse sobre um objeto, aciona o evento
MouseMove.
Vamos explicar esses eventos aqui, mas antes é importante entendermos que cada
movimento ou ação do usuário dispara um evento no programa. Mas esses eventos somente
terão alguma reação se programarmos isto na janela de codificação.
Change: Ocorre sempre que o usuário altera o valor contido na caixa de texto.
Click: Ocorre quando o usuário pressiona o botão esquerdo do mouse sobre a caixa de
texto.
DlbClick: Se o usuário apertar duas vezes o botão esquerdo do mouse sobre a caixa de
texto
KeyDown: Ocorre quando o usuário aperta uma tecla no teclado.
KeyUp: Ocorre quando o usuário solta a tecla apertada.
KeyPress: Ocorre quando uma tecla é pressionada e solta. Como argumento possui uma
variável cujo conteúdo é a tecla pressionada (código correspondente na tabela ASCII).
19
Cod. Cod. Cod. Cod.
0 · 32 Espaço 64 @ 96 `
1 · 33 ! 65 A 97 a
2 · 34 " 66 B 98 b
3 · 35 # 67 C 99 c
4 · 36 $ 68 D 100 d
5 · 37 % 69 E 101 e
6 · 38 & 70 F 102 f
7 · 39 ' 71 G 103 g
8 Backsp 40 ( 72 H 104 h
ace
9 Tab 41 ) 73 I 105 i
10 42 * 74 J 106 j
11 · 43 + 75 K 107 k
12 · 44 , 76 L 108 l
13 Enter 45 - 77 M 109 m
14 · 46 . 78 N 110 n
15 · 47 / 79 O 111 o
16 · 48 0 80 P 112 p
17 · 49 1 81 Q 113 q
18 · 50 2 82 R 114 r
19 · 51 3 83 S 115 s
20 · 52 4 84 T 116 t
21 · 53 5 85 U 117 u
22 · 54 6 86 V 118 v
23 · 55 7 87 W 119 w
24 · 56 8 88 X 120 x
25 · 57 9 89 Y 121 y
26 · 58 : 90 Z 122 z
27 Esc· 59 ; 91 [ 123 {
28 · 60 < 92 \ 124 |
29 · 61 = 93 ] 125 }
30 · 62 > 94 ^ 126 ~
31 · 63 ? 95 _ 127 ·
· Estes caracteres não são aceitos pelo Microsoft Windows.
Bem, agora que você já conhece as propriedades do TextBox, assim como os seus
eventos, vamos colocar em prática tudo isso. Que tal um exemplo envolvendo Labels,
TextBoxs e CommandButtons ?
20
Lembra-se daquele formulário que fizemos como exemplo do CommandButton ?
Vamos melhorá-lo:
Quanto aos botões, você pode deixar todos. Apenas os arraste para o canto direito do
formulário. Coloque 3 Labels. Você verá que ao colocar a Label dentro do formulário ela
tem a propriedade Caption
Definida como o nome do Label. Você deve trocá-la. Coloque uma com o Caption =
“Código”, outra =”Nome” outra = “Endereço”. O formulário deve ficar assim :
TxtNome
Text=””
TxtEndereco
Text=””
Defina para que a TxtCodigo aceita no máximo 5 caracteres e txtnome no máximo 20.
Defina para que ao pressionarmos a tecla <TAB> o foco passe primeiro pelas caixas de
texto, de cima para baixo, e depois pelos botões, novamente, de cima para baixo. Veremos
mais tarde como fazer as TextBoxs aceitarem somente números, ou fazer o inverso(fazem
com que elas não aceitem números) através do evento keypress ou keydown.
21
OptionButton
O OptionButton ou botão de opção serve para escolhermos entre várias opções dentro do
formulário. Podemos ter vários dentro do formulário, mas apenas um poderá ser marcado,
pois quando marcamos um, o outro é automaticamente desmarcado. Para usarmos vários
grupos de opções dentro do mesmo formulário, teríamos que usar um Frame, Objeto que
Eventos do OptionButton
Os eventos do OptionButton são praticamente os mesmo usados pelas TextBox, sendo
que não há nenhum em especial.
O Frame
É claro que, depois do exemplo anterior não poderíamos deixar de conhecer o Frame.
Esse controle, como você viu anteriormente serve para organizarmos melhor os controles
22
dentro do formulário. Todos os controles existentes dentro do Frame podem ser
desabilitados ou habilitados definindo a propriedade Enabled de Frame como True ou
False. Além desses recursos de aninhar controles, o Frame também traz uma interface mais
limpa para o usuário. Vamos conhecer algumas de suas propriedades:
Como você pode ver o Frame da esquerda está com a propriedade Enabled definida como
False. Estando assim não conseguiremos acessar nem mesmo os controles que estão dentro
do Frame.
Esse recurso é muito útil quando queremos restringir ao usuário o acesso a certas opções.
O frame, assim como o OptionButton, também não possui nenhum evento em especial,
sendo a maioria idênticos aos do OptionButton.
23
CheckBox
A CheckBox ou Caixa de checagem é utilizado para marcar opções. Não funciona igual
ao OptioButton, pois com a CheckBox podemos marcar várias opções, uma, ou nenhuma
opção, sendo que com o OptionButton, podemos selecionar apenas uma.
Eventos
O CheckBox tem praticamente os mesmo eventos do OptionButton.
Bem, agora que já conhecemos vários controles, assim como suas respectivas propriedades,
métodos e eventos, vamos criar um Form utilizando vários desses objetos. Faremos o
seguinte:
Primeiro – Crie um Form com as fontes, cores e ícones de sua preferência. Será um
cadastro de clientes. Nesse cadastro será necessário:
Nome, endereço, bairro e cidade. Para isso serão necessárias 4 TextBoxs e 4 Labels, Certo ?
Nomeia-as e defina as suas propriedades de acordo com o que você acha necessário(Não
esqueça que você vai se referir aos controles dentro do código através dos seus respectivos
nomes, por isso siga a regra de nomenclatura adequada ou utilize um nome que você tem
certeza de que não irá esquecer).
24
2- Casado
3- Divorciado
4- Viúvo
Todas essas opções serão representadas pelos OptionButtons que você vai inserir dentro
do respectivo Frame. Siga as regras de nomenclatura padrão para atribuir os nomes aos
Frames e Optionbuttons.
Quarto – Insira um CheckBox, que vai ser utilizado para saber se o cliente reside em
Cachoeira do Sul. A legenda desse CheckBox poderia ser “Reside em Cachoeira do Sul” ou
qualquer outra de sua preferência desde que pergunte se o cliente mora ou não em
Cachoeira do Sul.
Quinto – Deixe todos os controles de modo que o foco passe primeiro pelas TextBoxs, de
cima para baixo, depois pelas opções, da esquerda para direita, e depois pelos botões, de
cima para baixo.
MsgBox “OK”
Prossiga com os demais da mesma forma, trocando apenas o “OK” pelo nome do botão.
Sexto - Bem, agora que já criamos a interface vamos fazer com que as coisas funcionem.
Se você observar no Form, poderemos ver que existe uma Caixa de Texto, onde é
perguntado ao usuário a cidade do cliente. No entanto, existe um CheckBox ou caixa de
checagem que pergunta ao usuário se o cliente reside em Cachoeira do Sul. Ora, se
soubermos que o cliente reside em Cachoeira do Sul não seria necessário informar a
cidade.Para isso, será necessário associar a um evento do CheckBox, uma instrução que
limpasse a caixa de texto, para caso já tivéssemos digitado alguma valor como Cidade, e
desabilitasse a mesma para que não colocássemos nenhum valor, sendo que o cliente reside
em Cachoeira do Sul. Mãos a obra.
O ListBox
O ListBox ou caixa de listagem é uma caixa a qual podemos adicionar itens, removê-los
ou selecioná-los.
25
Caixa de Lista Caixa de Lista
Vazia, sem Vazia com
nenhum texto vários nomes
digitado em seu inseridos na
interior. propriedade
List
O ListBox cria um índice com o número do item selecionado. Este índice sempre inicia
pelo zero, ou seja, se selecionarmos o primeiro item, o número dele será zero. Se
selecionarmos o segundo, ele retornará um. Este índice é visível através de uma
propriedade em tempo de execução que veremos mais tarde.
Enabled: Habilita ou não o ListBox para o usuário selecionar algum item no objeto.
IntegralHeight: Determina a possibilidade dos itens dentro da caixa de lista ser exibido de
forma parcial.
IntegralHeight
com TRUE
IntegralHeight
com FALSE
26
Os nomes digitados nesta
propriedade em tempo de
projeto são automaticamente
inseridos dentro do ListBox,
mas existe outro processo de
se incluir dados no objeto em
tempo de execução.
MultiSelect: Quando esta propriedade esta habilitada significa que a caixa de lista aceitará
múltiplas seleções, ou seja, poderá ser selecionado mais de um ítem. As opções são 0 -
None para seleção somente de 1 ítem. 1 - Simple para seleção de vários itens usando apenas
o clicar do mouse ou barra de espaço. 2 - Extended é o padrão do Windows para multiplas
seleções. Para selecionar mais de 1 item usa-se a combinação de tecla CTRL + Click do
mouse ou barra de espaço.
Name: Nome que o Objeto ListBox terá. A abreviação padrão é “lst”.
Sorted: Classifica os itens existentes dentro do ListBox em ordem alfabética ou numérica
ascendente. Esta propriedade em tempo de execução tem a finalidade de informar o estado
que se encontra o Sorted.
27
List: Retorna o texto do item especificado no índice. Exemplo: List(2) irá mostrar o texto
existendo na lista referente ao índice 2.
Eventos do ListBox
De novo aqui só temos o evento DblClick(), que é gerado toda vez que dermos um duplo
clique sobre um item do ListBox.
Procure usar sempre o DblClick(), e não o evento Click(). Pois para o usuário é mais
intuitivo dar dois cliques numa caixa de listagem para abrir um certo item do que apenas
um.
Métodos do ListBox
AddItem – Usamos este método sempre que queremos adicionar um item ao ListBox. A
sintaxe usada é a seguinte:
RemoveItem – Este outro método é usado para removermos um item do ListBox. A sintaxe
á seguinte:
Você pode notar que é necessário informar o índice do item que se deseja remover.
Geralmente para remover um certo item que encontra-se selecionado pelo usuário usamos:
ListBoxTal.RemoveItem ListBoxTal.ListIndex
ListBoxTal.Clear
28
isso fosse feito, a caixa de texto deveria ser limpa para que um novo texto pudesse ser
digitado nessa caixa de texto. A interface do formulário poderia ficar assim:
Claro que você pode incrementar com algumas legendas para facilitar para o usuário.
Por se tratar de um exemplo, vamos padronizar os nomes dos controles existentes no
formulário:
O botão de AdicionarItem irá se chamar “CmdAdd”
O botão de RemoverItem irá se chamar “CmdRemove”
O botão de Limpar irá se chamar “CmdLimpa”
A Caixa de Texto irá se chamar “TxtItem”
A Caixa de listagem simplesmente “Lista”
Você vai notar que ao tentarmos remover um item sem ter selecionado nada na lista o
sistema vai gerar um erro, pois o valor da propriedade ListIndex, que deveria se referir ao
índice do item selecionado estará como “-1”, isso por quê não há nenhum item selecionado.
Logo mais veremos comandos condicionais, a qual poderemos manipulá-los para que não
deixem esses tipos de erros acontecerem.
O objeto ComboBox
O ComboBox ou caixa de combinação é uma combinação de um TextBox(caixa de
texto) com um ListBox(caixa de listagem). Podemos digitar caracteres dentro dela, além de
podermos teclar na seta que existe á sua direita e selecionarmos dados previamente
inseridos em sua lista.
30
ComboBox com a caixa de lista
expandida. Pode-se escolher um nome
qualquer na lista que ele será
automaticamente levado até a caixa de
texto.
0 - Dropdown Combo: é a opção padrão do Objeto. Aqui pode-se digitar qualquer nome na
área de digitação, clicar a seta para baixo e escolher qualquer um dos itens que ele será
automaticamente inserido na área de texto.
1 - Simple Combo: Caixa de Combinação simples. Aparece em destaque a área de edição
de texto, onde podemos digitar algum item; ou selecionar qualquer um que esteja na caixa
de lista, que será inserido na área de texto. O botão em forma de seta para baixo não existe
neste tipo de ComboBox. Se aumentarmos o tamanho da Caixa de Combinação na vertical,
aparecerá a lista e esta ficará fixa. Caso deixamos ela somente do tamanho da área de texto,
então a lista não aparecerá, e se quisermos saber quais nomes existe teremos que apertar no
teclado a seta para baixo ou para cima, para que os itens existentes dentro da Lista
apareçam.
31
2 - Dropdown List: Neste tipo de Caixa de Combinação o usuário pode somente escolher
um item relacionado na lista, não podendo digitar nada. A área de texto não aceitará
digitação.
Text: Nesta propriedade digita-se um texto que ficará, como padrão, fixo na área de texto
na caixa de combinação. Geralmente deixa-se em branco. Podemos usar essa propriedade
também, em tempo de execução, para saber qual texto o usuário digitou ou selecionou.
Métodos do ComboBox
Os métodos usados pelo ComboBox são os mesmo usados pelo ListBox(AddItem,
RemoveItem e Clear).
MaskedBox
O MaskedBox aparenta ser uma caixa de texto. A diferença é que ele tem vários recursos
adicionais. Ele tem recursos que possibilitam a colocação de uma máscara onde ele só vai
aceitar caracteres digitados de acordo com a máscara. Por exemplo, se quisermos que ele
aceite apenas números, basta colocar a máscara correspondente que todos os caracteres que
não são números serão ignorados automaticamente. Vamos agora conhecer as propriedades:
Este objeto é semelhante a uma caixa de texto, entretanto ele possui alguns recursos
adicionais, como a possibilidade de colocar uma máscara para o texto que irá ser digitado e
validar a digitação automaticamente.
Veja as principais propriedades:
32
* ClipText : Retorna o texto digitado no objeto sem os caracteres que compõem a
máscara.
Format : Determina o formato que os dados serão exibidos.
Use a propriedade Format para exibir dados em um formato consistente, ou seja, os
dados serão exibidos neste formato, mesmo que o usuário digite os dados diferentemente do
formato. Por exemplo, se você definir a propriedade Format para “dd/mmm/yyyy”, todas as
datas digitadas serão exibidas no formato 18/Set/1995. Se o usuário digitar a data como
18/09/95 (ou qualquer outro formato de data válido), o Visual Basic converterá a exibição
para o formato estabelecido, que é dia / mês-por-extenso-abreviado / ano-com-4-digitos.
A propriedade Format afeta apenas a maneira como um valor é exibido e não como
ele é armazenado. Da mesma forma, um formato de exibição não é aplicado até que o
usuário termine a digitação e o controle perca o foco.
Nada é exibido no campo para sugerir ou controlar o formato no qual os dados são
inseridos.
Se você precisar controlar a maneira como os dados são digitados, use uma máscara de
entrada além de ou ao invés de um formato de exibição de dados. Se você quiser que os
dados sejam exibidos exatamente como foram inseridos, não defina a propriedade Format.
* FormattedText : Retorna o texto digitado, incluindo os caracteres que compõem a
máscara.
Mask : Máscara que moldará o controle.
O Visual Basic fornece duas propriedades que produzem resultados parecidos: a
propriedade Format e o Mask.
Use a propriedade Mask para exibir caracteres de exibição literais no campo com
espaços em branco a serem preenchidos. Por exemplo, se todos os números de telefones
que inserir em um campo tiverem o mesmo formato, você poderá criar uma máscara de
entrada:
33
branco. Por exemplo, a máscara de entrada anterior solicita que todas as entradas
contenham exatamente os dígitos necessários para completar um código de área e número
de telefone, e que somente dígitos possam ser inseridos em cada espaço em branco.
Quando você define uma máscara de entrada e a propriedade Format para o mesmo objeto,
a propriedade Format tem precedência quando os dados são exibidos. Isso significa que
mesmo você tendo salvo uma máscara de entrada, ela é ignorada quando os dados são
formatados. O dado original como foi digitado não é alterado; a propriedade Format só
afeta a maneira como os dados são exibidos.
MaxLength : Determina a quantidade máxima de caracteres que o MaskEdBox
pode ter.
Name: Nomeia o objeto. Geralmente inicia o nome com “msk”
PromptChar : Escolhe o caractere padrão que será exibido simbolizando o estado
vazio. Por default possui o caractere “_”, e aconselho a substituir pelo caractere de espaço.
Esta propriedade não aceita vazio.
PromptInclude : Determina se o caractere inserido na propriedade PromptChar será
incluído na propriedade Text.
* Text : Contém o texto digitado pelo usuário no objeto.
Evento ValidationError : Este evento ocorre sempre que o usuário digita alguma
entrada que não corresponde a máscara estabelecida.
34
Construindo um sistema
Um sistema em VB é constituído por vários componentes e dividido em várias partes.
Nós já conhecemos os formulários(Forms), mas num sistema podem conter vários outros
componentes:
- MDI Forms
- Módulos(Módule)
- Módulos classe(Class Module)
- Relatórios (Data Report)
- User Controls
Estes são os principais componentes. Existem muitos outros que fogem ao objetivo do
nosso curso. Alguns, como o Módulo Classe
E o User Control também não serão abordados neste curso, apenas você terá uma noção do
que é e para que serve.
Relatórios – São relatórios gerados por uma ferramenta. Existem para facilitar o
nosso trabalho de gerar relatórios. Tem várias funções úteis a quais veremos mais tarde. Há
outros geradores de relatório além do Data Report. Trataremos disso na seção Impressão.
DataEnvironment – Este componente é muito útil para tratarmos com banco de dados.
Facilita muito o acesso aos dados e nos possibilita manipular o Banco de Dados com
poucas linhas de código.
35
Para adicionar um componente, acesse o menu Project e selecione qual componente você
deseja adicionar.
Initialize – Este evento ocorre quando o Form é chamado, seja pelo Visual Basic, ou por
um módulo onde definimos uma instrução para chamá-lo.
Load – Ocorre sempre que o Form é carregado na memória. Poderámos dizer que é o
ponto de entrada em qualquer formulário. Quando o formulário é chamado, antes mesmo de
podermos visualizar ele na tela, o evento Load já está ocorrendo.
Activate – Este evento ocorre logo após o evento Load. Quando este evento ocorre já
podemos ver o Formulário.
Terminate – Este evento ocorre após o evento Unload . Quando ele ocorre o formulário já
não está mais na memória, e muito menos podemos visualizá-lo.
Bem, é fácil deduzir que se criarmos um projeto, não alterarmos nada, e colocarmos esse
projeto pra rodar, o interpretador primeiro percorreria o evento Initialize do formulário,
depois o evento Load e depois o evento Activate. Ao fecharmos ele percorreria o evento
Unload e depois o evento Terminate.
36
No entanto, um projeto pode iniciar também por um módulo. Existe um evento chamado
Main que o Visual basic sempre procura nos módulos do seu projeto, caso você defina para
que ele procure. Podemos optar entre 2 pontos de entrada em sua aplicação:
Vamos conhecer as propriedades de projeto onde podemos definir isso. Acesse o menu
“Project” e selecione “Properties”. No caso de você ter um projeto com o nome de
“Exemplo” aparecerá “Exemplo Properties”. Aparecerá a seguinte janela:
Nome do projeto
Descrição do projeto.
Também é opcional.
Um projeto médio ou grande sempre começa em um módulo, através do
subprocedimento Main .
Menus
Até agora vimos como inserir botões e muitos outros controles em um formulário. Mas e
se quiséssemos inserir menus.
O Visual Basic oferece um editor de menus muito simples. Acessando o menu Tools,
Menu Editor ou teclando <F2> você abrirá o Menu Editor.
37
A propriedade Caption
mostra a legenda que será
exibida no menu.
A propriedade Name é o
nome do menu, para que
possamos nos referenciar a ele
no código.
A propriedade ShortCut
permite escolhermos um
atalho pelo teclado para o
menu em uma lista.
38
O botão Delete deleta o
item de menu
selecionado
Avança em um nível o
item selecionado,
transformando-o assim
em um submenu.
Recua em um nível o
item selecionado.
Move o item
selecionado uma posição
abaixo
Move o item
selecionado uma posição
acima
O botão Next passa para O botão Insert insere um
o item de menu seguinte. menu na posição
selecionada.
Exemplo de submenus.
Todos são antecipados
Por “....”
Menus dinâmicos
Menus dinâmicos são aqueles menus que aparecem quando clicamos com o botão direito
do mouse em cima de algum item.
O comando que chama esses menus é o PopUpMenu e sua sintaxe é a seguinte:
Claro que ainda temos que saber quando usar esse comando. Podemos usá-lo então no
evento MouseUp do objeto que vai ter o menu. Como sabemos, o evento MouseUp
acontece toda vez que clicamos o botão do mouse em cima do objeto. Vamos conhecer
melhor o evento MouseUp :
39
Como você pode ver, o evento MouseUp nos passa parâmetros dizendo que botão foi
pressionado, que tecla estava pressionada no momento em que pressionamos o botão do
mouse, a linha e a coluna onde foi pressionado o botão.
Button : retorna um número inteiro que informa qual dos botões foram apertados:
1 Botão esquerdo pressionado. vbLeftButton
2 Botão direito pressionado. vbRightButton
4 Botão do centro pressionado. vbMiddleButton
Shift : retorna um número inteiro que informa qual tecla estava pressionada no
momento em que algum botão do mouse também foi pressionado.
1 SHIFT pressionado. vbShiftMask
2 CTRL pressionado. vbCtrlMask
4 ALT pressionado vbAltMask
X : Coordenada para linha
Y : Coordenada para Coluna
Exemplo:
O código
Já falamos várias vezes sobre código aqui, no entanto nosso código se resumiu a atribuir
propriedades em tempo de execução a alguns objetos. Não iríamos muito longe apenas com
isso. Precisaríamos de comandos, funções e muitos outros.
Antes de vermos cada um desses itens detalhadamente, seria necessário dividir o código
em:
- SubProcedimentos
- Funções de Usuário
- Propriedades
- Eventos
40
detalhadamente, assim como o método de declará-los no código, vamos conhecer a nossa
amiga “Janela de Código”. É nela que estaremos trabalhando a maior parte do tempo.
Variáveis
Você já deve conhecê-las da matemática, onde geralmente tínhamos a variável X ou
variável Y.
41
Em programação, ela tem a mesma função com vários recursos adicionais.
Na matemática, só tínhamos a variável numérica. Na programação temos vários tipos de
variáveis. Vamos conhecê-las:
Quando atribuímos um determinado valor a uma variável esse valor fica armazenado na
memória e quando nos referenciamos a essa variável novamente esse valor é lido na
memória. Portanto, devemos pensar bem antes de escolher qual variável usaremos para
o nosso valor.
Você viu que existem cinco tipos de variáveis apenas para tratar com números. A Integer
abrange um certo valor, a Long outro, a Single outro, a Double outro e a Currency é a mais
adequada para tratarmos com valores monetários .
Devemos usar exatamente o tipo de variável que precisamos. No caso de você precisar
colocar o número 100 numa variável, o tipo Integer se enquadra perfeitamente. Já se
usarmos Long para um valor desse porte, estaríamos desperdiçando memória.
O tipo Variant, por exemplo, permite-nos, de antemão, atribuí-lo com um valor a qual não
sabemos qual é. No entanto, devemos usar o tipo Variant com muito cuidado, pois tem um
consumo de memória bem superior aos outros tipos de variáveis.
O Visual Basic nos permite atribuir um valor a uma variável sem precisarmos declarar o
seu tipo. No entanto essa prática apesar de facilitar o trabalho, não é recomendada. Você
deve estar se perguntando por quê:
Bem, em primeiro lugar, imagine você um sistema com milhares de linhas de código. E
nessas linhas você tivesse a seguinte linha:
42
Digamos que você se distraia e digite:
O que irá acontecer é que o compilador não vai dar nenhum aviso de erro, por quê assim
como existe a variável “Nome” pode existir também a variável “Nomex”. Tudo bem, o
programa irá compilar sem problema o seu código. Mas e, quando você precisasse desse
valor dentro da variável “Nome”?
Resposta: Ela não estaria lá!
E seu código?
Se quebraria.
Daria erro em um certo ponto. Talvez você demoraria para notar o erro, mas cedo ou
tarde, em determinada parte, iria ver que o valor não estava sendo gravado ou qualquer
outro tipo de erro.
Esse tipo de problema é comum se você não optar que o Visual Basic exija
obrigatoriamente a Declaração de Variáveis. Para isso, acessamos o Tools, Options e
selecionamos “Require Variable Declaration”, como mostra a figura.
43
Com este procedimento, se uma variável não for declarada o Visual Basic vai gerar um
erro dizendo que a variável não foi declarada.
Você deve estar se perguntando onde, e, como se declara uma variável. Há várias
palavras chave para se declarar uma variável. Trataremos primeiro do comando Dim. Sua
sintaxe é a seguinte:
Exemplo:
Dim Nome as string
Declaramos a variável “Valor” como sendo do tipo “Currency”, que é o tipo que usamos
para valores monetários, e, logo após atribuímos a ela o valor de “58,34”
Vamos tratar agora os diferentes tipos de variáveis que se dividem em numéricas, string,
lógicas, datas , objects e variants.
Variáveis numéricas
Uma variável numérica pode ser do tipo Integer, Long, Single ou Double como já vimos
anteriormente. Você escolhe a variável de acordo com as suas necessidades. Procure sempre
utilizar o tipo de variável de acordo com o que você precisa. Por exemplo, se você irá
armazenar um número entre zero e 100 em uma variável numérica do tipo Long, você
estaria utilizando mais recursos do que seu valor necessita. Pois numa caso destes, a
variável Single seria totalmente cabível. É muito importante que o programador leve em
44
consideração casos como este. Pois em um programa grande o gerenciamento de recursos é
de extrema importância.
Procure usar as variáveis numéricas apenas quando estas forem objetos de cálculos, ou
seja, use-as apenas quando for realizar operações matemáticas com os seus valores. Por
exemplo, você não precisa utilizar um tipo numérico para uma variável numérica que vai
conter um “Cpf” ou um “número de identidade”.
Variáveis Lógicas(Boolean)
Permitem somente dois valores: True or False. Ou seja, verdadeiro ou falso.
Este tipo de variável parece não nos prometer nada, mas são de extrema importância
dentro de um programa. Quando declaramos uma variável do tipo Boolean, ele é definida
automaticamente como False(Falso) e só passa a ser True(Verdadeiro) quando assim for
definida. Exemplo:
Declaramos duas variáveis, uma do tipo String, e outra do tipo lógica(Boolean). A variável
lógica “NomeIgual” tem a função de analisar a comparação entre a variável nome e uma
string qualquer. Se essa comparação for verdadeira, ele retornará true, e vice-versa. No
nosso exemplo acima, temos a variável “Nome” com o conteúdo “Maria da Silva”. A
comparamos com a string “Maria” e o resultado que a variável “NomeIgual” dará é False,
por quê a comparação não é verdadeira. Vejamos agora como a variável “NomeIgual”
poderia retornar True:
Convém observar que se trocássemos uma letra que fosse, de maiúscula para minúscula a
variável lógica “NomeIgual” já retornaria False.
45
Variável String
Ao tratarmos sobre as variáveis lógicas falamos sobre “String”. Uma string na verdade
pode ser o conteúdo de uma variável do tipo “String” ou qualquer conteúdo delimitado por
“” aspas. Uma string aceita caracteres alfanuméricos, símbolos, etc. Podemos fazer
concatenação com essas strings, assim como extrair uma parte de seu conteúdo e até fazer
comparações.
Concatenação seria juntarmos duas strings em uma só. Podemos usar para isso o
operador “+” ou o “&”. Exemplo:
“Visual “ + “Basic” resultaria “Visual Basic”
“13” + “12” resultaria “1312”
“Visual ” & “Basic” resultaria “Visual Basic”
“13” & “12” resultaria “1312”
Bem, olhando assim parece que o operador “+” e operador “&” são iguais, mas na
verdade não. A diferença está que o operador “+” força a soma e operador “&” força a
concatenação. Vejamos:
12 + ”13” resultaria 25
Note que ao tentarmos concatenar com o operador “+” uma string e um dado numérico ele
somou e transformou o resultado em um valor numérico.
Agora ficou bem claro que o operador “+” ao encontrar 2 tipos diferentes, ou seja, um
valor numérico e uma string, ele os somará e irá transformá-los em um valor numérico,
enquanto que o operador “&”, ao encontrar 2 tipos diferentes irá forçar a concatenação,
pegando o valor numérico e concatenando com a string, transformando assim o resultado
em uma string.
Resumindo, podemos usar tanto o operador “+” quanto o operador “&” para concatenar
strings, apesar de que geralmente é mais usado o “&”.
Variável Date
A variável Date nos possibilita o armazenamento de datas, porém, também podemos
armazenar horas. Quando atribuímos uma data a uma variável devemos usar o operador #.
Exemplo:
Data = #01/01/2001#
Data = 01/01/2001
46
Ou assim:
Data = ”01/01/2001”
Se a variável foi já foi declarada como Date, o programa retornará um erro dizendo que o
que estamos tentando passar não é uma data. Se a variável ainda não foi declarada, no
primeiro exemplo, ele pensará que estamos tentando dividir 01 por 01 por 2001 e colocará
o resultado na variável. No segundo ele armazenará uma string na variável tornando assim
uma variável do tipo String.
A variável Date nos possibilita fazer alguns cálculos:
a = #15/07/96#
b = #30/07/96#
b - a = 15 (Uma data menos outra retorna o intervalo em dias)
a + 3 = #18/07/96# ( uma data mais um valor numérico soma a quantidade de dias na data)
a - 3 = #12/07/96# ( uma data menos um valor numérico subtrai a quantidade de dias na
data.
Variável Variant
A variável do tipo Variant como o próprio nome sugere é uma variável que se transforma
em qualquer tipo, dependendo do conteúdo que lhe é atribuído. Por exemplo, se tivermos
uma variável “A” e atribuímos A=”José”, A será do tipo String, já se atribuirmos A = 1, A
será do tipo Integer.
A uso desse tipo de variável só é aconselhado quando não temos a menor idéia do
conteúdo que será atribuído a ela, pois uma variável do tipo VARIANT utiliza mais
recursos do que os outros tipos.
47
Crie um projeto novo no VB. Insira um TextBox no formulário. Agora coloque o código
acima no evento LOAD do Form e rode o projeto. Você verá que aparecerá a caixa de texto
com o texto “olá” em seu interior. Bem, vejamos como isso aconteceu.
Primeiro, criamos uma variável chamada Objeto, como sendo do tipo OBJECT.
Depois á instanciamos. Imagine o ato de instanciar como estar apontando para objeto.
Como tornar a variável um espelho do objeto.
Depois de instanciarmos a variável Objeto, fazendo que ela aponte para “Text1”(nossa
TextBox), podemos modificar as suas propriedades através da variável:
Objeto.text=”olá”
Simples, não é mesmo. Note que, ao declarar a variável, poderíamos usar diretamente o
tipo TEXTBOX. Pois como já falamos anteriormente, o Tipo Object seria como o Tipo
VARIANT, só que para objetos. Este exemplo usou um TextBox, mas poderíamos usar com
qualquer outro objeto existente no projeto.
Veremos instanciação com maiores detalhes mais adiante.
Declaração de Variáveis
O Visual Basic nos permite declarar variáveis em qualquer parte do código, no entanto,
existem algumas observações a serem feitas:
- Para que uma variável seja vista por todo o módulo, formulário, ou qualquer outro objeto
que a contém, a mesma deve ser declarada na seção General, Declarations do módulo.
- Para que a variável seja vista pelo projeto inteiro, devemos declará-la como Public, no
módulo principal. Veremos agora o que significa Public , assim como os demais
modificadores de acesso.
Modificadores de acesso
48
Os modificadores de acesso mudam a forma como o programa enxerga as variáveis. Se
declararmos uma variável usando no lugar de DIM a palavra chave PUBLIC na seção
General-Declarations do módulo principal, esta variável poderá ser usada em qualquer parte
do projeto.
Esta variável poderá ser usada dentro de qualquer formulário sem problemas. Já se
declararmos uma variável pública dentro de um formnulário, também poderíamos usá-la em
qualquer parte do projeto, no entanto devemos antecipá-la com o nome do formulário e um
ponto. Exemplo:
FormularioTal.Nome
Constantes
Uma constante é uma variável que terá um valor somente leitura, ou seja, poderemos
apenas ler o seu valor, mas não poderemos modificá-la. É útil quando temos um
determinado valor que é referenciado várias vezes dentro do projeto, e queremos uma
variável para representar esse valor, de forma que não precisemos mais digitar toda vez esse
valor.
Para declararem constantes, usamos a instrução CONST. Exemplo:
O tipo da constante não é obrigatório, de forma que a linha acima poderia ficar assim:
Const Numero = 3
No lugar do número 3 poderíamos usar qualquer expressão, seja ela uma string, ou uma
operação matemática, ou qualquer outra expressão válida envolvendo outras constantes.
As constantes são declaradas como Private por padrão, no entanto podemos usar os
modificadores de acesso Public antecipando a declaração. Exemplo:
49
FormularioTal.Data
Operadores
Agora que já aprendemos a trabalhar com variáveis, vamos conhecer os operadores, que
serão essências para a manipulação dos valores de nossas variáveis. Com eles, poderemos
realizar operações matemáticas, lógicas, etc. Os operadores se dividem em:
- Matemáticos
- Relacionais
- Lógicos
- String
Assim como na matemática, esses operadores sempre respeitam uma ordem para realizar os
cálculos:
1ª. Exponenciação
2ª. Multiplicação e Divisão
3ª. Adição e Subtração
7+3*2-4^2/2
Resultaria 5.
O programa primeiro calcularia as operações de exponenciação, depois de multiplicação
e divisão, e depois sim, irá realizar as operações de soma e subtração.
Caso quiséssemos que ele primeiro somasse, bastaria colocarmos a soma entre
parênteses:
50
(7+3)*2-4^2/2
Resultaria 12.
And – O mais usado de todos os operadores. Representa a palavra “E” em uma expressão.
Por exemplo:
A = 5 and b = 7
Significa a igual a 5 e b = 7
A = 5 or B = 7
Significa a igual a 5 ou B = 7
Para facilitar o entendimento, imagine o operador NOT antes da expressão como se fosse a
palavra NÂO.
Operadores de String
51
Como já vimos anteriormente, são representados pelo “+” e pelo “&”, sendo que o “+”
força o cálculo, no caso de termos uma das expressões sendo numérica, enquanto o “&”
força a concatenação, no caso de termos uma das partes sendo string e outra numérica. Para
maiores detalhes, consulte a seção anterior.
If <Condição> then
Else
Endif
52
Endif =Fim Do Comando SE
Vejamos um exemplo:
No caso da condição especificada no comando If, ou seja que 0o número seja maior que
2, então o bloco de código entre If e Else será executado. No caso da condição ser falsa,
será executado o bloco de código entre Else e Endif.
Além do If, Then, Else e Endif, temos também o ElseIf. Vejamos a sua sintaxe:
If <Condição> then
<Código a ser executado, caso a condição especificada no bloco If seja falsa e, a condição
do comando ElseIf seja verdadeira>
Else
Endif
Como você pode ver, o comando ElseIf, nos permite inserirmos mais opções condicionais
no comando IF. Quando a condição do comando If for falsa, o programa procura pelo
comando ElseIf, se ele existir. Sendo a condição do bloco ElseIf verdadeira, ele executa o
bloco do ElseIf. Podemos colocar quantos comandos ElseIf quisermos em um Bloco IF.
No caso de nenhuma das condições forem verdadeiras, será executado o Bloco Else, se ele
existir. É importante lembrar, que, por todo o bloco IF, o bloco de código que será lido
será o primeiro que a condição for verdadeira, sendo as demais ignoradas, e o programa
passando a executar a partir de Endif.
53
Numero = 4
If Numero = 1 then
Msgbox “Numero igual a 1”
Elseif Numero > 5 then
Msgbox “Numero maior que 5”
Else
Msgbox “Numero não é igual a 1 e não é maior que 5”
End if
No código acima, o comando If testa a variável Numero, que tem seu valor como 4. A
condição do comando If é caso a variável Numero seja igual a 1. Como ela não é, o
programa passa automaticamente para a próxima condição, ou seja, a do comando ElseIf,
que testa a variável, pra ver se ela é maior do que 5. Como o valor da variável é 4, no caso,
não é maior que 5, o programa passa novamente para a próxima condição. No nosso
exemplo, não temos mais nenhuma condição. Como nenhuma das condições foi verdadeira,
ele executará o bloco Else, que sempre é executado quando nenhumas das condições forem
verdadeiras.
Note que podemos ter quantos ElseIf quisermos em um bloco If, mas apenas um Else,
pois só ele será executado quando nenhuma das condições forem verdadeiras.
Lembram-se daquele nosso problema do cadastro com o nome do cliente em branco?
O nosso maior problema seria verificar se o TextBox estava vazio, e informar ao usuário
somente quando tivermos certeza que o TextBox está vazio. Vejamos como fazer isso:
Digamos que você tenha um TextBox chamado TxtCli e Um botão de comando chamado
CmdGravar.
Vamos usar o evento Click do botão. Ficaria assim:
If TxtCli.Text = “” then
onde “” representa uma string vazia. Poderíamos usar a constante Empty do VB também:
54
Se a condição for verdadeira, ou seja, se TxtCli estiver vazia, o bloco de código existente
entre If e Else, no caso do nosso exemplo, será executado.
Exibirá uma mensagem ao usuário dizendo que o código do cliente não foi informado,
depois moverá o foco para o TextBox.
Em caso da condição de IF não ser verdadeira, executará o bloco ELSE.
Informando ao usuário que o cadastro está ok. Por este exemplo podemos notar o quanto os
comandos condicionais facilitam nossa vida. Em continuidade aos comandos condicionais,
veremos mais um.
Select Case
O Select Case funciona de forma semelhante ao IF, mas é uma alternativa mais usada no
caso de termos um número de opções maiores.
Opção = 3
Case 1
<Bloco de código a ser executado, no caso da variável opção ser igual a 1>
Case 2
<Bloco de código a ser executado, no caso da variável opção ser igual a 1>
Case 3
<Bloco de código a ser executado, no caso da variável opção ser igual a 1>
Case Else
<Bloco de código a ser executado, no caso da variável opção não se enquadrar em nenhum
dos casos>
End Select
55
Select case Opção
Case 1
Note que não é necessário usarmos o nome da variável no caso. Isso por quê quando
iniciamos o SELECT CASE, já definimos que a expressão que iríamos testar seria a
variável Opção. Então a linha Case 1 testa se a variável Opção é igual a 1.
Se a variável Opção não for igual a 1, ela passará para o próximo caso:
Case 2
Não sendo a variável Opção igual a 2, ela passará para o próximo caso, e assim
sucessivamente até chegarmos no CASE ELSE, se ele existir. O CASE ELSE funciona
como o ELSE, do comando IF. Ele será executado quando nenhum dos casos for
verdadeiro.
O comando END SELECT encerra o SELECT CASE.
Comandos de Laço(Loops)
Os comandos de laço ou loopings são extremamente usados na programação. Fazem que
determinado bloco de código se repita até que uma condição seja ou se torne verdadeira.
Podem ser usados de várias maneiras. Veremos as formas mais usadas.
Do While, Loop
Este comando executa os comandos existentes entre Do While e Loop enquanto as
condições estabelecidas no comando Do While forem verdadeiras. Sua sintaxe é a seguinte.
Do While <Condição>
Loop
56
No código acima, temos uma variável Contador, que é igual a 0, o comando Do While
pede que o Loop se execute até que a variável contador seja menor que 11. A cada Loop
que se passa a variável Contador aumenta seu valor em 1. Quanto ela chegar a 11, O
comando Do While avaliará a condição e no caso dela não ser mais menor que 11, o
programa passará automaticamente a próxima linha após o comando Loop.
Do
Loop <Condição>
Do Until, Loop
O Do Until funciona da maneira inversa ao comando Do While. Enquanto o comando
Do While repete o laço(looping) , enquanto determinada condição for verdadeira, o
comando Do Until, repete o looping até que essa condição se torne verdadeira, ou seja, ele
repete a condição enquanto ela não for verdadeira.
No exemplo acima, o laço se repetirá até que a variável Contador satisfaça a condição
especificada em Do Until. Ou seja, quando a variável Contador for maior que 11, ou seja,
quando a variável
Contador for 12, o ciclo se encerrará.
57
Dim Contador as Integer
Contador = 1
Do
Print Contador
Contador = Contador + 1
Loop Until Contador > 11
Contadores
Agora que já vimos os comandos condicionais, passaremos aos contadores. Os
contadores tem inúmeras aplicações em programação. Vamos ao principal comando usado
como contador:
For, Next
O comando For realiza uma contagem entre um intervalo de números especificados.
<Bloco de código>
Next
Podemos pedir ao comando FOR que conte de forma diferente através do comando STEP.
O comando STEP modifica a forma com que o contador é incrementado. Por padrão, ele
será incrementado de 1 em 1. Com o comando STEP podemos configurar do modo que
quisermos.
58
Os comandos EXIT DO e EXIT FOR, forçam a saída de um loop ou de um contador,
respectivamente.
O comando EXIT DO nos permite forçarmos a saída de um loop criado através do
comando DO.
Dim Numero as Integer
Numero=0
Do While Numero<10
Print Numero
Numero = Numero +1
If Contador = 5 then
Exit Do
End if
Loop
O código acima sem o comando Exit Do iria contar até 9. Entretanto, temos um desvio
condicional que nos diz que se o número for igual a 5, o comando EXIT DO será
executado, e no entanto, o loop será quebrado.
O comando EXIT FOR força a saída de um contador. Vejamos um exemplo com a
mesma função do código anterior, porém usando um contador:
Bem, já conhecemos o suficiente sobre contadores para podermos colocar tudo isso em
prática. Então vamos fazer o seguinte:
- Insira um Botão que servirá para procurar determinado nome na lista e dizer se ele
existe ou não
Atenção:
O exercício deve ser feito utilizando um contador.
Solução:
Dim Contador As Integer
59
Dim NaoEncontrado As Boolean
For Contador = 0 To Lista.ListCount - 1
If Lista.List(Contador) = "NomeTal" Then
MsgBox "Encontrado"
NaoEncontrado = False
Exit For
End If
NaoEncontrado = True
Next
SubProcedimentos
Também podem ser chamados de subrotinas, procedimentos ou simplesmente rotinas.
Tem uma função específica dentro do projeto. Ou seja, em um projeto podemos ter uma
rotina de cadastro, uma de consulta, impressão, etc.
Um projeto médio ou grande que não fosse dividido em rotinas seria um verdadeiro
inferno para o programador, e para o usuário também. Em vista dos problemas que
acarretaria devido à demora na manutenção.
Além de organizar melhor o projeto, as subprocedimentos podem oferecer o
reaproveitamento de código, muito importante nos dias atuais quando se está sempre
correndo contra o relógio. Os subprocedimentos aceitam parâmetros, o que significa que
podemos tratar diferentes valores usando apenas um subprocedimento. Vejamos um
exemplo prático do que eu estou dizendo.
No nosso exercício anterior, utilizamos um contador que verificava se determinado nome
existia na lista. Digamos que quiséssemos mudar esse nome. Poderíamos criar um
subprocedimento passando para ele toda vez que o chamarmos o nome que queremos
procurar. Estaríamos passando um parâmetro para ele. Podemos colocar vários parâmetros
em um procedimento. Sejam eles variáveis, valores ou objetos.
Na verdade, já estamos trabalhando com subprocedimentos desde o início. Ao codificar
um evento Click de um botão de comando, você já está trabalhando em um
subprocedimento. A diferença é que este já é um subprocedimento padrão do botão.
Para criarmos um subprocedimento usamos a seguinte sintaxe:
End Sub
60
A palavra Private pode ser substituída por Public, caso precisarmos que o nosso
subprocedimento possa ser acessado por um módulo externo.
Quanto aos parâmetros podem ser passados da mesma forma que declaramos variáveis,
com a diferença que não precisamos usar o comando DIM. Esses parâmetros funcionam
como variáveis dentro do procedimento.
Poderíamos criar um subprocedimento para resolver aquele nosso problema anterior:
End Sub
Note que o único trabalho que tivemos na alteração do código foi trocar o nome que
procuraríamos pela variável Nome, que ao chamarmos o subprocedimento, terá o nome a
qual informamos no parâmetro.
Para chamarmos um subprocedimento, bastar chamá-lo pelo nome, com os seus
respectivos parâmetros:
ProcurarNaLista(“Maria da Silva”)
61
If Lista.List(Contador) = Nome Then
MsgBox "Encontrado"
NaoEncontrado = False
Exit For
End If
NaoEncontrado = True
Next
End Sub
No código acima, o contador nem chega a ser inciado e o comando Exit Sub já termina a
execução do subprocedimento, fazendo que todos os comandos do subprocedimento que
estiverem após o Exit Sub sejam ignorados.
Funções
Sua finalidade é retornar um valor, mas também podem executar operações. Temos
várias funções nativas do Visual Basic, a qual veremos logo mais, mas também podemos
construir nossas próprias funções. As funções são declaradas da mesma maneira que os
subprocedimentos, com a diferença que usaremos a palavra FUNCTION no lugar da
palavra SUB.
End Function
62
End Function
Ao Criarmos uma função, você pode automaticamente atribuir qualquer valor a ela, desde
que seja dentro da função. O Tipo de valor que a Function Soma terá vai depender do
valor que a ela for atribuído. Entretanto, podemos definir esse tipo na declaração da função:
Matrizes
Uma matriz nos possibilita o armazenamento de vários valores em uma única variável.
Isso porque ele possui níveis dentro dela. Para declararmos uma matriz usamos a seguinte
sintaxe:
Por exemplo, se quisermos ter uma variável chamada Nome armazenarmos 3 nomes
diferentes, faríamos o seguinte:
É importante lembrar que o número que vai entre parênteses quando declaramos a matriz
não é o número de níveis que existirá na matriz, pois a matriz por padrão sempre inicia com
o número zero. Por padrão, o número de níveis que existirá na matriz será o número que
colocarmos entre parênteses menos 1. Entretanto, podemos mudar isso definindo um nível
inicial e um nível final dentro da matriz. Para isso fazemos o seguinte:
63
Dim Matriz(1 to 10) as Integer
Como você pode ver, ao invés de usarmos somente um número que será o nível máximo
dentro da matriz, especificamos que os níveis existentes serão entre 1 e 10. Ou seja, o
primeiro nível será 1 e o último 10. Podemos especificar qualquer número inicial e a matriz
sempre existirá a partir daquele número. Por exemplo, se você definir para que a matriz
inicie por 2, se tentar usar a matriz como se o nível 1 existisse, o Visual Basic irá gerar um
erro em tempo de execução.
No nosso exemplo anterior usamos Dim Nome(2) as String
para declararmos uma matriz de 3 níveis, que terá Nome(0) como primeiro nível e
Nome(2) como o último nível.
Existe outra forma de fazer com que o primeiro nível de uma matriz não seja zero, que é
usando o comando Option Base. Com ele podemos definir um valor para ser um valor
inicial de todas as matrizes que forem criadas. O comando Option Base deve ser
adicionado á seção General-Declarations:
Se quisermos que todas as matrizes no módulo que o Option Base for declarado, usaremos
Option Base 1. Se quisermos que iniciem com 2, Option Base 2, e assim sucessivamente.
Todos os níveis dentro da matriz deverão ter valores de acordo com o tipo que foi
declarado, a menos que você declare uma matriz como sendo do tipo Variant.
No lugar do número que define o nível da matriz podemos usar também variáveis. Essa
prática é muito utilizada para iterar por todos os níveis da matriz, preenchendo-a com
valores. Veja um exemplo:
No código acima, usamos um contador para iterar pelos níveis da matriz. À medida que a
variável Contador é incrementada, é atribuído um valor diferente ao próximo nível. O
comando Print imprime o valor de Matriz(Contador) no formulário.
64
Matrizes dinâmicas
Eu disse aqui que existiam níveis dentro da matriz. Chamei de níveis para facilitar o
entendimento. A partir de agora chamaremos de elementos.
Ás vezes nós precisamos de uma matriz, mas não sabemos o número exato de elemesntos
que ela terá até determinado momento. O Visual Basic nos permite declarar a matriz
omitindo o número de elementos que ela terá:
No entanto, na linha acima declaramos a matriz, mas não criamos nenhum elemesnto
dentro dela. Para criarmos os elementos teríamos de usar o comando Redim:
Redim Matriz(10)
O comando Redim funciona de forma semelhante ao comando Dim, porém ele não declara
a variável, somente especifica o número de elementos que ela terá.
Podemos mudar o número de elementos quantas vezes quisermos através do comando
Redim, entretanto, todos os valores dos elementos existentes serão perdidos:
Depois especifica que a matriz deverá ter 2 elementos, através do comando Redim:
Redim Matriz(2)
Matriz(0) = ”Carlos”
Matriz(1) = ”Helena”
Matriz(2) = “José”
65
Redim Matriz(3)
E mandamos inprimir:
Print Matriz(0)
Print Matriz(1)
Print Matriz(2)
Matriz(0) = ”Carlos”
Matriz(1) = ”Helena”
Matriz(2) = “José”
A resposta é:
O comando Redim redimensiona a matriz, mas apaga todos os valores existentes nos
elementos:
Redim Matriz(3)
No nosso caso, nós definimos os valores e depois redimensionamos a matriz para que tenha
mais um elemento. Foi aí que os valores existentes nos elementos se perderam. Porém,
existe um meio de redimensionar a matriz preservando os valores dos elementos anteriores,
e esse meio é usando a cláusula Preserve junto com o comando Redim:
Troque a linha Redim Matriz(3) no projeto pela linha acima. Rode o projeto. Você verá
que dessa vez os valores foram preservados, graças à cláusula Preserve.
Matrizes Muldimensionais
Matriz multidimensional é na verdade uma matriz dentro de outra.
Usaremos no exemplo a seguir o comando Option Base para forçar as matrizes a iniciarem
com 1, facilitando assim o entendimento.
Option Base 1
Dim Caixa(3,2) as String
Caixa(0,0)=”Segunda-Feira”
66
Caixa(1,0)=”Terça-Feira”
Caixa(2,0)=”Quarta Feira”
Caixa(0,1)=”R$ 100,00”
Caixa(1,1)=”R$ 50,00”
Caixa(2,1)=”R$ 200,00”
Á primeira vista, isso complica um pouco a cabeça, no entanto, pode ser bem mais simples
se, ao criarmos a matriz imaginarmos uma tabela:
Coluna 1 Coluna 2
Linha 1 Segunda-Feira (1,1) R$ 100,00 (1,2)
Linha 2 Terça-Feira (2,1) R$ 50,00 (2,2)
Linha 3 Quarta-Feira (3,1) R$ 200,00 (3,2)
Essa é a representação gráfica da matriz Caixa. Como você pode ver, adicionamos 3
elementos e esses elementos, que são representados pelas linhas, e esses elementos foram
divididos em 2, representados pelas colunas. Entretanto, podemos ter muito mais
subdivisões do que isso. Por exemplo:
Option Base 1
Dim Matriz(3,2,5) as String
Lógica de programação
Eu diria que lógica de programação é a essência da programação. Um programador
poderia conhecer inúmeros comandos, funções e objetos, mas se não tivesse lógica de
programação nada adiantaria. Já usamos uma certa lógica de programação em vários
exemplos anteriores, no entanto, agora vamos nos aprofundar mais nela.
A lógica de programação é maneira que usamos os comandos, funções, variáveis,
operadores e os demais recursos da linguagem visando resolver os problemas. Pois os
comandos e funções não fazem nada sozinho. É você que vai criar toda estrutura. Cada
programador desenvolve seu próprio estilo. Alguns fazem uma determinada tarefa de uma
maneira mais fácil, outros fazem de uma maneira mais complicada. Isso depende da lógica
de cada um.
São muitos os caminhos para realizar a mesma tarefa. Um professor uma vez me disse
que, o programador deve sempre, escolher o caminho mais difícil. Eu diria o
seguinte.Escolha o caminho que ofereça:
67
- Melhor reaproveitamento do código
As bibliotecas
As bibliotecas, também chamadas de referências, são representadas por um arquivo de
sistema(um arquivo com extensão dll,old,tlb,ocx,etc). Ao anexarmos uma biblioteca em
nosso sistema teremos a nossa disposição o conjunto de objetos pertencentes a essa
biblioteca. Vá no menu Projects e selecione References. Irá abrir a seguinte janela:
Todas elas representam os comandos, funções e objetos nativos do Visual Basic e não
devem ser retiradas do projeto.
Com as bibliotecas podemos fazer quase tudo que imaginarmos. Existem bibliotecas que
nos possibilitam a conexão com diferentes bancos de dados, bibliotecas que nos
possibilitam executar vídeo, música, etc...
Ao declarar uma variável ou objeto, você já deve ter notado que depois da palavra da
palavra chave AS sempre abre uma lista com os tipos de variáveis e tipos de objetos
68
acessíveis ao projeto. Quando adicionamos uma nova biblioteca, novos objetos serão
adicionados a essa lista, e novos objetos poderão ser usados pelo projeto.
69
variedade de objetos para as mais diferentes funções. Tentarei aqui descrever as funções
mais importantes que são usadas com freqüência em aplicativos comerciais.
Quanto aos comandos, gostaria de abordar aqui apenas mais um, que se refere á abertura,
leitura e gravação em arquivos e, embora este comando não seja usado com muita
freqüência, pode nos fazer falta e, possivelmente poderemos fazer manutenção em um
sistema que tenha esse comando. Além disso, em muitos aplicativos é usado um arquivo de
registro (.INI” ) que deve ser lido com o comando Open.
Comando Open
Com a evolução dos bancos de dados praticamente não se usa mais o comando Open
para armazenar dados em arquivos. O comando Open serve para abrirmos um arquivo ou
até mesmo criá-lo. Sua sintaxe é a seguinte:
Open <caminho e nome do arquivo.> For <Tipo> <tipo de bloqueio> <as <Número de
arquivo>
C:\Arquivos\Teste.Txt
Tipo – Palavra chave que definirá o tipo de abertura de arquivo que estamos fazendo:
Append, Binary, Random, Input e OutPut. Se esta palavra chave for omitida o arquivo
será aberto no modo randômico(Random).
Tipo de Bloqueio- Opcional. Determina o tipo de bloqueio em que será aberto o arquivo.
Shared, Lock Read, Lock Write e Lock Read Write.
Este exemplo abre o arquivo no modo Binary somente para operações de gravação.
70
O exemplo a seguir abre o arquivo no modo Random. O arquivo contém registros do tipo
Record definido pelo usuário.
Este exemplo de código abre o arquivo para saída seqüencial; qualquer processo pode ler
ou gravar no arquivo.
Este exemplo de código abre o arquivo no modo Binary para leitura; outros processos não
conseguem ler o arquivo.
Close #1
Este exemplo abre o arquivo para entrada seqüencial usando a função Freefile para retornar
o próximo número de arquivo disponível
Close Freefile
Como você deve ter notado no código acima temos um comando que você não conhece:
o Close. Usamos para fechar um arquivo informando apenas o número antecipado por um
“#”.
Até agora vimos apenas como abrir os arquivos e fechá-los. Vamos agora conhecer
comandos que nos permitem gravar e ler dados de arquivos. Não vamos nos aprofundar
muito nesta parte devido ao pouco uso que faremos desses recursos. No entanto vamos
aprender o que precisamos: Gravar e ler dados de um arquivo.
Input – O comando Input nos possibilita ler dados de um arquivo aberto como seqüencial
e jogar os dados em uma variável. Exemplo:
71
Input #1, Nome
A linha acima irá ler uma linha do arquivo de número 1 aberto como seqüencial e jogará
o conteúdo da respectiva linha para a variável Nome. No caso de querermos que ele leia a
próxima linha, devemos usar novamente a instrução Input. Se não existir próxima linha e a
instrução Input for encontrada, o Visual Basic retornará um erro dizendo que foi
encontrado o fim do arquivo.
Vamos colocar um pouco do que aprendemos em prática. Primeiramente crie um arquivo
no bloco de notas. Insira qualquer texto na primeira linha desse arquivo e o salve-o com o
nome “Teste.Txt” no drive C.
Depois crie um formulário e insira um TextBox com o nome de “TxtLinha”. No evento
Load do formulário coloque o seguinte código:
Dim A As String
Open "c:\Teste.txt" For Input As #1
Input #1, A
TxtLinha.Text = A
Close #1
Rode o projeto.
Note que o TextBox do formulário obteve o conteúdo da primeira linha do arquivo texto
que criamos. Analisando o código acima, vejamos o que fizemos:
Dim A As String
Lemos uma linha do nosso arquivo e jogamos seu conteúdo para a variável A. Como o
arquivo recém foi aberto, ele vai ler a primeira linha.
Input #1, A
Fechamos o arquivo.
Close #1
Conseguimos o que precisamos. Lemos os dados de um arquivo e o bicho nem foi tão
feio como parece. Devo lembrar que há várias outras maneiras de fazer isso que ilustrei
72
aqui e maneiras bem mais complicadas inclusive. No entanto, essa resolve a maioria dos
nossos problemas. No caso de termos que ler mais linhas de um arquivo basta repetir a
instrução Input para que ele leia automaticamente a próxima linha desde que o arquivo
ainda não tenha sido fechado.
O exemplo a seguir ilustra um eficaz processo para lermos todas as linhas de forma
seqüencial e jogar os dados para um TextBox.
Dim A As String
Input #1, A
Texto = Texto & A ‘ Concatena a variável Texto com a última linha lida
Loop
Simples, não?
Porém quando temos mais de uma linha em um arquivo e usamos o comando Print # todas
as outras linhas são apagadas.
No caso de termos mais de uma linha em um arquivo devemos abrir o arquivo como
Random e usar o comando Put # para gravar os dados, como o exemplo a seguir:
Open "c:\teste.txt" For Random As #1
Put #1, 5, "Testando o comando Put"
Close #1
73
get
A novidade no código acima é o comando Put #. A esse comando devemos fornecer
primeiramente o número do arquivo, depois o número do registro, ou seja, a linha onde será
inserido os dados, e depois os dados que serão inseridos.
Bem, já sabemos como ler dados de um arquivo e gravar dados em um arquivo. O meu
objetivo em abordar esses comandos era o de passar ao aluno, meios para isso ser feito. No
entanto, não tratei aqui alguns comandos que julgo totalmente desnecessário e fogem do
objetivo do nosso curso. Além disso, existem muitos objetos do Visual Basic que fazem
essas tarefas com muito mais simplicidade e clareza.
Caso o aluno ainda tenha curiosidade em saber mais sobre comandos de leitura e
gravação de arquivos pode consultar o Help do Visual Basic.
Funções Internas
Representam todas as funções nativas do Visual Basic. Temos funções de manipulação de
strings, números, datas, objetos, tratamento de erros e muitas outras. Temos um número
muito grande de funções internas.
Tentarei aqui abordar as mais úteis e mais usadas.
Funções numéricas
ABS: Retorna o valor absoluto de um número(positivo).
Abs(Expressão numérica)
Print Abs(-30)
retornará 30
74
INT(<expressãoNumérica>)
Print Int(10.2)
Retornará 10
Print Int(-10.2)
Retornará -11
Funções de String
INSTR: Retorna a posição da primeira ocorrência de uma seqüência de caracteres
dentro de outra
Variável = InStr ({<posiçãoInicial>,] <string>,
<SubStringAPesquisar>[, <MétodoDeComparação])
75
Imprimirá 5
Caso a função InStr não encontre nenhuma ocorrência da substring que estamos
pesquisando ela retornará 0.
76
RIGHT: Retorna uma substring com os caracteres que se encontram da direita para
a esquerda dentro de uma expressão String.
VariávelNumérica=Right([<ExpressãoString>, <QuantidadeDeCaracteres>)
Print Right(“José Da Silva”,5)
Valor Impresso:Silva
SPACE: Retorna uma String com uma determinada quantidade de espaços vázios.
Space(<quantidadeDeCaracteres>)
77
Funções de Data e Hora
78
ww Semana
h Hora
n Minuto
s Segundo
A função DateDiff sempre calcula o intervalo com base na configuração que você
escolher em <Intervalo>. No exemplo acima, escolhemos “d”, o que fará que a função
calcule a diferença com base nos dias.
Se a expressão Data1 for uma data posterior a Data2 a função retornará um
número negativo.
DATEPART: extrai de uma determinada data uma parte dela relativo a dia, mês,
semana, quinzena, etc.
DatePart(<intervalo>, <expressãoData>)
Intervalo pode ser:
yyyy Ano
q Trimestre
m Mês
y Dia do ano
d Dia
w Dia da semana
ww Semana
h Hora
n Minuto
s Segundo
DATESERIAL: Retorna uma data para um dia, mês e ano especificados, ou seja,
monta a data com base nos argumentos especificados.
VariavelData = DateSerial(<ano>, <mês>, <dia>)
Print DateSerial("06", "02", "24")
Valor Impresso: 24/02/2006
79
Day(<expressãoData>)
Print Day("01/01/2001")
Valor Impresso: 1
Print Now
Imprimirá a date e hora corrente no momento em que foi executada a função.
Funções de conversão
80
CBOOL: Converte uma expressão para um valor lógico (True ou false). Se o
argumento for um zero, retornará False, caso contrário será True.
CBool(<expressão>)
Cbool(1)
Retornará True
Cbool(0)
Retornará False
Cbool(1 = 2)
Retornará False. Pois 1 não é igual a 2.
Dim A as Integer
Dim B as Integer
A=5
B=5
Print Cbool(A=B)
Print Cbyte(450)
O Visual Basic retornará um erro porquê expressões byte não podem ser maiores
que 255.
CDATE: Converte uma expressão para um tipo Data. Entretanto, esta conversão se
concretizará desde que a expressão usada como argumento seja mesmo no formato de uma
data, ou seja, dia/mês/Ano. Se pedirmos para fazer conversão da palavra “teste” para data
será retornado um erro.
Cdate(<expressão>)
81
Print Cdate(“01/01/2001”)
Valor Impresso: 01/01/2001
A função CDate retornará erro sempre que informarmos uma expressão que não
resulte em uma data válida.
CSTR: Converte uma expressão numérica, data ou outra em uma string (texto).
CStr(<expressão>)
Cstr(33)
Retornará “33”
STR: Converte um valor numérico para o tipo String (texto). Valido somente para
argumentos numéricos.
Str(<expressãoNumérica>)
Str(45)
Retornará “45”
82
vbUpperCaseConverte toda a expressão em letras maiúsculas.
vbLowerCase Converte toda a expressão em letras minúsculas.
vbProperCase Converte somente a primeira letra em maiúscula e o restante
em minúsculo.
VAL: Converte uma String com caracteres numéricos em uma variável númerica.
Val(<stringNumérica>)
Val(“33”)
Retornará 33
83
Dim Dias as Variant
Dias = Array("Dom", "Seg", "Ter", "Qua", "Qui", "Sex", "Sáb")
Print Dias(2)
Print Dias(4)
Valor Impresso: Ter
Valor Impresso: Qui
Funções lógicas
IIF: Analisa uma expressão lógica, e retorna valores para quando for falso ou
verdadeiro.
IIF (<ExpressãoLógica>,<ExpressãoParaVerdadeiro>, <ExpressãoParaFalso>)
Print IIf(2 > 1, "2 é maior que 1", "1 é maior que 2")
Imprimirá “2 é maior que 1”
84
Expr : Expressão variant que você quer avaliar.
Valor : Valor ou expressão que é retornado se a expressão correspondente for
True.
A função Switch analisa cada uma das expressões e retorna o valor contido em
<Valor> da primeira expressão correspondente que seja verdadeira . A função Switch deve
ser composta por pares de expressões e valores de retorno. Portanto não podemos passar
expressões sem informar os respectivos valores de retorno. Se isso for feito, o Visual Basic
retornará um erro em tempo de execução.
Funções de Disco
CURDIR: Retorna o diretório corrente.
CurDir[(<drive>)]
Print CurDir("C:")
Imprimirá o caminho completo do diretório corrente
DIR: Procura por um arquivo especificado e retorna seu nome caso o mesmo seja
encontrado. Caso não encontre retorna Null(Nulo). Podemos procurar arquivos por
atributos também.
Dir[(Nomedocaminho[, Atributos])]
Exemplo:
85
O exemplo acima funcionaria da mesma forma se usássemos a palavra Empty, que
representa vazio no lugar de “”:
0 vbNormal Normal.
1 vbReadOnly Somente Leitura.
2 vbHidden Oculto.
4 vbSystem Arquivo de sistema
16 vbDirectory Diretório ou pasta.
32 vbArchive O arquivo foi modificado desde o último backup.
Print GetAttr("C:\windows\system32\kernel32.dll")
Imprimirá 32
Funções de Teste
ISARRAY: Testa se uma variável é uma matriz
IsArray(<variável>)
ISDATE: Testa se o argumento pode ser convertido para uma data. Esta data deve
estar dentro dos padrões de data.
IsDate(<expressão>)
86
ISMISSING: Testa se um argumento opcional foi passado como parâmetro para
uma procedure ou função.
IsMissing(<NomedoArgumento>)
Print IsNumeric(“AB”)
Imprimirá False
Print IsNumeric(“10”)
Imprimirá True
Exemplo:
Dim A As Integer
A = 220
If VarType(A) = 2 Then
MsgBox "Variável A é Do Tipo Integer"
Else
MsgBox "Variável A não é do tipo Integer"
87
End If
Funções de Escolha
CHOOSE: Seleciona um valor de uma lista de argumentos.
Choose (<índice>, <Valor>[, <Valor>]...)
A função Choose retorna um valor de uma lista de valores separada por vírgula, com
base no número informado em <Índice>.
Print Choose(3,"Segunda-Feira","Terça-Feira","Quarta-Feira","Quinta-
Feira")
Imprimirá Quarta-Feira
88
ExpressãoPrompt : Expressão de seqüência de caracteres exibida como a
mensagem numa caixa de diálogo. O tamanho máximo de ExpressãoPrompt é de
aproximadamente 1024 caracteres, dependendo da largura dos caracteres usados. Se
ExpressãoPrompt for composto por mais de uma linha, você poderá separar as linhas
usando um caractere de retorno de carro (Chr(13)), um caractere de alimentação de linha
(Chr(10)) ou uma combinação de caracteres de retorno de carro e alimentação de linha
(Chr(13) & Chr(10)) entre cada linha.
89
modalidade da caixa de mensagem. Quando adicionar números para criar um valor final
para o argumento buttons, use somente um número de cada grupo.
Durante a digitação da função, quando formos escolher o estilo da mensagem, o
Visual Basic automaticamente apresenta uma lista com vários estilos:
Podemos selecionar qualquer um item da lista, pois na verdade, cada um desses itens,
são constantes que representam os números de estilos que vimos na tabela. Entretanto,
podemos substituir esses itens por uma soma resultante de um estilo personalizado que
possamos querer.
Observação Estas constantes são especificadas pelo Visual Basic para aplicativos.
Assim, os nomes podem ser usados em qualquer lugar do código em lugar dos valores
reais.
90
If MsgBox("Teste de Mensagem", vbOKCancel) = vbOK Then
MsgBox "Você clicou OK"
End If
A função MsgBox retorna um número dizendo qual foi o botão que o usuário
pressionou. No nosso exemplo acima, usamos a constante vbOK que representa o número
correspondente ao botão OK, para verificar se ele foi pressionado ou clicado. Caso seja,
usaremos novamente a função MsgBox como comando, apenas para informar ao usuário o
botão que ele clicou.
Note que ao usarmos a função MsgBox para retornar valores devemos colocar os seus
argumentos entre parênteses. E quando usarmos a função MsgBox apenas para exibir
mensagens, o uso dos parênteses não é necessário.
Formatação de Dados
<Expressão>: Seria a nossa expressão a ser formatada. Os dados que queremos formatar.
Pode ser uma string, uma expressão numérica, data, etc. ou qualquer variável dos tipos
citados.
<Formato>: O formato pode ser determinado pelas máscaras de formatação, que
veremos a seguir, ou ainda, por uma palavra-chave que determina para que tipo de dados
estamos formatando a <Expressão>.
91
Perceba que não podemos colocar uma formatação menor que os números que serão
impressos, pois senão a formatação não irá alcançar toda a extensão dos números.
O símbolo “#” é substituído por números quando existir número para ser
substituído. Note que o número decimal é “.3” e apesar de termos usado uma formatação
para casas decimais com dois símbolos “##”, não apareceu as duas casas decimais. Se
quisermos forçar o aparecimento de zeros quando não tiver número para ser impresso,
usados “0” no lugar de “#”. Veja:
Print Format(12345.3,”##,###.00”)
Valor Impresso: 12.345,30
Print Format(12345,”##,###.00”)
Valor Impresso: 12.345,00
Isto vale também para formatação de números sem casas decimais:
Print Format(45,”0000”)
Valor Impresso: 0045
Se quisermos uma formatação diferente para números negativos, basta colocar essa
formatação após o ponto-e-virgula.
Print Format(12345,”##,###.00; (-)##,###.00”)
Valor Impresso: 12.345,00
Print Format(-12345,”##,###.00; (-)##,###.00”)
Valor Impresso: (-)12.345,00
92
quiser que um zero à esquerda seja sempre exibido com números fracionários, use 0 como o
primeiro espaço reservado para dígito à esquerda do separador decimal. O caractere real
utilizado como espaço reservado para decimal na saída formatada depende do Formato
Numérico reconhecido pelo sistema.
E- E+ e- e+ Formato científico
Se a expressão de formato contiver pelo menos um espaço reservado para dígito (0
ou #) à direita de E-, E+, e- ou e+, o número é exibido em formato científico, sendo E ou e
inserido entre o número e seu expoente. O número de espaços reservados para dígito à
direita determina o número de dígitos do expoente. Use E- ou e- para incluir um sinal de
subtração (-) ao lado de expoentes negativos. Use E+ ou e+ para incluir um sinal de
subtração ao lado de expoentes negativos e um sinal de adição (+) ao lado de expoentes
positivos.
93
Para incluir uma seqüência de caracteres em Format a partir do código, você deve
usar Chr(34) para delimitar o texto (34 é código de caractere para aspas).
Percent : Exibe o número multiplicado por 100 com um sinal de porcentagem (%)
anexado à direita; sempre mostra dois dígitos à direita do separador de casa decimal.
Print Format(123456.7, "Percent")
Valor Impresso: 12345670,00%
Print Format(1, "Percent")
Valor Impresso: 100,00%
94
True/False : Exibe “False” se o número for 0; caso contrário, exibe “True”.
On/Off : Exibe “Off” se o número for 0; caso contrário, exibe “On”.
Print Format(1,”True/False”)
Valor Impresso: True
c Exibe a data como ddddd e a hora como ttttt, nessa ordem. Exibe apenas
informações de data se não houver parte fracionária para o número de série de data; exibe
apenas informações de hora se não houver parte inteira.
Print Format("01/08/96","c")
Valor Impresso: 01/08/96
Print Format(now,"c")
Valor Impresso: 01/08/96 22:51:11
w Exibe o dia da semana como um número (1 para domingo até 7 para sábado).
95
m Exibe o mês como um número sem zeros à esquerda. Se m vier
imediatamente depois de h ou hh, é exibido o minuto em lugar do mês.
Print Format("01/08/96","m")
Valor Impresso: 8
96
t t t t t Exibe uma hora como uma hora completa (inclusive hora, minuto e
segundo), formatada usando o separador de hora definido pelo formato de hora reconhecido
pelo sistema.
Print Format(now,"ttttt")
Valor Impresso: 23:17:27
Veja abaixo a relação das palavras-chaves aceita pela função Format para
expressões de data e hora:
General Date : Exibe a data e a hora nos formatos estabelecidos nas configurações
do Windows. Caso a expressão seja somente uma data, será exibido
Print Format(now,"general date")
Valor Impresso: 01/08/96 23:21:25
Print Format("01/08/96","general date")
Valor Impresso: 01/08/96
Print Format("09:24:11","general date")
Valor Impresso: 09:24:11
Long Date : Exibe uma data de acordo com o formato por extenso de data de seu
sistema.
Print Format("01/08/96","Long Date")
Valor Impresso: Quinta-feira, 1 de Agosto de 1996
Medium Date : Exibe uma data usando o formato médio de data apropriado para a
versão de idioma do aplicativo host.
Print Format("01/08/96","Medium Date")
Valor Impresso: 01-Ago-96
Short Date : Exibe uma data usando o formato abreviado de data de seu sistema.
Print Format("01/08/96","Short Date")
Valor Impresso: 01/08/96
Long Time : Exibe uma hora usando o formato por extenso de hora de seu sistema:
inclui horas, minutos, segundos.
Print Format("09:24:11","Long Time")
Valor Impresso: 09:24:11
97
Medium Time : Exibe uma hora no formato 12 horas usando horas e minutos e a
designação AM/PM.
Print Format("09:24:11","Medium Time")
Valor Impresso: 09:24 AM
Banco de Dados
Abordarei aqui, o assunto Banco de Dados na forma mais simples possível. O que quero
dizer é que não vamos nos prender a conhecer todos os recursos que um banco de dados
pode nos fornecer. Até mesmo por que esse foge ao objetivo do nosso curso. No entanto,
vamos aprender tudo o que precisamos para criar aplicativos comerciais usando um banco
de dados de uma forma limpa, rápida e simples.
Porém, devo dizer ao aluno que nunca é demais se aprofundar no assunto Banco de
Dados, tentando tirar o máximo de proveito que ele pode nos fornecer. Principalmente, com
tantos tipos novos de bancos de dados surgindo por aí.
98
A biblioteca de conexão, que contém os objetos que vamos usar para nos conectarmos
com os bancos de dados que criaremos, é o Microsoft D.A.O. (Microsoft Data Access
Objects) e nos permite nos conectarmos com banco de dados no formato Access, além de
tipos de bancos de dados mais antigos como Dbase, FoxPro, Paradox, etc.
Durante o nosso curso, trabalharemos com o Microsoft Access. Devo lembrar que a
mudança de um tipo de banco de dados para o outro está na que um tem mais ou menos
recursos que o outro, sendo que todos têm em comum, tabelas, campos, chave primária, etc.
Sempre que for utilizar um banco de dados que você ainda não conheça, consulte a sua
documentação.
Temos o próprio editor do Microsoft Access, caso você tenha o Office instalado:
99
e também o Visual Data Manager, que é uma ferramenta do Visual Basic:
O Visual Data Manager oferece uma interface mais básica e objetiva, porém tem a
desvantagem de ser toda em inglês e não oferece alguns recursos como gerenciamento de
relatórios e formulários. No entanto, como não vamos usar esses recursos de banco de
dados nesse curso, poderíamos usá-lo sem problemas.
Devo dizer que bancos de dados criados com as últimas versões do Microsoft Access
não são reconhecidas pelo Visual Data Manager, não podendo assim serem abertas.
As tabelas são bases de qualquer banco de dados. É delas que virão os dados a serem
processados por consultas, relatórios, formulários e demais objetos de banco de dados. As
tabelas são divididas em campos e registros.
Os campos são definidos quando definimos a estrutura da tabela, já os registros são
adicionados de acordo com a necessidade do usuário. Para ilustrar o que estou dizendo, veja
a tabela a seguir:
Registros
Campos
100
Criando uma tabela
Por razão de compatibilidade, vamos criar nossa tabela usando o Visual Data Manager,
lembrando que poderemos abrir o Banco de Dados usando o Microsoft Access
posteriormente, caso quisermos. Nas últimas versões do Access, talvez tenhamos que fazer
uma conversão.
Acesse, dentro do Visual Basic, o menu Add-Ins e selecione Visual Data Manager.
Depois de aberto, selecione a opção New para criar um novo banco de dados, depois
selecione o tipo, que no nosso caso é o Microsoft Access, e depois selecione Version 7.0
MDB, que oferece maior compatibilidade com as últimas versões do Access, podendo
assim ser aberto.
Abrirão 2 janelas, uma para serem executados instruções SQL *, e outra com as
propriedades do banco de dados.
* - Instruções SQL são instruções específicas de banco de dados como criar tabelas,
fazer manutenção dos dados, etc. Como nosso curso irá tratar os bancos de dados na
sua forma mais básica, as instruções SQL fogem do objetivo do nosso curso.
101
Já temos o banco de dados propriamente dito, agora precisamos criar tabelas. Para
criar uma tabela, clique com o botão direito do mouse em cima das propriedades e
selecione a opção New Table.
102
Aqui descrevemos
qual deve ser o
nome da tabela
Botão de adicionar
campo
Botão de remover
campo
Aqui definimos o
nome do campo
Aqui escolhemos o tipo
do campo em uma lista.
Segue as mesmas regras
para tipos de variáveis
Tamanho do
campo
Código
Nome
DataNasc
Telefone
Ao campo código, obviamente, você terá que escolher um tipo que aceite números.
O ideal seria usar um campo do tipo Long autoincrementável, fazendo assim que
cada cliente adicionado tenha um novo código automaticamente.
Para o campo Nome poderíamos usar um campo do tipo Text com um tamanho
de 40 caracteres sem problemas.
O campo DataNasc servirá para gravarmos datas de nascimento, portanto o tipo
DateTime seria o apropriado.
Quanto ao Telefone, deve ser do tipo Text por que usaremos sinais como - e * e
se colocarmos números com sinais em um campo numérico o Visual Basic
entenderá que estamos tentando calcular valores e retornará o resultado.
Depois de adicionar todos os campos, feche a janela de adicionar campo e clique
no botão Build the Table para confirmar a criação da tabela. Você vai notar que a
tabela já vai aparecer na janela de banco de dados.
104
Se você clicar 2 vezes com o botão esquerdo do mouse em cima dela, ela é aberta para
inclusão, alteração e edição de dados.
Se clicarmos com o botão direito em cima da tabela aparecem opções como Open, que
abrirá a tabela do mesmo modo como se tivéssemos dado 2 cliques; Design, que serve para
alterarmos a estrutura da tabela, Rename(renomear); Delete(deletar). Além disso, aparecem
outras opções que não nos serão úteis no momento.
Bem, vamos fazer uso da nossa tabela. Insira 5 registros com nomes, telefones e datas de
nascimento diferentes.
Você verá que, a cada novo registro que adicionarmos o campo Código é incrementado
em 1. Notará também que se um valor atribuído á um campo não coincidir com o tipo que
foi definido para o mesmo,a tabela não aceitará. Por exemplo, se você tiver um campo do
105
tipo DateTime, só conseguirá inserir datas. Esse tipo de data obedece à formatação que
você definir no Painel de Controle.
Criando índices
Um índice é usado para indexar registros. Por exemplo, se temos um campo Nome e
quisermos que este campo seja ordenado por ordem alfabética. Devemos criar um índice e
selecionar o campo Nome para que seja a base desse índice.
Um campo do tipo numérico, seja ele Integer, Long ou qualquer outro tipo numérico, ao
ser indexado ficará em ordem crescente. Um campo do tipo DateTime, por ordem
cronológica. Resumindo, um índice organiza os dados da forma mais presumível possível.
Um índice, além de organizar os registros com base em um campo, também torna as
pesquisas pelo campo que tem um índice, bem mais rápidas.
Vamos agora criar alguns índices na nossa tabela de clientes. Clique na tabela com o
botão direito e selecione a opção Design. Após, clique no botão Add Index para adicionar
um novo índice. Abrirá a seguinte janela:
Se a propriedade Primary
estiver marcada, significa que
o campo selecionado será a
chave primária. Podemos ter
apenas uma por tabela. Logo,
explicarei o que é chave
primária.
Por padrão, a atribuição de
um valor nulo a um campo Se a propriedade Unique for
indexado, gera um erro. Se a marcada, o campo não
propriedade IgnoreNulls for aceitará valores duplicados,
marcada, o campo passará a ou seja, se tivermos um
aceitar valores nulos. campo Nome com o valor
“Maria”, não poderemos ter
outro registro com um campo
Nome de mesmo valor.
Vamos agora adicionar um índice chamado Nome a tabela que criamos. Esse índice terá
como base o campo Nome. Não irá aceitar valores nulos nem valores iguais.
106
Definindo a chave primária
Uma chave primária é útil quando queremos que uma tabela não aceite valores nulos e
nem valores duplicados. Uma chave primária também é útil para se relacionar com outras
tabelas.
Podemos dizer que uma chave primária é um índice ou um conjunto de índices que não
podem ter valores repetidos ou nulos. Por exemplo, digamos que você defina como chave
primária 2 campos. Um referente ao campo Codigo e outro ao campo Nome. Poderíamos
até ter 2 códigos iguais e 2 nomes iguais, mas uma combinação de nome e código igual não
poderia existir. A chave primária nesse caso, seria um índice que definimos com a
propriedade Primary e definimos que o mesmo teria como base o campo Nome e o campo
Código.
Devo admitir que na teoria isso parece um pouco confuso, mas na prática fica bem mais
simples.
Uma tabela pode ter apenas uma chave primária(também chamada de índice primário),
mas pode ter vários índices. Se você tentar atribuir mais de um índice como Primary, irá
receber uma mensagem de erro dizendo que o índice não pode ser criado.
Como a tabela que criamos é bem mais simples e o índice que criamos(Nome), já dá
conta de não permitir valores nulos e repetidos, uma chave primária é no
momento,desnecessária.
107
Marque essa biblioteca e selecione OK.
Agora já podemos usar os objetos que essa biblioteca nos oferece.
Vamos agora, realizar algumas operações envolvendo bancos de dados. Primeiro crie
uma pasta de trabalho no diretório c:\ com o nome de Trabalho. Depois crie um banco de
dados com o nome DbCurso dentro dessa mesma pasta.
Crie uma tabela nesse banco de dados chamada clientes com os seguintes campos e
atributos:
Campo Tipo Tamanho
Codigo Long(Autoincrementável)
Nome Text 40
Cpf Text 15
Rg Text 11
DataNascimento DateTime
DataCadastro DateTime
Endereco Text 30
Bairro Text 3
Casado Boolean
Alguns campos aparecem sem seus respectivos tamanhos por quê não são necessários
devido ao tipo do campo selecionado.
Adicione um índice para o nome chamado IndNome, outro para o Código chamado
IndCodigo e uma chave primária com base no campo Nome e no campo Código e se
chamará Chave.
108
Através do Microsoft Access ou do Visual Data Manager, acrescente 5 registros a essa
tabela e grave-a.
Agora que já temos um banco de dados com uma tabela, vamos aprender como abrimos
o banco de dados e lemos os dados da tabela.
O primeiro objeto de banco de dados que vamos conhecer é objeto Database. Um
objeto Database contém propriedades, funções e métodos relativos á banco de dados. Para
abrir um banco de dados usando o objeto Database, devemos usar a função
OpenDatabase. Essa função só é disponível quando a biblioteca do Microsoft DAO foi
selecionada.
Primeiramente, devemos declarar um objeto Database. Vamos declarar uma variável
chamada Banco como sendo um objeto Database:
Depois, iremos instanciar o objeto Banco que criamos apontando para a função
OpenDatabase que abrirá o banco de dados que desejarmos. A função OpenDatabase tem
a seguinte sintaxe:
<Caminho e nome do banco de dados>- Uma string que representa o caminho completo,
incluindo o nome do banco de dados.
A pergunta que talvez esteja na sua cabeça é “Onde devo declarar um objeto Database?”.
Bem, na verdade um objeto Database, assim como as variáveis no Visual Basic, podem ser
declaradas em qualquer lugar. No entanto, se declararmos o objeto Database em um
subprocedimento, ele será restrito somente ao subprocedimento em que foi declarado. O
ideal é sempre usarmos declará-lo na seção General-Declarations do formulário ou
módulo que formos usá-lo. Se usarmos em um módulo, esteve objeto será visível em todos
os outros módulos e formulários. No nosso exemplo, usaremos na seção General-
Declarations do formulário onde ele será usado.
Vamos voltar a declaração do objeto Database que começamos.
109
Declaramos um objeto Database chamado Banco na seção General-Declarations do
nosso formulário.
Agora, para usarmos esse objeto, temos de instanciá-lo apontando para a função
OpenDatabase, como vimos anteriormente. O local ideal para fazer essa instanciação é no
evento Load do formulário. Teremos assim desta forma, o objeto instanciado durante todo
o tempo que o código estiver sendo executado no formulário.
A sintaxe da função OpenDataBase já vimos anteriormente. Veremos agora como
ficaria se usássemos o banco de dados que criamos na nossa pasta de trabalho.
O que é um Recordset?
Recordset é um objeto que representa uma tabela. Assim como o objeto Database
representa o banco de dados, o objeto Recordset representa uma tabela. Com ele, podemos
efetuar todas as operações em tabelas que fazíamos via Access ou Visual Data Manager.
Agora que já sabemos pra que serve um Recordset vamos aprender a declará-lo e
instanciá-lo. Primeiro, vá na seção General-Declarations, onde já declaramos um objeto
Database, e declare lá também um objeto Recordset com o nome de Tabela.
110
Depois de declarar o objeto Recordset, será necessário instanciá-lo. É aí que entra o
método OpenRecordset do objeto Database. Veremos agora a sintaxe do método
OpenRecordset:
OpenRecordset(<NomeDaTabela>,<Tipo>,<Opções>,<SomenteLeitura>)
DbOpenSnapShot – Esta outra contante nos permite abrir um objeto recordset como sendo
do tipo SnapShot. Um recordset do tipo SnapShot pode ser visto como uma cópia virtual
dos dados. Ou seja, é uma cópia da tabela no exato momento em que for criado o objeto
recordset tipo SnapShot. Não podem ser atulizados. Seu uso se restringe a consultas.
Devo lembrar que cada um desses tipos de RecordSet contem várias particularidades não
mencionadas aqui, sendo estas que citei, portanto, as mais importantes.
Voltando a abertura do nosso banco de dados, usaremos um objeto recordset do tipo
Table, pelo fato desse tipo de recordset ter as mesmas características de uma tabela. Dessa
forma, poderemos efetuar todas as operações que
precisamos(Inclusão,Alteração,Consulta,Exclusão).
Já que temos o objeto Database instanciado e o objeto RecordSet declarado, vamos
agora instanciar o objeto RecordSet, apontando para o método OpenRecordset do objeto
Database. Ficaria assim:
111
Instanciamos o objeto tipo Recordset apontando para o método OpenRecordset do
objeto DataBase. Como usamos no argumento <Tipo> do método OpenRecordset ,a
contante DbOpenTable, o objeto tipo RecordSet aberto, será do tipo Table. Ou seja, se
comportará como se fosse uma tabela normal.
Pronto! Agora a variável Tabela tem todas as características de um objeto recordset do
tipo Table e têm também todos os registros existentes na tabela Clientes.
Consultando Registros
<RecordSet>(<StringNomeCampo>)
ou
<RecordSet>!<NomeCampo>
Exemplo:
TxtNome.Text = Tabela(“Nome”)
Ou
TxtNome.Text = Tabela!Nome
112
MoveFirst – Move o ponteiro para o primeiro registro.
Exemplo:
Tabela.Move 3
Exemplos:
Tabela.MoveNext
Tabela.MoveLast
Tabela.MovePrevious
Métodos de procura
Um Recordset oferece alguns métodos para realizarmos operações de busca através das
tabelas. Veremos agora os métodos de busca e as suas particularidades.
FindFirst- É o método de procura mais usado. Ele procura um registro com base em uma
condição, a partir do primeiro registro. Sua sintaxe é a seguinte:
Recordset.FindFirst(StringComCondição)
Tabela.FindFirst(“Nome = ‘Joao’”)
Note que quando procuramos um campo do tipo Texto(Text), o texto a procurar deve ser
delimitados por aspas simples ‘’. Caso for um campo do tipo numérico(Integer,Long, etc...)
as aspas não são necessárias:
Tabela.FindFirst(“Código = 3”)
113
FindPrevious – A partir da atual posição do ponteiro no recordset, localiza o registro
anterior que satisfaça o critério. Segue a mesma sintaxe dos métodos anteriores.
FindLast – A partir do primeiro registro, procura pelo último registro que satisfaça o
critério estabelecido, no caso de termos mais de um registro encontrado. Segue a mesma
sintaxe dos métodos anteriores.
O método Seek
O método Seek oferece um meio de pesquisa mais rápido quando procuramos um
registro com um campo indexado. O método Seek só pode ser usado em um RecordSet do
tipo Table e é necessário que especifiquemos um índice corrente antes de fazermos a
pesquisa. Para especificar um índice corrente, usamos a propriedade Index do RecordSet.
Digamos que vamos usar o Recordset que já criamos q que se chama Tabela. Como você
lembra, quando criamos a tabela “Clientes” adicionamos um índice chamado Nome e é
este índice que iremos usar.
Tabela.Index =”Nome”
Feito isso, já poderemos usar o método Seek que tem a seguinte sintaxe:
Exemplo:
Tabela.Index =”Nome”
Tabela.Seek “=”, “João”
Após utilizarmos um método de procura, seja ele Seek ou qualquer um dos que vimos
anteriormente, o ponteiro de moverá para o registro que satisfaça as condições
estabelecidas nas opções de critério. Caso o registro não seja encontrado, o ponteiro
continuará no registro atual.
Quando uma operação de procura não obter sucesso, a propriedade NoMatch do objeto
Recordset passar a ter o valor True. Essa propriedade é útil para sabermos se o registro
que procuramos foi encontrado.
Exemplo:
114
Set Banco = Opendatabase(“C:\Trabalho\Dbcurso.mdb”)
Set Tabela = Banco.OpenRecordset(“Clientes”,Dbopentable)
Tabela.FindFirst(“Nome = ‘Maria’”)
If Tabela.Nomatch = True Then
MsgBox “Nome não foi encontrado”
Else
MsgBox “Nome foi encontrado”
Endif
Adidionando Registros
<Recordset>.AddNew
Feito isso, ainda precisamos usar o método Update do objeto Recordset para finalizar a
adição do novo registro. Este método trabalha em conjunto com o método AddNew.
Lembre-se de sempre usá-lo quando a adição do registro estiver OK.
<Recordset>.Update
Vamos ao exemplo prático para ilustrar esse processo, partindo do RecordSet que
criamos chamado Tabela
Tabela.AddNew
Tabela(“Nome”) = “Vanessa Martins Vargas”
Tabela(“Endereço”) = “João Borges Fortes, 2000”
Tabela(“DataNasc”) = # 15/09/1980 #
Tabela.Update
115
Atualizando Registros
Excluindo registros
Esta é a mais simples das operações envolvendo manipulação de registros. Para excluir
um registro, aponte para o registro que deseja excluir e use o método Delete do objeto
RecordSet. Exemplo:
Tabela.MoveLast
Tabela.Delete
É muito importante se atentar para o fato de precisar fechar a conexão dos objetos com a
tabela e o banco de dados quando não estivermos mais usando os dados provenientes deles.
Pois isto evitará que o banco de dados possa estar corrompindo futuramente. Para fechar
um Database, objeto que representa o banco de dados, devemos primeiramente fechar os
RecordSets baseados nesse Database. Se tentarmos fechar o Database primeiro sem
termos fechado o(s) Recordsets bseados nele, teremos um erro em tempo de execução.
Para fechar um RecordSet ou um DataBase, usamos o método Close.
Tabela.Close
Banco.Close
116
AbsolutePosition : Indica o numero do registro corrente da tabela em uso. Não podemos
consultar essa propriedade em um objeto Recordset do tipo Table. Somente SnapShot ou
Dynaset.
BOF : Retorna True quando foi feita uma tentativa de ir para um registro anterior ao
primeiro. Quando isto aontecer, om ponteiro não apontará para nenhum registro, tendo o
programador ter que fazer com que ele aponte para um registro novamente.
EOF : Retorna True quando for feita uma tentativa de ir para um registro superior ao
último.
NoMatch : Retorna True se uma pesquisa efetuada dentro da tabela foi bem-sucedida.
Com base nos métodos, propriedades e funções aprendidas, crie um cadastro com base na
tabela Clientes que criamos no banco de dados DbCurso. O cadastro deverá ter botões de
adicionar registros, um botão para ir para o próximo registro, anterior, primeiro e último.
Deverá ter também um botão de excluir registros e um para alterar.
Iremos conhecer agora alguns objetos que facilitam a nossa vida, quando precisamos
manipular dados de um banco de dados. O primeiro dos objetos que conheceremos é um
controle:
117
Não é nexessário nomear os TextBoxs. Vamos agora configurar o objeto Data. Sem mais
rodeios, vamos diretamente á propriedade que nos interessa e ela é a DatabaseName. Nela
escolheremos o banco de dados que tém a tabela que iremos usar.
Clicando no botão ao lado <...>, uma janela se abrirá para que possamos procurar pelo
banco de dados.
118
Bem, agora vamos conhecer o que o objeto Data tem a nos oferece. Primeiramente,
configure a opção DataSource dos TextBoxs. Note que quando adicionamos um objeto
Data ao formulário, o mesmo irá aparecer na lista da propriedade RecordSource das
TextBoxs existentes no formulário.
Selecione este objeto para todas as TextBoxs. Agora que já selecionamos o objeto Data
para a propriedade RecordSource de todos os TextBoxs, configure a propriedade DataField
das mesmas, uma por vez.
Note que se tudo estiver configurado de forma adequada, você pode escolher os campos
em uma lista na propriedade DataField de cada TextBox.
Selecione um a um, os respectivos campos para cada TextBox. Depois disso feito, rode o
projeto.
Você vai ver que podemos navegar através dos registros. Como você notou, a economia
de código foi de 100 %.
Tudo o que for digitado ou trocado nas TextBoxs vai ser alterado diretamente no banco
de dados, sem necessidade nenhuma de usar métodos Edit ou Update.
Devo dizer que é um excelente recurso para consultar dados. Na prática, naum se usa
muito esse tipo de controle. Pois na maioria dos aplicativos, temos que fazer validação do
que o usuário digita nas caixas de texto, limitar algumas delas, validar dados, etc. Além
disso, funções como excluir registros, adicionar registros, devem ser feitas manualmente.
O Controle DataGrid(DbGrid)
119
Depois de feito isso e o controle já estar visível na caixa de ferramentas, clique nele e o
arraste-o para o mesmo formulário onde criamos o nosso cadastro de clientes.
Vá na propriedade DataSource da DataGrid. Você verá que aparecerá o nosso objeto Data
na lista. Selecione-o. De fato, para usarmos o objeto DataGrid, temos que ter um objeto
Data já configurado, no mesmo formulário.
Feito isso, já preenchemos o DataGrid com os dados existentes no objeto Data. Rode o
projeto e confira o resultado.
120
Note que ao mudarmos de registro no DataGrid, o registro também troca no objeto Data
e vice-versa.
O Datagrid funciona de forma bem semelehante ao objeto Data. Quando alteramos um
campo via DataGrid, estamos alterando diretamente no banco de dados, sem necessidade de
algum comando adicional. No entanto existem propriedades que nos permitem bloquear
esse tipo de alteração direta. Vejamos algumas propriedades do DataGrid:
121
Alignment : Alinha dos dados na coluna na forma determinada nesta propriedade.
Impressão
O objeto Printer
O objeto Printer nos permite obter um total controle sobre as tarefas de impressão. Tem
propriedades que nos possibilitam alterar a fonte do que será impresso, alterar a impressora
padrão, alternar para fonte em negrito, etc. Tem métodos que nos possibilitam saltar para a
próxima página, terminar a impressão, imprimir na linha x, coluna x,etc. Veremos agora as
principais propriedades do Printer:
ColorMode: Determina ou mostra a capacidade de impressão colorida do dispositivo.
Copies: Especifica a quantidade de cópias de uma página que deve ser impressa.
CurrentX: Determina a coordenada horizontal que a impressora irá imprimir.
CurrentY: Determina a coordenada vertical que a impressora irá imprimir.
DeviceName: Mostra o nome da impressora padrão suportada pelo dispositivo
FontName: Determina qual fonte de letra a impressora usará para impressão.
FontBold: Determina se a fonte será em negrito.
FontItalic: Determina se a fonte será em itálico.
Fonts: Fornece uma lista de todas as fontes disponíveis para impressão.
FontSize: Determina o tamanho que a fonte de letra escolhida usará.
FontUnderline: Determina se a fonte será sublinhada.
Orientation: Determina a orientação do papel: Retrato ou Paisagem. Usamos as constantes
para definir o tipo escolhido:
vbPRORPortrait 1 Retrato
vbPRORLandscape 2 Paisagem
Page : Retorna o número da página que esta sendo impressa.
PaperSize: Determinamos o tamanho do papel. Podemos usamos as seguintes constantes:
vbPRPSLetter 1 Letter, 8 1/2 x 11 in.
VbPRPSLetterSmall 2 Letter Small, 8 1/2 x 11 in.
VbPRPSTabloid 3 Tabloid, 11 x 17 in.
VbPRPSLedger 4 Ledger, 17 x 11 in.
VbPRPSLegal 5 Legal, 8 1/2 x 14 in.
VbPRPSStatement 6 Statement, 5 1/2 x 8 1/2 in.
VbPRPSExecutive 7 Executive, 7 1/2 x 10 1/2 in.
122
vbPRPSA3 8 A3, 297 x 420 mm
vbPRPSA4 9 A4, 210 x 297 mm
vbPRPSA4Small 10 A4 Small, 210 x 297 mm
vbPRPSA5 11 A5, 148 x 210 mm
vbPRPSB4 12 B4, 250 x 354 mm
vbPRPSB5 13 B5, 182 x 257 mm
vbPRPSFolio 14 Folio, 8 1/2 x 13 in.
VbPRPSQuarto 15 Quarto, 215 x 275 mm
vbPRPS10x14 16 10 x 14 in.
vbPRPS11x17 17 11 x 17 in.
VbPRPSNote 18 Note, 8 1/2 x 11 in.
vbPRPSEnv9 19 Envelope #9, 3 7/8 x 8 7/8 in.
vbPRPSEnv10 20 Envelope #10, 4 1/8 x 9 1/2 in.
vbPRPSEnv11 21 Envelope #11, 4 1/2 x 10 3/8 in.
vbPRPSEnv12 22 Envelope #12, 4 1/2 x 11 in.
vbPRPSEnv14 23 Envelope #14, 5 x 11 1/2 in.
VbPRPSCSheet 24 C size sheet
vbPRPSDSheet 25 D size sheet
vbPRPSESheet 26 E size sheet
vbPRPSEnvDL 27 Envelope DL, 110 x 220 mm
vbPRPSEnvC3 29 Envelope C3, 324 x 458 mm
vbPRPSEnvC4 30 Envelope C4, 229 x 324 mm
vbPRPSEnvC5 28 Envelope C5, 162 x 229 mm
vbPRPSEnvC6 31 Envelope C6, 114 x 162 mm
vbPRPSEnvC65 32 Envelope C65, 114 x 229 mm
vbPRPSEnvB4 33 Envelope B4, 250 x 353 mm
vbPRPSEnvB5 34 Envelope B5, 176 x 250 mm
vbPRPSEnvB6 35 Envelope B6, 176 x 125 mm
vbPRPSEnvItaly 36 Envelope, 110 x 230 mm
vbPRPSEnvMonarch 37 Envelope Monarch, 3 7/8 x 7 1/2 in.
vbPRPSEnvPersonal 38 Envelope, 3 5/8 x 6 1/2 in.
vbPRPSFanfoldUS 39 U.S. Standard Fanfold, 14 7/8 x 11 in.
vbPRPSFanfoldStdGerma 40 German Standard Fanfold, 8 1/2 x 12
n in.
vbPRPSFanfoldLglGerma 41 German Legal Fanfold, 8 1/2 x 13 in.
n
vbPRPSUser 256 User-defined
Port: Retorna o nome da porta de impressão que será usada pela impressora padrão.
PrintQuality: Determina ou seta a resolução que a impressora irá usar.
VbPRPQDraft -1 Resolução Draft
vbPRPQLow -2 Baixa Resolução
vbPRPQMediu -3 Média Resolução
m
vbPRPQHigh -4 Alta Resolução
123
Vejamos agora, os principais métodos:
Quando usamos o objeto Printer, será de extrema necessidade o uso de uma função
auxiliar que só pode ser usado com o método Print ou com a instrução Print #. Esta função
é a função Tab e é usada para posicinar a saída. Imagine que estamos imprimindo alguma
coisa com o método Print. Queremos imprimir o título do relatório bem no centro da folha.
Se usássemos o método Print assim:
O título sairia no início da folha, agora usando a função Tab associada com o método
Print, podemos definir em qual coluna irá começar a impressão feita pelo método Print.
Deverá existir um ; (ponto e vírgula) entre a função Tab e o que queremos imprimir.
Mas se você não digitar não tem problema, pois o editor do Visual Basic se encarrega de
corrigir esse erro de sintaxe.
Vejamos agora, um exemplo de como poderia ser feito um relatório dos clientes na tabela
que criamos.
Primeiramente, abre o último projeto que criamos. No formulário que criamos, adicione
um botão de Imprimir e nomei-o como “CmdImprimir”.
124
No evento Load do botão, adicione o seguinte código:
Linha = 1
125
Printer.EndDoc
Printer.Font = "Arial"
Printer.FontBold = True
Printer.FontSize = 11
Uma para o banco de dados, outra para a tabela, e outra é referente a um contador de
linhas que criamos para limitarmos o número de linhas impressas por página em 50, quando
exceder, o programa irá passar para uma nova página.
Depois disto, instanciamos as variáveis do banco de dados e da tabela:
Linha = 1
Feito isso, iniciará um ciclio, a qual imprimirá um registro da tabela por vez, enquando a
tabela não chegar no final. Assim que tentarmos nos mover para um registro maior que o
último, o ciclio é interrompido e a impressão encerrará:
126
Na linha seguinte, verificamos se a variável Linha tem o valor 1, o que quer dizer que
estamos começando uma nova página, se tiver ela irá chamar o subprocedimento
Cabeçalho:
If Linha = 1 Then
Cabecalho
End If
Printer.Font = "Arial"
Printer.FontBold = True
Printer.FontSize = 11
Printer.FontBold = False
Linha = Linha + 1
Printer.Print Tab(5); Tabela!codigo;
127
Printer.Print Tab(15); Tabela!nome;
Printer.Print Tab(45); Tabela!endereco;
Printer.Print Tab(65); Tabela!datanasc;
Printer.Print Tab(93); Tabela!rg;
Printer.Print
If Linha = 50 Then
Printer.NewPage
Linha = 1
End If
Tabela.MoveNext
Incrementamos a variável Linha em 1, já que á cada ciclo será impressa uma linha:
Linha = Linha + 1
If Linha = 50 Then
Printer.NewPage
Linha = 1
End If
Se a linha for igual á 50, então usamos o método NewPage para passarmos para uma
nova página, e conseqüentemente, deveremos atribuir o Valor 1 a variável Linha. Pois
começaremos novamente a contar as linhas a partir de 1.
Depois de impresso o registro, passaremos para o próximo registro na tabela:
Tabela.MoveNext
Loop
Printer.EndDoc
128
É necessário usar esse método para encerrar a impressão, pois se não usássemos o
programa ficaria se comunicando com o Spool da impressora e os dados só seriam
impressos quando o programa fosse encerrado.
Existem várias versões do Crystal Reports espalhadas por aí. A versão que iremos usar é o
“Crystal Reports Report Design Component” .
Em outras versões do “Crystal Reports”, ele funciona como um programa separado onde
criamos os relatórios dentro dele mesmo. Esses relatórios, contituem um arquivo separado,
que terá de ser chamado pelo Visual Basic.
Com o “Crystal Reports Report Design Component” , você cria os relatórios dentro do
próprio Visual Basic, e não há necessidade nenhuma de ter um arquivo separado para cada
relatório. Esta é, na minha opinião, a granda vantagem de usar essa versão.
Bem, deixando de rodeios e indo ao que interessa, o que primeiramente precisamos para
criar um relatório usando o Crystal é ter ele instalado. Feito isso, ele já irá aparecer nos
menus do Visual Basic.
Para não termos problemas com o uso do assistente, devemos adicionar um componente
ao projeto. Vá no menu Project, selecione Components e marque o controle “Crystal
Report View Control”. Este controle é requerido pelo assistente quando ele cria o relatório e
se você não adicioná-lo terá problemas sérios ao encerrar o assistente. Esses “problemas
sérios” incluem o Visual Basic fechar e você perder tudo o que não foi salvo. Portanto, não
esqueça de marcar tal componente.
129
Para adicionarmos um novo relatório usando o Crystal Reports, acessamos o menu
Project e escolhemos a opção Add Crystal Reports 8.5.
Abrirá então uma janela perguntando se queremos criar o novo relatório usando o
assintente, se queremos criar um relatório vazio ou criar um relatório a partie de outro
existente.
Além disso, existe uma lista abaixo com vários tipos de relatórios predefinidos para que
possamos escolher.
Como vamos criar nosso relatório usando o assistente, marque a primeira opção e clique
em OK.
Feito isso, o assistente iniciará o processo:
130
Primeiramente, deveremos selecionar um banco de dados, de onde virão os dados do
relatório. Para fazer isso, clicamos no botão Project. Após clicarmos nesse botão, irá abrir
uma janela com várias opções para nos conectarmos com diferentes bancos de dados.
Como estamos utilizando conexão com banco de dados via DAO, marque a opção DAO
e clique no botão Browse para selecionar um banco de dados ou digite o caminho do banco
de dados na caixa de texto.
131
Note ainda que existe uma caixa abaixo, onde podemos selecionar para abrir vários tipos de
banco de dados diferentes. Como o banco de dados que iremos abrir é Access, então não
precisamos alterar.
132
Estando o nome do banco de dados e o tipo selecionado, podemos clicar no botão OK
para proseguirmos. Feito isso, abrirá uma janela onde podemos selecionar o objeto do
banco de dados que desejamos, no nosso caso, a tabela “Clientes”.
Atenção: Neste exemplo selecionamos a tabela “Clientes”. No entanto, podemos
selecionar mais de uma tabela sem problemas. O ato de adicionar mais de uma tabela ao
relatório não obriga o relatório a ser baseado em todas as tabelas. Mas por sua vez, mantém
essas tabelas disponíveis para usarmos no relatório.
Estando esta tabela selecionada, já podemos clicar no botão OK. O assistente retornará
novamente para a primeira tela.
Para proseguir, clicamos no botão Next.
133
O assistente então passará para o guia Fields, onde definimos quais campos aparecerão
no relatório:
Depois que você selecionar as opções que você deseja, clique em OK.
135
Veja que o assistente criou um Relatório(Report) com o nome “CrystalReports1”.
Nomeio-o como “RptClientes”. Caso já tivéssemos um relatório com o nome de
“CrystalReports1”, ele nomearia como “CrystalReports2”, e assim sucessivamente.
Note também que ele criou um formulário como o nome “Form1”. Se já tivéssemos um
formulário com esse nome, ele criaria um com o nome de “Form2” e assim sucessivamente.
Nome-o para “FrmRelCli”. Veja que esse formulário funciona como visualização dos
relatórios. Assim, quando precisarmos imprimir um relatório criado a partir do Crystal,
basta chamar o formulário que o assistente criou para esse relatório através do método
Show. O formulário fará toda a parte de imprimir o relatório para nós.
A janela abaixo mostra uma pré-visualização que foi criada pelo assistente do “Crystal”
em um formulário. Ela oferece recursos de Zoom, mudança de página, pesquisa e ainda
oferece recursos para alternarmos entre os grupos, caso estejamos trabalhando com
relatórios que contenham grupos.
Essa é única linha que teremos de alterar nesse código para que ele funcione
perfeitamente. Essa mudança só é necessária por que alteramos o nome do objeto Report.
Feito essa modificação, talvez você queira fazer alguns ajustes no Layout do relatório.
Um relatório é dividido em várias seções. Veremos agora a função de cada uma delas.
137
página ser impressa. Já o cabeçalho do relatório será impresso somente uma vez, antes de
qualquer página ser impressa.
A seção Details(detalhe) é a mais importante do relatório. É nela que irão os dados que
compõem o relatório. Como por exemplo, os campos nome, endereço, etc.
A seção Report Footer é o rodapé do relatório. Ou seja, é o que será impresso, no final do
relatório, após todas as páginas serem impressas.
A seção Page Footer é o rodapé da pagina. É o que será impresso no fim de cada página.
Usamos esta seção para imprimir, por exemplo, os números de página. Ao criar um
relatório pelo assistente, o Crystal automaticamente insere uma função, para retornar o
número de página nesta seção.
Text Objext – Um simples objeto de texto que tem a mesma função do objeto Label
nos formulários.
Além desses recursos, o Crystal ainda nos oferece recursos de poder inserir campos
especiais, como hora, data, etc. Vejamos alguns:
138
Exibe a data
Exibe a hora
Exibe a data de modificação
Exibe a hora da modificação
Exibe o número de registro
Exibe o número da página
Exibe o numero total de páginas
Printer.Font = "Arial"
Printer.FontBold = True
Printer.FontSize = 11
139
No evento Load do botão “CmdImprimir”, insira o seguinte código:
Linha = 1
If Linha = 1 Then
cabecalho
End If
Linha = Linha + 1
Printer.Print Tab(5); Tabela!codigo;
Printer.Print Tab(15); Tabela!nome;
Printer.Print Tab(45); Tabela!endereco;
Printer.Print Tab(65); Tabela!datanasc;
Printer.Print Tab(93); Tabela!rg;
Printer.Print
If Linha = 50 Then
Printer.NewPage
Linha = 1
End If
End If
Tabela.MoveNext
Loop
Printer.EndDoc
O código acima oferece um modo para filtrarmos alguma string com base no que for
digitado na TextBox.. Antes de o registro ser impresso, verificamos se a string inicial do
campo Nome do registro atual bate com o que foi digitado na Textbox.
Através da função Mid, que retorna uma substring de uma string, pegamos uma substring
inicial do campo Nome, com o tamanho da string que foi digitada em TxtFiltro. Se a
condição for verdadeira, tudo o que estiver no bloco If será executado e o registro será
impresso. Caso contrário, o programa passará ao próximo registro através do método
140
MoveNext do objeto Recordset “Tabela”. Depois disso, é encontrado o comando Loop e o
ciclo é reiniciado, passando o próximo registro agora pela verificação. Desta forma, só os
registros que coincidirem serão impressos. Rode o projeto e veja o resultado.
Como você pode confirmar, com o objeto Printer podemos controlar registro á registro o
que está sendo impresso. A questão então é: Como podemos criar relatórios com filtros no
Cystal?
Bem, na verdade existem muitas maneiras de se fazer isso. Algumas delas são até mesmo
bem complexas.
Ao definir uma tabela para um relatório, quando você o cria, seja pelo assistente ou outro
método, o relatório terá os dados da tabela naquele exato momento. Portanto, modificações
feitas na tabela após termos definido os dados no relatório, não serão refletidas no relatório.
Muitas pessoas usam uma tabela temporária (embora muita gente não aconselhe) para
filtrar somente os dados que se deseja em uma tabela (tabela temporária) e atribuem essa
tabela ao relatório. Alguns problemas com que você vai se deparar, são:
<
141
>
RptPlan.Database.SetDataSource Tabela
RptPlan.PrintOut
Esse código tem dois métodos do objeto Crystal Report que ainda não conhecemos. Um
deles é o método SetDataSource do objeto Database, que é membro do objeto Crystal
Report, ou seja, do relatório que criamos .
O objeto SetDataSource tem a função de atribuir uma origem de dados ao Crystal
Reports. Uma origem de dados pode ser uma tabela ou uma instrução SQL. Podemos, por
exemplo, criar um objeto RecordSet, instanciá-lo e atribuir ao relatório. Foi o que fizemos
no exemplo acima. Criamos um objeto Recordset chamado Tabela, instanciamos esse
objeto com a tabela que queremos usar no relatório. Como essa tabela é temporária,
efetuamos as possíveis operações de exclusão para deixar na tabela somente os dados que
nos interessam. Após isso, utilizamos o método SetDataSource, que, como você pode ver,
oferece uma sintaxe muito simples:
RptPlan.Database.SetDataSource Tabela
Depois disso, entra outro método que ainda não conhecemos, mas que também é muito
simples. É o método PrintOut do objeto Crystal Report. Este método envia diretamente o
relatório para a impressora.
Uma observação a ser feita e um problema bem comum é a de que quando você *chama
um relatório , fica armazenado nele o que foi impresso pela primeira vez. Então se você
voltar a imprimir esse relatório sem decarregá-lo da memória, e aplicar outro filtro, vai ver
que os dados impressos são iguais ao que você imprimiu na primeira vez.
Claro que se você aplicar o filtro, chamar o relatório, imprimir, fechar a aplicação e
voltar a imprimir o relatório, tudo funcionará perfeitamente. Mas, imagine que você tem um
formulário com um TextBox de filtro e um botão de impressão. Então você cria uma rotina
para visualizar a impressão. Provavelmente, você irá dar ao usuário a alternativa de digitar
um filtro e clicar no botão de impressão para ver o resultado, para depois imprimir. Então o
usuário poderia testar várias vezes o filtro selecionado que ele quer. O que acontece aqui é
que assim que ele atribuir uma origem de dados ao relatório pela primeira vez, os dados do
primeiro filtro que ele atribuir ao relatório, serão sempre os exibidos quando ele for acessar
o relatório novamente. Para contornar esse problema, devemos sempre descarregar o
relatório da memória, através do comando Unload, depois que ele foi usado. Exemplo:
Unload RptCli
142
visualizar os dados antes de imprimir, estiver exibindo dados do relatório e você
descarregar o relatório da memória, não haverá visualização dos dados. Uma dica: No
formulário de visualização (aquele que o assistente cria pra você e que possibilita visualizar
os dados), descarregue o relatório da memória no evento Unload. Exemplo:
If TxtFiltro.Text<>”” then
Set Tabela = Banco.OpenRecordset(“Select * from Clientes Where Nome Like ‘ “
& TxtFiltro.Text & “*’” )
Else
Set Tabela = Banco.OpenRecordset(“Clientes”)
End if
RptPlan.Database.SetDataSource Tabela
RptPlan.PrintOut
143
Primeiro, declaramos 2 variáveis. Um objeto Database e outro RecordSet.
If TxtFiltro.Text<>”” then
Se ela não estiver vazia, abrimos a tabela usando uma instrução SQL(Explicarei logo
após) que abre a tabela já com o filtro aplicado. Este filtro é feito com base nos primeiros
caracteres digitados em “TxtFiltro”:
Caso contrário:
Else
Set Tabela = Banco.OpenRecordset(“Clientes”)
Abrirá a tabela normalmente, sem nenhum filtro a aplicar, o que quer dizer que se não
difitarmos nada na TextBox, todos os registros serão exibidos no relatório.
Feito essa verificação, o bloco If é encerrado:
End if
Depois disso, atribuímos a tabela com ou sem o filtro ao nosso relatório e jogamos tudo
para a impressora:
RptPlan.Database.SetDataSource Tabela
RptPlan.PrintOut
Como você pode ver é um código bem simples e a única parte do código desconhecida
pelo aluno é o uso de uma instrução SQL para abrir e filtrar a tabela. Não é propósito do
nosso curso abordar sobre instruções SQL, no entanto, irei abordar ela sobre a questão de
filtros, sendo que é um recurso que não é complexo, mas ao mesmo tempo é um recurso
muito poderoso.
144
Para entender como funciona uma instrução SQL, primeiramente olhe para a linha a
seguir:
Select – Quer dizer que estamos selecionando campos de uma tabela. O * existente depois
da palavra Select quer dizer que todos os campos foram selecionados. Poderíamos escolher
somente Nome e Código, caso quiséssemos. Neste caso, o farámos demilitando os campos
por vírgula. Exemplo:
From – Especifica a origem de dados. O que virá após From é o nome da tabela de onde
virão os dados.
Where – Esta cláusula é o motivo pela qual fizemos esse superficial estudo sobre
instruções SQL . A cláusula Where nos permite aplicar um filtro à tabela com base no
critério especificado. O que irá após á cláusula Where é o critério de filtro. Olhamos
novamente para esta linha:
Um recurso muito útil que a linguagem SQL nos oferece é a possibilidade de procurar
registros pelos seus caracteres iniciais ou finais, ou, até mesmo, por uma Substring dentro
de uma string. Esse recurso é muito simples de usar. Utilizando o operador LIKE no lugar
do sinal de igual, com um * no início ou no final da string a procurar, podemos pesquisar
pelos caracteres iniciais ou finais, respectivamente. Podemos também, inserir um * no
início e outro no final da string. Estaremos desta forma, pesquisando qualquer registro que
contenha a string especificada. Para esclarecer um pouco sobre isso, dê uma olhada nos
exemplo á seguir:
145
Irá selecionar todos os registros que tiverem no campo nome nomes que comecem com
“Jô”:”João”, “José”,”Jovana”, etc...
O * no final da string indica que estamos ignorando os últimos caracteres.
O exemplo acima irá selecionar todos os registros em que o campo Nome termina com
“ao”. “João”, “Estevão”, etc. Ignorando desta forma, os primeiros caracteres.
O exemplo acima procura um registro em que o campo Nome contenha a string “ar”,
ignorando os primeiros e os últimos caracteres.
Associar a linguagem SQL aos nossos programas para filtrar dados oferece economia de
código e eficência. Nosso curso não se destina á abordar sobre a linguagem SQL, no
entanto achei importante abordar sobre a questão de filtros.
Você também pode, ao usar uma instrução SQL, utilizar todos os outros operadores do
Visual Basic para especificar opções de critério:
O exemplo acima retornará o registro que tenha no campo Codigo um valor igual a 3.
Além disso, Muitas funções do Visual Basic também funcionam dentro de uma instrução
SQL. A única diferença será que o aluno deverá substituir as aspas duplas “” pelas aspas
simples ‘’.
A forma como usamos as instruções SQL dentro do Visual Basic é muito simples. Basta
você a usar aonde colocaria o nome da tabela. Por exemplo:
Agora que já temos uma noção sobre instruções SQL, iremos analisar, áquela linha do
código que usamos para filtrar o relatório:
Set Tabela = Banco.OpenRecordset(“Select * from Clientes Where Nome = ‘ “ & TxtFiltro.Text &
“*’” )
É uma instrução SQL simples. O único fato que merece um esclarecimento é a concatenação
g que usamos para a instrução SQL.
Como temos um Textbox e o filtro será com base nesse Textbox, logo teremos que
concatenar a instrução SQL com o conteúdo de “TxtFiltro”, através da propriedade Text.
(“Select * from Clientes Where Nome = ‘ “ & TxtFiltro.Text
Após o sinal de igual(=), usamos uma ‘ (aspas simples), pois o campo a qual estamos
filtrando a tabela é Text, que funciona como se fosse uma variável String, por isso a
necessidade das ‘’(aspas simples). Como ainda iremos concatenar a instrução SQL com o
146
valor contido em “TxtFiltro”, apenas abrimos as aspas simples, deixando para fechar logo
após a concatenação com a Textbox “TxtFiltro”.
Depois da ‘(aspas simples), utilizamos a aspas duplas para fechar a string, e,
concatenamos, através do operador &, com o texto contido em “TxtFiltro”:
“ & TxtFiltro.Text
Para facilitar o entendimento, digamos que o usuário tenha digitado na Textbox, o string
“ma”. Essa string será concatenada com a string á esquerda dela através do operador &.
Isso resultará na seguinte String:
Como você viu, ainda faltam o * e uma aspa simples no final da expressão para que a
instrução SQL funcione. É isto que faz o restante da expressão:
& “*’ ”
Como resultado final, tudo o que for digitado na Textbox será pesquisado no campo
nome da tabela “Clientes”. Se os primeiros caracteres coincidirem, o registro será aceito.
147
Bem, a primeira coisa que devemos fazer nesse código, é retirar a linha existente na
seção General-Declarations do formulário, já que renomeamos o nome do formulário e
agora essa declaração não aponta para lugar algum.
Analisando o código, onde podemos nesse código aplicar o nosso filtro?
A resposta é: No evento Load.
Claro que colocar Um Textbox nesse formulário para digitar o filtro não seria o correto,
já que esse é um formulário próprio para a visualização. Como esse é um exemplo prático,
façamos o seguinte.
Criamos um novo formulário, como o que já criamos anteriormente para aplicar filtros,
com a seguinte aparência:
148
Dim Banco as Database
Dim Tabela as RecordSet
If FrmFiltro.TxtFiltro.Text<>”” then
Set Tabela = Banco.OpenRecordset(“Select * from Clientes Where Nome like ‘ “ &
FrmFiltro.TxtFiltro.Text & “*’” )
Else
Set Tabela = Banco.OpenRecordset(“Clientes”)
End if
RptCli.Database.SetDataSource Tabela
A única diferença está em 2 linhas nesse código, onde fizemos referência ao objeto
“TxtFiltro” do formulário “FrmFiltro”. O Visual Basic trata os objetos de um formulário
como variáveis públicas. Então podemos acessa-los de qualquer parte do projeto, bastando
anteceder seu nome pelo nome do formulário seguido de .(ponto).
FrmFiltro.TxtFiltro.Text
Enfim, com esse código acima, já conseguimos obter o filtro que precisamos. Com isso,
já podemos jogar os dados para a impressora. Mas não é isso que queremos agora. O que
queremos é visualizar os dados antes de imprimir. Olhando para o restante do código do
evento, só temos que alterar uma propriedade:
Screen.MousePointer = vbHourglass
CRViewer1.ReportSource = Report
CRViewer1.ViewReport
Screen.MousePointer = vbDefault
Alterando, ficará:
Screen.MousePointer = vbHourglass
CRViewer1.ReportSource = RptCli
CRViewer1.ViewReport
Screen.MousePointer = vbDefault
149
Rode o projeto e confira o resultado.
1
Autor:Dieimes Viana Corrêa
Email:dieimes_c@yahoo.com.br
Fone: (051) 91538814
150