Delphi e OpenOffice(BROffice) - Parte 4

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:

procedure TForm1.Button1Click(Sender: TObject);
begin
 BrOffice  := CreateOleObject('com.sun.star.ServiceManager');
 Desktop   := BrOffice.CreateInstance('com.sun.star.frame.Desktop');
 Documento := Desktop.LoadComponentFromURL('private:factory/scalc',
         			       '_blank', 0, VarArrayCreate([0,-1], varVariant));
 Planilha := Documento.getSheets.getByName('Planilha1');
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:

procedure TForm1.Button2Click(Sender: TObject);
begin
 Faixa := Planilha.getCellRangeByPosition(StrToInt(e1.Text), StrToInt(e2.Text),
                             StrToInt(e3.Text), StrToInt(e4.Text));
 Faixa.merge(true);
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.

procedure TForm1.Button3Click(Sender: TObject);
var
x : short;
begin
 Texto[0] := 'Escrevendo um texto grande';
 Texto[1] := 'Luis Fernando Veríssimo';
 Texto[2] := 'The Amazing Race';
 Texto[3] := 'República Federativa dos Estados Unidos do Brasil';
 Texto[4] := 'Um bilhão de Cruzeiros';

 if RadioButton1.Checked then
   Planilha.columns(SpinEdit1.Value).OptimalWidth := True
 else begin
   For x := 0 to 4 do
   begin
    Celula := Planilha.getCellByPosition(x, x + 1);
    Celula.setString(Texto[x]);
   end;
   Documento.getSheets.getByName('Planilha1').getColumns.OptimalWidth := True;
 end;
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).

procedure TForm1.Button5Click(Sender: TObject);
begin
 Planilha.getColumns.getByIndex(cbIni.ItemIndex).width := StrToInt(Edit1.Text);
end;

procedure TForm1.Button6Click(Sender: TObject);
begin
 Planilha.getRows.getByIndex(SpinEdit2.Value - 1).height := StrToInt(Edit2.Text);
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:

procedure TForm1.Button4Click(Sender: TObject);
var
 i : Integer;
 cel : variant;
begin
 for i := 0 to 1000 do
 begin
    Cel := Planilha.getCellByPosition(1, i);
    Cel.setValue(i);
    Celula := Planilha.getCellByPosition(0, i);
    Celula.setValue(i);
    Celula.NumberFormat := i;
 end;
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.

procedure TForm1.Button7Click(Sender: TObject);
begin
 if rbInv.Checked then
   Planilha.getColumns.getByIndex(ComboBox1.ItemIndex).isVisible := False
 else
   Planilha.getColumns.getByIndex(ComboBox1.ItemIndex).isVisible := True;
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:

//Insere o cabeçalho na planilha
procedure TForm1.Button8Click(Sender: TObject);
var
 Estilo, Padrao, Cabecalho : Variant;
begin
 Estilo := Documento.StyleFamilies.getByName('PageStyles');
 Padrao := Estilo.getByName('Default');
 Padrao.HeaderIsOn := True;
 Cabecalho := Padrao.RightPageHeaderContent;
 Case rgAlign.ItemIndex of
 0 : Cabecalho.LeftText.setString(Edit3.Text);
 1 : Cabecalho.CenterText.setString(Edit3.Text);
 2 : Cabecalho.RightText.setString(Edit3.Text);
 end;
 Padrao.RightPageHeaderContent := Cabecalho;
end;

//Insere o rodapé na planilha
procedure TForm1.Button9Click(Sender: TObject);
var
 Estilo, Padrao, Rodape : Variant;
begin
 Estilo := Documento.StyleFamilies.getByName('PageStyles');
 Padrao := Estilo.getByName('Default');
 Padrao.FooterIsOn := True;
 Rodape := Padrao.RightPageFooterContent;
 Case rgAlign1.ItemIndex of
 0 : Rodape.LeftText.setString(Edit4.Text);
 1 : Rodape.CenterText.setString(Edit4.Text);
 2 : Rodape.RightText.setString(Edit4.Text);
 end;
 Padrao.RightPageFooterContent := Rodape;
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.