VBA – Aplicando a propriedade Anchor em Formulários VBA

Depois do lançamento das versões do Visual Studio .NET, principalmente na parte de Windows Forms, construir formulários (UserForms) em VBA ficou demasiadamente “sem graça”. Fora a quantidade de controles adicionais, temos um controle maior sobre as propriedades do formulário.

Uma das mais valorizadas é o Anchor. Esta propriedade, como o próprio nome diz, ancora um determinado controle às dimensões do seu pai. Por exemplo, se você tem um botão no meio de um formulário e este botão estiver completamente ancorado, ele será redimensionado juntamente com o formulário. Da mesma forma, ele pode ser reposicionado enquanto o formulário é redimensionado.

O fato é, não temos isso no VBA. Se for necessário tal comportamento, ele deve ser feito na mão. Ou não!

O camarada Andy Pope desenvolveu um planilha que com alguns conjuntos de classes, adiciona o comportamente da propriedade Anchor a um formulário e controles no VBA. O efeito é como mostra o vídeo abaixo:

VBA – Aplicando a propriedade Anchor em Formulários VBA from Tomamais on Vimeo.

O código e a planilha para download podem ser vistas neste link:

http://www.andypope.info/vba/Anchor.htm

.NET : Obter o tamanho de um diretório com o .NET

Dica publicada pelo pessoal da BufaloInfo.

Não há ainda, nas classes do framework, um meio de obter o tamanho total de um diretório. Por isso o tamanho total de um diretório deve ser obtido pela soma do tamanho de seus arquivos e diretórios, da seguinte forma :

public static long Size(System.IO.DirectoryInfo dirInfo)
{
	long total = 0; 
 
	// Obtem o tamanho total dos arquivos no diretório
	foreach(System.IO.FileInfo file in dirInfo.GetFiles())
	total += file.Length; 
 
	// Obtem o tamanho total dos sub-diretórios da pasta
	foreach(System.IO.DirectoryInfo dir in dirInfo.GetDirectories())
	total += Size(dir); 
 
	return total;
}

É interessante observar que esta função é recursiva : Ao encontrar uma pasta a função chama a si mesma para poder calcular o tamanho da pasta e desta forma somar ao tamanho total.

No link abaixo há uma explicação mais detalha sobre Recursividade e os cuidados a considerar em seu uso:

http://pt.wikipedia.org/wiki/Recursividade

Update – Modelo de Cadastro em VBA no Excel

Olá pessoal,

Atendo a anseios de muitos que entraram em contato solicitando alterações desde seu lançamento, atualizei o Modelo de Aplicativo de Cadastro em VBA no Microsoft Excel para prever o que foi “mais pedido”.

Uma explicação completa e a nova versão podem ser acessadas nos links abaixo:

https://www.tomasvasquez.com.br/blog/modelo-de-aplicativo-de-cadastro-em-vba-no-microsoft-excel

Discussões sobre a planilha podem ser acompanhadas por aqui:

https://www.tomasvasquez.com.br/forum/viewforum.php?f=5

Bom proveito a todos

C# – Formatos Customizados para o DateTime

Este artigo é parte integrante do Curso Online de C#, disponibilizado neste link:

https://www.tomasvasquez.com.br/cursocsharp

O exemplos abaixo mostram as opções de formatação do tipo DateTime do C# utilizando o método String.Format. Estas opções também podem ser aplicadas através do método DateTime.ToString().

Formatos Customizados

São disponibilizados os seguintes formatos: y (ano), M (mês), d (dia), h (hora 12), H (hora 24), m (minuto), s (segundo), f (fração de segundo), F (fração de segundo com zeros omitidos), t (P.M ou A.M) e z (fuso horário).

O exemplos abaixo mostram o resultado de datas formatadas utilizando as opções acima:

// cria um objeto DateTime com o valor 2008-03-09 16:05:07.123
DateTime dt = new DateTime(2008, 3, 9, 16, 5, 7, 123);
 
String.Format("{0:y yy yyy yyyy}", dt);  // "8 08 008 2008"   ano
String.Format("{0:M MM MMM MMMM}", dt);  // "3 03 Mar March"  mês
String.Format("{0:d dd ddd dddd}", dt);  // "9 09 Sun Sunday" dia
String.Format("{0:h hh H HH}",     dt);  // "4 04 16 16"      hora 12/24
String.Format("{0:m mm}",          dt);  // "5 05"            minuto
String.Format("{0:s ss}",          dt);  // "7 07"            segundo
String.Format("{0:f ff fff ffff}", dt);  // "1 12 123 1230"   fração de segundo
String.Format("{0:F FF FFF FFFF}", dt);  // "1 12 123 123"    com os zeros omitidos
String.Format("{0:t tt}",          dt);  // "P PM"            A.M. ou P.M.
String.Format("{0:z zz zzz}",      dt);  // "-6 -06 -06:00"   fuso horário

Também é possível utilizar os separadores de data (/) e hora (:) na string. O padrão sugerido é o inglês, mas estes serão substituídos para o caracterer específico da cultura/idioma configurado no sistema operacional em execução. Estes podem ser obtidos diretamente através das propriedades DateTimeForma­tInfo.DateSepa­rator e DateTimeForma­tInfo.TimeSepa­rator, sob o namespace System.Globalization.

Exemplos:

// separador de data na cultura alemã é o "."
// (ou seja, este será colocado no lugar no "/")
String.Format("{0:d/M/yyyy HH:mm:ss}", dt); // "9/3/2008 16:05:07" - Inglês (en-US)
String.Format("{0:d/M/yyyy HH:mm:ss}", dt); // "9.3.2008 16:05:07" - Alemão (de-DE)

Outros exemplos de formatos customizados:

// dia/mês sem e com zeros
String.Format("{0:d/M/yyyy}", dt);            // "9/3/2009"
String.Format("{0:dd/MM/yyyy}", dt);          // "09/03/2009"
 
// nomes de dia e mês
String.Format("{0:ddd, MMM d, yyyy}", dt);    // "Dom, Mar 9, 2009"
String.Format("{0:dddd, d de MMMM de yyyy}", dt);  // "Domingo, 9 de Março de 2009"
 
// ano com 2 e 4 dígitos
String.Format("{0:dd/MM/yy}", dt);            // "09/03/09"
String.Format("{0:dd/MM/yyyy}", dt);          // "09/03/2009"

Formatos Padrozinados para o DateTime

O DateTimeForma­tInfo define formatos padrão para cada região/país. Por exemplo , a propriedade ShortTimePattern representa uma string que contém o valor h:mm tt para a cultura en-US culture, enquanto para a cultura de-DE o valor é HH:mm.

A tabela abaixo demonstra o padrões definidos para o tipo DateTimeForma­tInfo e seus valores para a cultura en-US, que é a padrão do .NET Framework. A primeira coluna contém os “especificadores” para o método String.Format.

Especificado Propriededade do DateTimeFormatInfo Valor padrão (en-US)
t ShortTimePattern h:mm tt
d ShortDatePattern M/d/yyyy
T LongTimePattern h:mm:ss tt
D LongDatePattern dddd, MMMM dd, yyyy
f (combinação entre D e t) dddd, MMMM dd, yyyy h:mm tt
F FullDateTimePattern dddd, MMMM dd, yyyy h:mm:ss tt
g (combinação de d e t) M/d/yyyy h:mm tt
G (combinação de d e T) M/d/yyyy h:mm:ss tt
m, M MonthDayPattern MMMM dd
y, Y YearMonthPattern MMMM, yyyy
r, R RFC1123Pattern ddd, dd MMM yyyy HH':'mm':'ss 'GMT' (*)
s SortableDateTi­mePattern yyyy'-'MM'-'dd'T'HH':'mm':'ss (*)
u UniversalSorta­bleDateTimePat­tern yyyy'-'MM'-'dd HH':'mm':'ss'Z' (*)
(*) = independe da cultura

Os exemplos abaixo utilizam os especificadores padrão de formatação através do método String.Format e seus resultados, neste caso, para a cultura en-US. Lembrando que os mesmos especificadores podem ser utilizados com o método ToString().

String.Format("{0:t}", dt);  // "4:05 PM"                         ShortTime
String.Format("{0:d}", dt);  // "3/9/2008"                        ShortDate
String.Format("{0:T}", dt);  // "4:05:07 PM"                      LongTime
String.Format("{0:D}", dt);  // "Sunday, March 09, 2008"          LongDate
String.Format("{0:f}", dt);  // "Sunday, March 09, 2008 4:05 PM"  LongDate+ShortTime
String.Format("{0:F}", dt);  // "Sunday, March 09, 2008 4:05:07 PM" FullDateTime
String.Format("{0:g}", dt);  // "3/9/2008 4:05 PM"                ShortDate+ShortTime
String.Format("{0:G}", dt);  // "3/9/2008 4:05:07 PM"             ShortDate+LongTime
String.Format("{0:m}", dt);  // "March 09"                        MonthDay
String.Format("{0:y}", dt);  // "March, 2008"                     YearMonth
String.Format("{0:r}", dt);  // "Sun, 09 Mar 2008 16:05:07 GMT"   RFC1123
String.Format("{0:s}", dt);  // "2008-03-09T16:05:07"             SortableDateTime
String.Format("{0:u}", dt);  // "2008-03-09 16:05:07Z"            UniversalSortableDateTime

Efetuar os testes acima na cultura brasileira (pt-BR), o resultado será:

String.Format("{0:t}", dt);  // "16:05"					ShortTime
String.Format("{0:d}", dt);  // "9/3/2008"					ShortDate
String.Format("{0:T}", dt);  // "16:05:07"					LongTime
String.Format("{0:D}", dt);  // "domingo, 9 de março de 2008"		LongDate
String.Format("{0:f}", dt);  // "domingo, 9 de março de 2008 16:05"		LongDate+ShortTime
String.Format("{0:F}", dt);  // "domingo, 9 de março de 2008 16:05:07" 	FullDateTime
String.Format("{0:g}", dt);  // "9/3/2008 16:05"				ShortDate+ShortTime
String.Format("{0:G}", dt);  // "9/3/2008 16:05:07"				ShortDate+LongTime
String.Format("{0:m}", dt);  // "09 de março"				MonthDay
String.Format("{0:y}", dt);  // "março de 2008"				YearMonth
String.Format("{0:r}", dt);  // "Sun, 09 Mar 2008 16:05:07 GMT"		RFC1123
String.Format("{0:s}", dt);  // "2008-03-09T16:05:07"			SortableDateTime
String.Format("{0:u}", dt);  // "2008-03-09 16:05:07Z"			UniversalSortableDateTime