Office Automation/fr: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		(Windows only)
2	2
3	3		La possibilité d'interagir avec les programmes office et générer des feuilles de calcul, des documents texte et des présentations depuis le code peut être de grande valeur au bureau, et permet de gagner beaucoup de temps pour ceux qui peuvent le faire.
4	4
5	5		Un exemple est la création d'applications qui peuvent lire et écrire des fichiers dans un format arbitraire et générer un fichier Excel, une tâche qu'il est bien plus efficace de faire par code que manuellement.
6	6
7	7		## Utilisation de OpenOffice UNO Bridge
8	8
9	9		OpenOffice a des bindings de langage pour C++, Java, JavaScript et Python. Sur Windows, OpenOffice peut aussi être manipulé en Pascal via COM Automation (voir ci-dessous), mais il n'y a actuellement aucune façon simple d'utiliser OpenOffice UNO (Universal Network Objects) depuis Pascal sur OS X et Linux. Si vous êtes interessé par le développement d'un "bridge" OO pour Pascal, veuillez vous référer au liens suivants pour plus d'information (attention: ces liens sont relativement techniques à la mode de Sun):
10	10
11	11		[api.openoffice.org](http://api.openoffice.org/)
12	12
13	13		[About Bridges](http://wiki.services.openoffice.org/wiki/Uno/Article/About_Bridges)
14	14
15	15		Voir aussi le sujet ci-dessous à propos de Python.
16	16
17	17		## Utilisation de COM Automation pour interagir avec OpenOffice et Microsoft Office
18	18
19	19		Automation est uniquement valable sous Windows donc les deux exemples suivants ne fonctionneront pas sous OS X ou Linux. Pour ces plateformes, veuillez vous référer à [Making do without Windows COM Automation](http://wiki.lazarus.freepascal.org/Multiplatform_Programming_Guide#Making_do_without_Windows_COM_Automation). Si vous avez seulement besoin de créer et/ou visualiser un document de traitement de text depuis votre programme, veuillez jeter un oeil à [XDev Toolkit](http://web.fastermac.net/~MacPgmr/XDev/XDevStatus.html#RTF).
20	20
21	21		### OpenOffice sur Windows
22	22
23	23		Voici un exemple simple sur comment ouvrir un document avec votre programme en utilisant le serveur Automation d'OpenOffice. Notez que ça ne marche que sur Windows.
24	24
25	25		``` pascal
26	26		program TestOO;
27	27
28	28		{$IFDEF FPC}
29	29		{$MODE Delphi}
30	30		{$ELSE}
31	31		{$APPTYPE CONSOLE}
32	32		{$ENDIF}
33	33
34	34		uses
35	35		SysUtils, Variants, ComObj;
36	36
37	37		const
38	38		ServerName = 'com.sun.star.ServiceManager';
39	39		var
40	40		Server : Variant;
41	41		Desktop : Variant;
42	42		LoadParams : Variant;
43	43		Document : Variant;
44	44		TextCursor : Variant;
45	45		begin
46	46		if Assigned(InitProc) then
47	47		TProcedure(InitProc);
48	48
49	49		try
50	50		Server := CreateOleObject(ServerName);
51	51		except
52	52		WriteLn('Unable to start OO.');
53	53		Exit;
54	54		end;
55	55
56	56		Desktop := Server.CreateInstance('com.sun.star.frame.Desktop');
57	57
58	58		LoadParams := VarArrayCreate([0, -1], varVariant);
59	59
60	60		{Crée un nouveeau document}
61	61		Document := Desktop.LoadComponentFromURL('private:factory/swriter', '_blank', 0, LoadParams);
62	62
63	63		{ou ouvrir un existant} // vous devez utiliser des / et non des \ ! dans le chemin d'accès
64	64		//Document := Desktop.LoadComponentFromURL('file:///C:/my/path/mydoc.doc', '_blank', 0, LoadParams);
65	65
66	66		TextCursor := Document.Text.CreateTextCursor;
67	67
68	68		{Insère un nouveau document} //Remplacer avc vos valeur de nom de fichier
69	69		TextCursor.InsertDocumentFromURL('file:///C:/my/path/mydoc.doc',
70	70		LoadParams);
71	71		end.
72	72		```
73	73
74	74		### Office sur Windows
75	75
76	76		Voici un exemple simple de comment ouvrir un document avec votre programme en utilisant le serveur d'automation de Word. Notez que ce serveur ne fonctionne que sous Windows. Ceci marchera avec Delphi et FPC.
77	77
78	78		``` pascal
79	79		program TestMsOffice;
80	80
81	81		{$IFDEF FPC}
82	82		{$MODE Delphi}
83	83		{$ELSE}
84	84		{$APPTYPE CONSOLE}
85	85		{$ENDIF}
86	86
87	87		uses
88	88		SysUtils, Variants, ComObj;
89	89
90	90		const
91	91		ServerName = 'Word.Application';
92	92		var
93	93		Server : Variant;
94	94		w:widestring;
95	95		begin
96	96		if Assigned(InitProc) then
97	97		TProcedure(InitProc);
98	98
99	99		try
100	100		Server := CreateOleObject(ServerName);
101	101		except
102	102		WriteLn('Unable to start Word.');
103	103		Exit;
104	104		end;
105	105
106	106		{ouvre un document existant} //Substituez votre votre chemin et nom de fichier
107	107		w:= UTF8Decode('c:\my\path\mydoc.doc');
108	108		Server.Documents.Open(w); //OLE utilises BSTR (http://msdn.microsoft.com/en-us/library/windows/desktop/ms221069(v=vs.85).aspx). Seule la widestring est compatible avec BSTR dans FPC, donc la conversion est nécessaire pour les caractères non latins.
109	109		Server.Visible := True; {Make Word visible}
110	110
111	111		end.
112	112		```
113	113
114	114		Voici un échantillon de code de comment travailler dans un document Word ouvert, en utilisant le serveur d'automation de Word.
115	115
116	116		``` pascal
117	117		var
118	118		Server: Variant;
119	119		begin
120	120		try
121	121		Server := GetActiveOleObject('Word.Application');
122	122		except
123	123		try
124	124		ShowMessage('Word pas encore ouvert, crée un objet');
125	125		// Si aucune instance de Word ne tourne, essayer de créer un nouvel objet Word
126	126		Server := CreateOleObject('Word.Application');
127	127		except
128	128		ShowMessage('Ne peut pas lancer Word/Word pas installé ?');
129	129		Exit;
130	130		end;
131	131		end;
132	132		end;
133	133		```
134	134
135	135		Limitations: Parce que End est un mot réservé de FPC, il doit être utiliser comme un paramètre après le signe &.
136	136
137	137		``` pascal
138	138		Server.ActiveDocument.Application.Selection.start := Server.ActiveDocument.Application.Selection.&end+1;
139	139		```
140	140
141	141		De nombreux exemples pour Excel sont disponibles dans la [[ExcelAutomation/de\|page Wiki allemande]].
142	142
143	143		## Tenter d'utiliser Python pour piloter OpenOffice
144	144
145	145		Parce qu'OpenOffice inclut le support pour Python, il semble possible d'exécuter des scripts Python depuis Pascal pour piloter OO, au lieu des actuelles liaisons(bindings) Pascal. Voici les étapes pour une possible approcjhe pour faire cela:
146	146
147	147		1. Tester UNO via une macro Python exécutée dans OO
148	148		2. Tester UNO via un script Python autonome
149	149		3. Support de l'exécution de scripts Python dans Pascal
150	150		4. Tester UNO via un script Python exécuté dans Pascal.
151	151		5. Une classe Pascal qui enveloppe Python UNO
152	152
153	153		Note: Les scripts suivant ont été testés avec OpenOffice 2.3.1 sur Windows XP et NeoOffice 2.2.5 Patch 6 sur Mac OS X 10.4.11 (PowerPC).
154	154
155	155		#### Etape 1. Tester UNO via une macro Python exécutée dans OO
156	156
157	157		OO a des outils pour créer des macro JavaScript, mais pas des macros en Python, donc utilisez un éditeur pour enregistrerle script suivant dans 'test_macro.py' et placez-le dans le dossier des macros utilisateur. Sur Windows, Ce dossier est:
158	158
159	159		C:\Document and Setting\<username>\Application Data\OpenOffice.org2\user\Scripts\python\Library1
160	160
161	161		Sur Mac OS X, ce dossier est:
162	162
163	163		~/Library/Preferences/NeoOffice-2.2/user/Scripts/python/Library1
164	164
165	165		Sur ces deux plates-formes, vous devrez créer le dossier python/Library1.
166	166
167	167		Voici le code pour test_macro.py, adapté de l'exemepl OO en Pascal du dessus:
168	168
169	169		``` python
170	170		# Macro Python qui teste UNO en créant un nouveau document et y insère du texte
171	171
172	172		import uno
173	173
174	174		def TestNewDoc():
175	175		ctx = uno.getComponentContext()
176	176		smgr = ctx.ServiceManager
177	177		desktop = smgr.createInstance('com.sun.star.frame.Desktop')
178	178		doc = desktop.loadComponentFromURL('private:factory/swriter', '_blank', 0, ())
179	179		textCursor = doc.Text.createTextCursor()
180	180		doc.Text.insertString(textCursor, 'Salut Monde', 0)
181	181		```
182	182
183	183		Dans OO, choisissez Tools \\| Macros \\| Organize Macros \\| Python et exécuter la macro pour être sûr que ça marche
184	184
185	185		#### Etape 2. Tester UNO via un script Python autonome
186	186
187	187		Voici le même code que dans le script autonome:
188	188
189	189		``` python
190	190		# Macro Python qui teste UNO en créant un nouveau document et y insère du texte
191	191
192	192		import sys
193	193
194	194		if sys.platform == 'darwin':
195	195		sys.path.append('/Applications/NeoOffice.app/Contents/MacOS')
196	196
197	197		import officehelper
198	198
199	199		ctx = officehelper.bootstrap()
200	200		smgr = ctx.ServiceManager
201	201		desktop = smgr.createInstance('com.sun.star.frame.Desktop')
202	202		doc = desktop.loadComponentFromURL('private:factory/swriter', '_blank', 0, ())
203	203		textCursor = doc.Text.createTextCursor()
204	204		doc.Text.insertString(textCursor, 'Hello World', 0)
205	205		```
206	206
207	207		Sauvez cela dans le fichier test.py et exécutez-le sur Windows depuis la ligne de commande. note: Sur Windows et Linux, utiliser la version de Python incluse dans OO ; sur Mac OS X, utilisez le Python 2.3 du système.
208	208
209	209		"\program files\openoffice.org 2.3\program\python" test.py
210	210
211	211		Sur Mac OS X, exécutez le script comme ça depuis la fenêtre Terminal:
212	212
213	213		``` bash
214	214		#!/bin/sh
215	215		export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH":/Applications/NeoOffice.app/Contents/MacOS"
216	216		python2.3 test.py
217	217		```
218	218
219	219		Malheureusement, ce script ne fonctionne pas non plus sur Windows ou Mac OS X (NDT: c''est ballot). Sur Windows, il affiche un dialogue d'erreur sans texte (!) et sort un message d'erreur vers la console qui dit "Cannot connect to soffice server". Sur Mac OS X, il démarre NeoOffice et crée le nouveau document, puis NeoOffice s'arrêt brutalement.
220	220
221	221		#### UNO Python A-faire
222	222
223	223		D'évidentes investigations supplémentaires sont nécessaires avant de pouvoir réaliser l'étape 3. Vous êtes le bienvenu pour travailler là-dessus. Voici deux choses à essayer:
224	224
225	225		- Tester sur Linux
226	226		- Tester sur des versions plus récentes d'OpenOffice
227	227
228	228		- Jan. 5, 2009: Résultats des tests d'OpenOffice 3 sur Windows:
229	229		- OO 3.0.0 Le support pour les utilisateurs de macro Python est rompu (Etape 1); corrigé avec OO 3.0.1 RC1.
230	230		- Etape 2 n'affiche plus le message vide de la boîte de dialogue et le message d'exception vers la console est différent, mais ne démarre toujours pas OO.
231	231		- Notez que les chemins vers les différentes parties de OO et des macros utilisateur ont changé avec OO 3.
232	232
233	233		------------------------------------------------------------------------
234	234
235	235		## En utilisant l'unité fpXMLXSDExport
236	236
237	237		FPC 2.6 et plus récent contient l'unité fpXMLXSDExport, partie des composant d'export de la FCL-DB. Avec cela, vous pouvez exporter des datasets vers divers formats XML, y compris un format compatible avec Microsoft Access et un format compatible avec Microsoft Excel.
238	238
239	239		Le format Access peut sortir du XML avec ou sans définition de donnée/table XSD incorporée. Observez que l'exportation de donnée de type binaire/blob nécessite une action supplémentaire à la fin de l'import Access car Access ne prend pas en charge les véritables champs binaires appropriés, seuls les champs OLE.
240	240
241	241		Dans le format Excel, les champs texte multi-ligne ne sont pas pris en charge actuellement: les fins de lignes sont supprimées pendant l'export.
242	242
243	243		Lazarus fournit un composant visuel pour cela: après l'installation du paquet lazdbexport, vous verrez le composant TXMLXSDExporter sur l'onglet Data Export.
244	244
245	245		Voir [[fpXMLXSDExport]] pour les détails.
246	246
247	247		## En utilisant la bibliothèque Spreadsheet de Free Pascal
248	248
249	249		Une autre façon d'automatiser les tâches répétitives est d'utiliser la bibliothèque [[FPSpreadsheet]]. Elle peut lire ou écrire des classeurs dans plusieurs formats et ne nécessite l'installation d'aucune application externe sur la machine.
250	250
251	251		Les avantages sont que FPSpreadsheet est à 100% du code [[Object Pascal\|Pascal Objet]] et qu'elle ne nécessite aucune bibliothèque ou programme.
252	252
253	253		## En écrivant un fichier Excel en utilisant ADO
254	254
255	255		Ecrire à l'auteur de la page anglaise.
256	256
257	257		## En écrivant/lisant un fichier Excel en utilisant OLE
258	258
259	259		Cette méthode nécessite qu'Excel soit installé sur la machine de l'utilisateur car elle utilise OLE pour y accéder.
260	260
261	261		*Garder à l'esprit que cette méthode démarre Excel en tâche de fond, lequel ouvre le fichier et travaille dessus comme un utilisateur véritable.*
262	262
263	263		- Créez un nouvelle fiche avec un TButton, un TStringGrid et un TEdit.
264	264		- Créez un nouveau fichier Excel et remplissez quelques cellules.
265	265
266		-	~~<figure>~~
267		-	~~<img src="excel123.png" title="excel123.png" />~~
268		-	~~<figcaption>excel123.png</figcaption>~~
269		-	~~</figure>~~
	266	+	![](/wiki-images/7/74/Excel123.png)
270	267
271	268		Exemple - Ouvrir/lire le fichier Excel:
272	269
273	270		``` pascal
274	271		uses ..... comobj;
275	272
276	273		procedure TForm1.Button1Click(Sender: TObject);
277	274
278	275		Var XLApp: OLEVariant;
279	276		x,y: byte;
280	277		path: variant;
281	278
282	279		begin
283	280		XLApp := CreateOleObject('Excel.Application'); // nécessite comobj dans uses
284	281		try
285	282		XLApp.Visible := False; // Cache Excel
286	283		XLApp.DisplayAlerts := False;
287	284		path := edit1.Text;
288	285		XLApp.Workbooks.Open(Path); // Ouvre le classeur
289	286		for x := 1 to 4 do
290	287		begin
291	288		for y := 1 to 6 do
292	289		begin
293	290		SG.Cells[x,y] := XLApp.Cells[y,x].Value; // Remplit le TStringGrid avec les valeurs
294	291		end;
295	292		end;
296	293		finally
297	294		XLApp.Quit;
298	295		XLAPP := Unassigned;
299	296		end;
300	297		```
301	298
302	299		Si vous voulez faire des modifications et que vous voulez les reporter dans Excel, vous pouvez utiliser:
303	300
304	301		``` pascal
305	302		XLApp.Cells[x,y].Value := SG.Cells[y,x];
306	303		```
307	304
308	305		Si vous voulez enregistrer:
309	306
310	307		``` pascal
311	308		XLApp.ActiveWorkBook.Save;
312	309		```
313	310
314	311		## En lisant/écrivant un fichier Excel en utilisant l'interface de composant SpreadSheet
315	312
316	313		Le composant fournit une bibliothèque d'interface, faisant abstraction des interfaces Excel COM et Calc Open Office UNO. Le composant est disponible là: <http://www.tcoq.org/composants>
317	314
318	315		Puisque l'Automation n'est pas encore disponible, mais que COM l'est, le composant d'interface fournit un ensemble de classes Lazarus encapsulant les appels à l'interface COM d'Excel (au dessous de l'Automation). Il
319	316
320	317		Since Automation is not yet available, but COM is available, the Excel interface component provides a set of Lazarus classes encapsulating calls to the Excel COM interface (the one below the Automation). Il masque la plupart des corvées du code de bas-niveau.
321	318
322	319		Soyez prudent, c'est un travail en cours. Vous l'utilisez à vos propres risques.
323	320
324	321		Fonctionnalité:
325	322
326	323		- création et chargement de classeurs Excel,
327	324		- enregistrement de classeurs,
328	325		- création et accès aux feuilles de calcul,
329	326		- obtention et modification des valeurs (et formules) dans les cellules,
330	327		- obtention et modification de la couleur des cellules,
331	328		- obtention et modification de la hauteur des lignes et de la largeur des colonnes,
332	329		- création de commentaires,
333	330		- création de formes ,
334	331		- création de graphes.
335	332
336	333		D'abord les Inits.
337	334
338	335		``` pascal
339	336		IMPLEMENTATION
340	337		USES
341	338		ExcelUtilities,
342	339		SpreadSheetInterfaces ;
343	340
344	341		VAR
345	342		aCell : IRange ;
346	343		aValue : OleVariant ; // Pas sûr de cela, mais ça marche. ie( Edit.Text := STRING(aValue); )
347	344		ExcelApp : TExcelApplication ;
348	345		ExcelWbs : IWorkBooks ;
349	346
350	347		ExcelBook : IWorkBook ;
351	348		ExcelSheet : ISheet ;
352	349		ExcelSheets : ISheets ;
353	350		```
354	351
355	352		Obtenir une feuille de calcul est simple:
356	353
357	354		``` pascal
358	355		// Initialisation le classeur Excel:
359	356		ExcelApp := TExcelApplication.Create(nil) ;
360	357		ExcelApp.Active := True ;
361	358		ExcelApp.Visible := True ;
362	359
363	360		ExcelWbs := ExcelApp.WorkBooks ;
364	361		ExcelBook := ExcelWbs.Add ;
365	362		ExcelSheets := ExcelBook.Sheets ;
366	363		ExcelSheet := ExcelSheets.Sheet(1) ;
367	364		```
368	365
369	366		S'amuser avec les cellules est aussi simple:
370	367
371	368		``` pascal
372	369		// Ajout d'une valeur
373	370		aCell := ExcelSheet.Cells(1, 1) ;
374	371		aCell.Value := 10;
375	372
376	373		// Ajout d'une formule
377	374		aCell := ExcelSheet.Cells(2,1) ;
378	375		aCell.Formula := '=A1+10' ;
379	376
380	377		// Obtenir la valeur calculée dans Excel
381	378		aValue := aCell.Value ;
382	379		```
383	380
384	381		Le cas de test fourni a de nombreux autres exemples.
385	382
386	383		## Copier du HTML dans le prese-papier
387	384
388	385		Vous pouvez copier du HTML dans le presse-papier lequel est compris par de nombreuses applications. De cette façon, vous pouvez copier du texte formaté. Pour les applications qui ne peuvent comprendre que du texte pur, vous pouvez copier du texte pur aussi.
389	386
390	387		Les applications Microsoft Office nécessite que le HTML passé par le presse-papier soit d'un format plus complexe que celui décrit ici.
391	388
392	389		[[Clipboard\|Voir ici un exemple qui marche avec Microsoft Office.]]
393	390
394	391		``` pascal
395	392		uses
396	393		ClipBrd;
397	394		...
398	395		// enregistrer le type mime type pour text/html. Vous pouvez faire cela une fois pour toutes au démarrage du programme:
399	396		ClipbrdFmtHTML:=RegisterClipboardFormat('text/html');
400	397		...
401	398		// Nettoyer les formats précédents du presse-papier avant de commencer
402	399		Clipboard.Clear;
403	400
404	401		// Déposer le texte et le HTML dans le presse-papier. Les autres applications choisiront le meilleur format automatiquement.
405	402		ThePlainUTF8Text:='Simple text';
406	403		Clipboard.AsText:=ThePlainUTF8Text;
407	404
408	405		AsHTML:='<b>Formatted</b> text'; // texte avec formatage
409	406		Clipboard.AddFormat(ClipbrdFmtHTML,AsHTML[1],length(AsHTML));
410	407		```
411	408
412	409		## Voir aussi
413	410
414	411		- [[Clipboard]]
415	412
416	413		## Liens externes
417	414
418	415		- [Excel file format](http://sc.openoffice.org/excelfileformat.pdf) - Description dans le site Web OpenOffice
419	416
420	417		---
421	418		From the Free Pascal wiki, page "Office Automation/fr", as it stood on 2020-02-21 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history