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

quarta-feira, 20 de agosto de 2008

Uma toolbar ao seu alcance

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.

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.

quarta-feira, 19 de setembro de 2007

Do CSListview para o HTML: um vôo sem escalas

Quando olho para o CSListview eu vejo um mundo de possibilidades. Minha "viagem" mais recente é a possibilidade de exportar os dados do CSListview para um arquivo no formato HTML. Sim, isso é perfeitamente possível. E relativamente fácil.

Uma subclasse do Listview
É claro que o assunto em questão requer conhecimentos da programação orientada ao objeto. O CSListview é uma subclasse da classe Listview, onde implemento os métodos que desejo e manipulo as informações necessárias para os recursos que pretendo criar.

Identificando as colunas
Com o CSListview eu tenho informações de cada uma das colunas criadas. Para isso, criei uma coleção de objetos e cada um deles representa uma dessas colunas. Assim, as informações de cada coluna ficam disponíveis à medida que eu necessitar.

Selecionando as colunas
São as colunas do CSListview que servirão de base para a criação de uma TABLE no arquivo HTML. O usuário deve ter a opção de escolher quais colunas devem ser colocadas no arquivo HTML e na ordem em que ele desejar. Essa seleção de colunas é que vai orientar a criação de cada comando TD dentro do arquivo HTML. Esse procedimento é semelhante ao que já existe no recurso de exportação de dados do CSListview para arquivos texto.

Ordenando as colunas
Penso em permitir ao usuário escolher quais as colunas que devem ser ordenadas para que a geração do arquivo HTML atenda a uma ordem específica de colunas. Por exemplo, em um CSListview de notas fiscais o usuário pode optar por ordenar os dados a partir das colunas de data de vencimento e fornecedor. Além disso, uma quebra de página pode ser implementada a cada mudança de informação de cada uma dessas colunas informadas. Por exemplo, se o usuário especificar uma quebra de página a cada mudança de um fornecedor, a geração do arquivo pode checar essa informação e fazer a quebra automática cada vez que um fornecedor diferente for encontrado nos dados da coluna correspondente. Esse procedimento poderá ser feito em qualquer uma das colunas escolhidas para ordenar a leitura das informações do CSListview.

Totalizando colunas
Outro recurso que imagino ser interessante é possibilitar ao usuário escolher quais colunas ele deseja totalizar. Nesse caso, a totalização poderia ser feita de várias maneiras, como por exemplo, uma soma simples dos valores, uma contagem ou até mesmo uma média dos valores. Outras formas de totalização podem ser implementadas futuramente.

As colunas respondem
Com as informações de cada uma das colunas "em minhas mãos", logo depois de selecionadas e ordenadas, basta que eu saiba a descrição de cada coluna, a largura em pixéis e a sua justificação, à esquerda, à direita ou centralizada. Com base nessas informações, enfim, a tabela no arquivo HTML pode ser feita.

As linhas de dados
Gerar as informações das linhas de dados no arquivo HTML talvez seja a parte mais fácil do processamento, afinal de contas, o CSListview fornece esses dados de maneira bem simples. Eu tenho o conteúdo de cada uma das linhas de dados, coluna por coluna. Bastaria encaixar as informações gerando um código HTML para cada uma das linhas de dados do CSListview.Isso seria feito utilizando a tag TR do arquivo HTML.

Cabecalhos e quantidade de linhas
A interface do CSListview para todo esse processo também oferecerá campos para que o usuário possa escolher um título para o arquivo HTML, além de informações como quantidade de linhas por página, a data e a hora da geração do arquivo. Isso permitirá ao usuário imprimir o arquivo HTML, com controle de linhas e quebra de pagina automáticos.

Arquivo gerado. Fim da viagem.
O CSListview possui outros inúmeros recursos. Mas esse último, a geração do arquivo HTML, tornou-se um desafio prazeroso. Os desenvolvedores que já adquiriram o CSListview receberão o recurso gratuitamente em uma próxima atualização. Caso exista interesse de outras pessoas pela aquisição dessa ferramenta, basta entrar em contato comigo pelo email abaixo:

alexandre.cia@iron.com.br

segunda-feira, 10 de setembro de 2007

E a torcida grita: OLE !

Você faz parte daquela torcida que adora experimentar novos recursos em seus aplicativos ? Conheça um pouco mais sobre a tecnologia OLE e experimente alguns desses recursos na manipulação de uma planilha do Excel.

Uma colaboração de Roberto Rinaldi.

Segundo o Wikipédia, o OLE é um sistema de objetos distribuídos e protocolo criado pela Microsoft, que permite a comunicação entre programas. Ele permite a um editor disponibilizar parte de um documento para outro editor, e então reimportá-lo. Por exemplo, um sistema de editoração gráfica pode enviar texto para um processador de texto ou uma figura para um editor gráfico usando OLE.

Neste post vamos nos ater ao padrão OLE 2.0 que nos permite utilizar um recurso chamado "automação OLE". Em nosso exemplo, vamos manipular uma planilha do Excell.

Inclua a seguinte diretiva no início do programa:

$set ooctrl(+P)

Essa diretiva é necessária em programas que utilizam a OLE. Em seguida, na class-control, vamos definir a classe referente ao objeto OLE que desejamos criar:

class-control.
MSExcel is class "$OLE$Excel.Application".

Defina as variáveis que serão utilizadas:

working-storage section.
77 ExcelObject object reference value null.
77 WorkBooksCollection object reference value null.
77 WorkBook object reference value null.
77 WorkSheet object reference value null.
77 Cell object reference value null.
77 CellRange object reference value null.
77 ActiveWindow object reference value null.
77 SelectedSheets object reference value null.

77 Linha pic xx comp-5 value zeros.
77 Coluna pic xx comp-5 value zeros.
77 Pagina object reference value null.
77 Valor pic xx comp-5 value zeros.

Agora vamos mostrar alguns recursos que podem ser usados com o objeto OLE:

procedure division.

*> Cria uma nova instância
invoke MSExcel "new" returning ExcelObject

*> informa que o aplicativo está visível
invoke ExcelObject "setVisible" using by value 1

*> retorna uma coleção de planilhas da pasta ativa
invoke ExcelObject "getWorkBooks" returning WorkBooksCollection

*> Adiciona uma planilha na pasta e retorna seu objeto
invoke WorkBooksCollection "add" returning WorkBook

*> Preenchimento das células
*> Linha de 1 até 5

perform varying Linha from 1 by 1 until Linha greater 5
....*> coluna de "A" até "D"
....perform varying coluna from 1 by 1 until Coluna greater 4
........*> Retorna a célula pelas coordenadas da linha e coluna
........invoke ExcelObject "getCells" using by value Linha
........by value Coluna returning Cell
........compute Valor = Linha * Coluna
........*> Estabelece o valor para a célula retornada
........invoke Cell "setValue" using by value Valor
........*> libera a memória destuindo o objeto
........invoke Cell "finalize" returning Cell
....end-perform
end-perform

*> Retorna o objeto referente as colunas A até D
invoke ExcelObject "getColumns" Using Z"A:D"
Returning CellRange

*> Formata a faixa selecionada
invoke CellRange "setNumberFormat" using Z"#.##0,00"

*> Retorna a página da planilha ativa
Invoke Workbook "GetActiveSheet" returning WorkSheet

*> Retorna as configurações de página
invoke WorkSheet "getPageSetup" returning Pagina

*> faz com que as linhas de grade sejam impressas
*> todas as configurações de página podem ser setadas aqui
invoke Pagina "setPrintGridLines" using by value 1

invoke Workbook "SaveAs" Using Z"teste.xls"

*> Retorna a janela ativa
invoke ExcelObject "getActiveWindow" returning ActiveWindow

*> retorna a planilha ativa
invoke ActiveWindow "getSelectedSheets"
returning SelectedSheets

*> Visualiza a impressão
invoke SelectedSheets "PrintPreview"

*> encerra todos objetos
invoke ExcelObject "finalize" returning ExcelObject
invoke WorkBooksCollection "finalize"
returning WorkBooksCollection
invoke WorkBook "finalize" returning WorkBook
invoke WorkSheet "finalize" returning WorkSheet
invoke Cell "finalize" returning Cell
invoke CellRange "finalize" returning CellRange
invoke ActiveWindow "finalize" returning ActiveWindow
invoke SelectedSheets "finalize" returning SelectedSheets
invoke Pagina "finalize" returning Pagina

*> encerra o programa
stop run.

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.