• CAPÍTULO 1

• Programação visual com Software Livre

• EDIT LIN EDITORIAL S.L, dos autores Daniel

Campos Fernández e José Luis Redrejo. Prólogo
de Benoit Minisini
•
•

◦ O QUE É O GAMBAS
•
•
• É óbvio que para os que falam o idioma espanhol, a palavra Gambas nos sugere algumas
coisas, mas todas elas não faz sentido no mundo dos computadores em geral e do
desenvolvimento da programação em particular. O autor original do Gambas, Benoit
Minisini, não fala uma palavra em nosso idioma e inocentemente nomeou sua obra com o
título de GAMBAS: Gambas almost means BASIC, ou seja, 'Gambas quase significa
BASIC'. Não é a primeira vez que o nome de uma marca criada em outros idiomas produz
estas estranhas coincidências, recordamos que cocacola(TM) teve que mudar sua pronuncia
na China porque a primeira versão do seu nome significava morder o cabeça de cera,
alguns de nós nos recordamos da nossa cara de assombro ao ver os anúncios de um carro em
que Suzuki chama de Pajero. Tampouco lembramos que havia outras linguagem de
programação com nome de animal, como Camel o Python, como o nome está em inglês em
espanhol não resulta em uma palavra tão chocante.
•
• Em fim, como Benoit, que tem os direitos autorais, não deseja trocar o nome, nós teremos
que ir nos acostumando que Gambas é algo mais que uma espécie de gostoso marisco. E
fazer do Gambas o sistema visual de desenvolvimento de programação em Linux para todos,
como fez um dia o Visual Basic(TM) no Windows. Porem como o tempo não passa em vão,
Gambas tenta não cometer os erros de antes. Na aplicação da linguagem BASIC alcançando
com o Gambas aplicações poderosas, profissionalidade e modernidade, sem abandonar a
simplicidade e clareza desta linguagem de programação de alto nível. Nunca mais poderá
dizer que construir aplicações visual para o Linux é um processo longo e complexo que leva
anos de trabalho só para gurus e maníacos da informática.
•
• Gambas não é só um sistema de programação, é também um ambiente de programação
visual para desenvolver aplicações gráficas ou de console. Possibilitando desenvolver
aplicações muito rapidamente. O programador desenha as janelas de forma gráfica, arrasta
objeto da caixa de ferramentas e escreve código em BASIC para cada objeto. Gambas é
orientado a evento, o que significa que chama automaticamente os procedimentos quando o
usuário da aplicação escolhe um menu, da um click com o mouse, move um objeto na tela,
etc.
•
•
•
 ◦ A linguagem BASIC: e sua história
•
•
• O nome BASIC corresponde as siglas Beginner's All Purpose Symbolic Instruction Cod
(Código de instruções de uso universal para principiantes). A linguagem foi desenvolvida
em 1964 no Dartmouth College pelos matemáticos John George Kemeny e Tom Kurtzas.
Tentavam construir uma linguagem de programação fácil de aprender para seus estudantes
de licenciatura. Devia ser um passo intermediário antes de aprender outras mais poderosas
naquela época , como FORTRAN ou ALGOL. este ultimo era a linguagem mais utilizada
nas aplicações de processamento de dados, enquanto o FORTRAN era utilizado para as
aplicações científicas Ambos eram difíceis de aprender, tinham grande quantidades de regras
nas estruturas de seus programas e suas sintaxe. O primeiro programa feito em BASIC foi
executado as quatro da madrugada de 1 de maio de 1964. Devido a sua simplicidade,
BASIC se tornou imediatamente muito popular e acabou sendo usado tanto em aplicações
científicas quanto comerciais. Teve o mesmo impacto nas linguagens de programação que a
aparição do PC sobre os grandes computadores.
•
• Quando se desenvolveu o BASIC era no tempo que a informática estava preza a
universidades e grandes empresas, com computadores do tamanho de uma casa. Porem de
repente as coisas começaram a mudar. Em 1971 a Intel
fabricava o primeiro microprocessador . Em 1975, a empresa
MITS lançou no mercado um kit de computadores chamado
Altair 8800 a um preço de 397 dólares. Era um computador
barato, porem não era para pessoas inexperiente, tinha que
saber eletrônica para poder monta-lo. Além disso tinha só 256
bytes (não é um erro, só bytes, nada de kbytes, megas ou
gigas) e se programava em código de maquinas a base de 0 e
1, movendo uns interruptores frontal. Dois jovem viram um
modelo em uma revista de eletrônica e decidiram monta-lo. E
ofereceram ao dono da MITS, além disso fizeram um
interpretador BASIC para os novos modelos de Altair. Eram
William Gates e Paul Allen, e aquele BASIC, com um
tamanho de 4 Kbytes foi o primeiro produto que uma nova
empresa chamada Microsoft. entregou.
•
•
• PC
• Figura 1. lançamento do Altair 8800
• Foi só o inicio. No final dos anos 70, Allen e Gates haviam portado BASIC para um bom
numero de plataformas: Atari, Apple,
•
• Commodore... e em 1981, quando desenvolveram o dos para a IBM e seu novo PC,
adicionaram também seu próprio interpretador BASIC ao sistema, nos anos posteriores
seguiram outras versões feitas por outras companhias como Borland, porem o declínio do
BASIC devido a
•
• utilização das interface gráficas e janelas que a Apple popularizou e a Microsoft adaptou
com sucessivas versões do Windows(TM), os convenceram que o padrão BASIC não era
uma linguagem apropriada para este ambiente.
•
• No entanto, em março de 1988 um desenvolvedor de software chamado Alan Cooper¹
tentava vender uma aplicação que permitia personalizar facilmente o ambiente de janelas
usando o mouse. Este programa se chamava Tripod e conseguiu que William Gates o
contratasse para desenvolver uma nova versão que se chamara Ruby, foi acrescentado uma
pequena linguagem de programação. Microsoft utilizou essa linguagem para sua própria
versão do BASIC, Quickbasic e em 20 de março de 1991 lançou no mercado com o nome de
Visual Basic à principio foi um verdadeiro fracasso de vendas, porem a versão 3 publicada
no outono de 1996 foi um êxito total, tanto que atualmente é a linguagem de programação
mais usada. Visual Basic seguiu e evoluiu, já está na versão 6.0, em 2002 foi integrado na
plataforma .NET de desenvolvimento, o que para muitos dos seguidores a um suposto
abandono da Microsoft, e que foi trocado boa parte das sintaxes adicionando complexidade
e contradição com o espírito e com o nome da linguagem. Em todo caso nos dias de hoje
calcula-se que entre 70% e 80% de todas as aplicações desenvolvida no Windows foram
feitas com algumas das versões do Visual Basic.
•
• As causas do êxito do Visual Basic são numerosas, porem entre outras citar-se como óbvia o
uso da linguagem BASIC que foi pensado para uma aprendizagem fácil. Outro dos motivos
é dispor de ambiente de desenvolvimento cômodo, que faz coisa pra criança desenhar a
interface gráfica de qualquer aplicação, afastando o programador da perda de tempo em
escrever o código necessário para criar as janelas, botões, etc., deixando concentrar-se
unicamente na solução do problema que qualquer programador tenta resolver . Com a
popularização de sistemas livres como o GNU/Linux, estas e outras faz-se prever que a
aparição de um ambiente equivalente e livre seria um êxito e contribuiria para muitos novos
software que poderemos utilizar. Sabemos de varias tentativas que não foram bem sucedidas
por lentidão em sua evolução, também por sua dificuldade de uso ou por não ser totalmente
livre e não haver uma comunidade por traz dando apoio ao projeto. Finalmente, Benoit
Minisini, um programador com experiência na escrita de compiladores que estava farto de
lutar contra as falhas de desenho do Visual Basic, e desejava poder usar um ambiente
GNU/Linux fácil em sua distribuição, e começou a desenvolver seu próprio ambiente para
Linux baseado em BASIC. Em 28 de fevereiro de 2002 pois na internet a primeira versão
pública do Gambas: gambas 0.20. Benoit eliminou do desenho da linguagem muitos dos
problemas que o Visual Basic tinha, como a gestão de erro e adicionando características
comuns a linguagens atuais mas modernas, como a orientação a objeto e a própria estrutura
dos programas². Como prova de fogo o próprio ambiente de desenvolvimento foi
programado em Gambas desde a primeira versão, servindo ao mesmo tempo de
demonstração do poder da linguagem e da detecção das necessidades e correção de erros que
foram incorporados nas diversas versões.
•
• Em janeiro de 2005, Benoit publicou a versão 1.0 na qual ia ser incorporado vários
componentes desenvolvido por outros programadores que colaboraram com ele: Daniel
Campos, Nigel Gerrard, Laurent Carlier, Rob Kudla e Ahmad Kahmal. Esta versão se
considerou suficientemente estável e encerrou um ciclo. A partir dessa data começou a
versão 2.0. Esta inclui algumas melhorias na linguagem, muito mais componentes e um
novo modelo de objeto que permitira usar o Gambas no futuro para desenvolvimento de
aplicações web com a mesma filosofia e facilidade que atualmente se usa para aplicações de
escritório.
•
•
• 1.2 Um ambiente Livre
• Gambas é um ambiente se desenvolvimento distribuído com a licença GPL GNU(General
Public Licence³). Isto significa que é distribuído sempre com o código fonte e respeita as
quatro liberdades que define a Free Software Foundation:

1. A liberdade de usar o programa com qualquer propósito.

2. A liberdade de estudar como funciona o programa e adaptá-lo as suas próprias

necessidades. Acesso ao código fonte é uma condição prévia para isto.

3. A liberdade de distribuir cópias, Dessa forma podemos ajudar aos outros

4. A liberdade de melhorar o programa e fazer públicas as melhorias para que todo mundo
ea comunidade se beneficie. Acesso ao código fonte é uma condição prévia para isto.
• Um dos enganos mais comuns no uso do software livre é acreditar que este modelo de
desenvolvimento obriga que o trabalho seja publicado grátis, o que não é de tudo verdade.
Estas quatro liberdades permitem que,  Qualquer um possa vender cópias do Gambas
(entregando sempre o código fonte e respeitando essas quatro liberdades) ou qualquer
aplicação desenvolvida com este programa. As aplicações desenvolvida com Gambas podem
ou não ser publicado sobre a licença GPL.

Também qualquer programador é livre para alterar a própria linguagem e modifica-lo a seu
gosto,  e sempre entregar o código correspondente a essas modificações, respeitando os
direitos autorais dos desenvolvedores originais.

Aparte as liberdades próprias da natureza de um projeto de software livre sobre GNU/Linux,

Gambas adiciona ainda mais facilidade para o programador:

Uma ajuda muito completa da linguagem a cada um dos componentes, algo que terão muito
a agradecer os que se empenharem a programar em Gambas, o que nos é habitual nos
projetos de software livre. A ajuda publicada está em inglês,  porem existe um grupo de
pessoas trabalhando na tradução para o espanhol. se todos nós colaborarmos na tradução, em
breve estará completa e disponível  para o resto dos usuários.

Uma API (interface para programar as aplicações) simples e bem documentada, o que
facilita os programadores criarem novos componentes para Gambas. A API  não é de
utilidade imediata para os que desenvolvem com esta linguagem, porem permite que os
programadores avançado possam adicionar novas funcionalidade ao ambiente de
desenvolvimento e criar novas ferramentas para o Gambas.

A linguagem está preparada para ser independente do gerenciador de janelas que use. Isto
significa que, sem trocar uma só linha do código,  uma aplicação pode ser compilada para
ser executada em um desktop  Gnome ou KDE, usando as bibliotecas próprias desses
desktop como sendo uma aplicação nativa deste ambiente. No futuro vamos poder
desenvolver componentes para o Windows, Fluxbox e outros gerenciadores de janelas não
poderão modificar seus códigos para que suas aplicações usem seus ambientes nativos.
Marcando, apenas uma opção para escolher qual componente usar antes de compilar,
(Atualmente só podemos escolher entre gtk e qt para Gnome e KDE).
 Para gerar distintas aplicações para distintos ambientes a partir do mesmo código fonte. Esta
característica não se encontra disponível em nenhuma outra linguagem existente o que torna
o Gambas um ambiente único.
•
•
• 1.2 Um ambiente Livre
•
•
• Gambas é um ambiente se desenvolvimento distribuído com a licença GPL GNU
(General Public LIcence³). Isto significa que é distribuído sempre com o código fonte e
respeita as quatro liberdades que define a Free Software Foundation:
•
• 1. A liberdade de usar o programa com qualquer
propósito.
•
• 2. A liberdade de estudar como funciona o programa e
adaptá-lo as suas próprias necessidades. Acesso
ao código fonte é uma condição prévia para isto.
•
• 3. A liberdade de distribuir cópias, Dessa forma
podemos ajudar aos outros
•
• 4. A liberdade de melhorar o programa e fazer públicas
as melhorias para que todo mundo e a
comunidade se beneficie. Acesso ao código fonte é uma
condição prévia para isto.
•
• Um dos enganos mais comuns no uso do software livre é acreditar que este modelo de
desenvolvimento obriga que o trabalho seja publicado grátis, o que não é de tudo verdade.
Estas quatro liberdades permitem que, Qualquer um possa vender cópias do Gambas
(entregando sempre o código fonte e respeitando essas quatro liberdades) ou qualquer
aplicação desenvolvida com este programa. As aplicações desenvolvida com Gambas podem
ou não ser publicado sobre a licença GPL.
•
• Também qualquer programador é livre para alterar a própria linguagem e modifica-lo a seu
gosto, e sempre entregar o código correspondente a essas modificações, respeitando os
direitos autorais dos desenvolvedores originais.
•
• Aparte as liberdades próprias da natureza de um projeto de software livre sobre GNU/Linux,
Gambas adiciona ainda mais facilidade para o programador:
•
• Uma ajuda muito completa da linguagem a cada um dos componentes, algo que terão muito
a agradecer os que se empenharem a programar em Gambas, o que nos é habitual nos
projetos de software livre. A ajuda publicada está em inglês, porem existe um grupo de
pessoas trabalhando na tradução para o espanhol. se todos nós colaborarmos na tradução, em
breve estará completa e disponível para o resto dos usuários.
•
• Uma API (interface para programar as aplicações) simples e bem documentada, o que
facilita os programadores criarem novos componentes para Gambas. A API não é de
utilidade imediata para os que desenvolvem com esta linguagem, porem permite que os
programadores avançado possam adicionar novas funcionalidade ao ambiente de
desenvolvimento e criar novas ferramentas para o Gambas.
•
• A linguagem está preparada para ser independente do gerenciador de janelas que use. Isto
significa que, sem trocar uma só linha do código, uma aplicação pode ser compilada para
ser executada em um desktop Gnome ou KDE, usando as bibliotecas próprias desses
desktop como sendo uma aplicação nativa deste ambiente. No futuro vamos poder
desenvolver componentes para o Windows, Fluxbox e outros gerenciadores de janelas não
poderão modificar seus códigos para que suas aplicações usem seus ambientes nativos.
Marcando, apenas uma opção para escolher qual componente usar antes de compilar,
(Atualmente só podemos escolher entre gtk e qt para Gnome e KDE).
•
• Para gerar distintas aplicações para distintos ambientes a partir do mesmo código fonte. Esta
característica não se encontra disponível em nenhuma outra linguagem existente o que torna
o Gambas um ambiente único.
•
• 1.3 Elementos do Gambas
•
•
• Para podermos desenvolver e executar programas feitos com Gambas, são necessários
diversos elementos:
•
• .Um compilador, que se encarregara de transformar o código fonte em arquivos que fazem
parte de um projeto feito em Gambas, em um programa executável.
•
• .Um interpretador capaz de fazer com que os programas feitos em Gambas sejam executados
pelo sistema operacional.
•
• .Um ambiente de desenvolvimento que facilite a programação e desenhos das interfaces
gráficas dos programas.
•
• Componentes que adicionam funcionalidades a linguagem. A palavra componente tem um
significado específico, que não se refere a partes genéricas, e sim a bibliotecas específicas
que lhe dotam de mais possibilidades. Na atualidade existe componentes para usar xml,
conexões de rede, opengl, sdl, ODBC, Varias bases de dados, expressões regulares, desktop
baseados em qt e gtk, etc. Estes componentes são desenvolvido por vários programadores,
seguindo as diretrizes da API do Gambas e a documentação publicada por Benoit Minisini.
•
•
• 1.4 Como obtê-lo
•
• As novas versões do Gambas são publicadas através da página oficial do projeto:
[Link] Na atualidade existem dois Gambas: o estável 1.0 e o de
desenvolvimento 1.9 que acabara na versão 2.0. Da versão estável só se publicou novas
versões quando foi para corrigir alguma falha que foi descoberta.
•
• No momento que escrevi estas linhas, a versão estável era a 1.0.11 e não se prever que haja
mudanças no futuro. A versão de desenvolvimento está em continua mudanças, melhorias e
adição de novos componentes. isto a faz muito atrativa, devido a existências de importantes
funcionalidades que não estão na versão estável (como os componentes gtk e ODBC).
Como essa é uma versão de desenvolvimento, é muito provável que tenha falhas não
descoberta e com certeza sofrera mudanças em um futuro próximo. Neste texto trataremos
de todas as novidades que a versão de desenvolvimento contem para que o o usuário possa
escolher qual das versões trabalhar. Boa parte das diferença se encontra nos novos
componentes. Algumas destas serão tratados neste texto, porque se o leitor quiser trabalhar
com eles deverá usar a versão desenvolvimento.
•
• As novas versões são publicado sempre em forma de código fonte, para que usuário que
desejarem compilem e obtenham todas as partes que o Gambas tem. Os autores de alguns
dos
•
• componentes que são feitos para o Gambas, são publicados em vários sites da web porem
todas são enviadas a Benoit Minisini e passam a fazer parte da publicação completa desta
linguagem de programação e da seguinte versão. Deste modo pode se dizer que que quando
Benoit faz uma nova publicação, o pacote do código fonte contem as ultimas versões de
todo o conjunto no momento.
•
• Como a compilação do Gambas e todos os seus pacotes associados pode ser uma tarefa
difícil para usuários inexperiente, é comum que se criem pacotes binários já compilados
preparado para ser instalados em várias distribuições gnu/Linux. Existe atualmente pacotes
disponíveis para Debian, Fedora, Mandriva, Gentoo, Slackware, QiLinux e Suse. Em alguns
casos, como para Fedora e Debian, está disponível tanto os pacotes da versão estável como a
de desenvolvimento.
•
• No caso do Debian, os pacotes são criados em gnuLiEx e posteriormente, convertidos a
Debian para que esteja disponível e usável nesta distribuição e em todas suas derivadas,
como Kinoppix, Guadalinex, Progeny, Xandros, Linspire, Skolelinux, etc. Por este motivo,
as ultimas versões estão sempre disponíveis antes nos repositórios do gnuLinEx já que
foram convertidos e aprovados em Debian. As linhas do arquivo /etc/apt/[Link] de um
sistema Debian para instalar a versão mais atualizada dos pacotes Gambas são:
•
• Para a versão estável: deb [Link] gambas/
•
• Para a versão de desenvolvimento: deb [Link] gambas
•
• A seguir, em qualquer um dos casos, para instalar todos os pacotes do Gambas, tem que
executar como root:
•
• apt-get update
• apt-get install gambas
•
• Mesmo que o código fonte do Gambas seja distribuído em um único arquivo compactado, a
instalação dos pacotes compilados e feita com uma boa quantidade de arquivos.
•
• A razão é que nem todos são necessário para executar aplicações feitas em Gambas. As
distribuições de Linux vem seguindo um critério de separar em vários pacotes o ambiente
de desenvolvimento (pacote gambas-ide), o interpretador (pacote gambas-runtime), foi feito
um pacote separado para cada um dos componentes. Se Você quiser programar em Gambas
são necessário a maioria deles, ao menos os que o ambiente de desenvolvimento necessita.
se quiser apenas executar um programa feito com esta linguagem , só é necessário gambas-
runtime e um pacote para cada um dos componentes que o programa usa. Por exemplo se for
um programa que foi feito para o desktop Gnome e não usa nenhum outro componente, só
será necessário no sistema os pacotes gambas-runtime e gambas-gb-gtk.
•
•

◦ 1.5 Compilação e dependências

•
•
• Se em lugar de instalar pacotes já compilados para as distribuições gnu/Linux desejarmos
compilar a partir do código fonte, deveremos seguir os passos habituais do sistema GNU. É
baixar, descomprimir o arquivo com os fontes, dentro do diretório que se criou ao
descomprimir e usando um terminal, executar as seguintes instruções:
•
• ./configure
• make
• make install
•
• O ultimo deles devemos faze-lo como root, se quisermos que o programa esteja disponível
para todos os usuários do computador. se estivermos acostumados a compilarmos aplicações
no sistema GNU, dispomos de um compilador instalado e de bastantes bibliotecas de
desenvolvimento. as instruções anteriores trataram de compilar e instalar todos os
componentes do Gambas, que são muitos. Se não tivermos as bibliotecas correspondentes a
algum deles simplesmente não se compilarão e a instrução ./configure nos informará delas.
É importante saber que o ambiente de desenvolvimento foi feito sobre a biblioteca gráficas
qt, portanto, para poder usar o ambiente necessitamos ter instalado ao menos essas
bibliotecas de desenvolvimento com uma versão igual ou superior a 3.0. A versão do
compilador gcc deve ser esta também, no mínimo. Cada um dos componentes tem
dependências de suas próprias bibliotecas e dependerá da distribuição Linux que usamos,
para saber o nome do pacote que deveremos instalar antes de podermos realizar a
compilação.
•
•
• 1.6 Familiarizando com a IDE
•
•
• Mesmo que um programa em Gambas possa ser feito com um editor de texto plano
qualquer, seria um desperdício não aproveitar um dos maiores atrativos que a linguagem
tem: sua IDE, o ambiente de desenvolvimento. A IDE do Gambas poupa o programador boa
parte do trabalho mais tedioso, lhe proporciona ferramentas que tornam muito mais fácil sua
tarefa, com utilitários de ajuda, desenhos da interface, auto completando as instruções,
tradução do programa, etc. Na imagem seguinte podemos ver algumas das janelas mais
importantes do ambiente, que se usa durante o desenvolvimento de uma aplicação:

• Figura 2. Ambiente de desenvolvimento do Gambas

• Quando o Gambas inicia, o primeiro que aparece é a janela de bem vindo
•
• Figura 3. Janela de bem vindo
•
• Aqui temos as opções de começar um novo projeto ou aplicação, abrir um projeto desde que
tenhamos seus arquivos disponíveis, abrir um usado recentemente ou um dos numerosos
exemplos que está incluído na ajuda do Gambas.

Antes de escolher qualquer uma dessas opções é necessário saber que todos os códigos
fontes de uma aplicação feito em Gambas é o  que se denomina projeto. O projeto é formado
por uma série de arquivos que no Gambas está sempre dentro de um único diretório. porem
o desenvolvedor pode criar vários sub diretórios e organizar a seu gosto, porem qualquer
gráfico, texto e código que faça parte da aplicação estará dentro do diretório do projeto. Por
isso se escolhermos nesta janela Novo projeto..., o assistente sempre criará um novo
diretório com o nome do projeto e ai ira introduzir todos os arquivos necessário para o
desenvolvimento da aplicação. Assim, para enviar a alguem o código fonte de uma aplicação
feito em Gambas ou mudar de computador ou de disco, é só copiar o diretório com o nome
do projeto, sem ter que preocupar-se com outros arquivos. Do mesmo modo, se a partir do
ambiente de desenvolvimento escolhermos um arquivo ou um gráfico para integra-lo ao
nosso trabalho, o arquivo será automaticamente copiado para o diretório do projeto.
•
•
• O primeiro exemplo
•
•
• Uma das formas mais habituais de começar a trabalhar com uma linguagem de programação
é fazendo um pequeno programa que mostra uma mensagem Olá mundo. isto é puro BASIC,
quer dizer, que é igual o que fizeram os autores do BASIC por volta de 1964.
•
• Naquele tempo as interfaces gráficas não existiam porque este primeiro programa era um
programa feito, no terminal. No BASIC original, fazer que aparecesse uma mensagem no
terminal era tão simples como escrever na linha:
•
• PRINT "Olá Mundo"
•
• Não é necessário nenhum
cabeçalho prévio, a instrução
PRINT serve para mostrar
qualquer cadeia de texto no
terminal, que no BASIC se
apresenta entre aspas duplas.
não existe programa tão
simples como esse. Vamos
ver como faze-lo com o
ambiente de
desenvolvimento Gambas:
•
• 1. Escolhemos a opção Novo
projeto na janela anterior
(Figura 3). Aparecerá um
assistente, Quando
pressionarmos Próximo.
Surgirá uma nova janela para
escolhermos o tipo de
aplicação. Escolheremos a terceira opção: criar um projeto de texto.
•
• 2. Damos um nome ao projeto, por exemplo olá mundo e um título. Pressionamos o botão
próximo (figura4) /\.
•
• Escolhemos o diretório do
disco em que queremos
cria-lo; pressionamos
novamente o botão próximo
e aparecerá um resumo com
os dados do projeto (Figura
5) =>.
•
• 3. A pressionarmos o botão
OK. se abrirá o ambiente de
desenvolvimento do
Gambas pronto para
começar a programar. Por
ser uma aplicação
• Figura 4
• Figura 4. Assistente do Gambas
•
• de terminal, que não possui interface gráfica, no momento só necessitamos nos fixar na
janela da esquerda, que em nosso caso terá
como título: Projeto – olamundo (figura 6).
•
• Na realidade esta é, provavelmente, a janela
mais importante para manipular o ambiente
de desenvolvimento. A primeira vista
podemos ver o menu superior, que contem as
entradas necessárias para salvar e carregar
projetos, ativar as varias janelas da IDE,
manipular a execução dos programas,
personalizar o ambiente (Ferramentas |
Preferências | Outros | Mostrar Mascote,
Podemos ocultar a animação do Camarão,
que nos está olhando ao abrir o projeto), etc.
•
• No momento nos fixamos só na arvore de
diretórios que contem. Podemos ver que a
raiz da arvore é o nome do projeto:
olamundo, e que dele saem três tipos: Classes
e Módulos, que são para Figura 5
• Figura 5. Dados do projeto.
•
•
• diversos tipos de arquivos de código fonte; e Dados, cujo nome indica sua finalidade,
Armazenar ai os arquivos de dados que a aplicação requeira.
•
• Desde o início, Gambas nos da duas formas de criar os programas, inclusive são tão
simples como o que iremos fazer. Podemos escolher entre uma programação orientada a
objetos, paradigma típico das linguagens de programação mais poderosas ou uma
programação estruturada simples. Sendo assim, o arquivo que contem o nosso programa
pode ser uma Classe ou um Módulo. Para simplificar, no momento vamos usar um Módulo.
Damos um click com o botão direito do Mouse sobre a arvore de pastas aparecerá um menu
contextual. Escolhemos a opção Novo | Módulo. Surgirá uma janela na qual escrevemos o
nome do módulo, por exemplo [Link], onde podemos escrever o código.
Figura 6
• Figura 6. Projeto - olamundo.
• Por fim podemos escrever nosso código em BASIC. O faremos justo antes da linha onde
está o END, Tal como está mostrando a (Figura 7).
•
• Depois que escrevermos o código o qual já conhecemos, pressionamos a tecla ENTER,
vemos que o ambiente colore o texto de uma maneira particular. Podemos parar um instante
e observar as varias cores que mostra a (Figura 7):
•
• Em cinza aparece uma linha que começa com uma aspa simples ('). isto indica que a linha é
um comentário, Quer dizer que não se trata de nenhum código de programação e o texto
após a aspa não Figura 7
• Figura 7. Janela onde escrevemos os códigos
• será executado nunca, são comentários que o programador pode e deve colocar para facilitar
que outros (ou ele mesmo, com o passar do tempo) entenda o que o programa faz nesse
ponto.
•
• .Em azul podemos ver palavras chave da linguagem BASIC.
•
• .Em rosa aparece a cadeia de texto.
•
• .A esquerda vemos um ressalte amarelo no começo das linhas que tenham sido
modificadas. Isto aparecerá sempre nas linhas que contenham modificações e que
ainda não tenham sido compiladas.
•
• Bem, já está pronto o programa. Para comprovar basta da um click no botão verde. com o
símbolo de Play, que está na tela do projeto. Ao faze-lo aparecerá uma nova janela chamada
Console na qual se verá a saída do nosso programa. Neste caso será um simples texto Olá
Mundo. Este é todo o código necessário, já podemos compilar o programa para gerar um
arquivo executável que funciona sem a necessidade do ambiente de desenvolvimento. Para
isso no menu da janela do projeto deve escolher: Projeto | Criar executável. Aparecerá uma
janela de diálogo para escolher o diretório onde queremos criar o executável. Click OK e o
gerará. Vamos encerrar agora o ambiente de desenvolvimento do Gambas e abrir um
terminal ao passar para console do Linux, podemos provar o funcionamento. Para isso, no
diretório onde foi criado o executável, fazemos:
•
• jose@a00-o04:~$ cd gambas/olamundo/
•
• jose@a00-o04:~/gambas/olamundo/$ ./[Link]
•
• Olá Mundo
•

◦ Melhor com um exemplo gráfico

•
•
• O Exemplo anterior Mostrava uma aplicação de console, que nos recorda os velhos tempos
de outros sistemas operacionais e a forma de trabalhar dos hackers da informática.
•
• Na realidade, fazer esse tipo de programa nos demonstra o potencial do Gambas, Mostra que
é realmente simples e igualmente fácil de realizar como em outras linguagens como Python
ou qualquer que seja a versão do BASIC.
•
• É melhor fazer o programa Olá Mundo para o ambiente gráfico que inunda os escritórios e
os computadores atuais. Para isso faremos igual a antes, iniciaremos o Gambas e criando
um Novo projeto seguindo exatamente os mesmos passos, exceto que no lugar de
escolhermos Criar um projeto de texto, quando o assistente nos apresentar as várias opções,
escolheremos Criar um projeto gráfico.
•
• Para não repetir nome, podemos denominar o projeto olamundo2. Ao acabar o processo
aparecerá de novo a janela do projeto, porem nesta ocasião terá um Caminho a mais na
arvore: Formulários. Um formulário é a área onde se desenha a interface gráfica da
 aplicação, quer dizer, onde se insere objetos como botões, caixa de texto, listas, caixas de
verificação, etc. Os formulários corresponderão as janelas que a aplicação mostrará.
•
• Dando um click com o botão direito do mouse sobre a árvore do projeto, escolhemos agora
no menu contextual que aparece: Novo | formulário. por simplicidade neste caso nem sequer
precisa trocar o nome, só da um click no botão OK aparecerá na tela a janela do formulário
e uma janela para escrever código BASIC quase idêntica a do exemplo anterior, sem nada
escrito. O resultado será algo parecido ao seguinte:

• Figura 8. Tela do formulário

•
• Dando um click sobre a palavra Form na janela da direita, correspondente a Caixa de
ferramenta, aparecerá vários objetos que podemos colocar em nosso formulários. entre estes
está o ícone do botão (se distingue rapidamente por ter a palavra OK escrito dentro). Dando
um click do mouse nele, podemos desenhar no formulário um botão, tem só que arrasta-lo
com o mouse e o botão esquerdo pressionado, para darmos a forma que queremos. Gambas
escreve o texto Button1, porem como este texto não é muito intuitivo o melhor é troca-lo.
Para isso é só selecionar o botão e depois, na janela propriedades, dá um click na linha onde
está Text. Agora Você pode escrever um novo texto, por exemplo Pressiona-me.
•
• Falta a página 34 e 35 ................................................................................................
•
• Uma aplicação nativa para o desktop KDE. Porem, com o componente Gtk disponível na
versão de desenvolvimento do Gambas, permite fazer programas enlaçados com as
bibliotecas do Gtk para realizar aplicações do desktop Gnome.
•
• Se tivermos instalados os pacotes do Gambas correspondentes a versão de desenvolvimento,
incluindo pacote gambas-gb-gtk, podemos recuperar a aplicação olamundo2 do exemplo
anterior, ir à janela do Projeto e da um click no menu Projeto | Propriedades | , aba
 Componentes, e [Link]. O resultado ao executar a aplicação é que se trata de uma
nova, porem antes do KDE e agora do Gnome. e sem trocar uma só linha de código!
•

• •
• Figura 10. Aplicação olamundo2 em KDE Figura 11. Aplicação olamundo2 em
Gnome
•
• Até os dias de hoje não existe nenhuma outra linguagem de programação que possa fazer
isto.
•
•

◦ 1.7 Componentes do sistema

•
•
• Ao longo dos parágrafos anteriores apareceram várias referências aos componentes do
Gambas, incluindo sua descrição no terceiro parágrafo deste capítulo. Este permitem
entender esta linguagem de programação. A interface desenvolvida por Bonoit para sua
programação fez com que vários programadores quisesse colaborar com ele, desenvolvendo
novos componentes que vão sendo adicionada as diversas versões do Gambas em cada nova
publicação. Na versão 1.0 estável do Gambas só podia desenvolver em C e C++, porem a
partir da versão 1.9.4 da
versão de desenvolvimento
podemos escrever
componentes também em
Gambas, o que abre
numerosas possibilidades
futuras já que é muito mais
simples que em C.
•
• A lista de componentes
disponíveis é ampla e
aumenta continuamente na
versão de desenvolvimento.
Porem a versão estável está
fixada os seguintes:
•
• * [Link]: para compressão de arquivos no formato zip e bzip2.
•
• * [Link]: para objetos visuais das bibliotecas gráficas qt.
•
• * [Link]: para objetos visuais das bibliotecas gráficas qt que não são padrão.
•
• * [Link]: um editor de texto que faz uso das bibliotecas gráficas qt.
Figura 12. Componentes.
•
• * [Link]: objetos próprios do desktop KDE.
•
• * [Link]: um navegador web do desktop KDE.
•
• * [Link]: objetos para conectar um servidor de rede e outras comunicação.
•
• * [Link]: objeto para construir servidores de rede.
•
• * [Link]: objeto de conexão a base de dados.
•
• * [Link]: driver para conectar ao servidor de base de dados MySQL
•
• * [Link]: driver par a conectar ao servidor de base de dados postgresql.
•
• * [Link]: driver para usar base dedados sqlite 2.x.
•
• * [Link]: objetos para manipular arquivos XML.
•
• * [Link]: coleções de funções para facilitar a migração do Visual Basic.
•
• * [Link]: objetos para reproduzir, mesclar e gravar arquivos de som.
•
• * [Link]: objetos para usar expressões regulares na linguagem.
•
• Na versão de desenvolvimento existe estes componentes (alguns dos quais tem sido muito
melhorados e aumentados, como o [Link] ) e outros mais, com uma lista em continuo
crescimento. No momento que escrevo essas linhas podemos contar com:
•
• * [Link]: objetos para encriptação DES e MD5.
•
• * [Link]: objetos para formulários independentes da bibliotecas gráficas usadas.
•
• * [Link]: objetos gráficos para formulários das bibliotecas gtk. Tem os mesmos
objetos que os componentes [Link], porem enlaçado com esta outra biblioteca de
desenvolvimento.
•
• * [Link]: driver para conectar a base de dados através do ODBC.
•
• * [Link]: objetos que dão varias informações sobre os componentes e o sistema
onde a aplicação é executada.
•
• * [Link]: objetos com desenhos tridimensionais para aceleração OpengL.
•
• * [Link]: objetos para o uso do protocolo rpc-xml.
•
• * [Link]: objetos para desenhos em duas dimensões com aceleração gráfica.
•
• * gb.v4l: objetos para captura de vídeos em Linux.
•
• * [Link]: utilizado para renderizar documentos pdf nas aplicações feitas em Gambas.
•
• A lista dos componentes disponíveis para o programador pode se ver na aba Componentes,
acessível através do menu Projeto | Propriedades. Cada um dos componentes corresponde a
um pacote compilado na distribuição, de forma que para termos adicionado ao projeto, por
exemplo, o componente [Link], teremos que instalar o pacote gambas-gb-sdl, e nos
computadores onde se queira executar a aplicação compilada.
•
• Ao darmos um click a cada um dos componentes aparecerá uma pequena descrição de sua
função, o nome do autor ou autores do componente, e uma lista dos controles que estará
disponível para o desenvolvedor se selecionar o componente (figura 12).
• Figura 12
• Figura 12. Componentes.
•
•
• Os controles são classes para
criar objetos úteis na
programação. Os objetos
criados podem ser visuais
(como abas, Caixas de textos ,
etc.) ou objeto de código
(como servidores de rede ou
conexões de base de dados).
se o componente tem objeto
visuais, estes se incorporam
em algumas das abas da Caixa
de Ferramentas do ambiente
de desenvolvimento.
•
• Nas imagens anteriores
podemos ver alguns objetos
gráficos que estão disponíveis
ao selecionarmos um
determinado componente.
•
• Cada componente tem sua
própria documentação que
encontra-se incluída na ajuda
do Gambas. Na versão estável
esta ajuda está sempre
 disponível; na versão de desenvolvimento só estará disponível se tiver sido selecionada para
seu uso no projeto.
•
• Todas as coisas que podemos fazer com o Gambas e não fazem parte da própria linguagem
BASIC, Programamos mediante o uso de componentes. Isto significa que, por exemplo, para
fazermos uma aplicação de base de dados é necessário selecionar o componente [Link] ou
não estarão disponível os objetos de conexão de base de dados. O mesmo ocorre com as
conexão de redes, captura de vídeo, etc. Estes objetos não fazem parte da linguagem BASIC.
•
• Figura 13Figura 14Figura 15
• Figuras 13, 14, 15. Caixa de Ferramentas com componentes e objetos gráficos.
•
•
• NOTAS
•
•
• 1 - [Link]
•
• 2 - diferença entre Gambas e Visual Basic:
•
• [Link]
•
• 3 - [Link]
•
• 4 - Tradução não oficial para o Espanhol em:
•
• [Link]
•
• 5 - Documentação do Gambas em espanhol:
•
• [Link]
•
• 6 - Instruções para colaborar na documentação em espanhol:
•
• [Link]
•
• 7 – Se a instalação for feita a partir de m sistema gnuLinEx, não é necessário adicionar
esta linha já que a versão de desenvolvimento do Gambas é parte do repositório oficial
do gnuLinEx.
•
• 8 – Devido a maior extensão do texto Criar um projeto de texto em português ser maior
que em outros idiomas, é possível que esta mensagem apareça cortada e não se
veja por completo. Não fique preocupado com isso, não afeta em nada a sua seleção
e suponhamos que seja corrigida em posteriores versões da IDE.
•
• CAPÍTULO 2

• Programação visual com Software Livre

• EDIT LIN EDITORIAL S.L, dos autores Daniel

Campos Fernández e José Luis Redrejo. Prólogo
de Benoit Minisini
•
•

◦ PROGRAMAÇÃO BÁSICA
•
•
•
• No Capitulo 1 Vimos alguns detalhes sobre a programação com Gambas. Agora
estudaremos, principalmente, as sintaxes e instruções mais importantes da linguagem
BASIC que o Gambas usa. Boa parte destas instruções existem no BASIC padrão e algumas
outras são extensões próprias do Gambas.
•
• No entanto o mais importante, neste capitulo é usarmos quase sempre exemplos de código
de console, como vimos no parágrafo o primeiro exemplo do capitulo 1. Fazendo deste
modo evitaremos as interferências que pode complicar a explicação de conceitos
relacionados com a programação gráfica e os componentes. Estes conceitos será explicado
nos capítulos posteriores.
•
•

◦ 2.1 Organização de um projeto em Gambas

•
•
•
• Antes de começar com a programação básica teremos que resumir alguns conceitos prévios:
•
• * Os códigos fontes dos programas feitos em Gambas está composto em um ou mais
arquivos que formam um projeto. Este projeto se arquiva em um diretório do mesmo nome.
•
• * Os Arquivos de código podem ser: Módulos (contem código em BASIC que se
executam diretamente), Classes (contem o código em BASIC que executa um objeto de
classe) e Formulários (áreas onde se desenha a interface gráfica da aplicação e que
correspondem as janelas do programa).
•
• * Os projetos de textos só contem Módulos ou Classes . as aplicações gráficas contem
Formulários e Classes, mas também podem conter Módulos.
•
• * O projeto pode conter outros arquivos de dados, documentos, textos, etc., sem código
BASIC para ser executado pela aplicação.
•
• * Os arquivos que contenham código em BASIC (Módulos e Classes) sempre estão
estruturados da seguinte maneira:
•
• * Declaração de variáveis.
•
• * Subrotinas e funções.
•

◦ Declaração de variáveis
•
• Os programas manipulam dados continuamente. Estes dados podem ser de muitos
tipos: números, letras, textos, etc. e trocam seus valores ao longo da execução do programa
(neste caso recebem o nome de variáveis) ao permanecer com um valor fixo durante todo o
tempo (então se denominam constantes). A estes dados que um programa usa é necessário
atribuir um nome identificador.
•
• O BASIC permite usar variáveis e constantes sem havermos declarado antes, quer dizer, sem
haver exposto no inicio do programa uma lista de todas as variáveis que iremos usar.
•
• Isso produz programas ilegíveis e quando chega a um tamanho médio é uma fonte constante
de erros. Para evitar isto, Gambas obriga a declarar as constantes e as variáveis antes de
utilizá-las
•
• Os lugares onde se pode declarar variáveis, depende do âmbito que se vai usar. Se
declararmos dentro de uma subrotina ou função (nos parágrafos seguintes veremos com
detalhes o que são subrotinas e funções), estará disponível para ser usada somente dentro
dessa subrotina ou função. Se declararmos no inicio de um arquivo de código (seja um
Módulo ou um Classe) estará disponível para todo o código desse arquivo, em todas as
subrotinas.
•
• Para declarar uma variável em uma subrotina ou função é só empregar a sintaxe:
•
• DIM nome_variável AS tipo_variável
•
• O tipo_variável faz referência ao tipo de dados da variável: número inteiro, cadeia de texto,
número decimal, etc. O nome da variável o programador escolhe livremente. É
recomendável que seja algo que indique o uso da variável. Devemos fugir de nomes como a,
b, c, etc., e usar por exemplo, idade, data_nascimento, altura, etc.
•
• As variáveis que declaramos dentro de uma subrotina ou função só serão usadas dentro
delas. Quando termina se destruirão. Isso permite usar o mesmo nome da variável dentro de
várias subrotinas e seu valor nunca se confundirá ou mesclará.
•
• Para declararmos uma variável no inicio de um Módulo ou Classe usamos a sintaxe:
•
• [STATIC] (PUBLIC | PRIVATE) nome_variável AS tipo_variável
•
• Se definirmos a variável como PRIVAT, estará disponível dentro do arquivo, mas não será
acessível nos outros arquivos do mesmo projeto. Se à declararmos PUBLIC, podemos
acessa-la no arquivo onde foi declarada ou de qualquer arquivo do projeto.
•
• A palavra STATIC se usa nos arquivos de Classe, não nos Módulos. Serve para definir um
comportamento especial em todos os objetos de uma mesma classe. Em poucas palavras
poderíamos explicar com um exemplo: se temos uma classe cachorro, teremos algumas
variáveis como cor, raça, peso, etc., e cada objeto cachorro terá seu próprio valor em cada
uma dessas variáveis.
•
• Ao mesmo tempo, podemos declarar uma variável que seja número_de_patas, de forma que
se trocarmos seu valor de 4 para 3, todos os objetos cachorro terão 3 patas e cada um
continuará com seu próprio peso, cor, etc. Neste caso a variável número_de_patas se
declarará STATIC no código BASIC no arquivo da classe cachorro. Veremos todos estes
comportamentos mais adiante neste mesmo capítulo.
•
• As constantes se define só no inicio de arquivos, Módulo ou Classe, não podemos defini-las
dentro das subrotinas e funções. A sintaxe é:
•
• (PUBLIC | PRIVATE ) CONST nome_constante AS tipo_constante = valor
•
• Portanto, é igual as variáveis, podem ser privada ou públicas.
•
• Vejamos um exemplo de tudo isso:
•
• 'Gambas module file
• 'Arquivo do módulo com o nome: exemploVariavel
• 'No livro em espanhol a constant era assim PRIVATE CONST Pi = 3.141592
• 'No meu teste só funcionou como está no exemplo
•
• PRIVATE idade AS Date
• PRIVATE altura AS Single
• PRIVATE CONST Ppi AS Float = 3.141592
• PUBLIC qualidade AS Integer
•
• PUBLIC SUB Subrotina1()
•
• DIM num AS Integer
•
• DIM nome AS String
• idade = 30
• num = 54
•
• END
•
• PUBLIC SUB subrotina2()
•
• DIM num AS Integer
• DIM apelido AS String
• idade = 32
• num = 4
•
• END
•
• Neste exemplo vimos que as variáveis idade e altura podem ser usadas em todo o arquivo.
Portanto, quando executar a subrotina1, idade valerá 30 e, depois que executar a subrotina2
valerá 32. Vimos também que a variável num está definida nas duas subrotinas. O valor de
num desaparece ao acabar cada uma das subrotinas e, portanto, durante a subrotina1 valerá
54 e durante a subrotina2 valerá 4 mas depois que se executa o END de cada uma dessas
subrotinas, simplesmente não existirá e se fizermos referência a num em qualquer outro
ponto do programa se produzirá um erro.
•
• Finalmente vemos que a variável qualidade está definida como pública. Isso significa que de
qualquer outro arquivo do programa pode ser feita referência a ela mediante o nome
[Link], onde exemplo Variável é o nome que foi dado ao arquivo onde
foi declarado qualidade.
•

◦ Subrotinas e Funções
•
• E impensável escrever todo o código de um programa sem a mínima organização. Em
BASIC o código se organiza dividindo-o em procedimentos. Existem dois tipos de
procedimentos: subrotinas e funções. Uma subrotina é um procedimento que executa algo,
mas não devolve nenhum valor. Exemplos de subrotinas seriam procedimentos para
desenhar algo na tela, tocar um som, etc. No entanto, uma função é um procedimento que
sempre devolve algo ao terminar sua execução. Exemplos de funções seriam os cálculos de
uma operação matemática que devolve um resultado, o processo para pedir dados ao
usuário da aplicação, etc.
•
• Já temos visto no capitulo anterior a sintaxes para declarar as subrotinas, já que que o
ambiente de desenvolvimento escreve automaticamente as subrotinas que o programa
executa ao darmos um click sobre um botão. A sintaxe completa é:
•
• (PUBLIC | PRIVATE) SUB nome_da_subrotina (p1 AS tipo_da_variável, p2 AS
tipo_da_variável, ......)
•
• ...código que a subrotina executa
•
• END
•
• As palavras PUBLIC e PRIVATE significa exatamente o mesmo que quando se define
variáveis: determina se a subrotina pode ser chamada só do arquivo onde foi codificado
(PRIVATE) ou de qualquer arquivo da mesma aplicação (PUBLIC).
•
• As variáveis p1, p2, etc., permite passar parâmetros à subrotina, que se comportam dentro
dela como variáveis declaradas dentro da própria subrotina. Quer dizer, desaparecem ao
executar o END final. Pode se passar tantos parâmetros quando se desejar numa subrotina,
declarando todos, obviamente
•
• Existem algumas subrotinas com nomes especiais no Gambas, portanto o programador não
deve usar esses nomes. São as seguintes:
•
• Main: existe em todas as aplicações do Gambas, que são no modo texto, não no modo
gráficos. Este é o ponto onde começa a executar o programa. Se não houvesse a subrotina
Main, Gambas daria uma mensagem de erro ao iniciar já que não saberia por onde começar.
•
• New e Free: se executam, respectivamente, ao criar-se e destruir-se um objeto. Só se
encontram nos arquivos de classe.
•
• Objeto_evento: executa-se automaticamente quando no Objeto ocorre um evento. Já foi
visto alguns exemplos no capitulo anterior, como btnsair_Click(), que executa quando o
usuário da aplicação da um click com o botão do mouse sobre o botão btnsair. Nas
aplicações gráficas, o evento Open do formulário, que inicia a aplicação, é a primeira
subrotina que o programa executará. No ultimo paragrafo deste capitulo trataremos
especificamente destes eventos, seus significados e utilidades.
•
• Vejamos um programa de exemplo. Para testarmos, vamos criar um novo programa de texto
seguindo os passos explicados no Capitulo 1, paragrafo O primeiro exemplo:
•
• PUBLIC SUB Main ( )
•
• Print_Media ( 4, 8 )
•
• END
•
• PUBLIC SUB Print_Media ( Valor1 AS Integer, Valor2 AS Integer )
•
• PRINT ( Valor1 + Valor2 ) / 2
•
• END
•
• Mesmo que este seja um programa pouco útil, serve para expressar com simplicidade a
forma de funcionar das subrotinas. Começa executando a subrotina Main, nela só existe uma
chamada para executar a subrotina Print_media passando os números inteiros 4 e 8 como
parâmetro. A subrotina Print_media mostra no console o resultado da média entre os dois
valores que foi passado como parâmetros.
•
• As sintaxes para declarar uma função é a seguinte:
•
• (PUBLIC | PRIVATE) FUNCTION nome_função (p1 AS Tipo_Variável, p2 AS
Tipo_Variável....) AS Tipo_Dados
•
• ......código que a função executa
•
• RETURN resultado_que_a_função_executou
•
• END
•
• A declaração é quase idêntica a da subrotina, acrescentando mais duas coisas: o tipo de dado
que a função devolve na primeira linha e a necessidade de usar a sentença RETURN do
BASIC para indicar o valor a devolver.
•
• Vamos a outro exemplo que produz o mesmo resultado que o anterior, porem usando uma
função:
•
• PUBLIC SUB Main ( )
•
• DIM Final AS Single
• Final = Calcula_Media ( 4, 8 )
• PRINT Final
•
• END
•
• PUBLIC FUNCTION Calcula_Media ( Valor1 AS Integer, Valor2 AS Integer ) AS Single
•
• RETURN ( Valor1 + Valor2 ) / 2
•
• END
•
• Neste caso é a subrotina Main que encarrega-se de mostrar no console o resultado da
operação. É muito importante destacar a diferença entre a forma de chamar uma subrotina e
chamar uma função. No exemplo anterior vimos que para chamar a subrotina era só escrever
seu nome com seus parâmetros entre parenteses. Agora vemos que para chamar a função
usamos uma designação, Final = Calcula_Media(4,8). Isto deve ser feito sempre ao chamar
uma função: a designação serve para recolher o valor devolvido. Por motivos óbvios, a
variável que recolhe o valor da função deve ser declarada do mesmo tipo de dado que o
devolvido pela função. No exemplo anterior a função devolve um dado tipo Single (um
numero real com decimais) e a variável Final e declarada portanto, do tipo Single.
•
• 2.2 Tipos de dados
•
•
• Temos visto ao longo dos textos anteriores o uso de variáveis e como são declaradas.
• Ate o momento, só conhecemos alguns tipos de dados. Veremos agora todos os que o
Gambas suporta:
•
• *Boolean: é um tipo de dados que pode ser o resultado de uma comparação, só aceita os
valores: False e True (Verdadeiro ou Falso em português).
•
• *Byte: representa um numero inteiro positivo entre 0 e 255.
•
• *Short: representa um numero inteiro com valores possível entre -32.768 e +32.767
•
• *Integer: representa um numero inteiro com valores possível entre -[Link] e
+[Link].
•
• *Long: representa um numero inteiro com valores possível entre -
[Link].854.775.808 e +[Link].854.775.807.
•
• *Single: representa um número real, com decimais, com valores possívelentre -1,7014118
+38 e +1,7014118E+38.
•
• *Float: representa um número real, com decimais, com valores possível entre -
8,98846567431105E e + -8,98846567431105E.
•
• *Date: serve para armazenar um valor de data e hora. Internamente, a data e hora são
armazenada no formato UTC, ao devolver o dado representa-se no formato local, segundo a
configuração do computador.
•
• *String: é usada para armazenar uma cadeia de texto. Em BASIC as cadeias de texto
designam-se mediante aspas duplas.
•
• *Variante: significa qualquer tipo de dados, quer dizer, pode armazenar uma Integer, Single,
String, etc. Devemos evitar seu uso porque ocupa mais memoria que as anteriores e os
cálculos com variantes são muito mais lentos.
•
• *Oobject: representa qualquer objeto criado em Gambas.
•
• É o programador quem escolhe o tipo de dado que deve ser declarado numa variável.
Devemos usar sempre os tipos de dados menores, já que ocupa menos memória e o
processador os manipula com mais velocidade. Isso pode limitar as opções da aplicação, por
isso que as vezes temos que optar por tipo maiores para não fechar possibilidades.
•
• Por exemplo, se você vai usar uma variável para definir a idade de uma pessoa, o lógico é
utilizar um dado tipo byte (o valor máximo e 255). se a idade a ser armazenada é de uma
arvore é conveniente usar uma do tipo Short, já que pode haver arvores com mais de 255
anos, mas não se conhece uma com mais de 32.767.
•
•

◦ Tipos de conversões
•
• Gambas permite várias conversões entre tipos de dados. A forma de fazer a
conversão pode ser implícita ou explicita. São conversões implícita quando o próprio
interpretador do Gambas encarrega-se de gestioná-las. Por exemplo:
•
• DIM Resultado AS Single
•
• DIM Operando1 AS Single
•
• DIM Operando2 AS Integer
•
• Operando1 = 3.5
• Operando2 = 2
• Resultado = Operando1 * Operando2
•
• Neste caso, para poder realizar a multiplicação, o interpretador converte, de forma
transparente para o programador, o operando2 para um valor Single. São conversões
explicitas as que o programador deve fazer ao escrever o código para poder realizar
operações, mesclar dados de vários tipos, etc.
•
• Estas conversões fazem-se mediante funções que estão incluídas no BASIC do Gambas.
Evidentemente, a conversão será feita sempre que seja possível, caso contrário é produzido
um erro. Esta é a lista de funções de conversão existente:
•
• *Cbool (expressão): converte a expressão à um valor booleano, verdadeiro ou falso. O
resultado será falso se a expressão é falsa, o numero 0, uma cadeia de texto vazia ou um
valor nulo. Será verdadeira nos demais casos. Por exemplo:
•
• -Devolve false as seguintes operações: Cbool(“”), Cbool(0), Cbool(NULL).
•
• -Devolve true as operações: Cbool(1), Cbool(“Gambas”).
•
• *CByte (expressão): converte a expressão em um valor tipo Byte. Primeiro converte a
expressão para um numero binário de 4 bytes. Se este número for maior que 255, corta
recolhendo os 8 bits de menor peso. Por exemplo, Cbyte(“17”) devolve 17, mas
Cbyte(100000) devolve 160. é porque o número 100.000 em binário é 11000011010100000,
seus 8 últimos bits são 10100000, que passado de binário a decimal é igual a 160. Se não
soubermos operar com números binários o melhor que podemos fazer é evitar este tipo de
conversão que resulta em valores tão “surpreendentes”.
•
• *CShort (expressão), CInt(expressão) ou CInteger(expressão), e CLong(expressão):
convertem respectivamente, a expressão em um número do tipo Short, Integer, e Long. No
caso de CShort a conversão realizada igual a CByte, podendo produzir resultados estranhos
igualmente se a expressão resultante de um número for maior que 32.767.
•
• *CDate (expressão): converte a expressão em uma data, mas devemos ter cuidado porque
não admite o formato de data local, só o formato inglês mês/dias/anos
horas:minutos:segundos. Quer dizer, CDate(“09/06/1972 [Link]”) isto é, dia 6 de
setembro de 1972
•
• *CSingle (expressão) ou CSng(expressão) e CFloat(expressão) ou CFlt(expressão):
convertem, respectivamente, a expressão de um número do tipo Single e Float. A expressão
deve usar o ponto (.) e não a vírgula (,) como separador decimal.
•
• *Cstr (expressão): converte a expressão em uma cadeia de texto sem levar em conta a
configuração local. Portanto, CStr(1.58) devolve a cadeia de texto 1.58, independente se a
configuração local indica que o separador decimal é um ponto ou uma vírgula o
Cstr(CDate(“09/06/1972 [Link]”)) devolve “09/06/1972 [Link]”.
•
• *Str$ (expressão): Converte a expressão em uma cadeia de texto, levando em conta a
configuração local. Portanto Str$(1.58) devolve a cadeia de texto 1,58, se a configuração
local estiver em português. Do mesmo modo Str$(CDate(“09/06/1972 [Link]”)) devolve
“06/09/1972 [Link]” se a configuração estiver em português já que neste idioma costuma
escrever as datas na forma dia/mês/ano.
•
• *Val (expressão): converte uma cadeia de texto em um tipo Boolean, Date ou outros tipos
numéricos, dependendo do conteúdo da expressão. Val é a expressão oposta de Str$ e
também leva em conta a configuração local do computador que à executa.
•
• O Gambas tenta converter a expressão em um tipo Date, se não pode tenta converter em um
número com decimais, se tão pouco pode, tenta converter em um número inteiro e
finalmente, tenta converter em um tipo Boolean.
•

◦ Matrizes
•
• Em numerosas ocasiões, quando se tenta resolver um problema mediante a
programação, surge a necessidade de contar com a possibilidade de armazenar vários dados
na mesma variável. A solução mais simples para este problema são as Matrizes ou Arrays.
Podemos definir matrizes que contenham qualquer tipo de dados, mas com a condição de
que todos os elementos sejam do mesmo tipo. Não há mais limites na dimensão da matriz a
não ser a memória do computador ou a capacidade do programador de operar com matrizes
de dimensões grandes.
•
• A sintaxe para trabalharmos com matrizes é a mesma que para as variáveis, no entanto entre
colchetes as dimensões da matriz. Alguns exemplos:
•
• DIM Notas [ 2, 3 ] AS Single
•
• DIM Idades [ 40 ] AS Integer
•
• DIM Isto_nao_ha_quem_o_manipule [ 4, 3, 2, 5, 6, 2 ] AS String
•
• Para acessar o valor de cada uma das celulas da matriz, teremos que referirmos sempre ao
seu índice. Em uma matriz de duas dimensões só podemos identificar facilmente por linhas
e colunas.
•
• Temos que levar em conta que o índice começa em 0, não em 1. Quer dizer, na matriz
Listado[3] existirão só valores correspondentes a Listado[0], Listado[1], Listado[2]. Se
tentarmos acessar a Listado[3] dará um erro Out of Bounds, fora do limite. Por exemplo:
•
• DIM Alunos [ 4, 10 ] AS String
•
• DIM Colunas AS Integer
•
• DIM Linhas AS Integer
•
• Colunas = 2
•
• Linhas = 6
•
• Alunos [ Colunas, Linhas ] = " Antônio Sousa "
•
• Temos que declarar estas matrizes com a dimensão máxima que vão ter. Isso nos leva a
supor que o interpretador do Gambas reserva a memória necessária para elas ao começar o
uso do programa. No entanto, tem vezes que, pelas características da aplicação,
desconhecemos a dimensão que terá a matriz, para resolver este problema, Gambas tem
predefinidas matrizes unidimensionais dinâmicas de todos os tipos de dados, exceto
Boolean. Estas matrizes trabalham de forma idêntica as anteriores, Já que fazem falta
funções para adicionar novos elementos a matriz, apaga-los ou saber o numero de
elementos que elas tem.
•
• Com este exemplo veremos o uso e funções mais usuais ao trabalharmos com matrizes
dinâmicas:
•
• DIM Nomes AS String [ ]
•
• 'A seguinte instrução inicializa nomes para poder usa-lo.
• 'É um passo prévio obrigatório:
• Nomes = NEW String [ ]
•
• 'Assim podemos adicionar valores a matriz:
• [Link] ( "Manoel" )
• [Link] ( "João" )
• [Link] ( "Antonio" )
•
• 'Count devolve o numero de elementos da matriz.
• 'A seguinte instruções mostrará 3 no console:
• PRINT [Link]
•
• 'A seguinte instrução apagará a linha de “João”
• [Link] ( 1 )
•
• PRINT [Link] 'mostrará 2
•
• PRINT Nomes [ 1 ] 'mostrará “Antonio”
•
• 'A seguinte instrução limpará nomes
• [Link]
•
• PRINT [Link] 'mostrará 0
•
• 2.3 Operadores matemáticos
•
•
•
• Quando se trata de trabalhar com números, Gambas tem as operações habituais como quase
todas as linguagem de programação:
•
• * +, -, *, / e se usa respectivamente, para a soma, subtração, multiplicação e divisão.
•
• * ^ é o operador de potencia, por exemplo, 4 ^ 3 = 64
•
• * Para a divisão existe dois operadores adicionais, \ o DIV e MOD, que devolvem,
respectivamente, a parte inteira do resultado da divisão e o resto. Quer dizer, (9 DIV 2 = 4),
(9 \ 2 = 4) e (9 MOD 4 = 1P).
•
• Alem destes operadores existem as seguintes funções matemáticas para realizar calculos
mais complexos:
•
• * Abs(número): devolve o valor absoluto de um número.
•
• * Dec(número): decrementa um número.
•
• * Frac (número): devolve a parte decimal de um número.
•
• * Inc (número): incrementa um número.
•
• * Int (número)devolve a parte inteira de um número.
•
• * Max (número1, numero2 .....): devolve o número maior.
•
• * Min (número1, número2 .....): devolve o número menor.
•
• * Round (número,decimais): Arredonda um numero com as decimais desejadas.
•
• * Sgn (número): Devolve o sinal de um número.
•
• * Rnd ([minimo],[máximo]): Devolve um número aleatório compreendido entre minimo e
máximo, se não expressar nenhum valor para minimo ou máximo, o numero estará
compreendido entre 0 e 1. se só expressarmos um valor, o numero estará compreendido
entre 0 e esse valor. Muito importante: antes de usar Rnd é necessário executar a instrução
Randomize que inicializa o gerador de números aleatórios. Se não fizermos isso obteremos o
mesmo número em sucessivas execuções.
•

◦ Operações lógicas
•
• Para realizar operações entre variáveis do tipo Boolean ou expressões cujo resultado
seja Boolean, existem algumas instruções similares as que podemos ver quase em todas as
linguagens de programação. Trata-se de AND, OR, NOT e XOR. Se tivermos conhecimento
de lógica e números binários, não será difícil identificar e saber o seu comportamento ao
tratar-se das operações binarias mais básicas. Caso contrário, será fácil usa-las e entender
seu funcionamento com uma simples tradução para o português das três primeiras: E, OU,
NÃO. Quer dizer, serve para unir condições do tipo: cor é verde e não é marrom, que se
escreveria:
•
• Cor = "Verde" AND NOT Cor = "Marrom"
•
• No caso de XOR é mais difícil de entender já que é uma operação especial chamada
OR exclusiva. O resultado de uma operação XOR é verdadeira quando os dois operando são
 diferentes e, falso, quando os dois operando são iguais. Na prática, esta operação é utilizada
em cálculos com números binários, ou em caso de estarmos seguro que conhecemos
perfeitamente seu funcionamento.
•

◦ 2.4 Manipulação de cadeias

•
• Umas das tarefas mais habituais nos programas de informática é o uso de cadeias de
texto, tanto para as aplicações de base de dados, como para a simples saída de mensagens na
tela. Em Gambas estão implementado todas as funções de cadeia de texto do BASIC padrão
mais as que estão presentes no Visual Basic. Antes de proceder a sua lista, destacamos que
existe um “operador” de cadeias de texto que permite concatena-las diretamente, Trata-se do
símbolo &. Vejamos um exemplo de seu uso
•
• DIM Nome AS String
• DIM Apelido AS String
•
• Nome = "Manoel"
• Apelidos = "Alvares Gomes"
•
• PRINT Apelidos & " , " & Nome
•
• A saída no console será:
•
• Alvares Gomes, Manoel
•
• Vejamos agora a lista das funções disponíveis para manipular cadeias de texto:
•
• * Asc (Cadeia,[Posição]): Devolve o código ASCII do caracter que está na posição indicada
na cadeia dada. Se não é dada a posição, devolve o código do primeiro caracter.
•
• * Chr$: devolve um caracter a partir de seu código ASCII. Esta função é útil para adicionar
caracteres especiais a uma cadeia de texto, por exemplo:
•
• PRINT "Manoel" & Chr$(10) & "Antonio"
•
• * insere uma tabulação entre os nomes, já que na tabela ASCII o código 10 corresponde a
um avanço de linha (Line Feed).
•
• * InStr (Cadeia, Sub cadeia [ , Inicio ] ): Procura a sub cadeia da cadeia e devolve um
número da posição onde a encontrou. Se não dermos o valor Inicio, a busca começará
nessa posição. Por exemplo:
•
• PRINT Instr( "Gambas é basic", "bas", 5 )
•
• devolve um 10, enquanto que:
•
• PRINT Instr( "Gambas é basic", "bas" )
•
• devolve 4
•
• * RinStr (Cadeia, Sub Cadeia [, Inicio ] ): função igual ao InStr, só que começa a busca da
direita para esquerda na cadeia.
•
• devolve:
•
•
• Faltam páginas 58-59
•
•
• No segundo caso podemos ver como, mesmo que o separador seja o espaço em branco, o
texto não fica separado um circo ao estar rodeado do caracter de escape.
•
• Havia, uma, vez, um
• Havia, uma, vez, um circo
•
• Controle de fluxo
•
•
• Umas das tarefas mais habituais nos programas de informática é o uso de cadeias de texto,
tanto para as aplicações de base de dados, como para a simples saída de mensagens na tela.
Em Gambas estão implementado todas as funções de cadeia de texto do BASIC padrão mais
as que estão presentes no Visual Basic. Antes de proceder a sua lista, destacamos que existe
um “operador” de cadeias de texto que permite concatena-las diretamente, Trata-se do
símbolo &. Vejamos um exemplo de seu uso
•
• São muitas as ocasiões em que o fluxo em que as instruções são executadas em um
programa não é adequado para resolver o problema.
•
• Todo o código BASIC que temos visto até agora executa suas instruções de cima a baixo,
conforme as vai encontrando. As vezes, com frequência, teremos que voltar atrás repetir
coisas, tomar decisões, etc. Estes tipo de ações denominam-se, controle de fluxo e o BASIC
do Gambas proporciona uma boa quantidade de sentenças para isso.
•
•

◦ IF ... THEN .... ELSE

•

É a sentença mais comum para tomar uma decisão: si cumpre-se uma decisão, então
executa-se algo, caso contrário, executa-se outra coisa.

Sua forma mais básica é:

• IF   Expressão  THEN

.........

END IF
•    
O si e o que executa-se é uma só instrução:

• IF  Expressão   THEN  sentença_a_executar

•
A sintaxe completa da instrução é:
• IF Expressão [ {AND IF   |   OR IF } Expressão .....  ] THEN

    ..............

[ ELSE IF Expressão [ { AND IF   |    OR IF } Expressão  ......  ] THEN  

    .............. ]

[   ELSE

    ..............  ]

ENDIF
•
• Alguns exemplos de uso:

DIM Idade AS Integer

    .................

IF  Idade > 20 THEN PRINT "Adulto"

IF Idade < 2 AND Idade  > 0 THEN

    PRINT "Bebê"

ELSE IF Idade   <  12    THEN

PRINT "Menino"

ELSE IF Idade < 18 THEN

     PRINT "Jovem"

ELSE

     PRINT "Adulto"

ENDIF
•
Dependendo do valor que que dermos a variável Idade ao escolher o primeiro IF, mostrará
um resultado diferente.
•
•
• Select
•
No exemplo anterior vimos que o fluxo do programa necessita revisar varias condições
sobre uma mesma variável, produzindo um IF dentro de outro (IF  aninhados). Esta estrutura
não e comoda de ler nem produz um código limpo. Para estes casos existe a sentença
SELECT, que é muito mais apropriada. Sua sintaxe é:

• SELECT [ CASE ]  Expressão

[ CASE Expressão  [ TO Expressão  # 2  ]  [,  ...... ]

    .............  ]

[ CASE Expressão  [ TO Expressão  # 2 ]  [,  ....... ]

    .............  ]

[ { CASE   ELSE     |     DEFAULT  }

• .............  ]
•
END SELECT
•
Vejamos como se aplica o mesmo exemplo anterior das idades:

• DIM  Idade AS Integer

• ...........
•
SELECT CASE Idade

CASE 0 TO 2

PRINT "Bebê"

CASE 2 TO 12

PRINT "Menino"

CASE    18

PRINT "Bingo, já podes votar"

CASE   13     TO    17

PRINT   "Jovem"

CASE     ELSE

PRINT "Adulto"

END  SELECT
•
Se trata de um código muito mais fácil de ler que o anterior.

◦ For
•
Quando faz-se necessário contar ou realizar uma ação com número determinadas vezes, a
sentença FOR  é a solução:

• FOR Variável = Expressão TO  Expressão  [ STEP Expressão ]

• ..........
•
NEXT
•
O loop incrementa a variável de um em um, a não ser que especifique-se um valor o STEEP.
Podemos especificar valores negativos, de forma que converta-se em uma conta a menos.
Por exemplo:

• DIM n AS Integer

FOR n = 10 TO 1 STEP -1

• PRINT n
•
NEXT
•
Se quisermos interromper o loop em algum ponto, podemos usar a sentença BREAK:

• DIM n AS Integer

FOR n = 10 TO 1 STEP -1

IF n = 3 THEN BREAK

• PRINT n

• NEXT
•
O loop Acabará quando n valer 3 e não será escrito os últimos três números. Dispomos
também da sentença CONTINUE, que permite saltar passos no loop.

• DIM n AS Integer

FOR n = 1 TO  4

IF n = 2 THEN CONTINUE
• PRINT n

• NEXT
•
Saltará em dois ao escrever os valores de n. Existe uma variante do loop FOR que usamos
ao percorrer elementos de uma coleção, como uma matriz. A sintaxe neste caso é:

• FOR EACH Variável IN Expressão

• ..........
•
NEXT
•
Vejamos um exemplo usando as matrizes dinâmicas que vimos neste capitulo:

• DIM  Matriz  AS  String [ ]

DIM  Elemento  AS  String

Matriz  =  NEW   String [ ]

[Link] ("Azul")

[Link] ("Roxo")

[Link] ("Verde")

FOR    EACH   Elemento IN Matriz

• PRINT    Elemento;
•
NEXT
•
Escreverá na saída: AzulRoxoVerde.
•
•

◦ WHILE e REPEAT
• Quando queremos repetir a execução de uma parte do código em varias ocasiões
dependendo de uma condição, temos duas instruções distintas: WHILE e REPEAT.

Seu comportamento e quase idêntico. A diferença  reside em que a condição necessária para
que execute o código é falsa desde o principio, com  REPEAT executará uma vez e com
WHILE  não executará nunca. A sintaxe de ambas é:

• WHILE   Condições

• .... instruções
• WEND

REPEAT   Condições

• .... instruções

• UNTIL Condições
•
No caso do loop WHILE existe uma variante da sintaxe consiste em substituir WHILE por
DO WHILE e WEND por LOOP. É exatamente o mesmo; depende do programador escolher
um formato ou outro. Vejamos um exemplo:

• DIM a AS Integer

a=1

WHILE a <= 10

PRINT "Ola Mundo" ;  a

INC a

WEND

a=1

DIM a AS Integer

REPEAT

PRINT "Ola Mundo" ; a

INC a

UNTIL  a  > 10

•
Este exemplo produzirá o mesmo resultado na execução do loop WHILE quanto no
REPEAT, em ambos os casos escreverá dez vezes “Ola Mundo”  junto ao valor da variável
que é incrementada de 1 a 10. O uso destas estruturas pode ser perigoso. Se durante a
execução do loop não houver uma forma de que a condição possa ser verdadeira ou falsa,
estaríamos  diante de um loop infinito e o programa entraria em situação de bloqueio.
•
•
• Depuração na IDE do Gambas
•
•
• Uma vez escrito parte do código de um programa, o usual é comprovar se funciona, mas o
habitual é que a maior parte das vezes não funciona na primeira tentativa. Tanto faz ser um
programador experiente ou não, as falhas fazem parte da rotina. Saber encontra-las e corrigi-
las é o que denomina-se
depuração e é uma das tarefas
mais importantes a realizar.
Quando são falhas de sintaxes,
o ambiente de
desenvolvimento só nos dá
mensagens indicativas do
problema, parando a execução
na linha em que ocorreu a
falha.
•
• Quando se adquire uma
certa intimidade com a
linguagem, as falhas de
sintaxes são cada vez menos,
• mas as falhas na lógica da
execução do programa
ocorreram sempre. Ainda mais
quando essa logica passa, por
instruções de controle de fluxo
como as que vimos neste
capitulo, a dificuldade de
encontrar os erros é maior, já
que a aplicação em várias
ocasiões pela mesma parte do código e é possível que a falha não ocorra na primeira vez que
se execute o código.
•
• Para facilitar esta tarefa, a IDE do Gambas dispõe de varias ferramentas de depuração.
Figura 1 Ponto de interrupção na linha de código
• A primeira delas é a possibilidade de fixar pontos de depuração. Quer dizer, sinalar lugar no
qual o programa parará para permitir ver o estado das variáveis e em que ponto da execução
encontra-se.
•
• Para fixar um ponto de interrupção em uma linha de código, temos que colocarmos o cursor
do mouse nessa linha e pressionar a tecla F9 ou o simbolo da mão levantada, que está na
parte superior da janela de código. As linhas que se fixa um ponto de interrupção tem o
fundo roxo.
•
•
• A mesma operação que cria um ponto o
elimina, ou seja, pressionando F9
novamente o fundo roxo desaparecerá. A
execução do programa, como se explicou
no capitulo anterior, inicia-se
pressionando o simbolo verde de Play na
janela do projeto ( ou pressionando a
tecla F5). Junto ao botão verde encontra-
se um botão de Pause, que permite parar
a execução, e outro de Stop que permite
detê-la a qualquer momento.
•
• Se quisermos correr a aplicação
executando uma a uma das instruções
para irmos observando por onde
transcorre o fluxo do programa, é só
pressionar a tecla F8 ou qualquer um dos
botões que se encontra a direita do
simbolo Stop. Fazendo isto, o ambiente
de desenvolvimento saltara a primeira
linha que deve
•
• correr e irá executando linha a linha cada vez que pressionarmos F8, e o ícone que mostra a
flecha entrando entre as chaves, mencionado anteriormente.
• Figura 2 Execução a partir da janela do
projeto
•
• O botão que está justamente a direita do Stop, que mostra uma flecha saltando por cima das
chaves, parece produzir o mesmo efeito (sua tecla de atalho é Shift + F8), mas não é assim:
o comportamento muda quando o programa chega a uma chamada, a uma sub-rotina ou
função.
•
• Neste caso, o Ícone executará a chamada e tudo o que a função ou sub-rotina tem que fazer,
em um só passo, sem que vemos o fluxo do programa pelo procedimento.
•
• Se tivéssemos pressionado F8 teríamos entrado na sub-rotina e visto passo a passo como as
instruções são executadas . Por tanto, com estes dois botões podemos escolher como
chegarmos a uma chamada ou procedimento, se quisermos também depurar esse
procedimento ou simplesmente executá-lo e passar a próxima linha de código.
•
• Finalmente, quando pausamos a execução do programa, aparece três novas abas na parte
inferior da janela do projeto. E na aba local se ver todas as variáveis do procedimento que
estamos executando e o valor que tem nesse momento. Na aba pilha (Stack) vemos a lista de
chamadas entre procedimentos que serão produzido até chegar a esse ponto do programa.
Assim podemos saber através de que passos chegamos a essa instrução. Finalmente, na aba
Observar (Watch) podemos introduzir qualquer expressão em BASIC, incluindo operações
com as variáveis que o programa tem declaradas para ver qual é o resultado e o valor que
tenham no momento da pausa.
•
 • Figura 3 Abas Local, Pilha e Observar da
janela Projeto.
•
•
•
•
•
•
•
•
•

◦ 2.6 Entrada e saída de arquivos

• Neste paragrafo veremos formas mais comuns de trabalhar com arquivos no

Gambas. Gambas trata os arquivos como um fluxo de dados (a palavra exata para isso é
Stream), o  que tem uma aplicação muito comoda: todos os fluxos de dados são tratados da
mesma maneira, pois o código para manipular um arquivo é igual ao código para manipular
uma conexão de rede, já que todos são objetos do tipo Stream. A operação tradicional com
um arquivo é abri-lo, cria-lo, escrever e ler dados. Vejamos como se usa:

• Arquivo = OPEN Nome_do_Arquivo FOR [ READ  |  INPUT ] [ WRITE  |  OUTPUT ] [

CREAT  |  APPEND ]  [ WATCH ]

• Abrimos um arquivo com várias finalidades:

• * READ ou INPUT: para ler dados,  no primeiro caso não se usa buffer de dados, com
IMPUT se houver um buffer intermediário.

* WRITE ou OUTPUT: para escrever dados, com WRITE não há buffer de dados, com
OUTPUT se usa.

* CREATE: se o arquivo não existe se cria. Se não usarmos esta palavra, o arquivo deve
existir antes de abri-lo ou dará um erro.

• * APPEND: os dados são adicionados ao final do texto.                                                        

•
• * WATCH: se especificarmos essa palavra, Gambas lançará os eventos (que veremos mais
adiante) File_Read e File_Write neste caso podemos ler e escrever no arquivo.
•
Agora, fecharemos um arquivo que foi aberto com a sentença OPEN.

• CLOSE [ # ] Arquivo
•
Escrevemos, convertendo em cadeia de texto, a Expressão no Arquivo aberto anteriormente.

• PRINT [  #Arquivo ,  ]  Expressão  ]

•
Se não especificarmos nenhum arquivo, digitamos a expressão no console, como temos visto
 em vários exemplos ao longo deste capitulo. A instrução PRINT admite um certo controle de
como se colocam as expressões,  dependendo de alguns símbolos de pontuação que
podemos colocar no final da sentença:

• * Se não há nada depois da Expressão, adiciona-se uma nova linha ao final. Portanto, a saída
da seguinte instrução PRINT será em uma nova linha.

* Se há um ponto e virgula atrás da Expressão, a seguinte instrução PRINT será escrita justo
atrás  da saída anterior, sem espaço, linhas ou tabulações intermediarias.

* Podemos utilizar uma virgula em lugar de um ponto e virgula, adiciona-se uma            
tabulação, como também podemos concatenar expressões em uma mesma linha.

• Seguidamente, escreveremos sem converter em cadeia de texto, a Expressão no Arquivo

aberto anteriormente. É uma instrução que costuma usar em lugar do PRINT quando os    
dados a escrever não são cadeias de textos, como no caso de arquivos binários.
•
WRITE [  #Arquivo ,  ]    Expressão  [  , Local  ]
•
Em qualquer caso, também pode ser usada com cadeias de texto e permitir indicar, com o
parâmetro Local, o números de caracteres que desejamos tirar em cada operação de escrita.
Ao contrario que com o PRINT, não podemos usar os sinais de pontuação para controlar a
posição da escrita. 

• INPUT  [  #Arquivo ,  ]   Variável1   [  ,  Variável2 ........    ]

•
Lemos, de um arquivo, um dado e atribuímos seu valor a  Variável1, Variável2, etc. Os
dados devem está separados no arquivo por virgula e em linhas diferentes. Se não
especificarmos o Arquivo, lemos os dados do console, esperando que o usuário da aplicação
o introduza....

• READ   [  #Arquivo  ,  ]  Variável  [  , Local  ]

•
Podemos dizer que é a instrução oposta a WRITE. Lemos do Arquivo dados binários e
atribuímos seu valor a Variável. Se essa é uma cadeia de texto, podemos fixar o local da
cadeia a ler.

• LINE INPPUT [  Arquivo  ,  ]  Variável

•
Em uma linha de texto inteira do arquivo, que atribuímos a variável. Não devemos usar para
ler o fluxo binários.

• Eof   ( Arquivo )
•
Devolve True  (verdadeiro) quando chega ao final do Arquivo e Falso (falso) em caso
contrário.

• Lof (  Fluxo  )
•
Se é Fluxo de dados em um arquivo, devolve seu tamanho. Se em lugar de um arquivo é um
Socket de uma conexão de rede ou um objeto Process, devolve o número de bytes que
 podemos ler de uma só vez. Uma vez vista  as sentenças mais comuns para manipular o
fluxo de dados, Vamos a alguns exemplos de uso:

• ' Ler dados de uma porta série:

' Requer selecionar o componente [Link] no projeto
DIM Arquivo AS File

Arquivo = OPEN "/dev/ttySO"  FOR READ WRITE WATCH

•
• .........................

'O evento File_Read é produzido quando há dados pra ler:

PUBLIC SUB File_Read()

DIM iByte AS Byte

READ #Arquivo,   iByte

PRINT  " Tenho um byte:  " ; iByte

'Ler o conteudo do arquivo      /etc/passwd  e o mostra no console:

DIM Arquivo AS File

DIM Linha AS String

Arquivo = OPEN   "/etc/passwd"  FOR INPUT

WHILE NOT Eof (Arquivo)

LINE INPUT #Arquivo,  Linha

PRINT Linha

WEND
 
CLOSE Arquivo
•
• 2.7 Controle de erros

• É certo que, em algum momento, na maioria dos programas, seja culpa do usuário, seja pelo
próprio fluxo da execução, ocorrem erros, como tentar apagar um arquivo que não existe,
fazer uma divisão por zero, conectar a um servidor web que não responde, etc. Em todos
estes casos o Gambas mostra uma mensagem na tela e o programa é interrompido e deixa de
funcionar. É evidente que esse é um comportamento que o desenvolvedor não deseja e deve
tomar medidas aportunas para evita-lo. A forma de fazer é implementando um controle de
erros para que a aplicação saiba o que deve fazer nesses casos. Gambas implementa as
instruções necessárias para capturar os erros e processa-lo segundo o desejo do
programador. As instruções para isso são:

TRY Sentença: executa a sentença sem lançar o erro quando ocorre, o programa continua
 pela sentença que está depois do TRY,  tanto faz existir erro ou não. Só podemos saber se
existe erro consultando a sentença ERRO que será verdadeiro ou falso. Por exemplo:

• ' Apagar arquivo que não existe

TRY KILL "/tmp/teste/"

'Comprovar se tivemos exito

IF ERROR THEN PRINT "Não foi possível apagar o arquivo"
•
FINALLY: É colocado no final de um procedimento. As instruções após essa sentença serão
sempre executadas, tanto faz se houve um erro no procedimento ou não.

CATCH: se colocada no final de um procedimento. As instruções após essa sentença São

executadas só se ocorrer um erro na execução do procedimento (incluindo os erros
produzidos  em subrotinas ou funções chamadas a partir deste procedimento). Se existe uma
instrução FINALY, terá de ser colocada na frente de CATCH.

Vamos ver um exemplo de FINALY e CATCH:

• SUB PrintFile (Nome_Arquivo AS String)

DIM Arquivo AS File

DIM Linha AS String

OPEN Nome_Arquivo FOR READ AS #Arquivo

WHILE NOT EOF (Arquivo)

LINE INPUT #Arquivo,  Linha

PRINT Linha

WEND

FINALLY   'Sempre vai ser executado, inclusive se houver erro

TRY CLOSE  #Arquivo

CATCH ' Só executa se houver erro

PRINT "Impossível mostrar o arquivo" ; Nome_Arquivo

END

2.8 Programação orientada a objeto com  Gambas

BASIC  é uma linguagem de programação estruturada. Isto significa que os programas tem o fluxo
que temos visto até agora: Inicia  em um ponto de uma subrotina e vai executando as instruções de
sima a baixo, com os saltos correspondentes as chamadas e procedimentos e varias funções de
controle de fluxo como loops, condições, etc.
Este tipo de programação permite resolver a maior parte dos problemas e está sendo usado há
muitos anos. Até os dias de hoje, seguem desenvolvendo aplicações com linguagens como BASIC
ou C, de programação estruturada. Desde os anos 70 se vem trabalhando também em outras
paradigma de programação: a programação orientada a objetos. As linguagem que adotam este
paradigma, como Smalltalk, Java o C++, tentam modelar a realidade. A execução destes programas
se baseia na interação dos vários objetos que definem o problema, tal e como ocorre na vida real,
como os objetos, pessoas e animais nos movemos, enviamos mensagens uns aos outros e 
executamos ações. A programação orientada a objeto é usada a cada dia com mais frequência
porque permite uma melhor divisão das tarefas que um programa deve fazer, facilita a depuração e a
colaboração entre vários programadores e nos projetos que são de grande tamanho e, em muitos
aspectos, tem um potencial muito maior que a programação estruturada.

Por todas estas razões, é comum se adicionar características de programação orientada a objetos a
linguagens que, como o BASIC, em principio não a tenham. Gambas permite fazer programas
estruturados a moda antiga, escrevendo o código em Módulo, como já vimos antes e também
permite a programação orientada a objeto mediante o uso de Classes. E mais, a maior parte dos
componentes que são adicionados a linguagem, tem mais alternativas que o uso de objetos.

Podemos ver como funciona tudo isso no Gambas pensando no caso de que tenhamos que escrever
um programa que simula o comportamento de um carro. Usando  a programação orientada a
objetos, definiremos cada uma das partes do carro mediante um arquivo de classes onde
escreveremos o código BASIC necessário para definir as características e a interface com que se
comunica com o mundo. Por exemplo, definiremos como é um volante, como é uma roda, como é
um assento, um acelerador, um motor, etc. Depois, baseado nessas informações, criaríamos  cada
um dos objetos para criar o carro: um volante, quatro rodas, vários assentos, um motor, um
acelerador, etc.  Cada um desses objetos responderia a certas mensagens, por exemplo, o volante
responderia a um giro atuando sobre o eixo das rodas, o motor responderia incrementando suas
rotações se recebesse uma pressão do acelerador, etc.

Cada vez que criamos um objeto baseando-nos em arquivo de classe que foi definido, dizemos que
o objeto foi instanciado. Podemos estanciar tantos objetos quanto desejar a partir de uma classe e
uma vez criados tem vida própria, são independentes uns dos outros com suas próprias variáveis
respondendo as várias ações segundo tenham sido definidos no classe.

Outra das características da programação orientada a objetos é a Herança. Quando um objeto herda
de outro objeto significa que é do mesmo tipo, mas que pode ter características acrescentadas. Por
exemplo, suponhamos que definimos a classe quadro_de texto com certas características como
tamanho de texto, alinhamento, etc. A seguir, podemos criar objeto dessa classe e são
quadro_de_texto. Com o Gambas podemos, alem do mas, criar uma nova classe, por exemplo:
quadro_de_texto_multilinha que herda do quadro_de_texto. Isso significa que um
quadro_de_texto_multilinha é um  quadro_de_texto só que são adicionados mais coisas. Todo o
comportamento e propriedades do quadro_de_texto já estão codificado e não há necessidade de
faze-lo novamente.

Vamos a um exemplo simples que esclarece alguns conceitos, para isso vamos criar no ambiente de
desenvolvimento um novo projeto de programa de texto. Para começar, vamos adicionar um
Módulo com um nome qualquer e dois arquivo de classe, a um nós chamamos SerVivo e ao outro
Homem.

Este é o código que devemos escrever no arquivo de classe [Link]:

 ' Gambas class file
PRIVATE Patas AS Integer
PRIVATE Nascimento AS Integer

PUBLIC SUB nascido(Data AS Date)

Nascimento = Year(Data)

END

PUBLIC SUB PPatas(Numero AS Integer)

Patas = Numero

END

PUBLIC FUNCTION Idade() AS Integer

RETURN Year(Now) - Nascimento

END

PUBLIC FUNCTION DPatas() AS Integer

RETURN Patas

END

Este é o código para escrever no arquivo de classes [Link]:

' Gambas class file

INHERITS SerVivo
PRIVATE Nome AS String
PRIVATE Apelido AS String

PUBLIC SUB PNome(Cadeia AS String)

Nome = Cadeia

END

PUBLIC SUB PApelido(Cadeia AS String)

Apelido = Cadeia

END

PUBLIC FUNCTION NomeCompleto() AS String

RETURN Nome & " " & Apelido

END

E este é o código para escrever no Módulo que havíamos criado:

' Gambas module file

PUBLIC SUB Main()
DIM Macaco AS SerVivo
DIM Sujeito AS Homem

Macaco = NEW SerVivo

[Link](CDate("2/2/1992"))
[Link](3)

PRINT [Link]()
PRINT [Link]()

Sujeito = NEW Homem

[Link](CDate("2/18/1969"))
[Link]("Vicente")
[Link]("Pires")

PRINT [Link]()
PRINT [Link]()

END

Vejamos os três arquivos, inclusive o de classe [Link] tem um código muito simples: declara
um par de varáveis, um par de subrotinas com  as quais podemos atribuir um valor a essas variáveis
e duas funções as quais devolvem valores de alguns cálculos realizado entre as variáveis e a data
atual.

O arquivo [Link] é muito similar, mas com uma sentença nova: no inicio do arquivo foi
declarado a instrução INHERITS SerVivo. Ao fazermos isso estamos dizendo que todos os objetos
que se estanciam na classe Homem será objeto SerVivo e, por tanto, terão também as mesmas
funções que um SerVivo e poderão realizar as mesmas operações.

Se for necessário alguns valores de inicialização dos objetos a ser criado, basta adicionarmos ao
arquivo de classe uma subrotina com a sintaxes: PUBLIC SUB New(). Todo o código que se crie
aqui será executado cada vez que se criar um objeto.

E finalmente, o módulo e seu procedimento Main. Ai declaramos duas variáveis: Macaco e Sujeito,
porem em lugar de declararmos como um dos tipos de dados que vimos nos primeiros parágrafos
deste capitulo, a declaramos como objeto da classe SerVivo e Homem. Portanto falando como
propriedade, Macaco  e Sujeito não são variáveis, e sim objetos. As classes correspondem aos
nomes dos dois arquivos de classe que definimos anteriormente. Alem disso, vimos que para criar
um objeto de uma classe é necessário usar sempre a palavra NEW, o que aconteceria mesmo que
executando o código da subrotina New do arquivo de classe, se esta subrotina existisse. Uma vez
que o objeto tenha sido criado, podemos ter acesso as suas subrotinas e funções escrevendo o nome
do objeto e o procedimento separados por um ponto. Só podemos acessar os procedimentos que
tenham sido declarados no arquivo de classe como PUBLIC.
Poupamos códigos obviamente para a classe Homem Afinal não tivemos que escrever as funções
que faz um SerVivo, há algumas consequências mais importantes que deduzimos deste exemplo. Tal
e como está escrito, poderíamos trocar o código da classe SerVivo, modificando e trocando as
variáveis, e o programa seguiria funcionando igual, sem ter que tocar em absoluto a classe Homem.

Quer dizer, podíamos, por exemplo, melhorar o método para calcular a idade, levando em conta o
dia do nascimento dentro do ano. Também podíamos trocar o nome das variáveis e não afetar a
classe Homem ou o resto do programa. Outras das possibilidade que existe é o uso dos arquivos de
classes tal e como estão em outro projeto onde o modo seres vivos é necessário, reutilizando de
formas simples o código já escrito.

Já foram elaborado multidão de livros e artigos sobre a programação orientada a objetos. A

pretensão deste parágrafo  é unicamente servir de mera introdução geral e explicar as sintaxes
necessária para seu uso com o Gambas. A melhor forma de aprender, e desfrutar dela e obter todo o
seu potencial é provando e vendo exemplos que á usem extensivamente.

O código fonte do ambiente de desenvolvimento Gambas faz um uso muito amplo de classes e
objetos, o que o torna uma fonte completa de exemplos. Está disponível dentro do diretório
apps/src/gambas2 do arquivo compactado    que contem os fontes do Gambas.

2.9 Propriedades, Métodos e Eventos

Os componentes que estendem as possibilidades do Gambas são de diversos tipos, mas todos eles
contem classes que definem diversos objetos. No caso dos componentes que servem para criar
interfaces gráficas, estes objetos incorporam um ícone à caixa de ferramentas do ambiente de
desenvolvimento. Não precisamos criar estes tipos de objetos escrevendo o código correspondente e
a palavra NEW, sendo só desenha-los sobre o formulário depois de ter pressionado o botão com o
ícone respectivo. E o ambiente de desenvolvimento é que se encarrega de escrever o código
necessário para cria-los.

Qualquer um dos objetos que é criado à partir dos componentes já tem um comportamento
definido em sua classe. Este comportamento incluem a interface com a qual os objetos se
comunicarão uns com os outros no programa, o necessário para que o programador possa defini-los
e faze-los atuar a sua conveniência. Para facilitar essas tarefas, estes objetos dispõe de Propriedades,
Métodos e Eventos. As Propriedades permitem trocar parâmetros do objeto. Na realidade, ao
darmos um valor a uma propriedade estamos designando valores a algumas variáveis do objeto que
este interpreta internamente para produzir um
efeito. Por exemplo, podemos designar a um
formulário um valor numérico a propriedade
Background, e com isso trocaríamos sua cor de
fundo. Para modificar as propriedades
dispomos da janelas de Propriedades na IDE
(visível ao pressionar F4 ou a partir do menu da
janela de projeto: Exibir (View) |
Propriedades), que nos permite faze-lo com
uma interface gráfica muito simples. Também
podemos trocar uma propriedade mediante
código fazendo referência ao nome do objeto e
a propriedade, separados por um ponto. Por exemplo: [Link] = 0, deixaria o fundo do
formulário Form1 em cor preta.

Os métodos são as funções que o objeto pode realizar. Só podem ser atribuídas mediante código
e cada objeto tem sua própria coleção de métodos. Por exemplo: [Link] faz que o botão
btnSair oculte-se. Finalmente, os eventos são subrotinas que executam-se para indicar algo que
ocorreu ao objeto. Um exemplo é o que vimos no capitulo anterior no evento Click do botão que
executa-se quando damos um click com o mouse. Os eventos são, na aplicação gráficas, os que
marcam o fluxo do programa. Por isso, com frequência se diz que Gambas é uma linguagem
orientada a eventos. É o usuário da aplicação ao interagir, que obriga ao programa a executar código
Figura 4. Evento Click
respondendo as suas ações. Os objetos em Gambas avisam com os eventos cada vez que
produzimos uma ação sobre eles.
É o programador o encarregado de escrever nas sub-rotinas que tratam os eventos o código
necessário para responder a eles.
O ambiente de desenvolvimento proporciona várias formas de conhecer os métodos, eventos e
propriedades que um objeto pode entender. A primeira e mais obvia é usando a ajuda, onde
podemos encontrar a lista de todas as classes de objetos disponíveis, com todas as explicações e a
lista completa de todas as propriedades. O editor de código também fornece informações, já que ao
escrever o nome de um objeto e ao digitar um ponto, aparece um menu contextual com a lista das
propriedades (em cor violeta) e métodos (em cor verde) que o objeto tem disponíveis.
Para os objetos gráficos há algumas ajudas a mais. A lista de propriedades disponível pode ser vista
na janela de Propriedades. Para os eventos podemos dar um click com o botão direito do mouse
sobre o objeto gráfico em seu formulário. Aparecerá um menu onde entre outaras, vemos a opção
Evento. Podemos escolher o evento que quisermos e, automaticamente, o ambiente escreverá o
código correspondente ao inicio e ao final do procedimento.

NOTAS

1 Os computadores só entendem de números, não de letras, para podermos usar caracteres se

aplicam tabelas de conversão que atribui um numero o código a cada caractere. A tabela de
conversão usada normalmente se chama ASCII.

Em [Link] podemos ver a tabela completa.