NetAlexpress

Animando uma GS automaticamente

2009-01-08T13:30:00.002-03:00

Uma das dificuldades de quem utiliza programas Cobol com uma tela desenhada pelo Dialog System é que no momento de um "animate", as chamadas ao Dialog não podem ser animadas automaticamente. Uma dica para resolver essa questão é mudar a constante padrão da chamada do Dialog System:

78 dialog-system VALUE "DSGRUN". *> essa é a definição padrão

Mude a linha acima para:

78 dialog-system VALUE "DS".

Tão logo seja feita uma chamada para o Dialog System, o IDE entrará no modo "animate" dentro da GS chamada, automaticamente.

Que dia é hoje ?

2008-11-17T19:05:00.004-03:00

Hoje é dia de conhecer o ACMonthCalendar, o calendário padrão do Windows para ser utilizado diretamente na tela de sua aplicação. O calendário padrão do Windows não vem no pacote oferecido pela Microfocus, se o desenvolvedor deseja utilizá-lo tem que recorrer ao componente DatePicker, que não é um dos mais amigáveis que existe.

O demo da aplicação está disponível no site do Clube Cobol.

Continue colaborando com o NetAlexpress. Com apenas R$ 49,00 (quarenta e nove reais) você recebe os fontes dessa aplicação e ajuda com as pesquisas do blog.

Listview: de 20 a 40 por cento mais rápido !

2008-09-22T09:03:00.003-03:00

Uma das dificuldades que os desenvolvedores sentem ao utilizar o Listview é a demora que existe incluindo uma quantidade razoável de dados em sua estrutura. Utilizando dois métodos simples, o desenvolvedor pode ganhar até 40 por cento do tempo gasto com esse procedimento, tornando assim o Listview mais rápido.

Quando estamos alimentando um Listview com dados, o Windows se encarrega de mostrar visualmente esse procedimento. As linhas e colunas do Listview vão sendo atualizadas, a barra de rolagem é redesenhada proporcionalmente à quantidade de ítens, entre outras coisas. O método "stopRedrawing" indica ao componente que nenhuma atualização visual deve ser feita enquanto os dados forem incluídos. O método "startRedrawing" retorna o componente à sua condição normal.

Localize em seu programa o ponto exatamente anterior à inclusão dos seus dados no Listview e então acrescente a linha abaixo:

invoke umListview "stopRedrawing"

Ao terminar a inclusão de dados em seu Listview, precisamos dizer a ele pra voltar a sua condição normal. Para isso, acrescente a linha abaixo:

invoke umListview "startRedrawing"

Você vai notar que a inclusão dos dados em seu componente será de 20 a 40 por cento mais rápida.

Observação: o fato do Listview não ser atualizado visualmente na inclusão dos dados, pode dar a impressão ao usuário de que o micro está travado, pois nada é mostrado no Listview indicando que ele está sendo "alimentado". Portanto, é interessante que alguma mensagem seja colocada ao usuário comentando sobre essa atualização.

HA HA.. HU HU ! O treeview é nosso !

2008-09-17T21:59:00.007-03:00

Para os desenvolvedores que um dia desejaram ter um Treeview em suas aplicações, esse artigo mostra que a utilização desse componente padrão do Windows não é assim uma tarefa das mais díficeis. Aproveite para colaborar como NetAlexpress adquirindo a classe ACTreeview e coloque um pouco mais de charme às suas aplicações.

Com um programa controlador único, você pode utilizar e controlar diversos componentes "treeview" em uma mesma janela. Além disso, você pode detectar alguns eventos como um ítem selecionado, um ítem abrindo ou fechando, mudar os ícones, deixar um ítem em negrito, além de outros recursos interessantes.

Baixe agora a versão demo no site do Clube Cobol. Categoria 3 - Códigos fonte e exemplos.

Para adquirir a versão com os fontes, basta utilizar o PagSeguro, no menu da esquerda do blog, fazendo uma doação no valor de R$ 49,00 (quarenta e nove reais) para colaborar com o NetAlexpress. Caso prefira, também pode ser feito um depósito bancário. Para isso, escreva para alexandre@ciasoftonline.com.br solicitando os dados para o depósito.

Aguarde o próximo componente: o ACMonthCalendar, um calendário que você vai poder utilizar nas janelas das suas aplicações. Até lá !

Uma toolbar ao seu alcance

2008-08-20T20:44:00.024-03:00

Eu recebo muitos emails de desenvolvedores interessados em utilizar a Toolbar padrão do Windows em suas aplicações. Nesse artigo, mostro como utilizar diversas toolbars em uma mesma janela, com a utilização de um programa controlador único, e sem a necessidade de se vincular ítens de menu aos botões.

Longe da dificuldade dos exemplos do NetExpress, essa demonstração mostra de maneira muito fácil o uso desse componente e também tem o intuito de buscar colaboração entre os leitores desse blog para que eu continue estimulado a escrever os artigos que ajudam a tantos desenvolvedores espalhados por todo o Brasil.

Colabore com o NetAlexpress !!!
Nessa versão de demonstração disponível para download no site do clube cobol não estão inclusos os fontes completos do projeto. Para receber os fontes completos, colabore com o NetAlexpress com R$ 49,00 (quarenta e nove reais) através de depósito bancário. Para maiores informações, envie email para alexandre@ciasoftonline.com.br.

O custo é pequeno justamente para que os desenvolvedores possam colaborar com o blog e também poderem ter acesso aos componentes mais utilizados nas aplicações gráficas, como a Toolbar. Minha intenção é criar novas classes para utilização de novos componentes e disponibilizar aqui no blog. No meu próximo artigo, vou escrever sobre a Treeview.

......$set mfoo
.......program-id. TBDemo.
.......class-control.

........*> Abaixo são definidas as classes utilizadas nesse programa
...........ACTButton is class "actbutton"
...........ACMaskedImageList is class "acmaskedimagelist"
...........ACUtils is class "acutils"
............
.......DATA DIVISION.
.......WORKING-STORAGE SECTION.

.......*> Variáveis usadas nas listas de imagens
.......77 umaLista object reference value null.
.......77 umaListaBmp object reference value null.

.......*> Variáveis usadas para identificar os ícones utilizados
.......77 icoAbrir pic 9(09) comp-5 value zeros.
.......77 icoNovo pic 9(09) comp-5 value zeros.
.......77 icoAlterar pic 9(09) comp-5 value zeros.
.......77 icoExcluir pic 9(09) comp-5 value zeros.
.......77 icoVisualizar pic 9(09) comp-5 value zeros.
.......77 icoGravar pic 9(09) comp-5 value zeros.
.......77 icoCancelar pic 9(09) comp-5 value zeros.
.......77 icoSair pic 9(09) comp-5 value zeros.

.......*> Variáveis usadas para identificar os bitmaps utilizados
.......77 bmp1 pic 9(09) comp-5 value zeros.
.......77 bmp2 pic 9(09) comp-5 value zeros.
.......77 bmp3 pic 9(09) comp-5 value zeros.
.......77 bmp4 pic 9(09) comp-5 value zeros.
.......77 bmp5 pic 9(09) comp-5 value zeros.
.......77 bmp6 pic 9(09) comp-5 value zeros.
.......77 bmp7 pic 9(09) comp-5 value zeros.
.......77 bmp8 pic 9(09) comp-5 value zeros.

.......*> Os botões da toolbar não terão vínculo com um item de menu
.......*> por isso ele será passado sempre com nulo
.......77 umItemNulo object reference value null.

.......*> Variáveis usadas para identificar os botões das toolbars
.......77 umBotaoClicado object reference value null.
.......77 umBotaoAbrir object reference value null.
.......77 umBotaoNovo object reference value null.
.......77 umBotaoAlterar object reference value null.
.......77 umBotaoExcluir object reference value null.
.......77 umBotaoVisualizar object reference value null.
.......77 umSeparador object reference value null.
.......77 umBotao1 object reference value null.
.......77 umBotao2 object reference value null.
.......77 umBotao3 object reference value null.
.......77 umBotao4 object reference value null.
.......77 umBotao5 object reference value null.
.......77 umBotao6 object reference value null.
.......77 umBotao7 object reference value null.
.......77 umBotao8 object reference value null.
.......77 umBotaoGravar object reference value null.
.......77 umBotaoCancelar object reference value null.
.......77 umBotaoSair object reference value null.

.......77 icone pic 9(09) comp-5 value zeros.
.......77 w pic 9(09) comp-5 value zeros.
.......77 h pic 9(09) comp-5 value zeros.
.......77 l pic 9(09) comp-5 value zeros.

.......78 dialog-system VALUE "DSGRUN".
.......01 Display-Error.
..........03 Display-Error-No PIC 9(4) comp-5.
..........03 Display-Details-1 PIC 9(4) comp-5.
..........03 Display-Details-2 PIC 9(4) comp-5.

.......COPY "DS-CNTRL.MF".
.......COPY "TBDemo.CPB".
.......COPY "KEYS.CPY".
.......PROCEDURE DIVISION.
.......Main-Process SECTION.
...........PERFORM Program-Initialize
...........PERFORM Program-Body UNTIL funcao = "SAIR"
...........perform Program-Terminate
............

......*--------------------------------------------------------------*
*.......Program-Initialize SECTION.
...........INITIALIZE Ds-Control-Block
...........INITIALIZE Data-block
...........MOVE Data-block-version-no TO Ds-Data-Block-Version-No
...........MOVE Version-no TO Ds-Version-No
...........MOVE Ds-Push-Set TO Ds-Control
...........MOVE "TBDemo" TO Ds-Set-Name
............

......*---------------------------------------------------------------*
.......Program-Body SECTION.
...........evaluate FUNCAO
.............when "MONTAR" perform Montar
.............when "BOTAOCLICADO" perform BotaoClicado
...........end-evaluate
...........perform Call-Dialog-System
............

......*---------------------------------------------------------------*
.......Montar section.
........*> Esse é a primeira seção chamada, que cria as listas
........*> de imagens e as toolbars
...........perform MontarListaDeImagens
...........perform MontarToolbar
...........perform MontarToolbarGravar
...........perform MontarToolbarLateral
............

......*-------------------------------------------------------------*
.......MontarListaDeImagens section.
........*> Aqui é criada a primeira lista de imagens, com 16x16 pixeis
...........move 16 to w h
...........invoke ACMaskedImageList "Nova" using w h returning umaLista
...........invoke umaLista "adicionarIcone" using z"abrir16.ico"
..................returning icoAbrir
...........invoke umaLista "adicionarIcone" using z"novo16.ico"
..................returning icoNovo
...........invoke umaLista "adicionarIcone" using z"alter16.ico"
..................returning icoAlterar
...........invoke umaLista "adicionarIcone" using z"exclui16.ico"
..................returning icoExcluir
...........invoke umaLista "adicionarIcone" using z"lupa16.ico"
..................returning icoVisualizar
...........invoke umaLista "adicionarIcone" using z"gravar16.ico"
..................returning icoGravar
...........invoke umaLista "adicionarIcone" using z"cancel16.ico"
..................returning icoCancelar
...........invoke umaLista "adicionarIcone" using z"sair.ico"
..................returning icoSair

........*> Aqui é criada outra lista de imagens, com 128x128 pixeis
...........move 128 to w h
...........invoke ACMaskedImageList "Nova" using w h
..................returning umaListaBmp
...........invoke umaListaBmp "adicionarBitmap" using z"iphone1.bmp"
..................returning bmp1
...........invoke umaListaBmp "adicionarBitmap" using z"iphone2.bmp"
..................returning bmp2
...........invoke umaListaBmp "adicionarBitmap" using z"iphone3.bmp"
..................returning bmp3
...........invoke umaListaBmp "adicionarBitmap" using z"iphone4.bmp"
..................returning bmp4
...........invoke umaListaBmp "adicionarBitmap" using z"iphone5.bmp"
..................returning bmp5
...........invoke umaListaBmp "adicionarBitmap" using z"iphone6.bmp"
..................returning bmp6
...........invoke umaListaBmp "adicionarBitmap" using z"iphone7.bmp"
..................returning bmp7
...........invoke umaListaBmp "adicionarBitmap" using z"iphone8.bmp"
..................returning bmp8
............

......*---------------------------------------------------------------*
.......MontarToolbar section.
........*> Nessa seção, adicionamos cada um dos botões das toolbars
...........invoke umaToolbar "lista"
...........invoke umaToolbar "semDivisor"
...........invoke umaToolbar "flat"

...........invoke umaToolbar "setarListaDeImagens" using umaLista
...........invoke umaToolbar "setarListaDeImagensHot" using umaLista

...........invoke umaToolbar "adicionarBotao"
..................using umItemNulo icoNovo
..................returning umBotaoNovo
...........invoke umBotaoNovo "setarTexto"
..................using z" Novo"
...........invoke umBotaoNovo "setarTooltip"
..................using z"Botão Novo..."

...........invoke umaToolbar "adicionarSeparador"

...........invoke umaToolbar "adicionarBotao"
..................using umItemNulo icoAlterar
..................returning umBotaoAlterar
...........invoke umBotaoAlterar "setarTexto"
..................using z" Alterar"
...........invoke umBotaoAlterar "setarTooltip"
..................using z"Botão Alterar..."

...........invoke umaToolbar "adicionarBotao"
..................using umItemNulo icoExcluir
..................returning umBotaoExcluir
...........invoke umBotaoExcluir "setarTexto"
..................using z" Excluir"
...........invoke umBotaoExcluir "setarTooltip"
..................using z"Botão Excluir..."

...........invoke umaToolbar "adicionarBotao"
..................using umItemNulo icoVisualizar
..................returning umBotaoVisualizar
...........invoke umBotaoVisualizar "setarTexto"
..................using z" Visualizar"
...........invoke umBotaoVisualizar "setarTooltip"
..................using z"Botão Visualizar..."

...........invoke umaToolbar "mostrar"
............

......*---------------------------------------------------------------*
.......MontarToolbarGravar section.
........*> Nessa seção, adicionamos cada um dos botões das toolbars
...........invoke umaToolbarGravar "lista"
...........invoke umaToolbarGravar "semDivisor"

...........invoke umaToolbarGravar "setarListaDeImagens"
..................using umaLista
...........invoke umaToolbarGravar "setarListaDeImagensHot"
..................using umaLista

...........invoke umaToolbarGravar "adicionarBotao"
..................using umItemNulo icoGravar
..................returning umBotaoGravar
...........invoke umBotaoGravar "setarTexto"
..................using z" Gravar"
...........invoke umBotaoGravar "setarTooltip"
..................using z"Botão Gravar..."

...........invoke umaToolbarGravar "adicionarBotao"
..................using umItemNulo icoCancelar
..................returning umBotaoCancelar
...........invoke umBotaoCancelar "setarTexto"
..................using z" Cancelar"
...........invoke umBotaoCancelar "setarTooltip"
..................using z"Botão Cancelar..."

...........invoke umaToolbarGravar "adicionarSeparador"
...........invoke umaToolbarGravar "adicionarBotao"
..................using umItemNulo icoSair
..................returning umBotaoSair
...........invoke umBotaoSair "setarTexto"
..................using z" Sair"
...........invoke umBotaoSair "setarTooltip"
..................using z"Botão Sair..."

...........invoke umaToolbarGravar "mostrar"
............

......*---------------------------------------------------------------*
.......MontarToolbarLateral section.
........*> Nessa seção, adicionamos cada um dos botões das toolbars
...........invoke umaToolbarLateral "semDivisor"
...........invoke umaToolbarLateral "multiplasLinhas"

...........invoke umaToolbarLateral "setarListaDeImagens"
..................using umaListaBmp
...........invoke umaToolbarGravar "setarListaDeImagensHot"
..................using umaListaBmp

...........invoke umaToolbarLateral "adicionarBotao"
..................using umItemNulo bmp1
..................returning umBotao1
...........invoke umBotao1 "BotaoCheckGroup"

...........invoke umaToolbarLateral "adicionarBotao"
..................using umItemNulo bmp2
..................returning umBotao2
...........invoke umBotao2 "BotaoCheckGroup"

...........invoke umaToolbarLateral "adicionarBotao"
..................using umItemNulo bmp3
..................returning umBotao3
...........invoke umBotao3 "BotaoCheckGroup"

...........invoke umaToolbarLateral "adicionarBotao"
..................using umItemNulo bmp4
..................returning umBotao4
...........invoke umBotao4 "BotaoCheckGroup"

...........invoke umaToolbarLateral "adicionarBotao"
..................using umItemNulo bmp5
..................returning umBotao5
...........invoke umBotao5 "BotaoCheckGroup"

...........invoke umaToolbarLateral "adicionarBotao"
..................using umItemNulo bmp6
..................returning umBotao6
...........invoke umBotao6 "BotaoCheckGroup"

...........invoke umaToolbarLateral "adicionarBotao"
..................using umItemNulo bmp7
..................returning umBotao7
...........invoke umBotao7 "BotaoCheckGroup"

...........invoke umaToolbarLateral "adicionarBotao"
..................using umItemNulo bmp8
..................returning umBotao8
...........invoke umBotao8 "BotaoCheckGroup"

...........invoke umaToolbarLateral "mostrar"
...........move 4 to l
...........invoke umaToolbarLateral "setarLinhas" using l
............

......*---------------------------------------------------------------*
.......BotaoClicado section.
........*> Quando um botão é clicado, ele é informado para a classe
........*> ACUtils que retorna através do método abaixo, o botão que
........*> foi clicado
...........invoke ACUtils "botaoDaToolbarClicado"
..................returning umBotaoClicado
...........evaluate umBotaoClicado
.............when umBotaoNovo display "Botão novo clicado..."
.............when umBotaoAlterar display "Botão alterar clicado..."
.............when umBotaoExcluir display "Botão excluir clicado..."
.............when umBotaoVisualizar display "Botão visualizar clicado..."

.............when umBotao1 display "Botão calendário clicado..."
.............when umBotao2 display "Botão som clicado..."
.............when umBotao3 display "Botão telefone clicado..."
.............when umBotao4 display "Botão música clicado..."
.............when umBotao5 display "Botão email clicado..."
.............when umBotao6 display "Botão texto clicado..."
.............when umBotao7 display "Botão configuração clicado..."
.............when umBotao8 display "Botão sms clicado..."

.............when umBotaoGravar display "Botão gravar clicado..."
.............when umBotaoCancelar display "Botão cancelar clicado..."
.............when umBotaoSair display "Botão sair clicado..."
...........end-evaluate
............

......*---------------------------------------------------------------*
.......Call-Dialog-System SECTION.
...........CALL dialog-system USING Ds-Control-lock,
....................................Data-Block
...........IF NOT Ds-No-Error
..............MOVE Ds-System-Error TO Display-error
..............DISPLAY "DS ERROR NO: " Display-error-no
..............DISPLAY "Error Details(1) : " Display-Details-1
..............DISPLAY "Error Details(2) : " Display-Details-2
..............PERFORM Program-Terminate
...........END-IF
............

......*---------------------------------------------------------------*
.......Program-Terminate SECTION.
........*> Ao final, as listas de imagens devem ser finalizadas
...........invoke umaLista "deepFinalize" returning umaLista
...........invoke umaListaBmp "deepFinalize" returning umaListaBmp
...........stop run
............

Ao terminar de escrever esse artigo, eu comentava com um amigo sobre o assunto e ele me alertava sobre o fato de alguns mais "espertinhos" resolverem colaborar em grupo com o blog. Por exemplo, dividir simbólicos quarenta e nove reais entre quatro ou mais pessoas e depois os fontes serem distribuídos entre todos. Seria realmente lamentável se o fato ocorresse, até porque a colaboração que peço é apenas um incentivo às minhas pesquisas. Não penso em ficar rico escrevendo artigos para o NetAlexpress. O prazer em ver os amigos desenvolvedores evoluindo com a ferramenta é muito maior do que qualquer quantia em dinheiro. O NetAlexpress surgiu para ajudar a todos os desenvolvedores. E vai continuar da mesma forma. Aos "mais espertos", caso eles apareçam, apenas o meu lamento.

Criando uma Splash Screen

2008-07-28T17:53:00.015-03:00

Splash Screen é o termo usado para descrever uma imagem que aparece enquanto um programa está sendo carregado. Normalmente elas não ocupam toda a área de trabalho, mas apenas um retângulo próximo do centro da tela. Esse artigo mostra como fazer uma Splash Screen utilizando áreas transparentes de tela.

O artigo trata da utilização da API "SetLayeredWindowAttributes", que faz com que determinadas áreas de uma janela fiquem transparentes. Nesse exemplo, determinei que a cor vermelha de uma imagem deve ficar transparente. A seguir, você encontra algumas imagens de exemplo e como elas ficam no desktop, depois de prontas.

program-id. Imagens.
class-control.
....CallBack is class "callback"
....BitmapData is class "bitmapd"
....Window is class "window"
....Color is class "color".

special-names.
....call-convention 66 is WAPI.

data division.
working-storage section.
77 aCallback object reference value null.
77 aWindow object reference value null.
77 aBitmap object reference value null.
77 aDrawingSurface object reference value null.

77 moved pic s9(09) comp-5 value 51.
77 resized pic s9(09) comp-5 value 52.
77 destroyed pic s9(09) comp-5 value 53.
77 gainedfocus pic s9(09) comp-5 value 56.

01 oldwinproc procedure-pointer.
01 ws-retcode pic s9(09) comp-5 redefines oldwinproc.

77 ws-good-ptr procedure-pointer.
77 ws-bad-ptr procedure-pointer.
77 ws-byte pic 9(02) comp-5.
77 ws-ex-style pic x(4) comp-5.
77 wsFlags pic 9(09) comp-5 value zeros.

77 wsColor object reference value null.
77 wsColorref pic s9(09) comp-5 value zeros.

77 wJanela pic 9(09) comp-5 value zeros.
77 hJanela pic 9(09) comp-5 value zeros.
77 x pic s9(09) comp-5 value zeros.
77 y pic s9(09) comp-5 value zeros.
77 w pic s9(09) comp-5 value zeros.
77 h pic s9(09) comp-5 value zeros.
77 wDesktop pic 9(09) comp-5 value zeros.
77 hDesktop pic 9(09) comp-5 value zeros.

78 WS-EX-LAYERED value h"00080000".
78 LWA-COLORKEY value h"00000001".
78 GWL-EXSTYLE value -20.

78 dialog-system VALUE "DSGRUN".
78 SM-CXSCREEN value 0.
78 SM-CYSCREEN value 1.

01 Display-Error.
...03 Display-Error-No PIC 9(4) comp-5.
...03 Display-Details-1 PIC 9(4) comp-5.
...03 Display-Details-2 PIC 9(4) comp-5.

copy "ds-cntrl.mf".
copy "imagens.cpb".

procedure division.
Main-Process SECTION.
...PERFORM Program-Initialize
...PERFORM Program-Body UNTIL EXIT-FLAG-TRUE
...PERFORM Program-Terminate.

Program-Initialize SECTION.
...INITIALIZE Ds-Control-Block
...INITIALIZE Data-block
...MOVE Data-block-version-no TO Ds-Data-Block-Version-No
...MOVE Version-no TO Ds-Version-No
...MOVE Ds-New-Set TO Ds-Control
...MOVE "Imagens" TO Ds-Set-Name.

Program-Body SECTION.
...PERFORM Call-Dialog-System

...*>-----------------------------------------------------------
...*> Aqui nós lemos uma imagem no formato bmp.

...invoke BitmapData "fromFileZ" using z"dinheiro.bmp"
.................................returning aBitmap

...*>-----------------------------------------------------------
...*> A janela é capturada como um objeto da classe Window e é
...*> redimensionada para o tamanho da imagem lida.

...invoke Window "fromHandle" using winhandle returning aWindow
...invoke aBitmap "getWidth" returning w
...invoke aBitmap "getheight" returning h
...invoke aWindow "scaleXYUp" using w h
...invoke aWindow "setWidthHeight" using w h

...*>-----------------------------------------------------------
...*> Aqui pegamos a resolução do computador.

...call wapi "GetSystemMetrics" using by value SM-CXSCREEN
............................returning wDesktop
...call wapi "GetSystemMetrics" using by value SM-CYSCREEN
............................returning hDesktop

...*>-----------------------------------------------------------
...*> Aqui nós centralizamos a janela.

...invoke aWindow "getNativeWidthHeight" using wJanela hJanela
...compute x = (wDesktop - wJanela) / 2
...compute y = (hDesktop - hJanela) / 2
...invoke aWindow "scaleXYUp" using x y
...invoke aWindow "setXY" using x y

...*>-----------------------------------------------------------
...*> Abaixo, pegamos a área da janela onde será mostrada a imagem
...*> e colocamos a imagem na linha 0 com a coluna 0.

...invoke aWindow "getdrawingsurface" returning aDrawingsurface
...move 0 to X Y
...invoke aDrawingsurface "DrawBitmapAt" using aBitmap X Y

...*>-----------------------------------------------------------
...*> As linhas seguintes adicionam o atributo padrão do Windows
...*> para aplicar áreas transparentes em janelas. A constante
...*> LWA-COLORKEY indica que apenas a área que possui a cor
...*> especificada ficará transparente. Em nosso exemplo, a cor
...*> vermelha ficará transparente.

...set ws-bad-ptr to entry "MF?637364Rubbish"
...set ws-good-ptr to entry "SetLayeredWindowAttributes"
...if ws-good-ptr = ws-bad-ptr
......exit program *> somente nas versões ME/2000/XP/2003 ou superior
...end-if
...call wapi "GetWindowLongA"
..............using by value winhandle
....................by value GWL-EXSTYLE
....................returning ws-ex-style
...add ws-ex-layered to ws-ex-style
...call wapi "SetWindowLongA"
.............using by value winhandle
...................by value GWL-EXSTYLE
...................by value ws-ex-style
...................returning ws-retcode
...move LWA-COLORKEY to wsFlags
...move 0 to ws-byte
...invoke Color "lightRed" returning wsColor
...invoke wsColor "asColorRef" returning wsColorref
...invoke wsColor "finalize" returning wsColor
...call wapi "SetLayeredWindowAttributes"
.............using by value winhandle
...................by value wsColorref
...................by value ws-byte
...................by value wsFlags
...................returning ws-retcode
...end-call

...*>-----------------------------------------------------------
...*> As linhas a seguir informam à janela que um método deve ser chamado,
...*> sempre que um determinado evento ocorrer. Em nosso exemplo, toda vez
...*> que a janela for movimentada, redimensionada ou ganhar o foco,
...*> a imagem será mostrada novamente.

...invoke Callback "new" using aDrawingsurface
...............................z"DrawBitmapAt"
...............................aBitmap
...............................x
...............................y
...............................returning aCallback
...invoke aWindow "setEvent" using moved aCallback
...invoke aWindow "setEvent" using resized aCallback
...invoke aWindow "setEvent" using gainedfocus aCallback
...invoke aCallback "finalize" returning aCallback
...perform Call-Dialog-System.

Program-Terminate SECTION.
...STOP RUN.

Call-Dialog-System SECTION.
...CALL dialog-system USING Ds-Control-Block,
...Data-Block
...IF NOT Ds-No-Error
......MOVE Ds-System-Error TO Display-error
......DISPLAY "DS ERROR NO: " Display-error-no
......DISPLAY "Error Details(1) : " Display-Details-1
......DISPLAY "Error Details(2) : " Display-Details-2
......PERFORM Program-Terminate
...END-IF.

Você pode fazer o download do fonte desse programa no site do Clube Cobol, com o título "Criando uma Splash Screen".

Observação: esse artigo não tem o objetivo de ensinar os métodos e comandos utilizados. Por isso, alguns dos comandos apresentados não foram detalhadamente explicados.

Um toque de arte (parte 3)

2008-07-25T14:18:00.004-03:00

Incrível como as telas que mostram as interfaces dos sistemas feitos nos mais diversos compiladores COBOL fizeram sucesso. É o post com maior número de acessos do ano no blog. Aproveitem para apreciar mais algumas interfaces enviadas pelos nossos amigos desenvolvedores.

NetCobol - Interface enviada por Paulo Viana, de Brumado - BA

NetExpress - Interface enviada por Alexandre Cortez, de Santos - SP

Um toque de arte (parte 2)

2008-07-21T09:14:00.007-03:00

Os "artistas" por esse Brasil afora entenderam o recado e começaram a enviar suas "obras de arte". Colabore enviando você também as melhores telas dos seus sistemas, além de informar sua cidade e qual compilador utiliza.

Acucobol - Interfaces enviadas por Luciano Martin, de São Paulo - SP

NetCobol - Interface enviada por Nicola Losacco, de Maringá - PR

NetExpress/SP2 - Interfaces enviadas por Sérgio Rodrigues, de Campo Grande - MS

Continuem enviando suas telas para o meu email: alexandre@ciasoftonline.com.br

Um toque de arte

2008-07-16T17:04:00.015-03:00

Os desenvolvedores COBOL e suas interfaces. Se você possui uma interface interessante em alguma rotina de seus sistemas, mande uma screenshot para o meu email para que eu possa publicá-la. Todas as telas foram feitas utilizando o Dialog System, do Microfocus NetExpress.

Interfaces enviadas por Alfredo Saviolli, de Londrina - PR.

Interface enviada por Antônio João

Interface enviada por Alexandre Hogler, de Blumenau - SC

Interface enviada por Reinaldo Rodrigues, de Santos - SP

Interface enviada por Bruno Segato, de São Paulo - SP

Aguardem as próximas interfaces. Até mais.

Os malabaristas e as janelas

2008-07-10T09:00:00.004-03:00

Vamos "tentar" tornar simples a tarefa de centralizar uma janela no desktop ? Apesar do Dialog System servir como opção no desenvolvimento de interfaces gráficas do Microfocus NetExpress, ele não oferece nenhum recurso ao desenvolvedor para centralizar uma simples tela na área de trabalho. Apesar de eu adorar o COBOL e principalmente a ferramenta NetExpress, eu confesso que é uma vergonha para nós desenvolvedores ter que fazer "malabarismos" para centralizar uma simples janela no desktop.

Para centralizarmos a janela no desktop, precisamos criá-la no evento SCREENSET-INITIALIZED da GS, antes que a janela apareça para o usuário. Em nosso exemplo, nossa janela chama-se WIN-PRINCIPAL:

DS-FUNCAO X 30.0

SCREENSET-INIITIALIZED
..CALLOUT-PARAMETER 1 CONFIG-FLAG $NULL
..CALLOUT-PARAMETER 2 CONFIG-VALUE $NULL
..MOVE 15 CONFIG-FLAG
..MOVE 1 CONFIG-VALUE
..CALLOUT "dsrtcfg" 3 $PARMLIST
*
..CREATE-WINDOW WIN-PRINCIPAL
..MOVE "CENTRALIZARJANELA" DS-FUNCAO
..RETC

Note que no evento SCREENSET-INITIALIZED, a janela ainda não aparece para o usuário. O comando CREATE-WINDOW cria a janela e toda a sua estrutura interna mas a mesma ainda não aparece para o usuário. É o momento de pegarmos as coordenadas da janela, além de sua largura e altura, para reposicioná-la no desktop. Isso será feito no programa Cobol. Na procedure division, precisamos alterar a section Program-Body para executar nossa operação. Além disso, vamos utilizar alguns vocabulários do Dialog System, portanto, o vocabulary copybook deve ser gerado também. Abaixo, cada uma das alterações que devem ser feitas em seu fonte Cobol:

special-names.

call-convention 66 is WAPI.

class-control.

Window is class "window".

working-storage section.
77 handle8 pic 9(08) comp-x value zeros.
77 handle9 pic 9(09) comp-5 value zeros.

77 umaJanela object reference value null.

77 x pic 9(09) comp-5 value zeros.
77 y pic 9(09) comp-5 value zeros.

77 wDesktop pic 9(09) comp-5 value zeros.
77 hDesktop pic 9(09) comp-5 value zeros.
77 wJanela pic 9(09) comp-5 value zeros.
77 hJanela pic 9(09) comp-5 value zeros.

78 SM-CXSCREEN value 0.
78 SM-CYSCREEN value 1.

procedure division.

Program-Body SECTION.
....evaluate ds-Funcao
......when "CENTRALIZARJANELA" perform CentralizarJanela
....end-evaluate
....perform Call-Dialog-System.

CentralizarJanela section.
....move-object-handle win-principal handle8
....move handle8 to handle9
....invoke Window "fromHandleWithClass" using handle9 Window
....returning umaJanela

....call WAPI "GetSystemMetrics" using by value SM-CXSCREEN
....returning wDesktop
....call WAPI "GetSystemMetrics" using by value SM-CYSCREEN
....returning hDesktop

....invoke umaJanela "getNativeWidthHeight" using wJanela hJanela
....compute x = (wDesktop - wJanela) / 2
....compute y = (hDesktop - hJanela) / 2
....invoke umaJanela "scaleXYUp" using x y
....invoke umaJanela "setXY" using x y

Quase 3 dúzias de linhas de programação para centralizar uma janela no desktop. Se alguém tiver alguma outra solução melhor que essa, por favor, eu agradeceria muito se pudesse me enviar para que eu a publique aqui. Caso contrário, vou achar que a Microfocus realmente adora um "circo"...

Update: o post foi corrigido depois da observação do meu amigo Bruno. Obrigado, Bruno.

O aniversariante do mês

2008-06-18T14:18:00.002-03:00

Nesse mes, o blog está comemorando um ano de vida. Nesse primeiro aniversário, fiquei imaginando durante alguns dias o quanto nos sentimos órfãos das empresas que comercializam o compilador Cobol para nós desenvolvedores. Afinal de contas, grite aí quem teve realmente um bom suporte quando teve dúvidas na utilização da linguagem. Alguém aí já ligou pra Microfocus ? DTS ? Fujitsu ? Quando criei esse blog pensei justamente nos amigos desenvolvedores órfãos por todo esse país. Eu me sinto privilegiado, pois tenho tempo para pesquisas com a linguagem. O resultado disso são os inúmeros artigos, dicas e comentários que surgiram aqui nesse primeiro ano de vida do blog.

O blog já ajudou e tem ajudado muito os desenvolvedores que utilizam o Microfocus NetExpress como ferramenta de trabalho. E para outros desenvolvedores que utilizam outros compiladores,o blog serve como história em quadrinhos: diverte e chama atenção pelas cores e novidades.

Diante de tanta informação e sucesso com o blog, a minha caixa de entrada do Outlook Express passou a ficar lotada de email´s com pedidos de esclarecimentos de dúvidas, pedidos de consultoria, etc. Sem contar as inúmeras janelas do meu Messenger piscando com dúvidas dos amigos mais chegados. Isso me deixa muito contente, pois é fruto de muita dedicação na produção de todo o material publicado aqui no blog.

Apesar da comemoração desse primeiro aniversário, o blog nunca receceu qualquer tipo de investimento, colaboração ou doação financeira para se manter. Sempre foi fruto de dedicação de minha parte e de alguns poucos colaboradores que criaram artigos para abrilhantar mais ainda essa parceria entre nós desenvolvedores.

Por conta disso, a partir desse primeiro ano de vida do blog, eu quero oferecer um serviço de consultoria a qualquer desenvolvedor que utilize o Microfocus NetExpress. Nessa consultoria, o desenvolvedor poderá tirar dúvidas sobre a utilização do ambiente de desenvolvimento, Dialog System, componentes, além de iniciar na programação orientada ao objeto. Esse serviço de consultoria será feito através de emails´s e contatos via Messenger.

Essa consultoria visa atender aos amigos desenvolvedores de uma forma mais personalizada, além de oficializar todo o suporte que já ofereço hoje de forma gratuita. Assim, criamos uma parceria de forma que eu possa colaborar com todos e assim ter um retorno para viabilizar novas pesquisas e produzir novos artigos para o blog.

Eu pretendo me reunir também com as pessoas que administram o site do Clube Cobol para doar parte desses rendimentos com a consultoria, colaborando assim diretamente com a manutenção do site.

Sendo assim, criei alguns pacotes de consultoria para oferecer aos amigos desenvolvedores:

Plano Mensal....: R$ 149,00 (cento e quarenta e nove reais por mes)
Plano Trimestral: R$ 399,00 (trezentos e noventa e nove reais por trimestre)
Plano Semestral.: R$ 799,00 (setecentos e noventa e nove reais por semestre)

Através dessa consultoria, os desenvolvedores poderão obter informações sobre desenvolvimento de rotinas, implementação da POO em suas aplicações, desenvolvimento de componentes, utilização das classes do NetExpress e participar das pesquisas mais recentes que tenho feito para a melhor utilização da ferramenta. É a oportunidade que o desenvolvedor terá para obter mais recursos e modernidade às suas aplicações.

Para obter maiores informações sobre essa consultoria, entre em contato através do email a seguir:

alexandre.cia@iron.com.br

Um grande abraço a todos.

Garçom ! O menu, por favor !

2008-04-01T17:12:00.009-03:00

Utilizando um novo conceito em seus programas, você pode aprender a criar menus totalmente dinâmicos sem a utilização do Dialog System. E se quiser dar uma gorjeta ao garçom, utilize o link do PagSeguro, aqui mesmo no blog.

Através do método "getMenubar" da classe Window, podemos pegar o menu de uma janela e criar submenus e ítens de menus, com os métodos das classes Menubar, Submenu e Menuitem. Tudo isso no fonte Cobol, sem a necessidade de utilizar o Dialog System.

Dentro do Dialog System, um evento especial detecta quando um ítem de menu criado fora do Dialog System foi selecionado. Chama-se ANY-OTHER-MENU-EVENT. O registrador especial $EVENT-DATA contém a identificação do ítem de menu selecionado.

Com esse código identificador, basta retornar ao programa Cobol e utilizar o método "menuitemAtCommand", com o objeto da classe Window. Um comando evaluate pode então detectar qual ítem de menu foi selecionado.

O fonte com a demonstração desse artigo encontra-se disponível para download no site do Clube Cobol.

O segredo do External File Handler

2008-01-31T14:01:00.000-03:00

Aprendendo sobre alguns recursos do compilador Microfocus, é possível acessar bancos de dados sem mexer numa única linha de código dos seus programas que acessam arquivos indexados. Sim, isso é possível. Continue usando "read", "start", "open", mas tenha em suas mãos o banco de dados de sua preferência.

Esse artigo foi escrito baseado na versão 3.0 e 3.1 do NetExpress.

Conhecendo o External File Handler

Quando escrevemos em nossos programas comandos de acesso a um arquivo, um "open", um "read" ou um "start", o compilador converte esses comandos em chamadas para o executável EXTFH.EXE. Esse é o executável do runtime que realiza todas as operações de arquivos no compilador Microfocus. As chamadas são feitas exatamente como no código a seguir:

call "EXTFH" using Operacao DadosDoArquivo

Um código específico é enviado ao EXTFH quando efetuamos, por exemplo, um "open" em um arquivo. Além do código específico da operação, os dados do arquivo são passados através de uma estrutura de dados, que se encontra no arquivo XFHFCD.CPY, um "copybook file" que pode ser copiado em qualquer fonte Cobol. Esse arquivo encontra-se na pasta SOURCE, dentro da pasta de instalação do NetExpress.

A estrutura de dados XFHFCD.CPY

No arquivo de ajuda do Microfocus NetExpress não existem muitas informações sobre a estrutura de dados encontrada no arquivo XFHFCD.CPY, infelizmente. Porém, com um pouco de paciência, o desenvolvedor vai encontrar a descrição de alguns dos campos dessa estrutura, além da relação completa dos códigos que identificam as operações de arquivos passadas para o EXTFH.

Criando seu próprio External File Handler

O compilador Microfocus permite que o desenvolvedor crie seu próprio External File Handler. Assim, todas as chamadas das operações de arquivos serão feitas para esse programa. Com esse recurso, o desenvolvedor pode "interceptar" as operações de um determinado arquivo e intepretá-las da forma que desejar. A diretiva CALLFH indica qual programa deve ser chamado para interpretar as operações de arquivo:

$SET CALLFH"MEUFH"

Com essa diretiva definida em um programa, todas as operações de arquivos nesse programa serão convertidas para o código a seguir:

call "MEUFH" using Operacao DadosDoArquivo

O programa MEUFH.CBL

No exemplo a seguir, o programa MEUFH.CBL recebe os dados do programa chamador e simplesmente faz a chamada para o EXTFH, que é o External File Handler padrão da Microfocus, sem fazer qualquer alteração nas operações de arquivos:

program-id. MEUFH.

linkage section.

01 lnkOperacao pic xx.

01 lnkDadosDoArquivo.

copy "XFHFCD.CPY".

procedure division using lnkOperacao lnkDadosDoArquivo.

....call "EXTFH" using lnkOperacao lnkDadosDoArquivo

....exit program.

Obtendo outras informações do arquivo

Adicionando algumas linhas, poderíamos obter outras informações do arquivo:

program-id. MEUFH.

working-storage section.

77 wsTamanhoDoRegistro pic 9(09) comp-5.

linkage section.

01 lnkOperacao pic xx.

01 lnkDadosDoArquivo.

copy "XFHFCD.CPY".

01 lnkNomeDoArquivo pic x(1024).

01 lnkRegistro pic x(32767).

procedure division using lnkOperacao lnkDadosDoArquivo.

....*> Para saber o nome do arquivo

....set address of lnkNomeDoArquivo to fcd-filename-address

....*> Para saber o tamanho do registro

....move fcd-current-rec-len to wsTamanhoDoRegistro

....*> Para pegar o conteúdo do registro que foi passado

....set address of lnkRegistro to fcd-record-address

....call "EXTFH" using lnkOperacao lnkDadosDoArquivo

....exit program.

Acessando tabelas de um banco de dados

Com as informações básicas descritas acima, o desenvolvedor poderia identificar qual operação foi requisitada e em qual arquivo essa operação seria efetuada. Identificada a operação, bastaria efetuar no mesmo programa MEUFH.CBL, chamadas a parágrafos ou rotinas que processariam a operação específica, porém, utilizando a tabela correspondente em um banco de dados. utilizando e atualizando a variável que corresponde ao registro do arquivo, ao retornar para o programa chamador, todos os dados estariam devidamente atualizados, sem a necessidade real de qualquer alteração no programa que contém os comandos "open", "read" ou "start".

Exemplos práticos

Aos desenvolvedores que pesquisarem sobre esse assunto e conseguirem resultados práticos, sintam-se à vontade para enviarem seus materiais, projetos e programas, para que eu possa publicá-los e assim ajudar a outros desenvolvedores que desejam utilizar os mesmos recursos. Compartilhando a informação, teremos sempre o melhor do que a linguagem pode nos oferecer. Estarei sempre contando com a colaboração de vocês.

O Word ou o Excel estão instalados ?

2008-01-17T16:26:00.000-03:00

Quem utiliza a tecnologia OLE com o Microfocus NetExpress sabe da infinidade de recursos que tem em mãos, para manipular instâncias do Word ou do Excel, por exemplo. Mas o desenvolvedor ao distribuir suas aplicações, pode encontrar pela frente alguns micros que não possuem esses programas instalados. Com um método bem simples, o incômodo com algumas mensagens de erro do NetExpress pode ser evitado.

Em seu programa, na class-control, defina a classe a seguir:

class-control.
....OLESup is class "olesup"

Na working-storage section, defina a seguinte variável:

77 wsResult pic 9(09) comp-5 value zeros.

Na procedure division, coloque os seguintes comandos antes de tentar criar instâncias do Word, por exemplo:

invoke OLESup "isServerRegistered" using z"Word.Application"

returning wsResult

if wsResult not = zeros

....display "O Word não está instalado nesse micro."

....stop run

end-if

Se o resultado for "zero" na váriável wsResult, então é porque o Word está realmente instalado no micro. Caso contrário, você pode então informar ao usuário que o Word não está instalado no micro em questão.

TYPEDEF - Definindo tipos

2008-01-10T15:27:00.000-03:00

Uma colaboração de Jair da Silva.

As estruturas de dados complexas ou simples que precisam ser declaradas várias vezes no mesmo programa ou em vários programas, podem ser definidas com a definição de tipos, um conceito nativo da linguagem C. Outro conveniente destas estruturas pré-definidas é que naquele momento que a memória nos falha recusando-se a lembrar qual o formato e/ou o tipo de dados deve ser definido para a chamada de uma classe ou uma função de biblioteca.

A declaração de estrutura é feita assim:

01 wsbdDataZ pic 9999/99/99 typedef.

01 wsbdDataX pic x(20) typedef.

01 wsbdDataXEd typedef.

...02 wsbdAnoX pic 9(04).

...02 f pic x(01).

...02 wsbdMesX pic 9(02).

...02 f pic x(01).

...02 wsbdDiaX pic 9(02).

...02 f pic x(01).

...02 wsbdHorX pic 9(02).

...02 f pic x(01).

...02 wsbdMinX pic 9(02).

...02 f pic x(01).

...02 wsbdSegX pic 9(02).

...02 f pic x(01).

01 wsbdData9 pic 9(08) typedef.

01 wsbdData9Ed typedef.

...02 wsbdDia9 pic 9(02).

...02 wsbdMes9 pic 9(02).

...02 wsbdAno9 pic 9(04).

Dispondo estas estruturas num arquivo à parte (um copybook, que em nosso exemplo poderia ser o arquivo tiposdef.cpy), podemos incluí-lo em qualquer ponto do programa e em qualquer programa. Aqui neste exemplo, definimos os campos com formatação de datas que são retornados pelos SGBDs mais comuns. Seu uso prático é descrito a seguir:

WORKING-STORAGE SECTION.
copy tiposdef.cpy.
01 Data-VctoX wsbdDataX.
01 Data-VctoXEd redefines Data-VctoX wsbdDataXEd.
01 Data-Vcto9 wsbdData9.

01 Data-PgtoX wsbdDataX.
01 Data-PgtoXEd redefines Data-PgtoX wsbdDataXEd.
01 Data-Pgto9 wsbdData9.

EXEC SQL
SELECT * FROM tabela (campos .... :Data-VctoX:Data-PgtoX ...)

WHERE campo-a = 'B200'
END-EXEC

Transformando a data de vencimento no padrão tupiniquim:

move wsbdDiaX of Data-VctoXEd to wsbdDia9 of Data-Vcto9.
move wsbdMesX of Data-VctoXEd to wsbdMes9 of Data-Vcto9.
move wsbdAnoX of Data-VctoXEd to wsbdAno9 of Data-Vcto9.

Agora temos em Data-Vcto9 nossa formatação tradicional.

Outros tipos podem ser criados dependendo aí da necessidade e da criatividade de cada desenvolvedor.

API´s: usando o arquivo WINDOWS.CPY

2008-01-03T20:56:00.000-03:00

Quando trabalhamos com funções do Windows - as chamadas API´s - precisamos definir variáveis e utilizar algumas constantes que por vezes confundem os desenvolvedores Cobol, personagens que verdadeiramente não estão muito acostumados a determinadas convenções existentes no SDK (System Development Kit) da Microsoft. O arquivo WINDOWS.CPY que vem junto ao Microfocus NetExpress, pode ser incluído via "copy" nos programas para facilitar e auxiliar o desenvolvedor na definição de variáveis e na utilização de constantes ou estruturas necessárias para a utilização das API´s.

Para utilizar o arquivo WINDOWS.CPY, vc precisa copiá-lo no início do seu programa. Antes mesmo da cláusula PROGRAM-ID:

copy "windows.cpy".
program-id. TesteAPI.

Caso utilize o arquivo WINDOWS.CPY em uma classe, coloque o "copy" antes da cláusula CLASS-ID:

copy "windows.cpy".
class-id. TesteAPI inherits from Base.

Nos dois casos, o compilador trata de referenciar automaticamente o arquivo WINDOWS.CPY a partir da pasta onde ele se encontra, que é a pasta SOURCE, dentro da pasta de instalação do Microfocus NetExpress.

Com o "copy" do arquivo WINDOWS.CPY fica mais fácil para o desenvolvedor definir determinadas variáveis que são encontradas em muitos exemplos na internet. Quando você encontrar um exemplo em C++ ou C# com uma definição de variável como a que mostro a seguir, com a utilização do arquivo WINDOWS.CPY é provável que você consiga definir as variáveis da mesma forma, diretamente no fonte Cobol. Isso porque o arquivo WINDOWS.CPY possui uma série de "typedef´s" identificando os principais tipos de variáveis utilizada. Typedef é um recurso que o compilador da Microfocus oferece para que o desenvolvedor possa criar estruturas de dados e utilizá-las no fonte Cobol, como uma definição básica. Esse recurso será tema de um artigo mais detalhado, em breve aqui no blog.

Veja a imagem a seguir das variáveis utilizadas na API "SendMessage" e como ficariam as mesmas definições de variáveis no fonte Cobol:

Baseado nas informações da imagem mostrada, definiríamos as variáveis envolvidas na API "SendMessage" da seguinte forma:

working-storage section.
77 wsHwnd HWND.
77 wsMsg UINT.
77 wsWParam WPARAM.
77 wsLParam LPARAM.
77 wsResult LRESULT.

Pode parecer um pouco estranho definir variáveis dessa forma em um fonte Cobol, mas a intenção da Microfocus foi facilitar a utilização dessas variáveis, tão comumente encontradas em programas ou funções escritas em C ou em outras linguagens semelhantes.

Além dos diversos tipos de variáveis, a maioria das API´s também já estão pré-definidas como constantes no arquivo WINDOWS.CPY. Com isso, uma chamada a uma API pode ser feita declarando explicitamente o nome da mesma no fonte Cobol:

call wapi SendMessage using by value wsHwnd
by value wsMSG
by value wsWParam
by value wsLParam
returning wsResult

A utilização de "typedef´s" ajuda a padronizar a definição de variáveis e estruturas. Como dito anteriormente, em um próximo artigo vou abordar esse assunto com detalhes, para exemplificar a utilização desse recurso em programas Cobol.

INT, GNT, LBR, EXE ou DLL ?

2007-11-30T07:25:00.000-03:00

Se você desenvolve aplicações Window ou UNIX utilizando o Micro Focus COBOL certamente já encontrou diferentes formatos de arquivos executáveis, como int, gnt, lbr, exe, dll, entre outros. Se você tem dúvidas sobre as diferenças entre esses formatos, esse artigo pode esclarecer algumas delas.

INT - Intermediate Code

Esse tipo de código foi introduzido pela Micro Focus por dois motivos principais: tamanho e portabilidade. Para executar esse código intermediário é necessário um interpretador, que fica dentro do Cobol Runtime System. Para entender um código intermediário, imagine uma série de chamadas a sub-rotinas. O interpretador contém sub-rotinas que manipulam cada instrução do código intermediário. Cada instrução lida do código intermediário, faz uma chamada para uma rotina específica no interpretador, que manipula essa instrução. Depois que a instrução é executada, o interpretador retorna o comando ao código intermediário para pegar a próxima instrução.

Assim que um programa é compilado e um código intermediário é gerado, tudo o que é necessário para executá-lo é o COBOL Runtime System. Por isso, se o Runtime System foi portado para uma nova plataforma, a aplicação estará disponível para ser executada sem a necessidade de ser recompilada.

Pelo fato do código intermediário ser interpretado, a performance de aplicações que executam um quantidade considerável de operações pode ser relativamente lenta.

GNT - Generated Code

Arquivos do tipo generated code contém código de máquina nativo, específico do processador que você está usando, diferentemente dos arquivos que usam o intermediate code. Por isso, os compiladores criam otimizações no código gerado para executá-lo o mais rápido possível, fazendo com que a performance das aplicações seja significantemente mais rápida, visto que o Runtime System não precisa interpretar instruções quando as aplicações são executadas.

Apesar dos arquivos generated code possuírem código nativo, eles também necessitam do COBOL Runtime System para serem carregados e executados. Porém, um intepretador não é necessário, pois o COBOL Runtime System oferece o suporte necessário para a execução do programa.

LBR - Library files

Enquanto a organização de aplicações em diversos módulos oferece um gerenciamento mais eficiente de memória, além de possibilitar que equipes de desenvolvimento trabalhem na mesma aplicação efetivamente, como resultado disso uma simples aplicação pode conter uma quantidade enorme de arquivos INT ou GNT a serem distribuídos. Isso traz algumas dificuldades para o gerenciamento da distribuição dessas aplicações, em comparação às aplicações linkadas em um único executável. Dando importância a esse detalhe, a Micro Focus então introduziu o conceito de library (lbr) files. Uma ferramenta chamada Library Manager foi criada permitindo aos desenvolvedores distribuírem diversos arquivos GNT e INT dentro de um único arquivo LBR. Ao invés de múltiplos arquivos INT e GNT, o desenvolvedor tem que distribuir apenas um arquivo LBR (ou mais, se desejar) e o COBOL Runtime System.

DLL - Dynamic Link Library
Em meados de 80, quando a IBM lançou o OS/2, sistema operacional que promovia muitas facilidades no gerenciamento de memória, também foi introduzido o conceito de dynamic link libraries (DLL´s). Uma DLL é um arquivo executável linkado que pode ser carregado dinamicamente por um programa quando necessário. E qual a importância desses arquivos para os desenvolvedores COBOL ? O uso de arquivos INT e GNT é perfeito se você desenvolve unicamente em COBOL e o COBOL Runtime System oferece todo o suporte adicional necessário para isso. Porém, se você deseja utilizar múltiplas linguagens de programação ou se você necessita chamar rotinas do sistema operacional que não são acessíveis utilizando o COBOL Runtime System, compilar programas para INT ou GNT não seria o mais conveniente, como você verá a seguir.

A utilização de API´s do sistema operacional
O Windows e o OS/2 trouxeram aos desenvolvedores o conceito de interface para programação de aplicações (Application Programming Interface - API). São funções que permitem escrever um programa utilizando uma linguagem de alto nível para acessar diretamente os recursos do sistema operacional. Para oferecer acesso a essa enorme variedade de funções API aos desenvolvedores COBOL, a Micro Focus vem adicionando recursos à linguagem COBOL desde os anos 80, que possibilitam aos desenvolvedores fazerem chamadas diretas às API´s. Porém, o uso de arquivo INT e GNT traziam um problema para acessar essas API´s, pois todas elas se encontram em arquivos DLL. Por padrão, para acessar uma API você precisa linkar a sua aplicação com um import library para a DLL que contém a API. Uma import library contém um código que localiza cada função em tempo de execução e a torna acessível para uma aplicação. Pelo fato de arquivos INT e GNT não serem linkados, teoricamente não seria possível a esses programas localizarem a API desejada. Apesar da teoria, sabemos que a Micro Focus oferece mecanismos alternativos para acessar API´s a partir de arquivos INT ou GNT, mas o modo mais eficiente de acessar uma API seria realmente compilar o programa para um OBJ e linká-lo com a import library correspondente.

Você também achará mais fácil utilizar arquivos DLL se estiver desenvolvendo aplicações que utilizam diferentes linguagens de programação.

E qual formato executável deve ser utilizado ?
Diante de tantos formatos diferentes de arquivos executáveis que você pode criar utilizando o Micro Focus COBOL, pode ser difícil decidir qual deles utilizar. As linhas a seguir podem lhe ajudar na escolha, mas isso também pode depender de alguns detalhes em particular de cada aplicação.

Portabilidade versus performance

Um código escrito em Micro Focus COBOL é praticamente portável sobre todas as plataformas existentes, considerando, é claro, que nenhuma chamada a uma API foi feita para um sistema operacional específico. Para isso, o código-fonte COBOL simplesmente deve ser compilado pelo Micro Focus COBOL para cada uma das plataformas.

Arquivo INT são totalmente portáveis. Um arquivo INT compilado para uma aplicação desenvolvida originalmente em uma plataforma Windows pode ser portado para diversas outras plataformas, como Sun Solaris, HP/UX, Linux e muitas outras plataformas UNIX. Se essa noção de portabilidade parece ser familiar, deve ser porque o JAVA chamou muita atenção com o conceito de "write once, run anywhere" (escreva uma vez, execute em qualquer lugar). Esse conceito não é novo para a Micro Focus, que já possibilitava aos desenvolvedores fazerem isso há mais de 20 anos.

O lado negativo de um arquivo INT é a performance. Pelo fato de ser interpretado, a performance nem sempre á tão boa quanto a de um arquivo GNT. O nível de performance pode variar, dependendo da funcionalidade da sua aplicação. Se sua aplicação gasta um pequeno tempo lendo ou gravando arquivos ou aguardando por alguma digitação do usuário, então a diferença de performance entre o arquivo INT e o arquivo GNT dificilmente deve comprometer a sua aplicação. Porém, se sua aplicação executa uma quantidade expressiva de cálculos e outras operações, então a diferença de performance pode ser muito significante.

Se sua aplicação foi desenvolvida para ser distribuída em diversas plataformas e não faz uso de algum recurso específico de um sistema operacional, então o uso de arquivos INT é recomendável. Apenas você pode determinar se a performance na utilização de arquivos INT atende às suas necessidades.

Arquivos GNT ou DLL ? O que utilizar ?
Se você pretende distribuir sua aplicação em uma plataforma única ou se a performance é um ponto crítico em seu sistema, então não considere a criação de arquivos INT. A próxima decisão é saber quando utilizar arquivos GNT ou DLL.

Se você já utiliza o Micro Focus COBOL há algum tempo e faz uso de arquivos GNT, então mantenha sua opção. Principalmente se você não necessita acessar API´s ou funções escritas em outras linguagens.

Se você está migrando para o Micro Focus COBOL ou se possui uma aplicação que faz uso de API´s ou funções de outras linguagens, então você deve considerar o link de sua aplicação em um arquivo EXE e seus sub-programas em arquivos DLL.

Minhas considerações
O texto escrito acima foi traduzido e resumido do seu original, no site da Micro Focus (www.microfocus.com). O texto é de autoria de Wayne Rippin. É um texto do ano de 2002 e de lá pra cá muita coisa mudou no compilador da Micro Focus, nos equipamentos, nas linguagens. Eu, particularmente, já utilizei quase todos os tipos de arquivos descritos anteriormente. A opção atual em minha empresa é a utilização de um executável principal (EXE) e a chamada às minhas sub-rotinas é feita em arquivos GNT. As classes que crio em minhas aplicações (POO) também são geradas em arquivos GNT. Algumas bibliotecas de funções específicas dos meus sistemas encontram-se em arquivos DLL. O "mix" entre todas essas opções de arquivos é perfeitamente possível, como você pode observar. Resta ao desenvolvedor determinar que tipo de arquivo melhor se encaixa de acordo com as necessidades de cada aplicação. Eu diria até que seria extremamente válido experimentar cada um desses tipos e saborear aquele que melhor gosto teve para o desenvolvedor.

Agora eu aguardo as considerações de vocês. As opiniões serão muito bem vindas.

NetExpress: a evolução da ferramenta

2007-11-18T15:47:00.000-03:00

A partir da versão 3.1

COBOL/JAVA Interoperability and EJB Wrapping
Facilidade de trabalhar com COBOL e módulos Java sem a necessidade de utilizar Java Native Interface (JNI)

Data Tools
Data Tools suporta arquivos indexados superiors a 2GB (IDX Format 8)

Dialog System
Maior número de Common Controls é suportado pelo produto. Geração através de Command Line do copyfile de uma Screenset

Internet Application Wizard
Disponível a geração de aplicações ISAPI através do Internet Application Wizard.

Microsoft Terminal Server
Net Express está homologado para trabalhar com Microsoft Windows NT Terminal Server e Microsoft Windows 2000 Terminal Services.

A partir da versão 3.1 Sp1

OLE Automation
Maior número de Data Types suportados pela programação OLE. Agora é possível trabalhar com campos COMP-3, COMP-X e COMP.

OpenESQL
Inclusão de ODBC Driver para XDB no produto Net Express. ODBC driver permite Autocommit para facilitar o processo de validação de código fonte.

Projects
Geração de projetos no Net Express a partir do DOS prompt.
SQL Option for DB2
Net Express inclui um SQL Option for DB2 Database. Esta facilitadade permite a conectividade do produto com o Mainframe IBM.

NLS changes
No Run-time para o produto Dialog System. O tempo de execução entre o Front-end do produto e a aplicação COBOL fica muito reduzido.
Screen Resolution Support
Inclusão de auto-definição na resolução dos Front-ends Dialog System. Este suporte permite que o Front-end seja criado com uma definição de monitor e ser ajustado automaticamente para outras definições.

Internet Explorer 6.0 Support
Suporte ao Microsoft Internet Explorer 6. A versão 5 do produto da Microsoft continua sendo suportada.

A partir da versão 4.0

Web Services
Net Express agora permite o desenvolvimento de WebServices COBOL sem a necessidade de software de terceiros.

COBOL/ J2EE Interoperability
A versão 4.0 do produto permitei gerar EJBs a partir de uma aplicação COBOL existente.

Micro Focus Enterprise Server
Enteprise Server permite a publicação de WebServices COBOL e COBOL/J2EE applications.

COBOL/ XML Support
Nova sintaxe é implementada ao File Handler do Micro Focus COBOL. Possibilita a manipulação de arquivos XML através de comandos COBOL.

Microsoft .NET Interoperability
Nova Interface Mapping Toolkit suporta o desenvolvimento de COM Objects a partir de uma aplicação COBOL existente.

Combined Documentation
Toda a documentação do software agora está disponível em HTML format.

SQL Option for DB2
SQL Option for DB2 agregou as funcionalidades do DB2 version 7.

Windows Server 2003 / XP Professional / 2000 SP 2
Somente o Net Express versão 4.0 é homologado para o Windows XP Professional/ Windows 2000 SP 2 e Windows 2003 32 Bit Mode.

A partir da versão 5.0

Rebuild
Utilitário REBUILD tem uma melhora considerável na performance, utilizando melhor espaço em disco para reconstruir arquivos Indexados.

Test Coverage
Esta funcionalidade permite que a área de QA Testing tenha uma documentação em formato HTML ou Texto da execução de um programa COBOL.

ISO 2002 COBOL Support
A arquitetura de escrita ISO 2002 COBOL foi incluida no compilador Net Express.

64-bit support
Net Express IDE pode ser utilizado para desenvolvimento de aplicações nativas em Windows 64 Bits (x64 ou Itanium 2).

CICS extension
Interface Mapping Toolkit tem suporte para extensão de aplicações CICS, permitindo criação de Service Interface baseado em um programa COBOL. Suporte a COMMAREA também foi implementado ao software.

Client/ server binding
Aplicações baseadas no Enterprise Server, agora podem ser publicadas no Micro Focus Server for SOA e o limite de 300 clients para cada objeto não existe mais. Agora o acesso simultâneo é ilimitado.

Demonstrations
Novos programas de exemplo foram implementados na versão 5.0 do produto. Agora é possível encontrar programas que demonstram os tópicos abaixo:

1. .NET Managed COBOL
2. Multithreading Applications
3. WebBook e WinBook Forms

Fonte: www.mundocobol.com.br

Criando listas de imagens

2007-11-07T09:08:00.000-03:00

Muitos dos componentes do Windows como o listview, toolbar, treeview, entre outros, utilizam listas de imagens para mostrar ícones ou bitmaps. Aprenda a criar listas de imagens com ícones em tempo de execução e faça uso desse recurso em suas aplicações.

São instâncias da classe MaskedImageList que são passadas como parâmetro para os principais componentes do Windows que utilizam listas de imagens. Essas listas de imagens utilizam instâncias da classe Icondata, que carregam um arquivo de ícone em memória.

O exemplo a seguir mostra como criar uma lista de imagens e como usá-la em um listview. O exemplo considera que um listview foi criado no programa, representado por uma variável na GS denominada umListview (obj-ref).

Defina na class-control, as classes que serão utilizadas:

class-control.

....Icondata is class "icondata"

....MaskedImageList is class "mskimglt".

Na working-storage section, crie as seguintes variáveis:

working-storage section.
77 umaLista object reference value null.

77 umIcone object reference value null.

77 wsNumeroDoIcone pic 9(09) comp-5 value zeros.

77 wsAltura pic 9(09) comp-5 value zeros.

77 wsLargura pic 9(09) comp-5 value zeros.
77 wsNumeroDoItem pic 9(09) comp-5 value zeros.

77 umItem object reference value null.

Depois de criado o listview, criaremos a lista de imagens que vai armazenar os ícones que serão utilizados. A classe MaskedImageList cria a lista recebendo como parâmetros a largura e a altura dos ícones, em pixéis:

CriarListaDeImagens section.

....move 16 to wsLargura wsAltura

....invoke MaskedImageList "new" using wsLargura wsAltura

....returning umaLista

Para adicionar ícones à lista, precisamos criar instâncias da classe Icondata. Para isso, vamos utilizar o método "fromFileZ". Essas instâncias serão adicionadas à lista de imagens pelo método "AddIcon". Esse método adiciona um ícone à lista e retorna como parâmetro um índice que vai identificar o ícone na lista de imagens. Depois de criada a lista de imagens, ela é passada ao listview como parâmetro do método "setSmallImages". Como a lista de imagens foi criada com ícones de 16x16 pixéis, então devemos utilizar arquivos de ícones que possuam essas mesmas características:

AdicionarIcones section.

....invoke IconData "fromFileZ" using z"printer.ico"

....returning umIcone

....invoke umaLista "addIcon" using umIcone returning wsNumeroDoIcone

....invoke IconData "fromFileZ" using z"disk.ico"

....returning umIcone

....invoke umaLista "addIcon" using umIcone returning wsNumeroDoIcone

....invoke umListview "setSmallImages" using umaLista

.....

Para indicar ao listview qual ícone utilizar em um determinado ítem, primeiro devemos pegar o ítem como uma instância da classe ListviewItem e utilizar o método "SetImageIndex", passando o índice que representa o ícone escolhido:

SetarIcones section.

....move 1 to wsNumeroDoItem

....invoke umListview "itemAtIndex" using wsNumeroDoItem

....returning umItem

....move 1 to wsNumeroDoIcone

....invoke umItem "setImageIndex" using wsNumeroDoIcone

Outros ícones podem ser adicionados a lista e outros ítens do listview podem ser mudados, utilizando os métodos demonstrados acima. Você pôde notar que os comandos mostrados necessitaram uma quantidade razável de linhas de código. A Programação Orientada ao Objeto possibilita que você crie a sua própria classe Listview e com isso, possa otimizar todos os procedimentos demonstrados nesse artigo.

Estou procurando representantes em outras cidades para que eu possa apresentar o Workshop - Programação Orientada ao Objeto com o Microfocus NetExpress. Saiba mais sobre o Workshop clicando aqui.

Workshop em Porto Alegre

2007-10-30T10:37:00.000-03:00

ALTERAÇÃO DE DATAS !!!

Devido a grande procura de pessoas interessadas tivemos que alterar as datas da apresentação do workshop em Porto Alegre, para adequarmos o local à quantidade de pessoas. A apresentação que estava marcada originalmente para os dias 10 e 11 de novembro de 2007 mudou para os dias 1 e 2 de dezembro de 2007.

Mais informações pelos emails abaixo:

alexandre.cia@iron.com.br

fcgatti@gatti.com.br

Clique na imagem para ampliá-la

Leia mais sobre o Workshop clicando aqui.

Uma StatusBar em tempo de execução

2007-10-26T08:59:00.000-03:00

Você gosta daquelas barras de status com seções recheadas de ícones, textos de ajuda ou barras de progresso ? Aprenda a criar uma barra de status em tempo de execução e mude o visual de suas aplicações.

Os exemplos que são colocados aqui no blog sempre levam em consideração a utilização dos recursos de vocabulários nas aplicações. Leia mais sobre o assunto no artigo "Aumentando o seu vocabulário".

Defina o tipo de chamada das API´s:

special-names.
call-convention 66 is wapi.

Definas as classes que serão utilizadas:

class-control.
ProgressBar is class "progress"
Window is class "window"
CharacterArray is class "chararry"
Icondata is class "icondata"
.

Defina as seguintes variáveis na working-storage section:

77 umaWindow object reference value null.
77 umaStatusbar object reference value null.
77 umaBarra object reference value null.
77 umIconeImpressora object reference value null.
77 umIconeOk object reference value null.
77 umTexto object reference value null.

77 handle8 pic 9(08) comp-x value zeros.
77 wHandle pic 9(09) comp-5 value zeros.
77 sHandle pic 9(09) comp-5 value zeros.
77 iHandle pic 9(09) comp-5 value zeros.

77 wsSecao pic 9(09) comp-5 value zeros.
77 wsLargura pic 9(09) comp-5 value zeros.
77 wsTotal pic 9(09) comp-5 value zeros.

77 x pic s9(09) comp-5 value zeros.
77 y pic s9(09) comp-5 value zeros.
77 w pic 9(09) comp-5 value zeros.
77 h pic 9(09) comp-5 value zeros.
77 hBarra pic 9(09) comp-5 value zeros.
77 hWindow pic 9(09) comp-5 value zeros.

78 SB-SETICON value 1039.

Na procedure division, a section abaixo captura a window principal da sua GS, criando assim uma instância da classe Window. Em nosso exemplo, a window principal definida dentro da GS chama-se win-principal. Em seguida, o método "addStatusbar" adiciona uma barra de status à window. A partir daí, tres seções serão criadas na barra de status. A primeira seção irá conter um ícone e um texto. Na segunda seção, criaremos uma barra de progresso que poderá ser usada pela aplicação. Na terceira e última seção da barra de status colocaremos outro ícone e mais um texto de exemplo. Veja os comandos a seguir:

CriarStatusBar section.
move-object-handle win-principal handle8
move handle8 to wHandle
invoke Window "fromHandleWithClass" using wHandle Window
returning umaWindow

*>--------------------------------------------------------
*> o método "addStatusBar" adiciona uma barra de status
*> à window

invoke umaWindow "addStatusbar" returning umaStatusbar
invoke umaStatusbar "create"

*>--------------------------------------------------------
*> os comandos a seguir pegam a altura da barra de status
*> e somam com a altura da window, em pixéis, para que a
*> a barra de status não esconda nenhum objeto que já exista
*> na window, perto de sua base

invoke umaWindow "getHeight" returning hWindow
invoke umaStatusbar "getHeight" returning hBarra
add hBarra to hWindow
invoke umaWindow "setHeight" using hWindow

*>--------------------------------------------------------
*> o método "setNumberOfParts" cria 3 seções na barra de status

move 3 to wsTotal
invoke umaStatusBar "setNumberOfParts" using wsTotal

*>--------------------------------------------------------
*> o método "setSectionWidth" ajusta o tamanho de uma seção

move 1 to wsSecao
move 400 to wsLargura
invoke umaStatusBar "setSectionWidth" using wsSecao wsLargura

move 2 to wsSecao
move 400 to wsLargura
invoke umaStatusBar "setSectionWidth" using wsSecao wsLargura

move 3 to wsSecao
move 800 to wsLargura
invoke umaStatusBar "setSectionWidth" using wsSecao wsLargura

*>--------------------------------------------------------
*> o método "SetSectionText" coloca um texto em uma seção.
*> Note que o método necessita de uma instância da classe
*> CharacterArray, passada como parâmetro.

invoke CharacterArray "withValue" using z"Relatório"
returning umTexto
move 1 to wsSecao
invoke umaStatusbar "setSectionText" using wsSecao umTexto
invoke umTexto "finalize" returning umTexto

*>--------------------------------------------------------
*> A classe Icondata cria uma instância a partir da informação
*> de um arquivo de ícone. Essas instâncias são utilizadas como
*> parâmetros em métodos de diversas classes
*> O método "getID" retorna o handle que representa o ícone

invoke IconData "fromFileZ" using z"printer.ico"
returning umIconeImpressora
invoke umIconeImpressora "getID" returning iHandle

*>--------------------------------------------------------
*> Agora usamos a mensagem SB-SETICON para colocar um ícone
*> em uma seção da barra de status.
*> Note que a API "SendMessageA" utiliza o número da seção
*> a partir do zero. Ou seja, a primeira seção é a seção
*> zero, a segunda seção é a seção número um, e assim por diante.

move 0 to wsSecao *> na verdade, representa a primeira seção
invoke umaStatusbar "getID" returning sHandle
call WAPI "SendMessageA" using by value sHandle
by value SB-SETICON size 4
by value wsSecao
by value iHandle

*>--------------------------------------------------------
*> A classe ProgressBar cria a barra de progressos, usando
*> como "parent window" a nossa barra de status.
*> Para posicionar a barra de progressos na seção correta,
*> precisamos pegar dados da seção, como linha, coluna,
*> largura e altura. Alguns ajustes foram feitos com essas
*> informações para centralizar a barra de progressos na seção

invoke Progressbar "new" using umaStatusbar
returning umaBarra
move 2 to wsSecao
invoke umaStatusbar "getSectionRect" using wsSecao x y w h
invoke umaBarra "create"
add 4 to y
add 2 to x
subtract 8 from w h
invoke umaBarra "setNativeXY" using x y
invoke umaBarra "setNativeWidthHeight" using w h
invoke umaBarra "show"

*>--------------------------------------------------------
*> Abaixo, colocamos um outro ícone e um novo texto na
*> terceira seção

invoke IconData "fromFileZ" using z"gravar16.ico"
returning umIconeOk
invoke umIconeOk "getID" returning iHandle

move 2 to wsSecao
invoke umaStatus "getID" returning sHandle
call WAPI "SendMessageA" using by value sHandle
by value SB-SETICON size 4
by value wsSecao
by value iHandle

invoke CharacterArray "withValue" using z"Alexandre Cortez"
returning umTexto
move 3 to wsSecao
invoke umaStatusbar "setSectionText" using wsSecao umTexto
invoke umTexto "finalize" returning umTexto

A partir daí, basta utilizar as rotinas acima para manipular cada uma das seções com outros ícones, outros textos e até mesmo utilizar a barra de progresso que foi criada.

Listview: mudando a cor de fundo

2007-10-19T09:45:00.000-03:00

Muitas pessoas me perguntam como alterar a cor de fundo de um Listview. O método "setBackgroundRGB" altera a cor de fundo da maioria dos componentes visuais do Windows. Veja como utilizá-lo:

Defina as seguintes variáveis na working-storage section:

77 wsRed pic 99 comp-5 value zeros.

77 wsGreen pic 99 comp-5 value zeros.

77 wsBlue pic 99 comp-5 value zeros.

Depois de criado o Listview, utilize o método "setBackgroundRGB":

move 255 to wsRed
move 255 to wsGreen
move 215 to wsBlue
invoke umListview "setBackgroundRGB" using wsRed wsGreen wsBlue

Os valores para wsRed, wsGreen e wsBlue podem ser encontrados em qualquer editor de desenhos, como o Paintbrush, por exemplo.

Clipboard: copie e cole !

2007-10-17T15:22:00.000-03:00

Uma classe simples de utilizar no NetExpress é a classe Clipboard. Com ela, você pode ler ou gravar informações na área de transferência do Windows. A classe só permite a gravação e a leitura de sequências de caracteres.

Defina as classes que serão utilizadas:

class-control.

Clipboard is class "clipbrd"

CharacterArray is class "chararry"

Defina as variáveis da working-storage section:

77 umaString object reference value null.

77 wsTexto pic x(255) value spaces.

A classe Clipboard trabalha com objetos (instâncias) da classe CharacterArray. Portanto, para gravar dados na área de transferência precisamos criar uma instância dessa classe:

move z"Este é um texto de exemplo." to wsTexto

invoke CharacterArray "withValue" using wsTexto

returning umaString

invoke Clipboard "write" using umaString

invoke umaString "finalize" returning umaString

Nesse momento, se o desenvolvedor estiver utilizando um editor de textos ou qualquer outro programa que permita colagem de dados da área de transferência, vai notar que a sequência de caracteres "Este é um exemplo de texto" será mostrada.

Para ler dados da área de transferência, utilize os seguintes comandos:

invoke Clipboard "read" returning umaString

invoke umaString "getValue" returning wsTexto

invoke umaString "finalize" returning umaString

Note que o método "getValue" espera que a variável de retorno tenha tamanho suficiente para armazenar a informação. Caso contrário, ocorrerá problemas de memória.

Em um próximo "post", vou mostrar a utilização de API´s para trabalhar com outros formatos de dados na área de transferência.

ProgressBar: Cadê o final ?

2007-10-04T09:04:00.000-03:00

Aprenda a animar uma barra de progressos, nos casos em que não se sabe a quantidade de informação a ser processada.

Para criar a barra de progressos, utilize o exemplo mostrado no artigo "Mostre o seu progresso".

Defina as novas variáveis na working-storage section:

77 bHandle pic 9(09) comp-5 value zeros.

77 wsMilisegundos pic 9(09) comp-5 value zeros.

78 PBM-SETMARQUEE value 1034.

78 PBS-MARQUEE value h"08".

Na procedure division, depois de criada a barra de progressos,basta adicionar os seguintes comandos antes do processamentode qualquer informação:

invoke umaProgressBar "AddBasicApiFlags"

using by value PBS-MARQUEE size 4

invoke umaProgressBar "getSystemHandle" returning bHandle

move 200 to wsMilisegundos

call WAPI "SendMessageA" using by value bHandle

by value PBM-SETMARQUEE

by value 1

by value wsMilisegundos

Para pausar a animação da barra de progressos:

invoke umaProgressBar "getSystemHandle" returning bHandle

move 0 to wsMilisegundos

call WAPI "SendMessageA" using by value bHandle

by value PBM-SETMARQUEE

by value 0

by value wsMilisegundos

Esse procedimento não requer que um valor seja passado para o componente a cada informação processada. Assim que a API é chamada, o componente passa a mostrar a animação automaticamente. A variável wsMilisegundos especifica o tempo da animação. Quanto menor o valor passado, mais rápida será a animação.

Perfumes para o Listview

2007-10-03T09:03:00.000-03:00

Acrescente algumas funcionalidades ao seu Listview, enviando mensagens para alterar o comportamento do mouse, rastrear a seleção de ítens, mudar as barras de rolagem e mostrar o conteúdo automático das colunas.

Defina o tipo de chamada das API´s:

special-names.

call-convention 66 is wapi.

Na working-storage section, defina as variáveis utilizadas:

77 ListviewHandle pic 9(09) comp-5 value zeros.

78 LVM-SETEXTENDEDLISTVIEWSTYLE value 4150.

78 LVS-EX-TRACKSELECT value h"00000008".

78 LVS-EX-ONECLICKACTIVATE value h"00000040".

78 LVS-EX-TWOCLICKACTIVATE value h"00000080".

78 LVS-EX-FLATSB value h"00000100".

78 LVS-EX-INFOTIP value h"00000400".

Vamos considerar que o Listview será representado pela variável umListview, definida como masterfield dentro da GS.

Para rastrear o ponteiro do mouse e selecionar o ítem automaticamente:

invoke umListview "GetSystemHandle" returning ListviewHandle