Arquivo da tag: Macros

Excel – Ativando Macros Automaticamente

Excel Macros Ativar Para Sempre
Eis um assunto polêmico. Tão polêmico que desde a primeira versão vez em que tive contato com o Microsoft Excel e VBA, ouço falar dele. Para quem programa em VBA, ter as macros ativadas é um requisito para que todo seu código, fruto de suas longas horas de trabalho façam algum sentido na vida de seus usuários e clientes.

Infelizmente, não há como forçar sua ativação pelo próprio Excel. É preciso intervenção externa, seja via configuração (nível de segurança de macros) ou por aplicação externa. Existe a opção de certificados digitais, que é mais segura, mas exigem um nível de conhecimento e acesso ao computador muito específico. Não vou entrar em detalhes, pois acredito que se chegou até aqui, já deve ter passado por tudo isso.

A opção que vamos explorar para obter essa façanha é a “aplicação externa”, onde vamos produzir um aplicativo em um linguagem de programação que não o VBA para ativar as automaticamente as macros. A escolha desta opção se dá, principalmente pelo fato de facilitar a distribuição, uma vez que não é preciso ter acesso a máquina do usuário ou qualquer outra configuração. É a abordagem perfeita para aqueles que distribuem suas planilhas para clientes a distância.

O aplicativo externo

Utilizarei a linguagem C# rodando sobre .NET. Se não a conhece, recomendo dar uma lida neste curso, até porque, todas as instruções para seguir os passos do aplicativo que vamos construir estão nele.

O motivo da escolha é porque, primeiro, já trabalho com ela há mais de 10 anos (UAU!). Segundo, ela tem sido a linguagem  mais utilizada para produzir aplicações para Windows na última década e vem sendo atualizada constantemente. Terceiro, se está lendo este artigo de um computador com Windows, você provavelmente já a tem instalada, tanto para executar como para criar aplicativo.

Nosso aplicativo será responsável por executar o Microsoft Excel, abrir o arquivo  que contém as nossas macros com elas ativadas, sem intervenção  do usuário. Bom demais para ser verdade não? Pois é isso mesmo que iremos fazer.

Criando o aplicativo

Passarei as instruções para que você possa criar o aplicativo sem precisar de programas adicionais. No futuro, você poderá facilitar o processo utilizando ferramentas mais avançadas, como o Visual Studio Express (que possui versões gratuitas). Para o momento, usaremos o Bloco de Notas e o compilador que vem com o .NET Framework, já instalado no seu Windows.

Vamos começar. Primeiro, crie uma pasta no seu disco no caminho:

C:\ExcelMacros.

É aqui que vamos trabalhar neste tutorial. Esse caminho não é obrigatório. No produto final, ele poderá estar onde quiser.

Obtenha seu arquivo Excel com suas macros. De preferência, coloque uma macro no Auto_Open ou no Workbook_Open para ter a visão imediata de que as macros estão sendo executadas. Salve o arquivo dentro da pasta que acabamos de criar acima. Para exemplo, vou usar um arquivo chamado ExcelComMacros.xlsm com o seguinte código VBA:

Private Sub Workbook_Open()
    MsgBox "Funcionou!"
End Sub

Dessa forma, terei certeza se o código funcionou assim que executar o aplicativo.

Agora, abra o Bloco de Notas e insira nele o seguinte código:

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Threading;
using System.Windows.Forms;
 
    static class Program
{
	// variáveis de instãncia
	static object oExcel = null;
	static object oBooks = null;
	static object oBook = null;
	static object oMissing = System.Reflection.Missing.Value;
	static System.Globalization.CultureInfo ci = Thread.CurrentThread.CurrentCulture;
 
	[STAThread]
	static void Main()
	{
		string CaminhoDoArquivo = @"C:\ExcelMacros\ExcelComMacros.xlsm";
 
		if (ExcelEstaInstalado())
		{
			try
			{
				if (System.IO.File.Exists(CaminhoDoArquivo))
				{
					AbrirArquivo(CaminhoDoArquivo); 
				}
				else
				{
					MessageBox.Show(string.Format("O arquivo {0} não foi encontrado", CaminhoDoArquivo));
				}
			}
			catch (System.IO.IOException)
			{
				MessageBox.Show("Erro de acesso ao arquivo. Verifique o arquivo de configuração ou as permissões de pasta");
			}
		}
		else
		{
			MessageBox.Show("Não foi possível encontrar a instalação do Microsoft Excel no seu computador");
		}
 
		Application.Exit();
	}
 
	private static void AbrirArquivo(string caminhoDoArquivo)
	{
		object oFileName = caminhoDoArquivo;
		oExcel = Activator.CreateInstance(Type.GetTypeFromProgID("Excel.Application"));
		oExcel.GetType().InvokeMember("AutomationSecurity", BindingFlags.SetProperty, null, oExcel, new object[] { 1 }, ci);
		oExcel.GetType().InvokeMember("Visible", BindingFlags.SetProperty, null, oExcel, new object[] { true }, ci);
		oBooks = oExcel.GetType().InvokeMember("Workbooks", BindingFlags.GetProperty, null, oExcel, null, ci);
		oBook = oBooks.GetType().InvokeMember("Open", BindingFlags.InvokeMethod, null, oBooks, new object[] { oFileName, oMissing, false }, ci);
	}
 
	public static bool ExcelEstaInstalado()
	{
		Type officeType = Type.GetTypeFromProgID("Excel.Application");
 
		if (officeType == null)
		{
			return false;
		}
		else
		{
			return true;
		}
	}
}

Salve o arquivo com o seguinte nome e caminho:

C:\ExcelMacros\AbreExcelComMacros.cs

A extensão “.cs” é própria para arquivos da linguagem C#. Como o C# é uma linguagem compilada e não script (ver mais no curso já citado), precisamos compilar nosso pequeno programa para que ele se torne um executável. Para isso, no seu computador, navegue até a pasta:

C:\Windows\Microsoft.NET\Framework

Caso seu Windows seja 64bit, a pasta alvo será “Framework64”. Dentro desta pasta, você verá todas as versões do .NET Framework, necessários para executar programas em C# instalados no seu computador. Em nosso caso, vamos utilizar a versão v2.0.50727, ou simplesmente versão 2.0, que tem tudo o que precisamos e também porque temos mais certeza de que os computadores dos clientes o terão instalado.

Agora, abra o Prompt de Comando do Windows (sim, aquela tela preta esquisita) executando-a em modo administrador. Nele, navegue até a pasta que encontramos logo acima com o comando:

cd C:\Windows\Microsoft.NET\Framework\v2.0.50727

Nessa pasta, existe o executável chamado csc.exe (CSharp Compiler), que é nosso compilador, ou seja, o cara que vai transformar nosso “.cs” em um “.exe” pra lá de útil. Se algum dia chegou a estudar Java, ele é equivalente ao “javac”.

Por fim, vamos compilar nosso programa. Execute a seguinte linha de comando:

csc /target:winexe /out:”C:\ExcelMacros\AbreExcelComMacros.exe” “C:\ExcelMacros\AbreExcelComMacros.cs”

O que isso faz? Gera um arquivo “.exe” do nosso código C# pronto para ser executado. Se alguma coisa der errado aqui, como alguma mensagem de erro do compilador, volte e recomece desde a criação da pasta.

Os três parâmetros passados para o compilador foram:

  • out: o caminho do arquivo de saída
  • target: o tipo de aplicativo gerado, no caso, um Windows Application
  • no fim de tudo, o arquivo com o código fonte da aplicação

O resultado será provavelmente este:

A pasta C:\ExcelMacros após a compilação do aplicativo
A pasta C:\ExcelMacros após a compilação do aplicativo

Em destaque, nosso arquivo .exe gerado. Agora, execute-o (duplo-clique, enter, etc). Se tudo der certo, você verá seu arquivo Excel ser aberto com as macros ativadas.

Como funciona?

Aqui, há algumas coisas para explicar. Como a intenção aqui é ser simples, vou resumir ao máximo:

O código que faz a maior parte da mágica está dentro do método AbrirArquivo, que recebe o caminho do arquivo no Excel no disco. O código cria uma instância o aplicativo Excel, o que é bastante trivial até mesmo no VBA. A grande sacada está na propriedade AutomationSecurity, que aqui é definida para o nível de segurança mínimo, o que faz que com o Excel, neste contexto, aceite executar as macros automaticamente.

O resto é simples, abre o arquivo, define o aplicativo como visível, etc. Há algumas verificações “bônus”, como checar se o arquivo existe ou se o Excel está instalado no método ExcelEstaInstalado.

Outro detalhe que merece ser mencionado é o fato do código usar Reflection (no linguajar do VB, Late Binding) ao invés de fazer referência a bibliotecas. O motivo é que o Excel e todo o Office tem APIs versionadas. Se você fizer um código fazendo referência para a versão 2010, abrir na 2007 daria conflito. O código como está, evita esse problema.

Tudo pronto

De posse desta façanha, você pode agora distribuir suas planilhas com este arquivo de apoio que servirá para facilitar a execução de seus aplicativos. Para este caso em específico, se você dominar a linguagem C#, poderá incrementar seu aplicativo com uma séria e outras verificações.

Arquivos de Exemplo:

ExcelMacros.zip (11.5 KiB)

Acompanhem a discussão no fórum:

http://www.tomasvasquez.com.br/forum/viewtopic.php?f=23&t=2946

Bom proveito!

VBA – Excluindo um módulo VBA programaticamente

Na necessidade de automação de projetos VBA, não é raro termos que manipular alguns de seus objetos, principalmente na questão de segurança. Uma delas e muito interessante é a manipulação de módulos VBA. Neste caso, o código abaixo efetua a exclusão de um módulo de nome Módulo1:

Sub ExcluirModuloVBA()
 
    Dim vbCom As Object
    Dim NomeModulo As String
    NomeModulo = "Módulo1"
    Set vbCom = Application.VBE.ActiveVBProject.VBComponents
 
    vbCom.Remove VBComponent:= vbCom.Item(NomeModulo)
    MsgBox NomeModulo & " excluído com sucesso"
 
End Sub

Lembrando, para que o códigos de manipulação de objetos VBA funcionem corretamente, é preciso habilitar a opção “Confiar no acesso ao modelo de objeto no projeto do VBA” na janela de Segurança de Macros.

Referências
http://www.ozgrid.com/VBA/delete-module.htm

VBA – Ocultando Funções e Macros para o Usuário

Quanto construímos funções e macros personalizadas em nossos programas feitos no VBA em Excel e Word, precisamos expô-las para que sejam acessadas por outros módulos ou mesmo Forms. Para isso, declaramo-as como Public ou simplesmente ocultamos o modificador de acesso que é Public por padrão.

Um inconveniente do VBA é que nossas Functions e Subs ficam disponíveis para o usuário quando este abre a janela de execução de macros (Alt+F8). Isso pode gerar uma série de situações inesperadas, além de erros.

Para que as funções desenvolvidas como Public no VBA não apareçam na caixa de diálogo de execução de macros, basta que na janela de código, seja um Módulo ou UserForm seja colocada a seguinte diretiva no cabeçalho:

Option Private Module

Experimente agora abrir a caixa de diálogo de execução de Macros ou no Excel, acessar a caixa de diálogo Inserir Função selecionar a  opção “Definida pelo usuário” e veja que as Functions e Subs dentro do módulo com a declaração acima.

Note também que a declaração só oculta o código VBA neste escopo. As Functions e Subs continuarão disponíveis para todo o aplicativo VBA, não afetando o aplicativo.

Bom proveito!

Referências:

http://www.allexperts.com/

Tomás

VBA – Agendando a execução de macros com a função OnTime

Introdução

Uma necessidade muito comum em aplicativos é utilizar critérios de tempo para execução de algumas rotinas. Esta é uma tarefa trivial em várias linguagens, mas poucos pensam em utilizá-la no VBA por achar muito complexo, tendo que envolver chamadas de API e outros recursos mais avançados da linguagem

Porém, o VBA do Microsoft Excel disponibiliza um método que facilita esse tipo de trabalho, o método OnTime().

O que é

O método OnTime programa um procedimento para ser executado em um momento especificado no futuro (seja em uma determinada hora do dia ou após uma quantidade específica de tempo decorrido).

A estrutura de chamada à função OnTime se faz da seguinte forma:

Application.OnTime([EarliestTime], [Procedure], [LatestTime], [Schedule])

Argumentos da função:

EarliestTime

Variant necessário. Especifica quando você deseja que esse procedimento seja executado.

Procedure

String necessário. O nome do procedimento a ser executado.

LatestTime

Variant opcional. Especifica até quando o procedimento pode ser executado. Por exemplo, se LatestTime estiver definido como EarliestTime + 30 e o Microsoft Excel não estiver em modo Pronto, Copiar, Recortar ou Localizar em EarliestTime devido a um outro procedimento estar sendo executado, o Microsoft Excel esperará 30 segundos para que o primeiro procedimento termine. Se o Microsoft Excel não estiver em modo Pronto dentro de 30 segundos, o procedimento não será executado. Se esse argumento for omitido, o Microsoft Excel esperará até que o procedimento possa ser executado.

Schedule

Variant opcional. True para programar um novo procedimento OnTime. False para limpar um procedimento definido anteriormente. O valor padrão é True.

Exemplo

Para informar ao VBA um valor de data válido para execução do método OnTime, usa-se a propriedade Now do VBA juntamente com a função TimeValue( . Somando as duas, é possível programar o procedimento para ser executado quando uma quantidade de tempo específica (contando a partir de agora) tiver decorrido.

Caso seja necessário informar uma hora específica, por exemplo, 3 da tarde (ou 15:00), usa-se TimeValue(time) onde time é um valor de hora informado através de uma String.

Veja os exemplos de código abaixo:

Public Sub ExecutaOnTime()
MsgBox "Opa! Executou."
End Sub
Public Sub TesteOnTime()
Call Application.OnTime(Now +
TimeValue("00:00:10"), "ExecutaOnTime")
End Sub

Execute a função TesteOnTime, deixando o cursor do mouse sobre ele (linha 5 a 6) e clicando em F5. Se tudo der certo, em 10 segundos você deverá ver esta mensagem:

Pronto! Conforme configuramos o OnTime para executar 10 segundos após a hora atual (linha 6) pois, Now retorna a data e hora atual e TimeValue(“00:00:10”) representa para o VBA 10 segundos, após executar a função TesteOnTime, ela programa a função ExecutaOnTime (linha 1) para ser executada neste tempo.

Para efeitos de teste, configure outros valores de tempo, mas tome o cuidado que sejam pequenos pois, se configurar para executar daqui a 24 horas (“24:00:00”), vai ter que esperar um bom tempo.

Para fazer outro teste interessante do OnTime, mude o código para ficar desta forma:

Public Sub ExecutaOnTime()
MsgBox "Opa!
Executou."
End Sub
Public Sub TesteOnTime()
Call Application.OnTime(TimeValue("13:00:00"),
"ExecutaOnTime")
End Sub

Da forma que está, o código irá configurar a função ExecutaOnTime (linha 1) para ser executada às na próxima 13:00 do computador em que está sendo executada. Como este é apenas um exemplo, configure uma hora que estiver mais próxima para não esperar muito.

É possível também cancelar a execução de uma macro agendada com o OnTime. O exemplo de código abaixo cancela a definição de OnTime do exemplo anterior, ou seja, caso a execução da função ExecutaOnTime estiver agendada, executar a função CancelaOnTime fará com que esta programação seja cancelada. isso é feito passando o valor False para o parâmetro Schedule (linha 10):

Public Sub</span> ExecutaOnTime()
MsgBox "Opa! Executou."
End Sub
Public Sub TesteOnTime()
Call Application.OnTime(TimeValue("13:00:00"),
"ExecutaOnTime")
End Sub
Public Sub</span> CancelaOnTime()
Call Application.OnTime(EarliestTime:=TimeValue("13:00:00"),
Procedure:="ExecutaOnTime", Schedule:=False)
End Sub

Conclusão

Com este recurso em mãos, é possível atender a algumas necessidades que no contexto do Excel pareciam inviáveis. Um exemplo típico é uma tela de apresentação ou SplashScreen como é conhecida que apresenta o programa e fecha em alguns segundos. Este é um bom teste para experimentar o uso do OnTime. Fica aí um desafio.