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