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