?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fdo#74697 Add Bluez 5 support for impress remote.
[LibreOffice.git] / xmloff / source / text / txtimp.cxx
blob42e0576936d70ba5f4bdd35167e04c73778b94c3
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20
21 #include <vector>
22
23 #include <boost/scoped_array.hpp>
24
25 #include <com/sun/star/container/XEnumerationAccess.hpp>
26 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
27 #include <com/sun/star/text/XChapterNumberingSupplier.hpp>
28 #include <com/sun/star/text/XTextFramesSupplier.hpp>
29 #include <com/sun/star/text/XTextGraphicObjectsSupplier.hpp>
30 #include <com/sun/star/text/XTextEmbeddedObjectsSupplier.hpp>
31 #include <com/sun/star/text/XFormField.hpp>
32 #include <com/sun/star/ucb/XAnyCompareFactory.hpp>
33 #include "xmloff/xmlnmspe.hxx"
34 #include <xmloff/txtstyli.hxx>
35 #include <xmloff/xmlnumi.hxx>
36
37 #include "txtparai.hxx"
38 #include <xmloff/txtprmap.hxx>
39 #include "xmloff/txtimppr.hxx"
40 #include <xmloff/xmlimp.hxx>
41 #include "txtvfldi.hxx"
42 #include "xmloff/i18nmap.hxx"
43 #include "XMLTextListItemContext.hxx"
44 #include "XMLTextListBlockContext.hxx"
45 #include "XMLTextFrameContext.hxx"
46 #include "XMLTextFrameHyperlinkContext.hxx"
47 #include "XMLSectionImportContext.hxx"
48 #include "XMLIndexTOCContext.hxx"
49 #include <xmloff/XMLFontStylesContext.hxx>
50 #include <xmloff/XMLEventsImportContext.hxx>
51 #include "XMLTrackedChangesImportContext.hxx"
52 #include "XMLChangeImportContext.hxx"
53 #include "XMLAutoMarkFileContext.hxx"
54
55 #include "XMLCalculationSettingsContext.hxx"
56 #include "XMLNumberStylesImport.hxx"
57 // XML import: reconstrution of assignment of paragraph style to outline levels (#i69629#)
58 #include <com/sun/star/beans/XPropertyState.hpp>
59 #include <txtlists.hxx>
60 #include <xmloff/odffields.hxx>
61 #include <comphelper/stlunosequence.hxx>
62
63 using ::com::sun::star::ucb::XAnyCompare;
64
65 using namespace ::std;
66 using namespace ::com::sun::star;
67 using namespace ::com::sun::star::uno;
68 using namespace ::com::sun::star::beans;
69 using namespace ::com::sun::star::text;
70 using namespace ::com::sun::star::frame;
71 using namespace ::com::sun::star::style;
72 using namespace ::com::sun::star::container;
73 using namespace ::com::sun::star::drawing;
74 using namespace ::com::sun::star::xml::sax;
75 using namespace ::com::sun::star::lang;
76 using namespace ::xmloff::token;
77 using namespace ::com::sun::star::ucb;
78 using ::comphelper::UStringLess;
79
80
81
82 static SvXMLTokenMapEntry aTextElemTokenMap[] =
83 {
84 { XML_NAMESPACE_TEXT, XML_P, XML_TOK_TEXT_P },
85 { XML_NAMESPACE_TEXT, XML_H, XML_TOK_TEXT_H },
86 { XML_NAMESPACE_TEXT, XML_LIST, XML_TOK_TEXT_LIST },
87 { XML_NAMESPACE_DRAW, XML_FRAME, XML_TOK_TEXT_FRAME_PAGE },
88 { XML_NAMESPACE_DRAW, XML_A, XML_TOK_DRAW_A_PAGE },
89 { XML_NAMESPACE_TABLE,XML_TABLE, XML_TOK_TABLE_TABLE },
90 { XML_NAMESPACE_TEXT, XML_VARIABLE_DECLS, XML_TOK_TEXT_VARFIELD_DECLS },
91 { XML_NAMESPACE_TEXT, XML_USER_FIELD_DECLS, XML_TOK_TEXT_USERFIELD_DECLS },
92 { XML_NAMESPACE_TEXT, XML_SEQUENCE_DECLS, XML_TOK_TEXT_SEQUENCE_DECLS },
93 { XML_NAMESPACE_TEXT, XML_DDE_CONNECTION_DECLS, XML_TOK_TEXT_DDE_DECLS },
94 { XML_NAMESPACE_TEXT, XML_SECTION, XML_TOK_TEXT_SECTION },
95 { XML_NAMESPACE_TEXT, XML_TABLE_OF_CONTENT, XML_TOK_TEXT_TOC },
96 { XML_NAMESPACE_TEXT, XML_OBJECT_INDEX, XML_TOK_TEXT_OBJECT_INDEX },
97 { XML_NAMESPACE_TEXT, XML_TABLE_INDEX, XML_TOK_TEXT_TABLE_INDEX },
98 { XML_NAMESPACE_TEXT, XML_ILLUSTRATION_INDEX, XML_TOK_TEXT_ILLUSTRATION_INDEX },
99 { XML_NAMESPACE_TEXT, XML_USER_INDEX, XML_TOK_TEXT_USER_INDEX },
100 { XML_NAMESPACE_TEXT, XML_ALPHABETICAL_INDEX, XML_TOK_TEXT_ALPHABETICAL_INDEX },
101 { XML_NAMESPACE_TEXT, XML_BIBLIOGRAPHY, XML_TOK_TEXT_BIBLIOGRAPHY_INDEX },
102 { XML_NAMESPACE_TEXT, XML_INDEX_TITLE, XML_TOK_TEXT_INDEX_TITLE },
103 { XML_NAMESPACE_TEXT, XML_TRACKED_CHANGES, XML_TOK_TEXT_TRACKED_CHANGES },
104 { XML_NAMESPACE_TEXT, XML_CHANGE_START, XML_TOK_TEXT_CHANGE_START },
105 { XML_NAMESPACE_TEXT, XML_CHANGE_END, XML_TOK_TEXT_CHANGE_END },
106 { XML_NAMESPACE_TEXT, XML_CHANGE, XML_TOK_TEXT_CHANGE },
107 { XML_NAMESPACE_OFFICE, XML_FORMS, XML_TOK_TEXT_FORMS },
108 { XML_NAMESPACE_TABLE, XML_CALCULATION_SETTINGS, XML_TOK_TEXT_CALCULATION_SETTINGS },
109 { XML_NAMESPACE_TEXT, XML_ALPHABETICAL_INDEX_AUTO_MARK_FILE, XML_TOK_TEXT_AUTOMARK },
110 // #i52127#
111 { XML_NAMESPACE_TEXT, XML_NUMBERED_PARAGRAPH, XML_TOK_TEXT_NUMBERED_PARAGRAPH },
112
113 XML_TOKEN_MAP_END
114 };
115
116 static SvXMLTokenMapEntry aTextPElemTokenMap[] =
117 {
118 { XML_NAMESPACE_TEXT, XML_SPAN, XML_TOK_TEXT_SPAN },
119 { XML_NAMESPACE_TEXT, XML_TAB, XML_TOK_TEXT_TAB_STOP },
120 { XML_NAMESPACE_TEXT, XML_LINE_BREAK, XML_TOK_TEXT_LINE_BREAK },
121 { XML_NAMESPACE_TEXT, XML_SOFT_PAGE_BREAK, XML_TOK_TEXT_SOFT_PAGE_BREAK },
122 { XML_NAMESPACE_TEXT, XML_S, XML_TOK_TEXT_S },
123 { XML_NAMESPACE_TEXT, XML_A, XML_TOK_TEXT_HYPERLINK },
124 { XML_NAMESPACE_TEXT, XML_RUBY, XML_TOK_TEXT_RUBY },
125
126 { XML_NAMESPACE_TEXT, XML_NOTE, XML_TOK_TEXT_NOTE },
127 { XML_NAMESPACE_TEXT, XML_BOOKMARK, XML_TOK_TEXT_BOOKMARK },
128 { XML_NAMESPACE_TEXT, XML_BOOKMARK_START, XML_TOK_TEXT_BOOKMARK_START },
129 { XML_NAMESPACE_TEXT, XML_BOOKMARK_END, XML_TOK_TEXT_BOOKMARK_END },
130 { XML_NAMESPACE_TEXT, XML_REFERENCE_MARK, XML_TOK_TEXT_REFERENCE },
131 { XML_NAMESPACE_TEXT, XML_REFERENCE_MARK_START,
132 XML_TOK_TEXT_REFERENCE_START },
133 { XML_NAMESPACE_TEXT, XML_REFERENCE_MARK_END,
134 XML_TOK_TEXT_REFERENCE_END },
135
136 { XML_NAMESPACE_DRAW, XML_FRAME, XML_TOK_TEXT_FRAME },
137 { XML_NAMESPACE_DRAW, XML_A, XML_TOK_DRAW_A },
138
139 // index marks
140 { XML_NAMESPACE_TEXT, XML_TOC_MARK, XML_TOK_TEXT_TOC_MARK },
141 { XML_NAMESPACE_TEXT, XML_TOC_MARK_START, XML_TOK_TEXT_TOC_MARK_START },
142 { XML_NAMESPACE_TEXT, XML_TOC_MARK_END, XML_TOK_TEXT_TOC_MARK_END },
143 { XML_NAMESPACE_TEXT, XML_USER_INDEX_MARK, XML_TOK_TEXT_USER_INDEX_MARK },
144 { XML_NAMESPACE_TEXT, XML_USER_INDEX_MARK_START,
145 XML_TOK_TEXT_USER_INDEX_MARK_START },
146 { XML_NAMESPACE_TEXT, XML_USER_INDEX_MARK_END,
147 XML_TOK_TEXT_USER_INDEX_MARK_END },
148 { XML_NAMESPACE_TEXT, XML_ALPHABETICAL_INDEX_MARK,
149 XML_TOK_TEXT_ALPHA_INDEX_MARK },
150 { XML_NAMESPACE_TEXT, XML_ALPHABETICAL_INDEX_MARK_START,
151 XML_TOK_TEXT_ALPHA_INDEX_MARK_START },
152 { XML_NAMESPACE_TEXT, XML_ALPHABETICAL_INDEX_MARK_END,
153 XML_TOK_TEXT_ALPHA_INDEX_MARK_END },
154
155 // sender fields
156 { XML_NAMESPACE_TEXT, XML_SENDER_FIRSTNAME,XML_TOK_TEXT_SENDER_FIRSTNAME},
157 { XML_NAMESPACE_TEXT, XML_SENDER_LASTNAME, XML_TOK_TEXT_SENDER_LASTNAME },
158 { XML_NAMESPACE_LO_EXT, XML_SENDER_INITIALS, XML_TOK_TEXT_SENDER_INITIALS },
159 { XML_NAMESPACE_TEXT, XML_SENDER_INITIALS, XML_TOK_TEXT_SENDER_INITIALS },
160 { XML_NAMESPACE_TEXT, XML_SENDER_TITLE, XML_TOK_TEXT_SENDER_TITLE },
161 { XML_NAMESPACE_TEXT, XML_SENDER_POSITION, XML_TOK_TEXT_SENDER_POSITION },
162 { XML_NAMESPACE_TEXT, XML_SENDER_EMAIL, XML_TOK_TEXT_SENDER_EMAIL },
163 { XML_NAMESPACE_TEXT, XML_SENDER_PHONE_PRIVATE,
164 XML_TOK_TEXT_SENDER_PHONE_PRIVATE },
165 { XML_NAMESPACE_TEXT, XML_SENDER_FAX, XML_TOK_TEXT_SENDER_FAX },
166 { XML_NAMESPACE_TEXT, XML_SENDER_COMPANY, XML_TOK_TEXT_SENDER_COMPANY },
167 { XML_NAMESPACE_TEXT, XML_SENDER_PHONE_WORK,
168 XML_TOK_TEXT_SENDER_PHONE_WORK },
169 { XML_NAMESPACE_TEXT, XML_SENDER_STREET, XML_TOK_TEXT_SENDER_STREET },
170 { XML_NAMESPACE_TEXT, XML_SENDER_CITY, XML_TOK_TEXT_SENDER_CITY },
171 { XML_NAMESPACE_TEXT, XML_SENDER_POSTAL_CODE,
172 XML_TOK_TEXT_SENDER_POSTAL_CODE },
173 { XML_NAMESPACE_TEXT, XML_SENDER_COUNTRY, XML_TOK_TEXT_SENDER_COUNTRY },
174 { XML_NAMESPACE_TEXT, XML_SENDER_STATE_OR_PROVINCE,
175 XML_TOK_TEXT_SENDER_STATE_OR_PROVINCE },
176
177 // misc. document fields
178 { XML_NAMESPACE_TEXT, XML_AUTHOR_NAME, XML_TOK_TEXT_AUTHOR_NAME },
179 { XML_NAMESPACE_TEXT, XML_AUTHOR_INITIALS, XML_TOK_TEXT_AUTHOR_INITIALS },
180 { XML_NAMESPACE_TEXT, XML_DATE, XML_TOK_TEXT_DATE },
181 { XML_NAMESPACE_TEXT, XML_TIME, XML_TOK_TEXT_TIME },
182 { XML_NAMESPACE_TEXT, XML_PAGE_NUMBER, XML_TOK_TEXT_PAGE_NUMBER },
183 { XML_NAMESPACE_TEXT, XML_PAGE_CONTINUATION_STRING,
184 XML_TOK_TEXT_PAGE_CONTINUATION_STRING },
185
186 // variable fields
187 { XML_NAMESPACE_TEXT, XML_VARIABLE_SET, XML_TOK_TEXT_VARIABLE_SET },
188 { XML_NAMESPACE_TEXT, XML_VARIABLE_GET, XML_TOK_TEXT_VARIABLE_GET },
189 { XML_NAMESPACE_TEXT, XML_VARIABLE_INPUT, XML_TOK_TEXT_VARIABLE_INPUT },
190 { XML_NAMESPACE_TEXT, XML_USER_FIELD_GET, XML_TOK_TEXT_USER_FIELD_GET },
191 { XML_NAMESPACE_TEXT, XML_USER_FIELD_INPUT,XML_TOK_TEXT_USER_FIELD_INPUT},
192 { XML_NAMESPACE_TEXT, XML_SEQUENCE, XML_TOK_TEXT_SEQUENCE },
193 { XML_NAMESPACE_TEXT, XML_EXPRESSION, XML_TOK_TEXT_EXPRESSION },
194 { XML_NAMESPACE_TEXT, XML_TEXT_INPUT, XML_TOK_TEXT_TEXT_INPUT },
195
196 // database fields
197 { XML_NAMESPACE_TEXT, XML_DATABASE_DISPLAY,
198 XML_TOK_TEXT_DATABASE_DISPLAY },
199 { XML_NAMESPACE_TEXT, XML_DATABASE_NEXT,
200 XML_TOK_TEXT_DATABASE_NEXT },
201 { XML_NAMESPACE_TEXT, XML_DATABASE_ROW_SELECT,
202 XML_TOK_TEXT_DATABASE_SELECT },
203 { XML_NAMESPACE_TEXT, XML_DATABASE_ROW_NUMBER,
204 XML_TOK_TEXT_DATABASE_ROW_NUMBER },
205 { XML_NAMESPACE_TEXT, XML_DATABASE_NAME, XML_TOK_TEXT_DATABASE_NAME },
206
207 // docinfo fields
208 { XML_NAMESPACE_TEXT, XML_INITIAL_CREATOR,
209 XML_TOK_TEXT_DOCUMENT_CREATION_AUTHOR },
210 { XML_NAMESPACE_TEXT, XML_DESCRIPTION, XML_TOK_TEXT_DOCUMENT_DESCRIPTION},
211 { XML_NAMESPACE_TEXT, XML_PRINTED_BY, XML_TOK_TEXT_DOCUMENT_PRINT_AUTHOR},
212 { XML_NAMESPACE_TEXT, XML_TITLE, XML_TOK_TEXT_DOCUMENT_TITLE },
213 { XML_NAMESPACE_TEXT, XML_SUBJECT, XML_TOK_TEXT_DOCUMENT_SUBJECT },
214 { XML_NAMESPACE_TEXT, XML_KEYWORDS, XML_TOK_TEXT_DOCUMENT_KEYWORDS },
215 { XML_NAMESPACE_TEXT, XML_CREATOR, XML_TOK_TEXT_DOCUMENT_SAVE_AUTHOR },
216 { XML_NAMESPACE_TEXT, XML_EDITING_CYCLES,
217 XML_TOK_TEXT_DOCUMENT_REVISION },
218 { XML_NAMESPACE_TEXT, XML_CREATION_DATE,
219 XML_TOK_TEXT_DOCUMENT_CREATION_DATE },
220 { XML_NAMESPACE_TEXT, XML_CREATION_TIME,
221 XML_TOK_TEXT_DOCUMENT_CREATION_TIME },
222 { XML_NAMESPACE_TEXT, XML_PRINT_DATE, XML_TOK_TEXT_DOCUMENT_PRINT_DATE },
223 { XML_NAMESPACE_TEXT, XML_PRINT_TIME, XML_TOK_TEXT_DOCUMENT_PRINT_TIME },
224 { XML_NAMESPACE_TEXT, XML_MODIFICATION_DATE,
225 XML_TOK_TEXT_DOCUMENT_SAVE_DATE },
226 { XML_NAMESPACE_TEXT, XML_MODIFICATION_TIME,
227 XML_TOK_TEXT_DOCUMENT_SAVE_TIME },
228 { XML_NAMESPACE_TEXT, XML_EDITING_DURATION,
229 XML_TOK_TEXT_DOCUMENT_EDIT_DURATION },
230 { XML_NAMESPACE_TEXT, XML_USER_DEFINED,
231 XML_TOK_TEXT_DOCUMENT_USER_DEFINED },
232
233 // misc fields
234 { XML_NAMESPACE_TEXT, XML_PLACEHOLDER, XML_TOK_TEXT_PLACEHOLDER },
235 { XML_NAMESPACE_TEXT, XML_HIDDEN_TEXT, XML_TOK_TEXT_HIDDEN_TEXT },
236 { XML_NAMESPACE_TEXT, XML_HIDDEN_PARAGRAPH,
237 XML_TOK_TEXT_HIDDEN_PARAGRAPH },
238 { XML_NAMESPACE_TEXT, XML_CONDITIONAL_TEXT,
239 XML_TOK_TEXT_CONDITIONAL_TEXT },
240 { XML_NAMESPACE_TEXT, XML_FILE_NAME, XML_TOK_TEXT_FILENAME },
241 { XML_NAMESPACE_TEXT, XML_CHAPTER, XML_TOK_TEXT_CHAPTER },
242 { XML_NAMESPACE_TEXT, XML_TEMPLATE_NAME, XML_TOK_TEXT_TEMPLATENAME },
243 { XML_NAMESPACE_TEXT, XML_PARAGRAPH_COUNT, XML_TOK_TEXT_PARAGRAPH_COUNT },
244 { XML_NAMESPACE_TEXT, XML_WORD_COUNT, XML_TOK_TEXT_WORD_COUNT },
245 { XML_NAMESPACE_TEXT, XML_TABLE_COUNT, XML_TOK_TEXT_TABLE_COUNT },
246 { XML_NAMESPACE_TEXT, XML_CHARACTER_COUNT, XML_TOK_TEXT_CHARACTER_COUNT },
247 { XML_NAMESPACE_TEXT, XML_IMAGE_COUNT, XML_TOK_TEXT_IMAGE_COUNT },
248 { XML_NAMESPACE_TEXT, XML_OBJECT_COUNT, XML_TOK_TEXT_OBJECT_COUNT },
249 { XML_NAMESPACE_TEXT, XML_PAGE_COUNT, XML_TOK_TEXT_PAGE_COUNT },
250 { XML_NAMESPACE_TEXT, XML_PAGE_VARIABLE_GET, XML_TOK_TEXT_GET_PAGE_VAR },
251 { XML_NAMESPACE_TEXT, XML_PAGE_VARIABLE_SET, XML_TOK_TEXT_SET_PAGE_VAR },
252 { XML_NAMESPACE_TEXT, XML_EXECUTE_MACRO, XML_TOK_TEXT_MACRO },
253 { XML_NAMESPACE_TEXT, XML_DDE_CONNECTION, XML_TOK_TEXT_DDE },
254 { XML_NAMESPACE_TEXT, XML_REFERENCE_REF, XML_TOK_TEXT_REFERENCE_REF },
255 { XML_NAMESPACE_TEXT, XML_BOOKMARK_REF, XML_TOK_TEXT_BOOKMARK_REF },
256 { XML_NAMESPACE_TEXT, XML_SEQUENCE_REF, XML_TOK_TEXT_SEQUENCE_REF },
257 { XML_NAMESPACE_TEXT, XML_NOTE_REF, XML_TOK_TEXT_NOTE_REF },
258 { XML_NAMESPACE_TEXT, XML_BIBLIOGRAPHY_MARK,
259 XML_TOK_TEXT_BIBLIOGRAPHY_MARK },
260 { XML_NAMESPACE_OFFICE, XML_ANNOTATION, XML_TOK_TEXT_ANNOTATION },
261 { XML_NAMESPACE_OFFICE, XML_ANNOTATION_END, XML_TOK_TEXT_ANNOTATION_END },
262 { XML_NAMESPACE_TEXT, XML_SCRIPT, XML_TOK_TEXT_SCRIPT },
263 { XML_NAMESPACE_TEXT, XML_TABLE_FORMULA, XML_TOK_TEXT_TABLE_FORMULA },
264 { XML_NAMESPACE_TEXT, XML_DROPDOWN, XML_TOK_TEXT_DROPDOWN },
265
266 // Calc fields
267 { XML_NAMESPACE_TEXT, XML_SHEET_NAME, XML_TOK_TEXT_SHEET_NAME },
268
269 // draw fields
270 { XML_NAMESPACE_TEXT, XML_MEASURE, XML_TOK_TEXT_MEASURE },
271
272 // RDF metadata
273 { XML_NAMESPACE_TEXT, XML_META, XML_TOK_TEXT_META },
274 { XML_NAMESPACE_TEXT, XML_META_FIELD, XML_TOK_TEXT_META_FIELD },
275
276 // redlining (aka change tracking)
277 { XML_NAMESPACE_TEXT, XML_CHANGE_START, XML_TOK_TEXTP_CHANGE_START },
278 { XML_NAMESPACE_TEXT, XML_CHANGE_END , XML_TOK_TEXTP_CHANGE_END },
279 { XML_NAMESPACE_TEXT, XML_CHANGE, XML_TOK_TEXTP_CHANGE },
280
281 { XML_NAMESPACE_PRESENTATION, XML_HEADER, XML_TOK_DRAW_HEADER },
282 { XML_NAMESPACE_PRESENTATION, XML_FOOTER, XML_TOK_DRAW_FOOTER },
283 { XML_NAMESPACE_PRESENTATION, XML_DATE_TIME, XML_TOK_DRAW_DATE_TIME },
284 { XML_NAMESPACE_TEXT, XML_PAGE_CONTINUATION, XML_TOK_TEXT_PAGE_CONTINUATION },
285
286 { XML_NAMESPACE_FIELD, XML_FIELDMARK, XML_TOK_TEXT_FIELDMARK },
287 { XML_NAMESPACE_FIELD, XML_FIELDMARK_START, XML_TOK_TEXT_FIELDMARK_START },
288 { XML_NAMESPACE_FIELD, XML_FIELDMARK_END, XML_TOK_TEXT_FIELDMARK_END },
289
290
291 XML_TOKEN_MAP_END
292 };
293
294 static SvXMLTokenMapEntry aTextPAttrTokenMap[] =
295 {
296 { XML_NAMESPACE_XML , XML_ID, XML_TOK_TEXT_P_XMLID },
297 { XML_NAMESPACE_XHTML, XML_ABOUT, XML_TOK_TEXT_P_ABOUT },
298 { XML_NAMESPACE_XHTML, XML_PROPERTY, XML_TOK_TEXT_P_PROPERTY },
299 { XML_NAMESPACE_XHTML, XML_CONTENT, XML_TOK_TEXT_P_CONTENT },
300 { XML_NAMESPACE_XHTML, XML_DATATYPE, XML_TOK_TEXT_P_DATATYPE },
301 { XML_NAMESPACE_TEXT, XML_ID, XML_TOK_TEXT_P_TEXTID },
302 { XML_NAMESPACE_TEXT, XML_STYLE_NAME, XML_TOK_TEXT_P_STYLE_NAME },
303 { XML_NAMESPACE_TEXT, XML_COND_STYLE_NAME,
304 XML_TOK_TEXT_P_COND_STYLE_NAME },
305 { XML_NAMESPACE_TEXT, XML_OUTLINE_LEVEL,XML_TOK_TEXT_P_LEVEL },
306 { XML_NAMESPACE_TEXT, XML_IS_LIST_HEADER,XML_TOK_TEXT_P_IS_LIST_HEADER },
307 { XML_NAMESPACE_TEXT, XML_RESTART_NUMBERING,XML_TOK_TEXT_P_RESTART_NUMBERING },
308 { XML_NAMESPACE_TEXT, XML_START_VALUE,XML_TOK_TEXT_P_START_VALUE },
309 XML_TOKEN_MAP_END
310 };
311
312 static SvXMLTokenMapEntry aTextNumberedParagraphAttrTokenMap[] =
313 {
314 { XML_NAMESPACE_XML , XML_ID, XML_TOK_TEXT_NUMBERED_PARAGRAPH_XMLID },
315 { XML_NAMESPACE_TEXT, XML_LIST_ID,
316 XML_TOK_TEXT_NUMBERED_PARAGRAPH_LIST_ID },
317 { XML_NAMESPACE_TEXT, XML_LEVEL, XML_TOK_TEXT_NUMBERED_PARAGRAPH_LEVEL },
318 { XML_NAMESPACE_TEXT, XML_STYLE_NAME,
319 XML_TOK_TEXT_NUMBERED_PARAGRAPH_STYLE_NAME },
320 { XML_NAMESPACE_TEXT, XML_CONTINUE_NUMBERING,
321 XML_TOK_TEXT_NUMBERED_PARAGRAPH_CONTINUE_NUMBERING },
322 { XML_NAMESPACE_TEXT, XML_START_VALUE,
323 XML_TOK_TEXT_NUMBERED_PARAGRAPH_START_VALUE },
324 XML_TOKEN_MAP_END
325 };
326
327 static SvXMLTokenMapEntry aTextListBlockAttrTokenMap[] =
328 {
329 { XML_NAMESPACE_XML , XML_ID, XML_TOK_TEXT_LIST_BLOCK_XMLID },
330 { XML_NAMESPACE_TEXT, XML_STYLE_NAME,
331 XML_TOK_TEXT_LIST_BLOCK_STYLE_NAME },
332 { XML_NAMESPACE_TEXT, XML_CONTINUE_NUMBERING,
333 XML_TOK_TEXT_LIST_BLOCK_CONTINUE_NUMBERING },
334 { XML_NAMESPACE_TEXT, XML_CONTINUE_LIST,
335 XML_TOK_TEXT_LIST_BLOCK_CONTINUE_LIST },
336 XML_TOKEN_MAP_END
337 };
338
339 static SvXMLTokenMapEntry aTextListBlockElemTokenMap[] =
340 {
341 { XML_NAMESPACE_TEXT, XML_LIST_HEADER, XML_TOK_TEXT_LIST_HEADER },
342 { XML_NAMESPACE_TEXT, XML_LIST_ITEM, XML_TOK_TEXT_LIST_ITEM },
343 XML_TOKEN_MAP_END
344 };
345
346 static SvXMLTokenMapEntry aTextFrameAttrTokenMap[] =
347 {
348 { XML_NAMESPACE_DRAW, XML_STYLE_NAME, XML_TOK_TEXT_FRAME_STYLE_NAME },
349 { XML_NAMESPACE_DRAW, XML_NAME, XML_TOK_TEXT_FRAME_NAME },
350 { XML_NAMESPACE_TEXT, XML_ANCHOR_TYPE, XML_TOK_TEXT_FRAME_ANCHOR_TYPE },
351 { XML_NAMESPACE_TEXT, XML_ANCHOR_PAGE_NUMBER, XML_TOK_TEXT_FRAME_ANCHOR_PAGE_NUMBER },
352 { XML_NAMESPACE_SVG, XML_X, XML_TOK_TEXT_FRAME_X },
353 { XML_NAMESPACE_SVG, XML_Y, XML_TOK_TEXT_FRAME_Y },
354 { XML_NAMESPACE_SVG, XML_WIDTH, XML_TOK_TEXT_FRAME_WIDTH },
355 { XML_NAMESPACE_FO, XML_MIN_WIDTH, XML_TOK_TEXT_FRAME_MIN_WIDTH },
356 { XML_NAMESPACE_STYLE, XML_REL_WIDTH, XML_TOK_TEXT_FRAME_REL_WIDTH },
357 { XML_NAMESPACE_SVG, XML_HEIGHT, XML_TOK_TEXT_FRAME_HEIGHT },
358 { XML_NAMESPACE_FO, XML_MIN_HEIGHT, XML_TOK_TEXT_FRAME_MIN_HEIGHT },
359 { XML_NAMESPACE_STYLE, XML_REL_HEIGHT, XML_TOK_TEXT_FRAME_REL_HEIGHT },
360 { XML_NAMESPACE_DRAW, XML_CHAIN_NEXT_NAME, XML_TOK_TEXT_FRAME_NEXT_CHAIN_NAME },
361 { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_TEXT_FRAME_HREF },
362 { XML_NAMESPACE_DRAW, XML_NAME, XML_TOK_TEXT_FRAME_FILTER_NAME },
363 { XML_NAMESPACE_DRAW, XML_ZINDEX, XML_TOK_TEXT_FRAME_Z_INDEX },
364 { XML_NAMESPACE_SVG, XML_TRANSFORM, XML_TOK_TEXT_FRAME_TRANSFORM },
365 { XML_NAMESPACE_DRAW, XML_CLASS_ID, XML_TOK_TEXT_FRAME_CLASS_ID },
366 { XML_NAMESPACE_DRAW, XML_CODE, XML_TOK_TEXT_FRAME_CODE },
367 { XML_NAMESPACE_DRAW, XML_OBJECT, XML_TOK_TEXT_FRAME_OBJECT },
368 { XML_NAMESPACE_DRAW, XML_ARCHIVE, XML_TOK_TEXT_FRAME_ARCHIVE },
369 { XML_NAMESPACE_DRAW, XML_MAY_SCRIPT, XML_TOK_TEXT_FRAME_MAY_SCRIPT },
370 { XML_NAMESPACE_DRAW, XML_MIME_TYPE, XML_TOK_TEXT_FRAME_MIME_TYPE },
371 { XML_NAMESPACE_DRAW, XML_APPLET_NAME, XML_TOK_TEXT_FRAME_APPLET_NAME },
372 { XML_NAMESPACE_DRAW, XML_FRAME_NAME, XML_TOK_TEXT_FRAME_FRAME_NAME },
373 { XML_NAMESPACE_DRAW, XML_NOTIFY_ON_UPDATE_OF_RANGES, XML_TOK_TEXT_FRAME_NOTIFY_ON_UPDATE },
374 { XML_NAMESPACE_DRAW, XML_NOTIFY_ON_UPDATE_OF_TABLE, XML_TOK_TEXT_FRAME_NOTIFY_ON_UPDATE },
375 XML_TOKEN_MAP_END
376 };
377
378 static SvXMLTokenMapEntry aTextContourAttrTokenMap[] =
379 {
380 { XML_NAMESPACE_SVG, XML_WIDTH, XML_TOK_TEXT_CONTOUR_WIDTH },
381 { XML_NAMESPACE_SVG, XML_HEIGHT, XML_TOK_TEXT_CONTOUR_HEIGHT },
382 { XML_NAMESPACE_SVG, XML_VIEWBOX, XML_TOK_TEXT_CONTOUR_VIEWBOX },
383 { XML_NAMESPACE_SVG, XML_D, XML_TOK_TEXT_CONTOUR_D },
384 { XML_NAMESPACE_DRAW,XML_POINTS, XML_TOK_TEXT_CONTOUR_POINTS },
385 { XML_NAMESPACE_DRAW,XML_RECREATE_ON_EDIT, XML_TOK_TEXT_CONTOUR_AUTO },
386 XML_TOKEN_MAP_END
387 };
388
389 static SvXMLTokenMapEntry aTextHyperlinkAttrTokenMap[] =
390 {
391 { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_TEXT_HYPERLINK_HREF },
392 { XML_NAMESPACE_OFFICE, XML_NAME, XML_TOK_TEXT_HYPERLINK_NAME },
393 { XML_NAMESPACE_XLINK, XML_SHOW, XML_TOK_TEXT_HYPERLINK_SHOW },
394 { XML_NAMESPACE_OFFICE, XML_TARGET_FRAME_NAME, XML_TOK_TEXT_HYPERLINK_TARGET_FRAME },
395 { XML_NAMESPACE_TEXT, XML_STYLE_NAME, XML_TOK_TEXT_HYPERLINK_STYLE_NAME },
396 { XML_NAMESPACE_TEXT, XML_VISITED_STYLE_NAME, XML_TOK_TEXT_HYPERLINK_VIS_STYLE_NAME },
397 { XML_NAMESPACE_OFFICE, XML_SERVER_MAP, XML_TOK_TEXT_HYPERLINK_SERVER_MAP },
398 XML_TOKEN_MAP_END
399 };
400
401 static SvXMLTokenMapEntry aTextMasterPageElemTokenMap[] =
402 {
403 { XML_NAMESPACE_STYLE, XML_HEADER, XML_TOK_TEXT_MP_HEADER },
404 { XML_NAMESPACE_STYLE, XML_FOOTER, XML_TOK_TEXT_MP_FOOTER },
405 { XML_NAMESPACE_STYLE, XML_HEADER_LEFT, XML_TOK_TEXT_MP_HEADER_LEFT },
406 { XML_NAMESPACE_STYLE, XML_FOOTER_LEFT, XML_TOK_TEXT_MP_FOOTER_LEFT },
407 { XML_NAMESPACE_STYLE, XML_HEADER_FIRST, XML_TOK_TEXT_MP_HEADER_FIRST },
408 { XML_NAMESPACE_STYLE, XML_FOOTER_FIRST, XML_TOK_TEXT_MP_FOOTER_FIRST },
409
410 XML_TOKEN_MAP_END
411 };
412
413 static SvXMLTokenMapEntry aTextFieldAttrTokenMap[] =
414 {
415 { XML_NAMESPACE_TEXT, XML_FIXED, XML_TOK_TEXTFIELD_FIXED },
416 { XML_NAMESPACE_TEXT, XML_DESCRIPTION, XML_TOK_TEXTFIELD_DESCRIPTION },
417 { XML_NAMESPACE_TEXT, XML_HELP, XML_TOK_TEXTFIELD_HELP },
418 { XML_NAMESPACE_TEXT, XML_HINT, XML_TOK_TEXTFIELD_HINT },
419 { XML_NAMESPACE_TEXT, XML_PLACEHOLDER_TYPE,
420 XML_TOK_TEXTFIELD_PLACEHOLDER_TYPE },
421 { XML_NAMESPACE_TEXT, XML_NAME, XML_TOK_TEXTFIELD_NAME },
422 { XML_NAMESPACE_TEXT, XML_FORMULA, XML_TOK_TEXTFIELD_FORMULA },
423 { XML_NAMESPACE_STYLE, XML_NUM_FORMAT, XML_TOK_TEXTFIELD_NUM_FORMAT },
424 { XML_NAMESPACE_STYLE, XML_NUM_LETTER_SYNC,
425 XML_TOK_TEXTFIELD_NUM_LETTER_SYNC },
426 { XML_NAMESPACE_TEXT, XML_DISPLAY_FORMULA,
427 XML_TOK_TEXTFIELD_DISPLAY_FORMULA },
428 { XML_NAMESPACE_TEXT, XML_VALUE_TYPE, XML_TOK_TEXTFIELD_VALUE_TYPE }, // #i32362#: src680m48++ saves text:value-type
429 { XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_TOK_TEXTFIELD_VALUE_TYPE },
430 { XML_NAMESPACE_TEXT, XML_VALUE, XML_TOK_TEXTFIELD_VALUE },
431 { XML_NAMESPACE_OFFICE, XML_VALUE, XML_TOK_TEXTFIELD_VALUE },
432 { XML_NAMESPACE_TEXT, XML_STRING_VALUE, XML_TOK_TEXTFIELD_STRING_VALUE },
433 { XML_NAMESPACE_OFFICE, XML_STRING_VALUE, XML_TOK_TEXTFIELD_STRING_VALUE },
434 { XML_NAMESPACE_TEXT, XML_DATE_VALUE, XML_TOK_TEXTFIELD_DATE_VALUE },
435 { XML_NAMESPACE_OFFICE, XML_DATE_VALUE, XML_TOK_TEXTFIELD_DATE_VALUE },
436 { XML_NAMESPACE_TEXT, XML_TIME_VALUE, XML_TOK_TEXTFIELD_TIME_VALUE },
437 { XML_NAMESPACE_OFFICE, XML_TIME_VALUE, XML_TOK_TEXTFIELD_TIME_VALUE },
438 { XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, XML_TOK_TEXTFIELD_BOOL_VALUE},
439 { XML_NAMESPACE_OFFICE, XML_CURRENCY, XML_TOK_TEXTFIELD_CURRENCY},
440 { XML_NAMESPACE_STYLE, XML_DATA_STYLE_NAME,
441 XML_TOK_TEXTFIELD_DATA_STYLE_NAME },
442 { XML_NAMESPACE_TEXT, XML_DISPLAY_OUTLINE_LEVEL,
443 XML_TOK_TEXTFIELD_NUMBERING_LEVEL },
444 { XML_NAMESPACE_TEXT, XML_SEPARATION_CHARACTER,
445 XML_TOK_TEXTFIELD_NUMBERING_SEPARATOR },
446 { XML_NAMESPACE_TEXT, XML_DISPLAY, XML_TOK_TEXTFIELD_DISPLAY },
447 { XML_NAMESPACE_TEXT, XML_TIME_ADJUST, XML_TOK_TEXTFIELD_TIME_ADJUST },
448 { XML_NAMESPACE_TEXT, XML_DATE_ADJUST, XML_TOK_TEXTFIELD_DATE_ADJUST },
449 { XML_NAMESPACE_TEXT, XML_PAGE_ADJUST, XML_TOK_TEXTFIELD_PAGE_ADJUST },
450 { XML_NAMESPACE_TEXT, XML_SELECT_PAGE, XML_TOK_TEXTFIELD_SELECT_PAGE },
451 { XML_NAMESPACE_TEXT, XML_DATABASE_NAME, XML_TOK_TEXTFIELD_DATABASE_NAME},
452 { XML_NAMESPACE_TEXT, XML_TABLE_NAME, XML_TOK_TEXTFIELD_TABLE_NAME },
453 { XML_NAMESPACE_TEXT, XML_COLUMN_NAME, XML_TOK_TEXTFIELD_COLUMN_NAME },
454 { XML_NAMESPACE_TEXT, XML_ROW_NUMBER, XML_TOK_TEXTFIELD_ROW_NUMBER },
455 { XML_NAMESPACE_TEXT, XML_CONDITION, XML_TOK_TEXTFIELD_CONDITION },
456 { XML_NAMESPACE_TEXT, XML_STRING_VALUE_IF_TRUE,
457 XML_TOK_TEXTFIELD_STRING_VALUE_IF_TRUE },
458 { XML_NAMESPACE_TEXT, XML_STRING_VALUE_IF_FALSE,
459 XML_TOK_TEXTFIELD_STRING_VALUE_IF_FALSE },
460 { XML_NAMESPACE_TEXT, XML_EDITING_CYCLES, XML_TOK_TEXTFIELD_REVISION },
461 { XML_NAMESPACE_TEXT, XML_OUTLINE_LEVEL, XML_TOK_TEXTFIELD_OUTLINE_LEVEL},
462 { XML_NAMESPACE_TEXT, XML_ACTIVE, XML_TOK_TEXTFIELD_ACTIVE },
463 { XML_NAMESPACE_TEXT, XML_NOTE_CLASS, XML_TOK_TEXTFIELD_NOTE_CLASS },
464 { XML_NAMESPACE_TEXT, XML_REFERENCE_FORMAT,
465 XML_TOK_TEXTFIELD_REFERENCE_FORMAT },
466 { XML_NAMESPACE_TEXT, XML_REF_NAME, XML_TOK_TEXTFIELD_REF_NAME },
467 { XML_NAMESPACE_TEXT, XML_CONNECTION_NAME,
468 XML_TOK_TEXTFIELD_CONNECTION_NAME },
469 { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_TEXTFIELD_HREF },
470 { XML_NAMESPACE_OFFICE, XML_TARGET_FRAME_NAME,
471 XML_TOK_TEXTFIELD_TARGET_FRAME },
472 { XML_NAMESPACE_TEXT, XML_ANNOTATION, XML_TOK_TEXTFIELD_ANNOTATION },
473 { XML_NAMESPACE_SCRIPT, XML_LANGUAGE, XML_TOK_TEXTFIELD_LANGUAGE },
474 { XML_NAMESPACE_TEXT, XML_KIND, XML_TOK_TEXTFIELD_MEASURE_KIND },
475 { XML_NAMESPACE_TEXT, XML_IS_HIDDEN, XML_TOK_TEXTFIELD_IS_HIDDEN },
476 { XML_NAMESPACE_TEXT, XML_CURRENT_VALUE,
477 XML_TOK_TEXTFIELD_CURRENT_VALUE },
478 { XML_NAMESPACE_TEXT, XML_TABLE_TYPE, XML_TOK_TEXTFIELD_TABLE_TYPE },
479 { XML_NAMESPACE_OFFICE, XML_NAME, XML_TOK_TEXT_NAME },
480
481 XML_TOKEN_MAP_END
482 };
483
484
485 // maximum allowed length of combined characters field
486 #define MAX_COMBINED_CHARACTERS 6
487
488 struct SAL_DLLPRIVATE XMLTextImportHelper::Impl
489 : private ::boost::noncopyable
490 {
491 boost::scoped_ptr<SvXMLTokenMap> m_pTextElemTokenMap;
492 boost::scoped_ptr<SvXMLTokenMap> m_pTextPElemTokenMap;
493 boost::scoped_ptr<SvXMLTokenMap> m_pTextPAttrTokenMap;
494 boost::scoped_ptr<SvXMLTokenMap> m_pTextFieldAttrTokenMap;
495 boost::scoped_ptr<SvXMLTokenMap> m_pTextNumberedParagraphAttrTokenMap;
496 boost::scoped_ptr<SvXMLTokenMap> m_pTextListBlockAttrTokenMap;
497 boost::scoped_ptr<SvXMLTokenMap> m_pTextListBlockElemTokenMap;
498 boost::scoped_ptr<SvXMLTokenMap> m_pTextFrameAttrTokenMap;
499 boost::scoped_ptr<SvXMLTokenMap> m_pTextContourAttrTokenMap;
500 boost::scoped_ptr<SvXMLTokenMap> m_pTextHyperlinkAttrTokenMap;
501 boost::scoped_ptr<SvXMLTokenMap> m_pTextMasterPageElemTokenMap;
502 boost::scoped_ptr< std::vector<OUString> > m_pPrevFrmNames;
503 boost::scoped_ptr< std::vector<OUString> > m_pNextFrmNames;
504 boost::scoped_ptr<XMLTextListsHelper> m_pTextListsHelper;
505
506 SvXMLImportContextRef m_xAutoStyles;
507 SvXMLImportContextRef m_xFontDecls;
508
509 UniReference< SvXMLImportPropertyMapper > m_xParaImpPrMap;
510 UniReference< SvXMLImportPropertyMapper > m_xTextImpPrMap;
511 UniReference< SvXMLImportPropertyMapper > m_xFrameImpPrMap;
512 UniReference< SvXMLImportPropertyMapper > m_xSectionImpPrMap;
513 UniReference< SvXMLImportPropertyMapper > m_xRubyImpPrMap;
514
515 boost::scoped_ptr<SvI18NMap> m_pRenameMap;
516
517 /* Change and extend data structure:
518 - data structure contains candidates of paragraph styles, which
519 will be assigned to the outline style
520 - data structure contains more than one candidate for each list level
521 of the outline style (#i69629#)
522 */
523 ::boost::scoped_array< ::std::vector< OUString > >
524 m_pOutlineStylesCandidates;
525
526 // start range, xml:id, RDFa stuff
527 typedef ::boost::tuple<
528 uno::Reference<text::XTextRange>, OUString,
529 ::boost::shared_ptr< ::xmloff::ParsedRDFaAttributes > >
530 BookmarkMapEntry_t;
531 /// start ranges for open bookmarks
532 ::std::map< OUString, BookmarkMapEntry_t,
533 ::comphelper::UStringLess> m_BookmarkStartRanges;
534
535 typedef ::std::vector< OUString > BookmarkVector_t;
536 BookmarkVector_t m_BookmarkVector;
537
538 /// name of the last 'open' redline that started between paragraphs
539 OUString m_sOpenRedlineIdentifier;
540
541 uno::Reference<text::XText> m_xText;
542 uno::Reference<text::XTextCursor> m_xCursor;
543 uno::Reference<text::XTextRange> m_xCursorAsRange;
544 uno::Reference<container::XNameContainer> m_xParaStyles;
545 uno::Reference<container::XNameContainer> m_xTextStyles;
546 uno::Reference<container::XNameContainer> m_xNumStyles;
547 uno::Reference<container::XNameContainer> m_xFrameStyles;
548 uno::Reference<container::XNameContainer> m_xPageStyles;
549 uno::Reference<container::XIndexReplace> m_xChapterNumbering;
550 uno::Reference<container::XNameAccess> m_xTextFrames;
551 uno::Reference<container::XNameAccess> m_xGraphics;
552 uno::Reference<container::XNameAccess> m_xObjects;
553 uno::Reference<lang::XMultiServiceFactory> m_xServiceFactory;
554
555 SvXMLImport & m_rSvXMLImport;
556
557 bool m_bInsertMode : 1;
558 bool m_bStylesOnlyMode : 1;
559 bool m_bBlockMode : 1;
560 bool m_bProgress : 1;
561 bool m_bOrganizerMode : 1;
562 bool m_bBodyContentStarted : 1;
563
564 // #107848#
565 /// Are we inside a <text:deletion> element (deleted redline section)
566 bool m_bInsideDeleteContext : 1;
567
568 typedef ::std::pair< OUString, OUString> field_name_type_t;
569 typedef ::std::pair< OUString, OUString > field_param_t;
570 typedef ::std::vector< field_param_t > field_params_t;
571 typedef ::std::pair< field_name_type_t, field_params_t > field_stack_item_t;
572 typedef ::std::stack< field_stack_item_t > field_stack_t;
573
574 field_stack_t m_FieldStack;
575
576 OUString m_sCellParaStyleDefault;
577
578 Impl( uno::Reference<frame::XModel> const& rModel,
579 SvXMLImport & rImport,
580 bool const bInsertMode, bool const bStylesOnlyMode,
581 bool const bProgress, bool const bBlockMode,
582 bool const bOrganizerMode)
583 : m_pTextElemTokenMap( 0 )
584 , m_pTextPElemTokenMap( 0 )
585 , m_pTextPAttrTokenMap( 0 )
586 , m_pTextFieldAttrTokenMap( 0 )
587 , m_pTextNumberedParagraphAttrTokenMap( 0 )
588 , m_pTextListBlockAttrTokenMap( 0 )
589 , m_pTextListBlockElemTokenMap( 0 )
590 , m_pTextFrameAttrTokenMap( 0 )
591 , m_pTextContourAttrTokenMap( 0 )
592 , m_pTextHyperlinkAttrTokenMap( 0 )
593 , m_pTextMasterPageElemTokenMap( 0 )
594 , m_pPrevFrmNames( 0 )
595 , m_pNextFrmNames( 0 )
596 , m_pTextListsHelper( new XMLTextListsHelper() )
597 , m_pRenameMap( 0 )
598 // XML import: reconstrution of assignment of paragraph style to outline levels (#i69629#)
599 , m_pOutlineStylesCandidates( 0 )
600 , m_xServiceFactory( rModel, UNO_QUERY )
601 , m_rSvXMLImport( rImport )
602 , m_bInsertMode( bInsertMode )
603 , m_bStylesOnlyMode( bStylesOnlyMode )
604 , m_bBlockMode( bBlockMode )
605 , m_bProgress( bProgress )
606 , m_bOrganizerMode( bOrganizerMode )
607 , m_bBodyContentStarted( true )
608 , m_bInsideDeleteContext( false )
609 {
610 }
611
612 void InitOutlineStylesCandidates()
613 {
614 if (!m_pOutlineStylesCandidates)
615 {
616 size_t const size(m_xChapterNumbering->getCount());
617 m_pOutlineStylesCandidates.reset(
618 new ::std::vector< OUString >[size] );
619 }
620 }
621
622 };
623
624
625 uno::Reference< text::XText > & XMLTextImportHelper::GetText()
626 {
627 return m_pImpl->m_xText;
628 }
629
630 uno::Reference< text::XTextCursor > & XMLTextImportHelper::GetCursor()
631 {
632 return m_pImpl->m_xCursor;
633 }
634
635 uno::Reference< text::XTextRange > & XMLTextImportHelper::GetCursorAsRange()
636 {
637 return m_pImpl->m_xCursorAsRange;
638 }
639
640 bool XMLTextImportHelper::IsInsertMode() const
641 {
642 return m_pImpl->m_bInsertMode;
643 }
644
645 bool XMLTextImportHelper::IsStylesOnlyMode() const
646 {
647 return m_pImpl->m_bStylesOnlyMode;
648 }
649
650 bool XMLTextImportHelper::IsBlockMode() const
651 {
652 return m_pImpl->m_bBlockMode;
653 }
654
655 bool XMLTextImportHelper::IsOrganizerMode() const
656 {
657 return m_pImpl->m_bOrganizerMode;
658 }
659
660 bool XMLTextImportHelper::IsProgress() const
661 {
662 return m_pImpl->m_bProgress;
663 }
664
665 uno::Reference<container::XNameContainer> const&
666 XMLTextImportHelper::GetParaStyles() const
667 {
668 return m_pImpl->m_xParaStyles;
669 }
670
671 uno::Reference<container::XNameContainer> const&
672 XMLTextImportHelper::GetTextStyles() const
673 {
674 return m_pImpl->m_xTextStyles;
675 }
676
677 uno::Reference<container::XNameContainer> const&
678 XMLTextImportHelper::GetNumberingStyles() const
679 {
680 return m_pImpl->m_xNumStyles;
681 }
682
683 uno::Reference<container::XNameContainer> const&
684 XMLTextImportHelper::GetFrameStyles() const
685 {
686 return m_pImpl->m_xFrameStyles;
687 }
688
689 uno::Reference<container::XNameContainer> const&
690 XMLTextImportHelper::GetPageStyles() const
691 {
692 return m_pImpl->m_xPageStyles;
693 }
694
695 uno::Reference<container::XIndexReplace> const&
696 XMLTextImportHelper::GetChapterNumbering() const
697 {
698 return m_pImpl->m_xChapterNumbering;
699 }
700
701 UniReference< SvXMLImportPropertyMapper > const&
702 XMLTextImportHelper::GetParaImportPropertySetMapper() const
703 {
704 return m_pImpl->m_xParaImpPrMap;
705 }
706
707 UniReference< SvXMLImportPropertyMapper > const&
708 XMLTextImportHelper::GetTextImportPropertySetMapper() const
709 {
710 return m_pImpl->m_xTextImpPrMap;
711 }
712
713 UniReference< SvXMLImportPropertyMapper > const&
714 XMLTextImportHelper::GetSectionImportPropertySetMapper() const
715 {
716 return m_pImpl->m_xSectionImpPrMap;
717 }
718
719 UniReference< SvXMLImportPropertyMapper > const&
720 XMLTextImportHelper::GetRubyImportPropertySetMapper() const
721 {
722 return m_pImpl->m_xRubyImpPrMap;
723 }
724
725 void XMLTextImportHelper::SetInsideDeleteContext(bool const bNew)
726 {
727 m_pImpl->m_bInsideDeleteContext = bNew;
728 }
729
730 bool XMLTextImportHelper::IsInsideDeleteContext() const
731 {
732 return m_pImpl->m_bInsideDeleteContext;
733 }
734
735 SvXMLImport & XMLTextImportHelper::GetXMLImport()
736 {
737 return m_pImpl->m_rSvXMLImport;
738 }
739
740 XMLTextListsHelper & XMLTextImportHelper::GetTextListHelper()
741 {
742 return *m_pImpl->m_pTextListsHelper;
743 }
744
745 const SvXMLTokenMap& XMLTextImportHelper::GetTextElemTokenMap()
746 {
747 if (!m_pImpl->m_pTextElemTokenMap.get())
748 {
749 m_pImpl->m_pTextElemTokenMap.reset(
750 new SvXMLTokenMap( aTextElemTokenMap ));
751 }
752 return *m_pImpl->m_pTextElemTokenMap;
753 }
754
755 const SvXMLTokenMap& XMLTextImportHelper::GetTextPElemTokenMap()
756 {
757 if (!m_pImpl->m_pTextPElemTokenMap.get())
758 {
759 m_pImpl->m_pTextPElemTokenMap.reset(
760 new SvXMLTokenMap( aTextPElemTokenMap ));
761 }
762 return *m_pImpl->m_pTextPElemTokenMap;
763 }
764
765 const SvXMLTokenMap& XMLTextImportHelper::GetTextPAttrTokenMap()
766 {
767 if (!m_pImpl->m_pTextPAttrTokenMap.get())
768 {
769 m_pImpl->m_pTextPAttrTokenMap.reset(
770 new SvXMLTokenMap( aTextPAttrTokenMap ));
771 }
772 return *m_pImpl->m_pTextPAttrTokenMap;
773 }
774
775 const SvXMLTokenMap& XMLTextImportHelper::GetTextFrameAttrTokenMap()
776 {
777 if (!m_pImpl->m_pTextFrameAttrTokenMap.get())
778 {
779 m_pImpl->m_pTextFrameAttrTokenMap.reset(
780 new SvXMLTokenMap( aTextFrameAttrTokenMap ));
781 }
782 return *m_pImpl->m_pTextFrameAttrTokenMap;
783 }
784
785 const SvXMLTokenMap& XMLTextImportHelper::GetTextContourAttrTokenMap()
786 {
787 if (!m_pImpl->m_pTextContourAttrTokenMap.get())
788 {
789 m_pImpl->m_pTextContourAttrTokenMap.reset(
790 new SvXMLTokenMap( aTextContourAttrTokenMap ));
791 }
792 return *m_pImpl->m_pTextContourAttrTokenMap;
793 }
794
795 const SvXMLTokenMap& XMLTextImportHelper::GetTextHyperlinkAttrTokenMap()
796 {
797 if (!m_pImpl->m_pTextHyperlinkAttrTokenMap.get())
798 {
799 m_pImpl->m_pTextHyperlinkAttrTokenMap.reset(
800 new SvXMLTokenMap( aTextHyperlinkAttrTokenMap ));
801 }
802 return *m_pImpl->m_pTextHyperlinkAttrTokenMap;
803 }
804
805 const SvXMLTokenMap& XMLTextImportHelper::GetTextMasterPageElemTokenMap()
806 {
807 if (!m_pImpl->m_pTextMasterPageElemTokenMap.get())
808 {
809 m_pImpl->m_pTextMasterPageElemTokenMap.reset(
810 new SvXMLTokenMap( aTextMasterPageElemTokenMap ));
811 }
812 return *m_pImpl->m_pTextMasterPageElemTokenMap;
813 }
814
815 const SvXMLTokenMap& XMLTextImportHelper::GetTextFieldAttrTokenMap()
816 {
817 if (!m_pImpl->m_pTextFieldAttrTokenMap.get())
818 {
819 m_pImpl->m_pTextFieldAttrTokenMap.reset(
820 new SvXMLTokenMap( aTextFieldAttrTokenMap ));
821 }
822 return *m_pImpl->m_pTextFieldAttrTokenMap;
823 }
824
825
826 namespace
827 {
828 class FieldParamImporter
829 {
830 public:
831 typedef pair<OUString,OUString> field_param_t;
832 typedef vector<field_param_t> field_params_t;
833 FieldParamImporter(const field_params_t* const pInParams, Reference<XNameContainer> xOutParams)
834 : m_pInParams(pInParams)
835 , m_xOutParams(xOutParams)
836 { };
837 void Import();
838
839 private:
840 const field_params_t* const m_pInParams;
841 Reference<XNameContainer> m_xOutParams;
842 };
843
844 void FieldParamImporter::Import()
845 {
846 ::std::vector<OUString> vListEntries;
847 ::std::map<OUString, Any> vOutParams;
848 for(field_params_t::const_iterator pCurrent = m_pInParams->begin();
849 pCurrent != m_pInParams->end();
850 ++pCurrent)
851 {
852 if(pCurrent->first.equalsAscii(ODF_FORMDROPDOWN_RESULT))
853 {
854 // sal_Int32
855 vOutParams[pCurrent->first] = makeAny(pCurrent->second.toInt32());
856 }
857 else if(pCurrent->first.equalsAscii(ODF_FORMCHECKBOX_RESULT))
858 {
859 // bool
860 vOutParams[pCurrent->first] = makeAny(pCurrent->second.toBoolean());
861 }
862 else if(pCurrent->first.equalsAscii(ODF_FORMDROPDOWN_LISTENTRY))
863 {
864 // sequence
865 vListEntries.push_back(pCurrent->second);
866 }
867 else
868 vOutParams[pCurrent->first] = makeAny(pCurrent->second);
869 }
870 if(!vListEntries.empty())
871 {
872 Sequence<OUString> vListEntriesSeq(vListEntries.size());
873 copy(vListEntries.begin(), vListEntries.end(), ::comphelper::stl_begin(vListEntriesSeq));
874 vOutParams[OUString(ODF_FORMDROPDOWN_LISTENTRY)] = makeAny(vListEntriesSeq);
875 }
876 for(::std::map<OUString, Any>::const_iterator pCurrent = vOutParams.begin();
877 pCurrent != vOutParams.end();
878 ++pCurrent)
879 {
880 try
881 {
882 m_xOutParams->insertByName(pCurrent->first, pCurrent->second);
883 }
884 catch(const ElementExistException&)
885 {
886 }
887 }
888 }
889 }
890
891 XMLTextImportHelper::XMLTextImportHelper(
892 uno::Reference<frame::XModel> const& rModel,
893 SvXMLImport& rImport,
894 bool const bInsertMode, bool const bStylesOnlyMode,
895 bool const bProgress, bool const bBlockMode,
896 bool const bOrganizerMode)
897 : m_pImpl( new Impl(rModel, rImport, bInsertMode, bStylesOnlyMode,
898 bProgress, bBlockMode, bOrganizerMode) )
899 , m_pBackpatcherImpl( MakeBackpatcherImpl() )
900 {
901 static OUString s_PropNameDefaultListId( "DefaultListId");
902
903 Reference< XChapterNumberingSupplier > xCNSupplier( rModel, UNO_QUERY );
904
905 if( xCNSupplier.is() )
906 {
907 m_pImpl->m_xChapterNumbering = xCNSupplier->getChapterNumberingRules();
908 if (m_pImpl->m_xChapterNumbering.is())
909 {
910 Reference< XPropertySet > const xNumRuleProps(
911 m_pImpl->m_xChapterNumbering, UNO_QUERY);
912 if ( xNumRuleProps.is() )
913 {
914 Reference< XPropertySetInfo > xNumRulePropSetInfo(
915 xNumRuleProps->getPropertySetInfo());
916 if (xNumRulePropSetInfo.is() &&
917 xNumRulePropSetInfo->hasPropertyByName(
918 s_PropNameDefaultListId))
919 {
920 OUString sListId;
921 xNumRuleProps->getPropertyValue(s_PropNameDefaultListId)
922 >>= sListId;
923 DBG_ASSERT( !sListId.isEmpty(),
924 "no default list id found at chapter numbering rules instance. Serious defect -> please inform OD." );
925 if ( !sListId.isEmpty() )
926 {
927 Reference< XNamed > const xChapterNumNamed(
928 m_pImpl->m_xChapterNumbering, UNO_QUERY);
929 if ( xChapterNumNamed.is() )
930 {
931 m_pImpl->m_pTextListsHelper->KeepListAsProcessed(
932 sListId,
933 xChapterNumNamed->getName(),
934 OUString() );
935 }
936 }
937 }
938 }
939 }
940 }
941
942 Reference< XStyleFamiliesSupplier > xFamiliesSupp( rModel, UNO_QUERY );
943 // DBG_ASSERT( xFamiliesSupp.is(), "no chapter numbering supplier" ); for clipboard there may be documents without styles
944
945 if( xFamiliesSupp.is() )
946 {
947 Reference< XNameAccess > xFamilies(xFamiliesSupp->getStyleFamilies());
948
949 const OUString aParaStyles("ParagraphStyles");
950 if( xFamilies->hasByName( aParaStyles ) )
951 {
952 m_pImpl->m_xParaStyles.set(xFamilies->getByName(aParaStyles),
953 UNO_QUERY);
954 }
955
956 const OUString aCharStyles("CharacterStyles");
957 if( xFamilies->hasByName( aCharStyles ) )
958 {
959 m_pImpl->m_xTextStyles.set(xFamilies->getByName(aCharStyles),
960 UNO_QUERY);
961 }
962
963 const OUString aNumStyles("NumberingStyles");
964 if( xFamilies->hasByName( aNumStyles ) )
965 {
966 m_pImpl->m_xNumStyles.set(xFamilies->getByName(aNumStyles),
967 UNO_QUERY);
968 }
969
970 const OUString aFrameStyles("FrameStyles");
971 if( xFamilies->hasByName( aFrameStyles ) )
972 {
973 m_pImpl->m_xFrameStyles.set(xFamilies->getByName(aFrameStyles),
974 UNO_QUERY);
975 }
976
977 const OUString aPageStyles("PageStyles");
978 if( xFamilies->hasByName( aPageStyles ) )
979 {
980 m_pImpl->m_xPageStyles.set(xFamilies->getByName(aPageStyles),
981 UNO_QUERY);
982 }
983 }
984
985 Reference < XTextFramesSupplier > xTFS( rModel, UNO_QUERY );
986 if( xTFS.is() )
987 {
988 m_pImpl->m_xTextFrames.set(xTFS->getTextFrames());
989 }
990
991 Reference < XTextGraphicObjectsSupplier > xTGOS( rModel, UNO_QUERY );
992 if( xTGOS.is() )
993 {
994 m_pImpl->m_xGraphics.set(xTGOS->getGraphicObjects());
995 }
996
997 Reference < XTextEmbeddedObjectsSupplier > xTEOS( rModel, UNO_QUERY );
998 if( xTEOS.is() )
999 {
1000 m_pImpl->m_xObjects.set(xTEOS->getEmbeddedObjects());
1001 }
1002
1003 XMLPropertySetMapper *pPropMapper =
1004 new XMLTextPropertySetMapper( TEXT_PROP_MAP_PARA, false );
1005 m_pImpl->m_xParaImpPrMap =
1006 new XMLTextImportPropertyMapper( pPropMapper, rImport );
1007
1008 pPropMapper = new XMLTextPropertySetMapper( TEXT_PROP_MAP_TEXT, false );
1009 m_pImpl->m_xTextImpPrMap =
1010 new XMLTextImportPropertyMapper( pPropMapper, rImport );
1011
1012 pPropMapper = new XMLTextPropertySetMapper( TEXT_PROP_MAP_FRAME, false );
1013 m_pImpl->m_xFrameImpPrMap =
1014 new XMLTextImportPropertyMapper( pPropMapper, rImport );
1015
1016 pPropMapper = new XMLTextPropertySetMapper( TEXT_PROP_MAP_SECTION, false );
1017 m_pImpl->m_xSectionImpPrMap =
1018 new XMLTextImportPropertyMapper( pPropMapper, rImport );
1019
1020 pPropMapper = new XMLTextPropertySetMapper( TEXT_PROP_MAP_RUBY, false );
1021 m_pImpl->m_xRubyImpPrMap =
1022 new SvXMLImportPropertyMapper( pPropMapper, rImport );
1023 }
1024
1025 XMLTextImportHelper::~XMLTextImportHelper()
1026 {
1027 }
1028
1029 SvXMLImportPropertyMapper *XMLTextImportHelper::CreateShapeExtPropMapper(SvXMLImport& rImport)
1030 {
1031 XMLPropertySetMapper *pPropMapper =
1032 new XMLTextPropertySetMapper( TEXT_PROP_MAP_FRAME, false );
1033 return new XMLTextImportPropertyMapper( pPropMapper, rImport );
1034 }
1035
1036 SvXMLImportPropertyMapper *XMLTextImportHelper::CreateParaExtPropMapper(SvXMLImport& rImport)
1037 {
1038 XMLPropertySetMapper *pPropMapper =
1039 new XMLTextPropertySetMapper( TEXT_PROP_MAP_SHAPE_PARA, false );
1040 return new XMLTextImportPropertyMapper( pPropMapper, rImport );
1041 }
1042
1043 SvXMLImportPropertyMapper *XMLTextImportHelper::CreateParaDefaultExtPropMapper(SvXMLImport& rImport)
1044 {
1045 XMLPropertySetMapper* pPropMapper =
1046 new XMLTextPropertySetMapper( TEXT_PROP_MAP_SHAPE_PARA, false );
1047 SvXMLImportPropertyMapper* pImportMapper = new XMLTextImportPropertyMapper( pPropMapper, rImport );
1048
1049 pPropMapper =
1050 new XMLTextPropertySetMapper( TEXT_PROP_MAP_TEXT_ADDITIONAL_DEFAULTS, false );
1051 pImportMapper->ChainImportMapper( new XMLTextImportPropertyMapper( pPropMapper, rImport ) );
1052
1053 return pImportMapper;
1054 }
1055
1056 SvXMLImportPropertyMapper*
1057 XMLTextImportHelper::CreateTableDefaultExtPropMapper(
1058 SvXMLImport& rImport )
1059 {
1060 XMLPropertySetMapper *pPropMapper =
1061 new XMLTextPropertySetMapper( TEXT_PROP_MAP_TABLE_DEFAULTS, false );
1062 return new SvXMLImportPropertyMapper( pPropMapper, rImport );
1063 }
1064
1065 SvXMLImportPropertyMapper*
1066 XMLTextImportHelper::CreateTableRowDefaultExtPropMapper(
1067 SvXMLImport& rImport )
1068 {
1069 XMLPropertySetMapper *pPropMapper =
1070 new XMLTextPropertySetMapper( TEXT_PROP_MAP_TABLE_ROW_DEFAULTS, false );
1071 return new SvXMLImportPropertyMapper( pPropMapper, rImport );
1072 }
1073
1074 void XMLTextImportHelper::SetCursor( const Reference < XTextCursor > & rCursor )
1075 {
1076 m_pImpl->m_xCursor.set(rCursor);
1077 m_pImpl->m_xText.set(rCursor->getText());
1078 m_pImpl->m_xCursorAsRange.set( rCursor, UNO_QUERY );
1079 }
1080
1081 void XMLTextImportHelper::ResetCursor()
1082 {
1083 m_pImpl->m_xCursor.set(0);
1084 m_pImpl->m_xText.set(0);
1085 m_pImpl->m_xCursorAsRange.set(0);
1086 }
1087
1088
1089 sal_Bool XMLTextImportHelper::HasFrameByName( const OUString& rName ) const
1090 {
1091 return (m_pImpl->m_xTextFrames.is() &&
1092 m_pImpl->m_xTextFrames->hasByName(rName))
1093 || (m_pImpl->m_xGraphics.is() &&
1094 m_pImpl->m_xGraphics->hasByName(rName))
1095 || (m_pImpl->m_xObjects.is() &&
1096 m_pImpl->m_xObjects->hasByName(rName));
1097 }
1098
1099 void XMLTextImportHelper::InsertString( const OUString& rChars )
1100 {
1101 DBG_ASSERT(m_pImpl->m_xText.is(), "no text");
1102 DBG_ASSERT(m_pImpl->m_xCursorAsRange.is(), "no range");
1103 if (m_pImpl->m_xText.is())
1104 {
1105 m_pImpl->m_xText->insertString(m_pImpl->m_xCursorAsRange,
1106 rChars, sal_False);
1107 }
1108 }
1109
1110 void XMLTextImportHelper::InsertString( const OUString& rChars,
1111 sal_Bool& rIgnoreLeadingSpace )
1112 {
1113 DBG_ASSERT(m_pImpl->m_xText.is(), "no text");
1114 DBG_ASSERT(m_pImpl->m_xCursorAsRange.is(), "no range");
1115 if (m_pImpl->m_xText.is())
1116 {
1117 sal_Int32 nLen = rChars.getLength();
1118 OUStringBuffer sChars( nLen );
1119
1120 for( sal_Int32 i=0; i < nLen; i++ )
1121 {
1122 sal_Unicode c = rChars[i];
1123 switch( c )
1124 {
1125 case 0x20:
1126 case 0x09:
1127 case 0x0a:
1128 case 0x0d:
1129 if( !rIgnoreLeadingSpace )
1130 sChars.append( (sal_Unicode)0x20 );
1131 rIgnoreLeadingSpace = sal_True;
1132 break;
1133 default:
1134 rIgnoreLeadingSpace = sal_False;
1135 sChars.append( c );
1136 break;
1137 }
1138 }
1139 m_pImpl->m_xText->insertString(m_pImpl->m_xCursorAsRange,
1140 sChars.makeStringAndClear(), sal_False);
1141 }
1142 }
1143
1144 void XMLTextImportHelper::InsertControlCharacter( sal_Int16 nControl )
1145 {
1146 DBG_ASSERT(m_pImpl->m_xText.is(), "no text");
1147 DBG_ASSERT(m_pImpl->m_xCursorAsRange.is(), "no range");
1148 if (m_pImpl->m_xText.is())
1149 {
1150 m_pImpl->m_xText->insertControlCharacter(
1151 m_pImpl->m_xCursorAsRange, nControl, sal_False);
1152 }
1153 }
1154
1155 void XMLTextImportHelper::InsertTextContent(
1156 Reference < XTextContent > & xContent )
1157 {
1158 DBG_ASSERT(m_pImpl->m_xText.is(), "no text");
1159 DBG_ASSERT(m_pImpl->m_xCursorAsRange.is(), "no range");
1160 if (m_pImpl->m_xText.is())
1161 {
1162 try {
1163 m_pImpl->m_xText->insertTextContent( m_pImpl->m_xCursorAsRange, xContent, sal_False);
1164 } catch ( const lang::IllegalArgumentException & )
1165 {
1166 SAL_WARN( "xmloff", "Cannot import part of the text - probably an image in the text frame?" );
1167 }
1168 }
1169 }
1170
1171 void XMLTextImportHelper::DeleteParagraph()
1172 {
1173 DBG_ASSERT(m_pImpl->m_xText.is(), "no text");
1174 DBG_ASSERT(m_pImpl->m_xCursor.is(), "no cursor");
1175 DBG_ASSERT(m_pImpl->m_xCursorAsRange.is(), "no range");
1176
1177 sal_Bool bDelete = sal_True;
1178 Reference < XEnumerationAccess > const xEnumAccess(
1179 m_pImpl->m_xCursor, UNO_QUERY);
1180 if( xEnumAccess.is() )
1181 {
1182 Reference < XEnumeration > xEnum(xEnumAccess->createEnumeration());
1183 DBG_ASSERT( xEnum->hasMoreElements(), "empty text enumeration" );
1184 if( xEnum->hasMoreElements() )
1185 {
1186 Reference < XComponent > xComp( xEnum->nextElement(), UNO_QUERY );
1187 DBG_ASSERT( xComp.is(), "got no component" );
1188 if( xComp.is() )
1189 {
1190 xComp->dispose();
1191 bDelete = sal_False;
1192 }
1193 }
1194 }
1195 if( bDelete )
1196 {
1197 if (m_pImpl->m_xCursor->goLeft( 1, sal_True ))
1198 {
1199 OUString sEmpty;
1200 m_pImpl->m_xText->insertString(m_pImpl->m_xCursorAsRange,
1201 sEmpty, sal_True);
1202 }
1203 }
1204 }
1205
1206 OUString XMLTextImportHelper::ConvertStarFonts( const OUString& rChars,
1207 const OUString& rStyleName,
1208 sal_uInt8& rFlags,
1209 sal_Bool bPara,
1210 SvXMLImport& rImport ) const
1211 {
1212 OUStringBuffer sChars( rChars );
1213 sal_Bool bConverted = sal_False;
1214 for( sal_Int32 j=0; j<rChars.getLength(); j++ )
1215 {
1216 sal_Unicode c = rChars[j];
1217 if( c >= 0xf000 && c <= 0xf0ff )
1218 {
1219 if( (rFlags & CONV_STAR_FONT_FLAGS_VALID) == 0 )
1220 {
1221 XMLTextStyleContext *pStyle = 0;
1222 sal_uInt16 nFamily = bPara ? XML_STYLE_FAMILY_TEXT_PARAGRAPH
1223 : XML_STYLE_FAMILY_TEXT_TEXT;
1224 if (!rStyleName.isEmpty() && m_pImpl->m_xAutoStyles.Is())
1225 {
1226 const SvXMLStyleContext* pTempStyle =
1227 ((SvXMLStylesContext *)&m_pImpl->m_xAutoStyles)->
1228 FindStyleChildContext( nFamily, rStyleName,
1229 sal_True );
1230 pStyle = PTR_CAST( XMLTextStyleContext,pTempStyle);
1231 }
1232
1233 if( pStyle )
1234 {
1235 sal_Int32 nCount = pStyle->_GetProperties().size();
1236 if( nCount )
1237 {
1238 UniReference < SvXMLImportPropertyMapper > xImpPrMap =
1239 ((SvXMLStylesContext *)&m_pImpl->m_xAutoStyles)
1240 ->GetImportPropertyMapper(nFamily);
1241 if( xImpPrMap.is() )
1242 {
1243 UniReference<XMLPropertySetMapper> rPropMapper =
1244 xImpPrMap->getPropertySetMapper();
1245 for( sal_Int32 i=0; i < nCount; i++ )
1246 {
1247 const XMLPropertyState& rProp = pStyle->_GetProperties()[i];
1248 sal_Int32 nIdx = rProp.mnIndex;
1249 sal_uInt32 nContextId = rPropMapper->GetEntryContextId(nIdx);
1250 if( CTF_FONTFAMILYNAME == nContextId )
1251 {
1252 rFlags &= ~(CONV_FROM_STAR_BATS|CONV_FROM_STAR_MATH);
1253 OUString sFontName;
1254 rProp.maValue >>= sFontName;
1255 OUString sStarBats( "StarBats" );
1256 OUString sStarMath( "StarMath" );
1257 if( sFontName.equalsIgnoreAsciiCase( sStarBats ) )
1258 rFlags |= CONV_FROM_STAR_BATS;
1259 else if( sFontName.equalsIgnoreAsciiCase( sStarMath ) )
1260 rFlags |= CONV_FROM_STAR_MATH;
1261 break;
1262 }
1263 }
1264 }
1265 }
1266
1267 }
1268
1269 rFlags |= CONV_STAR_FONT_FLAGS_VALID;
1270 }
1271 if( (rFlags & CONV_FROM_STAR_BATS ) != 0 )
1272 {
1273 sChars[j] = rImport.ConvStarBatsCharToStarSymbol( c );
1274 bConverted = sal_True;
1275 }
1276 else if( (rFlags & CONV_FROM_STAR_MATH ) != 0 )
1277 {
1278 sChars[j] = rImport.ConvStarMathCharToStarSymbol( c );
1279 bConverted = sal_True;
1280 }
1281 }
1282 }
1283
1284 return bConverted ? sChars.makeStringAndClear() : rChars;
1285 }
1286
1287 /* Helper method to determine, if a paragraph style has a list style (inclusive
1288 an empty one) inherits a list style (inclusive an empty one) from one of its parents (#i69629#)
1289 */
1290 /* Apply special case, that found list style equals the chapter numbering, also
1291 to the found list styles of the parent styles. (#i73973#)
1292 */
1293 static sal_Bool lcl_HasListStyle( OUString sStyleName,
1294 const Reference < XNameContainer >& xParaStyles,
1295 SvXMLImport& rImport,
1296 const OUString& sNumberingStyleName,
1297 const OUString& sOutlineStyleName )
1298 {
1299 sal_Bool bRet( sal_False );
1300
1301 if ( !xParaStyles->hasByName( sStyleName ) )
1302 {
1303 // error case
1304 return sal_True;
1305 }
1306
1307 Reference< XPropertyState > xPropState( xParaStyles->getByName( sStyleName ),
1308 UNO_QUERY );
1309 if ( !xPropState.is() )
1310 {
1311 // error case
1312 return sal_False;
1313 }
1314
1315 if ( xPropState->getPropertyState( sNumberingStyleName ) == PropertyState_DIRECT_VALUE )
1316 {
1317 // list style found
1318 bRet = sal_True;
1319 // special case: the set list style equals the chapter numbering
1320 Reference< XPropertySet > xPropSet( xPropState, UNO_QUERY );
1321 if ( xPropSet.is() )
1322 {
1323 OUString sListStyle;
1324 xPropSet->getPropertyValue( sNumberingStyleName ) >>= sListStyle;
1325 if ( !sListStyle.isEmpty() &&
1326 sListStyle == sOutlineStyleName )
1327 {
1328 bRet = sal_False;
1329 }
1330 }
1331 }
1332 else
1333 {
1334 // Tools.Outline settings lost on Save (#i77708#)
1335 sal_Int32 nUPD( 0 );
1336 sal_Int32 nBuild( 0 );
1337 // Don't use UPD for versioning: xmloff/source/text/txtstyli.cxx and txtimp.cxx (#i86058#)
1338 const bool bBuildIdFound = rImport.getBuildIds( nUPD, nBuild );
1339 // search list style at parent
1340 Reference<XStyle> xStyle( xPropState, UNO_QUERY );
1341 while ( xStyle.is() )
1342 {
1343 OUString aParentStyle( xStyle->getParentStyle() );
1344 if ( !aParentStyle.isEmpty() )
1345 {
1346 aParentStyle =
1347 rImport.GetStyleDisplayName( XML_STYLE_FAMILY_TEXT_PARAGRAPH,
1348 aParentStyle );
1349 }
1350 if ( aParentStyle.isEmpty() || !xParaStyles->hasByName( aParentStyle ) )
1351 {
1352 // no list style found
1353 break;
1354 }
1355 else
1356 {
1357 xPropState = Reference< XPropertyState >(
1358 xParaStyles->getByName( aParentStyle ),
1359 UNO_QUERY );
1360 if ( !xPropState.is() )
1361 {
1362 // error case
1363 return sal_True;
1364 }
1365 if ( xPropState->getPropertyState( sNumberingStyleName ) == PropertyState_DIRECT_VALUE )
1366 {
1367 // list style found
1368 bRet = sal_True;
1369 // Special case: the found list style equals the chapter numbering (#i73973#)
1370 Reference< XPropertySet > xPropSet( xPropState, UNO_QUERY );
1371 if ( xPropSet.is() )
1372 {
1373 OUString sListStyle;
1374 xPropSet->getPropertyValue( sNumberingStyleName ) >>= sListStyle;
1375 if ( !sListStyle.isEmpty() &&
1376 sListStyle == sOutlineStyleName )
1377 {
1378 bRet = sal_False;
1379 }
1380 // Special handling for text documents from OOo version prior OOo 2.4 (#i77708#)
1381 /* Check explicitly on certain versions and on import of
1382 text documents in OpenOffice.org file format (#i86058#)
1383 */
1384 else if ( sListStyle.isEmpty() &&
1385 ( rImport.IsTextDocInOOoFileFormat() ||
1386 ( bBuildIdFound &&
1387 ( ( nUPD == 641 ) || ( nUPD == 645 ) || // prior OOo 2.0
1388 ( nUPD == 680 && nBuild <= 9238 ) ) ) ) ) // OOo 2.0 - OOo 2.3.1
1389 {
1390 bRet = sal_False;
1391 }
1392 }
1393 break;
1394 }
1395 else
1396 {
1397 // search list style at parent
1398 xStyle = Reference<XStyle>( xPropState, UNO_QUERY );
1399 }
1400 }
1401 }
1402 }
1403
1404 return bRet;
1405 }
1406 OUString XMLTextImportHelper::SetStyleAndAttrs(
1407 SvXMLImport& rImport,
1408 const Reference < XTextCursor >& rCursor,
1409 const OUString& rStyleName,
1410 sal_Bool bPara,
1411 sal_Bool bOutlineLevelAttrFound,
1412 sal_Int8 nOutlineLevel,
1413 // Numberings/Bullets in table not visible aftzer save/reload (#i80724#)
1414 sal_Bool bSetListAttrs )
1415 {
1416 static OUString s_ParaStyleName( "ParaStyleName");
1417 static OUString s_CharStyleName( "CharStyleName");
1418 static OUString s_NumberingRules( "NumberingRules");
1419 static OUString s_NumberingIsNumber( "NumberingIsNumber");
1420 static OUString s_NumberingLevel( "NumberingLevel");
1421 static OUString s_ParaIsNumberingRestart( "ParaIsNumberingRestart");
1422 static OUString s_NumberingStartValue( "NumberingStartValue");
1423 static OUString s_PropNameListId( "ListId");
1424 static OUString s_PageDescName( "PageDescName");
1425 static OUString s_ServiceCombinedCharacters( "com.sun.star.text.TextField.CombinedCharacters");
1426 static OUString s_Content("Content");
1427 static OUString s_OutlineLevel( "OutlineLevel");
1428 static OUString s_NumberingStyleName( "NumberingStyleName");
1429
1430 const sal_uInt16 nFamily = bPara ? XML_STYLE_FAMILY_TEXT_PARAGRAPH
1431 : XML_STYLE_FAMILY_TEXT_TEXT;
1432 XMLTextStyleContext *pStyle = 0;
1433 OUString sStyleName( rStyleName );
1434 if (!sStyleName.isEmpty() && m_pImpl->m_xAutoStyles.Is())
1435 {
1436 const SvXMLStyleContext* pTempStyle =
1437 ((SvXMLStylesContext *)&m_pImpl->m_xAutoStyles)->
1438 FindStyleChildContext( nFamily, sStyleName, sal_True );
1439 pStyle = PTR_CAST( XMLTextStyleContext,pTempStyle);
1440 }
1441 if( pStyle )
1442 sStyleName = pStyle->GetParentName();
1443
1444 Reference < XPropertySet > xPropSet( rCursor, UNO_QUERY );
1445 Reference< XPropertySetInfo > xPropSetInfo(
1446 xPropSet->getPropertySetInfo());
1447
1448 // style
1449 if( !sStyleName.isEmpty() )
1450 {
1451 sStyleName = rImport.GetStyleDisplayName( nFamily, sStyleName );
1452 const OUString& rPropName = (bPara) ? s_ParaStyleName : s_CharStyleName;
1453 const Reference < XNameContainer > & rStyles = (bPara)
1454 ? m_pImpl->m_xParaStyles
1455 : m_pImpl->m_xTextStyles;
1456 if( rStyles.is() &&
1457 xPropSetInfo->hasPropertyByName( rPropName ) &&
1458 rStyles->hasByName( sStyleName ) )
1459 {
1460 xPropSet->setPropertyValue( rPropName, makeAny(sStyleName) );
1461 }
1462 else
1463 sStyleName = OUString();
1464 }
1465
1466 /* The outline level needs to be only applied as list level, if the heading
1467 is not inside a list and if it by default applies the outline style. (#i70748#)
1468 */
1469 bool bApplyOutlineLevelAsListLevel( false );
1470 // Numberings/Bullets in table not visible aftzer save/reload (#i80724#)
1471 if (bSetListAttrs && bPara
1472 && xPropSetInfo->hasPropertyByName( s_NumberingRules))
1473 {
1474 // Set numbering rules
1475 Reference< XIndexReplace > const xNumRules(
1476 xPropSet->getPropertyValue(s_NumberingRules), UNO_QUERY);
1477
1478 XMLTextListBlockContext * pListBlock(0);
1479 XMLTextListItemContext * pListItem(0);
1480 XMLNumberedParaContext * pNumberedParagraph(0);
1481 GetTextListHelper().ListContextTop(
1482 pListBlock, pListItem, pNumberedParagraph);
1483
1484 OSL_ENSURE(!(pListBlock && pNumberedParagraph), "XMLTextImportHelper::"
1485 "SetStyleAndAttrs: both list and numbered-paragraph???");
1486
1487 Reference < XIndexReplace > xNewNumRules;
1488 sal_Int8 nLevel(-1);
1489 OUString sListId;
1490 sal_Int16 nStartValue(-1);
1491 bool bNumberingIsNumber(true);
1492
1493 if (pListBlock) {
1494
1495 if (!pListItem) {
1496 bNumberingIsNumber = false; // list-header
1497 }
1498 // consider text:style-override property of <text:list-item>
1499 xNewNumRules.set(
1500 (pListItem != 0 && pListItem->HasNumRulesOverride())
1501 ? pListItem->GetNumRulesOverride()
1502 : pListBlock->GetNumRules() );
1503 nLevel = static_cast<sal_Int8>(pListBlock->GetLevel());
1504
1505 if ( pListItem && pListItem->HasStartValue() ) {
1506 nStartValue = pListItem->GetStartValue();
1507 }
1508
1509 // Inconsistent behavior regarding lists (#i92811#)
1510 sListId = m_pImpl->m_pTextListsHelper->GetListIdForListBlock(
1511 *pListBlock);
1512 }
1513 else if (pNumberedParagraph)
1514 {
1515 xNewNumRules.set(pNumberedParagraph->GetNumRules());
1516 nLevel = static_cast<sal_Int8>(pNumberedParagraph->GetLevel());
1517 sListId = pNumberedParagraph->GetListId();
1518 nStartValue = pNumberedParagraph->GetStartValue();
1519 }
1520
1521
1522 if (pListBlock || pNumberedParagraph)
1523 {
1524 // Assure that list style of automatic paragraph style is applied at paragraph. (#i101349#)
1525 sal_Bool bApplyNumRules = pStyle && pStyle->IsListStyleSet();
1526 if ( !bApplyNumRules )
1527 {
1528 sal_Bool bSameNumRules = xNewNumRules == xNumRules;
1529 if( !bSameNumRules && xNewNumRules.is() && xNumRules.is() )
1530 {
1531 // If the interface pointers are different then this does
1532 // not mean that the num rules are different. Further tests
1533 // are required then. However, if only one num rule is
1534 // set, no tests are required of course.
1535 Reference< XNamed > xNewNamed( xNewNumRules, UNO_QUERY );
1536 Reference< XNamed > xNamed( xNumRules, UNO_QUERY );
1537 if( xNewNamed.is() && xNamed.is() )
1538 {
1539 bSameNumRules = xNewNamed->getName() == xNamed->getName();
1540 }
1541 else
1542 {
1543 Reference< XAnyCompare > xNumRuleCompare( xNumRules, UNO_QUERY );
1544 if( xNumRuleCompare.is() )
1545 {
1546 bSameNumRules = (xNumRuleCompare->compare( Any(xNumRules), Any(xNewNumRules) ) == 0);
1547 }
1548 }
1549 }
1550 bApplyNumRules = !bSameNumRules;
1551 }
1552
1553 if ( bApplyNumRules )
1554 {
1555 // #102607# This may except when xNewNumRules contains
1556 // a Writer-NumRule-Implementation bug gets applied to
1557 // a shape. Since this may occur inside a document
1558 // (e.g. when edited), this must be handled
1559 // gracefully.
1560 try
1561 {
1562 xPropSet->setPropertyValue(
1563 s_NumberingRules, makeAny(xNewNumRules) );
1564 }
1565 catch(const Exception&)
1566 {
1567 ; // I would really like to use a warning here,
1568 // but I can't access the XMLErrorHandler from
1569 // here.
1570 }
1571 }
1572
1573 if (!bNumberingIsNumber &&
1574 xPropSetInfo->hasPropertyByName(s_NumberingIsNumber))
1575 {
1576 xPropSet->setPropertyValue(s_NumberingIsNumber, Any(sal_False));
1577 }
1578
1579 xPropSet->setPropertyValue( s_NumberingLevel, Any(nLevel) );
1580
1581 if( pListBlock && pListBlock->IsRestartNumbering() )
1582 {
1583 // TODO: property missing
1584 if (xPropSetInfo->hasPropertyByName(s_ParaIsNumberingRestart))
1585 {
1586 sal_Bool bTmp = sal_True;
1587 xPropSet->setPropertyValue(s_ParaIsNumberingRestart,
1588 makeAny(bTmp) );
1589 }
1590 pListBlock->ResetRestartNumbering();
1591 }
1592
1593 if ( 0 <= nStartValue &&
1594 xPropSetInfo->hasPropertyByName(s_NumberingStartValue))
1595 {
1596 xPropSet->setPropertyValue(s_NumberingStartValue,
1597 makeAny(nStartValue));
1598 }
1599
1600 if (xPropSetInfo->hasPropertyByName(s_PropNameListId))
1601 {
1602 if (!sListId.isEmpty()) {
1603 xPropSet->setPropertyValue(s_PropNameListId,
1604 makeAny(sListId) );
1605 }
1606 }
1607
1608 GetTextListHelper().SetListItem( (XMLTextListItemContext *)0 );
1609 }
1610 else
1611 {
1612 /* If the paragraph is not in a list but its style, remove it from
1613 the list. Do not remove it, if the list of the style is
1614 the chapter numbering rule.
1615 */
1616 if( xNumRules.is() )
1617 {
1618 bool bRemove( true );
1619 // Special handling for document from OOo 2.x (#i70748#)
1620 sal_Int32 nUPD( 0 );
1621 sal_Int32 nBuild( 0 );
1622 const bool bBuildIdFound = rImport.getBuildIds( nUPD, nBuild );
1623 DBG_ASSERT( ( bBuildIdFound && nUPD == 680 ) ||
1624 !pStyle ||
1625 !pStyle->IsListStyleSet() ||
1626 pStyle->GetListStyle().isEmpty(),
1627 "automatic paragraph style with list style name, but paragraph not in list???" );
1628 if ( ( bBuildIdFound && nUPD == 680 ) ||
1629 !pStyle || !pStyle->IsListStyleSet() )
1630 {
1631 if (m_pImpl->m_xChapterNumbering.is())
1632 {
1633 Reference< XNamed > xNumNamed( xNumRules, UNO_QUERY );
1634 Reference< XNamed > const xChapterNumNamed (
1635 m_pImpl->m_xChapterNumbering, UNO_QUERY);
1636 if ( xNumNamed.is() && xChapterNumNamed.is() &&
1637 xNumNamed->getName() == xChapterNumNamed->getName() )
1638 {
1639 bRemove = false;
1640 // RFE: inserting headings into text documents (#i70748#)
1641 bApplyOutlineLevelAsListLevel = true;
1642 }
1643 }
1644 }
1645 if ( bRemove )
1646 {
1647 xPropSet->setPropertyValue( s_NumberingRules, Any() );
1648 }
1649 }
1650 }
1651 }
1652
1653 // hard paragraph properties
1654 if( pStyle )
1655 {
1656 pStyle->FillPropertySet( xPropSet );
1657 if( bPara && pStyle->HasMasterPageName() &&
1658 xPropSetInfo->hasPropertyByName(s_PageDescName))
1659 {
1660 OUString sDisplayName(
1661 rImport.GetStyleDisplayName(
1662 XML_STYLE_FAMILY_MASTER_PAGE,
1663 pStyle->GetMasterPageName()) );
1664 if( sDisplayName.isEmpty() ||
1665 (m_pImpl->m_xPageStyles.is() &&
1666 m_pImpl->m_xPageStyles->hasByName( sDisplayName)))
1667 {
1668 xPropSet->setPropertyValue(s_PageDescName,
1669 makeAny(sDisplayName));
1670 }
1671 }
1672 if( bPara && !pStyle->GetDropCapStyleName().isEmpty() &&
1673 m_pImpl->m_xTextStyles.is())
1674 {
1675 OUString sDisplayName(
1676 rImport.GetStyleDisplayName(
1677 XML_STYLE_FAMILY_TEXT_TEXT,
1678 pStyle->GetDropCapStyleName()) );
1679 if (m_pImpl->m_xTextStyles->hasByName(sDisplayName) &&
1680 xPropSetInfo->hasPropertyByName( pStyle->sDropCapCharStyleName ) )
1681 {
1682 xPropSet->setPropertyValue( pStyle->sDropCapCharStyleName, makeAny(sDisplayName) );
1683 }
1684 }
1685
1686 // combined characters special treatment
1687 if (!bPara && pStyle->HasCombinedCharactersLetter())
1688 {
1689 // insert combined characters text field
1690 if (m_pImpl->m_xServiceFactory.is())
1691 {
1692 uno::Reference<beans::XPropertySet> const xTmp(
1693 m_pImpl->m_xServiceFactory->createInstance(
1694 s_ServiceCombinedCharacters), UNO_QUERY);
1695 if( xTmp.is() )
1696 {
1697 // fix cursor if larger than possible for
1698 // combined characters field
1699 if (rCursor->getString().getLength() >
1700 MAX_COMBINED_CHARACTERS)
1701 {
1702 rCursor->gotoRange(rCursor->getStart(), sal_False);
1703 rCursor->goRight(MAX_COMBINED_CHARACTERS, sal_True);
1704 }
1705
1706 // set field value (the combined character string)
1707 xTmp->setPropertyValue(s_Content,
1708 makeAny(rCursor->getString()));
1709
1710 // insert the field over it's original text
1711 Reference<XTextRange> xRange(rCursor, UNO_QUERY);
1712 Reference<XTextContent> xTextContent(xTmp, UNO_QUERY);
1713 if (m_pImpl->m_xText.is() && xRange.is())
1714 {
1715 // #i107225# the combined characters need to be inserted first
1716 // the selected text has to be removed afterwards
1717 m_pImpl->m_xText->insertTextContent( xRange->getStart(), xTextContent, sal_True );
1718
1719 if( !xRange->getString().isEmpty() )
1720 {
1721 try
1722 {
1723 uno::Reference< text::XTextCursor > xCrsr = xRange->getText()->createTextCursorByRange( xRange->getStart() );
1724 xCrsr->goLeft( 1, true );
1725 uno::Reference< beans::XPropertySet> xCrsrProperties( xCrsr, uno::UNO_QUERY_THROW );
1726 //the hard properties of the removed text need to be applied to the combined characters field
1727 pStyle->FillPropertySet( xCrsrProperties );
1728 xCrsr->collapseToEnd();
1729 xCrsr->gotoRange( xRange->getEnd(), true );
1730 xCrsr->setString( OUString() );
1731 }
1732 catch(const uno::Exception&)
1733 {
1734 }
1735 }
1736 }
1737 }
1738 }
1739 }
1740 }
1741
1742 // outline level; set after list style has been set
1743 // Complete re-worked and corrected: (#i53198#)
1744 // - set outline level at paragraph
1745 // - set numbering level at paragraph, if none is already set
1746 // - assure that style is marked as an outline style for the corresponding
1747 // outline level.
1748 // - DO NOT set type of numbering rule to outline.
1749 // - DO NOT set numbering rule directly at the paragraph.
1750
1751 // Some minor rework and adjust access to paragraph styles (#i70748#)
1752 if ( bPara )
1753 {
1754 // Headings not numbered anymore in 3.1 (#i103817#)
1755 sal_Int16 nCurrentOutlineLevelInheritedFromParagraphStyle = 0;
1756 const bool bHasOutlineLevelProp(
1757 xPropSetInfo->hasPropertyByName(s_OutlineLevel));
1758 if ( bHasOutlineLevelProp )
1759 {
1760 xPropSet->getPropertyValue(s_OutlineLevel)
1761 >>= nCurrentOutlineLevelInheritedFromParagraphStyle;
1762 }
1763 if ( nOutlineLevel > 0 )
1764 {
1765 if ( bHasOutlineLevelProp )
1766 {
1767 // In case that the value equals the value of its paragraph style
1768 // attribute outline level, the paragraph attribute value is left unset
1769 if ( nCurrentOutlineLevelInheritedFromParagraphStyle != nOutlineLevel )
1770 {
1771 xPropSet->setPropertyValue( s_OutlineLevel,
1772 makeAny( static_cast<sal_Int16>(nOutlineLevel) ) );
1773 }
1774 }
1775
1776 // RFE: inserting headings into text documents (#i70748#)
1777 if ( bApplyOutlineLevelAsListLevel )
1778 {
1779 sal_Int16 nNumLevel = -1;
1780 xPropSet->getPropertyValue( s_NumberingLevel ) >>= nNumLevel;
1781 if ( nNumLevel == -1 ||
1782 nNumLevel != (nOutlineLevel - 1) )
1783 {
1784 xPropSet->setPropertyValue( s_NumberingLevel,
1785 makeAny( static_cast<sal_Int8>(nOutlineLevel - 1) ) );
1786 }
1787 }
1788 /* Correction: (#i69629#)
1789 - for text document from version OOo 2.0.4/SO 8 PU4 and earlier
1790 the paragraph style of a heading should be assigned to the
1791 corresponding list level of the outline style.
1792 - for other text documents the paragraph style of a heading is only
1793 a candidate for an assignment to the list level of the outline
1794 style, if it has no direct list style property and (if exists) the
1795 automatic paragraph style has also no direct list style set.
1796 */
1797 if (m_pImpl->m_xParaStyles.is() && m_pImpl->m_xParaStyles->hasByName(sStyleName))
1798 {
1799 bool bOutlineStyleCandidate( false );
1800
1801 sal_Int32 nUPD( 0 );
1802 sal_Int32 nBuild( 0 );
1803 const bool bBuildIdFound = rImport.getBuildIds( nUPD, nBuild );
1804 // Lost outline numbering in master document (#i73509#)
1805 // Check explicitly on certain versions (#i86058#)
1806 if ( rImport.IsTextDocInOOoFileFormat() ||
1807 ( bBuildIdFound &&
1808 ( nUPD == 645 || nUPD == 641 ) ) )
1809 {
1810 bOutlineStyleCandidate = true;
1811 }
1812 else if ( nUPD == 680 && nBuild <= 9073 ) /* BuildId of OOo 2.0.4/SO8 PU4 */
1813 {
1814 bOutlineStyleCandidate = bOutlineLevelAttrFound;
1815 }
1816 if ( bOutlineStyleCandidate )
1817 {
1818 AddOutlineStyleCandidate( nOutlineLevel, sStyleName );
1819 }
1820 // Assure that heading applies the outline style (#i103817#)
1821 if ( ( !pStyle || !pStyle->IsListStyleSet() ) &&
1822 !bOutlineStyleCandidate &&
1823 m_pImpl->m_xChapterNumbering.is())
1824 {
1825 OUString sEmptyStr;
1826 if ( !lcl_HasListStyle( sStyleName,
1827 m_pImpl->m_xParaStyles, GetXMLImport(),
1828 s_NumberingStyleName,
1829 sEmptyStr ) )
1830 {
1831 // heading not in a list --> apply outline style
1832 xPropSet->setPropertyValue( s_NumberingRules,
1833 makeAny(m_pImpl->m_xChapterNumbering) );
1834 xPropSet->setPropertyValue( s_NumberingLevel,
1835 makeAny(static_cast<sal_Int8>(nOutlineLevel - 1)));
1836 }
1837 }
1838 }
1839 }
1840 //handle for text:p,if the paragraphstyle outlinelevel is set to[1~10]
1841 else if( bHasOutlineLevelProp )
1842 {
1843 if ( nCurrentOutlineLevelInheritedFromParagraphStyle != 0 )
1844 {
1845 sal_Int16 nZero = 0;
1846 xPropSet->setPropertyValue(s_OutlineLevel,
1847 makeAny( static_cast<sal_Int16>(nZero) ));
1848 }
1849 }
1850 }
1851
1852 return sStyleName;
1853 }
1854
1855 void XMLTextImportHelper::FindOutlineStyleName( OUString& rStyleName,
1856 sal_Int8 nOutlineLevel )
1857 {
1858 static OUString s_HeadingStyleName( "HeadingStyleName");
1859
1860 // style name empty?
1861 if( rStyleName.isEmpty() )
1862 {
1863 // Empty? Then we need o do stuff. Let's do error checking first.
1864 if (m_pImpl->m_xChapterNumbering.is() &&
1865 ( nOutlineLevel > 0 ) &&
1866 (nOutlineLevel <= m_pImpl->m_xChapterNumbering->getCount()))
1867 {
1868 nOutlineLevel--; // for the remainder, the level's are 0-based
1869
1870 // empty style name: look-up previously used name
1871
1872 // if we don't have a previously used name, we'll use the default
1873 m_pImpl->InitOutlineStylesCandidates();
1874 if (m_pImpl->m_pOutlineStylesCandidates[nOutlineLevel].empty())
1875 {
1876 // no other name used previously? Then use default
1877
1878 // iterate over property value sequence to find the style name
1879 Sequence<PropertyValue> aProperties;
1880 m_pImpl->m_xChapterNumbering->getByIndex( nOutlineLevel )
1881 >>= aProperties;
1882 for( sal_Int32 i = 0; i < aProperties.getLength(); i++ )
1883 {
1884 if (aProperties[i].Name == s_HeadingStyleName)
1885 {
1886 OUString aOutlineStyle;
1887 aProperties[i].Value >>= aOutlineStyle;
1888 m_pImpl->m_pOutlineStylesCandidates[nOutlineLevel]
1889 .push_back( aOutlineStyle );
1890 break; // early out, if we found it!.
1891 }
1892 }
1893 }
1894
1895 // finally, we'll use the previously used style name for this
1896 // format (or the default we've just put into that style)
1897 // take last added one (#i71249#)
1898 rStyleName =
1899 m_pImpl->m_pOutlineStylesCandidates[nOutlineLevel].back();
1900 }
1901 // else: nothing we can do, so we'll leave it empty
1902 }
1903 // else: we already had a style name, so we let it pass.
1904 }
1905
1906 void XMLTextImportHelper::AddOutlineStyleCandidate( const sal_Int8 nOutlineLevel,
1907 const OUString& rStyleName )
1908 {
1909 if (!rStyleName.isEmpty()
1910 && m_pImpl->m_xChapterNumbering.is()
1911 && (nOutlineLevel > 0)
1912 && (nOutlineLevel <= m_pImpl->m_xChapterNumbering->getCount()))
1913 {
1914 m_pImpl->InitOutlineStylesCandidates();
1915 m_pImpl->m_pOutlineStylesCandidates[nOutlineLevel-1].push_back(
1916 rStyleName);
1917 }
1918 }
1919
1920 void XMLTextImportHelper::SetOutlineStyles( sal_Bool bSetEmptyLevels )
1921 {
1922 static OUString s_NumberingStyleName( "NumberingStyleName");
1923 static OUString s_HeadingStyleName( "HeadingStyleName");
1924
1925 if ((m_pImpl->m_pOutlineStylesCandidates != NULL || bSetEmptyLevels) &&
1926 m_pImpl->m_xChapterNumbering.is() &&
1927 !IsInsertMode())
1928 {
1929 bool bChooseLastOne( false );
1930 {
1931 if ( GetXMLImport().IsTextDocInOOoFileFormat() )
1932 {
1933 bChooseLastOne = true;
1934 }
1935 else
1936 {
1937 sal_Int32 nUPD( 0 );
1938 sal_Int32 nBuild( 0 );
1939 if ( GetXMLImport().getBuildIds( nUPD, nBuild ) )
1940 {
1941 // check explicitly on certain versions
1942 bChooseLastOne = ( nUPD == 641 ) || ( nUPD == 645 ) || // prior OOo 2.0
1943 ( nUPD == 680 && nBuild <= 9073 ); // OOo 2.0 - OOo 2.0.4
1944 }
1945 }
1946 }
1947
1948 OUString sOutlineStyleName;
1949 {
1950 Reference<XPropertySet> xChapterNumRule(
1951 m_pImpl->m_xChapterNumbering, UNO_QUERY);
1952 const OUString sName("Name");
1953 xChapterNumRule->getPropertyValue(sName) >>= sOutlineStyleName;
1954 }
1955
1956 const sal_Int32 nCount = m_pImpl->m_xChapterNumbering->getCount();
1957 /* First collect all paragraph styles choosen for assignment to each
1958 list level of the outline style, then perform the intrinsic assignment.
1959 Reason: The assignment of a certain paragraph style to a list level
1960 of the outline style causes side effects on the children
1961 paragraph styles in Writer. (#i106218#)
1962 */
1963 ::std::vector<OUString> sChosenStyles(nCount);
1964 for( sal_Int32 i=0; i < nCount; ++i )
1965 {
1966 if ( bSetEmptyLevels ||
1967 (m_pImpl->m_pOutlineStylesCandidates &&
1968 !m_pImpl->m_pOutlineStylesCandidates[i].empty()))
1969 {
1970 // determine, which candidate is one to be assigned to the list
1971 // level of the outline style
1972 if (m_pImpl->m_pOutlineStylesCandidates &&
1973 !m_pImpl->m_pOutlineStylesCandidates[i].empty())
1974 {
1975 if ( bChooseLastOne )
1976 {
1977 sChosenStyles[i] =
1978 m_pImpl->m_pOutlineStylesCandidates[i].back();
1979 }
1980 else
1981 {
1982 for (sal_uInt32 j = 0;
1983 j < m_pImpl->m_pOutlineStylesCandidates[i].size();
1984 ++j)
1985 {
1986 if (!lcl_HasListStyle(
1987 m_pImpl->m_pOutlineStylesCandidates[i][j],
1988 m_pImpl->m_xParaStyles, GetXMLImport(),
1989 s_NumberingStyleName,
1990 sOutlineStyleName))
1991 {
1992 sChosenStyles[i] =
1993 m_pImpl->m_pOutlineStylesCandidates[i][j];
1994 break;
1995 }
1996 }
1997 }
1998 }
1999 }
2000 }
2001 // Trashed outline numbering in ODF 1.1 text document created by OOo 3.x (#i106218#)
2002 Sequence < PropertyValue > aProps( 1 );
2003 PropertyValue *pProps = aProps.getArray();
2004 pProps->Name = s_HeadingStyleName;
2005 for ( sal_Int32 i = 0; i < nCount; ++i )
2006 {
2007 // Paragraph style assignments in Outline of template lost from second level on (#i107610#)
2008 if ( bSetEmptyLevels || !sChosenStyles[i].isEmpty() )
2009 {
2010 pProps->Value <<= sChosenStyles[i];
2011 m_pImpl->m_xChapterNumbering->replaceByIndex(i,
2012 makeAny( aProps ));
2013 }
2014 }
2015 }
2016 }
2017
2018 void XMLTextImportHelper::SetHyperlink(
2019 SvXMLImport& rImport,
2020 const Reference < XTextCursor >& rCursor,
2021 const OUString& rHRef,
2022 const OUString& rName,
2023 const OUString& rTargetFrameName,
2024 const OUString& rStyleName,
2025 const OUString& rVisitedStyleName,
2026 XMLEventsImportContext* pEvents)
2027 {
2028 static OUString s_HyperLinkURL( "HyperLinkURL");
2029 static OUString s_HyperLinkName( "HyperLinkName");
2030 static OUString s_HyperLinkTarget( "HyperLinkTarget");
2031 static OUString s_UnvisitedCharStyleName( "UnvisitedCharStyleName");
2032 static OUString s_VisitedCharStyleName( "VisitedCharStyleName");
2033 static OUString s_HyperLinkEvents( "HyperLinkEvents");
2034
2035 Reference < XPropertySet > xPropSet( rCursor, UNO_QUERY );
2036 Reference < XPropertySetInfo > xPropSetInfo(
2037 xPropSet->getPropertySetInfo());
2038 if (!xPropSetInfo.is() || !xPropSetInfo->hasPropertyByName(s_HyperLinkURL))
2039 return;
2040
2041 xPropSet->setPropertyValue(s_HyperLinkURL, makeAny(rHRef));
2042
2043 if (xPropSetInfo->hasPropertyByName(s_HyperLinkName))
2044 {
2045 xPropSet->setPropertyValue(s_HyperLinkName, makeAny(rName));
2046 }
2047
2048 if (xPropSetInfo->hasPropertyByName(s_HyperLinkTarget))
2049 {
2050 xPropSet->setPropertyValue(s_HyperLinkTarget,
2051 makeAny(rTargetFrameName));
2052 }
2053
2054 if ( (pEvents != NULL) &&
2055 xPropSetInfo->hasPropertyByName(s_HyperLinkEvents))
2056 {
2057 // The API treats events at hyperlinks differently from most
2058 // other properties: You have to set a name replace with the
2059 // events in it. The easiest way to to this is to 1) get
2060 // events, 2) set new ones, and 3) then put events back.
2061 uno::Reference<XNameReplace> const xReplace(
2062 xPropSet->getPropertyValue(s_HyperLinkEvents), UNO_QUERY);
2063 if (xReplace.is())
2064 {
2065 // set events
2066 pEvents->SetEvents(xReplace);
2067
2068 // put events
2069 xPropSet->setPropertyValue(s_HyperLinkEvents, makeAny(xReplace));
2070 }
2071 }
2072
2073 if (m_pImpl->m_xTextStyles.is())
2074 {
2075 OUString sDisplayName(
2076 rImport.GetStyleDisplayName(
2077 XML_STYLE_FAMILY_TEXT_TEXT, rStyleName ) );
2078 if( !sDisplayName.isEmpty() &&
2079 xPropSetInfo->hasPropertyByName(s_UnvisitedCharStyleName) &&
2080 m_pImpl->m_xTextStyles->hasByName(sDisplayName))
2081 {
2082 xPropSet->setPropertyValue(s_UnvisitedCharStyleName,
2083 makeAny(sDisplayName));
2084 }
2085
2086 sDisplayName =
2087 rImport.GetStyleDisplayName(
2088 XML_STYLE_FAMILY_TEXT_TEXT, rVisitedStyleName );
2089 if( !sDisplayName.isEmpty() &&
2090 xPropSetInfo->hasPropertyByName(s_VisitedCharStyleName) &&
2091 m_pImpl->m_xTextStyles->hasByName(sDisplayName))
2092 {
2093 xPropSet->setPropertyValue(s_VisitedCharStyleName,
2094 makeAny(sDisplayName));
2095 }
2096 }
2097 }
2098
2099 void XMLTextImportHelper::SetRuby(
2100 SvXMLImport& rImport,
2101 const Reference < XTextCursor >& rCursor,
2102 const OUString& rStyleName,
2103 const OUString& rTextStyleName,
2104 const OUString& rText )
2105 {
2106 Reference<XPropertySet> xPropSet(rCursor, UNO_QUERY);
2107
2108 OUString sRubyText("RubyText");
2109 OUString sRubyCharStyleName("RubyCharStyleName");
2110
2111 // if we have one Ruby property, we assume all of them are present
2112 if (xPropSet.is() &&
2113 xPropSet->getPropertySetInfo()->hasPropertyByName( sRubyText ))
2114 {
2115 // the ruby text
2116 xPropSet->setPropertyValue(sRubyText, makeAny(rText));
2117
2118 // the ruby style (ruby-adjust)
2119 XMLPropStyleContext *pStyle = 0;
2120 if (!rStyleName.isEmpty() && m_pImpl->m_xAutoStyles.Is())
2121 {
2122 const SvXMLStyleContext* pTempStyle =
2123 ((SvXMLStylesContext *)&m_pImpl->m_xAutoStyles)->
2124 FindStyleChildContext( XML_STYLE_FAMILY_TEXT_RUBY,
2125 rStyleName, sal_True );
2126 pStyle = PTR_CAST(XMLPropStyleContext,pTempStyle);
2127
2128 if (NULL != pStyle)
2129 pStyle->FillPropertySet( xPropSet );
2130 }
2131
2132 // the ruby text character style
2133 if (m_pImpl->m_xTextStyles.is())
2134 {
2135 OUString sDisplayName(
2136 rImport.GetStyleDisplayName(
2137 XML_STYLE_FAMILY_TEXT_TEXT, rTextStyleName ) );
2138 if( (!sDisplayName.isEmpty()) &&
2139 m_pImpl->m_xTextStyles->hasByName( sDisplayName ))
2140 {
2141 xPropSet->setPropertyValue(sRubyCharStyleName, makeAny(sDisplayName));
2142 }
2143 }
2144 }
2145 }
2146
2147 void XMLTextImportHelper::SetAutoStyles( SvXMLStylesContext *pStyles )
2148 {
2149 m_pImpl->m_xAutoStyles = pStyles;
2150 }
2151
2152 SvXMLImportContext *XMLTextImportHelper::CreateTextChildContext(
2153 SvXMLImport& rImport,
2154 sal_uInt16 nPrefix, const OUString& rLocalName,
2155 const Reference< XAttributeList > & xAttrList,
2156 XMLTextType eType )
2157 {
2158 SvXMLImportContext *pContext = 0;
2159
2160 const SvXMLTokenMap& rTokenMap = GetTextElemTokenMap();
2161 sal_Bool bHeading = sal_False;
2162 sal_Bool bContent = sal_True;
2163 sal_uInt16 nToken = rTokenMap.Get( nPrefix, rLocalName );
2164 switch( nToken )
2165 {
2166 case XML_TOK_TEXT_H:
2167 bHeading = sal_True;
2168 case XML_TOK_TEXT_P:
2169 pContext = new XMLParaContext( rImport,
2170 nPrefix, rLocalName,
2171 xAttrList, bHeading );
2172 if (m_pImpl->m_bProgress && XML_TEXT_TYPE_SHAPE != eType)
2173 {
2174 rImport.GetProgressBarHelper()->Increment();
2175 }
2176 break;
2177 case XML_TOK_TEXT_NUMBERED_PARAGRAPH:
2178 pContext = new XMLNumberedParaContext(
2179 rImport, nPrefix, rLocalName, xAttrList );
2180 break;
2181 case XML_TOK_TEXT_LIST:
2182 pContext = new XMLTextListBlockContext( rImport, *this,
2183 nPrefix, rLocalName,
2184 xAttrList );
2185 break;
2186 case XML_TOK_TABLE_TABLE:
2187 if( XML_TEXT_TYPE_BODY == eType ||
2188 XML_TEXT_TYPE_TEXTBOX == eType ||
2189 XML_TEXT_TYPE_SECTION == eType ||
2190 XML_TEXT_TYPE_HEADER_FOOTER == eType ||
2191 XML_TEXT_TYPE_CHANGED_REGION == eType ||
2192 XML_TEXT_TYPE_CELL == eType )
2193 pContext = CreateTableChildContext( rImport, nPrefix, rLocalName,
2194 xAttrList );
2195 break;
2196 case XML_TOK_TEXT_SEQUENCE_DECLS:
2197 if ((XML_TEXT_TYPE_BODY == eType && m_pImpl->m_bBodyContentStarted) ||
2198 XML_TEXT_TYPE_HEADER_FOOTER == eType )
2199 {
2200 pContext = new XMLVariableDeclsImportContext(
2201 rImport, *this, nPrefix, rLocalName, VarTypeSequence);
2202 bContent = sal_False;
2203 }
2204 break;
2205
2206 case XML_TOK_TEXT_VARFIELD_DECLS:
2207 if ((XML_TEXT_TYPE_BODY == eType && m_pImpl->m_bBodyContentStarted) ||
2208 XML_TEXT_TYPE_HEADER_FOOTER == eType )
2209 {
2210 pContext = new XMLVariableDeclsImportContext(
2211 rImport, *this, nPrefix, rLocalName, VarTypeSimple);
2212 bContent = sal_False;
2213 }
2214 break;
2215
2216 case XML_TOK_TEXT_USERFIELD_DECLS:
2217 if ((XML_TEXT_TYPE_BODY == eType && m_pImpl->m_bBodyContentStarted)||
2218 XML_TEXT_TYPE_HEADER_FOOTER == eType )
2219 {
2220 pContext = new XMLVariableDeclsImportContext(
2221 rImport, *this, nPrefix, rLocalName, VarTypeUserField);
2222 bContent = sal_False;
2223 }
2224 break;
2225
2226 case XML_TOK_TEXT_DDE_DECLS:
2227 if ((XML_TEXT_TYPE_BODY == eType && m_pImpl->m_bBodyContentStarted) ||
2228 XML_TEXT_TYPE_HEADER_FOOTER == eType )
2229 {
2230 pContext = new XMLDdeFieldDeclsImportContext(
2231 rImport, nPrefix, rLocalName);
2232 bContent = sal_False;
2233 }
2234 break;
2235
2236 case XML_TOK_TEXT_FRAME_PAGE:
2237 if ((XML_TEXT_TYPE_BODY == eType && m_pImpl->m_bBodyContentStarted) ||
2238 XML_TEXT_TYPE_TEXTBOX == eType ||
2239 XML_TEXT_TYPE_CHANGED_REGION == eType )
2240 {
2241 TextContentAnchorType eAnchorType =
2242 XML_TEXT_TYPE_TEXTBOX == eType ? TextContentAnchorType_AT_FRAME
2243 : TextContentAnchorType_AT_PAGE;
2244 pContext = new XMLTextFrameContext( rImport, nPrefix,
2245 rLocalName, xAttrList,
2246 eAnchorType );
2247 bContent = sal_False;
2248 }
2249 break;
2250
2251 case XML_TOK_DRAW_A_PAGE:
2252 if ((XML_TEXT_TYPE_BODY == eType && m_pImpl->m_bBodyContentStarted) ||
2253 XML_TEXT_TYPE_TEXTBOX == eType ||
2254 XML_TEXT_TYPE_CHANGED_REGION == eType)
2255 {
2256 TextContentAnchorType eAnchorType =
2257 XML_TEXT_TYPE_TEXTBOX == eType ? TextContentAnchorType_AT_FRAME
2258 : TextContentAnchorType_AT_PAGE;
2259 pContext = new XMLTextFrameHyperlinkContext( rImport, nPrefix,
2260 rLocalName, xAttrList,
2261 eAnchorType );
2262 bContent = sal_False;
2263 }
2264 break;
2265
2266 case XML_TOK_TEXT_INDEX_TITLE:
2267 case XML_TOK_TEXT_SECTION:
2268 pContext = new XMLSectionImportContext( rImport, nPrefix, rLocalName );
2269 break;
2270
2271 case XML_TOK_TEXT_TOC:
2272 case XML_TOK_TEXT_OBJECT_INDEX:
2273 case XML_TOK_TEXT_TABLE_INDEX:
2274 case XML_TOK_TEXT_ILLUSTRATION_INDEX:
2275 case XML_TOK_TEXT_USER_INDEX:
2276 case XML_TOK_TEXT_ALPHABETICAL_INDEX:
2277 case XML_TOK_TEXT_BIBLIOGRAPHY_INDEX:
2278 if( XML_TEXT_TYPE_SHAPE != eType )
2279 pContext = new XMLIndexTOCContext( rImport, nPrefix, rLocalName );
2280 break;
2281
2282 case XML_TOK_TEXT_TRACKED_CHANGES:
2283 pContext = new XMLTrackedChangesImportContext( rImport, nPrefix,
2284 rLocalName);
2285 bContent = sal_False;
2286 break;
2287
2288 case XML_TOK_TEXT_CHANGE:
2289 case XML_TOK_TEXT_CHANGE_START:
2290 case XML_TOK_TEXT_CHANGE_END:
2291 pContext = new XMLChangeImportContext(
2292 rImport, nPrefix, rLocalName,
2293 (XML_TOK_TEXT_CHANGE_END != nToken),
2294 (XML_TOK_TEXT_CHANGE_START != nToken),
2295 sal_True);
2296 break;
2297
2298 case XML_TOK_TEXT_FORMS:
2299 pContext = rImport.GetFormImport()->createOfficeFormsContext(rImport, nPrefix, rLocalName);
2300 bContent = sal_False;
2301 break;
2302
2303 case XML_TOK_TEXT_AUTOMARK:
2304 if( XML_TEXT_TYPE_BODY == eType )
2305 {
2306 pContext = new XMLAutoMarkFileContext(rImport, nPrefix,rLocalName);
2307 }
2308 bContent = sal_False;
2309 break;
2310
2311 case XML_TOK_TEXT_CALCULATION_SETTINGS:
2312 pContext = new XMLCalculationSettingsContext ( rImport, nPrefix, rLocalName, xAttrList);
2313 bContent = sal_False;
2314 break;
2315
2316 default:
2317 if ((XML_TEXT_TYPE_BODY == eType && m_pImpl->m_bBodyContentStarted) ||
2318 XML_TEXT_TYPE_TEXTBOX == eType ||
2319 XML_TEXT_TYPE_CHANGED_REGION == eType )
2320 {
2321 Reference < XShapes > xShapes;
2322 pContext = rImport.GetShapeImport()->CreateGroupChildContext(
2323 rImport, nPrefix, rLocalName, xAttrList, xShapes );
2324 bContent = sal_False;
2325 }
2326 }
2327
2328 // handle open redlines
2329 if ( (XML_TOK_TEXT_CHANGE != nToken) &&
2330 (XML_TOK_TEXT_CHANGE_END != nToken) &&
2331 (XML_TOK_TEXT_CHANGE_START != nToken) )
2332 {
2333 // ResetOpenRedlineId();
2334 }
2335
2336 if( XML_TEXT_TYPE_BODY == eType && bContent )
2337 {
2338 m_pImpl->m_bBodyContentStarted = sal_False;
2339 }
2340
2341 return pContext;
2342 }
2343
2344 SvXMLImportContext *XMLTextImportHelper::CreateTableChildContext(
2345 SvXMLImport&,
2346 sal_uInt16 /*nPrefix*/, const OUString& /*rLocalName*/,
2347 const Reference< XAttributeList > & )
2348 {
2349 return 0;
2350 }
2351
2352 /// get data style key for use with NumberFormat property
2353 sal_Int32 XMLTextImportHelper::GetDataStyleKey(const OUString& sStyleName,
2354 sal_Bool* pIsSystemLanguage )
2355 {
2356 const SvXMLStyleContext* pStyle =
2357 ((SvXMLStylesContext *)&m_pImpl->m_xAutoStyles)->
2358 FindStyleChildContext( XML_STYLE_FAMILY_DATA_STYLE,
2359 sStyleName, sal_True );
2360
2361 // get appropriate context
2362
2363
2364 // first check if its a impress and draw only number format
2365 // this is needed since its also a SvXMLNumFormatContext,
2366 // that was needed to support them for controls in impress/draw also
2367 SdXMLNumberFormatImportContext* pSdNumStyle = PTR_CAST( SdXMLNumberFormatImportContext, pStyle );
2368 if( pSdNumStyle )
2369 {
2370 return pSdNumStyle->GetDrawKey();
2371 }
2372 else
2373 {
2374 SvXMLNumFormatContext* pNumStyle = PTR_CAST( SvXMLNumFormatContext, pStyle );
2375 if( pNumStyle )
2376 {
2377 if( pIsSystemLanguage != NULL )
2378 *pIsSystemLanguage = pNumStyle->IsSystemLanguage();
2379
2380 // return key
2381 return pNumStyle->GetKey();
2382 }
2383 }
2384 return -1;
2385 }
2386
2387 const SvxXMLListStyleContext *XMLTextImportHelper::FindAutoListStyle( const OUString& rName ) const
2388 {
2389 const SvxXMLListStyleContext *pStyle = 0;
2390 if (m_pImpl->m_xAutoStyles.Is())
2391 {
2392 const SvXMLStyleContext* pTempStyle =
2393 ((SvXMLStylesContext *)&m_pImpl->m_xAutoStyles)->
2394 FindStyleChildContext( XML_STYLE_FAMILY_TEXT_LIST, rName,
2395 sal_True );
2396 pStyle = PTR_CAST( SvxXMLListStyleContext ,pTempStyle);
2397 }
2398
2399 return pStyle;
2400 }
2401
2402 XMLPropStyleContext *XMLTextImportHelper::FindAutoFrameStyle( const OUString& rName ) const
2403 {
2404 XMLPropStyleContext *pStyle = 0;
2405 if (m_pImpl->m_xAutoStyles.Is())
2406 {
2407 const SvXMLStyleContext* pTempStyle =
2408 ((SvXMLStylesContext *)&m_pImpl->m_xAutoStyles)->
2409 FindStyleChildContext( XML_STYLE_FAMILY_SD_GRAPHICS_ID, rName,
2410 sal_True );
2411 pStyle = PTR_CAST( XMLPropStyleContext ,pTempStyle);
2412 }
2413
2414 return pStyle;
2415 }
2416
2417 XMLPropStyleContext* XMLTextImportHelper::FindSectionStyle(
2418 const OUString& rName ) const
2419 {
2420 XMLPropStyleContext* pStyle = NULL;
2421 if (m_pImpl->m_xAutoStyles.Is())
2422 {
2423 const SvXMLStyleContext* pTempStyle =
2424 ((SvXMLStylesContext *)&m_pImpl->m_xAutoStyles)->
2425 FindStyleChildContext(
2426 XML_STYLE_FAMILY_TEXT_SECTION,
2427 rName, sal_True );
2428 pStyle = PTR_CAST( XMLPropStyleContext,pTempStyle);
2429 }
2430
2431 return pStyle;
2432 }
2433
2434 XMLPropStyleContext* XMLTextImportHelper::FindPageMaster(
2435 const OUString& rName ) const
2436 {
2437 XMLPropStyleContext* pStyle = NULL;
2438 if (m_pImpl->m_xAutoStyles.Is())
2439 {
2440 const SvXMLStyleContext* pTempStyle =
2441 ((SvXMLStylesContext *)&m_pImpl->m_xAutoStyles)->
2442 FindStyleChildContext(
2443 XML_STYLE_FAMILY_PAGE_MASTER,
2444 rName, sal_True );
2445 pStyle = PTR_CAST( XMLPropStyleContext,pTempStyle);
2446 }
2447
2448 return pStyle;
2449 }
2450
2451
2452 void XMLTextImportHelper::PushListContext(XMLTextListBlockContext *i_pListBlock)
2453 {
2454 GetTextListHelper().PushListContext(i_pListBlock);
2455 }
2456
2457 void XMLTextImportHelper::PopListContext()
2458 {
2459 GetTextListHelper().PopListContext();
2460 }
2461
2462
2463 const SvXMLTokenMap& XMLTextImportHelper::GetTextNumberedParagraphAttrTokenMap()
2464 {
2465 if (!m_pImpl->m_pTextNumberedParagraphAttrTokenMap.get())
2466 {
2467 m_pImpl->m_pTextNumberedParagraphAttrTokenMap.reset(
2468 new SvXMLTokenMap( aTextNumberedParagraphAttrTokenMap ) );
2469 }
2470 return *m_pImpl->m_pTextNumberedParagraphAttrTokenMap;
2471 }
2472
2473 const SvXMLTokenMap& XMLTextImportHelper::GetTextListBlockAttrTokenMap()
2474 {
2475 if (!m_pImpl->m_pTextListBlockAttrTokenMap.get())
2476 {
2477 m_pImpl->m_pTextListBlockAttrTokenMap.reset(
2478 new SvXMLTokenMap( aTextListBlockAttrTokenMap ) );
2479 }
2480 return *m_pImpl->m_pTextListBlockAttrTokenMap;
2481 }
2482
2483 const SvXMLTokenMap& XMLTextImportHelper::GetTextListBlockElemTokenMap()
2484 {
2485 if (!m_pImpl->m_pTextListBlockElemTokenMap.get())
2486 {
2487 m_pImpl->m_pTextListBlockElemTokenMap.reset(
2488 new SvXMLTokenMap( aTextListBlockElemTokenMap ) );
2489 }
2490 return *m_pImpl->m_pTextListBlockElemTokenMap;
2491 }
2492
2493 SvI18NMap& XMLTextImportHelper::GetRenameMap()
2494 {
2495 if (!m_pImpl->m_pRenameMap.get())
2496 {
2497 m_pImpl->m_pRenameMap.reset( new SvI18NMap() );
2498 }
2499 return *m_pImpl->m_pRenameMap;
2500 }
2501
2502 void XMLTextImportHelper::InsertBookmarkStartRange(
2503 const OUString & sName,
2504 const Reference<XTextRange> & rRange,
2505 OUString const& i_rXmlId,
2506 ::boost::shared_ptr< ::xmloff::ParsedRDFaAttributes > & i_rpRDFaAttributes)
2507 {
2508 m_pImpl->m_BookmarkStartRanges[sName] =
2509 ::boost::make_tuple(rRange, i_rXmlId, i_rpRDFaAttributes);
2510 m_pImpl->m_BookmarkVector.push_back(sName);
2511 }
2512
2513 sal_Bool XMLTextImportHelper::FindAndRemoveBookmarkStartRange(
2514 const OUString & sName,
2515 Reference<XTextRange> & o_rRange,
2516 OUString & o_rXmlId,
2517 ::boost::shared_ptr< ::xmloff::ParsedRDFaAttributes > & o_rpRDFaAttributes)
2518 {
2519 if (m_pImpl->m_BookmarkStartRanges.count(sName))
2520 {
2521 Impl::BookmarkMapEntry_t & rEntry =
2522 (*m_pImpl->m_BookmarkStartRanges.find(sName)).second;
2523 o_rRange.set(rEntry.get<0>());
2524 o_rXmlId = rEntry.get<1>();
2525 o_rpRDFaAttributes = rEntry.get<2>();
2526 m_pImpl->m_BookmarkStartRanges.erase(sName);
2527 Impl::BookmarkVector_t::iterator it(m_pImpl->m_BookmarkVector.begin());
2528 while (it != m_pImpl->m_BookmarkVector.end() && it->compareTo(sName)!=0)
2529 {
2530 ++it;
2531 }
2532 if (it!=m_pImpl->m_BookmarkVector.end())
2533 {
2534 m_pImpl->m_BookmarkVector.erase(it);
2535 }
2536 return sal_True;
2537 }
2538 else
2539 {
2540 return sal_False;
2541 }
2542 }
2543
2544 OUString XMLTextImportHelper::FindActiveBookmarkName()
2545 {
2546 if (!m_pImpl->m_BookmarkVector.empty())
2547 {
2548 return m_pImpl->m_BookmarkVector.back();
2549 }
2550 else
2551 {
2552 return OUString(); // return the empty string on error...
2553 }
2554 }
2555
2556 void XMLTextImportHelper::pushFieldCtx( OUString name, OUString type )
2557 {
2558 m_pImpl->m_FieldStack.push(Impl::field_stack_item_t(
2559 Impl::field_name_type_t(name, type), Impl::field_params_t()));
2560 }
2561
2562 void XMLTextImportHelper::popFieldCtx()
2563 {
2564 if ( !m_pImpl->m_FieldStack.empty() )
2565 m_pImpl->m_FieldStack.pop();
2566 }
2567
2568 void XMLTextImportHelper::addFieldParam( OUString name, OUString value )
2569 {
2570 DBG_ASSERT(!m_pImpl->m_FieldStack.empty(),
2571 "stack is empty: not good! Do a pushFieldCtx before...");
2572 if (!m_pImpl->m_FieldStack.empty()) {
2573 Impl::field_stack_item_t & FieldStackItem(m_pImpl->m_FieldStack.top());
2574 FieldStackItem.second.push_back(Impl::field_param_t( name, value ));
2575 }
2576 }
2577
2578 OUString XMLTextImportHelper::getCurrentFieldType()
2579 {
2580 DBG_ASSERT(!m_pImpl->m_FieldStack.empty(),
2581 "stack is empty: not good! Do a pushFieldCtx before...");
2582 if (!m_pImpl->m_FieldStack.empty())
2583 {
2584 return m_pImpl->m_FieldStack.top().first.second;
2585 }
2586 else
2587 {
2588 return OUString();
2589 }
2590 }
2591
2592 bool XMLTextImportHelper::hasCurrentFieldCtx()
2593 {
2594 return !m_pImpl->m_FieldStack.empty();
2595 }
2596
2597 void XMLTextImportHelper::setCurrentFieldParamsTo(::com::sun::star::uno::Reference< ::com::sun::star::text::XFormField> &xFormField)
2598 {
2599 DBG_ASSERT(!m_pImpl->m_FieldStack.empty(),
2600 "stack is empty: not good! Do a pushFieldCtx before...");
2601 if (!m_pImpl->m_FieldStack.empty() && xFormField.is())
2602 {
2603 FieldParamImporter(&m_pImpl->m_FieldStack.top().second,
2604 xFormField->getParameters()).Import();
2605 }
2606 }
2607
2608
2609 void XMLTextImportHelper::ConnectFrameChains(
2610 const OUString& rFrmName,
2611 const OUString& rNextFrmName,
2612 const Reference < XPropertySet >& rFrmPropSet )
2613 {
2614 static OUString s_ChainNextName( "ChainNextName");
2615 static OUString s_ChainPrevName( "ChainPrevName");
2616
2617 if( rFrmName.isEmpty() )
2618 return;
2619
2620 if( !rNextFrmName.isEmpty() )
2621 {
2622 OUString sNextFrmName(GetRenameMap().Get( XML_TEXT_RENAME_TYPE_FRAME,
2623 rNextFrmName ));
2624 if (m_pImpl->m_xTextFrames.is()
2625 && m_pImpl->m_xTextFrames->hasByName(sNextFrmName))
2626 {
2627 rFrmPropSet->setPropertyValue(s_ChainNextName,
2628 makeAny(sNextFrmName));
2629 }
2630 else
2631 {
2632 if (!m_pImpl->m_pPrevFrmNames.get())
2633 {
2634 m_pImpl->m_pPrevFrmNames.reset( new std::vector<OUString> );
2635 m_pImpl->m_pNextFrmNames.reset( new std::vector<OUString> );
2636 }
2637 m_pImpl->m_pPrevFrmNames->push_back(rFrmName);
2638 m_pImpl->m_pNextFrmNames->push_back(sNextFrmName);
2639 }
2640 }
2641 if (m_pImpl->m_pPrevFrmNames.get() && !m_pImpl->m_pPrevFrmNames->empty())
2642 {
2643 for(std::vector<OUString>::iterator i = m_pImpl->m_pPrevFrmNames->begin(), j = m_pImpl->m_pNextFrmNames->begin(); i != m_pImpl->m_pPrevFrmNames->end() && j != m_pImpl->m_pNextFrmNames->end(); ++i, ++j)
2644 {
2645 if((*j).equals(rFrmName))
2646 {
2647 // The previuous frame must exist, because it existing than
2648 // inserting the entry
2649 rFrmPropSet->setPropertyValue(s_ChainPrevName, makeAny(*i));
2650
2651 i = m_pImpl->m_pPrevFrmNames->erase(i);
2652 j = m_pImpl->m_pNextFrmNames->erase(j);
2653
2654 // There cannot be more than one previous frames
2655 break;
2656 }
2657 }
2658 }
2659 }
2660
2661 sal_Bool XMLTextImportHelper::IsInFrame() const
2662 {
2663 static OUString s_TextFrame( "TextFrame");
2664
2665 sal_Bool bIsInFrame = sal_False;
2666
2667 // are we currently in a text frame? yes, if the cursor has a
2668 // TextFrame property and it's non-NULL
2669 Reference<XPropertySet> xPropSet(((XMLTextImportHelper *)this)->GetCursor(), UNO_QUERY);
2670 if (xPropSet.is())
2671 {
2672 if (xPropSet->getPropertySetInfo()->hasPropertyByName(s_TextFrame))
2673 {
2674 uno::Reference<XTextFrame> const xFrame(
2675 xPropSet->getPropertyValue(s_TextFrame), UNO_QUERY);
2676
2677 if (xFrame.is())
2678 {
2679 bIsInFrame = sal_True;
2680 }
2681 }
2682 }
2683
2684 return bIsInFrame;
2685 }
2686
2687 sal_Bool XMLTextImportHelper::IsInHeaderFooter() const
2688 {
2689 return sal_False;
2690 }
2691
2692 Reference< XPropertySet> XMLTextImportHelper::createAndInsertOLEObject(
2693 SvXMLImport&,
2694 const OUString& /*rHRef*/,
2695 const OUString& /*rStyleName*/,
2696 const OUString& /*rTblName*/,
2697 sal_Int32 /*nWidth*/, sal_Int32 /*nHeight*/ )
2698 {
2699 Reference< XPropertySet> xPropSet;
2700 return xPropSet;
2701 }
2702
2703 Reference< XPropertySet> XMLTextImportHelper::createAndInsertOOoLink(
2704 SvXMLImport&,
2705 const OUString& /*rHRef*/,
2706 const OUString& /*rStyleName*/,
2707 const OUString& /*rTblName*/,
2708 sal_Int32 /*nWidth*/, sal_Int32 /*nHeight*/ )
2709 {
2710 Reference< XPropertySet> xPropSet;
2711 return xPropSet;
2712 }
2713
2714 Reference< XPropertySet> XMLTextImportHelper::createAndInsertApplet(
2715 const OUString& /*rCode*/,
2716 const OUString& /*rName*/,
2717 sal_Bool /*bMayScript*/,
2718 const OUString& /*rHRef*/,
2719 sal_Int32 /*nWidth*/, sal_Int32 /*nHeight*/ )
2720 {
2721 Reference< XPropertySet> xPropSet;
2722 return xPropSet;
2723 }
2724 Reference< XPropertySet> XMLTextImportHelper::createAndInsertPlugin(
2725 const OUString& /*rMimeType*/,
2726 const OUString& /*rHRef*/,
2727 sal_Int32 /*nWidth*/, sal_Int32 /*nHeight*/ )
2728 {
2729 Reference< XPropertySet> xPropSet;
2730 return xPropSet;
2731 }
2732 Reference< XPropertySet> XMLTextImportHelper::createAndInsertFloatingFrame(
2733 const OUString& /*rName*/,
2734 const OUString& /*rHRef*/,
2735 const OUString& /*rStyleName*/,
2736 sal_Int32 /*nWidth*/, sal_Int32 /*nHeight*/ )
2737 {
2738 Reference< XPropertySet> xPropSet;
2739 return xPropSet;
2740 }
2741
2742 void XMLTextImportHelper::endAppletOrPlugin(
2743 const Reference < XPropertySet> &,
2744 std::map < const OUString, OUString, UStringLess > &)
2745 {
2746 }
2747 // redline helper: dummy implementation to be overridden in sw/filter/xml
2748 void XMLTextImportHelper::RedlineAdd( const OUString& /*rType*/,
2749 const OUString& /*rId*/,
2750 const OUString& /*rAuthor*/,
2751 const OUString& /*rComment*/,
2752 const util::DateTime& /*rDateTime*/,
2753 sal_Bool /*bMergeLastPara*/)
2754 {
2755 // dummy implementation: do nothing
2756 }
2757
2758 Reference<XTextCursor> XMLTextImportHelper::RedlineCreateText(
2759 Reference<XTextCursor> & /*rOldCursor*/,
2760 const OUString& /*rId*/)
2761 {
2762 // dummy implementation: do nothing
2763 Reference<XTextCursor> xRet;
2764 return xRet;
2765 }
2766
2767 void XMLTextImportHelper::RedlineSetCursor(
2768 const OUString& /*rId*/,
2769 sal_Bool /*bStart*/,
2770 sal_Bool /*bIsOutsideOfParagraph*/)
2771 {
2772 // dummy implementation: do nothing
2773 }
2774
2775 void XMLTextImportHelper::RedlineAdjustStartNodeCursor(sal_Bool)
2776 {
2777 // dummy implementation: do nothing
2778 }
2779
2780 void XMLTextImportHelper::SetShowChanges( sal_Bool )
2781 {
2782 // dummy implementation: do nothing
2783 }
2784
2785 void XMLTextImportHelper::SetRecordChanges( sal_Bool )
2786 {
2787 // dummy implementation: do nothing
2788 }
2789 void XMLTextImportHelper::SetChangesProtectionKey(const Sequence<sal_Int8> &)
2790 {
2791 // dummy implementation: do nothing
2792 }
2793
2794
2795 OUString XMLTextImportHelper::GetOpenRedlineId()
2796 {
2797 return m_pImpl->m_sOpenRedlineIdentifier;
2798 }
2799
2800 void XMLTextImportHelper::SetOpenRedlineId( OUString& rId)
2801 {
2802 m_pImpl->m_sOpenRedlineIdentifier = rId;
2803 }
2804
2805 void XMLTextImportHelper::ResetOpenRedlineId()
2806 {
2807 OUString sEmpty;
2808 SetOpenRedlineId(sEmpty);
2809 }
2810
2811 void
2812 XMLTextImportHelper::SetCellParaStyleDefault(OUString const& rNewValue)
2813 {
2814 m_pImpl->m_sCellParaStyleDefault = rNewValue;
2815 }
2816
2817 OUString const& XMLTextImportHelper::GetCellParaStyleDefault()
2818 {
2819 return m_pImpl->m_sCellParaStyleDefault;
2820 }
2821
2822 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE