fpvectorial - Text Document Support: what changed

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

Old	New		Line
1	1		# fpvectorial - Text Document Support
2	2
3	3		## About
4	4
5	5		The [[fpvectorial]] library can be used to create formatted text files in a variety of file formats. Current file support includes Open Document XML (odt) and Open Office XML (docx). The files can be opened in a variety of products including Microsoft Office, OpenOffice and LibreOffice.
6	6
7	7		As the name suggests, the FPVectorial library was originally created solely as a vector based image library. Support for creating documents was added to FPVectorial as the existing architecture already had the concept of a Document containing Pages, and it's architecture was easily extendable. Document support was added beside the existing image handling classes. Vector based images are differentiated from office documents by the type of page added to TvVectorialDocument.\
8	8
9	9		At this time, two different pages can be added to TvVectorialDocument:
10	10
11	11		- TvTextPageSequence: This is used by all Office Document writers.
12	12		- TvVectorialPage: This is used for Vector Image writers, and is currently ignored by the office document writers.
13	13
14	14		Currently there are two Office Document writers.
15	15
16	16		- TODTVectorialWriter.pas: for producing .odt files suitable for opening in OpenOffice and LibreOffice
17	17		- TDOCXVectorialWriter: for opening files in Microsoft Office 2007 onwards.
18	18
19	19		Instead of focusing on the requirements of each individual file format, Office Document support inside FPVectorial was added by creating and implementing a Document Class Hierarchy. It is then up to each individual reader and writer to interpret this class hierarchy.\
20	20
21	21		Alternative Library - fpOdf\
22	22		If you want to produce an ODT file by concentrating on the File Format, then the fpOdf library implemented by dgaspary and made available on the forums is recommended. This allows fine control when creating an ODT file, including many options not provided by FPVectorial - Document Support. A deeper understanding of the file format specification is required when using fpOdf; this complexity is hidden when using FPVectorial.\
23	23		Forum Link: [Topic: fpOdf - Creating and modifying OpenDocument ODF files with freepascal](http://forum.lazarus.freepascal.org/index.php/topic,21868.msg128463.html#msg128463)\
24	24
25	25		### License
26	26
27	27		[Modified](http://svn.freepascal.org/svn/lazarus/trunk/COPYING.modifiedLGPL.txt) [LGPL](http://svn.freepascal.org/svn/lazarus/trunk/COPYING.LGPL.txt) (same as FPC RTL and Lazarus LCL).\
28	28
29	29		## Download
30	30
31	31		fpvectorial comes in the Lazarus SVN, in the directory components/fpvectorial:
32	32
33		-	~~`svn co `[`http://svn.freepascal.org/svn/lazarus/trunk/components/fpvectorial`](http://svn.freepascal.org/svn/lazarus/trunk/components/fpvectorial)` fpvectorial`~~
	33	+	```text
	34	+	svn co http://svn.freepascal.org/svn/lazarus/trunk/components/fpvectorial fpvectorial
	35	+	```
34	36
35	37		See also [[fpvectorial]]\
36	38
37	39		## Hello World Example
38	40
39	41		The following code will produce a "Hello World" document. As no styles are defined, it is entirely up to the program used to open the resulting files (Microsoft Word, LibreOffice Write etc) to determine font and font size...
40	42
41	43		``` pascal
42	44		Program HelloWorld;
43	45
44	46		{$mode objfpc}{$H+}
45	47
46	48		Uses
47	49		fpvectorialpkg, fpvectorial;
48	50
49	51		Var
50	52		Document: TvVectorialDocument;
51	53		Page: TvTextPageSequence;
52	54		Paragraph: TvParagraph;
53	55
54	56		Begin
55	57		Document := TvVectorialDocument.Create;
56	58		Try
57	59		Page := Document.AddTextPageSequence;
58	60		Paragraph := Page.AddParagraph;
59	61		Paragraph.AddText('Hello World!');
60	62
61	63		Document.WriteToFile('Hello_World.docx', vfDOCX);
62	64		Document.WriteToFile('Hello_World.odt', vfODT);
63	65		Finally
64	66		Document.Free;
65	67		End;
66	68		End.
67	69		```
68	70
69	71		== Basic Concepts ==
70	72
71	73		### General
72	74
73	75		- A single FPVectorial Document (TvVectorialDocument) consists of a series of Page Sequences.
74	76		- Each Page Sequence can have it's own Header and Footer, and it's own Page Setup (size, orientation)
75	77		- Text, Tables, Images are added to the Page Sequence. In this way the document is built up.
76	78		- FPVectorial has no concept of how many pages are in a document, only the number of Page Sequences. A large multipage document may only have a single Page Sequence.
77	79		- A single Page Sequence can have multiple Paragraphs added.
78	80		- Headers and Footers are built up in an identical manner to a Page Sequence.
79	81		- TvVectorialDocument is responsible for freeing any entity added using the .AddXXX calls.
80	82
81	83		### Formatted Text
82	84
83	85		- Text is added inside Paragraphs (TvParagraph).
84	86		- Paragraphs consist of multiple text runs or document fields. A single Paragraph can have a single Paragraph Style. Each text run can have an optional Text Style applied (allowing, for instance, the bolding of individual words in a paragraph).
85	87		- All Paragraph and Text Styles must be defined before being used.
86	88		- FP Vectorial supports style inheritance.
87	89		- Microsoft Office, OpenOffice and LibreOffice allow only partial styles to be defined, though each office implements its own different set of defaults for any missing properties. If it is critical that the document look identical in each of the Office Suites, then the Styles should be fully defined.
88	90		- A default set of Styles can be added to the FP Vectorial Document by calling AddStandardTextDocumentStyles.
89	91		- Headings are Paragraph Styles, with additional properties covering Heading Level and numbering
90	92
91	93		### Document Fields
92	94
93	95		- Document Fields are added as TvField to Paragraphs via .AddField(AKind : TvFieldKind) : TvField
94	96		- Currently 5 simple fields are supported: vfkNumPages, vfkPage, vfkAuthor, vfkDateCreated, vfkDate
95	97		- fpvectorial holds no concept of current page or page count (only Page Sequences, which are separated by Section Breaks). Best guess values will therefore be added to the document during creation. The values can be updated in Microsoft Word by Selecting All, then pressing F9 (update fields). LibreWriter appears to automatically update the fields to correct values when opening the document.
96	98		- Numeric Fields can be formatted via TvField.NumberFormat as Decimal, lowercase/uppercase Roman or lowercase/uppercase Alphabetic
97	99		- Date Fields can be formatted cia TvField.DataFormat. Default value is 'd/MM/yyyy h:mm am/pm'
98	100
99	101		### Tables
100	102
101	103		- Tables are centered around TvTable
102	104		- A TvTable consists of a collection of rows.
103	105		- Table rows consist of a collection of cells.
104	106		- Tables can add optional column information. This must be provided if merged cells are being used.
105	107		- Any Table Cell can support any document object, including multiple paragraphs, images and even nested Tables.
106	108
107	109		### Lists
108	110
109	111		- Lists are centered around TvList.
110	112		- Each TvList can either have a TvParagraph added, or a child TvList (which is how we get deeper levels).
111	113		- Each TvList has both a TvStyle (which determines the default TvParagraph text appearance) and a TvListStyle (which determines the list behaviour).
112	114		- Each TvListStyle holds a list of TvListLevelStyle.
113	115		- Each TvListLevelStyle defines how each different level of the list behaves.
114	116		- Each List can be bulleted, or numbered.
115	117		- Supported numbering: Decimal, lowercase Roman, uppercase Roman, lowercase Alphabet, uppercase Alphabet.
116	118		- When dealing with numbered lists: Lists can be prefixed with single identifier (ie 1.) or numeric identifiers for all levels to date (ie 1.1.1.1.). This is handled through a boolean TvListLevelStyle.DisplayLevels.
117	119		- Two list styles are predefined in AddStandardFormats. StyleBulletList and StyleNumberList. Interestingly, the design for both docx and odt file formats (and consequently for fpvectorial) allow for a mixing of different list definitions within a list. So you can create a list that uses a mixture of the predefined StyleBulletList and StyleNumberList.
118	120
119	121		## Roadmap
120	122
121	123		\| Functionality \| OpenDocument (ODT) \| Office Open XML (DOCX) \|
122	124		\|----\|----\|----\|
123	125		\| File Version \| ODT 1.2 with extensions \| ECMA-376 1st Edition (2006) \|
124	126		\| Supported Style Types \| Paragraph and Text-Span \| Paragraph and Text \|
125	127		\| Table Support \| Yes \| Yes \|
126	128		\| List Support \| Yes \| Yes \|
127	129		\| Multiple Headers/Footers \| Not yet \| Yes \|
128	130		\| Tables in Header/Footer \| Not yet \| Not tested \|
129	131		\| Image Support \| Not yet \| Not yet \|
130	132		\| Images in Header/Footer \| Not yet \| Not yet \|
131	133		\| FPVectorial Image Support \| Not yet \| Not yet \|
132	134		\| Tab Stops \| Not yet \| Not yet \|
133	135		\| Document Fields \| Yes \| Yes \|
134	136		\| Meta Data \| Partially Implemented \| Not yet \|
135	137		\| Table of contents \| Not planned \| Not planned \|
136	138		\| Footnotes \| Not planned \| Not planned \|
137	139		\| Review/Revision \| Not planned \| Not planned \|
138	140		\| Bookmarks / Hyperlinks \| Not planned \| Not planned \|
139	141		\| Comments \| Not planned \| Not planned \|
140	142		\| Formulas \| Not planned \| Not planned \|
141	143
142	144		## Code Examples
143	145
144	146		### Styles
145	147
146	148		This example uses both the default styles that can be added to TvVectorialDocument via AddStandardTextDocumentStyles, and a Text-Span style added specifically to TvVectorialDocument. Text-Span styles should not be applied to Paragraphs, only to individual Text Spans within a Paragraph.
147	149
148	150		``` pascal
149	151		Uses
150	152		fpvectorialpkg, fpvectorial;
151	153
152	154		Var
153	155		Document: TvVectorialDocument;
154	156		Page: TvTextPageSequence;
155	157		Paragraph: TvParagraph;
156	158		BoldTextStyle: TvStyle;
157	159
158	160		Begin
159	161		Document := TvVectorialDocument.Create;
160	162		Try
161	163		// Adds the defaut Paragraph Styles
162	164		// StyleTextBody, StyleHeading1,
163	165		// StyleHeading2 & StyleHeading3
164	166		Document.AddStandardTextDocumentStyles(vfUnknown);
165	167
166	168		// Add our own Style
167	169		BoldTextStyle := Document.AddStyle();
168	170
169	171		BoldTextStyle.Kind := vskTextSpan;
170	172		BoldTextStyle.Name := 'Bold';
171	173		BoldTextStyle.Font.Bold := True;
172	174		BoldTextStyle.SetElements := BoldTextStyle.SetElements + [spbfFontBold];
173	175
174	176		// Create the Document
175	177		Page := Document.AddTextPageSequence;
176	178		Paragraph := Page.AddParagraph;
177	179		Paragraph.Style := Document.StyleTextBody;
178	180
179	181		// Add Hello World as two text spans within the same paragraph,
180	182		// and make 'World' bold
181	183		Paragraph.AddText('Hello ');
182	184		Paragraph.AddText('World!').Style := BoldTextStyle;
183	185
184	186		Document.WriteToFile('Hello_World.docx', vfDOCX);
185	187		Document.WriteToFile('Hello_World.odt', vfODT);
186	188		Finally
187	189		Document.Free;
188	190		End;
189	191		End.
190	192		```
191	193
192	194		![](/wiki-images/4/45/FPVectorial_-_Document_Support_-_Hello_World.png)
193	195
194	196		### Simple Table
195	197
196	198		This example adds a 5 column table to the Document. The first two rows are designated as Header Rows (rows which repeat at the top of each page). These header rows then have a grey background shading applied, and the text is bolded.
197	199
198	200		The very first row contains examples of merging cells. Only 3 cells are added, with the last two cells spanning two columns each (set via .SpannedCols).
199	201
200	202		``` pascal
201	203		program SimpleTable;
202	204
203	205		{$mode objfpc}{$H+}
204	206
205	207		uses
206	208		fpvectorialpkg,
207	209		fpvectorial,
208	210		fpvutils, // For RGBToFPColor()
209	211		SysUtils;
210	212
211	213		var
212	214		Document: TvVectorialDocument;
213	215		Page: TvTextPageSequence;
214	216		Paragraph: TvParagraph;
215	217		BoldTextStyle: TvStyle;
216	218		CenterStyle: TvStyle;
217	219		Table: TvTable;
218	220		Row: TvTableRow;
219	221		Cell: TvTableCell;
220	222		iRow: Integer;
221	223		iCol: Integer;
222	224
223	225		const
224	226		// Most dimensions in FPVectorial are in mm. If you want to specify
225	227		// anything in other units, be ready to do the conversion...
226	228		ONE_POINT_IN_MM = 0.35278;
227	229
228	230		begin
229	231		Document := TvVectorialDocument.Create;
230	232		try
231	233		// Adds the defaut Paragraph Styles
232	234		// StyleTextBody, StyleHeading1,
233	235		// StyleHeading2 & StyleHeading3
234	236		Document.AddStandardTextDocumentStyles(vfUnknown);
235	237
236	238		// Add our own Style for bolded text elements
237	239		BoldTextStyle := Document.AddStyle();
238	240		BoldTextStyle.Kind := vskTextSpan; // This style will only be applied to selected Text Spans
239	241		BoldTextStyle.Name := 'Bold';
240	242		BoldTextStyle.Font.Bold := True;
241	243		BoldTextStyle.SetElements := BoldTextStyle.SetElements + [spbfFontBold];
242	244
243	245		// Add our own style for centered paragraphs
244	246		CenterStyle := Document.AddStyle();
245	247		CenterStyle.Kind := vskTextBody; // This style will be applied to the whole Paragraph
246	248		CenterStyle.Name := 'Table Body Centered';
247	249		CenterStyle.Font.Name := 'Verdana';
248	250		CenterStyle.Font.Size := 8;
249	251		CenterStyle.Alignment := vsaCenter;
250	252		CenterStyle.MarginTop := 2 * ONE_POINT_IN_MM;
251	253		CenterStyle.MarginBottom := 2 * ONE_POINT_IN_MM;
252	254		CenterStyle.SetElements :=
253	255		[spbfFontSize, spbfFontName, spbfAlignment, sseMarginTop, sseMarginBottom];
254	256
255	257		// Create the Document, and add a simple Heading
256	258		Page := Document.AddTextPageSequence;
257	259		Paragraph := Page.AddParagraph;
258	260		Paragraph.Style := Document.StyleHeading1;
259	261		Paragraph.AddText('Simple Table');
260	262
261	263		// Add our Table, which will have 5 columns
262	264		Table := Page.AddTable;
263	265		Table.PreferredWidth := Dimension(100, dimPercent);
264	266
265	267		// As we will be merging cells, we have to define all the column widths
266	268		// so that ODT knows how many columns there will be.
267	269		// Getting the width exactly correct is not essential as LibreOffice Writer
268	270		// and Microsoft Word each treat this as a PreferredWidth value.
269	271		Table.ColWidthsUnits:=dimMillimeter;
270	272		Table.AddColWidth(50);
271	273		Table.AddColWidth(50);
272	274		Table.AddColWidth(50);
273	275		Table.AddColWidth(50);
274	276		Table.AddColWidth(50);
275	277
276	278		// Add a single row at the start which will contain merged cells
277	279		Row := Table.AddRow;
278	280		Row.BackgroundColor := RGBToFPColor(192, 192, 192); // Grey Shading
279	281		Row.Header := True; // Tell the table this is a Header Row
280	282		// Header Rows repeat at the top of each page
281	283
282	284		Cell := Row.AddCell;
283	285		Paragraph := Cell.AddParagraph;
284	286		Paragraph.Style := CenterStyle;
285	287		Paragraph.AddText('Category 1').Style := BoldTextStyle;
286	288
287	289		Cell := Row.AddCell;
288	290		Cell.SpannedCols:=2; // Make this cell cover two columns
289	291		Paragraph := Cell.AddParagraph;
290	292		Paragraph.Style := CenterStyle;
291	293		Paragraph.AddText('Category 2').Style := BoldTextStyle;
292	294
293	295		Cell := Row.AddCell;
294	296		Cell.SpannedCols:=2; // Make this cell cover two columns
295	297		Paragraph := Cell.AddParagraph;
296	298		Paragraph.Style := CenterStyle;
297	299		Paragraph.AddText('Category 3').Style := BoldTextStyle;
298	300
299	301		// Add 21 rows to the Table, with the first being the header row
300	302		for iRow := 0 to 20 do
301	303		begin
302	304		Row := Table.AddRow;
303	305
304	306		// Header Row
305	307		if iRow = 0 then
306	308		begin
307	309		Row.BackgroundColor := RGBToFPColor(192, 192, 192); // Grey Shading
308	310		Row.Header := True; // Tell the table this is a Header Row
309	311		// Header Rows repeat at the top of each page
310	312		end;
311	313
312	314		// Add 5 cells to each Row
313	315		for iCol := 0 to 4 do
314	316		begin
315	317		Cell := Row.AddCell;
316	318
317	319		// Each Cell is a TvRichText, we cad add anything we can add to the main
318	320		// body of a Document (for now Paragraphs, Tables or Lists)
319	321		Paragraph := Cell.AddParagraph;
320	322		Paragraph.Style := CenterStyle;
321	323
322	324		if iRow = 0 then
323	325		Paragraph.AddText(Format('Header Col %d', [iCol])).Style := BoldTextStyle
324	326		else
325	327		Paragraph.AddText(Format('Cell %d x %d', [iRow, iCol]));
326	328		end;
327	329		end;
328	330
329	331		Document.WriteToFile('Simple_Table.docx', vfDOCX);
330	332		Document.WriteToFile('Simple_Table.odt', vfODT);
331	333		finally
332	334		Document.Free;
333	335		end;
334	336		end.
335	337		```
336	338
337	339		![](/wiki-images/f/fe/FPVectorial_-_Document_Support_-_Simple_Table.png)
338	340
339	341		### Lists
340	342
341	343		Sample code to create a List Style
342	344
343	345		``` pascal
344	346		Var
345	347		lCurListStyle : TvListStyle;
346	348		lCurListLevelStyle : TvListLevelStyle;
347	349
348	350		Begin
349	351		lCurListStyle := {TvVectorialDocument.}AddListStyle();
350	352		lCurListStyle.Name := 'Numbered List Style';
351	353		StyleNumberList := lCurListStyle;
352	354
353	355		for i := 0 To NUM_MAX_LISTSTYLES-1 Do
354	356		begin
355	357		lCurListLevelStyle := StyleNumberList.AddListLevelStyle;
356	358		lCurListLevelStyle.Kind := vlskNumeric; // Other option in vlskBullet
357	359		lCurListLevelStyle.NumberFormat:= vnfDecimal; // Other options include: vnfDecimal, vnfLowerLetter,
358	360		// vnfLowerRoman, vnfUpperLetter & vnfUpperRoman
359	361
360	362		lCurListLevelStyle.Level := i;
361	363
362	364		lCurListLevelStyle.Prefix := '';
363	365		lCurListLevelStyle.Suffix := '.';
364	366		lCurListLevelStyle.DisplayLevels := True; // 1.1.1.1.
365	367		//lCurListLevelStyle.DisplayLevels := False; // 1.
366	368		lCurListLevelStyle.LeaderFontName := 'Arial';
367	369
368	370		// Bullet is positioned at MarginLeft - HangingIndent
369	371		lCurListLevelStyle.MarginLeft := 16.35*(i + 1);
370	372		lCurListLevelStyle.HangingIndent := 6.35 + 3*i;
371	373		end;
372	374		end;
373	375		```
374	376
375	377		Sample code to create a List which includes entries at different levels of indentation.
376	378
377	379		``` pascal
378	380		Var
379	381		List : TvList;
380	382		SubList: TvList;
381	383
382	384		Begin
383	385		//...
384	386		// Missing code can be copied from above examples, this is a code snippet to demonstrate lists only
385	387		//...
386	388
387	389		// Add a simple heading
388	390		CurParagraph := Page.AddParagraph();
389	391		CurParagraph.Style := Vec.StyleHeading2;
390	392		CurText := CurParagraph.AddText('Testing Lists');
391	393
392	394		// Indented numbered List
393	395		List := Page.AddList();
394	396		List.Style := Vec.StyleTextBody;
395	397		List.ListStyle := Vec.StyleNumberList;
396	398
397	399		// Start the list
398	400		List.AddParagraph('Level 1, Item 1');
399	401		List.AddParagraph('Level 1, Item 2');
400	402		List.AddParagraph('Level 1, Item 3');
401	403
402	404		// The next three entries are are placed at Level 2
403	405		SubList := List.AddList;
404	406		SubList.AddParagraph('Level 2, Item 1');
405	407		SubList.AddParagraph('Level 2, Item 2');
406	408		SubList.AddParagraph('Level 2, Item 3');
407	409
408	410		// The next three entries are are placed at Level 3
409	411		With SubList.AddList Do
410	412		begin
411	413		AddParagraph('Level 3, Item 1');
412	414		AddParagraph('Level 3, Item 2');
413	415		AddParagraph('Level 3, Item 3');
414	416		end;
415	417
416	418		// The next three entries are placed at Level 2
417	419		// NOTE: We are creating this SubList from the original List
418	420		SubList := List.AddList;
419	421		SubList.AddParagraph('Level 2, Item 1 (new SubList added to same upper List)');
420	422		SubList.AddParagraph('Level 2, Item 2 (new SubList added to same upper List)');
421	423		SubList.AddParagraph('Level 2, Item 3 (new SubList added to same upper List)');
422	424
423	425		// The next three entries are are placed at Level 3
424	426		SubList := SubList.AddList;
425	427		SubList.AddParagraph('Level 3, Item 1');
426	428		SubList.AddParagraph('Level 3, Item 2');
427	429		SubList.AddParagraph('Level 3, Item 3');
428	430
429	431		// Three more entries in the original list
430	432		List.AddParagraph('Level 1, Item 1 (Continuing on from same upper list)');
431	433		List.AddParagraph('Level 1, Item 2 (Continuing on from same upper list)');
432	434		List.AddParagraph('Level 1, Item 3 (Continuing on from same upper list)');
433	435
434	436		// Mixing the original list with a sublist that utilises a different ListStyle
435	437		// In this case, bullets
436	438		SubList := List.AddList;
437	439		SubList.ListStyle := Vec.StyleBulletList;
438	440		SubList.AddParagraph('Bullet Level 2, Item 1 (new SubList added to same upper List)');
439	441		SubList.AddParagraph('Bullet Level 2, Item 2 (new SubList added to same upper List)');
440	442		SubList.AddParagraph('Bullet Level 2, Item 3 (new SubList added to same upper List)');
441	443		```
442	444
443	445		Conceptual Output from the above code:
444	446
445	447
446	448		1\. Level 1, Item 1
447	449
448	450		2\. Level 1, Item 2
449	451
450	452		3\. Level 1, Item 3
451	453
452	454
453	455		3.1. Level 2, Item 1
454	456
455	457		3.2. Level 2, Item 2
456	458
457	459		3.3. Level 2, Item 3
458	460
459	461
460	462		3.3.1. Level 3, Item 1
461	463
462	464		3.3.2. Level 3, Item 2
463	465
464	466		3.3.3. Level 3, Item 3
465	467
466	468		3.4. Level 2, Item 1 (new SubList added to same upper List)
467	469
468	470		3.5. Level 2, Item 2 (new SubList added to same upper List)
469	471
470	472		3.6. Level 2, Item 3 (new SubList added to same upper List)
471	473
472	474
473	475		3.6.1. Level 3, Item 1
474	476
475	477		3.6.2. Level 3, Item 2
476	478
477	479		3.6.3. Level 3, Item 3
478	480
479	481		4\. Level 1, Item 1 (Continuing on from same upper list)
480	482
481	483		5\. Level 1, Item 2 (Continuing on from same upper list)
482	484
483	485		6\. Level 1, Item 3 (Continuing on from same upper list)
484	486
485	487
486	488		• Bullet Level 2, Item 1 (new SubList added to same upper List)
487	489
488	490		• Bullet Level 2, Item 2 (new SubList added to same upper List)
489	491
490	492		• Bullet Level 2, Item 3 (new SubList added to same upper List)
491	493
492	494		### Document Fields
493	495
494	496		The following code snippet shows how Document Fields are added:
495	497
496	498		``` pascal
497	499		CurParagraph := Page.AddParagraph();
498	500		CurParagraph.Style := Vec.StyleTextBody;
499	501		CurParagraph.AddText('Page Count: ');
500	502		CurParagraph.AddField(vfkNumPages);
501	503
502	504		CurParagraph := Page.AddParagraph();
503	505		CurParagraph.Style := Vec.StyleTextBody;
504	506		CurParagraph.AddText('Page: ');
505	507		CurParagraph.AddField(vfkPage);
506	508
507	509		CurParagraph := Page.AddParagraph();
508	510		CurParagraph.Style := Vec.StyleTextBody;
509	511		CurParagraph.AddText('Author: ');
510	512		CurParagraph.AddField(vfkAuthor);
511	513
512	514		CurParagraph := Page.AddParagraph();
513	515		CurParagraph.Style := Vec.StyleTextBody;
514	516		CurParagraph.AddText('Date Created: ');
515	517		CurParagraph.AddField(vfkDateCreated);
516	518
517	519		CurParagraph := Page.AddParagraph();
518	520		CurParagraph.Style := Vec.StyleTextBody;
519	521		CurParagraph.AddText('Date: ');
520	522		CurParagraph.AddField(vfkDate);
521	523		```
522	524
523	525		Output from above:
524	526
525	527
526	528		Page Count: 3
527	529
528	530		Page: 2
529	531
530	532		Author: FPVECTORIAL
531	533
532	534		Date Created: 24/09/2013
533	535
534	536		Date: 24/09/2013 2:08 PM
535	537
536	538		## Known Issues
537	539
538	540		- Table support in ODT writer results in large file sizes. This is due to the fact that a style is created for each individual cell, even if multiple cells are identically formatted. This also applied to row styles and column styles. In order to resolve this, Cell, Row and Column Styles could be normalised. Alternatively, the entire table formatting architecture could be re-written to force the end user to create and apply the styles themselves (in addition to also requiring DOCX table support to be re-written to support the new architecture, specific code will need adding to DOCX writer to interpret the new FP Vectorial Table Styles).
539	541		- ODT Writer produces files that cannot be opened in Word 2010.
540	542		- File MIMETYPE in ODTDocument should not be compressed. Currently clNone compression type is ignored by TZipper (possible cause for Word 2010 rejecting existing ODT files). Patch exists, but not yet added to FPC Trunk (See <http://mantis.freepascal.org/view.php?id=24897> & <http://mantis.freepascal.org/view.php?id=23533>).
541	543		- Double line not supported in ODT Tables. Two locations in ODTVectorialWriter.pas need to changed to enable support:
542	544		- LU_BORDERTYPE needs double adding (in CONST at start of unit. currently double is mapped to solid)
543	545		- function TvODTVectorialWriter.BordersToString needs to support double (see comment at start of function)
544	546
545	547		## TODO
546	548
547	549		### General
548	550
549	551		- Comprehensive testing, including opening the files in as many word processors and office suites as possible.
550	552		- DOCX and ODT Readers (volunteers required)
551	553		- Add PDF reader/writer (current PDF support is for Vector Image support only)
552	554		- Add HTML reader/writer
553	555		- Add RTF reader/writer
554	556		- Produce well documented examples and store in FPVectorial/Examples
555	557		- Code Documentation for distributing with Lazarus
556	558
557	559		### New Code
558	560
559	561		See Roadmap above...
560	562
561	563		### ODTWriter
562	564
563	565		- Support for Header/Footers and support for Tables within Headers/Footers. This requires a refactoring of ODT writer. Header and Footer content is actually stored in styles.xml, not in content.xml. All current text and table support can only produce content in content.xml.
564	566
565	567		---
566	568		From the Free Pascal wiki, page "fpvectorial - Text Document Support", as it stood on 2023-05-22 after a change by Serbod, 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).
567	569		Category: Data import and export
568	570		Category: FPVectorial

Back to history