xref: /aoo41x/main/xmloff/source/text/txtimp.cxx (revision c45df7c4)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the 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 "xmloff/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 "xmloff/txtimppr.hxx"
#include <xmloff/xmlimp.hxx>
#include "txtvfldi.hxx"
#include "xmloff/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"
#include <com/sun/star/beans/XPropertyState.hpp>

#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_OFFICE, XML_ANNOTATION_END, XML_TOK_TEXT_ANNOTATION_END },
    { 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_NAMESPACE_OFFICE, XML_NAME, XML_TOK_TEXT_NAME },

    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;
}