| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_xmloff.hxx" | |
| #include "XMLTextMarkImportContext.hxx" | |
| #include <rtl/ustring.hxx> | |
| #include <tools/debug.hxx> | |
| #include <xmloff/xmluconv.hxx> | |
| #include <xmloff/xmltoken.hxx> | |
| #include <xmloff/xmlimp.hxx> | |
| #include <xmloff/nmspmap.hxx> | |
| #include "xmloff/xmlnmspe.hxx" | |
| #include <xmloff/odffields.hxx> | |
| #include <com/sun/star/xml/sax/XAttributeList.hpp> | |
| #include <com/sun/star/text/XTextContent.hpp> | |
| #include <com/sun/star/beans/XPropertySet.hpp> | |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> | |
| #include <com/sun/star/container/XNamed.hpp> | |
| #include <com/sun/star/rdf/XMetadatable.hpp> | |
| #include <com/sun/star/text/XFormField.hpp> | |
| #include "RDFaImportHelper.hxx" | |
| using ::rtl::OUString; | |
| using ::rtl::OUStringBuffer; | |
| using namespace ::com::sun::star; | |
| using namespace ::com::sun::star::text; | |
| using namespace ::com::sun::star::uno; | |
| using namespace ::com::sun::star::beans; | |
| using namespace ::com::sun::star::lang; | |
| using namespace ::com::sun::star::container; | |
| using namespace ::com::sun::star::xml::sax; | |
| using namespace ::xmloff::token; | |
| XMLFieldParamImportContext::XMLFieldParamImportContext( | |
| SvXMLImport& rImport, | |
| XMLTextImportHelper& rHlp, | |
| sal_uInt16 nPrefix, | |
| const OUString& rLocalName ) : | |
| SvXMLImportContext(rImport, nPrefix, rLocalName), | |
| rHelper(rHlp) | |
| { | |
| } | |
| void XMLFieldParamImportContext::StartElement(const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList> & xAttrList) | |
| { | |
| SvXMLImport& rImport = GetImport(); | |
| ::rtl::OUString sName; | |
| ::rtl::OUString sValue; | |
| sal_Int16 nLength = xAttrList->getLength(); | |
| for(sal_Int16 nAttr = 0; nAttr < nLength; nAttr++) | |
| { | |
| OUString sLocalName; | |
| sal_uInt16 nPrefix = rImport.GetNamespaceMap(). | |
| GetKeyByAttrName( xAttrList->getNameByIndex(nAttr), | |
| &sLocalName ); | |
| if ( (XML_NAMESPACE_FIELD == nPrefix) && | |
| IsXMLToken(sLocalName, XML_NAME) ) | |
| { | |
| sName = xAttrList->getValueByIndex(nAttr); | |
| } | |
| if ( (XML_NAMESPACE_FIELD == nPrefix) && | |
| IsXMLToken(sLocalName, XML_VALUE) ) | |
| { | |
| sValue = xAttrList->getValueByIndex(nAttr); | |
| } | |
| } | |
| if (rHelper.hasCurrentFieldCtx() && sName.getLength()>0) { | |
| rHelper.addFieldParam(sName, sValue); | |
| } | |
| } | |
| TYPEINIT1( XMLTextMarkImportContext, SvXMLImportContext); | |
| XMLTextMarkImportContext::XMLTextMarkImportContext( | |
| SvXMLImport& rImport, | |
| XMLTextImportHelper& rHlp, | |
| sal_uInt16 nPrefix, | |
| const OUString& rLocalName ) | |
| : SvXMLImportContext(rImport, nPrefix, rLocalName) | |
| , m_rHelper(rHlp) | |
| , m_bHaveAbout(false) | |
| { | |
| } | |
| enum lcl_MarkType { TypeReference, TypeReferenceStart, TypeReferenceEnd, | |
| TypeBookmark, TypeBookmarkStart, TypeBookmarkEnd, | |
| TypeFieldmark, TypeFieldmarkStart, TypeFieldmarkEnd | |
| }; | |
| static SvXMLEnumMapEntry __READONLY_DATA lcl_aMarkTypeMap[] = | |
| { | |
| { XML_REFERENCE_MARK, TypeReference }, | |
| { XML_REFERENCE_MARK_START, TypeReferenceStart }, | |
| { XML_REFERENCE_MARK_END, TypeReferenceEnd }, | |
| { XML_BOOKMARK, TypeBookmark }, | |
| { XML_BOOKMARK_START, TypeBookmarkStart }, | |
| { XML_BOOKMARK_END, TypeBookmarkEnd }, | |
| { XML_FIELDMARK, TypeFieldmark }, | |
| { XML_FIELDMARK_START, TypeFieldmarkStart }, | |
| { XML_FIELDMARK_END, TypeFieldmarkEnd }, | |
| { XML_TOKEN_INVALID, 0 }, | |
| }; | |
| static const char *lcl_getFormFieldmarkName(rtl::OUString &name) | |
| { | |
| static const char sCheckbox[]=ODF_FORMCHECKBOX; | |
| static const char sFormDropDown[]=ODF_FORMDROPDOWN; | |
| if (name.compareToAscii("msoffice.field.FORMCHECKBOX")==0) | |
| return sCheckbox; | |
| else if (name.compareToAscii(ODF_FORMCHECKBOX)==0) | |
| return sCheckbox; | |
| if (name.compareToAscii(ODF_FORMDROPDOWN)==0) | |
| return sFormDropDown; | |
| else | |
| return NULL; | |
| } | |
| static rtl::OUString lcl_getFieldmarkName(rtl::OUString &name) | |
| { | |
| static const char sFormtext[]=ODF_FORMTEXT; | |
| if (name.compareToAscii("msoffice.field.FORMTEXT")==0) | |
| return rtl::OUString::createFromAscii(sFormtext); | |
| else if (name.compareToAscii(ODF_FORMTEXT)==0) | |
| return rtl::OUString::createFromAscii(sFormtext); | |
| else | |
| return name; | |
| } | |
| void XMLTextMarkImportContext::StartElement( | |
| const Reference<XAttributeList> & xAttrList) | |
| { | |
| if (!FindName(GetImport(), xAttrList)) | |
| { | |
| m_sBookmarkName = OUString(); | |
| } | |
| if (IsXMLToken(GetLocalName(), XML_FIELDMARK_END)) | |
| { | |
| m_sBookmarkName = m_rHelper.FindActiveBookmarkName(); | |
| } | |
| if (IsXMLToken(GetLocalName(), XML_FIELDMARK_START) || IsXMLToken(GetLocalName(), XML_FIELDMARK)) | |
| { | |
| if (m_sBookmarkName.getLength() == 0) | |
| { | |
| m_sBookmarkName = ::rtl::OUString::createFromAscii("Unknown"); | |
| } | |
| m_rHelper.pushFieldCtx( m_sBookmarkName, m_sFieldName ); | |
| } | |
| } | |
| void XMLTextMarkImportContext::EndElement() | |
| { | |
| SvXMLImportContext::EndElement(); | |
| static const OUString sAPI_reference_mark( | |
| RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.ReferenceMark")); | |
| static const OUString sAPI_bookmark( | |
| RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.Bookmark")); | |
| static const OUString sAPI_fieldmark( | |
| RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.Fieldmark")); | |
| static const OUString sAPI_formfieldmark( | |
| RTL_CONSTASCII_USTRINGPARAM("com.sun.star.text.FormFieldmark")); | |
| if (m_sBookmarkName.getLength() > 0) | |
| { | |
| sal_uInt16 nTmp; | |
| if (SvXMLUnitConverter::convertEnum(nTmp, GetLocalName(), | |
| lcl_aMarkTypeMap)) | |
| { | |
| switch ((lcl_MarkType)nTmp) | |
| { | |
| case TypeReference: | |
| // export point reference mark | |
| CreateAndInsertMark(GetImport(), | |
| sAPI_reference_mark, | |
| m_sBookmarkName, | |
| m_rHelper.GetCursorAsRange()->getStart(), | |
| ::rtl::OUString()); | |
| break; | |
| case TypeFieldmark: | |
| case TypeBookmark: | |
| { | |
| const char *formFieldmarkName=lcl_getFormFieldmarkName(m_sFieldName); | |
| bool bImportAsField=((lcl_MarkType)nTmp==TypeFieldmark && formFieldmarkName!=NULL); //@TODO handle abbreviation cases.. | |
| // export point bookmark | |
| const Reference<XInterface> xContent( | |
| CreateAndInsertMark(GetImport(), | |
| (bImportAsField?sAPI_formfieldmark:sAPI_bookmark), | |
| m_sBookmarkName, | |
| m_rHelper.GetCursorAsRange()->getStart(), | |
| m_sXmlId) ); | |
| if ((lcl_MarkType)nTmp==TypeFieldmark) { | |
| if (xContent.is() && bImportAsField) { | |
| // setup fieldmark... | |
| Reference< ::com::sun::star::text::XFormField> xFormField(xContent, UNO_QUERY); | |
| xFormField->setFieldType(rtl::OUString::createFromAscii(formFieldmarkName)); | |
| if (xFormField.is() && m_rHelper.hasCurrentFieldCtx()) { | |
| m_rHelper.setCurrentFieldParamsTo(xFormField); | |
| } | |
| } | |
| m_rHelper.popFieldCtx(); | |
| } | |
| } | |
| break; | |
| case TypeFieldmarkStart: | |
| case TypeBookmarkStart: | |
| // save XTextRange for later construction of bookmark | |
| { | |
| ::boost::shared_ptr< ::xmloff::ParsedRDFaAttributes > | |
| pRDFaAttributes; | |
| if (m_bHaveAbout && (TypeBookmarkStart | |
| == static_cast<lcl_MarkType>(nTmp))) | |
| { | |
| pRDFaAttributes = | |
| GetImport().GetRDFaImportHelper().ParseRDFa( | |
| m_sAbout, m_sProperty, | |
| m_sContent, m_sDatatype); | |
| } | |
| m_rHelper.InsertBookmarkStartRange( | |
| m_sBookmarkName, | |
| m_rHelper.GetCursorAsRange()->getStart(), | |
| m_sXmlId, pRDFaAttributes); | |
| } | |
| break; | |
| case TypeFieldmarkEnd: | |
| case TypeBookmarkEnd: | |
| { | |
| // get old range, and construct | |
| Reference<XTextRange> xStartRange; | |
| ::boost::shared_ptr< ::xmloff::ParsedRDFaAttributes > | |
| pRDFaAttributes; | |
| if (m_rHelper.FindAndRemoveBookmarkStartRange( | |
| m_sBookmarkName, xStartRange, | |
| m_sXmlId, pRDFaAttributes)) | |
| { | |
| Reference<XTextRange> xEndRange( | |
| m_rHelper.GetCursorAsRange()->getStart()); | |
| // check if beginning and end are in same XText | |
| if (xStartRange->getText() == xEndRange->getText()) | |
| { | |
| // create range for insertion | |
| Reference<XTextCursor> xInsertionCursor = | |
| m_rHelper.GetText()->createTextCursorByRange( | |
| xEndRange); | |
| try { | |
| xInsertionCursor->gotoRange(xStartRange, sal_True); | |
| } catch (uno::Exception&) { | |
| OSL_ENSURE(false, | |
| "cannot go to end position of bookmark"); | |
| } | |
| //DBG_ASSERT(! xInsertionCursor->isCollapsed(), | |
| // "we want no point mark"); | |
| // can't assert, because someone could | |
| // create a file with subsequence | |
| // start/end elements | |
| Reference<XTextRange> xInsertionRange( | |
| xInsertionCursor, UNO_QUERY); | |
| bool bImportAsField=((lcl_MarkType)nTmp==TypeFieldmarkEnd && m_rHelper.hasCurrentFieldCtx()); | |
| // insert reference | |
| const Reference<XInterface> xContent( | |
| CreateAndInsertMark(GetImport(), | |
| (bImportAsField?sAPI_fieldmark:sAPI_bookmark), | |
| m_sBookmarkName, | |
| xInsertionRange, | |
| m_sXmlId) ); | |
| if (pRDFaAttributes) | |
| { | |
| const Reference<rdf::XMetadatable> | |
| xMeta(xContent, UNO_QUERY); | |
| GetImport().GetRDFaImportHelper().AddRDFa( | |
| xMeta, pRDFaAttributes); | |
| } | |
| if ((lcl_MarkType)nTmp==TypeFieldmarkEnd) { | |
| if (xContent.is() && bImportAsField) { | |
| // setup fieldmark... | |
| Reference< ::com::sun::star::text::XFormField> xFormField(xContent, UNO_QUERY); | |
| if (xFormField.is() && m_rHelper.hasCurrentFieldCtx()) { | |
| rtl::OUString givenTypeName=m_rHelper.getCurrentFieldType(); | |
| rtl::OUString fieldmarkTypeName=lcl_getFieldmarkName(givenTypeName); | |
| xFormField->setFieldType(fieldmarkTypeName); | |
| m_rHelper.setCurrentFieldParamsTo(xFormField); | |
| } | |
| } | |
| m_rHelper.popFieldCtx(); | |
| } | |
| } | |
| // else: beginning/end in different XText -> ignore! | |
| } | |
| // else: no start found -> ignore! | |
| break; | |
| } | |
| case TypeReferenceStart: | |
| case TypeReferenceEnd: | |
| DBG_ERROR("reference start/end are handled in txtparai !"); | |
| break; | |
| default: | |
| DBG_ERROR("unknown mark type"); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| SvXMLImportContext *XMLTextMarkImportContext::CreateChildContext( sal_uInt16 nPrefix, | |
| const ::rtl::OUString& rLocalName, | |
| const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList >& ) | |
| { | |
| return new XMLFieldParamImportContext(GetImport(), m_rHelper, | |
| nPrefix, rLocalName); | |
| } | |
| Reference<XTextContent> XMLTextMarkImportContext::CreateAndInsertMark( | |
| SvXMLImport& rImport, | |
| const OUString& sServiceName, | |
| const OUString& sMarkName, | |
| const Reference<XTextRange> & rRange, | |
| const OUString& i_rXmlId) | |
| { | |
| // create mark | |
| const Reference<XMultiServiceFactory> xFactory(rImport.GetModel(), | |
| UNO_QUERY); | |
| Reference<XInterface> xIfc; | |
| if (xFactory.is()) | |
| { | |
| xIfc = xFactory->createInstance(sServiceName); | |
| if (!xIfc.is()) | |
| { | |
| OSL_ENSURE(false, "CreateAndInsertMark: cannot create service?"); | |
| return 0; | |
| } | |
| // set name (unless there is no name (text:meta)) | |
| const Reference<XNamed> xNamed(xIfc, UNO_QUERY); | |
| if (xNamed.is()) | |
| { | |
| xNamed->setName(sMarkName); | |
| } | |
| else | |
| { | |
| if (sMarkName.getLength()) | |
| { | |
| OSL_ENSURE(false, "name given, but XNamed not supported?"); | |
| return 0; | |
| } | |
| } | |
| // cast to XTextContent and attach to document | |
| const Reference<XTextContent> xTextContent(xIfc, UNO_QUERY); | |
| if (xTextContent.is()) | |
| { | |
| try | |
| { | |
| // if inserting marks, bAbsorb==sal_False will cause | |
| // collapsing of the given XTextRange. | |
| rImport.GetTextImport()->GetText()->insertTextContent(rRange, | |
| xTextContent, sal_True); | |
| // xml:id for RDF metadata -- after insertion! | |
| rImport.SetXmlId(xIfc, i_rXmlId); | |
| return xTextContent; | |
| } | |
| catch (com::sun::star::lang::IllegalArgumentException &) | |
| { | |
| OSL_ENSURE(false, "CreateAndInsertMark: cannot insert?"); | |
| return 0; | |
| } | |
| } | |
| } | |
| return 0; | |
| } | |
| sal_Bool XMLTextMarkImportContext::FindName( | |
| SvXMLImport& rImport, | |
| const Reference<XAttributeList> & xAttrList) | |
| { | |
| sal_Bool bNameOK = sal_False; | |
| // find name attribute first | |
| const sal_Int16 nLength = xAttrList->getLength(); | |
| for(sal_Int16 nAttr = 0; nAttr < nLength; nAttr++) | |
| { | |
| OUString sLocalName; | |
| const sal_uInt16 nPrefix = rImport.GetNamespaceMap(). | |
| GetKeyByAttrName( xAttrList->getNameByIndex(nAttr), | |
| &sLocalName ); | |
| if ( (XML_NAMESPACE_TEXT == nPrefix) && | |
| IsXMLToken(sLocalName, XML_NAME) ) | |
| { | |
| m_sBookmarkName = xAttrList->getValueByIndex(nAttr); | |
| bNameOK = sal_True; | |
| } | |
| else if ( (XML_NAMESPACE_XML == nPrefix) && | |
| IsXMLToken(sLocalName, XML_ID) ) | |
| { | |
| m_sXmlId = xAttrList->getValueByIndex(nAttr); | |
| } | |
| else if ( XML_NAMESPACE_XHTML == nPrefix ) | |
| { | |
| // RDFa | |
| if ( IsXMLToken( sLocalName, XML_ABOUT) ) | |
| { | |
| m_sAbout = xAttrList->getValueByIndex(nAttr); | |
| m_bHaveAbout = true; | |
| } | |
| else if ( IsXMLToken( sLocalName, XML_PROPERTY) ) | |
| { | |
| m_sProperty = xAttrList->getValueByIndex(nAttr); | |
| } | |
| else if ( IsXMLToken( sLocalName, XML_CONTENT) ) | |
| { | |
| m_sContent = xAttrList->getValueByIndex(nAttr); | |
| } | |
| else if ( IsXMLToken( sLocalName, XML_DATATYPE) ) | |
| { | |
| m_sDatatype = xAttrList->getValueByIndex(nAttr); | |
| } | |
| } | |
| else if ( (XML_NAMESPACE_FIELD == nPrefix) && | |
| IsXMLToken(sLocalName, XML_TYPE) ) | |
| { | |
| m_sFieldName = xAttrList->getValueByIndex(nAttr); | |
| } | |
| } | |
| return bNameOK; | |
| } |