Aprenda a desenvolver aplicativos

VBA e aproveitar seus recursos

Capítulo 1 - Entendendo o VBA (Visual
Basic for Applications)
...................................... 5

Introdução
..................................................................
Pré-requisitos para se trabalhar com
este livro ................................. 7

0 Visual Basic for Applications (VBA) e

o Microsoft Excel ............... 8

0 VBA e os objetos do Microsoft Excel

........................................... 10

As macros e a segurança no Excel

................................................... 11

Gravando uma nova macro

...............................................................
13

Visualizando o código VBA de uma

macro ..................................... 20
Capítulo 2 - Como criar programas:
lógica e algoritmos
.................................................... 27

Introdução
..................................................................

0 que é um algoritmo
..................................................................

Como criar um algoritmo

..................................................................

Entendendo um algoritmo
................................................................3

Algumas considerações sobre o uso de

algoritmos ....................... 36
Capítulo 3 - Manipulando os objetos do
Excel com o VBA - (Parte 1)
................................. 39

Introdução
..................................................................

Análise de um código do VBA

..........................................................40

Explorando outros objetos do Excel

............................................... 47

Capítulo 4 - Manipulando os objetos do

Excel com o VBA - (Parte 2)
.................................71

Introdução
..................................................................

Entendendo as variáveis
..................................................................

Utilizando variáveis no VBA do Excel

............................................... 75

Executando um programa passo a passo

para o Debug ................ 82

Prevenindo erros de execução e

resultados indesejados .............. 89

Algumas observações sobre estruturas

condicionais e de repetição
..............................................................
96
Criando botões para executar o
programa ...................................... 96

Alterando as propriedades do controle

Botão .............................. 104

Inserindo e organizando novos botões

......................................... 106
Introdução

Hoje como nunca, estamos vivendo

difusão em massa do uso dos
computadores para as mais diversas
tarefas, que vão desde o entretenimento
até a elaboração de sistemas de gestão
de dados.

De fato, em sua origem, o computador

foi criado para executar com maior
rapidez ações relacionadas ao trabalho,
tais como digitação de documentos,
armazenamento e busca de dados e
realização de cálculos extremamente
complexos em poucos segundos.
Todavia, em plena era digital ainda
acontece de termos que fazer inúmeras
vezes a mesma coisa (digitar o mesmo
documento, estruturar a mesma planilha
etc.).

Para resolver o problema da execução

repetitiva de tarefas rotineiras, muitos
aplicativos, entre os quais o Microsoft
Excel, incorporaram com o tempo
ferramentas e recursos que tornaram
possível "automatizar" determinadas
sequências de comandos, simplificando
de modo substancial o trabalho do
operador de um microcomputador.
 No Excel, por exemplo, é recorrente
termos que executar, em planilhas
diferentes, o mesmo tipo de operação,
como, por exemplo, uma filtragem
avançada que requer a definição de
vários parâmetros ou uma somatória de
dados que correspondam a determinado
critério. Assim, é possível criar um
"mini-programa" que faça todas essas
tarefas automaticamente sempre que
executado a partir de um atalho do
teclado ou um botão específico.

É nisso que consiste o VBA, acrônimo

de Visual Basic for Applications: um
ambiente de desenvolvimento onde é
possível escrever, via código de
programação, aplicativos que serão
executados exclusivamente dentro do
ambiente de trabalho do Microsoft Excel
(ou até mesmo em outros programas do
pacote Microsoft Office).

Na verdade, 0 VBA nada mais é que

uma versão especial derivada do
Microsoft Visual Basic, popular
linguagem de programação amplamente
utilizada para a criação de softwares,
desenvolvida e distribuída pela
Microsoft e parte integrante do pacote
Microsoft Visual Studio.

Criada a partir do aperfeiçoamento da

linguagem BASIC, o Visual Basic (ou
simplesmente VB) é dirigido por
eventos desencadeados a partir das
ações do usuário e possui um ambiente
de desenvolvimento integrado (IDE -
Integrated Development Environment)
totalmente gráfico, o que torna muito
mais simples a construção da interface
das aplicações (GUI - Graphical User
Interface, que dá ori gem ao nome
"Visual"). Em suas primeiras versões, o
Visual Basic não permitia acesso a
bancos de dados, sendo, portanto,
voltado apenas para a criação de
pequenos aplicativos de execução local;
mas, devido ao sucesso entre as
empresas que faziam uso de
componentes adicionais fabricados por
terceiros para acesso a dados, a
linguagem logo adotou tecnologias como
DAO (Data Access Object, um padrão
usado em engenharia de software), RDO
(Remote Data Object) e ADO (ActiveX
Data Objects, um mecanismo criado
pela própria Microsoft para a troca de
informações entre bases de dados),
permitindo fácil acesso a fontes de
dados externas, característica esta que
no VBA possibilita a obtenção de dados
provindos de bases criadas em outros
aplicativos, tais como o Microsoft
Access, por exemplo.

É interessante ressaltar que o Visual

Basic e o VBA utilizam o mesmo motor
de linguagem, isto é, a mesma estrutura
de sintaxe, o mesmo ambiente de edição
e, na grande maioria dos casos, as
mesmas ferramentas para o trabalho.

Pré-requisitos para se trabalhar com

este livro

Por tratarmos de um assunto bastante

específico, como a criação de
aplicativos pela linguagem VBA, é
extremamente importante que o usuário
possua domínio, mesmo que básico, das
características e funções do Microsoft
Excel.

Além disso, o leitor deverá conhecer

alguns conceitos relacionados ao
sistema operacional Microsoft Windows
(independentemente da versão,
preferencialmente a que se vai
trabalhar), tais como funcionamento e
estrutura de janelas e caixas de diálogo,
finalidade dos botões de comando,
cópia e colagem de dados e salvamento
de arquivos.

Portanto, sugerimos que, caso precise

rever ou aprofundar seus conhecimentos
sobre esses assuntos, adquira um dos
livros relativos aos argumentos citados,
publicados pela Digerati Books.

A construção de programas requer

também que se conheça um pouco da
lógica de programação, isto é, do modo
como o computador obtém e processa
dados e nos retorna o resultado
desejado. No decorrer deste capítulo,
aprofundaremos um pouco mais os
conceitos ligados à lógica de
programação, para fornecer as bases
necessárias para o desenvolvimento de
aplicativos em VBA.

O Visual Basic for Applications (VBA)

e o Microsoft Excel

As primeiras linguagens de macro para

planilhas eletrônicas associavam letras
aos comandos e elementos manipulados,
referindose às iniciais (em inglês)
necessários para a execução de uma
tarefa. Se, por exemplo, usava-se a
sequência de comandos Spreadsheet
(planilha) > Create (criar) > New
(nova), bastava digitar na macro o
comando SCN para que esse
procedimento fosse automatizado.

Percebeu-se sucessivamente que esta

sintaxe apresentava inúmeros
problemas:

• as linhas de código, uma vez escritas,

ficavam incompreensíveis até mesmo
para quem as criou, pois, vários
comandos começam com a mesma letra
e, para diferenciá-los uns dos outros,
usava-se a segunda ou a terceira letra,
tornando muito complexa a tarefa de
associar cada caractere ao comando a
que se referia;

• os caracteres se referiam aos nomes

dos comandos em inglês, o que tornava
indispensável sua memorização por
parte do operador;

• esse tipo de sintaxe não permitia

automatizar tarefas executadas com o
uso do mouse, como, por exemplo, o
desenho de um círculo pelo arraste.

Para resolver esses problemas, as

primeiras versões do Microsoft Excel
introduziram um novo tipo de linguagem,
na qual os comandos utilizados no
código eram independentes daqueles
usados pelo usuário na interface gráfica
do aplicativo. Por exemplo, para copiar
uma célula ou um intervalo selecionado,
o usuário podia optar por usar:

• a sequência Editar > Copiar;

• as teclas de atalho CTRL + C,-

• o botão Copiar na barra de

ferramentas;

- o comando Copiar do menu auxiliar.

 No ambiente da linguagem macro,
todavia, qualquer uma dessas ações era
traduzida em uma única função chamada
=coPY().

Esses códigos baseados em funções

apresentavam, porém, algumas
desvantagens: em primeiro lugar, eram
específicos para o Ex cel, não sendo
possível adaptá-los a outros aplicativos
similares; em segundo lugar, a cada nova
versão do aplicativo, novos comandos
surgiam e, para eles, novas funções eram
disponibilizadas, tornando demasiado
extensa a lista de comandos oferecidos
ao usuário.
 Ao adotar o VBA, o Microsoft Excel
passou a incorporar uma tecnologia de
automatização conhecida tecnicamente
pelo nome de OLE automation, que
constitui uma ferramenta poderosa para
resumir as tarefas rotineiras dos
aplicativos a simples códigos de
comandos.

0 Excel foi o primeiro programa a tirar

proveito total desta nova tecnologia e,
neste panorama, o VBA opera como uma
linguagem que permite ao usuário
interagir com a aplicação de modo
independente, valendo-se não dos
comandos do Excel, mas sim da sintaxe
e da estrutura da linguagem de
programação Visual Basic.

Embora o Excel ofereça o VBA, este

não apresenta nenhum ponto de contato
com a estrutura interna do Excel. De
fato, o Excel disponibiliza ao VBA os
seus recursos sob forma de uma
"biblioteca de objetos", com a qual o
VBA trabalha para interagir com o
aplicativo. Disto resulta que o VBA não
opera exclusivamente com o Excel, mas
também com qualquer outro aplicativo
capaz de lhe fornecer uma "biblioteca de
objetos" com a qual ele possa dialogar.

0 esquema apresentado na Figura 1.1

demonstra a relação entre o VBA, o
Excel e outros aplicativos.
 Figura 1.1.: Esquema de comunicação
entre o VBA e os aplicativos do
Microsoft Office.

Na verdade, o VBA que acompanha o

Excel não é a única linguagem que pode
se comunicar com a Biblioteca de
objetos, pois, cada linguagem que
oferece suporte à tecnologia OLE
automation pode controlar os objetos do
Excel, bem como de outros aplicativos
compatíveis. Entre as linguagens mais
conhecidas, vale a pena citar o próprio
Visual Studio da Microsoft, o C++ e o
Delphi da Borland Software
Corporation.
O VBA e os objetos do Microsoft Excel

Como dissemos no tópico anterior, a

Biblioteca de objetos do Excel oferece
ao VBA a possibilidade de interagir
com seus recursos. Ao afirmarmos isto,
fica claro que tais objetos são
disponibilizados não apenas ao
ambiente de desenvolvimento, mas
também, e mais importante, ao usuário
que dele faz uso. Em outras palavras,
para poder escrever seus próprios
códigos em VBA, você deverá conhecer
os objetos do Excel com os quais
operar, e assim explorar de modo
completo e aprofundado este recurso.
 A melhor maneira de compreender
como o VBA dialoga com os objetos do
Excel é, de início, gravar macros
simples utilizando a ferramenta de
gravação de macros e, em seguida,
visualizar o código gerado
automaticamente pelo VBA, como
faremos mais adiante.

Saiba mais: uma macro nada mais é

do que uma sequência de ações
gravada pelo usuário, a qual passa a
constituir um pequeno programa -
cujo código é gerado pelo próprio
VBA - que pode ser executado
inúmeras vezes a partir de um único
comando associado a uma
 combinação de teclas de atalho ou a
um botão inserido nas barras de
ferramentas do aplicativo.

É de extrema importância ressaltar

que, por executar códigos de programa
dentro do Excel, macros e aplicativos
VBA podem representar uma grave
ameaça para os usuários, pois, podem
conter códigos maliciosos criados para
corromper ou, pior, roubar informações
preciosas contidas em suas planilhas.

No tópico a seguir, veremos quais são

as medidas tomadas pelo Excel para
prevenir a execução de códigos
potencialmente perigosos e como
podemos nos defender desse tipo de
ataque.

As macros e a segurança no Excel

A possibilidade de criar e executar

códigos de programa dentro do Excel
pelo VBA foi explorada como brecha de
segurança pelos hackers, os famosos
"piratas da informática", para inserir
códigos ocultos ou mascarados com a
finalidade de acessar e manipular
informações contidas não apenas em
planilhas eletrônicas, mas também em
qualquer pasta de armazenamento do
computador. De fato, com muita perícia
e profundos conhecimentos em
programação e funcionamento do
computador, um hacker pode utilizar o
Visual Basic for Application para gerar
um pequeno vírus, graças ao qual obtém
acesso aos dados armazenados no
computador.

Por este motivo, já a partir da versão

2003, a Microsoft adotou em todos os
aplicativos do pacote Office um sistema
de segurança que bloqueia, por padrão,
a inicialização automática de macros e
programas VBA, alertando o usuário
sempre que um desses recursos tenta
executar qualquer tipo de operação, seja
no arquivo aberto ou em qualquer outro
local do computador.
 A adoção desse sistema de segurança,
porém, faz com que nem mesmo o
usuário consiga executar as macros e os
códigos VBA por ele gerados, o que
impossibilita testar seu funcionamento.
Assim, para que possamos realizar
nossos procedimentos, será necessário
alterar as configurações de segurança
acessando a Central de confiabilidade
do Microsoft Excel 2007.

Veja como proceder:

1. Inicie o Microsoft Excel 2007.

2. Clique no botão Office, localizado

no canto superior-esquerdo da janela do
aplicativo.

3. Embaixo, à direita do menu aberto,

clique no botão Opções do Excel,
acessando a caixa de diálogo com o
mesmo nome (Figura 1.2):

4. Na coluna de opções à esquerda da

janela, clique em Central de
confiabilidade.

5. No quadro maior, à direita, são

exibidas as opções do sistema de
segurança do Excel 2007. Clique no
grande botão rotulado Configurações da
Central de confiabilidade, à direita no
centro da janela.
 Figura 1.2.: Clique neste botão para
acessar as opções do aplicativo.
 6. Na nova janela Central de
confiabilidade, clique em Configurações
de macro, do lado esquerdo.

7. No grupo de opções à direita,

marque Habilitar todas as macros (...),
como mostra a Figura 1.3:

Figura 1.3.: Habilite a execução de

macros clicando na respectiva opção.

S. Clique no botão OK em todas as

janelas abertas para confirmar e retornar
ao espaço de trabalho do Excel.

As outras opções da janela da Central

de confiabilidade resultam nas seguintes
operações:

• ao marcar a opção Desabilitar todas

as macros sem notificação, todas as
macros estarão bloqueadas sem que
nenhuma mensagem de alerta seja
exibida ao usuário;

• ao marcar a opção Desabilitar todas

as macros com notificação, todas as
macros serão bloqueadas e o usuário
será notificado sempre que ocorrer o
bloqueio;
• ao marcar a opção Desabilitar todas
as macros, exceto as digitalmente
assinadas, o Excel liberará somente a
execução de macros e programas VBA
providos de assinaturas digitais,
usadas para confirmar a origem e a
integridade de um código de editor de
software;

• ao marcar a opção Habilitar todas as

macros (...), o Excel executará
qualquer macro e/ou programa VBA
anexado ao arquivo em uso. Trata-se
de uma opção perigosa quando não se
sabe a origem do documento, portanto
recomendamos mantê-la ativa ao abrir
documentos recebidos por e-mail ou
 descarregados pela Internet.

Lembre-se de que, a partir deste

momento, o Excel executará qualquer
macro ou programa VBA contido nas
planilhas abertas. Caso queira bloquear
novamente a execução de códigos
potencialmente maliciosos, repita os
procedimentos dos passos 1 a 6 e, na
janela da Central de confiabilidade,
marque a opção Desabilitar todas as
macros com notificação.

Gravando uma nova macro

Agora que a execução de macros e

códigos VBA está habilitada, podemos
experimentar na prática como criar e
gerenciar esses recursos no Excel.

Para começar, usaremos o sistema de

gravação de macros para gerar uma
nova macro que realize simples
operações de formatação para, em
seguida, visualizar no ambiente de
edição do VBA o respectivo código,
gerado automaticamente. Desta forma
teremos maior familiaridade com os
conceitos ligados à programação, tais
como objetos, linhas de código e
sintaxe.

Acompanhe o procedimento:
 1. Inicie o Excel com uma nova
planilha em branco.

2. Com o arraste do mouse, selecione

um intervalo de células qualquer na
planilha. Não se preocupe com a
quantidade e a posição das células
selecionadas, pois, esta ação ainda não
está sendo gravada pelo Excel, serve
apenas para aplicarmos a formatação
desejada em algumas células.

3. Na faixa de opções do Excel, clique

na guia Exibição.

4. Na extremidade direita da faixa de

opções, clique na pequena seta
localizada logo abaixo do botão
Macros, como mostra a Figura 1.4:

Figura 1.4.: 0 botão que dá acesso

ao recurso de Macro.

5. Note que é exibido um pequeno

menu com três opções:

• Exibir macros: usado para abrir a

caixa de diálogo que exibe a lista das
macros já existentes e fornece opções
para interagir com elas.

• Gravar macro/Parar gravação:

clicando nesta opção começa-se a
gravação de uma nova macro, como
veremos em breve. Caso a gravação já
tenha sido iniciada, o comando a
interrompe.

• Usar referências relativas: trata-se de

uma opção extremamente importante,
pois afeta diretamente a área afetada
pela execução da macro criada.
Quando ativada, faz com que as ações
realizadas pela macro abranjam o
intervalo de células relativo à primeira
célula selecionada na hora da
execução, independentemente do
intervalo selecionado durante a
gravação da macro. Por exemplo, se,
ao gravarmos uma macro,
selecionamos o intervalo A1:D6 mas,
ao executá-la, clicamos na célula B1, o
intervalo sele cionado pela macro será
B1:E6, ou seja, será reajustado
relativamente ao endereço da célula
ativa no momento da execução. Ao
contrário, desmarcando esta opção, a
macro agirá sempre no mesmo
intervalo selecionado quando ela foi
gravada, descartando qualquer outro
grupo de células selecionado pelo
usuário ao executá-la. Por padrão, esta
opção encontra-se desmarcada, porém,
para o nosso exemplo, precisamos que
seja ativada, portanto, clique Usar
referências relativas. Ao marcar a
opção, seu ícone no menu ficará
contornado por uma sutil borda
alaranjada. Não é necessário ativar
este recurso sempre que se grava uma
macro, pois, uma vez habilitado, ele
assim permanecerá até que se clice
novamente sobre o respectivo
comando. Antes de marcar ou
desmarcar esta opção, lembre-se de
verificar seu estado. A Figura 1.5
mostra a opção habilitada (em cima) e
desabilitada (em baixo).
Figura 1.5.: Verifique o estado da opção
antes de clicá-la.

6. Agora, clique novamente na seta

abaixo do botão Macros e, novamente
no menu suspenso, clique no comando
Gravar macro, para abrir a caixa de
diálogo com o mesmo nome.

7. Na pequena janela - mostrada na

Figura 1.6 - façamos as seguintes
configurações:
Figura 1.6.: A caixa de diálogo Gravar
Macro.

a. Clique no campo rotulado Nome da

macro, apague o nome sugerido pelo
aplicativo e digite um nome que
identifique claramente, em poucas
palavras, a finalidade da macro a ser
criada. 0 nome da macro não pode
conter caracteres especiais ($, %, &, #,
!, ?, . etc.) nem espaços em branco,
portanto use apenas letras (com ou sem
acentos, maiúsculas ou minúsculas) e
números. Para o nosso exemplo usamos
o nome MacroFormataçãol.

b. Logo abaixo, clique no pequeno

campo quadrado rotulado Tecla de
atalho e precedido por Ctrl +, então,
digite a letra que, pressionada junto com
a tecla Ctrl, comporá a combinação de
teclas de atalho para executar a macro
rapidamente. Por exemplo, se digitar a
letra K, o atalho que executará a macro
será Ctrl + K. Como sabemos, o Excel
já possui atalhos do teclado para os
comandos mais comuns, por isso, pode
acontecer de escolhermos para a macro
uma combinação já em uso. Neste caso,
o Excel se encarrega de alterar
automaticamente a combinação de teclas
para não gerar conflitos com os atalhos
já existentes. Por exemplo, suponhamos
que queremos associar à nossa macro a
combinação de teclas Ctrl + F mas que,
porém, está associada por padrão ao
comando Localizar e Substituir; ao
teclarmos F no campo Tecla de atalho, a
combinação é automaticamente alterada
para Ctrl + Shift + F, como podemos
observar na Figura 1.7.

c. Para continuar, abra o menu

desdobrável Armazenar macro em, onde
podemos escolher entre as seguintes
opções:

• Pasta de trabalho pessoal de macros:

clicando nesta opção, a macro será
gravada em uma pasta reservada ao
armazenamento de macros, o que torna
possível sua execução em qualquer
documento do Excel aberto.

• Nova pasta de trabalho: com esta

opção, será criada uma nova pasta de
trabalho onde será armazenada esta
 macro e em que será possível guardar,
sucessivamente, outras macros.

• Esta pasta de trabalho: neste caso, a

macro será armazenada juntamente ao
arquivo em uso e estará disponível
somente para este documento, não
podendo ser empregada em outras
pastas de trabalho do Excel.

• Para o nosso exemplo, mantenha ativa

a opção Esta pasta de trabalho.

d. No campo Descrição, podemos

digitar um breve texto que explique de
forma resumida as operações realizadas
pela macro. Embora o preenchimento
deste campo seja opcional, é
recomendável utilizá-lo, especialmente
quando criamos planilhas que serão
manipuladas por outras pessoas.

A Figura 1.7 mostra a caixa de diálogo

Gravar macro devidamente configurada
para o procedimento.
 Figura 1.7.: Veja como ficaram as
configurações da nossa nova macro.

8. Clique no botão OK para começar a

gravação da macro. Saiba que, a partir
deste momento, todas as operações
realizadas serão gravadas pelo Excel na
sequência exata em que são executadas.
Caso faça algo errado, não precisa se
preocupar: basta usar normalmente o
comando Desfazer e repetir a ação
corretamente, pois o gravador de macros
desconsidera a gravação de qualquer
comando desfeito.

9. Então, realizemos a formatação do

intervalo selecionado: acesse a guia
Início da faixa de opções.

10. Clique a pequena seta à direita do

botão Bordas.

11. No menu, clique a opção Todas as

bordas, como mostrado na Figura 1.8:
Figura 1.8.: Aplique bordas ao intervalo
selecionado.

12. Abra novamente o menu de bordas

e, desta vez, clique Borda superior
espessa.

13. Use o menu desdobrável Fonte

para aplicar a fonte Courier New.

14. Altere o tamanho da fonte para 10.

15. Em seguida, abra o menu do botão

Cor de preenchimento e use a paleta de
cores para aplicar uma cor de sua
preferência.

Terminadas as operações de
formatação, vamos interromper a
gravação e testar o funcionamento da
macro criada. Para isso:

16. Na faixa de opções, acesse

novamente a guia Exibição e clique na
seta abaixo do botão Macros.
 17. Note que agora é exibido o
comando Parar gravação, clique-o.

Pronto! Dispomos agora de uma macro

chamada MacroFormataçãol que, ao ser
acionada pelas teclas Ctrl + Shift + F,
formatará qualquer intervalo
selecionado aplicando bordas,
preenchimento e fonte definidos durante
a gravação.

Para testar seu funcionamento, faça o

seguinte:

18. Selecione outro intervalo na mesma

pasta de trabalho (pode ser em uma
planilha qualquer, desde que na pasta de
trabalho ativa).

19. Pressione a combinação de teclas

de atalho definida na caixa de diálogo
Gravar macro (no nosso exemplo, Ctrl +
Shift + F).

Se tudo foi feito corretamente, o

intervalo selecionado será formatado de
acordo com as especificações
fornecidas ao criar a macro.

Sugerimos que salve este arquivo, pois

retornaremos a usá-los em nossos
exemplos. 0 salvamento de pastas de
trabalho que contêm macros requer
alguns cuidados especiais. Vejamos
quais:

1. Clique o botão Office.

2. Clique o comando Salvar ou, se

preferir, use a combinação de teclas de
atalho Ctrl + B.

3. Na janela Salvar como selecione

normalmente a pasta na qual deseja
salvar o documento e digite um nome
para ele no campo Nome do arquivo (o
nosso arquivo foi salvo com o nome
Macro-l).

4. Logo abaixo, no menu desdobrável

Tipo, é preciso selecionar um formato
de arquivo que ofereça suporte para a
gravação de pastas de trabalho com
macros e/ou aplicativos VBA. Para isso,
abra-o e selecione a opção Pasta de
trabalho habilitada para macro do Excel,
como mostra a Figura 1.9:
 Figura 1.9.: Ao salvar, selecione o
formato de arquivo com suporte a
macros.

S. Para concluir, clique no botão

Salvar.

Se, ao salvar, esquecermos de

selecionar o formato de arquivo
apropriado para o armazenamento de
macros, é exibida a mensagem mostrada
na Figura 1.10. Caso isso ocorra, clique
Não e escolha o formato de arquivo
correto.
 Figura 1.10.: Esta mensagem alerta
sobre impossibilidade de salvar macros
no formato atual.

Visualizando o código VBA de uma

macro

Neste tópico faremos nosso primeiro

contato com o ambiente de
desenvolvimento do VBA. 0 intuito é
compreender sua estrutura e seu
funcionamento, bem como a essência de
um código de programa escrito em VBA
para, sucessivamente, criar nossos
próprios códigos ou modificar aqueles
gerados automaticamente.

Vejamos, então, como acessar o modo

de edição do VBA. Primeiramente, é
imprescindível ter aberto um arquivo
que contenha uma macro ou um
aplicativo VBA. Para o nosso exemplo,
usaremos o arquivo Macro_1, que
contém a macro de formatação gravada
no tópico anterior. Para melhor
compreender as explicações descritas a
seguir, sugerimos que o leitor use o
mesmo arquivo, caso não o tenha salvo
ou queira criá-lo novamente, reveja os
procedimentos mostrados no tópico
Gravando uma nova macro deste
capítulo. Então comecemos:

1. Com o arquivo Macro-1 aberto,

clique a guia Exibição da faixa de
opções do Excel.

2. Na extremidade direita da faixa,

clique logo abaixo do botão Macros e,
no menu suspenso, clique na opção
Exibir macros, para visualizar a caixa
de diálogo Macro mostrada na Figura
1.11:
Figura 1.11.: Nesta caixa podemos ver e
modificaras macros existentes.

3. Na pequena janela aberta,

observamos as seguintes características:
• no quadro rotulado Nome da macro o
Excel lista todas as macros existentes
na pasta de trabalho aberta. Repare
que, no nosso caso, é listada apenas a
macro criada anteriormente, que
chamamos MacroFormataçãol;

• logo abaixo do quadro superior, o

menu desdobrável Macros em permite
escolher a pasta de trabalho em que
estão armazenadas as macros que
desejamos visualizar. A opção exibida
por padrão é Todas as pastas de
trabalho abertas, que faz com que
sejam listadas as macros de qualquer
pasta de trabalho aberta no Excel, ativa
ou não. Portanto, se estivermos, por
exemplo, com três pastas de trabalho
abertas e cada uma delas contivesse
uma ou mais macros, todas elas seriam
listadas na caixa de diálogo Macro.
Para visualizar apenas as macros da
pasta de trabalho ativa, basta abrir o
menu desdobrável e selecionar a opção
Esta pasta de trabalho. 0 leitor deve se
lembrar que, ao realizar a definição
das características da macro antes de
começar sua gravação, o Excel
disponibilizou a possibilidade de
armazenar todas as macros em uma
pasta de trabalho específica para este
fim (veja o passo 7, item c do tópico
Gravando uma nova macro), apesar de
não termos usado esta opção, caso o
usuário tivesse uma pasta de
armazenamento de macros, ela também
seria mostrada como opção no menu
desdobrável Macros em, como mostra
a Figura 1.12:

Figura 1.12.: Um exemplo de pasta de

trabalho específica para macros.

• abaixo do menu desdobrável,

podemos ver a descrição que
digitamos ao criar a macro. Trata-se de
um detalhe muito importante, que
permite ao usuário entender com
clareza as operações executadas pela
macro. Por isso, ao criar uma nova
macro, é de extrema importância
digitar uma descrição resumida, porém
clara, daquilo que a macro fará na
planilha em que será executada;

• à direita da caixa de diálogo Macro,

temos a sequência de botões que
permitem interagir com a macro
selecionada. São eles:

• Executar: executa a macro

selecionada no quadro à esquerda.
• Depurar: permite executar a macro
passo a passo acompanhando a
execução de cada linha de código que
compõe a mesma. É um recurso muito
utilizado para encontrar e corrigir
eventuais erros na macro.

• Editar: como veremos logo adiante,

serve para acessar o ambiente de
desenvolvimento do VBA para editar
manualmente o código de
programação.

• Criar: permite iniciar a criação de

uma nova macro.

• Excluir: clique neste botão se

desejar excluir a macro selecionada
no quadro à esquerda.

• Opções: abre a caixa de diálogo

Opções de macro, estruturalmente
idêntica àquela exibida ao gravar uma
nova macro. Nela, podemos alterar as
teclas de atalho e/ou a descrição
associadas à macro selecionada.

• Cancelar: assim como o botão

Fechar no canto superior-direito da
janela, serve para fechar a caixa de
diálogo descartando quaisquer
alterações feitas.

4. Clique no botão Editar para acessar,

finalmente, o ambiente de
desenvolvimento do VBA.

5. É importante ressaltar que, neste

momento, não estamos mais trabalhando
no Excel, mas sim no sistema VBA,
portanto, todos os elementos da janela
são distintos e específicos deste
ambiente, não tendo nada em comum
com a interface do Microsoft Excel
2007. Observe com muita atenção a
janela exibida na Figura 1.13 e veja, de
cima para baixo, os elementos de que
dispomos para trabalhar com o VBA:
 Figura 1.13.: A janela do ambiente de
desenvolvimento do VBA.

a. Na parte superior da janela

encontra-se a Barra de título, graças à
qual percebemos não estar mais no
Excel, mas em outro ambiente: note que
ela traz escrito Microsoft Visual Basic,
seguido pelo nome da pasta de trabalho
em que a macro foi gravada (no nosso
caso, Macro [Link]).

b. Logo abaixo, temos a Barra de

menus do VBA, que traz comandos
específicos deste ambiente de
desenvolvimento. Aqui não
encontraremos os comandos
relacionados ao Excel, e sim aqueles
necessários para trabalharmos com
códigos de programas.

c. Mais embaixo, encontra-se a Barra

de ferramentas do VBA, com os botões
de atalho para os comandos mais
comumente empregados durante a
criação e/ou edição de códigos, como,
por exemplo, salvar, executar,
interromper execução do código etc. 0
campo localizado na extremidade direita
da barra merece atenção especial,
vemos ali a referência da linha e da
coluna em que se encontra o cursor na
área de digitação do código. No
exemplo da Figura 1.14, o texto Ln 37,
Co119 informa que o cursor está na
linha 37 e na coluna 10. Este recurso
torna-se muito útil durante o processo de
depura ção do código, isto é, durante a
busca e eventual correção de erros no
código.
Figura 1.14.: 0 campo mostra a posição
do cursor no código.

d. À esquerda do espaço de trabalho

do VBA, a pequena janela cuja barra de
título traz o rótulo Projeto - VBA
Project, é chamada Project Explorer
(explorador do projeto) e serve para
uma visão geral dos elementos que
compõem o projeto VBA ativo. Como
podemos observar na Figura 1.15, sua
estrutura lembra muito à do Windows
Explorer (o gerenciador de arquivos e
pastas do sistema operacional
Windows) e, no nosso exemplo, lista os
seguintes itens:

Figura 1.15.: A janela no Project

Explorer.
• Pasta Microsoft Excel objetos:
agrupa todos os objetos da pasta de
trabalho ativa. Como sabemos, o VBA
no Excel permite desenvolver novas
funcionalidades e automatizar tarefas.
Para isso, ele trabalha com os
elementos das pastas do Excel
(planilhas, células, intervalos, linhas,
colunas, gráficos, tabelas etc.)
tratandoos como objetos com os quais
ele possa interagir. No exemplo, o
Project Explorer lista a pasta de
trabalho e as três planilhas nela
contidas.

• Pasta Módulos: exibe todos os

módulos presentes no projeto ativo. No
 VBA os módulos são os recipientes
que contêm os códigos de programação
e é possível ter um módulo para cada
sequência de linhas de código. No
exemplo temos apenas um, chamado
pelo próprio programa de Módulol.

e. Abaixo do Project Explorer, temos a

janela de Propriedades (Figura 1.16)
que, ao selecionarmos um objeto, não só
exibe suas propriedades como também
permite alterá-las. Cada objeto possui
propriedades específicas, portanto, o
conteúdo da janela Propriedades pode
variar sensivelmente quanto à
quantidade de opções exibidas. No
exemplo da Figura 1.16, a janela mostra
as propriedades do objeto Planl, que é a
planilha 1 da nossa pasta de trabalho.
As propriedades são exibidas em duas
colunas: à esquerda o nome da
propriedade e, à direita, sua
configuração atual; por exemplo, tendo
como referência visual a Figura 1.16, a
propriedade Name (nome, em destaque)
tem como parâmetro atual Planl. Se
desejássemos alterar o nome da Planl no
ambiente do VBA, bastaria digitar o
novo nome na janela Propriedades ao
lado na propriedade Name:
Figura 1.16.: A janela Propriedades. Em
destaque a propriedade Name.
 f. 0 quadro que ocupa todo o centro do
espaço de trabalho do VBA é a Área do
código (Figura 1.17), em que é exibido
o código existente ou é possível digitar
um novo código do zero. Note, em sua
parte superior, a presença de dois menus
desdobráveis, que permitem selecionar
o objeto (à esquerda, atualmente
apresenta o texto (Geral)) e o
procedimento (à direita, agora contém o
rótulo MacroFormataçãol, que é o nome
da nossa macro).
 Figura 1.17.: A área do código.

Observe as linhas de código escritas

automaticamente pelo VBA ao
gravarmos a macro de formatação: por
enquanto elas podem não fazer muito
sentido, pois, ainda não conhecemos a
estrutura e a sintaxe da linguagem VBA.
Antes de aprofundarmos nossos
conhecimentos nessa linguagem, porém,
é preciso fazer uma rápida abordagem
às regras que regem a criação de
códigos de programas.

Por isso, no próximo capítulo,

aprenderemos um pouco sobre lógica de
programação de algoritmos, de modo a
adquirir uma base sólida que nos
ajudará muito na compreensão e na
criação dos nossos programas em VBA.

Para sair do editor do VBA e retornar

ao espaço de trabalho do Microsoft
Excel, basta abrir o menu Arquivo e
clicar Fechar e voltar para Microsoft
Excel ou, se preferir, apenas teclar o
atalho Alt + Q. Caso seja exibida uma
pequena caixa de diálogo pedindo
confirmação, clique Sim.
Introdução

Independentemente de quem as cria e

distribui, todas as linguagens de
programação têm essencialmente o
mesmo propósito, o de permitir ao
programador dar instruções ao
computador. De fato, trabalhar com uma
linguagem de programação significa
essencialmente saber instruir um
computador sobre como agir e/ou
responder às nossas ações. Fala-se em
"linguagem", pois utiliza-se um tipo de
idioma específico, que deve ser
entendido pelo usuário e pela máquina
para que a mesma saiba interpretar as
vontades de quem a opera.

Cabe aqui uma relação válida entre as

linguagens de programação e os idiomas
dos diversos países do mundo: o
aprendizado de uma língua não pode ser
reduzido ao ato de decorar as palavras
que a compõem, mas é preciso conhecer
as regras gramaticais e sintáticas, bem
como as conjugações dos verbos e o uso
correto de cada tempo e modo, os
diversos artigos e conjunções, as
expressões, as "frases feitas" etc. Neste
aspecto, a informática vale das
estruturas linguísticas em geral para
definir as linguagem por meio da qual
um programador possa "conversar" com
uma máquina.

Todavia, existe uma diferença

substancial entre aprender um idioma e
uma linguagem de programação: se, no
primeiro caso, podemos aprender as
regras de sintaxe e composição
simultaneamente ao uso de palavras e
verbos, na programação, é
imprescindível conhecer primeiro o
conceito de como se constroi um código
de programação, para, em seguida,
aprender seus comandos específicos e
suas regras de composição.

Este conceito é chamado de lógica de

programação, e visa formar o aspirante
programador sobre como definir e
estruturar aquilo que será o "esqueleto"
do programa, ou seja, o fluxograma
daquilo que o computador deverá fazer,
em que sequência e quantas vezes cada
operação deverá ser executada.

A estrutura de um programa, isto é, o

seu esquema de funcionamento
essencial, é totalmente independente da
linguagem de programação que se
pretende utilizar para escrevê-lo; por
isso, as regras definidas pela lógica são
as mesmas para todas as linguagens,
sempre.

A atividade de programação pode ser

dividida em dois momentos: o primeiro
consiste em definir com clareza e
coerência qual é o objetivo a ser
atingido ou, em outras palavras, aquilo
que o programa deverá fazer (o que
fazer?); o segundo é traçar o sistema de
como o programa fará para atingir o
objetivo (como fazer?).

No próximo tópico nos ocuparemos do

segundo momento, isto é: uma vez que
sabemos o que fazer, é preciso estruturar
um sistema que instrua o computador
sobre como fazê-lo. Para isso veremos
como estruturar algoritmos simples que
ajudem a direcionar a construção do
nosso código. Fazendo outra relação
com o nosso cotidiano, podemos dizer
que um algoritmo é, para o programador,
o mesmo que um projeto para um
construtor: um esquema a ser seguido no
qual se encontrarão todos os detalhes
necessários.

Por se tratar de um assunto muito

complexo, abordaremos neste capítulo
apenas os conceitos essenciais para os
fins deste livro, deixando o leitor à
vontade para prosseguir os estudos nesta
área e aprofundar seus conhecimentos.

O que é um algoritmo

Um algoritmo é um procedimento
constituído por uma sequência de
operações básicas, que visa transformar
um ou mais valores fornecidos pelo
usuário (chamados de "dados de
entrada" ou input) em um ou mais
valores de saída (output), apresentados
ao usuário como resultado da execução.
Portanto, um algoritmo define uma
função que processa o conjunto dos
dados de entrada, traçando um
procedimento finito que permite
determinar cada possível entrada e os
respectivos valores de saída.

Em palavras mais simples, um

algoritmo é constituído basicamente por
uma sequência estruturada de instruções
a serem executadas pelo computador na
ordem exata em que aparece no
algoritmo.

Podemos comparar um algoritmo a uma

série de indicações fornecidas para
chegarmos a um determinado local. Veja
um exemplo - suponhamos que um
motorista nos pergunta qual é o caminho
para chegar à borracharia mais próxima
e nós, sabendo onde ela está, nos
oferecemos para ajudá-lo a encontrá-la.
Assim, daremos a ele as instruções:

Siga em frente até o próximo semáforo,

então vire à direita e, depois, vire na
primeira viela à esquerda. Vá adiante
até chegar num grande supermercado
que está à sua direita numa grande
rotatória. No segundo cruzamento pelo
qual passará, vire à direita. Estará na
rua Dom Pedro ll. a ,borracharia fica
do lado esquerdo.

Pressupondo que nós fornecemos as

indicações exatas e que o motorista irá
segui-Ias exatamente como as
descrevemos, com certeza ele chegará
ao lugar certo. Contudo, se, mesmo
sabendo exatamente onde a borracharia
está, fornecêssemos indicações
imprecisas, ou pior, erradas, o motorista
ficaria perdido e não chegaria ao local.

Da mesma forma, quando escrevemos

um algoritmo para um programa de
computador, devemos ser extremamente
precisos, pois o computador fará, ao pé
da letra, tudo que indicarmos por meio
do algoritmo; portanto, ao informar
qualquer instrução errada, o resultado
não será o esperado, retornando erro na
execução do programa ou uma resposta
diferente da almejada.

A criação de algoritmos envolve o uso

de elementos como variáveis; funções;
estruturas condicionais e de repetição
etc. Nos exemplos deste capítulo
atentaremos à estruturação de
procedimentos, não aprofundando
questões específicas que fogem do nosso
propósito.

Como criar um algoritmo

A construção de um algoritmo pode ser

muito complexa e demorada ou
extremamente simples, dependendo
unicamente do tipo e da quantidade de
operações que o programa executará.
Como dissemos na introdução, o intuito
deste capítulo não é entrar em detalhes
relativos à lógica de programação, mas
sim fornecer ao leitor uma base de
conhecimento que o ajude a se orientar
na construção de linhas de código, bem
como entender a estrutura de códigos
existentes, como o que vimos no
exemplo da macro gravada nos
procedimentos do Capítulo 1. Por este
motivo, trataremos neste tópico apenas
das características gerais da estrutura de
um algoritmo para criar
"pseudoalgoritmos", que nos servirão
para criar o código de programa
propriamente dito.

Começaremos a tratar do assunto a

partir de um exemplo prático ao alcance
da maioria dos usuários do Excel.
Digamos que o nosso objetivo seja
construir um algoritmo que descreva a
sequência de passos necessários para
formatar um determinado intervalo de
células a critério do usuário.

Vamos definir em detalhes aquilo que o

nosso pseudo-código deverá fazer:

Primeiramente deverá renomear a Plan1

para Novo - Cadastro, em seguida
deverá excluir as planilhas Plan2 e
Plan3. Depois deverá aplicar ao
intervalo de células A3:F23 todas as
bordas simples, fonte Times New
Roman com tamanho 11, preenchimento
na cor cinza claro, moldura externa mais
espessa. Em seguida, no intervalo A3:
F3, deverá aplicar ao texto o estilo
Negrito, a cor branca e o alinhamento
centralizado, alterar o preenchimento
das células para azul escuro e aplicar
também moldura espessa. Então deverá
preparar os cabeçalhos das colunas
inserindo, respectivamente, as palavras
Nome Completo, Contatol, Contato2,
Endereço, RG, CPF, deixando a planilha
pronta para o uso.

Então, vejamos como ficaria a

estrutura do nosso projeto de código. No
próximo tópico analisaremos suas
características.
Entendendo um algoritmo

Como dissemos anteriormente, ao criar

um algoritmo usam-se comandos gerais,
isto é, não específicos de uma
determinada linguagem de programação.
Isso permite que a sequência de
comandos possa ser adaptada a qualquer
linguagem, bastando para isso adequar o
algoritmo às regras de sintaxe e usando
os comandos e parâmetros específicos
da linguagem de programação em uso.
 Então, vamos decifrar, trecho por
trecho, aquilo que o algoritmo está
programado para fazer:

• Linha 1: Algoritmo
"formataPlanilha". A primeira linha de
um algoritmo sempre começa com o
termo Algoritmo seguido pelo seu
nome, entre aspas. No nosso exemplo,
chamamos nosso algoritmo de
formatarPlanilha. Geralmente, os
nomes dos algoritmos e dos elementos
em seu interior seguem um padrão de
nomenclatura denominado
"camelCasing", que diz o seguinte:

• o nome deve conter apenas letras

e/ou números, mas não pode utilizar
caracteres especiais (%, &, !, ?, #
etc.) nem acentos, cedilha e espaços
em branco. Também não pode ser
igual a qualquer nome de comando,
parâmetro ou valor reservado aos
comandos;

• quando o nome é composto por duas

ou mais palavras, elas deverão estar
emendadas sem espaço, a primeira
deverá começar com letra minúscula e
a segunda com letra maiúscula. Por
exemplo, veja o nome dado ao nosso
algoritmo: formatarPlanilha.

Esse sistema de nomenclatura, apesar

de não ser obrigatório, é empregado
por todos os programadores com o
propósito de padronizar termos e modo
de escrever; portanto, recomendamos
segui-lo.

• Linha 2: // altera bordas, fonte,

preenchimento...

Na segunda linha encontramos uma

característica muito interessante dos
algoritmos: trata-se da possibilidade
de digitar comentários, isto é, breves
textos que não serão processados, mas
que servem para documentar ou
comentar trechos do "pseudo-código".
Nos algoritmos essas linhas devem
começar sempre com duas barras, mas
veremos sucessivamente que cada
linguagem de programação tem seu
próprio sistema de marcação para
sinalizar tais partes. No nosso exemplo
o comentário explica de modo
resumido o que irá acontecer nas
próximas linhas.

• Linha 3: início.

Ao escrever um algoritmo, sempre

deve-se identificar o início dos
procedimentos com a palavra início,
como no nosso exemplo.

• Linhas 4 a 9: planilha ("planl")

.selecionar...

Aqui é importante observar como a

propriedade nome do objeto Plan1 foi
alterado. Neste caso, para facilitar,
optamos por usar a mesma sintaxe
utilizada pelo VBA para nos referir às
ações e às propriedades relativas a
cada planilha, que consiste em separar
o objeto e a respectiva
propriedade/ação por um ponto.

Assim, por exemplo, na linha 7, o

comando planilha ("plan2"). excluir
indica que desejamos excluir o objeto
"planilha" identificado pelo rótulo
p/an2.
• Linha 10: // aplica ao intervalo
A3:F23 a formatação desejada.

Mais uma vez, uma linha de comentário

que informa as operações realizadas
pelas linhas que seguem.

• Linha 11: em seleção intervalo A3:

F23.

Usamos esta linha para descrever em

qual intervalo de células as alterações
deverão ser feitas. Este trecho de
código simula uma estrutura de
repetição, na qual todas as ações
contidas deverão ser realizadas
enquanto o intervalo estiver
selecionado (trata-se apenas de uma
representação, pois, a construção de
uma estrutura com todos os atributos
requer amplo conhecimento sobre este
assunto, o que foge do nosso escopo).
De qualquer forma, esta estrutura
começa na linha 11 com a instrução em
seleção intervalo A3: F23 e termina na
linha 23 onde, como veremos, há o
comando que encerra esta parte.

Todos os comandos incluídos entre as

linhas 11 e 23 serão aplicados apenas
ao intervalo especificado como
seleção.

• Linhas 12 a 22: [Link] = interna

e externa...

Nessa sequência de linhas, são

informadas as características de
formatação a serem aplicadas a todas
as células do intervalo selecionado. A
sintaxe é essencialmente a mesma que
vimos nas linhas 4 a 9, pois, para
separar o elemento a ser formatado da
propriedades usa-se um ponto; o
símbolo de igual seguido pelo valor
serve para especificar a nova
configuração da propriedade. Veja um
exemplo: a linha [Link] = preto
significa que a propriedade "cor" do
elemento "borda" deverá ser
configurada com o valor "preto", o que
resulta na aplicação da cor preta nas
bordas do intervalos selecionado.

0 mesmo vale para os demais

elementos e as respectivas
propriedades: [Link] = branco,
[Link] = 11, [Link]
= azul escuro etc.

• Linha 23: fim seleção.

Esta simples linha de comando

demarca o fim das operações a serem
realizadas no intervalo especificado na
linha 11. Como veremos mais adiante,
o VBA utiliza um sistema bastante
parecido, porém com outros termos.
• Linha 25: em seleção. intervalo
A3:F3.

Abaixo de mais uma linha de

comentário (linha 24), é definido o
início de outro intervalo de células, no
qual deverão ser aplicadas opções de
formatação diferentes do primeiro.
Esta estrutura de seleção de intervalo
se encerrará na linha 34 com o
respectivo comando de "fim seleção".

• Linhas 27 a 33: [Link] =

negrito...

De modo análogo ao visto nas linhas

12 a 22, esta série de linhas do
algoritmo especifica, para cada
elemento, o valor da respectiva
propriedade, aplicando assim a
formatação desejada. Observe, mais
uma vez, a estrutura sintática adotada
para descrever os objetos, as
propriedades e atribuir os valores:
[Link] = valor.

• Linha 36: em seleção.célula A3.

Abaixo do encerramento da seleção na

linha 34 e de mais uma linha de
comentário identificada pelos
caracteres //, encontramos o começo de
outra seleção que, desta vez, não afeta
um intervalo, mas sim apenas a célula
 A3.

• Linhas 37 e 38: [Link]údo =

"Nome completo"...

A única alteração realizada na célula

A3 é a inserção do texto Nome
completo como seu conteúdo. De novo,
o objeto (célula B3) é separado da sua
propriedade (conteúdo) pelo ponto e a
atribuição do valor é feita usando o
símbolo =.

Na linha 38 temos o comando que

delimita o fim das ações aplicadas a
esta seleção.

• Linhas 39 a 53: [Link]údo =

"Contatol"...

No restante das linhas do algoritmo,

repete-se basicamente a inserção de
valores nas células B3, D3, E3 e F3,
usando a mesma sequência de
comandos que vimos nas linhas 37 a
39, que consiste em demarcar a
seleção da célula (em
seleção.célula...)e especificar, para
cada uma delas, o respectivo conteúdo,
finalizando em seguida a estrutura de
seleção (fim seleção).

• Linha 54: Fim Algoritmo.

Com esta linha sinalizamos a

 conclusão de todo o procedimento,
encerrando o algoritmo.

Em algoritmos mais complexos, entre a

primeira linha e a marcação início é
feita normalmente a declaração de
constantes e variáveis, isto é, definem-
se nomes para posições da memória
RAM do computador nas quais serão
armazenados dados introduzidos pelo
usuário ou pelo programador durante a
execução do programa. Contudo, os
nossos programas não necessitarão
desse tipo de recurso.

Algumas considerações sobre o uso de

algoritmos
 Embora estejamos tratando de
algoritmos extremamente simples,
voltamos a dar ênfase à importância de
seu uso no processo de desenvolvimento
de um programa, seja qual for seu nível
de complexidade.

Imagine o que aconteceria se um

construtor pensasse no projeto de uma
casa durante a sua construçãoe e, ao
concluir, percebesse que, quase não
sobrou espaço para a cozinha. Como
resolver o problema? Seria preciso
derrubar tudo e construir de novo, com
evidente desperdício de material e,
obviamente, de tempo para ficar pronta.
Assim, uma casa que poderia ter ficado
pronta em dois meses e com certa
quantia de dinheiro, levará o dobro do
tempo para ficar pronta e consumirá
muito mais recursos do que o esperado,
por falta de planejamento.

0 mesmo acontece com o programador

que julga desnecessário "perder tempo"
com algoritmos e começa a digitação do
código sem qualquer planejamento
prévio. Se, com o programa pronto,
perceber que o resultado não é o
esperado, ou ainda, vários erros
ocorrem durante a execução, o tempo
gasto com o debug (correção) e reescrita
do código será muito maior do que o
usado na elaboração de um bom
algoritmo a ser seguido.

Caso o leitor queira aprofundar seus

conhecimentos sobre este assunto,
sugerimos a leitura do livro Curso
Essencial de Lógica de Programação (da
autora Marilane Almeida, ISBN 978-85-
60480-88-3), também publicado pela
Digerati Books.

Introdução
 Nas macros e, consequentemente, nos
códigos VBA, alguns parâmetros,
métodos e propriedades são executados
e apontam para um ou mais objetos da
biblioteca do Excel. Para modificar
instruções gravadas por uma macro, mas
também para digitar um programa no
VBA a partir do zero, é de extrema
importância conhecer os métodos e as
propriedades que se referem a tais
objetos.

Neste capítulo aprenderemos como os

métodos e as propriedades apontam para
os objetos e como usar as ferramentas
do Visual Basic for Applications para
acessar e manipular a biblioteca
disponibilizada pelo Excel.

Análise de um código do VBA

No capítulo anterior falamos dos

algoritmos e da sua importância para
estruturar um programa, seja qual for a
linguagem empregada pelo programador.

A abordagem à estrutura dos

algoritmos é de extrema importância
também para compreender melhor os
códigos exibidos pelos ambientes de
desenvolvimento das diversas
linguagens de programação.

Neste tópico analisaremos a estrutura

do código gerado pelo VBA ao
gravarmos a macro de formatação vista
nos procedimentos do tópico Gravando
uma nova macro, do Capítulo 1.
Faremos isso relacionando cada linha
aos conceitos vistos, no Capítulo 2.

Para isso, vamos abrir o arquivo

Macro_1.xlsm, que contém a macro
gravada:

1. Caso esteja fechado, inicie o Excel e

abra o arquivo que contém a macro da
qual deseja visualizar o código (no
nosso caso, Macro [Link]).

2. Clique na guia Exibição da faixa de

opções do Excel.
 3. Na extremidade direita da faixa,
clique a seta logo abaixo do botão
Macros e, no menu suspenso, clique na
opção Exibir Macros, para abrir a caixa
de diálogo Macro.

4. No quadro à esquerda, certifique-se

de que a macro que deseja exibir esteja
selecionada. No nosso exemplo há
apenas uma macro, chamada
MacroFormataçãol.

5. Então, à direita da caixa de diálogo,

clique no botão Editar para acessar o
ambiente de desenvolvimento do Visual
Basic for Application.
 Neste momento, concentremos a nossa
atenção na grande área central, que
ocupa a maior parte do espaço de
trabalho do VBA, pois, é aqui que o
código é apresentado.

Observemos o código por partes,

assim como fizemos com o algoritmo do
tópico Entendendo um algoritmo, do
Capítulo 2.

As primeiras linhas do código,

apresentadas na Figura 3.1, apresentam
as seguintes características:
Figura 3.1.: A primeira parte do código
da nossa macro.

• todo procedimento escrito em VBA

segue as regras da linguagem Visual
Basic e, portanto, deve começar com a
instrução Sub (abreviação de
Subroutine) seguida pelo nome do
procedimento e um par de parênteses.
Um procedimento Sub é constituído
por uma sequência de ações
programadas em VB, incluída entre as
instruções Sub e End Sub. Os
procedimentos Sub podem utilizar
argumentos (constantes, variáveis,
expressões etc.) os quais, quando
presentes, devem ser especificados
entre parênteses após o nome do
procedimento. Quando, todavia,
nenhum argumento for especificado, a
instrução Sub deve incluir um conjunto
de parênteses vazios após o seu nome.

• as seis linhas que começam com o

apóstrofe `, logo abaixo da instrução
Sub, são as linhas de comentário. 0
apóstrofe no início da linha de código
indica ao VBA que não deverá
processar aquela linha, mas pulá-la,
pois, não contém comandos. Trata-se
do mesmo conceito visto nos
algoritmos, apenas substituindo as
barras // pelo apóstrofe `. Essas linhas
de comentários são geradas
automaticamente pelo gravador de
macros do Excel e tra zem informações
como o nome da macro, a descrição
que digitamos ao gravá-la e a
combinação de teclas de atalho a ser
usada para executá-la. As linhas em
branco são deixadas por razões de
clareza na leitura e, caso o usuário as
julgue desnecessárias, podem ser
apagadas sem consequências na
execução do código. É possível
também adicionar linhas de comentário
personalizadas da seguinte forma:

a. clique com o mouse logo à direita do

apóstrofe da linha 7 (ou da última linha
de comentário);
 b. tecle Enter para abrir mais uma linha
de espaço entre os comentários
existentes e o início do procedimento;

c. digite um apóstrofe e tecle um

espaço;

d. digite o seu comentário

normalmente, usando todos os tipos de
caracteres (acentos, espaços,
maiúsculos, minúsculos, números etc.).

A Figura 3.2 mostra um exemplo de

comentário acrescentado pelo usuário ao
código existente:
 Figura 3.2.: Digitando um comentário
personalizado.

Durante a digitação, o texto do

comentário apresentará cor preta, mas,
ao teclar Enter, ele ficará na cor verde
como as demais linhas de comentário.

É importante lembrar que qualquer

alteração feita ao código deve ser salva
para que seja efetivada. Para isso use as
teclas de atalho Ctrl + B ou o botão
Salvar da barra de ferramentas do editor
do VBA.
 Após as linhas de comentário, inicia-se
a sequência de procedimentos
propriamente dita, em que são
executadas as ações especificadas pelo
programador ou registradas durante a
gravação da macro.

Observemos com atenção o trecho de

código mostrado na Figura 3.3:

Figura 3.3.: 0 primeiro trecho de

procedimentos.
 Trata-se das linhas 11 a 23 do código
VBA, em que podemos destacar alguns
aspectos importantes:

• note que o procedimento começa com

a instrução With [Link], que
podemos traduzir do inglês como Com
seleção. fonte. Esta é, de fato, a parte
do código que executa o trabalho,
selection indica a seleção atual e font é
o atributo, isto é, a propriedade da
seleção.

• a instrução With permite especificar

um objeto no qual serão executadas
toda diversas instruções de uma vez só;
o uso das instruções With faz com que
os procedimentos nelas contidos sejam
executados com mais rapidez e ajudam
a evitar digitação repetitiva. Toda
instrução With deve ser encerrada com
a instrução End With , que determina o
fim da sequência de ações para aquela
seleção.

Este conceito é essencialmente

idêntico ao que observamos em
algumas linhas (11, 26 etc.) do
algoritmo estudado no capítulo
anterior, onde vimos, por exemplo, o
uso da instrução em seleção. intervalo
A3:F23 para delimitar um intervalo no
qual seria executada uma série de
comandos.
• a série de linhas abaixo da instrução
With realiza as alterações específicas
para cada propriedade do objeto
afetado pelo procedimento. Sabemos
que a seleção interessa, neste caso, a
fonte. Assim, cada propriedade dela é
alterada em uma linha de código.
Vejamos alguns exemplos:

• Narre = "Courier New": altera a

propriedade Name do objeto Font para
o valor impostado.

• Size = "11": define o valor da

propriedade Size (tamanho) com o
valor 11.
 • Strikethrough = False: imposta o
estilo tachado (riscado, Strikethrough
em inglês) como desabilitado (false =
falso, isto é, não ativado).

• Underline = xlUnderlineStyleNone:
define como "nenhum" o estilo de
sublinhado (xlUnderlineStyleNone, ou,
lido em inglês, Excel Underline Stile
None, ou seja, "nenhum estilo de
sublinhado do Excel").

Vejamos agora o que acontece em outro

trecho do nosso código, que vai da linha
39 até alinha 44, mostrado na Figura
3.4:
 Figura 3.4.: Outro trecho do código.

Temos aqui mais um exemplo de

estrutura de repetição empregada para
alterar diversas propriedades de um
mesmo objeto, sem a necessidade de
repetir, para cada linha, o objeto em
questão. Observe:

• a instrução "With [Link]

(xlEdgeLeft) ", na linha 39, seleciona a
extremidade esquerda (x/EdgeLeft) das
bordas do intervalo em questão e,
como prevê a sintaxe de With, encerra-
se na linha 44 com a instrução End
With. Como dissemos anteriormente, a
linha de código 39 pode ser traduzida
literalmente em português como Com a
seleção nas bordas (extremidade
esquerda);

• as linhas 40, 41, 42 e 43 realizam,

respectivamente, as seguintes
alterações ao objeto apontado pela
instrução With:

• LineStyle = xlContinuous: altera a

propriedade LineStyle (estilo da
linha) do objeto Border para que a
aparência da borda seja uma linha
contínua.
 • Colorlndex = 0: define o valor da
propriedade Colorlndex (índice da
cor) com o valor 0, que se refere à
cor preta.

• TintAndShade = 0: imposta os
estilos de borda especiais como
desabilitados (0).

• .Weight = xlThin: configura o peso

(ou espessura) da linha (Weight) com
espessura sutil (Thin).

Uma vez compreendida a estrutura das

linhas 39 a 44, que configura apenas a
borda esquerda, observe no código
(Figura 3.5) como ela se repete para
cada borda das células: o código é
praticamente o mesmo, a única mudança
ocorre no parâmetro - entre parênteses -
do objeto Borders que, para cada
estrutura With, aponta, respectivamente,
para as bordas:

• Superior: "With
[Link](xlEdgeTop)";

• Inferior: "With [Link]

(xlEdgeBottom) ".

• Direita: "With [Link]

(xlEdgeRight) ".

• Interna vertical: "With

[Link] (xllnsideVerti-cal)".
• Interna horizontal: "With
[Link] (xllnsideHo-
rizontal)".
 Figura 3.5.: Observe a estrutura
repetitiva do código.

Acompanhando com atenção cada linha

do código VBA, podemos aprender
facilmente a sintaxe dessa linguagem,
bem como alguns comandos relativos à
alteração das propriedades dos objetos.

Reparemos, por exemplo, o que

acontece na linha 81 do nosso código,
mostrada na Figura 3.6: a estrutura with
é a mesma já vista nas linhas anteriores,
porém aqui a propriedade weight =
xlThin, que define a espessura da borda
da célula, foi configurada com o valor
xlMedium, isto é, mais espessa do que
as outras, que usam o valor xlThin.

Figura 3.6.: Na linha 81, um outro valor

para a propriedade Weight do objeto
Border.

É muito importante ressaltar que o

VBA, assim como a grande maioria das
linguagens de programação atuais,
baseia seus comandos em inglês.
Portanto, o domínio desta língua facilita
muito a compreensão e a digitação de
códigos de programas.
 Vamos continuar a análise do nosso
código em busca de outros objetos da
biblioteca do Microsoft Excel,
concentrando nossa atenção na linha de
código 113, localizada poucas linhas
antes do final do procedimento (Figura
3.7):

Figura 3.7.: A linha 113 trata do objeto

Interior.

Neste caso a estrutura With se ocupa

da manipulação das propriedades de um
outro objeto: trata-se de Interior, que se
refere ao preenchimento das células.
Vamos conhecer suas propriedades:

• LineStyle = xlContinuous: altera a

propriedade LineStyle (estilo da linha)
do objeto Border para que a aparência
da borda seja uma linha contínua.

• Pattern = xlSolid: define o valor da

propriedade Pattern (padrão de
preenchimento) com o valor xlsolid, ou
seja, sólido.

• PatternColorlndex = xlAutomatic:
imposta em automático a cor do padrão
de preenchimento.
• ThemeColor =
xlThemeColorAccent1: aplica um tema
de aparência especial à cor de
preenchimento (neste caso, o tema
usado é Accent1, traduzido em
português como Ênfase 1).

• TintAndShade =
0.599993896298105: configura o valor
correspondente à cor de preenchimento
desejada.

• PatternTintAndShade = 0: define a
cor do padrão de preenchimento (neste
caso zero, porque nenhum padrão foi
aplicado).
 É interessante observar que as
propriedades disponíveis variam de
acordo com o objeto com o qual se
trabalha. Isso é facilmente perceptível
comparando as propriedades do objeto
Border (mostradas na Figura 3.4) com
as do objeto Interior (Figura 3.7).

Em fim, o procedimento termina com a

instrução End Sub, que demarca o
término dos comandos e,
consequentemente, do programa em si.

Explorando outros objetos do Excel

Para aprofundar ainda mais o estudo

dos objetos que compõem a biblioteca
específica do Excel, gravaremos mais
uma macro.

Desta vez, não se tratará apenas de

uma macro de formatação, realizaremos
procedimentos diferenciados para que o
código VBA gerado aponte para outros
objetos do Excel. Este procedimento
visa fornecer ao leitor visão mais ampla
possível das capacidades de
manipulação de planilhas via VBA para
adquirir o domínio que, num segundo
momento, permitirá digitar do zero
códigos de programas.

Preparando a planilha
 Este procedimento será baseado na
simulação de uma situação prática
bastante comum entre os usuários do
Microsoft Excel. Digamos que seja
preciso preparar a estrutura de uma
planilha para o gerenciamento semanal
dos pedidos de uma empresa: o usuário
deverá criar a planilha, completa de
fórmulas e formatação, e alimentá-la
com os dados relativos aos pedidos da
semana atual. Na semana seguinte,
precisará de outra planilha para os
novos pedidos, estruturalmente idêntica
à da semana anterior, porém em branco.
E assim por diante, a cada nova semana
o operador deverá criar outra planilha,
provavelmente copiando a da semana
anterior e excluindo todo seu conteúdo
para inserir novos dados.

Então, vamos criar a planilha de que

precisamos; sucessivamente trataremos
de automatizar o processo de duplicação
e da limpeza do conteúdo da planilha.

Durante a digitação, lembre-se de fazer

os ajustes necessários à largura das
colunas para que cada texto caiba na
respectiva célula, sem invadir a célula à
direita. Lembre-se também que os textos
sugeridos neste procedimento serão
apresentados entre aspas duplas
("texto") para diferenciá-los das
instruções e que tais aspas devem ser
desconsideradas ao digitá-los.

1. Inicie o Excel com uma nova pasta

de trabalho em branco já aberta no
espaço de trabalho.

2. Selecione com um clique a célula Al

e digite: "Controle Semanal de Pedidos"
(não use as aspas).

3. Agora, clique a célula A3 e digite o

texto "Semana de":, em seguida, aumente
um pouco a largura da coluna A de modo
que o texto digitado caiba por inteiro na
célula A3, sem ocupar parte da célula ao
lado.

4. Clique na célula C3 e digite "até".

 5. Em seguida, ative a célula A5 e
digite "Código".

6. Na célula B5, digite "Cliente".

7. Clique na célula C5 e digite

"Vendedor".

S. Em D5, digite "Data do Pedido".

9. Na célula E5, digite "Previsão de

Envio".

10. Na célula F5, digite "Situação".

11. Ative a célula G5 e digite

"Transportadora".
 12. Em H5, digite o texto 'Atraso
(dias)".

A Figura 3.8 mostra como deve estar a

planilha até o momento:

Figura 3.8.: Verifique estrutura da

planilha até agora.

Vamos agora aplicar a formatação às

células preenchidas:
 13. Selecione o intervalo de células
A1:H1 e faça o seguinte:

a. Clique no botão Mesclar e

centralizar para que o título da planilha
fique centralizado dentro do intervalo
selecionado

b. Altere a fonte para outra de sua

preferência (para o nosso exemplo
usamos Arial Rounded MT Bold).

c. Aumente o tamanho da fonte (no

nosso caso usamos o tamanho 18,
adequado à fonte escolhida).

d. Altere a cor de preenchimento da

célula mesclada (use um tom à sua
 escolha, nós optamos pela cor azul
escuro, texto 2, mais claro 40%).

e. Altere também a cor da fonte (no

caso usamos o branco). Para preservar
a legibilidade, sugerimos usar fonte
clara quando o preenchimento é escuro
e vice-versa, pois um texto claro sobre
preenchimento claro (ou escuro sobre
preenchimento escuro) torna se
praticamente ilegível, tanto na tela do
computador quanto no papel ao
imprimir a planilha.

14. Agora, aplique às células A3 e C3

a seguinte formatação:
a. Fonte Arial, tamanho 10.

b. Aplique o estilo Negrito e o

alinhamento à direita.

15. Nas células B3 e D3, aplique a

mesma formatação das células A3 e C3,
porém sem o Negrito e com alinhamento
à esquerda.

16. Então, selecione o intervalo

A5:H15, que conterá os dados da nossa
planilha. Este intervalo inclui, ao todo,
dez linhas, a primeira das quais é
reservada aos cabeçalhos das colunas,
sobrando apenas nove linhas para
cadastrar os eventuais pedidos a serem
gerenciados. 0 que acontecerá se houver
mais de nove pedidos a serem
cadastrados? Não se preocupe com isso
por enquanto, pois, a seguir usaremos
um recurso que tornará flexível a
quantidade de linhas para a inserção de
dados na tabela.

17. Na faixa de opções do Excel 2007,

clique na guia Início e, no grupo Estilo,
clique o pequeno triângulo à direita do
rótulo do botão Formatar como tabela,
mostrado na Figura 3.9:
 Figura 3.9.: Clique o botão Formatar
como tabela.

Esta opção permite aplicar

rapidamente um estilo de formatação
pré-definido ao intervalo selecionado.
Além disso, ativa automaticamente a
opção de filtragem e outras
características que veremos logo
adiante.

18. No menu com as opções de estilos

pré-formatados, escolha a opção de sua
preferência (para este exemplo
aplicamos o Estilo de tabela média 9).

19. Antes de aplicar a formatação, é

exibida uma pequena caixa de diálogo
na qual devemos confirmar o intervalo
ao qual o estilo será aplicado (veja a
Figura 3.10). Observe, no campo Onde
estão os dados da tabela, a referência ao
intervalo previamente selecionado e
corrija-a se necessário, atrás da caixa
de diálogo, repare que o intervalo
selecionado é contornado por uma
moldura tracejada animada. Na caixa,
marque a opção Minha tabela tem
cabeçalhos, pois, no nosso exemplo já
definimos os cabeçalhos das colunas.

20. Clique no botão OK para confirmar

e aplicar o estilo de formatação
escolhido
 Figura 3.10.: A caixa de diálogo
Formatar como Tabela.

Em instantes o estilo é aplicado.

Vamos analisar alguns aspectos
especiais desse recurso do Excel 2007:

• na linha dos cabeçalhos, que no nosso

caso é a 5, todas as células do
intervalo receberam o botão que dá
acesso ao recurso de filtragem de
dados (Figura 3.11), extremamente útil
nas operações de busca e alteração dos
dados:

Figura 3.11.: Os botões do Filtro são

 ativados automaticamente.

• a última célula da planilha (H15 no

nosso exemplo) apresenta uma pequena
alça em seu canto inferior-direito
(Figura 3.12). Trata-se da alça de
redimensionamento da tabela, usada
para expandir as opções de formatação
e as fórmulas, caso precisemos de mais
linhas para cadastrar novos pedidos.
Uma peculiaridade deste recurso é que,
ao ativar a última célula da tabela e
pressionar a tecla Tab, a formatação (e
eventuais fórmulas) é expandida
automaticamente para a linha inferior,
tornando desnecessário copiar
formatos e fórmulas para novas linhas
e, como no nosso exemplo,
preservando a alternância das cores de
preenchimento das linhas (azul
claro/azul escuro). A expansão da área
da tabela também pode ser feita
posicionando o ponteiro do mouse
sobre a alça e arrastando para baixo
proporcionalmente à quantidade de
linhas adicionais que se deseja utilizar.
 Figura 3.12.: A alça de expansão da
tabela.

Agora que a estrutura da tabela está

pronta, vamos acrescentar outros
recursos que facilitarão a entrada de
dados por parte do usuário. Veja:

21. Clique a célula K5 e digite o texto

"Situação".

22. Na célula K6, digite "Enviado".

23. Em K7, digite "Não enviado".

Não aplique qualquer formatação a

essas células, pois, na verdade, elas
ficarão ocultas e serão usadas apenas
como fonte para uma lista de opções
para preencher a coluna Situação
(coluna F) da planilha.

Continuemos:
 24. Selecione o intervalo F6:F15.

25. Na faixa de opções do Excel 2007,

clique a guia Dados e, no grupo
Ferramentas de dados, clique o pequeno
triângulo à direita do rótulo do botão
Validação de dados, mostrado na Figura
3.13:

Figura 3.13.: 0 botão Validação de

dados.

26. No menu aberto, clique a opção

Validação de dados, para que seja
aberta a janela de mesmo nome, visível
na Figura 3.14:

Figura 3.14.: A janela com as opções de

validação.

0 recurso de validação de dados

permite restringir o leque de valores que
o usuário pode digitar na célula, é muito
usado para prevenir a entrada de valores
inválidos ou inadequados ou, como no
nosso caso, para fazer com que o
operador não digite valor algum, mas
apenas escolha entre uma série de
opções pré-definidas.

Vejamos como utilizá-lo:

27. Na janela Validação de dados, abra

o menu desdobrável rotulado Permitir e,
dentre suas opções, clique Lista.

28. À direita do menu, mantenha

marcadas ambas as caixas Ignorar em
branco e Menu suspenso na célula.

29. Então, dê um clique dentro do

campo rotulado Fonte, em que devemos
especificar onde o Excel deverá buscar
as opções a serem apresentadas nas
células da coluna Situação.

30. Em seguida, clique o botão

localizado na extremidade direita do
campo Fonte (Figura 3.15) para recolher
a janela e selecionar, diretamente na
planilha, o intervalo que contém as
entradas da lista, como mostrado na
Figura 3.16.
 Figura 3.15.: Clique este botão para
recolhera janela e...

Figura 3.16.: Selecionar na planilha as

opções da lista.
 31. Após selecionar o intervalo
K5:K7, tecle Enter para retornar à
janela Validação de Dados.

32. Clique OK para aplicar a lista ao

intervalo selecionado.

33. Para fazer com que as opções da

lista, que estão na coluna K, não sejam
exibidas nem impressas, clique com o
botão auxiliar do mouse o botão de
seleção da coluna K e, no menu
suspenso, selecione Ocultar, como
mostra a Figura 3.17:
 Figura 3.17.: Ocultando as opções da
lista.

Para testar, clique qualquer célula da

tabela na coluna F e repare, à direita, no
surgimento de um pequeno botão que
abre o menu desdobrável com as opções
de entrada que digitamos anteriormente
na coluna K (Figura 3.18):

Figura 3.18.: 0 resultado da aplicação

 da lista.

No nosso exemplo, disponibilizamos

ao usuário três opções (Situação,
Enviado e Não enviado) para que, se no
momento de preencher a tabela não se
saiba a situação do pedido, há uma
opção "neutra" que pode ser adotada (no
nosso caso Situação).

Ao utilizar este recurso, o Excel não

aceitará, nessas células, a inclusão de
outros valores que não sejam os da lista
e, caso o usuário tente digitar qualquer
outra coisa, será exibida uma mensagem
de erro alertando que o valor não é
válido (Figura 3.19):
 Figura 3.19.: A mensagem de alerta de
valor inválido.

Para completar a produção da planilha,

vamos inserir a fórmula que calculará os
dias de atraso em relação à previsão de
envio.

34. Clique na célula H6 e digite

afórmula mostrada:= SE (F6= "não
enviado";(HOJE ())-E6;"").
 0 que esta fórmula faz, afinal?

Ela usa a função condicional SE para

que o cálculo do atraso seja feito apenas
caso a célula da coluna Situação
contenha Não enviado, ou seja, somente
se o pedido ainda não foi enviado ao
cliente. Assim, se a situação do pedido
for "não enviado", subtrai-se da data
atual (HOJE ()) a data do pedido (que
no nosso exemplo está na coluna E) para
saber de quantos dias é o atraso no
envio. Mas, se o pedido constar como
"enviado" ou se o valor da Situação não
foi definido, o cálculo do atraso não
será feito e a célula permanecerá vazia
"".
 É interessante observar que o cálculo
do atraso baseia-se no resultado da
função HOJE, que retorna sempre a data
do dia em que a planilha é aberta.
Assim, a quantidade de dias em atraso
será recalculada automaticamente ao
abrir a pasta de trabalho.

Ao concluir a digitação da fórmula

tecle Enter e note que ela será expandida
automaticamente a todas as demais
células da mesma coluna incluídas na
formatação da tabela (no nosso caso, até
a linha 15). Repare também como,
apesar de conterem a fórmula, as células
não apresentam em seu interior qualquer
texto ou valor, pois, as relativas à
situação estão vazias e, portanto, o
resultado da fórmula é "", isto é, vazio.

Vamos acrescentar também outra

característica interessante que agregará
um aspecto mais profissional à nossa
planilha: faremos com que um ícone seja
exibido ao lado dos dias de atraso
dependendo de sua quantidade, isto é:

• se a quantidade de dias de atraso for

cinco ou mais, deverá aparecer um
ícone vermelho chamando a atenção
naquela célula;

• se o atraso for entre um e quatro dias,

o ícone apresentado deverá ser
 amarelo;

• caso não haja atraso, nada aparecerá.

Para fazer isto, usaremos um recurso

que, especialmente na versão 2007 do
Excel, ganhou novas opções e teve sua
funcionalidade expandida
consideravelmente: estamos falando da
Formatação condicional, graças à qual
podemos definir opções de formatação
de células que variam de acordo com
seu valor (ou em outras células da pasta
de trabalho). Vejamos como utilizar este
recurso:

35. Selecione o intervalo de células

H6:H15.

36. Na faixa de opções do Excel 2007,

clique a guia Início e, no grupo
denominado Estilo, dê um clique no
botão Formatação condicional, mostrado
na Figura 3.20:
Figura 3.20.: As opções de Formatação
condicional.

37. No menu de opções que surge,

clique no comando Nova regra,
localizado na parte inferior.

38. Em instantes é aberta a janela Nova

regra de formatação (Figura 3.21), onde
realizaremos as seguintes configurações:

a. Na seção superior, rotulada

Selecione um tipo de regra, marque ou
mantenha a primeira opção Formatar
todas as células com base em seus
respectivos valores.
b. No painel Edite a descrição da
regra, localizado na área inferior da
janela, abra o menu desdobrável Estilo
de formatação e, nele, selecione a
opção Conjunto de ícones.

c. Mais embaixo, à direita, abra o

menu desdobrável Estilo do ícone e
selecione a opção 3 símbolos
(circulados) - optamos por esse estilo
de visualização, pois, julgamos ser o
mais apropriado para o exemplo.
Sugerimos que o leitor explore as
demais opções de ícones disponíveis
para conhecê-las e aplicá-las ao seu
gosto sempre que necessário.
d. Logo à direita do menu recém-usado,
marque a caixa Ordem inversa dos
ícones, para que o símbolo vermelho
seja mostrado para valores mais altos, o
amarelo para os intermediários e o
verde para os mais baixos.

e. Agora, abra o primeiro menu

desdobrável rotulado como Tipo,
relativo à linha do símbolo vermelho
identificável pelo texto quando o valor
for, e nele selecione a opção Número.

f. No campo Valor, logo à esquerda,

digite o número 5.

g. Em seguida, clique o segundo menu

Tipo (embaixo do primeiro) relativo
ao símbolo amarelo (linha quando < 5
e, e configure-o também com a opção
Número.

h. no respectivo campo Valor, à

esquerda do menu desdobrável, digite
1.

L Mantenha marcadas as demais

opções. A Figura 3.21 mostra a janela
Nova regra de formatação devidamente
configurada com as opções descritas
acima. Com essas configurações,
definimos que quando a quantidade de
dias de atraso for maior ou igual a
cinco, será apresentado o símbolo
vermelho e, quando for de um ou mais,
será apresentado o símbolo amarelo.
Testaremos o funcionamento logo mais.
Figura 3.21.: A janela usada para definir
a regra que determinará a formatação
das células.

j. clique o botão OK para aplicar a

regra definida e fechar a janela.
 39. De volta à planilha, note que por
enquanto nenhum símbolo é exibido,
pois ainda não alimentamos a tabela
com os pedidos a serem controlados.

Concluiremos agora renomeando a

planilha Planl e excluindo as outras
duas, que estão em branco. Para isso:

40. Dê clique-duplo na guia da Planl,

no rodapé do espaço de trabalho do
Excel.

41. Note que o nome da planilha entrou

em modo de edição, destacado por uma
tarja preta. Digite o novo nome (no
nosso caso, usamos Semanal) e tecle
Enter.

42. Agora, clique como botão auxiliara

guia da Plan2 e, no menu suspenso,
selecione o comando Excluir (caso
Plan2 contenha qualquer dado, será
solicitada confirmação antes da
exclusão).

43. Repita o procedimento anterior

para excluir também Plan3.

Antes de continuarmos com os

procedimentos de gravação da macro, é
preciso preencher a planilha com alguns
dados de pedidos: faça isso de modo
que pelo menos 10 linhas da planilha
fiquem preenchidas. Não se preocupe
com os dados inseridos, pois trata-se
apenas de um exemplo. No nosso caso,
alimentamos a tabela com informações
fictícias, como mostra a figura 3.22:

Figura 3.22.: Veja como ficou a nossa

planilha preenchida e formatada.

Note, na Figura 3.22, que as células da

coluna Atraso (dias) apresentam
pequenos símbolos à esquerda dos
respectivos valores: é o resultado da
formatação condicional que definimos
anteriormente. Nas linhas 7, 10 e 14, em
que a quantidade de dias de atraso é
menor que 5, o símbolo é amarelo; na
linha 11, em que o pedido acumulou 10
dias de atraso no envio, é exibido o
símbolo vermelho; nas linhas 9, 15 e 16,
que contêm valores negativos pois a
previsão de envio e sucessiva à data
atual, aparece um símbolo verde,
indicando que não há com o que se
preocupar.

Para finalizar salve a pasta de trabalho

numa de sua preferência. Para o nome
do arquivo, sugerimos Macro-2.
 Lembre-se que utilizaremos macros e
VBA nesta planilha, portanto, ao salvar,
é imprescindível alterar o tipo de
arquivo para Pasta de trabalho
habilitada para macro do Excel. Caso
tenha dúvidas sobre como salvar
arquivos habilitados para o uso de
macros, leia novamente os passos 19 a
22 do tópico Gravando uma nova macro
do Capítulo 1.

Iniciando a gravação da nova macro

Vimos que a produção da nossa

planilha de controle de pedidos
necessita de várias operações e, como
consequência, leva um tempo
considerável para ser concluída.
Imagine se, a cada semana, o usuário
precisasse produzir essa tabela do zero
ou, na melhor das hipóteses, criar uma
cópia deste arquivo e limpar todo seu
conteúdo. Tratar-se-ia justamente do
tipo de ação repetitiva que o uso de
macros e VBA visa dispensar.

Portanto, vamos gravar, nesta pasta de

trabalho, uma macro que duplique a
planilha Semanal e limpe seu conteúdo,
mantendo, porém, a fórmula que calcula
os dias de atraso do envio. Comecemos
com os procedimentos:

1. Com a planilha pronta e já aberta no

espaço de trabalho do Excel 2007,
clique a guia Exibição da faixa de
opções.

2. Na extremidade direita da faixa de

opções, vá com a pequena seta
localizada logo abaixo do botão Macros
e, no menu exibido, clique em Usar
referências relativas. Ao marcar a
opção, seu ícone no menu ficará
contornado por uma sutil borda
alaranjada.

3. Abra novamente o menu de opções

do botão Macros e, desta vez, clique o
comando Gravar macro, para abrir a
caixa de diálogo de mesmo nome.
 4. Na pequena janela - mostrada na
Figura 3.23 - façamos as seguintes
configurações:

Figura 3.23.: A caixa de diálogo Gravar

macro, devidamente configurada.
a. Clique o campo rotulado Nome da
macro, apague o nome sugerido pelo
aplicativo e digite outro que
identifique claramente, em poucas
palavras, a finalidade da macro a ser
criada (lembrese de não usar
caracteres especiais nem espaços).
Para o nosso exemplo, usamos o nome
Dupl carLimpar.

b. Logo abaixo, clique o pequeno

campo rotulado Tecla de atalho e
precedido por Ctrl+ e digite a letra
que, pressionada junto com a tecla
Ctrl, comporá a combinação de teclas
de atalho para executar a macro
rapidamente. No nosso caso,
associamos a nova macro às teclas de
atalho Ctrl + D.

c. Para continuar, abra o menu

desdobrável Armazenar macro em.
Neste caso, a macro será armazenada
juntamente ao arquivo em uso e estará
disponível somente para este
documento e não para os demais
arquivos de pastas de trabalho do
Excel. Então, mantenha ativa a opção
Esta pasta de trabalho.

d. No campo Descrição, digite um

breve texto que explique de forma
resumida as operações realizadas pela
macro. Para a nossa macro, digitamos
 Duplica a planilha ativa, limpa os
dados mantendo as fórmulas.

5. Clique no botão OK para começar a

gravação da macro. Lembrese que a
partir de agora todas as operações
realizadas serão gravadas.

6. Posicione o cusor do mouse sobre a

guia da planilha Semana 1 e dê um
clique com o botão auxiliar.

7. No menu suspenso, clique o

comando Mover ou copiar mostrado na
figura 3.24:
Figura 3.24.: Clique este comando para
duplicar a planilha ativa.

8. É aberta a pequena caixa de diálogo

Mover ou copiar, que contém as opções
necessárias para criar a cópia da nossa
planilha. No quadro central desta janela,
clique (mover para o final), de modo
que a cópia da planilha apareça à direita
da guia da planilha atual.

9. Ainda na caixa de diálogo Mover ou

copiar, marque a opção Criar uma cópia,
caso contrário a planilha seria movida e
não copiada. A Figura 3.25 mostra a
caixa de diálogo já definida com as
opções indicadas:
Figura 3.25.: Configure a janela Mover
ou Copiar como na figura.

10. Clique OK para confirmar e

duplicar a planilha Semanal.
 11. Observe, no rodapé do espaço de
trabalho, que surgirá uma nova guia de
planilha, rotulada automaticamente
Semanal (2), o que indica ser a cópia da
planilha Semanal - este é dado
automaticamente pelo Excel.

12. Com a cópia ativa, selecione o

intervalo de células A6:G16 e pressione
a tecla Delete para limpar todo o
conteúdo (cuidado para não apagar os
valores da coluna H, que serão limpos
automaticamente por se tratar de
resultados de uma fórmula).

13. Clique na célula B3, que contém a

data de início da semana considerada
pela planilha, e tecle Delete para
apagar.

14. Faça o mesmo com a célula D3,

removendo seu conteúdo.

15. Agora que a planilha está

completamente limpa, vá até a faixa de
opções, acesse novamente a guia
Exibição e clique no botão Macros.

16. Clique o comando Parar gravação,

disponibilizado durante a gravação.

Concluímos! A macro está agora

gravada e disponível para a execução e
pode ser acionada usando as teclas de
atalho definidas durante a sua criação
(no nosso caso, CTRL + D). Se quiser
testar seu funcionamento, pressione as
teclas de atalho e veja o resultado.

A nova macro também pode ser

acionada a partir da janela Macro. Veja:

17. De volta à guia Exibição da faixa

de opções, clique no ícone do botão
Macros (não na seta para baixo) para
abrir diretamente a janela de mesmo
nome.

18. Nela, observe que no quadro ao

centro é listada a macro que criamos
(Figura 3.26), para executá-la, basta
clicar o botão Executar, localizado em
cima à direita da janela:

Figura 3.26.: A nova macro encontra-se

disponível na janela Macro.
 No tópico a seguir, analisaremos o
código gerado ao gravar esta macro
para, em seguida, realizar algumas
alterações com a ajuda do VBA.

0 código VBA da nova macro

A macro gravada no tópico anterior

realiza ações bem diferentes daquela
gravada no nosso primeiro exemplo.
Então, vamos explorar mais uma vez o
código VBA gerado para conhecermos
mais a fundo os objetos da biblioteca do
Excel 2007 e vermos como podem ser
manipulados via programação em VBA.

No começo deste capítulo, aprendemos

a acessar o ambiente de
desenvolvimento do VBA a partir do
botão Editar da janela Macro. Vamos
conhecer agora um outro método para ter
acesso às funções de programação VBA
do Excel 2007:

1. Na extremidade direita da faixa de

opções, clique no botão Office.

2. Clique em Opções do Excel, na

parte inferior direita do menu.

3. Abre-se a janela que permite

configurar as opções do Excel, dividida
em duas áreas verticais: uma mais
estreita, à esquerda, que contém as
opções relativas aos grupos de opções a
serem altera das; outra maior, à direita,
que mostra as opções do grupo
escolhido à esquerda.

4. Na seção à esquerda, verifique que

esteja ativo o grupo Mais usados,
destacado em laranja. Caso não esteja
ativo, clique-o.

5. Na área maior, à direita, marque a

caixa Mostrar guia Desenvolvedor na
Faixa de Opções, como mostrado na
Figura 3.27:
 Figura 3.27.: A opção adiciona a guia
Desenvolvedor na faixa de opções do
Excel.

6. Clique OK para confirmar e sair.

Observe com atenção a faixa de

opções do Excel e repare o surgimento
de uma nova opção entre as guias: trata-
se da guia Desenvolvedor, que inclui
todos os comandos necessários para
interagir com o ambiente de
desenvolvimento VBA e gerenciar
macros e códigos existentes. A Figura
3.28 mostra a nova guia, que é composta
por três grupos de botões e comandos, e
suas opções:

Figura 3.28.: A guia Desenvolvedor e

seu conteúdo.

• Código: que contém os botões que

dão acesso ao código VBA, seja ele
digitado pelo usuário ou gerado a
partir da gravação de macros, traz
também as opções para definir
referência relativa e modificar as
configurações de segurança para
macros e códigos.

• Controles: agrupa os comandos

necessários para a inserção de
elementos de controle, tais como
botões, menus drop-down etc.

• XML: traz os comandos para acessar,

editar e criar códigos XML, um
subtipo de SGML (acrônimo de
Standard General/zed Markup
Language, ou "linguagem padronizada
de marcação genérica") capaz de
descrever diversos tipos de dados. Seu
propósito principal é simplificar o
 compartilhamento de informações por
meio da Internet.

Para exibir o código VBA da macro

Dupl/carLimpar, faça o seguinte:

7. Ainda na guia Desenvolvedor,

clique o botão Visual Basic, em
destaque na Figura 3.29:

Figura 3.29.: 0 botão que dá acesso ao

 VBA.

De imediato somos transportados para

o ambiente de desenvolvimento Visual
Basic for Application, cujas
características foram descritas de forma
detalhada no tópico Visualizando o
código VBA de uma macro do Capítulo
1.

Note, porém, que a área central da tela,

normalmente ocupada pelo código, está
preenchida com a cor cinza e nenhum
código de programa é apresentado. Isto
ocorre porque ainda não selecionamos
nenhum objeto na coluna à esquerda.
Então:
 8. Leve o ponteiro do mouse sobre o
objeto Módulol, exibido no painel com a
estrutura dos objetos à esquerda do
espaço de trabalho do VBA.

9. Dê dois cliques sobre o Módulol

para que o respectivo código passe a ser
mostrado na área central da tela, como
podemos observar na Figura 3.30:
 Figura 3.30.: Dê duplo-clique em
Módu/o9 para abrir o código à direita.

Note como o código gerado pela

segunda macro é razoavelmente mais
enxuto e simples do que o que
analisamos no início deste capítulo.

Vamos concentrar nossa atenção no

código e conhecer os objetos envolvidos
nesta segunda sequência de ações
gravada:

• como já vimos, todo procedimento

em VBA deve começar com a instrução
Sub, seguida pelo nome e por um par
de parênteses que, quando presentes,
 inclui eventuais parâmetros adicionais
(neste caso estão vazios, pois, não há
argumentos para o procedimento). Para
cada instrução Sub é indispensável, no
final do procedimento, uma instrução
End Sub, que indica seu fim.

• logo abaixo, temos as seis linhas de

comentários inseridas automaticamente
pelo gravador de macros do Excel
2007. Se desejar, digite um comentário
personalizado começando a linha com
um apóstrofe ` seguido por um espaço
e, então, o texto desejado.

As linhas que vão de 8 a 15 contém, de

fato, as ações executadas pela nossa
macro (acompanhe na Figura 3.30):

• a instrução "Sheets ("Semanal")

.Select", na linha 8, realiza a seleção
da planilha Semanal. Neste caso, o
objeto em questão é Sheets, isto é,
"planilhas", seguido pelo nome da
planilha a ser selecionada especificado
entre parênteses e entre aspas. A ação
Select, separada do objeto por um
ponto, faz a seleção;

• na linha 9, o comando "Sheets

("Semanal") Copy After: =Sheets (1) "
possui estrutura idêntica à da linha
anterior. 0 que muda é a ação,
especificada após o ponto, que neste
caso determina que a planilha em
objeto seja copiada depois Copy After
da planilha atual, que é a primeira
Sheets (1);

• a linha 10 apresenta uma nova

instrução: "[Link](5,
0).Range ("A1:G11").Select- Trata-se
de um comando que seleciona o
intervalo Range A1:G11. 0 leitor deve
estar lembrando que, ao gravarmos a
macro, o intervalo que continha os
dados não era A1:G11, mas sim
A6:G16. Embora possa parecer um
erro do programa, isto é explicado
pelo fato de estarmos usando a opção
de "referência relativa": note que esta
linha de código começa coma instrução
[Link](5, o), que significa
que a seleção deve ser deslocada
Offset de cinco linhas e zero colunas 5,
o a partir da célula ativa célula ativa
ActiveCeli. De fato, ao deslocarmos
cinco linhas abaixo do intervalo
A1:G11, chegaremos justamente ao
intervalo A6:G16. Então, encontramos
aqui mais dois objetos, que são
ActiveCell (célula ativa) e Range
(intervalo);

• o comando
"[Link]", na linha 11,
apenas limpa o conteúdo
ClearContents da área selecionada
 (Selection).

• nas linhas 12, 13, 14 e 15 repete-se a

mesma ação para limpar,
respectivamente, as células B3 e D3,
consideradas sempre relativamente à
célula Al.

Salve a pasta de trabalho, pois iremos

utilizá-la novamente nos próximos
procedimentos.

Agora que o leitor está mais

familiarizado com o conceito de
"objeto" e conheceu a estrutura dos
códigos VBA, está apto a criar e
modificar seus próprios códigos de
programa. A partir do próximo capítulo,
trabalharemos mais especificamente
com a criação de códigos de programa
personalizados.
Introdução

No capítulo anterior analisamos em

detalhes a estrutura dos códigos gerados
pelo VBA ao gravarmos uma macro,
conhecemos a sintaxe desta linguagem
de programação e aprendemos como o
Visual Basic for Applications manipula
os objetos do Excel alterando suas
propriedades nas diversas linhas de
código.
 Nos tópicos deste capítulo
trabalharemos diretamente no ambiente
de desenvolvimento do VBA para criar
códigos a partir do zero e,
consequentemente, corrigir e aprimorar
códigos existentes.

Durante as explicações passo a passo,

procuraremos ilustrar com exemplos
práticos para facilitar a compreensão
dos assuntos abordados. Para isso,
sugerimos acompanhar os passos
descritos, se possível realizando cada
procedimento em seu computador, de
modo a experimentar e ver de perto o
resultado das operações feitas.
 Boa leitura e... bom trabalho!

Entendendo as variáveis

No universo da informática e, mais

especificamente, da programação, as
variáveis podem ser descritas como
porções da memória RAM do
computador que constituem recipientes
usados para armazenar valores
limitadamente à execução de um
programa. Em outras palavras, uma
variável liga um elemento (no sentido
amplo do termo, isto é, um valor, um
número, um texto etc.) a um
identificador (o nome da variável), de
modo que o próprio elemento possa ser
acessado pelo programa sempre que
necessário. Durante a execução de um
programa, as variáveis são usadas para
armazenar temporariamente valores dos
quais o próprio programa precisará para
poder completar seus procedimentos.

Ao falarmos em "conteúdo" de uma

variável, nos referimos, na verdade, ao
elemento ao qual a variável está
associada.

Para que possam ser usadas, as

variáveis precisam ser declaradas, isto
é, criadas no início do procedimento e,
ao longo da execução, receber dados de
acordo com suas limitações e
características. Tais dados podem ser
fornecidos pelo programador ao criar o
código ou pelo usuário, por meio da
solicitação de emissão de valores.

A declaração de uma variável segue a

sintaxe:

Para atribuir um valor a uma variável,

independentemente da linguagem de
programação em uso, adota-se a seguinte
sintaxe:

Vejamos, a seguir, um exemplo de

código em linguagem Visual Basic no
qual serão declaradas e depois
preenchidas algumas variáveis:

No exemplo acima é iniciado um novo

procedimento de nove linhas com o
nome Teste, que apresenta em seu início
uma linha de comentário que especifica
a função do código.

Nas linhas 3, 4 e 5, que começam com

a instrução Dim, são declaradas
(criadas) três variáveis, respectivamente
nomeusuário, idade e altura. Ao declarar
uma variável é preciso especificar que
tipo de dados ela receberá. Observe no
quadro a seguir os tipos de dados
utilizados na linguagem Visual Basic for
Application.
Tabela 4.1.

0 tipo de dado de uma variável

determina os valores que a mesma
poderá receber e armazenar. Trata-se de
um detalhe de extrema importância, pois
os diversos tipos de dados requerem uso
diferenciado da memória, como
podemos observar na Tabela 4.1. Se,
por exemplo, sabemos com certeza que
determinado valor será um número
inteiro, devemos declarar a variável
como Integer, pois, assim o computador
reservará para esta variável o espaço de
memória adequado. Se, ao contrário, o
valor a ser armazenado na variável será
decimal, é preciso declarar a variável
como single OU Long, dependendo da
quantidade de casas decimais; esse tipo
de valor ocupa mais espaço em memória
e, por isso, deve ser usado apenas
quando é realmente necessário.

Note que a variável nomeUsuário foi

declarada como String, isto é, texto, pois
irá armazenar o nome de uma pessoa. A
variável idade, por sua vez, foi
declarada como Integer, pois receberá
um número sem casas decimais. Já a
variável altura foi definida como Single,
isto é, um número decimal simples (a
altura normalmente é expressa em
valores decimais, isto é, com a vírgula).
 Nas linhas de código 6, 7 e 8, as
variáveis declaradas recebem os
respectivos valores, colocando primeiro
o nome da variável, depois o símbolo =
e, em seguida, o valor que se deseja
armazenar nela.

Utilizando variáveis no VBA do Excel

Agora que entendemos o que são as

variáveis e qual é a sua função num
código de programa, vejamos como
utilizá-las na prática.

No exemplo deste tópico editaremos

com o VBA macro que gravamos e
salvamos no arquivo Macro_2.x/sm,
utilizada para duplicar e limpar uma
planilha de controle de pedidos. Caso
precise criar a planilha, leia novamente
os passos descritos nos tópicos
Preparando a planilha e Iniciando a
gravação da nova macro, no Capítulo 3
deste livro. Quando estiver com a
planilha pronta e salva, acompanhe os
passos a seguir.

A macro Dupl carLímpar é

extremamente útil, pois limita a
duplicação da planilha e a limpeza do
conteúdo a um simples atalho do teclado
(CTRL + D, no nosso caso) Todavia,
pode ser aprimorada em seus detalhes.
 Ao executarmos a macro, a planilha é
duplicada e seu conteúdo é excluído,
mas a planilha resultante traz o mesmo
nome da plani lha original seguido
apenas por um número entre parênteses
que a diferencia da primeira, o que pode
gerar muita confusão na hora de editar o
conteúdo, principalmente quando houver
dezenas de planilhas na pasta de
trabalho. A macro ficaria mais
interessante se permitisse ao usuário
digitar um nome para a nova planilha,
evitando assim qualquer chance de
confundir a nova planilha com as demais
já existentes.

Podemos fazer isto usando algumas

características do VBA para incrementar
o código original da macro
DupiicarLimpar. Vejamos como
proceder:

1. Inicie o Microsoft Excel 2007 e abra

o arquivo que contém a macro a ser
editada (no nosso caso, Macro [Link]).

2. Na faixa de opções, clique na guia

Desenvolvedor (caso não esteja
disponível, veja os passos 1 a 6 do
tópico O código VBA da nova macro do
Capítulo 3 para habilitar esta guia).

3. No grupo Código, clique no botão

Visual Basic para entrar no ambiente de
desenvolvimento do VBA.

4. No espaço de trabalho do Visual

Basic for Applications, acesse o painel
Projeto - VBA Project, à esquerda, e dê
um clique no pequeno sinal +" à
esquerda da pasta "Módulos" para
exibir os módulos de programa
existentes, como mostra a Figura 4.1:
Figura 4.1.: Abra a pasta que contém o
módulo com o código.

S. Então, clique duas vezes no item

Módulol, que contém o código VBA da
macro DuplicarLimpar. 0 código é
exibido e passa a ocupar toda a área
central do espaço de trabalho.

6. Dê um clique depois do apóstrofe da

última linha de comentário e, em
seguida, tecle Enter duas vezes, para
criar duas linhas em branco entre os
comentários e as linhas de comandos.

7. Vamos inserir um comentário

pessoal com o qual documentaremos o
código, explicando a função das linhas
que inseriremos: digite um apóstrofe (' ),
dê um espaço e digite (sem aspas) o
texto Declaração de variáveis. Ao
concluir, tecle Enter para passar para a
linha inferior e note que o comentário
recebeu a cor verde, para se diferenciar
das linhas de comando.

8. Agora vamos declarar a variável da

qual precisaremos: digite a seguinte
linha de comando:

Dim nomePlanilha as String

Tecle Enter e veja que as palavras-

chave dos comandos ("Dim" e "As
String") são destacadas na cor azul, o
que indica que o VBA reconheceu e
aceitou os comandos, como mostra a
Figura 4.2:
 Figura 4.2.: Declare a variável
nomeP/ani/ha como mostrado na figura.

Temos, assim, um espaço de memória

reservado, chamado nomePlanilha, no
qual o VBA irá armazenar um nome para
a nova planilha. Mas precisamos fazer
com que o programa peça ao usuário que
digite o nome, caso contrário a variável
não terá sentido algum.

Então, vamos alterar o código da

macro para que o nosso programa
mostre uma caixa de diálogo na qual o
usuário deverá inserir um nome para a
nova planilha. Siga com atenção os
passos.

9. Realize nas linhas de código as

alterações descritas a seguir, alterando
apenas os valores modificados em
relação ao código original (em negrito
as linhas que sofreram alterações) - as
linhas de código estão numeradas para
facilitar a referência às mesmas
futuramente, portanto, não precisa
digitar os números relativos a cada linha
:
 Vamos analisar cada linha do código
para compreendê-lo. No próximo tópico
executaremos a macro para ver o
resultado na prática:

• (1 - 7): as primeiras sete linhas

permaneceram inalteradas e, nas linhas
oito e nove, encontramos o comentário
e a linha de comando que fazem a
declaração da variável nomePlanilha,
um espaço de memória em que, mais
adiante, será armazenado o nome que o
usuário informará para a cópia da
planilha.

• (10): nessa linha inserimos um

comentário que indica o trecho de
código responsável pela execução do
procedimento propriamente dito.

• (11 - 12): as linhas não foram

alteradas e contêm, respectivamente,
os comandos responsáveis por
selecionar e copiar a planilha Semanal.

• (13): apresenta um novo elemento

extremamente útil para adicionar
interação entre o usuário e o código de
programa; de fato, nesta linha de
código é usado o comando InputBox
(caixa de entrada) para que, durante a
execução, seja exibida uma caixa de
diálogo com o texto especificado entre
parênteses e aspas (neste caso, solicita
que o usuário digite um nome a ser
dado à nova planilha). Observe
atentamente a sintaxe usada para fazer
com que o texto digitado na caixa de
entrada seja armazenado dentro da
variável, nomePlanilha: para atribuir
um valor qualquer a uma variável, usa-
se sempre a estrutura:

A qual deve ser lida como: variável

recebe conteúdo. 0 símbolo = é o
caractere-chave que indica ao programa
que o valor à direita deverá ser
armazenado na posição de memória
(variável) indicada à esquerda. Neste
caso, o conteúdo da variável será o
texto digitado pelo usuário na InputBox
apresentada no momento da execução.

• (14 - 15): nessas linhas instruímos o

programa para que selecione (.Select)
a planilha resultante da cópia da
primeira (que por enquanto se chama
Semana 1(2), de acordo com o padrão
de nomenclatura do Excel) e que altere
a sua propriedade Name (nome)
usando o conteúdo da variável
nomePlanilha, a qual contém o nome
informado pelo usuário na caixa de
entrada vista na linha 13.

• (16): nesta linha do programa,

alteramos o comando gerado pelo
gravador de macros do Excel, que
usava referência relativa às células da
planilha (veja o tópico 0 código VBA
da nova macro, no Capítulo 3 deste
livro); a alteração consistiu na substitui
ção dos comandos de referência
relativa pelo nome específico do
intervalo (.Range) a ser selecionado
(A6:G16). 0 nome da planilha ativa
também foi alterado, pois a referência
relativa Activecell. Offset (5, 0) foi
 substituída pela referência exata à
planilha (Sheets), cujo nome foi
digitado pelo usuário e armazenado na
variável nomePlanilha; Para
esclarecer, basta comparar a linha de
código original (a primeira) com a
nova (em negrito):

Arriscando uma tradução literal do

código, podemos dizer que a nova linha
de código significa: "selecione o
intervalo A6:G16 da planilha cujo nome
está armazenado na variável
nomePianiiha".

Note que nas linhas 11 e 12 do código

do nosso programa, o nome da planilha
a ser selecionada e copiada é
especificado entre parênteses e aspas;
porém, na linha 16 o nome não aparece
entre aspas. Não se trata de um erro,
mas de uma regra de sintaxe do VBA: no
caso das linhas 11 e 12 o texto entre
aspas se refere ao nome que já existe na
planilha ativa, enquanto na linha 16 o
parâmetro entre parênteses não é o nome
da planilha em si, mas o nome da
variável que, por sua vez, contém o
nome dado à planilha; por se tratar de
um nome de variável, e não de um
simples texto, nomePianiiha não é
colocado entre aspas. Em outras
palavras, quando o argumento de um
comando ou propriedade é um texto, este
deverá ser especificado entre aspas, mas
quando é um nome de variável, uma
expressão ou um outro comando, não
podemos usar as aspas.

• (17, 19 e 21): essas linhas contêm o

comando que limpa o conteúdo
(.ClearContents) das células
selecionadas que não sofreram
alterações em relação ao código
original.

• (18 - 20): para duas linhas valem as

mesmas considerações feitas para a
linha 16, isto é, substituímos as
referências relativas usadas
 anteriormente por referências
específicas às células que devem ser
selecionadas. É interessante notar que,
mesmo que a seleção envolva uma
única célula em cada linha, a
propriedade alterada continua sendo
".Range" (intervalo), pois mesmo uma
única célula é assim considerada pelo
código.

• (22): como sempre, a instrução End

Sub marca o fim do procedimento.

Por razões de clareza, e também para

facilitar futuras consultas, sugerimos que
salve esta planilha com o código
alterado em uma outra pasta de trabalho,
de modo a conservar tanto o código
original (gerado pelo gravador de
macros) quanto o programa alterado
manualmente.

Para isso:

10. Clique no botão Office, localizado

na extremidade direita da faixa de
opções.

11. No menu, posicione o ponteiro do

mouse sobre a opção Salvar como.

12. No submenu aberto, clique na

segunda opção: Pasta de trabalho
habilitada para macro do Excel
(mostrada na Figura 4.3).
 Figura 4.3.: Salve a pasta de trabalho
habilitando as macros nela contidas.

13. Na janela Salvar como, selecione a

mesma pasta que contêm os outros
arquivos gerados durante a execução
dos procedimentos apresentados neste
livro.

14. Para o nome do arquivo, sugerimos

manter o padrão adotado até agora,
nomeando a pasta de trabalho como
Macro-3.

15. Clique no botão Salvar para

concluir.

Não feche a pasta de trabalho.

Permaneça no ambiente de
desenvolvimento do VBA, pois no
tópico que segue iremos verificar o
funcionamento do código que criamos.

Executando um programa passo a passo

para o Debug

Uma vez digitado ou alterado o código,

é possível executar uma verificação
prévia antes de utilizá-lo. A operação de
verificação e correção de erros no
código de um programa é conhecida
pelo nome Debug, recurso oferecido por
qualquer linguagem de programação,
incluindo o VBA.

Nesse tópico veremos como executar o

nosso código passo a passo para
perceber o que acontece em decorrência
da execução de cada linha do programa.
Simularemos também alguns erros para
ver como o VBA alerta sobre problemas
no código e como intervir para a
correção.

No tópico anterior, sugerimos que o

arquivo com o código alterado em VBA
fosse salvo com o nome Macro 3 e
mantido aberto. Caso tenha fechado a
pasta de trabalho Macro 3, abra-a
novamente e, na faixa de opções, use o
botão Visual Basic da guia
Desenvolvedor para voltar ao ambiente
de desenvolvimento do Visual Basic for
Applications.

0 nosso código faz uso de uma variável

chamada nomePianiiha a qual armazena
na memória RAM do computador o
nome a ser dado à cópia da planilha
gerada. Uma das características mais
interessantes do processo de Debug é,
justamente, a possibilidade de
inspecionar o conteúdo das variáveis a
cada passo da execução do programa;
este recurso se torna particularmente útil
quando o programa usa muitas variáveis,
mas pode ser usado também para
verificar se a variável criada (uma ou
mais) está recebendo os valores
corretos, de modo que o programa
retorne o resultado esperado.

Vejamos, então, como habilitar o

monitoramento das variáveis e
acompanhar as mudanças que ocorrem
ao longo da execução das linhas de
código do programa.

1. No espaço de trabalho do VBA,

abra o menu Exibir e clique janela
'Variáveis locais', como mostrado na
Figura 4.4:

Figura 4.4.: Use este comando para

exibir o painel Variáveis locais.
 2. Repare que na parte inferior da tela
do VBA, logo abaixo da área do código,
é exibido um painel retangular cuja
barra de título traz o nome Variáveis
Locais (Figura 4.5); a área interna deste
painel é dividida em três colunas,
respectivamente: "expressão", "valor" e
"tipo". Trata-se de informações
importantes sobre a variável, que serão
preenchidas no decorrer do programa
com os valores inseridos pelo usuário
(como no nosso caso) ou gerados pelo
próprio código.
 Figura 4.5.: A janela Variáveis locais,
no rodapé da tela do VBA.

Agora, vamos iniciar a execução do

programa, porém indicando ao VBA que
queremos que ele pare num determinado
ponto do código para podermos
observar com atenção cada ação
executada:

3. Coloque o ponteiro do mouse sobre

a linha 14 do nosso código, que traz o
comando Sheets ("Semanal (2) ")
.Select".

4. Agora, desloque o ponteiro para a

esquerda, posicionando-o sobre a barra
vertical cinza, tendo o cuidado de se
manter à altura da linha 14 do programa.

5. Em seguida dê um clique e note que

a linha é marcada com uma bola
vermelha e selecionada com uma tarja
da mesma cor, como mostra a Figura
4.6. Inserimos assim um ponto de
interrupção, isto é, definimos que o
programa deverá ser executados
somente até esta linha e parar, ignorando
as linhas abaixo. Fizemos isto para
vermos o que acontece no programa
depois que o usuário digita o nome da
planilha na caixa de entrada (InputBox).
 Figura 4.6.: Inserindo um ponto de
interrupção no programa.

6. Então, vamos executar o programa

até o ponto de interrupção inserido: na
barra de ferramentas do VBA, clique no
botão Executar Sub/User Form (Figura
4.7.) ou, se preferir, use a tecla de atalho
F5 para iniciar a execução:

Figura 4.7.: 0 botão Executar Sub/User

Form.

7. A execução do programa é
extremamente rápida, em instantes
somos levados à planilha Semanal e é
exibida a caixa de diálogo (/nputBox) na
qual somos solicitados a inserir um
nome para a nova planilha, como mostra
a Figura 4.8:

Figura 4.8.: A caixa de diálogo exibida

pelo comando InputBox usado no
código.)
 8. Use o campo da caixa de diálogo
para digitar o nome que deseja dar à
planilha (no nosso caso usamos
Semana2) e, em seguida, clique no botão
OK para confirmar.

9. Logo voltaremos ao ambiente VBA e

uma tarja amarela destacará o ponto
exato em que a execução do programa
parou, como podemos observar na
Figura 4.9:
 Figura 4.9.: A execução para na linha
indicada pela tarja amarela.

Concentremos a nossa atenção no

painel Variáveis locais (Figura 4.10), no
rodapé do espaço de trabalho, e
vejamos o que aconteceu até agora:
observe que neste momento as três
colunas foram preenchidas,
respectivamente, com as seguintes
informações:

Figura 4.10.: 0 conteúdo do painel

Variáveis locais.

• a coluna Expressão contém

nomePlanilha, isto é, o nome da
variável que está sendo utilizada pelo
programa. Caso houvesse outras
variáveis, seus respectivos nomes
apareceriam listados um abaixo do
outro; na coluna Valor temos o
conteúdo da variável, ou seja, o valor
armazenado na memória do
computador, que no nosso caso é
Semana2, nada mais que o texto que
digitamos na caixa de diálogo
apresentada pelo programa;na coluna
Tipo somos informados sobre o tipo de
dado armazenado na memória que, no
nosso caso, é String, isto é, texto (caso
queria relembrar os tipos de dados
aceitos pelo VBA, consulte o tópico
Entendendo as variáveis deste
capítulo).
 Resumidamente, o painel nos informa
que o nosso programa usou uma variável
chamada nomePlanilha, que contém
dados do tipo "texto" e que atualmente
está preenchida com o valor Semana2.

Ainda no painel Variáveis locais, a

linha que traz a informação Módulol
acompanhada por um sinal + serve
apenas para nos informar qual módulo
do programa faz uso da variável (ou das
variáveis) listadas.

Para interromper o Debug e redefinir a

execução do programa, basta clicar no
botão Redefinir, disponível na barra de
ferramentas do VBA (Figura 4.11):
 Figura 4.11.: 0 botão Redefinir, que
interrompe o debug.

Note que o ponto de interrupção

inserido anteriormente continua ativo.
Para removê-lo, apenas clique a bola
vermelha em correspondência da linha
em que o código foi interrompido.

É de suma importância ressaltar que,

ao executarmos o programa, mesmo para
o Debug, todas as ações executadas pelo
código são aplicadas de fato à pasta de
trabalho em uso. No nosso caso, por
exemplo, o código foi executado até o
momento em que o usuário digita o nome
para a nova planilha, mas antes que tal
nome fosse aplicado. Assim, a planilha
Semanal chegou a ser duplicada, porém
não recebeu nome algum e não teve seu
conteúdo apagado, pois, a execução do
programa foi parada antes que essas
operações fossem executadas, como
mostra a Figura 4.12. Portanto, fique
atento antes de executar qualquer código
para testes, pois poderia comprometer
seriamente a estrutura e o conteúdo do
arquivo. Por razões de segurança, é
altamente recomendável criar uma cópia
do arquivo antes de realizar qualquer
teste de código VBA.
Figura 4.12.: 0 procedimento não foi
concluído e a planilha não foi
renomeada nem limpa.

Para procedermos, apague a planilha

duplicada durante o teste:

11. Clique com o botão auxiliar a guia

da planilha Semanal (2) e, no menu
suspenso, selecione o comando Excluir.

12. Em seguida, retorne ao ambiente de

desenvolvimento do VBA.

Agora, vamos executar o programa por

inteiro:

13. Para sair do VBA, abra o menu

Arquivo e clique no comando Fechar e
voltar para o Microsoft Excel, ou, se
preferir, use as teclas de atalho ALT +
Q.

14. Com a planilha Semanal ativa, e

sem mais planilhas na pasta de trabalho,
use as teclas de atalho definidas para
acionar a macro (no nosso caso CTRL +
D).

Se tudo foi feito como descrito nos

passos acima, será exibida a caixa de
diálogo para a inserção do nome da
planilha e, ao clicar no botão OK, a
nova planilha é criada, renomeada e
seus dados apagados. Obtemos assim,
com apenas um comando, uma nova
planilha baseada na anterior, pronta para
o uso.

Podemos usar o atalho quantas vezes for

necessário, sempre que precisarmos de
uma nova planilha para gerenciar os
pedidos de mais uma semana.

Use as teclas de atalho Ctrl + B para

salvar as alterações feitas na pasta de
trabalho. No próximo tópico
aprenderemos como descobrir e corrigir
eventuais pontos fracos do nosso
código.

Prevenindo erros de execução e

resultados indesejados

Graças ao programa criado, podemos

agora obter uma nova planilha já
formatada e com as fórmulas prontas,
baseada numa planilha já existente na
pasta de trabalho.

Tudo parece funcionar perfeitamente,

exatamente da forma como esperávamos
que o nosso código trabalhasse.
Todavia, existem problemas "ocultos"
no nosso programa, que só se
manifestarão em determinadas
condições, isto é, quando o usuário não
agir como deveria.
 Um bom programador deve considerar
todas as possibilidades de erro para
que, ao ser utilizado no dia a dia, seu
programa não apresente qualquer
problema de funcionamento, o que
acarretaria danos para o usuário e, nos
casos piores, perda de dados
importantes.

Então, vamos descobrir o que pode

sair errado no nosso programa e tratar
todas as possibilidades de problemas na
execução.

Vejamos um exemplo prático:

1. Caso não esteja em execução, inicie

o Excel 2007 e abra a pasta de trabalho
Macro-3, que contém o código do
programa VBA criado e modificado
anteriormente.

2. Sem acessar o Visual Basic, apenas

pressione as teclas de atalho que
acionam o programa (no nosso exemplo,
CTRL + D).

3. Quando for exibida a caixa de

entrada solicitando a inserção do nome
da nova planilha, não digite nada:
mantenha o campo em branco e clique
no botão OK.

A execução do programa é
interrompida imediatamente e o Visual
Basic for Application mostra uma janela
com uma mensagem de erro de
execução, que podemos observar na
Figura 4.13:

Figura 4.13.: A janela informa que

algo deu errado no programa.
 Clique no botão Fim para interromper
o programa.

Como acontece em praticamente todos

os programas, a mensagem de erro
apresentada não é muito clara, o que
torna difícil compreender qual foi o
problema que causou a interrupção.

Aqui está a explicação: caso o usuário

clique OK sem especificar um nome
para a planilha, o Excel definirá um
nome aleatório e a variável
nomePlanilha ficará vazia. Assim, as
linhas de código que seguem, que como
vimos fazem referência à variável para
selecionar a planilha e limpar seu
conteúdo, não poderão ser executadas,
pois a variável nomePlanilha não aponta
para nenhuma planilha do nosso arquivo.
Esse é o "erro de definição de objeto"
ao qual a mensagem de erro se refere.

Para resolver este problema temos

duas soluções: ou impedir que o usuário
deixe o nome em branco, ou fazer com
que, caso o usuário não digite nenhum
nome, o nosso programa se encarregue
de fazer isso.

Agora, vamos provocar mais um erro

no programa:

4. Exclua a planilha gerada pela

tentativa de execução anterior.

5. Tecle o atalho que dispara a

execução do código (para o nosso
exemplo, Ctrl + D);

6. Quando a caixa de entrada solicitar

o nome da nova planilha, digite
exatamente o mesmo nome da planilha
que já existe (no nosso caso, Semanal) e
clique o botão OK.

Mais uma vez, o programa para e exibe

uma mensagem de erro que, neste caso,
apresenta uma explicação um pouco
mais clara que a anterior (Figura 4.14).
Clique no botão Fim para fechá-la:
 Figura 4.14.: Mais uma
mensagem de erro.

Mas o que foi que aconteceu desta vez?

Simples: sabemos que o Excel não

permite que duas planilhas tenham o
mesmo nome, portanto, ao digitarmos
para a nova planilha um nome idêntico
ao da que já existe, o programa entrou
em crash, isto é, travou.

A solução deste erro é razoavelmente

simples: primeiramente podemos
modificar o texto apresentado na caixa
de entrada (InputBox) de modo que
avise o usuário para que ele não use um
nome de planilha já existente; também
será preciso alterar o código do
programa para verificar se de fato, o
nome especificado para a nova planilha
não é igual a nenhum outro já em uso.

Os exemplos citados são de casos

comuns em que as coisas podem não
acontecer como o programador esperava
e em que as ações do usuário podem
causar travamentos no programa.

Vejamos, então, como modificar o

nosso código VBA para que tais erros
sejam prevenidos e tratados. Antes de
continuar, certifique-se que a pasta de
trabalho Macro_3 contenha apenas uma
planilha (Semanal). Caso seja
necessário, apague eventuais cópias
geradas anteriormente.

7. Com o arquivo Macro_3 já aberto

no Excel, acesse a guia Desenvolvedor
da faixa de opções.

8. No grupo Código, clique no botão

Visual Basic para entrar no ambiente de
desenvolvimento do VBA.

9. Modifique o código do programa

exatamente como descrito a seguir - as
linhas de código estão numeradas para
facilitar a referência às mesmas
futuramente, portanto não é necessário
digitar os números relativos a cada
linha; as que apresentam alterações em
relação ao código anterior estão
destacadas em negrito:
 Tentemos compreender o que mudou no
código do nosso programa.

Note que foram acrescentadas oito

novas linhas que vão da linha 13 até a
linha 20. A primeira (13) e a última
delas (20) são apenas comentários
usados para documentar o código sobre
a função dos comandos inseridos. 0
tratamento de erros em si ocorre na
sequência de instruções que vai da linha
14 à linha 19. Vejamos o que acontece:
• (14): na linha quatorze temos um
novo elemento muito usado na criação
de programas: trata-se da instrução
While (enquanto, em português), que
serve para criar loops, isto é,
estruturas de repetição nas quais
determinado(s) comando(s) se
repete(m) até que uma ou mais
condições sejam satisfeitas. Assim
como vimos anteriormente, instruções,
comandos, propriedades e métodos do
VBA são baseados no idioma inglês,
por isso, mais uma vez, temos uma
linha de código para a qual podemos
arriscar uma tradução literal: enquanto
o conteúdo da variável nomePlanilha
seja vazio ou igual ao nome da planilha
Semanal...

Note que, neste caso, o loop

(repetição) ocorrerá sempre que
qualquer uma das duas condições
especificadas se verifica: ou quando a
variável nomePlanilha está vazia ou
(or) quando seu conteúdo é igual ao
nome da planilha existente.

• (15): o comando da linha quinze

permaneceu substancialmente igual,
apenas mudamos o texto apresentado
na caixa de diálogo, acrescentando que
o usuário não poderá utilizar nomes de
planilhas existentes.
• (16 - 17): encontramos aqui mais um
conceito muito importante a ser
abordado, o de "estrutura condicional".
Na linha 15 o usuário é chamado a
inserir um nome e a estrutura de
repetição While checa se o nome é
válido e só segue adiante na execução
do programa quando o nome digitado
for aceito, e isso já seria suficiente
para evitar erros no programa. Mas o
nosso programa vai além e faz uma
segunda verificação de validez do
nome: SE (i f) o conteúdo da variável
nomePlanilha for vazio ou (or) for
igual ao nome da planilha existente,
ENTÃO (Then) será mostrada uma
caixa de diálogo (MsgBox) que
informará ao usuário que o nome que
inseriu é inválido. A principal
diferença entre as caixas de diálogo
mostradas pelo comando InputBox
(usado na linha quinze) e aquelas
exibidas pelo comando MsgBox é que
as primeiras permitem a digitação (ou
entrada) de dados num campo
específicos, possibilitando a interação
do usuário com o programa, enquanto
as segundas apenas mostram
mensagens, sem a possibilidade de
digitar nelas ou modificar seu
conteúdo.

• (18 - 19): tanto as estruturas de

repetição (While) quanto as
condicionais (If) precisam ser
encerradas com as respectivas
instruções de fechamento, seguindo a
mesma lógica pela qual todo
procedimento (Sub) deve ser
encerrado com a respectiva instrução
(End Sub). Assim, o comando End if na
linha 18 indica o término da estrutura
condicional iniciada na linha dezesseis
e o comando Wend, na linha 19,
determina o fim da estrutura de
repetição While que começou na linha
quatorze.

• As demais linhas de código (de 21 a

29), que se encarregam de renomear a
planilha e limpar seu conteúdo,
 permaneceram inalteradas em relação
ao código original.

Entender os elementos que compõem a

estrutura do código criado é essencial
para que o leitor possa, futuramente,
aplicar os mesmos conceitos em outras
circunstâncias, adequando o programa
às suas necessidades. Por esse motivo
recomendamos que realize as atividades
propostas nos procedimentos passo a
passo ilustrados, para poder ver na
prática o resultado e ter exemplos nos
quais se basear para a criação de seus
próprios programas em VBA.

A Figura 4.15 mostra a janela do VBA

com o código devidamente modificado.

Figura 4.15.: 0 código exibido na janela

do VBA.

Para testar o funcionamento do

programa, faça o seguinte:
 10. Saia do VBA teclando o atalho Alt
+ Q.

11. De volta à planilha ativa, ative o

programa com as teclas de atalho a ele
associadas, que, no nosso caso, são Ctrl
+ D, e siga o procedimento
normalmente.

Experimente inserir valores

propositalmente errados e/ou deixar o
campo da caixa de entrada em branco e
veja o resultado. As caixas de diálogos
exibidas durante a execução devem ser
iguais às mostradas nas Figuras 4.16 e
4.17:
Figura 4.16,: A caixa que solicita a
inserção do nome...

Figura 4.17.:...e aquela exibida ao

usarmos um nome inválido.
 É importante lembrar que os exemplos
apresentados neste tópico representam
apenas uma pequena parte dos possíveis
erros que podem ocorrer durante a
execução de um programa. Cabe ao
desenvolvedor analisar e esgotar
qualquer hipótese de conflito que possa
ocorrer, para produzir aplicações
estáveis e confiáveis que, de fato,
resolvam com rapidez as questões para
as quais foram criadas.

Algumas observações sobre estruturas

condicionais e de repetição

No tópico anterior complementamos o

nosso código com algumas linhas em
que usamos as instruções while e If para
criar, respectivamente, uma estrutura de
repetição, também chamada ioop, e uma
condicional.

Em ambos os casos, estamos lidando

com um tipo especial de código
conhecido tecnicamente com o nome de
Estruturas de controle. Tal nome deriva
do fato que esses comandos permitem
controlar o trajeto da execução do
programa, desviando-o do seu curso
que, por padrão, seria apenas
sequencial.

De fato, um código de programa

sempre é executado sequencialmente de
cima para baixo, a partir das primeiras
instruções e descendo, linha por linha,
até chegar no fim do procedimento.
Todavia, as estruturas de controle
permitem que o programador direcione a
execução até um determinado ponto ou,
ainda, que certo trecho do código se
repita tantas vezes quanto necessário
para atingir o objetivo do programa.

No exemplo do código que criamos, a

execução do programa começa, passa
pela declaração da variável
nomePlaniiha, depois seleciona e copia
a planilha Semanal e, neste ponto, entra
na estrutura de controle while, da qual
sairá somente se todas as condições
fixadas pelo programador se
verificarem. Ainda dentro da estrutura
de ioop, a execução é controlada por
outra condição (If) que, neste caso,
direciona a execução para que seja
exibida uma mensagem de erro
personalizada.

Após passar por essas estruturas, o

código continua sua execução sequencial
até alcançar o término do programa.

Criando botões para executar o

programa

Possuímos agora uma pasta de trabalho

com uma planilha modelo, a partir da
qual poderemos criar, em instantes,
novas planilhas prontas para a inserção
dos dados relativos aos pedidos de cada
semana.

0 programa responsável pela

duplicação da planilha modelo foi
criado a partir da gravação de uma
macro simples que, num segun do
momento, foi amplamente modificada
graças aos comandos disponibilizados
pelo ambiente de desenvolvimento do
Visual Basic for Applications.
Obtivemos, assim, um mini aplicativo
associado a uma combinação de teclas
de atalho que, além de muito útil, inclui
interação com o usuário para a escolha
do nome da nova planilha gerada.

Embora o uso de teclas de atalho esteja

plenamente em sintonia com o conceito
essencial do uso de macros e VBA, isto
é, economizar tempo, ele pode não ser
tão prático para aqueles usuários que
não tenham o hábito de empregar esse
tipo de recurso; além do mais, para
acionar o programa é imprescindível
lembrar qual é a combinação de teclas a
ele associado, pois nem a faixa de
opções do Excel 2007, nem a própria
planilha, oferecem a possibilidade e
iniciar o programa criado de outra
maneira.
 Assim, para tornar o uso do aplicativo
ainda mais prático, intuitivo e acessível
a todo tipo de usuário, iremos associar
sua execução a um botão na faixa de
opções e a outro que será exibido dentro
da planilha modelo Semanal.

Vejamos como proceder para fazer

isso:

1. Inicie o Excel 2007 e abra o arquivo

Macro _3.xlsm, que contém a versão
completa do nosso aplicativo em VBA;
permaneça na planilha, pois não é
necessário acessar o ambiente do VBA
para a inserção de botões.
 2. Clique o botão Office, localizado na
extremidade esquerda da faixa de
opções.

3. Embaixo, à direita do menu exibido,

clique no botão Opções do Excel para
abrir a caixa de diálogo homônima.

4. Na coluna de opções menor, à

esquerda, selecione a categoria
Personalizar, na qual poderemos
customizar os botões exibidos na Barra
de acesso rápido. Trata-se da pequena
barra de botões exibida em cima à
direita do botão Office, como mostra a
Figura 4.18, que, por padrão, traz
apenas os atalhos para os comandos
Salvar, Desfazer e Refazer.

Figura 4.18.: A Barra de acesso

rápido.

5. Na seção direita da janela de

opções, faça o seguinte:

a. Abra o menu desdobrável rotulado

Escolher comandos em (que agora
contém a opção Comandos mais
usados) e clique em Macros;

b. Note que o quadro logo abaixo do

 menu desdobrável passa a exibir
apenas duas opções (Figura 4.19):

• <Separador>: usada para inserir na

Barra de acesso rápido, uma pequena
linha vertical para organizar e separar
grupos de botões.

• DuplicarLimpar: é o nome do
procedimento que criamos.

Caso a pasta de trabalho ativa contenha

mais de uma macro ou mais de um
procedimento VBA, todos seriam
listados neste painel.
 Figura 4.19.: A listagem das macros
existentes no arquivo.

c. Agora, abra o menu desdobrável

rotulado Personalizar Barra de
ferramentas de acesso rápido
(localizado acima da lista à direita) e
selecione a opção De Macro_3.xlsm.
Isso é extremamente importante, pois faz
com que o botão associado ao nosso
procedimento apareça apenas ao abrir
este arquivo; se, ao contrário,
tivéssemos mantido a opção Para todos
os documentos (Padrão), o botão seria
disponibilizado para qualquer pasta de
trabalho aberta, o que resultaria em erro,
pois o nosso procedimento foi criado
apenas para o arquivo Macro _3.x/sm;na
lista à esquerda, selecione a macro
DupiicarLimpar e clique o botão
Adicionar », disponível à direita da
lista. Repare agora que a opção relativa
à nossa macro DupiicarLimpar passou
para a lista à direita, que contém os
outros botões atualmente exibidos na
Barra de acesso rápido (Figura 4.20).
Se desejar remover algum dos itens da
lista à direita, basta selecioná-lo e
clicar o botão Remover:

Figura 4.20.: Adicione o botão na lista à

direita.

d. Com o procedimento
DupiicarLimpar ainda selecionado na
lista à direita, desloque o ponteiro do
mouse para baixo até o botão
Modificar e clique-o para exibir a
janela com os ícones que podem ser
aplicados ao botão.

e. Na janela aberta, selecione com um

clique o ícone de sua preferência e, no
campo Nome para a exibição, digite o
texto que será exibido ao passar o
mouse sobre o botão (Figura 4.21) - no
nosso exemplo usamos Duplicar e
limpar planilha (Ctrl + D); em seguida
clique OK para que sua escolha seja
aplicada.
 Figura 4.21.: Escolha um ícone e um
texto para o novo botão.

f. se quiser, use os botões em forma de

 seta para cima e seta para baixo, à
direita da lista, para alterar a ordem de
apresentação dos botões: a posição
superior da lista se refere à posição
mais à esquerda da barra de botões,
assim, por exemplo, para que o seu
botão apareça em primeiro lugar à
esquerda, deverá estar em primeiro
lugar na lista. Para o nosso exemplo,
não foi preciso fazer isto, pois apenas
um botão é exibido;clique no botão OK
na região inferior-direita da janela de
opções para concluir a inserção do
novo botão.

Observe agora, na Barra de acesso

rápido, a presença do botão que executa
o nosso procedimento (Figura 4.22):

Figura 4.22.: 0 botão é exibido na Barra

de acesso rápido.

Experimente clicá-lo para ver o

resultado. Em seguida, tecle o atalho
Ctrl + B para salvar as alterações que
fizemos.

Por se tratar de um botão muito

pequeno, corre-se o risco que o mesmo
passe despercebido para a maioria dos
usuários, principalmente para aqueles
que ainda não têm familiaridade com a
nova interface introduzida pela versão
2007 do Microsoft Office.

Não podemos esquecer que de nada

adianta criar um procedimento VBA se a
pessoa que fará uso da planilha não
conseguirá executá-lo.

Para facilitarmos ainda mais a

execução do procedimento
DuplicarLimpar, vamos inserir um botão
dentro da própria planilha, de modo que
fique bem visível e possa ser empregado
rapidamente.

Acompanhe os passos descritos a

seguir:
 1. Com o arquivo Macro_3.xlsm ainda
aberto no Excel 2007, acesse a guia
Desenvolvedor da faixa de opções.

2. No grupo Controle, clique o botão

Inserir, como mostrado na Figura 4.23:

Figura 4.23.: Use este botão para inserir

 controles na planilha.

Os controles disponibilizados pelo

Excel 2007 podem ser de dois tipos:

• Controles Active X: podem ser

definidos como mini aplicativos (ou
appletts) disponibilizados pelo
software, que podem ser reutilizados
em diversas ocasiões. No caso dos
aplicativos que compõem o pacote
Microsoft Office, a maioria desses
objetos são visuais, isto é, trata-se de
novos elementos de interação que
podem ser inseridos no documento.

Os Controles Active X foram

introduzidos inicialmente com a
linguagem de programação Visual
Basic e sua aplicação era restrita
apenas aos programas que fossem
executados no ambiente Windows. Em
seguida, porém, foram implementados
para que pudessem ser executados
também em plataformas diferentes,
como, por exemplo, em ambiente Web
ou Internet via browser. Com o passar
do tempo, as funções Active X
passaram a ser estendidas também ao
Visual Basic for Applications,
podendo ser inseridas em qualquer tipo
de documento gerado com aplicativos
que suportam esta função.
Embora o uso de Controles Active X
seja seguro, é preciso lembrar que tais
elementos são usados para programar
sequências de ações que serão
executadas no computador. Na Internet
é fácil encontrar inúmeros plug-ins
para o Excel sob forma de controles
Active X que, na maioria dos casos,
trazem interessantes funções adicionais
que podem ser implementadas às
nossas planilhas. Todavia, há também
muitos casos de vírus mascarados de
plug-ins que, ao serem baixados e
instalados, passam a assumir o
controle do código, podendo causar
estragos consideráveis no computador
e até mesmo perda ou desvio de
informações confidenciais preciosas.
Portanto, todo cuidado é pouco ao
instalar controles Active X cuja
procedência não é especificada ou é
duvidosa.

• Controles de formulário: são objetos

da interface gráfica do usuário, como
uma caixa de texto, uma caixa de
seleção, uma barra de rolagem ou um
botão de comando, que permitem ao
usuários controlar programas e/ou
macros. 0 uso de Controles de
formulário está estritamente
relacionado ao que estamos
aprendendo pois, mais uma vez, trata-
se de recursos que visam tornar mais
 fácil a integração de novas
funcionalidades, bem como a
realização mais rápida de tarefas
rotineiras.

De posse dessas informações, vamos

utilizar alguns controles oferecidos pelo
próprio Excel para manipular a nossa
pasta de trabalho. Continuemos com os
procedimentos:

3. No menu exibido ao clicar no botão

Inserir, clique na primeira opção
disponível no grupo Controles de
formulário, chamada botão (Controle de
formulário).
 4. Então, vá até o local onde deseja
posicionar o botão, clique e arraste no
sentido diagonal para baixo e para a
direita, como se estivesse desenhando
um retângulo, de modo a definir o
tamanho do novo botão (Figura 4.24).

Figura 4.24.: Arraste para desenhar o

botão.
 5. Ao liberar o mouse, o novo botão
aparece na planilha e, quase
simultaneamente, é exibida a janela
Atribuir macro.

6. No painel central desta janela são

exibidas todas as macros da pasta de
trabalho ativa ou, dependendo da opção
escolhida no menu desdobrável
embaixo, de todas as pastas de trabalho
abertas. No nosso exemplo, é listada
apenas a macro LimparDupiicar, criada
neste arquivo; selecione-a e clique OK
no rodapé da janela (Figura 4.25).
Figura 4.25.: Atribua ao botão a macro
desejada.

7. De volta à planilha, note que o botão

ainda está destacado com a borda de
seleção pontilhada, o que indica estar no
modo de edição. Isso significa que ainda
podemos realizar algumas alterações de
aparência em nosso botão.

8. Então, clique e arraste sobre o texto

do rótulo do botão - que agora é botão n,
onde n é um número sequencial dado
pelo programa - para selecioná-lo, como
num editor de texto.

9. Em seguida, apague o rótulo

definido pelo Excel e digite outro que
descreva resumidamente a função do
botão; no caso usamos DupiicarPianiiha,
como mostra a Figura 4.26:
Figura 4.26.: Com o botão em modo de
edição, alteramos o rótulo.

10. Caso seja necessário, use as alças

de redimensionamento, representadas
por pequenos círculos brancos ao redor
do botão, para modificar altura e
largura.

11. Ao concluir, basta clicar em

qualquer ponto da planilha para sair do
modo de edição.
 Pronto! 0 botão foi criado e já está
funcionando, pois atribuímos a ele a
execução da macro Dupl carLimpar.
Teste-o clicando nele e, em seguida,
salve as alterações que fizemos.

Alterando as propriedades do controle

Botão

Ao inserirmos um botão, sua aparência

segue os padrões ditados pelo esquema
pré-definido do aplicativo. Porém é
possível modificar algumas
características do botão para aprimorar
não apenas o aspecto visual, mas
também como ele reagirá ao alterarmos
a estrutura da planilha na qual foi
inserido.

Vejamos, então, como acessar as

propriedades do botão.

1. Clique com o botão auxiliar do

mouse no botão DupiicarPianiiha que
criamos na planilha Semanal.

2. No menu suspenso, clique na opção

Formatar controle (Figura 4.27).
 Figura 4.27.: Acessando as
propriedades do botão.

3. Em instantes é exibida a caixa de

diálogo Formatar controle (Figura.
4.28), na qual dispomos de sete guias,
que são:

• Fonte: esta guia agrupa todas as

opções de formatação da fonte do rótulo
do botão. Trata-se substancialmente da
mesma janela apresentada quando
clicamos na guia Fonte da janela
Formatar células do Excel. Realize
algumas alterações na aparência da fonte
para experimentar: no nosso caso
aplicamos a fonte Verdana, com tamanho
10, negrito e cor azul escuro (sugerimos
que o tamanho do texto fique entre 8 e
12 para que o rótulo caiba por inteiro
sem a necessidade de aumentar demais o
tamanho do botão).
Figura 4.28.: A janela Propriedades do
controle.

• Alinhamento: aqui podemos

determinar qual será o alinhamento do
rótulo em relação ao botão. Além das
opções de alinhamento vertical e
horizontal, é possível definir também a
orientação do texto. Ao marcar a caixa
Tamanho automático, o tamanho do
texto é ajustado automaticamente de
acordo com a área do botão.

• Tamanho: nesta guia são incluídas as

opções relativas ao tamanho do botão;
podemos alterar a largura e a altura
digitando novos valores em
centímetros nas caixas superiores ou
especificando valores em percentual
nas caixas ao centro da janela. Se a
caixa Fixar proporção estiver marcada,
altura e largura serão ajustadas uma em
função da outra sempre que uma das
duas for alterada, para manter a
proporção entre largura e altura do
botão.

• Bloqueio: traz as caixas que

permitem bloquear ou desbloquear a
edição do botão. Essa função passa a
ter efeito somente quando a proteção
da planilha estiver ativa.

• Propriedades: as opções desta guia

permitem modificar aspectos
importantes de como o nosso botão se
comportará caso as linhas e/ou as
colunas nas quais foi inserido sejam
redimensionadas. Para evitar que o
tamanho do botão mude ao alterar as
dimensões das linhas/colunas, é
recomendável que a caixa Não mover
ou redimensionar com células esteja
marcada. Por padrão, os botões não
são impressos juntamente com a
planilha; todavia, se quiser imprimí-
los, basta ativar com um clique a caixa
Imprimir objeto; sugerimos que deixe
esta opção desativada.

• Margens: traz quatro campos nos

quais podemos especificar, se
necessário, as margens esquerda,
direita, superior e inferior. Trata-se
das margens internas, ou seja, o espaço
entre as bordas do botão e o rótulo.
Por /pré-definição, as margens são
 configuradas automaticamente pelo
aplicativo, mas caso queira alterá-las
manualmente, basta desmarcar a caixa
Automática e inserir nos campos os
valores desejados.

• Web: permite especificar um texto

alternativo que será exibido nos
programas de navegação (ou browsers)
caso a planilha seja publicada num
site. No nosso caso, não alteramos esta
propriedade.

4. Após realizar as alterações

desejadas, clique OK para confirmar.

S. Salve a pasta de trabalho.

Inserindo e organizando novos botões

Agora que sabemos como inserir

controles do tipo botão de comando
numa planilha, vejamos como trabalhar
com vários deles, organizando-os para
tornar seu uso o mais intuitivo e simples
possível.

Para ilustrar este exemplo, criamos no

arquivo Macro _3.x/sm um novo
procedimento que salva a pasta de
trabalho ativa. Se desejar, faça o mesmo
antes de seguir na leitura deste tópico.

Então, com o arquivo Macro_3.xlsm já

aberto no Excel 2007, faça o seguinte:
 1. Acesse a guia Desenvolvedor da
faixa de opções e, no grupo Controle,
clique no botão Inserir.

2. No menu exibido, clique no ícone

botão Controle de formulário do grupo
Controles de formulário.

3. No local onde deseja posicionar o

botão, clique e arraste para desenhar o
novo botão.

4. No painel central da janela Atribuir

macro, exibida ao liberar o mouse,
selecione a macro que deseja atribuir ao
botão, no nosso exemplo Salvar, e
clique OK.
 5. Com o botão ainda no modo de
edição, altere o rótulo do novo botão
para Salvar.

6. Clique em qualquer local da

planilha para sair do modo de edição.

7. Clique com o botão auxiliar do

mouse no botão Salvar e, no menu
suspenso, clique Formatar controle para
personalizar a aparência do botão.

A Figura 4.29 mostra como ficou o

botão Salvar do nosso exemplo:
Figura 4.29.: Um novo botão associado
a uma macro Salvar.

Agora, vamos inserir uma moldura com

um pequeno rótulo que ajude o usuário a
entender de que botões se trata:

1. Na guia Desenvolvedor da faixa de

opções, clique novamente no botão
Inserir.

2. Entre as opções exibidas no menu,

selecione Caixa de grupo (Controle de
formulário) - é a primeira opção da
segunda fileira (Figura 4.30).

Figura 4.30.: Esta opção cria molduras

de grupos.
 3. Clique e arraste na área ao redor
dos botões criando uma moldura que
envolva ambos, como mostrado na
Figura 4.31;

Figura 4.31.: Desenhe uma moldura em

volta dos botões.

4. Para concluir, selecione o texto do

rótulo da moldura (atualmente "Caixa de
grupo ", onde n é um número sequencial
dado pelo programa) e altere-o
digitando um nome que descreva os
botões - no nosso caso usamos o rótulo
Macros.

A Figura 4.32 mostra o resultado final

do trabalho.

A caixa de grupo não possui, neste

caso, nenhuma função prática, mas é
muito útil para agrupar os botões,
facilitando o seu manuseio.
 Figura 4.32.: 0 resultado final do
trabalho.

Salve as alterações feitas e, se desejar,

teste os botões.
Sandra Rita
 Que o Excel é uma ferramenta que
aumenta a produtividade, isso
praticamente todo mundo sabe. E isso é
obtido por meio dos cálculos, controles
de tipos variados de valores e dados e
até situações do mundo corporativo que
são resolvidas de forma prática, rápida
e extremamente profissional em seu
ambiente. Por meio deste livro, o leitor
passará por um verdadeiro upgrade
profissional e será capaz de criar e
trabalhar com:

- Funções simples e complexas

- Tabelas dinâmicas
- Gráficos

- Macros e funções para

variação percentual

- Juros compostos e de valor futuro

- Cálculo de hipóteses de

pagamentos e prazo
 Edson J. R. Lobo

Tão importante quanto o

desenvolvimento de um software, uma
modelagem bem feita organiza a sua
implementação, reduz problemas futuros
em seu funcionamento, eleva a
consistência das informações e aumenta
o nível geral de qualidade de um
sistema. Para aqueles que desejam
alcançar esse patamar de
profissionalismo em seus sistemas, esta
leitura pode ser considerada
imprescindível, visto que abrange estes
e outros assuntos:

- Método e processos no MIDDS

- Método Interativo e

Documentado de Desenvolvimento
de Software

- Modelagem de software com UML

- Tipos e funcionalidade de
diagramas

-Arquitetura de software

- Model-View-Controller

-Arquitetura em 3 Camadas

-Análise de requisitos

- MDA (Model Driven Architecture)