Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 479 insertions, 0 deletions

diff --git a/xmloff/source/meta/xmlmetae.cxx b/xmloff/source/meta/xmlmetae.cxx
new file mode 100644
index 000000000..994610a7f
--- /dev/null
+++ b/xmloff/source/meta/xmlmetae.cxx
@@ -0,0 +1,479 @@
+/* -*- 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 <i18nlangtag/languagetag.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <sal/log.hxx>
+
+#include <xmloff/xmlmetae.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmlnamespace.hxx>
+
+#include <com/sun/star/beans/XPropertyAccess.hpp>
+#include <com/sun/star/beans/StringPair.hpp>
+#include <com/sun/star/document/XDocumentProperties.hpp>
+#include <com/sun/star/util/DateTime.hpp>
+#include <com/sun/star/util/Duration.hpp>
+#include <com/sun/star/xml/sax/XSAXSerializable.hpp>
+
+#include <sax/tools/converter.hxx>
+
+#include <comphelper/sequence.hxx>
+#include <unotools/docinfohelper.hxx>
+
+using namespace com::sun::star;
+using namespace ::xmloff::token;
+
+static void lcl_AddTwoDigits( OUStringBuffer& rStr, sal_Int32 nVal )
+{
+    if ( nVal < 10 )
+        rStr.append( '0' );
+    rStr.append( nVal );
+}
+
+OUString
+SvXMLMetaExport::GetISODateTimeString( const util::DateTime& rDateTime )
+{
+    //  return ISO date string "YYYY-MM-DDThh:mm:ss"
+
+    OUStringBuffer sTmp;
+    sTmp.append( static_cast<sal_Int32>(rDateTime.Year) );
+    sTmp.append( '-' );
+    lcl_AddTwoDigits( sTmp, rDateTime.Month );
+    sTmp.append( '-' );
+    lcl_AddTwoDigits( sTmp, rDateTime.Day );
+    sTmp.append( 'T' );
+    lcl_AddTwoDigits( sTmp, rDateTime.Hours );
+    sTmp.append( ':' );
+    lcl_AddTwoDigits( sTmp, rDateTime.Minutes );
+    sTmp.append( ':' );
+    lcl_AddTwoDigits( sTmp, rDateTime.Seconds );
+
+    return sTmp.makeStringAndClear();
+}
+
+void SvXMLMetaExport::SimpleStringElement( const OUString& rText,
+        sal_uInt16 nNamespace, enum XMLTokenEnum eElementName )
+{
+    if ( !rText.isEmpty() ) {
+        SvXMLElementExport aElem( mrExport, nNamespace, eElementName,
+                                  true, false );
+        mrExport.Characters( rText );
+    }
+}
+
+void SvXMLMetaExport::SimpleDateTimeElement( const util::DateTime & rDate,
+        sal_uInt16 nNamespace, enum XMLTokenEnum eElementName )
+{
+    if (rDate.Month != 0) { // invalid dates are 0-0-0
+        OUString sValue = GetISODateTimeString( rDate );
+        if ( !sValue.isEmpty() ) {
+            SvXMLElementExport aElem( mrExport, nNamespace, eElementName,
+                                      true, false );
+            mrExport.Characters( sValue );
+        }
+    }
+}
+
+void SvXMLMetaExport::MExport_()
+{
+    //  generator
+    {
+        SvXMLElementExport aElem( mrExport, XML_NAMESPACE_META, XML_GENERATOR,
+                                  true, true );
+        mrExport.Characters( ::utl::DocInfoHelper::GetGeneratorString() );
+    }
+
+    //  document title
+    SimpleStringElement  ( mxDocProps->getTitle(),
+                           XML_NAMESPACE_DC, XML_TITLE );
+
+    //  description
+    SimpleStringElement  ( mxDocProps->getDescription(),
+                           XML_NAMESPACE_DC, XML_DESCRIPTION );
+
+    //  subject
+    SimpleStringElement  ( mxDocProps->getSubject(),
+                           XML_NAMESPACE_DC, XML_SUBJECT );
+
+    //  created...
+    SimpleStringElement  ( mxDocProps->getAuthor(),
+                           XML_NAMESPACE_META, XML_INITIAL_CREATOR );
+    SimpleDateTimeElement( mxDocProps->getCreationDate(),
+                           XML_NAMESPACE_META, XML_CREATION_DATE );
+
+    //  modified...
+    SimpleStringElement  ( mxDocProps->getModifiedBy(),
+                           XML_NAMESPACE_DC, XML_CREATOR );
+    SimpleDateTimeElement( mxDocProps->getModificationDate(),
+                           XML_NAMESPACE_DC, XML_DATE );
+
+    //  printed...
+    SimpleStringElement  ( mxDocProps->getPrintedBy(),
+                           XML_NAMESPACE_META, XML_PRINTED_BY );
+    SimpleDateTimeElement( mxDocProps->getPrintDate(),
+                           XML_NAMESPACE_META, XML_PRINT_DATE );
+
+    //  keywords
+    const uno::Sequence< OUString > keywords = mxDocProps->getKeywords();
+    for (const auto& rKeyword : keywords) {
+        SvXMLElementExport aKwElem( mrExport, XML_NAMESPACE_META, XML_KEYWORD,
+                                    true, false );
+        mrExport.Characters( rKeyword );
+    }
+
+    //  document language
+    {
+        OUString sValue = LanguageTag( mxDocProps->getLanguage()).getBcp47( false);
+        if (!sValue.isEmpty()) {
+            SvXMLElementExport aElem( mrExport, XML_NAMESPACE_DC, XML_LANGUAGE,
+                                      true, false );
+            mrExport.Characters( sValue );
+        }
+    }
+
+    //  editing cycles
+    {
+        SvXMLElementExport aElem( mrExport,
+                                  XML_NAMESPACE_META, XML_EDITING_CYCLES,
+                                  true, false );
+        mrExport.Characters( OUString::number(
+            mxDocProps->getEditingCycles() ) );
+    }
+
+    //  editing duration
+    //  property is a int32 (seconds)
+    {
+        sal_Int32 secs = mxDocProps->getEditingDuration();
+        SvXMLElementExport aElem( mrExport,
+                                  XML_NAMESPACE_META, XML_EDITING_DURATION,
+                                  true, false );
+        OUStringBuffer buf;
+        ::sax::Converter::convertDuration(buf, util::Duration(
+                    false, 0, 0, 0, secs/3600, (secs%3600)/60, secs%60, 0));
+        mrExport.Characters(buf.makeStringAndClear());
+    }
+
+    //  default target
+    const OUString sDefTarget = mxDocProps->getDefaultTarget();
+    if ( !sDefTarget.isEmpty() )
+    {
+        mrExport.AddAttribute( XML_NAMESPACE_OFFICE, XML_TARGET_FRAME_NAME,
+                               sDefTarget );
+
+        //! define strings for xlink:show values
+        const XMLTokenEnum eShow = sDefTarget == "_blank" ? XML_NEW : XML_REPLACE;
+        mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, eShow );
+
+        SvXMLElementExport aElem( mrExport,
+                                  XML_NAMESPACE_META,XML_HYPERLINK_BEHAVIOUR,
+                                  true, false );
+    }
+
+    //  auto-reload
+    const OUString sReloadURL = mxDocProps->getAutoloadURL();
+    const sal_Int32 sReloadDelay = mxDocProps->getAutoloadSecs();
+    if (sReloadDelay != 0 || !sReloadURL.isEmpty())
+    {
+        mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF,
+                              mrExport.GetRelativeReference( sReloadURL ) );
+
+        OUStringBuffer buf;
+        ::sax::Converter::convertDuration(buf, util::Duration(false, 0, 0, 0,
+                sReloadDelay/3600, (sReloadDelay%3600)/60, sReloadDelay%60, 0));
+        mrExport.AddAttribute( XML_NAMESPACE_META, XML_DELAY,
+            buf.makeStringAndClear());
+
+        SvXMLElementExport aElem( mrExport, XML_NAMESPACE_META, XML_AUTO_RELOAD,
+                                  true, false );
+    }
+
+    //  template
+    const OUString sTplPath = mxDocProps->getTemplateURL();
+    if ( !sTplPath.isEmpty() )
+    {
+        mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+        mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONREQUEST );
+
+        //  template URL
+        mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF,
+                              mrExport.GetRelativeReference(sTplPath) );
+
+        //  template name
+        mrExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TITLE,
+                              mxDocProps->getTemplateName() );
+
+        //  template date
+        mrExport.AddAttribute( XML_NAMESPACE_META, XML_DATE,
+                GetISODateTimeString( mxDocProps->getTemplateDate() ) );
+
+        SvXMLElementExport aElem( mrExport, XML_NAMESPACE_META, XML_TEMPLATE,
+                                  true, false );
+    }
+
+    //  user defined fields
+    uno::Reference< beans::XPropertyAccess > xUserDefined(
+        mxDocProps->getUserDefinedProperties(), uno::UNO_QUERY_THROW);
+    const uno::Sequence< beans::PropertyValue > props =
+        xUserDefined->getPropertyValues();
+    for (const auto& rProp : props) {
+        OUStringBuffer sValueBuffer;
+        OUStringBuffer sType;
+        if (!::sax::Converter::convertAny(sValueBuffer, sType, rProp.Value))
+        {
+            continue;
+        }
+        mrExport.AddAttribute( XML_NAMESPACE_META, XML_NAME, rProp.Name );
+        mrExport.AddAttribute( XML_NAMESPACE_META, XML_VALUE_TYPE,
+                              sType.makeStringAndClear() );
+        SvXMLElementExport aElem( mrExport, XML_NAMESPACE_META,
+                                  XML_USER_DEFINED, true, false );
+        mrExport.Characters( sValueBuffer.makeStringAndClear() );
+    }
+
+    const uno::Sequence< beans::NamedValue > aDocStatistic =
+            mxDocProps->getDocumentStatistics();
+    // write document statistic if there is any provided
+    if ( !aDocStatistic.hasElements() )
+        return;
+
+    for ( const auto& rDocStat : aDocStatistic )
+    {
+        sal_Int32 nValue = 0;
+        if ( rDocStat.Value >>= nValue )
+        {
+            OUString aValue = OUString::number( nValue );
+            if ( rDocStat.Name == "TableCount" )
+                mrExport.AddAttribute(
+                    XML_NAMESPACE_META, XML_TABLE_COUNT, aValue );
+            else if ( rDocStat.Name == "ObjectCount" )
+                mrExport.AddAttribute(
+                    XML_NAMESPACE_META, XML_OBJECT_COUNT, aValue );
+            else if ( rDocStat.Name == "ImageCount" )
+                mrExport.AddAttribute(
+                    XML_NAMESPACE_META, XML_IMAGE_COUNT, aValue );
+            else if ( rDocStat.Name == "PageCount" )
+                mrExport.AddAttribute(
+                    XML_NAMESPACE_META, XML_PAGE_COUNT, aValue );
+            else if ( rDocStat.Name == "ParagraphCount" )
+                mrExport.AddAttribute(
+                    XML_NAMESPACE_META, XML_PARAGRAPH_COUNT, aValue );
+            else if ( rDocStat.Name == "WordCount" )
+                mrExport.AddAttribute(
+                    XML_NAMESPACE_META, XML_WORD_COUNT, aValue );
+            else if ( rDocStat.Name == "CharacterCount" )
+                mrExport.AddAttribute(
+                    XML_NAMESPACE_META, XML_CHARACTER_COUNT, aValue );
+            else if ( rDocStat.Name == "CellCount" )
+                mrExport.AddAttribute(
+                    XML_NAMESPACE_META, XML_CELL_COUNT, aValue );
+            else
+            {
+                SAL_WARN("xmloff", "Unknown statistic value!");
+            }
+        }
+    }
+    SvXMLElementExport aElem( mrExport,
+        XML_NAMESPACE_META, XML_DOCUMENT_STATISTIC, true, true );
+}
+
+const char s_xmlns[] = "xmlns";
+const char s_xmlns2[] = "xmlns:";
+const char s_meta[] = "meta:";
+const char s_href[] = "xlink:href";
+
+SvXMLMetaExport::SvXMLMetaExport(
+        SvXMLExport& i_rExp,
+        const uno::Reference<document::XDocumentProperties>& i_rDocProps ) :
+    mrExport( i_rExp ),
+    mxDocProps( i_rDocProps ),
+    m_level( 0 )
+{
+    assert(mxDocProps.is());
+}
+
+SvXMLMetaExport::~SvXMLMetaExport()
+{
+}
+
+void SvXMLMetaExport::Export()
+{
+    uno::Reference< xml::sax::XSAXSerializable> xSAXable(mxDocProps,
+        uno::UNO_QUERY);
+    if (xSAXable.is()) {
+        ::std::vector< beans::StringPair > namespaces;
+        const SvXMLNamespaceMap & rNsMap(mrExport.GetNamespaceMap());
+        for (sal_uInt16 key = rNsMap.GetFirstKey();
+             key != USHRT_MAX; key = rNsMap.GetNextKey(key)) {
+            beans::StringPair ns;
+            const OUString attrname = rNsMap.GetAttrNameByKey(key);
+            if (!attrname.startsWith(s_xmlns2, &ns.First)
+                || attrname == s_xmlns) // default initialized empty string
+            {
+                assert(!"namespace attribute not starting with xmlns unexpected");
+            }
+            ns.Second = rNsMap.GetNameByKey(key);
+            namespaces.push_back(ns);
+        }
+        xSAXable->serialize(this, comphelper::containerToSequence(namespaces));
+    } else {
+        // office:meta
+        SvXMLElementExport aElem( mrExport, XML_NAMESPACE_OFFICE, XML_META,
+                                  true, true );
+        // fall back to using public interface of XDocumentProperties
+        MExport_();
+    }
+}
+
+// css::xml::sax::XDocumentHandler:
+void SAL_CALL
+SvXMLMetaExport::startDocument()
+{
+    // ignore: has already been done by SvXMLExport::exportDoc
+    assert(m_level == 0 && "SvXMLMetaExport: level error");
+}
+
+void SAL_CALL
+SvXMLMetaExport::endDocument()
+{
+    // ignore: will be done by SvXMLExport::exportDoc
+    assert(m_level == 0 && "SvXMLMetaExport: level error");
+}
+
+// unfortunately, this method contains far too much ugly namespace mangling.
+void SAL_CALL
+SvXMLMetaExport::startElement(const OUString & i_rName,
+    const uno::Reference< xml::sax::XAttributeList > & i_xAttribs)
+{
+
+    if (m_level == 0) {
+        // namespace decls: default ones have been written at the root element
+        // non-default ones must be preserved here
+        const sal_Int16 nCount = i_xAttribs->getLength();
+        for (sal_Int16 i = 0; i < nCount; ++i) {
+            const OUString name(i_xAttribs->getNameByIndex(i));
+            if (name.startsWith(s_xmlns)) {
+                bool found(false);
+                const SvXMLNamespaceMap & rNsMap(mrExport.GetNamespaceMap());
+                for (sal_uInt16 key = rNsMap.GetFirstKey();
+                     key != USHRT_MAX; key = rNsMap.GetNextKey(key)) {
+                    if (name == rNsMap.GetAttrNameByKey(key)) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found) {
+                    m_preservedNSs.emplace_back(name,
+                        i_xAttribs->getValueByIndex(i));
+                }
+            }
+        }
+        // ignore the root: it has been written already
+        ++m_level;
+        return;
+    }
+
+    if (m_level == 1) {
+        // attach preserved namespace decls from root node here
+        for (const auto& rPreservedNS : m_preservedNSs) {
+            const OUString ns(rPreservedNS.First);
+            bool found(false);
+            // but only if it is not already there
+            const sal_Int16 nCount = i_xAttribs->getLength();
+            for (sal_Int16 i = 0; i < nCount; ++i) {
+                const OUString name(i_xAttribs->getNameByIndex(i));
+                if (ns == name) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                mrExport.AddAttribute(ns, rPreservedNS.Second);
+            }
+        }
+    }
+
+    // attach the attributes
+    if (i_rName.startsWith(s_meta)) {
+        // special handling for all elements that may have
+        // xlink:href attributes; these must be made relative
+        const sal_Int16 nLength = i_xAttribs->getLength();
+        for (sal_Int16 i = 0; i < nLength; ++i) {
+            const OUString name (i_xAttribs->getNameByIndex (i));
+            OUString value(i_xAttribs->getValueByIndex(i));
+            if (name.startsWith(s_href)) {
+                value = mrExport.GetRelativeReference(value);
+            }
+            mrExport.AddAttribute(name, value);
+        }
+    } else {
+        const sal_Int16 nLength = i_xAttribs->getLength();
+        for (sal_Int16 i = 0; i < nLength; ++i) {
+            const OUString name  (i_xAttribs->getNameByIndex(i));
+            const OUString value (i_xAttribs->getValueByIndex(i));
+            mrExport.AddAttribute(name, value);
+        }
+    }
+
+    // finally, start the element
+    // #i107240# no whitespace here, because the DOM may already contain
+    // whitespace, which is not cleared when loading and thus accumulates.
+    mrExport.StartElement(i_rName, m_level <= 1);
+    ++m_level;
+}
+
+void SAL_CALL
+SvXMLMetaExport::endElement(const OUString & i_rName)
+{
+    --m_level;
+    if (m_level == 0) {
+        // ignore the root; see startElement
+        return;
+    }
+    assert(m_level >= 0 && "SvXMLMetaExport: level error");
+    mrExport.EndElement(i_rName, false);
+}
+
+void SAL_CALL
+SvXMLMetaExport::characters(const OUString & i_rChars)
+{
+    mrExport.Characters(i_rChars);
+}
+
+void SAL_CALL
+SvXMLMetaExport::ignorableWhitespace(const OUString & /*i_rWhitespaces*/)
+{
+    mrExport.IgnorableWhitespace(/*i_rWhitespaces*/);
+}
+
+void SAL_CALL
+SvXMLMetaExport::processingInstruction(const OUString &,
+    const OUString &)
+{
+    // ignore; the exporter cannot handle these
+}
+
+void SAL_CALL
+SvXMLMetaExport::setDocumentLocator(const uno::Reference<xml::sax::XLocator>&)
+{
+    // nothing to do here, move along...
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */