
segunda-feira, 17 de novembro de 2008
Que dia é hoje ?

quinta-feira, 17 de janeiro de 2008
O Word ou o Excel estão instalados ?
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:
sexta-feira, 26 de outubro de 2007
Uma StatusBar em tempo de execução

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.
quinta-feira, 4 de outubro de 2007
ProgressBar: Cadê o final ?
Para criar a barra de progressos, utilize o exemplo mostrado no artigo "Mostre o seu progresso".
77 bHandle pic 9(09) comp-5 value zeros.
78 PBM-SETMARQUEE value 1034.
Na procedure division, depois de criada a barra de progressos,basta adicionar os seguintes comandos antes do processamentode qualquer informação:
invoke umaProgressBar "AddBasicApiFlags"
invoke umaProgressBar "getSystemHandle" returning bHandle
invoke umaProgressBar "getSystemHandle" returning bHandle
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.
quarta-feira, 5 de setembro de 2007
Mostre o seu progresso !
Primeiro, vamos definir o tipo de chamada das API´s:
special-names.
Em seguida, as classes que serão utilizadas:
class-control.
As seguintes variáveis serão utilizadas:
working-storage section.
77 wsHandle pic 9(09) comp-5 value zeros.
77 umaJanela object reference value null.
77 wsLarguraDaJanela pic s9(09) comp-5 value zeros.
77 wsMes pic 99 value zeros.
Agora vamos imaginar que uma determinada rotina vai processar valores dos doze meses de um ano. Vamos mostrar o progresso desse processamento criando uma ProgressBar dentro de uma DialogBox em tempo de execução, como mostram as linhas a seguir:
ProcessarMeses section.
call wapi "GetActiveWindow" returning wsHandle
*>---------------------------------------------------------
invoke Window "fromHandleWithClass" using wsHandle Window
*>---------------------------------------------------------
invoke DialogBox "new" using umaJanela returning umaDialogBox
*>---------------------------------------------------------
invoke umaDialogBox "create"
*>---------------------------------------------------------
invoke umaJanela "GetWidthHeight"
*>---------------------------------------------------------
invoke ProgressBar "new" using umaDialog
*>---------------------------------------------------------
invoke umaProgressBar "Create"
*>---------------------------------------------------------
move 0 to wsMes wsPosicao
*-----------------------------------------------------------
A cada mes processado, o título da DialogBox é alterado pelo método "setTitleZ", informando cada mes que está sendo processado. A ProgressBar também é atualizada pelo método "setPosition", indicando o progresso do processamento.
quarta-feira, 22 de agosto de 2007
Eu coleciono registros. E você ?
....CharacterArray is class "chararry"
....OrderedCollection is class "ordrdcll".
Vamos tomar como exemplo um registro de um arquivo de bancos, com código e nome do banco. Mas você pode adaptar esse exemplo com qualquer outra FD:
FD CadastroDeBancos.
01 RegistroDoBanco.
...02 CodigoDoBanco pic 9(03).
...02 NomeDoBanco pic x(60).
77 umaColecao object reference value null.
77 umObjeto object reference value null.
77 wsTamanho pic 9(09) comp-5 value zeros.
77 wsQuantidade pic 9(09) comp-5 value zeros.
77 wsPosicao pic 9(09) comp-5 value zeros.
A primeira coisa a ser feita é criar uma coleção para armazenar todos os objetos contendo os registros lidos. Essa coleção é criada a partir do método "OfReferences" da classe OrderedCollection:
move 0 to wsQuantidade
invoke OrderedCollection "ofReferences" using wsQuantidade
returning umaColecao
Agora, digamos que exista um procedimento em seu programa que leia o arquivo de bancos, registro a registro, através de um "read ArquivoDeBancos next". A cada registro lido, você pode criar então um objeto do tipo CharacterArray, através do método "WithLengthValue". Esse método recebe como parâmetros, o tamanho e o conteúdo do objeto que se deseja criar. Em nosso exemplo, vamos passar o tamanho do registro de bancos e o seu conteúdo:
invoke CharacterArray "withLengthValue"
using wsTamanho RegistroDoBanco returning umObjeto
invoke umaColecao "at" using wsPosicao
returning umObjeto
quinta-feira, 16 de agosto de 2007
A classe OpenDialog: selecionando arquivos

O exemplo a seguir demonstra como utilizar os métodos da classe OpenDialog:
Defina as classes utilizadas, na class-control:
class-control.
....OpenDialog is class "opendlg"
....CharacterArray is class "chararry".
Defina o tipo de chamada na special-names:
Na procedure division, siga os seguintes passos:
A API "GetActiveWindow" retorna o handle da janela que está ativa. O método "fromHandleWithClass" da classe Window, cria um objeto a partir de um handle informado. Daí em diante, vários métodos podem ser utilizados para manipular a aparência e o comportamento da janela de seleção de arquivos. Veja alguns deles:
Para criar filtros de arquivos:
invoke CharacterArray "withValue" using z"Arquivo BMP (*.bmp)"
invoke CharacterArray "withValue" using z"Arquivo GIF (*.gif)"
Não está documentada de forma clara em nenhum dos manuais de ajuda do NetExpress que após criar filtros para uma janela de seleção de arquivos, um último filtro deve ser adicionado. Esse último filtro contém carateres nulos, finalizando assim a lista de filtros. Veja como adicionaro último filtro:
Quando esse último filtro não é adicionado, a janela de seleção de arquivos mostra caracteres estranhos no SelectionBox de tipos de arquivos, como mostra a imagem a seguir:

Para pegar o nome completo do arquivo selecionado:
Para pegar o nome base do arquivo selecionado (sem o caminho):
Se um arquivo é selecionado, um objeto contendo o nome do arquivo é retornado pelo método. Se o usuário sai da janela através do botão "Cancelar" ou pelo botao de "Fechar", o objeto retornado será setado com nulo:
if umNomeDeArquivo not = null
Outros métodos podem ser utilizados com a classe OpenDialog. A relação completa você encontra no manual de ajuda MFNXCL30.CHM ou MFNXCL31.CHM na pasta de instalação do NetExpress.
quarta-feira, 18 de julho de 2007
CharacterArray e OrderedCollection: Caracteres e coleções
A classe CharacterArray cria objetos contendo cadeias de caracteres. A manipulação desses objetos pode ser feita através de métodos bem fáceis de usar. Muitas classes necessitam de objetos desse tipo, como parâmetros a serem passados para os métodos. Por isso, é uma classe que considero de suma importância para quem quer utilizar a OOP.
A classe OrderedCollection cria objetos que podem conter outros objetos dentro deles. A classe OrderedCollection utiliza métodos que buscam qualquer um desses objetos da coleção através de índices. Você pode também buscar objetos dentro das coleções através de métodos de procura.
Os exemplos abaixo consideram que as classes CharacterArray e OrderedCollection estão declaradas na class-control:
class-control.
....CharacterArray is class "chararry"
....OrderedCollection is class "ordrdcll"
.....
Declare também as seguintes variáveis na working-storage section:
working-storage section.
77 umaColecao object reference value null.
77 umaString object reference value null.
77 umaNovaString object reference value null.
77 s pic 9(09) comp-5 value zeros.
77 i pic 9(09) comp-5 value zeros.
77 wsTexto pic x(255) value spaces.
Criando objetos do tipo CharacterArray. Esse é o método que eu mais utilizo em minhas aplicações:
invoke CharacterArray "withValue" using z"Ciasoft"
returning umaString
Para concatenar outra string, ao final do objeto:
invoke umaString "concatZ" using z" Online"
returning umaNovaString
Para retornar o conteúdo do objeto:
invoke umaNovaString "getValue" returning wsTexto
Para retornar o conteúdo do objeto, terminando com nulo:
invoke umaNovaString "getValueZ" returning wsTexto
Para converter o conteúdo do objeto em letras maiúsculas:
invoke umaString "asUppercase" returning umaNovaString
Para converter o conteúdo do objeto em letras minúsculas:
invoke umaString "asLowercase" returning umaNovaString
Para finalizar os objetos:
invoke umaString "finalize" returning umaString
invoke umaNovaString "finalize" returning umaNovaString
Esses são apenas alguns métodos que utilizo em minhas aplicações. Experimente utilizar outros métodos dessa classe. Obtenha mais informações sobre todos os métodos da classe CharacterArray no manual online da Microfocus.
Criando coleções. Para criar um objeto da classe OrderedCollection,utilize o seguinte método:
move 0 to s
invoke OrderedCollection "ofReferences" using s
returning umaColecao
Para adicionar objetos na coleção:
invoke umaColecao "add" using umaString
invoke umaColecao "add" using umaNovaString
Para saber quantos objetos existem na coleção:
invoke umaColecao "size" returning s
Para buscar o objeto em uma determinada posição:
move 2 to i
invoke umaColecao "at" using i returning umaString
Para remover um objeto da coleção, em uma determinada posição:
move 2 to i
invoke umaColecao "removeAtIndex" using i returning umaString
Para finalizar a coleção e todos os objetos dentro dela:
invoke umaColecao "deepFinalize" returning umaColecao
Muitos outros métodos podem ser utilizados com coleções. No manual online da Microfocus, você pode experimentar utilizá-los.
Uma aplicação prática para o uso dessas classes, por exemplo, é ler uma certa quantidade de registros de um arquivo, criar um objeto do tipo CharacterArray para cada um desses registros lidos e adicioná-los, um a um, em um objeto do tipo OrderedCollection. Com isso, você pode ter uma coleção de registros dentro de um único objeto, podendo passá-lo como parâmetro, por exemplo, para um programa de relatório que vai imprimir os registros. Mas essa é só uma idéia, dentre tantas outras que você pode criar, de acordo com a sua necessidade.
domingo, 3 de junho de 2007
Lista de arquivos em um Listbox

- Vamos utilizar vocabulários. Portanto, copie o arquivos de definição de vocabulários do Dialog System na primeira linha do seu programa:
copy dslang.cpy.
- Defina as seguintes classes, na class-control:
class-control.
....CharacterArray is class "chararry"
....Filename is class "filename"
....Listbox is class "listbox".
- Na working-storage section, defina as variáveis que serão utilizadas:
working-storage section.
77 handle8 pic 9(08) comp-x value zeros.
77 handle9 pic 9(09) comp-5 value zeros.
77 umaMascara object reference value null.
77 umaColecao object reference value null.
77 umListbox object reference value null.
- Esse exemplo requer que você tenha um listbox na janela de sua aplicação. Em nosso exemplo, o listbox foi definido na GS com o nome LB-ARQUIVOS. É nele que será colocada a lista de arquivos. Depois que a window de sua aplicação for criada, capture o listbox utilizando um método da classe Listbox:
CapturarListbox section.
....move-object-handle lb-arquivos handle8
....move handle8 to handle9
....invoke Listbox "fromHandleWithClass" using handle9 Listbox
...........returning umListbox
- Depois de capturado o listbox, vamos criar então a coleção de arquivos com uma determinada máscara e em seguida setar a coleção no objeto listbox:
CriarColecaoDeArquivos section.
....invoke CharacterArray "withValue" using z"c:\windows\*.bmp"
...........returning umaMascara
....invoke Filename "expandWildCards" using umaMascara
...........returning umaColecao
....invoke umListbox "setContents" using umaColecao
....invoke umaColecao "deepFinalize" returning umaColecao
....invoke umaMascara "finalize" returning umaMascara
Seguindo esse mesmo exemplo, você pode mudar a máscara de arquivos e mostrar outras listas, de acordo com a sua necessidade.
terça-feira, 29 de maio de 2007
Capturando objetos da GS
- Temos que definir a classe PushButton na Class-Control, no início do programa, logo depois do Program-ID:
program-id. Teste.
class-control.
....PushButton is class "pushbutt".
- No fonte cobol, defina duas variáveis que vão servir de referência ao objeto. São os "handles".
working-storage section.
77 handle9 pic 9(09) comp-5 value zeros.
77 umBotao object reference value null.
- Levando-se em consideração que estamos utilizando vocabulários, vamos pegar o "handle" do botão e a partir dele, criar um objeto utilizando o método da classe PushButton:
PegarObjetoBotao section.
...move-object-handle PB-GRAVAR handle8
...move handle8 to handle9
...invoke PushButton "fromHandleWithClass" using handle9 PushButon
..........returning umBotao
- A partir daí, nós temos um botão da GS na variável umBotao, como um objeto. Com esse objeto em mãos, podemos invokar quaisquer métodos para manipular o comportamento e o visual do botão, sem recorrer aos comandos do Dialog System. Utilize, por exemplo, o método a seguir:
invoke umBotao "hide"
- É um método simples, que vai fazer desaparecer o botão. Para mostrá-lo novamente, utilize o método "show":
invoke umBotao "show"
Esse exemplo pode ser utilizado também para outros objetos da GS, como window, selectionbox, listbox, etc. Não esqueça que para cada um desses objetos, a definição das classes correspondentes deve ser feita no início do programa, na class-control. Consulte os arquivos de ajuda (MFNXCL30.chm ou MFNXCL31.chm) para conhecer os métodos que podem ser utilizados para cada classe.
sexta-feira, 18 de maio de 2007
A Microfocus não me deu uma "mãozinha"...
MUDAR-PONTEIRO
SET-MOUSE-SHAPE WIN-PRINCIPAL "SYS-WAIT"
Além do "SYS-WAIT", posso utilizar ainda o "SYS-ARROW", "SYS-TEXT", "SYS-MOVE", "SYS-NWSE", "SYS-NESW", "SYS-WE", "SYS-NS" e "SYS-QUESICON". Pois bem. E se eu quiser usar como ponteiro do mouse, aquela "mãozinha" famosa, utilizada nos links dos browsers ? Bem, isso não é possível através do Dialog System, a não ser que eu crie um arquivo de cursor ".cur" e o especifique em um arquivo DS.ICN, por exemplo. Mas não é exatamente isso que eu quero.
Pesquisei então nas classes do NetExpress. A classe MouseCursor é quem cria os ponteiros do mouse para as aplicações. Mas não existe também nessa classe, métodos para criação da "mãozinha", somente dos ponteiros mencionados acima. Resolvi olhar o programa-fonte dessa classe - sim, o programa-fonte está no seu micro - para ver como eram criados os objetos. Olhei o método de classe "SYS-WAIT", para ver como ele retornava o objeto:
A constante IDC-WAIT que aparece no método encontra-se no arquivo WINDOWS.CPY. Esse arquivo contém todas as definições de variáveis e constantes que devem ser utilizadas com as API´s do Windows. Ela possui o valor 32514. Baseado nessas informações, resolvi procurar no Google alguma informação sobre essas constantes e seus valores. Rapidamente descobri uma que me interessava: IDC-HAND, com o valor 32649. Essa constante não está documentada no WINDOWS.CPY. Pensei então que poderia fazer a mesma coisa que o método "SYS-WAIT", só que passando como parâmetro a constante IDC-HAND com o seu valor 32649.method-id. "SYS-WAIT".
local-storage section.
01 aCursorType pic x(4) comp-5.
01 aCursorId pic x(4) comp-5.
linkage section.
01 lnkCursor usage object reference.
procedure division returning lnkCursor.move IDC-WAIT to aCursorType
invoke super "new" returning lnkCursor
invoke lnkCursor "initialize" using aCursorType
exit method.
end method "SYS-WAIT".
working-storage section.
77 i pic s9(09) comp-5 value zeros.78 IDC-HAND value 32649.
procedure division.invoke MouseCursor "new" returning umCursor
move IDC-HAND to i
invoke umCursor "initialize" using i
Teoricamente, eu já teria uma "mãozinha" como ponteiro de mouse, referenciado acima pelo objeto umCursor. Bastava setar esse objeto em uma "window" por exemplo, pra ver se tudo havia funcionado.
invoke umaWindow "setCursor" using umCursor
Utilizei o método "SetCursor" e pronto. A Microfocus não me deu nenhuma "mãozinha" mas ela estava lá, passeando por sobre a tela.