Mostrando postagens com marcador Objetos. Mostrar todas as postagens
Mostrando postagens com marcador Objetos. Mostrar todas as postagens

segunda-feira, 17 de novembro de 2008

Que dia é hoje ?

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.


quinta-feira, 17 de janeiro de 2008

O Word ou o Excel estão instalados ?

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.

sexta-feira, 26 de outubro de 2007

Uma StatusBar em tempo de execução


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.

quinta-feira, 4 de outubro de 2007

ProgressBar: Cadê o final ?

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.

quarta-feira, 5 de setembro de 2007

Mostre o seu progresso !

Em muitas ocasiões torna-se extremamente útil mostrar ao usuário o andamento de um determinado processamento dentro dos sistemas. Aprenda como criar uma DialogBox e uma ProgressBar em tempo de execução e mostre a todos o seu progresso:

Primeiro, vamos definir o tipo de chamada das API´s:

special-names.
call-convention 66 is WAPI.

Em seguida, as classes que serão utilizadas:

class-control.
Window is class "window"
DialogBox is class "dilogbox"
ProgressBar is class "progress"
.

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 umaDialogBox object reference value null.
77 umaProgressBar object reference value null.

77 wsLarguraDaJanela pic s9(09) comp-5 value zeros.
77 wsAlturaDaJanela pic s9(09) comp-5 value zeros.
77 wsLargura pic s9(09) comp-5 value zeros.
77 wsAltura pic s9(09) comp-5 value zeros.
77 wsX pic s9(09) comp-5 value zeros.
77 wsY pic s9(09) comp-5 value zeros.
77 wsInicio pic 9(09) comp-5 value zeros.
77 wsFim pic 9(09) comp-5 value zeros.
77 wsPosicao pic 9(09) comp-5 value zeros.

77 wsMes pic 99 value zeros.
77 wsTexto pic x(255) value spaces.

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.
*>---------------------------------------------------------
*> A API "GetActiveWindow" retorna o handle da janela ativa

call wapi "GetActiveWindow" returning wsHandle

*>---------------------------------------------------------
*> O método "fromHandleWithClass" retorna a instância
*> da classe Window, referente ao handle informado

invoke Window "fromHandleWithClass" using wsHandle Window
returning umaJanela

*>---------------------------------------------------------
*> O método "new" retorna uma nova instância da classe DialogBox

invoke DialogBox "new" using umaJanela returning umaDialogBox

*>---------------------------------------------------------
*> Os métodos "create", "setWidth" e "setHeight", cria e
*> define largura e altura (em pixéis) da DialogBox,
*> respectivamente

invoke umaDialogBox "create"
move 1200 to wsLargura
move 74 to wsAltura
invoke umaDialogBox "setWidthHeight" using wsLargura wsAltura

*>---------------------------------------------------------
*> os métodos abaixo retornam a largura e a altura da janela
*> para que a DialogBox seja centralizada

invoke umaJanela "GetWidthHeight"
using wsLarguraDaJanela wsAlturaDaJanela
compute wsX = (lsLarguraDaJanela / 2) - (wsLargura / 2)
compute wsY = (lsAlturaDaJanela / 2) - (wsAltura / 2)
invoke umaDialogBox "setXY" using wsX wsY
invoke umaDialogBox "show"

*>---------------------------------------------------------
*> O método "new" retorna uma nova instância da classe ProgressBar

invoke ProgressBar "new" using umaDialog
returning umaProgressBar

*>---------------------------------------------------------
*> Os métodos abaixo fazem a criação e ajustam a posição,
*> largura, altura, o valor inicial e o valor final da
*> ProgressBar.

invoke umaProgressBar "Create"
move 2 to wsY
invoke umaProgressBar "setY" using wsY
move 70 to wsAltura
move 1200 to wsLargura
invoke umaProgressBar "setWidthHeight" using wsLargura wsAltura
move 1 to wsInicio
move 12 to wsFim
invoke umaProgressBar "SetRange" using wsInicio wsFim
invoke umaProgressBar "show"

*>---------------------------------------------------------
*> O procedimento a seguir apenas demonstra como seria
*> mostrada a ProgressBar, a cada mes que é processado

move 0 to wsMes wsPosicao
perform 12 times
....add 1 to wsMes wsPosicao
....move spaces to wsTexto
....string "Processando mes " wsMes "..." x"00" into wsTexto
....invoke umaDialogBox "setTitleZ" using wsTexto
....invoke umaProgressBar "setPosition" using wsPosicao
.......
....*> aqui seria feito um processamento qualquer
.......
end-perform
invoke umaProgressBar "finalize" returning umaProgressBar
invoke umaDialogBox "finalize" returning umaDialogBox

*-----------------------------------------------------------

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ê ?

Você coleciona tampinhas, latinhas de alumínio, selos ou carrinhos em miniatura ? Aprenda a criar coleções de registros dos seus arquivos indexados e comece a pensar mais em objetos:

Na class-control, defina as classes que serão utilizadas:

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

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

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:

move length of RegistroDoBanco to wsTamanho
invoke CharacterArray "withLengthValue"
using wsTamanho RegistroDoBanco returning umObjeto

Em seguida, armazenamos o objeto criado utilizando o método "Add". Esse método armazena os objetos na coleção, na mesma ordem em que são adicionados: o primeiro fica na primeira posição da coleção, o segundo na segunda posição, e assim por diante:

invoke umaColecao "add" using umObjeto

Isso deve ser feito a cada registro lido do arquivo. Ao terminar a leitura do arquivo, você terá o objeto umaColecao contendo diversos objetos, cada um deles com o conteúdo de um registro lido do arquivo de bancos. Uma aplicação prática para a utilização desse recurso seria criar rotinas que gerem essas coleções baseadas em determinados critérios. Em uma rotina que manipulasse um arquivo de empresas poderiam ser criadas coleções de empresas de um determinado tipo: pessoa jurídica, por exemplo. Em uma rotina que manipulasse um arquivo de funcionários poderiam ser criadas coleções com funcionários ativos, outra com funcionários desligados.

Quando um programa recebe uma coleção de objetos, ele pode saber a quantidade de objetos na coleção através do método "size":

invoke umaColecao "size" returning wsQuantidade

Se você deseja pegar um objeto em uma posição específica dentro da coleção, pode se utilizar o método "at":

move 5 to wsPosicao
invoke umaColecao "at" using wsPosicao
returning umObjeto


No exemplo acima, recuperamos o objeto na quinta posição da coleção. Note que se a coleção não contém o objeto na posição especificada, uma mensagem de erro será retornada. Se a coleção contém 5 objetos, você não pode tentar recuperar um objeto na posição 9, por exemplo.

Depois de recuperado um objeto, você pode retornar seu conteúdo novamente em uma variável. Em nosso exemplo, vamos recuperar o conteúdo diretamente no registro de bancos. Para retornar o conteúdo de um objeto, utilize o método "getValue":

invoke umObjeto "getValue" returning RegistroDoBanco

Atente para um detalhe: a variável que receberá o conteúdo de um objeto deve ter tamanho suficiente para armazenar a informação. Caso o tamanho não seja suficiente, você pode ter problemas de violação de memória.

Agora é só usar a criatividade e criar as suas próprias coleções de registros.

quinta-feira, 16 de agosto de 2007

A classe OpenDialog: selecionando arquivos


A classe OpenDialog permite ao desenvolvedor utilizar a janela padrão do Windows para selecionar arquivos.
O exemplo a seguir demonstra como utilizar os métodos da classe OpenDialog:

Defina as classes utilizadas, na class-control:

class-control.
....Window is class "window"
....OpenDialog is class "opendlg"
....CharacterArray is class "chararry"
.



Defina o tipo de chamada na special-names:

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


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

working-storage section.
77 wsHandle pic 9(09) comp-5 value zeros.
77 umaJanela object reference value null.
77 umaOpenDialog object reference value null.
77 umFiltro object reference value null.
77 umaExtensao object reference value null.
77 wsArquivo pic x(255) value spaces.


Na procedure division, siga os seguintes passos:

MontarOpenDialog section.
....call wapi "GetActiveWindow" returning wsHandle
....invoke Window "fromHandleWithClass"
...........using wsHandle Window
...........returning umaJanela
....invoke OpenDialog "new" using umaJanela
...........returning umaOpenDialog


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 mudar o título da janela:

invoke umaOpenDialog "setTitleZ" using z"Selecionar a imagem de fundo..."


Para criar filtros de arquivos:

invoke CharacterArray "withValue" using z"Arquivo JPG (*.jpg)"
.......returning umFiltro
invoke CharacterArray "withValue" using z"*.jpg"
.......returning umaExtensao
invoke umaOpenDialog "AddFilter" using umFiltro umaExtensao
invoke umFiltro "finalize" returning umFiltro
invoke umaExtensao "finalize" returning umaExtensao

invoke CharacterArray "withValue" using z"Arquivo BMP (*.bmp)"
.......returning umFiltro
invoke CharacterArray "withValue" using z"*.bmp"
.......returning umaExtensao
invoke umaOpenDialog "AddFilter" using umFiltro umaExtensao
invoke umFiltro "finalize" returning umFiltro
invoke umaExtensao "finalize" returning umaExtensao

invoke CharacterArray "withValue" using z"Arquivo GIF (*.gif)"
.......returning umFiltro
invoke CharacterArray "withValue" using z"*.gif"
.......returning umaExtensao
invoke umaOpenDialog "AddFilter" using umFiltro umaExtensao
invoke umFiltro "finalize" returning umFiltro
invoke umaExtensao "finalize" returning umaExtensao

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:

invoke CharacterArray "withValue" using x"0000"
.......returning umFiltro
invoke CharacterArray "withValue" using x"0000"
.......returning umaExtensao
invoke umaOpenDialog "AddFilter" using umFiltro umaExtensao
invoke umFiltro "finalize" returning umFiltro
invoke umaExtensao "finalize" returning umaExtensao


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 mostrar a janela de seleção de arquivos:

invoke umaOpenDialog "show"


Para pegar o nome completo do arquivo selecionado:

invoke umaOpenDialog "getFile" returning umNomeDeArquivo


Para pegar o nome base do arquivo selecionado (sem o caminho):

invoke umaOpenDialog "getFileTitle" returning umNomeDeArquivo


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
...move spaces to wsArquivo
...invoke umNomeDeArquivo "getValue" returning wsArquivo
end-if


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

Manipular cadeias de caracteres com a utilização de objetos é uma tarefa fácil e agradável. Construir coleções de objetos pode facilitar ainda mais o desenvolvimento de procedimentos dentro dos aplicativos. Para isso, só precisamos conhecer um pouco das classes CharacterArray e OrderedCollection, do NetExpress.

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

Você precisa mostrar uma lista de arquivos com uma máscara específica em suas aplicações ? Utilize as classes CharacterArray, Filename, Listbox e mãos à obra. Siga passo-a-passo o exemplo a seguir e ofereça mais esse recurso em suas aplicações:





- 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

Um exercício interessante para quem está começando a se aventurar no mundo da OO é modificar a aparência de alguns objetos na tela, através dos métodos que cada um deles oferece. Quem utiliza o Dialog System pode capturar os objetos da GS através de um simples procedimento. Vamos, por exemplo, capturar um botão da GS, passo a passo:

- 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".
Defina também a variável que vai receber o objeto "pushbutton".

working-storage section.
77 handle8 pic 9(08) comp-x value zeros.
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"...

Quem gosta de utilizar os recursos do mouse em telas feitas com o Dialog System já deve ter reparado que existem algumas opções paramudar o ponteiro do mouse, movimentando-o por sobre determinados objetos na GS. Isso é feito com a função SET-MOUSE-SHAPE:

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:

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


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.

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.