/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* 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 .
*/
#include "XMLTextMarkImportContext.hxx"
#include <rtl/ustring.hxx>
#include <sal/log.hxx>
#include <osl/diagnose.h>
#include <sax/tools/converter.hxx>
#include <xmloff/xmluconv.hxx>
#include <xmloff/xmltoken.hxx>
#include <xmloff/xmlimp.hxx>
#include <xmloff/xmlnamespace.hxx>
#include <xmloff/odffields.hxx>
#include <xmloff/xmlement.hxx>
#include <com/sun/star/frame/XModel.hpp>
#include <com/sun/star/text/ControlCharacter.hpp>
#include <com/sun/star/text/XTextContent.hpp>
#include <com/sun/star/text/XTextRangeCompare.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 <comphelper/diagnose_ex.hxx>
#include <RDFaImportHelper.hxx>
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 ) :
SvXMLImportContext(rImport),
rHelper(rHlp)
{
}
void XMLFieldParamImportContext::startFastElement(sal_Int32 /*nElement*/, const css::uno::Reference< css::xml::sax::XFastAttributeList> & xAttrList)
{
OUString sName;
OUString sValue;
for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
{
switch (aIter.getToken())
{
case XML_ELEMENT(FIELD, XML_NAME):
sName = aIter.toString();
break;
case XML_ELEMENT(FIELD, XML_VALUE):
sValue = aIter.toString();
break;
default:
XMLOFF_WARN_UNKNOWN("xmloff", aIter);
}
}
if (rHelper.hasCurrentFieldCtx() && !sName.isEmpty()) {
rHelper.addFieldParam(sName, sValue);
}
}
XMLTextMarkImportContext::XMLTextMarkImportContext(
SvXMLImport& rImport,
XMLTextImportHelper& rHlp,
uno::Reference<uno::XInterface> & io_rxCrossRefHeadingBookmark )
: SvXMLImportContext(rImport)
, m_rHelper(rHlp)
, m_rxCrossRefHeadingBookmark(io_rxCrossRefHeadingBookmark)
, m_isHidden(false)
, m_bHaveAbout(false)
{
}
namespace {
enum lcl_MarkType { TypeReference, TypeReferenceStart, TypeReferenceEnd,
TypeBookmark, TypeBookmarkStart, TypeBookmarkEnd,
TypeFieldmark, TypeFieldmarkStart, TypeFieldmarkSeparator, TypeFieldmarkEnd
};
}
SvXMLEnumMapEntry<lcl_MarkType> const 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_SEPARATOR, TypeFieldmarkSeparator },
{ XML_FIELDMARK_END, TypeFieldmarkEnd },
{ XML_TOKEN_INVALID, lcl_MarkType(0) },
};
static const OUString & lcl_getFormFieldmarkName(std::u16string_view name)
{
if (name == ODF_FORMCHECKBOX ||
name == u"msoffice.field.FORMCHECKBOX" ||
name == u"ecma.office-open-xml.field.FORMCHECKBOX")
return ODF_FORMCHECKBOX;
else if (name == ODF_FORMDROPDOWN ||
name == u"ecma.office-open-xml.field.FORMDROPDOWN")
return ODF_FORMDROPDOWN;
else
return EMPTY_OUSTRING;
}
static OUString lcl_getFieldmarkName(OUString const& name)
{
if (name == "msoffice.field.FORMTEXT" ||
name == "ecma.office-open-xml.field.FORMTEXT")
return ODF_FORMTEXT;
else
return name;
}
void XMLTextMarkImportContext::startFastElement( sal_Int32 nElement,
const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
{
if (!FindName(xAttrList))
{
m_sBookmarkName.clear();
}
if ((nElement & TOKEN_MASK) == XML_FIELDMARK_START ||
(nElement & TOKEN_MASK) == XML_FIELDMARK)
{
if (m_sBookmarkName.isEmpty())
{
m_sBookmarkName = "Unknown";
}
m_rHelper.pushFieldCtx( m_sBookmarkName, m_sFieldName );
}
if ((nElement & TOKEN_MASK) == XML_BOOKMARK_START)
{
m_rHelper.setBookmarkAttributes(m_sBookmarkName, m_isHidden, m_sCondition);
}
}
static auto InsertFieldmark(SvXMLImport & rImport,
XMLTextImportHelper & rHelper, bool const isFieldmarkSeparatorMissing) -> void
{
assert(rHelper.hasCurrentFieldCtx()); // was set up in StartElement()
// fdo#86795 check if it's actually a checkbox first
auto const [ name, type ] = rHelper.getCurrentFieldType();
OUString const fieldmarkTypeName = lcl_getFieldmarkName(type);
if (fieldmarkTypeName == ODF_FORMCHECKBOX ||
fieldmarkTypeName == ODF_FORMDROPDOWN)
{ // sw can't handle checkbox with start+end
SAL_INFO("xmloff.text", "invalid fieldmark-start/fieldmark-end ignored");
return;
}
uno::Reference<text::XTextRange> const xStartRange(rHelper.getCurrentFieldStart());
uno::Reference<text::XTextCursor> const xCursor(
rHelper.GetText()->createTextCursorByRange(xStartRange));
uno::Reference<text::XTextRangeCompare> const xCompare(rHelper.GetText(), uno::UNO_QUERY);
if (xCompare->compareRegionStarts(xStartRange, rHelper.GetCursorAsRange()) < 0)
{
SAL_WARN("xmloff.text", "invalid field mark positions");
assert(false);
}
xCursor->gotoRange(rHelper.GetCursorAsRange(), true);
Reference<XTextContent> const xContent = XMLTextMarkImportContext::CreateAndInsertMark(
rImport, u"com.sun.star.text.Fieldmark"_ustr, name, xCursor,
OUString(), isFieldmarkSeparatorMissing);
if (!xContent.is())
return;
// setup fieldmark...
Reference<text::XFormField> const xFormField(xContent, UNO_QUERY);
assert(xFormField.is());
try {
xFormField->setFieldType(fieldmarkTypeName);
} catch (uno::RuntimeException const&) {
// tdf#140437 somehow old documents had the field code in the type
// attribute instead of field:param
SAL_INFO("xmloff.text", "invalid fieldmark type, converting to param");
// add without checking: FieldParamImporter::Import() catches ElementExistException
rHelper.addFieldParam(ODF_CODE_PARAM, fieldmarkTypeName);
xFormField->setFieldType(ODF_UNHANDLED);
}
rHelper.setCurrentFieldParamsTo(xFormField);
// move cursor after setFieldType as that may delete/re-insert
rHelper.GetCursor()->gotoRange(xContent->getAnchor()->getEnd(), false);
rHelper.GetCursor()->goLeft(1, false); // move before CH_TXT_ATR_FIELDEND
// tdf#129520: AppendTextNode() ignores the content index!
// plan B: insert a spurious paragraph break now and join
// it in PopFieldmark()!
rHelper.GetText()->insertControlCharacter(rHelper.GetCursor(),
text::ControlCharacter::PARAGRAPH_BREAK, false);
rHelper.GetCursor()->goLeft(1, false); // back to previous paragraph
}
static auto PopFieldmark(XMLTextImportHelper & rHelper) -> void
{
// can't verify name because it's not written as an attribute...
uno::Reference<text::XTextContent> const xField(rHelper.popFieldCtx(),
uno::UNO_QUERY);
if (!xField.is())
return;
if (rHelper.GetText() == xField->getAnchor()->getText())
{
try
{ // skip CH_TXT_ATR_FIELDEND
rHelper.GetCursor()->goRight(1, true);
rHelper.GetCursor()->setString(OUString()); // undo AppendTextNode from InsertFieldmark
rHelper.GetCursor()->gotoRange(xField->getAnchor()->getEnd(), false);
}
catch (uno::Exception const&)
{
assert(false); // must succeed
}
}
else
{
SAL_INFO("xmloff.text", "fieldmark has invalid positions");
// could either dispose it or leave it to end at the end of the document?
xField->dispose();
}
}
void XMLTextMarkImportContext::endFastElement(sal_Int32 nElement)
{
static constexpr OUString sAPI_bookmark = u"com.sun.star.text.Bookmark"_ustr;
lcl_MarkType nTmp{};
if (!SvXMLUnitConverter::convertEnum(nTmp, SvXMLImport::getNameFromToken(nElement), lcl_aMarkTypeMap))
return;
if (m_sBookmarkName.isEmpty() && TypeFieldmarkEnd != nTmp && TypeFieldmarkSeparator != nTmp)
return;
switch (nTmp)
{
case TypeReference:
// export point reference mark
CreateAndInsertMark(GetImport(),
u"com.sun.star.text.ReferenceMark"_ustr,
m_sBookmarkName,
m_rHelper.GetCursorAsRange()->getStart());
break;
case TypeBookmark:
{
// tdf#94804: detect duplicate heading cross reference bookmarks
if (m_sBookmarkName.startsWith("__RefHeading__"))
{
if (m_rxCrossRefHeadingBookmark.is())
{
uno::Reference<container::XNamed> const xNamed(
m_rxCrossRefHeadingBookmark, uno::UNO_QUERY);
m_rHelper.AddCrossRefHeadingMapping(
m_sBookmarkName, xNamed->getName());
break; // don't insert
}
}
}
[[fallthrough]];
case TypeFieldmark:
{
const OUString formFieldmarkName=lcl_getFormFieldmarkName(m_sFieldName);
bool bImportAsField = (nTmp==TypeFieldmark && !formFieldmarkName.isEmpty()); //@TODO handle abbreviation cases...
// export point bookmark
const Reference<XInterface> xContent(
CreateAndInsertMark(GetImport(),
(bImportAsField ? u"com.sun.star.text.FormFieldmark"_ustr : sAPI_bookmark),
m_sBookmarkName,
m_rHelper.GetCursorAsRange()->getStart(),
m_sXmlId) );
if (nTmp==TypeFieldmark) {
if (xContent.is() && bImportAsField) {
// setup fieldmark...
Reference< css::text::XFormField> xFormField(xContent, UNO_QUERY);
xFormField->setFieldType(formFieldmarkName);
if (xFormField.is() && m_rHelper.hasCurrentFieldCtx()) {
m_rHelper.setCurrentFieldParamsTo(xFormField);
}
}
m_rHelper.popFieldCtx();
}
if (TypeBookmark == nTmp
&& m_sBookmarkName.startsWith("__RefHeading__"))
{
assert(xContent.is());
m_rxCrossRefHeadingBookmark = xContent;
}
}
break;
case TypeBookmarkStart:
// save XTextRange for later construction of bookmark
{
std::shared_ptr< ::xmloff::ParsedRDFaAttributes >
xRDFaAttributes;
if (m_bHaveAbout && TypeBookmarkStart == nTmp)
{
xRDFaAttributes =
GetImport().GetRDFaImportHelper().ParseRDFa(
m_sAbout, m_sProperty,
m_sContent, m_sDatatype);
}
m_rHelper.InsertBookmarkStartRange(
m_sBookmarkName,
m_rHelper.GetCursorAsRange()->getStart(),
m_sXmlId, xRDFaAttributes);
}
break;
case TypeBookmarkEnd:
{
// tdf#94804: detect duplicate heading cross reference bookmarks
if (m_sBookmarkName.startsWith("__RefHeading__"))
{
if (m_rxCrossRefHeadingBookmark.is())
{
uno::Reference<container::XNamed> const xNamed(
m_rxCrossRefHeadingBookmark, uno::UNO_QUERY);
m_rHelper.AddCrossRefHeadingMapping(
m_sBookmarkName, xNamed->getName());
break; // don't insert
}
}
// get old range, and construct
Reference<XTextRange> xStartRange;
std::shared_ptr< ::xmloff::ParsedRDFaAttributes >
xRDFaAttributes;
if (m_rHelper.FindAndRemoveBookmarkStartRange(
m_sBookmarkName, xStartRange,
m_sXmlId, xRDFaAttributes))
{
Reference<XTextRange> xEndRange(
m_rHelper.GetCursorAsRange()->getStart());
// check if beginning and end are in same XText
if (xStartRange.is() && xEndRange.is() && xStartRange->getText() == xEndRange->getText())
{
// create range for insertion
Reference<XTextCursor> xInsertionCursor =
m_rHelper.GetText()->createTextCursorByRange(
xEndRange);
try {
xInsertionCursor->gotoRange(xStartRange, true);
} catch (uno::Exception&) {
TOOLS_WARN_EXCEPTION("xmloff.text",
"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<XInterface> xContent;
// insert reference
xContent = CreateAndInsertMark(GetImport(),
sAPI_bookmark,
m_sBookmarkName,
xInsertionCursor,
m_sXmlId);
if (xRDFaAttributes)
{
const Reference<rdf::XMetadatable>
xMeta(xContent, UNO_QUERY);
GetImport().GetRDFaImportHelper().AddRDFa(
xMeta, xRDFaAttributes);
}
const Reference<XPropertySet> xPropertySet(xContent, UNO_QUERY);
if (xPropertySet.is())
{
xPropertySet->setPropertyValue(u"BookmarkHidden"_ustr, uno::Any(m_rHelper.getBookmarkHidden(m_sBookmarkName)));
xPropertySet->setPropertyValue(u"BookmarkCondition"_ustr, uno::Any(m_rHelper.getBookmarkCondition(m_sBookmarkName)));
}
if (m_sBookmarkName.startsWith("__RefHeading__"))
{
assert(xContent.is());
m_rxCrossRefHeadingBookmark = std::move(xContent);
}
}
// else: beginning/end in different XText -> ignore!
}
// else: no start found -> ignore!
break;
}
case TypeFieldmarkStart:
{
break;
}
case TypeFieldmarkSeparator:
{
InsertFieldmark(GetImport(), m_rHelper, false);
break;
}
case TypeFieldmarkEnd:
{
if (m_rHelper.hasCurrentFieldCtx() && !m_rHelper.hasCurrentFieldSeparator())
{ // backward compat for old files without separator
InsertFieldmark(GetImport(), m_rHelper, true);
}
PopFieldmark(m_rHelper);
break;
}
case TypeReferenceStart:
case TypeReferenceEnd:
OSL_FAIL("reference start/end are handled in txtparai !");
break;
default:
OSL_FAIL("unknown mark type");
break;
}
}
css::uno::Reference< css::xml::sax::XFastContextHandler > XMLTextMarkImportContext::createFastChildContext(
sal_Int32 ,
const css::uno::Reference< css::xml::sax::XFastAttributeList >& )
{
return new XMLFieldParamImportContext(GetImport(), m_rHelper);
}
Reference<XTextContent> XMLTextMarkImportContext::CreateAndInsertMark(
SvXMLImport& rImport,
const OUString& sServiceName,
const OUString& sMarkName,
const Reference<XTextRange> & rRange,
const OUString& i_rXmlId,
bool const isFieldmarkSeparatorMissing)
{
// create mark
const Reference<XMultiServiceFactory> xFactory(rImport.GetModel(),
UNO_QUERY);
Reference<XInterface> xIfc;
if (xFactory.is())
{
xIfc = xFactory->createInstance(sServiceName);
if (!xIfc.is())
{
OSL_FAIL("CreateAndInsertMark: cannot create service?");
return nullptr;
}
// 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.isEmpty())
{
OSL_FAIL("name given, but XNamed not supported?");
return nullptr;
}
}
if (isFieldmarkSeparatorMissing)
{
uno::Reference<beans::XPropertySet> const xProps(xIfc, uno::UNO_QUERY_THROW);
xProps->setPropertyValue(u"PrivateSeparatorAtStart"_ustr, uno::Any(true));
}
// 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, true);
// xml:id for RDF metadata -- after insertion!
rImport.SetXmlId(xIfc, i_rXmlId);
return xTextContent;
}
catch (css::lang::IllegalArgumentException &)
{
OSL_FAIL("CreateAndInsertMark: cannot insert?");
return nullptr;
}
}
}
return nullptr;
}
bool XMLTextMarkImportContext::FindName(
const Reference<XFastAttributeList> & xAttrList)
{
bool bNameOK = false;
// find name attribute first
for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
{
OUString sValue = aIter.toString();
switch(aIter.getToken())
{
case XML_ELEMENT(TEXT, XML_NAME):
m_sBookmarkName = sValue;
bNameOK = true;
break;
case XML_ELEMENT(XML, XML_ID):
m_sXmlId = sValue;
break;
// RDFa
case XML_ELEMENT(XHTML, XML_ABOUT):
m_sAbout = sValue;
m_bHaveAbout = true;
break;
case XML_ELEMENT(XHTML, XML_PROPERTY):
m_sProperty = sValue;
break;
case XML_ELEMENT(XHTML, XML_CONTENT):
m_sContent = sValue;
break;
case XML_ELEMENT(XHTML, XML_DATATYPE):
m_sDatatype = sValue;
break;
case XML_ELEMENT(FIELD, XML_TYPE):
m_sFieldName = sValue;
break;
case XML_ELEMENT(LO_EXT, XML_HIDDEN):
::sax::Converter::convertBool(m_isHidden, sValue);
break;
case XML_ELEMENT(LO_EXT, XML_CONDITION):
m_sCondition = sValue;
break;
default:
XMLOFF_WARN_UNKNOWN("xmloff", aIter);
}
}
return bNameOK;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V560 A part of conditional expression is always true: TypeBookmarkStart == nTmp.