Delphi e OpenOffice(BROffice) - Parte 1

I - INTRODUÇÃO

Vamos inicar um novo passeio; um passeio diferente, um passeio pelo mundo do software de código aberto. Abro esse artigo, não querendo dar a idéia de que será algo original. Mas de apresentar a idéia da comunicação OLE entre aplicações Delphi e a família de documentos BrOffice (ou OpenOffice - Writer, Calc, Base e Impress). Porque estou querendo dar ênfase a essa idéia? Simples! o Sistema da empresa onde trabalho, comunica-se tranquilamente com a família Microsoft Office, porém um de nossos clientes resolveu adotar a família BrOffice para sua empresa, e o mais cômico disso tudo, foi porque eu que os incentivei. Mas não tinha idéia de que a parte da comunicação seria tão complexa, mais complexa do que pegar e rodar uma macro no Office e rapidamente obter as propriedades que poderiam ser acessadas e as incorporar em nosso aplicativo.

A minha idéia não é nem um pouco original, mas como falei, ela é interessante porque nos remete a um novo aprendizado, e muitas vezes deixamos de implementar algo, já que a quantidade de informação é rara ou, o trabalho cobrará suas dívidas em relação ao tempo perdido, tornando-o muito oneroso, tanto para sua empresa como para os clientes. Mas o mais importante de tudo é tomar a iniciativa e seguir em frente.

II – REFERÊNCIAS

Leio muitos artigos escritos em revistas de programação e sites relacionados ao Delphi e raramente vejo uma referência dando crédito aos que nos ensinaram e que nos possibilitaram dar os ponta-pés iniciais no assunto; nesse caso, gostaria de ressaltar o documento escrito por Sérgio Hernandes que está hospedado no site www.broffice.org e pode ser obtido no seguinte endereço: http://ooomacros.org/dev.php#133853. Uma segunda referênca que poderá lhe dar uma luz é o livro chamado: OpenOffice.org Macros Explained do escritor Andrew Pitonyak de 2004 (velho, mas todo que é velho é importante para nossas vidas).

III - OBSERVAÇÕES IMPORTANTES

Não será apresentado detalhes pertinentes ao uso dos aplicativos, isto é, como salvar, abrir e editar arquivos ou executar comandos de compilação. Esses são pressupostos necessários para os que estão interessados nesse assunto.

IV – PROBLEMAS

No caso de encontrar erros nos procedimentos, favor relatar. Não sou dono da verdade, portanto as críticas construtivas serão bem-vindas. Não darei atenção para qualquer crítica ríspida, pois trato todos com respeito.

V – APLICATIVOS

Delphi 7 ou qualquer versão superior e também a Suite BrOffice - estou usando a versão 3.1 com o Builder 9420 - Instalação Padrão.

VI - DIREITOS DE CÓPIA

Assunto autorizado somente para o site www.PlanetaDelphi.com.br. Esse conteúdo não pode ser copiado ou re-linkado sem prévia autorização do seu autor ou do responsável pelo site, nesse caso Sr. Felipe Monteiro. Toda a cópia e re-linkagem sem autorização prévia e por escrito dos responsáveis mencionados anteriormente, estarão sujeitas aos termos da lei de pirataria.

Delphi e BrOffice

Iniciando as aplicações do pacote

IMPORTANTE: sempre declarar na seção USES a Unit ComObj para todos os exemplos apresentados.

Para que possamos executar as diversas aplicações do pacote BrOffice, faremos uso basicamente de um procedimento chamado LoadComponentFromURL que recebe 4 parâmetro e segue este formato: LoadComponentFromURL(sURL, sFrame, FlagDeBusca, Array); As tabelas abaixo,

apresentam os valores permitidos para cada um dos parâmetros.

Tabela 1 - URL – String – Primeiro Parâmetro

Tabela 2 - Frames – Segundo Parâmetro

Flag de Busca - Terceiro Parâmetro

É um valor constate que define o algoritmo que será usado para encontra o quadro de destino. Use o valor 0 nesse parâmetro para cancelar.

Array – Quarto Parâmetro

Nesse parâmetro são passados parâmetros para o descritor de mídia do arquivo, definindo diversar propriedades para o carregamento.

Executando os diversos Frames - Criando o nosso primeiro aplicativo

Não esqueça que o BROffice deve estar instalado.

Nesse aplicativo, vamos simplesmente fazer com que o nosso programa execute um dos programas BROffice que o usuário desejar executar. Execute o Delphi, crie uma nova aplicação e no form adicione um componente radiogroup contendo os nomes das aplicações (factory´s) na propriedade itens, uma variável pública chamada aplicação e um botão. Conforme a figura abaixo.

Vamos escrever algum código agora. No evento onClick do radiogroup edite o seguinte código:

view source print ? 01.Case RadioGroup1.ItemIndex of02. 0 : Aplicacao := ''; 03. 1 : Aplicacao := 'private:factory/scalc'; 04. 2 : Aplicacao := 'private:factory/swriter'; 05. 3 : Aplicacao := 'private:factory/swriter/web'; 06. 4 : Aplicacao := 'private:factory/swriter/GlobalDocument'; 07. 5 : Aplicacao := 'private:factory/sdraw'; 08. 6 : Aplicacao := 'private:factory/smath'; 09. 7 : Aplicacao := 'private:factory/simpress'; 10. 8 : Aplicacao := 'private:factory/schart'; 11. 9 : Aplicacao := '.component:Bibliography/View1'; 12.end;

Para o evento onClick do botão, edite o seguinte código:

view source print ? 01.procedure TForm1.Button1Click(Sender: TObject); 02.var03. BrOffice, Desktop, Executar : Variant; 04.begin05. if RadioGroup1.ItemIndex <> 0 then06. begin07. BrOffice := CreateOleObject('com.sun.star.ServiceManager'); //1ª Linha 08. Desktop := BrOffice.CreateInstance('com.sun.star.frame.Desktop'); //2ª Linha 09. Executar := Desktop.LoadComponentFromURL(Aplicacao, '_blank', 0, //3ª Linha 10. VarArrayCreate([0,-1], varVariant)); 11. end; 12. 13. BrOffice := Unassigned; 14. Desktop := Unassigned; 15. Executar := Unassigned; 16. {Atente para as letras maísculas e minúsculas. Se a palavra frame por exemplo 17. for colocada em maiúscula, uma exceção lhe será apresentada.}18.end;

Vou fazer agora um pequeno detalhemento do que foi feito no evento onclick do botão. Veja que foram declaradas três variáveis do tipo Variant – São elas: BrOffice, Desktop e Executar. A variant BROffice é a inicialização, muito parecido com a chamada do Office, ao invés de chamar por exemplo 'Excel.Application' estará chamando um elemento chamado Service Manager do módulo 'com.sun.star'. Já a variável Desktop criar uma instância contendo os elementos comuns da plataforma; a variável Executar será encarregada de ser uma referência a aplicação, isto quer dizer que, quando clicar no botão para executar o programa desejado, por exemplo o Calc, Executar terá todo o conjunto de módulos pertinentes ao Calc, a partir dele, poderemos acessar as propriedades de Pastas, Planilhas e Células.

Por fim, vemos declaradas as três variáveis mencionadas anteriormente, porém recebendo a atribuição de Unassigned. Estamos somente limpando as variáveis, mais nada.

Download desta aula

Delphi e BrOffice - Parte 1.rar

Até a próxima aula !!!

Continuação - Delphi e OpenOffice(BROffice) - Parte 2

Trabalhando com Arquivos e Planilhas no Calc

I – REQUISITOS NECESSÁRIOS PARA O MÓDULO

Ter entendido e treinado a versão do artigo apresentada como introdução. Delphi e OpenOffice(BROffice) - Parte 2

II – OBJETIVOS

Entender a dinâmica de trabalho com planilhas e arquivos do Calc. Os principais cuidados para ter sucesso no processo de transferência de dados OLE entre Delphi 7 e BrOffice.

III – IMPORTANTE

Atente para os comandos, já que a linguagem é case-sensitive.

IV – INICIANDO

Vamos criar uma nova aplicação, e nela adiconaremos os seguintes componentes do Delphi: Um Edit, um SpinEdit, um StringGrid, um CheckBox, um ListBox e como não pode faltar, um botão.

Deixo a formatação da tela para você. Muitas vezes os tutoriais induzem a ter que fazer tudo dentro de uma certa configuração, eu não pretendo fazer isso agora. O que faremos nessa parte de nosso tutorial? Simples!! Através do spinedit, definiremos o número de planilhas que serão criadas em nossa aplicação, não edite o campo índice do stringgrid, pois é ele quem coloca as planilhas em ordem dentro da pasta (o mesmo que no Excel), a medida que o spinedit tem seu valor modificado o número de linhas é incrementado ou decrementado e automaticamente gera os índices. No campo do Edit você poderá escolher qualquer nome para o arquivo e o destino do arquivo. Quando iniciamos o processamento, podemos marcar a opção que verifica se já existe uma planilha com um dos nomes que estamos registrando (não podem haver duas planilhas com o mesmo nome na mesma pasta); e para finalizar, vamos capturar o nome das planilhas que registramos e seus respectivos índices dentro da pasta.

Vamos inserir o código em nosso sistema e iniciar as explicações necessárias. Os eventos dos componentes estão com seus nomes sublinhados.

view source print ? 01.procedure TForm1.FormShow(Sender: TObject); 02.begin03. StringGrid1.Cells[0,0] := 'Indice'; 04. StringGrid1.Cells[1,0] := 'Nome da Planilha'; 05. SpinEdit1.OnChange(sender); 06.end; 07. 08.procedure TForm1.SpinEdit1Change(Sender: TObject); 09.var10. x : Integer; 11.begin12. If (SpinEdit1.Value = 1) then13. begin14. ShowMessage('Uma planilha deve estar presente obrigatoriamente na pasta'); 15. SpinEdit1.Value := 1; 16. StringGrid1.RowCount := 2; 17. end else begin18. StringGrid1.RowCount := SpinEdit1.Value + 1; 19. For x := 1 to StringGrid1.RowCount do20. StringGrid1.Cells[0,x] := Format('%d',[x - 1]); 21. end; 22.end;

O evento onShow do formulário simplesmente coloca os indices nas linhas quando a aplicação é iniciada e atribui o número de linhas pelo evento onChange do SpinEdit1. Nada de “phenomenal”. O evento onChange do spinEdit1 tem um pequeno if limitando o número de planilhas existentes para um documento. Para que a pasta possa existir, ela necessita de pelo menos uma planilha.

Vamos para a parte nervosa!!!

view source print ? 01.procedure TForm1.Button1Click(Sender: TObject); 02. var03. N, x : SHORT; 04. Remover : array[0..2] of String; 05. begin06.

07. BrOffice := CreateOleObject('com.sun.star.ServiceManager'); 08. Desktop := BrOffice.CreateInstance('com.sun.star.frame.Desktop'); 09. Documento := Desktop.LoadComponentFromURL('private:factory/scalc', '_blank', 0, 10. VarArrayCreate([0,-1], varVariant)); 11. 12. //Vai guardar o nome para excluir as planilhas originais na sequência 13. For x := 0 to 2 do14. Remover[x] := Documento.Sheets.getByIndex(x).Name; 15. 16. { Insere as planilhas nomeadas pelo usuarios, baseados no índice de nosso 17. sistema }18. For x := 1 to StringGrid1.RowCount - 1 do19. begin20. if CheckBox1.Checked then21. begin22. if not Documento.Sheets.hasByName(StringGrid1.Cells[1, x]) then23. Documento.getSheets.insertNewByName(StringGrid1.Cells[1, x] , x - 1) 24. else25. ShowMessageFmt('A planilha que você inseriu com o nome de %s não será criada' + #13 + 26. 'porque ela já existe na pasta!',[StringGrid1.Cells[1, x]]); 27. end else28. Documento.getSheets.insertNewByName(StringGrid1.Cells[1, x] , x - 1); 29. end; 30. { remove as planilhas criadas automaticamente pelo sistema 31. veremos mais tarde como fazer a exclusão ou renomear através de um módulo 32. chamado de UNO }33. For x := 0 to 2 do34. Documento.getSheets.removeByName(Remover[x]); 35. 36. { Recupera novamente a quantidade de planilhas registrada ou inseridas e 37. apresenta o nome no ListBox }38. N := Documento.getSheets.GetCount; 39. For x := 0 to Pred(N) do40. lbNomes.Items.Insert(x, Format('Index da Plan: %d - Nome: %s', 41. [x, Documento.Sheets.getByIndex(x).Name])); 42. end;

Vamos agora enteder o que foi programado. O primeiro bloco como podemos assim dizer, somente foi feita a declaração das variáveis para criar os elementos do Broffice. No primeiro for lhe foi apresentado a seguinte situação: Documento.Sheets.getByIndex(x).Name; A variável documento armazena as propriedades, funções e procedimentos relativos ao documento; avançamos para a propriedade da planilha (Sheets) e através da função getByIndex capituramos o índice da planilha dentro da pasta. Obviamente que a propriendade Name nos retornará o nome da planilha. O que fiz não foi pegar o número de planilhas na pasta, isso seria o mais correto, porém, como sabemos que a pasta sempre conterá três planilhas (a não ser que o miserável do usuário altere alguma configuração) então não coletei esse valor. Mas esse procedimento seria o mais correto, capturar o número de planilhas de uma pasta e na sequência obter seus nomes.

No segundo for, é iniciado o processo de inserir as planilhas que registramos no StringGrid. O que faz o CheckBox1? Ele questiona se o usuário deseja verificar se já existe o nome da planilha na pasta em que estamos trabalhando. Através da função hasByName('NomeDaPlanilha') podemos verificar se ela já existe. É uma função simples e seu único parâmetro é o nome da planilha. É uma função Boleana, se o nome existe, o retorno da função é True, caso contrário, False – obviamente!

Como foi dito, através da função hasByName verificamos se existe alguma planilha contendo o nome que passamos em nosso grid; se não existir, vamos usar uma função nova chamada insertNewByName('NomeDaPlanilha', Índice). O primeiro parâmetro da função é uma String e o segundo um valor Inteiro. Veja também que, um documento sempre será um container para armazenar diversas folhas ou planilhas como sabemos. Assim getSheets() retornará todos os objetos de planilhas dentro da pasta. O Índice da função insertNewByName sempre inicia do ZERO (0). O que estou querendo dizer é, se quiser inserir uma nova planilha com o nome de 'Contabilidade', em uma pasta e que ela esteja na segunda folha, diminua o valor real menos 1 – A primeira planilha tem o índice Zero, a segunda Um, a terceira Dois e assim por diante.

Para remover uma planilha você usará a função removeByName('NomeDaPlanilha'), é bem simples e seu parâmetro é uma String. Coloque o nome da planilha que deseja excluir e pronto. Em nosso exemplo, isso foi feito colocando os nomes em um array quando pressionamos o botão Executar Calc. Não haveria necessidade de fazer isso, já que sabemos que sempre os nomes serão 'Planilha1', 'Planilha2' e 'Planilha3'. Logo o exemplo do primeiro for foi meramente ilustrativo conforme explicado inicialmente.

Aumentando um pouco mais a complexidade!!!! Não é igual ao Excel....

O BrOffice é uma ferramenta desenvolvida por diversos profissionais e seu objetivo e atender os diversos sistemas operacionais que estão presentes no mercado. Vamos para o segundo botão do nosso pequeno programa e que executa o comando salvar da planilha. Um detalhe importante e por isso fiz essa pequena introdução, quando salvamos um documento no BrOffice, devemos passar o caminho contendo um formato diferente, parecido com as plataformas Linux, você sempre passará o caminho para salvar o arquivo no seguinte formato: 'file:///' + Pastas + NomeDoDocumento + extensão. Outro pequeno detalhe, as barras devem ser as barras de data e não as barras invertidas que são o padrão Microsoft. Se você pensar em salvar um arquivo em algo parecido com: C:\Meus Documentos\Minha Pasta\Subpasta\MinhaPlanilha.odt, deverá converter isso para: file:///C:/Meus Documentos/Minha Pasta/Subpasta/MinhaPlanilha.odt e por esse motive inserimos a função TranformaDeCaminhoParaURL. Veja a sua declaração em nosso pequeno sistema:

view source print ? 1.function TForm1.TranformaDeCaminhoParaURL(nomeArq: String): String; 2.var3. NomeFile : String; 4.begin5. NomeFile := LowerCase(nomeArq); 6. if (Pos('file:///', NomeFile) = 0) then7. result := 'file:///' + StringReplace(NomeFile, '\', '/', [rfReplaceAll, rfIgnoreCase]); 8.end;

Deixo na sua responsabilidade de fazer as verificações da existência do arquivo e da pasta. Não irei tratar de detalhes reais de um programa. Como falei, para que você salve um arquivo do Calc é necessário alterar a formato de definição do caminho. O BrOffice sempre passa a idéia para esse tipo de coisa como se fosse um endereço URL, logo, sempre que vocês ver URL em um parâmetro já saberá o que mais ou menos está sendo exigido.

Sigamos agora para os eventos do segundo botão.

view source print ? 01.procedure TForm1.Button2Click(Sender: TObject); 02.var03. Valores : Variant; 04. Destino : String; 05.begin06. Destino := TranformaDeCaminhoParaURL(Edit1.Text); 07. Valores := VarArrayCreate([0,0], varVariant); 08. Valores[0] := AtribuirValores('Overwrite',true); 09. Destino := Destino + '.ods'; //Extensão da planilha do broffice 10. Documento.storeAsURL(Destino, Valores); 11.end;

A variável Valores é muito interessante e ela lhe dará acesso a um grande universo; essa variável ela faz referência a dois parâmetros – um chamado Name e outro chamado Value. Passa a idéia de um array multidimensional, algo como Teste[0][0] e Teste[0][1], a função VarArrayCreate cria um array de variantes, sendo então o primeiro parâmetro o tamanho do array e o segundo, o tipo de valores registrados no array. Se você usar VarArrayCreate([0, 4], varInteger) estará fazendo uma referência a algo assim:

view source print ? 1.Elementos := VarArrayCreate([0,4], varInteger); 2.Elementos[0] := 1; 3.Elementos[1] := 2; 4.Elementos[2] := 100;

5.Elementos[3] := 1000; 6.Elementos[4] := 10000;

O que foi feito então em nosso botão: Criamos o array e informamos que ele conterá um único valor. Na sequência temos a seguinte declaração: Valores[0] := AtribuirValores('Overwrite', true); Essa função também foi criada e adicionada no parte inicial do nosso pequeno programa, e está registrada da seguinte forma:

view source print ? 01.function TForm1.AtribuirValores(Nome, Valor : Variant): Variant; 02.var03. Reflec : Variant; 04.begin05. Reflec := BrOffice.createInstance('com.sun.star.reflection.CoreReflection'); 06. Reflec.forName('com.sun.star.beans.PropertyValue').createObject(result); 07. result.Name := Nome; 08. result.Value:= Valor; 09.end;

Essa função não foi criada por mim, mas está presente naquele documento menciaonado em nossa primeira lição. Essa função cria uma instância do Core do BrOffice e atribuir propriedades de valor. Você usará muito essa função, porque podemos atribuir os elementos de formatação de células e até mesmo salvar arquivos usando a estrutura UNO que veremos mais adiante. Ao usarmos a função, atente que estamos definindo a atribuição de propriedades para o elemento ZERO – Valores[0] e estamos dizendo o seguinte Valores[0][Name] := 'Overwrite' e Valores[0][Value] := true; Veja que isso é somente uma representação. Isto feito, avançamos para o procedimento storeAsUrl(URL, Array); e fizemos então:

view source print ? 1.Documento.storeAsURL(Destino, Valores);

Salva o documento na pasta especificada e dentro daquele padrão que modificamos e exigido pelo BrOffice. E então o array chamado Valores e dizendo que se existir um arquivo com o mesmo nome no local que estamos salvando ele será sobreescrito. O recomendável é sempre fazer AtribuirValores('Overwrite', false). Isso é o recomendável.

Um pequeno detalhe, estamos trabalhando com arquivos do tipo BrOffice, então adicionei ao endereço a extensão para o arquivo – tipo '.ODS' que é o padrão de extensão.

Download

O código fonte se encontra anexado a este artigo. Baixe-o se achar necessário.\

Delphi e BrOffice - Parte 2.rar

Até o próximo passo!

Continuação - Delphi e OpenOffice(BROffice) - Parte 3

ALCANÇANDO AS CÉLULAS NO CALC

I – REQUISITOS

É necessário ter acompanhado os dois módulo anteriores já que apresentam o conteúdo introdutório do assunto.

II – INTRODUÇÃO

Como pudemos observar na segunda parte desse artigo, acessamos planilhas, salvamos com os nomes desejados, excluímos e inserimos planilhas. A idéia básica é sempre abordarmos as partes mais externas e assim, ir avançando para as "entranhas". Bem, chegamos numa das partes mais importantes de nosso artigo – cito como mais importante, porque sempre fazemos a parte da formatação quando exportamos os dados para uma planilha ou para um documento de texto. Nossos clientes adoram, mas muitas vezes não tem noção da complexidade existente para que a tarefa seja executada.

O que veremos nesse momento de nosso artigo? Faremos acesso as células e adiconaremos as respectivas formatações: fonte, cor da célula, tamanho da célula, alinhamento, quebra de texto, borda e angulo de inclinação de nosso texto. Será necessário iniciarmos tudo do zero sendo que a parte prinicpal das chamadas OLE podem ser devidamente copiadas dos módulos anteriores.

As células no BrOffice seguem o mesmo padrão de nomenclatura do Excel, isto é, nome da Coluna e nome da Linha. Na parte da programação, você pode fazer referência ao nome da célula ou aos índices da Coluna e Linha; deixando mais claro, poderemos tanto usar a referência da célula pelo processo normal (A2, B5, C6, AJ38) ou ainda por índices (0,0 = A1, 4,2 = E3). Porém um detalhe importante deve ser posto: as referências de nome (A2, B5 e etc) são facilmente acessadas com o módulo UNO, sem ele, o acesso se dá facilmente usando o método getCellByPosition(Col, Row).

O Nosso exercício quando finalizado deverá estar parecido mais ou menos com a tela apresentada abaixo:

III – CODIFICANDO

O que faremos a partir de agora, será adicionarmos conteúdo a nossa planilha. O que estou fazendo de diferente, é somente declarar as variáveis do tipo variant como públicas, devido a facilidade de executar as coisas mais facilmente. Até porque o escopo de visualização de variáveis, funções e métodos não estão sendo avaliadas nesse momento. Isso caberá exclusivamente a você.

Na parte inicial de nosso sistema, defini as seguintes variáveis:

view source print ? 1.var2. Form1: TForm1; 3. 4. BrOffice, Desktop, Documento : Variant; 5. Planilha, Celula : Variant;

Declaramos também as unit ComObj e ShellAPI. A justificativa se dá que a unit ComObj nos dá o acesso aos objetos OLE, já a ShellAPI simplesmente foi adicionada com a intenção de capturar os nomes das fontes do sistema, para que a partir dai, pudéssemos aplicar na formatação de nossa planilha. Nada de mais até agora.

Em nossa pequena aplicação temos somente um botão, ele aplicará a mesma formatação a todos os valores das células e bordas que forem utilizados. Veja a primeira parte do evento onClick do botão:

view source print ? 01.procedure TForm1.Button1Click(Sender: TObject); 02.var03. X, Y : SHORT; 04. Valor : String; 05.begin06. BrOffice := CreateOleObject('com.sun.star.ServiceManager'); 07. Desktop := BrOffice.CreateInstance('com.sun.star.frame.Desktop'); 08. Documento := Desktop.LoadComponentFromURL('private:factory/scalc', 09. '_blank', 0, VarArrayCreate([0,-1], varVariant)); 10. 11. Planilha := Documento.getSheets.getByName('Planilha1'); 12. : Variant;

Desta vez modificamos um pouco a chamada a forma como capituramos o nome da planilha, usamos um método chamado getByName(Nome da Planilha), o pressuposto é que o desenvolvedor saberá quais planilhas estão presentes em sua pasta. Informamos então que estaremos trabalhando com a primeira folha chamada Planilha1. Um pouco mais abaixo, como aparece no código seguinte, declaramos dois laços For, porém no segundo laço, encontramos a seguinte atribuição – Célula := Planilha.getCellByPosition(X, Y), onde: X representa a coluna e Y a linha. Preste a atenção para esse método, pois através dele, poderemos obter ou atribuir valores, funções e formatação para as células. Um outro ponto importante a ressaltar é que, você não usará o método dessa forma getCellByPosition('A', 1) isso está errado, sempre deverá utilizar getCellByPosition(0, 0); essa referência diz que estamos trabalhando com a célula A1.

view source print ? 1.For X := cbIni.ItemIndex to CbFim.ItemIndex do2.begin3. For Y := 0 to Pred(SpinEdit1.Value) do4. begin5. Celula := Planilha.getCellByPosition(X, Y);

Ótimo, já sabemos como podemos trabalhar com as linhas e colunas, fica mais fácil ainda iniciar o processo de inserção de valores em nossas células. Veja a sequência de código e encontramos a seguinte declaração: Celula.setString(' Aqui vai uma String'). Por padrão, quando digitamos uma String em uma célula tanto no Excel como no Scalc, os valores ficam alinhados a esquerda. Para que possamos inserir valores numéricos por exemplo, usaremos quase o mesmo método, somente trocando de setString para setValue. Tudo igual, somente muda os valores que está sendo inserido.

view source print ? 1.if rbTipo1.Checked then2.begin3. Valor := cbIni.Items.Strings[X] + IntToStr(Y + 1); 4. Celula.setString(Valor); 5.end else begin6. Valor := IntToStr(RandomRange(-123456789, 123456789)); 7. Celula.setValue(Valor); 8.end;

Nesse momento entramos nos demais elementos de formatação de Células. A propriedade CharFonteName é onde definimos o nome da fonte que iremos trabalhar para a célula, ela recebe um valor do tipo String. Em nossa aplicação, criamos duas pequenas funções, para justamente adicionar no ComboBox2 os nomes da fontes encontrada em nosso sistema. Você poderia usar um FontDialog para obter as propriedades de nome, tamanho, cor e estilo; isso poderia lhe trazer um certo problema, principalmente relacionados a cor, sublinhado e Estilo. A propriedade CharHeight recebe um valor inteiro e define o tamanho da fonte. As duas funções que adicionam os nomes de fontes dentro do ComboBox2 são:

view source print ? 01.function EnumFontsProc(var LogFont: TLogFont; var TextMetric: TTextMetric; 02. FontType: Integer; Data: Pointer): Integer; stdcall; 03.begin04. TStrings(Data).Add(LogFont.lfFaceName); 05. Result := 1;

06.end; 07. 08.procedure TForm1.CapturarNomesDeFontes; 09.var10. DC: HDC; 11.begin12. DC := GetDC(0); 13. EnumFonts(DC, nil, @EnumFontsProc, Pointer(ComboBox2.Items)); 14. ReleaseDC(0, DC); 15. ComboBox2.Sorted := True; 16. ComboBox2.ItemIndex := 0; 17.end;

Essas funções estão presentes no exemplo do arquivo de ajuda do Delphi – nome: RichEdit.

view source print ? 1.//Nome da Fonte 2.Celula.CharFontName := ComboBox2.Text; 3. 4.//Tamanho da Fonte 5.Celula.CharHeight := StrToInt(Edit1.Text);

A parte do alinhamento, tanto o horizontal como o vertical, podem ser definidos através das propriedades HoriJustify e VertJustify. Atente que elas apresentam diferenças de constates de uma para outra. Para HoriJustify, temos:

• STANDARD : é o alinhamento padrão tanto para números como para textos, sendo a esqueda para as strings e a direita para os números;

• LEFT : o conteúdo é alinhado no lado esquerdo da célula; • CENTER : o conteúdo é alinhado no centro da célula;• RIGHT : o conteúdo é alinhado no lado direito da célula;• BLOCK : o conteúdo é alinhando em relação ao comprimento da célula; • REPEAT : o conteúdo é repetido dentro da célula para preenchê-la.

Para VertJustify, temos:

• STANDARD : é o valor usado como padrão;• TOP : o conteúdo da célula é alinhado pelo topo;• CENTER : o conteúdo da célula é alinhado pelo centro;• BOTTOM : o conteúdo da célula é alinhado pela base.

Como poderá observar no código fonte dessa aplicação, verá que para HoriJustify estamos usando respectivamente os seguintes valores: 0, 1, 2, 3, 4 e 5. Já para as definições de VertJustify estou usando os valores: 0, 1, 2 e 3. Se a programação se der dentro do ambiente de macros do BrOffice, deveremos usar as constantes sendo obedecidos os módulos em que são declarados. Diferentemente do que fazemos aqui onde emitimos os valores da indexação dos valores.

view source print ? 1.//Alinhamento Horizontal 2.Celula.HoriJustify := RetornaValorDoCombobox('-', ComboBox3); 3. 4.//Alinhamento Vertical 5.Celula.VertJustify := RetornaValorDoCombobox('-', ComboBox4);

Para os sublinhados, temos 18 (dezoito) tipos diferentes, e podem ser definidos como:

• 0 - None // Sem sublinhado. • 1 - Single // linha simples.• 2 - Double // linha dupla.• 3 - Dotted // linha pontilhada.

• 4 - DontKnow // Sublinhado desconhecido. • 5 - Dash // linha tracejada. • 6 - LongDash // traços longos. • 7 - DashDot // traço e ponto sequenciados. • 8 - DashDotDot // traço, ponto, ponto sequencia. • 9 - SmallWave // Ondas pequenas. • 10 - Wave // Em onda. • 11 - DoubleWave // Em ondas duplas. • 12 - Bold // linha em negrito. • 13 - BoldDotted // pontos em negrito. • 14 - BoldDash // traços em negrito. • 15 - BoldLongDash // Traços longo em negrito. • 16 - BoldDashDot // Traço, ponto e sequencia em negrito. • 17 - BoldDashDotDot // Traço, ponto, ponto, sequencia em negrito. • 18 - BoldWave // onda Negritada....

Para atribuir um tipo de sublinhado a sua fonte, use a propriedade CharUnderline, atribuindo um dos valores apresentados acima.

view source print ? 1.//Tipo de Sublinhado 2.Celula.CharUnderline:= RetornaValorDoCombobox('-', ComboBox5);

Para atribuirmos itálico, usamos a propriedade CharWeight e estão disponíveis as seguintes contantes, conforme a lista abaixo:

• 0 - Dontknow = Camera / desconhecido.• 50 - Thin = 50% do peso da fonte. • 60 - UltraLight = 60% do peso da fonte.• 75 - Light = 75% do peso da fonte.• 90 - SemiLight = 90% do peso da fonte.• 100 - Normal = 100% peso da fonte normal (100%). • 110 - SemiBold = 110% do peso da fonte. • 150 - Bold = 150% do peso da fonte. • 175 - UltraBold = 175% do peso da fonte. • 200 - Negro = 200% do peso da fonte

view source print ? 1.//Tipo de Itálico 2.Celula.CharWeight := RetornaValorDoCombobox('-', ComboBox6);

Até esse momento de nossa codificação, tudo vai de "vento em popa", porém quando falamos de cores, tanto para background das células, como para bordas e o conteúdo, a coisa muda um pouco. Podemos definir cores usando uma função no Delphi definida como RGB(Red, Green, Blue), podendo em cada parâmetro, receber um valor Short de 0 a 255. Porém, se executarmos a seguinte atribuição a uma cor no BrOffice, algo do tipo – RGB(123, 066, 222), é bem provável que a cor apresentada, não seja aquela esperada. Porque isso acontece? Aqui vai uma explicação simples: porque o valor utilizado para representar uma cor no BrOffice é compreendido como um único número inteiro. Em código pascal, poderíamos dar como exemplo, o seguinte:

view source print ? 1.Var 2. vRed : Short; //Valor entre 0 e 255 3. vGree: Short; //Valor entre 0 e 255 4. vBlue: Short; //Valor entre 0 e 255 5. vColorBR : Integer; //Valores podem variar em 16, 577 e 320

Então, para facilitar ainda mais sua vida, você poderá usar uma das seguintes cores indexadas e conforme são apresentadas em nossa aplicação num pequeno grid de 10 X 11. Utilizando os valores aqui listados, não há erro. O Excel também trabalha com uma indexação de cores, porém

se você usar o RGB as cores sairão dentro do que você estava prevendo. Não podemos dizer o mesmo para o BrOffice.

Para atribuir uma cor de fonte use a propriedade CharColor, e para o Background utilize a propriedade CellBackColor , para ambos, atribua um dos valores da tabela acima.

view source print ? 1.//Cor da Fonte 2.Celula.CharColor := RetornaValorDoCombobox('-', ComboBox7); 3. 4.//Cor do Background da Célula 5.Celula.CellBackColor:= RetornaValorDoCombobox('-', ComboBox1);

Entendido os problemas relacionados as cores e obviamente que sanadas as dúvidas, voltemos a parte light da coisa. Se estiver interessado em rotacionar o texto dentro de uma célula, utilize as propriedades RotateReference e RotateAngle. A propriedade mais importante é realmente RotateAngle. Você pode fazer a atribuição como o exemplo do código nessa sequência. Onde multiplicamos o valor por 100. A propriedade aceita valores iguais ou maiores a 0,01. Eis o motivo de eu fazer a multiplicação por 100. Para um ângulo de 45, ficaria a seguinte definição por exemplo: Celula.RotateAngle := 4500; // 45 * 100. A propriedade RotateReference é utilizada como referência para a partida da rotação do conteúdo. Pode ser o valor 0 (ZERO) para a partir da base, 1 para partir do topo e 2 para partir do centro da célula.

view source print ? 1.//Permite rotacionar o conteúdo da célula 2.if Rotacionar.Checked then3.begin4. Celula.RotateReference := RadioGroup1.ItemIndex; 5. Celula.RotateAngle := StrToInt(Edit2.Text) * 100;

6.end;

Para quebrar o conteúdo do texto, defina a propriedade IsTextWarapped para True. É uma propriedade booleana, portanto, aceitará somete true ou false.

view source print ? 1.//Quebrar o conteúdo da Célula 2.if cbQuebrar.Checked then3. Celula.IsTextWrapped := True;

As bordas da células podem conter formatações diferentes, isto é, podemos formatar a borda superior com espessura e cor diferente da borda inferior, assim como a borda da esquerda totalmente diferente da direita. O processo de formatação da borda tem muito mais recursos quando trabalhamos com as estruturas UNO, como veremos mais adiante. A atribuição da formatação das bordas usa na verdade, uma estrutura do módulo table e que por consequência, utiliza uma outra tabela onde definimos as especificações para cor, espessura da borda interna e externa e a distância entre elas. Para que você possa formatar as bordas de suas células, será necessário usar a função AtribuirBordas, Essa função é parecida com aquela que criamos nas segunda parte para podermos salvar nossos arquivos.

view source print ? 01.function TForm1.AtribuirBordas(Cor, EspLinInter, EspLinExter, 02. DistLinha : Variant): Variant; 03.var04. otherRef : Variant; 05.begin06. otherRef := BrOffice.createInstance('com.sun.star.reflection.CoreReflection'); 07. otherRef.forName('com.sun.star.table.BorderLine').createObject(result); 08. result.Color := Cor; 09. result.InnerLineWidth := EspLinInter ; 10. result.OuterLineWidth := EspLinExter; 11. result.LineDistance := DistLinha; 12.end;

Como pode ser visto, estamos utilizando o módulo BorderLine. É o que fazemos então atribuindo a propriedade relativa a cada célula. Veja que atribuimos a Celula.TopBorder := AtribuirBordas(...... Estamos dizendo que a borda superior terá a configuração passada em seus parâmetros. Esses parâmetros podem ser diferentes para cada borda desejada. Se você quiser somente que as bordas superiores e inferiores apareçam, atribuia as propriedades somente a essas duas bordas e esqueça as demais.

view source print ? 01.//Formatação das bordas das Células 02. if bSup.Checked then03. Celula.TopBorder := AtribuirBordas(RetornaValorDoCombobox('-', ComboBox8), 04. StrToInt(Edit4.Text), 05. StrToInt(Edit5.Text), 06. StrToInt(Edit6.Text)); 07. if bEsq.Checked then08. Celula.LeftBorder := AtribuirBordas(RetornaValorDoCombobox('-', ComboBox8), 09. StrToInt(Edit4.Text), 10. StrToInt(Edit5.Text), 11. StrToInt(Edit6.Text)); 12. if bDir.Checked then13. Celula.RightBorder := AtribuirBordas(RetornaValorDoCombobox('-', ComboBox8), 14. StrToInt(Edit4.Text), 15. StrToInt(Edit5.Text), 16. StrToInt(Edit6.Text)); 17. if bInf.Checked then18. Celula.BottomBorder := AtribuirBordas(RetornaValorDoCombobox('-', ComboBox8), 19. StrToInt(Edit4.Text), 20. StrToInt(Edit5.Text), 21. StrToInt(Edit6.Text)); 22. 23. end;

24. end; 25.end;

Estimados amigos, na sequência vamos nos aprofundar ainda mais em nossas planilhas. Novamente volto a frizar que se erros ou inconscistências ocorrerem, enviem-me um printscreen da tela e se possível o código fonte para que possa analisar e buscar as respecitvas soluções. Gostaria também de acrescentar que isso tudo é fruto de testes e mais testes, portanto podem haver outras variantes de código que realizam a mesma tarefa de forma mais complexa ou mais simples.

Código fonte acompanha este exercício.

Delphi e BrOffice - Parte 3.zip

Continuação - Delphi e OpenOffice(BROffice) - Parte 4

CÉLULAS – Formatações Adicionais

I – INTRODUÇÃO

No artigo anterior tivemos o privilégio de formatar as células dentro de um padrão desejado. Nesse momento, vamos avançar para algumas questões ainda relacionadas com a formatação das células. A parte da inicialização já é conhecida. O que gostaria de atentar aqui é o seguinte: o usuário deve primeiro criar o documento pressionando o botão 1º passo – Executar o Scalc. O código desse botão está definido da seguinte forma:

view source print ? 1.procedure TForm1.Button1Click(Sender: TObject); 2.begin3. BrOffice := CreateOleObject('com.sun.star.ServiceManager'); 4. Desktop := BrOffice.CreateInstance('com.sun.star.frame.Desktop'); 5. Documento := Desktop.LoadComponentFromURL('private:factory/scalc', 6. '_blank', 0, VarArrayCreate([0,-1], varVariant)); 7. Planilha := Documento.getSheets.getByName('Planilha1'); 8.end;

As variáveis estão definidas como públicas para que possamos usá-las em toda a aplicação. Vamos então iniciar a continuação da formatação. Codificaremos a mesclagem de células. Não é incomum adicionar uma célula contendo um texto que seja um detalhamento de informações, algo como: ABCDE – Sistema de Automação Comercial – Relatório SPED para Contabilidade e para finalizar, um tom de cinza no fundo. A mesclagem exige duas células ou mais e pode estar dentro de um intervalo do tipo A2:F2 ou ainda A2:A10; podemos então executar essa tarefa na horizontal ou vertical, ou em ambos os casos, onde define-se o intervalo B5:G15. Vejamos:

view source print ? 1.procedure TForm1.Button2Click(Sender: TObject); 2.begin3. Faixa := Planilha.getCellRangeByPosition(StrToInt(e1.Text), StrToInt(e2.Text), 4. StrToInt(e3.Text), StrToInt(e4.Text)); 5. Faixa.merge(true); 6.end;

A variável Faixa é do tipo Variant, não poderia ser diferente nesse momento. O comando é simples e exige que se tenha quatro valores, ao invés de usarmos getCellByPosiotion onde temos somente uma célula, definiremos o comando como getCellRangeByPosition(Col_Ini, Row_Ini. Col_fim, Row_Fim) . Também é importante ressaltar que ao executar o Calc estou selecionando sempre a primeira planilha. Para completar nosso comando, executamos o método Merge(boolean). E a mágica está feita. Em nosso exemplo, você poderá fazer a mesclagem diversas vezes, bastando para isso, mudar os valores e pressionar o botão mesclar células.

Quando o usuário do Excel digita um valore muito extenso, o conteúdo da célula passa a ser representado por cerquihas (#), no BrOffice é a mesma coisa, só que não tão enfático com o Excel que preenche a célula inteira com cerquilhas. Eu nunca prestei muita atenção no Excel com relação a essa questão do ajuste de largura, sempre que terminava a inserção de dados nas colunas mandava que a cada célula preenchida, o comando AutoFit fosse executado. O Calc usa um comando chamado OptimalWidth. É um método booleano. Em nosso exemplo, vamos trabalhar

com o ajuste de largura para todas as colunas da planilha ou somente para a coluna desejada. O seguinte comando foi registrado no botão Ajuste a Coluna.

view source print ? 01.procedure TForm1.Button3Click(Sender: TObject); 02.var03.x : short; 04.begin05. Texto[0] := 'Escrevendo um texto grande'; 06. Texto[1] := 'Luis Fernando Veríssimo'; 07. Texto[2] := 'The Amazing Race'; 08. Texto[3] := 'República Federativa dos Estados Unidos do Brasil'; 09. Texto[4] := 'Um bilhão de Cruzeiros'; 10. 11. if RadioButton1.Checked then12. Planilha.columns(SpinEdit1.Value).OptimalWidth := True 13. else begin14. For x := 0 to 4 do15. begin16. Celula := Planilha.getCellByPosition(x, x + 1); 17. Celula.setString(Texto[x]); 18. end; 19. Documento.getSheets.getByName('Planilha1').getColumns.OptimalWidth := True; 20. end; 21.end;

O array Texto é somente para preencher as células com um conteúdo relativamente extenso. Mas no primeiro if encontramos a atribuição: Planilha.columns(SpinEdit1.Value).OptimalWidth := True. Todas as planilhas possuem uma propriedade columns(Indice) que faz referência a uma coluna. Então acessamos o membro e definimos o índice. A propriedade OptimalWidth é definida para True. Se o usuário de nossa aplicação escolher ajustar os tamanhos de todas as colunas da planilha, o valor da variável array Texto será inserida em 5 colunas diferentes através do for. Mas na seqüência de nosso código é quem fará o ajuste de todas as colunas. O código Planilha.getColumns.OptimalWidth := True; Para que o ajuste fosse feito em todas as colunas da planilha, usamos o método getColumns que retorna todas as colunas e atribuímos então OptimalWidth e pronto. Esse comando é interessante porque ao invés de fazermos tudo individualmente, faz-se uma vez só e o efeito recai sobre todas as colunas.

Ainda tratando do tamanho de uma célula, podemos ajustar a largura da coluna ou a altura da linha, não esqueça que quando fazemos isso, a coluna desde a primeira linha até a última ficará com a mesma largura, o mesmo diz respeito a linha. Vejamos então a terceira parte que está relacionada as dimensões em nossa aplicação. Para podermos aumentar ou diminuir as dimensões de uma célula usaremos os membros novamente da planilha, nesse caso, getColumns e getRows. O método getColumns retorna todas as colunas de uma planilha e getRows retorna todas as linhas. Como consequência usamos um segundo método para informar qual das linhas ou colunas iremos alterar através de getByIndex(Indice) e então as propriedades width e height. Ambas, recebem um valor inteiro em centésimos de milímetros (1/100 mm).

view source print ? 01.procedure TForm1.Button5Click(Sender: TObject); 02.begin03. Planilha.getColumns.getByIndex(cbIni.ItemIndex).width := StrToInt(Edit1.Text); 04.end; 05. 06.procedure TForm1.Button6Click(Sender: TObject); 07.begin08. Planilha.getRows.getByIndex(SpinEdit2.Value - 1).height := StrToInt(Edit2.Text); 09.end;

Usando o Excel como referência mais uma vez, quando estamos exportando valores para uma planilha, acabamos aproveitando para definir a máscara como o valor da célula será apresentado. Faríamos algo do tipo: Selection.NumberFormat := '$#,##0.00'. No BrOffice não será diferente, será usado a mesma propriedade. Veja a seguir:

view source print ?

01.procedure TForm1.Button4Click(Sender: TObject); 02.var03. i : Integer; 04. cel : variant; 05.begin06. for i := 0 to 1000 do07. begin08. Cel := Planilha.getCellByPosition(1, i); 09. Cel.setValue(i); 10. Celula := Planilha.getCellByPosition(0, i); 11. Celula.setValue(i); 12. Celula.NumberFormat := i; 13. end; 14.end;

Existe uma recomendação, infelizmente não lembro quem agora fez a menção do limite que numberFormat poderia alcançar, mas que um valor confortável estaria até mil, e eis o motivo do porque que meu laço for foi definido até esse valor. O que faço nesse processo é colocar o valor da variável i na coluna A e aplicar uma máscara através do método NumberFormat. Atente que o formato da célula passa a ser relativo ao contador do laço for – I. Faço isso, simplesmente para coletar os formatos disponíveis (formatos padrão) e que poderão ser aplicados em qualquer situação. Na caixa de texto adicionada ao nosso programa, você encontrará a forma e o índice para NumberFormat. Existe uma forma alternativa de verificar se existe uma máscara que você precisa trabalhar, se ela não existir poderá ser adicionada nessa listagem, mas não é nosso foco no momento.

A visibilidade de uma coluna pode ser aplicada de uma forma bastante simples, para isso estaremos trabalhando com o método IsVisible que recebe um valor booleano. O código abaixo dispensa qualquer explicação já que foi detalhado até o método getByIndex. Defina o índice da coluna e atribua True ou False.

view source print ? 1.procedure TForm1.Button7Click(Sender: TObject); 2.begin3. if rbInv.Checked then4. Planilha.getColumns.getByIndex(ComboBox1.ItemIndex).isVisible := False 5. else6. Planilha.getColumns.getByIndex(ComboBox1.ItemIndex).isVisible := True; 7.end;

Para encerrarmos essa paste de nossos estudos com chave de ouro, vamos adicionar cabeçalho e rodapé a nossa planilha. Gostaria de ressaltar que, deve ter pelo menos um valor em qualquer célula para que o cabeçalho ou rodapé possam ser visualizados em sua folha de impressão ou até mesmo em sua visualização de impressão. O cabeçalho e rodapé do BrOffice possui o mesmo sistema do Excel: é separado em 3 faixas – a esquerda, a direita e centralizado na página. Na sequencia, veja os códigos definidos para a inserção desses elementos em nosso documento:

view source print ? 01.//Insere o cabeçalho na planilha 02.procedure TForm1.Button8Click(Sender: TObject); 03.var04. Estilo, Padrao, Cabecalho : Variant; 05.begin06. Estilo := Documento.StyleFamilies.getByName('PageStyles'); 07. Padrao := Estilo.getByName('Default'); 08. Padrao.HeaderIsOn := True; 09. Cabecalho := Padrao.RightPageHeaderContent; 10. Case rgAlign.ItemIndex of11. 0 : Cabecalho.LeftText.setString(Edit3.Text); 12. 1 : Cabecalho.CenterText.setString(Edit3.Text); 13. 2 : Cabecalho.RightText.setString(Edit3.Text); 14. end; 15. Padrao.RightPageHeaderContent := Cabecalho; 16.end; 17.

18.//Insere o rodapé na planilha 19.procedure TForm1.Button9Click(Sender: TObject); 20.var21. Estilo, Padrao, Rodape : Variant; 22.begin23. Estilo := Documento.StyleFamilies.getByName('PageStyles'); 24. Padrao := Estilo.getByName('Default'); 25. Padrao.FooterIsOn := True; 26. Rodape := Padrao.RightPageFooterContent; 27. Case rgAlign1.ItemIndex of28. 0 : Rodape.LeftText.setString(Edit4.Text); 29. 1 : Rodape.CenterText.setString(Edit4.Text); 30. 2 : Rodape.RightText.setString(Edit4.Text); 31. end; 32. Padrao.RightPageFooterContent := Rodape; 33.end;

Tanto para o cabeçalho como para o rodapé foram utilizadas as mesmas variáveis (Estilo e Padrao). Essa parte do sistema poderia ficar relativamente mais curta, já que a variável Estilo receberá o estilo sendo usado atualmente em seu documento. Na variável Padrão é aplicado o estilo chamado Default. Podem ser criados estilo diferentes de acordo com cada usuário. Se for usar um outro estilo, verifique os nomes dos estilos existentes. O que é que muda do Cabeçalho para o Rodapé? Olhe a terceira linha de cada um dos eventos, para o cabeçalho temos Padrao.HeaderIsOn, essa é uma propriedade booleana e informa que será aplicado o cabeçalho; para o rodapé usaremos Padrao.FooterIsOn. Na quarta linha de cada um dos códigos vemos a seguinte atribuição: Cabecalho := Padrao.RightPageHeaderContent; e Rodape := Padrao.RightPageFooterContent; As variáveis cabeçalho e rodapé recebem as características, as informações já contidas ou atribuídas anteriormente. Na seqüência, o Case verifica o tipo de alinhamento definido pelo usuário, que poderá ser: a esquerda, a direita e centralizado, sendo LeftText, CenterText e RightText. E obviamente o conteúdo que é uma string, passada por setText(String contendo o texto). E finalizando, inserimos efetivamente as informações através da atribuição da linha de comando Padrao.RightPageHeaderContent := Cabecalho; e Padrao.RightPageFooterContent := Rodape; É um jogo de enviar e receber propriedades.

Espero que até esse momento essas informações tenham lhe sido úteis. Nos próximos passos avançaremos para fórmulas, ordenações, criação de macros, impressão, margens e etc.

Se desejar baixar o código fonte: Delphi e BrOffice - Parte 4.rar

Abraços e até o próximo módulo.

Continuação - Delphi e OpenOffice(BROffice) - Parte 5

CÉLULAS – Usando Funções ou definindo fórmulas

I – INTRODUÇÃO

Em nosso último artigo, vimos como configurar uma célula em suas diversas propriedades, tais como: visibilidade, formato, mesclagem, largura e altura. Vimos também a parte do cabeçalho e rodapé da nossa planilha. Agora, vamos partir para a questão de como trabalhar com fórmulas e funções. As chamadas para o aplicativo já são de seu conhecimento e entendo que não há mais necessidade de enfocar, portanto, se você não acompanhou as explicações anteriores, recomendo que volte um ou dois tutoriais para poder prosseguir nessa 5ª parte.

II – ATRIBUINDO FUNÇÕES OU FÓRMULAS

Até nosso último tutorial não tratamos de como fazer o processo mais importante: executar operações de cálculo no CALC. Formatar é somente um recurso visual que ajuda na visualização dos dados prontos para nossos usuários. A parte do cálculo é muito simples. Vejamos no código abaixo:

view source print ? 1.procedure TForm1.btExecutarClick(Sender: TObject); 2.begin3. AtribuirVariaveis; 4. Planilha.getCellByPosition(0,0).Value := StrToFloat(A1.Text); //A1 5. Planilha.getCellByPosition(0,1).Value := StrToFloat(A2.Text); //A2 6. Planilha.getCellByPosition(0,2).Value := StrToFloat(A3.Text); //A3 7. Planilha.getCellByPosition(0,3).Formula := F1.Text; 8.end;

A diferença básica apresentadas nos tutoriais anteriores é que agora estamos dizendo que trabalhamos com valores através da atribuição Planilha.getCellByPosition(0,0).Value. Para que um cálculo seja executado é definido ao invés de value o atributo Formula. Não confunda com uma função. O BROffice possui uma lista das funções mais utilizadas, não as confunda com as fórmulas que você cria. Nesse segundo momento, vamos verificar como usar as funções. Um detalhe importante eu devo deixar claro, se você tentar aplicar as funções usando o nome em português, algo como: SOMA(X:Y), MULT(X:Y) e assim por diante, provavelmente obterá um erro pelo nome da função. Esses nomes devem ser passados em Inglês. Para ter acesso a todas as funções, acesse o site:

http://wiki.services.openoffice.org/wiki/Documentation/How_Tos/Calc:_Functions_listed_by_category

view source print ? 01.procedure TForm1.buExecFuncaoClick(Sender: TObject); 02.begin03. AtribuirVariaveis; 04. Planilha.getCellByPosition(0,0).Value := StrToFloat(A4.Text); //A1 05. Planilha.getCellByPosition(0,1).Value := StrToFloat(A5.Text); //A2 06. Planilha.getCellByPosition(0,2).Value := StrToFloat(A6.Text); //A3 07. Case cbFuncao.ItemIndex of08. 0 : Planilha.getCellByPosition(0,3).Formula := '=SUM(A1:A3)'; //soma 09. 1 : Planilha.getCellByPosition(0,3).Formula := '=AVERAGE(A1:A3)'; //média 10. 2 : Planilha.getCellByPosition(0,3).Formula := '=MAX(A1:A3)'; //máximo 11. 3 : Planilha.getCellByPosition(0,3).Formula := '=MIN(A1:A3)'; //mínimo 12. 4 : Planilha.getCellByPosition(0,3).Formula := '=PRODUCT(A1:A3)'; //multiplica 13. end; 14.end;

III – PROPRIEDADES DO DOCUMENTO

Aproveitando o “gancho” para não ficar muito em cima de uma coisa só, vamos aproveitar para adicionar propriedades do autor ao documento. As propriedades podem ser acessadas no menu Arquivo do BrOffice e no submenu > Propriedades. Para atribuí-las ao seu documento, devemos usar a variável Documento e não a Planilha. Você pode definir outras poucas propriedades do

documento, porém as que estou passando abaixo, são as mais comuns. Em nosso tutorial, acrescentei mais uma procedure chamada Propriedades e que está definida na seguinte forma:

view source print ? 01.procedure TForm1.Propriedades; 02.begin03. if chProp.Checked then04. begin05. Documento.DocumentInfo.Author := edAut.Text; //Autor do documento 06. Documento.DocumentInfo.Title := edTit.Text; //Título do documento 07. Documento.DocumentInfo.Subject := edAss.Text; //Assunto do documento 08. Documento.DocumentInfo.Keywords := edKeyW.Text; //Palavras-Chave do documento 09. Documento.DocumentInfo.Description := mmDesc.Text; //Descrição do conteúdo 10. end; 11.end;

E aqui na sequência, a forma como fica quando executamos o nosso aplicativo contendo as descrições preenchidas, veja:

Essa é mais uma parte de nosso tutorial. Espero agora que mesmo sendo pouca conteúdo apresentado, eles tenham sido de grande valia para implementar em suas aplicações.

Se desejar baixar o código fonte: Delphi e BrOffice - Parte 5.zip

Abraços e até o próximo módulo.