FiveWin - Manual Em Portugus

CA-CLIPPER + FIVEWIN

Curso de Iniciação

A documentação entregue neste curso é propriedade de Ortiz de Zíñiga, S.L.

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.

1997 Ortiz de Zíñiga, S.L. Reservados todos os direitos

Tradução para o português do Brasil por Maurício Ventura FariaJaneiro de 2001

INTRODUÇÃO.....................................................................................................................1

O QUE É FIVEWIN?.................................................................................................................1COMPILAR................................................................................................................................2LINKAR....................................................................................................................................2ARQUITETURA..........................................................................................................................2UTILITÁRIOS NECESSÁRIOS............................................................................................3COMO ORGANIZAR SEU TRABALHO COM WINDOWS................................................................3INSTALAÇÃO DO FIVEWIN.......................................................................................................4COMPATIBILIDADE COM FIVEWIN...........................................................................................4EXERCÍCIOS..............................................................................................................................5

ELEMENTOS FUNDAMENTAIS DE UMA APLICAÇÃO DE GESTÃO EM WINDOWS............................................................................................................................7

JANELA PRINCIPAL...................................................................................................................7MENUS...................................................................................................................................10BARRA DE BOTÕES.................................................................................................................11BARRA DE MENSAGENS:........................................................................................................12CAIXAS DE DIÁLOGO.............................................................................................................12NOSSO PRIMEIRO PROGRAMA COM FIVEWIN........................................................................13EXERCÍCIOS............................................................................................................................14

CONTROLES DO WINDOWS.........................................................................................15

O QUE SÃO OS CONTROLES....................................................................................................15TIPOS DE CONTROLES............................................................................................................18

Botões...............................................................................................................................18Barras de rolagem............................................................................................................18List boxes..........................................................................................................................19Group boxes......................................................................................................................19Gets (Edit text)..................................................................................................................19Says (Text)........................................................................................................................19Boxes.................................................................................................................................20Radio buttons....................................................................................................................20Check boxes......................................................................................................................20Combo boxes....................................................................................................................20

CONTROLES AVANÇADOS......................................................................................................21Browses.............................................................................................................................21Meters...............................................................................................................................23Bitmap (Control)..............................................................................................................24Botão Bar (Button bar).....................................................................................................24Uso de BWCC.DLL..........................................................................................................25

EXERCÍCIOS............................................................................................................................26

RECURSOS DO WINDOWS............................................................................................27

O QUE SÃO OS RECURSOS ?....................................................................................................27RC OU DLL?.........................................................................................................................28TIPOS DE RECURSOS...............................................................................................................29

Diálogos...........................................................................................................................29Menus...............................................................................................................................29Atalhos..............................................................................................................................29Matrizes de Cadeias de Caracteres (String Tables).........................................................29Bitmaps.............................................................................................................................29Ícones................................................................................................................................30

Cursores...........................................................................................................................30Fontes...............................................................................................................................31

RESOURCE WORKSHOP..........................................................................................................31Caixas de Diálogo............................................................................................................33Trabalhando com controles..............................................................................................33Tab Stop............................................................................................................................33Agrupando controles........................................................................................................33Ordem dos controles.........................................................................................................34Ferramentas de alinhamento e ajuste de tamanho...........................................................34Experimentando uma caixa de diálogo............................................................................34Controles criados pelo usuário........................................................................................34Bitmaps, Ícones e cursores...............................................................................................35

EXERCÍCIOS............................................................................................................................35

IMPRESSÃO EM FIVEWIN.............................................................................................37

IMPRESSÃO EM MICROSOFT WINDOWS.................................................................................37O GERADOR DE RELATÓRIOS.................................................................................................38EXERCÍCIOS............................................................................................................................42

MANIPULAÇÃO DE BASES DE DADOS......................................................................43

MUDANÇAS NA PROGRAMAÇÃO............................................................................................43O OBJETO DATABASE............................................................................................................43EXERCÍCIOS............................................................................................................................44

O DEBUGGER DO FIVEWIN..........................................................................................45

UTILIZAÇÃO DO DEBUGGER...................................................................................................45EXERCÍCIOS............................................................................................................................45

PROGRAMAÇÃO AVANÇADA......................................................................................47

REFRESH DO SISTEMA............................................................................................................47MANIPULAÇÃO DE JANELAS MDI..........................................................................................47MENUS FLUTUANTES.............................................................................................................49OS BRUSHES..........................................................................................................................50O CLIPBOARD........................................................................................................................50ARQUIVOS INI.......................................................................................................................51TIMERS...................................................................................................................................51MULTIMÍDIA..........................................................................................................................52CONTROLES VBX..................................................................................................................52ODBC....................................................................................................................................54MANIPULAÇÃO DE DLLS.......................................................................................................56DYNAMIC DATA EXCHANGE (DDE)......................................................................................57MANIPULAÇÃO DE ARQUIVOS DE HELP.................................................................................58EXERCÍCIOS............................................................................................................................59

OBJECTS: MECANISMO OOPS DO FIVEWIN...........................................................61

HIERARQUIA DE CLASSES......................................................................................................61ACESSO AOS DADOS E MÉTODOS...........................................................................................62CRIAÇÃO DE NOVAS CLASSES................................................................................................63EXERCÍCIOS............................................................................................................................64

CONEXÃO COM A API DO WINDOWS.......................................................................65

COMO CONECTAR?................................................................................................................65

UM PROGRAMA EM C.............................................................................................................66EXERCÍCIOS............................................................................................................................66

Curso CA-Clipper + FiveWin

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:

Ambiente MDI (Multiple Document Interface) Menus pop-up

Barras de Botões Bitmaps (Imagens) Fontes True Type Cursores Ícones Caixas de diálogo Acesso a DLL Controles VBX Clipboard Enlaces DDE Arquivos INI Metafiles Meters Brushes Som (Arquivos WAV, MID) Vídeo (AVI) ODBC

Ademais FiveWin incorpora a classe TWBrowse para poder produzir browse sob Windows e a classe TReport para produzir qualquer relatório.

Ortiz de Zíñiga, S.L. 11


Compilar

Para compilar uma aplicação produzida com FiveWin compile como fazia normalmente:

CLIPPER Teste /n/w

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

A LIB 501_502 só é necessária se for utilizar Microsoft LINK.É necessário um linker para aplicações Windows, o qual não é fornecido com o CA-Clipper pelo que deverá adquiri-lo a parte. Pode-se utilizar o linker da Microsoft LINK.EXE versão 5.3 ou posterior, ou Blinker 3.0 ou posterior sendo este último o mais recomendado.

Sintaxe para Microsoft LINK: Link //se:700 //NOE <Aplicação>,,nul, FiveWin WinApi ;

Clipper501_520,..\include\FiveWin.def

Sintaxe para Blinker 3.0:

Blinker fi Aplicação @FiveWin.lnk

O arquivo Fivewin.lnk vem incorporado ao FiveWin.

Arquitetura

A arquitetura do FiveWin está baseada nos seguintes níveis:

1 Comandos xBase2 Classes e objetos3 Funções4 Windows API

Utilizando os comandos xBase poderemos rapidamente produzir nossos primeiros programas. Quando necessitar um pouco mais de controle terá que descer um pouco mais de nível, tenha em mente que quanto mais baixo nível mais controle porém diminui sua produtividade.

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.

As Classes incorporadas ao FiveWin para o desenvolvimento de aplicações Windows faz com que não seja necessário em quase nenhum caso ter que se aprofundar até o último nível da API do Windows, porém, se o desejar poderá acessá-lo sem problemas.

UTILITÁRIOS NECESSÁRIOS

Além do FiveWin e CA-Clipper serão necessárias uma série de utilitários:

linker para Windows compilador de recursos Gerador visual de recursos (Resource Workshop da Borland)

O linker de recursos é necessário já que o fornecido com o CA-Clipper não é capaz de produzir executáveis para Windows.

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.

Também é recomendado mas não imprescindível a obtenção de um compilador de ‘Helps’ se desejar produzir ‘Helps’ sob Windows e documentação sobre a API do Windows em formato Help da Microsoft para sua consulta quando queiramos acessar a API.

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.

Como organizar seu trabalho com Windows

Os programas que você vai produzir com FiveWin serão autênticos executáveis tipo Windows, porém a maioria das ferramentas que vai utilizar são tipo DOS, como o compilador do CA-Clipper, o linker Blinker 3.0 e provavelmente seu editor de programação favorito.

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:

Crie um grupo novo no Gerenciador de programas no qual incluirá todas as aplicações que esteja desenvolvendo.

Execute seu editor a partir de uma janela DOS para isso deverá carregar o editor através de um arquivo PIF indicando no mesmo que será executado em uma janela DOS.



Se não puder executar o compilador e o linker a partir de seu editor crie um novo ícone de programa no gerenciador de programas para executar o compilador e o linker a partir do Windows.

De qualquer maneira, para desenvolver comodamente a partir do Windows é praticamente necessário um computador 486 com 4Mb de RAM.

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

Por padrão FiveWin é instalado no diretório do CA-Clipper, porém pode-se modifica-lo se o desejar.

É preferível que cada vez que instale FiveWin o faça em um diretório diferente, e experimente a nova versão antes de destruir a já existente.

Leia a informação contida no arquivo Whatsnew.txt para conhecer as últimas melhorias produzidas no FiveWin assim como os possíveis erros corrigidos.

Se você possui a versão protegida por contra-senha (como é o caso da versão existente na Espanha) será necessário registrar sua versão do FiveWin, para isso deverá pedir a seu distribuidor que proporcione uma chave de registro. Antes de registrar-se certifique-se de que tem somente uma versão do Fivewin.lib que é a que quer registrar.

É possível que seja necessário modificar o arquivo Samples\Build.bat para acomoda-lo aos ‘paths’ e ‘sets’ de seu computador.

Se a instalação realizou-se corretamente vá ao diretório Samples e tente criar sua primeira aplicação realizando a seguinte instrução:

SAMPLES\Build Tutor01

Será criado um programa de nome Tutor01.Exe que funciona realmente em Windows. Vá ao Windows e tente executá-lo.

Compatibilidade com FiveWin

Quando falamos de compatibilidade temos que distinguir entre compatibilidade com FiveWin e compatibilidade com Windows, a principio se uma LIB é compatível com Windows também é compatível com FiveWin, para que uma LIB seja compatível com



Windows tem que rodar em modo protegido e além disso não deve acessar o hardware diretamente nem deve utilizar o vídeo já que é domínio exclusivo do Windows e para tanto deve-se utilizar os serviços que o Windows proporciona para acessar estes recursos.

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.

Existem dois tipos diferentes de janela principal, que são:

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.

A sintaxe para criar uma janela no FiveWin é a seguinte:

#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.

Se desejar colocar a janela numa posição predefinida:

... FROM nAcima, nEsquerda TO nAbaixo, nDireita ...

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

Se desejar especificar outros estilos o FiveWin oferece as seguintes cláusulas:

NOSYSMENU NOCAPTION NOICONIZE NOZOOM



Também podemos especificar qualquer combinação delas utilizando diretamente os flags da API do Windows e utilizando a função nOr() do FiveWin:

... STYLE nOr( WS_BORDER, WS_MAXIMIZE, ... )

Os diferentes estilos possíveis podem ser encontrados no arquivo Include\Winapi.ch que é automaticamente carregado pelo FiveWin quando se carrega Fivewin.ch ou também no help on-line da API do Windows que pode ser encontrada em vários produtos comerciais de programação Windows ou na internet.

Se desejar que a janela principal seja uma janela MDI simplesmente especifique a cláusula ao criar a janela:

DEFINE WINDOW oWnd TITLE "A MDI environment" MDI

O FiveWin controla automaticamente todas as mensagens que a janela principal recebe e você só deve processar aquelas que lhe interessem utilizando uma linguagem de comandos simples que sempre começa pela cláusula ‘ON’, atribuídos quando a janela é ativada.

ACTIVATE WINDOW oWnd ;ON PAINT ... ;ON LEFT CLICK ... ;ON RESIZE ... ;

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.

DEFINE WINDOW oWnd ... VSCROLLoDEFINE WINDOW oWnd ... HSCROLLo as dosDEFINE WINDOW oWnd ... VSCROLL HSCROLL

Ao colocar barras de rolagem também será possível interceptar as mensagens ou eventos que elas recebem da mesma forma que o resto das cláusulas ‘ON ...’

ACTIVATE WINDOW oWnd ... ON UP ... ON DOWN ... ON LEFT ... ON RIGHT ... ON PAGEUP ... ON PAGEDOWN ...

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.

Para finalizar a execução da janela utilize o método ‘End’.



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:

ACTIVATE WINDOW oWnd ; VALID MsgYesNo( "Deseja Terminar?" )

Quando tentar fechar a janela a partir do menu de sistema ou pressionando Alt+F4 o programa mostrará uma caixa de diálogo na qual haverá dois botões “Sim” e “Não” com a mensagem “Deseja terminar?”, se pressionar “Sim” a função devolverá .T. e a janela será fechada, pelo contrario, se pressionar “Não” a função devolverá .F. e a janela no será fechada.

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.

A partir do menu o usuário pode acessar todos os processos do programa.

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 oMenuMENUITEM <cItem> MESSAGE <cMessage> ACTION <uAction>MENUITEM <cItem> MESSAGE <cMessage> MENU

MENUITEM <cItem> MESSAGE <cMessage> ACTION <uAction>ENDMENU...SEPARATORMENUITEM <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

MENUITEM <cItem> MESSAGE <cMessage>MENU MENUITEM <cItem> MESSAGE <cMessage> ACTION <uAction>

... ENDMENUMENUITEM <cItem> MESSAGE <cMessage> ACTION <uAction>

Para ativar o menu dever-se-á primeiro associa-lo a uma janela. A forma mais simples de faze-lo é:



DEFINE WINDOW <oWnd> <otherClauses> ; MENU BuildMenu()......Function BuildMenu()local oMenu

MENU oMenu MENUITEM <cItem> MESSAGE <cMessage> ... ... ENDMENUreturn oMenu

ou podemos produzi-lo quando a janela esteja criada com o comando:

SET MENU OF <oWnd> TO <oMenu>

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.

Existe a possibilidade de selecionar um aspecto 3D à barra de botões simplesmente adicionando a cláusula 3D na criação da mesma.

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:

#xcommand DEFINE BUTTONBAR [ <oBar> ] ; [ <size: SIZE, BUTTONSIZE, SIZEBUTTON > <nWidth>, <nHeight> ] ;

[ <_3d: 3D, 3DLOOK> ] ; [ <mode: TOP, LEFT, RIGHT, BOTTOM, FLOAT> ] ; [ <wnd: OF, WINDOW, DIALOG> <oWnd> ] ; [ CURSOR <oCursor> ] ;



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.

FiveWin suporta dois métodos de utilização de caixas de diálogo:

Construídas com código fonte A partir de recursos gerados com um editor de recursos para Windows

O segundo método é o mais aconselhável já que permite definir as caixas visualmente de uma forma muito rápida e intuitiva, para utilizar este método será necessário um editor de recursos como o Resource WorkShop da Borland, ou AppStudio da Microsoft ou o Resource Studio da Symantec.

No Windows as caixas de diálogo podem ser de duas categorias:

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:

DEFINE DIALOG oDlg ; [ FROM <nTop>, <nLeft> TO <nBottom>, <nRight> ] ; [ NAME <cName> ] ;



A cláusula ‘NAME’ indica o nome desse diálogo se criado através de um editor de recursos.

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.

@ <nRow>, <nCol> ... OF oDlg

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

REDEFINE ID ... OF oDlg

que será explicado em profundidade mais adiante.

Para ativar a caixa de diálogo utilize o comando ‘Activate’

ACTIVATE DIALOG oDlg

Nosso primeiro programa com FiveWin

Vamos produzir nosso primeiro programa com FiveWin que terá as seguintes características:

Janela principal tipo SDI Menu com uma única opção de fechar a janela Barra de mensagens mostrando nosso nome A mensagem típica no centro da janela “Meu primeiro programa com

FiveWin” Validação de abandono da aplicação mediante a caixa de diálogo

predefinida ‘MsgYesNo’

O código fonte deste pequeno programa pode ser encontrado no disquete com o nome:

tutor2\exemplo1.prg.

Será reproduzido aqui por comodidade.

#include “FiveWin.ch”

STATIC oWnd

FUNCTION Main()

DEFINE WINDOW oWnd TITLE “Meu primeiro programa FiveWin” ; MENU BuildMenu()



SET MESSAGE OF oWnd TO “Meu nome” CENTERED

ACTIVATE WINDOW oWnd VALID MsgYesNO(“Deseja sair?”)

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

O que são os controles

Os controles na realidade são janelas com características especiais para facilitar a entrada de dados e a comunicação da aplicação com o usuário. Dizemos que são janelas já que todos eles são objetos herdados da classe Janela (tWindow) mesmo que à primeira vista se parecem muito pouco, mas o importante a se levar em conta é que são objetos e que muitas de suas características são herança da classe genérica janela.

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.

Um atalho é um pressionamento de teclado que diretamente nos leva ao controle desejado. Para criar um atalho temos que definir no título ou caption do controle o símbolo ‘&’ diante da letra que queremos que atue como atalho e pressionando a tecla ‘Alt’ mais a letra indicada saltaremos diretamente ao controle. No caso dos controles botões quando pressionarmos o atalho se produzirá o pressionamento do mesmo. Deve-se ter a precaução de não definir o mesmo atalho a dois controles já que sempre se saltará ao primeiro deles. Ha botões que podem receber foco porém não tem nenhum título ou caption, pelo que a principio não é possível estabelecer nenhum atalho para os mesmos, porém isso é possível. O truque consiste em colocar o atalho no controle SAY que pode existir bem encima ou ao lado e indicar que esse controle SAY tem a propriedade de grupo. No próximo capítulo quando se estudar o Editor de Recursos será possível observar com maior clareza o funcionamento.

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.

Um controle pode estar habilitado (Enabled) ou desabilitado (Disabled), no primeiro caso poderemos dar foco a esse controle com o mouse ou pressionando o tabulador sucessivamente até chegar ao mesmo e no segundo caso o controle será mostrado normalmente em uma cor gris para indicar que não está disponível.

Neste capítulo encontraremos muitas alusões à possibilidade de criar controles a partir de “recursos” que possivelmente não compreenda como funcionam realmente, não se preocupe por que no próximo capítulo serão estudados em profundidade, simplesmente tenha em mente que um recurso é um arquivo externo onde se guarda parte do programa executável que são os dados, assim, por exemplo, a definição de uma caixa diálogo com todos os controles que incorpore podem ser definidos em um recurso e nosso arquivo executável não tem por que produzir a criação dos mesmos, a idéia fundamental que deve assimilar é que qualquer controle pode ser criado diretamente a partir de programa ou também redefinido a partir de um recurso externo criado com um editor de recursos.

Os controles podem ser criados diretamente ou também a partir de recursos, no primeiro caso devemos criar o controle utilizando comandos estilo xBase e indicando as características principais do mesmo como o são coordenadas, texto, etc.

@ <nRow>, <nCol> GET oGet VAR uVAr ;OF oDlg ;PICTURE “....” ;VALID .... ;WHEN .... ;....

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:

... CONTROL ... OF oDlg

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()

É possível controlar a dinâmica da introdução de dados através dos eventos produzidos em cada controle. Por exemplo, quando um controle recupera foco você pode indicar a execução de certa instrução simplesmente inicializando o dado ‘bGotFocus’ que é um code-block desse controle, ‘bGotFocus’ é um DADO da classe tControl que se for diferente de NIL é avaliado quando o controle recebe foco. Por exemplo, se queremos que soe um bip quando um controle recebe foco, faríamos o seguinte:

oControl:bGotFocus := {|| tone(100,2)}

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.



@ nRow, nCol CHECKBOX oChk VAR lData ; OF oDlg ; ON CLICK MinhaFuncao()

Se não fosse utilizada a cláusula ON CLICK poderíamos fazer o seguinte:

oChk:bClicked := {|| MiFuncion()}

e o resultado seria o mesmo.

Tipos de controles

O Windows implementa de maneira padrão, a partir de a versão 3.0, os seguintes controles:

BotõesOs 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 rolagemAs 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

Os eventos ‘Up’ e ‘Down’ são produzidos quando se pressiona com o mouse os botões superior e inferior da barra de rolagem. ‘Page up’ e ‘Page down’ são produzidos quando se pressiona com o mouse no interior da barra de rolagem acima do botão-indicador ou por baixo do mesmo. O evento ‘Thumbpos’ é produzido quando realizamos um ‘drag’ do botão indicador.



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.

As barras de rolagem podem ser horizontais ou verticais.

List boxesUm 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.

Na última versão do FiveWin foi incorporada a possibilidade de incluir algum bitmap ou imagem a cada um dos elementos.

Group boxesUm 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.

Gets (Edit text)Um Edit text é o equivalente a um Get do CA-Clipper. Devido ao fato do Edit text padrão do Windows não manipular nenhum tipo de máscara ou picture ao estilo CA-Clipper, FiveWin implementa os gets utilizando um objeto Get genuíno do CA-Clipper, incluído como dado dentro do objeto tGet, para efeitos práticos, isto significa que se alguma vez você manipulou diretamente a classe Get original do CA-Clipper pode seguir fazendo-o com a simples precaução de atualizar o controle para que as modificações sejam visualizadas.

A edição de um campo memo é realizada através de um Get multi-line já que para o Windows o controle é o mesmo. A diferença é que o CA-Clipper não é capaz de mostrar um campo memo como um get múltiplo. Esse get multi-line pode ter barras de scroll tanto verticais como horizontais.

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.

As diferenças do CA-Clipper é que se podem definir a justificação do texto: esquerda, centralizado o direita.

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.

BoxesOs 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 buttonsOs 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.

A criação de um radiobutton a partir de código fonte seria:

@ nRow, nCol RADIO oRadioCart VAR nCartao ; PROMPT “Visa”,”Americam Express”,”Dinners” ; OF oDlg

O ‘redefine’ de um radiobutton a partir de recursos seria:

REDEFINE RADIO oRadioCart VAR nCartao ;ID 101,102,103 ;

OF oDlg

Check boxesUm 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 boxesUm 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.

Sua operação é exatamente igual ao listbox.

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.

BrowsesOs 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:


Barra de rolagem

Barra de rolagem

Botão

Radio button

Combo box

List box

Say (Text) Retângulo (box)

Menu do sistema

21


@ <nRow>, <nCol> LISTBOX [ <oBrw> ] ; FIELDS <cFields,...> ; [ FIELDSIZES <aColSizes,...> ] ; [ HEAD | HEADER | HEADERS <aHeaders,...> ] ; [ ID <nId> ] ; [ SIZE <nWidth>, <nHeigth> ] ; [ ON CHANGE | ON CLICK <uChange> ] ; [ ON RIGHT CLICK <uRClick> ] ; [ ON LEFT DBLCLICK <uLDblClick> ] ; [ OF | DIALOG <oDlg> ]

A cláusula HEADERS permite indicar o cabeçalho de cada uma das colunas.

A cláusula SIZE permite indicar o tamanho que terá o controle, é opcional e se não for introduzida será calculada automaticamente.

A cláusula FIELDSIZES permite indicar a largura de cada coluna em pixels, se omitida esta cláusula o controle se ajustará automaticamente, mas nem sempre de forma correta porque como o Windows utiliza fontes ou tipos de letra proporcionais, um campo de 20 caracteres nem sempre ocupa o mesmo em vídeo já que o “i” por exemplo ocupa muito menos que o “M”, o controle browse calcula a largura de coluna baseando-se no tamanho do campo multiplicado pela largura da letra “B”, é possível que ao mostrar campos todos em maiúsculas não seja possível observar em algum campo a descrição completa, por outro lado, em campos muito compridos com letras minúsculas parecerá que se desperdiça uma grande quantidade de espaço. Uma solução para este problema seria examinar todos os registros da base de dados para ver qual é o mais largo porém isto levaria uma grande quantidade de tempo, de qualquer maneira, este problema não é tão grave já que pode-se modificar a largura de qualquer coluna em tempo de execução simplesmente fazendo um drag com o mouse.

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)

A manipulação de janelas MDI será explicado no capítulo de programação avançada.

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.

MetersO 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> ]

As características fundamentais de um Meter são o total que vai representar e o número atual representado, ou seja, o total em uma reindexação seriam o número de registros e o número atual seria o Recno, ou seja,

local nRecno := Recno() ,; nTotal := LastRec()

@ <nRow>, <nCol> METER oMeter VAR nRecno ; TOTAL nTotal ; OF oDlg

Quando desejarmos atualizar o meter fazemos os seguinte:

nRecno += 1oMeter:Refresh()

ou

oMeter:Set(nRecno+1)

Também podemos criar o Meter a partir de recursos, a sintaxe de ‘REDEFINE’ é a seguinte:

REDEFINE METER [ <oMeter> VAR ] <nAtual> ; [ TOTAL <nTotal> ] ; [ ID <nId> ] ; [ OF <oWnd> ];



[ 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.

A imagem pode ser carregada a partir de um arquivo ou também de recursos.

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.

Sua sintaxe é a seguinte:

@ <nRow>, <nCol> BITMAP [ <oBmp> ] ; [ NAME | RESNAME | RESOURCE <cResName> ] ; [ FILE | FILENAME | DISK <cBmpFile> ] ; [ NOBORDER | NO BORDER ] ; [ SIZE <nWidth>, <nHeight> ] ; [ OF | WINDOW | DIALOG <oWnd> ] ; [ ON CLICK | ON LEFT CLICK <uLClick> ] ; [ ON RIGHT CLICK <uRClick> ] ; [ SCROLL ] ; [ ADJUST ] ; [ CURSOR <oCursor> ] ; [ PIXO ] ; [ MESSAGE <cMsg> ] ; [ UPDATE ] ; [ WHEN <WhenFunc> ]

Também podemos criar o controle a partir de recursos, a sintaxe de ‘REDEFINE’ é a seguinte:

REDEFINE BITMAP [ <oBmp> ] ; [ ID <nId> ] ; [ OF | WINDOW | DIALOG <oWnd> ] ; [ NAME | RESNAME | RESOURCE <cResName> ] ; [ FILE | FILENAME | DISK <cBmpFile> ] ; [ ON ClICK | ON LEFT CLICK <uLClick> ] ; [ ON RIGHT CLICK <uRClick> ] ; [ SCROLL ] ; [ ADJUST ] ; [ CURSOR <oCursor> ] ; [ MESSAGE <cMsg> ] ; [ UPDATE ] ; [ WHEN <WhenFunc> ]

Botão Bar (Button bar)O botão Bar permite mostrar botões com uma imagem em seu interior dentro das barras de botões que se implementam com a classe Button Bar que como recordará servem para colocar uma barra de botões em uma janela para ter um acesso mais rápido às opções de menu mais usadas.



A imagem pode ser carregada a partir de um arquivo bitmap ou a partir de recursos.

Se inclusa a cláusula GROUP será criado um separador entre o botão definido anteriormente e o atual, da mesma forma se inclusa a cláusula TOOLTIP “mensagem” será apresentada uma mensagem em uma janela flutuante logo abaixo do botão quando o cursor for posicionado encima do mesmo.

Sua sintaxe é a seguinte:

DEFINE BUTTON [<oBtn>] ; [ OF | BUTTONBAR <oBar> ] ; [ NAME | RESNAME | RESOURCE <cResName1>; [,<cResName2>] ] ; [ FILE | FILENAME | DISK <cBmpFile1>; [,<cBmpFile2>] ] ; [ ACTION | EXEC <uAction> ] ; [ GROUP ] ; [ MESSAGE <cMsg> ] ; [ ADJUST ] ; [ WHEN <uWhen> ] ; [ TOOLTIP <cToolTip> ]

Também podemos criar o controle a partir de recursos, a sintaxe de ‘REDEFINE’ é a seguinte:

REDEFINE BUTTON [<oBtn>] ; [ ID <nId> ] ; [ OF | BUTTONBAR <oBar> ] ; [ NAME | RESNAME | RESOURCE <cResName1> [,<cResName2>] ] ; [ FILE | FILENAME | DISK <cBmpFile1> [,<cBmpFile2>] ] ; [ ACTION | EXEC <uAction> ] ; [ MESSAGE <cMsg> ] ; [ ADJUST ] ; [ WHEN <uWhen> ] ; [ UPDATE <lUpdate> ]

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.DLLNo 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.

Seu funcionamento é exatamente igual ao de seu controle padrão correspondente e a única precaução que temos que ter é a de carregar a LIB Bwcc.dll quando executarmos a aplicação.

LoadLibrary( "BWCC.dll" )

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

O que são os recursos ?

Os Recursos são uma das partes mais importantes na programação Windows. Podemos definir os recursos como o conjunto de dados que complementam qualquer aplicação para seu funcionamento correto, ou seja, qualquer programa consta de uma lógica implementada através de processos e dados que nos permitem dar corpo a toda a aplicação.

A parte de dados de qualquer aplicação pode ser armazenada completamente ou em parte em uma LIB de carga dinâmica (DLL) ou inclusa dentro do executável, estes dados são também chamados recursos os quais podem ser manipulados e modificados externamente, fora do programa.

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).

Graças a esta tecnologia podemos produzir autênticos programas ‘Data-Driven’, o que significa que podemos modificar os dados do programa sem necessidade de voltar a compilar ou relinkar a aplicação.

O mais importante deste processo é compreender como podemos criar um objeto a partir de um recurso e como definir o redefinir seu comportamento.

Existem três métodos para criar um objeto com FiveWin:

1. @ nRow, nCol ...: Este é o método original do CA-Clipper que cria um objeto e imediatamente o mostra em vídeo, é por exemplo o caso de @ nRow, nCol GET. Neste caso é o CA-Clipper que cria o objeto e não está baseado em recursos.

2. DEFINE <ObjectClass> <ObjectName>: Este segundo método é o principal para criar objetos no FiveWin, porém, esse objeto não é apresentado, para isso temos que ativa-lo posteriormente com o comando ACTIVATE... Este sistema também não está baseado em recursos.

3. REDEFINE .... ID ...: Neste caso estamos utilizando recursos, o objeto está criado com antecedência, porém você necessita modificar ou definir seu comportamento. Uma vez que tenha redefinido seu



comportamento o objeto pode ser ativado utilizando o comando ACTIVATE...

Se deseja utilizar recursos em suas aplicações este é o processo a segui:

Consiga um editor de recursos como o Borland Resource Workshop. Este editor de recursos pode ser encontrado com quase todos os compiladores da Borland para Windows, como Turbo C++, Borland C++ ou Turbo Pascal.

Comece a desenhar as caixas de diálogo de sua aplicação com o editor de recursos. Os recursos desenhados podem ser guardados dentro de uma DLL ou em um arquivo RC (os arquivos RC são arquivos ASCII que podem ser compilados e agregados ao executável). No diretório \FiveWin\dll existe uma DLL vazia que pode ser utilizada para guardar recursos (faça uma copia da DLL vazia para cada projeto).

Ao desenhar suas caixas de diálogo deverá fornecer um nome distinto a cada uma delas, esse nome permitirá selecioná-las a partir do programa. Cada controle incluso em suas caixas de diálogo deverá ter um identificador único para esse diálogo e será também através desse identificador que poderá redefinir cada um dos controles

Se os recursos forem criados numa DLL deverá indicar ao programa que vai utilizá-la com o seguinte comando:

SET RESOURCES TO <Arquivo.DLL>

Se os recursos forem criados em um arquivo RC, ele deverá ser compilado com um compilador de recursos (RC.EXE) e incluído no executável. Uma vez criado o executável realize o seguinte:

RC -K Programa.Exe

RC ou DLL?

Os dois sistemas são válidos para guardar recursos, porém existem diferenças importantes entre eles:

A principal vantagem de usar arquivo .RC é que podemos utilizar DEFINES para renomear aos identificadores dos controles, o que significa que não temos necessidade de memorizar os identificadores de todos os controles existentes, ou seja, pode criar um arquivo .CH com os DEFINES necessários e indicar ao arquivo .RC que também utilize esse arquivo.

Outra vantagem é que não é necessário utilizar o comando: SET RESOURCES TO ...

O único inconveniente do arquivo .RC é que terá que compilar os recursos cada vez que o executável é gerado, porém este processo é muito rápido.

A principal vantagem de guardar recursos em uma DLL é que é possível produzir autênticas aplicações “Data-driven” e que uma mesma DLL pode ser compartilhada por varias aplicações.

O principal inconveniente das DLL é que não é possível usar DEFINES para identificar cada controle.



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álogosUm 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.

MenusOs 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.

Recomendamos produzir os menus diretamente a partir de código já que é muito mais rápido.

AtalhosOs 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.

Em geral os programadores Windows utilizam os atalhos para duplicar funções de menu, permitindo ao usuário acessar estas funções de uma forma mais rápida.

Matrizes de Cadeias de Caracteres (String Tables)Os string tables contém textos, como descrições, perguntas, mensagens de erro, etc. que são mostradas nos programas. A principal vantagem de utilizar string tables é que é possível traduzir facilmente a aplicação para outro idioma por exemplo.

BitmapsUm 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:

@ <nRow>, <nCol> BITMAP [ <oBmp> ] ; [ NAME | RESNAME | RESOURCE <cResName> ] ; [ FILE | FILENAME | DISK <cBmpFile> ] ; [ NOBORDER | NO BORDER ] ; [ SIZE <nWidth>, <nHeight> ] ; [ OF | WINDOW | DIALOG <oWnd> ] ;



[ ON CLICK | ON LEFT CLICK <uLClick> ] ; [ ON RIGHT CLICK <uRClick> ] ; [ SCROLL ] ; [ ADJUST ] ; [ CURSOR <oCursor> ] ; [ PIXO ] ; [ MESSAGE <cMsg> ] ; [ UPDATE ] ; [ WHEN <WhenFunc> ]

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.

ÍconesOs í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.

FiveWin implementa um comando para criar o objeto tIcon e deve-se utilizar o já conhecido comando DEFINE WINDOW para criar a janela e associar o ícone recém criado.

DEFINE ICON oIcon RESOURCE "Meu_Icone"DEFINE WINDOW oWnd ICON oIcon

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.

Também pode-se incluir um ícone na sessão de controle em qualquer caixa de diálogo, também a partir de recursos ou criando-o diretamente a partir do FiveWin.

A partir de recursos:

REDEFINE ICON <oIcon> ; [ ID <nId> ] ; [ <resource: NAME, RESOURCE, RESNAME> <cResName> ] ; [ <file: FILE, FILENAME, DISK> <cIcoFile> ] ; [ ON CLICK <uClick> ] ; [ <of: OF, WINDOW, DIALOG> <oWnd> ] ; [ <update: UPDATE> ] ; [ WHEN <uWhen> ] ;

A partir de código:

@ <nRow>, <nCol> ICON [ <oIcon> ] ; [ <resource: NAME, RESOURCE, RESNAME> <cResName> ] ; [ <file: FILE, FILENAME, DISK> <cIcoFile> ] ; [ <border:BORDER> ] ; [ ON CLICK <uClick> ] ; [ <of: OF, WINDOW, DIALOG> <oWnd> ] ; [ <update: UPDATE> ] ; [ WHEN <uWhen> ]

CursoresUm 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

Os cursores só podem ser utilizados a partir de recursos.

FontesOs 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

Pode-se especificar varias cláusulas ao criar uma fonte como:

NAME: O nome da fonte, Arial, System, Times, etc.. SIZE: O tamanho da fonte indicando largura e altura. Recomendamos

que sempre indique um 0 para a largura e um número negativo para a altura, desta maneira Microsoft Windows se encarrega de proporcionar a largura para altura dada.

BOLD: Se desejar a fonte em negrito ITALIC: Se desejar a fonte em itálico UNDERLINE: Se desejar a fonte sublinhada FROM USER: Se utilizada esta cláusula, a criação da fonte se fará de

forma iterativa mostrando-se ao usuário uma caixa de diálogo com todas as possibilidades de criação da fonte.

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.

A partir deste editor de programas poderemos criar todos os recursos anteriormente enunciados através de um ambiente visual de uso muito fácil.

Como se comentou anteriormente os recursos podem ser guardados em uma DLL ou também em um arquivo RC, no primeiro caso a descrição de cada um dos recursos é guardada no próprio arquivo DLL, porém, quando se trata de arquivos RC, só se guarda a descrição de parte dos recursos que uma aplicação vai utilizar, assim sendo, o conteúdo de certos recursos estarão guardados em arquivos separados, assim, por exemplo, as imagens são guardadas em arquivos .BMP, os ícones em arquivos .ICO e os cursores em arquivos .CUR.

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"

Esta instrução permite ao compilador de recursos (RC.EXE) resolver todas as referencias a identificadores e os possíveis estilos de qualquer recurso ou controle. Em Winapi.ch estão inclusos quase todos os possíveis estilos de cada um dos controles, mas é possível que algum não esteja, nesse caso o compilador de recursos avisará dizendo que não conhece um determinado identificador como por exemplo o identificador BBS_BITMAP que identifica um controle como do tipo ‘Borland Bitmap Style’, quando isto ocorrer quer dizer que no arquivo Winapi.ch não existe nenhum define que identifique BBS_BITMAP com nenhum número pelo que deve-se incluir no arquivo .RC manualmente a definição desse identificador da seguinte maneira:

#define BBS_BITMAP 0x8000L

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.

A melhor forma de aprender a utilizar o editor de recursos é praticando e quando tiver alguma dúvida consulte o help On-line que acompanha o programa.



Caixas de DiálogoPara 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.

Trabalhando com controlesOs controles se incluem dentro das caixas de diálogo para passar e acessar informação aos usuários. Se desejar obter mais informação a respeito dos controles consulte o capítulo anterior deste Curso.

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 StopUma 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 controlesO 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’.

Para definir um grupo de controles,



1. Se for necessário mova os controles até que se encontrem todos juntos.

2. Clique sobre a paleta de ferramentas que mostra um “G”, então, o cursor se converterá em um “G” e cada um dos controles que é o primeiro membro de um grupo será marcado com um retângulo.

3. Para cada grupo que queira definir, clique no primeiro membro de cada um deles de tal forma que seja marcado por um retângulo.

Não é necessário que se identifique o último membro de um grupo.

Esta técnica de grupo também é utilizada quando se quer proporcionar um atalho a um controle que não tem título, como por exemplo um Get. Neste caso, se estabelece um grupo entre esse Get e o Say associado, se associa um atalho ao Say e se dá a propriedade ao Say do primeiro membro de grupo, além disso, o Get deve ser o controle seguinte depois do Say na ordem em que se acessa.

Ordem dos controlesCom esta ferramenta podemos modificar a ordem em que se acessa os controles. A ordem é especialmente importante quando estão definidos grupos com os controles. Se os controles não são ordenados perfeitamente, o usuário pode ficar muito confuso com a utilização do programa.

Para estabelecer a ordem, utilize a ferramenta de ordenação que se encontra na paleta de ferramentas representada por um botão com os número “1,2”, ao pressionar esse botão o Resource Workshop mostrará o número de ordem de cada controle, simplesmente clique sobre cada controle para estabelecer a nova ordem, o primeiro controle clicado se converterá no controle número 1, e cada novo clique aumentará sucessivamente o contador de ordenação até que todos os controles sejam clicados.

Ferramentas de alinhamento e ajuste de tamanhoO Resource Workshop inclui algumas ferramentas para alinhamento ou ajuste de tamanho de controles, esta ferramenta é muito simples e economiza trabalho já que permite, por exemplo, forçar que vários controles tenham a mesma altura, a mesma largura, estejam separados vertical ou horizontalmente no mesmo espaçamento, estejam centralizados vertical ou horizontalmente na caixa de diálogo, etc.

Durante o curso será mostrado como produzir todas estas operações.

Experimentando uma caixa de diálogoNão é necessário que compile e linque seu programa para observar como funciona sua caixa de diálogo recém criada já que o Resource Workshop proporciona uma ferramenta para testa-la. Simplesmente pressione o botão ‘Test’ da paleta de ferramentas.

Controles criados pelo usuárioÉ possível indicar ao Resource Workshop que vamos utilizar controles que a princípio não estão disponíveis no editor de recursos. Para isso, temos que pressionar o botão Custom Control representado por uma chave na paleta de ferramentas e indicar o nome de classe que vai ter o novo controle. Uma vez introduzido um controle customizado, faça um double-click para indicar o estilo do mesmo. Por exemplo, para incluir um controle browse do FiveWin o nome de classe seria ‘tWbrowse’ e o estilo:



0|WS_CHILD|WS_VISIBLE|WS_TABSTOP|WS_BORDER|WS_VSCROLL|WS_HSCROLL

Bitmaps, Ícones e cursoresA criação de bitmaps, ícones e cursores é realmente intuitiva e se parece muito ao PaintBrush do Windows pelo que acreditamos que não vale a pena nos expendermos nisso.

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

Impressão em Microsoft Windows

A principal diferença existente entre Microsoft Windows e MSDOS no que diz respeito à impressão, é que sob Microsoft Windows se manipula a impressora de forma gráfica. Isso significa que podemos utilizar fontes de tamanhos distintos, poderemos produzir todo tipo de figuras geométricas como linhas, círculos, retângulos, etc. e inclusive incluir bitmaps (imagens) dentro de nossos relatórios.

FiveWin automatiza todo o processo oferecendo o máximo de potência e flexibilidade e a mínima complexidade possível.

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:

Para gerar um relatório da base de dados ativa simplesmente faça uma chamada à função Report().

Se desejar gerar um relatório de um browse execute o método :Report() desta classe.

Se quer produzir uma impressão de qualquer controle, diálogo ou janela, execute o método :HardCopy(nZoom) do objeto.

Se desejar produzir tarefas mais sofisticadas deverá utilizar diretamente o objeto tPrinter ou utilizar o gerador de Relatórios que acompanha o FiveWin.

Para criar um objeto tPrinter simplesmente utilize os seguintes comandos xBase:

PRINT oPrn NAME “Meu primeiro relatório” PREVIEW

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.

Normalmente criará varias páginas com as seqüências

PAGE......ENDPAGE

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:

:nVertSize() devolve a altura da página em milímetros :nHorizSize() devolve a largura da página em milímetros :nVertRes() devolve a resolução vertical da página em milímetros :nHorizRes() devolve a resolução horizontal da página em milímetros :nLogPixelY() devolve a resolução por polegada vertical (por exemplo 300

ppp típico das laser) :nLogPixelX() devolve a resolução por polegada horizontal :Cmtr2Pix(nRow, nCol): que transforma coordenadas em centímetros em

coordenadas em pixels :Inch2Pix(nRow, nCol): que transforma coordenadas em polegadas em

coordenadas em pixels

Na realidade, os mais usados serão estes dois últimos.

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 oPrinterDEFINE 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 sintaxe para criar qualquer relatório é a seguinte:

REPORT ....COLUMN ...COLUMN ...[ GROUP ... ]

ENDREPORT

ACTIVATE REPORT ...

Primeiramente deve-se fornecer toda a informação geral do relatório como o título, cabeçalho, rodapé, fontes que serão utilizadas, etc.

REPORT [ <oReport> ] ; [ TITLE <bTitle, ...> [< LEFT | CENTER | CENTERED | RIGHT > ] ]; [ HEADER <bHead, ...> [< LEFT | CENTER | CENTERED | RIGHT > ] ]; [ FOOTER <bFoot, ...> [< LEFT | CENTER | CENTERED | RIGHT > ] ]; [ FONT <oFont, ...> ] ; [ PEN <oPen, ...> ] ; [ < SUMMARY > ] ; [ < FILE | FILENAME | DISK > <cRptFile> ] ; [ < NAME | RESNAME | RESOURCE > <cResName> ] ; [ < TO PRINTER > ] ; [ < PREVIEW > ] ; [ TO FILE <toFile> ] ; [ TO DEVICE <oDevice> ] ; [ CAPTION <cName> ]

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.

As cláusulas HEADER e FOOTER têm o mesmo funcionamento da cláusula TITLE e servem para especificar o cabeçalho e o rodapé do relatório.

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

Lembre-se de que deve-se destruir as fontes quando terminar o relatório.

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

Lembre-se que deve-se destruir os Pens quando terminar o relatório.

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 SUMMARY permite imprimir só um sumario do relatório, ou seja, somente a informação dos grupos. Logicamente não faz sentido utilizar esta cláusula se não houver nenhum grupo criado.

A cláusula TO PRINTER permite mandar diretamente o relatório à impressora, PREVIEW nos mostra primeiramente o relatório no vídeo e TO FILE exporta o relatório para um arquivo ASCII. Se o objeto tPrinter sobre o qual se vai produzir o relatório já tiver sido criado podemos indicá-lo utilizando a cláusula TO DEVICE oPrinter.

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).

O próximo passo será indicar as colunas desse relatório com o comando:

COLUMN [ <oRptCol> ] ; [ TITLE <bTitle, ...> ] ; [ AT <nCol> ] ; [ DATA <bData, ...> ] ; [ SIZE <nSize> ] ; [ PICTURE <cPicture, ...> ] ; [ FONT <uFont> ] ; [ < TOTAL > [ FOR <bTotalExpr> ] ] ; [ < LEFT | CENTER | CENTERED | RIGHT > ] ; [ < SHADOW > ] ; [ < GRID > [ <nPen> ] ]

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 LEFT|CENTER|RIGHT permite indicar como se visualizará o texto tanto do título como dos dados.

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 > ]

Lembre-se que podemos incluir tantos grupos quantos forem necessários.

GROUP ON Empregado->Idade

A cláusula ON permite indicar a expressão de quebra , ou seja, se queremos uma quebra quando mudar a idade, a expressão seria:

GROUP ON Empregado->Idade

As cláusulas HEADER e FOOTER permitem indicar um cabeçalho e um rodapé por cada grupo (só uma linha).

A cláusula FONT funciona exatamente igual as colunas. Com elas, indicamos a fonte utilizada na impressão da quebra.

A cláusula EJECT permite produzir um salto de página a cada 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.

É nas cláusulas ON onde se encontra o verdadeiro poder do gerador de relatórios e quando tiver experiência no uso delas, poderá produzir absolutamente qualquer relatório.

A melhor forma de aprender a utilizar o gerador de relatórios é executar e analisar em profundidade o tutorial que acompanha a FiveWin.

O gerador de relatórios utiliza 4 classes para produzir seu conteúdo:

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:

Por padrão, o Windows permite um máximo de 20 arquivos abertos por aplicação. Para conseguir abrir mais arquivos devemos utilizar a função SetHandleCount() que pertence ao FiveWin e que recebe como único parâmetro o número de arquivos que desejamos abrir e devolve os que realmente o Windows pôde oferecer. O número máximo de arquivos abertos é 255, porém, recomendamos que indique a quantidade que sua aplicação realmente necessita.

Se desejar mostrar uma base de dados em duas janelas distintas isso só será possível abrindo-a duas vezes com ‘Alias’ diferentes. Além disso, deverá programar como se fosse um ambiente de rede, ou seja, não poderá abrir as bases de dados em modo exclusivo e deverá bloquear os registros cada vez que realizar uma operação sobre eles. Se estiver utilizando Windows 3.1 será necessário carregar o programa SHARE.EXE antes de carregar Windows, para Windows 3.11 (trabalho em grupo) ou Windows 9x não é necessário.

FiveWin incorpora uma poderosa classe DataBase que pode lhe economizar muito tempo de programação.

Se estiver trabalhando com versões do CA-Clipper anteriores à versão 5.2d poderá ter sérios problemas com alguns RDDs, sobretudo com o driver DbfCdx. De qualquer maneira recomendamos que utilize o driver Comix ou Six os quais são excelentes.

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.

Um objeto DataBase é essencialmente um buffer em onde você manipula os dados do arquivo e que posteriormente grava no arquivo fisicamente.



Para criá-lo, só necessita utilizar o comando DATABASE depois de abrir a base de dados.

Local oDbfUSE “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().

Tradicionalmente qualquer programador CA-Clipper necessitava criar variáveis locais que atuam como buffer para armazenar cada um dos valores de cada campo, principalmente quando se programa em ambientes de rede. Outra alternativa era utilizar uma matriz como buffer e utilizar funções para carregar e gravar, cujos nomes mais usados devido a implementação em FoxPro são Scatter() e Gather(). O inconveniente de usar matrizes é que não podemos usar os nomes de campos diretamente e portanto temos que produzir DEFINES indicando que campo corresponde a cada elemento do array.

#define CODIGO aDbf[1]#define NOME aDbf[2]

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.

O debugger requer uma DLL para seu funcionamento chamada Fwdbf.dll.

É 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() ... SKIPENDDO

Manipulação de janelas MDI

Uma janela MDI é aquela que por sua vez contém outras janelas em seu interior. As janelas filhas nunca podem sair do escopo da janela mãe, porém, podem ser movidas, redimensionadas, iconizadas, destruídas e criadas.

Na realidade, uma janela MDI é como o ambiente do Windows, porém para a sua aplicação.

Se tivéssemos que desenhar pessoalmente o ambiente MDI seria realmente um trabalho enorme, porém, o Windows nos oferece tudo o necessário para produzi-lo.

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:

Janela principal: tMdiFrame que é a janela armazenadora da janelas filhas e é a que por exemplo contém a barra de menu.

Janela cliente: tMdiClient que é a janela que realmente manipula as janelas filhas. É uma janela invisível.

Janelas filhas: tMdiChild que são as janelas filhas da janela MDI.



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 oWndChildo

@ 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 ...ENDMENUACTIVATE POPUP oMenu OF oDlg AT nRow, nCol

Normalmente menus pop-up são utilizados ao se pressionar o botão direito do mouse e portanto as coordenadas nRow, nCol seriam as coordenadas do mouse ao se pressionar o botão direito.

Static oWnd

Function Main()

DEFINE WINDOW oWnd...ACTIVATE WINDOW oWnd ON RIGHT CLICK PopuMenu(nRow,nCol)....Function PopupMenu()local oMenu

MENU oMenu POPUP MENUITEM ... MENUITEM ... ENDMENU ACTIVATE POPUP oMenu OF oWnd AT nRow, nCol

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.

DEFINE BRUSH <oBrush> ; [ STYLE <Style> ] ; [ COLOR <nRGBColor> ] ; [ FILE | FILENAME | DISK <cBmpFile> ]; [ RESOURCE | NAME | RESNAME <cBmpRes> ]...DEFINE WINDOW oWnd BRUSH oBrush

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.

O primeiro passo é definir o objeto clipboard e ativa-lo

DEFINE CLIPBOARD oClp OF oWndACTIVATE CLIPBOARD oClp

Uma vez definido poderemos utilizar os métodos desta classe para produzir todas as operações necessárias, que são:

oClp:Clear() para limpar o clipboard oClp:SetData() para mandar dados ao clipboard oClp:GetData() para recuperar dados do clipboard

No esqueça de fechar o clipboard uma vez que tenha terminado de usa-lo.



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"

SET SECTION "Principal" ; ENTRY "Título" ; OF oIni ; TO cTitulo

DEFAULT

A cláusula GET pode indicar um valor padrão se o desejar.

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 som de extensão WAV se utiliza a função SndPlaySound() com o nome do arquivo que se quer reproduzir.

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.

FiveWin se apoia no arquivo BiVbx.DLL da Borland para implementar o acesso aos controles VBX. Esse arquivo se encontra nos últimos compiladores da Borland para Windows e não é fornecido com FiveWin.

A última versão do Resource Workshop da Borland permite também trabalhar com controles VBX e para isso incorpora uma opção para adicionar estes controles. FiveWin permite usar controles VBX tanto a partir de código como a partir de recursos.

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.

Sua funcionamento é muito parecida ao de qualquer outro controle porém dependendo de sua funcionalidade é muito possível que tenham propriedades e eventos muito específicos que não existam em nenhum outro controle visto antes.

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.

FiveWin incorpora um pequeno utilitário para inspecionar os controles VBX. Esse programa se encontra em código fonte que deverá ser compilado e linkado. Seu nome é VbxClass.prg e se encontra no diretório \fw\Samples.

Para criar um controle VBX a partir de código:

@ <nRow>, <nCol> VBX [<oVbx>] ; [ OF <oWnd> ] ; [ SIZE <nWidth>, <nHeight> ] ; [ <file: FILE, FILENAME, DISK> <cVbxFile> ] ; [ CLASS <cVbxClass> ] ; [ ON <cClause1> <uAction1> ; [ ON <cClauseN> <uActionN> ] ]

Como pode observar sua sintaxe é muito parecida à de qualquer controle porém com uma serie de diferenças:

Deve especificar o arquivo VBX a usar. Deve especificar a classe do controle, informação que deve ser

proporcionada pelo fabricante do controle. Pode coincidir ou não com o nome do arquivo, se não conhecer o nome não inclua esta cláusula já que é opcional. Se seu controle não executa corretamente, é possível que tenha que indicar o nome de classe.

As cláusulas ON permitem qualquer verbo, ou seja, você pode incluir no comando a cláusula ‘ON LUNES’ porém possivelmente não servirá para nada. Temos que nos concentrar nos eventos que o controle possui pois são eles que devem ser incluídos na cláusula ON. Por exemplo é muito provável que seu novo controle responda à cláusula ‘ON CLICK’.



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.

Para criar (redefinir) um controle VBX a partir de recursos:

REDEFINE VBX [<oControl>] ; [ ID <nId> ] ; [ OF <oDlg> ] ; [ COLOR <nClrFore> [,<nClrBack>] ] ; [ ON <cClause1> <uAction1> ; [ ON <cClauseN> <uActionN> ] ]

como podemos observar a sintaxe é muito parecida à de qualquer controle.

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”

e utilizaremos o seguinte comando:

DEFINE ODBC <oDbc> ; [ NAME <cName> ] ; [ USER <cUser> ] ; [ PASSWORD <cPassword> ] ; [ CONNECT <cConnect> ] ; [ FROM USER ]

oDbc é a variável que carrega o objeto recém criado.

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.

A cláusula CONNECT é utilizada no caso de uma conecção a um mecanismo SQL e temos que introduzir o ‘Data Source Name’ que pode ser por exemplo “Oracle-Serv1”.

Como podemos observar no comando é permitido selecionar a conecção ODBC de forma interativa.

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.

Recomendamos que analise em profundidade o programa de exemplo Odbc1.prg no qual se mostra a atual forma de utilizar ODBC.

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:

Byte, char (1 byte de comprimento) Word, Bool, Handle, hWnd, hDC (2 bytes de comprimento) Long, String, Lpstr, Ptr (4 bytes de comprimento) Double (8 bytes de comprimento)

Return indica o tipo de dado que a função devolverá. Os valores podem ser os mesmos que o tipo.

A cláusula Lib indica o nome da LIB a ser utilizada.

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).

Uma das melhorias introduzidas na última versão do FiveWin é a possibilidade de passar ponteiros a estas funções. Para isso só temos que passar o parâmetro por referência.

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.



Dynamic Data Exchange (DDE)

DDE é um sistema de comunicação entre aplicações. Para poder estabelecer uma comunicação entre duas aplicações é necessário que uma delas seja DDE cliente e a outra DDE servidor ou vice-versa. O DDE cliente é o que iniciará a conversação e pedirá ao servidor que execute uma série de ações. A sintaxe dessas ações ou verbos dependerão do servidor DDE.

FiveWin pode atuar tanto como cliente ou como servidor DDE.

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).

Se deseja utilizar a partir do FiveWin qualquer ferramenta de geração de relatórios produzido por outro fabricante como CA-Ret, Crystal Reports, R&R, Report Smith, etc. não terá como fazê-lo senão através de uma ligação DDE.

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.

Os passos necessários em qualquer ligação DDE são os seguintes:

Estabelecer a conecção com o servidor DDE Ativar a conecção Produzir a comunicação com o método Execute() Finalizar a conecção.

Para estabelecer a conecção utilizamos o seguinte comando

DEFINE <dde:DDE,LINK> <oDde> ; [ SERVICE <cService> ] ; [ TOPIC <cTopic> ] ; [ ITEM <cItem> ] ; [ VALID <uEnd> ]

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”) QUITENDIF

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.



Manipulação de arquivos de Help

Neste capítulo se dará informação de como acessar um arquivo de help para Windows, em nenhum caso se explicará como confeccioná-lo.

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:

HelpIndex() que ativa o help mostrando o índice do mesmo. Pode-se invocar HelpIndex() a partir de uma opção de menu HelpConteúdo.

HelpSearch(cTexto) que ativa o help e busca a cadeia cTexto. Se não for introduzido nenhum texto, o programa solicitará ao operador.

HelpTopic(nTopic) que permite ativar em um determinado tópico.

O FiveWin, em sua última versão, melhorou substancialmente seu sistema de help. Atualmente só é necessário estabelecer o arquivo de help a utilizar, do resto o FiveWin se encarrega.

O sistema funciona da seguinte maneira, ao criar uma janela, um diálogo ou um controle, poderá indicar, se o desejar, um número para identificar o tópico correspondente de seu help (oWnd:nHelpId) e quase todos os controles e janelas tem a possibilidade de associá-lo diretamente com seu comando. Quando o usuário pressionar F1 em qualquer parte da aplicação o FiveWin buscará o identificador do help na janela ou controle que tenha foco, e, se o identificador for zero, irá ascendendo a sua classe mãe até encontrar um identificador diferente de zero. Se não encontrar nenhum identificador diferente de zero mostrará o índice do help.

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()

Também é possível associar um identificador de help a cada opção de menu.



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”.



OBJECTS: MECANISMO OOPS DO FIVEWIN

O FiveWin incorpora ao CA-Clipper um mecanismo para programação orientada a objetos de nome OBJECTS.

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

Tfont Font Class

Twindow Window base Class Tdialog Dialog Boxes Tbar Button bar TMdiFrame MDI support TMdiClient MDI support TMdiChild MDI support TMsgBar Messages bar Tcontrol Base Class for controls Tbitmap Pictures in Bitmaps Tbutton PushButtons TCheckBox Logical checkboxes TComboBox Get + ListBox functionality Tget Typical Clipper GET Ticon Icons as controls TListBox ListBox selection list Tmeter Meter controls TMultiGet Gets for Memo editing Tradio Radio controls TScrollBar ScrollBars controls



TVbX Visual Basic controls TWBrowse Browse controls Tmenu Menu Class TMenuItem Menu MenuItems

Tblock FiveWin disk-storable codeblocks

TMCI Media Control interface Tvideo AVI Video controls

TRadMenu Radio Controls Menu

Tprinter Printer ClassTreport Report engineTrColumn Report engineTrGroup Report engineTrLine Report engine

Ttimer Timer Class

Acesso aos dados e métodos

Podemos acessar qualquer dado ou método de uma classe desde que não esteja protegido e realmente no FiveWin ha muito poucos dados protegidos, já que foi construído com a intenção de oferecer a máxima flexibilidade possível.

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.



Criação de novas classes

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:

#include "Objects.ch" ou #include “Fivewin.ch”

CLASS <NovaClasse> [ FROM <ClasseMãe> ] DATA <NomeDado1> DATA <NomeDado2> ... METHOD <NomeMetodo1>( [ <params,...> ] ) ; [ CONSTRUCTOR | SETGET | VIRTUAL | BLOCK ] METHOD <NomeMetodo2>( [ <params,...> ] ) ; [ CONSTRUCTOR | SETGET | VIRTUAL | BLOCK ]ENDCLASS

NovaClasse é o nome da nova classe que vamos criar. Seu nome não pode exceder 10 caracteres.

ClasseMãe é o nome da classe superior à que pertence se é uma classe herdada.

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.

Paramx é uma lista de possíveis parâmetros que o método pode receber.

Os métodos podem receber varias cláusulas:

Constructor que indica o método utilizado para construir uma instância da classe, ou seja, o objeto. É caracterizado por devolver uma referência de si mesmo.

Virtual que é um método que não faz nada, porém, é muito útil para herança ou quando se está criando e experimentando um classe.

Inline é um método definido na mesma linha de definição.

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

Dentro de qualquer método podemos acessar qualquer dado da classe simplesmente utilizando a variável Self. Por exemplo, para acessar um dado de nome nOrdem faríamos: Self:nOrdem, por comodidade OBJECTS permite substituir a palavra “Self:” por “::” pelo que ficaria ::nOrdem.

Se desejar acessar um dado ou método de sua classe superior utilize a variável “Parent(NomeMãe)”, se desejar acessar a sua classe mãe principal deverá utilizar “Super”. Por exemplo, se uma classe tem um método do mesmo nome que sua classe mãe principal



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”.



Conecção com a API do Windows

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.

O CA-Clipper utiliza símbolos PASCAL com um máximo de 10 caracteres. Assim sendo, se vai utilizar identificadores do Windows com menos de 10 caracteres é possível que obtenha símbolos duplicados, este é o motivo pelo qual o FiveWin renomeou todas as funções da API de menos de 10 caracteres colocando um underscore no começo delas. Se sua função tem menos de 10 caracteres lembre-se de redefini-la com um underscore no arquivo Winten.h.

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

Todos seus programa em C deverão começar pelos seguintes includes:

#include <Winten.h>#include <Windows.h>#include <Clipapi.h>

Como cabeçalho de funções se utiliza a palavra ‘CLIPPER’

CLIPPER Funcao(params){......}

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>

//--------------------------------------------------------//

CLIPPER SNDPLAYSOU() // ND( <cArquivo>, <nModo> )--> <lExito>{ _retl( sndPlaySound( _parc( 1 ), _parni( 2 ) ) );}

//--------------------------------------------------------//

Observe os detalhes de nossa função:

Colocamos o include de MMSystem.h que é aonde está a função SndPlaySound() prototipada

Utilizamos a cadeia CLIPPER no começo da função. Utilizamos até 10 caracteres para a definição da função É um bom costume colocar como comentário os possíveis caracteres a

partir do 10 e, além disso, dos parâmetros que vai manipular e o que vai retornar

Como pode-se observar _parc( 1 ) é uma função que recolhe o primeiro parâmetro passado à função que é de tipo caracter, e _parn(2) é o segundo parâmetro que é de tipo numérico.

A função devolve um valor lógico através da função _retl()

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.


Documents

FiveWin - Manual Em Portugus