Tudo sobre Visual Basic

Tudo sobre Visual Basic

(Parte 5 de 7)

É importante destacar que podem existir um bloco With dentro de outro, sendo que o mais interno terá efeito sobre todos os objetos a ele subordinados enquanto não for encontrado um End With fechando-o. Antes e depois do bloco mais interno, quem tem efeito é o With mais externo.

Evento Load

Load é o evento que ocorre quando um formulário é lido. Usamos Load normalmente para a inicialização de variáveis privadas ou então para escrever comandos e rotinas que devem ser executadas logo que o formulário é aberto. Ou melhor: no evento Load de um formulário usamos comandos e rotinas cuja execução é necessária ao seu funcionamento e de seus controles de uma maneira geral.

O Aplicativo TesteCor

Vamos testar o que aprendemos em um novo aplicativo. Ele funcionará assim: quando um botão de comando for clicado, a cor do texto de um label mudará para a próxima cor numa escala pré-definida, e o rótulo desse label deverá informar qual é a cor atual. Por exemplo: se a cor atual for “2 – Verde”, passará a ser “3 – Ciano”. Um outro botão fará o processo inverso, ou melhor: a cor passará a ser a anterior na escala.

Mas qual é a melhor maneira de codificar esse processo todo? Vejamos:

Algumas cores serão modificadas a cada vez que um dos botões for clicado. Então, precisamos guardar o código da cor atual em uma variável que possa ser acessada por várias procedures, já que cada evento é ligado a uma procedure. Resumindo: precisamos de variáveis privadas.

Existe também uma seqüência de comandos repetida para alguns botões: a mudança de uma das cores do label e a exibição do nome dessa cor. Então, podemos criar uma subrotina que contenha essa seqüência de comandos e possa ser chamada pela procedure Click de um dos botões, de modo a não haver necessidade de repetição de código.

Microsoft Visual Basic 632

Funções QBColor e RGB

Essas funções geram cores de acordo com valores que representam códigos associados a elas. A diferença entre ambas é que QBColor só aceita os valores de 0 a 15, cada um representando uma cor diferente, enquanto RGB permite a composição de uma cor pela mistura das cores básicas Vermelho (Red), Verde (Green) e Azul (Blue), daí seu nome. A quantidade de vermelho, verde e azul que deve ser usada na composição da cor é representada por valores inteiros que variam de 0 a 255. Veja as sintaxes:

QBColor(<código>) RGB(<vermelho>,<verde>,<azul>)

Os códigos aceitos por QBColor são os seguintes:

Código Cor Código Cor Código Cor Código Cor 0 Preto 4 Vermelho 8 Cinza 12 Vermelho Claro 1Azul5Magenta9Azul Claro13Magenta Claro 2 Verde 6 Amarelo 10 Verde Claro 14 Amarelo Claro 3 Ciano 7 Branco 1 Ciano Claro 15 Branco Brilhante

Na tabela abaixo estão os valores de vermelho, verde e azul necessários para se conseguir algumas cores com a função RGB:

Cor Desejada Vermelho Verde Azul

Como você com certeza já percebeu, em nosso caso a função QBColor é a que melhor se encaixa. Mas vamos começar a trabalhar: crie o formulário de acordo com o exemplo:

Altere as propriedades dos objetos:

ObjetoNomeOutras Propriedades = Valor

FormulárioFrmTesteCaption = Teste das Cores

StartUpPosition = 2 – Center Screen

LabelLabel1Caption = Cor do Texto: LabelLabel2Caption = Cor do Fundo:

Microsoft Visual Basic 633

ObjetoNomeOutras Propriedades = Valor

LabelLblTesteCaption = Teste das Cores

Alignment = 2 – Center BackColor = Branco BorderStyle = 1 – Fixed Single Font = Arial, Negrito, tamanho 20

LabelLblTextoCaption = 0 – Preto

BorderStyle = 1 – Fixed Single Font = Negrito

LabelLblFundoCaption = 15 – Branco Brilhante

BorderStyle = 1 – Fixed Single Font = Negrito

Botão de ComandocmdTextoAntCaption = Anterior Botão de ComandocmdTextoProxCaption = Próxima Botão de ComandocmdFundoAntCaption = Anterior Botão de ComandocmdFundoProxCaption = Próxima

Sendo assim, vamos criar nossa codificação:

1.Abra a janela Código na seção Declarations. Vamos declarar as variáveis privadas:

Dim vCorTexto As Integer Dim vCorFundo As Integer

2. Dê agora um duplo click sobre uma área do formulário que não contenha nenhum controle. A janela

Código é aberta no evento Load do objeto Form, aonde vamos inicializar as variáveis que declaramos no item anterior:

Private Sub Form_Load()
vCorTexto = 0

vCorFundo = 15 End Sub

Private Sub cmdTextoAnt_Click()
vCorTexto = vCorTexto - 1
If vCorTexto < 0 Then vCorTexto = 15

3.Acesse a procedure Click do botão cmdTextoAnt e escreva os comandos abaixo: MudaCorTexto End Sub

Note como o comando If...Then foi usado: já que só existe um comando após Then, End If não foi necessário. No entanto, poderíamos escrever essa estrutura da seguinte maneira, com o mesmo resultado:

If vCorTexto < 0 Then vCorTexto = 15 End If

Você deve ter percebido também que temos algo novo nessa procedure: o comando MudaCorTexto. Na verdade, isso é a chamada a uma subrotina, aquela que citamos quando estávamos planejando nosso aplicativo. Podemos criar uma subrotina através da opção Add Procedure do menu Tools: o VB abre uma caixa de diálogo onde devemos informar, entre outras coisas, o nome da subrotina que será criada (veja a figura na próxima página), mas existe uma maneira mais simples:

Criando uma Subrotina

A criação de subrotinas pode ser feita diretamente na janela Código, bastando para isso fazer a declaração da procedure (ou funcão – veremos mais adiante). Subrotinas podem ser declaradas como privadas ou públicas. Usamos a palavra reservada Sub para inicar uma procedure, e o comando “End Sub” para fechá-la.

1. Com a janela Código aberta, escolha a opção General na caixa de combinação Object. Proc deve estar na seção Declarations;

2.Declare a procedure MudaCorTexto escrevendo o cabeçalho a seguir: Public Sub MudaCorTexto()

Microsoft Visual Basic 634

A janela Add Procedure

3. Note que, quando terminar a declaração, o próprio VB insere o comando End Sub fechando a procedure, que deve estar parecida com a da figura abaixo:

Private Sub MudaCorTexto()
With lblTexto

4.Vamos então escrever os comandos da subrotina: lblTeste.ForeColor = QBColor(vCorTexto)

Select Case vCorTexto

Case 0

.Caption = "0 - Preto"

Case 1

.Caption = "1 - Azul"

Case 2

.Caption = "2 - Verde"

Case 3

.Caption = "3 - Ciano"

Case 4

.Caption = "4 - Vermelho"

Case 5

.Caption = "5 - Magenta"

Case 6

.Caption = "6 - Amarelo"

Case 7

.Caption = "7 - Branco"

Case 8

.Caption = "8 - Cinza"

Case 9

.Caption = "9 - Azul Claro"

Case 10

.Caption = "10 - Verde Claro"

Case 1

.Caption = "1 - Ciano Claro"

Case 12

.Caption = "12 - Vermelho Claro"

Case 13

.Caption = "13 - Magenta Claro"

Case 14

.Caption = "14 - Amarelo Claro"

Case Else .Caption = "15 - Branco Brilhante"

Microsoft Visual Basic 635

End Select

End With End Sub

5.Execute o aplicativo, teste o funcionamento do botão e verifique se está de acordo com o planejado.

6. Escreva a procedure cmdTextoProx_Click: note que ela é quase igual à do botão cmdTextoAnt, só que muda para a próxima cor na escala:

Private Sub cmdTextoProx_Click()
vCorTexto = vCorTexto + 1
If vCorTexto > 15 Then vCorTexto = 0
'Chamada da subrotina:

MudaCorTexto End Sub

7. Escreva agora as procedures para os eventos click dos botões cmdFundoAnt e cmdFundoProx, e a subrotina a ser chamada por elas, que deve ter o nome de MudaCorFundo. A propriedade a ser alterada para exibir a nova cor é a BackColor;

8.Teste o funcionamento de todos os botões e verifique se está de acordo com nosso planejamento. 9.Salve o formulário com o nome de frmTeste e o projeto com o nome de TesteCor.

Estruturas de Repetição

As Estruturas de Repetição permitem que uma ou mais linhas de código sejam executadas um determinado número de vezes ou até que uma condição seja verdadeira. Resumindo: criam loops.

Estruturas Do While

A estrutura Do While (faça enquanto) permite que um determinado bloco de comandos seja executado enquanto uma condição for verdadeira. Existem dois tipos de estruturas Do While:

Loop com teste a priori: como você sabe, esse tipo de loop testa sua condição de término antes da execução dos comandos que estão nele contidos, o que implica na possibilidade desses comandos não serem executados, caso a condição de término seja satisfeita logo de início. A sintaxe para a criação de loops com teste a priori em VB usando Do While é a seguinte:

Do While <condição> <comandos> Loop

Loop com teste a posteriori: já esse tipo de loop testa sua condição de término após a execução dos comandos nele contidos, ou seja, os comandos serão executados ao menos uma vez, mesmo que a condição de término seja satisfeita logo de início. A sintaxe de Do While com teste a posteriori é a seguinte:

Do <comandos> Loop While <condição>

Veja exemplos da estrutura Do While usando os dois tipos de loop para a mesma operação:

Do While vTotal < 500Do vTotal = vTotal + QuantidadevTotal = vTotal + Quantidade LoopLoop While vTotal < 500

Estruturas Do Until

Do Until quer dizer “faça até que”. Essa estrutura difere da anterior por executar os comandos do loop enquanto a condição for falsa. Também existem duas sintaxes para Do Until:

Loop com teste a priori:Do Until <condição> <comandos> Loop

Loops com teste a posteriori:Do <comandos> Loop Until <condição>

Microsoft Visual Basic 636

Para que a diferença entre as duas estruturas fique mais clara, vamos alterar os exemplos usados em Do While para estruturas Do Until. Note que foi necessária uma mudança na formulação da condição de término do loop para obtermos o mesmo efeito:

Do Until vTotal >= 500Do vTotal = vTotal + QuantidadevTotal = vTotal + Quantidade LoopLoop Until vTotal >= 500

Estrutura For Next

Essa estrutura deve ser usada quando se conhece de antemão o número de vezes que o loop será executado. Sua sintaxe é a seguinte:

For <contador> = <valor inicial> To <valor final> [Step <valor do incremento>] <comandos> Next <contador>

Onde:

Contador é uma variável que será usada para controlar o número de vezes que o loop será executado; Valor Inicial é o primeiro valor que a variável de controle assumirá; Valor Final é o último valor que o contador assumirá na execução do loop;

Valor do Incremento é o valor que será somado ou subtraído (pois podemos usar valores negativos) do contador a cada vez que Next for executado.

Ao entrar em um loop For Next o VB faz com que o contador seja igual ao valor de início. A cada vez que os comandos são executados e a estrutura atinge o Next, o contador é incrementado pelo valor indicado em Step (que é opcional – se não for declarado será assumido o valor 1) e comparado com o valor final indicado. Se o contador ultrapassar o valor final, o loop será terminado, caso contrário a seqüência de comandos será executada novamente.

Exemplo: a estrutura abaixo calcula a soma dos números de 1 a 100:

vSoma = 0 For i = 1 To 100 vSoma = vSoma + i Next i

Com uma pequena mudança na estrutura, somaremos apenas os números ímpares entre 1 e 100:

vSoma = 0 For i = 1 To 100 Step 2 vSoma = vSoma + i Next i

Comando Exit

O comando Exit permite que um loop ou uma subrotina sejam abandonados (terminem antes do final normal de sua execução). A sintaxe do comando Exit exige que indiquemos que estrutura queremos abandonar, assim:

Para abandonar um loop Do: Exit Do
Para abandonar um loop For: Exit For
Para abandonar uma subrotina Sub: Exit Sub
Para abandonar uma subrotina Function: Exit Function

And, Or, Xor e Not

Os operadores lógicos And, Or, Xor e Not (E, Ou, Ou exclusivo e Não) são normalmente usados em estruturas de controle para estabelecer uma relação entre duas ou mais condições em uma mesma expressão. Como já vimos na lição 2, a função desses operadores é a seguinte:

And faz uma combinação das condições, retornando verdadeiro somente se todas as condições da expressão forem verdadeiras.

Or funciona de maneira contrária: a expressão só será falsa se todas as condições forem falsas.

Microsoft Visual Basic 637

Xor é semelhante a Or, mas retorna falso se todas as condições forem verdadeiras. Not inverte a condição de verdadeiro para falso e vice-versa. Veja a tabela de resultados:

OperadorCondição 1Condição 2Resultado

And

Verdadeiro Verdadeiro Verdadeiro Verdadeiro Falso Falso

Falso Verdadeiro Falso Falso Falso Falso

Verdadeiro Verdadeiro Verdadeiro Verdadeiro Falso Verdadeiro

Falso Verdadeiro Verdadeiro Falso Falso Falso

Xor

Verdadeiro Verdadeiro Falso Verdadeiro Falso Verdadeiro

Falso Verdadeiro Verdadeiro Falso Falso Falso

Not Verdadeiro Falso Falso Verdadeiro

O Aplicativo Fatorial

Para testar o uso das estruturas de repetição, vamos escrever um pequeno aplicativo para calcular o fatorial de um número inteiro (n!), que é o resultado da multiplicação dos números inteiros de 1 até n. Exemplo:

Veja o modelo e a tabela de propriedades no início da próxima página. A codificação do aplicativo envolve apenas um evento: quando o usuário clicar em cmdCalcular ou teclar Enter o fatorial do número digitado em txtNúmero será calculado e exibido em lblFatorial.

1. Inicie um novo projeto; 2.Formate o formulário e altere as propriedades dos objetos como a seguir:

ObjetoNomeOutras Propriedades = Valor

FormuláriofrmFatorialCaption = Fatorial

StartUpPosition = 2 – Center Screen

LabelLabel1Caption = Digite um número: LabelLabel2Caption = O fatorial desse número é: Caixa de TextotxtNúmeroText = “” LabellblFatorialCaption = “”

Alignment = 2 – Center BackColor = Branco BorderStyle = 1 – Fixed Single

Botão de ComandocmdCalcularCaption = Calcular Default = True

Microsoft Visual Basic 638

3.Abra a janela Código no evento Click do botão Calcular e escreva os comandos para o cálculo:

Dim vNúmero As Double, vFatorial As Double
vNúmero = Val(txtNúmero.Text)
If vNúmero < 0 Then
Beep
lblFatorial.Caption = Empty
Else
If vNúmero = 0 Or vNúmero = 1 Then
lblFatorial.Caption = 1
Else
vFatorial = 1
Do
vFatorial = vFatorial * vNúmero
vNúmero = vNúmero - 1
Loop Until vNúmero <= 1
lblFatorial.Caption = Str(vFatorial)
End If
End If

Private Sub cmdCalcular_Click() txtNúmero.SetFocus End Sub

Observações:

Por definição, 0! = 1; O comando Beep faz com que o computador emita um sinal sonoro (um “apito”).

Note o uso do operador Or no segundo If: poderíamos escrever a condição vNúmero <= 1 ao invés da expressão usada, já que nesse ponto temos a certeza que vNúmero não é negativo (veja o If anterior), mas fizemos isso para exemplificar o uso de Or;

Como exercício de fixação, reescreva o loop do cálculo do fatorial usando as estruturas Do While e For Next. Tente também modificar as estruturas de teste a posteriori para teste a priori.

4.Grave o formulário com o nome de frmFator e o projeto com o nome de Fatorial.

Microsoft Visual Basic 639

Lição 5: Tratamento de Erros de Execução

Eis um assunto importantíssimo: tratamento de erros irrecuperáveis de execução. Quando um erro irrecuperável acontece, o VB emite uma mensagem informando o erro e encerra a execução do aplicativo. Esses erros acontecem sob várias condições: um arquivo não encontrado, incompatibilidade entre tipos de variáveis, uma chamada de função inválida, falta de memória, etc.

É fácil conferirmos essa característica: execute a calculadora que fizemos na lição 2 e, ao invés de um número, digite uma letra qualquer nas caixa de textos. Quando você executar um cálculo, uma caixa de mensagem com os dizeres “Run-time Error” aparecerá informando o tipo do erro que ocorreu, e o aplicativo será encerrado.

Nessa lição aprenderemos a trabalhar com esses erros de modo que, mesmo que um deles aconteça, o aplicativo não seja encerrado. Adicionalmente, aprenderemos a usar as caixas de mensagem e de entrada da dados do VB.

Comando On Error

Esse comando é a chave para o tratamento de erros no VB: sua função é a de desviar o fluxo da execução de uma procedure para um parágrafo em caso de erro irrecuperável. Sua sintaxe é a seguinte:

On Error GoTo <nome_de_parágrafo>

O parágrafo para o qual o fluxo será desviado deve obrigatoriamente fazer parte da mesma procedure, e deve estar posicionado no final da mesma, antes do comando End Sub. O nome do parágrafo é identificado por ser terminado com dois pontos – “:”.

(Parte 5 de 7)

Comentários