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 sourceprint?
01.Case RadioGroup1.ItemIndex of
02. 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 sourceprint?
01.procedure TForm1.Button1Click(Sender: TObject);
02.var
03. BrOffice, Desktop, Executar : Variant;
04.begin
05. if RadioGroup1.ItemIndex <> 0 then
06. begin
07. 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 sourceprint?
01.procedure TForm1.FormShow(Sender: TObject);
02.begin
03. 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.var
10. x : Integer;
11.begin
12. If (SpinEdit1.Value = 1) then
13. begin
14. ShowMessage('Uma planilha deve estar presente obrigatoriamente na pasta');
15. SpinEdit1.Value := 1;
16. StringGrid1.RowCount := 2;
17. end else begin
18. StringGrid1.RowCount := SpinEdit1.Value + 1;
19. For x := 1 to StringGrid1.RowCount do
20. 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 sourceprint?
01.procedure TForm1.Button1Click(Sender: TObject);
02. var
03. N, x : SHORT;
04. Remover : array[0..2] of String;
05. begin
06.
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 do
14. 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 do
19. begin
20. if CheckBox1.Checked then
21. begin
22. if not Documento.Sheets.hasByName(StringGrid1.Cells[1, x]) then
23. Documento.getSheets.insertNewByName(StringGrid1.Cells[1, x] , x - 1)
24. else
25. 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 else
28. 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 do
34. 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) do
40. 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 sourceprint?
1.function TForm1.TranformaDeCaminhoParaURL(nomeArq: String): String;
2.var
3. NomeFile : String;
4.begin
5. NomeFile := LowerCase(nomeArq);
6. if (Pos('file:///', NomeFile) = 0) then
7. 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 sourceprint?
01.procedure TForm1.Button2Click(Sender: TObject);
02.var
03. Valores : Variant;
04. Destino : String;
05.begin
06. 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 sourceprint?
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 sourceprint?
01.function TForm1.AtribuirValores(Nome, Valor : Variant): Variant;
02.var
03. Reflec : Variant;
04.begin
05. 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 sourceprint?
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 sourceprint?
1.var
2. 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 sourceprint?
01.procedure TForm1.Button1Click(Sender: TObject);
02.var
03. X, Y : SHORT;
04. Valor : String;
05.begin
06. 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 sourceprint?
1.For X := cbIni.ItemIndex to CbFim.ItemIndex do
2.begin
3. For Y := 0 to Pred(SpinEdit1.Value) do
4. begin
5. 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 sourceprint?
1.if rbTipo1.Checked then
2.begin
3. Valor := cbIni.Items.Strings[X] + IntToStr(Y + 1);
4. Celula.setString(Valor);
5.end else begin
6. 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 sourceprint?
01.function EnumFontsProc(var LogFont: TLogFont; var TextMetric: TTextMetric;
02. FontType: Integer; Data: Pointer): Integer; stdcall;
03.begin
04. TStrings(Data).Add(LogFont.lfFaceName);
05. Result := 1;
06.end;
07.
08.procedure TForm1.CapturarNomesDeFontes;
09.var
10. DC: HDC;
11.begin
12. 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 sourceprint?
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 sourceprint?
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 sourceprint?
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 sourceprint?
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 sourceprint?
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 sourceprint?
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 sourceprint?
1.//Permite rotacionar o conteúdo da célula
2.if Rotacionar.Checked then
3.begin
4. 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 sourceprint?
1.//Quebrar o conteúdo da Célula
2.if cbQuebrar.Checked then
3. 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 sourceprint?
01.function TForm1.AtribuirBordas(Cor, EspLinInter, EspLinExter,
02. DistLinha : Variant): Variant;
03.var
04. otherRef : Variant;
05.begin
06. 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 sourceprint?
01.//Formatação das bordas das Células
02. if bSup.Checked then
03. Celula.TopBorder := AtribuirBordas(RetornaValorDoCombobox('-', ComboBox8),
04. StrToInt(Edit4.Text),
05. StrToInt(Edit5.Text),
06. StrToInt(Edit6.Text));
07. if bEsq.Checked then
08. Celula.LeftBorder := AtribuirBordas(RetornaValorDoCombobox('-', ComboBox8),
09. StrToInt(Edit4.Text),
10. StrToInt(Edit5.Text),
11. StrToInt(Edit6.Text));
12. if bDir.Checked then
13. Celula.RightBorder := AtribuirBordas(RetornaValorDoCombobox('-', ComboBox8),
14. StrToInt(Edit4.Text),
15. StrToInt(Edit5.Text),
16. StrToInt(Edit6.Text));
17. if bInf.Checked then
18. 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 sourceprint?
1.procedure TForm1.Button1Click(Sender: TObject);
2.begin
3. 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 sourceprint?
1.procedure TForm1.Button2Click(Sender: TObject);
2.begin
3. 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 sourceprint?
01.procedure TForm1.Button3Click(Sender: TObject);
02.var
03.x : short;
04.begin
05. 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 then
12. Planilha.columns(SpinEdit1.Value).OptimalWidth := True
13. else begin
14. For x := 0 to 4 do
15. begin
16. 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 sourceprint?
01.procedure TForm1.Button5Click(Sender: TObject);
02.begin
03. Planilha.getColumns.getByIndex(cbIni.ItemIndex).width := StrToInt(Edit1.Text);
04.end;
05.
06.procedure TForm1.Button6Click(Sender: TObject);
07.begin
08. 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 sourceprint?
01.procedure TForm1.Button4Click(Sender: TObject);
02.var
03. i : Integer;
04. cel : variant;
05.begin
06. for i := 0 to 1000 do
07. begin
08. 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 sourceprint?
1.procedure TForm1.Button7Click(Sender: TObject);
2.begin
3. if rbInv.Checked then
4. Planilha.getColumns.getByIndex(ComboBox1.ItemIndex).isVisible := False
5. else
6. 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 sourceprint?
01.//Insere o cabeçalho na planilha
02.procedure TForm1.Button8Click(Sender: TObject);
03.var
04. Estilo, Padrao, Cabecalho : Variant;
05.begin
06. Estilo := Documento.StyleFamilies.getByName('PageStyles');
07. Padrao := Estilo.getByName('Default');
08. Padrao.HeaderIsOn := True;
09. Cabecalho := Padrao.RightPageHeaderContent;
10. Case rgAlign.ItemIndex of
11. 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.var
21. Estilo, Padrao, Rodape : Variant;
22.begin
23. Estilo := Documento.StyleFamilies.getByName('PageStyles');
24. Padrao := Estilo.getByName('Default');
25. Padrao.FooterIsOn := True;
26. Rodape := Padrao.RightPageFooterContent;
27. Case rgAlign1.ItemIndex of
28. 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 sourceprint?
1.procedure TForm1.btExecutarClick(Sender: TObject);
2.begin
3. 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 sourceprint?
01.procedure TForm1.buExecFuncaoClick(Sender: TObject);
02.begin
03. 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 of
08. 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 sourceprint?
01.procedure TForm1.Propriedades;
02.begin
03. if chProp.Checked then
04. begin
05. 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.