Escolar Documentos
Profissional Documentos
Cultura Documentos
Curso de Iniciação
Nenhuma parte deste documento pode ser reproduzida ou transmitida de nenhuma forma, nem por nenhum meio, seja eletrônico ou
mecânico, com nenhum propósito, sem a previa autorização por escrito de Ortiz de Zíñiga, S.L.
CONTROLES DO WINDOWS.........................................................................................14
O QUE SÃO OS CONTROLES..........................................................................................................14
TIPOS DE CONTROLES..................................................................................................................17
Botões...............................................................................................................................17
Barras de rolagem...........................................................................................................17
List boxes..........................................................................................................................18
Group boxes.....................................................................................................................18
Gets (Edit text).................................................................................................................18
Says (Text)........................................................................................................................18
Boxes................................................................................................................................19
Radio buttons...................................................................................................................19
Check boxes......................................................................................................................19
Combo boxes....................................................................................................................19
CONTROLES AVANÇADOS............................................................................................................20
Browses............................................................................................................................20
Meters...............................................................................................................................22
Bitmap (Control)..............................................................................................................23
Botão Bar (Button bar)....................................................................................................23
Uso de BWCC.DLL..........................................................................................................24
EXERCÍCIOS...............................................................................................................................25
RECURSOS DO WINDOWS............................................................................................26
O QUE SÃO OS RECURSOS ?.........................................................................................................26
RC OU DLL?..........................................................................................................................27
TIPOS DE RECURSOS....................................................................................................................28
Diálogos...........................................................................................................................28
Menus...............................................................................................................................28
Atalhos.............................................................................................................................28
Matrizes de Cadeias de Caracteres (String Tables)........................................................28
Bitmaps.............................................................................................................................28
Ícones...............................................................................................................................29
Cursores...........................................................................................................................29
Fontes...............................................................................................................................30
RESOURCE WORKSHOP...............................................................................................................30
Caixas de Diálogo............................................................................................................32
Trabalhando com controles.............................................................................................32
Tab Stop...........................................................................................................................32
Agrupando controles........................................................................................................32
Ordem dos controles........................................................................................................33
Ferramentas de alinhamento e ajuste de tamanho..........................................................33
Experimentando uma caixa de diálogo............................................................................33
Controles criados pelo usuário........................................................................................33
Bitmaps, Ícones e cursores...............................................................................................34
EXERCÍCIOS...............................................................................................................................34
IMPRESSÃO EM FIVEWIN.............................................................................................35
IMPRESSÃO EM MICROSOFT WINDOWS..........................................................................................35
O GERADOR DE RELATÓRIOS........................................................................................................36
EXERCÍCIOS...............................................................................................................................40
O DEBUGGER DO FIVEWIN..........................................................................................43
UTILIZAÇÃO DO DEBUGGER..........................................................................................................43
EXERCÍCIOS...............................................................................................................................43
PROGRAMAÇÃO AVANÇADA......................................................................................44
REFRESH DO SISTEMA.................................................................................................................44
MANIPULAÇÃO DE JANELAS MDI................................................................................................44
MENUS FLUTUANTES..................................................................................................................46
OS BRUSHES.............................................................................................................................47
O CLIPBOARD...........................................................................................................................47
ARQUIVOS INI..........................................................................................................................48
TIMERS....................................................................................................................................48
MULTIMÍDIA.............................................................................................................................49
CONTROLES VBX.....................................................................................................................49
ODBC....................................................................................................................................51
MANIPULAÇÃO DE DLLS...........................................................................................................53
DYNAMIC DATA EXCHANGE (DDE)............................................................................................54
MANIPULAÇÃO DE ARQUIVOS DE HELP..........................................................................................55
EXERCÍCIOS...............................................................................................................................56
INTRODUÇÃO
O Que é FiveWin?
FiveWin é uma biblioteca para CA-Clipper que permite a execução de programas sob
Windows. Dentro do pacote existe muito mais do que pode-se imaginar a primeira vista, já
que FiveWin proporciona ao CA-Clipper um autêntico ambiente orientado a objetos com
criação de novas classes, herança, polimorfismo, etc.
FiveWin utiliza este potencial OOPS para criar suas próprias classes e acessar toda a API
do Windows sem que o programador tenha necessidade de se comunicar com a mesma,
além disso, devido ao fato que o FiveWin incorpora no pacote todos os fontes dessas
classes é realmente simples modificar ou subclassificar qualquer delas para atender nossas
necessidades. Ademais o uso de todas as classes pode ser feito utilizando-se comandos ao
mais puro estilo Dbase, pelo que a utilização do FiveWin é realmente simples.
FiveWin nos dá acesso a quase a totalidade de recursos do Windows como por exemplo:
Ademais FiveWin incorpora a classe TWBrowse para poder produzir browse sob Windows
e a classe TReport para produzir qualquer relatório.
Compilar
Para compilar uma aplicação produzida com FiveWin compile como fazia normalmente:
Quase todas as aplicações escritas com FiveWin necessitam que se inclua a seguinte linha:
#include "FiveWin.ch"
Linkar
FiveWin consiste das seguintes LIBs:
• FiveWin.LIB
• WinApi.LIB
• 501_520
Arquitetura
A arquitetura do FiveWin está baseada nos seguintes níveis:
1 Comandos xBase
2 Classes e objetos
3 Funções
4 Windows API
FiveWin faz um uso extensivo de novos objetos, porém graças ao preprocessador do CA-
Clipper o uso dos mesmos está disfarçado em forma de comandos cuja sintaxe é mais
natural, assim sendo é possível acessar diretamente as classes sem necessidade de utilizar
os comandos xBase.
UTILITÁRIOS NECESSÁRIOS
Além do FiveWin e CA-Clipper serão necessárias uma série de utilitários:
O compilador de recursos permitirá incluir em seu executável final recursos gerados através
do Resource Workshop, por exemplo, são recursos as imagens, os ícones que se encontram
em quase todos os programas para Windows.
Por exemplo o ícone que possuem todas as aplicações Windows quando se minimizam é
um recurso que normalmente se guarda em um arquivo com extensão ICO, porém, como
veremos em capítulos posteriores pode-se encontrar em um arquivo de extensão RC ou
incluso dentro de uma DLL. Para juntar este ícone ao executável deverá ser criado um
arquivo RC com o Resource WorkShop e utilizar a ferramenta RC.EXE para incluí-lo
definitivamente no executável.
Não é necessário adquirir nenhum editor para Windows, e de fato pode seguir utilizando o
mesmo de sempre, recomendamos que organize seu ambiente de programação da seguinte
maneira:
Instalação do FiveWin
FiveWin se instala automaticamente em seu computador sob a seguinte estrutura:
C:\Clipper5
Fwxxx Onde xxx é a versão do FiveWin
Bitmaps algumas imagens para incluir em suas próprias aplicações
Cursors alguns cursores para incluir em suas próprias aplicações
Dll DLL vazia p/ utilizar como armazenador de seus recursos
Icons alguns ícones para incluir em suas próprias aplicações
Ide Ambiente IDE do FiveWin (no operativo pelo momento)
Include Arquivos de Cabeçalho tanto para CA-Clipper como para C
Lib LIBs do FiveWin
Manual Guia Norton
Samples Tutoriais e exemplos
Source Fontes
Classes Classes
Function Funções
Tools Utilitários
Winapi Conecção CA-Clipper e Windows API
Devido ao FiveWin incorporar seu próprio mecanismo OOPS é incompatível com outros
mecanismos OOPS existentes como Class(y), que é utilizado por algumas LIBs comerciais,
logo FiveWin é incompatível com Class(y) e com todas aquelas funções de outras LIBs que
utilizem um run-time Class(y), por exemplo a LIB Funcky II o utiliza, porém, pode-se usar
perfeitamente com FiveWin, sempre e quando não se utilize as classes que vem
incorporadas na LIB Funcky II.
São compatíveis com FiveWin as LIBs Comix, Six 2.0 e parte de Funcky entre outras.
Quando começar a programar sob Windows se dará conta que grande quantidade das LIBs
que estava usando já não são necessárias porque o próprio Windows lhe dá suporte para
produzir o mesmo , como por exemplo LIBs gráficas, de acesso a redes locais, envio de
faxes, etc. Ademais descobrirá novas formas de LIBs como o são os controles VBX e as
DLLs os quais se podem utilizar perfeitamente a partir do FiveWin e sem nenhuma
limitação.
Exercícios
1. Que flags são necessários e quais são recomendáveis para o uso do compilador do
CA-Clipper com FiveWin?
2. Modificar Build.Bat para o seguinte ambiente: CA-Clipper em diretório D:\CLP
3. Prepare seu ambiente de programação sob Windows.
ELEMENTOS FUNDAMENTAIS DE
UMA APLICAÇÃO DE GESTÃO EM
WINDOWS
Janela Principal
Toda aplicação Windows deve ter uma janela principal. Geralmente esta janela terá um
título ou ‘Caption’, um menu, uma barra de botões e uma barra de mensagens em sua parte
inferior, entretanto, como veremos mais adiante, não é necessária a existência de todos
estes componentes.
• Janela SDI
• Janela MDI
SDI significa Single document interface, ou seja, um único documento ou janela para toda
a aplicação e MDI que significa Multiple document interface, no qual existem múltiplos
documentos ou janelas dentro da janela principal. Exemplos de janelas MDI são o
gerenciador de programas e o gerenciador de arquivos ( Windows 3.x ), nos quais pode-se
observar que existe uma janela principal e dentro da mesma existem outras janelas ‘filhas’.
No caso do Gerenciador de programas cada janela filha corresponde a um grupo do
gerenciador de programas.
O projeto MDI é mais apropriado quando o programa deve abrir múltiplas instâncias do
mesmo tipo de documento, ou seja, num programa para editar arquivos DBF genérico é
preferível produzi-lo com um projeto MDI, no resto dos casos recomendamos um projeto
SDI, que é mais simples de manter e de compreender por parte do usuário. Ao criar uma
aplicação é importante ter em mente que ela será utilizada por um usuário que muitas vezes
desconhece a interface do Windows e a complexidade da aplicação em sua totalidade,
assim sendo, se permitir múltiplas janelas abertas, cada uma delas diferente, será difícil o
usuário aprender a utilizar sua aplicação.
As janelas podem ter vários estilos ou propriedades, como por exemplo uma que tenha
título, que possa ser movida, que se possa ser redimensionada, etc.. FiveWin permite
indicar, na criação da janela, o estilo que a mesma deve ter.
A partir de nossa janela principal poderemos, utilizando um menu, abrir novas janelas,
porém o habitual é abrir caixas de diálogo que na realidade são janelas que possuem
características especiais que as diferenciam do resto das janelas, que são:
• Sua execução é modal, ou seja, não é possível voltar à janela principal até
que a caixa de diálogo seja fechada, por exemplo pressionando um botão de
‘Aceitar’ na caixa de diálogo. Também pode-se construir caixas de diálogo
não modais, porém não é o habitual.
• As caixas de diálogo podem ser definidas em recursos externos.
• Os construtores visuais de recursos só manipulam caixas de diálogo, não
janelas.
• Todos os ‘controles’ do Microsoft Windows podem ser colocados em
caixas de diálogo e quase nunca em janelas.
• As caixas de diálogo não podem ser redimensionadas
• As caixas de diálogo não podem conter menus.
As características das caixas de diálogo serão vistas com mais detalhes num capítulo
separado.
#include “Fivewin.ch”
Static oWnd
Function Main()
DEFINE WINDOW oWnd TITLE "Meu programa"
ACTIVATE WINDOW oWnd MAXIMIZED
return nil
Neste exemplo estamos gerando a janela mais comum, com coordenadas e estilo
prefixados, que quando ativada abre-se em modo maximizado, ocupando todo o vídeo.
Nota: Para mais informação sobre a diferença entre janela em estado normal ou maximizado
consulte o tutorial do Microsoft Windows.
Desta forma, simulamos as coordenadas tipo texto que utilizamos normalmente com
CA-Clipper de linha e coluna, já que Microsoft Windows utiliza coordenadas em pixels. Se
desejar utilizar coordenadas em pixels, como o Microsoft Windows faz, simplesmente
introduza a cláusula PIXELS no comando.
Podemos aplicar uma grande variedade de estilos a uma janela. Por padrão, a janela possui
o estilo definido na API do Windows como OVERLAPPED-WINDOW, que significa que
possui as seguintes características:
• Caption ou Título
• Menu de sistema
• Redimensionável
• Botões de minimizar e maximizar
• NOSYSMENU
• NOCAPTION
• NOICONIZE
• NOZOOM
Se desejar que a janela principal seja uma janela MDI simplesmente especifique a cláusula
ao criar a janela:
Cada uma das cláusulas que podemos controlar é o que chamaremos um ‘Evento’, ou seja,
quando se produz o evento de pressionamento do botão esquerdo do mouse e este se
encontre dentro de nossa janela se executará o código que especificarmos na cláusula ‘ON
LEFT CLICK’.
A princípio não será necessário manipular quase nenhum evento, mas quando tiver mais
experiência com FiveWin é possível que sejam de grande utilidade.
Também podemos incluir barras de rolagem na janela. Para isso devemos incluir a
cláusula VSCROLL para barras verticais e HSCROLL para as horizontais.
Nosso objeto janela oWnd terá por sua vez definidos os objetos Scrollbar que serão:
oWnd:oVScroll e oWnd:oHScroll
Assim será possível manipular diretamente os eventos cada um desses objetos recebe.
oWnd:End()
Esta instrução indica ao objeto janela que ele deve finalizar. Se for especificada a cláusula
VALID quando a janela for ativada, então a instrução indicada será avaliada e se
retornar .T. a janela terminará mas não se retornar .F. . Por exemplo:
Menus
A estrutura típica de um programa Windows é criar uma janela principal e associar um
menu à mesma a partir do qual acessaremos todas as opções da aplicação.
Deve-se tentar produzir previamente um projeto de seu menu sem faze-lo demasiado
complicado, o mais simples possível e criando submenus para englobar opções do mesmo
tipo.
Com o FiveWin não é necessário a seqüência típica ‘DO CASE’ para controlar que opção
foi selecionada, quando um elemento do menu é definido, se especifica diretamente a ação
que será produzida quando da escolha.
MENU oMenu
MENUITEM <cItem> MESSAGE <cMessage> ACTION <uAction>
MENUITEM <cItem> MESSAGE <cMessage>
MENU
MENUITEM <cItem> MESSAGE <cMessage> ACTION <uAction>
ENDMENU
...
SEPARATOR
MENUITEM <cItem> MESSAGE <cMessage> ACTION <uAction>
ENDMENU
‘MESSAGE e ACTION’ são cláusulas opcionais. Se não se especifica nenhuma ação então
nada ocorrerá quando da escolha desse elemento do menu a não ser de que haja um
submenu que se encarregue desta opção.
Podemos especificar todos os submenus que desejarmos e com o aninhamento que seja
necessário, para cria-lo só deverá aninhar dentro de uma estrutura MENU ... ENDMENU
uma nova estrutura MENU ... ENDMENU
Para ativar o menu dever-se-á primeiro associa-lo a uma janela. A forma mais simples de
faze-lo é:
Barra de botões
A barra de botões se tornou um padrão dentro dos componentes que podemos encontrar em
quase todas as aplicações para Windows.
O propósito desta barra não é outro que oferecer um acesso rápido às opções mais
utilizadas de sua aplicação.
Uma barra de botões bem projetada ajuda enormemente no aprendizado e uso de qualquer
aplicação. Não utilize imagens sem sentido, pelo contrario, tente utilizar imagens que de
uma forma intuitiva indiquem a ação a produzir quando seja pressionada com o mouse.
A barra de botões é uma área da janela na qual se vão alojar uma serie de botões com
imagens em seu interior. As ações que estes botões realizam podem ser opções duplicadas
já existentes em opções de menu visto que a as barras de botões não pode ser acessada a
partir do teclado.
Normalmente a barra de botões deve estar na parte superior da janela abaixo do menu,
porém, o FiveWin tem a habilidade de colocar a barra de botões onde se deseja
simplesmente pressionando o botão direito do mouse.
Todas as janelas possuem um objeto :oBtnBar que é onde se guarda a referencia à barra de
botões.
Para incluir uma barra de botões em qualquer janela se utiliza o seguinte comando:
Barra de mensagens:
A barra de mensagens também é um padrão que podemos encontrar em quase todas as
aplicações para Windows .
Uma barra de mensagens é um controle que se coloca na parte inferior da janela que mostra
informação relacionada com o elemento de menu que este atualmente selecionado ou, no
caso de uma barra de botões, com o botão sobre o qual se encontre o cursor do mouse.
FiveWin mostra a barra de botões com efeito 3D sem necessidade de ter que especifica-lo e
opcionalmente lhe permite colocar as mensagens centralizadas na barra de mensagens.
Atualmente em fase Beta e provavelmente disponível quando estiver lendo este documento,
a barra de botões implementará a possibilidade de ter múltiplas colunas com informação de
tempo, setas, estado do teclado, etc.
Caixas de Diálogo
Em Windows a introdução de qualquer dado por parte do usuário em uma aplicação se faz
através das caixas de diálogo. As caixas de diálogo são janelas especializadas em recolher
informação através de controles padrão do Windows.
Não é uma prática recomendável utilizar a janela principal de uma aplicação para recolher
dados.
• Modais
• Não modais
As modais são aquelas que não permitem ao usuário produzir nenhuma ação até
que se feche esta caixa de diálogo, em MSDOS sempre utilizamos caixas de
diálogo modais. As caixas de diálogo não modais permitem ao usuário fazer
outras coisas enquanto estão ativas. A principio e até que esteja um pouco mais
familiarizado com o Windows utilize unicamente caixas modais já que temos que
saber muito bem o que se está fazendo quando se utilizam caixas não modais.
Uma caixa de diálogo é um objeto e para cria-la utilizaremos a sintaxe típica também
utilizada na criação de janelas porém com algumas variações:
Depois se está desenhando diretamente a partir de código fonte deverá associar todos os
controles que esta caixa de diálogo vai ter, pelo contrario se criada com um editor de
recursos os controles já estarão criados e só será necessário redefini-os para modificar
alguma característica dos mesmos se assim o desejar.
Se esta criando a caixa de diálogo diretamente a sintaxe é muito parecida à dos comandos
do CA-Clipper.
Lembre-se de especificar sempre ‘OF oDlg’ , desta forma o controle saberá a quem ele
pertence (seu armazenador).
Se esta criando a caixa de diálogo a partir de recursos é possível que necessite redefinir
algum controle, para isso deverá utilizar o comando
O código fonte deste pequeno programa pode ser encontrado no disquete com o
nome:
tutor2\exemplo1.prg.
#include “FiveWin.ch”
STATIC oWnd
FUNCTION Main()
MENU BuildMenu()
return nil
//-----------------------------------------------------//
Function BuildMenu()
local oMenu
MENU oMenu
MENUITEM “Fim” ACTION oWnd:End()
ENDMENU
Return oMenu
Exercícios
1. Tente adicionar ao programa de exemplo uma barra de botões estilo 3D.
2. Faça um programa com uma opção de menu em sua janela principal que ao
executar-se abra uma caixa de diálogo com o título “Minha primeira caixa de
diálogo”.
3. Faça um programa no qual cada vez que se pressionar o botão esquerdo do mouse
soe um bip.
CONTROLES do Windows
Os controles devem ser incorporados apenas nas caixas de diálogo, porém, também podem
ser incluídos nas janelas se necessário. CA-Clipper (sob MSDOS) só possui dois tipos de
controles que seriam o controle GET e o controle SAY que em Windows se chamam EDIT
TEXT e TEXT. O Windows inclui mais controles que melhoram substancialmente a
interface com o usuário.
Todos os controles herdam suas propriedades da classe tControl que por sua vez é uma
classe herdada de tWindow. Cada controle do Windows está implementado no FiveWin
com uma nova classe para fazer com que seu uso seja realmente simples. Você não tem
porque saber a princípio como é a hierarquia de classes do FiveWin porém é recomendável
que desde o principio vá adquirindo a sensação de compreender como realmente é FiveWin
por dentro, já que isso permitirá explora-lo ao máximo.
Os controles devem estar contidos sempre em uma janela ou caixa de diálogo e não podem
ter nenhum menu associado. Todos os controles tem um número identificador do mesmo
pelo qual podemos acessar quando utilizamos controles criados através de um editor de
recursos.
Neste capítulo se faz uma relação dos controles padrão e os mais importantes que se podem
utilizar com FiveWin indicando as características de cada um deles, sua funcionalidade e
alguns conselhos para sua utilização, porém não se dá uma explicação exaustiva sobre as
distintas cláusulas de criação de cada um deles com comandos xBase, nem tampouco uma
relação de todos os métodos e dados dos mesmos. Para obter maior informação sobre cada
um destes controles utilize o guia Norton que acompanha a LIB FiveWin.
Em uma caixa de diálogo onde se encontrem vários controles somente um deles recebe
informação do usuário, se diz que esse controle tem ‘Focus’, quando um controle tem foco
é facilmente reconhecível, no caso de um Get poderá observar o cursor do teclado e no caso
de um botão observará um retângulo fino ao redor do título do mesmo e uma marca mais
escura que no resto dos botões. Nem todos os controles podem ter foco por não fazer
sentido, é o caso de um Say ou Text.
Para acessar um controle só temos que posicionar o mouse encima dele e fazer um click do
botão esquerdo, com o teclado há duas formas de acessar, a primeira consiste em pressionar
a tecla ‘TAB’ com o que se passa o foco para o controle seguinte até que cheguemos ao
controle desejado, pressionando ‘TAB’ avançamos até o controle seguinte e com
‘Alt+TAB’ retrocedemos ao controle anterior; o segundo método consiste em pressionar o
atalho desse controle, se ele o tiver.
Aqueles controles que podem ter vários estados, como por exemplo um botão: pressionado
ou não pressionado, um checbox: verdadeiro ou falso, etc., podem ter seu estado
modificado pressionando-se o controle com o botão esquerdo do mouse ou também
pressionando a tecla de espaço quando esse controle tiver foco.
Porém, se o controle foi criado com recursos (explicar-se-a a forma de faze-lo no capítulo
seguinte) é possível que não necessite fazer nada com o controle como por exemplo um
controle SAY com o qual não existe muito mais a fazer que apresenta-lo dentro da caixa de
diálogo, porém pode ser que seja necessário modificar o comportamento desse controle
para acomodá-lo a suas necessidades, por exemplo, se for um campo Get devemos ter
alguma forma de saber que valor tem esse campo uma vez terminada a edição do mesmo,
ou utilizar uma determinada mascara de edição, para todos esses casos se utiliza o comando
‘REDEFINE’ que existe para todos os controles do FiveWin. Com este comando podemos
não só obter uma referencia ao controle desenhado via recursos como também modificar
seu comportamento e aparência. Como comentado antes, todo controle tem um
identificador e graças a ele podemos acessar o mesmo, a sintaxe é a seguinte:
REDEFINE CONTROL oControl ID .... OF oDlg
Por exemplo, para modificar a máscara de um Get e, além disso, guardar o resultado de sua
edição na variável cData faríamos o seguinte:
REDEFINE GET oGet VAR cData ID 101 PICTURE “!!!!!!” OF oDlg
Lembre-se bem o que acaba de ler porque esta é uma das bases do FiveWin e uma de suas
características mais poderosas. A diferença de outras linguagens é que elas
constantemente subclassificam qualquer classe quando necessitam modificar qualquer dado
ou comportamento da mesma. FiveWin utiliza a técnica de ‘redefinir’ que acreditamos
que em muitos casos é mais adequada e rápida.
É importante que ao criar os controles, indique sempre a que diálogo ou janela eles
pertencem com a cláusula OF:
Ao criar controles diretamente a partir de código fonte deverá indicar a linha e coluna onde
deseja que apareçam, igual às janelas ou aos diálogos, esta linha e coluna pode ser o
equivalente a coordenadas tipo texto, ou também pode-se introduzir as coordenadas
diretamente em pixels incluindo a cláusula PIXELS ao criar o controle. Se utilizar
coordenadas tipo texto tenha em mente que é possível introduzir valores decimais na linha e
na coluna.
É possível que o dado representado por um determinado controle varie durante a edição, ou
por outro controle ou, por exemplo, por ser o campo de uma base de dados e o ponteiro de
navegação do mesmo foi movido, nestes caso é necessário atualizar a informação contida
nesses controles e, para isso, se utiliza um método genérico do FiveWin implementado na
classe base tWindow que é ‘refresh’.
oGet:Refresh()
Uma técnica pouco usada pela maioria dos programadores FiveWin, porém muito prática, é
utilizar a cláusula UPDATE ao criar o controle. Quando incluímos esta cláusula,
podemos atualizar todos os controles com esta cláusula simplesmente mandando o método
Update a seu diálogo armazenador.
oDlg:Update()
Assim como o dado ‘bGotFocus’ existem outros dados da classe para manipular o resto dos
eventos que podem ser produzidos. FiveWin inicializa para você os code-blocks mais
usuais dependendo do tipo de controle. Por exemplo, se em um check box queremos
controlar quando seu estado é alterado, existe uma cláusula na criação do mesmo que é ‘ON
CLICK’, na realidade, o que o FiveWin faz via preprocessador é associar ao dado
‘bClicked’ da classe tCheckbox a instrução que você introduziu no comando.
Tipos de controles
O Windows implementa de maneira padrão, a partir de a versão 3.0, os seguintes controles:
Botões
Os botões do Windows permitem estabelecer determinadas operações que são executadas
quando estes são pressionados, sua funcionalidade é muito parecida às opções de menu no
sentido de que tem uma cláusula ‘ACTION’ na qual se indica a instrução a ser executada
quando o botão é pressionado.
Um botão pode levar a cláusula DEFAULT que indica que a ação desse botão se executará
quando se pressionar a tecla Enter, a não ser que esse controle não tenha foco nesse
momento. Logicamente, só deve haver um botão com esta cláusula em uma mesma caixa
de diálogo.
Se o botão é criado a partir de código fonte é possível indicar uma imagem ou arquivo
bitmap, isto é uma característica do FiveWin que não é padrão do Windows.
Barras de rolagem
As barras de rolagem o ‘scrollbars’ são controles que podem ser usados numa infinidade
de ocasiões, por exemplo, podem servir-nos para navegar por um arquivo de texto, uma
base de dados ou uma imagem bitmap que não caiba em sua totalidade em uma caixa de
diálogo.
A característica principal das barras de rolagem são as instruções que podem ser executadas
ao produzir determinadas operações com as mesmas (eventos), estas são as principais:
• On up
• On down
• On page up
• On page down
• On Thumbpos
Ao criar uma barra de rolagem deve-se indicar valores máximos e mínimos para a
mesma, assim como o incremento que se produzirá no valor quando um evento
tipo ‘Page up’ o ‘Page down’ é produzido.
List boxes
Um listbox é um controle que manipula listas que logicamente estão implementadas sob
FiveWin como matrizes.
Um listbox tem associado a si uma matriz com todos os elementos da lista e sempre ha um
elemento que é o ativo, a não ser que a matriz esteja vazia.
Uma vez criado o listbox, pode-se adicionar, modificar, eliminar os elementos do mesmo
utilizando os métodos que o FiveWin proporciona para a manipulação desta classe.
Group boxes
Um Group box é um controle que simplesmente engloba outros controles ou para que sua
apresentação seja mais intuitiva, ou também por que os controles agregados atuam como
um único controle, este é o caso dos Radio buttons que são controles que mostram dois
estados: ON|OFF . Quando vários radio buttons estão contidos em um group box somente
um deles pode estar ON simulando efetivamente os botões dos antigos rádios.
Um dos feitos do FiveWin foi a implementação das cláusulas VALID e WHEN típicas do
CA-Clipper, já que estas duas cláusulas não estão implementadas no Windows.
Says (Text)
O controle Say ou Text é um texto fixo que pode ser ou não multi-linha e que pode estar
justificado à esquerda, centralizado ou à direita.
Sua funcionalidade é muito parecida ao Say do CA-Clipper com a diferença de que por
tratar-se de um objeto agora pode ser manipulado, alterado seu texto, etc.
Boxes
Os boxes são retângulos que permitem melhorar a apresentação de caixas de diálogo, dando
um efeito 3D quando o comando a seguir é utilizado no inicio do programa
SET 3D LOOK ON
Para que esse efeito seja efetivo deve existir a LIB Ctrl3d.dll , se possível, no diretório
Windows\System de seu computador.
Radio buttons
Os Radio buttons são controles que mostram dois estados: ON|OFF, porém, quando vários
radio buttons estão contidos em um group box somente um deles pode estar ON simulando
efetivamente os botões dos rádios antigos.
São utilizados quando se deseja um input de um número compreendido entre vários valores.
Por exemplo, se utilizarmos a variável nCartao para armazenar o possível cartão a utilizar,
1 poderia ser Visa, 2 Americam Express e 3 Dinners, cada uma das opções estaria
representada por um radio button porém, logicamente, quando um deles estiver selecionado
o resto deverá estar em OFF.
Realmente são três controles que atuam como um só. Por este motivo, talvez seja o
controle mais complicado de utilizar. Quando definido via recursos não se deve esquecer
de incluí-os em um group box. Se definido a partir de código fonte então se comporta
como um único controle e, da mesma forma, ao estabelecermos o ‘REDEFINE’ para
FiveWin passam a ser um único controle.
Check boxes
Um check box é um controle que pode ter dois estados: verdadeiro ou falso, e portanto se
utiliza uma variável lógica para recuperar seu valor.
É muito recomendável seu uso em vez dos típicos Gets que se faz com CA-Clipper de
“Sim”/”Não”.
Combo boxes
Um combo box é um listbox drop down, ou seja, é um listbox que quando não tem foco nos
mostra o elemento ativo, porém, quando recebe foco, se abre como se se tratasse de um
menu tipo persiana.
A vantagem fundamental deste tipo de controle é que o mesmo necessita muito menos
espaço que o listbox, porém, só podemos ver todas as opções possíveis quando acessamos o
mesmo.
Menu do sistema
Botão
Barra de rolagem
List box
Combo box
Say (Text)
Retângulo (box)
Controles Avançados
Os controles avançados são todos aqueles que não são padrão do Windows.
FiveWin implementa diretamente alguns controles que não existem no Windows, como o
controle tWbrowse que permite manipular bases de dados, ou o controle tMeter que é
utilizado para mostrar barras de progresso de, por exemplo, uma reindexação.
A Borland através de seu editor de Recursos permite também utilizar os já famosos BWCC
(Borland Window Common Control) para isso temos que utilizar em nossos programas a
LIB da Borland BWCC.DLL.
FiveWin permite também utilizar controles criados por outros fabricantes como o são os
controles VBX.
Browses
Os browses são controles especializados na edição de bases de dados, seu funcionamento é
parecido ao browse original do CA-Clipper, porém, sua implementação é distinta já que a
diferença deste é que os browses do FiveWin não contém por sua vez objetos colunas, o
que é uma das limitações do FiveWin, e é o motivo pelo qual com a ultima versão se
introduziu um novo browse com objetos colunas porém manteve-se o original.
Recomendamos utilizar o original do FiveWin sempre que possível já que é muito mais
rápido.
A sintaxe é muito parecida à do controle List box com a diferença de que se utiliza a
cláusula FIELDS para indicar que campos de uma base de dados serão editados:
A cláusula SIZE permite indicar o tamanho que terá o controle, é opcional e se não for
introduzida será calculada automaticamente.
A partir do comando podemos manipular os eventos mais típicos que um controle Browse
pode ter como ‘ON CHANGE’ que é quando fazemos um clique sobre o objeto browse e
alteramos o elemento ativo e portanto o ponteiro da base de dados, ‘ON RIGHT CLICK’
quando pressionamos o botão direito do mouse ou o ‘ON LEFT DBLCLICK’ que é quando
realizamos um clique duplo com o botão esquerdo do mouse.
É habitual, sobretudo em ambientes MDI, fazer com que um browse ocupe toda a superfície
de uma janela filha (Child), e que quando redimensionamos esta janela se redimensione o
controle Browse, para isso FiveWin implementa um método na classe tMdiChild, que é o
método :SetControl().
oChildWnd:SetControl(oBrowse)
Também podemos criar browses a partir de recursos, porém, devido a esse controle não ser
um controle padrão nem do Windows nem do Resource Workshop, temos que indicar ao
WorkShop que queremos criar um controle de usuário (custom control). No próximo
capítulo será mostrado como produzi-lo a partir do Resource Workshop, porém uma vez
realizado, para implementa-lo em nosso programa faríamos:
REDEFINE LISTBOX [ <oBrw> ] ;
FIELDS [ <cFields,...>] ;
[ FIELDSIZES <aColSizes,...> ] ;
[ HEAD | HEADER | HEADERS <aHeaders,...> ] ;
[ ID <nId> ] ;
[ ON CHANGE | ON CLICK <uChange> ] ;
[ ON RIGHT CLICK <uRClick> ] ;
[ ON DBLCLICK <uDblClick> ] ;
[ OF | WINDOW | DIALOG <oDlg> ]
O browse tem uma série de métodos específicos para bases de dados, como a possibilidade
de estabelecer um filtro na mesma, a possibilidade de utilizar um array em vez de uma base
de dados, etc..
Um método muito utilizado da browse é o método ‘lEditCol’ que permite editar on-line o
campo onde se encontre o cursor. Por exemplo, se desejarmos editar o campo quando um
clique duplo é feito:
oBrowse:blDblClick := {|nRow, nCol, nFlags| ;
oBrowse:lEditCol(nCol,...)
Consulte o guia Norton para obter maior informação sobre seu uso.
Outro método muito utilizado da classe Browse é o método :Report() que nos permite
produzir um relatório impresso do browse, é realmente prático para pequenos relatórios.
Meters
O controle Meter é utilizado para mostrar barras de progresso e sua utilização pode ser
muito variada: um processo de reindexação, cálculo complexo sobre uma base de dados,
etc.
FiveWin torna realmente simples o uso de barras de progresso sendo sua sintaxe a seguinte:
@ <nRow>, <nCol> METER [ <oMeter> VAR ] <nAtual> ;
[ TOTAL <nTotal> ] ;
[ SIZE <nWidth>, <nHeight> ];
[ OF <oWnd> ] ;
[ UPDATE ] ;
[ PIXO ] ;
[ FONT <oFont> ] ;
[ PROMPT <cPrompt> ] ;
[ NOPERCENTAGE ] ;
[ COLOR | COLORS <nClrPane>, <nClrText> ] ;
[ BARCOLOR <nClrBar>, <nClrBText> ]
ou
oMeter:Set(nRecno+1)
[ UPDATE ] ;
[ FONT <oFont> ] ;
[ PROMPT <cPrompt> ] ;
[ NOPERCENTAGE ] ;
[ COLOR | COLORS <nClrPane>, <nClrText> ] ;
[ BARCOLOR <nClrBar>, <nClrBText> ] ;
Bitmap (Control)
O controle bitmap tem como missão a manipulação de imagens em formato “bitmap”, este
controle nos permite colocar em uma caixa de diálogo qualquer imagem bitmap e de
qualquer resolução e número de cores.
O controle Bitmap nos permite ajustar o bitmap às dimensões que desejamos utilizando o
método Stretch ou a cláusula Adjust no comando, da mesma forma se o bitmap é maior que
nosso controle podemos incluir barras de rolagem simplesmente adicionando a cláusula
Scroll.
Não faz muito sentido redefinir este controle já que não é possível criá-lo a partir de
recursos visto que as barras de botões ainda que possam ser colocadas em diálogos não é
habitual (só em janelas), porém, este redefine pode ser usado para colocar um bitmap em
um botão convencional do Windows que de outra forma não seria possível senão usando os
controles avançados da Borland (Bwcc.dll) explicados na continuação.
Uso de BWCC.DLL
No Resource Workshop da Borland podemos observar que além disso dos controles
standard do Windows existem outros adicionais que se autodenominam ‘Borland ... style’
sendo os pontos o equivalente controle padrão, ou seja existe um ‘Borland Radiobutton
Sytle’ por exemplo, também existem outros controles que não tem seu controle padrão
correspondente como é o controle Bitmap que nada tem que ver com o do FiveWin porém
que de certo modo tem a mesma funcionalidade, porém, o do FiveWin é mais potente.
Por suposição, esta LIB deve encontrar-se no diretório onde se executa a aplicação ou nos
diretórios \Windows ou Windows\System.
Exercícios
1. Faça um programa que inicie com uma caixa de diálogo com dois botões, um para
iniciar uma segunda caixa de diálogo e outro para abandonar a aplicação.
2. Faça um programa que inicie com uma caixa de diálogo que contenha um listbox
com os nomes de todos os alunos e que quando selecionar um deles o conteúdo de
outro controle tipo Get seja atualizado com o aluno selecionado, da mesma forma
se se edita o Get e se modifica o aluno que a alteração também se reflita no listbox.
3. Faça um programa que contenha três Gets e um botão de Aceitar, quando
pressionar o botão verificar que nenhum dos Gets esteja em branco e se algum
estiver, o programa deverá dar um bip e dar foco ao primeiro controle que esteja
em branco, caso contrario deverá fechar o diálogo e mostrar uma mensagem com
os diálogos predefinidos abaixo das funções ‘Msg’ indicando que o processo
terminou corretamente.
4. Faça um programa que contenha um controle Browse para editar a base de dados
Alunos.Dbf e além disso permita a edição on-line de qualquer de seus campos.
RECURSOS DO WINDOWS
A separação entre código e dados é o que permitiu o começo da “Programação visual”, que
permite desenhar todos os dados que uma aplicação vai manipular visualmente para depois
inclui-os em nossa aplicação final.
FiveWin está projetada para fazer uso extensivo dos recursos do Windows pelo que o uso
de um editor de recursos é essencial na programação com FiveWin porém não é
absolutamente necessário (lembre-se do comando REDEFINE).
O mais importante deste processo é compreender como podemos criar um objeto a partir de
um recurso e como definir o redefinir seu comportamento.
RC ou DLL?
Os dois sistemas são válidos para guardar recursos, porém existem diferenças importantes
entre eles:
Tipos de recursos
Os recursos são dados que definem a parte visível de um programa. Por exemplo, quando
você abre uma caixa de diálogo e clica em um botão para produzir uma determinada tarefa
em seu programa, você esta utilizando na realidade recursos. Além das caixas de diálogo e
botões seu programa pode incluir ícones, cursores, bitmaps (imagens), menus e atalhos de
teclado.
Diálogos
Um diálogo é uma janela que comunica informação ao usuário e permite ao mesmo
selecionar uma dentre varias opções, como abrir um arquivo, selecionar um cor, buscar um
texto, etc.
Menus
Os programas Windows podem incorporar uma barra de menu. Cada elemento de menu
pode por sua vez incluir outro submenu. Por exemplo, quase todos os programas do
Windows incorporam uma opção de menu Arquivo que inclui comandos para criar ou abrir
um arquivo existente.
Atalhos
Os atalhos são combinações de teclado que o usuário pressiona para produzir determinadas
tarefas. Por exemplo a combinação de teclado “Alt+F4” é um atalho para fechar a janela
ou diálogo ativo.
Bitmaps
Um bitmap é uma representação binaria de uma imagem gráfica. O Windows utiliza grande
quantidade de bitmaps. Por exemplo, são bitmaps as imagens típicas de qualquer janela
como as barras de rolagem, o símbolo do menu de controle ou os botões de minimizar ou
maximizar.
FiveWin incorpora a classe tBitmap para facilitar a manipulação dos mesmos. Para
introduzir um bitmap o mais prático é utilizar o comando BITMAP:
Como podemos observar, no comando a cláusula RESOURCE permite indicar o nome que
o bitmap tem no arquivo de recursos, e a cláusula FILE permite indicar o nome do
arquivo .BMP, logicamente, deve-se utilizar uma ou outra cláusula.
Ícones
Os ícones são pequenos bitmaps, geralmente de 32x32 pixels de tamanho, utilizados para
representar as aplicações quando estão minimizadas.
Toda janela que possa ser minimizada nos mostrará seu ícone se o mesmo estiver
incorporado ao executável. Para indicar que uma janela tem um determinado ícone isso
deverá ser feito quando ela é definida.
Se é o ícone da janela principal, este deverá necessariamente ser criado a partir de recursos
e com um arquivo .RC. No resto dos casos o ícone pode ser criado a partir de um arquivo
.ICO.
A partir de código:
Cursores
Um cursor é um pequeno bitmap de 32x32 pixels de tamanho que representa a posição do
mouse no vídeo. Os programas Windows utilizam os cursores para indicar o tipo de tarefa
que está sendo executada em cada momento. Exemplos típicos de cursores são a flecha, o
relógio de areia ou o Hi-Beam de edição.
Toda janela pode ter seu próprio cursor, que será mostrado quando colocarmos o cursor do
mouse em seu interior. Tenha em mente que quando nos referimos a janela o estamos
fazendo em sentido amplo, ou seja, diálogos e controles também podem ter seu próprio
cursor já que também são janelas.
FiveWin implementa um comando para criar o objeto tCursor e deverá ser utilizado o já
conhecido comando DEFINE WINDOW para criar a janela e associar o cursor recém
criado. Da mesma maneira quase todos os controles tem a possibilidade de ter um objeto
tCursor associado.
DEFINE CURSOR oCurosr RESOURCE "Meu_Cursor"
DEFINE WINDOW oWnd CURSOR oCursor
Fontes
Os programas Windows utilizam fontes para definir o tipo de letra, o tamanho e estilo do
texto a utilizar.
FiveWin utiliza a classe tFont para fazer seu uso mais prático. Para criar uma fonte utilize
o seguinte comando:
DEFINE FONT oFont NAME “ARIAL” SIZE 10,10
Toda janela pode ter sua própria fonte para todos os textos que mostre, tenha em mente que
quando nos referimos a janela o estamos fazendo em sentido amplo, ou seja, um diálogo e
um controle também podem ter sua própria fonte já que também são janelas para isso pode-
se especificar a cláusula FONT na criação dos mesmos.
DEFINE FONT oFont NAME “ARIAL” SIZE 0,-12
@ 2, 2 GET cText OF oWnd FONT oFont
Resource Workshop
Neste ponto será feita uma breve discussão sobre o Resource Workshop da Borland
objetivando unicamente que o aluno se encontre confortável o quanto antes possível com
esta potentíssima ferramenta e portanto não tem intenção de mostrar todas e cada uma de
seus possibilidades. Se desejar mais informação sobre este programa recomendamos que
leia em profundidade o manual que acompanha o Workshop, sobretudo o capítulo dedicado
à criação de caixas de diálogo.
Os programas sob Windows utilizam números para identificar cada um dos recursos. Você
utiliza estes números em seus programas para acessar cada um dos recursos, porém, os
números não são muito descritivos e por isso se utilizam diretivas ‘#DEFINE’ para associar
a cada número uma definição simbólica. Normalmente sob CA-Clipper se guardam as
diretivas DEFINE dentro de um arquivo com extensão .CH.
É importante que cada vez que crie um projeto novo inclua em seu arquivo .RC a seguinte
instrução:
#include "winapi.ch"
Para encontrar este número deverá busca-lo no arquivo de nome Windows.h que se
encontra no diretório \Include de seu compilador C que acompanha o Resource Workshop.
A partir do Resource WorkShop pode-se abrir um projeto criado com um arquivo .RC ou
através de uma DLL, mas também pode-se abrir simplesmente um arquivo bitmap, um
ícone o um cursor, simplesmente para editá-lo.
Recomendamos que não utilizem o Resource Workshop para criar seus menus e atalhos já
que é muito mais prático criá-los diretamente a partir do FiveWin.
É muito fácil copiar recursos entre projetos. Para isso deverá carregar o Resource
Workshop varias vezes, abrir um projeto distinto em cada um deles e utilizar as opções de
Copiar e Colar para ir copiando recursos de um projeto para outro.
Caixas de Diálogo
Para criar uma caixa de diálogo deverá ser utilizada somente a opção novo recurso, diálogo
e na continuação introduzir todos os controles que sua nova caixa vai ter.
Para introduzir controles deverá selecionar primeiro o controle que deseja com o mouse
dentro da janela de controles disponíveis e na seqüência clicar na área da caixa de diálogo
onde deseja colocar o controle.
Uma vez criado o diálogo, poderá modificar seu tamanho ou move-lo com o mouse. Para
modificar o estilo do dialogo realize um double-click em qualquer parte da caixa de diálogo
e será mostrada a janela de estilos da caixa de diálogo, não se assuste com a quantidade de
estilos possíveis já que não necessita conhecer mais que alguns deles, pelo menos no
principio e, além disso, a maioria deles são muito intuitivos.
Para obter informações sobre cada um dos estilos consulte o help On-line.
Inclusive, alguns dos estilos não são manipulados pelo FiveWin pelo que não faz sentido
utilizá-los.
No Resource Workshop existe uma paleta de controles, disponível sempre que editamos
caixas de diálogo, que permitem de uma maneira simples e intuitiva a inclusão de qualquer
controle na caixa de diálogo nas coordenadas e com as dimensões que desejarmos.
Cada um dos controles tem por sua vez estilos que podem ser mostrados realizando um
double-click em cada um deles.
Tab Stop
Uma vez introduzidos todos os controles em nossa caixa de diálogo poderemos identificar
quais receberão foco quando se pressionar o tabulador e quais não, por padrão o Resource
Workshop, dependendo do controle, dará o estilo ‘Tab Stop’ ao controle, sendo que o
mesmo pode ser alterado se o desejar. Por exemplo, um texto fixo não tem sentido que
tenha este estilo.
Para estabelecer este estilo em cada controle pode-se acessar a janela de estilo de cada um
dos controles ou também utilizar a ferramenta incorporada ao Resource Workshop na paleta
de ferramentas a qual simplifica tremendamente o trabalho.
Agrupando controles
O agrupamento de controles é uma técnica que permite ao usuário mover-se entre um grupo
de controles com as setas de cursor, é por exemplo, o caso dos radio buttons. Quando se
estabelece um agrupamento de controles, apenas o primeiro controle do grupo deverá ter o
estilo ‘Tab Stop’.
0|WS_CHILD|WS_VISIBLE|WS_TABSTOP|WS_BORDER|WS_VSCROLL|WS_HSCROLL
Exercícios
1. Faça um programa que acesse uma caixa de diálogo mediante um arquivo .RC e o
mesmo programa acessando o diálogo através de uma DLL.
2. Faça um programa com uma janela principal que ao ser minimizada mostre um
ícone criado em uma DLL e, quando o cursor se encontrar dentro da janela se
converta no símbolo “+”.
3. Faça um programa com uma caixa de diálogo com um controle browse para
acessar à base de dados Alunos.dbf.
4. Faça um programa com uma caixa de diálogo que contenha todos os tipos de
controles disponíveis no Resource Workshop através de um arquivo .RC.
IMPRESSÃO EM FIVEWIN
FiveWin implementa a impressão através de um objeto tPrinter o que faz com que a tarefa
seja realmente simples. Além disso, o FiveWin incorpora técnicas para criar alguns
relatórios rapidamente sem necessidade de programar, como por exemplo:
Se desejar produzir tarefas mais sofisticadas deverá utilizar diretamente o objeto tPrinter ou
utilizar o gerador de Relatórios que acompanha o FiveWin.
PAGE
...
oPrn:Say(nRow, nCol, cText, ...)
...
ENDPAGE
ENDPRINT
O comando PRINT cria um objeto tPrinter, e, a partir desse momento, já se pode manipular
a impressão que os métodos e dados desta classe oferecem.
Podemos incluir a cláusula FROM USER que mostra uma caixa de diálogo com todas as
impressoras disponíveis para que o usuário escolha a que deseja. Se esta cláusula não for
incluída, a impressora selecionada será a definida como padrão no painel de controle, ou se
for utilizada a função PrinterSetup() aquela que for definida.
A função PrinterSetup() permite selecionar uma impressora com todas as suas opções de
resolução, dimensão de página, etc.. porém somente para a aplicação atual, ou seja, não se
gravarão as alterações realizadas. Esta mesma função é usada por uma multiplicidade de
programas como por exemplo o Notepad na opção “Especificar impressora”.
A cláusula PREVIEW permite ver em vídeo cada uma das páginas a imprimir, podendo-se
fazer Zoom de qualquer delas e imprimir as que se desejar.
E dentro das mesmas fará chamadas ao método Say da classe tPrinter para imprimir o texto
que se deseja, tenha em mente que os parâmetros de linha e coluna que recebe o método
Say temos que dá-los em pixels e, dependendo da resolução da impressora, os resultados
serão distintos, por este motivo a classe tPrinter oferece vários métodos para resolver este
problema:
O problema das resoluções distintas de cada impressora também nos afetarão com as fontes
já que quanto maior a resolução da impressora menores elas serão impressas, para isso o
FiveWin inclui no comando de criação da fonte a cláusula ‘OF’.
PRINTER oPrinter
DEFINE FONT oFont NAME “ARIAL” SIZE 0,-10 OF oPrinter
Se depois disso verificarmos aos valores nHeight e nWidth do objeto tPrinter dar-se-á conta
que são valores muito superiores por terem sido redimensionados automaticamente.
Lembre-se de destruir a fonte uma vez terminada a impressão com o método End()
oFont:End() O RELEASE FONT oFont
O gerador de relatórios
O gerador de relatórios do FiveWin permite produzir quase qualquer relatório de uma
forma muito simples, entendendo por relatório qualquer lista baseada em colunas de
informação.
O gerador de relatórios faz um uso muito extensivo de classes, porém, graças aos comandos
seu uso é realmente simples.
A cláusula TITLE indicará o título do relatório sendo que pode-se incluir vários títulos
separados por vírgulas, o que permite que o título ocupe mais de uma linha, além disso
pode-se incluir a cláusula LEFT, CENTER o RIGHT, por padrão o título se mostrará
centralizado.
Pode-se utilizar qualquer expressão que devolva uma cadeia de caracteres para definir o
título, o cabeçalho ou o relatório e, a cada impressão, a expressão será avaliada, desta forma
é possível indicar por exemplo que o rodapé de página é oReport:nPage e cada vez que se
imprima o rodapé de página oReport:nPage será avaliado e portanto indicará perfeitamente
o número de página do relatório. Em última análise, o texto que você introduzir como
descritor do título, cabeçalho ou rodapé de página é convertido em code-blocks, para que
possam ser avaliados cada vez que o mesmo é impresso.
A cláusula FONT permite indicar, separados por vírgulas, todos os objetos Fontes que
serão utilizados no Report, não é necessário incluir a cláusula OF oPrinter ao criar a fonte
já que o próprio gerador de relatórios se encarrega de redimensionar as fontes dependendo
da resolução da impressora. Uma vez indicadas as fontes para indicar por exemplo que
uma coluna utilizará a primeira fonte da lista, simplesmente temos que fazer:
COLUMN DATA... TITLE... FONT 1
A cláusula PEN permite indicar, separados por vírgulas, todos os objetos PEN utilizados no
Report, um PEN é um objeto que permite identificar a espessura e cor de uma linha, círculo
ou retângulo, ou seja, é o equivalente a uma caneta. Como verá mais adiante é possível
indicar ao gerador de relatórios que imprima linhas verticais de margem de colunas. Para
criar um PEN utilize o seguinte comando:
DEFINE PEN oPen WIDTH 2
Assim como no caso dos fontes se queremos que uma coluna tenha traços de margem
deverá utilizar a cláusula GRID indicando o número de PEN a utilizar
COLUMN DATA... TITLE... GRID PEN 1
A cláusula CAPTION permite indicar o título do relatório que será mostrado na janela de
pré-visualização e a partir do administrador de impressão (Spooler).
A cláusula TITLE permite indicar o título da coluna, que pode ocupar varias linhas,
separando-as por vírgulas.
A cláusula DATA é utilizada para indicar os dados a serem impressos. Não é necessário
que sejam convertidos em cadeias de caracteres e podemos utilizar qualquer expressão.
Assim como o título, pode ocupar varias linhas.
A cláusula SIZE permite indicar a largura da coluna. Esta largura não é em pixels e sim
em caracteres. Não é necessário introduzir este valor já que o gerador de relatórios o
calcula para você.
A cláusula PICTURE permite estabelecer uma máscara a ser utilizada para os dados. É
muito importante que se utilize a cláusula Picture para os campos numéricos que queira
totalizar em vez de fazer um Transform() do dado.
A cláusula FONT permite indicar que número de fonte deve ser utilizada para a coluna,
dentre todas as indicadas quando se criou o Report. Aqui, podemos fornecer uma
expressão que devolva um número em vez do número diretamente. Por exemplo,
poderíamos fazer os seguinte:
COLUMN TITLE... DATA... FONT iif(Salario>100000,1,2)
desta forma o dado seria impresso com a fonte 1 quando o salário for menor ou igual a
100.000 e com a fonte 2 quando for superior.
A cláusula TOTAL permite especificar se desejamos totais desta coluna e, além disso, é
possível incluir um condição de totalização. Por exemplo:
COLUMN TITLE... DATA... TOTAL FOR NOME=“INACIO”
A cláusula SHADOW faz com que o fundo da coluna seja impresso em uma cor cinza claro
e a cláusula GRID permite colocar linhas de borda na coluna.
Se necessário, podemos estabelecer grupos de quebra para imprimir totais parciais das
colunas com totais. Para isso devemos utilizar o comando:
GROUP [ <oRptGrp> ] ;
[ ON <bGroup> ] ;
[ HEADER <bHead> ] ;
[ FOOTER <bFoot> ] ;
[ FONT <uFont> ] ;
[ < EJECT > ]
A cláusula FONT funciona exatamente igual as colunas. Com elas, indicamos a fonte
utilizada na impressão da quebra.
Para começar a impressão devemos utilizar o comando ACTIVATE REPORT que pode
incluir uma série de cláusulas que permitem especificar condições de impressão e modificar
o relatório enquanto esta sendo gerado.
• Classe tReport
• Classe tRLine
• Classe tRColumn
• Classe tRGroup
A classe tReport contém toda a informação geral de relatório e é armazenador do resto das
classes.
A classe tRLine é utilizada para todas as impressões feitas horizontalmente em todo o corpo
do relatório, como por exemplo o título, o cabeçalho ou o rodapé de página.
A classe tRColumn armazena toda a informação de cada uma das colunas do relatório. A
classe tReport tem um dado de nome ::aColumns no qual se guardam todos os objetos
tRColumn.
Por último, a classe tRGroup engloba todas as definições de grupo inseridas no relatório.
O gerador de relatórios foi criado em sua totalidade por Ortiz de Zúnhiga, S.L. e em
concreto por Ignacio Ortiz de Zúnhiga.
Exercícios
1. Faça um programa que contenha um browse com o arquivo Alunos.dbf e um botão
para imprimir a base de dados utilizando o método que a classe browse incorpora.
2. Faça um programa que imprime uma ficha completa de um aluno manipulando
diretamente a classe tPrinter.
3. Gere um relatório com o gerador de relatórios de todos os campos do arquivo
Alunos.dbf ordenando-o por nome e estabelecendo um grupo no campo sexo.
4. Tente incluir nesse relatório um bitmap no canto superior esquerdo.
MANIPULAÇÃO DE BASES DE
DADOS
Mudanças na programação
FiveWin não impõe nenhum tipo de restrição ou alteração no projeto habitual de bases de
dados a partir do CA-Clipper e, assim sendo, podemos continuar trabalhando da mesma
forma que em MSDOS. Porém há certos pontos que devem ser levados em consideração:
O objeto Database
O objeto database foi desenhado com o único propósito de tornar mais fácil a manipulação
dos arquivos DBF, reduzindo consideravelmente a quantidade de código necessário para
sua manipulação.
O objeto DataBase não tem como objetivo substituir completamente a forma normal de se
acessar os arquivos DBF, já que muitas vezes é inclusive aconselhável seu uso.
Para criá-lo, só necessita utilizar o comando DATABASE depois de abrir a base de dados.
Local oDbf
USE “Alunos”
DATABASE oDbf
O objeto oDBF terá como dados todos os campos desse arquivo, ou seja, se a base de dados
tiver um campo de nome CODIGO existirá também no arquivo DBF um campo com o
mesmo nome.
Quando for necessário que o objeto database carregue novos valores deveremos utilizar o
método :Load(). Podemos então modificar qualquer campo utilizando os dados do objeto e
gravar as alterações com o método :Save().
O objeto database resolve completamente este problema, já que não será mais necessário
criar variáveis locais para cada campo, só será necessário criar uma única variável local
para guardar o objeto database.
Infelizmente o objeto database tem uma limitação que é não poder manipular nomes de
campo com mais de 9 caracteres, já que internamente o CA-Clipper coloca uma imposição
sob qualquer dado de classe e estes não podem ter mais de 10 caracteres de comprimento.
De qualquer maneira, não é uma limitação muito importante.
Exercícios
1. Faça um programa que contenha um browse do arquivo Alunos.dbf e um botão
para editar o registro atual utilizando um objeto database, ao terminar a edição o
browse deverá refletir as alterações efetuadas.
2. Modifique o programa anterior para que funcione em rede local.
3. Faça um programa que abra duas janelas de uma vez, uma com o browse e outra
com os dados do registro atual e que ao mover o browse automaticamente seja
atualizada a janela de registro. (utilizar um objeto database para a janela de
registro) .
O DEBUGGER DO FIVEWIN
Utilização do debugger
FiveWin oferece seu próprio debugger ou depurador. Para usa-lo, só temos que incluir o
flag /b ao compilar os programas e ao executar a aplicação o debugger aparecerá
automaticamente no vídeo.
É muito mais difícil depurar uma aplicação sob Windows que sob MSDOS, já que é
impossível parar a atividade que o Windows realiza para interagir com o usuário. Por
exemplo, cada vez que movemos o mouse o Windows manda mensagens a aplicação
indicando o movimento e a aplicação deve processar estas mensagens.
De qualquer maneira, o depurador do FiveWin não é de muita utilidade já que lhe falta
muita operacionalidade. Por isso, recomendamos utilizar a função MsgInfo() nas partes
do programa onde seja necessário um “Watch-point”. Esta solução é muito válida, já que
o processo compilar-linkar do FiveWin com Blinker é muito rápido.
Cada vez que um erro é produzido no FiveWin, um arquivo de nome Erro.log é gerado, no
qual se mostra uma grande quantidade de informação.
Exercícios
1. Faça um programa com o debugger e inspecione o objeto janela alterando seus
títulos e, além disso, execute um break-point ao fechar a janela.
PROGRAMAÇÃO AVANÇADA
Refresh do sistema
Ao realizar processos que ocupem uma grande quantidade de tempo, como por exemplo
rastrear uma informação em uma grande base de dados, devemos levar em conta que o
Windows não poderá atualizar todo o sistema até que o processo termine. Por exemplo, se
existisse um relógio no vídeo, este ficaria completamente parado até que a busca
terminasse.
Para resolver este problema, o FiveWin incorpora uma função “SysRefresh()” que pode ser
chamada tantas vezes quantas forem necessárias e que permitirá atualizar o sistema ao
executar processos longos:
DO WHILE !Eof()
....
SysRefresh()
...
SKIP
ENDDO
Na realidade, uma janela MDI é como o ambiente do Windows, porém para a sua
aplicação.
Para entender como funciona uma janela MDI temos que saber que na realidade existe uma
janela invisível que é a janela cliente, ou seja, em um ambiente MDI existem três classes de
janelas:
Criar janelas MDI é realmente uma trabalho simples, o realmente complicado é levar em
conta que nos encontramos em um ambiente não-modal puro e portanto devemos manipula-
lo com muita precaução. Por exemplo, se uma janela filha tem um arquivo de texto e outra
um arquivo DBF quando selecionarmos a opção imprimir que possa existir no menu
principal nosso programa deverá saber qual janela é a que está ativa quando se seleciona a
ação de menu e atuar de acordo. Da mesma forma, se não existe nenhuma janela filha, a
opção de menu imprimir deveria estar desabilitada. Enfim, um ambiente MDI supõe mais
trabalho para o programador para controlar todas as possíveis situações que podem ser
produzidas num ambiente não-modal. Por todo isso recomendamos que só sejam
produzidos ambientes MDI quando todas as janelas filhas que serão abertas sejam do
mesmo tipo, como por exemplo, de tratamento de textos. Em um ambiente MDI pode-se
disparar uma determinada opção com uma caixa de diálogo e não uma janela filha.
Recomendamos que não comece a utilizar janelas MDI até que se encontre realmente
prático com o FiveWin.
FiveWin permite indicar um menu diferente para cada janela filha criada, porém,
sinceramente não recomendamos que o faça já que consome uma grande quantidade de
recursos do Windows e, além disso, os atalhos de menu deixam de funcionar enquanto haja
algum duplicado. Porém, se quer fazer um bom projeto, deverá criar um menu para
quando no haja nenhuma janela filha e outro menu quando elas existirem. Tenha em
mente que ao alternar de janela filha, o menu deverá ser atualizado, o que pode ser um
grande trabalho.
A única diferença ao criar uma janela MDI é que deverá incluir a cláusula MDI ao utilizar o
comando de criação da janela.
DEFINE WINDOW <oWnd> ;
[ FROM <nTop>, <nLeft> TO <nBottom>, <nRight> ] ;
[ TITLE <cTitle> ] ;
[ STYLE <nStyle> ] ;
[ MENU <oMenu> ] ;
[ BRUSH <oBrush> ] ;
[ ICON <oIcon> ] ;
[ MDI ] ;
[ COLOR | COLORS <nClrFore> [,<nClrBack>] ] ;
[ VSCROLL | VERTICAL SCROLL ] ;
[ HSCROLL | HORIZONTAL SCROLL ] ;
[ MENUINFO <nMenuInfo> ] ;
[ NONE | SINGLE ] ;
[ OF <oParent> ]
Uma cláusula que só as janelas MDI (frame) possuem é MENUINFO. Normalmente todas
as janelas MDI devem ter incorporado como opção de menu a possibilidade de colocar as
janelas em cascada, lado a lado, iconizá-las ou selecionar uma delas a partir de menu. Com
esta cláusula indicaremos em qual número do menu principal queremos adicionar as novas
opções. A medida que as janelas vão abrindo ou fechando, a opção de menu selecionada
refletirá as alterações.
Para criar cada uma das janelas filhas temos que adicionar a cláusula MDICHILD e indicar
qual é sua janela armazenadora com a instrução OF:
DEFINE WINDOW [<oWnd>] ;
[ MDICHILD ] ;
[ FROM <nTop>, <nLeft> TO <nBottom>, <nRight> ] ;
[ TITLE <cTitle> ] ;
[ BRUSH <oBrush> ] ;
[ CURSOR <oCursor> ] ;
[ MENU <oMenu> ] ;
[ ICON <oIco> ] ;
[ OF <oParent> ] ;
[ VSCROLL ] ;
[ HSCROLL ] ;
[ COLOR | COLORS <nClrFore> [,<nClrBack>] ] ;
[ PIXO ]
As janelas filhas não podem ter um menu próprio, porém, podem ter uma barra de botões.
Uma janela filha poderá ter um browse ou um get multi-line e, além disso, ao ser
redimensionada, queremos que se redimensione o browse ou o get. Para isso existe um
método na classe tMdiChild que é :SetControl()
@ 0,0 GET oControl... MEMO OF oWndChild
o
@ 0,0 LISTBOX oControl BROWSE ... OF oWndChild
oWndChild:SetControl( oControl )
Menus flutuantes
Como seu nome indica um menu flutuante é um menu que pode aparecer em qualquer lugar
de uma janela.
Para criar um menu flutuante temos que indicar a cláusula POPUP da seguinte forma
MENU oMenu POPUP
MENUITEM ...
MENUITEM ...
ENDMENU
ACTIVATE POPUP oMenu OF oDlg AT nRow, nCol
Function Main()
Return NIL
Isso não funciona porque nRow e nCol tem as coordenadas relativas à janela e o menu pop-
up utiliza as coordenadas do vídeo (Windows desktop) ,assim sendo, temos que fazer uma
pequena conversão de coordenadas de janela para coordenadas de vídeo:
local aCoors := {nRow, nCol}
...
ClientToScreen(::oWnd:hWnd, aCoors)
...
ACTIVATE POPUP oMenu OF oWnd AT aCoors[1], aCoors[2]
Os Brushes
Os brushes são objetos gráficos que automaticamente preenchem a superfície de outro
objeto.
Podemos criar brushes de uma determinada cor, com um estilo que corresponda a uma
textura já definida e, inclusive com base em um arquivo bitmap.
Seu uso consiste em primeiro defini-lo e depois inclui-lo na definição da janela ou diálogo.
Existe uma grande variedade de estilos predefinidos com os quais pode-se experimentar:
• Diagonal
• Horizontal
• Vertical
• Fdiagonal
• Bdiagonal
• Cross
• Diagcross
• Borland
• Tiled
• Bricks
O Clipboard
O clipboard é um buffer onde se guarda informação que pode ser acessada por todas as
aplicações do Windows .
FiveWin tem uma classe para acessar ao Clipboard que facilita bastante o seu uso. Uma
das limitações do FiveWin é que ele só é capaz de manipular informação de tipo texto.
Uma vez definido poderemos utilizar os métodos desta classe para produzir todas as
operações necessárias, que são:
Arquivos INI
Os arquivos INI são arquivos de texto que o Windows utiliza como arquivos de
configuração de forma extensiva e que, além disso, permite que qualquer aplicação crie
seus próprios arquivos INI ou modifique os próprios do Windows.
Como certamente deve saber, o Windows utiliza um arquivo INI para guardar sua
configuração que é o arquivo Win.Ini que se encontra no diretório do Windows.
Os arquivos INI estão divididos em seções e dentro de cada seção se incluem chaves
seguidas pelo sinal de igual e pelo dado que deve ser guardado nesta chave.
// Arquivo WIN.INI
[Intl]
sLanguage=por
Neste exemplo a seção Internacional de nome abreviado “Intl” tem uma chave que é
“sLanguage” cujo valor atual é “por”. Como pode-se imaginar, esta linha do arquivo
Win.Ini esta indicando o idioma selecionado na configuração do painel de controle para a
representação de números e datas.
Podemos observar que todo o trabalho que pode-se produzir com arquivos INI é carregar ou
gravar um determinado valor em uma chave dentro de uma seção específica.
FiveWin tem implementada uma classe tIni para manipular estes arquivos. Primeiramente
deverá abrir o arquivo desejado, se não for indicado nenhum nome é que quer acessar
diretamente o Win.Ini . Na continuação fazemos todas as operações que desejarmos e por
último fechamos o arquivo.
INI oIni FILE "Arquivo.ini"
GET cTitulo ;
SECTION "Principal" ;
ENTRY "Título" ;
OF oIni ;
DEFAULT "Título da janela"
DEFAULT
Outra característica fundamental é que o dado pode ser uma cadeia, um número, uma data
ou um valor lógico, o que evita ter que fazer alguma transformação nos dados.
Os arquivos INI podem ser de grande utilidade para guardar parâmetros de seu programa.
Timers
Os timers são temporizadores que permitem executar uma instrução cada certo tempo. Não
é aconselhável o uso indiscriminado dos mesmos e as tarefas que executam devem ser
muito rápidas e curtas.
Um timer é sempre associado a uma janela, ou seja, se se destrói a janela se destrói o timer.
Para criar um timer temos primeiro que defini-lo e posteriormente ativa-lo. Pode-se
desativa-lo com o comando Deactivate ou destrui-lo com o comando Release
DEFINE TIMER <oTimer> ;
[ INTERVAL <nInterval> ] ;
[ ACTION <uAction> ] ;
[ OF | WINDOW | DIALOG <oWnd> ]
...
ACTIVATE TIMER <oTimer>
...
DEACTIVATE TIMER <oTimer>
RELEASE TIMER <oTimer>
O intervalo dos timers se refere sempre em milésimos de segundo, ou seja, se indicado que
o intervalo é 1000 se produzirá a instrução indicada na cláusula ACTION a cada segundo.
Multimídia
FiveWin incorpora algumas capacidades multimídia como a possibilidade de reproduzir
arquivos de som e de vídeo.
Para reproduzir um arquivo de vídeo de extensão AVI FiveWin possui uma classe que é
tVideo com seus correspondentes comandos
@ 0,0 VIDEO oVideo FILE “MeuVideo.avi” SIZE 200,200 OF oWnd
@ 2,0 BUTTON “Play” OF oWnd ACTION oVideo:Play(1)
Para reproduzir sons e vídeo é necessário que o computador tenha capacidades multimídia.
Controles VBX
Os controles VBX são controles específicos de Visual Basic especializados na realização de
determinadas tarefas.
Estes controles se tornaram muito populares já que atualmente existem controles para
produzir um grande número de tarefas de uma forma muito prática. Por exemplo Visual
Basic tem um controle para visualizar bitmaps, outro para produzir círculos, etc. Esta
popularidade fez com que quase todas as linguagens de programação Windows tenham
suporte para sua utilização.
Porém, os dias dos controles VBX estão contados já que serão substituídos por novos
controles de nome OCX que só funcionarão em sistemas de 32 bits e serão baseados na
utilização de OLE de forma extensiva. De qualquer maneira, não parece que esse dia
esteja muito perto já que novos controles VBX continuam sendo criados por muitas
companhias.
Ha três níveis de controles VBX devido ao fato que ha três versões de Visual Basic no
mercado, FiveWin e quase todas as outras linguagens, inclusive o Visual C++ da Microsoft
só suportam o primeiro nível, pelo que ao comprar um controle VBX assegure-se que é de
nível 1. Quase todos os fabricantes de controles intentam ser de nível 1 já que assim seu
mercado potencial de venda é muito maior.
Grande quantidade dos controles Visual Basic já estão implementados diretamente pelo
FiveWin pelo que não será necessário usá-los.
Os controles VBX são armazenados em arquivos com a mesma extensão e para poder
utilizá-los em nossos programas é necessário entregar estes arquivos ao futuro usuário e
gravá-los em seu diretório \Windows\System.
Antes de trabalhar com qualquer VBX é importante que tenha a documentação do mesmo
já que se não a tiver, é muito provável que seja incapaz de faze-lo funcionar corretamente.
Como pode observar sua sintaxe é muito parecida à de qualquer controle porém com uma
serie de diferenças:
Alguns controles não funcionam bem dentro de uma janela e só funcionam em caixas de
diálogo. Sempre que utilizar um controle VBX em uma caixa de diálogo utilize um editor
de recursos porque isso evitará uma grande quantidade de problemas.
ODBC
ODBC é o padrão proposto pela Microsoft para acessar bases de dados a partir de
aplicações Windows. ODBC é para o Windows o que o RDD é para o CA-Clipper.
CA-Clipper RDD é uma arquitetura aberta para utilizar uma multiplicidade de drivers que
acessam bases de dados. ODBC é uma arquitetura aberta para utilizar em todas as
aplicações Windows.
De a mesma maneira que CA-Clipper tem um mecanismo interno para a manipulação dos
RDD, o Windows possui seu próprio mecanismo cujo nome é Odbc.dll o qual permite que
qualquer driver ODBC se comunique com ele, fazendo que para o programador só exista
um único driver, ou seja, o mesmo código independentemente do sistema de arquivos que
se utilize, inclusive acesso a dados através de servidores SQL.
ODBC impõe suas próprias regras de utilização pelo que terá que ajustar-se às mesmas. Se
está familiarizado com linguagens SQL não será muito difícil, porém, se só tiver
experi6encia programando com bases de dados navegacionais (Cobol, dBase, Paradox) o
processo de aprendizagem pode ser acentuado já que deverá aprender SQL.
ODBC não é a panacéia. Só temos que comparar a rapidez de qualquer driver RDD do
CA-Clipper com o driver de manipulação de arquivos DBF proporcionado pela Microsoft
em Visual Basic ou Access. Realmente as diferenças são tremendas, não obstante está
claro que ODBC é o futuro e que com o tempo os drivers para ODBC serão melhores e as
máquinas mais potentes.
FiveWin + ODBC permite fazer algo que até agora era impossível que é acessar servidores
SQL sob ambiente cliente-servidor, já que da mesma forma que seu programa é capaz de
acessar dados locais com um driver ODBC para arquivos Dbase, só temos que modificar o
driver para indicar que agora os dados serão encontrados em um servidor UNIX com um
mecanismo SQL de Oracle por exemplo.
Se os sistemas que você vai desenvolver vão ser utilizados em empresas médias ou grandes,
recomendamos que comece já a desenvolver sob ODBC. Em qualquer outro caso utilize
os RDD do CA-Clipper.
FiveWin utiliza uma classe para acessar qualquer base de dados via ODBC que é a classe
tDbOdbc na qual estão implementados comandos principalmente um para criar uma
conecção ODBC e outro para estabelecer as consultas.
Para fazer uma transição mais simples a partir de arquivos Dbase para ODBC, FiveWin
implementou a classe ODBC de forma que prossigamos utilizando o mesmo esquema
dBase para acessar os dados.
Para utilizar ODBC a partir de qualquer aplicação Windows deve-se assegurar que todos os
usuários que vão utilizar a aplicação tenham carregado em seu computador o driver ODBC
e que além disso este esteja configurado corretamente. ODBC necessita saber a priori que
bases de dados serão utilizadas via ODBC e que drivers vão utilizar, pelo que deve-se
configura-lo em cada uma das máquinas.
Para estabelecer uma conecção ODBC deveremos incluir no arquivo .Prg a instrução
#include “sql.ch”
A cláusula NAME é o nome da base de dados a utilizar e que corresponde com o nome que
consta na configuração do ODBC e não com o nome de nenhum arquivo DBF. Uma única
conecção ODBC pode acessar múltiplos arquivos DBF, assim sendo, quando configuramos
ODBC devemos indicar que arquivos serão acessados através de um determinado NAME.
As cláusulas User e Password são utilizadas em algumas conexões ODBC e nem sempre
são necessárias.
Se ocorrer algum erro na conecção, podemos verificar com o dado :nRetCode do objeto
oDbc que terá um valor diferente de zero.
Uma vez estabelecida a conecção, poderemos produzir qualquer consulta com o comando
ODBC oDbc EXECUTE cCommand
O cCommand é uma cadeia com qualquer instrução SQL que seja suportada pelo driver
utilizado, como por exemplo:
ODBDC oDbc EXECUTE “SELECT * FROM CLIENTES”
Temos notado que este comando não funciona ao menos na última versão do FiveWin e
que foi implementada uma classe nova de nome OdbcStmt que se encarrega de fazer as
conexões físicas e manter a informação de cada consulta que se faça ao objeto oDbc. Este
novo objeto se encarrega de estabelecer a conecção física com o driver ODBC da seguinte
forma:
oStmt := OdbcStmt:New(oDbc)
da mesma forma deveremos verificar o dado oSmt:nRetcode para ver se a conecção foi
correta.
Uma vez estabelecida a conecção pode-se utilizar o método :Execute() para produzir
qualquer consulta. No caso de uma instrução ‘SELECT’ o objeto oStmt terá toda a
informação do Cursor. Um cursor em SQL é um handle a uma tabela temporária criada
através da instrução SELECT, com a instrução Fetch obtemos em SQL todas as colunas da
tabela temporária. Para mais informação consulte qualquer livro sobre SQL.
Manipulação de DLLs
A partir do FiveWin podemos acessar qualquer biblioteca de ligação dinâmica para utiliza-
la em seus próprios programas.
Para poder utilizar qualquer função que se encontre em uma DLL devemos primeiramente
defini-la com o seguinte comando
DLL [STATIC] FUNCTION <FunName>( ;
[ <Param1> AS <Type> ] ;
[ <ParamN> AS <Type> ] ) ;
AS <return> [PASCAL] LIB <DllName>
este comando deverá ser incluído no princípio ou final de seu .Prg e nunca dentro de uma
função o procedimento.
FunName é o nome da função, recorde que não pode ter mais de 10 caracteres, Paramx
indica o nome dos parâmetros que a função receberá e type indica o tipo destes parâmetros
que pode ser:
Return indica o tipo de dado que a função devolverá. Os valores podem ser os mesmos
que o tipo.
Por último, a cláusula Pascal indica se a função acessada utiliza convenção Pascal o não,
normalmente todas as funções da API do Windows utilizam convenção Pascal. (quando em
C uma função é definida como tipo Pascal ela não distingue entre maiúsculas nem
minúsculas e além disso não coloca o underscore no princípio da função).
Se sua aplicação faz uso extensivo de funções que se encontrem em uma DLL é preferível
produzir um pequeno módulo em C para acessar as mesmas já que a velocidade aumenta
consideravelmente. No capítulo de conecção com a API será mostrada a forma de faze-lo.
Para poder estabelecer a comunicação com um servidor DDE é necessário conhecer todos
os verbos que esse servidor admite e embora pareça mentira muito poucos fabricantes de
software fornecem informação exaustiva sobre DDE. Por exemplo, a documentação que
acompanha o SDK do Windows só oferece informação DDE do gerenciador de programas
(Progman.exe).
Tenha em mente que DDE tem limitações e exige que ambas aplicações estejam carregadas
na memória.
FiveWin incorpora uma classe e um conjunto de comandos para produzir ligações DDE.
A cláusula Service indica a aplicação que vai atuar como DDE server, devemos ter a
precaução de que esta aplicação esteja carregada utilizando a função WinExec()
#DEFINE SW_MINNOACTIVE 7
...
nStatus := WinExec(“Server.Exe”,SW_MINNOACTIVE)
IF nStatus < 32 .and. nStatus != 16
MsgStop(“Erro - não foi possível disparar Server.exe”)
QUIT
ENDIF
As cláusulas Topic e Item são opcionais e seu uso depende do servidor DDE o requerer.
A cláusula Valid é utilizada para produzir qualquer operação ao finalizar a conecção DDE.
Existem no mercado produtos muito bons para desenhar arquivos de help, dos quais se
podem destacar dois deles, o primeiro e mais espetacular é Visual Help da WinWare Inc.
(CIS: 70272,1656) o qual tem um ambiente visual muito atrativo, e o segundo é o Quick
and dirty help de Phil Allen software. Ambos produtos são shareware e podem ser
encontrados em vários BBS e CD-Roms. Existem produtos mais profissionais porém
cremos que para a maioria dos programadores são excessivamente complexos e de uma
dificuldade desnecessária.
FiveWin incorpora uma série de funções para acessar helps do Windows, no princípio de
sua aplicação deverá designar qual é seu arquivo de help com a instrução
SET HELP TO “Ajuda.hlp”
Uma vez realizada esta instrução poderá utilizar uma série de funções para invocá-lo, as
mais importantes são as seguintes:
Quase todos os programas que implementam ‘Helps’ para Windows criam um arquivo de
cabeçalho com os defines de todos os tópicos existentes cuja extensão costuma ser .hhh,
pelo que só terá que fazer um INCLUDE desse arquivo em seus arquivos .PRG e ao indicar
o identificador de help não utilize o número e sim o símbolo descritor do mesmo no arquivo
.HHH que é o mesmo utilizado com a ferramenta de geração de helps.
Se deseja incluir um botão de help para um diálogo na cláusula ACTION desse botão
ponha só
oDlg:HelpTopic()
Exercícios
1. Faça um programa que abra uma base de dados qualquer com um browse sob um
ambiente MDI com uma opção de menu para imprimi-la.
2. Faça uma janela que quando pressionar o botão direito mostre um menu Pop-up
com as opções Um, dois e três
3. Coloque um brush qualquer no programa produzido anteriormente
4. Faça uma caixa de dialogo com um get e dois botões, um para fazer um copy do
dado do Get ao Clipboard e outro que faça um “Paste” do clipboard ao Get.
5. Faça um programa que guarde em um arquivo INI o Título da janela e suas
coordenadas ao abandonar a aplicação.
6. Faça um janela que mostre a hora atual utilizando um timer
7. Crie uma caixa de diálogo na qual se utilize o controle Switch.Vbx.
8. Faça um programa que crie um novo grupo no gerenciador de programas de nome
Prova e com um elemento que execute o Notepad com o arquivo “Autoexec.bat”.
Como pode-se observar até agora temos utilizado uma vasta gama de objetos novos que não
existem normalmente em CA-Clipper e que logicamente foram criados pelo FiveWin.
A grande vantagem que o FiveWin oferece é que, além disso, você pode criar suas próprias
classes, herdar das já existentes e inclusive modificar as atuais já que FiveWin oferece
todos os fontes das classes que utiliza.
Até o momento não construímos nenhuma classe nova nem modificamos nenhum dado ou
método de nenhuma já que não foi necessário. Porém seria uma lástima não aproveitar
em benefício próprio as possibilidades que a OOPS nos oferece. Quando tiver prática
com a programação orientada a objetos se perguntará como alguma vez pôde programar
sem ela.
Hierarquia de classes
No que concerne à manipulação de janelas, o FiveWin utiliza uma classe base tWindow
que é herdada pelo resto das janelas e diálogos e uma classe intermediária de nome tControl
que por sua vez é herdada por todos os controles. Do resto das classes, quase nenhuma
tem classe superior.
TDDE Dynamic Data Exchange
Se for necessário modificar um dado de uma classe, podemos fazê-lo, porém devemos
saber muito bem o que estamos fazendo. O FiveWin utiliza os comandos para ocultar
precisamente a complexidade de algumas construções de objetos que recebem uma grande
quantidade de parâmetros. Porém há dados que sem dúvida teremos que modificar
quando começarmos a programar com FiveWin. Por exemplo, se desejarmos modificar o
valor de um controle Get deveremos utilizar o método cText() desta classe, podemos
modificar os dados e a seguir utilizar o método Refresh() porém recomendamos que antes
de modificar qualquer dado de uma classe certifique-se de que não há nenhum método para
produzir esta tarefa já que possivelmente ao alterar o dado seja feito algo mais que
possivelmente você não tenha percebido ou desconheça. Por exemplo, a classe Listbox
tem um dado que são os itens desse listbox que são guardados em uma matriz. Você pode
adicionar elementos à matriz porém possivelmente produza um erro de execução. Observe
como, além disso, a classe Listbox possui um método de nome AddItem() que, logicamente
deverá ser utilizado para adicionar novos elementos.
É importante que analise todos os dados e métodos de cada classe que queira manipular,
seu arquitetura é muito simples e em pouco tempo será capaz de tirar o máximo proveito
do FiveWin acessando diretamente os métodos e dados de cada classe.
Quando uma classe é herdada de outra superior esta classe tem seus próprios dados e além
disso os de suas classes superiores, e o mesmo ocorrerá com os métodos. Quando um
método de uma classe coincidir com outro de sua classe superior sempre tem precedência o
método da classe filha, porém, podemos fazer que a partir do método da classe filha se
execute também o método da classe mãe como veremos mais adiante. Por exemplo,
podemos criar um objeto janela herdado da classe tWindow que só verifique se a tecla F4
foi pressionada e, caso contrario, que seja sua classe superior a que processa o
pressionamento de teclado.
Pode-se criar todas as classes que se desejar, porém, só uma por .PRG. Para criar uma
nova classe esta é a sintaxe que deve utilizar:
NovaClasse é o nome da nova classe que vamos criar. Seu nome não pode exceder 10
caracteres.
NomeDadox é o nome de cada um dos dados que a classe vai Ter. Pode-se colocar tantos
nomes quantos forem necessários, separando-os por vírgulas ou colocando várias sentenças
DATA.
NomeMetodox é o nome de cada um dos métodos que a classe vai ter. Pode-se colocar
tantos métodos quantos forem necessários com várias sentenças METHOD.
Os métodos que não são em linha devem ser codificados na seqüência da definição da
classe. Para codificá-los se utiliza a seguinte sintaxe:
METHOD <NomeMetodo>( [<params,...>] ) CLASS <Classe>
....
....
return
para que ao terminar de executar seu próprio método se execute o de sua classe mãe
faríamos:
METHOD KeyDown(nKey) CLASS Janela
...
IF nKey == KEY_F4
RETURN ...
ENDIF
RETURN Super:KeyDown(nKey)
Exercícios
1. Faça um programa que mostre numa janela constantemente a posição do cursor do
mouse.
2. Crie uma nova classe de nome retângulo com os dados largura e altura e com o
método constructor New e o método área
3. Crie um método para a classe Get de forma que inverta o sentido de suas letras, ou
seja, se no Get há ao valor “123” ao executar o método :Inverter() passará a valer
“321”.
Como Conectar?
A princípio, o FiveWin incorpora uma série de funções para conectar com a API que você
pode utilizar dentro de seus programas. Não tem implementadas todas, porém como verá
em seguida, é muito fácil implementar aquelas que necessite.
Conectar com a API do Windows a partir de sua aplicação é uma tarefa muito simples, só é
necessário um pequeno conhecimento de programação em C, mas não demasiado.
A primeira coisa que deve-se Ter em mente é que o CA-Clipper utiliza seu próprio sistema
de Stack para as variáveis e portanto não pode-se passar parâmetros diretamente a partir do
CA-Clipper a uma função em C e tampouco poderá esta função em C devolver parâmetros
ao CA-Clipper. Para resolver este problema o CA-Clipper proporciona o que eles chamam
“Extended system of CA-Clipper”, que consiste em funções _par...() para recuperar a partir
de C parâmetros passados a partir do CA-Clipper e funções _ret...() para devolver valores a
partir de C para o CA-Clipper.
Para compilar sua pequena função em C pode utilizar qualquer compilador porém deverá
utilizar o modelo largo de memória e indicar ao compilador que não linque, para isso se
utilizam por exemplo a partir da Borland C++ os flags: -c -ml
FiveWin incorpora todos os fontes de conecção com a API onde poderá observar o quão
simples é.
Um programa em C
Por exemplo a função que nos permite reproduzir um arquivo .wav seria da seguinte forma:
#include <WinTen.h>
#include <Windows.h>
#include <MMSystem.h>
#include <ClipApi.h>
//--------------------------------------------------------//
//--------------------------------------------------------//
Se desejar obter mais informação recomendamos que analise todos os fontes que
acompanham o FiveWin no diretório \Fw\Source\Winapi e consultar a documentação
oferecida pelo CA-Clipper sobre seu “Extended System”.
Exercícios
1. Faça uma função em C que devolva o diretório do Windows.