diff options
Diffstat (limited to 'xmloff/source/text/txtimp.cxx')
| -rw-r--r-- | xmloff/source/text/txtimp.cxx | 3062 |
1 files changed, 3062 insertions, 0 deletions
diff --git a/xmloff/source/text/txtimp.cxx b/xmloff/source/text/txtimp.cxx new file mode 100644 index 000000000000..87710d310d76 --- /dev/null +++ b/xmloff/source/text/txtimp.cxx @@ -0,0 +1,3062 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_xmloff.hxx" + +#include <vector> + +#include <boost/scoped_array.hpp> +#include <boost/tuple/tuple.hpp> + +#include <tools/solar.h> +#include <tools/debug.hxx> +#ifndef _SVSTDARR_STRINGSDTOR_DECL +#define _SVSTDARR_STRINGSDTOR +#include <svl/svstdarr.hxx> +#endif +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/beans/PropertyValue.hpp> +#include <com/sun/star/container/XEnumerationAccess.hpp> +#include <com/sun/star/container/XNameContainer.hpp> +#include <com/sun/star/style/XStyleFamiliesSupplier.hpp> +#include <com/sun/star/text/XTextCursor.hpp> +#include <com/sun/star/text/XChapterNumberingSupplier.hpp> +#include <com/sun/star/text/XTextFramesSupplier.hpp> +#include <com/sun/star/text/XTextGraphicObjectsSupplier.hpp> +#include <com/sun/star/text/XTextEmbeddedObjectsSupplier.hpp> +#include <com/sun/star/text/TextContentAnchorType.hpp> +#include <com/sun/star/text/XTextFrame.hpp> +#include <com/sun/star/text/XFormField.hpp> +#include <com/sun/star/drawing/XShapes.hpp> +#include <com/sun/star/util/DateTime.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/ucb/XAnyCompareFactory.hpp> +#include <com/sun/star/container/XNamed.hpp> +#include <xmloff/xmltoken.hxx> +#include "xmlnmspe.hxx" +#include <xmloff/txtstyli.hxx> +#include <xmloff/families.hxx> +#include <xmloff/xmlnumfi.hxx> +#include <xmloff/xmlnumi.hxx> +#include <xmloff/xmlictxt.hxx> +#include <xmloff/xmlimppr.hxx> + +#include "txtparai.hxx" +#include <xmloff/txtimp.hxx> +#include <xmloff/txtprmap.hxx> +#include "txtimppr.hxx" +#include <xmloff/xmlimp.hxx> +#include "txtvfldi.hxx" +#include "i18nmap.hxx" +#include "XMLTextListItemContext.hxx" +#include "XMLTextListBlockContext.hxx" +#include "XMLTextFrameContext.hxx" +#include "XMLPropertyBackpatcher.hxx" +#include "XMLTextFrameHyperlinkContext.hxx" +#include "XMLSectionImportContext.hxx" +#include "XMLIndexTOCContext.hxx" +#include <xmloff/XMLFontStylesContext.hxx> +#include <xmloff/ProgressBarHelper.hxx> +#include <xmloff/nmspmap.hxx> +#include <xmloff/XMLEventsImportContext.hxx> +#include "XMLTrackedChangesImportContext.hxx" +#include "XMLChangeImportContext.hxx" +#include "XMLAutoMarkFileContext.hxx" + +#include "XMLCalculationSettingsContext.hxx" +#include <xmloff/formsimp.hxx> +#include "XMLNumberStylesImport.hxx" +// --> OD 2006-10-12 #i69629# +#include <com/sun/star/beans/XPropertyState.hpp> +// <-- + +// --> OD 2008-04-25 #refactorlists# +#include <txtlists.hxx> +// <-- +#include <xmloff/odffields.hxx> +#include <comphelper/stlunosequence.hxx> + +using ::rtl::OUString; +using ::rtl::OUStringBuffer; +using ::com::sun::star::ucb::XAnyCompare; + +using namespace ::std; +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::text; +using namespace ::com::sun::star::frame; +using namespace ::com::sun::star::style; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::drawing; +using namespace ::com::sun::star::xml::sax; +using namespace ::com::sun::star::lang; +using namespace ::xmloff::token; +using ::com::sun::star::util::DateTime; +using namespace ::com::sun::star::ucb; +using namespace ::com::sun::star; +using ::comphelper::UStringLess; + + + +static __FAR_DATA SvXMLTokenMapEntry aTextElemTokenMap[] = +{ + { XML_NAMESPACE_TEXT, XML_P, XML_TOK_TEXT_P }, + { XML_NAMESPACE_TEXT, XML_H, XML_TOK_TEXT_H }, + { XML_NAMESPACE_TEXT, XML_LIST, XML_TOK_TEXT_LIST }, + { XML_NAMESPACE_DRAW, XML_FRAME, XML_TOK_TEXT_FRAME_PAGE }, + { XML_NAMESPACE_DRAW, XML_A, XML_TOK_DRAW_A_PAGE }, + { XML_NAMESPACE_TABLE,XML_TABLE, XML_TOK_TABLE_TABLE }, +// { XML_NAMESPACE_TABLE,XML_SUB_TABLE, XML_TOK_TABLE_SUBTABLE }, + { XML_NAMESPACE_TEXT, XML_VARIABLE_DECLS, XML_TOK_TEXT_VARFIELD_DECLS }, + { XML_NAMESPACE_TEXT, XML_USER_FIELD_DECLS, XML_TOK_TEXT_USERFIELD_DECLS }, + { XML_NAMESPACE_TEXT, XML_SEQUENCE_DECLS, XML_TOK_TEXT_SEQUENCE_DECLS }, + { XML_NAMESPACE_TEXT, XML_DDE_CONNECTION_DECLS, XML_TOK_TEXT_DDE_DECLS }, + { XML_NAMESPACE_TEXT, XML_SECTION, XML_TOK_TEXT_SECTION }, + { XML_NAMESPACE_TEXT, XML_TABLE_OF_CONTENT, XML_TOK_TEXT_TOC }, + { XML_NAMESPACE_TEXT, XML_OBJECT_INDEX, XML_TOK_TEXT_OBJECT_INDEX }, + { XML_NAMESPACE_TEXT, XML_TABLE_INDEX, XML_TOK_TEXT_TABLE_INDEX }, + { XML_NAMESPACE_TEXT, XML_ILLUSTRATION_INDEX, XML_TOK_TEXT_ILLUSTRATION_INDEX }, + { XML_NAMESPACE_TEXT, XML_USER_INDEX, XML_TOK_TEXT_USER_INDEX }, + { XML_NAMESPACE_TEXT, XML_ALPHABETICAL_INDEX, XML_TOK_TEXT_ALPHABETICAL_INDEX }, + { XML_NAMESPACE_TEXT, XML_BIBLIOGRAPHY, XML_TOK_TEXT_BIBLIOGRAPHY_INDEX }, + { XML_NAMESPACE_TEXT, XML_INDEX_TITLE, XML_TOK_TEXT_INDEX_TITLE }, + { XML_NAMESPACE_TEXT, XML_TRACKED_CHANGES, XML_TOK_TEXT_TRACKED_CHANGES }, + { XML_NAMESPACE_TEXT, XML_CHANGE_START, XML_TOK_TEXT_CHANGE_START }, + { XML_NAMESPACE_TEXT, XML_CHANGE_END, XML_TOK_TEXT_CHANGE_END }, + { XML_NAMESPACE_TEXT, XML_CHANGE, XML_TOK_TEXT_CHANGE }, + { XML_NAMESPACE_OFFICE, XML_FORMS, XML_TOK_TEXT_FORMS }, + { XML_NAMESPACE_TABLE, XML_CALCULATION_SETTINGS, XML_TOK_TEXT_CALCULATION_SETTINGS }, + { XML_NAMESPACE_TEXT, XML_ALPHABETICAL_INDEX_AUTO_MARK_FILE, XML_TOK_TEXT_AUTOMARK }, + // --> FLR #i52127# + { XML_NAMESPACE_TEXT, XML_NUMBERED_PARAGRAPH, XML_TOK_TEXT_NUMBERED_PARAGRAPH }, + // <-- + + XML_TOKEN_MAP_END +}; + +static __FAR_DATA SvXMLTokenMapEntry aTextPElemTokenMap[] = +{ + { XML_NAMESPACE_TEXT, XML_SPAN, XML_TOK_TEXT_SPAN }, + { XML_NAMESPACE_TEXT, XML_TAB, XML_TOK_TEXT_TAB_STOP }, + { XML_NAMESPACE_TEXT, XML_LINE_BREAK, XML_TOK_TEXT_LINE_BREAK }, + { XML_NAMESPACE_TEXT, XML_SOFT_PAGE_BREAK, XML_TOK_TEXT_SOFT_PAGE_BREAK }, + { XML_NAMESPACE_TEXT, XML_S, XML_TOK_TEXT_S }, + { XML_NAMESPACE_TEXT, XML_A, XML_TOK_TEXT_HYPERLINK }, + { XML_NAMESPACE_TEXT, XML_RUBY, XML_TOK_TEXT_RUBY }, + + { XML_NAMESPACE_TEXT, XML_NOTE, XML_TOK_TEXT_NOTE }, + { XML_NAMESPACE_TEXT, XML_BOOKMARK, XML_TOK_TEXT_BOOKMARK }, + { XML_NAMESPACE_TEXT, XML_BOOKMARK_START, XML_TOK_TEXT_BOOKMARK_START }, + { XML_NAMESPACE_TEXT, XML_BOOKMARK_END, XML_TOK_TEXT_BOOKMARK_END }, + { XML_NAMESPACE_TEXT, XML_REFERENCE_MARK, XML_TOK_TEXT_REFERENCE }, + { XML_NAMESPACE_TEXT, XML_REFERENCE_MARK_START, + XML_TOK_TEXT_REFERENCE_START }, + { XML_NAMESPACE_TEXT, XML_REFERENCE_MARK_END, + XML_TOK_TEXT_REFERENCE_END }, + + { XML_NAMESPACE_DRAW, XML_FRAME, XML_TOK_TEXT_FRAME }, + { XML_NAMESPACE_DRAW, XML_A, XML_TOK_DRAW_A }, + + // index marks + { XML_NAMESPACE_TEXT, XML_TOC_MARK, XML_TOK_TEXT_TOC_MARK }, + { XML_NAMESPACE_TEXT, XML_TOC_MARK_START, XML_TOK_TEXT_TOC_MARK_START }, + { XML_NAMESPACE_TEXT, XML_TOC_MARK_END, XML_TOK_TEXT_TOC_MARK_END }, + { XML_NAMESPACE_TEXT, XML_USER_INDEX_MARK, XML_TOK_TEXT_USER_INDEX_MARK }, + { XML_NAMESPACE_TEXT, XML_USER_INDEX_MARK_START, + XML_TOK_TEXT_USER_INDEX_MARK_START }, + { XML_NAMESPACE_TEXT, XML_USER_INDEX_MARK_END, + XML_TOK_TEXT_USER_INDEX_MARK_END }, + { XML_NAMESPACE_TEXT, XML_ALPHABETICAL_INDEX_MARK, + XML_TOK_TEXT_ALPHA_INDEX_MARK }, + { XML_NAMESPACE_TEXT, XML_ALPHABETICAL_INDEX_MARK_START, + XML_TOK_TEXT_ALPHA_INDEX_MARK_START }, + { XML_NAMESPACE_TEXT, XML_ALPHABETICAL_INDEX_MARK_END, + XML_TOK_TEXT_ALPHA_INDEX_MARK_END }, + + // sender fields + { XML_NAMESPACE_TEXT, XML_SENDER_FIRSTNAME,XML_TOK_TEXT_SENDER_FIRSTNAME}, + { XML_NAMESPACE_TEXT, XML_SENDER_LASTNAME, XML_TOK_TEXT_SENDER_LASTNAME }, + { XML_NAMESPACE_TEXT, XML_SENDER_INITIALS, XML_TOK_TEXT_SENDER_INITIALS }, + { XML_NAMESPACE_TEXT, XML_SENDER_TITLE, XML_TOK_TEXT_SENDER_TITLE }, + { XML_NAMESPACE_TEXT, XML_SENDER_POSITION, XML_TOK_TEXT_SENDER_POSITION }, + { XML_NAMESPACE_TEXT, XML_SENDER_EMAIL, XML_TOK_TEXT_SENDER_EMAIL }, + { XML_NAMESPACE_TEXT, XML_SENDER_PHONE_PRIVATE, + XML_TOK_TEXT_SENDER_PHONE_PRIVATE }, + { XML_NAMESPACE_TEXT, XML_SENDER_FAX, XML_TOK_TEXT_SENDER_FAX }, + { XML_NAMESPACE_TEXT, XML_SENDER_COMPANY, XML_TOK_TEXT_SENDER_COMPANY }, + { XML_NAMESPACE_TEXT, XML_SENDER_PHONE_WORK, + XML_TOK_TEXT_SENDER_PHONE_WORK }, + { XML_NAMESPACE_TEXT, XML_SENDER_STREET, XML_TOK_TEXT_SENDER_STREET }, + { XML_NAMESPACE_TEXT, XML_SENDER_CITY, XML_TOK_TEXT_SENDER_CITY }, + { XML_NAMESPACE_TEXT, XML_SENDER_POSTAL_CODE, + XML_TOK_TEXT_SENDER_POSTAL_CODE }, + { XML_NAMESPACE_TEXT, XML_SENDER_COUNTRY, XML_TOK_TEXT_SENDER_COUNTRY }, + { XML_NAMESPACE_TEXT, XML_SENDER_STATE_OR_PROVINCE, + XML_TOK_TEXT_SENDER_STATE_OR_PROVINCE }, + + // misc. document fields + { XML_NAMESPACE_TEXT, XML_AUTHOR_NAME, XML_TOK_TEXT_AUTHOR_NAME }, + { XML_NAMESPACE_TEXT, XML_AUTHOR_INITIALS, XML_TOK_TEXT_AUTHOR_INITIALS }, + { XML_NAMESPACE_TEXT, XML_DATE, XML_TOK_TEXT_DATE }, + { XML_NAMESPACE_TEXT, XML_TIME, XML_TOK_TEXT_TIME }, + { XML_NAMESPACE_TEXT, XML_PAGE_NUMBER, XML_TOK_TEXT_PAGE_NUMBER }, + { XML_NAMESPACE_TEXT, XML_PAGE_CONTINUATION_STRING, + XML_TOK_TEXT_PAGE_CONTINUATION_STRING }, + + // variable fields + { XML_NAMESPACE_TEXT, XML_VARIABLE_SET, XML_TOK_TEXT_VARIABLE_SET }, + { XML_NAMESPACE_TEXT, XML_VARIABLE_GET, XML_TOK_TEXT_VARIABLE_GET }, + { XML_NAMESPACE_TEXT, XML_VARIABLE_INPUT, XML_TOK_TEXT_VARIABLE_INPUT }, + { XML_NAMESPACE_TEXT, XML_USER_FIELD_GET, XML_TOK_TEXT_USER_FIELD_GET }, + { XML_NAMESPACE_TEXT, XML_USER_FIELD_INPUT,XML_TOK_TEXT_USER_FIELD_INPUT}, + { XML_NAMESPACE_TEXT, XML_SEQUENCE, XML_TOK_TEXT_SEQUENCE }, + { XML_NAMESPACE_TEXT, XML_EXPRESSION, XML_TOK_TEXT_EXPRESSION }, + { XML_NAMESPACE_TEXT, XML_TEXT_INPUT, XML_TOK_TEXT_TEXT_INPUT }, + + // database fields + { XML_NAMESPACE_TEXT, XML_DATABASE_DISPLAY, + XML_TOK_TEXT_DATABASE_DISPLAY }, + { XML_NAMESPACE_TEXT, XML_DATABASE_NEXT, + XML_TOK_TEXT_DATABASE_NEXT }, + { XML_NAMESPACE_TEXT, XML_DATABASE_ROW_SELECT, + XML_TOK_TEXT_DATABASE_SELECT }, + { XML_NAMESPACE_TEXT, XML_DATABASE_ROW_NUMBER, + XML_TOK_TEXT_DATABASE_ROW_NUMBER }, + { XML_NAMESPACE_TEXT, XML_DATABASE_NAME, XML_TOK_TEXT_DATABASE_NAME }, + + // docinfo fields + { XML_NAMESPACE_TEXT, XML_INITIAL_CREATOR, + XML_TOK_TEXT_DOCUMENT_CREATION_AUTHOR }, + { XML_NAMESPACE_TEXT, XML_DESCRIPTION, XML_TOK_TEXT_DOCUMENT_DESCRIPTION}, + { XML_NAMESPACE_TEXT, XML_PRINTED_BY, XML_TOK_TEXT_DOCUMENT_PRINT_AUTHOR}, + { XML_NAMESPACE_TEXT, XML_TITLE, XML_TOK_TEXT_DOCUMENT_TITLE }, + { XML_NAMESPACE_TEXT, XML_SUBJECT, XML_TOK_TEXT_DOCUMENT_SUBJECT }, + { XML_NAMESPACE_TEXT, XML_KEYWORDS, XML_TOK_TEXT_DOCUMENT_KEYWORDS }, + { XML_NAMESPACE_TEXT, XML_CREATOR, XML_TOK_TEXT_DOCUMENT_SAVE_AUTHOR }, + { XML_NAMESPACE_TEXT, XML_EDITING_CYCLES, + XML_TOK_TEXT_DOCUMENT_REVISION }, + { XML_NAMESPACE_TEXT, XML_CREATION_DATE, + XML_TOK_TEXT_DOCUMENT_CREATION_DATE }, + { XML_NAMESPACE_TEXT, XML_CREATION_TIME, + XML_TOK_TEXT_DOCUMENT_CREATION_TIME }, + { XML_NAMESPACE_TEXT, XML_PRINT_DATE, XML_TOK_TEXT_DOCUMENT_PRINT_DATE }, + { XML_NAMESPACE_TEXT, XML_PRINT_TIME, XML_TOK_TEXT_DOCUMENT_PRINT_TIME }, + { XML_NAMESPACE_TEXT, XML_MODIFICATION_DATE, + XML_TOK_TEXT_DOCUMENT_SAVE_DATE }, + { XML_NAMESPACE_TEXT, XML_MODIFICATION_TIME, + XML_TOK_TEXT_DOCUMENT_SAVE_TIME }, + { XML_NAMESPACE_TEXT, XML_EDITING_DURATION, + XML_TOK_TEXT_DOCUMENT_EDIT_DURATION }, + { XML_NAMESPACE_TEXT, XML_USER_DEFINED, + XML_TOK_TEXT_DOCUMENT_USER_DEFINED }, + + // misc fields + { XML_NAMESPACE_TEXT, XML_PLACEHOLDER, XML_TOK_TEXT_PLACEHOLDER }, + { XML_NAMESPACE_TEXT, XML_HIDDEN_TEXT, XML_TOK_TEXT_HIDDEN_TEXT }, + { XML_NAMESPACE_TEXT, XML_HIDDEN_PARAGRAPH, + XML_TOK_TEXT_HIDDEN_PARAGRAPH }, + { XML_NAMESPACE_TEXT, XML_CONDITIONAL_TEXT, + XML_TOK_TEXT_CONDITIONAL_TEXT }, + { XML_NAMESPACE_TEXT, XML_FILE_NAME, XML_TOK_TEXT_FILENAME }, + { XML_NAMESPACE_TEXT, XML_CHAPTER, XML_TOK_TEXT_CHAPTER }, + { XML_NAMESPACE_TEXT, XML_TEMPLATE_NAME, XML_TOK_TEXT_TEMPLATENAME }, + { XML_NAMESPACE_TEXT, XML_PARAGRAPH_COUNT, XML_TOK_TEXT_PARAGRAPH_COUNT }, + { XML_NAMESPACE_TEXT, XML_WORD_COUNT, XML_TOK_TEXT_WORD_COUNT }, + { XML_NAMESPACE_TEXT, XML_TABLE_COUNT, XML_TOK_TEXT_TABLE_COUNT }, + { XML_NAMESPACE_TEXT, XML_CHARACTER_COUNT, XML_TOK_TEXT_CHARACTER_COUNT }, + { XML_NAMESPACE_TEXT, XML_IMAGE_COUNT, XML_TOK_TEXT_IMAGE_COUNT }, + { XML_NAMESPACE_TEXT, XML_OBJECT_COUNT, XML_TOK_TEXT_OBJECT_COUNT }, + { XML_NAMESPACE_TEXT, XML_PAGE_COUNT, XML_TOK_TEXT_PAGE_COUNT }, + { XML_NAMESPACE_TEXT, XML_PAGE_VARIABLE_GET, XML_TOK_TEXT_GET_PAGE_VAR }, + { XML_NAMESPACE_TEXT, XML_PAGE_VARIABLE_SET, XML_TOK_TEXT_SET_PAGE_VAR }, + { XML_NAMESPACE_TEXT, XML_EXECUTE_MACRO, XML_TOK_TEXT_MACRO }, + { XML_NAMESPACE_TEXT, XML_DDE_CONNECTION, XML_TOK_TEXT_DDE }, + { XML_NAMESPACE_TEXT, XML_REFERENCE_REF, XML_TOK_TEXT_REFERENCE_REF }, + { XML_NAMESPACE_TEXT, XML_BOOKMARK_REF, XML_TOK_TEXT_BOOKMARK_REF }, + { XML_NAMESPACE_TEXT, XML_SEQUENCE_REF, XML_TOK_TEXT_SEQUENCE_REF }, + { XML_NAMESPACE_TEXT, XML_NOTE_REF, XML_TOK_TEXT_NOTE_REF }, + { XML_NAMESPACE_TEXT, XML_BIBLIOGRAPHY_MARK, + XML_TOK_TEXT_BIBLIOGRAPHY_MARK }, + { XML_NAMESPACE_OFFICE, XML_ANNOTATION, XML_TOK_TEXT_ANNOTATION }, + { XML_NAMESPACE_TEXT, XML_SCRIPT, XML_TOK_TEXT_SCRIPT }, + { XML_NAMESPACE_TEXT, XML_TABLE_FORMULA, XML_TOK_TEXT_TABLE_FORMULA }, + { XML_NAMESPACE_TEXT, XML_DROPDOWN, XML_TOK_TEXT_DROPDOWN }, + + // Calc fields + { XML_NAMESPACE_TEXT, XML_SHEET_NAME, XML_TOK_TEXT_SHEET_NAME }, + + // draw fields + { XML_NAMESPACE_TEXT, XML_MEASURE, XML_TOK_TEXT_MEASURE }, + + // RDF metadata + { XML_NAMESPACE_TEXT, XML_META, XML_TOK_TEXT_META }, + { XML_NAMESPACE_TEXT, XML_META_FIELD, XML_TOK_TEXT_META_FIELD }, + + // redlining (aka change tracking) + { XML_NAMESPACE_TEXT, XML_CHANGE_START, XML_TOK_TEXTP_CHANGE_START }, + { XML_NAMESPACE_TEXT, XML_CHANGE_END , XML_TOK_TEXTP_CHANGE_END }, + { XML_NAMESPACE_TEXT, XML_CHANGE, XML_TOK_TEXTP_CHANGE }, + + { XML_NAMESPACE_PRESENTATION, XML_HEADER, XML_TOK_DRAW_HEADER }, + { XML_NAMESPACE_PRESENTATION, XML_FOOTER, XML_TOK_DRAW_FOOTER }, + { XML_NAMESPACE_PRESENTATION, XML_DATE_TIME, XML_TOK_DRAW_DATE_TIME }, + { XML_NAMESPACE_TEXT, XML_PAGE_CONTINUATION, XML_TOK_TEXT_PAGE_CONTINUATION }, + + { XML_NAMESPACE_FIELD, XML_FIELDMARK, XML_TOK_TEXT_FIELDMARK }, + { XML_NAMESPACE_FIELD, XML_FIELDMARK_START, XML_TOK_TEXT_FIELDMARK_START }, + { XML_NAMESPACE_FIELD, XML_FIELDMARK_END, XML_TOK_TEXT_FIELDMARK_END }, + + + XML_TOKEN_MAP_END +}; + +static __FAR_DATA SvXMLTokenMapEntry aTextPAttrTokenMap[] = +{ + { XML_NAMESPACE_XML , XML_ID, XML_TOK_TEXT_P_XMLID }, + { XML_NAMESPACE_XHTML, XML_ABOUT, XML_TOK_TEXT_P_ABOUT }, + { XML_NAMESPACE_XHTML, XML_PROPERTY, XML_TOK_TEXT_P_PROPERTY }, + { XML_NAMESPACE_XHTML, XML_CONTENT, XML_TOK_TEXT_P_CONTENT }, + { XML_NAMESPACE_XHTML, XML_DATATYPE, XML_TOK_TEXT_P_DATATYPE }, + { XML_NAMESPACE_TEXT, XML_ID, XML_TOK_TEXT_P_TEXTID }, + { XML_NAMESPACE_TEXT, XML_STYLE_NAME, XML_TOK_TEXT_P_STYLE_NAME }, + { XML_NAMESPACE_TEXT, XML_COND_STYLE_NAME, + XML_TOK_TEXT_P_COND_STYLE_NAME }, + { XML_NAMESPACE_TEXT, XML_OUTLINE_LEVEL,XML_TOK_TEXT_P_LEVEL }, + { XML_NAMESPACE_TEXT, XML_IS_LIST_HEADER,XML_TOK_TEXT_P_IS_LIST_HEADER }, + { XML_NAMESPACE_TEXT, XML_RESTART_NUMBERING,XML_TOK_TEXT_P_RESTART_NUMBERING }, + { XML_NAMESPACE_TEXT, XML_START_VALUE,XML_TOK_TEXT_P_START_VALUE }, + XML_TOKEN_MAP_END +}; + +static __FAR_DATA SvXMLTokenMapEntry aTextNumberedParagraphAttrTokenMap[] = +{ + { XML_NAMESPACE_XML , XML_ID, XML_TOK_TEXT_NUMBERED_PARAGRAPH_XMLID }, + { XML_NAMESPACE_TEXT, XML_LIST_ID, + XML_TOK_TEXT_NUMBERED_PARAGRAPH_LIST_ID }, + { XML_NAMESPACE_TEXT, XML_LEVEL, XML_TOK_TEXT_NUMBERED_PARAGRAPH_LEVEL }, + { XML_NAMESPACE_TEXT, XML_STYLE_NAME, + XML_TOK_TEXT_NUMBERED_PARAGRAPH_STYLE_NAME }, + { XML_NAMESPACE_TEXT, XML_CONTINUE_NUMBERING, + XML_TOK_TEXT_NUMBERED_PARAGRAPH_CONTINUE_NUMBERING }, + { XML_NAMESPACE_TEXT, XML_START_VALUE, + XML_TOK_TEXT_NUMBERED_PARAGRAPH_START_VALUE }, + XML_TOKEN_MAP_END +}; + +static __FAR_DATA SvXMLTokenMapEntry aTextListBlockAttrTokenMap[] = +{ + { XML_NAMESPACE_XML , XML_ID, XML_TOK_TEXT_LIST_BLOCK_XMLID }, + { XML_NAMESPACE_TEXT, XML_STYLE_NAME, + XML_TOK_TEXT_LIST_BLOCK_STYLE_NAME }, + { XML_NAMESPACE_TEXT, XML_CONTINUE_NUMBERING, + XML_TOK_TEXT_LIST_BLOCK_CONTINUE_NUMBERING }, + // --> OD 2008-04-22 #refactorlists# + { XML_NAMESPACE_TEXT, XML_CONTINUE_LIST, + XML_TOK_TEXT_LIST_BLOCK_CONTINUE_LIST }, + XML_TOKEN_MAP_END +}; + +static __FAR_DATA SvXMLTokenMapEntry aTextListBlockElemTokenMap[] = +{ + { XML_NAMESPACE_TEXT, XML_LIST_HEADER, XML_TOK_TEXT_LIST_HEADER }, + { XML_NAMESPACE_TEXT, XML_LIST_ITEM, XML_TOK_TEXT_LIST_ITEM }, + XML_TOKEN_MAP_END +}; + +static __FAR_DATA SvXMLTokenMapEntry aTextFrameAttrTokenMap[] = +{ + { XML_NAMESPACE_DRAW, XML_STYLE_NAME, XML_TOK_TEXT_FRAME_STYLE_NAME }, + { XML_NAMESPACE_DRAW, XML_NAME, XML_TOK_TEXT_FRAME_NAME }, + { XML_NAMESPACE_TEXT, XML_ANCHOR_TYPE, XML_TOK_TEXT_FRAME_ANCHOR_TYPE }, + { XML_NAMESPACE_TEXT, XML_ANCHOR_PAGE_NUMBER, XML_TOK_TEXT_FRAME_ANCHOR_PAGE_NUMBER }, + { XML_NAMESPACE_SVG, XML_X, XML_TOK_TEXT_FRAME_X }, + { XML_NAMESPACE_SVG, XML_Y, XML_TOK_TEXT_FRAME_Y }, + { XML_NAMESPACE_SVG, XML_WIDTH, XML_TOK_TEXT_FRAME_WIDTH }, + { XML_NAMESPACE_FO, XML_MIN_WIDTH, XML_TOK_TEXT_FRAME_MIN_WIDTH }, + { XML_NAMESPACE_STYLE, XML_REL_WIDTH, XML_TOK_TEXT_FRAME_REL_WIDTH }, + { XML_NAMESPACE_SVG, XML_HEIGHT, XML_TOK_TEXT_FRAME_HEIGHT }, + { XML_NAMESPACE_FO, XML_MIN_HEIGHT, XML_TOK_TEXT_FRAME_MIN_HEIGHT }, + { XML_NAMESPACE_STYLE, XML_REL_HEIGHT, XML_TOK_TEXT_FRAME_REL_HEIGHT }, + { XML_NAMESPACE_DRAW, XML_CHAIN_NEXT_NAME, XML_TOK_TEXT_FRAME_NEXT_CHAIN_NAME }, + { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_TEXT_FRAME_HREF }, + { XML_NAMESPACE_DRAW, XML_NAME, XML_TOK_TEXT_FRAME_FILTER_NAME }, + { XML_NAMESPACE_DRAW, XML_ZINDEX, XML_TOK_TEXT_FRAME_Z_INDEX }, + { XML_NAMESPACE_SVG, XML_TRANSFORM, XML_TOK_TEXT_FRAME_TRANSFORM }, + { XML_NAMESPACE_DRAW, XML_CLASS_ID, XML_TOK_TEXT_FRAME_CLASS_ID }, + { XML_NAMESPACE_DRAW, XML_CODE, XML_TOK_TEXT_FRAME_CODE }, + { XML_NAMESPACE_DRAW, XML_OBJECT, XML_TOK_TEXT_FRAME_OBJECT }, + { XML_NAMESPACE_DRAW, XML_ARCHIVE, XML_TOK_TEXT_FRAME_ARCHIVE }, + { XML_NAMESPACE_DRAW, XML_MAY_SCRIPT, XML_TOK_TEXT_FRAME_MAY_SCRIPT }, + { XML_NAMESPACE_DRAW, XML_MIME_TYPE, XML_TOK_TEXT_FRAME_MIME_TYPE }, + { XML_NAMESPACE_DRAW, XML_APPLET_NAME, XML_TOK_TEXT_FRAME_APPLET_NAME }, + { XML_NAMESPACE_DRAW, XML_FRAME_NAME, XML_TOK_TEXT_FRAME_FRAME_NAME }, + { XML_NAMESPACE_DRAW, XML_NOTIFY_ON_UPDATE_OF_RANGES, XML_TOK_TEXT_FRAME_NOTIFY_ON_UPDATE }, + { XML_NAMESPACE_DRAW, XML_NOTIFY_ON_UPDATE_OF_TABLE, XML_TOK_TEXT_FRAME_NOTIFY_ON_UPDATE }, + XML_TOKEN_MAP_END +}; + +static __FAR_DATA SvXMLTokenMapEntry aTextContourAttrTokenMap[] = +{ + { XML_NAMESPACE_SVG, XML_WIDTH, XML_TOK_TEXT_CONTOUR_WIDTH }, + { XML_NAMESPACE_SVG, XML_HEIGHT, XML_TOK_TEXT_CONTOUR_HEIGHT }, + { XML_NAMESPACE_SVG, XML_VIEWBOX, XML_TOK_TEXT_CONTOUR_VIEWBOX }, + { XML_NAMESPACE_SVG, XML_D, XML_TOK_TEXT_CONTOUR_D }, + { XML_NAMESPACE_DRAW,XML_POINTS, XML_TOK_TEXT_CONTOUR_POINTS }, + { XML_NAMESPACE_DRAW,XML_RECREATE_ON_EDIT, XML_TOK_TEXT_CONTOUR_AUTO }, + XML_TOKEN_MAP_END +}; + +static __FAR_DATA SvXMLTokenMapEntry aTextHyperlinkAttrTokenMap[] = +{ + { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_TEXT_HYPERLINK_HREF }, + { XML_NAMESPACE_OFFICE, XML_NAME, XML_TOK_TEXT_HYPERLINK_NAME }, + { XML_NAMESPACE_XLINK, XML_SHOW, XML_TOK_TEXT_HYPERLINK_SHOW }, + { XML_NAMESPACE_OFFICE, XML_TARGET_FRAME_NAME, XML_TOK_TEXT_HYPERLINK_TARGET_FRAME }, + { XML_NAMESPACE_TEXT, XML_STYLE_NAME, XML_TOK_TEXT_HYPERLINK_STYLE_NAME }, + { XML_NAMESPACE_TEXT, XML_VISITED_STYLE_NAME, XML_TOK_TEXT_HYPERLINK_VIS_STYLE_NAME }, + { XML_NAMESPACE_OFFICE, XML_SERVER_MAP, XML_TOK_TEXT_HYPERLINK_SERVER_MAP }, + XML_TOKEN_MAP_END +}; + +static __FAR_DATA SvXMLTokenMapEntry aTextMasterPageElemTokenMap[] = +{ + { XML_NAMESPACE_STYLE, XML_HEADER, XML_TOK_TEXT_MP_HEADER }, + { XML_NAMESPACE_STYLE, XML_FOOTER, XML_TOK_TEXT_MP_FOOTER }, + { XML_NAMESPACE_STYLE, XML_HEADER_LEFT, XML_TOK_TEXT_MP_HEADER_LEFT }, + { XML_NAMESPACE_STYLE, XML_FOOTER_LEFT, XML_TOK_TEXT_MP_FOOTER_LEFT }, + + XML_TOKEN_MAP_END +}; + +static __FAR_DATA SvXMLTokenMapEntry aTextFieldAttrTokenMap[] = +{ + { XML_NAMESPACE_TEXT, XML_FIXED, XML_TOK_TEXTFIELD_FIXED }, + { XML_NAMESPACE_TEXT, XML_DESCRIPTION, XML_TOK_TEXTFIELD_DESCRIPTION }, + { XML_NAMESPACE_TEXT, XML_HELP, XML_TOK_TEXTFIELD_HELP }, + { XML_NAMESPACE_TEXT, XML_HINT, XML_TOK_TEXTFIELD_HINT }, + { XML_NAMESPACE_TEXT, XML_PLACEHOLDER_TYPE, + XML_TOK_TEXTFIELD_PLACEHOLDER_TYPE }, + { XML_NAMESPACE_TEXT, XML_NAME, XML_TOK_TEXTFIELD_NAME }, + { XML_NAMESPACE_TEXT, XML_FORMULA, XML_TOK_TEXTFIELD_FORMULA }, + { XML_NAMESPACE_STYLE, XML_NUM_FORMAT, XML_TOK_TEXTFIELD_NUM_FORMAT }, + { XML_NAMESPACE_STYLE, XML_NUM_LETTER_SYNC, + XML_TOK_TEXTFIELD_NUM_LETTER_SYNC }, + { XML_NAMESPACE_TEXT, XML_DISPLAY_FORMULA, + XML_TOK_TEXTFIELD_DISPLAY_FORMULA }, + { XML_NAMESPACE_TEXT, XML_VALUE_TYPE, XML_TOK_TEXTFIELD_VALUE_TYPE }, // #i32362#: src680m48++ saves text:value-type + { XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_TOK_TEXTFIELD_VALUE_TYPE }, + { XML_NAMESPACE_TEXT, XML_VALUE, XML_TOK_TEXTFIELD_VALUE }, + { XML_NAMESPACE_OFFICE, XML_VALUE, XML_TOK_TEXTFIELD_VALUE }, + { XML_NAMESPACE_TEXT, XML_STRING_VALUE, XML_TOK_TEXTFIELD_STRING_VALUE }, + { XML_NAMESPACE_OFFICE, XML_STRING_VALUE, XML_TOK_TEXTFIELD_STRING_VALUE }, + { XML_NAMESPACE_TEXT, XML_DATE_VALUE, XML_TOK_TEXTFIELD_DATE_VALUE }, + { XML_NAMESPACE_OFFICE, XML_DATE_VALUE, XML_TOK_TEXTFIELD_DATE_VALUE }, + { XML_NAMESPACE_TEXT, XML_TIME_VALUE, XML_TOK_TEXTFIELD_TIME_VALUE }, + { XML_NAMESPACE_OFFICE, XML_TIME_VALUE, XML_TOK_TEXTFIELD_TIME_VALUE }, + { XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, XML_TOK_TEXTFIELD_BOOL_VALUE}, + { XML_NAMESPACE_OFFICE, XML_CURRENCY, XML_TOK_TEXTFIELD_CURRENCY}, + { XML_NAMESPACE_STYLE, XML_DATA_STYLE_NAME, + XML_TOK_TEXTFIELD_DATA_STYLE_NAME }, + { XML_NAMESPACE_TEXT, XML_DISPLAY_OUTLINE_LEVEL, + XML_TOK_TEXTFIELD_NUMBERING_LEVEL }, + { XML_NAMESPACE_TEXT, XML_SEPARATION_CHARACTER, + XML_TOK_TEXTFIELD_NUMBERING_SEPARATOR }, + { XML_NAMESPACE_TEXT, XML_DISPLAY, XML_TOK_TEXTFIELD_DISPLAY }, + { XML_NAMESPACE_TEXT, XML_TIME_ADJUST, XML_TOK_TEXTFIELD_TIME_ADJUST }, + { XML_NAMESPACE_TEXT, XML_DATE_ADJUST, XML_TOK_TEXTFIELD_DATE_ADJUST }, + { XML_NAMESPACE_TEXT, XML_PAGE_ADJUST, XML_TOK_TEXTFIELD_PAGE_ADJUST }, + { XML_NAMESPACE_TEXT, XML_SELECT_PAGE, XML_TOK_TEXTFIELD_SELECT_PAGE }, + { XML_NAMESPACE_TEXT, XML_DATABASE_NAME, XML_TOK_TEXTFIELD_DATABASE_NAME}, + { XML_NAMESPACE_TEXT, XML_TABLE_NAME, XML_TOK_TEXTFIELD_TABLE_NAME }, + { XML_NAMESPACE_TEXT, XML_COLUMN_NAME, XML_TOK_TEXTFIELD_COLUMN_NAME }, + { XML_NAMESPACE_TEXT, XML_ROW_NUMBER, XML_TOK_TEXTFIELD_ROW_NUMBER }, + { XML_NAMESPACE_TEXT, XML_CONDITION, XML_TOK_TEXTFIELD_CONDITION }, + { XML_NAMESPACE_TEXT, XML_STRING_VALUE_IF_TRUE, + XML_TOK_TEXTFIELD_STRING_VALUE_IF_TRUE }, + { XML_NAMESPACE_TEXT, XML_STRING_VALUE_IF_FALSE, + XML_TOK_TEXTFIELD_STRING_VALUE_IF_FALSE }, + { XML_NAMESPACE_TEXT, XML_EDITING_CYCLES, XML_TOK_TEXTFIELD_REVISION }, + { XML_NAMESPACE_TEXT, XML_OUTLINE_LEVEL, XML_TOK_TEXTFIELD_OUTLINE_LEVEL}, + { XML_NAMESPACE_TEXT, XML_ACTIVE, XML_TOK_TEXTFIELD_ACTIVE }, + { XML_NAMESPACE_TEXT, XML_NOTE_CLASS, XML_TOK_TEXTFIELD_NOTE_CLASS }, + { XML_NAMESPACE_TEXT, XML_REFERENCE_FORMAT, + XML_TOK_TEXTFIELD_REFERENCE_FORMAT }, + { XML_NAMESPACE_TEXT, XML_REF_NAME, XML_TOK_TEXTFIELD_REF_NAME }, + { XML_NAMESPACE_TEXT, XML_CONNECTION_NAME, + XML_TOK_TEXTFIELD_CONNECTION_NAME }, + { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_TEXTFIELD_HREF }, + { XML_NAMESPACE_OFFICE, XML_TARGET_FRAME_NAME, + XML_TOK_TEXTFIELD_TARGET_FRAME }, + { XML_NAMESPACE_TEXT, XML_ANNOTATION, XML_TOK_TEXTFIELD_ANNOTATION }, + { XML_NAMESPACE_SCRIPT, XML_LANGUAGE, XML_TOK_TEXTFIELD_LANGUAGE }, + { XML_NAMESPACE_TEXT, XML_KIND, XML_TOK_TEXTFIELD_MEASURE_KIND }, + { XML_NAMESPACE_TEXT, XML_IS_HIDDEN, XML_TOK_TEXTFIELD_IS_HIDDEN }, + { XML_NAMESPACE_TEXT, XML_CURRENT_VALUE, + XML_TOK_TEXTFIELD_CURRENT_VALUE }, + { XML_NAMESPACE_TEXT, XML_TABLE_TYPE, XML_TOK_TEXTFIELD_TABLE_TYPE }, + + XML_TOKEN_MAP_END +}; + + +// maximum allowed length of combined characters field +#define MAX_COMBINED_CHARACTERS 6 + +struct SAL_DLLPRIVATE XMLTextImportHelper::Impl + : private ::boost::noncopyable +{ + ::std::auto_ptr<SvXMLTokenMap> m_pTextElemTokenMap; + ::std::auto_ptr<SvXMLTokenMap> m_pTextPElemTokenMap; + ::std::auto_ptr<SvXMLTokenMap> m_pTextPAttrTokenMap; + ::std::auto_ptr<SvXMLTokenMap> m_pTextFieldAttrTokenMap; + ::std::auto_ptr<SvXMLTokenMap> m_pTextNumberedParagraphAttrTokenMap; + ::std::auto_ptr<SvXMLTokenMap> m_pTextListBlockAttrTokenMap; + ::std::auto_ptr<SvXMLTokenMap> m_pTextListBlockElemTokenMap; + ::std::auto_ptr<SvXMLTokenMap> m_pTextFrameAttrTokenMap; + ::std::auto_ptr<SvXMLTokenMap> m_pTextContourAttrTokenMap; + ::std::auto_ptr<SvXMLTokenMap> m_pTextHyperlinkAttrTokenMap; + ::std::auto_ptr<SvXMLTokenMap> m_pTextMasterPageElemTokenMap; + ::std::auto_ptr<SvStringsDtor> m_pPrevFrmNames; + ::std::auto_ptr<SvStringsDtor> m_pNextFrmNames; + + // --> OD 2008-04-25 #refactorlists# + ::std::auto_ptr<XMLTextListsHelper> m_pTextListsHelper; + // <-- + + SvXMLImportContextRef m_xAutoStyles; + SvXMLImportContextRef m_xFontDecls; + + XMLSectionList_Impl m_SectionList; + + UniReference< SvXMLImportPropertyMapper > m_xParaImpPrMap; + UniReference< SvXMLImportPropertyMapper > m_xTextImpPrMap; + UniReference< SvXMLImportPropertyMapper > m_xFrameImpPrMap; + UniReference< SvXMLImportPropertyMapper > m_xSectionImpPrMap; + UniReference< SvXMLImportPropertyMapper > m_xRubyImpPrMap; + + ::std::auto_ptr<SvI18NMap> m_pRenameMap; + // --> OD 2006-10-12 #i69629# - change and extend data structure: + // - data structure contains candidates of paragraph styles, which + // will be assigned to the outline style + // - data structure contains more than one candidate for each list level + // of the outline style + ::boost::scoped_array< ::std::vector< ::rtl::OUString > > + m_pOutlineStylesCandidates; + // <-- + + // start range, xml:id, RDFa stuff + typedef ::boost::tuple< + uno::Reference<text::XTextRange>, ::rtl::OUString, + ::boost::shared_ptr< ::xmloff::ParsedRDFaAttributes > > + BookmarkMapEntry_t; + /// start ranges for open bookmarks + ::std::map< ::rtl::OUString, BookmarkMapEntry_t, + ::comphelper::UStringLess> m_BookmarkStartRanges; + + typedef ::std::vector< ::rtl::OUString > BookmarkVector_t; + BookmarkVector_t m_BookmarkVector; + + /// name of the last 'open' redline that started between paragraphs + ::rtl::OUString m_sOpenRedlineIdentifier; + + uno::Reference<text::XText> m_xText; + uno::Reference<text::XTextCursor> m_xCursor; + uno::Reference<text::XTextRange> m_xCursorAsRange; + uno::Reference<container::XNameContainer> m_xParaStyles; + uno::Reference<container::XNameContainer> m_xTextStyles; + uno::Reference<container::XNameContainer> m_xNumStyles; + uno::Reference<container::XNameContainer> m_xFrameStyles; + uno::Reference<container::XNameContainer> m_xPageStyles; + uno::Reference<container::XIndexReplace> m_xChapterNumbering; + uno::Reference<container::XNameAccess> m_xTextFrames; + uno::Reference<container::XNameAccess> m_xGraphics; + uno::Reference<container::XNameAccess> m_xObjects; + uno::Reference<lang::XMultiServiceFactory> m_xServiceFactory; + + SvXMLImport & m_rSvXMLImport; + + bool m_bInsertMode : 1; + bool m_bStylesOnlyMode : 1; + bool m_bBlockMode : 1; + bool m_bProgress : 1; + bool m_bOrganizerMode : 1; + bool m_bBodyContentStarted : 1; + + // #107848# + // One more flag to remember if we are inside a deleted redline section + bool m_bInsideDeleteContext : 1; + + typedef ::std::pair< ::rtl::OUString, ::rtl::OUString> field_name_type_t; + typedef ::std::pair< ::rtl::OUString, ::rtl::OUString > field_param_t; + typedef ::std::vector< field_param_t > field_params_t; + typedef ::std::pair< field_name_type_t, field_params_t > field_stack_item_t; + typedef ::std::stack< field_stack_item_t > field_stack_t; + + field_stack_t m_FieldStack; + + ::rtl::OUString m_sCellParaStyleDefault; + + Impl( uno::Reference<frame::XModel> const& rModel, + SvXMLImport & rImport, + bool const bInsertMode, bool const bStylesOnlyMode, + bool const bProgress, bool const bBlockMode, + bool const bOrganizerMode) + : m_pTextElemTokenMap( 0 ) + , m_pTextPElemTokenMap( 0 ) + , m_pTextPAttrTokenMap( 0 ) + , m_pTextFieldAttrTokenMap( 0 ) + , m_pTextNumberedParagraphAttrTokenMap( 0 ) + , m_pTextListBlockAttrTokenMap( 0 ) + , m_pTextListBlockElemTokenMap( 0 ) + , m_pTextFrameAttrTokenMap( 0 ) + , m_pTextContourAttrTokenMap( 0 ) + , m_pTextHyperlinkAttrTokenMap( 0 ) + , m_pTextMasterPageElemTokenMap( 0 ) + , m_pPrevFrmNames( 0 ) + , m_pNextFrmNames( 0 ) + // --> OD 2008-04-25 #refactorlists# + , m_pTextListsHelper( new XMLTextListsHelper() ) + // <-- + , m_pRenameMap( 0 ) + // --> OD 2006-10-12 #i69629# + , m_pOutlineStylesCandidates( 0 ) + // <-- + , m_xServiceFactory( rModel, UNO_QUERY ) + , m_rSvXMLImport( rImport ) + , m_bInsertMode( bInsertMode ) + , m_bStylesOnlyMode( bStylesOnlyMode ) + , m_bBlockMode( bBlockMode ) + , m_bProgress( bProgress ) + , m_bOrganizerMode( bOrganizerMode ) + , m_bBodyContentStarted( true ) + // #107848# Initialize inside_deleted_section flag correctly + , m_bInsideDeleteContext( false ) + { + } + + void InitOutlineStylesCandidates() + { + if (!m_pOutlineStylesCandidates) + { + size_t const size(m_xChapterNumbering->getCount()); + m_pOutlineStylesCandidates.reset( + new ::std::vector< ::rtl::OUString >[size] ); + } + } + +}; + + +uno::Reference< text::XText > & XMLTextImportHelper::GetText() +{ + return m_pImpl->m_xText; +} + +uno::Reference< text::XTextCursor > & XMLTextImportHelper::GetCursor() +{ + return m_pImpl->m_xCursor; +} + +uno::Reference< text::XTextRange > & XMLTextImportHelper::GetCursorAsRange() +{ + return m_pImpl->m_xCursorAsRange; +} + +bool XMLTextImportHelper::IsInsertMode() const +{ + return m_pImpl->m_bInsertMode; +} + +bool XMLTextImportHelper::IsStylesOnlyMode() const +{ + return m_pImpl->m_bStylesOnlyMode; +} + +bool XMLTextImportHelper::IsBlockMode() const +{ + return m_pImpl->m_bBlockMode; +} + +bool XMLTextImportHelper::IsOrganizerMode() const +{ + return m_pImpl->m_bOrganizerMode; +} + +bool XMLTextImportHelper::IsProgress() const +{ + return m_pImpl->m_bProgress; +} + +XMLSectionList_Impl & XMLTextImportHelper::GetSectionList() +{ + return m_pImpl->m_SectionList; +} + +uno::Reference<container::XNameContainer> const& +XMLTextImportHelper::GetParaStyles() const +{ + return m_pImpl->m_xParaStyles; +} + +uno::Reference<container::XNameContainer> const& +XMLTextImportHelper::GetTextStyles() const +{ + return m_pImpl->m_xTextStyles; +} + +uno::Reference<container::XNameContainer> const& +XMLTextImportHelper::GetNumberingStyles() const +{ + return m_pImpl->m_xNumStyles; +} + +uno::Reference<container::XNameContainer> const& +XMLTextImportHelper::GetFrameStyles() const +{ + return m_pImpl->m_xFrameStyles; +} + +uno::Reference<container::XNameContainer> const& +XMLTextImportHelper::GetPageStyles() const +{ + return m_pImpl->m_xPageStyles; +} + +uno::Reference<container::XIndexReplace> const& +XMLTextImportHelper::GetChapterNumbering() const +{ + return m_pImpl->m_xChapterNumbering; +} + +UniReference< SvXMLImportPropertyMapper > const& +XMLTextImportHelper::GetParaImportPropertySetMapper() const +{ + return m_pImpl->m_xParaImpPrMap; +} + +UniReference< SvXMLImportPropertyMapper > const& +XMLTextImportHelper::GetTextImportPropertySetMapper() const +{ + return m_pImpl->m_xTextImpPrMap; +} + +UniReference< SvXMLImportPropertyMapper > const& +XMLTextImportHelper::GetFrameImportPropertySetMapper() const +{ + return m_pImpl->m_xFrameImpPrMap; +} + +UniReference< SvXMLImportPropertyMapper > const& +XMLTextImportHelper::GetSectionImportPropertySetMapper() const +{ + return m_pImpl->m_xSectionImpPrMap; +} + +UniReference< SvXMLImportPropertyMapper > const& +XMLTextImportHelper::GetRubyImportPropertySetMapper() const +{ + return m_pImpl->m_xRubyImpPrMap; +} + +void XMLTextImportHelper::SetInsideDeleteContext(bool const bNew) +{ + m_pImpl->m_bInsideDeleteContext = bNew; +} + +bool XMLTextImportHelper::IsInsideDeleteContext() const +{ + return m_pImpl->m_bInsideDeleteContext; +} + +SvXMLImport & XMLTextImportHelper::GetXMLImport() +{ + return m_pImpl->m_rSvXMLImport; +} + +XMLTextListsHelper & XMLTextImportHelper::GetTextListHelper() +{ + return *m_pImpl->m_pTextListsHelper; +} + +const SvXMLTokenMap& XMLTextImportHelper::GetTextElemTokenMap() +{ + if (!m_pImpl->m_pTextElemTokenMap.get()) + { + m_pImpl->m_pTextElemTokenMap.reset( + new SvXMLTokenMap( aTextElemTokenMap )); + } + return *m_pImpl->m_pTextElemTokenMap; +} + +const SvXMLTokenMap& XMLTextImportHelper::GetTextPElemTokenMap() +{ + if (!m_pImpl->m_pTextPElemTokenMap.get()) + { + m_pImpl->m_pTextPElemTokenMap.reset( + new SvXMLTokenMap( aTextPElemTokenMap )); + } + return *m_pImpl->m_pTextPElemTokenMap; +} + +const SvXMLTokenMap& XMLTextImportHelper::GetTextPAttrTokenMap() +{ + if (!m_pImpl->m_pTextPAttrTokenMap.get()) + { + m_pImpl->m_pTextPAttrTokenMap.reset( + new SvXMLTokenMap( aTextPAttrTokenMap )); + } + return *m_pImpl->m_pTextPAttrTokenMap; +} + +const SvXMLTokenMap& XMLTextImportHelper::GetTextFrameAttrTokenMap() +{ + if (!m_pImpl->m_pTextFrameAttrTokenMap.get()) + { + m_pImpl->m_pTextFrameAttrTokenMap.reset( + new SvXMLTokenMap( aTextFrameAttrTokenMap )); + } + return *m_pImpl->m_pTextFrameAttrTokenMap; +} + +const SvXMLTokenMap& XMLTextImportHelper::GetTextContourAttrTokenMap() +{ + if (!m_pImpl->m_pTextContourAttrTokenMap.get()) + { + m_pImpl->m_pTextContourAttrTokenMap.reset( + new SvXMLTokenMap( aTextContourAttrTokenMap )); + } + return *m_pImpl->m_pTextContourAttrTokenMap; +} + +const SvXMLTokenMap& XMLTextImportHelper::GetTextHyperlinkAttrTokenMap() +{ + if (!m_pImpl->m_pTextHyperlinkAttrTokenMap.get()) + { + m_pImpl->m_pTextHyperlinkAttrTokenMap.reset( + new SvXMLTokenMap( aTextHyperlinkAttrTokenMap )); + } + return *m_pImpl->m_pTextHyperlinkAttrTokenMap; +} + +const SvXMLTokenMap& XMLTextImportHelper::GetTextMasterPageElemTokenMap() +{ + if (!m_pImpl->m_pTextMasterPageElemTokenMap.get()) + { + m_pImpl->m_pTextMasterPageElemTokenMap.reset( + new SvXMLTokenMap( aTextMasterPageElemTokenMap )); + } + return *m_pImpl->m_pTextMasterPageElemTokenMap; +} + +const SvXMLTokenMap& XMLTextImportHelper::GetTextFieldAttrTokenMap() +{ + if (!m_pImpl->m_pTextFieldAttrTokenMap.get()) + { + m_pImpl->m_pTextFieldAttrTokenMap.reset( + new SvXMLTokenMap( aTextFieldAttrTokenMap )); + } + return *m_pImpl->m_pTextFieldAttrTokenMap; +} + + +namespace +{ + class FieldParamImporter + { + public: + typedef pair<OUString,OUString> field_param_t; + typedef vector<field_param_t> field_params_t; + FieldParamImporter(const field_params_t* const pInParams, Reference<XNameContainer> xOutParams) + : m_pInParams(pInParams) + , m_xOutParams(xOutParams) + { }; + void Import(); + + private: + const field_params_t* const m_pInParams; + Reference<XNameContainer> m_xOutParams; + }; + + void FieldParamImporter::Import() + { + ::std::vector<OUString> vListEntries; + ::std::map<OUString, Any> vOutParams; + for(field_params_t::const_iterator pCurrent = m_pInParams->begin(); + pCurrent != m_pInParams->end(); + ++pCurrent) + { + if(pCurrent->first.equalsAscii(ODF_FORMDROPDOWN_RESULT)) + { + // sal_Int32 + vOutParams[pCurrent->first] = makeAny(pCurrent->second.toInt32()); + } + else if(pCurrent->first.equalsAscii(ODF_FORMCHECKBOX_RESULT)) + { + // bool + vOutParams[pCurrent->first] = makeAny(pCurrent->second.toBoolean()); + } + else if(pCurrent->first.equalsAscii(ODF_FORMDROPDOWN_LISTENTRY)) + { + // sequence + vListEntries.push_back(pCurrent->second); + } + else + vOutParams[pCurrent->first] = makeAny(pCurrent->second); + } + if(!vListEntries.empty()) + { + Sequence<OUString> vListEntriesSeq(vListEntries.size()); + copy(vListEntries.begin(), vListEntries.end(), ::comphelper::stl_begin(vListEntriesSeq)); + vOutParams[OUString::createFromAscii(ODF_FORMDROPDOWN_LISTENTRY)] = makeAny(vListEntriesSeq); + } + for(::std::map<OUString, Any>::const_iterator pCurrent = vOutParams.begin(); + pCurrent != vOutParams.end(); + ++pCurrent) + { + try + { + m_xOutParams->insertByName(pCurrent->first, pCurrent->second); + } + catch(ElementExistException) + { } + } + } +} + +XMLTextImportHelper::XMLTextImportHelper( + uno::Reference<frame::XModel> const& rModel, + SvXMLImport& rImport, + bool const bInsertMode, bool const bStylesOnlyMode, + bool const bProgress, bool const bBlockMode, + bool const bOrganizerMode) + : m_pImpl( new Impl(rModel, rImport, bInsertMode, bStylesOnlyMode, + bProgress, bBlockMode, bOrganizerMode) ) + , m_pBackpatcherImpl( MakeBackpatcherImpl() ) +{ + static ::rtl::OUString s_PropNameDefaultListId( + RTL_CONSTASCII_USTRINGPARAM("DefaultListId")); + + Reference< XChapterNumberingSupplier > xCNSupplier( rModel, UNO_QUERY ); + + if( xCNSupplier.is() ) + { + m_pImpl->m_xChapterNumbering = xCNSupplier->getChapterNumberingRules(); + // --> OD 2008-05-15 #refactorlists# + if (m_pImpl->m_xChapterNumbering.is()) + { + Reference< XPropertySet > const xNumRuleProps( + m_pImpl->m_xChapterNumbering, UNO_QUERY); + if ( xNumRuleProps.is() ) + { + Reference< XPropertySetInfo > xNumRulePropSetInfo( + xNumRuleProps->getPropertySetInfo()); + if (xNumRulePropSetInfo.is() && + xNumRulePropSetInfo->hasPropertyByName( + s_PropNameDefaultListId)) + { + ::rtl::OUString sListId; + xNumRuleProps->getPropertyValue(s_PropNameDefaultListId) + >>= sListId; + DBG_ASSERT( sListId.getLength() != 0, + "no default list id found at chapter numbering rules instance. Serious defect -> please inform OD." ); + if ( sListId.getLength() ) + { + Reference< XNamed > const xChapterNumNamed( + m_pImpl->m_xChapterNumbering, UNO_QUERY); + if ( xChapterNumNamed.is() ) + { + m_pImpl->m_pTextListsHelper->KeepListAsProcessed( + sListId, + xChapterNumNamed->getName(), + ::rtl::OUString() ); + } + } + } + } + } + // <-- + } + + Reference< XStyleFamiliesSupplier > xFamiliesSupp( rModel, UNO_QUERY ); +// DBG_ASSERT( xFamiliesSupp.is(), "no chapter numbering supplier" ); for clipboard there may be documents without styles + + if( xFamiliesSupp.is() ) + { + Reference< XNameAccess > xFamilies(xFamiliesSupp->getStyleFamilies()); + + const OUString aParaStyles(RTL_CONSTASCII_USTRINGPARAM("ParagraphStyles")); + if( xFamilies->hasByName( aParaStyles ) ) + { + m_pImpl->m_xParaStyles.set(xFamilies->getByName(aParaStyles), + UNO_QUERY); + } + + const OUString aCharStyles(RTL_CONSTASCII_USTRINGPARAM("CharacterStyles")); + if( xFamilies->hasByName( aCharStyles ) ) + { + m_pImpl->m_xTextStyles.set(xFamilies->getByName(aCharStyles), + UNO_QUERY); + } + + const OUString aNumStyles(RTL_CONSTASCII_USTRINGPARAM("NumberingStyles")); + if( xFamilies->hasByName( aNumStyles ) ) + { + m_pImpl->m_xNumStyles.set(xFamilies->getByName(aNumStyles), + UNO_QUERY); + } + + const OUString aFrameStyles(RTL_CONSTASCII_USTRINGPARAM("FrameStyles")); + if( xFamilies->hasByName( aFrameStyles ) ) + { + m_pImpl->m_xFrameStyles.set(xFamilies->getByName(aFrameStyles), + UNO_QUERY); + } + + const OUString aPageStyles(RTL_CONSTASCII_USTRINGPARAM("PageStyles")); + if( xFamilies->hasByName( aPageStyles ) ) + { + m_pImpl->m_xPageStyles.set(xFamilies->getByName(aPageStyles), + UNO_QUERY); + } + } + + Reference < XTextFramesSupplier > xTFS( rModel, UNO_QUERY ); + if( xTFS.is() ) + { + m_pImpl->m_xTextFrames.set(xTFS->getTextFrames()); + } + + Reference < XTextGraphicObjectsSupplier > xTGOS( rModel, UNO_QUERY ); + if( xTGOS.is() ) + { + m_pImpl->m_xGraphics.set(xTGOS->getGraphicObjects()); + } + + Reference < XTextEmbeddedObjectsSupplier > xTEOS( rModel, UNO_QUERY ); + if( xTEOS.is() ) + { + m_pImpl->m_xObjects.set(xTEOS->getEmbeddedObjects()); + } + + XMLPropertySetMapper *pPropMapper = + new XMLTextPropertySetMapper( TEXT_PROP_MAP_PARA ); + m_pImpl->m_xParaImpPrMap = + new XMLTextImportPropertyMapper( pPropMapper, rImport ); + + pPropMapper = new XMLTextPropertySetMapper( TEXT_PROP_MAP_TEXT ); + m_pImpl->m_xTextImpPrMap = + new XMLTextImportPropertyMapper( pPropMapper, rImport ); + + pPropMapper = new XMLTextPropertySetMapper( TEXT_PROP_MAP_FRAME ); + m_pImpl->m_xFrameImpPrMap = + new XMLTextImportPropertyMapper( pPropMapper, rImport ); + + pPropMapper = new XMLTextPropertySetMapper( TEXT_PROP_MAP_SECTION ); + m_pImpl->m_xSectionImpPrMap = + new XMLTextImportPropertyMapper( pPropMapper, rImport ); + + pPropMapper = new XMLTextPropertySetMapper( TEXT_PROP_MAP_RUBY ); + m_pImpl->m_xRubyImpPrMap = + new SvXMLImportPropertyMapper( pPropMapper, rImport ); +} + +XMLTextImportHelper::~XMLTextImportHelper() +{ +} + +SvXMLImportPropertyMapper *XMLTextImportHelper::CreateShapeExtPropMapper(SvXMLImport& rImport) +{ + XMLPropertySetMapper *pPropMapper = + new XMLTextPropertySetMapper( TEXT_PROP_MAP_FRAME ); + return new XMLTextImportPropertyMapper( pPropMapper, rImport, + const_cast<XMLFontStylesContext*>(rImport.GetFontDecls()) ); +} + +SvXMLImportPropertyMapper *XMLTextImportHelper::CreateCharExtPropMapper(SvXMLImport& rImport, XMLFontStylesContext *pFontDecls) +{ + XMLPropertySetMapper *pPropMapper = + new XMLTextPropertySetMapper( TEXT_PROP_MAP_TEXT ); + if (!pFontDecls) + pFontDecls = const_cast<XMLFontStylesContext*>(rImport.GetFontDecls()); + return new XMLTextImportPropertyMapper( pPropMapper, rImport, pFontDecls ); +} + +SvXMLImportPropertyMapper *XMLTextImportHelper::CreateParaExtPropMapper(SvXMLImport& rImport, XMLFontStylesContext *pFontDecls) +{ + XMLPropertySetMapper *pPropMapper = + new XMLTextPropertySetMapper( TEXT_PROP_MAP_SHAPE_PARA ); + if (!pFontDecls) + pFontDecls = const_cast<XMLFontStylesContext*>(rImport.GetFontDecls()); + return new XMLTextImportPropertyMapper( pPropMapper, rImport, pFontDecls ); +} + +SvXMLImportPropertyMapper *XMLTextImportHelper::CreateParaDefaultExtPropMapper(SvXMLImport& rImport, XMLFontStylesContext* pFontDecls) +{ + if (!pFontDecls) + pFontDecls = const_cast<XMLFontStylesContext*>(rImport.GetFontDecls()); + + XMLPropertySetMapper* pPropMapper = + new XMLTextPropertySetMapper( TEXT_PROP_MAP_SHAPE_PARA ); + SvXMLImportPropertyMapper* pImportMapper = new XMLTextImportPropertyMapper( pPropMapper, rImport, pFontDecls ); + + pPropMapper = + new XMLTextPropertySetMapper( TEXT_PROP_MAP_TEXT_ADDITIONAL_DEFAULTS ); + pImportMapper->ChainImportMapper( new XMLTextImportPropertyMapper( pPropMapper, rImport, pFontDecls ) ); + + return pImportMapper; +} + +SvXMLImportPropertyMapper* + XMLTextImportHelper::CreateTableDefaultExtPropMapper( + SvXMLImport& rImport, + XMLFontStylesContext* ) +{ + XMLPropertySetMapper *pPropMapper = + new XMLTextPropertySetMapper( TEXT_PROP_MAP_TABLE_DEFAULTS ); + return new SvXMLImportPropertyMapper( pPropMapper, rImport ); +} + +SvXMLImportPropertyMapper* + XMLTextImportHelper::CreateTableRowDefaultExtPropMapper( + SvXMLImport& rImport, + XMLFontStylesContext* ) +{ + XMLPropertySetMapper *pPropMapper = + new XMLTextPropertySetMapper( TEXT_PROP_MAP_TABLE_ROW_DEFAULTS ); + return new SvXMLImportPropertyMapper( pPropMapper, rImport ); +} + +void XMLTextImportHelper::SetCursor( const Reference < XTextCursor > & rCursor ) +{ + m_pImpl->m_xCursor.set(rCursor); + m_pImpl->m_xText.set(rCursor->getText()); + m_pImpl->m_xCursorAsRange.set( rCursor, UNO_QUERY ); +} + +void XMLTextImportHelper::ResetCursor() +{ + m_pImpl->m_xCursor.set(0); + m_pImpl->m_xText.set(0); + m_pImpl->m_xCursorAsRange.set(0); +} + + +sal_Bool XMLTextImportHelper::HasFrameByName( const OUString& rName ) const +{ + return (m_pImpl->m_xTextFrames.is() && + m_pImpl->m_xTextFrames->hasByName(rName)) + || (m_pImpl->m_xGraphics.is() && + m_pImpl->m_xGraphics->hasByName(rName)) + || (m_pImpl->m_xObjects.is() && + m_pImpl->m_xObjects->hasByName(rName)); +} + +void XMLTextImportHelper::InsertString( const OUString& rChars ) +{ + DBG_ASSERT(m_pImpl->m_xText.is(), "no text"); + DBG_ASSERT(m_pImpl->m_xCursorAsRange.is(), "no range"); + if (m_pImpl->m_xText.is()) + { + m_pImpl->m_xText->insertString(m_pImpl->m_xCursorAsRange, + rChars, sal_False); + } +} + +void XMLTextImportHelper::InsertString( const OUString& rChars, + sal_Bool& rIgnoreLeadingSpace ) +{ + DBG_ASSERT(m_pImpl->m_xText.is(), "no text"); + DBG_ASSERT(m_pImpl->m_xCursorAsRange.is(), "no range"); + if (m_pImpl->m_xText.is()) + { + sal_Int32 nLen = rChars.getLength(); + OUStringBuffer sChars( nLen ); + + for( sal_Int32 i=0; i < nLen; i++ ) + { + sal_Unicode c = rChars[i]; + switch( c ) + { + case 0x20: + case 0x09: + case 0x0a: + case 0x0d: + if( !rIgnoreLeadingSpace ) + sChars.append( (sal_Unicode)0x20 ); + rIgnoreLeadingSpace = sal_True; + break; + default: + rIgnoreLeadingSpace = sal_False; + sChars.append( c ); + break; + } + } + m_pImpl->m_xText->insertString(m_pImpl->m_xCursorAsRange, + sChars.makeStringAndClear(), sal_False); + } +} + +void XMLTextImportHelper::InsertControlCharacter( sal_Int16 nControl ) +{ + DBG_ASSERT(m_pImpl->m_xText.is(), "no text"); + DBG_ASSERT(m_pImpl->m_xCursorAsRange.is(), "no range"); + if (m_pImpl->m_xText.is()) + { + m_pImpl->m_xText->insertControlCharacter( + m_pImpl->m_xCursorAsRange, nControl, sal_False); + } +} + +void XMLTextImportHelper::InsertTextContent( + Reference < XTextContent > & xContent ) +{ + DBG_ASSERT(m_pImpl->m_xText.is(), "no text"); + DBG_ASSERT(m_pImpl->m_xCursorAsRange.is(), "no range"); + if (m_pImpl->m_xText.is()) + { + m_pImpl->m_xText->insertTextContent( + m_pImpl->m_xCursorAsRange, xContent, sal_False); + } +} + +void XMLTextImportHelper::DeleteParagraph() +{ + DBG_ASSERT(m_pImpl->m_xText.is(), "no text"); + DBG_ASSERT(m_pImpl->m_xCursor.is(), "no cursor"); + DBG_ASSERT(m_pImpl->m_xCursorAsRange.is(), "no range"); + + sal_Bool bDelete = sal_True; + Reference < XEnumerationAccess > const xEnumAccess( + m_pImpl->m_xCursor, UNO_QUERY); + if( xEnumAccess.is() ) + { + Reference < XEnumeration > xEnum(xEnumAccess->createEnumeration()); + DBG_ASSERT( xEnum->hasMoreElements(), "empty text enumeration" ); + if( xEnum->hasMoreElements() ) + { + Reference < XComponent > xComp( xEnum->nextElement(), UNO_QUERY ); + DBG_ASSERT( xComp.is(), "got no component" ); + if( xComp.is() ) + { + xComp->dispose(); + bDelete = sal_False; + } + } + } + if( bDelete ) + { + if (m_pImpl->m_xCursor->goLeft( 1, sal_True )) + { + OUString sEmpty; + m_pImpl->m_xText->insertString(m_pImpl->m_xCursorAsRange, + sEmpty, sal_True); + } + } +} + +OUString XMLTextImportHelper::ConvertStarFonts( const OUString& rChars, + const OUString& rStyleName, + sal_uInt8& rFlags, + sal_Bool bPara, + SvXMLImport& rImport ) const +{ + OUStringBuffer sChars( rChars ); + sal_Bool bConverted = sal_False; + for( sal_Int32 j=0; j<rChars.getLength(); j++ ) + { + sal_Unicode c = rChars[j]; + if( c >= 0xf000 && c <= 0xf0ff ) + { + if( (rFlags & CONV_STAR_FONT_FLAGS_VALID) == 0 ) + { + XMLTextStyleContext *pStyle = 0; + sal_uInt16 nFamily = bPara ? XML_STYLE_FAMILY_TEXT_PARAGRAPH + : XML_STYLE_FAMILY_TEXT_TEXT; + if (rStyleName.getLength() && m_pImpl->m_xAutoStyles.Is()) + { + const SvXMLStyleContext* pTempStyle = + ((SvXMLStylesContext *)&m_pImpl->m_xAutoStyles)-> + FindStyleChildContext( nFamily, rStyleName, + sal_True ); + pStyle = PTR_CAST( XMLTextStyleContext,pTempStyle); + } + + if( pStyle ) + { + sal_Int32 nCount = pStyle->_GetProperties().size(); + if( nCount ) + { + UniReference < SvXMLImportPropertyMapper > xImpPrMap = + ((SvXMLStylesContext *)&m_pImpl->m_xAutoStyles) + ->GetImportPropertyMapper(nFamily); + if( xImpPrMap.is() ) + { + UniReference<XMLPropertySetMapper> rPropMapper = + xImpPrMap->getPropertySetMapper(); + for( sal_Int32 i=0; i < nCount; i++ ) + { + const XMLPropertyState& rProp = pStyle->_GetProperties()[i]; + sal_Int32 nIdx = rProp.mnIndex; + sal_uInt32 nContextId = rPropMapper->GetEntryContextId(nIdx); + if( CTF_FONTFAMILYNAME == nContextId ) + { + rFlags &= ~(CONV_FROM_STAR_BATS|CONV_FROM_STAR_MATH); + OUString sFontName; + rProp.maValue >>= sFontName; + OUString sStarBats( RTL_CONSTASCII_USTRINGPARAM("StarBats" ) ); + OUString sStarMath( RTL_CONSTASCII_USTRINGPARAM("StarMath" ) ); + if( sFontName.equalsIgnoreAsciiCase( sStarBats ) ) + rFlags |= CONV_FROM_STAR_BATS; + else if( sFontName.equalsIgnoreAsciiCase( sStarMath ) ) + rFlags |= CONV_FROM_STAR_MATH; + break; + } + } + } + } + + } + + rFlags |= CONV_STAR_FONT_FLAGS_VALID; + } + if( (rFlags & CONV_FROM_STAR_BATS ) != 0 ) + { + sChars.setCharAt( j, rImport.ConvStarBatsCharToStarSymbol( c ) ); + bConverted = sal_True; + } + else if( (rFlags & CONV_FROM_STAR_MATH ) != 0 ) + { + sChars.setCharAt( j, rImport.ConvStarMathCharToStarSymbol( c ) ); + bConverted = sal_True; + } + } + } + + return bConverted ? sChars.makeStringAndClear() : rChars; +} + +// --> OD 2006-10-12 #i69629# +// helper method to determine, if a paragraph style has a list style (inclusive +// an empty one) inherits a list style (inclusive an empty one) from one of its parents +// --> OD 2007-01-29 #i73973# +// apply special case, that found list style equals the chapter numbering, also +// to the found list styles of the parent styles. +sal_Bool lcl_HasListStyle( OUString sStyleName, + const Reference < XNameContainer >& xParaStyles, + SvXMLImport& rImport, + const OUString& sNumberingStyleName, + const OUString& sOutlineStyleName ) +{ + sal_Bool bRet( sal_False ); + + if ( !xParaStyles->hasByName( sStyleName ) ) + { + // error case + return sal_True; + } + + Reference< XPropertyState > xPropState( xParaStyles->getByName( sStyleName ), + UNO_QUERY ); + if ( !xPropState.is() ) + { + // error case + return sal_False; + } + + if ( xPropState->getPropertyState( sNumberingStyleName ) == PropertyState_DIRECT_VALUE ) + { + // list style found + bRet = sal_True; + // special case: the set list style equals the chapter numbering + Reference< XPropertySet > xPropSet( xPropState, UNO_QUERY ); + if ( xPropSet.is() ) + { + OUString sListStyle; + xPropSet->getPropertyValue( sNumberingStyleName ) >>= sListStyle; + if ( sListStyle.getLength() != 0 && + sListStyle == sOutlineStyleName ) + { + bRet = sal_False; + } + } + } + else + { + // --> OD 2007-12-07 #i77708# + sal_Int32 nUPD( 0 ); + sal_Int32 nBuild( 0 ); + // --> OD 2008-03-19 #i86058# +// rImport.getBuildIds( nUPD, nBuild ); + const bool bBuildIdFound = rImport.getBuildIds( nUPD, nBuild ); + // <-- + // <-- + // search list style at parent + Reference<XStyle> xStyle( xPropState, UNO_QUERY ); + while ( xStyle.is() ) + { + OUString aParentStyle( xStyle->getParentStyle() ); + if ( aParentStyle.getLength() > 0 ) + { + aParentStyle = + rImport.GetStyleDisplayName( XML_STYLE_FAMILY_TEXT_PARAGRAPH, + aParentStyle ); + } + if ( aParentStyle.getLength() == 0 || + !xParaStyles->hasByName( aParentStyle ) ) + { + // no list style found + break; + } + else + { + xPropState = Reference< XPropertyState >( + xParaStyles->getByName( aParentStyle ), + UNO_QUERY ); + if ( !xPropState.is() ) + { + // error case + return sal_True; + } + if ( xPropState->getPropertyState( sNumberingStyleName ) == PropertyState_DIRECT_VALUE ) + { + // list style found + bRet = sal_True; + // --> OD 2007-01-29 #i73973# + // special case: the found list style equals the chapter numbering + Reference< XPropertySet > xPropSet( xPropState, UNO_QUERY ); + if ( xPropSet.is() ) + { + OUString sListStyle; + xPropSet->getPropertyValue( sNumberingStyleName ) >>= sListStyle; + if ( sListStyle.getLength() != 0 && + sListStyle == sOutlineStyleName ) + { + bRet = sal_False; + } + // --> OD 2007-12-07 #i77708# + // special handling for text documents from OOo version prior OOo 2.4 + // --> OD 2008-03-19 #i86058# + // check explicitly on certain versions and on import of + // text documents in OpenOffice.org file format + else if ( sListStyle.getLength() == 0 && + ( rImport.IsTextDocInOOoFileFormat() || + ( bBuildIdFound && + ( ( nUPD == 641 ) || ( nUPD == 645 ) || // prior OOo 2.0 + ( nUPD == 680 && nBuild <= 9238 ) ) ) ) ) // OOo 2.0 - OOo 2.3.1 + { + bRet = sal_False; + } + // <-- + } + // <-- + break; + } + else + { + // search list style at parent + xStyle = Reference<XStyle>( xPropState, UNO_QUERY ); + } + } + } + } + + return bRet; +} +// <-- +OUString XMLTextImportHelper::SetStyleAndAttrs( + SvXMLImport& rImport, + const Reference < XTextCursor >& rCursor, + const OUString& rStyleName, + sal_Bool bPara, + sal_Bool bOutlineLevelAttrFound, + sal_Int8 nOutlineLevel, + // --> OD 2007-08-17 #i80724# + sal_Bool bSetListAttrs ) + // <-- +{ + static ::rtl::OUString s_ParaStyleName( + RTL_CONSTASCII_USTRINGPARAM("ParaStyleName")); + static ::rtl::OUString s_CharStyleName( + RTL_CONSTASCII_USTRINGPARAM("CharStyleName")); + static ::rtl::OUString s_NumberingRules( + RTL_CONSTASCII_USTRINGPARAM("NumberingRules")); + static ::rtl::OUString s_NumberingIsNumber( + RTL_CONSTASCII_USTRINGPARAM("NumberingIsNumber")); + static ::rtl::OUString s_NumberingLevel( + RTL_CONSTASCII_USTRINGPARAM("NumberingLevel")); + static ::rtl::OUString s_ParaIsNumberingRestart( + RTL_CONSTASCII_USTRINGPARAM("ParaIsNumberingRestart")); + static ::rtl::OUString s_NumberingStartValue( + RTL_CONSTASCII_USTRINGPARAM("NumberingStartValue")); + static ::rtl::OUString s_PropNameListId( + RTL_CONSTASCII_USTRINGPARAM("ListId")); + static ::rtl::OUString s_PageDescName( + RTL_CONSTASCII_USTRINGPARAM("PageDescName")); + static ::rtl::OUString s_ServiceCombinedCharacters( + RTL_CONSTASCII_USTRINGPARAM( + "com.sun.star.text.TextField.CombinedCharacters")); + static ::rtl::OUString s_Content(RTL_CONSTASCII_USTRINGPARAM("Content")); + static ::rtl::OUString s_OutlineLevel( + RTL_CONSTASCII_USTRINGPARAM("OutlineLevel")); + static ::rtl::OUString s_NumberingStyleName( + RTL_CONSTASCII_USTRINGPARAM("NumberingStyleName")); + + const sal_uInt16 nFamily = bPara ? XML_STYLE_FAMILY_TEXT_PARAGRAPH + : XML_STYLE_FAMILY_TEXT_TEXT; + XMLTextStyleContext *pStyle = 0; + OUString sStyleName( rStyleName ); + if (sStyleName.getLength() && m_pImpl->m_xAutoStyles.Is()) + { + const SvXMLStyleContext* pTempStyle = + ((SvXMLStylesContext *)&m_pImpl->m_xAutoStyles)-> + FindStyleChildContext( nFamily, sStyleName, sal_True ); + pStyle = PTR_CAST( XMLTextStyleContext,pTempStyle); + } + if( pStyle ) + sStyleName = pStyle->GetParentName(); + + Reference < XPropertySet > xPropSet( rCursor, UNO_QUERY ); + Reference< XPropertySetInfo > xPropSetInfo( + xPropSet->getPropertySetInfo()); + + // style + if( sStyleName.getLength() ) + { + sStyleName = rImport.GetStyleDisplayName( nFamily, sStyleName ); + const String& rPropName = (bPara) ? s_ParaStyleName : s_CharStyleName; + const Reference < XNameContainer > & rStyles = (bPara) + ? m_pImpl->m_xParaStyles + : m_pImpl->m_xTextStyles; + if( rStyles.is() && + xPropSetInfo->hasPropertyByName( rPropName ) && + rStyles->hasByName( sStyleName ) ) + { + xPropSet->setPropertyValue( rPropName, makeAny(sStyleName) ); + } + else + sStyleName = OUString(); + } + + // --> OD 2008-09-10 #i70748# + // The outline level needs to be only applied as list level, if the heading + // is not inside a list and if it by default applies the outline style. + bool bApplyOutlineLevelAsListLevel( false ); + // --> OD 2007-08-17 #i80724# + if (bSetListAttrs && bPara + && xPropSetInfo->hasPropertyByName( s_NumberingRules)) + // <-- + { + // Set numbering rules + Reference< XIndexReplace > const xNumRules( + xPropSet->getPropertyValue(s_NumberingRules), UNO_QUERY); + + XMLTextListBlockContext * pListBlock(0); + XMLTextListItemContext * pListItem(0); + XMLNumberedParaContext * pNumberedParagraph(0); + GetTextListHelper().ListContextTop( + pListBlock, pListItem, pNumberedParagraph); + + OSL_ENSURE(!(pListBlock && pNumberedParagraph), "XMLTextImportHelper::" + "SetStyleAndAttrs: both list and numbered-paragraph???"); + + Reference < XIndexReplace > xNewNumRules; + sal_Int8 nLevel(-1); + ::rtl::OUString sListId; + sal_Int16 nStartValue(-1); + bool bNumberingIsNumber(true); + + if (pListBlock) { + + if (!pListItem) { + bNumberingIsNumber = false; // list-header + } + // --> OD 2008-05-08 #refactorlists# + // consider text:style-override property of <text:list-item> + xNewNumRules.set( + (pListItem != 0 && pListItem->HasNumRulesOverride()) + ? pListItem->GetNumRulesOverride() + : pListBlock->GetNumRules() ); + // <-- + nLevel = static_cast<sal_Int8>(pListBlock->GetLevel()); + + if ( pListItem && pListItem->HasStartValue() ) { + nStartValue = pListItem->GetStartValue(); + } + + // --> OD 2008-08-15 #i92811# + sListId = m_pImpl->m_pTextListsHelper->GetListIdForListBlock( + *pListBlock); + // <-- + } + else if (pNumberedParagraph) + { + xNewNumRules.set(pNumberedParagraph->GetNumRules()); + nLevel = static_cast<sal_Int8>(pNumberedParagraph->GetLevel()); + sListId = pNumberedParagraph->GetListId(); + nStartValue = pNumberedParagraph->GetStartValue(); + } + + + if (pListBlock || pNumberedParagraph) + { + // --> OD 2009-08-24 #i101349# + // Assure that list style of automatic paragraph style is applied at paragraph. + sal_Bool bApplyNumRules = pStyle && pStyle->IsListStyleSet(); + if ( !bApplyNumRules ) + { + sal_Bool bSameNumRules = xNewNumRules == xNumRules; + if( !bSameNumRules && xNewNumRules.is() && xNumRules.is() ) + { + // If the interface pointers are different then this does + // not mean that the num rules are different. Further tests + // are required then. However, if only one num rule is + // set, no tests are required of course. + Reference< XNamed > xNewNamed( xNewNumRules, UNO_QUERY ); + Reference< XNamed > xNamed( xNumRules, UNO_QUERY ); + if( xNewNamed.is() && xNamed.is() ) + { + bSameNumRules = xNewNamed->getName() == xNamed->getName(); + } + else + { + Reference< XAnyCompare > xNumRuleCompare( xNumRules, UNO_QUERY ); + if( xNumRuleCompare.is() ) + { + bSameNumRules = (xNumRuleCompare->compare( Any(xNumRules), Any(xNewNumRules) ) == 0); + } + } + } + bApplyNumRules = !bSameNumRules; + } + + if ( bApplyNumRules ) + // <-- + { + // #102607# This may except when xNewNumRules contains + // a Writer-NumRule-Implementation bug gets applied to + // a shape. Since this may occur inside a document + // (e.g. when edited), this must be handled + // gracefully. + try + { + xPropSet->setPropertyValue( + s_NumberingRules, makeAny(xNewNumRules) ); + } + catch( Exception e ) + { + ; // I would really like to use a warning here, + // but I can't access the XMLErrorHandler from + // here. + } + } + + if (!bNumberingIsNumber && + xPropSetInfo->hasPropertyByName(s_NumberingIsNumber)) + { + xPropSet->setPropertyValue(s_NumberingIsNumber, Any(sal_False)); + } + + xPropSet->setPropertyValue( s_NumberingLevel, Any(nLevel) ); + + if( pListBlock && pListBlock->IsRestartNumbering() ) + { + // TODO: property missing + if (xPropSetInfo->hasPropertyByName(s_ParaIsNumberingRestart)) + { + sal_Bool bTmp = sal_True; + xPropSet->setPropertyValue(s_ParaIsNumberingRestart, + makeAny(bTmp) ); + } + pListBlock->ResetRestartNumbering(); + } + + if ( 0 <= nStartValue && + xPropSetInfo->hasPropertyByName(s_NumberingStartValue)) + { + xPropSet->setPropertyValue(s_NumberingStartValue, + makeAny(nStartValue)); + } + + // --> OD 2008-04-23 #refactorlists# + if (xPropSetInfo->hasPropertyByName(s_PropNameListId)) + { + if (sListId.getLength()) { + xPropSet->setPropertyValue(s_PropNameListId, + makeAny(sListId) ); + } + } + // <-- + + GetTextListHelper().SetListItem( (XMLTextListItemContext *)0 ); + } + else + { + // If the paragraph is not in a list but its style, remove it from + // the list. + // --> OD 2005-10-25 #126347# - do not remove it, if the list + // of the style is the chapter numbering rule. + if( xNumRules.is() ) + { + bool bRemove( true ); + // --> OD 2008-12-17 #i70748# - special handling for document from OOo 2.x + sal_Int32 nUPD( 0 ); + sal_Int32 nBuild( 0 ); + const bool bBuildIdFound = rImport.getBuildIds( nUPD, nBuild ); + DBG_ASSERT( ( bBuildIdFound && nUPD == 680 ) || + !pStyle || + !pStyle->IsListStyleSet() || + pStyle->GetListStyle().getLength() == 0, + "automatic paragraph style with list style name, but paragraph not in list???" ); + if ( ( bBuildIdFound && nUPD == 680 ) || + !pStyle || !pStyle->IsListStyleSet() ) + { + if (m_pImpl->m_xChapterNumbering.is()) + { + Reference< XNamed > xNumNamed( xNumRules, UNO_QUERY ); + Reference< XNamed > const xChapterNumNamed ( + m_pImpl->m_xChapterNumbering, UNO_QUERY); + if ( xNumNamed.is() && xChapterNumNamed.is() && + xNumNamed->getName() == xChapterNumNamed->getName() ) + { + bRemove = false; + // --> OD 2008-09-10 #i70748# + bApplyOutlineLevelAsListLevel = true; + // <-- + } + } + } + // <-- + if ( bRemove ) + { + xPropSet->setPropertyValue( s_NumberingRules, Any() ); + } + } + // <-- + } + } + + // hard paragraph properties + if( pStyle ) + { + pStyle->FillPropertySet( xPropSet ); + if( bPara && pStyle->HasMasterPageName() && + xPropSetInfo->hasPropertyByName(s_PageDescName)) + { + OUString sDisplayName( + rImport.GetStyleDisplayName( + XML_STYLE_FAMILY_MASTER_PAGE, + pStyle->GetMasterPageName()) ); + if( !sDisplayName.getLength() || + (m_pImpl->m_xPageStyles.is() && + m_pImpl->m_xPageStyles->hasByName( sDisplayName))) + { + xPropSet->setPropertyValue(s_PageDescName, + makeAny(sDisplayName)); + } + } + if( bPara && pStyle->GetDropCapStyleName().getLength() && + m_pImpl->m_xTextStyles.is()) + { + OUString sDisplayName( + rImport.GetStyleDisplayName( + XML_STYLE_FAMILY_TEXT_TEXT, + pStyle->GetDropCapStyleName()) ); + if (m_pImpl->m_xTextStyles->hasByName(sDisplayName) && + xPropSetInfo->hasPropertyByName( sDisplayName ) ) + { + xPropSet->setPropertyValue( pStyle->sDropCapCharStyleName, makeAny(sDisplayName) ); + } + } + + // combined characters special treatment + if (!bPara && pStyle->HasCombinedCharactersLetter()) + { + // insert combined characters text field + if (m_pImpl->m_xServiceFactory.is()) + { + uno::Reference<beans::XPropertySet> const xTmp( + m_pImpl->m_xServiceFactory->createInstance( + s_ServiceCombinedCharacters), UNO_QUERY); + if( xTmp.is() ) + { + // fix cursor if larger than possible for + // combined characters field + if (rCursor->getString().getLength() > + MAX_COMBINED_CHARACTERS) + { + rCursor->gotoRange(rCursor->getStart(), sal_False); + rCursor->goRight(MAX_COMBINED_CHARACTERS, sal_True); + } + + // set field value (the combined character string) + xTmp->setPropertyValue(s_Content, + makeAny(rCursor->getString())); + + // insert the field over it's original text + Reference<XTextRange> xRange(rCursor, UNO_QUERY); + Reference<XTextContent> xTextContent(xTmp, UNO_QUERY); + if (m_pImpl->m_xText.is() && xRange.is()) + { + // #i107225# the combined characters need to be inserted first + // the selected text has to be removed afterwards + m_pImpl->m_xText->insertTextContent( xRange->getStart(), xTextContent, sal_True ); + + if( xRange->getString().getLength() ) + { + try + { + uno::Reference< text::XTextCursor > xCrsr = xRange->getText()->createTextCursorByRange( xRange->getStart() ); + xCrsr->goLeft( 1, true ); + uno::Reference< beans::XPropertySet> xCrsrProperties( xCrsr, uno::UNO_QUERY_THROW ); + //the hard properties of the removed text need to be applied to the combined characters field + pStyle->FillPropertySet( xCrsrProperties ); + xCrsr->collapseToEnd(); + xCrsr->gotoRange( xRange->getEnd(), true ); + xCrsr->setString( ::rtl::OUString() ); + } + catch( const uno::Exception& rEx ) + { + (void)rEx; + } + } + } + } + } + } + } + + // outline level; set after list style has been set + // --> OD 2005-08-25 #i53198# + // Complete re-worked and corrected: + // - set outline level at paragraph + // - set numbering level at paragraph, if none is already set + // - assure that style is marked as an outline style for the corresponding + // outline level. + // - DO NOT set type of numbering rule to outline. + // - DO NOT set numbering rule directly at the paragraph. + + // --> OD 2008-12-09 #i70748# + // Some minor rework and adjust access to paragraph styles + if ( bPara ) + { + // --> OD 2009-08-18 #i103817# + sal_Int16 nCurrentOutlineLevelInheritedFromParagraphStyle = 0; + const bool bHasOutlineLevelProp( + xPropSetInfo->hasPropertyByName(s_OutlineLevel)); + if ( bHasOutlineLevelProp ) + { + xPropSet->getPropertyValue(s_OutlineLevel) + >>= nCurrentOutlineLevelInheritedFromParagraphStyle; + } + // <-- + //if ( bPara && nOutlineLevel != -1 ) //#outline level,removed by zhaojianwei + if ( nOutlineLevel > 0 ) //add by zhaojianwei + { + //#outline level,removed by zhaojianwei + if ( bHasOutlineLevelProp ) + { + // In case that the value equals the value of its paragraph style + // attribute outline level, the paragraph attribute value is left unset + if ( nCurrentOutlineLevelInheritedFromParagraphStyle != nOutlineLevel ) + { + xPropSet->setPropertyValue( s_OutlineLevel, + makeAny( static_cast<sal_Int16>(nOutlineLevel) ) ); + } + }//<-end,zhaojianwei + + // --> OD 2008-09-10 #i70748# + if ( bApplyOutlineLevelAsListLevel ) + { + sal_Int16 nNumLevel = -1; + xPropSet->getPropertyValue( s_NumberingLevel ) >>= nNumLevel; + if ( nNumLevel == -1 || + nNumLevel != (nOutlineLevel - 1) ) + { + xPropSet->setPropertyValue( s_NumberingLevel, + makeAny( static_cast<sal_Int8>(nOutlineLevel - 1) ) ); + } + } + // <-- + // --> OD 2006-10-13 #i69629# - correction: + // - for text document from version OOo 2.0.4/SO 8 PU4 and earlier + // the paragraph style of a heading should be assigned to the + // corresponding list level of the outline style. + // - for other text documents the paragraph style of a heading is only + // a candidate for an assignment to the list level of the outline + // style, if it has no direct list style property and (if exists) the + // automatic paragraph style has also no direct list style set. + if (m_pImpl->m_xParaStyles->hasByName(sStyleName)) + { + bool bOutlineStyleCandidate( false ); + + sal_Int32 nUPD( 0 ); + sal_Int32 nBuild( 0 ); + // --> OD 2007-12-19 #152540# + const bool bBuildIdFound = rImport.getBuildIds( nUPD, nBuild ); + // --> OD 2007-07-25 #i73509# + // --> OD 2008-03-19 #i86058# - check explicitly on certain versions + if ( rImport.IsTextDocInOOoFileFormat() || + ( bBuildIdFound && + ( nUPD == 645 || nUPD == 641 ) ) ) + { + bOutlineStyleCandidate = true; + } + else if ( nUPD == 680 && nBuild <= 9073 ) /* BuildId of OOo 2.0.4/SO8 PU4 */ + { + bOutlineStyleCandidate = bOutlineLevelAttrFound; + } + // <-- +// else +// { +// Reference< XPropertyState > xStylePropState( +// xParaStyles->getByName( sStyleName ), UNO_QUERY ); +// if ( xStylePropState.is() && +// xStylePropState->getPropertyState( sNumberingStyleName ) == PropertyState_DIRECT_VALUE ) +// { +// bOutlineStyleCandidate = false; +// } +// // --> OD 2007-01-11 #i73361# +// // The automatic paragraph style doesn't have to be considered. +// // else if ( pStyle && /* automatic paragraph style */ +// // pStyle->IsListStyleSet() ) +// // { +// // bOutlineStyleCandidate = false; +// // } +// // <-- +// else +// { +// bOutlineStyleCandidate = true; +// } +// } + + if ( bOutlineStyleCandidate ) + { + AddOutlineStyleCandidate( nOutlineLevel, sStyleName ); + } + // --> OD 2009-08-18 #i103817# + // Assure that heading applies the outline style + if ( ( !pStyle || !pStyle->IsListStyleSet() ) && + !bOutlineStyleCandidate && + m_pImpl->m_xChapterNumbering.is()) + { + OUString sEmptyStr; + if ( !lcl_HasListStyle( sStyleName, + m_pImpl->m_xParaStyles, GetXMLImport(), + s_NumberingStyleName, + sEmptyStr ) ) + { + // heading not in a list --> apply outline style + xPropSet->setPropertyValue( s_NumberingRules, + makeAny(m_pImpl->m_xChapterNumbering) ); + xPropSet->setPropertyValue( s_NumberingLevel, + makeAny(static_cast<sal_Int8>(nOutlineLevel - 1))); + } + } + // <-- + } + // <-- + } + //-> #outlinelevel added by zhaojianwei + //handle for text:p,if the paragraphstyle outlinelevel is set to[1~10] + else if( bHasOutlineLevelProp ) + { + if ( nCurrentOutlineLevelInheritedFromParagraphStyle != 0 ) + { + sal_Int16 nZero = 0; + xPropSet->setPropertyValue(s_OutlineLevel, + makeAny( static_cast<sal_Int16>(nZero) )); + } + }//<-end,zhaojianwei + } + // <-- + + return sStyleName; +} + +void XMLTextImportHelper::FindOutlineStyleName( ::rtl::OUString& rStyleName, + sal_Int8 nOutlineLevel ) +{ + static ::rtl::OUString s_HeadingStyleName( + RTL_CONSTASCII_USTRINGPARAM("HeadingStyleName")); + + // style name empty? + if( rStyleName.getLength() == 0 ) + { + // Empty? Then we need o do stuff. Let's do error checking first. + if (m_pImpl->m_xChapterNumbering.is() && + ( nOutlineLevel > 0 ) && + (nOutlineLevel <= m_pImpl->m_xChapterNumbering->getCount())) + { + nOutlineLevel--; // for the remainder, the level's are 0-based + + // empty style name: look-up previously used name + + // if we don't have a previously used name, we'll use the default + m_pImpl->InitOutlineStylesCandidates(); + if (m_pImpl->m_pOutlineStylesCandidates[nOutlineLevel].empty()) + { + // no other name used previously? Then use default + + // iterate over property value sequence to find the style name + Sequence<PropertyValue> aProperties; + m_pImpl->m_xChapterNumbering->getByIndex( nOutlineLevel ) + >>= aProperties; + for( sal_Int32 i = 0; i < aProperties.getLength(); i++ ) + { + if (aProperties[i].Name == s_HeadingStyleName) + { + rtl::OUString aOutlineStyle; + aProperties[i].Value >>= aOutlineStyle; + m_pImpl->m_pOutlineStylesCandidates[nOutlineLevel] + .push_back( aOutlineStyle ); + break; // early out, if we found it!. + } + } + } + + // finally, we'll use the previously used style name for this + // format (or the default we've just put into that style) + // --> OD 2006-11-06 #i71249# - take last added one + rStyleName = + m_pImpl->m_pOutlineStylesCandidates[nOutlineLevel].back(); + // <-- + } + // else: nothing we can do, so we'll leave it empty + } + // else: we already had a style name, so we let it pass. +} + +void XMLTextImportHelper::AddOutlineStyleCandidate( const sal_Int8 nOutlineLevel, + const OUString& rStyleName ) +{ + if (rStyleName.getLength() + && m_pImpl->m_xChapterNumbering.is() + && (nOutlineLevel > 0) + && (nOutlineLevel <= m_pImpl->m_xChapterNumbering->getCount())) + { + m_pImpl->InitOutlineStylesCandidates(); + m_pImpl->m_pOutlineStylesCandidates[nOutlineLevel-1].push_back( + rStyleName); + } +} + +void XMLTextImportHelper::SetOutlineStyles( sal_Bool bSetEmptyLevels ) +{ + static ::rtl::OUString s_NumberingStyleName( + RTL_CONSTASCII_USTRINGPARAM("NumberingStyleName")); + static ::rtl::OUString s_HeadingStyleName( + RTL_CONSTASCII_USTRINGPARAM("HeadingStyleName")); + + if ((m_pImpl->m_pOutlineStylesCandidates != NULL || bSetEmptyLevels) && + m_pImpl->m_xChapterNumbering.is() && + !IsInsertMode()) + { + bool bChooseLastOne( false ); + { + if ( GetXMLImport().IsTextDocInOOoFileFormat() ) + { + bChooseLastOne = true; + } + else + { + sal_Int32 nUPD( 0 ); + sal_Int32 nBuild( 0 ); + if ( GetXMLImport().getBuildIds( nUPD, nBuild ) ) + { + // check explicitly on certain versions + bChooseLastOne = ( nUPD == 641 ) || ( nUPD == 645 ) || // prior OOo 2.0 + ( nUPD == 680 && nBuild <= 9073 ); // OOo 2.0 - OOo 2.0.4 + } + } + } + + OUString sOutlineStyleName; + { + Reference<XPropertySet> xChapterNumRule( + m_pImpl->m_xChapterNumbering, UNO_QUERY); + const OUString sName(RTL_CONSTASCII_USTRINGPARAM("Name")); + xChapterNumRule->getPropertyValue(sName) >>= sOutlineStyleName; + } + + const sal_Int32 nCount = m_pImpl->m_xChapterNumbering->getCount(); + // --> OD 2009-11-13 #i106218# + // First collect all paragraph styles choosen for assignment to each + // list level of the outline style, then perform the intrinsic assignment. + // Reason: The assignment of a certain paragraph style to a list level + // of the outline style causes side effects on the children + // paragraph styles in Writer. + ::std::vector<OUString> sChosenStyles(nCount); + // <-- + for( sal_Int32 i=0; i < nCount; ++i ) + { + if ( bSetEmptyLevels || + (m_pImpl->m_pOutlineStylesCandidates && + !m_pImpl->m_pOutlineStylesCandidates[i].empty())) + { + // determine, which candidate is one to be assigned to the list + // level of the outline style + if (m_pImpl->m_pOutlineStylesCandidates && + !m_pImpl->m_pOutlineStylesCandidates[i].empty()) + { + if ( bChooseLastOne ) + { + sChosenStyles[i] = + m_pImpl->m_pOutlineStylesCandidates[i].back(); + } + else + { + for (sal_uInt32 j = 0; + j < m_pImpl->m_pOutlineStylesCandidates[i].size(); + ++j) + { + if (!lcl_HasListStyle( + m_pImpl->m_pOutlineStylesCandidates[i][j], + m_pImpl->m_xParaStyles, GetXMLImport(), + s_NumberingStyleName, + sOutlineStyleName)) + { + sChosenStyles[i] = + m_pImpl->m_pOutlineStylesCandidates[i][j]; + break; + } + } + } + } + } + } + // --> OD 2009-11-13 #i106218# + Sequence < PropertyValue > aProps( 1 ); + PropertyValue *pProps = aProps.getArray(); + pProps->Name = s_HeadingStyleName; + for ( sal_Int32 i = 0; i < nCount; ++i ) + { + // --> OD 2009-12-11 #i107610# + if ( bSetEmptyLevels || + sChosenStyles[i].getLength() > 0 ) + // <-- + { + pProps->Value <<= sChosenStyles[i]; + m_pImpl->m_xChapterNumbering->replaceByIndex(i, + makeAny( aProps )); + } + } + // <-- + } +} + +void XMLTextImportHelper::SetHyperlink( + SvXMLImport& rImport, + const Reference < XTextCursor >& rCursor, + const OUString& rHRef, + const OUString& rName, + const OUString& rTargetFrameName, + const OUString& rStyleName, + const OUString& rVisitedStyleName, + XMLEventsImportContext* pEvents) +{ + static ::rtl::OUString s_HyperLinkURL( + RTL_CONSTASCII_USTRINGPARAM("HyperLinkURL")); + static ::rtl::OUString s_HyperLinkName( + RTL_CONSTASCII_USTRINGPARAM("HyperLinkName")); + static ::rtl::OUString s_HyperLinkTarget( + RTL_CONSTASCII_USTRINGPARAM("HyperLinkTarget")); + static ::rtl::OUString s_UnvisitedCharStyleName( + RTL_CONSTASCII_USTRINGPARAM("UnvisitedCharStyleName")); + static ::rtl::OUString s_VisitedCharStyleName( + RTL_CONSTASCII_USTRINGPARAM("VisitedCharStyleName")); + static ::rtl::OUString s_HyperLinkEvents( + RTL_CONSTASCII_USTRINGPARAM("HyperLinkEvents")); + + Reference < XPropertySet > xPropSet( rCursor, UNO_QUERY ); + Reference < XPropertySetInfo > xPropSetInfo( + xPropSet->getPropertySetInfo()); + if (!xPropSetInfo.is() || !xPropSetInfo->hasPropertyByName(s_HyperLinkURL)) + return; + + xPropSet->setPropertyValue(s_HyperLinkURL, makeAny(rHRef)); + + if (xPropSetInfo->hasPropertyByName(s_HyperLinkName)) + { + xPropSet->setPropertyValue(s_HyperLinkName, makeAny(rName)); + } + + if (xPropSetInfo->hasPropertyByName(s_HyperLinkTarget)) + { + xPropSet->setPropertyValue(s_HyperLinkTarget, + makeAny(rTargetFrameName)); + } + + if ( (pEvents != NULL) && + xPropSetInfo->hasPropertyByName(s_HyperLinkEvents)) + { + // The API treats events at hyperlinks differently from most + // other properties: You have to set a name replace with the + // events in it. The easiest way to to this is to 1) get + // events, 2) set new ones, and 3) then put events back. + uno::Reference<XNameReplace> const xReplace( + xPropSet->getPropertyValue(s_HyperLinkEvents), UNO_QUERY); + if (xReplace.is()) + { + // set events + pEvents->SetEvents(xReplace); + + // put events + xPropSet->setPropertyValue(s_HyperLinkEvents, makeAny(xReplace)); + } + } + + if (m_pImpl->m_xTextStyles.is()) + { + OUString sDisplayName( + rImport.GetStyleDisplayName( + XML_STYLE_FAMILY_TEXT_TEXT, rStyleName ) ); + if( sDisplayName.getLength() && + xPropSetInfo->hasPropertyByName(s_UnvisitedCharStyleName) && + m_pImpl->m_xTextStyles->hasByName(sDisplayName)) + { + xPropSet->setPropertyValue(s_UnvisitedCharStyleName, + makeAny(sDisplayName)); + } + + sDisplayName = + rImport.GetStyleDisplayName( + XML_STYLE_FAMILY_TEXT_TEXT, rVisitedStyleName ); + if( sDisplayName.getLength() && + xPropSetInfo->hasPropertyByName(s_VisitedCharStyleName) && + m_pImpl->m_xTextStyles->hasByName(sDisplayName)) + { + xPropSet->setPropertyValue(s_VisitedCharStyleName, + makeAny(sDisplayName)); + } + } +} + +void XMLTextImportHelper::SetRuby( + SvXMLImport& rImport, + const Reference < XTextCursor >& rCursor, + const OUString& rStyleName, + const OUString& rTextStyleName, + const OUString& rText ) +{ + Reference<XPropertySet> xPropSet(rCursor, UNO_QUERY); + + OUString sRubyText(RTL_CONSTASCII_USTRINGPARAM("RubyText")); + OUString sRubyCharStyleName(RTL_CONSTASCII_USTRINGPARAM("RubyCharStyleName")); + + // if we have one Ruby property, we assume all of them are present + if (xPropSet.is() && + xPropSet->getPropertySetInfo()->hasPropertyByName( sRubyText )) + { + // the ruby text + xPropSet->setPropertyValue(sRubyText, makeAny(rText)); + + // the ruby style (ruby-adjust) + XMLPropStyleContext *pStyle = 0; + if (rStyleName.getLength() && m_pImpl->m_xAutoStyles.Is()) + { + const SvXMLStyleContext* pTempStyle = + ((SvXMLStylesContext *)&m_pImpl->m_xAutoStyles)-> + FindStyleChildContext( XML_STYLE_FAMILY_TEXT_RUBY, + rStyleName, sal_True ); + pStyle = PTR_CAST(XMLPropStyleContext,pTempStyle); + + if (NULL != pStyle) + pStyle->FillPropertySet( xPropSet ); + } + + // the ruby text character style + if (m_pImpl->m_xTextStyles.is()) + { + OUString sDisplayName( + rImport.GetStyleDisplayName( + XML_STYLE_FAMILY_TEXT_TEXT, rTextStyleName ) ); + if( (sDisplayName.getLength() > 0) && +// xPropSetInfo->hasPropertyByName( sRubyCharStyleName ) && + m_pImpl->m_xTextStyles->hasByName( sDisplayName )) + { + xPropSet->setPropertyValue(sRubyCharStyleName, makeAny(sDisplayName)); + } + } + } +} + +void XMLTextImportHelper::SetAutoStyles( SvXMLStylesContext *pStyles ) +{ + m_pImpl->m_xAutoStyles = pStyles; +} + +void XMLTextImportHelper::SetFontDecls( XMLFontStylesContext *pFontDecls ) +{ + m_pImpl->m_xFontDecls = pFontDecls; + ((XMLTextImportPropertyMapper *)m_pImpl->m_xParaImpPrMap.get()) + ->SetFontDecls( pFontDecls ); + ((XMLTextImportPropertyMapper *)m_pImpl->m_xTextImpPrMap.get()) + ->SetFontDecls( pFontDecls ); +} + +const XMLFontStylesContext *XMLTextImportHelper::GetFontDecls() const +{ + return (XMLFontStylesContext *)&m_pImpl->m_xFontDecls; +} + +sal_Bool XMLTextImportHelper::HasDrawNameAttribute( + const Reference< XAttributeList > & xAttrList, + SvXMLNamespaceMap& rNamespaceMap ) +{ + sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; + for( sal_Int16 i=0; i < nAttrCount; i++ ) + { + const OUString& rAttrName = xAttrList->getNameByIndex( i ); + + OUString aLocalName; + sal_uInt16 nPrefix = + rNamespaceMap.GetKeyByAttrName( rAttrName, &aLocalName ); + if( XML_NAMESPACE_DRAW == nPrefix && + IsXMLToken( aLocalName, XML_NAME ) ) + { + return xAttrList->getValueByIndex(i).getLength() != 0; + } + } + + return sal_False; +} + +SvXMLImportContext *XMLTextImportHelper::CreateTextChildContext( + SvXMLImport& rImport, + sal_uInt16 nPrefix, const OUString& rLocalName, + const Reference< XAttributeList > & xAttrList, + XMLTextType eType ) +{ + SvXMLImportContext *pContext = 0; + + const SvXMLTokenMap& rTokenMap = GetTextElemTokenMap(); + sal_Bool bHeading = sal_False; + sal_Bool bContent = sal_True; + sal_uInt16 nToken = rTokenMap.Get( nPrefix, rLocalName ); + switch( nToken ) + { + case XML_TOK_TEXT_H: + bHeading = sal_True; + case XML_TOK_TEXT_P: + pContext = new XMLParaContext( rImport, + nPrefix, rLocalName, + xAttrList, bHeading ); + if (m_pImpl->m_bProgress && XML_TEXT_TYPE_SHAPE != eType) + { + rImport.GetProgressBarHelper()->Increment(); + } + break; + case XML_TOK_TEXT_NUMBERED_PARAGRAPH: + pContext = new XMLNumberedParaContext( + rImport, nPrefix, rLocalName, xAttrList ); + break; + case XML_TOK_TEXT_LIST: + pContext = new XMLTextListBlockContext( rImport, *this, + nPrefix, rLocalName, + xAttrList ); + break; + case XML_TOK_TABLE_TABLE: + if( XML_TEXT_TYPE_BODY == eType || + XML_TEXT_TYPE_TEXTBOX == eType || + XML_TEXT_TYPE_SECTION == eType || + XML_TEXT_TYPE_HEADER_FOOTER == eType || + XML_TEXT_TYPE_CHANGED_REGION == eType || + XML_TEXT_TYPE_CELL == eType ) + pContext = CreateTableChildContext( rImport, nPrefix, rLocalName, + xAttrList ); + break; + case XML_TOK_TEXT_SEQUENCE_DECLS: + if ((XML_TEXT_TYPE_BODY == eType && m_pImpl->m_bBodyContentStarted) || + XML_TEXT_TYPE_HEADER_FOOTER == eType ) + { + pContext = new XMLVariableDeclsImportContext( + rImport, *this, nPrefix, rLocalName, VarTypeSequence); + bContent = sal_False; + } + break; + + case XML_TOK_TEXT_VARFIELD_DECLS: + if ((XML_TEXT_TYPE_BODY == eType && m_pImpl->m_bBodyContentStarted) || + XML_TEXT_TYPE_HEADER_FOOTER == eType ) + { + pContext = new XMLVariableDeclsImportContext( + rImport, *this, nPrefix, rLocalName, VarTypeSimple); + bContent = sal_False; + } + break; + + case XML_TOK_TEXT_USERFIELD_DECLS: + if ((XML_TEXT_TYPE_BODY == eType && m_pImpl->m_bBodyContentStarted)|| + XML_TEXT_TYPE_HEADER_FOOTER == eType ) + { + pContext = new XMLVariableDeclsImportContext( + rImport, *this, nPrefix, rLocalName, VarTypeUserField); + bContent = sal_False; + } + break; + + case XML_TOK_TEXT_DDE_DECLS: + if ((XML_TEXT_TYPE_BODY == eType && m_pImpl->m_bBodyContentStarted) || + XML_TEXT_TYPE_HEADER_FOOTER == eType ) + { + pContext = new XMLDdeFieldDeclsImportContext( + rImport, nPrefix, rLocalName); + bContent = sal_False; + } + break; + + case XML_TOK_TEXT_FRAME_PAGE: + if ((XML_TEXT_TYPE_BODY == eType && m_pImpl->m_bBodyContentStarted) || + XML_TEXT_TYPE_TEXTBOX == eType || + XML_TEXT_TYPE_CHANGED_REGION == eType ) + { + TextContentAnchorType eAnchorType = + XML_TEXT_TYPE_TEXTBOX == eType ? TextContentAnchorType_AT_FRAME + : TextContentAnchorType_AT_PAGE; + pContext = new XMLTextFrameContext( rImport, nPrefix, + rLocalName, xAttrList, + eAnchorType ); + bContent = sal_False; + } + break; + + case XML_TOK_DRAW_A_PAGE: + if ((XML_TEXT_TYPE_BODY == eType && m_pImpl->m_bBodyContentStarted) || + XML_TEXT_TYPE_TEXTBOX == eType || + XML_TEXT_TYPE_CHANGED_REGION == eType) + { + TextContentAnchorType eAnchorType = + XML_TEXT_TYPE_TEXTBOX == eType ? TextContentAnchorType_AT_FRAME + : TextContentAnchorType_AT_PAGE; + pContext = new XMLTextFrameHyperlinkContext( rImport, nPrefix, + rLocalName, xAttrList, + eAnchorType ); + bContent = sal_False; + } + break; + + case XML_TOK_TEXT_INDEX_TITLE: + case XML_TOK_TEXT_SECTION: +#ifndef SVX_LIGHT + pContext = new XMLSectionImportContext( rImport, nPrefix, rLocalName ); +#else + // create default context to skip content + pContext = new SvXMLImportContext( rImport, nPrefix, rLocalName ); +#endif // #ifndef SVX_LIGHT + break; + + case XML_TOK_TEXT_TOC: + case XML_TOK_TEXT_OBJECT_INDEX: + case XML_TOK_TEXT_TABLE_INDEX: + case XML_TOK_TEXT_ILLUSTRATION_INDEX: + case XML_TOK_TEXT_USER_INDEX: + case XML_TOK_TEXT_ALPHABETICAL_INDEX: + case XML_TOK_TEXT_BIBLIOGRAPHY_INDEX: +#ifndef SVX_LIGHT + if( XML_TEXT_TYPE_SHAPE != eType ) + pContext = new XMLIndexTOCContext( rImport, nPrefix, rLocalName ); +#else + // create default context to skip content + pContext = new SvXMLImportContext( rImport, nPrefix, rLocalName ); +#endif // #ifndef SVX_LIGHT + break; + + case XML_TOK_TEXT_TRACKED_CHANGES: +#ifndef SVX_LIGHT + pContext = new XMLTrackedChangesImportContext( rImport, nPrefix, + rLocalName); +#else + // create default context to skip content + pContext = new SvXMLImportContext( rImport, nPrefix, rLocalName ); +#endif // #ifndef SVX_LIGHT + bContent = sal_False; + break; + + case XML_TOK_TEXT_CHANGE: + case XML_TOK_TEXT_CHANGE_START: + case XML_TOK_TEXT_CHANGE_END: + pContext = new XMLChangeImportContext( + rImport, nPrefix, rLocalName, + (XML_TOK_TEXT_CHANGE_END != nToken), + (XML_TOK_TEXT_CHANGE_START != nToken), + sal_True); + break; + + case XML_TOK_TEXT_FORMS: +#ifndef SVX_LIGHT + pContext = rImport.GetFormImport()->createOfficeFormsContext(rImport, nPrefix, rLocalName); +#else + // create default context to skip content + pContext = new SvXMLImportContext( rImport, nPrefix, rLocalName ); +#endif // #ifndef SVX_LIGHT + bContent = sal_False; + break; + + case XML_TOK_TEXT_AUTOMARK: + if( XML_TEXT_TYPE_BODY == eType ) + { + pContext = new XMLAutoMarkFileContext(rImport, nPrefix,rLocalName); + } + bContent = sal_False; + break; + + case XML_TOK_TEXT_CALCULATION_SETTINGS: +#ifndef SVX_LIGHT + pContext = new XMLCalculationSettingsContext ( rImport, nPrefix, rLocalName, xAttrList); +#else + // create default context to skip content + pContext = new SvXMLImportContext( rImport, nPrefix, rLocalName ); +#endif // #ifndef SVX_LIGHT + bContent = sal_False; + break; + + default: + if ((XML_TEXT_TYPE_BODY == eType && m_pImpl->m_bBodyContentStarted) || + XML_TEXT_TYPE_TEXTBOX == eType || + XML_TEXT_TYPE_CHANGED_REGION == eType ) + { + Reference < XShapes > xShapes; + pContext = rImport.GetShapeImport()->CreateGroupChildContext( + rImport, nPrefix, rLocalName, xAttrList, xShapes ); + bContent = sal_False; + } + } + +// if( !pContext ) +// pContext = new SvXMLImportContext( GetImport(), nPrefix, rLocalName ); + + // handle open redlines + if ( (XML_TOK_TEXT_CHANGE != nToken) && + (XML_TOK_TEXT_CHANGE_END != nToken) && + (XML_TOK_TEXT_CHANGE_START != nToken) ) + { +// ResetOpenRedlineId(); + } + + if( XML_TEXT_TYPE_BODY == eType && bContent ) + { + m_pImpl->m_bBodyContentStarted = sal_False; + } + + return pContext; +} + +SvXMLImportContext *XMLTextImportHelper::CreateTableChildContext( + SvXMLImport&, + sal_uInt16 /*nPrefix*/, const OUString& /*rLocalName*/, + const Reference< XAttributeList > & ) +{ + return 0; +} + +/// get data style key for use with NumberFormat property +sal_Int32 XMLTextImportHelper::GetDataStyleKey(const OUString& sStyleName, + sal_Bool* pIsSystemLanguage ) +{ + const SvXMLStyleContext* pStyle = + ((SvXMLStylesContext *)&m_pImpl->m_xAutoStyles)-> + FindStyleChildContext( XML_STYLE_FAMILY_DATA_STYLE, + sStyleName, sal_True ); + + // get appropriate context + + + // first check if its a impress and draw only number format + // this is needed since its also a SvXMLNumFormatContext, + // that was needed to support them for controls in impress/draw also + SdXMLNumberFormatImportContext* pSdNumStyle = PTR_CAST( SdXMLNumberFormatImportContext, pStyle ); + if( pSdNumStyle ) + { + return pSdNumStyle->GetDrawKey(); + } + else + { + SvXMLNumFormatContext* pNumStyle = PTR_CAST( SvXMLNumFormatContext, pStyle ); + if( pNumStyle ) + { + if( pIsSystemLanguage != NULL ) + *pIsSystemLanguage = pNumStyle->IsSystemLanguage(); + + // return key + return pNumStyle->GetKey(); + } + } + return -1; +} + +const SvxXMLListStyleContext *XMLTextImportHelper::FindAutoListStyle( const OUString& rName ) const +{ + const SvxXMLListStyleContext *pStyle = 0; + if (m_pImpl->m_xAutoStyles.Is()) + { + const SvXMLStyleContext* pTempStyle = + ((SvXMLStylesContext *)&m_pImpl->m_xAutoStyles)-> + FindStyleChildContext( XML_STYLE_FAMILY_TEXT_LIST, rName, + sal_True ); + pStyle = PTR_CAST( SvxXMLListStyleContext ,pTempStyle); + } + + return pStyle; +} + +XMLPropStyleContext *XMLTextImportHelper::FindAutoFrameStyle( const OUString& rName ) const +{ + XMLPropStyleContext *pStyle = 0; + if (m_pImpl->m_xAutoStyles.Is()) + { + const SvXMLStyleContext* pTempStyle = + ((SvXMLStylesContext *)&m_pImpl->m_xAutoStyles)-> + FindStyleChildContext( XML_STYLE_FAMILY_SD_GRAPHICS_ID, rName, + sal_True ); + pStyle = PTR_CAST( XMLPropStyleContext ,pTempStyle); + } + + return pStyle; +} + +XMLPropStyleContext* XMLTextImportHelper::FindSectionStyle( + const OUString& rName ) const +{ + XMLPropStyleContext* pStyle = NULL; + if (m_pImpl->m_xAutoStyles.Is()) + { + const SvXMLStyleContext* pTempStyle = + ((SvXMLStylesContext *)&m_pImpl->m_xAutoStyles)-> + FindStyleChildContext( + XML_STYLE_FAMILY_TEXT_SECTION, + rName, sal_True ); + pStyle = PTR_CAST( XMLPropStyleContext,pTempStyle); + } + + return pStyle; +} + +XMLPropStyleContext* XMLTextImportHelper::FindPageMaster( + const OUString& rName ) const +{ + XMLPropStyleContext* pStyle = NULL; + if (m_pImpl->m_xAutoStyles.Is()) + { + const SvXMLStyleContext* pTempStyle = + ((SvXMLStylesContext *)&m_pImpl->m_xAutoStyles)-> + FindStyleChildContext( + XML_STYLE_FAMILY_PAGE_MASTER, + rName, sal_True ); + pStyle = PTR_CAST( XMLPropStyleContext,pTempStyle); + } + + return pStyle; +} + + +void XMLTextImportHelper::PushListContext(XMLTextListBlockContext *i_pListBlock) +{ + GetTextListHelper().PushListContext(i_pListBlock); +} + +void XMLTextImportHelper::PopListContext() +{ + GetTextListHelper().PopListContext(); +} + + +const SvXMLTokenMap& XMLTextImportHelper::GetTextNumberedParagraphAttrTokenMap() +{ + if (!m_pImpl->m_pTextNumberedParagraphAttrTokenMap.get()) + { + m_pImpl->m_pTextNumberedParagraphAttrTokenMap.reset( + new SvXMLTokenMap( aTextNumberedParagraphAttrTokenMap ) ); + } + return *m_pImpl->m_pTextNumberedParagraphAttrTokenMap; +} + +const SvXMLTokenMap& XMLTextImportHelper::GetTextListBlockAttrTokenMap() +{ + if (!m_pImpl->m_pTextListBlockAttrTokenMap.get()) + { + m_pImpl->m_pTextListBlockAttrTokenMap.reset( + new SvXMLTokenMap( aTextListBlockAttrTokenMap ) ); + } + return *m_pImpl->m_pTextListBlockAttrTokenMap; +} + +const SvXMLTokenMap& XMLTextImportHelper::GetTextListBlockElemTokenMap() +{ + if (!m_pImpl->m_pTextListBlockElemTokenMap.get()) + { + m_pImpl->m_pTextListBlockElemTokenMap.reset( + new SvXMLTokenMap( aTextListBlockElemTokenMap ) ); + } + return *m_pImpl->m_pTextListBlockElemTokenMap; +} + +SvI18NMap& XMLTextImportHelper::GetRenameMap() +{ + if (!m_pImpl->m_pRenameMap.get()) + { + m_pImpl->m_pRenameMap.reset( new SvI18NMap() ); + } + return *m_pImpl->m_pRenameMap; +} + +void XMLTextImportHelper::InsertBookmarkStartRange( + const OUString sName, + const Reference<XTextRange> & rRange, + OUString const& i_rXmlId, + ::boost::shared_ptr< ::xmloff::ParsedRDFaAttributes > & i_rpRDFaAttributes) +{ + m_pImpl->m_BookmarkStartRanges[sName] = + ::boost::make_tuple(rRange, i_rXmlId, i_rpRDFaAttributes); + m_pImpl->m_BookmarkVector.push_back(sName); +} + +sal_Bool XMLTextImportHelper::FindAndRemoveBookmarkStartRange( + const OUString sName, + Reference<XTextRange> & o_rRange, + OUString & o_rXmlId, + ::boost::shared_ptr< ::xmloff::ParsedRDFaAttributes > & o_rpRDFaAttributes) +{ + if (m_pImpl->m_BookmarkStartRanges.count(sName)) + { + Impl::BookmarkMapEntry_t & rEntry = + (*m_pImpl->m_BookmarkStartRanges.find(sName)).second; + o_rRange.set(rEntry.get<0>()); + o_rXmlId = rEntry.get<1>(); + o_rpRDFaAttributes = rEntry.get<2>(); + m_pImpl->m_BookmarkStartRanges.erase(sName); + Impl::BookmarkVector_t::iterator it(m_pImpl->m_BookmarkVector.begin()); + while (it != m_pImpl->m_BookmarkVector.end() && it->compareTo(sName)!=0) + { + it++; + } + if (it!=m_pImpl->m_BookmarkVector.end()) { + m_pImpl->m_BookmarkVector.erase(it); + } + return sal_True; + } + else + { + return sal_False; + } +} + +::rtl::OUString XMLTextImportHelper::FindActiveBookmarkName() +{ + if (!m_pImpl->m_BookmarkVector.empty()) { + return m_pImpl->m_BookmarkVector.back(); + } else return ::rtl::OUString(); // return the empty string on error... +} + +::com::sun::star::uno::Reference< ::com::sun::star::text::XTextRange > XMLTextImportHelper::GetRangeFor(::rtl::OUString &sName) +{ + return m_pImpl->m_BookmarkStartRanges[sName].get<0>(); +} + + +void XMLTextImportHelper::pushFieldCtx( ::rtl::OUString name, ::rtl::OUString type ) +{ + m_pImpl->m_FieldStack.push(Impl::field_stack_item_t( + Impl::field_name_type_t(name, type), Impl::field_params_t())); +} + +void XMLTextImportHelper::popFieldCtx() +{ + m_pImpl->m_FieldStack.pop(); +} + +void XMLTextImportHelper::addFieldParam( ::rtl::OUString name, ::rtl::OUString value ) +{ + DBG_ASSERT(!m_pImpl->m_FieldStack.empty(), + "stack is empty: not good! Do a pushFieldCtx before..."); + if (!m_pImpl->m_FieldStack.empty()) { + Impl::field_stack_item_t & FieldStackItem(m_pImpl->m_FieldStack.top()); + FieldStackItem.second.push_back(Impl::field_param_t( name, value )); + } +} +::rtl::OUString XMLTextImportHelper::getCurrentFieldName() +{ + DBG_ASSERT(!m_pImpl->m_FieldStack.empty(), + "stack is empty: not good! Do a pushFieldCtx before..."); + if (!m_pImpl->m_FieldStack.empty()) { + return m_pImpl->m_FieldStack.top().first.first; + } else return ::rtl::OUString(); +} + +::rtl::OUString XMLTextImportHelper::getCurrentFieldType() +{ + DBG_ASSERT(!m_pImpl->m_FieldStack.empty(), + "stack is empty: not good! Do a pushFieldCtx before..."); + if (!m_pImpl->m_FieldStack.empty()) { + return m_pImpl->m_FieldStack.top().first.second; + } else return ::rtl::OUString(); +} + +bool XMLTextImportHelper::hasCurrentFieldCtx() +{ + return !m_pImpl->m_FieldStack.empty(); +} + +void XMLTextImportHelper::setCurrentFieldParamsTo(::com::sun::star::uno::Reference< ::com::sun::star::text::XFormField> &xFormField) +{ + DBG_ASSERT(!m_pImpl->m_FieldStack.empty(), + "stack is empty: not good! Do a pushFieldCtx before..."); + if (!m_pImpl->m_FieldStack.empty() && xFormField.is()) + { + FieldParamImporter(&m_pImpl->m_FieldStack.top().second, + xFormField->getParameters()).Import(); + } +} + + +void XMLTextImportHelper::ConnectFrameChains( + const OUString& rFrmName, + const OUString& rNextFrmName, + const Reference < XPropertySet >& rFrmPropSet ) +{ + static ::rtl::OUString s_ChainNextName( + RTL_CONSTASCII_USTRINGPARAM("ChainNextName")); + static ::rtl::OUString s_ChainPrevName( + RTL_CONSTASCII_USTRINGPARAM("ChainPrevName")); + + if( !rFrmName.getLength() ) + return; + + if( rNextFrmName.getLength() ) + { + OUString sNextFrmName(GetRenameMap().Get( XML_TEXT_RENAME_TYPE_FRAME, + rNextFrmName )); + if (m_pImpl->m_xTextFrames.is() + && m_pImpl->m_xTextFrames->hasByName(sNextFrmName)) + { + rFrmPropSet->setPropertyValue(s_ChainNextName, + makeAny(sNextFrmName)); + } + else + { + if (!m_pImpl->m_pPrevFrmNames.get()) + { + m_pImpl->m_pPrevFrmNames.reset( new SvStringsDtor ); + m_pImpl->m_pNextFrmNames.reset( new SvStringsDtor ); + } + m_pImpl->m_pPrevFrmNames->Insert( new String( rFrmName ), + m_pImpl->m_pPrevFrmNames->Count() ); + m_pImpl->m_pNextFrmNames->Insert( new String( sNextFrmName ), + m_pImpl->m_pNextFrmNames->Count() ); + } + } + if (m_pImpl->m_pPrevFrmNames.get() && m_pImpl->m_pPrevFrmNames->Count()) + { + sal_uInt16 nCount = m_pImpl->m_pPrevFrmNames->Count(); + for( sal_uInt16 i=0; i<nCount; i++ ) + { + String *pNext = (*m_pImpl->m_pNextFrmNames)[i]; + if( OUString(*pNext) == rFrmName ) + { + // The previuous frame must exist, because it existing than + // inserting the entry + String *pPrev = (*m_pImpl->m_pPrevFrmNames)[i]; + + rFrmPropSet->setPropertyValue(s_ChainPrevName, + makeAny(OUString( *pPrev ))); + + m_pImpl->m_pPrevFrmNames->Remove( i, 1 ); + m_pImpl->m_pNextFrmNames->Remove( i, 1 ); + delete pPrev; + delete pNext; + + // There cannot be more than one previous frames + break; + } + } + } +} + +sal_Bool XMLTextImportHelper::IsInFrame() const +{ + static ::rtl::OUString s_TextFrame( + RTL_CONSTASCII_USTRINGPARAM("TextFrame")); + + sal_Bool bIsInFrame = sal_False; + + // are we currently in a text frame? yes, if the cursor has a + // TextFrame property and it's non-NULL + Reference<XPropertySet> xPropSet(((XMLTextImportHelper *)this)->GetCursor(), UNO_QUERY); + if (xPropSet.is()) + { + if (xPropSet->getPropertySetInfo()->hasPropertyByName(s_TextFrame)) + { + uno::Reference<XTextFrame> const xFrame( + xPropSet->getPropertyValue(s_TextFrame), UNO_QUERY); + + if (xFrame.is()) + { + bIsInFrame = sal_True; + } + } + } + + return bIsInFrame; +} + +sal_Bool XMLTextImportHelper::IsInHeaderFooter() const +{ + return sal_False; +} + +Reference< XPropertySet> XMLTextImportHelper::createAndInsertOLEObject( + SvXMLImport&, + const OUString& /*rHRef*/, + const OUString& /*rStyleName*/, + const OUString& /*rTblName*/, + sal_Int32 /*nWidth*/, sal_Int32 /*nHeight*/ ) +{ + Reference< XPropertySet> xPropSet; + return xPropSet; +} + +Reference< XPropertySet> XMLTextImportHelper::createAndInsertOOoLink( + SvXMLImport&, + const OUString& /*rHRef*/, + const OUString& /*rStyleName*/, + const OUString& /*rTblName*/, + sal_Int32 /*nWidth*/, sal_Int32 /*nHeight*/ ) +{ + Reference< XPropertySet> xPropSet; + return xPropSet; +} + +Reference< XPropertySet> XMLTextImportHelper::createAndInsertApplet( + const OUString& /*rCode*/, + const OUString& /*rName*/, + sal_Bool /*bMayScript*/, + const OUString& /*rHRef*/, + sal_Int32 /*nWidth*/, sal_Int32 /*nHeight*/ ) +{ + Reference< XPropertySet> xPropSet; + return xPropSet; +} +Reference< XPropertySet> XMLTextImportHelper::createAndInsertPlugin( + const OUString& /*rMimeType*/, + const OUString& /*rHRef*/, + sal_Int32 /*nWidth*/, sal_Int32 /*nHeight*/ ) +{ + Reference< XPropertySet> xPropSet; + return xPropSet; +} +Reference< XPropertySet> XMLTextImportHelper::createAndInsertFloatingFrame( + const OUString& /*rName*/, + const OUString& /*rHRef*/, + const OUString& /*rStyleName*/, + sal_Int32 /*nWidth*/, sal_Int32 /*nHeight*/ ) +{ + Reference< XPropertySet> xPropSet; + return xPropSet; +} + +void XMLTextImportHelper::endAppletOrPlugin( + const Reference < XPropertySet> &, + std::map < const rtl::OUString, rtl::OUString, UStringLess > &) +{ +} +// redline helper: dummy implementation to be overridden in sw/filter/xml +void XMLTextImportHelper::RedlineAdd( + const OUString& /*rType*/, + const OUString& /*rId*/, + const OUString& /*rAuthor*/, + const OUString& /*rComment*/, + const DateTime& /*rDateTime*/, + sal_Bool /*bMergeLastPara*/) +{ + // dummy implementation: do nothing +} + +Reference<XTextCursor> XMLTextImportHelper::RedlineCreateText( + Reference<XTextCursor> & /*rOldCursor*/, + const OUString& /*rId*/) +{ + // dummy implementation: do nothing + Reference<XTextCursor> xRet; + return xRet; +} + +void XMLTextImportHelper::RedlineSetCursor( + const OUString& /*rId*/, + sal_Bool /*bStart*/, + sal_Bool /*bIsOutsideOfParagraph*/) +{ + // dummy implementation: do nothing +} + +void XMLTextImportHelper::RedlineAdjustStartNodeCursor(sal_Bool) +{ + // dummy implementation: do nothing +} + +void XMLTextImportHelper::SetShowChanges( sal_Bool ) +{ + // dummy implementation: do nothing +} + +void XMLTextImportHelper::SetRecordChanges( sal_Bool ) +{ + // dummy implementation: do nothing +} +void XMLTextImportHelper::SetChangesProtectionKey(const Sequence<sal_Int8> &) +{ + // dummy implementation: do nothing +} + + +OUString XMLTextImportHelper::GetOpenRedlineId() +{ + return m_pImpl->m_sOpenRedlineIdentifier; +} + +void XMLTextImportHelper::SetOpenRedlineId( ::rtl::OUString& rId) +{ + m_pImpl->m_sOpenRedlineIdentifier = rId; +} + +void XMLTextImportHelper::ResetOpenRedlineId() +{ + OUString sEmpty; + SetOpenRedlineId(sEmpty); +} + +void +XMLTextImportHelper::SetCellParaStyleDefault(::rtl::OUString const& rNewValue) +{ + m_pImpl->m_sCellParaStyleDefault = rNewValue; +} + +::rtl::OUString const& XMLTextImportHelper::GetCellParaStyleDefault() +{ + return m_pImpl->m_sCellParaStyleDefault; +} + |