| /************************************************************** |
| * |
| * 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 (( bool(m_pImpl->m_pOutlineStylesCandidates) || 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 chosen 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; |
| } |
| |
