Curso Básico de Logic Basic 7.

0
© 2002-2010 Eleusmário Mariano Rabelo

Introdução
Apresentação
O Logic Basic é uma linguagem Básica de programação para facilitar o
desenvolvimento de programas no ambiente Windows, destinada a desenvolver a
lógica de programação em crianças, jovens e adultos iniciantes em computação,
mas é ideal também para programadores profissionais que desejam desenvolver
programas com maior rapidez e facilidade.
É uma linguagem simples, divertida e interessante, porém com poderosos
recursos que poderão ser utilizados pelo programador à medida em que for se
aprofundando dentro da linguagem.

O Logic Basic é muito amigável, com um ambiente de programação claro e

bastante estruturado, ou seja, ele incentiva o programador a fazer programas
organizados, exercitando assim, o seu raciocínio de acordo com as mais modernas
linguagens de programação.

Com o Logic Basic, você poderá desenvolver programas comerciais, de animação

gráfica, jogos, apresentações áudio-visuais, programas educativos, musicais, e
tudo aquilo que sua mente puder imaginar.

Visão geral sobre o Logic Basic

Como funciona o Logic Basic?
O Logic Basic possui dois ambientes: Janela e Código. No ambiente de Código
você escreverá o seu programa, e no ambiente da Janela o seu programa será
executado.

Ao ser acionado o botão Executar (botão com uma seta verde para a direita), o
Logic Basic executará o(s) comando(s) da primeira linha, depois o da segunda,
depois o da terceira e assim por diante. Ou seja, ele executará o seu programa
como se estivesse lendo um texto, onde você diz: "Faça isso", "Faça aquilo", ... na
ordem da primeira linha para a última.

A Janela é um local onde você, através dos comandos do Código, escreverá

palavras, desenhará figuras, e também receberá informações do teclado, do
mouse, do disco rígido do computador, etc.
Nela você poderá desenhar fundos, que são imagens que ficarão fixas no plano de
fundo da janela, também poderá desenhar objetos, que são figuras para as quais
você atribuirá um nome, e que poderão ser movidas ou modificadas através da
programação. Há também sons que poderão ser tocados a qualquer momento
durante a execução de seu programa.

Há também as Extensões de Código, onde você poderá colocar alguns trechos do

código para melhor organizar o seu programa. Para acessar o código principal,
deve-se pressionar o botão Código (botão contendo a letra "C"), e para acessar
as extensões, basta pressionar um dos 6 botões do lado direito da janela de
código.

Salvando e abrindo programas

Os programas em Logic Basic poderão ser salvos em qualquer pasta selecionada
pelo programador,. e é aconselhável que se crie uma pasta para cada programa,
onde serão gravados o código fonte, as figuras, objetos, sons, etc. referentes ao
programa. A extensão dos programas em Logic Basic é .LBC, mas não é
necessário você informá-la, pois o Logic Basic a colocará automaticamente.

Nome menu Arquivo temos quatro opções para criação, abertura e gravação de
programas:
Novo programa: Quando este botão for pressionado, O Visual apagará o box de
código e criará um novo programa com o nome de Novo.Lbc.
Abrir programa: O Logic Basic apresentará a você uma caixa de diálogo
contendo os
nomes dos programas gravados. Digite o nome do programa desejado ou dê um
duplo-clique em cima do mesmo.
Salvar: Ao pressionar este botão, o programa que estiver no box de código
Será gravado no disco com o nome atual, sem perguntas.
Salvar como: O Logic Basic apresentará uma caixa de diálogo para que você
informe o nome do programa a ser gravado. Caso o mesmo já tenha
sido gravado anteriormente, basta dar um duplo-clique no programa
da listagem.

Extensões de código
A extensões de código são destinadas para se colocar partes do código para
melhor organizar o programa. Você pode imaginar essas extensões como uma
continuação do código principal, e quando você executa o programa é como elas
estivessem concatenadas (emendadas) ao código principal. É aconselhável que
nas extensões sejam colocados apenas funções que são executadas a partir do
código principal, como veremos mais adiante.

Ao pressionar um dos botões de extensões, o Logic Basic apresentará na janela

de código a extensão correspondente ao número pressionado. Na parte superior
esquerda da janela de código há uma caixa de texto (com a frase "Código
Principal") onde deverá ser escrito um nome para identificar o trecho de código
referente à extensão. Este nome é opcional, não é necessário colocá-lo, mas é
recomendável, para melhorar a clareza e o raciocínio do programa.

Primeiro Programa em Logic Basic

A janela do Logic Basic é dividida em linhas e colunas. A quantidade padrão de
linhas e colunas é 27 por 79 respectivamente, ou seja, o número da primeira linha
é 0 (zero) e a última é 26, o número da primeira coluna é 0 e a última é 78.
O nosso primeiro programa será posicionar uma frase em uma determinada linha e
em uma determinada coluna (a isto chamamos "Coordenada") e escrevê-la na
janela.

Escrevendo na Janela do Logic Basic

A primeira coisa a fazer é escrever um comando no código para informar ao Logic
Basic em qual linha e coluna ele deverá escrever ou desenhar alguma coisa. O
nome deste comando é Posicione:

Posicione Linha, Coluna

Os valores Linha e Coluna são denominados ARGUMENTOS. Portanto, Linha é

o primeiro argumento e Coluna é o segundo argumento do comando Posicione.
Os argumentos de um comando devem ser separados por vírgulas, e podemos
escrever um comando por linha, ou vários na mesma linha, desde que sejam
separados por ; (ponto e vírgula). O próximo passo então é escrever uma frase na
janela. Para isso utilizaremos o comando Escreva:

Escreva "Uma frase qualquer..."

Note que a frase deve estar entre aspas, para que o Logic Basic trate as palavras
como apenas um argumento; sem as aspas, as palavras poderiam ser
confundidas, no caso do exemplo acima, como se fossem três argumentos!

Executando o primeiro programa

Vamos então colocar em prática o que foi ensinado até agora. No ambiente de
Código digite os seguintes comandos:

Posicione 11, 33
Escreva "Alô Mundo!"

Em seguida pressione o botão Executar, ou a tecla F5. O resultado deverá ser a

frase Alô Mundo! escrita no centro da janela do Logic Basic.
Para voltar ao ambiente de código, pressione F6.

Exercício
Altere os valores dos argumentos Linha e Coluna do comando Posicione, e veja os
resultados. Altere também a frase do comando Escreva.

Comandos Básicos
Mensagem
O Logic Basic possui também um comando denominado Mensagem, idêntico ao
comando Escreva, com a diferença que este não escreve diretamente na janela
do Logic Basic, e sim em um pequeno box de mensagem centralizado no vídeo, e
portanto, sua posição não obedece ao comando Posicione:

Mensagem "Uma frase qualquer..."

LimpaJanela
O comando LimpaJanela apaga todos os textos da janela do Logic Basic, exceto
a imagem de fundo e os objetos. Este comando não possui nenhum argumento:

LimpaJanela

Fundo
O comando Fundo coloca uma imagem de fundo na janela do Logic Basic. Essa
imagem de fundo é fixa e sempre ficará atrás de todos os textos, campos e objetos
que forem escritos ou desenhados na janela.
Para isso, deve-se digitar o comando Fundo, o sinal de igual, e em seguida o
caminho do arquivo de imagem, que pode ser qualquer arquivo de imagem que
contenha a extensão bmp, jpg, gif, ico, wmf, emf, por exemplo:

Fundo = "C:\LogicBasic\Fundos\Espaco.jpg”

Para informar o caminho, deve-se digitar o "drive", as pastas e sub-pastas,

separadas por barra inversa, e por último o nome do arquivo. Se o arquivo de
imagem estiver na mesma pasta onde estiver gravado o programa fonte, basta
informar o nome do arquivo de imagem, no caso do exemplo acima, Espaco.jpg.
O Comando acima colocará a imagem de nome Espaco.jpg no fundo da janela do
Logic Basic. Note que os nomes dos fundos não possuem acentos, nem Ç, assim
como os nomes dos comandos, objetos, sons, etc. Este critério foi adotado para
facilitar a programação, pois padronizando estes nomes, evita-se confusões e
erros na codificação, incentivando o programador a adotar boas técnicas de
programação.

Comentários
O Logic Basic permite você colocar comentários no código do programa, de modo
que eles não tenham nenhum efeito no programa; é como se não existissem no
código.

Para isso basta colocar o sinal ' (apóstrofo), no início da linha ou após alguma
linha de comando, que qualquer texto digitado após ele será ignorado pelo Logic
Basic:

Fundo = "C:\Windows\Nuvens.jpg" 'Coloca um fundo de nuvens na Janela

No exemplo acima, o texto escrito após o comando

Fundo = "C:\Windows\Nuvens.jpg" será ignorado.

Colocando vários comandos em uma mesma linha

Quando for colocado ; (ponto-e-vírgula) após um comando, poderá ser escrito
outro comando após o mesmo, na mesma linha. Isto melhora a clareza do
programa, e também diminui o número de linhas. Na verdade, para o Logic Basic,
cada comando separado por ponto-e-vírgula é considerado como uma nova linha.
Desta maneira, você poderá colocar quantos comandos desejar em uma mesma
linha. Por exemplo:

Posicione 11, 33; Escreva "Alô Mundo!"

O exemplo acima escreve o nosso primeiro programa com dois comandos em uma
mesma linha.

Comandos de finalização de programas

Os comandos FimPrograma e FimJanela encerram o programa na linha em que
forem colocados. O primeiro apenas finaliza o programa, mas mantém a Janela do
Logic Basic ativa. O segundo, finaliza o programa e fecha a Janela do Logic Basic.

Memoria
No Logic Basic você poderá criar memórias para guardar textos, números, objetos,
figuras, sons, etc. Para isto você deverá utilizar o comando denominado Memoria.
Você poderá colocar vários destes comandos no código, mas eles devem ser
colocados sempre nas primeiras linhas do programa do código principal. Para criar
as memórias basta digitar os nomes das memórias logo após o comando Memoria:
Memoria Nome, Valor, Sol, SomOceano
Memoria X, Y, Texto, Aviao, Lua

O nome de uma memória não poderá conter espaços em seu corpo, por isso no
exemplo acima, a memória "SomOceano" não foi escrita "Som Oceano".

Após as memórias terem sido criadas, poderemos colocar textos, números,

objetos e sons nas mesmas, utilizando o operador = (igual). Por exemplo:

Nome = "João da Silva"

Valor = 1234,50

Note que textos devem ser colocados entre aspas, veremos o porquê a seguir...

Ao atribuirmos textos a uma memória, eles devem ser escritos entre aspas. Na
maioria das linguagens de programação, uma sequência de letras ou caracteres
são denominados Strings. A partir de agora, trataremos textos como Strings para
facilitar o diálogo, e também para que o programador comece a se familiarizar com
este termo. Portanto, quando falarmos de Strings estaremos falando de textos,
letras, e também números na forma de texto.

Um número, quando estiver entre aspas, será tratado como uma String, e quando
estiver sem aspas, será tratado como um valor numérico; isto quer dizer que
poderemos efetuar cálculos com ele.

Uma memória pode ser atribuída a outra memória, por exemplo:

X=7
Valor = X

No exemplo acima, a memória X recebeu o número 7. Em seguida a memória

Valor recebeu o valor da memória X, que é 7. Portanto, o conteúdo da memória
Valor é igual a 7.

Para o Logic Basic, um número, ou uma memória contendo um número, são vistos
como números. Ou seja, 7 é um número, e X também é um número. Só que você
não pode ver o número que está em X, mas o Logic Basic sim, porque está em
sua memória. O mesmo ocorre com strings, objetos e sons. Quando uma palavra
for uma memória, o Logic Basic irá trabalhar com o seu conteúdo e não com o seu
nome. Vamos exemplificar com o seguinte programa:

Escreva Nome

Ao Pressionar o botão Janela, o resultado será a seguinte palavra: Nome. O Logic

Basic escreveu Nome porque esta palavra não é uma memória.
Agora vamos modificar o programa para o seguinte código:
Memoria Nome
Nome = "João da Silva"
Escreva Nome

Ao pressionar o botão Janela, o resultado agora será o seguinte: João da Silva. O

Logic Basic escreveu João da Silva, porque a palavra Nome foi declarada como
uma memória ao Logic Basic, e ele sabendo disso, escreveu o seu contéudo.

Os tipos de memória do Logic Basic se resumem em quatro: memória de textos

(strings), memórias numéricas, memórias de objetos e memórias de sons.

A função das memórias não é apenas guardar textos e números, elas podem ser
modificadas a qualquer momento pelo programador, através de operadores,
comandos e novas atribuições. No Logic Basic temos quatro tipos de operadores:
Operadores aritméticos, Operadores de incremento e decremento, de comparação
e lógicos.

Operadores Aritméticos:

+ Soma
- Diferença
* Multiplicação
/ Divisão
% Resto da divisão

Operadores de incremento e decremento:

++ Soma 1 a ele mesmo

-- Diminui 1 dele mesmo
+= Soma a ele um número
-= Diminui dele um número

Operadores de comparação:

= Igual
< Menor que
> Maior que
<= Menor ou igual
>= Maior ou igual
<> Diferente

Operadores lógicos:

E Conjunção lógica
OU Disjunção lógica
O operador = é de comparação apenas quando estiver dentro de um comando de
comparação, em outras situações ele é um operador de atribuição.
A seguir, alguns exemplos de atribuições e cálculos com memórias e números:

Memoria X, Y, Total

X=3
Escreva "O valor de X é igual a ", X
Y=X+7
Escreva "O valor de Y é igual a ", Y
Total = X * Y
Escreva "O Valor de X multiplicado por Y é igual a ", Total
X++
Escreva "O valor de X incrementado é ", X
X += 5
Escreva "O valor de X incrementado com 5 é ", X

Mouse
O Logic Basic permite você posicionar na posição corrente do mouse. Para isso,
basta digitar o comando Posicione, e em seguida duas memórias reservadas do
Logic Basic: LinhaMouse e ColunaMouse. Você também pode verificar se houve
um clique, bastando verificar o conteúdo da memória reservada CliqueMouse. Se
o conteúdo for SIM, quer dizer que houve um clique, caso contrário o conteúdo
será NAO. A seguir, um exemplo de posicionamento pelo mouse:

Memoria Peixe, Teste

Fundo = "\LogicBasic65\Programas\Aquario\Aquario.jpg"

Cria Objeto
Peixe = "\LogicBasic65\Programas\Aquario\Peixe8.gif"
FimCria

Cria Som
Teste = "\LogicBasic65\Programas\Aquario\Bolhas.wav"
FimCria

INICIO
Posicione LinhaMouse, ColunaMouse
Desenhe Peixe
Aguarde 0,1
Se CliqueMouse = Sim
Som Teste
FimSe
VaPara INICIO
Você também poderá verificar se o botão direito ou esquerdo mantém-se
pressionado ou não. Para isto basta utilizar o comando TestaMouse, que retorna
0 se o botão não estiver pressionado e 1 se ele estiver pressionado. Ele retorna
uma string com duas posições, a primeira para o botão esquerdo do mouse e a
segunda para o botão direito. Por exemplo:

Memoria SitMouse

SitMouse = TestaMouse

SitMouse será igual a "00" se nenhum botão estiver pressionado, "10" se o botão
esquerdo estiver pressionado e "01" se o botão direito estiver
pressionado.

Exercício
Digite o programa de exemplos de atribuições e cálculos com memórias no box de
código do Logic Basic, e pressione o botão Executar para executar o programa.
Depois volte ao código, altere alguns valores, execute o programa novamente e
veja o resultado.

Entrada e saída de textos

EntraTexto
O Comando EntraTexto permite colocar um texto digitado em uma memória. Para
isso você deverá criar uma memória e executar o comando EntraTexto,
atribuindo o seu resultado à memória:

Memoria Nome

Nome = EntraTexto, "Digite o seu nome:"

Escreva "Seu nome é ", Nome

Note que o comando Escreva, no exemplo anterior, escreve dois argumentos em

uma mesma linha: uma string e uma memória. O resultado é que os dois serão
escritos em sequência na mesma linha da Janela. Isto pode ser feito para qualquer
quantidade de argumentos, e os tipos dos argumentos podem ser variados.

Componentes
Componentes são caixas de texto, caixas para digitação de números, caixas
combinadas de texto e listagem, botões de opção, caixas de checagem, etc. O
Logic Basic permite ao programador colocar quantos componentes desejar na
janela, e na ordem e tipos que lhe convier, e depois obter o valor de cada um, ou
seja, aquilo que foi digitado em uma caixa de texto, por exemplo. Para colocar um
componente na janela do Logic Basic, basta executar o comando Componente e
em seguida o tipo do componente, que pode ser Texto, Combo, Moeda, Opção
ou Check. Após o tipo do componente, coloca-se um ponto ou sub-linha e mais
uma extensão para identificar o componente, ou seja, nomeá-lo. No próximo
argumento, informa-se entre aspas vários parâmetros, como linha, coluna,
tamanho, etc. com o seguinte critério: informa-se o parâmetro, em seguida dois
pontos e o valor do parâmetro e ponto-e-vírgula para finalizar, por exemplo:

Componente "Texto.Nome", "Lin:5; Col:10; Tam:30;"

Para obter o valor digitado na caixa de texto, basta executar o comando

Componente seguido do identificador Valor e o nome do componente:

Componente Valor, "Texto.Nome"

A seguir um pequeno programa que exemplifica uma entrada de dados onde é

solicitado o nome e a idade do usuário, e em seguida estes dados são escritos na
janela do Logic Basic:

Memoria Nome, Idade

Posicione 5, 5; Escreva "Informe o seu nome:"

Posicione 7,5; Escreva "Informe a sua idade:"

Componente "Texto.Nome", "Lin:5; Col:27; Tam:30;"

Componente "Texto.Idade", "Lin:7; Col:27; Tam:5;"

Botao Especial; "OK", 9,27,1; FimBotao

Aguarde CliqueBotao

Componente Valor "Texto.Nome"; Nome = Retorno

Componente Valor "Texto.Idade"; Idade = Retorno

Posicione 11,5; Escreva "Seu nome é ", Nome, " e sua idade é ",
Idade, " anos"

Aguarde
O Logic Basic possui um comando denominado Aguarde que paralisa a execução
do programa até que uma tecla seja pressionada, ou até que se esgote um tempo
pré-determinado, dependendo do tipo de argumento que for passado para ele:

Memoria Tecla
Aguarde Tecla
Escreva Tecla

O Programa acima cria uma memória de nome Tecla, e em seguida aguarda uma
tecla ser pressionada; ao ser pressionada uma tecla o Logic Basic coloca a letra
correspondente à tecla digitada na memória Tecla; depois escreve o conteúdo da
memória Tecla na Janela do Logic Basic.

Escreva "Por favor, Aguarde 5 segundos..."

Aguarde 5
Escreva "Ok"

O programa acima escreve o texto "Por favor, Aguarde 5 segundos...", em

seguida aguarda 5 segundos, e após este tempo, escreve Ok na janela do Logic
Basic.

Se o argumento do comando Aguarde for CliqueObjeto ou CliqueBotao, o Logic

Basic aguardará até que um objeto ou botão seja "clicado" pelo mouse, e colocará
na memória reservada Retorno o nome do objeto que foi clicado, ou a descrição
do botão, por exemplo:

Aguarde CliqueObjeto
Escreva Retorno

Obs.: as palavras acima que estão na cor vermelha são identificadores ou palavras
reservadas do Logic Basic.

Objetos, Sons e Vídeo

Objetos
Os objetos são figuras que podem ser desenhadas na Janela do Logic Basic, e
que possuem propriedades especiais.
Os objetos podem ter tamanhos variados, e você pode colocar vários objetos
simultâneamente na janela do Logic Basic.
Para desenhar um objeto na Janela do Logic Basic, primeiramente você deve criar
uma memória para colocá-lo. O nome desta memória pode ser um nome que
lembre a figura, para que o programa fique claro.
Para colocar um objeto em uma memória, você deve utilizar o comando Cria com
o identificador Objeto, e em seguida o caminho do nome do arquivo de imagem,
da seguinte maneira:
Memoria Aviao, Peixe

Cria Objeto
Aviao = "\LogicBasic65\Programas\Disco\Disco.gif"
Peixe = "\LogicBasic65\Programas\Aquario\Peixe3.gif”
FimCria

Você pode criar quantos objetos desejar após o comando cria, sendo um objeto
por linha, e ao terminar de criar os objetos, deve-se colocar o comando FimCria.

Após criados os objetos, no exemplo anterior, nós temos agora duas memórias de
objetos: Aviao e Peixe; que podem ser facilmente desenhadas e manipuladas
pelo Logic Basic.
Para desenhar os objetos na Janela do Logic Basic, basta posicioná-las com o
comando Posicione e em seguida digitar o comando Desenhe, e em seguida o
nome da memória de objeto:

Posicione 10, 20
Desenhe Aviao
Posicione 15, 30
Desenhe Peixe

Uma das propriedades dos objetos, é que eles possuem o fundo transparente, ou
seja, a área da figura que contiver a cor igual à cor de transparência, onde o
padrão é a cor Branco, ficará transparente em relação ao fundo e a outros objetos.
Outra propriedade interessante, é que podemos colocar um objeto na frente ou
atrás de outro, bastando informar mais um argumento no comando desenhe:

Desenhe Aviao, Frente

Desenhe Peixe, Atras

Transparência de objetos
Quando os objetos são desenhados na janela do Logic Basic, eles podem ser
desenhados com o fundo opaco ou transparente. No modo transparente, as áreas
da figura que tiverem a cor igual à cor de transparência, ficam transparentes. O
comando Transparente permite modificar as características de transparência do
objeto. O identificador CorTransparente define qual será a cor de transparência,
e o identificador Modo define o tipo de transparência:

Opaco: Sem transparência.

Normal: Este é o modo padrão, e os objetos terão transparência somente com a
cor de fundo = Preto. Se o arquivo de imagem estiver no formato .Gif e possuir
transparência, o Logic Basic irá desenhar o objeto com a transparência da
imagem.
Otimizado: O objeto poderá ter transparência com qualquer cor, dependendo da
cor definida pelo identificador CorTransparente. Este modo utiliza recursos
avançados de manipulação de gráficos do Windows, e para desenhar os objetos,
deve-se utilizar os comandos DesenheObjetos e PosicioneObjeto, sendo ideal
quando se deseja maior velocidade e pefeição em animações gráficas.

Transparente Modo = Otimizado, CorTransparente = Branco

O comando acima define o objeto como sendo transparente no modo otimizado,

com cor de transparência igual a Branco.

O comando transparente deverá ser colocado sempre antes do comando Cria

Objeto, e em um mesmo programa você poderá ter objetos com cores de
transparência diferentes, bastando separá-los em comandos Cria Objeto
diferentes, e antes de cada um deles, definir a cor de transparência desejada.

Som e Vídeo
A maneira de criar sons é idêntica à de objetos, com a diferença que você vai
informar o identificador Som após o comando Cria, e em seguida o caminho do
arquivo de som, que pode ser qualquer arquivo de som válido (wav, mid, mp3,
etc.):

Memoria MusicaMickey, Aplausos

Cria som
MusicaMickey = “\LogicBasic65\Programas\Mickey\Mickey Mouse
Theme.mid”
Aplausos = “\LogicBasic65\Programas\Memoria\Aplausos.wav”
FimCria

Após criadas as memórias de som, para tocar o som basta digitar o comando Som
e a seguir o nome da memória de som:

Som MusicaMickey
Som Aplausos

Você poderá também tocar vários sons ou músicas ao mesmo tempo (mixar),
bastando para isso informar um número de canal de som para cada som, por
exemplo:

Som MusicaMickey, 0
Som Aplausos, 1

Desta maneira, os dois sons acima serão tocados ao mesmo tempo.

Para encerrar os sons, utilize o comando FimSom, e em seguida o canal:

FimSom 0
FimSom 1

Você também poderá executar arquivos de vídeo (mpeg, avi, etc.) bastando para
isso configurar primeiramente a tela onde o vídeo será mostrado, com o comando
Video. Por exemplo:

Video 5, 5, 25, 80, 0, "Visivel", "SemControle", "TamanhoPadrao",

"TelaNormal"

O comando acima cria uma tela na posição 5,5, com 25 linhas e 80 colunas, no
canal de som 0, visível e sem os controles (play, pause, etc.). O argumento
TamanhoPadrao faz com que a tela seja redimensionada ao tamanho original do
filme, portanto os argumentos linhas e colunas serão ignorados. Por último o
argumento TelaNormal executa o vídeo em tela normal, se for informado
TelaCheia o vídeo será executado em tela cheia.

Após configurada a tela, basta executar o vídeo com o comando Som, informando
o nome do arquivo e o canal de som da seguinte maneira:

Som "C:\Windows\Tour.avi", 0

Existem vários outros comandos e recursos para se trabalhar com som e vídeo,
mas esses são tópicos mais avançados que não serão vistos neste curso básico.

Comandos Direcionais e Condicionais

Comando direcional VaPara
Como já vimos anteriormente, o Logic Basic executa o programa linha por linha, da
primeira até a última. Mas você pode direcionar a execução do programa para
outra linha, para outro ponto do programa. Para isso o Logic Basic possui um
comando denominado VaPara que faz com que a execução vá para uma
determinada linha, bastando que você crie uma linha com um determinado nome e
direcione a execução para esta linha com este comando. Por exemplo:

Memoria T

INICIO
Escreva "Pressione uma tecla qualquer..."
Aguarde T
Escreva "A tecla é", T
VaPara INICIO

Note que no programa acima, digitamos uma linha denominada INICIO;

solicitamos a digitação de uma tecla, e em seguida escrevemos a tecla digitada
na Janela. Feito isto, direcionamos a execução para a linha INICIO, e a rotina é
repetida novamente. A isto chamamos de Laço, ou Loop (em inglês).

Comando Condicional Se
Este é um comando que existe em todas as linguagens de programação, e sua
função é condicionar a execução de um ou mais comandos de acordo com o
resultado de uma expressão: se a expressão for verdadeira, ele executa o
comando, se for falsa não executa, ou executa outro(s) comandos. O nome deste
comando é Se, e ele possui mais dois comandos auxiliares: CasoContrario e
FimSe. O primeiro executa outro(s) comando caso o resultado da expressão seja
falso, e o segundo deve ser colocado sempre no fim de uma cláusula Se. Por
exemplo:

Memoria X

X=1
Se X = 1
Escreva "X é igual a 1!"
CasoContrario
Escreva "X não é igual a 1!"
FimSe

O comando CasoContrario não é obrigatório, mas o comando FimSe deverá ser

colocado obrigatoriamente para finalizar cada Se que for criado. Quando algum
argumento após o comando Se não for uma memória, e sim uma string ou
número decimal com vírgula, deve-se colocá-los entre aspas. Por exemplo:

Se X = "3,141592"

Funções
Funções são grupos de códigos de podem ser executados separadamente do
código principal, para executar uma determinada tarefa. De dentro de uma função,
pode-se executar outras funções, e elas também possuem uma propriedade
denominada recursividade, onde uma função pode executar ela mesmo ! As
funções deverão ser escritas sempre após o fim do programa, ou na janela de
extensões.
Para escrever uma função, basta escrever um nome em uma linha, para identificar
a função, e nas próximas linhas digitar o código da função. Na última linha da
função, deve-se escrever o comando Retorne, que fará com que a execução volte
para a próxima linha após o comando que a executou. Para se executar uma
função, basta digitar o comando Execute e em seguida o nome da função. Por
exemplo:
Escreva "Teste de função:"
Execute Teste()
Escreva "Função executada com sucesso !"
FimPrograma

Teste()
Escreva "Estou dentro da função !"
Escreva "Pressione qualquer tecla para retornar..."
Aguarde
Retorne

Trabalhando com textos

Unir
O Logic Basic possui diversos comandos para manipular textos, ou "strings". O
comando Unir une uma ou mais strings. Por exemplo:

Memoria Gato, Rato, Resultado

Gato = "O gato"

Rato = " e o rato"
Resultado = Unir Gato, Rato, " são bons amigos!"
Escreva Resultado

Ao executar este programa, o comando Unir unirá as três strings e colocará o

resultado na memória Resultado. Em seguida o Logic Basic escreverá o conteúdo
de Resultado na janela: O gato e o rato são bons amigos!

Separe
O comando Separe separa trechos de um texto, de acordo com dois argumentos:
o primeiro é a posição inicial no texto, e o segundo é o comprimento em letras do
texto a ser separado. Por exemplo:

Memoria Resultado

Resultado = Separe "Hoje é um dia chuvoso!", 15, 7

Escreva Resultado

A posição da primeira letra do texto "Hoje é um dia chuvoso!" é 1, portanto a

posição da primeira letra da palavra "chuvoso" é 15; o seu comprimento em letras
é 7, portanto, o conteúdo da memória Resultado será chuvoso.
 Data e Hora
O Logic Basic permite você obter a data e a hora do computador, e colocá-los em
memória. Para isso, você deve utilizar dois comandos: Data e Hora:

Memoria Hoje, Agora

Hoje = Data
Agora = Hora
Escreva "Hoje é", Hoje, "Agora são", Agora

O programa do exemplo acima cria duas memórias: Hoje e Agora, e em seguida

atribui o retorno do comando Data e Hora às memórias Hoje e Agora
respectivamente, e escreve o resultado na janela do Logic Basic.

Formata
O comando Formata formata um número de acordo com um determinado formato,
denominado "máscara". A máscara pode escrita de duas formas: com o símbolo #
ou com o
número 0 (zero). A seguir alguns exemplos do comando Formata:

Memoria X, S

X = 1123,57
S = Formata X, "##.##0,00"

O Resultado do exemplo acima é 1.123,57.

X = 10
S = Formata X, "00000"

O resultado do exemplo acima é 00010.

X = "123,5"
S = Formata X, "00000,00"

O resultado do exemplo acima é 00123,50.

X = "1234,5"
S = Formata X, Padrao

O resultado do exemplo acima é 1.234,50. Neste último caso, o número é

formatado no padrão de moeda com duas casas decimais, sendo recomendável a
sua utilização, pois este formato não depende das configurações de moeda do
Windows, que pode acarretar problemas nos outros formatos, dependendo da
configuração.

Alinha
O comando Alinha cria um campo com um determinado número de espaços, e
dentro deste campo, alinha o conteúdo de uma memória, à direita ou à esquerda,
e retorna o resultado para uma memória. Este comando possui três argumentos: o
primeiro é a memória, o segundo, o tamanho do campo, e o terceiro, DIR ou ESQ;
"DIR" informa que o alinhamento será à direita, e "ESQ" à esquerda. Por exemplo:

Memoria S
S = "Logic Basic"
S = Alinha S, 20, DIR
Escreva "<", S, ">"

Exercícios
Crie mais algumas memórias no programa de exemplo Unir; atribua textos a elas
e junte-as com as strings da linha do comando Unir.
No exemplo do comando Separe, modifique os valores da posição inicial e
comprimento, execute o programa (pressionando o botão Janela) e veja o
resultado. Depois retire o segundo argumento comprimento e veja o resultado.
Digite os exemplos do comando Formata no código do Logic Basic e pressione o
botão Janela; depois altere os números e as máscaras para ver o resultado.

Matrizes
Matrizes são um conjunto de memórias que possuem um único nome, e cada
elemento de uma matriz possui um índice numérico de identificação. Uma matriz é
declarada da seguinte forma: o nome da matriz juntamente com um valor numérico
entre parênteses:

Memoria Nome(20), Idade(20)

A linha de comando acima cria duas matrizes: Nome com 20 memórias e Idade
com 20 memórias. O índice de uma matriz começa com o valor 0 (zero); portanto
no exemplo acima, o índice varia de 0 a 19. A seguir, um exemplo de como colocar
e obter textos e números em matrizes:

Memoria Nome(20), Idade(20)

Nome(0) = "Priscila"
Idade(0) = 10
Nome(1) = "Jorge"
Idade(1) = 20
Nome(2) = "Rossana"
Idade(2) = 16

Neste exemplo, colocamos valores nas matrizes somente até o índice 2, mas
poderemos colocar valores até o índice 19. As matrizes que não foram colocados
valores ficarão com o conteúdo vazio.
Note que criamos duas matrizes com a mesma quantidade de índices, e
associamos os índices da matriz Nome com os índices da matriz Idade, por
exemplo, o Nome(0) corresponde à Idade(0), o Nome(1) corresponde à Idade(1) e
assim por diante. Isso é importante porque podemos criar registros para fazer, por
exemplo, um cadastro de clientes, associando cada cliente a um índice.
Para obter um valor de uma matriz, basta informar o nome da matriz e o índice
entre parênteses, por exemplo:

Escreva Nome(2)

Se colocarmos o comando acima no final do nosso exemplo anterior, o resultado

será Rossana.
No índice da matriz, podemos colocar também memórias numéricas, que por
serem variáveis, tornam as matrizes um poderoso recurso de programação. A
seguir, um exemplo de como listar os nomes na janela, utilizando uma memória
como índice:

Memoria X

X=0
INICIO
Escreva Nome(X), " - ", Idade(X)
X=X+1
Se X <= 2
VaPara INICIO
FimSe

Se inserirmos este programa no nosso primeiro exemplo, serão listados na janela

do Logic Basic os três primeiros nomes com suas respectivas idades. Nesta rotina,
a memória X é inicilizada com o valor 0 (zero). Em seguida, o Logic Basic escreve
o Nome e a Idade com o índice 0 (zero), e soma mais 1 à memória X. Então o
valor de X passa a ser igual a 1. O comando Se verifica se o valor de X é menor
ou igual a 2, se for verdade, ele direciona a execução para a linha INICIO, se for
falso, ele vai para a próxima linha após o comando FimSe. Como o valor de X é
menor, a execução será direcionada para a linha INICIO e será escrito o Nome e a
Idade com o índice 1, e assim por diante, até que o valor de X seja maior do que 2.
 Comando ProcureMatriz
O Logic Basic possui um comando denominado ProcureMatriz, que informa o
número do índice de uma matriz, que contiver o conteúdo igual ao argumento
informado. Por exemplo:

Memoria Y

Y = ProcureMatriz Nome, "Jorge"

Se Y = -1
Escreva "Nome não encontrado !"
CasoContrario
Escreva Nome(Y), Idade(Y)
FimSe

Primeiramente declaramos uma memória Y para servir como índice. Em seguida,

atribuimos o resultado do comando ProcureMatriz à memória Y, onde foi passado
dois argumentos: o nome da matriz onde o Logic Basic irá procurar, e o texto a ser
procurado, que no caso é o nome "Jorge". Se o comando ProcureMatriz não
encontrar o nome "Jorge" na matriz Nome, ele retornará o valor -1, ou seja, este
valor será colocado em Y. Se o comando encontrar o nome, ele retornará o valor
do índice correspondente ao nome encontrado. Finalizando, testamos com o
comando Se, se o valor de Y é igual a -1, se for verdade, será escrito na janela:
Nome não encontrado, caso contrário, será escrito na janela o nome e a idade
correspondente ao índice encontrado, que no caso é Jorge 20.

Gravação e leitura de memórias

Gravação de memórias
O Logic Basic possui um comando denominado GravaMemoria, que grava todas
as memórias criadas e seus respectivos conteúdos em um determinado arquivo. O
caminho do arquivo deve ser informado entre aspas, ou uma memória contendo o
caminho e pode ser qualquer nome válido para arquivos no formato Windows, com
ou sem extensão:

GravaMemoria "\LogicBasic65\Teste.Arq"

Carregamento de memórias
O comando CarregaMemoria é o inverso do comando GravaMemoria, ou seja,
ele lê as memórias gravadas em um arquivo e coloca na memória do Logic Basic.
Um detalhe importante é que o conteúdo das memórias do programa ficarão
exatamente iguais ao momento em que foram gravadas, e se elas já possuiam
algum conteúdo, eles serão sobrepostos pelos valores gravados. Se houverem
outras memórias no programa que foram criadas após as que foram gravadas, os
conteúdos dessas memórias serão mantidos.

CarregaMemoria "\LogicBasic65\Teste.Arq"

O comando CarregaMemoria poderá ser executado mesmo que o arquivo não

exista, ele simplesmente deixará a memória como está.

Exclusão de memórias

O Logic Basic permite você apagar uma memória, e para isso você deve utilizar o
comando ApagaMemoria, bastando informar o nome da memória a ser apagada.
Vamos supor que o nome da memória seja Nome:

ApagaMemoria Nome

O comando acima apaga a memória Nome e consequentemente o seu conteúdo.

Após apagar memórias, deve-se executar o comando ReorganizaMemoria, para

que as lacunas que ficarem nas posições das memórias apagadas sejam
removidas, e também para que os índices das matrizes sejam reorganizados, por
exemplo, se você apagar uma matriz de índice 7, a matriz de índice 8 passará a
ser a 7, a de índice 9 passará a ser a 8 e assim por diante.

Obs.: Cuidado para não confundir apagar uma memória com apagar o
conteúdo de uma memória. Para apagar apenas o conteúdo de uma memória,
basta atribuir uma string vazia para a memória:

Nome = ""

O comando ApagaMemoria elimina completamente a memória; é como se você

não a tivesse criado.

Comando Menu
O comando Menu permite criar um box com até 10 opções, onde, após
selecionada uma das opções, coloca a opção selecionada na memória reservada
do Logic Basic Retorno.
Para criar um menu, digite o comando Menu e a seguir um argumento (texto), que
será o cabeçalho do Menu. Em seguida, nas próximas linhas, escreva o texto de
cada opção, um em cada linha, entre aspas. Ao terminar o menu, digite o comando
FimMenu. Para saber qual opção foi selecionada, basta verificar o conteúdo da
memória Retorno. A seguir um exemplo de como criar um Menu:

Posicione 1, 1
Menu "Selecione um dos nomes a seguir:"
"Priscila"
 "Jorge"
"Rossana"
FimMenu
Posicione 10, 30
Escreva Retorno

Comando Botao
O comando Botao permite criar botões de comando na janela do Logic Basic.
Para criar botões, digite o comando Botao, e em seguida, nas próximas linhas,
escreva o nome dos botões entre aspas, e cada um com quatro argumentos: Linha
inicial, Coluna inicial, Altura em linhas e Comprimento em colunas. Após ter
definido todos os botões, deve-se colocar o comando FimBotao. Os botões
permanecerão visíveis até que seja executado o comando Botao Remove.
Quando o comando Botao é executado, todos os botões definidos são colocados
na janela do Logic Basic, e para saber qual botão foi pressionado deve-se
executar o comando Aguarde CliqueBotao, e em seguida verificar o conteúdo da
memória Retorno. Quando o comando Botao Remove for executado, todos os
botões são removidos da janela do Logic Basic. Exemplo:

Botao
"Sim", 10,10,2,10
"Não", 10,30,2,10
FimBotao

Aguarde CliqueBotao
Mensagem Retorno
Botao Remove

Você também pode inserir imagens gráficas no botão, bastando para isso, informar
o caminho do arquivo de imagem após os argumentos, por exemplo:

Botao
"", 10,10,2,10, "C:\Temp\Sim.bmp"
"", 10,30,2,10, "C:\Temp\Nao.bmp"
FimBotao

A partir da versão 6.5 do Logic Basic, foram implementados botões especiais,

além de permitir ao programador criar qualquer tipo de botão. Para isso, basta
informar a palavra chave Especial logo após o comando Botão, e informar as
coordenadas do botão e o seu tipo, que pode variar de 1 a 8, sendo que o tipo 9
deverá ser informado quando o programador desejar configurar seu próprio botão:

Botao Especial
"Sim", 10,10,1
 "Não", 10,30,2
FimBotao

Aguarde CliqueBotao
Mensagem Retorno

Box de Listagem
O Logic Basic possui um box de listagem destinado a listar textos alinhadamente
em colunas, com várias configurações.

BoxPosicao
O comando BoxPosicao define a posição superior esquerda do box na janela do
Logic Basic. Por exemplo:

BoxPosicao 10, 10

BoxConfig
O comando BoxConfig configura o box de listagem, e é obrigatória a sua
execução antes da ativação do box. Este comando possui diversos argumentos
como nome do fonte, tamanho do fonte, cor de fundo, cor da letra, etc., por
exemplo:

BoxConfig Nome="Arial", Tamanho=10, CorFundo=AzulEscuro,

CorLetra=Branco

BoxTitulo
Este comando deve ser executado após o comando BoxConfig, e define o título
das colunas do box de listagem, por exemplo:

BoxTitulo "Nome", 30
BoxTitulo "Idade", 10

Para cada coluna a ser criada deve-se executar um comando BoxTitulo, que
serão criadas na ordem em que forem executados.

BoxAtiva
Este comando ativa o box de listagem na janela do Logic Basic de acordo com as
definições atribuídas aos comandos BoxPosicao, BoxConfig, BoxTitulo.
 BoxAdd, BoxNew
Os comandos BoxAdd e BoxNew permitem a inserção de textos no box de
listagem. A cada chamada do comando BoxAdd é inserido um texto em uma
coluna da últimna linha do box de listagem, na ordem da primeira para a última
coluna. Ao serem preenchidas todas as colunas da linha, deve-se executar o
comando BoxNew para que seja criada uma nova linha no box. Por exemplo:

Memoria Nome(10), Idade(10), Cont

Nome(0) ="Priscila"; Idade(0) = "10"

Nome(1) = "Jorge"; Idade(1) = "20"
Nome(2) ="Rossana"; Idade(2) = "16"
Nome(3) = "Ana Paula"; Idade(3) = "5"
Nome(4) = "Cristiano"; Idade(4) = "30"
Nome(5) = "Cristina"; Idade(5) = "25"

BoxPosicao 5,19
BoxConfig Nome="Arial", Tamanho=10, CorFundo=AzulEscuro,
CorLetra=Branco
BoxTitulo "Nome", 30; BoxTitulo "Idade", 10
BoxAtiva

Cont = 0
INICIO
BoxAdd Nome(Cont)
BoxAdd Idade(Cont)
BoxNew
Cont++
Se Cont <= 6; VaPara INICIO; FimSe

O programa anterior, cria duas matrizes, Nome e Idade, e uma memória Cont
para servir como contador de índice. A seguir ele coloca 6 nomes e 6 idades nas
matrizes, respectivamente. Em seguida, como já foi visto anteriormente, ele faz um
laço que insere os conteúdos da matriz Nome e Idade no box de listagem.

BoxDesativa
Este comando desativa o box de listagem, removendo o mesmo da janela do Logic
Basic. Há vários outros comandos para se trabalhar com o box de listagem, como
selecionamento de linhas, leitura do conteúdo dos campos, etc. Para maiores
detalhes veja o manual de referência dos comandos.

Operadores lógicos
Os operadores E e OU são utilizados na linha de comando SE para efetuar
operações lógicas entre expressões. O operador E efetua uma operação lógica
entre expressões de modo que ele retorna um resultado verdadeiro se todas as
expressões forem verdadeiras ao mesmo tempo; se pelo menos uma das
expressões for falsa, ele retorna falso. O operador OU efetua uma operação lógica
entre expressões de modo que se pelo menos uma das expressões for verdadeira,
ele retorna um resultado verdadeiro, e retorna falso somente se todas as
expressões forem falsas. Você poderá efetuar operações lógicas com várias
expressões em uma mesma linha, mas não poderá colocar em uma mesma linha
os operadores E e OU, ou seja, a linha do comando SE só poderá ter um tipo de
operador lógico.
A seguir, exemplos dos operadores lógicos:

Memoria X, Y

X=1
Y=1
Se X = 1 EY=1 'Retorna Verdadeiro
Se X = 1 EY=2 'Retorna Falso
Se X = 1 OU X = 2 'Retorna Verdadeiro
Se X = 2 OU Y = 2 'Retorna Falso

Depuração de programas
Depuração é o mesmo que "Tirar Defeitos", "Solucionar problemas", de um
programa de computador. O Logic Basic oferece um recurso para facilitar este
trabalho, e para isto foi criado o botão Depurar. Ao ser pressionado este botão,
será ativado o "modo de duparação". Deste modo, quando o programa for
executado (ao se pressionar o botão Janela), as linhas de comando irão sendo
mostrados em uma pequena janela, à medida que o programa for sendo
executado.
Desta maneira, o programador irá visualizando passo a passo o que o
interpretador do Logic Basic está executando, ou seja, verá ao mesmo tempo a
linha de comando e o seu resultado na janela. Com este recurso, ficará fácil
detectar algum erro no programa, pois se o Logic Basic não executar o programa
de acordo com aquilo que é esperado, com certeza há algum erro na linha de
comando onde ocorre o erro.
O programador deverá, então, verificar se não há algum comando escrito
incorretamente, verificar se as memórias utilizadas foram declaradas, etc.

Outros comandos do Logic Basic

Fonte
Através do comando Fonte é possível alterar o nome do fonte de caracteres da
janela do Logic Basic, o tamanho, a cor, e colocar em negrito ou itálico. Para isso
basta digitar o comando Fonte e em seguida os identificadores Nome, Tamanho,
Negrito, Italico e Cor. Os identificadores podem ser colocados em qualquer
ordem, e também podem ser omitidos. Por exemplo:

Fundo = Azul
Fonte Nome = "Arial", Tamanho = 38, Negrito = SIM, Italico = SIM, Cor
= Verde
Escreva "Logic Basic"
A linha de comando acima define o nome do fonte igual a Arial, com o tamanho
38, em negrito e itálico, com cor Verde. O palavra-chave Sim ativa Negrito e
Itálico, e a palavra-chave Nao desativa.

Janela
O comando Janela altera a resolução da janela em linhas e colunas, a posição da
janela na área de trabalho do Windows em linhas e colunas e o tamanho da janela
do Logic Basic em linhas e colunas. Um detalhe importante é que a posição e o
tamanho dependem da resolução da janela, que é calculada de acordo com o
tamanho atual da janela, portanto esta deve ser definida em primeiro lugar. Os
argumentos podem ser colocados todos em uma mesma linha, a seu critério.

A seguir, um exemplo do comando Janela:

Janela Resolucao = 25, 80, Posicao = 0, 0, Tamanho = 33, 100

O comando acima define a Janela com uma resolução de 25 linhas por 80

colunas, com a posicao superior esquerda na linha 0, coluna 0, e a altura da
Janela com 33 linhas e comprimento de 100 colunas.

Aleatorio
O comando Aleatorio retorna um número aleatório que pode variar de 0 ao valor
do seu argumento. Por exemplo:

Memoria X

X = Aleatorio 100
Escreva X

O programa anterior escreve na janela do Logic Basic um valor entre 0 e 100,

escolhido aleatoriamente pelo Logic Basic.

Memórias Reservadas e Cores

O Logic Basic possui algumas memórias reservadas, ou seja, memórias que já são
criadas automaticamente assim que um programa é executado. Como elas são
memórias reservadas do Logic Basic, você não poderá criar memórias com estes
nomes.
As memórias reservadas incluem também algumas memórias contendo valores de
cores, mas você poderá criar outras memórias de cores além destas, utilizando o
comando RGB.
A seguir, a listagem das memórias reservadas do Logic Basic:

Retorno
LinhaMouse
ColunaMouse
CliqueMouse
CorAtual
Azul
Vermelho
Verde
Amarelo
AzulClaro
AzulEscuro
VermelhoEscuro
VerdeEscuro
AmareloEscuro
RetornoBox
TotalFontes
PastaPrograma
Preto
Branco
PastaWindows
AreaTrabalho MenuProgramas
EDTotal
EDColuna
EDTextoCampo
TestaBotao

A memória Retorno é uma área de transferência onde são colocados os valores

de retorno de alguns comandos.

Comandos de impressora
O Logic Basic possui comandos para imprimir textos e desenhos na impressora.
Estes comandos são idênticos aos comandos para escrever na Janela, com
algumas pequenas diferenças. A quantidade de linhas e colunas do papel
depende da configuração da impressora, mas normalmente é aproximadamente
70 linhas por 100 colunas. Para definir a posição a imprimir, o comando é Imp
Posicione, e em seguida o número da linha e o número da coluna.
 Para escrever ou desenhar na impressora, o comando é Imp e em seguida um
dos dois identificadores, Escreva ou Desenhe. A maneira de escrever e desenhar
é idêntica aos comandos Escreva e Desenhe já vistos anteriormente.
O Identificador Desenhe para impressora, não desenha campos, mas pode
imprimir, além dos objetos padrão do Logic Basic, figuras ou imagens, bastando
informar o caminho do arquivo, entre aspas após o identificador.

Para definir o fonte de caracteres da impressora, deve-se digitar o comando Imp e

em seguida o identificador Fonte, que é idêntico ao comando Fonte, com a
diferença que este não possui o identificador Cor.
Para mudar de página basta digitar o comando Imp e em seguida o identificador
NovaPagina.

No final do trabalho de impressão, deve-se colocar o comando Imp Fim, para que
os dados sejam efetivamente direcionados para a impressora.
A seguir, um exemplo de como desenhar e escrever na impressora:

Memoria Disco
Imp Fonte Nome = "Ms Sans Serif", Tamanho = 38, Negrito = SIM,
Italico = SIM

Cria Objeto
Disco = "C:\LogicBasic\Objetos\Disco.gif"
FimCria

Imp Posicione 10, 0

Imp Escreva "Alô, mundo!"
Imp Posicione 20, 0
Imp Desenhe Disco
Imp Posicione 30, 0
Imp Desenhe "C:\LogicBasic\Objetos\Satelite.gif"
Imp Fim
Mensagem "Relatorio Impresso com Sucesso !"

Banco de Dados Nativo do Logic Basic

O Logic Basic possui uma implementação nativa de banco de dados muito simples
e fácil de usar, mas que contém poderosos recursos que permitem inclusive sua
utilização em ambiente de rede.

Criando um Banco de Dados Nativo

Para criar um banco de dados em Logic Basic, deve-se utilizar o comando BD.
Cada Banco de Dados se refere a um arquivo e uma tabela, podendo ser criados
vários Bancos de Dados, um para cada tabela. As definições do Banco de Dados
deverão ser colocados no cabeçalho do programa, ou seja, no início do programa,
logo após o(s) comando(s) Memoria.
Para criar um banco de dados, deve-se digitar o comando BD e em seguida dois
argumentos: o primeiro é o nome do Banco de Dados, e o segundo, o caminho
onde será gravado o arquivo do Banco de Dados. O nome do arquivo não deverá
ser informado, apenas as pastas e sub-pastas, pois o nome do arquivo será
informado no comando de abertura do banco de dados AbreBD.
Em seguida deve-se definir os campos da tabela, informando-se o nome do campo
entre aspas e o seu tamanho, um em cada linha. Ao final da definição, deve-se
colocar o comando FimBD.
Por exemplo, vamos criar um Banco de Dados de um arquivo de Clientes:

BD Clientes "C:\LogicBasic\Arquivos"
"Nome", 30
"Idade", 10
"ValorCompras", 15
FimBD

Abrindo e Fechando um Banco de Dados

Após a criação de um Banco de Dados, deve-se abri-lo com o comando AbreBD
para permitir a gravação e leitura de registros. Neste comando basta informar
como argumento apenas o nome do arquivo, pois o seu caminho já está definido
no comando BD. A extensão do arquivo é LBA, mas não é obrigatório informá-lo,
pois o Logic Basic o colocará automaticamente se você não colocá-lo.
Você poderá abrir outro arquivo para este mesmo Banco de Dados, mas
primeiramente você deverá fechá-lo como o comando FechaBD. Por exemplo,
vamos supor que você defina um Banco de Dados para movimentos de um
controle de estoque do ano todo, mas você queira gravar o movimento de cada
mês em arquivos separados. Sendo assim você poderá abrir um arquivo para
gravar os movimentos em um mês, fechar o arquivo, e abrir outro arquivo para
gravar o movimento de outro mês, mas não é permitido abrir mais de um arquivo
ao mesmo tempo para um mesmo Banco de Dados.

Gravando registros no Banco de Dados

Ao criarmos o Banco de Dados, o Logic Basic cria um registro com a estrutura dos
campos da tabela que foi definida, para que sejam colocados os dados nos
campos antes que o registro seja gravado no arquivo. Para colocar um dado em
um campo, basta informar o nome do Banco de Dados seguido de ponto e o nome
do campo, por exemplo, vamos preencher os campos do Banco de Dados do
exemplo anterior:

Clientes.Nome = "João da Silva"

Clientes.Idade = 30
Clientes.ValorCompras = 1500,00
Estes registros tem as mesmas características de uma memória normal, e você
poderá atribuir strings, números e expressões da mesma forma como se atribui a
uma memória, e também poderá utilizá-los como argumento da função Entre.

Após ter preenchido os campos com seus respectivos dados, para adicionar um
novo registro ao Banco de Dados, basta utilizar o comando AdicionaRegistro e
em seguida o nome do Banco de Dados, por exemplo:

AdicionaRegistro Clientes

Com este comando, todos os campos do Banco de Dados Clientes serão

gravados em um novo registro no arquivo.

Lendo registros do Banco de Dados

Para ler um registro do Banco de Dados é muito simples, basta digitar o comando
LeRegistro, em seguida o nome do Banco de Dados e a posição do registro. A
posição do registro pode variar de 0 ao total de registros do arquivo menos um.
Por exemplo:

LeRegistro Clientes 3

O exemplo anterior lê o registro de número 3 do arquivo.

Após a leitura do registro, os dados lidos estarão disponíveis nas memórias do
registro, por exemplo:

Escreva Clientes.Nome, " - ", Clientes.Idade, " - ",

Clientes.ValorCompras

Para saber a quantidade de registros de um Banco de Dados, basta utilizar o

comando TotalRegistros seguido do nome do Banco de Dados:

Memoria T
T = TotalRegistros Clientes

A seguir, um exemplo de como ler todos os registros do Banco de Dados Clientes:

Memoria X, T

T = TotalRegistros Clientes
X=0
INICIO
LeRegistro Clientes X
Escreva Clientes.Nome, " - ", Clientes.Idade, " - ", Clientes.ValorCompras
X=X+1
Se X < T; VaPara INICIO; FimSe
 Leitura ordenada de registros
A leitura de registros que fizemos no exemplo anterior, lê os registros na
sequência em que foram gravados. Mas podemos ler os registros em qualquer
ordem que desejarmos, bastando utilizar o comando OrdemBD, que ordena o
arquivo por um campo, ou pela combinação de vários campos. Para isso, devemos
passar como argumentos o nome do Banco de Dados e em seguida o nome do(s)
campo(s) em que o arquivo será ordenado:

OrdemBD Clientes, "Idade", "Nome"

O comando acima ordena o Banco de Dados de Clientes por ordem de Idade e

Nome. Esta é uma ordenação composta, ou seja, por mais de um campo, e no
caso deste exemplo, o arquivo será ordenado primeiramente por idade, e se
houver um grupo de idades iguais, os nomes que fazem parte deste grupo serão
ordenados em ordem alfabética. A seguir, um exemplo de leitura ordenada:

Memoria X, T

OrdemBD Clientes, "Idade", "Nome"

T = TotalRegistros Clientes
X=0
INICIO
LeRegistro Clientes X
Escreva Clientes.Nome, " - ", Clientes.Idade, " - ", Clientes.ValorCompras
X=X+1
Se X < T; VaPara INICIO; FimSe

O comando OrdemBd gera um índice de ordenação para o Banco de Dados, e

deve ser colocado sempre antes da rotina que irá utilizar o índice. Se
você necessitar de um novo índice com outra ordenação, bastar
executar o comando OrdemBd novamente antes da rotina que utilizará
o índice. A partir do momento em que for definido um índice para o
Banco de Dados, toda leitura que for feita será ordenada pelo índice.
Se você desejar voltar a ler o arquivo sequencialmente, basta informar
o argumento Sequencial após o comando OrdemBD:

OrdemBD Clientes, "Sequencial"

Procura de registros no Banco de Dados

Você pode procurar um determinado registro no Banco de Dados, de acordo com
o índice atual do Banco de Dados, bastando digitar o comando Procure, seguido
do nome do Banco de Dados, o identificador Primeiro, Ultimo ou Proximo, e a
string a ser procurada. Por exemplo, vamos supor que você deseje procurar o
registro que contenha o nome "João da Silva" no Banco de Dados:

Memoria Posicao

OrdemBD Clientes "Nome"

Posicao = Procure Clientes, Primeiro, "João da Silva"

Se Posicao = -1
Mensagem "Registro não encontrado !"
CasoContrario
LeRegistro Clientes Posicao
Escreva Clientes.Nome, " - ", Clientes.Idade, " - ",
Clientes.ValorCompra
FimSe

No exemplo acima, o Banco de Dados é ordenado por "Nome", em seguida é

executado o comando Procure que retorna -1 caso a string procurada não seja
encontrada, ou a posição do registro, caso haja um registro contendo o campo
"Nome" igual ao nome procurado. Neste último caso, basta executar o comando
LeRegistro informando a posição retornada.
Os identificadores Primeiro e Ultimo são utilizados no caso em que houverem
vários registros com campos de ordenação iguais, por exemplo, vamos supor que
no arquivo existam três nomes "João da Silva"; se for informado o identificador
Primeiro, será retornada a posição do primeiro dos três registros, se for informado
o identificador Ultimo, será retornada a posição do último dos três registros. O
identificador Proximo retorna a posição do registro com campos de ordenação
mais próximo(s) daquele que está sendo procurado.

Exclusão de registros do Banco De Dados

Para excluir um registro do Banco de Dados basta executar o comando
ExcluiRegistro, seguido do nome do Banco de Dados e a posição do registro a
ser excluído. A posição a ser excluída dependerá do índice atual do Banco de
Dados, ou seja, poderá ser sequencial ou pelo índice. Assim, se o Banco de Dados
não possuir ordenação, será excluído o registro da posição absoluta informada, se
o Banco de Dados possuir ordenação, será excluída a posição relativa ao índice.
Assim, você poderá excluir o registro da posição retornada pelo comando
Procure. Por exemplo:

ExcluiRegistro Clientes Posicao

O Logic Basic também possui um comando denominado LimpaBD, que pode ser
utilizado para limpar os registros excluídos do arquivo, tornando-o menor e mais
leve. Este comando não é obrigatório de ser executado após a exclusão de
registros no arquivo, somente quando houver um grande número de exclusões
acumuladas, e pode ser utilizado a critério do programador. Para executar este
comando, basta informar como argumento o nome do Banco de Dados:

LimpaBd Clientes

Programas Executáveis
O Logic Basic permite que os programas sejam compilados para que seja gerado
um programa executável, que pode ser copiado para outro computador e
executado sem a necessidade da instalação do Logic Basic. Outra vantagem deste
recurso, é que os programas executáveis não podem ser lidos por nenhum
programa, nem mesmo o editor de texto do Logic Basic, pois estão em código
binário.

Para compilar um programa é muito fácil, basta pressionar o botão Compilar no

ambiente de código do Logic Basic, informar o nome do programa executável, que
deverá ter a extensão EXE, se não for informada a extensão, o Logic Basic a
colocará automaticamente. Você poderá compilar vários programas em um só
arquivo executável, por exemplo, vamos supor que você utilizou o comando
CarregaPrograma para executar outro programa, então você poderá compilar o
programa principal e também o programa secundário em um mesmo arquivo. Para
isso você deve compilar o programa principal, por exemplo no arquivo Teste.exe,
depois carregue o programa secundário e compile ele no mesmo arquivo, nesse
caso quando o Logic Basic perguntar se deseja adicionar o programa ao arquivo já
existente, pressione o botão “Sim”.

Para executar um programa compilado, basta dar um duplo-clique sobre o

programa executável que o mesmo será executado imediatamente.

Considerações gerais sobre o Logic Basic

Esta seção tem o objetivo de esclarecer alguns detalhes e convenções
importantes sobre o Logic Basic.
Existem duas palavras-chaves denominadas Sim e Nao, que quando forem
utilizadas em comparações ou atribuições, possuem os valores Verdadeiro e
Falso respectivamente.
Dentro do comando Se poderão ser colocados outros comandos Se, desde que
cada Se seja finalizado por seu respectivo comando FimSe.
Comandos não podem ser passados como argumento para outros comandos; os
valores retornados de comandos, devem ser colocados primeiramente em
memórias, para depois serem passados para outros comandos. Por exemplo, você
não pode escrever a data, passando o comando Data para o comando Escreva.
Primeiramente, você deve criar uma memória, atribuir o resultado do comando
Data a ela, e depois escrevê-la com o comando Escreva.