9a608faf3c
Change-Id: I4837cb60c2c78b5a9008b6ffbb6323da50c7c705 Reviewed-on: https://gerrit.libreoffice.org/c/core/+/176111 Tested-by: Jenkins Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
583 lines
21 KiB
C++
583 lines
21 KiB
C++
/* -*- 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: */
|