| /************************************************************** |
| * |
| * 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" |
| |
| /** @#file |
| * |
| * export of all text fields |
| */ |
| #include "txtflde.hxx" |
| #include <xmloff/xmlexp.hxx> |
| #include <xmloff/xmlnumfe.hxx> |
| #include <xmloff/xmltoken.hxx> |
| #include <xmloff/xmlement.hxx> |
| #include <xmloff/xmluconv.hxx> |
| #include <xmloff/xmlnume.hxx> |
| #include "xmloff/numehelp.hxx" |
| |
| #include <xmloff/families.hxx> |
| #include <xmloff/XMLEventExport.hxx> |
| #include "XMLTextCharStyleNamesElementExport.hxx" |
| #include <xmloff/nmspmap.hxx> |
| #include <com/sun/star/util/DateTime.hpp> |
| #include <com/sun/star/util/Date.hpp> |
| #include <com/sun/star/lang/XServiceInfo.hpp> |
| #include <com/sun/star/text/UserDataPart.hpp> |
| #include <com/sun/star/text/PageNumberType.hpp> |
| #include <com/sun/star/style/NumberingType.hpp> |
| #include <com/sun/star/text/ReferenceFieldPart.hpp> |
| #include <com/sun/star/text/ReferenceFieldSource.hpp> |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <com/sun/star/beans/XPropertyState.hpp> |
| #include <com/sun/star/text/XTextField.hpp> |
| #include <com/sun/star/text/XDependentTextField.hpp> |
| #include <com/sun/star/text/XTextFieldsSupplier.hpp> |
| |
| #include <com/sun/star/text/SetVariableType.hpp> |
| #include <com/sun/star/text/PlaceholderType.hpp> |
| #include <com/sun/star/text/FilenameDisplayFormat.hpp> |
| #include <com/sun/star/text/ChapterFormat.hpp> |
| #include <com/sun/star/text/TemplateDisplayFormat.hpp> |
| #include <com/sun/star/frame/XModel.hpp> |
| #include <com/sun/star/container/XNameReplace.hpp> |
| #include <com/sun/star/uno/Sequence.h> |
| #include <com/sun/star/util/NumberFormat.hpp> |
| #include <com/sun/star/text/BibliographyDataType.hpp> |
| #include <com/sun/star/sdb/CommandType.hpp> |
| #include <com/sun/star/rdf/XMetadatable.hpp> |
| #include <rtl/ustrbuf.hxx> |
| #include <tools/debug.hxx> |
| #include <rtl/math.hxx> |
| |
| #include <vector> |
| |
| using ::rtl::OUString; |
| using ::rtl::OUStringBuffer; |
| |
| using namespace ::std; |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::text; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::util; |
| using namespace ::com::sun::star::style; |
| using namespace ::com::sun::star::document; |
| using namespace ::com::sun::star::container; |
| using namespace ::xmloff::token; |
| |
| |
| static sal_Char __READONLY_DATA FIELD_SERVICE_SENDER[] = "ExtendedUser"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_AUTHOR[] = "Author"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_JUMPEDIT[] = "JumpEdit"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_GETEXP[] = "GetExpression"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_SETEXP[] = "SetExpression"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_USER[] = "User"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_INPUT[] = "Input"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_USERINPUT[] = "InputUser"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DATETIME[] = "DateTime"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_PAGENUMBER[] = "PageNumber"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DB_NEXT[] = "DatabaseNextSet"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DB_SELECT[] = "DatabaseNumberOfSet"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DB_NUMBER[] = "DatabaseSetNumber"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DB_DISPLAY[] = "Database"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DB_NAME[] = "DatabaseName"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_CONDITIONAL_TEXT[] = "ConditionalText"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_HIDDEN_TEXT[] = "HiddenText"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_HIDDEN_PARAGRAPH[] = "HiddenParagraph"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_CHANGE_AUTHOR[] = "DocInfo.ChangeAuthor"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_CHANGE_AUTHOR2[] = "docinfo.ChangeAuthor"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_CHANGE_DATE_TIME[] = "DocInfo.ChangeDateTime"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_CHANGE_DATE_TIME2[] = "docinfo.ChangeDateTime"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_EDIT_TIME[] = "DocInfo.EditTime"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_EDIT_TIME2[] = "docinfo.EditTime"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_DESCRIPTION[] = "DocInfo.Description"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_DESCRIPTION2[] = "docinfo.Description"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_CREATE_AUTHOR[] = "DocInfo.CreateAuthor"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_CREATE_AUTHOR2[] = "docinfo.CreateAuthor"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_CREATE_DATE_TIME[] = "DocInfo.CreateDateTime"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_CREATE_DATE_TIME2[] = "docinfo.CreateDateTime"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_CUSTOM[] = "DocInfo.Custom"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_CUSTOM2[] = "docinfo.Custom"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_PRINT_AUTHOR[] = "DocInfo.PrintAuthor"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_PRINT_AUTHOR2[] = "docinfo.PrintAuthor"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_PRINT_DATE_TIME[] = "DocInfo.PrintDateTime"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_PRINT_DATE_TIME2[] = "docinfo.PrintDateTime"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_KEY_WORDS[] = "DocInfo.KeyWords"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_KEY_WORDS2[] = "docinfo.KeyWords"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_SUBJECT[] = "DocInfo.Subject"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_SUBJECT2[] = "docinfo.Subject"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_TITLE[] = "DocInfo.Title"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_TITLE2[] = "docinfo.Title"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_REVISION[] = "DocInfo.Revision"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DOC_INFO_REVISION2[] = "docinfo.Revision"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_FILE_NAME[] = "FileName"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_CHAPTER[] = "Chapter"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_TEMPLATE_NAME[] = "TemplateName"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_PAGE_COUNT[] = "PageCount"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_PARAGRAPH_COUNT[] = "ParagraphCount"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_WORD_COUNT[] = "WordCount"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_CHARACTER_COUNT[] = "CharacterCount"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_TABLE_COUNT[] = "TableCount"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_GRAPHIC_COUNT[] = "GraphicObjectCount"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_OBJECT_COUNT[] = "EmbeddedObjectCount"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_REFERENCE_PAGE_SET[] = "ReferencePageSet"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_REFERENCE_PAGE_GET[] = "ReferencePageGet"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_SHEET_NAME[] = "SheetName"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_MACRO[] = "Macro"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_GET_REFERENCE[] = "GetReference"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DDE[] = "DDE"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_URL[] = "URL"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_BIBLIOGRAPHY[] = "Bibliography"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_SCRIPT[] = "Script"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_ANNOTATION[] = "Annotation"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_COMBINED_CHARACTERS[] = "CombinedCharacters"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_META[] = "MetadataField"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_MEASURE[] = "Measure"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_TABLE_FORMULA[] = "TableFormula"; |
| static sal_Char __READONLY_DATA FIELD_SERVICE_DROP_DOWN[] = "DropDown"; |
| |
| SvXMLEnumStringMapEntry __READONLY_DATA aFieldServiceNameMapping[] = |
| { |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_SENDER, FIELD_ID_SENDER ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_AUTHOR, FIELD_ID_AUTHOR ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_JUMPEDIT, FIELD_ID_PLACEHOLDER ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_GETEXP, FIELD_ID_VARIABLE_GET ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_SETEXP, FIELD_ID_VARIABLE_SET ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_USER, FIELD_ID_USER_GET ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_INPUT, FIELD_ID_TEXT_INPUT ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_USERINPUT, FIELD_ID_USER_INPUT ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DATETIME, FIELD_ID_TIME ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_PAGENUMBER, FIELD_ID_PAGENUMBER ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_REFERENCE_PAGE_SET, FIELD_ID_REFPAGE_SET ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_REFERENCE_PAGE_GET, FIELD_ID_REFPAGE_GET ), |
| |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DB_NEXT, FIELD_ID_DATABASE_NEXT ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DB_SELECT, FIELD_ID_DATABASE_SELECT ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DB_NUMBER, FIELD_ID_DATABASE_NUMBER ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DB_DISPLAY, FIELD_ID_DATABASE_DISPLAY ), |
| // workaround for #no-bug#: Database/DataBase |
| ENUM_STRING_MAP_ENTRY( "DataBase", FIELD_ID_DATABASE_DISPLAY ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DB_NAME, FIELD_ID_DATABASE_NAME ), |
| |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_CREATE_AUTHOR, FIELD_ID_DOCINFO_CREATION_AUTHOR ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_CREATE_AUTHOR2, FIELD_ID_DOCINFO_CREATION_AUTHOR ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_CREATE_DATE_TIME, FIELD_ID_DOCINFO_CREATION_TIME), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_CREATE_DATE_TIME2, FIELD_ID_DOCINFO_CREATION_TIME), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_CHANGE_AUTHOR, FIELD_ID_DOCINFO_SAVE_AUTHOR ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_CHANGE_AUTHOR2, FIELD_ID_DOCINFO_SAVE_AUTHOR ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_CHANGE_DATE_TIME, FIELD_ID_DOCINFO_SAVE_TIME ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_CHANGE_DATE_TIME2, FIELD_ID_DOCINFO_SAVE_TIME ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_EDIT_TIME, FIELD_ID_DOCINFO_EDIT_DURATION ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_EDIT_TIME2, FIELD_ID_DOCINFO_EDIT_DURATION ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_DESCRIPTION, FIELD_ID_DOCINFO_DESCRIPTION ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_DESCRIPTION2, FIELD_ID_DOCINFO_DESCRIPTION ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_CUSTOM, FIELD_ID_DOCINFO_CUSTOM ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_CUSTOM2, FIELD_ID_DOCINFO_CUSTOM ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_PRINT_AUTHOR, FIELD_ID_DOCINFO_PRINT_AUTHOR ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_PRINT_AUTHOR2, FIELD_ID_DOCINFO_PRINT_AUTHOR ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_PRINT_DATE_TIME, FIELD_ID_DOCINFO_PRINT_TIME ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_PRINT_DATE_TIME2, FIELD_ID_DOCINFO_PRINT_TIME ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_KEY_WORDS, FIELD_ID_DOCINFO_KEYWORDS ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_KEY_WORDS2, FIELD_ID_DOCINFO_KEYWORDS ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_SUBJECT, FIELD_ID_DOCINFO_SUBJECT ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_SUBJECT2, FIELD_ID_DOCINFO_SUBJECT ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_TITLE, FIELD_ID_DOCINFO_TITLE ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_TITLE2, FIELD_ID_DOCINFO_TITLE ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_REVISION, FIELD_ID_DOCINFO_REVISION ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DOC_INFO_REVISION2, FIELD_ID_DOCINFO_REVISION ), |
| |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_CONDITIONAL_TEXT, FIELD_ID_CONDITIONAL_TEXT ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_HIDDEN_TEXT, FIELD_ID_HIDDEN_TEXT ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_HIDDEN_PARAGRAPH, FIELD_ID_HIDDEN_PARAGRAPH ), |
| |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_FILE_NAME, FIELD_ID_FILE_NAME ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_CHAPTER, FIELD_ID_CHAPTER ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_TEMPLATE_NAME, FIELD_ID_TEMPLATE_NAME ), |
| |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_PAGE_COUNT, FIELD_ID_COUNT_PAGES ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_PARAGRAPH_COUNT, FIELD_ID_COUNT_PARAGRAPHS ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_WORD_COUNT, FIELD_ID_COUNT_WORDS ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_CHARACTER_COUNT, FIELD_ID_COUNT_CHARACTERS ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_TABLE_COUNT, FIELD_ID_COUNT_TABLES ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_GRAPHIC_COUNT, FIELD_ID_COUNT_GRAPHICS ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_OBJECT_COUNT, FIELD_ID_COUNT_OBJECTS ), |
| |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_MACRO, FIELD_ID_MACRO ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_GET_REFERENCE, FIELD_ID_REF_REFERENCE ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DDE, FIELD_ID_DDE ), |
| |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_BIBLIOGRAPHY, FIELD_ID_BIBLIOGRAPHY ), |
| |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_SCRIPT, FIELD_ID_SCRIPT ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_ANNOTATION, FIELD_ID_ANNOTATION ), |
| |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_COMBINED_CHARACTERS, FIELD_ID_COMBINED_CHARACTERS ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_META, FIELD_ID_META ), |
| |
| // non-writer fields |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_SHEET_NAME, FIELD_ID_SHEET_NAME ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_URL, FIELD_ID_URL ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_MEASURE, FIELD_ID_MEASURE ), |
| |
| // deprecated fields |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_TABLE_FORMULA, FIELD_ID_TABLE_FORMULA ), |
| ENUM_STRING_MAP_ENTRY( FIELD_SERVICE_DROP_DOWN, FIELD_ID_DROP_DOWN ), |
| |
| ENUM_STRING_MAP_END() |
| }; |
| |
| |
| |
| // property accessor helper functions |
| inline sal_Bool GetBoolProperty(const OUString&, |
| const Reference<XPropertySet> &); |
| inline sal_Bool GetOptionalBoolProperty(const OUString&, |
| const Reference<XPropertySet> &, |
| const Reference<XPropertySetInfo> &, |
| sal_Bool bDefault); |
| inline double GetDoubleProperty(const OUString&, |
| const Reference<XPropertySet> &); |
| inline OUString const GetStringProperty(const OUString&, |
| const Reference<XPropertySet> &); |
| inline sal_Int32 GetIntProperty(const OUString&, |
| const Reference<XPropertySet> &); |
| inline sal_Int16 GetInt16Property(const OUString&, |
| const Reference<XPropertySet> &); |
| inline sal_Int8 GetInt8Property(const OUString&, |
| const Reference<XPropertySet> &); |
| inline DateTime const GetDateTimeProperty( const OUString& sPropName, |
| const Reference<XPropertySet> & xPropSet); |
| inline Date const GetDateProperty( const OUString& sPropName, |
| const Reference<XPropertySet> & xPropSet); |
| inline Sequence<OUString> const GetStringSequenceProperty( |
| const OUString& sPropName, |
| const Reference<XPropertySet> & xPropSet); |
| |
| |
| |
| XMLTextFieldExport::XMLTextFieldExport( SvXMLExport& rExp, |
| XMLPropertyState* pCombinedCharState) |
| : rExport(rExp), |
| pUsedMasters(NULL), |
| sServicePrefix(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.textfield.")), |
| sFieldMasterPrefix(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.FieldMaster.")), |
| sPresentationServicePrefix(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.TextField.")), |
| |
| sPropertyAdjust(RTL_CONSTASCII_USTRINGPARAM("Adjust")), |
| sPropertyAuthor(RTL_CONSTASCII_USTRINGPARAM("Author")), |
| sPropertyChapterFormat(RTL_CONSTASCII_USTRINGPARAM("ChapterFormat")), |
| sPropertyChapterNumberingLevel(RTL_CONSTASCII_USTRINGPARAM("ChapterNumberingLevel")), |
| sPropertyCharStyleNames(RTL_CONSTASCII_USTRINGPARAM("CharStyleNames")), |
| sPropertyCondition(RTL_CONSTASCII_USTRINGPARAM("Condition")), |
| sPropertyContent(RTL_CONSTASCII_USTRINGPARAM("Content")), |
| sPropertyDataBaseName(RTL_CONSTASCII_USTRINGPARAM("DataBaseName")), |
| sPropertyDataBaseURL(RTL_CONSTASCII_USTRINGPARAM("DataBaseURL")), |
| sPropertyDataColumnName(RTL_CONSTASCII_USTRINGPARAM("DataColumnName")), |
| sPropertyDataCommandType(RTL_CONSTASCII_USTRINGPARAM("DataCommandType")), |
| sPropertyDataTableName(RTL_CONSTASCII_USTRINGPARAM("DataTableName")), |
| sPropertyDate(RTL_CONSTASCII_USTRINGPARAM("Date")), |
| sPropertyDateTime(RTL_CONSTASCII_USTRINGPARAM("DateTime")), |
| sPropertyDateTimeValue(RTL_CONSTASCII_USTRINGPARAM("DateTimeValue")), |
| sPropertyDDECommandElement(RTL_CONSTASCII_USTRINGPARAM("DDECommandElement")), |
| sPropertyDDECommandFile(RTL_CONSTASCII_USTRINGPARAM("DDECommandFile")), |
| sPropertyDDECommandType(RTL_CONSTASCII_USTRINGPARAM("DDECommandType")), |
| sPropertyDependentTextFields(RTL_CONSTASCII_USTRINGPARAM("DependentTextFields")), |
| sPropertyFalseContent(RTL_CONSTASCII_USTRINGPARAM("FalseContent")), |
| sPropertyFields(RTL_CONSTASCII_USTRINGPARAM("Fields")), |
| sPropertyFieldSubType(RTL_CONSTASCII_USTRINGPARAM("UserDataType")), |
| sPropertyFileFormat(RTL_CONSTASCII_USTRINGPARAM("FileFormat")), |
| sPropertyFullName(RTL_CONSTASCII_USTRINGPARAM("FullName")), |
| sPropertyHint(RTL_CONSTASCII_USTRINGPARAM("Hint")), |
| sPropertyInitials(RTL_CONSTASCII_USTRINGPARAM("Initials")), |
| sPropertyInstanceName(RTL_CONSTASCII_USTRINGPARAM("InstanceName")), |
| sPropertyIsAutomaticUpdate(RTL_CONSTASCII_USTRINGPARAM("IsAutomaticUpdate")), |
| sPropertyIsConditionTrue(RTL_CONSTASCII_USTRINGPARAM("IsConditionTrue")), |
| sPropertyIsDataBaseFormat(RTL_CONSTASCII_USTRINGPARAM("DataBaseFormat")), |
| sPropertyIsDate(RTL_CONSTASCII_USTRINGPARAM("IsDate")), |
| sPropertyIsExpression(RTL_CONSTASCII_USTRINGPARAM("IsExpression")), |
| sPropertyIsFixed(RTL_CONSTASCII_USTRINGPARAM("IsFixed")), |
| sPropertyIsFixedLanguage(RTL_CONSTASCII_USTRINGPARAM("IsFixedLanguage")), |
| sPropertyIsHidden(RTL_CONSTASCII_USTRINGPARAM("IsHidden")), |
| sPropertyIsInput(RTL_CONSTASCII_USTRINGPARAM("Input")), |
| sPropertyIsShowFormula(RTL_CONSTASCII_USTRINGPARAM("IsShowFormula")), |
| sPropertyIsVisible(RTL_CONSTASCII_USTRINGPARAM("IsVisible")), |
| sPropertyItems(RTL_CONSTASCII_USTRINGPARAM("Items")), |
| sPropertyLevel(RTL_CONSTASCII_USTRINGPARAM("Level")), |
| sPropertyMacro(RTL_CONSTASCII_USTRINGPARAM("Macro")), |
| sPropertyMeasureKind(RTL_CONSTASCII_USTRINGPARAM("Kind")), |
| sPropertyName(RTL_CONSTASCII_USTRINGPARAM("Name")), |
| sPropertyNumberFormat(RTL_CONSTASCII_USTRINGPARAM("NumberFormat")), |
| sPropertyNumberingSeparator(RTL_CONSTASCII_USTRINGPARAM("NumberingSeparator")), |
| sPropertyNumberingType(RTL_CONSTASCII_USTRINGPARAM("NumberingType")), |
| sPropertyOffset(RTL_CONSTASCII_USTRINGPARAM("Offset")), |
| sPropertyOn(RTL_CONSTASCII_USTRINGPARAM("On")), |
| sPropertyPlaceholder(RTL_CONSTASCII_USTRINGPARAM("PlaceHolder")), |
| sPropertyPlaceholderType(RTL_CONSTASCII_USTRINGPARAM("PlaceHolderType")), |
| sPropertyReferenceFieldPart(RTL_CONSTASCII_USTRINGPARAM("ReferenceFieldPart")), |
| sPropertyReferenceFieldSource(RTL_CONSTASCII_USTRINGPARAM("ReferenceFieldSource")), |
| sPropertyReferenceFieldType(RTL_CONSTASCII_USTRINGPARAM("ReferenceFieldType")), |
| sPropertyRevision(RTL_CONSTASCII_USTRINGPARAM("Revision")), |
| sPropertyScriptType(RTL_CONSTASCII_USTRINGPARAM("ScriptType")), |
| sPropertySelectedItem(RTL_CONSTASCII_USTRINGPARAM("SelectedItem")), |
| sPropertySequenceNumber(RTL_CONSTASCII_USTRINGPARAM("SequenceNumber")), |
| sPropertySequenceValue(RTL_CONSTASCII_USTRINGPARAM("SequenceValue")), |
| sPropertySetNumber(RTL_CONSTASCII_USTRINGPARAM("SetNumber")), |
| sPropertySourceName(RTL_CONSTASCII_USTRINGPARAM("SourceName")), |
| sPropertySubType(RTL_CONSTASCII_USTRINGPARAM("SubType")), |
| sPropertyTargetFrame(RTL_CONSTASCII_USTRINGPARAM("TargetFrame")), |
| sPropertyTrueContent(RTL_CONSTASCII_USTRINGPARAM("TrueContent")), |
| sPropertyURL(RTL_CONSTASCII_USTRINGPARAM("URL")), |
| sPropertyURLContent(RTL_CONSTASCII_USTRINGPARAM("URLContent")), |
| sPropertyUserText(RTL_CONSTASCII_USTRINGPARAM("UserText")), |
| sPropertyValue(RTL_CONSTASCII_USTRINGPARAM("Value")), |
| sPropertyVariableName(RTL_CONSTASCII_USTRINGPARAM("VariableName")), |
| sPropertyVariableSubType(RTL_CONSTASCII_USTRINGPARAM("VariableSubtype")), |
| sPropertyHelp(RTL_CONSTASCII_USTRINGPARAM("Help")), |
| sPropertyTooltip(RTL_CONSTASCII_USTRINGPARAM("Tooltip")), |
| sPropertyTextRange(RTL_CONSTASCII_USTRINGPARAM("TextRange")), |
| pCombinedCharactersPropertyState(pCombinedCharState) |
| { |
| SetExportOnlyUsedFieldDeclarations(); |
| } |
| |
| XMLTextFieldExport::~XMLTextFieldExport() |
| { |
| delete pCombinedCharactersPropertyState; |
| delete pUsedMasters; |
| } |
| |
| /// get the field ID (as in FieldIDEnum) from XTextField |
| enum FieldIdEnum XMLTextFieldExport::GetFieldID( |
| const Reference<XTextField> & rTextField, |
| const Reference<XPropertySet> & xPropSet) |
| { |
| // get service names for rTextField (via XServiceInfo service) |
| Reference<XServiceInfo> xService(rTextField, UNO_QUERY); |
| const Sequence<OUString> aServices = xService->getSupportedServiceNames(); |
| const OUString* pNames = aServices.getConstArray(); |
| sal_Int32 nCount = aServices.getLength(); |
| |
| OUString sFieldName; // service name postfix of current field |
| |
| // search for TextField service name |
| while( nCount-- ) |
| { |
| if (pNames->matchIgnoreAsciiCase(sServicePrefix)) |
| { |
| // TextField found => postfix is field type! |
| sFieldName = pNames->copy(sServicePrefix.getLength()); |
| break; |
| } |
| |
| ++pNames; |
| } |
| |
| // if this is not a normal text field, check if its a presentation text field |
| if( sFieldName.getLength() == 0 ) |
| { |
| const OUString* pNames2 = aServices.getConstArray(); |
| sal_Int32 nCount2 = aServices.getLength(); |
| // search for TextField service name |
| while( nCount2-- ) |
| { |
| if( 0 == pNames2->compareTo(sPresentationServicePrefix, sPresentationServicePrefix.getLength())) |
| { |
| // TextField found => postfix is field type! |
| sFieldName = pNames2->copy(sPresentationServicePrefix.getLength()); |
| break; |
| } |
| |
| ++pNames2; |
| } |
| |
| if( sFieldName.getLength() != 0 ) |
| { |
| if( sFieldName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM( "Header" ) ) == 0 ) |
| { |
| return FIELD_ID_DRAW_HEADER; |
| } |
| else if( sFieldName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM( "Footer" ) ) == 0 ) |
| { |
| return FIELD_ID_DRAW_FOOTER; |
| } |
| else if( sFieldName.reverseCompareToAsciiL( RTL_CONSTASCII_STRINGPARAM( "DateTime" ) ) == 0 ) |
| { |
| return FIELD_ID_DRAW_DATE_TIME; |
| } |
| } |
| } |
| |
| // map postfix of service name to field ID |
| DBG_ASSERT(sFieldName.getLength()>0, "no TextField service found!"); |
| return MapFieldName(sFieldName, xPropSet); |
| } |
| |
| enum FieldIdEnum XMLTextFieldExport::MapFieldName( |
| const OUString& sFieldName, // field (master) name |
| const Reference<XPropertySet> & xPropSet) // for subtype |
| { |
| // we'll proceed in 2 steps: |
| // a) map service name to preliminary FIELD_ID |
| // b) map those prelim. FIELD_IDs that correspond to several field types |
| // (in our (XML) world) to final FIELD IDs |
| |
| |
| // a) find prelim. FIELD_ID via aFieldServiceMapping |
| |
| // check for non-empty service name |
| DBG_ASSERT(sFieldName.getLength()>0, "no valid service name!"); |
| enum FieldIdEnum nToken = FIELD_ID_UNKNOWN; |
| if (sFieldName.getLength() > 0) |
| { |
| // map name to prelim. ID |
| sal_uInt16 nTmp; |
| sal_Bool bRet = GetExport().GetMM100UnitConverter().convertEnum( |
| nTmp, sFieldName, aFieldServiceNameMapping); |
| |
| // check return |
| DBG_ASSERT(bRet, "Unknown field service name encountered!"); |
| if (! bRet) |
| { |
| nToken = FIELD_ID_UNKNOWN; |
| } |
| else |
| { |
| nToken = (enum FieldIdEnum)nTmp; |
| } |
| } else { |
| // invalid service name |
| nToken = FIELD_ID_UNKNOWN; |
| } |
| |
| // b) map prelim. to final FIELD_IDs |
| switch (nToken) { |
| case FIELD_ID_VARIABLE_SET: |
| if (GetBoolProperty(sPropertyIsInput, xPropSet)) |
| { |
| nToken = FIELD_ID_VARIABLE_INPUT; |
| } |
| else |
| { |
| switch (GetIntProperty(sPropertySubType, xPropSet)) |
| { |
| case SetVariableType::STRING: // text field |
| case SetVariableType::VAR: // num field |
| nToken = FIELD_ID_VARIABLE_SET; |
| break; |
| case SetVariableType::SEQUENCE: |
| nToken = FIELD_ID_SEQUENCE; |
| break; |
| case SetVariableType::FORMULA: |
| default: |
| nToken = FIELD_ID_UNKNOWN; |
| break; |
| } |
| } |
| break; |
| |
| case FIELD_ID_VARIABLE_GET: |
| switch (GetIntProperty(sPropertySubType, xPropSet)) |
| { |
| case SetVariableType::STRING: // text field |
| case SetVariableType::VAR: // num field |
| nToken = FIELD_ID_VARIABLE_GET; |
| break; |
| case SetVariableType::FORMULA: |
| nToken = FIELD_ID_EXPRESSION; |
| break; |
| case SetVariableType::SEQUENCE: |
| default: |
| nToken = FIELD_ID_UNKNOWN; |
| break; |
| } |
| break; |
| |
| case FIELD_ID_TIME: |
| if (GetBoolProperty(sPropertyIsDate, xPropSet)) |
| { |
| nToken = FIELD_ID_DATE; |
| } |
| break; |
| |
| case FIELD_ID_PAGENUMBER: |
| // NumberingType not available in non-Writer apps |
| if (xPropSet->getPropertySetInfo()-> |
| hasPropertyByName(sPropertyNumberingType)) |
| { |
| if (NumberingType::CHAR_SPECIAL == GetIntProperty( |
| sPropertyNumberingType, xPropSet)) |
| { |
| nToken = FIELD_ID_PAGESTRING; |
| } |
| } |
| break; |
| |
| case FIELD_ID_DOCINFO_CREATION_TIME: |
| if (GetBoolProperty(sPropertyIsDate, xPropSet)) |
| { |
| nToken = FIELD_ID_DOCINFO_CREATION_DATE; |
| } |
| break; |
| |
| case FIELD_ID_DOCINFO_PRINT_TIME: |
| if (GetBoolProperty(sPropertyIsDate, xPropSet)) |
| { |
| nToken = FIELD_ID_DOCINFO_PRINT_DATE; |
| } |
| break; |
| |
| case FIELD_ID_DOCINFO_SAVE_TIME: |
| if (GetBoolProperty(sPropertyIsDate, xPropSet)) |
| { |
| nToken = FIELD_ID_DOCINFO_SAVE_DATE; |
| } |
| break; |
| |
| case FIELD_ID_REF_REFERENCE: |
| switch (GetInt16Property(sPropertyReferenceFieldSource, xPropSet)) |
| { |
| case ReferenceFieldSource::REFERENCE_MARK: |
| nToken = FIELD_ID_REF_REFERENCE; |
| break; |
| case ReferenceFieldSource::SEQUENCE_FIELD: |
| nToken = FIELD_ID_REF_SEQUENCE; |
| break; |
| case ReferenceFieldSource::BOOKMARK: |
| nToken = FIELD_ID_REF_BOOKMARK; |
| break; |
| case ReferenceFieldSource::FOOTNOTE: |
| nToken = FIELD_ID_REF_FOOTNOTE; |
| break; |
| case ReferenceFieldSource::ENDNOTE: |
| nToken = FIELD_ID_REF_ENDNOTE; |
| break; |
| default: |
| nToken = FIELD_ID_UNKNOWN; |
| break; |
| } |
| break; |
| |
| case FIELD_ID_COMBINED_CHARACTERS: |
| case FIELD_ID_SCRIPT: |
| case FIELD_ID_ANNOTATION: |
| case FIELD_ID_BIBLIOGRAPHY: |
| case FIELD_ID_DDE: |
| case FIELD_ID_MACRO: |
| case FIELD_ID_REFPAGE_SET: |
| case FIELD_ID_REFPAGE_GET: |
| case FIELD_ID_COUNT_PAGES: |
| case FIELD_ID_COUNT_PARAGRAPHS: |
| case FIELD_ID_COUNT_WORDS: |
| case FIELD_ID_COUNT_CHARACTERS: |
| case FIELD_ID_COUNT_TABLES: |
| case FIELD_ID_COUNT_GRAPHICS: |
| case FIELD_ID_COUNT_OBJECTS: |
| case FIELD_ID_CONDITIONAL_TEXT: |
| case FIELD_ID_HIDDEN_TEXT: |
| case FIELD_ID_HIDDEN_PARAGRAPH: |
| case FIELD_ID_DOCINFO_CREATION_AUTHOR: |
| case FIELD_ID_DOCINFO_DESCRIPTION: |
| case FIELD_ID_DOCINFO_CUSTOM: |
| case FIELD_ID_DOCINFO_PRINT_AUTHOR: |
| case FIELD_ID_DOCINFO_TITLE: |
| case FIELD_ID_DOCINFO_SUBJECT: |
| case FIELD_ID_DOCINFO_KEYWORDS: |
| case FIELD_ID_DOCINFO_REVISION: |
| case FIELD_ID_DOCINFO_EDIT_DURATION: |
| case FIELD_ID_DOCINFO_SAVE_AUTHOR: |
| case FIELD_ID_TEXT_INPUT: |
| case FIELD_ID_USER_INPUT: |
| case FIELD_ID_AUTHOR: |
| case FIELD_ID_SENDER: |
| case FIELD_ID_PLACEHOLDER: |
| case FIELD_ID_USER_GET: |
| case FIELD_ID_DATABASE_NEXT: |
| case FIELD_ID_DATABASE_SELECT: |
| case FIELD_ID_DATABASE_DISPLAY: |
| case FIELD_ID_DATABASE_NAME: |
| case FIELD_ID_DATABASE_NUMBER: |
| case FIELD_ID_TEMPLATE_NAME: |
| case FIELD_ID_CHAPTER: |
| case FIELD_ID_FILE_NAME: |
| case FIELD_ID_META: |
| case FIELD_ID_SHEET_NAME: |
| case FIELD_ID_MEASURE: |
| case FIELD_ID_URL: |
| case FIELD_ID_TABLE_FORMULA: |
| case FIELD_ID_DROP_DOWN: |
| ; // these field IDs are final |
| break; |
| |
| default: |
| nToken = FIELD_ID_UNKNOWN; |
| } |
| |
| // ... and return final FIELD_ID |
| return nToken; |
| } |
| |
| // is string or numeric field? |
| sal_Bool XMLTextFieldExport::IsStringField( |
| FieldIdEnum nFieldType, |
| const Reference<XPropertySet> & xPropSet) |
| { |
| switch (nFieldType) { |
| |
| case FIELD_ID_VARIABLE_GET: |
| case FIELD_ID_VARIABLE_SET: |
| case FIELD_ID_VARIABLE_INPUT: |
| { |
| // depends on field sub type |
| return ( GetIntProperty(sPropertySubType, xPropSet) == |
| SetVariableType::STRING ); |
| } |
| |
| case FIELD_ID_USER_GET: |
| case FIELD_ID_USER_INPUT: |
| { |
| Reference<XTextField> xTextField(xPropSet, UNO_QUERY); |
| DBG_ASSERT(xTextField.is(), "field is no XTextField!"); |
| sal_Bool bRet = GetBoolProperty(sPropertyIsExpression, |
| GetMasterPropertySet(xTextField)); |
| return !bRet; |
| } |
| |
| case FIELD_ID_META: |
| return 0 > GetIntProperty(sPropertyNumberFormat, xPropSet); |
| |
| case FIELD_ID_DATABASE_DISPLAY: |
| // TODO: depends on... ??? |
| // workaround #no-bug#: no data type |
| return 5100 == GetIntProperty(sPropertyNumberFormat, xPropSet); |
| |
| case FIELD_ID_TABLE_FORMULA: |
| // legacy field: always a number field (because it always has |
| // a number format) |
| return sal_False; |
| |
| case FIELD_ID_COUNT_PAGES: |
| case FIELD_ID_COUNT_PARAGRAPHS: |
| case FIELD_ID_COUNT_WORDS: |
| case FIELD_ID_COUNT_CHARACTERS: |
| case FIELD_ID_COUNT_TABLES: |
| case FIELD_ID_COUNT_GRAPHICS: |
| case FIELD_ID_COUNT_OBJECTS: |
| case FIELD_ID_DOCINFO_SAVE_TIME: |
| case FIELD_ID_DOCINFO_SAVE_DATE: |
| case FIELD_ID_DOCINFO_CREATION_DATE: |
| case FIELD_ID_DOCINFO_CREATION_TIME: |
| case FIELD_ID_DOCINFO_PRINT_TIME: |
| case FIELD_ID_DOCINFO_PRINT_DATE: |
| case FIELD_ID_DOCINFO_EDIT_DURATION: |
| case FIELD_ID_DOCINFO_REVISION: |
| case FIELD_ID_DATABASE_NUMBER: |
| case FIELD_ID_EXPRESSION: |
| case FIELD_ID_SEQUENCE: |
| case FIELD_ID_DATE: |
| case FIELD_ID_TIME: |
| case FIELD_ID_PAGENUMBER: |
| case FIELD_ID_REFPAGE_SET: |
| case FIELD_ID_REFPAGE_GET: |
| case FIELD_ID_DOCINFO_CUSTOM: |
| // always number |
| return sal_False; |
| |
| case FIELD_ID_COMBINED_CHARACTERS: |
| case FIELD_ID_BIBLIOGRAPHY: |
| case FIELD_ID_DDE: |
| case FIELD_ID_REF_REFERENCE: |
| case FIELD_ID_REF_SEQUENCE: |
| case FIELD_ID_REF_BOOKMARK: |
| case FIELD_ID_REF_FOOTNOTE: |
| case FIELD_ID_REF_ENDNOTE: |
| case FIELD_ID_MACRO: |
| case FIELD_ID_TEMPLATE_NAME: |
| case FIELD_ID_CHAPTER: |
| case FIELD_ID_FILE_NAME: |
| case FIELD_ID_CONDITIONAL_TEXT: |
| case FIELD_ID_HIDDEN_TEXT: |
| case FIELD_ID_HIDDEN_PARAGRAPH: |
| case FIELD_ID_DOCINFO_CREATION_AUTHOR: |
| case FIELD_ID_DOCINFO_DESCRIPTION: |
| case FIELD_ID_DOCINFO_PRINT_AUTHOR: |
| case FIELD_ID_DOCINFO_TITLE: |
| case FIELD_ID_DOCINFO_SUBJECT: |
| case FIELD_ID_DOCINFO_KEYWORDS: |
| case FIELD_ID_DOCINFO_SAVE_AUTHOR: |
| case FIELD_ID_DATABASE_NAME: |
| case FIELD_ID_TEXT_INPUT: |
| case FIELD_ID_SENDER: |
| case FIELD_ID_AUTHOR: |
| case FIELD_ID_PAGESTRING: |
| case FIELD_ID_SHEET_NAME: |
| case FIELD_ID_MEASURE: |
| case FIELD_ID_URL: |
| case FIELD_ID_DROP_DOWN: |
| // always string: |
| return sal_True; |
| |
| case FIELD_ID_SCRIPT: |
| case FIELD_ID_ANNOTATION: |
| case FIELD_ID_DATABASE_NEXT: |
| case FIELD_ID_DATABASE_SELECT: |
| case FIELD_ID_VARIABLE_DECL: |
| case FIELD_ID_USER_DECL: |
| case FIELD_ID_SEQUENCE_DECL: |
| case FIELD_ID_PLACEHOLDER: |
| case FIELD_ID_UNKNOWN: |
| case FIELD_ID_DRAW_HEADER: |
| case FIELD_ID_DRAW_FOOTER: |
| case FIELD_ID_DRAW_DATE_TIME: |
| default: |
| DBG_ERROR("unknown field type/field has no content"); |
| return sal_True; // invalid info; string in case of doubt |
| } |
| } |
| |
| /// export the styles needed by the given field. Called on first pass |
| /// through document |
| void XMLTextFieldExport::ExportFieldAutoStyle( |
| const Reference<XTextField> & rTextField, const sal_Bool bProgress, |
| const sal_Bool bRecursive ) |
| { |
| // get property set |
| Reference<XPropertySet> xPropSet(rTextField, UNO_QUERY); |
| |
| // add field master to list of used field masters (if desired) |
| if (NULL != pUsedMasters) |
| { |
| Reference<XDependentTextField> xDepField(rTextField, UNO_QUERY); |
| if (xDepField.is()) |
| { |
| Reference<XText> xOurText = rTextField->getAnchor()->getText(); |
| |
| map<Reference<XText>, set<OUString> >::iterator aMapIter = |
| pUsedMasters->find(xOurText); |
| |
| // insert a list for our XText (if necessary) |
| if (aMapIter == pUsedMasters->end()) |
| { |
| set<OUString> aSet; |
| (*pUsedMasters)[xOurText] = aSet; |
| aMapIter = pUsedMasters->find(xOurText); |
| } |
| |
| // insert this text field master |
| OUString sFieldMasterName = GetStringProperty( |
| sPropertyInstanceName, xDepField->getTextFieldMaster()); |
| if (sFieldMasterName.getLength() > 0) |
| aMapIter->second.insert( sFieldMasterName ); |
| } |
| // else: no dependent field -> no master -> ignore |
| } |
| |
| // get Field ID |
| FieldIdEnum nToken = GetFieldID(rTextField, xPropSet); |
| |
| // export the character style for all fields |
| // with one exception: combined character fields export their own |
| // text style below |
| Reference <XPropertySet> xRangePropSet(rTextField->getAnchor(), UNO_QUERY); |
| if (FIELD_ID_COMBINED_CHARACTERS != nToken) |
| { |
| GetExport().GetTextParagraphExport()->Add( |
| XML_STYLE_FAMILY_TEXT_TEXT, xRangePropSet); |
| } |
| |
| // process special styles for each field (e.g. data styles) |
| switch (nToken) { |
| |
| case FIELD_ID_DATABASE_DISPLAY: |
| { |
| sal_Int32 nFormat = GetIntProperty(sPropertyNumberFormat, xPropSet); |
| // workaround: #no-bug#; see IsStringField(...) |
| if ( (5100 != nFormat) && |
| !GetBoolProperty(sPropertyIsDataBaseFormat, xPropSet) ) |
| { |
| GetExport().addDataStyle(nFormat); |
| } |
| break; |
| } |
| |
| case FIELD_ID_DATE: |
| case FIELD_ID_TIME: |
| { |
| // date and time fields are always number fields, but the |
| // NumberFormat property is optional (e.g. Calc doesn't |
| // support it) |
| Reference<XPropertySetInfo> xPropSetInfo( |
| xPropSet->getPropertySetInfo() ); |
| if ( xPropSetInfo->hasPropertyByName( sPropertyNumberFormat ) ) |
| { |
| sal_Int32 nFormat = |
| GetIntProperty(sPropertyNumberFormat, xPropSet); |
| |
| // nFormat may be -1 for numeric fields that display their |
| // variable name. (Maybe this should be a field type, then?) |
| if (nFormat != -1) |
| { |
| if( ! GetOptionalBoolProperty( |
| sPropertyIsFixedLanguage, |
| xPropSet, xPropSetInfo, sal_False ) ) |
| { |
| nFormat = |
| GetExport().dataStyleForceSystemLanguage(nFormat); |
| } |
| |
| GetExport().addDataStyle( nFormat, |
| nToken == FIELD_ID_TIME ); |
| } |
| } |
| } |
| break; |
| |
| case FIELD_ID_META: |
| // recurse into content (does not export element, so can be done first) |
| if (bRecursive) |
| { |
| ExportMetaField(xPropSet, true, bProgress); |
| } |
| // fall-through: for the meta-field itself! |
| case FIELD_ID_DOCINFO_PRINT_TIME: |
| case FIELD_ID_DOCINFO_PRINT_DATE: |
| case FIELD_ID_DOCINFO_CREATION_DATE: |
| case FIELD_ID_DOCINFO_CREATION_TIME: |
| case FIELD_ID_DOCINFO_SAVE_TIME: |
| case FIELD_ID_DOCINFO_SAVE_DATE: |
| case FIELD_ID_DOCINFO_EDIT_DURATION: |
| case FIELD_ID_VARIABLE_SET: |
| case FIELD_ID_VARIABLE_GET: |
| case FIELD_ID_VARIABLE_INPUT: |
| case FIELD_ID_USER_GET: |
| case FIELD_ID_EXPRESSION: |
| case FIELD_ID_TABLE_FORMULA: |
| case FIELD_ID_DOCINFO_CUSTOM: |
| // register number format, if this is a numeric field |
| if (! IsStringField(nToken, xPropSet)) { |
| |
| sal_Int32 nFormat = |
| GetIntProperty(sPropertyNumberFormat, xPropSet); |
| |
| // nFormat may be -1 for numeric fields that display their |
| // variable name. (Maybe this should be a field type, then?) |
| if (nFormat != -1) |
| { |
| // handle formats for fixed language fields |
| // for all these fields (except table formula) |
| if( ( nToken != FIELD_ID_TABLE_FORMULA ) && |
| ! GetOptionalBoolProperty( |
| sPropertyIsFixedLanguage, |
| xPropSet, xPropSet->getPropertySetInfo(), |
| sal_False ) ) |
| { |
| nFormat = |
| GetExport().dataStyleForceSystemLanguage(nFormat); |
| } |
| |
| GetExport().addDataStyle(nFormat); |
| } |
| } |
| break; |
| |
| case FIELD_ID_COMBINED_CHARACTERS: |
| { |
| // export text style with the addition of the combined characters |
| DBG_ASSERT(NULL != pCombinedCharactersPropertyState, |
| "need proper PropertyState for combined characters"); |
| const XMLPropertyState *aStates[] = { pCombinedCharactersPropertyState, 0 }; |
| GetExport().GetTextParagraphExport()->Add( |
| XML_STYLE_FAMILY_TEXT_TEXT, xRangePropSet, |
| aStates); |
| break; |
| } |
| |
| case FIELD_ID_SCRIPT: |
| case FIELD_ID_ANNOTATION: |
| case FIELD_ID_BIBLIOGRAPHY: |
| case FIELD_ID_DDE: |
| case FIELD_ID_REF_REFERENCE: |
| case FIELD_ID_REF_SEQUENCE: |
| case FIELD_ID_REF_BOOKMARK: |
| case FIELD_ID_REF_FOOTNOTE: |
| case FIELD_ID_REF_ENDNOTE: |
| case FIELD_ID_MACRO: |
| case FIELD_ID_REFPAGE_SET: |
| case FIELD_ID_REFPAGE_GET: |
| case FIELD_ID_COUNT_PAGES: |
| case FIELD_ID_COUNT_PARAGRAPHS: |
| case FIELD_ID_COUNT_WORDS: |
| case FIELD_ID_COUNT_CHARACTERS: |
| case FIELD_ID_COUNT_TABLES: |
| case FIELD_ID_COUNT_GRAPHICS: |
| case FIELD_ID_COUNT_OBJECTS: |
| case FIELD_ID_CONDITIONAL_TEXT: |
| case FIELD_ID_HIDDEN_TEXT: |
| case FIELD_ID_HIDDEN_PARAGRAPH: |
| case FIELD_ID_DOCINFO_CREATION_AUTHOR: |
| case FIELD_ID_DOCINFO_DESCRIPTION: |
| case FIELD_ID_DOCINFO_PRINT_AUTHOR: |
| case FIELD_ID_DOCINFO_TITLE: |
| case FIELD_ID_DOCINFO_SUBJECT: |
| case FIELD_ID_DOCINFO_KEYWORDS: |
| case FIELD_ID_DOCINFO_REVISION: |
| case FIELD_ID_DOCINFO_SAVE_AUTHOR: |
| case FIELD_ID_SEQUENCE: |
| case FIELD_ID_PAGENUMBER: |
| case FIELD_ID_PAGESTRING: |
| case FIELD_ID_AUTHOR: |
| case FIELD_ID_SENDER: |
| case FIELD_ID_PLACEHOLDER: |
| case FIELD_ID_USER_INPUT: |
| case FIELD_ID_TEXT_INPUT: |
| case FIELD_ID_DATABASE_NEXT: |
| case FIELD_ID_DATABASE_SELECT: |
| case FIELD_ID_DATABASE_NAME: |
| case FIELD_ID_DATABASE_NUMBER: |
| case FIELD_ID_TEMPLATE_NAME: |
| case FIELD_ID_CHAPTER: |
| case FIELD_ID_FILE_NAME: |
| case FIELD_ID_SHEET_NAME: |
| case FIELD_ID_MEASURE: |
| case FIELD_ID_URL: |
| case FIELD_ID_DROP_DOWN: |
| case FIELD_ID_DRAW_DATE_TIME: |
| case FIELD_ID_DRAW_FOOTER: |
| case FIELD_ID_DRAW_HEADER: |
| ; // no formats for these fields! |
| break; |
| |
| case FIELD_ID_UNKNOWN: |
| default: |
| DBG_ERROR("unknown field type!"); |
| // ignore -> no format for unkowns |
| break; |
| } |
| } |
| |
| /// export the given field to XML. Called on second pass through document |
| void XMLTextFieldExport::ExportField( |
| const Reference<XTextField> & rTextField, sal_Bool bProgress ) |
| { |
| // get property set |
| Reference<XPropertySet> xPropSet(rTextField, UNO_QUERY); |
| |
| // get property set of range (for the attributes) |
| Reference <XPropertySet> xRangePropSet(rTextField->getAnchor(), UNO_QUERY); |
| |
| // get Field ID |
| enum FieldIdEnum nToken = GetFieldID(rTextField, xPropSet); |
| |
| // special treatment for combined characters field, because it is |
| // exported as a style |
| const XMLPropertyState* aStates[] = { pCombinedCharactersPropertyState, 0 }; |
| const XMLPropertyState **pStates = |
| FIELD_ID_COMBINED_CHARACTERS == nToken |
| ? aStates |
| : 0; |
| |
| // find out whether we need to set the style or hyperlink |
| sal_Bool bHasHyperlink; |
| sal_Bool bIsUICharStyle; |
| sal_Bool bHasAutoStyle; |
| OUString sStyle = GetExport().GetTextParagraphExport()-> |
| FindTextStyleAndHyperlink( xRangePropSet, bHasHyperlink, bIsUICharStyle, |
| bHasAutoStyle, pStates ); |
| sal_Bool bHasStyle = (sStyle.getLength() > 0); |
| |
| // export hyperlink (if we have one) |
| Reference < XPropertySetInfo > xRangePropSetInfo; |
| if( bHasHyperlink ) |
| { |
| Reference<XPropertyState> xRangePropState( xRangePropSet, UNO_QUERY ); |
| xRangePropSetInfo = xRangePropSet->getPropertySetInfo(); |
| bHasHyperlink = |
| GetExport().GetTextParagraphExport()->addHyperlinkAttributes( |
| xRangePropSet, xRangePropState, |
| xRangePropSetInfo ); |
| } |
| SvXMLElementExport aHyperlink( GetExport(), bHasHyperlink, |
| XML_NAMESPACE_TEXT, XML_A, |
| sal_False, sal_False ); |
| |
| if( bHasHyperlink ) |
| { |
| // export events (if supported) |
| OUString sHyperLinkEvents(RTL_CONSTASCII_USTRINGPARAM( |
| "HyperLinkEvents")); |
| if (xRangePropSetInfo->hasPropertyByName(sHyperLinkEvents)) |
| { |
| Any aAny = xRangePropSet->getPropertyValue(sHyperLinkEvents); |
| Reference<XNameReplace> xName; |
| aAny >>= xName; |
| GetExport().GetEventExport().Export(xName, sal_False); |
| } |
| } |
| |
| { |
| XMLTextCharStyleNamesElementExport aCharStylesExport( |
| GetExport(), bIsUICharStyle && |
| GetExport().GetTextParagraphExport() |
| ->GetCharStyleNamesPropInfoCache().hasProperty( |
| xRangePropSet, xRangePropSetInfo ), bHasAutoStyle, |
| xRangePropSet, sPropertyCharStyleNames ); |
| |
| // export span with style (if necessary) |
| // (except for combined characters field) |
| if( bHasStyle ) |
| { |
| // export <text:span> element |
| GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_STYLE_NAME, |
| GetExport().EncodeStyleName( sStyle ) ); |
| } |
| SvXMLElementExport aSpan( GetExport(), bHasStyle, |
| XML_NAMESPACE_TEXT, XML_SPAN, |
| sal_False, sal_False); |
| |
| // finally, export the field itself |
| ExportFieldHelper( rTextField, xPropSet, xRangePropSet, nToken, |
| bProgress ); |
| } |
| } |
| |
| /// export the given field to XML. Called on second pass through document |
| void XMLTextFieldExport::ExportFieldHelper( |
| const Reference<XTextField> & rTextField, |
| const Reference<XPropertySet> & rPropSet, |
| const Reference<XPropertySet> &, |
| enum FieldIdEnum nToken, |
| sal_Bool bProgress ) |
| { |
| // get property set info (because some attributes are not support |
| // in all implementations) |
| Reference<XPropertySetInfo> xPropSetInfo(rPropSet->getPropertySetInfo()); |
| |
| OUString sPresentation = rTextField->getPresentation(sal_False); |
| |
| // process each field type |
| switch (nToken) { |
| case FIELD_ID_AUTHOR: |
| // author field: fixed, field (sub-)type |
| ProcessBoolean(XML_FIXED, |
| GetBoolProperty(sPropertyIsFixed, rPropSet), sal_True); |
| ExportElement(MapAuthorFieldName(rPropSet), sPresentation); |
| break; |
| |
| case FIELD_ID_SENDER: |
| // sender field: fixed, field (sub-)type |
| ProcessBoolean(XML_FIXED, |
| GetBoolProperty(sPropertyIsFixed, rPropSet), sal_True); |
| ExportElement(MapSenderFieldName(rPropSet), sPresentation); |
| break; |
| |
| case FIELD_ID_PLACEHOLDER: |
| // placeholder field: type, name, description |
| ProcessString(XML_PLACEHOLDER_TYPE, |
| MapPlaceholderType( |
| GetInt16Property(sPropertyPlaceholderType, rPropSet))); |
| ProcessString(XML_DESCRIPTION, |
| GetStringProperty(sPropertyHint,rPropSet), sal_True); |
| ExportElement(XML_PLACEHOLDER, sPresentation); |
| break; |
| |
| case FIELD_ID_VARIABLE_SET: |
| { |
| // variable set field: name, visible, format&value |
| ProcessString(XML_NAME, |
| GetStringProperty(sPropertyVariableName, rPropSet)); |
| ProcessDisplay(GetBoolProperty(sPropertyIsVisible, rPropSet), |
| sal_False); |
| ProcessString(XML_FORMULA, XML_NAMESPACE_OOOW, |
| GetStringProperty(sPropertyContent, rPropSet), |
| sPresentation); |
| ProcessValueAndType(IsStringField(nToken, rPropSet), |
| GetIntProperty(sPropertyNumberFormat, rPropSet), |
| GetStringProperty(sPropertyContent, rPropSet), |
| sPresentation, |
| GetDoubleProperty(sPropertyValue, rPropSet), |
| sal_True, sal_True, sal_True, |
| ! GetOptionalBoolProperty( |
| sPropertyIsFixedLanguage, |
| rPropSet, xPropSetInfo, sal_False ) ); |
| ExportElement(XML_VARIABLE_SET, sPresentation); |
| break; |
| } |
| case FIELD_ID_VARIABLE_GET: |
| { |
| // variable get field: name, format&value |
| ProcessString(XML_NAME, |
| GetStringProperty(sPropertyContent, rPropSet)); |
| sal_Bool bCmd = GetBoolProperty(sPropertyIsShowFormula, rPropSet); |
| ProcessDisplay(sal_True, bCmd); |
| // #i81766# for older versions export of the value-type |
| sal_Bool bExportValueType = !bCmd && ( GetExport().getExportFlags() & EXPORT_SAVEBACKWARDCOMPATIBLE ); |
| // show style, unless name will be shown |
| ProcessValueAndType(IsStringField(nToken, rPropSet), |
| GetIntProperty(sPropertyNumberFormat, rPropSet), |
| sEmpty, sEmpty, 0.0, // values not used |
| sal_False, |
| bExportValueType, |
| !bCmd, |
| ! GetOptionalBoolProperty( |
| sPropertyIsFixedLanguage, |
| rPropSet, xPropSetInfo, sal_False ) ); |
| ExportElement(XML_VARIABLE_GET, sPresentation); |
| break; |
| } |
| case FIELD_ID_VARIABLE_INPUT: |
| // variable input field: name, description, format&value |
| ProcessString(XML_NAME, |
| GetStringProperty(sPropertyVariableName, rPropSet)); |
| ProcessString(XML_DESCRIPTION, |
| GetStringProperty(sPropertyHint , rPropSet)); |
| ProcessDisplay(GetBoolProperty(sPropertyIsVisible, rPropSet), |
| sal_False); |
| ProcessString(XML_FORMULA, XML_NAMESPACE_OOOW, |
| GetStringProperty(sPropertyContent, rPropSet), |
| sPresentation); |
| ProcessValueAndType(IsStringField(nToken, rPropSet), |
| GetIntProperty(sPropertyNumberFormat, rPropSet), |
| GetStringProperty(sPropertyContent, rPropSet), |
| sPresentation, |
| GetDoubleProperty(sPropertyValue, rPropSet), |
| sal_True, sal_True, sal_True, |
| ! GetOptionalBoolProperty( |
| sPropertyIsFixedLanguage, |
| rPropSet, xPropSetInfo, sal_False ) ); |
| ExportElement(XML_VARIABLE_INPUT, sPresentation); |
| break; |
| |
| case FIELD_ID_USER_GET: |
| // user field: name, hidden, style |
| { |
| sal_Bool bCmd = GetBoolProperty(sPropertyIsShowFormula, rPropSet); |
| ProcessDisplay(GetBoolProperty(sPropertyIsVisible, rPropSet), |
| bCmd); |
| ProcessValueAndType(IsStringField(nToken, rPropSet), |
| GetIntProperty(sPropertyNumberFormat, rPropSet), |
| sEmpty, sEmpty, 0.0, // values not used |
| sal_False, sal_False, !bCmd, |
| ! GetOptionalBoolProperty( |
| sPropertyIsFixedLanguage, |
| rPropSet, xPropSetInfo, sal_False ) ); |
| |
| // name from FieldMaster |
| ProcessString(XML_NAME, |
| GetStringProperty(sPropertyName, |
| GetMasterPropertySet(rTextField))); |
| ExportElement(XML_USER_FIELD_GET, sPresentation); |
| break; |
| } |
| |
| case FIELD_ID_USER_INPUT: |
| // user input field: name (from FieldMaster), description |
| // ProcessString(XML_NAME, |
| // GetStringProperty(sPropertyName, |
| // GetMasterPropertySet(rTextField))); |
| ProcessString(XML_NAME, |
| GetStringProperty(sPropertyContent, rPropSet)); |
| ProcessString(XML_DESCRIPTION, |
| GetStringProperty(sPropertyHint, rPropSet)); |
| ExportElement(XML_USER_FIELD_INPUT, sPresentation); |
| break; |
| |
| case FIELD_ID_SEQUENCE: |
| { |
| // sequence field: name, formula, seq-format |
| OUString sName = GetStringProperty(sPropertyVariableName, rPropSet); |
| // TODO: use reference name only if actually beeing referenced. |
| ProcessString(XML_REF_NAME, |
| MakeSequenceRefName( |
| GetInt16Property(sPropertySequenceValue, rPropSet), |
| sName)); |
| ProcessString(XML_NAME, sName); |
| ProcessString(XML_FORMULA, XML_NAMESPACE_OOOW, |
| GetStringProperty(sPropertyContent, rPropSet), |
| sPresentation); |
| ProcessNumberingType(GetInt16Property(sPropertyNumberingType, |
| rPropSet)); |
| ExportElement(XML_SEQUENCE, sPresentation); |
| break; |
| } |
| |
| case FIELD_ID_EXPRESSION: |
| { |
| // formula field: formula, format&value |
| sal_Bool bCmd = GetBoolProperty(sPropertyIsShowFormula, rPropSet); |
| ProcessString(XML_FORMULA, XML_NAMESPACE_OOOW, |
| GetStringProperty(sPropertyContent, rPropSet), |
| sPresentation); |
| ProcessDisplay(sal_True, bCmd); |
| ProcessValueAndType(IsStringField(nToken, rPropSet), |
| GetIntProperty(sPropertyNumberFormat, rPropSet), |
| GetStringProperty(sPropertyContent, rPropSet), |
| sPresentation, |
| GetDoubleProperty(sPropertyValue, rPropSet), |
| !bCmd, !bCmd, !bCmd, |
| ! GetOptionalBoolProperty( |
| sPropertyIsFixedLanguage, |
| rPropSet, xPropSetInfo, sal_False ) ); |
| ExportElement(XML_EXPRESSION, sPresentation); |
| break; |
| } |
| |
| case FIELD_ID_TEXT_INPUT: |
| // text input field: description and string-value |
| ProcessString(XML_DESCRIPTION, |
| GetStringProperty(sPropertyHint, rPropSet)); |
| ProcessString(XML_HELP, |
| GetStringProperty(sPropertyHelp, rPropSet), true); |
| ProcessString(XML_HINT, |
| GetStringProperty(sPropertyTooltip, rPropSet), true); |
| ExportElement(XML_TEXT_INPUT, sPresentation); |
| break; |
| |
| case FIELD_ID_TIME: |
| // all properties (except IsDate) are optional! |
| if (xPropSetInfo->hasPropertyByName(sPropertyNumberFormat)) |
| { |
| ProcessValueAndType(sal_False, |
| GetIntProperty(sPropertyNumberFormat,rPropSet), |
| sEmpty, sEmpty, 0.0, // not used |
| sal_False, sal_False, sal_True, |
| ! GetOptionalBoolProperty( |
| sPropertyIsFixedLanguage, |
| rPropSet, xPropSetInfo, sal_False ), |
| sal_True); |
| } |
| if (xPropSetInfo->hasPropertyByName(sPropertyDateTimeValue)) |
| { |
| // no value -> current time |
| ProcessDateTime(XML_TIME_VALUE, |
| GetDateTimeProperty(sPropertyDateTimeValue, |
| rPropSet), |
| sal_False ); |
| } |
| if (xPropSetInfo->hasPropertyByName(sPropertyDateTime)) |
| { |
| // no value -> current time |
| ProcessDateTime(XML_TIME_VALUE, |
| GetDateTimeProperty(sPropertyDateTime,rPropSet), |
| sal_False ); |
| } |
| if (xPropSetInfo->hasPropertyByName(sPropertyIsFixed)) |
| { |
| ProcessBoolean(XML_FIXED, |
| GetBoolProperty(sPropertyIsFixed, rPropSet), |
| sal_False); |
| } |
| if (xPropSetInfo->hasPropertyByName(sPropertyAdjust)) |
| { |
| // adjust value given as integer in minutes |
| ProcessDateTime(XML_TIME_ADJUST, |
| GetIntProperty(sPropertyAdjust, rPropSet), |
| sal_False, sal_True, sal_True); |
| } |
| ExportElement(XML_TIME, sPresentation); |
| break; |
| |
| case FIELD_ID_DATE: |
| // all properties (except IsDate) are optional! |
| if (xPropSetInfo->hasPropertyByName(sPropertyNumberFormat)) |
| { |
| ProcessValueAndType(sal_False, |
| GetIntProperty(sPropertyNumberFormat,rPropSet), |
| sEmpty, sEmpty, 0.0, // not used |
| sal_False, sal_False, sal_True, |
| ! GetOptionalBoolProperty( |
| sPropertyIsFixedLanguage, |
| rPropSet, xPropSetInfo, sal_False ) ); |
| } |
| if (xPropSetInfo->hasPropertyByName(sPropertyDateTimeValue)) |
| { |
| // no value -> current date |
| ProcessDateTime(XML_DATE_VALUE, |
| GetDateTimeProperty(sPropertyDateTimeValue, |
| rPropSet), |
| // #96457#: date fields should also save time |
| sal_False); |
| } |
| // TODO: remove double-handling after SRC614 |
| else if (xPropSetInfo->hasPropertyByName(sPropertyDateTime)) |
| { |
| ProcessDateTime(XML_DATE_VALUE, |
| GetDateTimeProperty(sPropertyDateTime,rPropSet), |
| // #96457#: date fields should also save time |
| sal_False); |
| } |
| if (xPropSetInfo->hasPropertyByName(sPropertyIsFixed)) |
| { |
| ProcessBoolean(XML_FIXED, |
| GetBoolProperty(sPropertyIsFixed, rPropSet), |
| sal_False); |
| } |
| if (xPropSetInfo->hasPropertyByName(sPropertyAdjust)) |
| { |
| // adjust value given as number of days |
| ProcessDateTime(XML_DATE_ADJUST, |
| GetIntProperty(sPropertyAdjust, rPropSet), |
| sal_True, sal_True, sal_True); |
| } |
| ExportElement(XML_DATE, sPresentation); |
| break; |
| |
| case FIELD_ID_PAGENUMBER: |
| // all properties are optional |
| if (xPropSetInfo->hasPropertyByName(sPropertyNumberingType)) |
| { |
| ProcessNumberingType(GetInt16Property(sPropertyNumberingType, |
| rPropSet)); |
| } |
| if (xPropSetInfo->hasPropertyByName(sPropertyOffset)) |
| { |
| sal_Int32 nAdjust = GetIntProperty(sPropertyOffset, rPropSet); |
| |
| if (xPropSetInfo->hasPropertyByName(sPropertySubType)) |
| { |
| // property SubType used in MapPageNumebrName |
| ProcessString(XML_SELECT_PAGE, |
| MapPageNumberName(rPropSet, nAdjust)); |
| } |
| ProcessIntegerDef(XML_PAGE_ADJUST, nAdjust, 0); |
| } |
| ExportElement(XML_PAGE_NUMBER, sPresentation); |
| break; |
| |
| case FIELD_ID_PAGESTRING: |
| { |
| ProcessString(XML_STRING_VALUE, |
| GetStringProperty(sPropertyUserText, rPropSet), |
| sPresentation); |
| sal_Int32 nDummy = 0; // MapPageNumberName need int |
| ProcessString(XML_SELECT_PAGE, MapPageNumberName(rPropSet, nDummy)); |
| if( 0 == ( GetExport().getExportFlags() & EXPORT_SAVEBACKWARDCOMPATIBLE ) ) |
| ExportElement(XML_PAGE_CONTINUATION, sPresentation); |
| else |
| ExportElement(XML_PAGE_CONTINUATION_STRING, sPresentation); |
| break; |
| } |
| |
| case FIELD_ID_DATABASE_NAME: |
| ProcessString(XML_TABLE_NAME, |
| GetStringProperty(sPropertyDataTableName, rPropSet)); |
| ProcessCommandType(GetIntProperty(sPropertyDataCommandType, rPropSet)); |
| ProcessDisplay(GetBoolProperty(sPropertyIsVisible, rPropSet), |
| sal_False); |
| ExportDataBaseElement(XML_DATABASE_NAME, sPresentation, |
| rPropSet, xPropSetInfo); |
| break; |
| |
| case FIELD_ID_DATABASE_NUMBER: |
| ProcessString(XML_TABLE_NAME, |
| GetStringProperty(sPropertyDataTableName, rPropSet)); |
| ProcessCommandType(GetIntProperty(sPropertyDataCommandType, rPropSet)); |
| ProcessNumberingType( |
| GetInt16Property(sPropertyNumberingType,rPropSet)); |
| ProcessInteger(XML_VALUE, |
| GetIntProperty(sPropertySetNumber, rPropSet)); |
| ProcessDisplay(GetBoolProperty(sPropertyIsVisible, rPropSet), |
| sal_False); |
| ExportDataBaseElement(XML_DATABASE_ROW_NUMBER, sPresentation, |
| rPropSet, xPropSetInfo); |
| break; |
| |
| case FIELD_ID_DATABASE_NEXT: |
| ProcessString(XML_TABLE_NAME, |
| GetStringProperty(sPropertyDataTableName, rPropSet)); |
| ProcessCommandType(GetIntProperty(sPropertyDataCommandType, rPropSet)); |
| ProcessString(XML_CONDITION, XML_NAMESPACE_OOOW, |
| GetStringProperty(sPropertyCondition, rPropSet)); |
| DBG_ASSERT(sPresentation.equals(sEmpty), |
| "Unexpected presentation for database next field"); |
| ExportDataBaseElement(XML_DATABASE_NEXT, OUString(), |
| rPropSet, xPropSetInfo); |
| break; |
| |
| case FIELD_ID_DATABASE_SELECT: |
| ProcessString(XML_TABLE_NAME, |
| GetStringProperty(sPropertyDataTableName, rPropSet)); |
| ProcessCommandType(GetIntProperty(sPropertyDataCommandType, rPropSet)); |
| ProcessString(XML_CONDITION, XML_NAMESPACE_OOOW, |
| GetStringProperty(sPropertyCondition, rPropSet)); |
| ProcessInteger(XML_ROW_NUMBER, |
| GetIntProperty(sPropertySetNumber, rPropSet)); |
| DBG_ASSERT(sPresentation.equals(sEmpty), |
| "Unexpected presentation for database select field"); |
| ExportDataBaseElement(XML_DATABASE_ROW_SELECT, OUString(), |
| rPropSet, xPropSetInfo); |
| break; |
| |
| case FIELD_ID_DATABASE_DISPLAY: |
| { |
| // get database, table and column name from field master |
| const Reference<XPropertySet> & xMaster = GetMasterPropertySet(rTextField); |
| ProcessString(XML_TABLE_NAME, |
| GetStringProperty(sPropertyDataTableName, xMaster)); |
| ProcessCommandType(GetIntProperty(sPropertyDataCommandType, xMaster)); |
| ProcessString(XML_COLUMN_NAME, |
| GetStringProperty(sPropertyDataColumnName, xMaster)); |
| // export number format if available (happens only for numbers!) |
| if (!GetBoolProperty(sPropertyIsDataBaseFormat, rPropSet)) |
| { |
| ProcessValueAndType(sal_False, // doesn't happen for text |
| GetIntProperty(sPropertyNumberFormat,rPropSet), |
| sEmpty, sEmpty, 0.0, // not used |
| sal_False, sal_False, sal_True, sal_False); |
| } |
| ProcessDisplay(GetBoolProperty(sPropertyIsVisible, rPropSet), |
| sal_False); |
| ExportDataBaseElement(XML_DATABASE_DISPLAY, sPresentation, |
| xMaster, xMaster->getPropertySetInfo()); |
| break; |
| } |
| |
| case FIELD_ID_DOCINFO_REVISION: |
| ProcessBoolean(XML_FIXED, |
| GetBoolProperty(sPropertyIsFixed, rPropSet), sal_False); |
| ExportElement(MapDocInfoFieldName(nToken), sPresentation); |
| break; |
| |
| case FIELD_ID_DOCINFO_EDIT_DURATION: |
| case FIELD_ID_DOCINFO_SAVE_TIME: |
| case FIELD_ID_DOCINFO_CREATION_TIME: |
| case FIELD_ID_DOCINFO_PRINT_TIME: |
| case FIELD_ID_DOCINFO_SAVE_DATE: |
| case FIELD_ID_DOCINFO_CREATION_DATE: |
| case FIELD_ID_DOCINFO_PRINT_DATE: |
| ProcessValueAndType(sal_False, |
| GetIntProperty(sPropertyNumberFormat, rPropSet), |
| sEmpty, sEmpty, 0.0, |
| sal_False, sal_False, sal_True, |
| ! GetOptionalBoolProperty( |
| sPropertyIsFixedLanguage, |
| rPropSet, xPropSetInfo, sal_False ) ); |
| |
| // todo: export date/time value, but values not available -> core bug |
| ProcessBoolean(XML_FIXED, |
| GetBoolProperty(sPropertyIsFixed, rPropSet), sal_False); |
| ExportElement(MapDocInfoFieldName(nToken), sPresentation); |
| break; |
| |
| case FIELD_ID_DOCINFO_CREATION_AUTHOR: |
| case FIELD_ID_DOCINFO_DESCRIPTION: |
| case FIELD_ID_DOCINFO_PRINT_AUTHOR: |
| case FIELD_ID_DOCINFO_TITLE: |
| case FIELD_ID_DOCINFO_SUBJECT: |
| case FIELD_ID_DOCINFO_KEYWORDS: |
| case FIELD_ID_DOCINFO_SAVE_AUTHOR: |
| if (xPropSetInfo->hasPropertyByName(sPropertyIsFixed)) |
| { |
| ProcessBoolean(XML_FIXED, |
| GetBoolProperty(sPropertyIsFixed, rPropSet), sal_False); |
| } |
| ExportElement(MapDocInfoFieldName(nToken), sPresentation); |
| break; |
| |
| case FIELD_ID_DOCINFO_CUSTOM: |
| { |
| ProcessValueAndType(sal_False, // doesn't happen for text |
| GetIntProperty(sPropertyNumberFormat,rPropSet), |
| sEmpty, sEmpty, 0.0, // not used |
| sal_False, sal_False, sal_True, |
| ! GetOptionalBoolProperty( |
| sPropertyIsFixedLanguage, |
| rPropSet, xPropSetInfo, sal_False )); |
| uno::Any aAny = rPropSet->getPropertyValue( sPropertyName ); |
| ::rtl::OUString sName; |
| aAny >>= sName; |
| ProcessString(XML_NAME, sName); |
| ProcessBoolean(XML_FIXED, GetBoolProperty(sPropertyIsFixed, rPropSet), sal_False); |
| ExportElement(XML_USER_DEFINED, sPresentation); |
| break; |
| } |
| |
| case FIELD_ID_COUNT_PAGES: |
| case FIELD_ID_COUNT_PARAGRAPHS: |
| case FIELD_ID_COUNT_WORDS: |
| case FIELD_ID_COUNT_CHARACTERS: |
| case FIELD_ID_COUNT_TABLES: |
| case FIELD_ID_COUNT_GRAPHICS: |
| case FIELD_ID_COUNT_OBJECTS: |
| // all properties optional (applies to pages only, but I'll do |
| // it for all for sake of common implementation) |
| if (xPropSetInfo->hasPropertyByName(sPropertyNumberingType)) |
| { |
| ProcessNumberingType(GetInt16Property(sPropertyNumberingType, |
| rPropSet)); |
| } |
| ExportElement(MapCountFieldName(nToken), sPresentation); |
| break; |
| |
| case FIELD_ID_CONDITIONAL_TEXT: |
| ProcessString(XML_CONDITION, XML_NAMESPACE_OOOW, |
| GetStringProperty(sPropertyCondition, rPropSet)); |
| ProcessString(XML_STRING_VALUE_IF_TRUE, |
| GetStringProperty(sPropertyTrueContent, rPropSet)); |
| ProcessString(XML_STRING_VALUE_IF_FALSE, |
| GetStringProperty(sPropertyFalseContent, rPropSet)); |
| ProcessBoolean(XML_CURRENT_VALUE, |
| GetBoolProperty(sPropertyIsConditionTrue, rPropSet), |
| sal_False); |
| ExportElement(XML_CONDITIONAL_TEXT, sPresentation); |
| break; |
| |
| case FIELD_ID_HIDDEN_TEXT: |
| ProcessString(XML_CONDITION, XML_NAMESPACE_OOOW, |
| GetStringProperty(sPropertyCondition, rPropSet)); |
| ProcessString(XML_STRING_VALUE, |
| GetStringProperty(sPropertyContent, rPropSet)); |
| ProcessBoolean(XML_IS_HIDDEN, |
| GetBoolProperty(sPropertyIsHidden, rPropSet), |
| sal_False); |
| ExportElement(XML_HIDDEN_TEXT, sPresentation); |
| break; |
| |
| case FIELD_ID_HIDDEN_PARAGRAPH: |
| ProcessString(XML_CONDITION, XML_NAMESPACE_OOOW, |
| GetStringProperty(sPropertyCondition, rPropSet)); |
| ProcessBoolean(XML_IS_HIDDEN, |
| GetBoolProperty(sPropertyIsHidden, rPropSet), |
| sal_False); |
| DBG_ASSERT(sPresentation.equals(sEmpty), |
| "Unexpected presentation for hidden paragraph field"); |
| ExportElement(XML_HIDDEN_PARAGRAPH); |
| break; |
| |
| case FIELD_ID_TEMPLATE_NAME: |
| ProcessString(XML_DISPLAY, |
| MapTemplateDisplayFormat( |
| GetInt16Property(sPropertyFileFormat, rPropSet))); |
| ExportElement(XML_TEMPLATE_NAME, sPresentation); |
| break; |
| |
| case FIELD_ID_CHAPTER: |
| ProcessString(XML_DISPLAY, |
| MapChapterDisplayFormat( |
| GetInt16Property(sPropertyChapterFormat, rPropSet))); |
| // API numbers 0..9, we number 1..10 |
| ProcessInteger(XML_OUTLINE_LEVEL, |
| GetInt8Property(sPropertyLevel, rPropSet) + 1); |
| ExportElement(XML_CHAPTER, sPresentation); |
| break; |
| |
| case FIELD_ID_FILE_NAME: |
| // all properties are optional |
| if (xPropSetInfo->hasPropertyByName(sPropertyFileFormat)) |
| { |
| ProcessString(XML_DISPLAY, |
| MapFilenameDisplayFormat( |
| GetInt16Property(sPropertyFileFormat, rPropSet))); |
| } |
| if (xPropSetInfo->hasPropertyByName(sPropertyIsFixed)) |
| { |
| ProcessBoolean(XML_FIXED, |
| GetBoolProperty(sPropertyIsFixed, rPropSet), |
| sal_False); |
| } |
| ExportElement(XML_FILE_NAME, sPresentation); |
| break; |
| |
| case FIELD_ID_REFPAGE_SET: |
| ProcessBoolean(XML_ACTIVE, |
| GetBoolProperty(sPropertyOn, rPropSet), sal_True); |
| ProcessIntegerDef(XML_PAGE_ADJUST, |
| GetInt16Property(sPropertyOffset, rPropSet), 0); |
| DBG_ASSERT(sPresentation.equals(sEmpty), |
| "Unexpected presentation page variable field"); |
| ExportElement(XML_PAGE_VARIABLE_SET); |
| break; |
| |
| case FIELD_ID_REFPAGE_GET: |
| ProcessNumberingType( |
| GetInt16Property(sPropertyNumberingType, rPropSet)); |
| ExportElement(XML_PAGE_VARIABLE_GET, sPresentation); |
| break; |
| |
| case FIELD_ID_MACRO: |
| ExportMacro( rPropSet, sPresentation ); |
| break; |
| |
| case FIELD_ID_REF_SEQUENCE: |
| // reference to sequence: format, name, find value (and element) |
| // was: if (nSeqNumber != -1) ... |
| ProcessString(XML_REFERENCE_FORMAT, |
| MapReferenceType(GetInt16Property( |
| sPropertyReferenceFieldPart, rPropSet)), |
| XML_TEMPLATE); |
| ProcessString(XML_REF_NAME, |
| MakeSequenceRefName( |
| GetInt16Property(sPropertySequenceNumber, rPropSet), |
| GetStringProperty(sPropertySourceName, rPropSet) ) ); |
| ExportElement( |
| MapReferenceSource( |
| GetInt16Property(sPropertyReferenceFieldSource, rPropSet)), |
| sPresentation); |
| break; |
| |
| case FIELD_ID_REF_REFERENCE: |
| case FIELD_ID_REF_BOOKMARK: |
| // reference to bookmarks, references: format, name (and element) |
| ProcessString(XML_REFERENCE_FORMAT, |
| MapReferenceType(GetInt16Property( |
| sPropertyReferenceFieldPart, rPropSet)), |
| XML_TEMPLATE); |
| ProcessString(XML_REF_NAME, |
| GetStringProperty(sPropertySourceName, rPropSet)); |
| ExportElement( |
| MapReferenceSource(GetInt16Property( |
| sPropertyReferenceFieldSource, rPropSet)), |
| sPresentation); |
| break; |
| |
| case FIELD_ID_REF_FOOTNOTE: |
| case FIELD_ID_REF_ENDNOTE: |
| // reference to end-/footnote: format, generate name, (and element) |
| GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_NOTE_CLASS, |
| FIELD_ID_REF_ENDNOTE==nToken ? XML_ENDNOTE : XML_FOOTNOTE ); |
| ProcessString(XML_REFERENCE_FORMAT, |
| MapReferenceType(GetInt16Property( |
| sPropertyReferenceFieldPart, rPropSet)), |
| XML_TEMPLATE); |
| ProcessString(XML_REF_NAME, |
| MakeFootnoteRefName(GetInt16Property( |
| sPropertySequenceNumber, rPropSet))); |
| ExportElement( |
| MapReferenceSource(GetInt16Property( |
| sPropertyReferenceFieldSource, rPropSet)), |
| sPresentation); |
| break; |
| |
| case FIELD_ID_DDE: |
| // name from field master |
| ProcessString(XML_CONNECTION_NAME, |
| |
| GetStringProperty(sPropertyName, |
| GetMasterPropertySet(rTextField))); |
| ExportElement(XML_DDE_CONNECTION, sPresentation); |
| break; |
| |
| case FIELD_ID_SHEET_NAME: |
| // name of spreadsheet (Calc only) |
| ExportElement(XML_SHEET_NAME, sPresentation); |
| break; |
| |
| case FIELD_ID_URL: |
| { |
| // this field is a special case because it gets mapped onto a |
| // hyperlink, rather than one of the regular text field. |
| ProcessString(XML_HREF, GetExport().GetRelativeReference(GetStringProperty(sPropertyURL, rPropSet)), |
| sal_False, XML_NAMESPACE_XLINK); |
| ProcessString(XML_TARGET_FRAME_NAME, |
| GetStringProperty(sPropertyTargetFrame,rPropSet), |
| sal_True, XML_NAMESPACE_OFFICE); |
| SvXMLElementExport aUrlField(rExport, XML_NAMESPACE_TEXT, XML_A, |
| sal_False, sal_False); |
| GetExport().Characters(sPresentation); |
| break; |
| } |
| |
| case FIELD_ID_BIBLIOGRAPHY: |
| { |
| ProcessBibliographyData(rPropSet); |
| ExportElement(XML_BIBLIOGRAPHY_MARK, sPresentation); |
| break; |
| } |
| |
| case FIELD_ID_SCRIPT: |
| ProcessString(XML_LANGUAGE, |
| GetStringProperty(sPropertyScriptType, rPropSet), |
| sal_True, XML_NAMESPACE_SCRIPT); |
| DBG_ASSERT(sPresentation.equals(sEmpty), |
| "Unexpected presentation for script field"); |
| if (GetBoolProperty(sPropertyURLContent, rPropSet)) |
| { |
| ProcessString(XML_HREF, |
| GetExport().GetRelativeReference(GetStringProperty(sPropertyContent, rPropSet)), |
| sal_False, XML_NAMESPACE_XLINK); |
| ExportElement(XML_SCRIPT); |
| } |
| else |
| { |
| ExportElement(XML_SCRIPT, |
| GetStringProperty(sPropertyContent, rPropSet)); |
| } |
| break; |
| |
| case FIELD_ID_ANNOTATION: |
| { |
| // check for empty presentation (just in case) |
| DBG_ASSERT(sPresentation.equals(sEmpty), |
| "Unexpected presentation for annotation field"); |
| |
| // annotation element + content |
| OUString aAnnotationName; |
| rPropSet->getPropertyValue(sPropertyName) >>= aAnnotationName; |
| if ( aAnnotationName.getLength() > 0 ) |
| { |
| GetExport().AddAttribute( XML_NAMESPACE_OFFICE, XML_NAME, aAnnotationName ); |
| } |
| SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_OFFICE, XML_ANNOTATION, sal_False, sal_True ); |
| |
| // author |
| OUString aAuthor( GetStringProperty(sPropertyAuthor, rPropSet) ); |
| if ( aAuthor.getLength() > 0 ) |
| { |
| SvXMLElementExport aCreatorElem( GetExport(), XML_NAMESPACE_DC, |
| XML_CREATOR, sal_True, |
| sal_False ); |
| GetExport().Characters(aAuthor); |
| } |
| |
| // date time |
| DateTime aDate( GetDateTimeProperty(sPropertyDateTimeValue, rPropSet) ); |
| { |
| OUStringBuffer aBuffer; |
| GetExport().GetMM100UnitConverter().convertDateTime(aBuffer, |
| aDate, |
| sal_True); |
| SvXMLElementExport aDateElem( GetExport(), XML_NAMESPACE_DC, |
| XML_DATE, sal_True, |
| sal_False ); |
| GetExport().Characters(aBuffer.makeStringAndClear()); |
| } |
| |
| // initials |
| if ( GetExport().getDefaultVersion() > SvtSaveOptions::ODFVER_012 ) |
| { |
| OUString aInitials( GetStringProperty(sPropertyInitials, rPropSet) ); |
| if ( aInitials.getLength() > 0 ) |
| { |
| SvXMLElementExport aCreatorElem( |
| GetExport(), |
| XML_NAMESPACE_TEXT_EXT, |
| XML_SENDER_INITIALS, |
| sal_True, |
| sal_False ); |
| GetExport().Characters(aInitials); |
| } |
| } |
| |
| com::sun::star::uno::Reference < com::sun::star::text::XText > xText; |
| try |
| { |
| com::sun::star::uno::Any aRet = rPropSet->getPropertyValue(sPropertyTextRange); |
| aRet >>= xText; |
| } |
| catch ( com::sun::star::uno::Exception& ) |
| {} |
| |
| if ( xText.is() ) |
| GetExport().GetTextParagraphExport()->exportText( xText ); |
| else |
| ProcessParagraphSequence(GetStringProperty(sPropertyContent,rPropSet)); |
| break; |
| } |
| |
| case FIELD_ID_COMBINED_CHARACTERS: |
| { |
| // The style with the combined characters attribute has |
| // already been handled in the ExportField method. So all that |
| // is left to do now is to export the characters. |
| GetExport().Characters(sPresentation); |
| break; |
| } |
| |
| case FIELD_ID_META: |
| { |
| ExportMetaField(rPropSet, false, bProgress); |
| break; |
| } |
| |
| case FIELD_ID_MEASURE: |
| { |
| ProcessString(XML_KIND, MapMeasureKind(GetInt16Property(sPropertyMeasureKind, rPropSet))); |
| ExportElement( XML_MEASURE, sPresentation ); |
| break; |
| } |
| |
| case FIELD_ID_TABLE_FORMULA: |
| ProcessString( XML_FORMULA, XML_NAMESPACE_OOOW, |
| GetStringProperty(sPropertyContent, rPropSet) ); |
| ProcessDisplay( sal_True, |
| GetBoolProperty(sPropertyIsShowFormula, rPropSet), |
| sal_True ); |
| ProcessValueAndType( sal_False, |
| GetIntProperty(sPropertyNumberFormat, rPropSet), |
| sEmpty, sEmpty, 0.0f, |
| sal_False, sal_False, sal_True, |
| sal_False, sal_False ); |
| ExportElement( XML_TABLE_FORMULA, sPresentation ); |
| break; |
| |
| case FIELD_ID_DROP_DOWN: |
| { |
| ProcessString(XML_NAME, GetStringProperty(sPropertyName, rPropSet)); |
| ProcessString(XML_HELP, |
| GetStringProperty(sPropertyHelp, rPropSet), true); |
| ProcessString(XML_HINT, |
| GetStringProperty(sPropertyTooltip, rPropSet), true); |
| SvXMLElementExport aElem( GetExport(), |
| XML_NAMESPACE_TEXT, XML_DROPDOWN, |
| sal_False, sal_False ); |
| ProcessStringSequence |
| (GetStringSequenceProperty( sPropertyItems, rPropSet ), |
| GetStringProperty( sPropertySelectedItem, rPropSet ) ); |
| |
| GetExport().Characters( sPresentation ); |
| } |
| break; |
| |
| case FIELD_ID_DRAW_HEADER: |
| { |
| SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_PRESENTATION, XML_HEADER, sal_False, sal_False ); |
| } |
| break; |
| |
| case FIELD_ID_DRAW_FOOTER: |
| { |
| SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_PRESENTATION, XML_FOOTER, sal_False, sal_False ); |
| } |
| break; |
| |
| case FIELD_ID_DRAW_DATE_TIME: |
| { |
| SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_PRESENTATION, XML_DATE_TIME, sal_False, sal_False ); |
| } |
| break; |
| |
| case FIELD_ID_UNKNOWN: |
| default: |
| DBG_ERROR("unknown field type encountered!"); |
| // always export content |
| GetExport().Characters(sPresentation); |
| } |
| } |
| |
| |
| /// export field declarations / field masters |
| void XMLTextFieldExport::ExportFieldDeclarations() |
| { |
| Reference<XText> xEmptyText; |
| ExportFieldDeclarations(xEmptyText); |
| } |
| |
| /// export field declarations / field masters |
| void XMLTextFieldExport::ExportFieldDeclarations( |
| const Reference<XText> & rText ) |
| { |
| // store lists for decl elements |
| vector<OUString> aVarName; |
| vector<OUString> aUserName; |
| vector<OUString> aSeqName; |
| vector<OUString> aDdeName; |
| |
| // get text fields supplier and field master name access |
| Reference<XTextFieldsSupplier> xTextFieldsSupp(GetExport().GetModel(), |
| UNO_QUERY); |
| if( !xTextFieldsSupp.is() ) |
| return; |
| |
| Reference<container::XNameAccess> xFieldMasterNameAccess( |
| xTextFieldsSupp->getTextFieldMasters(), UNO_QUERY); |
| |
| // where to get the text field masters from? |
| // a) we get a specific XText: then use pUsedMasters |
| // b) the XText is empty: then export all text fields |
| Sequence<OUString> aFieldMasters; |
| if (rText.is()) |
| { |
| // export only used masters |
| DBG_ASSERT(NULL != pUsedMasters, |
| "field masters must be recorded in order to be " |
| "written out separatly" ); |
| if (NULL != pUsedMasters) |
| { |
| map<Reference<XText>, set<OUString> > ::iterator aMapIter = |
| pUsedMasters->find(rText); |
| if (aMapIter != pUsedMasters->end()) |
| { |
| // found the set of used field masters |
| set<OUString> & rOurMasters = aMapIter->second; |
| |
| // copy set to sequence |
| aFieldMasters.realloc( rOurMasters.size() ); |
| sal_Int32 i = 0; |
| for( set<OUString>::iterator aSetIter = rOurMasters.begin(); |
| aSetIter != rOurMasters.end(); |
| aSetIter++, i++ ) |
| { |
| aFieldMasters[i] = *aSetIter; |
| } |
| |
| pUsedMasters->erase(rText); |
| } |
| // else: XText not found -> ignore |
| } |
| // else: no field masters have been recorded -> ignore |
| } |
| else |
| { |
| // no XText: export all! |
| aFieldMasters = xFieldMasterNameAccess->getElementNames(); |
| } |
| |
| for(sal_Int32 i=0; i<aFieldMasters.getLength(); i++) { |
| |
| // get field master name |
| OUString sFieldMaster = aFieldMasters[i]; |
| |
| // workaround for #no-bug# |
| static const sal_Char sDB[] = |
| "com.sun.star.text.FieldMaster.DataBase."; |
| if ( sFieldMaster.matchIgnoreAsciiCaseAsciiL( sDB, sizeof(sDB)-1) ) |
| { |
| continue; |
| } |
| |
| |
| OUString sFieldMasterType; |
| OUString sVarName; |
| ExplodeFieldMasterName(sFieldMaster, sFieldMasterType, sVarName); |
| |
| // get XPropertySet of this field master |
| Reference<XPropertySet> xPropSet; |
| Any aAny = xFieldMasterNameAccess->getByName(sFieldMaster); |
| aAny >>= xPropSet; |
| |
| // save interesting field masters |
| if (0 == sFieldMasterType.compareToAscii(FIELD_SERVICE_SETEXP)) |
| { |
| sal_Int32 nType = GetIntProperty(sPropertySubType, xPropSet); |
| |
| // sequence or variable? |
| if ( SetVariableType::SEQUENCE == nType ) |
| { |
| aSeqName.push_back( sFieldMaster ); |
| } |
| else |
| { |
| aVarName.push_back( sFieldMaster ); |
| } |
| } |
| else if (0 == sFieldMasterType.compareToAscii(FIELD_SERVICE_USER)) |
| { |
| aUserName.push_back( sFieldMaster ); |
| } |
| else if (0 == sFieldMasterType.compareToAscii(FIELD_SERVICE_DDE)) |
| { |
| aDdeName.push_back( sFieldMaster ); |
| } |
| else |
| { |
| ; // ignore |
| } |
| } |
| |
| // now process fields: |
| |
| // variable field masters: |
| if ( !aVarName.empty() ) |
| { |
| SvXMLElementExport aElem( GetExport(), |
| XML_NAMESPACE_TEXT, |
| XML_VARIABLE_DECLS, |
| sal_True, sal_True ); |
| |
| for (vector<OUString>::iterator aVarIter = aVarName.begin(); |
| aVarIter != aVarName.end(); |
| aVarIter++) { |
| |
| OUString sName = *aVarIter; |
| |
| // get field master property set |
| Reference<XPropertySet> xPropSet; |
| Any aAny = xFieldMasterNameAccess->getByName(sName); |
| aAny >>= xPropSet; |
| |
| // field name and type |
| OUString sFieldMasterType; |
| OUString sVarName; |
| ExplodeFieldMasterName(sName, sFieldMasterType, sVarName); |
| |
| // determine string/numeric field |
| sal_Bool bIsString = ( GetIntProperty(sPropertySubType, xPropSet) |
| == SetVariableType::STRING ); |
| |
| // get dependent field property set |
| Reference<XPropertySet> xFieldPropSet; |
| if (GetDependentFieldPropertySet(xPropSet, xFieldPropSet)) |
| { |
| // process value and type. |
| ProcessValueAndType( |
| bIsString, |
| GetIntProperty(sPropertyNumberFormat, xFieldPropSet), |
| sEmpty, sEmpty, 0.0, |
| sal_False, sal_True, sal_False, sal_False); |
| } |
| else |
| { |
| // If no dependent field is found, only string and |
| // float types can be supported |
| |
| // number format: 0 is default number format for 1st |
| // language. should be: getDefaultNumberFormat(Locale) |
| // from NumberFormats |
| ProcessValueAndType( |
| bIsString, |
| 0, sEmpty, sEmpty, 0.0, |
| sal_False, sal_True, sal_False, sal_False); |
| } |
| |
| ProcessString(XML_NAME, sVarName); |
| ExportElement(XML_VARIABLE_DECL, sal_True); |
| } |
| } |
| // else: no declarations element |
| |
| // sequence field masters: |
| if ( !aSeqName.empty() ) |
| { |
| SvXMLElementExport aElem( GetExport(), |
| XML_NAMESPACE_TEXT, |
| XML_SEQUENCE_DECLS, |
| sal_True, sal_True ); |
| |
| for (vector<OUString>::iterator aSeqIter = aSeqName.begin(); |
| aSeqIter != aSeqName.end(); |
| aSeqIter++) { |
| |
| OUString sName = *aSeqIter; |
| |
| // get field master property set |
| Reference<XPropertySet> xPropSet; |
| Any aAny = xFieldMasterNameAccess->getByName(sName); |
| aAny >>= xPropSet; |
| |
| // field name and type |
| OUString sFieldMasterType; |
| OUString sVarName; |
| ExplodeFieldMasterName(sName, sFieldMasterType, sVarName); |
| |
| // outline level |
| sal_Int32 nLevel = 1 + GetIntProperty( |
| sPropertyChapterNumberingLevel, xPropSet); |
| DBG_ASSERT(nLevel >= 0, "illegal outline level"); |
| DBG_ASSERT(nLevel < 127, "possible illegal outline level"); |
| ProcessInteger(XML_DISPLAY_OUTLINE_LEVEL, nLevel); |
| |
| // separation character |
| if (nLevel > 0) { |
| ProcessString(XML_SEPARATION_CHARACTER, GetStringProperty( |
| sPropertyNumberingSeparator, xPropSet)); |
| } |
| ProcessString(XML_NAME, sVarName); |
| ExportElement(XML_SEQUENCE_DECL, sal_True); |
| } |
| } |
| // else: no declarations element |
| |
| // user field field masters: |
| if ( !aUserName.empty() ) |
| { |
| SvXMLElementExport aElem( GetExport(), |
| XML_NAMESPACE_TEXT, |
| XML_USER_FIELD_DECLS, |
| sal_True, sal_True ); |
| |
| for (vector<OUString>::iterator aUserIter = aUserName.begin(); |
| aUserIter != aUserName.end(); |
| aUserIter++) { |
| |
| OUString sName = *aUserIter; |
| |
| // get field master property set |
| Reference<XPropertySet> xPropSet; |
| Any aAny = xFieldMasterNameAccess->getByName(sName); |
| aAny >>= xPropSet; |
| |
| // field name and type |
| OUString sFieldMasterType; |
| OUString sVarName; |
| ExplodeFieldMasterName(sName, sFieldMasterType, sVarName); |
| |
| if (GetBoolProperty(sPropertyIsExpression, xPropSet)) |
| { |
| // expression: |
| ProcessValueAndType( |
| sal_False, |
| 0, sEmpty, sEmpty, |
| GetDoubleProperty(sPropertyValue, xPropSet), |
| sal_True, |
| sal_True, |
| sal_False, |
| sal_False); |
| } |
| else |
| { |
| // string: write regardless of default |
| ProcessString(XML_VALUE_TYPE, XML_STRING, sal_False, |
| XML_NAMESPACE_OFFICE); |
| ProcessString(XML_STRING_VALUE, |
| GetStringProperty(sPropertyContent, xPropSet), |
| sal_False, XML_NAMESPACE_OFFICE ); |
| } |
| ProcessString(XML_NAME, sVarName); |
| ExportElement(XML_USER_FIELD_DECL, sal_True); |
| } |
| } |
| // else: no declarations element |
| |
| // DDE field field masters: |
| if ( !aDdeName.empty() ) |
| { |
| SvXMLElementExport aElem( GetExport(), |
| XML_NAMESPACE_TEXT, |
| XML_DDE_CONNECTION_DECLS, |
| sal_True, sal_True ); |
| |
| for (vector<OUString>::iterator aDdeIter = aDdeName.begin(); |
| aDdeIter != aDdeName.end(); |
| aDdeIter++) |
| { |
| OUString sName = *aDdeIter; |
| |
| // get field master property set |
| Reference<XPropertySet> xPropSet; |
| Any aAny = xFieldMasterNameAccess->getByName(sName); |
| aAny >>= xPropSet; |
| |
| // check if this connection is being used by a field |
| Reference<XPropertySet> xDummy; |
| if (GetDependentFieldPropertySet(xPropSet, xDummy)) |
| { |
| |
| ProcessString(XML_NAME, |
| GetStringProperty(sPropertyName, xPropSet), |
| sal_False, XML_NAMESPACE_OFFICE); |
| |
| // export elements; can't use ProcessString because |
| // elements are in office namespace |
| ProcessString(XML_DDE_APPLICATION, |
| GetStringProperty(sPropertyDDECommandType, |
| xPropSet), |
| sal_False, XML_NAMESPACE_OFFICE); |
| ProcessString(XML_DDE_TOPIC, |
| GetStringProperty(sPropertyDDECommandFile, |
| xPropSet), |
| sal_False, XML_NAMESPACE_OFFICE); |
| ProcessString(XML_DDE_ITEM, |
| GetStringProperty(sPropertyDDECommandElement, |
| xPropSet), |
| sal_False, XML_NAMESPACE_OFFICE); |
| sal_Bool bIsAutomaticUpdate = GetBoolProperty( |
| sPropertyIsAutomaticUpdate, xPropSet); |
| if (bIsAutomaticUpdate) |
| { |
| GetExport().AddAttribute(XML_NAMESPACE_OFFICE, |
| XML_AUTOMATIC_UPDATE, |
| XML_TRUE); |
| } |
| |
| ExportElement(XML_DDE_CONNECTION_DECL, sal_True); |
| } |
| // else: no dependent field -> no export of field declaration |
| } |
| } |
| // else: no declarations element |
| } |
| |
| void XMLTextFieldExport::SetExportOnlyUsedFieldDeclarations( |
| sal_Bool bExportOnlyUsed) |
| { |
| delete pUsedMasters; |
| pUsedMasters = NULL; |
| |
| // create used masters set (if none is used) |
| if (bExportOnlyUsed) |
| pUsedMasters = new map<Reference<XText>, set<OUString> > ; |
| } |
| |
| void XMLTextFieldExport::ExportElement(enum XMLTokenEnum eElementName, |
| sal_Bool bAddSpace) |
| { |
| // can't call ExportElement(eElementName, const OUString&) with empty |
| // string because xmlprinter only uses empty tags if no content |
| // (not even empty content) was written. |
| |
| DBG_ASSERT(XML_TOKEN_INVALID != eElementName, "invalid element name!"); |
| if (XML_TOKEN_INVALID != eElementName) |
| { |
| // Element |
| SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_TEXT, |
| eElementName, bAddSpace, bAddSpace ); |
| } // else: ignore |
| } |
| |
| void XMLTextFieldExport::ExportElement(enum XMLTokenEnum eElementName, |
| const OUString& sContent, |
| sal_Bool bAddSpace) |
| { |
| DBG_ASSERT(eElementName != XML_TOKEN_INVALID, "invalid element name!"); |
| if (eElementName != XML_TOKEN_INVALID) |
| { |
| // Element |
| SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_TEXT, |
| eElementName, bAddSpace, bAddSpace ); |
| // export content |
| GetExport().Characters(sContent); |
| } else { |
| // always export content |
| GetExport().Characters(sContent); |
| } |
| } |
| |
| void XMLTextFieldExport::ExportMacro( |
| const Reference<XPropertySet> & rPropSet, |
| const OUString& rContent ) |
| { |
| // some strings we'll need |
| OUString sEventType( RTL_CONSTASCII_USTRINGPARAM( "EventType" )); |
| OUString sStarBasic( RTL_CONSTASCII_USTRINGPARAM( "StarBasic" )); |
| OUString sScript( RTL_CONSTASCII_USTRINGPARAM( "Script" )); |
| OUString sLibrary( RTL_CONSTASCII_USTRINGPARAM( "Library" )); |
| OUString sMacroName( RTL_CONSTASCII_USTRINGPARAM( "MacroName" )); |
| OUString sOnClick( RTL_CONSTASCII_USTRINGPARAM( "OnClick" )); |
| OUString sPropertyMacroLibrary( RTL_CONSTASCII_USTRINGPARAM( "MacroLibrary" )); |
| OUString sPropertyMacroName( RTL_CONSTASCII_USTRINGPARAM( "MacroName" )); |
| OUString sPropertyScriptURL( RTL_CONSTASCII_USTRINGPARAM( "ScriptURL" )); |
| |
| |
| // the description attribute |
| ProcessString(XML_DESCRIPTION, |
| GetStringProperty(sPropertyHint, rPropSet), |
| rContent); |
| |
| // the element |
| SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_TEXT, |
| XML_EXECUTE_MACRO, sal_False, sal_False ); |
| |
| // the <office:events>-macro: |
| |
| // 1) build sequence of PropertyValues |
| Sequence<PropertyValue> aSeq; |
| OUString sName; |
| rPropSet->getPropertyValue( sPropertyScriptURL ) >>= sName; |
| |
| // if the ScriptURL property is not empty then this is a Scripting |
| // Framework URL, otherwise treat it as a Basic Macro |
| if (sName.getLength() != 0) |
| { |
| aSeq = Sequence<PropertyValue> (2); |
| PropertyValue* pArr = aSeq.getArray(); |
| pArr[0].Name = sEventType; |
| pArr[0].Value <<= sScript; |
| pArr[1].Name = sScript; |
| pArr[1].Value = rPropSet->getPropertyValue( sPropertyScriptURL ); |
| } |
| else |
| { |
| aSeq = Sequence<PropertyValue> (3); |
| PropertyValue* pArr = aSeq.getArray(); |
| pArr[0].Name = sEventType; |
| pArr[0].Value <<= sStarBasic; |
| pArr[1].Name = sLibrary; |
| pArr[1].Value = rPropSet->getPropertyValue( sPropertyMacroLibrary ); |
| pArr[2].Name = sMacroName; |
| pArr[2].Value = rPropSet->getPropertyValue( sPropertyMacroName ); |
| } |
| |
| // 2) export the sequence |
| GetExport().GetEventExport().ExportSingleEvent( aSeq, sOnClick, sal_False ); |
| |
| // and finally, the field presentation |
| GetExport().Characters(rContent); |
| } |
| |
| void XMLTextFieldExport::ExportMetaField( |
| const Reference<XPropertySet> & i_xMeta, |
| bool i_bAutoStyles, sal_Bool i_bProgress ) |
| { |
| bool doExport(!i_bAutoStyles); // do not export element if autostyles |
| // check version >= 1.2 |
| switch (GetExport().getDefaultVersion()) { |
| case SvtSaveOptions::ODFVER_011: // fall thru |
| case SvtSaveOptions::ODFVER_010: doExport = false; break; |
| default: break; |
| } |
| |
| const Reference < XEnumerationAccess > xEA( i_xMeta, UNO_QUERY_THROW ); |
| const Reference < XEnumeration > xTextEnum( xEA->createEnumeration() ); |
| |
| if (doExport) |
| { |
| const Reference<rdf::XMetadatable> xMeta( i_xMeta, UNO_QUERY_THROW ); |
| |
| // style:data-style-name |
| ProcessValueAndType(sal_False, |
| GetIntProperty(sPropertyNumberFormat, i_xMeta), |
| sEmpty, sEmpty, 0.0, sal_False, sal_False, sal_True, |
| sal_False, sal_False /*, sal_False*/ ); |
| |
| // text:meta-field without xml:id is invalid |
| xMeta->ensureMetadataReference(); |
| |
| // xml:id for RDF metadata |
| GetExport().AddAttributeXmlId(xMeta); |
| } |
| |
| SvXMLElementExport aElem( GetExport(), doExport, |
| XML_NAMESPACE_TEXT, XML_META_FIELD, sal_False, sal_False ); |
| |
| // recurse to export content |
| GetExport().GetTextParagraphExport()-> |
| exportTextRangeEnumeration( xTextEnum, i_bAutoStyles, i_bProgress ); |
| } |
| |
| /// export all data-style related attributes |
| void XMLTextFieldExport::ProcessValueAndType( |
| sal_Bool bIsString, /// do we process a string or a number? |
| sal_Int32 nFormatKey, /// format key for NumberFormatter; inv. if string |
| const OUString& sContent, /// string content; possibly invalid |
| const OUString& sDefault, /// default string |
| double fValue, /// float content; possibly invalid |
| sal_Bool bExportValue, /// export value attribute? |
| sal_Bool bExportValueType, /// export value-type attribute? |
| sal_Bool bExportStyle, /// export style-sttribute? |
| sal_Bool bForceSystemLanguage, /// export language attributes? |
| sal_Bool bTimeStyle) // exporting a time style? |
| { |
| // String or number? |
| if (bIsString) |
| { |
| |
| // string: attributes value-type=string, string-value=... |
| |
| if (bExportValue || bExportValueType) |
| { |
| XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes( |
| GetExport(), sContent, sDefault, bExportValue); |
| } |
| |
| } |
| else |
| { |
| |
| // number: value-type=..., value...=..., data-style-name=... |
| |
| DBG_ASSERT(bExportValueType || !bExportValue, "value w/o value type not supported!"); |
| |
| // take care of illegal formats |
| // (shouldn't happen, but does if document is corrupted) |
| if (-1 != nFormatKey) |
| { |
| if (bExportValue || bExportValueType) |
| { |
| XMLNumberFormatAttributesExportHelper:: |
| SetNumberFormatAttributes( |
| GetExport(), nFormatKey, fValue, bExportValue); |
| } |
| |
| if (bExportStyle) |
| { |
| // don't export language (if desired) |
| if( bForceSystemLanguage ) |
| nFormatKey = |
| GetExport().dataStyleForceSystemLanguage( nFormatKey ); |
| |
| OUString sDataStyleName = |
| GetExport().getDataStyleName(nFormatKey, bTimeStyle); |
| if( sDataStyleName.getLength() > 0 ) |
| { |
| GetExport().AddAttribute( XML_NAMESPACE_STYLE, |
| XML_DATA_STYLE_NAME, |
| sDataStyleName ); |
| } // else: ignore (no valid number format) |
| } // else: ignore (no number format) |
| } |
| } |
| } |
| |
| |
| |
| /// process display related properties |
| void XMLTextFieldExport::ProcessDisplay(sal_Bool bIsVisible, |
| sal_Bool bIsCommand, |
| sal_Bool bValueDefault) |
| { |
| enum XMLTokenEnum eValue; |
| |
| if (bIsVisible) |
| { |
| eValue = bIsCommand ? XML_FORMULA : XML_VALUE; |
| } |
| else |
| { |
| eValue = XML_NONE; |
| } |
| |
| // omit attribute if default |
| if (!bValueDefault || (eValue != XML_VALUE)) |
| { |
| GetExport().AddAttribute(XML_NAMESPACE_TEXT, XML_DISPLAY, eValue); |
| } |
| } |
| |
| |
| |
| /// export boolean property |
| void XMLTextFieldExport::ProcessBoolean(enum XMLTokenEnum eName, |
| sal_Bool bBool, sal_Bool bDefault) |
| { |
| DBG_ASSERT( eName != XML_TOKEN_INVALID, "invalid element token"); |
| if ( XML_TOKEN_INVALID == eName ) |
| return; |
| |
| // write attribute (if different than default) |
| // negate to force 0/1 values (and make sal_Bool comparable) |
| if ((!bBool) != (!bDefault)) { |
| GetExport().AddAttribute(XML_NAMESPACE_TEXT, eName, |
| (bBool ? XML_TRUE : XML_FALSE) ); |
| } |
| } |
| |
| |
| |
| |
| /// export string attribute |
| void XMLTextFieldExport::ProcessString(enum XMLTokenEnum eName, |
| const OUString& sValue, |
| sal_Bool bOmitEmpty, |
| sal_uInt16 nPrefix) |
| { |
| DBG_ASSERT( eName != XML_TOKEN_INVALID, "invalid element token"); |
| if ( XML_TOKEN_INVALID == eName ) |
| return; |
| |
| // check for empty string, if applicable |
| if ( bOmitEmpty && (sValue.getLength()==0) ) |
| return; |
| |
| // write attribute |
| GetExport().AddAttribute(nPrefix, eName, sValue); |
| } |
| |
| void XMLTextFieldExport::ProcessString(enum XMLTokenEnum eName, |
| sal_uInt16 nValuePrefix, |
| const OUString& sValue, |
| sal_Bool bOmitEmpty, |
| sal_uInt16 nPrefix) |
| { |
| OUString sQValue = |
| GetExport().GetNamespaceMap().GetQNameByKey( nValuePrefix, sValue, sal_False ); |
| ProcessString( eName, sQValue, bOmitEmpty, nPrefix ); |
| } |
| |
| /// export a string attribute |
| void XMLTextFieldExport::ProcessString(enum XMLTokenEnum eName, |
| const ::rtl::OUString& sValue, |
| const ::rtl::OUString& sDefault, |
| sal_uInt16 nPrefix) |
| { |
| if (sValue != sDefault) |
| { |
| ProcessString(eName, sValue, sal_False, nPrefix); |
| } |
| } |
| |
| /// export a string attribute |
| void XMLTextFieldExport::ProcessString(enum XMLTokenEnum eName, |
| sal_uInt16 nValuePrefix, |
| const ::rtl::OUString& sValue, |
| const ::rtl::OUString& sDefault, |
| sal_uInt16 nPrefix) |
| { |
| if (sValue != sDefault) |
| { |
| ProcessString(eName, nValuePrefix, sValue, sal_False, nPrefix); |
| } |
| } |
| |
| |
| /// export string attribute |
| void XMLTextFieldExport::ProcessString( |
| enum XMLTokenEnum eName, |
| enum XMLTokenEnum eValue, |
| sal_Bool bOmitEmpty, |
| sal_uInt16 nPrefix) |
| { |
| DBG_ASSERT( eName != XML_TOKEN_INVALID, "invalid element token" ); |
| DBG_ASSERT( bOmitEmpty || (eValue != XML_TOKEN_INVALID), |
| "invalid value token" ); |
| if ( XML_TOKEN_INVALID == eName ) |
| return; |
| |
| // check for empty string, if applicable |
| if (bOmitEmpty && (eValue == XML_TOKEN_INVALID)) |
| return; |
| |
| GetExport().AddAttribute(nPrefix, eName, eValue); |
| } |
| |
| /// export a string attribute |
| void XMLTextFieldExport::ProcessString( |
| enum XMLTokenEnum eName, |
| enum XMLTokenEnum eValue, |
| enum XMLTokenEnum eDefault, |
| sal_uInt16 nPrefix) |
| { |
| if ( eValue != eDefault ) |
| ProcessString( eName, eValue, sal_False, nPrefix); |
| } |
| |
| |
| /// export a string as a sequence of paragraphs |
| void XMLTextFieldExport::ProcessParagraphSequence( |
| const ::rtl::OUString& sParagraphSequence) |
| { |
| // iterate over all string-pieces separated by return (0x0a) and |
| // put each inside a paragraph element. |
| SvXMLTokenEnumerator aEnumerator(sParagraphSequence, sal_Char(0x0a)); |
| OUString aSubString; |
| while (aEnumerator.getNextToken(aSubString)) |
| { |
| SvXMLElementExport aParagraph( |
| GetExport(), XML_NAMESPACE_TEXT, XML_P, sal_True, sal_False); |
| GetExport().Characters(aSubString); |
| } |
| } |
| |
| // export an integer attribute |
| void XMLTextFieldExport::ProcessInteger(enum XMLTokenEnum eName, |
| sal_Int32 nNum) |
| { |
| DBG_ASSERT( eName != XML_TOKEN_INVALID, "invalid element token"); |
| if ( XML_TOKEN_INVALID == eName ) |
| return; |
| |
| GetExport().AddAttribute(XML_NAMESPACE_TEXT, eName, |
| OUString::valueOf(nNum)); |
| } |
| |
| /// export an integer attribute, omit if default |
| void XMLTextFieldExport::ProcessIntegerDef(enum XMLTokenEnum eName, |
| sal_Int32 nNum, sal_Int32 nDefault) |
| { |
| if (nNum != nDefault) |
| ProcessInteger(eName, nNum); |
| } |
| |
| |
| |
| /// export a numbering type |
| void XMLTextFieldExport::ProcessNumberingType(sal_Int16 nNumberingType) |
| { |
| // process only if real format (not: like page descriptor) |
| if (NumberingType::PAGE_DESCRIPTOR != nNumberingType) |
| { |
| OUStringBuffer sTmp( 10 ); |
| // number type: num format |
| GetExport().GetMM100UnitConverter().convertNumFormat( sTmp, |
| nNumberingType ); |
| GetExport().AddAttribute(XML_NAMESPACE_STYLE, XML_NUM_FORMAT, |
| sTmp.makeStringAndClear() ); |
| // and letter sync, if applicable |
| GetExport().GetMM100UnitConverter().convertNumLetterSync( sTmp, |
| nNumberingType ); |
| |
| if (sTmp.getLength()) |
| { |
| GetExport().AddAttribute(XML_NAMESPACE_STYLE, XML_NUM_LETTER_SYNC, |
| sTmp.makeStringAndClear() ); |
| } |
| } |
| // else: like page descriptor => ignore |
| } |
| |
| |
| /// export a date, time, or duration |
| void XMLTextFieldExport::ProcessDateTime(enum XMLTokenEnum eName, |
| double dValue, |
| sal_Bool bIsDate, |
| sal_Bool bIsDuration, |
| sal_Bool bOmitDurationIfZero, |
| sal_uInt16 nPrefix) |
| { |
| // truncate for date granularity |
| if (bIsDate) |
| { |
| dValue = ::rtl::math::approxFloor(dValue); |
| } |
| |
| OUStringBuffer aBuffer; |
| if (bIsDuration) |
| { |
| // date/time durationM handle bOmitDurationIfZero |
| if (!bOmitDurationIfZero || !::rtl::math::approxEqual(dValue, 0.0)) |
| { |
| rExport.GetMM100UnitConverter().convertTime(aBuffer, dValue); |
| } |
| } |
| else |
| { |
| // date/time value |
| rExport.GetMM100UnitConverter().convertDateTime(aBuffer, dValue); |
| } |
| |
| // output attribute |
| ProcessString(eName, aBuffer.makeStringAndClear(), sal_True, nPrefix); |
| } |
| |
| /// export a date or time |
| void XMLTextFieldExport::ProcessDateTime(enum XMLTokenEnum eName, |
| const DateTime& rTime, |
| sal_Bool bIsDate, |
| sal_uInt16 nPrefix) |
| { |
| OUStringBuffer aBuffer; |
| |
| DateTime aDateTime(rTime); |
| |
| // truncate dates |
| if(bIsDate) |
| { |
| aDateTime.HundredthSeconds = 0; |
| aDateTime.Seconds = 0; |
| aDateTime.Minutes = 0; |
| aDateTime.Hours = 0; |
| } |
| |
| // date/time value |
| rExport.GetMM100UnitConverter().convertDateTime(aBuffer, aDateTime); |
| |
| // output attribute |
| ProcessString(eName, aBuffer.makeStringAndClear(), sal_True, nPrefix); |
| } |
| |
| /// export date according to ISO 8601 |
| void XMLTextFieldExport::ProcessDate( |
| enum XMLTokenEnum eName, |
| const ::com::sun::star::util::Date& rDate, |
| sal_uInt16 nPrefix) |
| { |
| // the easiest way: delegate to ProcessDateTime (as date) |
| DateTime aDateTime; |
| aDateTime.Day = rDate.Day; |
| aDateTime.Month = rDate.Month; |
| aDateTime.Year = rDate.Year; |
| ProcessDateTime(eName, aDateTime, sal_True, nPrefix); |
| } |
| |
| |
| /// export a date, time, or duration |
| void XMLTextFieldExport::ProcessDateTime(enum XMLTokenEnum eName, |
| sal_Int32 nMinutes, |
| sal_Bool bIsDate, |
| sal_Bool bIsDuration, |
| sal_Bool bOmitDurationIfZero, |
| sal_uInt16 nPrefix) |
| { |
| // handle bOmitDurationIfZero here, because we can precisely compare ints |
| if (!(bIsDuration && bOmitDurationIfZero && (nMinutes==0))) |
| { |
| ProcessDateTime(eName, (double)nMinutes / (double)(24*60), |
| bIsDate, bIsDuration, bOmitDurationIfZero, nPrefix); |
| } |
| } |
| |
| |
| SvXMLEnumMapEntry __READONLY_DATA aBibliographyDataTypeMap[] = |
| { |
| { XML_ARTICLE, BibliographyDataType::ARTICLE }, |
| { XML_BOOK, BibliographyDataType::BOOK }, |
| { XML_BOOKLET, BibliographyDataType::BOOKLET }, |
| { XML_CONFERENCE, BibliographyDataType::CONFERENCE }, |
| { XML_CUSTOM1, BibliographyDataType::CUSTOM1 }, |
| { XML_CUSTOM2, BibliographyDataType::CUSTOM2 }, |
| { XML_CUSTOM3, BibliographyDataType::CUSTOM3 }, |
| { XML_CUSTOM4, BibliographyDataType::CUSTOM4 }, |
| { XML_CUSTOM5, BibliographyDataType::CUSTOM5 }, |
| { XML_EMAIL, BibliographyDataType::EMAIL }, |
| { XML_INBOOK, BibliographyDataType::INBOOK }, |
| { XML_INCOLLECTION, BibliographyDataType::INCOLLECTION }, |
| { XML_INPROCEEDINGS, BibliographyDataType::INPROCEEDINGS }, |
| { XML_JOURNAL, BibliographyDataType::JOURNAL }, |
| { XML_MANUAL, BibliographyDataType::MANUAL }, |
| { XML_MASTERSTHESIS, BibliographyDataType::MASTERSTHESIS }, |
| { XML_MISC, BibliographyDataType::MISC }, |
| { XML_PHDTHESIS, BibliographyDataType::PHDTHESIS }, |
| { XML_PROCEEDINGS, BibliographyDataType::PROCEEDINGS }, |
| { XML_TECHREPORT, BibliographyDataType::TECHREPORT }, |
| { XML_UNPUBLISHED, BibliographyDataType::UNPUBLISHED }, |
| { XML_WWW, BibliographyDataType::WWW }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| |
| |
| |
| void XMLTextFieldExport::ProcessBibliographyData( |
| const Reference<XPropertySet>& rPropSet) |
| { |
| // get the values |
| Any aAny = rPropSet->getPropertyValue(sPropertyFields); |
| Sequence<PropertyValue> aValues; |
| aAny >>= aValues; |
| |
| // one attribute per value (unless empty) |
| sal_Int32 nLength = aValues.getLength(); |
| for (sal_Int32 i = 0; i < nLength; i++) |
| { |
| if (aValues[i].Name.equalsAsciiL("BibiliographicType", |
| sizeof("BibiliographicType")-1)) |
| { |
| sal_Int16 nTypeId = 0; |
| aValues[i].Value >>= nTypeId; |
| OUStringBuffer sBuf; |
| |
| if (SvXMLUnitConverter::convertEnum(sBuf, nTypeId, |
| aBibliographyDataTypeMap)) |
| { |
| rExport.AddAttribute(XML_NAMESPACE_TEXT, |
| XML_BIBLIOGRAPHY_TYPE, |
| sBuf.makeStringAndClear()); |
| } |
| // else: ignore this argument |
| } |
| else |
| { |
| OUString sStr; |
| aValues[i].Value >>= sStr; |
| |
| if (sStr.getLength() > 0) |
| { |
| rExport.AddAttribute(XML_NAMESPACE_TEXT, |
| MapBibliographyFieldName(aValues[i].Name), |
| sStr); |
| } |
| } |
| } |
| } |
| |
| /// export CommandTypeAttribute |
| void XMLTextFieldExport::ProcessCommandType( |
| sal_Int32 nCommandType) |
| { |
| enum XMLTokenEnum eToken = XML_TOKEN_INVALID; |
| switch( nCommandType ) |
| { |
| case sdb::CommandType::TABLE: eToken = XML_TABLE; break; |
| case sdb::CommandType::QUERY: eToken = XML_QUERY; break; |
| case sdb::CommandType::COMMAND: eToken = XML_COMMAND; break; |
| } |
| |
| if( eToken != XML_TOKEN_INVALID ) |
| rExport.AddAttribute( XML_NAMESPACE_TEXT, XML_TABLE_TYPE, eToken ); |
| } |
| |
| |
| void XMLTextFieldExport::ProcessStringSequence( |
| const Sequence<OUString>& rSequence, |
| const OUString sSelected ) |
| { |
| // find selected element |
| sal_Int32 nSelected = -1; |
| sal_Int32 nLength = rSequence.getLength(); |
| const OUString* pSequence = rSequence.getConstArray(); |
| for( sal_Int32 i = 0; i < nLength; i++ ) |
| { |
| if( pSequence[i] == sSelected ) |
| nSelected = i; |
| } |
| |
| // delegate to ProcessStringSequence(OUString,sal_Int32) |
| ProcessStringSequence( rSequence, nSelected ); |
| } |
| |
| void XMLTextFieldExport::ProcessStringSequence( |
| const Sequence<OUString>& rSequence, |
| sal_Int32 nSelected ) |
| { |
| sal_Int32 nLength = rSequence.getLength(); |
| const OUString* pSequence = rSequence.getConstArray(); |
| for( sal_Int32 i = 0; i < nLength; i++ ) |
| { |
| if( i == nSelected ) |
| rExport.AddAttribute( XML_NAMESPACE_TEXT, |
| XML_CURRENT_SELECTED, XML_TRUE ); |
| rExport.AddAttribute( XML_NAMESPACE_TEXT, XML_VALUE, pSequence[i] ); |
| SvXMLElementExport aElement( rExport, XML_NAMESPACE_TEXT, XML_LABEL, |
| sal_False, sal_False ); |
| } |
| } |
| |
| void XMLTextFieldExport::ExportDataBaseElement( |
| enum XMLTokenEnum eElementName, |
| const OUString& sPresentation, |
| const Reference<XPropertySet>& rPropertySet, |
| const Reference<XPropertySetInfo>& rPropertySetInfo ) |
| { |
| DBG_ASSERT( eElementName != XML_TOKEN_INVALID, "need token" ); |
| DBG_ASSERT( rPropertySet.is(), "need property set" ); |
| DBG_ASSERT( rPropertySetInfo.is(), "need property set info" ); |
| |
| // get database properties |
| OUString sDataBaseName; |
| OUString sDataBaseURL; |
| OUString sStr; |
| if( ( rPropertySet->getPropertyValue( sPropertyDataBaseName ) >>= sStr ) |
| && ( sStr.getLength() > 0 ) ) |
| { |
| sDataBaseName = sStr; |
| } |
| else if( rPropertySetInfo->hasPropertyByName( sPropertyDataBaseURL ) && |
| (rPropertySet->getPropertyValue( sPropertyDataBaseURL ) >>= sStr) && |
| (sStr.getLength() > 0) ) |
| { |
| sDataBaseURL = sStr; |
| } |
| |
| // add database name property (if present) |
| if( sDataBaseName.getLength() > 0 ) |
| rExport.AddAttribute( XML_NAMESPACE_TEXT, XML_DATABASE_NAME, |
| sDataBaseName ); |
| SvXMLElementExport aDataBaseElement( GetExport(), |
| XML_NAMESPACE_TEXT, eElementName, |
| sal_False, sal_False ); |
| |
| // write URL as children |
| if( sDataBaseURL.getLength() > 0 ) |
| { |
| rExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, sDataBaseURL ); |
| SvXMLElementExport aDataSourceElement( |
| GetExport(), XML_NAMESPACE_FORM, XML_CONNECTION_RESOURCE, |
| sal_False, sal_False ); |
| } |
| |
| // write presentation |
| rExport.Characters( sPresentation ); |
| } |
| |
| |
| |
| // explode a field master name into field type and field name |
| sal_Bool XMLTextFieldExport::ExplodeFieldMasterName( |
| const OUString& sMasterName, OUString& sFieldType, OUString& sVarName) |
| { |
| sal_Int32 nLength = sFieldMasterPrefix.getLength(); |
| sal_Int32 nSeparator = sMasterName.indexOf('.', nLength); |
| sal_Bool bReturn = sal_True; |
| |
| #ifdef DBG_UTIL |
| // check for service name |
| bReturn &= (0 == sFieldMasterPrefix.compareTo(sMasterName, nLength)); |
| #endif |
| |
| // '.' found? |
| if (nSeparator <= nLength) { |
| nSeparator = sMasterName.getLength(); |
| DBG_WARNING("no field var name!"); |
| bReturn = sal_False; |
| } |
| else |
| { |
| sFieldType = sMasterName.copy(nLength, nSeparator-nLength); |
| sVarName = sMasterName.copy(nSeparator+1); |
| } |
| |
| return bReturn; |
| } |
| |
| |
| // for XDependentTextFields, get PropertySet of FieldMaster |
| Reference<XPropertySet> XMLTextFieldExport::GetMasterPropertySet( |
| const Reference<XTextField> & rTextField) |
| { |
| // name, value => get Property set of TextFieldMaster |
| Reference<XDependentTextField> xDep(rTextField, UNO_QUERY); |
| return xDep->getTextFieldMaster(); |
| } |
| |
| // get PropertySet of (any; the first) dependent field |
| sal_Bool XMLTextFieldExport::GetDependentFieldPropertySet( |
| const Reference<XPropertySet> & xMaster, |
| Reference<XPropertySet> & xField) |
| { |
| Any aAny; |
| Sequence<Reference<XDependentTextField> > aFields; |
| aAny = xMaster->getPropertyValue(sPropertyDependentTextFields); |
| aAny >>= aFields; |
| |
| // any fields? |
| if (aFields.getLength() > 0) |
| { |
| // get first one and return |
| Reference<XDependentTextField> xTField = aFields[0]; |
| xField = Reference<XPropertySet>(xTField, UNO_QUERY); |
| DBG_ASSERT(xField.is(), |
| "Surprisinlgy, this TextField refuses to be a PropertySet!"); |
| return sal_True; |
| } |
| else |
| { |
| return sal_False; |
| } |
| } |
| |
| |
| /// map placeholder type |
| enum XMLTokenEnum XMLTextFieldExport::MapPlaceholderType(sal_uInt16 nType) |
| { |
| enum XMLTokenEnum eType = XML_TEXT; |
| |
| switch (nType) |
| { |
| case PlaceholderType::TEXT: |
| eType = XML_TEXT; |
| break; |
| |
| case PlaceholderType::TABLE: |
| eType = XML_TABLE; |
| break; |
| |
| case PlaceholderType::TEXTFRAME: |
| eType = XML_TEXT_BOX; |
| break; |
| |
| case PlaceholderType::GRAPHIC: |
| eType = XML_IMAGE; |
| break; |
| |
| case PlaceholderType::OBJECT: |
| eType = XML_OBJECT; |
| break; |
| |
| default: |
| // unknown placeholder: XML_TEXT |
| DBG_ERROR("unknown placeholder type"); |
| } |
| |
| return eType; |
| } |
| |
| |
| /// element name for author fields |
| enum XMLTokenEnum XMLTextFieldExport::MapAuthorFieldName( |
| const Reference<XPropertySet> & xPropSet) |
| { |
| // Initalen oder voller Name? |
| return GetBoolProperty(sPropertyFullName, xPropSet) |
| ? XML_AUTHOR_NAME : XML_AUTHOR_INITIALS; |
| } |
| |
| enum XMLTokenEnum XMLTextFieldExport::MapPageNumberName( |
| const Reference<XPropertySet> & xPropSet, |
| sal_Int32& nOffset) |
| { |
| enum XMLTokenEnum eName = XML_TOKEN_INVALID; |
| PageNumberType ePage; |
| Any aAny = xPropSet->getPropertyValue(sPropertySubType); |
| ePage = *(PageNumberType*)aAny.getValue(); |
| |
| switch (ePage) |
| { |
| case PageNumberType_PREV: |
| eName = XML_PREVIOUS; |
| nOffset += 1; |
| break; |
| case PageNumberType_CURRENT: |
| eName = XML_CURRENT; |
| break; |
| case PageNumberType_NEXT: |
| eName = XML_NEXT; |
| nOffset -= 1; |
| break; |
| default: |
| DBG_ERROR("unknown page number type"); |
| eName = XML_TOKEN_INVALID; |
| break; |
| } |
| |
| return eName; |
| } |
| |
| /// map TemplateDisplayFormat to XML |
| enum XMLTokenEnum XMLTextFieldExport::MapTemplateDisplayFormat(sal_Int16 nFormat) |
| { |
| enum XMLTokenEnum eName = XML_TOKEN_INVALID; |
| |
| switch (nFormat) |
| { |
| case TemplateDisplayFormat::FULL: |
| eName = XML_FULL; |
| break; |
| case TemplateDisplayFormat::PATH: |
| eName = XML_PATH; |
| break; |
| case TemplateDisplayFormat::NAME: |
| eName = XML_NAME; |
| break; |
| case TemplateDisplayFormat::NAME_AND_EXT: |
| eName = XML_NAME_AND_EXTENSION; |
| break; |
| case TemplateDisplayFormat::AREA: |
| eName = XML_AREA; |
| break; |
| case TemplateDisplayFormat::TITLE: |
| eName = XML_TITLE; |
| break; |
| default: |
| DBG_ERROR("unknown template display format"); |
| eName = XML_TOKEN_INVALID; |
| break; |
| } |
| |
| return eName; |
| } |
| |
| /// map count/statistics field token to XML name |
| enum XMLTokenEnum XMLTextFieldExport::MapCountFieldName(FieldIdEnum nToken) |
| { |
| enum XMLTokenEnum eElement = XML_TOKEN_INVALID; |
| |
| switch (nToken) |
| { |
| case FIELD_ID_COUNT_PAGES: |
| eElement = XML_PAGE_COUNT; |
| break; |
| case FIELD_ID_COUNT_PARAGRAPHS: |
| eElement = XML_PARAGRAPH_COUNT; |
| break; |
| case FIELD_ID_COUNT_WORDS: |
| eElement = XML_WORD_COUNT; |
| break; |
| case FIELD_ID_COUNT_CHARACTERS: |
| eElement = XML_CHARACTER_COUNT; |
| break; |
| case FIELD_ID_COUNT_TABLES: |
| eElement = XML_TABLE_COUNT; |
| break; |
| case FIELD_ID_COUNT_GRAPHICS: |
| eElement = XML_IMAGE_COUNT; |
| break; |
| case FIELD_ID_COUNT_OBJECTS: |
| eElement = XML_OBJECT_COUNT; |
| break; |
| default: |
| DBG_ERROR("no count field token"); |
| eElement = XML_TOKEN_INVALID; |
| break; |
| } |
| |
| return eElement; |
| } |
| |
| /// map ChapterDisplayFormat to XML string |
| enum XMLTokenEnum XMLTextFieldExport::MapChapterDisplayFormat(sal_Int16 nFormat) |
| { |
| enum XMLTokenEnum eName = XML_TOKEN_INVALID; |
| |
| switch (nFormat) |
| { |
| case ChapterFormat::NAME: |
| eName = XML_NAME; |
| break; |
| case ChapterFormat::NUMBER: |
| eName = XML_NUMBER; |
| break; |
| case ChapterFormat::NAME_NUMBER: |
| eName = XML_NUMBER_AND_NAME; |
| break; |
| case ChapterFormat::NO_PREFIX_SUFFIX: |
| eName = XML_PLAIN_NUMBER_AND_NAME; |
| break; |
| case ChapterFormat::DIGIT: |
| eName = XML_PLAIN_NUMBER; |
| break; |
| default: |
| DBG_ERROR("unknown chapter display format"); |
| eName = XML_TOKEN_INVALID; |
| break; |
| } |
| |
| return eName; |
| } |
| |
| |
| /// map FilenameDisplayFormat to XML attribute names |
| enum XMLTokenEnum XMLTextFieldExport::MapFilenameDisplayFormat(sal_Int16 nFormat) |
| { |
| enum XMLTokenEnum eName = XML_TOKEN_INVALID; |
| |
| switch (nFormat) |
| { |
| case FilenameDisplayFormat::FULL: |
| eName = XML_FULL; |
| break; |
| case FilenameDisplayFormat::PATH: |
| eName = XML_PATH; |
| break; |
| case FilenameDisplayFormat::NAME: |
| eName = XML_NAME; |
| break; |
| case FilenameDisplayFormat::NAME_AND_EXT: |
| eName = XML_NAME_AND_EXTENSION; |
| break; |
| default: |
| DBG_ERROR("unknown filename display format"); |
| } |
| |
| return eName; |
| } |
| |
| |
| /// map ReferenceFieldPart to XML string |
| enum XMLTokenEnum XMLTextFieldExport::MapReferenceType(sal_Int16 nType) |
| { |
| enum XMLTokenEnum eElement = XML_TOKEN_INVALID; |
| |
| switch (nType) |
| { |
| case ReferenceFieldPart::PAGE: |
| eElement = XML_PAGE; |
| break; |
| case ReferenceFieldPart::CHAPTER: |
| eElement = XML_CHAPTER; |
| break; |
| case ReferenceFieldPart::TEXT: |
| eElement = XML_TEXT; |
| break; |
| case ReferenceFieldPart::UP_DOWN: |
| eElement = XML_DIRECTION; |
| break; |
| case ReferenceFieldPart::CATEGORY_AND_NUMBER: |
| eElement = XML_CATEGORY_AND_VALUE; |
| break; |
| case ReferenceFieldPart::ONLY_CAPTION: |
| eElement = XML_CAPTION; |
| break; |
| case ReferenceFieldPart::ONLY_SEQUENCE_NUMBER: |
| eElement = XML_VALUE; |
| break; |
| case ReferenceFieldPart::PAGE_DESC: |
| // small hack: this value never gets written, because |
| // XML_TEMPLATE is default |
| eElement = XML_TEMPLATE; |
| break; |
| // --> OD 2007-09-14 #i81002# |
| case ReferenceFieldPart::NUMBER: |
| eElement = XML_NUMBER; |
| break; |
| case ReferenceFieldPart::NUMBER_NO_CONTEXT: |
| eElement = XML_NUMBER_NO_SUPERIOR; |
| break; |
| case ReferenceFieldPart::NUMBER_FULL_CONTEXT: |
| eElement = XML_NUMBER_ALL_SUPERIOR; |
| break; |
| // <-- |
| default: |
| DBG_ERROR("unknown reference type"); |
| eElement = XML_TEMPLATE; |
| break; |
| } |
| |
| return eElement; |
| } |
| |
| /// map ReferenceFieldPart to XML string |
| enum XMLTokenEnum XMLTextFieldExport::MapReferenceSource(sal_Int16 nType) |
| { |
| enum XMLTokenEnum eElement = XML_TOKEN_INVALID; |
| |
| switch (nType) |
| { |
| case ReferenceFieldSource::REFERENCE_MARK: |
| eElement = XML_REFERENCE_REF; |
| break; |
| case ReferenceFieldSource::SEQUENCE_FIELD: |
| eElement = XML_SEQUENCE_REF; |
| break; |
| case ReferenceFieldSource::BOOKMARK: |
| eElement = XML_BOOKMARK_REF; |
| break; |
| case ReferenceFieldSource::FOOTNOTE: |
| case ReferenceFieldSource::ENDNOTE: |
| eElement = XML_NOTE_REF; |
| break; |
| default: |
| DBG_ERROR("unknown reference source"); |
| break; |
| } |
| |
| return eElement; |
| } |
| |
| |
| /// element name for sender fields |
| enum XMLTokenEnum XMLTextFieldExport::MapSenderFieldName( |
| const Reference<XPropertySet> & xPropSet) |
| { |
| enum XMLTokenEnum eName = XML_TOKEN_INVALID; |
| |
| // sub-field type |
| switch (GetInt16Property(sPropertyFieldSubType, xPropSet)) |
| { |
| case UserDataPart::COMPANY : |
| eName = XML_SENDER_COMPANY; |
| break; |
| case UserDataPart::FIRSTNAME : |
| eName = XML_SENDER_FIRSTNAME; |
| break; |
| case UserDataPart::NAME : |
| eName = XML_SENDER_LASTNAME; |
| break; |
| case UserDataPart::SHORTCUT : |
| eName = XML_SENDER_INITIALS; |
| break; |
| case UserDataPart::STREET : |
| eName = XML_SENDER_STREET; |
| break; |
| case UserDataPart::COUNTRY : |
| eName = XML_SENDER_COUNTRY; |
| break; |
| case UserDataPart::ZIP : |
| eName = XML_SENDER_POSTAL_CODE; |
| break; |
| case UserDataPart::CITY : |
| eName = XML_SENDER_CITY; |
| break; |
| case UserDataPart::TITLE : |
| eName = XML_SENDER_TITLE; |
| break; |
| case UserDataPart::POSITION : |
| eName = XML_SENDER_POSITION; |
| break; |
| case UserDataPart::PHONE_PRIVATE : |
| eName = XML_SENDER_PHONE_PRIVATE; |
| break; |
| case UserDataPart::PHONE_COMPANY : |
| eName = XML_SENDER_PHONE_WORK; |
| break; |
| case UserDataPart::FAX : |
| eName = XML_SENDER_FAX; |
| break; |
| case UserDataPart::EMAIL : |
| eName = XML_SENDER_EMAIL; |
| break; |
| case UserDataPart::STATE : |
| eName = XML_SENDER_STATE_OR_PROVINCE; |
| break; |
| default: |
| DBG_WARNING("unknown sender type"); |
| eName = XML_TOKEN_INVALID; |
| break; |
| } |
| |
| return eName; |
| } |
| |
| enum XMLTokenEnum XMLTextFieldExport::MapDocInfoFieldName( |
| enum FieldIdEnum nToken) |
| { |
| enum XMLTokenEnum eElement = XML_TOKEN_INVALID; |
| |
| switch (nToken) |
| { |
| case FIELD_ID_DOCINFO_CREATION_AUTHOR: |
| eElement = XML_INITIAL_CREATOR; |
| break; |
| case FIELD_ID_DOCINFO_CREATION_DATE: |
| eElement = XML_CREATION_DATE; |
| break; |
| case FIELD_ID_DOCINFO_CREATION_TIME: |
| eElement = XML_CREATION_TIME; |
| break; |
| case FIELD_ID_DOCINFO_DESCRIPTION: |
| eElement = XML_DESCRIPTION; |
| break; |
| case FIELD_ID_DOCINFO_PRINT_TIME: |
| eElement = XML_PRINT_TIME; |
| break; |
| case FIELD_ID_DOCINFO_PRINT_DATE: |
| eElement = XML_PRINT_DATE; |
| break; |
| case FIELD_ID_DOCINFO_PRINT_AUTHOR: |
| eElement = XML_PRINTED_BY; |
| break; |
| case FIELD_ID_DOCINFO_TITLE: |
| eElement = XML_TITLE; |
| break; |
| case FIELD_ID_DOCINFO_SUBJECT: |
| eElement = XML_SUBJECT; |
| break; |
| case FIELD_ID_DOCINFO_KEYWORDS: |
| eElement = XML_KEYWORDS; |
| break; |
| case FIELD_ID_DOCINFO_REVISION: |
| eElement = XML_EDITING_CYCLES; |
| break; |
| case FIELD_ID_DOCINFO_EDIT_DURATION: |
| eElement = XML_EDITING_DURATION; |
| break; |
| case FIELD_ID_DOCINFO_SAVE_TIME: |
| eElement = XML_MODIFICATION_TIME; |
| break; |
| case FIELD_ID_DOCINFO_SAVE_DATE: |
| eElement = XML_MODIFICATION_DATE; |
| break; |
| case FIELD_ID_DOCINFO_SAVE_AUTHOR: |
| eElement = XML_CREATOR; |
| break; |
| default: |
| DBG_WARNING("unknown docinfo field type!"); |
| eElement = XML_TOKEN_INVALID; |
| break; |
| } |
| |
| return eElement; |
| } |
| |
| enum XMLTokenEnum XMLTextFieldExport::MapBibliographyFieldName(OUString sName) |
| { |
| enum XMLTokenEnum eName = XML_TOKEN_INVALID; |
| |
| if (sName.equalsAsciiL("Identifier", sizeof("Identifier")-1)) |
| { |
| eName = XML_IDENTIFIER; |
| } |
| else if (sName.equalsAsciiL("BibiliographicType", |
| sizeof("BibiliographicType")-1)) |
| { |
| eName = XML_BIBLIOGRAPHY_TYPE; |
| } |
| else if (sName.equalsAsciiL("Address", sizeof("Address")-1)) |
| { |
| eName = XML_ADDRESS; |
| } |
| else if (sName.equalsAsciiL("Annote", sizeof("Annote")-1)) |
| { |
| eName = XML_ANNOTE; |
| } |
| else if (sName.equalsAsciiL("Author", sizeof("Author")-1)) |
| { |
| eName = XML_AUTHOR; |
| } |
| else if (sName.equalsAsciiL("Booktitle", sizeof("Booktitle")-1)) |
| { |
| eName = XML_BOOKTITLE; |
| } |
| else if (sName.equalsAsciiL("Chapter", sizeof("Chapter")-1)) |
| { |
| eName = XML_CHAPTER; |
| } |
| else if (sName.equalsAsciiL("Edition", sizeof("Edition")-1)) |
| { |
| eName = XML_EDITION; |
| } |
| else if (sName.equalsAsciiL("Editor", sizeof("Editor")-1)) |
| { |
| eName = XML_EDITOR; |
| } |
| else if (sName.equalsAsciiL("Howpublished", sizeof("Howpublished")-1)) |
| { |
| eName = XML_HOWPUBLISHED; |
| } |
| else if (sName.equalsAsciiL("Institution", sizeof("Institution")-1)) |
| { |
| eName = XML_INSTITUTION; |
| } |
| else if (sName.equalsAsciiL("Journal", sizeof("Journal")-1)) |
| { |
| eName = XML_JOURNAL; |
| } |
| else if (sName.equalsAsciiL("Month", sizeof("Month")-1)) |
| { |
| eName = XML_MONTH; |
| } |
| else if (sName.equalsAsciiL("Note", sizeof("Note")-1)) |
| { |
| eName = XML_NOTE; |
| } |
| else if (sName.equalsAsciiL("Number", sizeof("Number")-1)) |
| { |
| eName = XML_NUMBER; |
| } |
| else if (sName.equalsAsciiL("Organizations", sizeof("Organizations")-1)) |
| { |
| eName = XML_ORGANIZATIONS; |
| } |
| else if (sName.equalsAsciiL("Pages", sizeof("Pages")-1)) |
| { |
| eName = XML_PAGES; |
| } |
| else if (sName.equalsAsciiL("Publisher", sizeof("Publisher")-1)) |
| { |
| eName = XML_PUBLISHER; |
| } |
| else if (sName.equalsAsciiL("School", sizeof("School")-1)) |
| { |
| eName = XML_SCHOOL; |
| } |
| else if (sName.equalsAsciiL("Series", sizeof("Series")-1)) |
| { |
| eName = XML_SERIES; |
| } |
| else if (sName.equalsAsciiL("Title", sizeof("Title")-1)) |
| { |
| eName = XML_TITLE; |
| } |
| else if (sName.equalsAsciiL("Report_Type", sizeof("Report_Type")-1)) |
| { |
| eName = XML_REPORT_TYPE; |
| } |
| else if (sName.equalsAsciiL("Volume", sizeof("Volume")-1)) |
| { |
| eName = XML_VOLUME; |
| } |
| else if (sName.equalsAsciiL("Year", sizeof("Year")-1)) |
| { |
| eName = XML_YEAR; |
| } |
| else if (sName.equalsAsciiL("URL", sizeof("URL")-1)) |
| { |
| eName = XML_URL; |
| } |
| else if (sName.equalsAsciiL("Custom1", sizeof("Custom1")-1)) |
| { |
| eName = XML_CUSTOM1; |
| } |
| else if (sName.equalsAsciiL("Custom2", sizeof("Custom2")-1)) |
| { |
| eName = XML_CUSTOM2; |
| } |
| else if (sName.equalsAsciiL("Custom3", sizeof("Custom3")-1)) |
| { |
| eName = XML_CUSTOM3; |
| } |
| else if (sName.equalsAsciiL("Custom4", sizeof("Custom4")-1)) |
| { |
| eName = XML_CUSTOM4; |
| } |
| else if (sName.equalsAsciiL("Custom5", sizeof("Custom5")-1)) |
| { |
| eName = XML_CUSTOM5; |
| } |
| else if (sName.equalsAsciiL("ISBN", sizeof("ISBN")-1)) |
| { |
| eName = XML_ISBN; |
| } |
| else |
| { |
| DBG_ERROR("Unknown bibliography info data"); |
| eName = XML_TOKEN_INVALID; |
| } |
| |
| return eName; |
| } |
| |
| enum XMLTokenEnum XMLTextFieldExport::MapMeasureKind(sal_Int16 nKind) |
| { |
| switch( nKind ) |
| { |
| case 0: |
| return XML_VALUE; |
| case 1: |
| return XML_UNIT; |
| } |
| return XML_GAP; |
| } |
| |
| OUString XMLTextFieldExport::MakeFootnoteRefName( |
| sal_Int16 nSeqNo) |
| { |
| // generate foot-/endnote ID |
| OUStringBuffer aBuf; |
| aBuf.appendAscii("ftn"); |
| aBuf.append((sal_Int32)nSeqNo); |
| return aBuf.makeStringAndClear(); |
| } |
| |
| OUString XMLTextFieldExport::MakeSequenceRefName( |
| sal_Int16 nSeqNo, |
| const OUString& rSeqName) |
| { |
| // generate foot-/endnote ID |
| OUStringBuffer aBuf; |
| aBuf.appendAscii("ref"); |
| aBuf.append(rSeqName); |
| aBuf.append((sal_Int32)nSeqNo); |
| return aBuf.makeStringAndClear(); |
| } |
| |
| // |
| // Property accessor helper functions |
| // |
| |
| // to be relegated (does that word exist?) to a more appropriate place |
| // |
| |
| |
| inline sal_Bool GetBoolProperty( |
| const OUString& sPropName, |
| const Reference<XPropertySet> & xPropSet) |
| { |
| Any aAny = xPropSet->getPropertyValue(sPropName); |
| sal_Bool bBool = *(sal_Bool *)aAny.getValue(); |
| return bBool; |
| } |
| |
| inline sal_Bool GetOptionalBoolProperty( |
| const OUString& sPropName, |
| const Reference<XPropertySet> & xPropSet, |
| const Reference<XPropertySetInfo> & xPropSetInfo, |
| sal_Bool bDefault) |
| { |
| return xPropSetInfo->hasPropertyByName( sPropName ) |
| ? GetBoolProperty( sPropName, xPropSet ) : bDefault; |
| } |
| |
| inline double GetDoubleProperty( |
| const OUString& sPropName, |
| const Reference<XPropertySet> & xPropSet) |
| { |
| Any aAny = xPropSet->getPropertyValue(sPropName); |
| double fDouble = 0.0; |
| aAny >>= fDouble; |
| return fDouble; |
| } |
| |
| inline OUString const GetStringProperty( |
| const OUString& sPropName, |
| const Reference<XPropertySet> & xPropSet) |
| { |
| Any aAny = xPropSet->getPropertyValue(sPropName); |
| OUString sString; |
| aAny >>= sString; |
| return sString; |
| } |
| |
| inline sal_Int32 GetIntProperty( |
| const OUString& sPropName, |
| const Reference<XPropertySet> & xPropSet) |
| { |
| Any aAny = xPropSet->getPropertyValue(sPropName); |
| sal_Int32 nInt = 0; |
| aAny >>= nInt; |
| return nInt; |
| } |
| |
| inline sal_Int16 GetInt16Property( |
| const OUString& sPropName, |
| const Reference<XPropertySet> & xPropSet) |
| { |
| Any aAny = xPropSet->getPropertyValue(sPropName); |
| sal_Int16 nInt = 0; |
| aAny >>= nInt; |
| return nInt; |
| } |
| |
| inline sal_Int8 GetInt8Property( |
| const OUString& sPropName, |
| const Reference<XPropertySet> & xPropSet) |
| { |
| Any aAny = xPropSet->getPropertyValue(sPropName); |
| sal_Int8 nInt = 0; |
| aAny >>= nInt; |
| return nInt; |
| } |
| |
| inline DateTime const GetDateTimeProperty( |
| const OUString& sPropName, |
| const Reference<XPropertySet> & xPropSet) |
| { |
| Any aAny = xPropSet->getPropertyValue(sPropName); |
| DateTime aTime; |
| aAny >>= aTime; |
| return aTime; |
| } |
| |
| inline Date const GetDateProperty( |
| const OUString& sPropName, |
| const Reference<XPropertySet> & xPropSet) |
| { |
| Any aAny = xPropSet->getPropertyValue(sPropName); |
| Date aDate; |
| aAny >>= aDate; |
| return aDate; |
| } |
| |
| inline Sequence<OUString> const GetStringSequenceProperty( |
| const OUString& sPropName, |
| const Reference<XPropertySet> & xPropSet) |
| { |
| Any aAny = xPropSet->getPropertyValue(sPropName); |
| Sequence<OUString> aSequence; |
| aAny >>= aSequence; |
| return aSequence; |
| } |