Estava procurando no forum mas não achei o que eu gostaria, preciso chamar o Excel via

delphi 7 e juntamente com a chamada abrir uma planilha que se encontra em outra pasta.
Utilizo o XP Home.

ShellExecute(Handle, nil, PChar(\'c:\\meus documentos\\teste1.xls\'), nil, nil,

SW_SHOWNORMAL)

declarar: ShellApi

Delphi -
Abrir
arquivo
de
qualquer
extensão
Delphi

adicionar à cláusula uses da unit: ComObj

var
Msword: Variant;
procedure TForm1.Button1Click(Sender: TObject);
begin
Msword:=createoleObject("Word.Basic");
Msword.AppShow;
Msword.fileopen("c:\documento.doc");
end;

adicionar à cláusula uses da unit: ShellApi

procedure TForm1.Button1Click(Sender: TObject);
begin

ShellExecute(handle,nil,"winword.exe","c:\DadosLaurinha.doc",nil,sw_ShowMaximized);
end;

var caminho: string;

begin
caminho := "D:\Meus documentos\VigilanciaSanit\Fontes\Nice.doc";
if (fileExists(caminho)) then
ShellExecute(Handle, nil, Pchar(caminho), nil, nil, SW_SHOWNORMAL);
end;
procedure TForm1.Button1Click(Sender: TObject);
var objExcel,Sheet,Chart,s : Variant;
cTitulo : string;
i : integer;
begin
//OBS: Voce deve usar a Clausula ComObj no USES para usar o EXCEL
// Utilize também a Clausula Clipbrd pois neste exemplo faremos uso da memória

// Cria uma instancia para utilizar o Excel

cTitulo := 'Planilha de Teste';
objExcel := CreateOleObject('Excel.Application');
objExcel.Visible := True;
objExcel.Caption := cTitulo;

// Caso queria abrir uma planilha ao invéz de gera-la use os comandos abaixo
//objExcel.Workbooks.Open('c:\teste.xls');
//Sheet := objExcel.Workbooks[1].WorkSheets[cTitulo];
// Daqui em diante os comandos na Planilha são os mesmos do resto do Exemplo
//Sheet.Range['A1','Z70'].Replace('Nome','Alterado');

// Adiciona planilha(sheet)
objExcel.Workbooks.Add;
objExcel.Workbooks[1].Sheets.Add;
objExcel.Workbooks[1].WorkSheets[1].Name := cTitulo;
Sheet := objExcel.Workbooks[1].WorkSheets[cTitulo];

// É possivel copiar um valor da memória diretamente para a planilha

// mas como não se tem controle de onde ele será colado, este processo pode
// ser meio inconveniente
//Clipboard.AsText := 'Linha Copiada para Memória';
//Sheet.paste;

// Nota:
// Pode-se preencher as linhas usando o comando abaixo, desta forma vc usaria
// a planilha como se ela fosse uma Array, em alguns casos pode ser interessante
// mas no geral considero bem mais trabalhoso, abaixo demonstro outra forma de
trabalho
// usando o RANGE que torna o trabalho bem mais simples
//Sheet.Cells[1,1] := 'Coluna[1,1]';

// Preenchendo as Colunas
// Usando o RANGE vc pode preencher várias colunas ao mesmo tempo usando
['A1','A10']
// Ou preencher apenas uma usando ['A1'], isso torna o processo ágil e simples
Sheet.Range['A1'] := 'Código';
Sheet.Range['B1'] := 'Nome';
Sheet.Range['C1'] := 'Fone';
Sheet.Range['D1'] := 'Salário';

// por aqui tu limparias a planilha

// No caso do FOR se torna interessante usar o SHEET.CELLS (veja como)

// Atente que usei o FOR a partir do numero 2 desta forma pularemos a
// primeira linha que ja contem um cabeçalho preenchido acima
for i := 2 to 10 do begin
Sheet.Cells[i,1] := i;
Sheet.Cells[i,2] := 'Nome Cliente '+inttostr(i);
Sheet.Cells[i,3] := 'Fone Cliente '+inttostr(i);
// Formata o Numero para se tornar MOEDA
Sheet.Cells[i,4].NumberFormat := 'R$ #.##0,00_);(R$ #.##0,00)';
Sheet.Cells[i,4] := 1000*i;
end;

// Formatando o Cabeçalho
Sheet.Range['A1','D1'].font.name := 'Verdana'; // Fonte
Sheet.Range['A1','D1'].font.size := 12; // Tamanho da Fonte
Sheet.Range['A1','D1'].font.bold := true; // Negrito
Sheet.Range['A1','D1'].font.italic := true; // Italico
Sheet.Range['A1','D1'].font.color := clYellow; // Cor da Fonte
Sheet.Range['A1','D1'].Interior.Color := $00ffcf9c; // Cor da Célula
// Define o tamanho das Colunas (basta fazer em uma delas e as demais serão
alteradas)
Sheet.Range['B1','C1' ].ColumnWidth := 27;
Sheet.Range['B1','C1' ].RowHeight := 25;
Sheet.Range['D1'] .ColumnWidth := 16;

// Outras formas de Formatar

Sheet.Range['E1'] := 'Subscrito';
Sheet.Range['E2'] := 'Superescrito';
Sheet.Range['E3'] := 'Sublinhado';
Sheet.Range['E4'] := 'Strike';
Sheet.Range['E1'].font.Subscript := true; // Subscrito
Sheet.Range['E2'].font.Superscript := true; // Superescrito
Sheet.Range['E3'].font.Underline := true; // Sublinhado
Sheet.Range['E4'].font.Strikethrough := true; // Strike

// Colocando a Borda em um unico lado da Célula

Sheet.Range['E5'].Font.size := 7;
Sheet.Range['E5'].ColumnWidth := 20;
Sheet.Range['E5'] := 'Só um lado da Celula com Borda';
Sheet.Range['E5'].Borders.Item[$00000009].Weight := $FFFFEFD6;
Sheet.Range['E5'].Borders.Item[$00000009].Color := clRed;
//-- Espessura da Linha
//========================
{xlHairline = $00000001;
xlMedium = $FFFFEFD6;
xlThick = $00000004;
xlThin = $00000002;}
//-- Posição da Celula que se deseja colocar a Borda
//=====================================================
{xlInsideHorizontal = $0000000C;
xlInsideVertical = $0000000B;
xlDiagonalDown = $00000005;
xlDiagonalUp = $00000006;
xlEdgeBottom = $00000009;
xlEdgeLeft = $00000007;
xlEdgeRight = $0000000A;
xlEdgeTop = $00000008;}

// Incluindo Formulas (a formula deve ser incluida com seu nome original em
Inglês
// caso contrário podera ocorrer problemas)
Sheet.Cells[i,3] := 'Total R$';
// Na linha abaixo inclui uma soma e converti para Moeda atravez do NUMBERFORMAT
Sheet.Cells[i,4].NumberFormat := 'R$ #.##0,00_);(R$ #.##0,00)';
Sheet.Cells[i,4].formula := '=SUM(D210)';

// Alinhando as Células
Sheet.Range['A1'].VerticalAlignment := 1; // 1=Top - 2=Center - 3=Bottom
Sheet.Range['B1'].VerticalAlignment := 2;
Sheet.Range['C1'].VerticalAlignment := 3;

Sheet.Range['B1'].HorizontalAlignment := 3; // 3=Center - 4=Right

Sheet.Range['C1'].HorizontalAlignment := 3;
Sheet.Range['D1'].HorizontalAlignment := 4;

// Adiciona Grade nas Colunas

Sheet.Range['A1','D11'].Borders.LineStyle := 1;
Sheet.Range['A1','D11'].Borders.Weight := 2;
Sheet.Range['A1','D11'].Borders.ColorIndex := 1;

// Excecuta um Replace na Celula localizada

// Lembre-se que ele alterara todas as celulas localizadas dentro
// do RANGE escolhido, ou seja, se ouverem 10 Colunas com o texto
// desejado este comando alterara as 10
Sheet.Range['A1','Z70'].Replace('Fone Cliente 10','Repassou o Texto');

// Cria Grafico
Sheet.ChartObjects.Add(10,160,450,130); // Coordenadas (Left,Top,Width,Height)
Chart := Sheet.ChartObjects[1]; // Cria o Grafico
Chart.Chart.ChartType := $FFFFEFFA; // Tipo do Grafico (veja tabela abaixo)
Chart.Chart.SeriesCollection.Add(Sheet.Range['D210']);

// Pode-se dar um PrintPreview apenas no Gráfico, use o comando abaixo

//Chart.Chart.PrintPreview;

//--TIPOS DE GRAFICOS
//======================
{xlColumnClustered = $00000033;
xlColumnStacked = $00000034;
xlColumnStacked100 = $00000035;
xl3DColumnClustered = $00000036;
xl3DColumnStacked = $00000037;
xl3DColumnStacked100 = $00000038;
xlBarClustered = $00000039;
xlBarStacked = $0000003A;
xlBarStacked100 = $0000003B;
xl3DBarClustered = $0000003C;
xl3DBarStacked = $0000003D;
xl3DBarStacked100 = $0000003E;
xlLineStacked = $0000003F;
xlLineStacked100 = $00000040;
xlLineMarkers = $00000041;
xlLineMarkersStacked = $00000042;
xlLineMarkersStacked100 = $00000043;
xlPieOfPie = $00000044;
xlPieExploded = $00000045;
xl3DPieExploded = $00000046;
xlBarOfPie = $00000047;
xlXYScatterSmooth = $00000048;
xlXYScatterSmoothNoMarkers = $00000049;
xlXYScatterLines = $0000004A;
xlXYScatterLinesNoMarkers = $0000004B;
xlAreaStacked = $0000004C;
 xlAreaStacked100 = $0000004D;
xl3DAreaStacked = $0000004E;
xl3DAreaStacked100 = $0000004F;
xlDoughnutExploded = $00000050;
xlRadarMarkers = $00000051;
xlRadarFilled = $00000052;
xlSurface = $00000053;
xlSurfaceWireframe = $00000054;
xlSurfaceTopView = $00000055;
xlSurfaceTopViewWireframe = $00000056;
xlBubble = $0000000F;
xlBubble3DEffect = $00000057;
xlStockHLC = $00000058;
xlStockOHLC = $00000059;
xlStockVHLC = $0000005A;
xlStockVOHLC = $0000005B;
xlCylinderColClustered = $0000005C;
xlCylinderColStacked = $0000005D;
xlCylinderColStacked100 = $0000005E;
xlCylinderBarClustered = $0000005F;
xlCylinderBarStacked = $00000060;
xlCylinderBarStacked100 = $00000061;
xlCylinderCol = $00000062;
xlConeColClustered = $00000063;
xlConeColStacked = $00000064;
xlConeColStacked100 = $00000065;
xlConeBarClustered = $00000066;
xlConeBarStacked = $00000067;
xlConeBarStacked100 = $00000068;
xlConeCol = $00000069;
xlPyramidColClustered = $0000006A;
xlPyramidColStacked = $0000006B;
xlPyramidColStacked100 = $0000006C;
xlPyramidBarClustered = $0000006D;
xlPyramidBarStacked = $0000006E;
xlPyramidBarStacked100 = $0000006F;
xlPyramidCol = $00000070;
xl3DColumn = $FFFFEFFC;
xlLine = $00000004;
xl3DLine = $FFFFEFFB;
xl3DPie = $FFFFEFFA;
xlPie = $00000005;
xlXYScatter = $FFFFEFB7;
xl3DArea = $FFFFEFFE;
xlArea = $00000001;
xlDoughnut = $FFFFEFE8;
xlRadar = $FFFFEFC9; }

// O PrintPreview abre a tela de visualização do Excel

// e o PrintOut imprime na impressora padrão do Windows
//Sheet.PrintPreview;
//Sheet.PrintOut;

// o SaveAs permite que vc salve automáticamente o relatório gerado

//Sheet.SaveAs('c:\teste.xls');

__________________________________________________________________________
Recibo de Pagamento: Integrando Delphi com Word

Integrando uma aplicação Delphi com um documento Microsoft Word para realizar a
emissão de recibos de pagamentos:

1º Passo: modelo do recibo no Word

Criar um novo documento no Microsof Word e desenvolver o modelo do recibo de
pagamento acrescentando campos de texto que serão substituídos por valores
definidos na aplicação Delphi. O "Campo de Texto", indicado pela seta azul
na Figura 1, encontra-se na barra de ferramentas formulários disponível na "Guia
Desenvolvedor" na versão 2010 do Microsoft Word. Para mostrar a "Guia
Desenvolvedor" na barra de menu do Word deve-se:
a) No menu Arquivo, clicar em Opções.
b) Na janela "Opções do Word", clicar em Personalizar Faixa de Opções e a
seguir marcar a caixa Desenvolvedor em "Guias Principais".

Dois aspectos importantes devem ser observados na construção do modelo do

recibo no Word:
1) Os campos de texto devem ser identificados na caixa "Indicador" da janela
"Opções de formulário de texto" aberta através de um duplo clique do mouse sobre
o respectivo campo. Na Figura 1 pode-se observar os nomes sugeridos para os
campos de texto, na ordem: Pagador, Extenso, Referente, Valor, Tipo, Local e
Assina. Estes nomes serão usados pelo Delphi para atribuir os valores dos
componentes de entrada da interface da aplicação aos respectivos campos no
documento Word.
2) Concluído o modelo do recibo ele deverá ser salvo na pasta da aplicação com o
nome "RECIBO" do tipo "Modelo do Word" (RECIBO.dot).

Figura 1. Modelo do recido desenvolvido no Word.

2º Passo: desenvolvendo a aplicação Delphi
Criar uma nova aplicação no ambiente de desenvolvimento Delphi 7 através da
opção do menu "File|New|Application..." e implementar o formulário principal como
sugere a Figura 2.

Figura 2. Formulário principal da aplicação.

Relação dos componentes do formulário principal com a ordem sequencial, o nome do

componente, a página da sua localização e as propriedades que devem ser alteradas com os
seus respectivos valores.
1. Label pág. Standard 2. Edit pág. Standard 3. Label pág. Standard
Caption Valor: Name edValor Caption Pagador:
Left 10 Left 10 Left 10
Top 5 Top 19 Top 50
Font negrito, azul
Text apagar
Width 100

4. Edit pág. Standard 5. Label pág. Standard 6. Edit pág. Standard

Name edPagador Caption Referente a: Name edReferente
Left 10 Left 10 Left 10
Top 64 Top 95 Top 109
Text apagar Text apagar
Width 430 Width 430

7. RadioGroup pág. Standard 8. GroupBox pág. Standard 9. Label pág. Standard

Name rgTipo Caption Cheque: Caption Banco:
Caption Pagamento: Left 150 Left 10
Left 10 Top 140 Top 24
Top 140 Height 70
Items Dinheiro Width 288
Cheque
ItemIndex 0
Columns 1
Height 70
Width 125

10. Edit pág. Standard 11. Label pág. Standard 12. Edit pág. Standard
Name edBanco Caption Agência: Name edAgencia
Left 10 Left 105 Left 105
Top 38 Top 24 Top 38
Text apagar Text apagar
Width 75 Width 75

13. Label pág. Standard 14. Edit pág. Standard 15. Label pág. Standard
Caption Conta: Name edConta Caption Local:
Left 200 Left 200 Left 10
Top 24 Top 38 Top 220
Text apagar
Width 75

16. Edit pág. Standard 17. Label pág. Standard 18. Edit pág. Standard
Name edLocal Caption Assina: Name edAssina
Left 10 Left 10 Left 10
Top 234 Top 265 Top 279
Text apagar Text apagar
Width 430 Width 430

19. Button pág. Standard 20. BitBtn pág. Additional

Name Button1 Kind bkClose
Caption &Imprimir Caption &Fechar
Left 125 Left 365
Top 17 Top 17

3º Passo: adicionando a unit "Um" ao projeto

O valor do recibo também será apresentado por extenso no documento. No
artigo Valor Por Extenso: Delphi foi desenvolvida a unit "Um" com a função
"valorPorExtenso" que recebe um valor do tipo real e retorna o extenso deste valor.
Para utilizar a unit citada neste projeto deve-se:
a) Fazer o download
em http://www.pb.utfpr.edu.br/omero/Delphi/Artigos/Um.rar e extrair a unit na
pasta do projeto.
b) Adicionar a unit ao projeto através da opção do menu "Project|Add to project..."

4º Passo: implementação
a) Fazer referência as unit's "ComObj" e "Um" no início da implementation do
formulário da aplicação como mostra a Listagem 1. A unit "ComObj" disponibiliza
a funçãoCreateOleObject utilizada para criar uma instância do aplicativo Microsoft
Word. Já a unit "Um" oferece a função valorPorExtenso para retornar um valor
monetário por extenso.

Listagem 1. Fazendo referência as units "ComObj" e "Um".

1 uses ComObj, Um;

b) No evento "onClick" do botão "Imprimir" o aplicativo Microsoft Word é aberto

com um novo documento, criado a partir do modelo do recibo, e os componentes
de entrada são atribuidos aos respectivos campos de formulário como mostra
a Listagem 2.

Listagem 2. Evento "onClick" do botão "Imprimir".

1 procedure TForm1.Button1Click(Sender: TObject);
var WApp: variant; // variável associada ao aplicativo Microsoft Word
2 WDoc: variant; // variável associada ao documento criado no Word
3 path: string;
4 vlr: real;
5 begin
6 // verifica se o Microsoft Word já está aberto
if (VarIsEmpty(WApp))
7 then WApp := CreateOleObject('Word.Application');
8
9 path := ExtractFilePath(Application.ExeName);
10 // cria um documento no Word a partir do modelo do recibo
11 WDoc := WApp.Documents.Open(path + 'RECIBO.dot');
WApp.Visible := True;
12
13 try
14 vlr := StrToFloat(edValor.Text);
15 // move os componentes de entrada da aplicacao Delphi
16 // para os campos de texto do recibo no Microsoft Word
17 WDoc.FormFields.Item('Valor').Result := Format('%m', [vlr]);
WDoc.FormFields.Item('Pagador').Result := edPagador.Text;
18 WDoc.FormFields.Item('Referente').Result := edReferente.Text;
19 WDoc.FormFields.Item('Extenso').Result := valorPorExtenso(vlr);
20 WDoc.FormFields.Item('Referente').Result := edReferente.Text;
21 WDoc.FormFields.Item('Local').Result := edLocal.Text;
WDoc.FormFields.Item('Assina').Result := edAssina.Text;
22
if (rgTipo.ItemIndex = 0) // pagamento em dinheiro
23 then WDoc.FormFields.Item('Tipo').Result :=
24 'Pagamento em Dinheiro.'
25 else // pagamento com cheque
26 WDoc.FormFields.Item('Tipo').Result :=
'Pagamento efetuado com o Cheque do Banco: ' +
27 edBanco.Text + ', Agência: ' + edAgencia.Text + ', Conta: ' +
28 edConta.Text + '.';
29 except
30 end;
end;
31
32
33
34
35
36
37

Aspectos importantes da codificação apresentada na Listagem 2:

1) A variável "WApp" recebe uma instância do aplicativo Microsoft Word através da
instrução: WApp := CreateOleObject('Word.Application');
2) A variável "WDoc" recebe o documento criado no Word a partir do modelo salvo
na pasta da aplicação através da instrução: WDoc :=
WApp.Documents.Open(path + 'RECIBO.dot');
3) Os valores dos componentes de entrada na interface são atribuídos aos
respectivos campos de texto no documento Word através de instruções, como por
exemplo:
WDoc.FormFields.Item('Valor').Result := Format('%m', [vlr]);
WDoc.FormFields.Item('Pagador').Result := edPagador.Text;
WDoc.FormFields.Item('Extenso').Result := valorPorExtenso(vlr);

Executando a aplicação deve-se informar todos as informações relacionadas ao

recibo: valor (R$), nome do pagador, finalidade do recibo, tipo do pagamento (em
dinheiro ou cheque), local do pagamento e o nome de quem assina, como mostra o
exemplo apresentado naFigura 2.

Figura 2. Ilustrando a execução da aplicação.

Pressionando o botão "Imprimir" os dados de entrada serão atribuídos aos
respectivos campos texto no recibo criado no Word como mostra a Figura 3.

Figura 3. Documento criado no Word com os valores atribuidos pela aplicação Delphi.
Boa noite a todos. Utilizo Delphi 7.

Nao sei se eh bug no componente MEMO ou eu

q nao sei usar direito...
No meu software, eu tenho um componente
MEMO...

Entao, faz de conta q eu tenho um MEMO com 2

linhas

ABCD
12345

//var LINHA1, LINHA2: string;

LINHA1 := Memo.Lines.ValueFromIndex[0];
LINHA2 := Memo.Lines.ValueFromIndex[1];

Entao, a string LINHA1, fica como BCD e o

LINHA2 fica como 2345
O foda eh q eu tenho uma rotina q le centenas
de linhas em 1 memo, entao uso um "repeat"
com um contador pra varrer o memo e
processar os dados, e nisso todas as linhas
perdem o 1º caracter.

Alguem me ajuda??

Editado pela última vez por Marc-br em Seg Mai 12, 2008
2:16 pm, num total de 2 vezes

Voltar ao Topo

Flavio_Ctba Enviada: Seg Mai 12, 2008 10:38

Novato am Assunto:

Registrado: Quinta-Feira, 7 de Fevereiro de 2008

oi Marc-br,
Mensagens: 87
Localização: Curitiba Realmente eu testei o metodo
Memo.Lines.ValueFromIndex[0]; e a
primeira letra da linha é comida.
Não sei se a finalidade deste método é
essa mesmo de pegar as informações da
linha inteira ou é outro...

Mas pra resolver o seu problema voce pode

fazer o seguinte:

ShowMessage(Memo.Lines[0]); //mostra a
linha1 do memo
 ShowMessage(Memo.Lines[1]); //mostra a
linha2 do memo

espero q ajude,

flw

Voltar ao Topo

Marc-br Enviada: Seg Mai 12, 2008 2:10

Aprendiz pm Assunto:

Registrado: Terça-Feira, 3 de Julho de 2007

Do seu jeito funcionou
Mensagens: 117
Localização: Franca-SP deve ser bug da função ValueFromIndex[x]
mesmo, sempre come a 1º letra...

Outro jeito q funcionou é

MEMO1.Lines.Strings[i]
Primeira Dica:

174 - Criar um documento no Word

Uses ComObj

procedure TForm1.Button1Click(Sender: TObject);

var
MSWord: Variant;
begin
MSWord:= CreateOleObject (´Word.Basic´);
MSWord.AppShow;//mostra o word
MSWord.FileNew;//inicia um novo documento
MSWord.insert(´Contrato de Locação´); //Escreve algo
MSWord.insert(#13+´Contrato de Locação´);//Pula uma linha e
escreve
MSWord.FontSize(24);//muda o tamanho da fonte
MSWord.italic;//coloca italico
MSWord.bold;//coloca negrito
MSWord.underline;//sublina
MSWord.insert(13+´Contrato de Locação´);//pula a linha e escreve
novamente
MSWord.FontSize(12);//muda o tamanho da fonte
MSWord.Font(´Arial´);//muda a fonte usada
MSWord.underline(false);//retira o sublinhado
MSWord.italic(false);//retira o italico
MSWord.bold(false);//retira o bold
MSWord.insert(13 +´teste´);
MSWord.insert(#13+9 +´teste´);//nova linha e um TAB
MSWord.insert(13+Table1Razao_Social.Value);//insere algo de uma
tabela
MSWord.LineUp(2, 1); //seleciona uma parte do texto
MSWord.TextToTable(ConvertFrom := 2, NumColumns := 1);//
monta uma tabela com o texto selecionado
MSWord.FileSaveAs(´c:\temp\test.txt´, 3); //Salva o arquivo
end;

Obs feita pelo Ruberval

MSWord.JustifyPara; // alinhamento justificado

MSWord.RightPara; // alinhamento a direita
MSWord.LeftPara; // alinhamento a esquerda
MSWord.InsertPageBreak; // quebrar página

Segunda Dica
421 - Gerar uma tabela no Word através do Delphi
Inclua na seção uses: ComObj

{ - Coloque um botão no Form;

- Altere o evento OnClick do botão conforme abaixo: }

procedure TForm1.Button1Click(Sender: TObject);

var
Word: Variant;
begin
{ Abre o Word }
Word := CreateOleObject(´Word.Application´);
try
{ Novo documento }
Word.Documents.Add;
try
{ Adiciona tabela de 2 linhas e 3 colunas }
Word.ActiveDocument.Tables.Add(
Range := Word.Selection.Range,
NumRows := 2,
NumColumns := 3);
{ Escreve na primeira célula }
Word.Selection.TypeText(Text := ´Linha 1, Coluna 1´);
{ Próxima célula }
Word.Selection.MoveRight(12);
{ Escreve }
Word.Selection.TypeText(Text := ´Linha 1, Coluna 2´);
Word.Selection.MoveRight(12);
Word.Selection.TypeText(Text := ´Linha 1, Coluna 3´);
Word.Selection.MoveRight(12);
Word.Selection.TypeText(Text := ´Linha 2, Coluna 1´);
Word.Selection.MoveRight(12);
Word.Selection.TypeText(Text := ´Linha 2, Coluna 2´);
Word.Selection.MoveRight(12);
Word.Selection.TypeText(Text := ´Linha 2, Coluna 3´);
{ Auto-Formata }
Word.Selection.Tables.Item(1).Select; { Seleciona a 1º tabela }
Word.Selection.Cells.AutoFit; { auto-formata }
{ Imprime 1 cópia }
Word.ActiveDocument.PrintOut(Copies := 1);
ShowMessage(´Aguarde o término da impressão...´);
{ Para salvar... }
Word.ActiveDocument.SaveAs(FileName := ´c:\Tabela.doc´);
finally
{ Fecha documento }
Word.ActiveDocument.Close(SaveChanges := 0);
end;
finally
{ Fecha o Word }
Word.Quit;
end;
end;
Observações
Foram usados neste exemplo o Delphi4 e MS-Word97.