Apostila - Macro e VBA Para Ms Excel

MACRO E VBA PARA MS EXCEL

“ Todos direitos reservados. Proibida a reprodução, mesmo parcial, por qualquer processo mecânico, eletrônico, reprográfico, etc., sem a autorização, por escrito, do(s) autor(es) e da editora.”

www.webaula.com.br Pág.: 2/2 Proibida a reprodução e utilização não autorizada, de todo ou parte do conteúdo deste material. Todos os direitos são reservados e licenciados pelo Grupo Zargon e Poliedro Educacional - Copyright© 1999-2004 Powered by webAula

MACRO E VBA PARA EXCEL

SUMÁRIO

INTRODUÇÃO......................................................................................................................................................................................4 MACROS ...............................................................................................................................................................................................4 NÍVEIS DE SEGURANÇA DE MACROS ......................................................................................................................................................4 GRAVANDO UMA MACRO .....................................................................................................................................................................6 EXECUTANDO A GRAVAÇÃO DA MACRO ..............................................................................................................................................7 ABRINDO PASTAS DE TRABALHO COM MACROS ...................................................................................................................................9 EXECUTANDO UMA MACRO............................................................................................................................................................... 10 CONHECENDO A JANELA MACRO ....................................................................................................................................................... 11 EXECUTANDO A MACRO UTILIZANDO TECLA DE ATALHO E BOTÃO DA BARRA DE FERRAMENTAS....................................................... 11

O EDITOR DO VISUAL BASIC...................................................................................................................................................... 14 CONHECENDO O EDITOR DO VISUAL BASIC ........................................................................................................................................ 14 OS COMPONENTES DA JANELA DO EDITOR........................................................................................................................................... 14 A BARRA DE FERRAMENTAS PADRÃO................................................................................................................................................ 15 O PROJECT EXPLORER........................................................................................................................................................................ 16 A JANELA DE CÓDIGOS........................................................................................................................................................................ 16 ENTENDENDO UM POUCO OS CÓDIGOS................................................................................................................................................. 17 A JANELA VERIFICAÇÃO IMEDIATA .................................................................................................................................................... 17

CRIANDO E EDITANDO MACROS.............................................................................................................................................. 18 CRIANDO UMA MACRO...................................................................................................................................................................... 18 VISUALIZANDO O CÓDIGO DAS MACROS ............................................................................................................................................. 18 VISUALIZANDO O CÓDIGO DAS MACROS ............................................................................................................................................. 18 OBJETOS, MÉTODOS E PROPRIEDADES ................................................................................................................................................ 19 EDITANDO MACROS ........................................................................................................................................................................... 20 CRIANDO UMA MACRO COM CÉLULAS SELECIONADAS........................................................................................................................ 20 TESTANDO A MACRO PARA FORMATAR TABELA ................................................................................................................................ 21 EVITANDO ERROS COM MACROS ......................................................................................................................................................... 23 TRATANDO O ERRO............................................................................................................................................................................. 23 CRIANDO MACROS COM VÁ RIOS OBJETOS E FUNÇÕES DO EXCEL.......................................................................................................... 24 CONHECENDO A PASTA DE TRABALHO................................................................................................................................................ 25 CONSTRUINDO A CAIXA DE DIÁLOGO .................................................................................................................................................. 26 CRIANDO A MACRO FILTRAR.............................................................................................................................................................. 29 CRIANDO A MACRO EXIBIR_TUDO ..................................................................................................................................................... 29 CRIANDO A MACRO EXIBIR_CAIXA ................................................................................................................................................... 29 VINCULANDO AS MACROS AOS CONTROLES ........................................................................................................................................ 30

INTRODUÇÃO AO VBA.................................................................................................................................................................. 32 VBA - VISUAL BASIC FOR APPLICATION............................................................................................................................................ 32 PROGRAMAÇÃO EM VBA................................................................................................................................................................... 32 VARIÁVEIS ......................................................................................................................................................................................... 33 TIPOS DE VARIÁVEIS........................................................................................................................................................................... 33 DECLARAÇÃO DE VARIÁVEIS.............................................................................................................................................................. 34 CONSTANTES ..................................................................................................................................................................................... 35 OPERADORES...................................................................................................................................................................................... 36 A ESTRUTURA DO VBA...................................................................................................................................................................... 37 PROCEDIMENTOS................................................................................................................................................................................ 38 SUBS E FUNCTIONS ............................................................................................................................................................................. 38 ARGUMENTOS DE SUBS E FUNCTIONS.................................................................................................................................................. 39 OS ARGUMENTOS DE UMA ROTINA ..................................................................................................................................................... 39



CONSTRUINDO PROCEDIMENTOS......................................................................................................................................................... 40 TESTANDO PROCEDIMENTOS............................................................................................................................................................... 40 CONSTRUINDO FUNÇÕES ..................................................................................................................................................................... 41 TESTANDO FUNÇÕES ........................................................................................................................................................................... 42 CAIXAS DE MENSAGEM...................................................................................................................................................................... 43 ESTRUTURAS CONDICIONAIS.............................................................................................................................................................. 48 O COMANDO IF.................................................................................................................................................................................. 48 O COMANDO SELECT ......................................................................................................................................................................... 51 ESTRUTURAS DE REPETIÇÃO .............................................................................................................................................................. 52 O COMANDO FOR .............................................................................................................................................................................. 52 O COMANDO WHILE.......................................................................................................................................................................... 54

DEPURAÇÃO DE CÓDIGO........................................................................................................................................................... 56 DEPURANDO UM CÓDIGO ................................................................................................................................................................... 56

TRATAMENTO DE ERROS EM ROTINAS................................................................................................................................. 61 TRATANDO ERROS ............................................................................................................................................................................. 61 GERANDO ERROS ............................................................................................................................................................................... 63 PROPRIEDADES E MÉTODOS DO OBJETO ERR ...................................................................................................................................... 66

A HIERARQUIA DE OBJETOS DO EXCEL............................................................................................................................... 68 OBJETOS DO EXCEL ............................................................................................................................................................................ 68 O OBJETO APPLICATION..................................................................................................................................................................... 68 O OBJETO WORKBOOKS..................................................................................................................................................................... 70 O OBJETO WORKSHEETS.................................................................................................................................................................... 71 O OBJETO RANGE .............................................................................................................................................................................. 73

WORKBOOKS E WORKSHEETS................................................................................................................................................. 75 O PROJECT EXPLORER........................................................................................................................................................................ 75 PROGRAMANDO COM EVENTOS........................................................................................................................................................... 76

O USERFORM................................................................................................................................................................................... 79 CONHECENDO OS FORMULÁRIOS - USERFORMS................................................................................................................................. 79 CRIANDO FORMULÁRIOS.................................................................................................................................................................... 81 PROGRAMANDO O FORMULÁ RIO......................................................................................................................................................... 84 UTILIZANDO O FORMULÁRIO NA PLANILHA ........................................................................................................................................ 87

SEGURANÇA DE MACROS........................................................................................................................................................... 89 SEGURANÇA ....................................................................................................................................................................................... 89 PROTEGENDO CÓDIGOS ....................................................................................................................................................................... 90

CONCLUSÃO..................................................................................................................................................................................... 92



INTRODUÇÃO

MACROS

Uma macro é um conjunto de instruções que é executada dentro de um aplicativo do Microsoft Office. Caso execute uma tarefa várias vezes no Microsoft Excel, por exemplo, você pode automatizá-la com uma macro. Uma macro é uma seqüência de comandos e funções armazenadas em um módulo do Visual Basic e pode ser executada sempre que você precisar executar a tarefa.

Por exemplo, se você sempre faz a mesma formatação de títulos em suas planilhas como fonte Arial, tamanho 14, negrito e sublinhado duplo, você pode criar uma macro com todas essas formatações já definidas e, no momento de utilizar fica muito mais simples, ao invés de ter que selecionar a fonte, selecionar o tamanho, selecionar o botão negrito e selecionar o sublinhado duplo, você simplesmente seleciona a macro, que pode estar em forma de botão em alguma barra de ferramentas ou como opção em algum menu.

Gravação de uma macro: Quando uma macro é gravada, o Microsoft Excel armazena informações sobre cada ação que você faz ao executar um série de comandos. Quando você para a gravação da macro, essa seqüência de ações realizadas formam a macro. O Visual Basic armazena cada macro em um novo módulo anexado a uma pasta de trabalho.

Execução de uma macro: Você pode executar uma macro escolhendo-a na lista na caixa de diálogo Macros, que se encontra no menu Ferramentas/Macro. Para que uma macro seja executada sempre que clicar em um botão específico ou pressionar uma determinada combinação de teclas, você pode atribuir a macro a um botão da barra de ferramentas, um atalho do teclado ou um objeto gráfico em uma planilha.

Em Ferramentas/Macro você encontra outras opções além de Macros. Macros traz a lista de macros já existentes em sua pasta de trabalho. Gravar nova macro é usada quando você deseja criar uma nova macro. Segurança define o nível de segurança de suas pastas de trabalho e Editor de Visual Basic que exibe o código de suas macros.

Gerenciamento de suas macros: Após gravar uma macro, você pode exibir seu código com o Editor do Visual Basic para corrigir erros ou alterar o que a macro faz. Por exemplo, caso deseje que a macro de formatação de título também deixe o título em itálico, pode gravar outra macro para aplicar itálico a uma célula e copiar as instruções dessa macro para a macro de formatação de título.

O Editor do Visual Basic é um programa criado para facilitar a gravação e edição de código de macro para iniciantes. Com uma visão simples de como funciona o Visual Basic, você consegue fazer alterações simples nas macros. Com o Editor do Visual Basic, é possível editar macros, copiar macros de um módulo para outro, copiar macros entre pastas de trabalho diferentes, renomear os módulos que armazenam as macros ou renomear as próprias macros.

Segurança de macros: O Microsoft Excel fornece proteção contra vírus que podem ser transmitidos através das macros. Sempre que abrir uma pasta de trabalho que contenha macros, você poderá ser avisado que aquela pasta de trabalho contém macros, podendo aceitar ou não que o arquivo seja aberto com macros, para isso, você precisa ativar os níveis de segurança das macros.

NÍVEIS DE SEGURANÇA DE MACROS

Para criarmos uma macro é muito simples, mas, antes de qualquer coisa, vamos verificar como está o nível de segurança de nossas pastas de trabalho, pois, dependendo do nível de segurança nenhuma macro pode ser executada.

Você pode fazer isso selecionando a opção Ferramentas/Macro/Segurança, aparecendo a janela a seguir:



As opções de nível de segurança definem o modo como o Excel trabalha a proteção contra os

vírus de macro. Na caixa de diálogo Segurança (menu Ferramentas/Macro), em diferentes condições, em todas as configurações, se o software antivírus que funciona com o Microsoft Office estiver instalado e o arquivo contiver macros, o arquivo será examinado para verificar a existência de vírus conhecidos antes de ser aberto.

Os níveis de segurança disponíveis são:

• Alto: neste nível de segurança as macros passam por um processo de segurança rigoroso e, na maioria dos casos, as pastas de trabalho são abertas sem as macros, ou seja, as macros não são ativadas.

• Médio: neste nível de segurança o usuário interage ao abrir uma pasta de trabalho que contenha macros; ele é questionado se deseja abrir o arquivo com habilitando as macros ou não.

• Baixo: quando o nível de segurança é definido como baixo, todas as macros são tratadas da mesma forma, independentemente se o arquivo contém ou não macro, ele será aberto da mesma forma, se contém macros, todas as macros são ativadas.

O nível de segurança mais utilizado é o Médio, pois, com a definição desse nível, sempre que abrirmos uma pasta de trabalho (arquivo) que contenha macros, o Microsoft Excel nos perguntará se desejamos habilitar ou desabilitar as macros existentes no arquivo. Dessa forma, podemos desabilitar as macros, caso, não conheçamos a procedência do arquivo que desejamos abrir.

Recapitulando, passo a passo como definir o nível de segurança no Microsoft Excel:

• No menu Ferramentas, clicamos em Macro.

• Selecionamos a opção Segurança.

• Na guia Nível de segurança selecionamos o nível de segurança que desejamos.



GRAVANDO UMA MACRO

No menu Ferramentas, posicionamos o ponteiro sobre Macro e, em seguida clicamos em Gravar nova macro. Aparecerá a caixa de diálogo abaixo:

Na caixa Nome da macro, inserimos um nome para a macro que estamos criando.

Observações:

• O primeiro caractere do nome da macro deve ser uma letra. Os demais caracteres podem ser letras, números ou caracteres sublinhados;

• Não são permitidos espaços no nome de uma macro;

• Não utilize caracteres especiais como nome da macro, como, por exemplo, %, $, #, &, entre outros.

• Não utilize como nome de macro que seja uma referência de célula, como, por exemplo, A1, B6, entre outros.

Se desejamos executar a macro pressionando uma tecla de atalho do teclado, precisamos inserir uma letra na caixa Tecla de atalho. Podemos usar CTRL+ letra (para letras minúsculas) ou CTRL+SHIFT+ letra (para letras maiúsculas), onde letra representa qualquer tecla de letra do teclado.

A letra da tecla de atalho usada não pode ser um número ou caractere especial, como, por exemplo, %, $, #, &, entre outros.

Observação:

• A tecla de atalho substituirá qualquer tecla de atalho padrão do Microsoft Excel enquanto a pasta de trabalho que contém a macro estiver aberta. Por exemplo, se você utilizar a letra C, ou seja, tecla de atalho CTRL + C, você estará substituindo a função padrão desse atalho que é Copiar para a macro que você está criando.

Na caixa Armazenar macro em, escolhemos o local onde desejamos gravar a macro.

As opções disponíveis são:

• Pasta de trabalho pessoal de macros: a macro fica disponível toda vez que você utilizar o Excel, para qualquer pasta de trabalho;



• Nova pasta de trabalho: abre uma nova pasta de trabalho e a macro fica disponível quando essa nova pasta de trabalho estiver aberta;

• Esta pasta de trabalho: grava a macro na pasta de trabalho ativa, a macro fica disponível nesta pasta de trabalho.

Podemos ainda adicionar uma descrição da macro na caixa Descrição. É interessante descrever nesta caixa o que a macro faz, pois, esse comentário pode ajudá-lo no futuro, quando for dar alguma manutenção nesta macro – você saberá o que a seqüência de comandos faz.

EXECUTANDO A GRAVAÇÃO DA MACRO

Quando definimos os dados de gravação da macro:

• Nome da macro;

• Tecla de atalho;

• Local de armazenamento, e;

• Descrição.

E, depois disso, clicamos no botão OK, aparecerá uma barra de ferramentas, conforme a figura abaixo:

Esta barra de ferramentas é chamada de barra de ferramentas Parar gravação. Ela possui exatamente a função que o nome dela diz, ela serve para parar a gravação da macro, ou seja, tudo o que você fizer enquanto esta barra de ferramentas estiver ativa, estará sendo gravado, quando terminar de executar as ações da macro, pare a gravação clicando no botão Parar gravação.

Além do botão Parar gravação, esta barra também possui o botão Referência relativa. Este botão quando ativado faz a gravação dos endereços relativos das células e não endereços absolutos. Caso você queira gravar endereços relativos de células, você pode selecionar esse botão. Se marcar este botão, toda a macro a ser gravada será executada com referências relativas até que você desmarque o botão.

Vamos explicar melhor como funciona essa gravação de macro:

Suponhamos que queremos fazer uma macro para justificar o texto em alguma célula e centralizá-lo verticalmente, conforme mostrado nas células a seguir:



Vamos no menu Ferramentas, opção Macro e selecionamos a opção Gravar nova macro. Preencheremos a caixa de diálogo Gravar macro da seguinte forma:

Quando clicamos no botão Ok já sabemos que surge a barra de ferramentas Parar gravação.

Agora, iniciamos o processo de gravação da macro, ou seja, não clicamos no botão Para gravação e, sim, na seqüência de comandos que a macro fará.

No menu Formatar, selecionamos a opção Células. Clicamos na guia Alinhamentos. Definiremos as configurações do alinhamos de texto da seguinte forma:

• Horizontal: Justificar;



• Vertical: Centro.

Vejamos a figura a seguir:

Clicamos em Ok. A caixa de formatação de células será fechada e nossa macro está pronta. Agora clicamos no botão Parar gravação e a gravação da macro será finalizada.

ABRINDO PASTAS DE TRABALHO COM MACROS

A macro que acabamos de criar no exemplo anterior ficou armazenada nesta pasta de trabalho, conforme definimos. Toda vez que abrirmos esta pasta de trabalho, poderemos utilizar esta macro, desde que para isso optamos por ativar as macros do arquivo.

Sempre que abrimos esta pasta de trabalho (este arquivo), aparecerá a seguinte caixa de mensagem:



Esta mensagem aparece porque o nível de segurança de macros foi marcado como médio. Caso tivéssemos marcado como baixo, o arquivo seria aberto normalmente com a macro ativa e caso tivéssemos marcado alto, o arquivo seria aberto com a macro desativada.

Se escolhemos a opção Ativar macros, poderemos utilizar a macro criada. Se escolhemos a opção Desativar macros, não será possível usar a macro criada.

EXECUTANDO UMA MACRO

Para utilizar a macro feita por nós. Faremos o seguinte:

Selecionamos a opção Ferramentas/Macro/Macros. A janela abaixo será mostrada:

Vemos que a macro FormatarCelula encontra-se listada nesta janela. Toda macro criada nesta pasta de trabalho ou em alguma outra pasta de trabalho que esteja aberta ou ainda na pasta de trabalho pessoal de macros apareceria nesta janela.

Você somente precisa selecionar a macro desejada, neste caso, a macro FormatarCelula e depois clicar no botão Executar.

Ao fazer isso, o conteúdo da célula A1 da planilha ficou formatado com texto horizontalmente justificado e verticalmente centralizado.

Macros, então, têm a função de simplificar nosso trabalho. Ao invés de sempre termos que fazer tarefas repetidas, podemos gravá-las numa macro.

Observação:

• Vale lembrar que essa macro, utilizada no exemplo, somente serve para formatar a célula A1 de cada planilha. Isso acontece porque quando gravamos a macro, a célula A1 estava selecionada, então, independente da planilha que está selecionada, sempre a célula A1 será formatada com seu texto alinhado justificado horizontalmente e centralizado verticalmente. Mas, o que faremos, caso desejamos formatar outras células? Veremos mais à frente como podemos deixar nossa macros mais genéricas, ou seja, podemos utilizar a macro em qualquer célula ou conjunto de células.



CONHECENDO A JANELA MACRO

A janela Macro tem outras características e funções além de, simplesmente, executar uma macro. Os componentes desta janela são:

• Nome da Macro: nesta caixa de texto você informa qual a macro que você irá trabalhar. Você pode digitar o nome da macro ou selecioná-lo da lista de macros existentes.

• Executar: botão que serve para executar a macro selecionada. Todas as ações encerradas na macro serão executadas.

• Cancelar: fecha a janela sem fazer nada.

• Entrar: exibe o código da macro no Editor do Visual Basic para que você possa depurar a macro. Depurar uma macro significa testar linha a linha de código da macro para procurar possíveis erros que possam ter. mais à frente iremos aprender como se depura um código.

• Editar: abre o código da macro no Editor do Visual Basic para que você possa alterar a macro criada.

• Criar: cria uma nova macro. Abre o Editor do Visual Basic para que você insira os códigos referentes à criação desta nova macro. Este botão somente fica ativo quando você digita um nome na caixa Nome da Macro que não está na lista de macros.

• Excluir: remove a macro selecionada.

• Opções: abre uma nova janela com informações da macro selecionada: nome da macro, tecla de atalho e descrição. Você pode alterar a tecla de atalho e a descrição.

• Macros em: aqui você decide se deseja mostrar todas as macros deste arquivo somente – Esta pasta de trabalho ou de todos os arquivos abertos – Todas as pastas de trabalho abertas.

• Descrição: exibe a descrição da macro selecionada.

EXECUTANDO A MACRO UTILIZANDO TECLA DE ATALHO E BOTÃO DA BARRA DE FERRAMENTAS

Você pode testar a macro criada de outras formas também. Você pode utilizar a tecla de atalho ou ainda criar um botão para executar a macro.

Uma outra forma de executar esta macro em questão é selecionando as teclas CTRL + SHIFT + F, pois foi a tecla de atalho que definimos na criação da macro.

Podemos ainda criar um botão na barra de ferramentas Formatação para executar esta macro. Para isso selecionamos o menu Exibir / Barra de ferramentas / Personalizar. Na janela que se abre, escolha guia Comandos.



Esta guia se subdivide em: Categorias e Comandos. Escolheremos a categoria Macros. Logo em seguida, selecionamos o comando Personalizar botão e o arrastamos para algum lugar da barra de ferramentas Formatação.



Soltamos o botão na barra, ele fica na posição que definimos (que o soltamos).

Clicamos com o botão direito do mouse sobre este botão. Existem várias opções, como mudar o nome do botão, editar a imagem que aparece, ente outros.

Selecionaremos a opção Atribuir macro. Ao clicarmos nesta opção surge a janela Atribuir Macro, assim escolhemos a macro desejada e clicamos no botão Ok. O botão está configurado com a macro desejada.



O EDITOR DO VISUAL BASIC

CONHECENDO O EDITOR DO VISUAL BASIC

O Editor do Visual Basic pode ser utilizado para criação e edição de macros; criação de módulos, procedimentos e funções; e, ainda, para quem tem familiaridade com programação, é possível desenvolver até sistemas inteligentes para planilhas.

A janela do Editor do Visual Basic é mostrada abaixo:

OS COMPONENTES DA JANELA DO EDITOR

Para acessarmos o editor do Visual Basic é necessário ir até a opção Ferramentas / Macro / Editor do Visual Basic.

Quando fazemos isso, é aberta uma nova janela, ou seja, o editor do Visual Basic é programado para trabalhar como um programa à parte do Excel, mas, na verdade, tudo que é feito nele é interno ao Excel.

Conheceremos um pouco dos componentes da janela do editor.

Na barra de título lemos Microsoft Visual Basic acrescido do nome do arquivo (pasta de trabalho) do Excel aberto.

Na barra de menu, vemos algumas opções comuns e outras nem tanto. definiremos cada uma delas:



• Arquivo – menu com opções comuns, tais como, salvar arquivo, importar ou exportar arquivo e fechar editor, voltando para o Excel;

• Editar – menu com as opções copiar, recortar, colar, localizar, substituir, entre outras opções a que você já está acostumado, também possui algumas opções específicas do editor como listar constantes, listar propriedades, entre outras;

• Exibir – neste menu você consegue exibir vários objetos próprios do editor, tais como, o objeto Verificação imediata, o objeto Project Explorer, ente outros;

• Inserir – este menu será utilizado quando quisermos inserir novos módulos, procedimentos ou formulários ;

• Formatar – aqui você pode formatar alinhamento, espaçamento, dimensionamento, ente outros tipos de formato.;

• Depurar – as opções deste menu são utilizadas quando você deseja verificar o funcionamento de um código feito, vamos estudar mais à frente como se depura um procedimento ou função;

• Executar – neste menu você tem a opção de executar alguma rotina feita ou parar a execução da mesma;

• Ferramentas – menu com opções próprias do editor também, por exemplo, você consegue acessar a lista de macros que existem em sua pasta de trabalho;

• Suplementos – gerenciador de suplementos do editor – os suplementos são ferramentas personalizada que adicionam recursos ao Visual Basic.

A BARRA DE FERRAMENTAS PADRÃO

A barra de ferramenta principal do editor do Visual Basic é a padrão, que é mostrada abaixo:

1 – Exibir Microsoft Excel – retorna para o Excel;

2 – Inserir Procedimento, Módulo ou Form – insere uma área de trabalho para que possamos programar;

3 – Salvar – grava o que está sendo feito;

4 – Recortar – move o trecho de código selecionado para que, mais tarde, seja colado;

5 – Copiar – copia o trecho de código selecionado para que, mais tarde, seja colado;

6 – Colar – cola em algum lugar especificado o trecho de código recortado ou copiado;

7 – Localizar – procura por palavras, expressões ou comandos dentro dos códigos;

8 – Desfazer – desfaz alguma ação executada;

9 – Refazer – refaz alguma ação executada;

10 – Executar – executa o trecho de código descrito;



11 – Interromper – interrompe (pausa) alguma execução em andamento;

12 – Redefinir – para a execução em andamento;

13 – Modo de criação;

14 – Project Explorer – exibe ou esconde a janela do Project Explorer;

15 – Propriedades – exibe ou esconde a janela de Propriedades;

16 – Pesquisador de objeto – exibe ou esconde a janela do Object Browser;

17 – Caixa de ferramentas – exibe ou esconde a barra de caixa de ferramentas (a ser utilizada nos forms);

18 – Ajuda do Mircosoft Visual Basic;

19 – Posição onde está o cursor – linha e coluna.

O PROJECT EXPLORER

O Project Explorer é uma janela que exibe uma lista hierárquica de todos os itens contidos e referenciados em cada projeto que está aberto no Editor do Visual Basic.

Os elementos da janela do Project Explorer são:

• Botão Exibir código: exibe a janela de código (área de trabalho do editor) para que você possa gravar e editar código associado a algum item selecionado.

• Botão Exibir objeto: exibe a janela Objeto para o item selecionado, um documento ou um form.

• Botão Alternar pastas: Oculta e mostra as pastas de objetos enquanto exibe os itens individuais contidos nelas.

Além dos botões acima a janela do Project Explorer contém vários itens que podem ser:

• Projeto: sempre que trabalhamos no editor do Visual Basic estamos trabalhando com um projeto (VBAProject);

• Objetos do Excel: todas as planilhas existentes na pasta de trabalho (Plan1, Plan2, Plan3) e ainda um objeto que representa a pasta de trabalho inteira (EstaPasta_de_Trabalho);

• Módulos: todos os módulos existentes, cada macro que você cria é inserida em um módulo diferente.

A JANELA DE CÓDIGOS

A janela de códigos é a área de trabalho do editor. É nela que você irá inserir o seu código, seja uma função nova que estará criando, seja uma macro que esteja editando, ou outro tipo de código.

Por exemplo, o código a seguir pertence a uma macro criada para formatação de células:



ENTENDENDO UM POUCO OS CÓDIGOS

Você observará que toda macro que você criar será criada com o nome de Sub, note que na imagem anterior o nome da macro é Formatar, esse nome aparece logo no início – Sub Formatar( ) e no fim do código da macro temos – End Sub. Dessa forma a macro – seqüência de comandas é delimitada.

Dentro da macro na primeira parte vem algumas linhas descritivas. Essas linhas são precedidas pelo símbolo apóstrofe (‘). Toda linha precedida por apóstrofe significa que é um comentário e não é executada, desta forma, você pode escrever qualquer coisa após o apóstrofe pois será considerado um comentário.

Neste caso específico, temos na primeira linha de comentário o nome da macro, na segunda linha temos a descrição que informamos na criação da macro e na terceira linha de comentário a tecla de atalho que foi definida para a macro.

Depois destes comentários seguem os comandos que serão realizados ao executarmos a macro.

Observações:

• Você pode inserir um comentário em qualquer lugar do código;

• Cada linha de código (linha que não é precedida de apóstrofe) do editor é um comando a ser executado.

A JANELA VERIFICAÇÃO IMEDIATA

Abaixo da janela do código temos a janela Verificação Imediata que será utilizada quando formos depurar algum código.



CRIANDO E EDITANDO MACROS

CRIANDO UMA MACRO

Conforme já visto, para criar a macro, vamos em Ferramentas / Macro / Gravar nova macro.

Vamos trabalhar com duas macros. Uma será chamado Formatar. Esta macro terá como tecla de atalho a letra f (CTRL + f). Ela será salva nesta pasta de trabalho e a descrição será: Macro para formatar a célula com fonte Arial, tamanho 14, negrito e sublinhado.

O nome da outra macro será Formatar_2. Esta macro não terá tecla de atalho. Ela será salva nesta pasta de trabalho também e a descrição será: Macro para formatar a célula com fonte Comic Sans MS, tamanho 14 e cor azul.

VISUALIZANDO O CÓDIGO DAS MACROS

Vamos agora compreender os códigos gerados para cada uma das macros. Isso é feito selecionando Ferramentas / Macro / Editor do Visual Basic.

No Project Explorer existem dois módulos. O conteúdo do Módulo1 é a macro Formatar e o conteúdo do Módulo2 é a macro Formatar_2.

Para visualizar o código de cada um dos módulos, damos um clique duplo sobre o módulo a ser visualizado e o código aparecerá na janela ao lado ou ainda damos um clique com o botão direito do mouse sobre um dos módulos e escolhemos a opção Exibir código.

Quando clicamos com o botão direito do mouse sobre algum módulo outras opções aparecem além da opção Exibir código.

A opção Inserir, serve para inserir um novo módulo, form ou procedimento.

A opção Remover Módulo, serve para excluir o módulo selecionado, com isso sua macro será removida também, caso o conteúdo do módulo seja uma macro. Ao remover um módulo o editor pergunta se você antes deseja exportá-lo, caso opte por sim, você estará removendo este módulo deste arquivo e enviando para outro.

VISUALIZANDO O CÓDIGO DAS MACROS

Vamos analisar o conteúdo dos códigos das duas macros:

Macro 1

Sub Formatar() With Selection.Font .Name = "Arial" .FontStyle = "Negrito" .Size = 14 .Strikethrough = False .Superscript = False .Subscript = False .OutlineFont = False .Shadow = False .Underline = xlUnderlineStyleDouble .ColorIndex = xlAutomatic End With



End Sub

Macro 2

Sub Formatar_2() With Selection.Font .Name = "Comic Sans MS" .FontStyle = "Normal" .Size = 14 .Strikethrough = False .Superscript = False .Subscript = False .OutlineFont = False .Shadow = False .Underline = xlUnderlineStyleNone .ColorIndex = 5 End With End Sub

Note que alguns comandos são comuns nas duas macros. Vamos verificar esses comandos em comum primeiramente.

Instrução Sub: declara o nome, os argumentos e o código que formam o corpo de um procedimento. Toda macro inicia por Sub Nome() e termina com End Sub, onde Nome é o nome dado à macro.

Instrução With: executa uma série de instruções em um objeto. Neste caso, o objeto selecionado é o Selection.Font, isto significa que todos os comandos entre o With Objeto e o End With serão feitos com este objeto.

Observe que alguns comandos dentro da instrução With se repetem nas duas macros, alguns com valores diferentes, outros com valores iguais.

O comando .Name define a fonte a ser utilizada.

O comando .FontStyle define o estilo de fonte a ser utilizado.

O comando .Size define o tamanho da fonte a ser utilizado.

O comando .Strikethrough define se a fonte terá o efeito tachado ou não. Os valores possíveis são true (efeito tachado ativo) e False (efeito tachado inativo). O mesmo ocorre para os comandos .Superscript e .Subscript que definem os efeitos sobrescrito e subscrito, respectivamente.

O comando .Underline define o sublinhado da fonte, os tipos mais comuns de sublinhados são: (sem sublinhado), xlUnderlineStyleSingle (sublinhado simples) e xlUnderlineStyleDouble (sublinhado duplo).

OBJETOS, MÉTODOS E PROPRIEDADES

O comando .ColorIndex define a cor da fonte, cada cor de fonte é representada por um número inteiro, por exemplo, a cor azul é representada pelo número 5.

Estes comandos, nada mais são, do que propriedades da formatação de fonte, por isso são tidos como propriedades.

Para entendermos bem o funcionamento da programação no Visual Basic, devemos saber o seguinte: sempre quando trabalhamos com algum elemento do Excel, estamos trabalhando com um objeto, por exemplo, fonte, parágrafo, célula, entre outros. Cada objeto possui métodos que são as ações que esses objetos podem realizar e cada objeto possui propriedades que são as características do objeto.



Desta forma, sempre quando formos trabalhar com macros, estaremos utilizando objetos, propriedades e métodos.

A grande vantagem é que, ao executarmos as ações que uma macro fará, o próprio Excel grava todo o código para nós. Nós somente iremos trabalhar com os códigos de uma macro se quisermos alterar alguma coisa no código sem ter que fazer todo o processo de gravação de uma macro novamente.

EDITANDO MACROS

Agora que você já identificou os principais comandos das duas macros, podemos editar qualquer uma das macros, em nosso exemplo faremos isso com a macro Formatar.

Na linha de código onde está o nome da fonte a ser utilizada vamos trocar de Arial para Comic Sans MS.

Na linha de código onde está o tamanho da fonte, vamos trocar de 14 para 16.

Na linha de código onde está o sublinhado, vamos trocar de duplo para simples.

Na linha de código onde está a cor, vamos trocar de automática para 3 (cor vermelha).

Depois disso, basta clicar no botão Salvar do editor e testar a macro no Excel.

O código da macro ficou assim:

Sub Formatar() With Selection.Font .Name = "Comic Sans MS" .FontStyle = "Negrito" .Size = 16 .Strikethrough = False .Superscript = False .Subscript = False .OutlineFont = False .Shadow = False .Underline = xlUnderlineStyleSingle .ColorIndex = 3 End With End Sub

CRIANDO UMA MACRO COM CÉLULAS SELECIONADAS

Veja a planilha a seguir. Faremos uma macro para formatar essa tabela.

Para este exemplo, utilizaremos uma macro chamada Formatar_Tabela. Ela não terá tecla de atalho. A macro será gravada nesta pasta de trabalho.

A descrição da macro será: Macro para formatar uma tabela com fontes, bordas e sombreamentos.



Para a gravação da macro, façamos o seguinte:

• Selecionaremos da célula A3 até a célula D8;

• Vamos em Formatar / AutoFormatação;

• Na janela que se abre, escolhemos a opção Clássico 3;

• Ainda com as células selecionadas, vamos no botão Bordas, na barra de ferramentas Formatação e selecionamos a opção Todas as bordas.

Paramos a gravação da macro.

A macro utilizada na tabela definida no início fica assim:

TESTANDO A MACRO PARA FORMATAR TABELA

Para testar a macro criada anteriormente, vamos criar outra planilha conforme abaixo:

Nem precisamos selecionar a tabela a ser formatada, a própria macro faz isso e formata a tabela da forma que havíamos definido.

Mas isso nem sempre é bom!

Vejamos na próxima planilha Turismo.



Ao executarmos a macro novamente, observamos que não foi toda a tabela que ficou formatada, somente uma parte dela. Mesmo se você selecionar toda a tabela, somente serão formatadas as células do intervalo A3:D8.

Isso acontece porque ao gravar a macro, gravamos também a seleção de células que foi feita, ou seja, a macro funciona em qualquer planilha da pasta de trabalho, porém somente formata a região das células A3 até D8.

Para verificarmos isso vamos abrir a macro para edição. Lembrando-se que, para isso vamos em Ferramentas / Macro / Macros. Selecionamos a macro Formatar_Tabela e clicamos no botão Editar. Esta é outra forma de se abrir o editor do Visual Basic, abrindo-o na macro que deseja visualizar ou alterar.

Observe que o primeiro comando da macro é:

Range("A3:D8").Select

Este comando define que a formatação da tabela será feita no intervalo das células A3 até D8. teremos que mudar isso para que a formatação de nossa tabela fique genérica.

Ao invés de utilizar o comando Range("A3:D8").Select, podemos trocá-lo por este outro:

Selection.CurrentRegion.Select

Este comando indica que a formatação deverá ser feita no intervalo de células selecionadas. Neste caso, para executar a macro daqui por diante será preciso selecionar as células que deseja formatar antes de executar a macro.

A macro agora somente funciona nas células selecionadas da planilha.

Testando isso na planilha Turismo, antes de executar a macro, selecionamos da célula A3 até D12. Veja que toda a tabela foi formatada.



EVITANDO ERROS COM MACROS

Toda macro feita, mesmo testada corretamente e pronta para ser utilizada, dependendo da ação executada pelo usuário, pode gerar algum erro.

Por exemplo, esta macro Formatar_Tabela, caso selecionemos uma célula vazia de alguma planilha e executamos a macro, ocorre o seguinte erro:

Este erro ocorre porque não foi selecionado nenhum intervalo de células para ser formatado e o comando AutoFormatação que está inserido na macro está esperando por um intervalo de seleção.

Observe que a janela do erro possui dois botões ativos Fim e Depurar.

Se você clicar no botão Depurar, você será levado para o código da macro que gerou o erro.

Se você clicar no botão Fim, simplesmente sra finalizado o processo.

Veja também que existe um número inteiro indicando o erro ocorrido. Para cada erro ocorrido existe um número diferente. Para esse erro o número inteiro que trata disso é o 1004.

TRATANDO O ERRO

Caso selecionamos no botão Depurar, somos levados para o editor do Visual Basic. A segunda linha de código fica marcada de amarelo. É aí que está sendo gerado o erro, ou seja, logo quando se utiliza a AutoFormatação.



Como já sabemos o que ocasionou o erro, não precisamos depurar o código, vamos então parar a execução da macro. Para isso, clicamos no botão Redefinir que está na barra de ferramentas Padrão do editor.

Para tratar este erro vamos utilizar o objeto de tratamento de erros – o objeto Err. Este objeto contém informações sobre os erros gerados em tempo de execução, ou seja, erros que somente acontecem quando as macros são executadas.

Como pode ocorrer qualquer tipo de erro e em qualquer lugar do código, vamos inserir a seguinte instrução no início do código, antes de qualquer comando:

On Error Resume Next

Esta instrução simplesmente adia o tratamento do erro.

No final da macro, após o último comando da macro, vamos inserir o tratamento para este erro específico.

If Err.Number = 1004 Then Selection.Clear MsgBox "Você precisa selecionar um intervalo de células." End If

Estes comandos testam se foi gerado o erro de número 1004. Se este erro foi gerado limpa qualquer formatação feita na célula e emite uma mensagem de erro amigável para o usuário.

O código da macro fica assim:

Sub Formatar_Tabela() On Error Resume Next ( … ) – comandos da macro If Err.Number = 1004 Then Selection.Clear MsgBox "Você precisa selecionar um intervalo de células." End If End Sub

Observação: MsgBox é uma instrução do Visual Basic que mostra uma caixa de mensagem na tela para o usuário, mais à frente aprenderemos mais sobre MsgBox.

CRIANDO MACROS COM VÁRIOS OBJETOS E FUNÇÕES DO EXCEL



Em nosso próximo exemplo de macro, iremos construir um pequeno sistema que lerá dados de uma tabela com vários dados e esses dados serão filtrados de acordo com o filtro que estabelecermos.

Construiremos mais de uma macro na pasta de trabalho para isso.

Para a realização desse exemplo, teremos que ter algumas noções avançadas de Excel.

Utilizaremos os seguintes recursos do Excel:

• Filtro Avançado: recurso que se encontra no menu Dados, opção Filtrar. Tem a função de filtrar, de maneira rápida, um subconjunto de dados em uma tabela, dessa forma os dados ficam fáceis de serem localizados e trabalhados. O filtro avançado é utilizado quando temos critérios avançados para o filtro.

• Inserir Caixa de Diálogo: este recurso é bastante utilizado quando desejamos que apareça para o usuário uma caixa de diálogo para que ele escolha ente uma opção ou outra, ou informe algum dado, ou seja, para que ele interaja com o Excel de forma simples e rápida. Para inserir uma caixa de diálogo na pasta de trabalho, você deverá clicar com o botão direito sobre qualquer guia da planilha e selecionar a opção inserir, aparecerá uma janela para que você escolha a opção desejada.

• Caixa de Combinação: objeto que se encontra na barra de ferramentas Formulários. É utilizada quando temos uma lista de valores que serão escolhidos pelo usuário para que seja realizado algum filtro, por exemplo.

• Botões de Comando: objeto que também se encontra na barra de ferramentas Formulários. São botões que poderão ser clicados pelo usuário para efetuarem alguma ação – macro.

Utilizaremos estes recursos listados e ainda os recursos das macros.

CONHECENDO A PASTA DE TRABALHO

O arquivo que trabalharemos possui três planilhas, dispostas da seguinte forma:

• Planilha 1: Empresas – listagem com o código, nome e valores das empresas que são usados na planilha principal. Esta planilha possui uma tabela com os dados das empresas. Foi definido um nome para a tabela (região das células A3 até C9). O nome desta tabela é “Empresas”.

• Planilha 2: Auxiliar – planilha auxiliar onde serão armazenados alguns valores a serem utilizados pelos filtros a serem feitos.



• Planilha 3: Ações – planilha principal, é onde se encontram os dados a serem trabalhados. Será nesta planilha que iremos inserir nossos controles para as macros. Nesta planilha já foi utilizado a função PROCV na coluna Empresa e na coluna Valor, para trazer os valores referentes ao código da empresa digitado na coluna Código. Na coluna Total foi utilizado uma fórmula para multiplicar o valor pela quantidade.

Primeiramente, vamos trabalhar todo o arquivo para depois iniciarmos o processo de gravação da macro.

CONSTRUINDO A CAIXA DE DIÁLOGO

Vamos inserir a caixa de diálogo no arquivo: para isso clique com o botão direito do mouse sobre qualquer guia de planilha na parte inferior do Excel e selecione a opção Inserir. Aparecerá a caixa de diálogo abaixo:



Para a construção da caixa de diálogo selecionamos a opção Caixa de diálogo do MS Excel 5.0. Feito isso dê Ok.

Aparecerá uma nova planilha em sua pasta de trabalho, chamada Caixa de diálogo1.

Podemos formatar a caixa, para que ela possa ter um título e ainda podemos diminuir o tamanho da mesma (altura e/ou largura), para que depois possamos inserir o controle a ser utilizado nela.

Iremos inserir um controle na caixa. À direita da caixa está a barra de ferramentas Formulários. Caso esta barra não esteja visível, nós a selecionamos indo no menu Exibir, opção Barra de Ferramentas.

Nesta barra, selecionamos o controle Caixa de combinação.

Agora que a caixa de diálogo está pronta temos que fazê-la funcionar. Primeiramente, vamos fazer os nomes das empresas aparecerem na caixa de combinação.

Para isso, clicamos com o botão direito do mouse sobre a caixa de combinação desenhada sobre a caixa de diálogo.

Selecionamos a opção Formatar controle. A janela formatar controle será utilizada para informarmos ao Excel, quais os dados que aparecerão na caixa de diálogo (de onde eles virão) e para onde irá o dado que for selecionado pelo usuário.

A figura abaixo, mostra a janela Formatar controle, com a guia Controle selecionada, é nesta guia que iremos trabalhar.



A caixa de combinação deverá ser formatada com os seguintes valores:

• Intervalo de entrada: estes são os dados que aparecerão na caixa.

• Vínculo da célula: este parâmetro servirá para armazenar o dados (no caso – o nome da empresa) a ser escolhido pelo usuário.

• Linhas suspensas: este parâmetro informa quantas linhas a caixa de diálogo terá, o padrão é o número 8.

Para testar a caixa de diálogo, selecionamos na barra de ferramentas Formulários, o controle Executar caixa de diálogo. Ele é o último controle da barra de ferramentas.

Clicamos nele e a caixa de diálogo aparecerá como surgirá para o usuário.

Qualquer empresa que for escolhida na caixa de combinação de nossa caixa de diálogo terá seu índice na célula escolhida para ser vínculo da célula, porém, para melhorarmos a performance de nosso pequeno sistema, vamos fazer o seguinte: de acordo com o índice da célula da empresa escolhida iremos buscar o nome da empresa na planilha Empresas e colocá-lo em outra célula.



Então, selecionamos a célula vínculo. Vamos ao menu Inserir, opção Função. Na caixa de diálogo Inserir função, selecionamos a categoria Procura e referência. Feito isso, selecionamos a função Índice.

Na caixa seguinte, de nome Selecionar argumentos, escolhemos a primeira opção: matriz;núm_linha, núm_coluna.

Preenchemos os argumentos da seguinte forma:

• Matriz: intervalo das células que contém os dados que desejamos.

• Núm_linha: célula índice.

• Núm_coluna: número da coluna que terá seu valor retornado.

CRIANDO A MACRO FILTRAR

Selecionamos a planilha Ações e clicamos em qualquer célula no intervalo de células que contém dados.

Vamos iniciar o processo de gravação de macro. Vamos à opção Ferramentas / Macro / Gravar nova macro. Daremos nome à macro de Filtrar. A descrição da mesma será: Macro para realizar um filtro avançado no conjunto de dados da planilha Ações.

Os passos para gravação da macro são:

• Selecionar Dados / Filtrar / Filtro Avançado.

• Na caixa de diálogo que aparecerá, deixar selecionada a opção Filtrar a lista no local.

• Verifique se o Intervalo da lista selecionado está o intervalo de células onde estão os dados da planilha..

• Em Intervalo de critérios, selecione as células A1:A2 da planilha Auxiliar.

Criamos nossa primeira macro que executa a ação de filtrar os dados de acordo com uma empresa.

CRIANDO A MACRO EXIBIR_TUDO

Agora que criamos a macro Filtrar, vamos criar uma nova macro que terá o efeito contrário ao da macro Filtrar ou seja servirá para exibir todos os dados da lista da planilha Ações.

Lembre-se de ficar com alguma célula da planilha Ações selecionada, alguma célula que possua dado da tabela.

Vamos à opção Ferramentas / Macro / Gravar nova macro. Daremos nome à macro de Exibir_Tudo. A descrição da mesma será: Macro para mostrar todos os dados da tabela de Ações. Clique em Ok.

O passo para gravação da macro é:

• Vamos em Dados / Filtrar / Mostrar Todos.

CRIANDO A MACRO EXIBIR_CAIXA



Agora, iremos criar nossa última macro.

Selecionamos a planilha onde está a caixa de diálogo.

Vamos à opção Ferramentas / Macro / Gravar nova macro. Daremos nome à macro de Exibir_Caixa. A descrição da mesma será: Macro para exibir na tela a caixa de diálogo para escolha da empresa. Clique em Ok.

Os passos para gravação da macro são:

• Selecionamos o controle Executar caixa de diálogo na barra de ferramentas Formulários.

• Na caixa de diálogo, escolhemos alguma empresa.

• Clicamos em Ok, na caixa de diálogo.

Simplesmente, fizemos uma macro que abre a caixa de diálogo para seleção de alguma empresa.

VINCULANDO AS MACROS AOS CONTROLES

Retornando à planilha Ações, se a barra de ferramentas Formulários não estiver visível nesta planilha, faça-a aparecer marcando a opção Exibir / Barra de Ferramentas / Formulários.

Vamos inserir dois botões no alto da planilha.

Selecionamos o controle Botão na barra de ferramentas Formulários, depois desenhamos o botão abaixo do título da planilha.

Ao terminar o desenho, verificamos que a caixa de diálogo Atribuir macro aparece. Selecionamos a macro Exibir_Caixa, para o primeiro botão. O botão ficou atrelado à macro Exibir_Caixa. Modificamos o nome do botão para Filtrar.

Agora, vamos criar outro botão ao lado deste.

Selecionamos novamente o controle Botão na barra de ferramentas Formulários, depois desenhamos o botão ao lado direito do botão Filtrar.

Atribuímos a este botão a macro Exibir_Tudo. O nome do botão será Exibir.

Agora, falta atribuirmos a macro Filtrar a algum controle. Vá até a planilha onde está a caixa de diálogo e clicando com o botão direito do mouse no botão Ok, da caixa de diálogo, selecionamos a opção Atribuir macro e escolhemos a macro Filtrar.

Pronto, os controles com as macros atribuídas estão criados.





INTRODUÇÃO AO VBA

VBA - VISUAL BASIC FOR APPLICATION

O Visual Basic for Applications é uma linguagem de programação disponível no Pacote Office para ser utilizada em conjunto com alguma aplicação do Microsoft Office, como, por exemplo, no Access, no Word e, no Excel, como em outras aplicações.

Dependendo da ação que queremos executar, precisaremos conhecer um pouco de lógica de programação e da própria sintaxe da linguagem VBA para criarmos procedimentos e funções a serem utilizados em nossas pastas de trabalho.

Vamos aprender a sintaxe da linguagem VBA e também, em paralelo, um pouco de lógica de programação. Pois, o intuito neste curso não é formar programadores, mas sim, usuários finais que, com algum conhecimento de Macros e VBA, podem criar pastas de trabalho em alto nível de desenvolvimento.

Iremos dividir o estudo de VBA da seguinte forma:

• Estrutura do VBA

• Variáveis;

• Tipos de variáveis;

• Declaração de variáveis;

• Constantes;

• Módulos;

• Procedimentos;

• Funções;

• Estruturas de controle condicionais;

• Estruturas de controle de repetição;

• Interação com o usuário – caixas de mensagem.

• Objetos e Eventos – propriedades e métodos.

PROGRAMAÇÃO EM VBA

Já vimos que, para programarmos qualquer coisa em VBA, no Excel, é necessário acessarmos a opção Ferramentas / Macro / Editor do Visual Basic.

Acessando esta opção podemos estar criando e editando códigos da linguagem, sejam códigos de uma macro ou de uma função definida pelo usuário.

Veremos os fundamentos da linguagem VBA, sua estrutura fundamental e os principais elementos da linguagem.



O VBA – Visual Basic for Application é uma linguagem de programação baseada na conhecida linguagem Basic. Ela foi concebida para funcionar em conjunto com diferentes aplicações de forma a potenciar a robustez das mesmas. Você pode utilizar a linguagem VBA nos aplicativos do Microsoft Office, como o Word, Access e o Excel.

Ela se enquadra nos ambientes de programação baseados no processamento de seqüência de eventos. Por exemplo, você pode associar tarefas a serem executadas a determinado botão, dessa forma, quando o botão for acionado, as tarefas a ele associadas serão executadas.

VARIÁVEIS

Variáveis são espaços alocados na memória do computador específicos para cada programa que podem ser modificadas durante a execução do código deste programa.

Cada variável tem um nome que a identifica unicamente no escopo a que ela está ligada. A variável pode possuir um tipo ou não. Associar um tipo a uma variável seria dizer que a variável irá receber durante a execução do programa valores inteiros, variável do tipo inteiro; ou senão valores de data e hora, variável do tipo data; e, assim por diante.

A vantagem de se especificar um tipo a uma variável é que já fica definido que a variável irá receber esse tipo de valor durante toda a execução do código daquele programa. Isso facilita na resolução de erros que podem ocorrer com valores associados incorretamente a variáveis, como, por exemplo, uma variável recebe um número decimal e depois recebe um valor texto.

Os nomes de uma variável precisam ser iniciados com algum caractere. Podem conter dígitos, só não pode começar pro dígito. Não podem conter espaços em branco. Não podem conter caracteres inválidos, como, +, &, ^, *, entre outros. Variáveis não podem receber nomes de palavras-chaves da linguagem. O tamanho do nome de uma variável são 255 caracteres.

Exemplos de nomes de variáveis:

Variáveis inválidas Explicação

1num Variáveis não podem começar por dígitos

num 9 Variáveis não podem conter espaços em branco

data+hora Variáveis não podem conter caracteres inválidos

dim Variáveis não podem ser palavras-chaves do VBA

Variáveis válidas Explicação

num1 Inicia-se por caractere e não há espaço em branco

data_hora A separação é feita por _ esse caractere é válido; já o – (hífen) não é válido

texto Variável comum, não é palavra-chave do VBA; não é palavra reservada

TIPOS DE VARIÁVEIS

Os tipos de variáveis encontrados no VBA são:



Variant – tipo genérico; quando você não define o tipo da variável na declaração da mesma, ela recebe o tipo variant, ou seja, pode ser qualquer tipo no decorrer do programa.

Boolean – tipo em que a variável somente recebe dois tipos de valores: verdadeiro (True) ou falso (False ).

Byte – tipo inteiro onde o valor assumido pela variável varia no intervalo de 0 até 255.

Integer – tipo inteiro onde o valor assumido pela variável varia no intervalo de -32.768 até 32.767

Long – tipo inteiro onde o valor assumido pela variável varia no intervalo de -2.147.483.648 até 2.147.483.647

Single – tipo decimal onde o valor assumido pela variável varia no intervalo de -3,402823E38 até -1,401298E-45 (para valores negativos) e 1,401298E-45 até 3,402823E38 (para valores positivos).

Double – tipo decimal onde o valor assumido pela variável varia no intervalo de -1,79769313486232E308 até -4,94065645841247E-324 (para valores negativos) e 4,94065645841247E-324 até 1,79769313486232E308 (para valores positivos).

Currency – tipo decimal onde o valor assumido pela variável varia no intervalo de -922.337.203.685.477,5808 até 922.337.203.685.477,5807 (utilizado para valores monetários).

Decimal – tipo decimal onde o valor assumido pela variável varia no intervalo de +/-79.228.162.514.264.337.593.543.950.335 (sem casas decimais) e +/-7,9228162514264337593543950335 (com casas decimais)

Date – tipo data onde o valor assumido pela variável varia no intervalo de 01/01/100 até 31/12/9999

String – tipo texto onde o valor assumido pela variável varia no intervalo de 1 até aproximadamente 2 bilhões de caracteres (65.400 se tamanho fixo)

Object – tipo genérico para referência a objetos.

DECLARAÇÃO DE VARIÁVEIS

A declaração de variável é importante para que você não cometa erros ao construir algum código de programação, conforme já dito anteriormente, inserir um valor inteiro para uma variável e depois, inserir, para esta mesma variável um valor string (texto).

Declarando variáveis fica mais fácil uma futura manutenção no código. Além de se declarar a variável e definir seu tipo, você poderá indicar com um comentário à frente o que e para que servirá a variável.

O Editor do Visual Basic possui duas formas de trabalhar no que diz respeito a variáveis. Você pode definir se deseja que seja obrigatória a declaração de todas as variáveis ou não.

Para informar ao Editor do Visual Basic que a declaração de variáveis é obrigatória, você precisa selecionar no menu Ferramentas / Opções e marcar a opção Requer declaração de variáveis.

Fazendo isso, toda vez que você criar um módulo para desenvolvimento de algum código, para alguma rotina a ser executada aparecerá no alto da tela do módulo as palavras chaves:

Option Explicit

Verifique isso, selecionando na opção Inserir / Módulo.



Note que no módulo já vem as palavras-chaves que indicam que a declaração de variáveis é obrigatória.

A declaração de variáveis depende da utilização que você fará das variáveis dentro de seu código.

Caso você queira que a variável seja visível em todos os módulos e durante toda a execução do programa, você deverá utilizar a instrução Public.

Caso você queira que a variável seja visível apenas no próprio módulo e durante toda a execução do programa, você deverá utilizar a instrução Private. Usando essa instrução em algum módulo você não conseguirá acessar essa mesma variável em outro módulo.

Caso você queira que a variável seja visível apenas no próprio procedimento e durante a sua execução, você deverá utilizar a instrução Dim.

Abaixo seguem alguns exemplos de declaração de variáveis:

CONSTANTES

Constantes são valores fixos que podem ser utilizados no programa.

Suponhamos que você deseja fazer um programa onde será preciso algumas mensagens pré-definidas em vários lugares do código.

Você pode declarar uma constante para cada constante e no momento que precisar, utilizar a constante adequada.



Você pode ainda querer definir constantes para valores pré-definidos, por exemplo, uma constante Masculino com valor 1 e uma constante Feminino para valor 2, seriam constantes utilizadas para alguma variável do tipo Sexo.

Para declarar uma constante no código, você utiliza a palavra chave Const.

Exemplo:

Const Masculino = 1, Feminino = 2

Como nas variáveis você pode separar as constantes por vírgula.

Como nas variáveis também, você pode definir que a constante será utilizada em todos os módulos ou somente em um. Por padrão, a constante é Private.

Exemplo:

Public Const Mensagem1 = “Seja bem vindo”

Private Const Mensagem2 = “Obrigado”

OPERADORES

Para realizarmos as diversas operações entre as variáveis precisamos utilizar os operadores contidos no VBA. Os operadores são:

Aritméticos

+ Adição

- Subtração

* Multiplicação

/ Divisão decimal (19 / 2 = 9,5)

\ Divisão inteira (19 \ 2 = 9)

Mod Resto da divisão inteira (19 Mod 2 = 1)

Exponenciação

Texto

& Concatenação (“um” & “dois” = “umdois”



Relacionais

= Igual a

<> Diferente de

> Maior que

>= Maior ou igual a

< Menor que

<= Menor ou igual a

Lógicos

And E lógico

Or Ou lógico

Not Negação

Os operadores, quando utilizados, têm algumas regras de precedência a serem seguidos.

As precedências dos operadores são:

Operador Operação

Exponenciação

* , / Multiplicação e divisão

\ Divisão inteira

Mod Resto da divisão inteira

+ , - Adição e subtração

& Concatenação

= , > , < , <> , >= , <= Relacionais

And, Or, Not Lógica

A ESTRUTURA DO VBA

O Editor do Visual Basic, como já deve ter percebido, é dividido em módulos. Podemos criar nossas rotinas em módulos diversos ou todas em um único módulo.

Quando criamos uma macro, o código da mesma localiza-se dentro de um módulo.

O módulo, então, é o local onde armazenamos os códigos de nossas rotinas.



As rotinas que criamos em nossos códigos são chamadas de procedimentos e são de dois tipos procedimentos subs e procedimentos functions.

PROCEDIMENTOS

Quando certa seqüência de instruções de um código (programa) é executada repetidamente em diferentes partes do código, deve ser criado um procedimento que substitua e concentre num único local a seqüência de instruções relativa à rotina a ser executada.

Daí o procedimento ser conhecido como rotina.

Imagine que sempre você precisa testar os erros em suas macros, como já fizemos em tópicos anteriores. Ao invés de criarmos os códigos de tratamento de erros em cada macro, podemos criar um procedimento genérico para tratamento de erros de macros e utilizar esse procedimento em cada código da macro. Desta forma estaríamos racionando o trabalho.

O uso de procedimentos aumenta a produtividade do programador, pois diminui o tamanho global do código a escrever, facilita a edição da seqüência de instruções relativa à tarefa e minimiza a potencial ocorrência de erros, pois, se você reescreve o código várias vezes, a chance de errar é bem maior.

Imagine que depois de tudo feito, uma regra de negócio é modificada, imagine o trabalho que não daria se você tivesse que trocar essa regra de negócio em cada parte do código que escreveu, seria muito mais trabalhoso e você poderia acabar esquecendo algum lugar.

Existem dois tipos de rotinas:

• Sub;

• Function.

SUBS E FUNCTIONS

A diferença primordial de subs e functions é que um procedimento - sub não retorna nenhum valor, já uma função – function retorna um valor definido.

Existem outras diferenças ente subs e functions, a saber:

• Como a function retorna algum valor é necessário (não obrigatório) que a mesma seja tipada, isto é, seria interessante definirmos um tipo para o valor retornado pela função;

• Uma function sempre deverá ser atribuída a alguma variável, um sub não é atribuído a nada, ele simplesmente é utilizado no código;

• Ambos, subs e functions possuem argumentos (assunto a ser tratado à frente).

A sintaxe de um sub é:

Sub NomedoSub (argumentos)

Comandos

End Sub

A sintaxe de uma function é:



Function NomedaFunction (argumentos) As Tipo

Comandos

End Function

ARGUMENTOS DE SUBS E FUNCTIONS

Os argumentos nas rotinas são os chamados parâmetros que devem ser passados para o procedimento ou função para que os devidos cálculos e/ou ações sejam executados.

Um procedimento ou função pode possuir ou não argumentos, dependendo da ação a ser executada por ele.

Vamos começar nosso estudo de argumentos utilizando as funções que já são definidas no próprio Excel e que utilizam parâmetros e outras não.

Você já usou a função Se? A função Se é uma função que se localiza na categoria lógica do Excel e ela é utilizada quando temos um teste lógico a ser feito podendo retornar um valor verdadeiro ou um valor falso.

Por exemplo, suponhamos que de acordo com as notas de cada aluno de uma turma em determinada escola, se o aluno tirou nota maior ou igual a 70, ele foi aprovado, senão ele foi reprovado.

Se você utilizar a função Se do Excel par resolver esse problema, teremos o seguinte:

OS ARGUMENTOS DE UMA ROTINA

Note que a função Se possui 3 argumentos (3 parâmetros). O primeiro parâmetro é o teste lógico, o segundo parâmetro é o valor a ser retornado caso o resultado do teste seja verdadeiro e o terceiro parâmetro é o valor a ser retornado caso o resultado do teste seja falso.

Observação: Os valores dentro de cada argumento são apenas demonstrativos.

Da mesma forma que a função Se possui 3 argumentos, a função Hoje, da categoria Data e Hora, não possui argumento nenhum.



Veja a tela a seguir:

CONSTRUINDO PROCEDIMENTOS

Para construir um procedimentos, entramos no Editor do Visual Basic e inserimos um módulo: Inserir / Módulo.

Vamos construir inicialmente um procedimento que não possui parâmetro nenhum.

O procedimento que iremos construir é simples: iremos mostrar um número de mensagens na tela para o usuário poder visualizar.

Alguns comandos utilizados neste procedimento ainda não foram estudados, serão vistos mais à frente no curso, mas copie o código como acima para que possamos testar a utilização de procedimentos.

Observe também que podemos colocar comentários em várias regiões de nosso código. O Visual Basic considera que tudo que está pós um apóstrofe ‘ é um comentário, por esse motivo que podemos ter comentários logo no início da linha ou na mesma linha de um código, após o código.

Este procedimento é bastante simples. Inicialmente declaramos as variáveis e depois fazemos com que a variável msg receba a mensagem a aparecer para o usuário. Depois utilizamos o comando for para fazer o seguinte, para num (que é outra variável) variando de 1 até 3 mostre a mensagem na tela.

TESTANDO PROCEDIMENTOS

Para testarmos o procedimento façamos o seguinte: a janela “Verificação Imediata” deve estar visível no editor. Se não estiver, vamos em Exibir / Janela ‘Verificação Imediata’.



Na janela em branco que surge você poderá testar seu procedimento.

Para testar o procedimento escrevemos na janela “Verificação Imediata” a palavra call seguida pelo nome do procedimento.

Neste exemplo ficará: call MostraMensagem

Ao pressionar a tecla ENTER aparecerá a mensagem na tela:

Ao dar Ok aparece a mensagem 2 e depois aparece a mensagem 3, pois em nosso procedimento definimos que a mensagem irá aparecer 3 vezes.

Quando um procedimento possui parâmetro para testá-lo, simplesmente colocamos o valor do parâmetro após o nome do procedimento. Caso tenha mais de um parâmetro, separamos cada parâmetro por vírgula.

Para utilizarmos um procedimento do Excel, fazemos como para as macros, podemos criar botões de comando para isso ou ainda podemos ir diretamente em Ferramentas / Macro / Macros e veremos que o procedimento feito por nós encontra-se na listagem das macros.

CONSTRUINDO FUNÇÕES

A nossa função irá receber dois números e retornar como resultado a adição da multiplicação ente os dois números e a divisão ente eles.

Para fazermos a função, podemos utilizar o mesmo módulo onde está o procedimento ou um outro módulo.

O código da função é mostrado a seguir:

Note que a função possui dois parâmetros inteiros. Isto é uma limitação para ela, pois os valores do tipo integer têm um intervalo de variação pequeno. Se você passar um argumento com um valor muito grande, a função dará um erro ao ser executada. Isso pode ser tratado da mesma forma que tratamos erros de nossas macros no início do curso. Vermos novamente mais à frente.

Observe também que a função é definida como do tipo single, pois mesmo entrando com 2 valores inteiros teremos ocasiões em que a divisão dará como resultado um número decimal e por isso ao ser somada com a multiplicação o número é decimal.



Uma diferença entre procedimentos e funções que também pode ser vista aqui é: o resultado da função é lançado pra ela mesma, observe que o cálculo feito é jogado para o próprio nome da função Calculo.

TESTANDO FUNÇÕES

Para testar um procedimento vimos que basta utilizar a Janela “Verificação Imediata”. Pois bem, para testarmos funções também, porém ao invés de utilizarmos a palavra-chave call, iremos utilizar o sinal de interrogação ?.

Devemos digitar:

? NomedaFunção Argumentos

Com a função fica assim:

? Calculo 3 , 4

Ao pressionar ENTER, aparece o resultado logo abaixo:

12,75

Quando criamos procedimentos vimos que os mesmo aparecem no Excel como se fossem macros, ou seja, se você for em Ferramentas / Macro / Macros, os procedimentos criados estará listados lá.

Mas se formos em Macros agora veremos que a função criada não está lá.

Quando criamos uma função no Editor do Visual Basic, esta função recebe a denominação do Excel de função Definida pelo Usuário.

Para verificar isso, vamos em Inserir / Função. Na caixa que se abre escolhemos a categoria Definida pelo Usuário. Vemos que a função está lá.



Ao utilizar a função veremos que ela possui os dois argumentos definidos por nós na função: Num1 e Num2.

A tela com os argumentos da função é:

CAIXAS DE MENSAGEM

Como já vimos no exemplo que fizemos de procedimento, algumas vezes precisamos que apareça uma caixa de mensagem para o usuário.

Essa caixa de mensagem pode ser apenas para efeito de informação como também pode ser uma forma do usuário interagir com a ação a ser executada, pois, se a caixa de mensagem traz uma pergunta e dependendo da resposta que ele der, uma determinada ação é executada.

Existem dois tipos de caixas de mensagens que iremos aprender neste tópico:

• MsgBox

• InputBox

A MsgBox é bastante utilizada quando queremos transmitir uma mensagem a um usuário ou alertá-lo de algum erro ocorrido ou ainda queremos fazer uma pergunta onde ele poderá responder Sim ou Não ou ainda Ok ou Cancelar.

Para utilizar a caixa de mensagem MsgBox temos que, primeiramente, aprender a sintaxe da mesma:

MsgBox Mensagem, Tipo e Botões, Título

Onde:

Mensagem – é o texto que irá aparecer na caixa de mensagem para o usuário, pode ser uma informação, um alerta ou uma pergunta.

Tipo – é o tipo da caixa de mensagem. Existem quatro tipos de caixa de mensagem:

Tipo Explicação



vbInformation Caixa de mensagem do tipo Informação

vbExclamation Caixa de mensagem do tipo Alerta

vbCritical Caixa de mensagem do tipo Erro

vbQuestion Caixa de mensagem do tipo Interrogação

Botões – são os botões a serem utilizados pela caixa de mensagem. O padrão, quando não se informa qual(is) o(s) botão(ões) que irá(ao) aparecer é o botão Ok (vbOkOnly).

Botão Explicação

vbOkOnly Botão Ok

vbOkCancel Botões Ok e Cancelar

vbAbortRetryIgnore Botões Anular, Repetir e Ignorar

vbYesNo Botões Sim e Não

vbYesNoCancel Botões Sim, Não e Cancelar

vbRetryCancel Botões Repetir e Cancelar

Para os tipos de botões mostrados acima, dependendo do botão clicado pelo usuário existirá um tipo retornado para a ação referente a ele ser executada.

Os tipos possíveis a serem retornados são:

Resposta Explicação

vbOk Usuário clicou no botão Ok

vbCancel Usuário clicou no botão Cancelar

vbAbort Usuário clicou no botão Anular

vbRetry Usuário clicou no botão Repetir

vbIgnore Usuário clicou no botão Ignorar

vbYes Usuário clicou no botão Sim

vbNo Usuário clicou no botão Não

Título – é o título da caixa de mensagem.

O código abaixo serve para testarmos as caixas de mensagem com componentes diferentes. Ainda não estaremos testando o valor retornado pela caixa de mensagem.



No código anterior, no final de algumas linhas você verá que existe o símbolo _ (underscore). Este símbolo é utilizado quando o conteúdo de uma linha não terminou e continua na próxima linha. Se você quiser, você poderá digitar sem o underscore, porém, terá que fazer cada comando numa linha.

O comando select veremos nos próximos tópicos do nosso curso. Para testar os tipos de caixa de mensagem retornados, utilizamos a Janela “Verificação Imediata”. Digitamos o nome do procedimento seguido por um número, variando de 1 a 6, que são os tipos de exemplos inseridos no código.

Veremos que para cada número utilizado no teste será retornada uma caixa de mensagem diferente com botões diferentes, como os dois exemplos que seguem:



• Caixa de mensagem do tipo Informação, com botão Ok

• Caixa de mensagem do tipo Alerta, com botões Ok e Cancelar

• Caixa de mensagem do tipo Erro, com botões Sim e Não

• Caixa de mensagem do tipo Pergunta, com botões Sim, Não e Cancelar

• Caixa de mensagem do tipo Pergunta, com botões Repetir e Cancelar



• Caixa de mensagem do tipo Alerta, com botões Anular, Repetir e Ignorar

A InputBox é uma caixa de mensagem onde o usuário pode informar um valor qualquer numa

caixa de texto.

A sintaxe da InputBox é bastante simples:

InputBox (Mensagem, Título, Valor Padrão)

Onde:

Mensagem – é o texto que virá dentro da caixa de mensagem para o usuário.

Título – é o título da caixa de mensagem.

Valor Padrão – é algum valor que você já queira que venha preenchido na caixa de texto.

Para começarmos a aprender um pouco sobre a InputBox digite o código a seguir:

Ao testar o procedimento acima, veremos que aparecerá uma InputBox onde digitaremos qualquer coisa.

Logo em seguida, ao clicarmos em Ok, aparecerá uma caixa de mensagem com o que você digitou na InputBox.



ESTRUTURAS CONDICIONAIS

As estruturas condicionais no VBA servem para ser utilizadas quando precisamos analisar determinada condição ou expressão e dependendo do caso, essa condição ou expressão testada retorna algo diferente para cada situação.

Aprenderemos duas estruturas condicionais:

• If

• Select

O COMANDO IF

O comando If é bastante similar à função Se do Excel.

O comando If analisa uma condição e se o resultado for verdadeiro executa determinado(s) comando(s), caso contrário, pode não fazer nada ou executar outro(s) comando(s)

A sintaxe do comando If é:

If condição Then

Comandos a serem executados caso condição seja verdadeira

End If

Na sintaxe acima o comando If é mostrado da forma mais simples, ou seja, se a condição for verdadeira os comandos dento do If serão executadas.

Outra sintaxe para o comando If é:

If condição Then

Comandos a serem executados caso condição seja verdadeira

Else

Comandos a serem executados caso condição seja falsa

End If

Você pode fazer mais interações com o comando If, imagine que você possui várias condições a serem testadas, você pode usar o comando If assim:



If condição 1 Then

Comandos a serem executados caso condição 1 seja verdadeira

ElseIf condição 2 Then


ElseIf condição 3 Then


...

Else

Comandos a serem executados caso nenhuma condição seja verdadeira

End If

Vejamos o código abaixo:

Observe que estamos utilizando o comando If ... ElseIf ... Else ... End If, pois temos várias situações de intervalos de notas para os alunos.

O código acima define a função Conceito:



A janela de argumentos da função contém o único argumento desta função que é a nota do aluno.

Para finalizar temos que fazer alguns tratamentos na função, por exemplo, o que acontecerá se a nota for maior do que 100 ou menor do que 0? Isso é um erro, pois as notas variam de 0 a 100.

Para isso vamos acrescentar ao código da função o seguinte: se a nota for menor do que 0 ou maior do que 100, o conceito do aluno será I (inválido). Desta forma termos mais uma estrutura if para ser completada.



O COMANDO SELECT

O comando Select analisa uma expressão que pode retornar algum valor, e, para cada valor retornado pode ser executado determinado comando ou comandos.

A sintaxe do comando Select é:

Select Case expressão

Case valor 1

Comando a ser executado caso a expressão retorne valor 1

Case valor 2

Comando a ser executado caso a expressão retorne valor 2

...

Case valor N

Comando a ser executado caso a expressão retorne valor N

Case Else

Comando a ser executado caso não retorne nenhum valor testado acima

End Select

Para aprendermos a utilização do comando Select, vejamos o código abaixo:



Verifique que o usuário poderá digitar qualquer valor do tipo byte, ou seja, algum valor variando de 0 a 255. Se ele digitar 1, 2 ou 3 aparecerá uma mensagem para ele de Bom dia, Boa tarde ou Boa noite.

Note que, a última instrução do comando Select é um Case Else, isto quer dizer que, se o usuário digitar qualquer número diferente de 1, 2 ou 3 será executada a expressão que está dentro desta cláusula.

ESTRUTURAS DE REPETIÇÃO

As estruturas de repetição no VBA servem para quando precisamos repetir um mesmo comando ou uma mesma seqüência de comandos um número determinado de vezes.

Aprenderemos duas estruturas de repetição:

• For

• While

O COMANDO FOR

O comando For faz com que determinadas instruções sejam executadas enquanto um incrementador estiver variando de um número até outro.

A sintaxe do comando For é:

For Contador = Valor Inicial To Valor Final

Comandos a serem executados

Next

Um exemplo do uso do comando For é:

For num = 1 To 3

MsgBox “Mensagem número: ” & num

Next

Serão mostradas três caixas de mensagens, ou seja, será mostrada a caixa de mensagem com a mensagem “Mensagem número: 1”, depois será mostrada a caixa de mensagem com a mensagem



“Mensagem número: 2” e, por último, será mostrada a caixa de mensagem com a mensagem “Mensagem número: 3”.

Como exemplo, construiremos um procedimento (macro) para modificar a cor da fonte de cada célula da coluna Conceito, dependendo do conceito que o aluno tirou, da forma seguinte:

• Conceito A = cor Azul (11)

• Conceito B = cor Verde (10)

• Conceito C = cor Amarelo (6)

• Conceito D = cor Laranja (46)

• Conceito R = cor Vermelho (3)

Entre parênteses foram colocados os valores correspondentes de cada cor.

O código a seguir descreve o exposto acima:



Podemos incrementar mais os comandos dentro de cada cláusula select.

Façamos o seguinte:

Para cada conceito além da cor, definiremos também que a fonte será negrita. Para isso utilize o comando Selection.Font.Bold = True em cada cláusula. Definiremos também que a cor de preenchimento da célula terá os seguintes tons:

• Conceito A = cor de preenchimento Turquesa Claro (34)

• Conceito B = cor de preenchimento Verde Claro (35)

• Conceito C = cor de preenchimento Azul Claro (41)

• Conceito D = cor de preenchimento Marrom Claro (40)

• Conceito R = cor de preenchimento Azul Pálido (37)

Para modificar a cor de preenchimento de cada célula utilizamos o comando Selection.Interior.ColorIndex = Cor, onde Cor corresponde à cor a ser utilizada.

O COMANDO WHILE

Como o comando For, o comando While também é como estrutura de repetição. Ele funciona da seguinte forma: enquanto uma condição for verdadeira as instruções no interior do While serão executadas.

A sintaxe do comando While é:

While Condição

Comandos a serem executados enquanto a condição for verdadeira

Wend

Como exemplo, faremos o seguinte se o valor contido na célula for menor do que 50.000 a célula será preenchida da cor vermelha, agora, se o valor contido na célula for maior ou igual a 50.000 a célula será preenchida da cor verde.

Para fazermos essa rotina precisaremos utilizar mais alguns conceitos do Excel e do VBA, como, por exemplo, a função IsNumeric que testa se determinado valor é número ou não. Essa função é bastante utilizada par evitarmos erros desnecessários.

Veremos em mais exemplos mais funções do VBA, algumas funções pré-definidas pelo VBA tem características semelhantes à IsNumeric, tais como:

• IsNull – verifica se determinado valor/variável é nula;

• IsDate – verifica se determinado valor/variável é data;

• IsEmpty – verifica se determinado valor/variável está vazio;

• IsObject – verifica se determinado valor/variável é um objeto

Todas essas funções sempre retornam um valor booleano (lógico) – verdadeiro ou falso.

Vejamos o código abaixo:



Vamos entender a rotina acima.

Existem dois comandos While na rotina. O primeiro serve para controlar as linhas selecionadas e o segundo as colunas. Observe que as variáveis i e j variam de acordo com as linhas e colunas. Ambas iniciam com o valor 1.

Cada um dos incrementadores varia de acordo com o número de linhas e o número de colunas selecionadas.

Utilizamos a função IsNumeric para verificarmos se o conteúdo da célula ativa é um valor numérico, se for um valor numérico fazemos a comparação se é menor que 50.000 este valor e atribuímos vermelho ou verde, conforme o resultado.

Quando utilizamos a rotina acima:

• Células com valores menores que 50.000 ficam preenchidas de vermelho;

• Células com valores maiores ou iguais a 50.000 ficam preenchidas de verde;

• Células contendo texto não são formatadas.



DEPURAÇÃO DE CÓDIGO

DEPURANDO UM CÓDIGO

Quando criamos uma macro, um procedimento ou uma função estamos sujeitos a cometer erros. Alguns desses erros são fáceis de serem vistos, pois, podem ser erro de sintaxe de algum comando que, ao testarmos a rotina feita, o próprio Visual Basic já acusa o erro.

Porém alguns desses erros podem ser mais difíceis de serem encontrados, pois, podem ser os chamados erros de semântica, ou seja, sintaticamente está tudo correto, mas em algum lugar do código pode estar errado o comando que usamos, por exemplo, ao invés de fazermos uma variável receber o valor de 0, estamos fazendo com que ela receba o valor de 1, quando o correto seria o 0.

Para ficar mais simples acharmos os erros, torna-se interessante irmos executando cada rotina linha a linha de código. Fazer isso é depurar o código ou com muitos chamam debugar o código(porque em Inglês depurar = debug).

Com a depuração de código podemos encontrar facilmente os erros que estão ocorrendo no código que estamos testando.

A depuração em si, é um teste que fazemos com o código que está sendo produzido. Por este motivo é importante testarmos o código de todas as formas possíveis.

Por exemplo, imagine que temos uma rotina para um determinado cálculo entre dois valores distintos, onde um dos valores só pode ser positivo e inteiro e o outro só pode ser negativo e inteiro. Teríamos que testar de várias formas diferentes, ou seja, com parâmetros, ambos os números positivos, ambos os números negativos, um positivo e outro negativo, valores incorretos – tipo texto, data, entre outros testes.

Ao fazermos a depuração ficamos mais seguros de que a rotina testada funciona.

Muitas vezes, esquecemos de inserir o tratamento de erro em alguma rotina, sendo que em muitas ocasiões este tratamento é imprescindível. Isso fica claro quando executamos a depuração do código, pois, na utilização de uma rotina existem várias situações que podem acontecer.

Na depuração do código, nada mais fazemos do que simularmos essas várias situações.

Muito bem, agora que você já sabe o que é e para que serve a depuração de código vamos tratar de aprender como depurar um código.

Lembre-se, daqui para frente sempre que preciso vamos depurar os códigos feitos por nós, para termos a certeza de que os mesmo funcionam corretamente.

Antes de começarmos a depurar um código, vamos conhecer as ferramentas de depuração que existem no Editor do Visual Basic.

No Editor do Visual Basic, existe uma opção no menu chamada Depurar. Dentro deste menu temos várias opções que serão utilizadas por nós para depuração de código. Veremos as mais comuns delas.

Além do menu Depurar, temos também no Editor do Visual Basic uma barra de ferramentas também chamada Depurar. Ela possui as mesmas opções que existem no menu Depurar. Para exibi-la vamos em Exibir / Barra de Ferramentas e escolhemos a barra de ferramentas Depurar.



A figura abaixo mostra a barra de ferramentas depurar:

A descrição de cada comando desta barra de ferramentas é dada a seguir:

1 – Modo de criação

2 – Executar Sub/UserForm (continuar)

3 – Interromper

4 – Redefinir (parar a execução)

5 – Ativar/desativar pontos de interrupção

6 – Depuração Total

7 – Depuração parcial

8 – Depuração circular

9 – Janela “Variáveis Locais”

10 – Janela “Verificação Imediata” – é a mesma janela que já utilizamos para testar nosso códigos feitos

11 – Janela “Inspeção de Variáveis”

12 – Inspeção de variáveis Rápida

13 – Pilha de chamadas

Para exemplificar a depuração de um código utilizaremos a rotina ConceitoCor mostrada a seguir:



Antes de depurar um código temos que definir os pontos de interrupção para que a depuração comece a partir dali. Este ponto de interrupção nada mais é do que a marca onde daremos início à depuração do código linha a linha. Muitas vezes este ponto não precisa ser na primeira linha do código da rotina, mas sim, no lugar em que você acha que está o erro.

Neste exemplo vamos marcar como ponto de interrupção a linha:

TotalLinha = Selection.Cells.Count

Observação: Você não consegue marcar como ponto de parada linhas de comentário e nem linhas de declaração de variáveis e constantes, somente linhas de comando.

Para marcar uma linha como ponto de interrupção, fazemos o seguinte:

Com o cursor na linha definida acima, selecionamos a opção Ativar/desativar pontos de interrupção na barra de ferramentas Depurar.

Com o cursor na linha pressionamos a tecla F9.

Com o mouse, clicamos na região cinza logo à frente da linha.



Se você utilizar qualquer uma das opções acima uma vez, ativa o ponto de interrupção, se utilizar novamente desativa.

Marcando a linha como ponto de interrupção, podemos iniciar a depuração do código.

Vamos até a planilha Alunos e selecionamos as células G4 até G17.

Feito isso, em Ferramentas / Macro / Macros executamos a macro ConceitoCor.

O que acontece quando você faz isso?

Você é levado para o código e a linha que marcou como ponto de interrupção fica marcada de amarelo.

A partir daí, começa a depuração.

Antes de qualquer coisa, ao apontar o mouse para a variável TotalLinha o valor atual da variável aparece.

O valor atual dela é 0 (zero). Pressionando a tecla F8 a linha amarela que marca a linha de código que está sendo executada passa para a próxima linha de comando. Apontando o mouse novamente para a variável TotalLinha o valor atual já mudou.



O que aconteceu? Ao avançarmos para a próxima linha, pressionando a tecla F8, a variável TotalLinha recebeu o total de linhas selecionadas.

Agora se apontamos o mouse para a variável Linha, veremos que ela está com o valor 0 (zero), se pressionar F8 novamente, ela receberá o valor 1 (um).

Uma outra forma de visualizar o conteúdo de uma variável no momento é utilizando a Janela Variáveis locais. Acionamos esta opção na barra de ferramentas Depurar.

Esta janela traz todas as variáveis utilizadas na rotina e, à medida que você vai depurando o código (pressionando a tecla F8) as variáveis vão trocando de valores.

Ao pressionarmos a tecla F8 várias vezes, observamos que a linha amarela vai trocando até que retorna para a linha:

Range("G" & Linha).Select ' Define a célula ativa no momento

Isso acontece porque estamos dentro de um comando de repetição.

Você não precisa ficar depurando o código até o fim, você pode testá-lo até encontrar o problema, caso tenha algum problema e depois parar a execução ou terminar a execução.

Para interromper a depuração você pode utilizar os comandos Continuar na barra de ferramentas Depurar ou Redefinir também na barra de ferramentas Depurar.

Observação: Não se esqueça de, após terminar a depuração de um código, desmarcar todos os pontos de parada do mesmo.



TRATAMENTO DE ERROS EM ROTINAS

TRATANDO ERROS

Já vimos alguns exemplos de tratamento de erros em macros. Naquele momento vimos apenas um modo básico de se tratar um erro que pode ocorrer na execução de alguma rotina.

Sempre é aconselhável realizarmos o tratamento dos erros, pois, o usuário ao executar uma rotina, ou seja, utilizar alguma planilha sua que contém macros ou funções não necessariamente pode saber muito bem como utilizar essas rotinas e, com isso, gerar erros, que se não forem tratados por você ficaria difícil para ele entender o que está acontecendo.

Utilizaremos alguns tratamentos de erro, melhorando para o usuário a utilização das rotinas feitas por nós.

Usaremos uma rotina onde o usuário entrará com dois números inteiros e retornaremos em duas células diferentes do Excel o resultado da divisão inteira e o resultado do resto da divisão inteira.

Para entendermos o processamento da rotina, a planilha é mostrada conforme abaixo:

O código é mostrado abaixo:



Executando a macro, se o usuário sempre inserir valores inteiros nas duas caixas de entrada, a rotina sempre executará corretamente.

Observe que os dois números inteiros que digita em cada caixa de entrada aparecem, respectivamente, nas células B3 e B4, conforme descrito no código da rotina e, logo em seguida, o resultado da divisão e do resto da divisão aparecem nas células B6 e B7.

Testando a rotina, acionarmos a macro surge a primeira caixa de entrada “Digite o dividendo”.

Digitamos o valor inteiro 10 nesta caixa e damos Ok. Ao fazermos isso, aparece a segunda caixa de entrada “Digite o divisor”.



Digitamos o valor 3 nesta caixa e também demos Ok. O resultado será: quociente = 3 e resto = 1.

GERANDO ERROS

Experimentaremos agora executar a macro novamente e vamos começar a gerar alguns erros propositadamente.

Primeiro: digitando tanto no dividendo ou no divisor um texto, ao invés de um número inteiro. Aparecerá o seguinte erro:

O erro aparece porque num1 ou num2 são variáveis do tipo inteiro e não admitem receber valor texto.

Se você clicar no botão Depurar, aparecerá marcada de amarelo exatamente a linha que deu erro, ou a linha do num1 recebendo o valor da caixa de entrada do dividendo ou a linha da variável num2 recebendo o valor da caixa de entrada do divisor. Como já sabemos qual é o erro, para parar a depuração marque o botão Redefinir.

Se você clicar no botão Fim, simplesmente parará a execução.

Observe que o número do erro gerado foi 13 – Tipos Incompatíveis. Para cada erro que pode ocorrer existe um número de erro específico e uma descrição.

O erro acima ocorrerá caso digite um texto ou uma data ou qualquer outro valor que não seja numérico.

Segundo: outro erro que poderá ocorrer é fácil de gerarmos também. Executando a macro, inseriremos qualquer valor no dividendo e no divisor digitaremos 0. Aparecerá o erro abaixo:



Isto significa que é um erro a divisão por zero e este erro, no VBA é tratado como o erro de código 11.

Terceiro: mais um erro que pode ocorrer é o seguinte: digitando tanto como dividendo ou como divisor um número muito grande, maior que 32768. Lembre-se: os números inteiros variam num intervalo de -32768 a +32767. O erro abaixo ocorrerá:

O erro de código 6, é o erro que informa estouro no limite aceito pela variável.

Vimos que muitos erros podem ocorrer numa rotina simples como esta que, simplesmente, executa duas operações matemáticas: uma divisão inteira e um resto da divisão inteira.

Além destes três erros que testamos, pode até ser que outros erros possam ser gerados pelo usuário.

Por este motivo teremos que aprender como tratar esses erros, ou seja, como não deixar que o erro estoure na tela do usuário aparecendo uma mensagem para ele que ele não entenda.

Para realizarmos o tratamento de erro da rotina Divisao, logo abaixo dela criaremos a rotina TrataErro.

Você observou que sempre o código do erro gerado pelo VBA é um valor numérico inteiro, não é? Então desta forma, o parâmetro de entrada desta rotina será um parâmetro inteiro. Para não termos problemas de estouro com este parâmetro, iremos declará-lo do tipo Long.

Testamos também três tipos de erros retornados, os tipos de código 13 – tipos incompatíveis, 11 – divisão por zero e 6 – estouro de limite.

Vamos utilizar o comando Select para testar estes valores retornados e ainda utilizar uma cláusula Else do Select caso outro erro não tratado por nós apareça.

Criamos a rotina conforme a seguir:



Existem duas formas de tratarmos os erros ocorridos em uma rotina.

A primeira delas já vimos em tópicos anteriores, quando estudamos macros. Utilizamos o comando:

On Error Resume Next

Com este comando se qualquer erro ocorre em algum comando, alguma instrução do código, a execução pula para a próxima linha de comando.

Uma outra forma de utilizarmos o tratamento de erro, é fazendo uso do comando a seguir:

On Error Goto Rótulo

Com esse comando, informamos ao VBA que, se algum erro ocorrer nas linhas de código abaixo deste comando, a execução do código pula para onde está o Rótulo. Este Rótulo é um nome que damos a determinada linha significando que, a partir dali continuará a ser executado o código.

A sintaxe de uma rotina com o tratamento de erros fica assim:

On Error Goto TratamentodeErro ‘ este nome do rótulo pode ser qualquer um

... comandos ... ‘ comandos da rotina

TratamentodeErro: ‘ rótulo seguido de dois pontos

... comandos ... ‘ comandos a serem executados caso ocorra algum erro

O código a seguir mostra a rotina Divisao com o tratamento de erro.

Somente um detalhe deste código ainda não foi explicado. Qual o porquê da linha de comando Exit Sub?

Este comando será preciso por que toda vez que executarmos esta rotina, caso não dê nenhum erro a execução normal será feita e logo após o comando Range("B7").FormulaR1C1 = resto, o próximo comando a ser executado seria TrataErro Err.Number.

Desta forma sempre iríamos executar a rotina de tratamento de erro e isso não é preciso, pois, somente será preciso quando de fato der erro. Por este motivo, utilizamos o comando Exit Sub, informando que ali é o final normal da rotina caso não ocorra erro algum.



Observação: Note que na chamada da rotina TrataErro passamos como parâmetro o número do erro gerado pelo VBA, ou seja, o Err.Number.

PROPRIEDADES E MÉTODOS DO OBJETO ERR

Vimos que quando são gerados erros em nossas rotinas entra em ação o objeto Err. É esse objeto que é responsável por qualquer erro de execução que ocorrerá no VBA.

Quando ocorre qualquer erro em tempo de execução, as propriedades do objeto Err são preenchidas com informações que identificam com exclusividade o erro e a informação que podem ser usados para tratá-lo.

A principal propriedade do objeto Err é a propriedade Number. Esta propriedade retorna o número do erro gerado em tempo de execução.

Além desta propriedade o objeto Err possui outras propriedades e métodos, a saber:

Objeto Err

Propriedades

Number Retorna um valor numérico que especifica um erro

Description Retorna a descrição de um erro

Source Retorna a origem do erro – objeto ou aplicativo



HelpFile Retorna o caminho completo para um arquivo de ajuda sobre o erro

HelpContext Retorna o ID de contexto para um arquivo de ajuda

LastDLLError Retorna um código de erro do sistema

Métodos

Clear Limpa todas as definições do objeto Err

Raise Gera um erro em tempo de execução

O código abaixo mostra a utilização dos métodos e propriedades do Objeto Err:

Observe que estamos gerando o erro 11 com a ajuda do método Raise. Para modificar o erro gerado modifique o número 11 por outro.

Para testarmos a rotina, utilizamos a janela Verificação Imediata do editor.

Observação: na construção da mensagem de erro foi utilizada a constante vbCrLf que é uma constante própria do VBA que significa quebra de linha.



A HIERARQUIA DE OBJETOS DO EXCEL

OBJETOS DO EXCEL

A hierarquia dos objetos do Excel funciona da seguinte forma:

1. Objeto Application

2. Objeto Workbooks

3. Objeto Worksheets

4. Objeto Range

Destes quatro objetos listados acima, já trabalhamos algumas vezes com o objeto Range. Ele foi utilizado quando queríamos trabalhar com uma célula ou um intervalo de células.

Mas vejamos hierarquicamente cada um dos objetos.

O objeto Application é o próprio aplicativo Excel, ou seja, é a aplicação como um todo. Este objeto contém um conjunto de Workbooks.

O objeto Workbook é cada arquivo aberto do Excel, ou seja, é cada pasta de trabalho. Este objeto possui um conjunto de Worksheets.

O objeto Worksheet é cada planilha dentro de uma pasta de trabalho, desta forma quando queremos trabalhar com planilhas utilizamos este objeto. Este objeto contém um conjunto de Ranges.

O objeto Range, como já visto representa uma célula ou um conjunto de células.

O OBJETO APPLICATION

O objeto Application é utilizado quando queremos de alguma forma trabalhar com a aplicação do Excel como um todo.

Algumas propriedades e métodos do objeto Application serão vistos por nós.

O método Caption modifica o nome do aplicativo “Microsoft Excel” para o nome que desejamos. Desta forma se escrevemos:

Application.Caption = “Teste de Título”

Na barra de títulos do Excel, ao invés de termos Microsoft Excel, estará Teste de Título.

A rotina a seguir nos mostra como mudar o nome do aplicativo:



Para testar esta rotina, vamos na janela Verificação Imediata e digitamos o nome da rotina em seguida damos ENTER. Ao olharmos para a janela do Excel e a barra de título do mesmo o nome foi modificado.

O método Run executa uma determinada macro. Utilizando Application.Run podemos passar como parâmetros a macro e seus parâmetros, caso tenha.

Para utilizarmos este método, vamos criar uma macro simples. Em um arquivo do Excel que está aberto, criamos uma macro que formata uma célula com a fonte Courier New e cor vermelha.

Depois que você parar a gravação dessa macro, vamos ao Editor do Visual Basic e criamos a que se encontra abaixo:

Onde FormataFonte é o nome da macro criada.

Observe a macro abaixo. São passados dois parâmetros para a macro FormataFonte2, o nome da fonte e a cor da fonte e estes parâmetros são utilizados no código da macro:

Veja a rotina abaixo:



A execução desta rotina na janela Verificação Imediata faz com que a macro FormataFonte2 seja executada com a fonte e a cor informadas. A célula selecionada ficará com a formatação escolhida.

Exemplo:

• ExecutaMacro2 "Times New Roman", 6 (fonte Times New Roman e cor amarela);

• ExecutaMacro2 "Tahoma", 15 (fonte Tahoma e cor cinza);

• ExecutaMacro2 "Verdana", 32 )fonte Verdana e cor azul).

Outro método que você pode utilizar é o método Quit.

Este método encerra o Excel, ou seja, fecha todas as janelas do Excel que estejam abertas.

A rotina a seguir utiliza este método:

O OBJETO WORKBOOKS

O objeto Workbooks é utilizado quando queremos de alguma forma trabalhar com as pastas de trabalho do Excel.

Algumas propriedades e métodos do objeto Workbooks serão vistos por nós.

Vimos que no objeto Application o método Quit encerra a aplicação, ou seja, fecha o Excel. Para fecharmos uma pasta de trabalho específica, utilizamos o método Close.

O código a seguir mostra um exemplo do método Close:

Para testarmos esta rotina, suponhamos que temos um arquivo aberto chamado “Divisao.xls”. Podemos utilizar esta rotina FecharArquivo na janela verificação Imediata da seguinte forma:



FecharArquivo "Divisao"

O arquivo “Divisao.xls” será fechado.

Como você pode fechar um arquivo que está aberto, você também pode abrir um arquivo. Para isso, veja a rotina abaixo:

Ao realizar o teste desta rotina você terá que passar como parâmetro não somente o nome do arquivo que será aberto, como foi feito no teste anterior da rotina para fechar o arquivo, mas também o caminho completo que leva até o arquivo.

Por exemplo, para testar esta rotina utilizando a janela Verificação Imediata, faça da seguinte forma:

AbrirArquivo "C:\Excel\Divisao.xls"

Onde:

C:\Excel\ é a pasta em seu computador onde está gravado o arquivo Divisao.xls.

O OBJETO WORKSHEETS

O objeto Worksheets é utilizado quando queremos de alguma forma trabalhar com as planilhas contidas em uma pasta de trabalho do Excel.

Algumas propriedades e métodos do objeto Worksheets serão vistos por nós.

Vamos, primeiramente, visualizar um código para nomear planilhas.

Para testar esta rotina utilizando a janela Verificação Imediata fazemos da seguinte forma:

NomearPlanilha 1, "Teste 1"



Se você testar novamente e utilizar um número de planilha inexistente, como fizemos um tratamento de erro, a nossa rotina retornará a janela para o usuário:

Isto porque você tentou acessar uma planilha inexistente em sua pasta de trabalho.

Para criamos uma nova planilha em uma pasta de trabalho vamos utilizar o seguinte código:

Com este código podemos criar uma planilha onde acharmos necessário. Por padrão, sempre uma planilha é inserida na posição anterior à planilha que está selecionada.

Para excluirmos uma planilha o processo é semelhante ao da criação, porém, ao invés do método Add, utilizaremos o método Delete.

Veja o código a seguir:

Com este código você pode excluir uma planilha passando como parâmetro o número (índice da mesma) ou o nome da planilha.

Observe que utilizamos antes do nome de cada parâmetro a palavra-chave Optional, ela tem a finalidade de informar que o parâmetro não é obrigatório. Por isso existem duas forma para testar essa rotina:



• ExcluirPlanilha 1

• ExcluirPlanilha ,"Plan3"

Veja que no primeiro teste, passamos somente o número da planilha que queremos apagar. No segundo teste passamos virgula seguido do nome da planilha que queremos apagar. Em ambos os casos omitimos um dos parâmetros.

O OBJETO RANGE

O objeto Range, com certeza, é o mais utilizado por nós, por este mesmo, até antes de falarmos diretamente sobre ele já o utilizamos algumas vezes.

Utilizamos o objeto Range quando queremos trabalhar com determinada célula ou determinado intervalo de células.

Por exemplo, podemos querer que determinada célula receba determinado valor, ou podemos querer ler os valores contidos em várias células.

Podemos ainda querer formatar um determinado intervalo de células. Para tudo isso utilizamos o objeto Range.

Observe a rotina a seguir, onde, primeiramente, contamos a quantidade de células que existe no intervalo de B2 até B8. Depois que fazemos isso, somamos os valores que estão dentro de cada célula. Logo em seguida extraímos a média destes valores, dividindo a soma pela quantidade. Com a média formatamos a célula para que nela somente tenha duas casas decimais.



Podemos utilizar a rotina acima numa planilha como esta:

O botão chamado Calcular acionará a rotina Totais.

Clicando no botão veremos o resultado aparecendo nas células B10, B11 e B12.



WORKBOOKS E WORKSHEETS

O PROJECT EXPLORER

Você já reparou que no Project Explorer do Editor do Visual Basic, além dos módulos que criamos existem também um espaço onde temos os objetos do Excel, ou seja, geralmente, temos o objeto EstaPasta_de_Trabalho que é o arquivo que está aberto e também as planilhas que se encontram neste arquivo, conforme a figura abaixo:

Se dermos um clique duplo no objeto EstaPasta_de_Trabalho na área de trabalho ao lado aparecerá um espaço para trabalharmos com o objeto WorkBooks e seus eventos.

Se dermos um clique duplo em qualquer uma das planilhas – Plan1, Plan2 ou Plan3, ou seja lá qual for o nome que as mesmas possuam no arquivo que está aberto, na área de trabalho ao lado aparecerá um espaço para trabalharmos com o objeto WorkSheets e seus eventos.

Dando um clique duplo no objeto EstaPasta_de_Trabalho na área de trabalho, temos duas caixas de combinação no topo da tela. Uma delas é a caixa de combinação Objeto e a outra é a caixa de combinação Procedimento (Evento).

Selecionando Workbook na caixa de combinação Objeto, automaticamente já aparece um evento associado a este objeto. O evento Open que é o evento padrão deste objeto.

Observe agora que na caixa de combinação procedimento temos todos os eventos associados ao objeto Workbook.

Veja na figura abaixo. O objeto Workbook está selecionado na caixa de combinação da esquerda e na caixa de combinação da direita estão os eventos que podem ser associados a este objeto.

Para cada evento que você selecionar na caixa de combinação à direita surgirá um procedimento para você construir o código do mesmo.



Dando um clique duplo no objeto Plan1 na área de trabalho, temos as duas caixas de combinação no topo da tela novamente. Uma delas é a caixa de combinação Objeto e a outra é a caixa de combinação Procedimento (Evento).

Selecionando Worksheet na caixa de combinação Objeto, automaticamente já aparece um evento associado a este objeto. O evento SelectionChange que é o evento padrão deste objeto.

Observe agora que na caixa de combinação procedimento temos todos os eventos associados ao objeto Worksheet.

Veja na figura abaixo. O objeto Worksheet está selecionado na caixa de combinação da esquerda e na caixa de combinação da direita estão os eventos que podem ser associados a este objeto.

Para cada evento que você selecionar na caixa de combinação à direita surgirá um procedimento para você construir o código do mesmo.

PROGRAMANDO COM EVENTOS

Com um arquivo vazio do Excel, trabalharemos no Editor do Visual Basic e utilizaremos a Plan1 para trabalharmos com os eventos associados a ela.

Para iniciar nosso trabalhos, no Project Explorer damos um clique duplo em Plan1 ou senão clicamos com botão direito do mouse sobre Plan1 e escolhemos Exibir Código. Selecionamos o objeto Worksheet.

Conforme já visto o evento SelectionChange já foi selecionado.

Incluiremos neste evento o seguinte comando:

MsgBox “Teste”

Voltando ao Excel e digitando qualquer coisa na célula A1, o que acontece? Aparece a caixa de mensagem “Teste”.

Se você trocar de célula novamente, a caixa de mensagem aparecerá novamente.

O que você fizer nesta planilha fará com que a caixa de mensagem apareça.

É isto que o evento SelectionChange faz, para qualquer mudança na planilha, os comandos em seu interior serão executados, como neste caso o único comando que ele possui é a exibição de uma caixa de mensagem, ele está fazendo exatamente isto.

Se você trocar de planilha no Excel, o evento não funciona nesta outra planilha, pois ele foi utilizado na Plan1. Para usá-lo nesta outra planilha teríamos que inseri-lo em seu código.

O evento BeforeDoubleClick ocorre quando você dá um clique duplo com o botão do mouse em qualquer célula da planilha.



Quando faz isso, antes mesmo de efetuar a ação do duplo clique, o evento é realizado.

Você pode testar este evento da mesma forma que testou o anterior.

Criaremos dentro dele um MsgBox com algum conteúdo. Você verá que ao clicar duas vezes na planilha o evento será executado, ou seja, a caixa de mensagem aparecerá.

O evento BeforeRightClick ocorre quando você clica com o botão direito do mouse em alguma célula de sua planilha.

Quando faz isso, antes de aparecerem as opções disponíveis ao clicar com o botão direito do mouse, serão executados os comandos que estão dentro do evento BeforeRightClick.

Podemos testar este evento também.

Observe que os eventos já possuem alguns parâmetros pré-definidos.

No caso do evento SelectionChange existe o parâmetro Target que é um objeto do tipo Range.

No caso dos eventos BeforeDoubleClick e BeforeRightClick, além do parâmetro Target, temos também o parâmetro Cancel que é do tipo lógico – verdadeiro ou falso.

Estes parâmetros, não necessariamente precisam ser utilizados no código que virá dentro do procedimento.

Veremos um exemplo que utiliza o parâmetro.



Você vê que a variável Target é a mesma coisa de utilizarmos o objeto ActiveCell, ou seja, é a célula ativa ou células ativas que foram selecionadas.



O USERFORM

CONHECENDO OS FORMULÁRIOS - USERFORMS

É possível no editor do Visual Basic criarmos formulários para entrada de dados em nossas planilhas.

Para trabalharmos com formulários no Editor do Visual Basic acessamos a opção Inserir e criamos um UserForm. Aparecerá um userform para que possamos trabalhar.

Quando trabalhamos com formulários, utilizaremos a caixa de ferramentas para construção dos controles que aparecerão no formulário.

A caixa de ferramentas do Editor do Visual Basic aparece quando inserimos um formulário ou senão quando selecionamos Exibir / Caixa de ferramentas, desde que estejamos com algum formulário ativo.

A caixa de ferramentas é mostrada abaixo:

Faremos uma breve descrição sobre cada um dos componentes desta caixa de ferramentas:

1. Selecionar Objetos – é um controle utilizado para selecionar os objetos que se encontram em um formulário para arrastá-los ou redimensioná-los ou ainda excluí-los.

2. Rótulo – é utilizado quando queremos dar nomes as campos que estarão no formulário. É utilizado para legenda dos campos ou controles.



3. Caixa de Texto – é o controle utilizado par entrada de qualquer tipo de texto. O usuário poderá digitar qualquer informação neste campo.

4. Caixa de Combinação – é o controle que conterá uma listagem de itens onde o usuário pode selecionar um deles.

5. Caixa de Listagem – é o controle que conterá uma listagem de itens onde o usuário pode escolher um único item ou vários itens.

6. Caixa de Seleção – é o controle utilizado para seleção de várias opções, o usuário pode selecionar uma única opção ou várias.

7. Botão de Opção – é utilizado quando o usuário somente pode escolher uma opção dentre uma lista de opções.

8. Botão de Ativação – é utilizado como o controle anterior, o usuário somente pode escolher um único botão.

9. Moldura – é utilizado quando queremos agrupar os controles dentro de uma moldura. No caso dos botões de opção é aconselhável colocá-los dentro da moldura, pois, dentro do mesmo formulário podemos ter dois grupos diferentes de botões de opções, dessa forma colocando-os em molduras diferentes, o usuário poderá selecionar uma opção de cada grupo.

10. Botão de Comando – são os botões que executarão os comandos.

11. Faixa de Tabulação – permite a separação dos controles em páginas diferentes. Utilizado quando o formulário possuir muitos controles.

12. Multi-página – permite a apresentação de várias telas de controles diferentes. Também é utilizado quando o formulário possuir muitos controles.

13. Barra de Rolagem – ferramenta gráfica para navegação rápida em uma lista onde cada posição assumida pela rolagem é uma valor.

14. Botão de Rotação – controle para incrementador e decrementador de números.

15. Imagem – exibe uma imagem em seu formulário.

16. RefEdit – exibe um controle parecido com uma caixa de texto , porém, contendo uma alça ao final que ao ser acionada, o formulário se esconde e você pode preencher a caixa de texto, visualizando a planilha abaixo do formulário. É parecido com as caixas de texto das funções do Excel.

Além da caixa de ferramentas também utilizaremos a janela Propriedades. Para exibi-la, selecione Exibir / Janela Propriedades.

Nesta janela aparecem as propriedades do controle selecionado no momento, deixando você modificar as propriedades do controle em questão.



CRIANDO FORMULÁRIOS

Faremos um exemplo para aprendermos formulários.

Precisaremos de uma planilha conforme abaixo. O nome dessa planilha será Funcionarios.

O botão de comando Cadastrar Funcionários, por enquanto não acionará nenhuma macro.

Precisaremos de uma outra planilha conforme abaixo. O nome dessa planilha será Cargos.



No Editor do Visual Basic selecionamos Inserir / UserForm. Surgirá um formulário para trabalharmos.

Nas propriedades deste formulário definimos o seguinte:

Propriedade (Name) – nome do formulário: frmFuncionario

Propriedade Caption – nome que aparece na barra de título do formulário: Cadastro de Funcionários

Agora, iremos começar a inserir os controles no formulário. Para inserir cada controle, você somente precisa selecionar o controle desejado na caixa de ferramentas e depois desenhá-lo no formulário.

Nós iremos inserir no formulário os seguintes controles: 3 rótulos, 2 caixas de texto, 1 caixa de combinação e 3 botões de comando.

A figura abaixo demonstra como o formulário irá ficar:

Vamos configurar agora as propriedades de cada controle.

Para os rótulos, precisamos definir a propriedade Caption de cada um deles.

Para a primeira caixa de texto, definiremos as seguintes propriedades:

• (Name) – nome do controle: txtNome

• TabIndex – índice de tabulação (caso o usuário queira usar a tecla TAB para mudar entre campos): 1



Para a caixa de combinação que vem logo abaixo desta caixa de texto, definiremos as propriedades:

• (Name): cboCargo

• TabIndex: 2

Para a segunda caixa de texto que vem abaixo da caixa de combinação, definiremos assim:

• (Name): txtSalario

• TabIndex: 3

Agora, faltam os 3 botões. A configuração dos três será dada a seguir:

Botão Salvar:

• (Name): cmdSalvar

• Caption: Salvar

• TabStop – indica se o tabulador passará pelo controle (se o usuário pressionar a tecla TAB todos os campos que estão com TabStop = True serão acionados na seqüência do TabIndex): False

Botão Limpar:

• (Name): cmdLimpar

• Caption: Limpar

• TabStop: False

Botão Fechar:

• (Name): cmdFechar

• Caption: Fechar

• TabStop: False

Para configurar cada propriedade do controle basta selecionar o controle com um único clique do mouse e ir até as propriedades do mesmo.



PROGRAMANDO O FORMULÁRIO

Clicando com o botão direito do mouse sobre o fundo do Formulário, selecionaremos a opção Exibir Código.

Vamos inserir um código para que, ao ativar o formulário a caixa de combinação cboCargo seja preenchida com os nomes dos cargos que estão na planilha Cargos.

Para fazermos isso, verifique se na caixa de combinação Objeto está selecionado o objeto UserForm. Caso não esteja, selecione-o. Agora, selecione o evento Activate.

Aparecerá o evento abaixo:

O código a seguir ficará neste evento:

Neste evento, estamos selecionando a planilha Cargos com o comando Worksheets("Cargos").Select.

Depois selecionamos a célula B4 desta planilha. Fazemos isso utilizando o comando Range("B4").Select. Selecionamos esta célula, pois é a partir dela que estão os cargos que iremos utilizar para preencher nossa caixa de combinação.



Agora, utilizaremos um comando de repetição para avançarmos pela coluna B até que não haja mais dados para serem preenchidos.

Enquanto existem dados na coluna B, a partir da célula B4, vamos preenchendo a caixa de combinação cboCargo com o comando cboCargo.AddItem ActiveCell.Value.

O comando ActiveCell.Offset(1, 0).Select serve para avançarmos as linhas da tabela, ou seja, a coluna permanece sempre a mesma B e a linha a cada repetição é avançada para baixo.

Ao final retornamos para a planilha Funcionarios.

Desta forma, quando o formulário frmFuncionarios for acionado a caixa de combinação cboCargo será preenchida com todos os cargos.

Agora criaremos um procedimento chamado Limpa. Ele será utilizado quando o botão Limpar for executado e também quando o botão Salvar for executado, logo após gravar os valores contidos em cada campo.

O código do procedimento Limpa é mostrado a seguir:

Este código é bastante simples.

No formulário temos três campos: txtNome, txtSalario e cboCargo. Este procedimento faz com que a propriedade Text de cada um destes campos receba o valor vazio (“” – abre e fecha aspas duplas).

A propriedade Text dos campos é os valor que o campo recebe ou tem em determinado momento.

Se o nosso formulário tivesse mais campos, bastaria colocarmos para cada campo, a sua propriedade Text recebendo vazio. Assim, limparíamos todo o formulário.

Este procedimento será usado no botão Limpar, obviamente, e no botão Salvar, pois limpando o formulário após o usuário clicar no botão Salvar, fica mais fácil para ele caso queira cadastrar mais funcionários.

Além do procedimento Limpa que já criamos. Vamos, agora, criar a função ValidaCadastro. Esta função será responsável por testar se todos os campos foram preenchidos e, somente se tiverem sido preenchidos, é que a gravação dos dados será realizada.

Esta função não somente testará se os dados foram todos preenchidos, mas no caso do salário, além de testar se foi preenchido, testará também se foi preenchido com um valor numérico. Para este teste utilizaremos a função IsNumeric que retorna verdadeiro se o valor é numérico e falso, caso contrário.

Esta função retornará, como resultado, um valor lógico (booleano). Se tudo foi preenchido corretamente retornará o valor verdadeiro, caso contrário retornará o valor falso.

O código deste procedimento é mostrado ao lado:



Retornando ao formulário, inseriremos o código em qualquer botão, dando um clique sobre o botão que desejamos inserir este código.

Vamos começar pelo botão Fechar.

O código do mesmo é:

O comando Unload serve para fechar o formulário, neste caso, estamos informando que o formulário frmFuncionario será fechado.

O código do botão Limpar é ainda mais simples.

Teremos que acionar o procedimento Limpa já criado anteriormente.

O código do botão Limpar é:



Agora só falta inserirmos o código do botão Salvar:

A explicação deste código é simples:

Primeiramente, verificamos se está tudo preenchido corretamente utilizando o comando If ValidaCadastro Then.

Feito isso, verificamos se é o primeiro registro que iremos inserir ou não. Veja que testamos o valor que está contido na célula A4 - If Range("A4").Value = "" Then. Se este valor está vazio selecionamos a célula A4, senão selecionamos a célula A3 e, a partir dela, iremos até a última célula preenchida (Selection.End(xlDown).Select) e avançaremos para a próxima célula (ActiveCell.Offset(1, 0).Select).

Agora preenchemos os valores contidos em cada campo do formulário em suas respectiva célula.

Por último, usamos o procedimento Limpa para limpar os campos do formulário.

UTILIZANDO O FORMULÁRIO NA PLANILHA

Criaremos um módulo para chamar o formulário. No Editor do Visual Basic, criaremos um módulo indo em Inserir / Módulo.

Vamos criar uma rotina – macro chamada CadastraFuncionario.

É esta rotina que será utilizada ao clicarmos no botão Cadastra Funcionários que está na planilha Funcionarios.

O código desta rotina é:



O comando NomedoFormulario.Show serve para abrir o formulário desejado, neste caso o formulário é o frmFuncionario.

O valor 1 logo após este comando indica que enquanto este formulário estiver aberto, o usuário não poderá clicar na planilha abaixo, se não colocar nada após o evento Show, isto será possível.



SEGURANÇA DE MACROS

SEGURANÇA

Nós já vimos, no início desta apostila, como nos protegemos de algum tipo de vírus de macro.

É sempre aconselhável deixarmos selecionada a opção Médio do nível de segurança de macros.

Com esta opção selecionada, sempre que abrimos qualquer arquivo que contém macros, antes somos perguntados se desejamos ativar as macros ou não.

Desta forma, se sabemos a procedência do arquivo ativamos as macros nele contidas, senão podemos desativá-las.

A opção nível Médio escolhemos em Ferramentas / Macro / Segurança. Aparecendo a tela abaixo:

Ao abrirmos um arquivo que contém macros, a caixa de diálogo abaixo aparecerá:



PROTEGENDO CÓDIGOS

Tudo o que você faz no Editor do Visual Basic pode ficar disponível somente para quem você permitir o acesso.

Desta forma, seu código ficará protegido contra aqueles usuários que queiram abrir seus códigos, podendo fazer alguma mudança e até mesmo estragando-os.

Para proteger códigos, fazemos o seguinte:

Vamos ao Editor do Visual Basic e selecione Ferramentas / Propriedades do VBAProject.

A janela com as propriedades do projeto aparecerá.

Acionaremos a guia Proteção.



Nesta guia, marcamos a opção Bloquear projeto para exibição. Depois, digitamos uma senha para exibir o código novamente e confirmamos a senha.

Feito isso, o código deste projeto está protegido. Somente quem possui a senha poderá acessá-lo.

Para desproteger códigos, basta fazer o mesmo processo, porém, desmarcando a opção para bloqueá-lo e retirando a senha e confirmação de senha.



CONCLUSÃO

Esperamos que o conteúdo desta apostila tenha servido de suporte para as suas aulas. Lembre-se que nada substitui uma boa aula de seu professor.

A informática sofre mudanças bruscas muito rapidamente, procure no futuro uma biblioteca auxiliar e fique atento ao lançamento de novos aplicativos e versões.

A Zargon Computação estará sempre ao seu dispor para solucionar dúvidas quando necessário.

Atenciosamente,

Diretoria de Treinamento Zargon Tecnologia em Informática

Documents

Apostila - Macro e VBA Para Ms Excel