summaryrefslogtreecommitdiffstats
path: root/comphelper/source
diff options
context:
space:
mode:
Diffstat (limited to 'comphelper/source')
-rw-r--r--comphelper/source/compare/AnyCompareFactory.cxx136
-rw-r--r--comphelper/source/container/IndexedPropertyValuesContainer.cxx127
-rw-r--r--comphelper/source/container/NamedPropertyValuesContainer.cxx169
-rw-r--r--comphelper/source/container/container.cxx140
-rw-r--r--comphelper/source/container/containermultiplexer.cxx159
-rw-r--r--comphelper/source/container/embeddedobjectcontainer.cxx1508
-rw-r--r--comphelper/source/container/enumerablemap.cxx713
-rw-r--r--comphelper/source/container/enumhelper.cxx280
-rw-r--r--comphelper/source/container/interfacecontainer2.cxx421
-rw-r--r--comphelper/source/container/namecontainer.cxx166
-rw-r--r--comphelper/source/eventattachermgr/eventattachermgr.cxx740
-rw-r--r--comphelper/source/misc/AccessibleImplementationHelper.cxx43
-rw-r--r--comphelper/source/misc/DirectoryHelper.cxx213
-rw-r--r--comphelper/source/misc/SelectionMultiplex.cxx111
-rw-r--r--comphelper/source/misc/accessiblecomponenthelper.cxx177
-rw-r--r--comphelper/source/misc/accessiblecontexthelper.cxx248
-rw-r--r--comphelper/source/misc/accessibleeventnotifier.cxx274
-rw-r--r--comphelper/source/misc/accessiblekeybindinghelper.cxx97
-rw-r--r--comphelper/source/misc/accessibleselectionhelper.cxx172
-rw-r--r--comphelper/source/misc/accessibletexthelper.cxx800
-rw-r--r--comphelper/source/misc/accessiblewrapper.cxx616
-rw-r--r--comphelper/source/misc/accimplaccess.cxx54
-rw-r--r--comphelper/source/misc/anycompare.cxx453
-rw-r--r--comphelper/source/misc/anytohash.cxx210
-rw-r--r--comphelper/source/misc/anytostring.cxx316
-rw-r--r--comphelper/source/misc/asyncnotification.cxx259
-rw-r--r--comphelper/source/misc/asyncquithandler.cxx44
-rw-r--r--comphelper/source/misc/automationinvokedzone.cxx33
-rw-r--r--comphelper/source/misc/backupfilehelper.cxx2504
-rw-r--r--comphelper/source/misc/base64.cxx220
-rw-r--r--comphelper/source/misc/compbase.cxx231
-rw-r--r--comphelper/source/misc/componentbase.cxx59
-rw-r--r--comphelper/source/misc/configuration.cxx279
-rw-r--r--comphelper/source/misc/configurationhelper.cxx170
-rw-r--r--comphelper/source/misc/debuggerinfo.cxx91
-rw-r--r--comphelper/source/misc/dispatchcommand.cxx81
-rw-r--r--comphelper/source/misc/docpasswordhelper.cxx741
-rw-r--r--comphelper/source/misc/docpasswordrequest.cxx179
-rw-r--r--comphelper/source/misc/documentinfo.cxx177
-rw-r--r--comphelper/source/misc/evtlistenerhlp.cxx37
-rw-r--r--comphelper/source/misc/evtmethodhelper.cxx59
-rw-r--r--comphelper/source/misc/fileurl.cxx27
-rw-r--r--comphelper/source/misc/getexpandeduri.cxx32
-rw-r--r--comphelper/source/misc/graphicmimetype.cxx171
-rw-r--r--comphelper/source/misc/hash.cxx257
-rw-r--r--comphelper/source/misc/instancelocker.cxx445
-rw-r--r--comphelper/source/misc/instancelocker.hxx111
-rw-r--r--comphelper/source/misc/interaction.cxx71
-rw-r--r--comphelper/source/misc/logging.cxx159
-rw-r--r--comphelper/source/misc/lok.cxx287
-rw-r--r--comphelper/source/misc/mimeconfighelper.cxx909
-rw-r--r--comphelper/source/misc/namedvaluecollection.cxx308
-rw-r--r--comphelper/source/misc/numberedcollection.cxx213
-rw-r--r--comphelper/source/misc/numbers.cxx120
-rw-r--r--comphelper/source/misc/officerestartmanager.cxx157
-rw-r--r--comphelper/source/misc/officerestartmanager.hxx67
-rw-r--r--comphelper/source/misc/proxyaggregation.cxx243
-rw-r--r--comphelper/source/misc/random.cxx123
-rw-r--r--comphelper/source/misc/sequenceashashmap.cxx378
-rw-r--r--comphelper/source/misc/servicedecl.cxx161
-rw-r--r--comphelper/source/misc/sharedmutex.cxx42
-rw-r--r--comphelper/source/misc/simplefileaccessinteraction.cxx120
-rw-r--r--comphelper/source/misc/solarmutex.cxx103
-rw-r--r--comphelper/source/misc/stillreadwriteinteraction.cxx156
-rw-r--r--comphelper/source/misc/storagehelper.cxx713
-rw-r--r--comphelper/source/misc/string.cxx623
-rw-r--r--comphelper/source/misc/synchronousdispatch.cxx81
-rw-r--r--comphelper/source/misc/syntaxhighlight.cxx740
-rw-r--r--comphelper/source/misc/threadpool.cxx394
-rw-r--r--comphelper/source/misc/traceevent.cxx144
-rw-r--r--comphelper/source/misc/typedescriptionref.hxx51
-rw-r--r--comphelper/source/misc/types.cxx146
-rw-r--r--comphelper/source/misc/weak.cxx57
-rw-r--r--comphelper/source/misc/weakeventlistener.cxx74
-rw-r--r--comphelper/source/misc/xmlsechelper.cxx319
-rw-r--r--comphelper/source/officeinstdir/officeinstallationdirectories.cxx249
-rw-r--r--comphelper/source/officeinstdir/officeinstallationdirectories.hxx75
-rw-r--r--comphelper/source/processfactory/processfactory.cxx117
-rw-r--r--comphelper/source/property/ChainablePropertySet.cxx239
-rw-r--r--comphelper/source/property/ChainablePropertySetInfo.cxx95
-rw-r--r--comphelper/source/property/MasterPropertySet.cxx398
-rw-r--r--comphelper/source/property/MasterPropertySetInfo.cxx105
-rw-r--r--comphelper/source/property/genericpropertyset.cxx247
-rw-r--r--comphelper/source/property/opropertybag.cxx540
-rw-r--r--comphelper/source/property/opropertybag.hxx218
-rw-r--r--comphelper/source/property/propagg.cxx870
-rw-r--r--comphelper/source/property/property.cxx203
-rw-r--r--comphelper/source/property/propertybag.cxx206
-rw-r--r--comphelper/source/property/propertycontainer.cxx76
-rw-r--r--comphelper/source/property/propertycontainerhelper.cxx494
-rw-r--r--comphelper/source/property/propertysethelper.cxx271
-rw-r--r--comphelper/source/property/propertysetinfo.cxx120
-rw-r--r--comphelper/source/property/propertystatecontainer.cxx183
-rw-r--r--comphelper/source/property/propmultiplex.cxx153
-rw-r--r--comphelper/source/property/propstate.cxx228
-rw-r--r--comphelper/source/streaming/basicio.cxx182
-rw-r--r--comphelper/source/streaming/memorystream.cxx286
-rw-r--r--comphelper/source/streaming/oslfile2streamwrap.cxx171
-rw-r--r--comphelper/source/streaming/seekableinput.cxx233
-rw-r--r--comphelper/source/streaming/seqinputstreamserv.cxx215
-rw-r--r--comphelper/source/streaming/seqoutputstreamserv.cxx144
-rw-r--r--comphelper/source/streaming/seqstream.cxx247
-rw-r--r--comphelper/source/streaming/streamsection.cxx91
-rw-r--r--comphelper/source/windows/windows_process.cxx262
-rw-r--r--comphelper/source/xml/attributelist.cxx73
-rw-r--r--comphelper/source/xml/ofopxmlhelper.cxx493
-rw-r--r--comphelper/source/xml/xmltools.cxx99
107 files changed, 29092 insertions, 0 deletions
diff --git a/comphelper/source/compare/AnyCompareFactory.cxx b/comphelper/source/compare/AnyCompareFactory.cxx
new file mode 100644
index 000000000..40e5f0806
--- /dev/null
+++ b/comphelper/source/compare/AnyCompareFactory.cxx
@@ -0,0 +1,136 @@
+/* -*- 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 <com/sun/star/ucb/XAnyCompareFactory.hpp>
+#include <com/sun/star/i18n/Collator.hpp>
+#include <com/sun/star/lang/Locale.hpp>
+#include <com/sun/star/uno/Sequence.h>
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/lang/XInitialization.hpp>
+
+using namespace com::sun::star::uno;
+using namespace com::sun::star::ucb;
+using namespace com::sun::star::lang;
+using namespace com::sun::star::i18n;
+
+namespace {
+
+class AnyCompare : public ::cppu::WeakImplHelper< XAnyCompare >
+{
+ Reference< XCollator > m_xCollator;
+
+public:
+ AnyCompare( Reference< XComponentContext > const & xContext, const Locale& rLocale )
+ : m_xCollator(Collator::create( xContext ))
+ {
+ m_xCollator->loadDefaultCollator( rLocale,
+ 0 ); //???
+ }
+
+ virtual sal_Int16 SAL_CALL compare( const Any& any1, const Any& any2 ) override;
+};
+
+class AnyCompareFactory : public cppu::WeakImplHelper< XAnyCompareFactory, XInitialization, XServiceInfo >
+{
+ Reference< XAnyCompare > m_xAnyCompare;
+ Reference< XComponentContext > m_xContext;
+ Locale m_Locale;
+
+public:
+ explicit AnyCompareFactory( Reference< XComponentContext > const & xContext ) : m_xContext( xContext )
+ {}
+
+ // XAnyCompareFactory
+ virtual Reference< XAnyCompare > SAL_CALL createAnyCompareByName ( const OUString& aPropertyName ) override;
+
+ // XInitialization
+ virtual void SAL_CALL initialize( const Sequence< Any >& aArguments ) override;
+
+ // XServiceInfo
+ virtual OUString SAL_CALL getImplementationName( ) override;
+ virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+ virtual Sequence< OUString > SAL_CALL getSupportedServiceNames( ) override;
+};
+
+}
+
+sal_Int16 SAL_CALL AnyCompare::compare( const Any& any1, const Any& any2 )
+{
+ sal_Int16 aResult = 0;
+
+ OUString aStr1;
+ OUString aStr2;
+
+ any1 >>= aStr1;
+ any2 >>= aStr2;
+
+ aResult = static_cast<sal_Int16>(m_xCollator->compareString(aStr1, aStr2));
+
+ return aResult;
+}
+
+Reference< XAnyCompare > SAL_CALL AnyCompareFactory::createAnyCompareByName( const OUString& aPropertyName )
+{
+ // for now only OUString properties compare is implemented
+ // so no check for the property name is done
+
+ if( aPropertyName == "Title" )
+ return m_xAnyCompare;
+
+ return Reference< XAnyCompare >();
+}
+
+void SAL_CALL AnyCompareFactory::initialize( const Sequence< Any >& aArguments )
+{
+ if( aArguments.hasElements() )
+ {
+ if( aArguments[0] >>= m_Locale )
+ {
+ m_xAnyCompare = new AnyCompare( m_xContext, m_Locale );
+ return;
+ }
+ }
+}
+
+OUString SAL_CALL AnyCompareFactory::getImplementationName( )
+{
+ return "AnyCompareFactory";
+}
+
+sal_Bool SAL_CALL AnyCompareFactory::supportsService( const OUString& ServiceName )
+{
+ return cppu::supportsService(this, ServiceName);
+}
+
+Sequence< OUString > SAL_CALL AnyCompareFactory::getSupportedServiceNames( )
+{
+ return { "com.sun.star.ucb.AnyCompareFactory" };
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+AnyCompareFactory_get_implementation(
+ css::uno::XComponentContext *context,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new AnyCompareFactory(context));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/container/IndexedPropertyValuesContainer.cxx b/comphelper/source/container/IndexedPropertyValuesContainer.cxx
new file mode 100644
index 000000000..f5b7358d6
--- /dev/null
+++ b/comphelper/source/container/IndexedPropertyValuesContainer.cxx
@@ -0,0 +1,127 @@
+/* -*- 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 <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
+#include <comphelper/indexedpropertyvalues.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <o3tl/safeint.hxx>
+
+namespace com::sun::star::uno { class XComponentContext; }
+
+using namespace com::sun::star;
+
+
+namespace comphelper {
+
+
+IndexedPropertyValuesContainer::IndexedPropertyValuesContainer() noexcept
+{
+}
+
+// XIndexContainer
+void SAL_CALL IndexedPropertyValuesContainer::insertByIndex( sal_Int32 nIndex, const css::uno::Any& aElement )
+{
+ sal_Int32 nSize(maProperties.size());
+ if ((nSize < nIndex) || (nIndex < 0))
+ throw lang::IndexOutOfBoundsException();
+
+ uno::Sequence<beans::PropertyValue> aProps;
+ if (!(aElement >>= aProps))
+ throw lang::IllegalArgumentException("element is not beans::PropertyValue", static_cast<cppu::OWeakObject*>(this), 2);
+ if (nSize == nIndex)
+ maProperties.push_back(aProps);
+ else
+ maProperties.insert(maProperties.begin() + nIndex, aProps);
+}
+
+void SAL_CALL IndexedPropertyValuesContainer::removeByIndex( sal_Int32 nIndex )
+{
+ if ((nIndex < 0) || (o3tl::make_unsigned(nIndex) >= maProperties.size()))
+ throw lang::IndexOutOfBoundsException();
+
+ maProperties.erase(maProperties.begin() + nIndex);
+}
+
+// XIndexReplace
+void SAL_CALL IndexedPropertyValuesContainer::replaceByIndex( sal_Int32 nIndex, const css::uno::Any& aElement )
+{
+ sal_Int32 nSize(maProperties.size());
+ if ((nIndex >= nSize) || (nIndex < 0))
+ throw lang::IndexOutOfBoundsException();
+
+ uno::Sequence<beans::PropertyValue> aProps;
+ if (!(aElement >>= aProps))
+ throw lang::IllegalArgumentException("element is not beans::PropertyValue", static_cast<cppu::OWeakObject*>(this), 2);
+ maProperties[nIndex] = aProps;
+}
+
+// XIndexAccess
+sal_Int32 SAL_CALL IndexedPropertyValuesContainer::getCount( )
+{
+ return maProperties.size();
+}
+
+css::uno::Any SAL_CALL IndexedPropertyValuesContainer::getByIndex( sal_Int32 nIndex )
+{
+ sal_Int32 nSize(maProperties.size());
+ if ((nIndex >= nSize) || (nIndex < 0))
+ throw lang::IndexOutOfBoundsException();
+
+ return uno::Any( maProperties[nIndex] );
+}
+
+// XElementAccess
+css::uno::Type SAL_CALL IndexedPropertyValuesContainer::getElementType( )
+{
+ return cppu::UnoType<uno::Sequence<beans::PropertyValue>>::get();
+}
+
+sal_Bool SAL_CALL IndexedPropertyValuesContainer::hasElements( )
+{
+ return !maProperties.empty();
+}
+
+//XServiceInfo
+OUString SAL_CALL IndexedPropertyValuesContainer::getImplementationName( )
+{
+ return "IndexedPropertyValuesContainer";
+}
+
+sal_Bool SAL_CALL IndexedPropertyValuesContainer::supportsService( const OUString& ServiceName )
+{
+ return cppu::supportsService(this, ServiceName);
+}
+
+css::uno::Sequence< OUString > SAL_CALL IndexedPropertyValuesContainer::getSupportedServiceNames( )
+{
+ return { "com.sun.star.document.IndexedPropertyValues" };
+}
+
+} // namespace comphelper
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+IndexedPropertyValuesContainer_get_implementation(
+ css::uno::XComponentContext *,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new comphelper::IndexedPropertyValuesContainer());
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/container/NamedPropertyValuesContainer.cxx b/comphelper/source/container/NamedPropertyValuesContainer.cxx
new file mode 100644
index 000000000..a44837f11
--- /dev/null
+++ b/comphelper/source/container/NamedPropertyValuesContainer.cxx
@@ -0,0 +1,169 @@
+/* -*- 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 <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/uno/Sequence.h>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <comphelper/sequence.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <cppuhelper/supportsservice.hxx>
+#include <map>
+
+
+namespace com::sun::star::uno { class XComponentContext; }
+using namespace com::sun::star;
+
+typedef std::map< OUString, uno::Sequence<beans::PropertyValue> > NamedPropertyValues;
+
+namespace {
+
+class NamedPropertyValuesContainer : public cppu::WeakImplHelper< container::XNameContainer, lang::XServiceInfo >
+{
+public:
+ NamedPropertyValuesContainer() noexcept;
+
+ // XNameContainer
+ virtual void SAL_CALL insertByName( const OUString& aName, const css::uno::Any& aElement ) override;
+ virtual void SAL_CALL removeByName( const OUString& Name ) override;
+
+ // XNameReplace
+ virtual void SAL_CALL replaceByName( const OUString& aName, const css::uno::Any& aElement ) override;
+
+ // XNameAccess
+ virtual css::uno::Any SAL_CALL getByName( const OUString& aName ) override;
+ virtual css::uno::Sequence< OUString > SAL_CALL getElementNames( ) override;
+ virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override;
+
+ // XElementAccess
+ virtual css::uno::Type SAL_CALL getElementType( ) override;
+ virtual sal_Bool SAL_CALL hasElements( ) override;
+
+ //XServiceInfo
+ virtual OUString SAL_CALL getImplementationName( ) override;
+ virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+ virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames( ) override;
+
+private:
+ NamedPropertyValues maProperties;
+};
+
+}
+
+NamedPropertyValuesContainer::NamedPropertyValuesContainer() noexcept
+{
+}
+
+// XNameContainer
+void SAL_CALL NamedPropertyValuesContainer::insertByName( const OUString& aName, const uno::Any& aElement )
+{
+ if( maProperties.find( aName ) != maProperties.end() )
+ throw container::ElementExistException();
+
+ uno::Sequence<beans::PropertyValue> aProps;
+ if( !(aElement >>= aProps ) )
+ throw lang::IllegalArgumentException("element is not beans::PropertyValue", static_cast<cppu::OWeakObject*>(this), 2);
+
+ maProperties.emplace( aName, aProps );
+}
+
+void SAL_CALL NamedPropertyValuesContainer::removeByName( const OUString& Name )
+{
+ NamedPropertyValues::iterator aIter = maProperties.find( Name );
+ if( aIter == maProperties.end() )
+ throw container::NoSuchElementException();
+
+ maProperties.erase( aIter );
+}
+
+// XNameReplace
+void SAL_CALL NamedPropertyValuesContainer::replaceByName( const OUString& aName, const css::uno::Any& aElement )
+{
+ NamedPropertyValues::iterator aIter = maProperties.find( aName );
+ if( aIter == maProperties.end() )
+ throw container::NoSuchElementException();
+
+ uno::Sequence<beans::PropertyValue> aProps;
+ if( !(aElement >>= aProps) )
+ throw lang::IllegalArgumentException("element is not beans::PropertyValue", static_cast<cppu::OWeakObject*>(this), 2);
+
+ (*aIter).second = aProps;
+}
+
+// XNameAccess
+css::uno::Any SAL_CALL NamedPropertyValuesContainer::getByName( const OUString& aName )
+{
+ NamedPropertyValues::iterator aIter = maProperties.find( aName );
+ if( aIter == maProperties.end() )
+ throw container::NoSuchElementException();
+
+ uno::Any aElement;
+
+ aElement <<= (*aIter).second;
+
+ return aElement;
+}
+
+css::uno::Sequence< OUString > SAL_CALL NamedPropertyValuesContainer::getElementNames( )
+{
+ return comphelper::mapKeysToSequence(maProperties);
+}
+
+sal_Bool SAL_CALL NamedPropertyValuesContainer::hasByName( const OUString& aName )
+{
+ NamedPropertyValues::iterator aIter = maProperties.find( aName );
+ return aIter != maProperties.end();
+}
+
+// XElementAccess
+css::uno::Type SAL_CALL NamedPropertyValuesContainer::getElementType( )
+{
+ return cppu::UnoType<uno::Sequence<beans::PropertyValue>>::get();
+}
+
+sal_Bool SAL_CALL NamedPropertyValuesContainer::hasElements( )
+{
+ return !maProperties.empty();
+}
+
+//XServiceInfo
+OUString SAL_CALL NamedPropertyValuesContainer::getImplementationName( )
+{
+ return "NamedPropertyValuesContainer";
+}
+
+sal_Bool SAL_CALL NamedPropertyValuesContainer::supportsService( const OUString& ServiceName )
+{
+ return cppu::supportsService(this, ServiceName);
+}
+
+css::uno::Sequence< OUString > SAL_CALL NamedPropertyValuesContainer::getSupportedServiceNames( )
+{
+ return { "com.sun.star.document.NamedPropertyValues" };
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+NamedPropertyValuesContainer_get_implementation(
+ css::uno::XComponentContext *,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new NamedPropertyValuesContainer());
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/container/container.cxx b/comphelper/source/container/container.cxx
new file mode 100644
index 000000000..7b2432723
--- /dev/null
+++ b/comphelper/source/container/container.cxx
@@ -0,0 +1,140 @@
+/* -*- 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 <com/sun/star/uno/XInterface.hpp>
+#include <com/sun/star/container/XIndexAccess.hpp>
+#include <com/sun/star/container/XChild.hpp>
+#include <comphelper/container.hxx>
+#include <o3tl/any.hxx>
+#include <utility>
+#include <osl/diagnose.h>
+
+
+namespace comphelper
+{
+
+
+IndexAccessIterator::IndexAccessIterator(css::uno::Reference< css::uno::XInterface> xStartingPoint)
+ :m_xStartingPoint(std::move(xStartingPoint))
+{
+ OSL_ENSURE(m_xStartingPoint.is(), "IndexAccessIterator::IndexAccessIterator : no starting point !");
+}
+
+IndexAccessIterator::~IndexAccessIterator() {}
+
+
+css::uno::Reference< css::uno::XInterface> const & IndexAccessIterator::Next()
+{
+ bool bCheckingStartingPoint = !m_xCurrentObject.is();
+ // Is the current node the starting point?
+ bool bAlreadyCheckedCurrent = m_xCurrentObject.is();
+ // Have I already tested the current node through ShouldHandleElement?
+ if (!m_xCurrentObject.is())
+ m_xCurrentObject = m_xStartingPoint;
+
+ css::uno::Reference< css::uno::XInterface> xSearchLoop( m_xCurrentObject);
+ bool bHasMoreToSearch = true;
+ bool bFoundSomething = false;
+ while (!bFoundSomething && bHasMoreToSearch)
+ {
+ // Priming loop
+ if (!bAlreadyCheckedCurrent && ShouldHandleElement(xSearchLoop))
+ {
+ m_xCurrentObject = xSearchLoop;
+ bFoundSomething = true;
+ }
+ else
+ {
+ // First, check to see if there's a match below
+ css::uno::Reference< css::container::XIndexAccess> xContainerAccess(xSearchLoop, css::uno::UNO_QUERY);
+ if (xContainerAccess.is() && xContainerAccess->getCount() && ShouldStepInto(xContainerAccess))
+ {
+ css::uno::Any aElement(xContainerAccess->getByIndex(0));
+ xSearchLoop = *o3tl::doAccess<css::uno::Reference<css::uno::XInterface>>(aElement);
+ bCheckingStartingPoint = false;
+
+ m_arrChildIndizies.push_back(sal_Int32(0));
+ }
+ else
+ { // otherwise, look above and to the right, if possible
+ while (!m_arrChildIndizies.empty())
+ { // If the list isn't empty and there's nothing above
+ css::uno::Reference< css::container::XChild> xChild(xSearchLoop, css::uno::UNO_QUERY);
+ OSL_ENSURE(xChild.is(), "IndexAccessIterator::Next : a content has no appropriate interface !");
+
+ css::uno::Reference< css::uno::XInterface> xParent( xChild->getParent());
+ xContainerAccess.set(xParent, css::uno::UNO_QUERY);
+ OSL_ENSURE(xContainerAccess.is(), "IndexAccessIterator::Next : a content has an invalid parent !");
+
+ // Remove the index that SearchLoop had within this parent from my stack
+ sal_Int32 nOldSearchChildIndex = m_arrChildIndizies[m_arrChildIndizies.size() - 1];
+ m_arrChildIndizies.pop_back();
+
+ if (nOldSearchChildIndex < xContainerAccess->getCount() - 1)
+ { // Move to the right in this row
+ ++nOldSearchChildIndex;
+ // and check the next child
+ css::uno::Any aElement(xContainerAccess->getByIndex(nOldSearchChildIndex));
+ xSearchLoop = *o3tl::doAccess<css::uno::Reference<css::uno::XInterface>>(aElement);
+ bCheckingStartingPoint = false;
+ // and update its position in the list.
+ m_arrChildIndizies.push_back(nOldSearchChildIndex);
+
+ break;
+ }
+ // Finally, if there's nothing more to do in this row (to the right), we'll move on to the next row.
+ xSearchLoop = xParent;
+ bCheckingStartingPoint = false;
+ }
+
+ if (m_arrChildIndizies.empty() && !bCheckingStartingPoint)
+ { //This is the case if there is nothing to the right in the original search loop
+ bHasMoreToSearch = false;
+ }
+ }
+
+ if (bHasMoreToSearch)
+ { // If there is still a node in the tree which can be tested
+ if (ShouldHandleElement(xSearchLoop))
+ {
+ m_xCurrentObject = xSearchLoop;
+ bFoundSomething = true;
+ }
+ else
+ if (bCheckingStartingPoint)
+ bHasMoreToSearch = false;
+ bAlreadyCheckedCurrent = true;
+ }
+ }
+ }
+
+ if (!bFoundSomething)
+ {
+ OSL_ENSURE(m_arrChildIndizies.empty(), "IndexAccessIterator::Next : items left on stack ! how this ?");
+ Invalidate();
+ }
+
+ return m_xCurrentObject;
+}
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/container/containermultiplexer.cxx b/comphelper/source/container/containermultiplexer.cxx
new file mode 100644
index 000000000..c687e7279
--- /dev/null
+++ b/comphelper/source/container/containermultiplexer.cxx
@@ -0,0 +1,159 @@
+/* -*- 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 <comphelper/containermultiplexer.hxx>
+#include <com/sun/star/container/XContainer.hpp>
+#include <osl/diagnose.h>
+
+namespace comphelper
+{
+
+
+ using namespace ::com::sun::star::uno;
+ using namespace ::com::sun::star::lang;
+ using namespace ::com::sun::star::container;
+
+ OContainerListener::OContainerListener(::osl::Mutex& _rMutex)
+ :m_rMutex(_rMutex)
+ {
+ }
+
+
+ OContainerListener::~OContainerListener()
+ {
+ if (m_xAdapter.is())
+ {
+ m_xAdapter->dispose();
+ }
+ }
+
+
+ void OContainerListener::_elementInserted( const ContainerEvent& /*_rEvent*/ )
+ {
+ }
+
+
+ void OContainerListener::_elementRemoved( const ContainerEvent& )
+ {
+ }
+
+
+ void OContainerListener::_elementReplaced( const ContainerEvent& /*_rEvent*/ )
+ {
+ }
+
+
+ void OContainerListener::_disposing(const EventObject& )
+ {
+ }
+
+
+ void OContainerListener::setAdapter(OContainerListenerAdapter* pAdapter)
+ {
+ ::osl::MutexGuard aGuard(m_rMutex);
+ m_xAdapter = pAdapter;
+ }
+
+ OContainerListenerAdapter::OContainerListenerAdapter(OContainerListener* _pListener,
+ const Reference< XContainer >& _rxContainer)
+ :m_xContainer(_rxContainer)
+ ,m_pListener(_pListener)
+ {
+ if (m_pListener)
+ m_pListener->setAdapter(this);
+
+ osl_atomic_increment(&m_refCount);
+ try
+ {
+ m_xContainer->addContainerListener(this);
+ }
+ catch(const Exception&)
+ {
+ OSL_FAIL("Exception caught!");
+ }
+ osl_atomic_decrement(&m_refCount);
+ }
+
+
+ OContainerListenerAdapter::~OContainerListenerAdapter()
+ {
+ }
+
+
+ void OContainerListenerAdapter::dispose()
+ {
+ if (!m_xContainer.is())
+ return;
+
+ try
+ {
+ Reference< XContainerListener > xPreventDelete(this);
+ m_xContainer->removeContainerListener(xPreventDelete);
+ m_pListener->setAdapter(nullptr);
+ }
+ catch(const Exception&)
+ {
+ OSL_FAIL("Exception caught!");
+ }
+ m_xContainer = nullptr;
+ m_pListener = nullptr;
+ }
+
+
+ void SAL_CALL OContainerListenerAdapter::disposing( const EventObject& _rSource)
+ {
+ if (m_pListener)
+ {
+ // tell the listener
+ m_pListener->_disposing(_rSource);
+ // disconnect the listener
+ if ( m_pListener )
+ m_pListener->setAdapter(nullptr);
+ }
+
+ m_xContainer = nullptr;
+ m_pListener = nullptr;
+ }
+
+
+ void SAL_CALL OContainerListenerAdapter::elementInserted( const ContainerEvent& _rEvent )
+ {
+ if (m_pListener)
+ m_pListener->_elementInserted(_rEvent);
+ }
+
+
+ void SAL_CALL OContainerListenerAdapter::elementRemoved( const ContainerEvent& _rEvent )
+ {
+ if (m_pListener)
+ m_pListener->_elementRemoved(_rEvent);
+ }
+
+
+ void SAL_CALL OContainerListenerAdapter::elementReplaced( const ContainerEvent& _rEvent )
+ {
+ if (m_pListener)
+ m_pListener->_elementReplaced(_rEvent);
+ }
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/container/embeddedobjectcontainer.cxx b/comphelper/source/container/embeddedobjectcontainer.cxx
new file mode 100644
index 000000000..094597fe6
--- /dev/null
+++ b/comphelper/source/container/embeddedobjectcontainer.cxx
@@ -0,0 +1,1508 @@
+/* -*- 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 <com/sun/star/container/XChild.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/embed/EmbeddedObjectCreator.hpp>
+#include <com/sun/star/embed/WrongStateException.hpp>
+#include <com/sun/star/embed/XEmbeddedObject.hpp>
+#include <com/sun/star/embed/XEmbedPersist.hpp>
+#include <com/sun/star/embed/XLinkageSupport.hpp>
+#include <com/sun/star/embed/XTransactedObject.hpp>
+#include <com/sun/star/embed/XOptimizedStorage.hpp>
+#include <com/sun/star/embed/EntryInitModes.hpp>
+#include <com/sun/star/io/IOException.hpp>
+#include <com/sun/star/util/XCloseable.hpp>
+#include <com/sun/star/util/XModifiable.hpp>
+#include <com/sun/star/embed/EmbedStates.hpp>
+#include <com/sun/star/beans/XPropertySetInfo.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/embed/Aspects.hpp>
+#include <com/sun/star/embed/EmbedMisc.hpp>
+
+#include <comphelper/seqstream.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/storagehelper.hxx>
+#include <comphelper/embeddedobjectcontainer.hxx>
+#include <comphelper/sequence.hxx>
+#include <comphelper/propertysequence.hxx>
+#include <comphelper/propertyvalue.hxx>
+#include <cppuhelper/weakref.hxx>
+#include <sal/log.hxx>
+
+#include <algorithm>
+#include <unordered_map>
+
+
+using namespace ::com::sun::star;
+
+namespace comphelper {
+
+typedef std::unordered_map<OUString, uno::Reference<embed::XEmbeddedObject>> EmbeddedObjectContainerNameMap;
+struct EmbedImpl
+{
+ // TODO/LATER: remove objects from temp. Container storage when object is disposed
+ EmbeddedObjectContainerNameMap maNameToObjectMap;
+ // to speed up lookup by Reference
+ std::unordered_map<uno::Reference<embed::XEmbeddedObject>, OUString> maObjectToNameMap;
+ uno::Reference < embed::XStorage > mxStorage;
+ EmbeddedObjectContainer* mpTempObjectContainer;
+ uno::Reference < embed::XStorage > mxImageStorage;
+ uno::WeakReference < uno::XInterface > m_xModel;
+
+ bool mbOwnsStorage : 1;
+ bool mbUserAllowsLinkUpdate : 1;
+
+ const uno::Reference < embed::XStorage >& GetReplacements();
+};
+
+const uno::Reference < embed::XStorage >& EmbedImpl::GetReplacements()
+{
+ if ( !mxImageStorage.is() )
+ {
+ try
+ {
+ mxImageStorage = mxStorage->openStorageElement(
+ "ObjectReplacements", embed::ElementModes::READWRITE );
+ }
+ catch (const uno::Exception&)
+ {
+ mxImageStorage = mxStorage->openStorageElement(
+ "ObjectReplacements", embed::ElementModes::READ );
+ }
+ }
+
+ if ( !mxImageStorage.is() )
+ throw io::IOException("No ObjectReplacements");
+
+ return mxImageStorage;
+}
+
+EmbeddedObjectContainer::EmbeddedObjectContainer()
+ : pImpl(new EmbedImpl)
+{
+ pImpl->mxStorage = ::comphelper::OStorageHelper::GetTemporaryStorage();
+ pImpl->mbOwnsStorage = true;
+ pImpl->mbUserAllowsLinkUpdate = true;
+ pImpl->mpTempObjectContainer = nullptr;
+}
+
+EmbeddedObjectContainer::EmbeddedObjectContainer( const uno::Reference < embed::XStorage >& rStor )
+ : pImpl(new EmbedImpl)
+{
+ pImpl->mxStorage = rStor;
+ pImpl->mbOwnsStorage = false;
+ pImpl->mbUserAllowsLinkUpdate = true;
+ pImpl->mpTempObjectContainer = nullptr;
+}
+
+EmbeddedObjectContainer::EmbeddedObjectContainer( const uno::Reference < embed::XStorage >& rStor, const uno::Reference < uno::XInterface >& xModel )
+ : pImpl(new EmbedImpl)
+{
+ pImpl->mxStorage = rStor;
+ pImpl->mbOwnsStorage = false;
+ pImpl->mbUserAllowsLinkUpdate = true;
+ pImpl->mpTempObjectContainer = nullptr;
+ pImpl->m_xModel = xModel;
+}
+
+void EmbeddedObjectContainer::SwitchPersistence( const uno::Reference < embed::XStorage >& rStor )
+{
+ ReleaseImageSubStorage();
+
+ if ( pImpl->mbOwnsStorage )
+ pImpl->mxStorage->dispose();
+
+ pImpl->mxStorage = rStor;
+ pImpl->mbOwnsStorage = false;
+}
+
+bool EmbeddedObjectContainer::CommitImageSubStorage()
+{
+ if ( !pImpl->mxImageStorage )
+ return true;
+
+ try
+ {
+ bool bReadOnlyMode = true;
+ uno::Reference < beans::XPropertySet > xSet(pImpl->mxImageStorage,uno::UNO_QUERY);
+ if ( xSet.is() )
+ {
+ // get the open mode from the parent storage
+ sal_Int32 nMode = 0;
+ uno::Any aAny = xSet->getPropertyValue("OpenMode");
+ if ( aAny >>= nMode )
+ bReadOnlyMode = !(nMode & embed::ElementModes::WRITE );
+ } // if ( xSet.is() )
+ if ( !bReadOnlyMode )
+ {
+ uno::Reference< embed::XTransactedObject > xTransact( pImpl->mxImageStorage, uno::UNO_QUERY_THROW );
+ xTransact->commit();
+ }
+ }
+ catch (const uno::Exception&)
+ {
+ return false;
+ }
+
+ return true;
+}
+
+void EmbeddedObjectContainer::ReleaseImageSubStorage()
+{
+ CommitImageSubStorage();
+
+ if ( pImpl->mxImageStorage.is() )
+ {
+ try
+ {
+ pImpl->mxImageStorage->dispose();
+ pImpl->mxImageStorage.clear();
+ }
+ catch (const uno::Exception&)
+ {
+ SAL_WARN( "comphelper.container", "Problems releasing image substorage!" );
+ }
+ }
+}
+
+EmbeddedObjectContainer::~EmbeddedObjectContainer()
+{
+ ReleaseImageSubStorage();
+
+ if ( pImpl->mbOwnsStorage )
+ pImpl->mxStorage->dispose();
+
+ delete pImpl->mpTempObjectContainer;
+}
+
+void EmbeddedObjectContainer::CloseEmbeddedObjects()
+{
+ for( const auto& rObj : pImpl->maNameToObjectMap )
+ {
+ uno::Reference < util::XCloseable > const & xClose = rObj.second;
+ if( xClose.is() )
+ {
+ try
+ {
+ xClose->close( true );
+ }
+ catch (const uno::Exception&)
+ {
+ }
+ }
+ }
+}
+
+OUString EmbeddedObjectContainer::CreateUniqueObjectName()
+{
+ OUString aStr;
+ sal_Int32 i=1;
+ do
+ {
+ aStr = "Object " + OUString::number( i++ );
+ }
+ while( HasEmbeddedObject( aStr ) );
+ // TODO/LATER: should we consider deleted objects?
+
+ return aStr;
+}
+
+uno::Sequence < OUString > EmbeddedObjectContainer::GetObjectNames() const
+{
+ return comphelper::mapKeysToSequence(pImpl->maNameToObjectMap);
+}
+
+bool EmbeddedObjectContainer::HasEmbeddedObjects() const
+{
+ return !pImpl->maNameToObjectMap.empty();
+}
+
+bool EmbeddedObjectContainer::HasEmbeddedObject( const OUString& rName )
+{
+ auto aIt = pImpl->maNameToObjectMap.find( rName );
+ if (aIt != pImpl->maNameToObjectMap.end())
+ return true;
+ if (!pImpl->mxStorage.is())
+ return false;
+ return pImpl->mxStorage->hasByName(rName);
+}
+
+bool EmbeddedObjectContainer::HasEmbeddedObject( const uno::Reference < embed::XEmbeddedObject >& xObj ) const
+{
+ return pImpl->maObjectToNameMap.find(xObj) != pImpl->maObjectToNameMap.end();
+}
+
+bool EmbeddedObjectContainer::HasInstantiatedEmbeddedObject( const OUString& rName )
+{
+ // allows to detect whether the object was already instantiated
+ // currently the filter instantiate it on loading, so this method allows
+ // to avoid objects pointing to the same persistence
+ auto aIt = pImpl->maNameToObjectMap.find( rName );
+ return ( aIt != pImpl->maNameToObjectMap.end() );
+}
+
+OUString EmbeddedObjectContainer::GetEmbeddedObjectName( const css::uno::Reference < css::embed::XEmbeddedObject >& xObj ) const
+{
+ auto it = pImpl->maObjectToNameMap.find(xObj);
+ if (it == pImpl->maObjectToNameMap.end())
+ {
+ SAL_WARN( "comphelper.container", "Unknown object!" );
+ return OUString();
+ }
+ return it->second;
+}
+
+uno::Reference< embed::XEmbeddedObject>
+EmbeddedObjectContainer::GetEmbeddedObject(
+ const OUString& rName, OUString const*const pBaseURL)
+{
+ SAL_WARN_IF( rName.isEmpty(), "comphelper.container", "Empty object name!");
+
+ uno::Reference < embed::XEmbeddedObject > xObj;
+ auto aIt = pImpl->maNameToObjectMap.find( rName );
+
+#if OSL_DEBUG_LEVEL > 1
+ uno::Reference < container::XNameAccess > xAccess( pImpl->mxStorage, uno::UNO_QUERY );
+ uno::Sequence< OUString> aSeq = xAccess->getElementNames();
+ const OUString* pIter = aSeq.getConstArray();
+ const OUString* pEnd = pIter + aSeq.getLength();
+ for(;pIter != pEnd;++pIter)
+ {
+ (void)*pIter;
+ }
+ OSL_ENSURE( aIt != pImpl->maNameToObjectMap.end() || xAccess->hasByName(rName), "Could not return object!" );
+#endif
+
+ // check if object was already created
+ if ( aIt != pImpl->maNameToObjectMap.end() )
+ xObj = (*aIt).second;
+ else
+ xObj = Get_Impl(rName, uno::Reference<embed::XEmbeddedObject>(), pBaseURL);
+
+ return xObj;
+}
+
+uno::Reference<embed::XEmbeddedObject> EmbeddedObjectContainer::Get_Impl(
+ const OUString& rName,
+ const uno::Reference<embed::XEmbeddedObject>& xCopy,
+ OUString const*const pBaseURL)
+{
+ uno::Reference < embed::XEmbeddedObject > xObj;
+ try
+ {
+ // create the object from the storage
+ uno::Reference < beans::XPropertySet > xSet( pImpl->mxStorage, uno::UNO_QUERY );
+ bool bReadOnlyMode = true;
+ if ( xSet.is() )
+ {
+ // get the open mode from the parent storage
+ sal_Int32 nMode = 0;
+ uno::Any aAny = xSet->getPropertyValue("OpenMode");
+ if ( aAny >>= nMode )
+ bReadOnlyMode = !(nMode & embed::ElementModes::WRITE );
+ }
+
+ // object was not added until now - should happen only by calling this method from "inside"
+ //TODO/LATER: it would be good to detect an error when an object should be created already, but isn't (not an "inside" call)
+ uno::Reference < embed::XEmbeddedObjectCreator > xFactory = embed::EmbeddedObjectCreator::create( ::comphelper::getProcessComponentContext() );
+ uno::Sequence< beans::PropertyValue > aObjDescr(1 + (xCopy.is() ? 1 : 0) + (pBaseURL ? 1 : 0));
+ auto itObjDescr = aObjDescr.getArray();
+ itObjDescr->Name = "Parent";
+ itObjDescr->Value <<= pImpl->m_xModel.get();
+ if (pBaseURL)
+ {
+ ++itObjDescr;
+ itObjDescr->Name = "DefaultParentBaseURL";
+ itObjDescr->Value <<= *pBaseURL;
+ }
+ if ( xCopy.is() )
+ {
+ ++itObjDescr;
+ itObjDescr->Name = "CloneFrom";
+ itObjDescr->Value <<= xCopy;
+ }
+
+ uno::Sequence< beans::PropertyValue > aMediaDescr{ comphelper::makePropertyValue(
+ "ReadOnly", bReadOnlyMode) };
+ xObj.set( xFactory->createInstanceInitFromEntry(
+ pImpl->mxStorage, rName,
+ aMediaDescr, aObjDescr ), uno::UNO_QUERY );
+
+ // insert object into my list
+ AddEmbeddedObject( xObj, rName );
+ }
+ catch (uno::Exception const& e)
+ {
+ SAL_WARN("comphelper.container", "EmbeddedObjectContainer::Get_Impl: exception caught: " << e);
+ }
+
+ return xObj;
+}
+
+uno::Reference < embed::XEmbeddedObject > EmbeddedObjectContainer::CreateEmbeddedObject( const uno::Sequence < sal_Int8 >& rClassId,
+ const uno::Sequence < beans::PropertyValue >& rArgs, OUString& rNewName, OUString const* pBaseURL )
+{
+ if ( rNewName.isEmpty() )
+ rNewName = CreateUniqueObjectName();
+
+ SAL_WARN_IF( HasEmbeddedObject(rNewName), "comphelper.container", "Object to create already exists!");
+
+ // create object from classid by inserting it into storage
+ uno::Reference < embed::XEmbeddedObject > xObj;
+ try
+ {
+ uno::Reference < embed::XEmbeddedObjectCreator > xFactory = embed::EmbeddedObjectCreator::create( ::comphelper::getProcessComponentContext() );
+
+ const size_t nExtraArgs = pBaseURL ? 2 : 1;
+ uno::Sequence< beans::PropertyValue > aObjDescr( rArgs.getLength() + nExtraArgs );
+ auto pObjDescr = aObjDescr.getArray();
+ pObjDescr[0].Name = "Parent";
+ pObjDescr[0].Value <<= pImpl->m_xModel.get();
+ if (pBaseURL)
+ {
+ pObjDescr[1].Name = "DefaultParentBaseURL";
+ pObjDescr[1].Value <<= *pBaseURL;
+ }
+ std::copy( rArgs.begin(), rArgs.end(), pObjDescr + nExtraArgs );
+ xObj.set( xFactory->createInstanceInitNew(
+ rClassId, OUString(), pImpl->mxStorage, rNewName,
+ aObjDescr ), uno::UNO_QUERY );
+
+ AddEmbeddedObject( xObj, rNewName );
+
+ OSL_ENSURE( !xObj.is() || xObj->getCurrentState() != embed::EmbedStates::LOADED,
+ "A freshly create object should be running always!" );
+ }
+ catch (uno::Exception const& e)
+ {
+ SAL_WARN("comphelper.container", "EmbeddedObjectContainer::CreateEmbeddedObject: exception caught: " << e);
+ }
+
+ return xObj;
+}
+
+uno::Reference < embed::XEmbeddedObject > EmbeddedObjectContainer::CreateEmbeddedObject( const uno::Sequence < sal_Int8 >& rClassId, OUString& rNewName, OUString const* pBaseURL )
+{
+ return CreateEmbeddedObject( rClassId, uno::Sequence < beans::PropertyValue >(), rNewName, pBaseURL );
+}
+
+void EmbeddedObjectContainer::AddEmbeddedObject( const css::uno::Reference < css::embed::XEmbeddedObject >& xObj, const OUString& rName )
+{
+#if OSL_DEBUG_LEVEL > 1
+ SAL_WARN_IF( rName.isEmpty(), "comphelper.container", "Added object doesn't have a name!");
+ uno::Reference < container::XNameAccess > xAccess( pImpl->mxStorage, uno::UNO_QUERY );
+ uno::Reference < embed::XEmbedPersist > xEmb( xObj, uno::UNO_QUERY );
+ uno::Reference < embed::XLinkageSupport > xLink( xEmb, uno::UNO_QUERY );
+ // if the object has a persistence and the object is not a link than it must have persistence entry in the storage
+ OSL_ENSURE( !( xEmb.is() && ( !xLink.is() || !xLink->isLink() ) ) || xAccess->hasByName(rName),
+ "Added element not in storage!" );
+#endif
+
+ // remember object - it needs to be in storage already
+ auto aIt = pImpl->maNameToObjectMap.find( rName );
+ OSL_ENSURE( aIt == pImpl->maNameToObjectMap.end(), "Element already inserted!" );
+ pImpl->maNameToObjectMap[ rName ] = xObj;
+ pImpl->maObjectToNameMap[ xObj ] = rName;
+ uno::Reference < container::XChild > xChild( xObj, uno::UNO_QUERY );
+ if ( xChild.is() && xChild->getParent() != pImpl->m_xModel.get() )
+ xChild->setParent( pImpl->m_xModel.get() );
+
+ // look for object in temporary container
+ if ( !pImpl->mpTempObjectContainer )
+ return;
+
+ auto& rObjectContainer = pImpl->mpTempObjectContainer->pImpl->maNameToObjectMap;
+ auto aIter = std::find_if(rObjectContainer.begin(), rObjectContainer.end(),
+ [&xObj](const EmbeddedObjectContainerNameMap::value_type& rEntry) { return rEntry.second == xObj; });
+ if (aIter == rObjectContainer.end())
+ return;
+
+ // copy replacement image from temporary container (if there is any)
+ OUString aTempName = aIter->first;
+ OUString aMediaType;
+ uno::Reference < io::XInputStream > xStream = pImpl->mpTempObjectContainer->GetGraphicStream( xObj, &aMediaType );
+ if ( xStream.is() )
+ {
+ InsertGraphicStream( xStream, rName, aMediaType );
+ xStream = nullptr;
+ pImpl->mpTempObjectContainer->RemoveGraphicStream( aTempName );
+ }
+
+ // remove object from storage of temporary container
+ uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY );
+ if ( xPersist.is() )
+ {
+ try
+ {
+ pImpl->mpTempObjectContainer->pImpl->mxStorage->removeElement( aTempName );
+ }
+ catch (const uno::Exception&)
+ {
+ }
+ }
+
+ // temp. container needs to forget the object
+ pImpl->mpTempObjectContainer->pImpl->maObjectToNameMap.erase( aIter->second );
+ pImpl->mpTempObjectContainer->pImpl->maNameToObjectMap.erase( aIter );
+}
+
+bool EmbeddedObjectContainer::StoreEmbeddedObject(
+ const uno::Reference < embed::XEmbeddedObject >& xObj, OUString& rName, bool bCopy,
+ const OUString& rSrcShellID, const OUString& rDestShellID )
+{
+ uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY );
+ if ( rName.isEmpty() )
+ rName = CreateUniqueObjectName();
+
+#if OSL_DEBUG_LEVEL > 1
+ uno::Reference < container::XNameAccess > xAccess( pImpl->mxStorage, uno::UNO_QUERY );
+ OSL_ENSURE( !xPersist.is() || !xAccess->hasByName(rName), "Inserting element already present in storage!" );
+ OSL_ENSURE( xPersist.is() || xObj->getCurrentState() == embed::EmbedStates::RUNNING, "Non persistent object inserted!");
+#endif
+
+ // insert objects' storage into the container storage (if object has one)
+ try
+ {
+ if ( xPersist.is() )
+ {
+ uno::Sequence < beans::PropertyValue > aSeq;
+ if ( bCopy )
+ {
+ auto aObjArgs(::comphelper::InitPropertySequence({
+ { "SourceShellID", uno::Any(rSrcShellID) },
+ { "DestinationShellID", uno::Any(rDestShellID) }
+ }));
+ xPersist->storeToEntry(pImpl->mxStorage, rName, aSeq, aObjArgs);
+ }
+ else
+ {
+ //TODO/LATER: possible optimization, don't store immediately
+ //xPersist->setPersistentEntry( pImpl->mxStorage, rName, embed::EntryInitModes::ENTRY_NO_INIT, aSeq, aSeq );
+ xPersist->storeAsEntry( pImpl->mxStorage, rName, aSeq, aSeq );
+ xPersist->saveCompleted( true );
+ }
+ }
+ }
+ catch (uno::Exception const& e)
+ {
+ SAL_WARN("comphelper.container", "EmbeddedObjectContainer::StoreEmbeddedObject: exception caught: " << e);
+ // TODO/LATER: better error recovery should keep storage intact
+ return false;
+ }
+
+ return true;
+}
+
+bool EmbeddedObjectContainer::InsertEmbeddedObject( const uno::Reference < embed::XEmbeddedObject >& xObj, OUString& rName )
+{
+ // store it into the container storage
+ if (StoreEmbeddedObject(xObj, rName, false, OUString(), OUString()))
+ {
+ // remember object
+ AddEmbeddedObject( xObj, rName );
+ return true;
+ }
+ else
+ return false;
+}
+
+uno::Reference < embed::XEmbeddedObject > EmbeddedObjectContainer::InsertEmbeddedObject( const uno::Reference < io::XInputStream >& xStm, OUString& rNewName )
+{
+ if ( rNewName.isEmpty() )
+ rNewName = CreateUniqueObjectName();
+
+ // store it into the container storage
+ bool bIsStorage = false;
+ try
+ {
+ // first try storage persistence
+ uno::Reference < embed::XStorage > xStore = ::comphelper::OStorageHelper::GetStorageFromInputStream( xStm );
+
+ // storage was created from stream successfully
+ bIsStorage = true;
+
+ uno::Reference < embed::XStorage > xNewStore = pImpl->mxStorage->openStorageElement( rNewName, embed::ElementModes::READWRITE );
+ xStore->copyToStorage( xNewStore );
+ }
+ catch (const uno::Exception&)
+ {
+ if ( bIsStorage )
+ // it is storage persistence, but opening of new substorage or copying to it failed
+ return uno::Reference < embed::XEmbeddedObject >();
+
+ // stream didn't contain a storage, now try stream persistence
+ try
+ {
+ uno::Reference < io::XStream > xNewStream = pImpl->mxStorage->openStreamElement( rNewName, embed::ElementModes::READWRITE );
+ ::comphelper::OStorageHelper::CopyInputToOutput( xStm, xNewStream->getOutputStream() );
+
+ // No mediatype is provided so the default for OLE objects value is used
+ // it is correct so for now, but what if somebody introduces a new stream based embedded object?
+ // Probably introducing of such an object must be restricted ( a storage must be used! ).
+ uno::Reference< beans::XPropertySet > xProps( xNewStream, uno::UNO_QUERY_THROW );
+ xProps->setPropertyValue("MediaType",
+ uno::Any( OUString( "application/vnd.sun.star.oleobject" ) ) );
+ }
+ catch (uno::Exception const& e)
+ {
+ // complete disaster!
+ SAL_WARN("comphelper.container", "EmbeddedObjectContainer::InsertEmbeddedObject: exception caught: " << e);
+ return uno::Reference < embed::XEmbeddedObject >();
+ }
+ }
+
+ // stream was copied into the container storage in either way, now try to open something form it
+ uno::Reference < embed::XEmbeddedObject > xRet = GetEmbeddedObject( rNewName );
+ try
+ {
+ if ( !xRet.is() )
+ // no object could be created, so withdraw insertion
+ pImpl->mxStorage->removeElement( rNewName );
+ }
+ catch (const uno::Exception&)
+ {
+ }
+
+ return xRet;
+}
+
+uno::Reference < embed::XEmbeddedObject > EmbeddedObjectContainer::InsertEmbeddedObject( const css::uno::Sequence < css::beans::PropertyValue >& aMedium, OUString& rNewName, OUString const* pBaseURL )
+{
+ if ( rNewName.isEmpty() )
+ rNewName = CreateUniqueObjectName();
+
+ uno::Reference < embed::XEmbeddedObject > xObj;
+ try
+ {
+ uno::Reference < embed::XEmbeddedObjectCreator > xFactory = embed::EmbeddedObjectCreator::create( ::comphelper::getProcessComponentContext() );
+ uno::Sequence< beans::PropertyValue > aObjDescr(pBaseURL ? 2 : 1);
+ auto pObjDescr = aObjDescr.getArray();
+ pObjDescr[0].Name = "Parent";
+ pObjDescr[0].Value <<= pImpl->m_xModel.get();
+ if (pBaseURL)
+ {
+ pObjDescr[1].Name = "DefaultParentBaseURL";
+ pObjDescr[1].Value <<= *pBaseURL;
+ }
+ xObj.set( xFactory->createInstanceInitFromMediaDescriptor(
+ pImpl->mxStorage, rNewName, aMedium, aObjDescr ), uno::UNO_QUERY );
+ uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY );
+
+ OSL_ENSURE( !xObj.is() || xObj->getCurrentState() != embed::EmbedStates::LOADED,
+ "A freshly create object should be running always!" );
+
+ // possible optimization: store later!
+ if ( xPersist.is())
+ xPersist->storeOwn();
+
+ AddEmbeddedObject( xObj, rNewName );
+ }
+ catch (const uno::Exception&)
+ {
+ }
+
+ return xObj;
+}
+
+uno::Reference < embed::XEmbeddedObject > EmbeddedObjectContainer::InsertEmbeddedLink( const css::uno::Sequence < css::beans::PropertyValue >& aMedium, OUString& rNewName )
+{
+ if ( rNewName.isEmpty() )
+ rNewName = CreateUniqueObjectName();
+
+ uno::Reference < embed::XEmbeddedObject > xObj;
+ try
+ {
+ uno::Reference < embed::XEmbeddedObjectCreator > xFactory = embed::EmbeddedObjectCreator::create(::comphelper::getProcessComponentContext());
+ uno::Sequence< beans::PropertyValue > aObjDescr{ comphelper::makePropertyValue(
+ "Parent", pImpl->m_xModel.get()) };
+ xObj.set( xFactory->createInstanceLink( pImpl->mxStorage, rNewName, aMedium, aObjDescr ), uno::UNO_QUERY );
+
+ uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY );
+
+ OSL_ENSURE( !xObj.is() || xObj->getCurrentState() != embed::EmbedStates::LOADED,
+ "A freshly create object should be running always!" );
+
+ // possible optimization: store later!
+ if ( xPersist.is())
+ xPersist->storeOwn();
+
+ AddEmbeddedObject( xObj, rNewName );
+ }
+ catch (uno::Exception const& e)
+ {
+ SAL_WARN("comphelper.container", "EmbeddedObjectContainer::InsertEmbeddedLink: "
+ "exception caught: " << e);
+ }
+
+ return xObj;
+}
+
+bool EmbeddedObjectContainer::TryToCopyGraphReplacement( EmbeddedObjectContainer& rSrc,
+ const OUString& aOrigName,
+ const OUString& aTargetName )
+{
+ bool bResult = false;
+
+ if ( ( &rSrc != this || aOrigName != aTargetName ) && !aOrigName.isEmpty() && !aTargetName.isEmpty() )
+ {
+ OUString aMediaType;
+ uno::Reference < io::XInputStream > xGrStream = rSrc.GetGraphicStream( aOrigName, &aMediaType );
+ if ( xGrStream.is() )
+ bResult = InsertGraphicStream( xGrStream, aTargetName, aMediaType );
+ }
+
+ return bResult;
+}
+
+uno::Reference < embed::XEmbeddedObject > EmbeddedObjectContainer::CopyAndGetEmbeddedObject(
+ EmbeddedObjectContainer& rSrc, const uno::Reference <embed::XEmbeddedObject>& xObj, OUString& rName,
+ const OUString& rSrcShellID, const OUString& rDestShellID )
+{
+ uno::Reference< embed::XEmbeddedObject > xResult;
+
+ // TODO/LATER: For now only objects that implement XEmbedPersist have a replacement image, it might change in future
+ // do an incompatible change so that object name is provided in all the move and copy methods
+ OUString aOrigName;
+ try
+ {
+ uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY_THROW );
+ aOrigName = xPersist->getEntryName();
+ }
+ catch (const uno::Exception&)
+ {
+ }
+
+ if ( rName.isEmpty() )
+ rName = CreateUniqueObjectName();
+
+ // objects without persistence are not really stored by the method
+ if (xObj.is() && StoreEmbeddedObject(xObj, rName, true, rSrcShellID, rDestShellID))
+ {
+ SAL_INFO_IF(rDestShellID.isEmpty(), "comphelper.container",
+ "SfxObjectShell with no base URL?"); // every shell has a base URL, except the clipboard SwDocShell
+ xResult = Get_Impl(rName, xObj, &rDestShellID);
+ if ( !xResult.is() )
+ {
+ // this is a case when object has no real persistence
+ // in such cases a new object should be explicitly created and initialized with the data of the old one
+ try
+ {
+ uno::Reference< embed::XLinkageSupport > xOrigLinkage( xObj, uno::UNO_QUERY );
+ if ( xOrigLinkage.is() && xOrigLinkage->isLink() )
+ {
+ // this is an OOo link, it has no persistence
+ OUString aURL = xOrigLinkage->getLinkURL();
+ if ( aURL.isEmpty() )
+ throw uno::RuntimeException();
+
+ // create new linked object from the URL the link is based on
+ uno::Reference < embed::XEmbeddedObjectCreator > xCreator =
+ embed::EmbeddedObjectCreator::create( ::comphelper::getProcessComponentContext() );
+
+ uno::Sequence< beans::PropertyValue > aMediaDescr{ comphelper::makePropertyValue(
+ "URL", aURL) };
+ uno::Sequence< beans::PropertyValue > aObjDescr{ comphelper::makePropertyValue(
+ "Parent", pImpl->m_xModel.get()) };
+ xResult.set(xCreator->createInstanceLink(
+ pImpl->mxStorage,
+ rName,
+ aMediaDescr,
+ aObjDescr ),
+ uno::UNO_QUERY_THROW );
+ }
+ else
+ {
+ // the component is required for copying of this object
+ if ( xObj->getCurrentState() == embed::EmbedStates::LOADED )
+ xObj->changeState( embed::EmbedStates::RUNNING );
+
+ // this must be an object based on properties, otherwise we can not copy it currently
+ uno::Reference< beans::XPropertySet > xOrigProps( xObj->getComponent(), uno::UNO_QUERY_THROW );
+
+ // use object class ID to create a new one and transfer all the properties
+ uno::Reference < embed::XEmbeddedObjectCreator > xCreator =
+ embed::EmbeddedObjectCreator::create( ::comphelper::getProcessComponentContext() );
+
+ uno::Sequence< beans::PropertyValue > aObjDescr{ comphelper::makePropertyValue(
+ "Parent", pImpl->m_xModel.get()) };
+ xResult.set(xCreator->createInstanceInitNew(
+ xObj->getClassID(),
+ xObj->getClassName(),
+ pImpl->mxStorage,
+ rName,
+ aObjDescr ),
+ uno::UNO_QUERY_THROW );
+
+ if ( xResult->getCurrentState() == embed::EmbedStates::LOADED )
+ xResult->changeState( embed::EmbedStates::RUNNING );
+
+ uno::Reference< beans::XPropertySet > xTargetProps( xResult->getComponent(), uno::UNO_QUERY_THROW );
+
+ // copy all the properties from xOrigProps to xTargetProps
+ uno::Reference< beans::XPropertySetInfo > xOrigInfo = xOrigProps->getPropertySetInfo();
+ if ( !xOrigInfo.is() )
+ throw uno::RuntimeException();
+
+ const uno::Sequence< beans::Property > aPropertiesList = xOrigInfo->getProperties();
+ for ( const auto & p : aPropertiesList )
+ {
+ try
+ {
+ xTargetProps->setPropertyValue(
+ p.Name,
+ xOrigProps->getPropertyValue( p.Name ) );
+ }
+ catch (const beans::PropertyVetoException&)
+ {
+ // impossibility to copy readonly property is not treated as an error for now
+ // but the assertion is helpful to detect such scenarios and review them
+ SAL_WARN( "comphelper.container", "Could not copy readonly property!" );
+ }
+ }
+ }
+
+ if ( xResult.is() )
+ AddEmbeddedObject( xResult, rName );
+ }
+ catch (const uno::Exception&)
+ {
+ if ( xResult.is() )
+ {
+ try
+ {
+ xResult->close( true );
+ }
+ catch (const uno::Exception&)
+ {
+ }
+ xResult.clear();
+ }
+ }
+ }
+ }
+
+ SAL_WARN_IF( !xResult.is(), "comphelper.container", "Can not copy embedded object that has no persistence!" );
+
+ if ( xResult.is() )
+ {
+ // the object is successfully copied, try to copy graphical replacement
+ if ( !aOrigName.isEmpty() )
+ TryToCopyGraphReplacement( rSrc, aOrigName, rName );
+
+ // the object might need the size to be set
+ try
+ {
+ if ( xResult->getStatus( embed::Aspects::MSOLE_CONTENT ) & embed::EmbedMisc::EMBED_NEEDSSIZEONLOAD )
+ xResult->setVisualAreaSize( embed::Aspects::MSOLE_CONTENT,
+ xObj->getVisualAreaSize( embed::Aspects::MSOLE_CONTENT ) );
+ }
+ catch (const uno::Exception&)
+ {
+ }
+ }
+
+ return xResult;
+}
+
+// #i119941, bKeepToTempStorage: use to specify whether store the removed object to temporary storage+
+void EmbeddedObjectContainer::RemoveEmbeddedObject( const OUString& rName, bool bKeepToTempStorage )
+{
+ uno::Reference < embed::XEmbeddedObject > xObj = GetEmbeddedObject( rName );
+ if ( xObj.is() )
+ RemoveEmbeddedObject( xObj, bKeepToTempStorage );
+}
+
+bool EmbeddedObjectContainer::MoveEmbeddedObject( const OUString& rName, EmbeddedObjectContainer& rCnt )
+{
+ // find object entry
+ auto aIt2 = rCnt.pImpl->maNameToObjectMap.find( rName );
+ OSL_ENSURE( aIt2 == rCnt.pImpl->maNameToObjectMap.end(), "Object does already exist in target container!" );
+
+ if ( aIt2 != rCnt.pImpl->maNameToObjectMap.end() )
+ return false;
+
+ uno::Reference < embed::XEmbeddedObject > xObj;
+ auto aIt = pImpl->maNameToObjectMap.find( rName );
+ if ( aIt != pImpl->maNameToObjectMap.end() )
+ {
+ xObj = (*aIt).second;
+ try
+ {
+ if ( xObj.is() )
+ {
+ // move object
+ OUString aName( rName );
+ rCnt.InsertEmbeddedObject( xObj, aName );
+ pImpl->maObjectToNameMap.erase( aIt->second );
+ pImpl->maNameToObjectMap.erase( aIt );
+ uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY );
+ if ( xPersist.is() )
+ pImpl->mxStorage->removeElement( rName );
+ }
+ else
+ {
+ // copy storages; object *must* have persistence!
+ uno::Reference < embed::XStorage > xOld = pImpl->mxStorage->openStorageElement( rName, embed::ElementModes::READ );
+ uno::Reference < embed::XStorage > xNew = rCnt.pImpl->mxStorage->openStorageElement( rName, embed::ElementModes::READWRITE );
+ xOld->copyToStorage( xNew );
+ }
+
+ rCnt.TryToCopyGraphReplacement( *this, rName, rName );
+ // RemoveGraphicStream( rName );
+
+ return true;
+ }
+ catch (const uno::Exception&)
+ {
+ SAL_WARN( "comphelper.container", "Could not move object!");
+ return false;
+ }
+
+ }
+ else
+ SAL_WARN( "comphelper.container", "Unknown object!");
+ return false;
+}
+
+// #i119941, bKeepToTempStorage: use to specify whether store the removed object to temporary storage+
+bool EmbeddedObjectContainer::RemoveEmbeddedObject( const uno::Reference < embed::XEmbeddedObject >& xObj, bool bKeepToTempStorage )
+{
+ uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY );
+ OUString aName;
+ if ( xPersist.is() )
+ aName = xPersist->getEntryName();
+
+#if OSL_DEBUG_LEVEL > 1
+ uno::Reference < container::XNameAccess > xAccess( pImpl->mxStorage, uno::UNO_QUERY );
+ uno::Reference < embed::XLinkageSupport > xLink( xPersist, uno::UNO_QUERY );
+ sal_Bool bIsNotEmbedded = !xPersist.is() || ( xLink.is() && xLink->isLink() );
+
+ // if the object has a persistence and the object is not a link than it must have persistence entry in the storage
+ OSL_ENSURE( bIsNotEmbedded || xAccess->hasByName(aName), "Removing element not present in storage!" );
+#endif
+
+ // somebody still needs the object, so we must assign a temporary persistence
+ try
+ {
+ if ( xPersist.is() && bKeepToTempStorage ) // #i119941
+ {
+
+ if ( !pImpl->mpTempObjectContainer )
+ {
+ pImpl->mpTempObjectContainer = new EmbeddedObjectContainer();
+ try
+ {
+ // TODO/LATER: in future probably the temporary container will have two storages ( of two formats )
+ // the media type will be provided with object insertion
+ OUString aOrigStorMediaType;
+ uno::Reference< beans::XPropertySet > xStorProps( pImpl->mxStorage, uno::UNO_QUERY_THROW );
+ static constexpr OUStringLiteral s_sMediaType(u"MediaType");
+ xStorProps->getPropertyValue( s_sMediaType ) >>= aOrigStorMediaType;
+
+ SAL_WARN_IF( aOrigStorMediaType.isEmpty(), "comphelper.container", "No valuable media type in the storage!" );
+
+ uno::Reference< beans::XPropertySet > xTargetStorProps(
+ pImpl->mpTempObjectContainer->pImpl->mxStorage,
+ uno::UNO_QUERY_THROW );
+ xTargetStorProps->setPropertyValue( s_sMediaType,uno::Any( aOrigStorMediaType ) );
+ }
+ catch (const uno::Exception&)
+ {
+ SAL_WARN( "comphelper.container", "Can not set the new media type to a storage!" );
+ }
+ }
+
+ OUString aTempName, aMediaType;
+ /* Do not create a new name for a removed object, in the pImpl->mpTempObjectContainer,
+ because the original m_aEntryName of xObj will be overwritten by InsertEmbeddedObject(),
+ so uno::Reference < embed::XEmbeddedObject >& xObj will misbehave in
+ EmbeddedObjectContainer::StoreAsChildren and SfxObjectShell::SaveCompletedChildren
+ and will throw an exception because of objects with the same names! */
+ if( !pImpl->mpTempObjectContainer->HasEmbeddedObject(aName) )
+ aTempName = aName;
+
+ pImpl->mpTempObjectContainer->InsertEmbeddedObject( xObj, aTempName );
+
+ uno::Reference < io::XInputStream > xStream = GetGraphicStream( xObj, &aMediaType );
+ if ( xStream.is() )
+ pImpl->mpTempObjectContainer->InsertGraphicStream( xStream, aTempName, aMediaType );
+
+ // object is stored, so at least it can be set to loaded state
+ xObj->changeState( embed::EmbedStates::LOADED );
+ }
+ else
+ // objects without persistence need to stay in running state if they shall not be closed
+ xObj->changeState( embed::EmbedStates::RUNNING );
+ }
+ catch (const uno::Exception&)
+ {
+ return false;
+ }
+
+ auto aIter = std::find_if(pImpl->maNameToObjectMap.begin(), pImpl->maNameToObjectMap.end(),
+ [&xObj](const EmbeddedObjectContainerNameMap::value_type& rEntry) { return rEntry.second == xObj; });
+ if (aIter != pImpl->maNameToObjectMap.end())
+ {
+ pImpl->maObjectToNameMap.erase( aIter->second );
+ pImpl->maNameToObjectMap.erase( aIter );
+ uno::Reference < container::XChild > xChild( xObj, uno::UNO_QUERY );
+ if ( xChild.is() )
+ xChild->setParent( uno::Reference < uno::XInterface >() );
+ }
+ else
+ SAL_WARN( "comphelper.container", "Object not found for removal!" );
+
+ if ( !xPersist || !bKeepToTempStorage ) // #i119941#
+ return true;
+
+ // remove replacement image (if there is one)
+ RemoveGraphicStream( aName );
+
+ // now it's time to remove the storage from the container storage
+ try
+ {
+#if OSL_DEBUG_LEVEL > 1
+ // if the object has a persistence and the object is not a link than it must have persistence entry in storage
+ OSL_ENSURE( bIsNotEmbedded || pImpl->mxStorage->hasByName( aName ), "The object has no persistence entry in the storage!" );
+#endif
+ if ( xPersist.is() && pImpl->mxStorage->hasByName( aName ) )
+ pImpl->mxStorage->removeElement( aName );
+ }
+ catch (const uno::Exception&)
+ {
+ SAL_WARN( "comphelper.container", "Failed to remove object from storage!" );
+ return false;
+ }
+
+ return true;
+}
+
+void EmbeddedObjectContainer::CloseEmbeddedObject( const uno::Reference < embed::XEmbeddedObject >& xObj )
+{
+ // disconnect the object from the container and close it if possible
+
+ auto aIter = std::find_if(pImpl->maNameToObjectMap.begin(), pImpl->maNameToObjectMap.end(),
+ [&xObj](const EmbeddedObjectContainerNameMap::value_type& rEntry) { return rEntry.second == xObj; });
+ if (aIter == pImpl->maNameToObjectMap.end())
+ return;
+
+ pImpl->maObjectToNameMap.erase( aIter->second );
+ pImpl->maNameToObjectMap.erase( aIter );
+
+ try
+ {
+ xObj->close( true );
+ }
+ catch (const uno::Exception&)
+ {
+ // it is no problem if the object is already closed
+ // TODO/LATER: what if the object can not be closed?
+ }
+}
+
+uno::Reference < io::XInputStream > EmbeddedObjectContainer::GetGraphicStream( const OUString& aName, OUString* pMediaType )
+{
+ uno::Reference < io::XInputStream > xStream;
+
+ SAL_WARN_IF( aName.isEmpty(), "comphelper.container", "Retrieving graphic for unknown object!" );
+ if ( !aName.isEmpty() )
+ {
+ try
+ {
+ uno::Reference < embed::XStorage > xReplacements = pImpl->GetReplacements();
+ uno::Reference < io::XStream > xGraphicStream = xReplacements->openStreamElement( aName, embed::ElementModes::READ );
+ xStream = xGraphicStream->getInputStream();
+ if ( pMediaType )
+ {
+ uno::Reference < beans::XPropertySet > xSet( xStream, uno::UNO_QUERY );
+ if ( xSet.is() )
+ {
+ uno::Any aAny = xSet->getPropertyValue("MediaType");
+ aAny >>= *pMediaType;
+ }
+ }
+ }
+ catch (uno::Exception const& e)
+ {
+ SAL_INFO("comphelper.container",
+ "EmbeddedObjectContainer::GetGraphicStream(): " << e);
+ }
+ }
+
+ return xStream;
+}
+
+uno::Reference < io::XInputStream > EmbeddedObjectContainer::GetGraphicStream( const css::uno::Reference < css::embed::XEmbeddedObject >& xObj, OUString* pMediaType )
+{
+ // try to load it from the container storage
+ return GetGraphicStream( GetEmbeddedObjectName( xObj ), pMediaType );
+}
+
+bool EmbeddedObjectContainer::InsertGraphicStream( const css::uno::Reference < css::io::XInputStream >& rStream, const OUString& rObjectName, const OUString& rMediaType )
+{
+ try
+ {
+ uno::Reference < embed::XStorage > xReplacements = pImpl->GetReplacements();
+
+ // store it into the subfolder
+ uno::Reference < io::XOutputStream > xOutStream;
+ uno::Reference < io::XStream > xGraphicStream = xReplacements->openStreamElement( rObjectName,
+ embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE );
+ xOutStream = xGraphicStream->getOutputStream();
+ ::comphelper::OStorageHelper::CopyInputToOutput( rStream, xOutStream );
+ xOutStream->flush();
+
+ uno::Reference< beans::XPropertySet > xPropSet( xGraphicStream, uno::UNO_QUERY_THROW );
+
+ xPropSet->setPropertyValue("UseCommonStoragePasswordEncryption",
+ uno::Any( true ) );
+ xPropSet->setPropertyValue("MediaType", uno::Any(rMediaType) );
+
+ xPropSet->setPropertyValue("Compressed",
+ uno::Any( true ) );
+ }
+ catch (const uno::Exception&)
+ {
+ return false;
+ }
+
+ return true;
+}
+
+bool EmbeddedObjectContainer::InsertGraphicStreamDirectly( const css::uno::Reference < css::io::XInputStream >& rStream, const OUString& rObjectName, const OUString& rMediaType )
+{
+ try
+ {
+ uno::Reference < embed::XStorage > xReplacement = pImpl->GetReplacements();
+ uno::Reference < embed::XOptimizedStorage > xOptRepl( xReplacement, uno::UNO_QUERY_THROW );
+
+ // store it into the subfolder
+ uno::Sequence< beans::PropertyValue > aProps{
+ comphelper::makePropertyValue("MediaType", rMediaType),
+ comphelper::makePropertyValue("UseCommonStoragePasswordEncryption", true),
+ comphelper::makePropertyValue("Compressed", true)
+ };
+
+ if ( xReplacement->hasByName( rObjectName ) )
+ xReplacement->removeElement( rObjectName );
+
+ xOptRepl->insertStreamElementDirect( rObjectName, rStream, aProps );
+ }
+ catch (const uno::Exception&)
+ {
+ return false;
+ }
+
+ return true;
+}
+
+
+void EmbeddedObjectContainer::RemoveGraphicStream( const OUString& rObjectName )
+{
+ try
+ {
+ uno::Reference < embed::XStorage > xReplacements = pImpl->GetReplacements();
+ xReplacements->removeElement( rObjectName );
+ }
+ catch (const uno::Exception&)
+ {
+ }
+}
+namespace {
+ void InsertStreamIntoPicturesStorage_Impl( const uno::Reference< embed::XStorage >& xDocStor,
+ const uno::Reference< io::XInputStream >& xInStream,
+ const OUString& aStreamName )
+ {
+ OSL_ENSURE( !aStreamName.isEmpty() && xInStream.is() && xDocStor.is(), "Misuse of the method!" );
+
+ try
+ {
+ uno::Reference< embed::XStorage > xPictures = xDocStor->openStorageElement(
+ "Pictures",
+ embed::ElementModes::READWRITE );
+ uno::Reference< io::XStream > xObjReplStr = xPictures->openStreamElement(
+ aStreamName,
+ embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE );
+ uno::Reference< io::XOutputStream > xOutStream(
+ xObjReplStr->getInputStream(), uno::UNO_QUERY_THROW );
+
+ ::comphelper::OStorageHelper::CopyInputToOutput( xInStream, xOutStream );
+ xOutStream->closeOutput();
+
+ uno::Reference< embed::XTransactedObject > xTransact( xPictures, uno::UNO_QUERY );
+ if ( xTransact.is() )
+ xTransact->commit();
+ }
+ catch (const uno::Exception&)
+ {
+ SAL_WARN( "comphelper.container", "The images storage is not available!" );
+ }
+ }
+
+}
+
+bool EmbeddedObjectContainer::StoreAsChildren(bool _bOasisFormat,bool _bCreateEmbedded, bool _bAutoSaveEvent,
+ const uno::Reference < embed::XStorage >& _xStorage)
+{
+ bool bResult = false;
+ try
+ {
+ comphelper::EmbeddedObjectContainer aCnt( _xStorage );
+ const uno::Sequence < OUString > aNames = GetObjectNames();
+ const OUString* pIter = aNames.getConstArray();
+ const OUString* pEnd = pIter + aNames.getLength();
+ for(;pIter != pEnd;++pIter)
+ {
+ uno::Reference < embed::XEmbeddedObject > xObj = GetEmbeddedObject( *pIter );
+ SAL_WARN_IF( !xObj.is(), "comphelper.container", "An empty entry in the embedded objects list!" );
+ if ( xObj.is() )
+ {
+ bool bSwitchBackToLoaded = false;
+ uno::Reference< embed::XLinkageSupport > xLink( xObj, uno::UNO_QUERY );
+
+ uno::Reference < io::XInputStream > xStream;
+ OUString aMediaType;
+
+ sal_Int32 nCurState = xObj->getCurrentState();
+ if ( nCurState == embed::EmbedStates::LOADED || nCurState == embed::EmbedStates::RUNNING )
+ {
+ // means that the object is not active
+ // copy replacement image from old to new container
+ xStream = GetGraphicStream( xObj, &aMediaType );
+ }
+
+ if ( !xStream.is() && getUserAllowsLinkUpdate() )
+ {
+ // the image must be regenerated
+ // TODO/LATER: another aspect could be used
+ if ( xObj->getCurrentState() == embed::EmbedStates::LOADED )
+ bSwitchBackToLoaded = true;
+
+ xStream = GetGraphicReplacementStream(
+ embed::Aspects::MSOLE_CONTENT,
+ xObj,
+ &aMediaType );
+ }
+
+ if ( _bOasisFormat || (xLink.is() && xLink->isLink()) )
+ {
+ if ( xStream.is() )
+ {
+ if ( _bOasisFormat )
+ {
+ // if it is an embedded object or the optimized inserting fails the normal inserting should be done
+ if ( _bCreateEmbedded
+ || !aCnt.InsertGraphicStreamDirectly( xStream, *pIter, aMediaType ) )
+ aCnt.InsertGraphicStream( xStream, *pIter, aMediaType );
+ }
+ else
+ {
+ // it is a linked object exported into SO7 format
+ InsertStreamIntoPicturesStorage_Impl( _xStorage, xStream, *pIter );
+ }
+ }
+ }
+
+ uno::Reference< embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY );
+ if ( xPersist.is() )
+ {
+ uno::Sequence< beans::PropertyValue > aArgs( _bOasisFormat ? 3 : 4 );
+ auto pArgs = aArgs.getArray();
+ pArgs[0].Name = "StoreVisualReplacement";
+ pArgs[0].Value <<= !_bOasisFormat;
+
+ // if it is an embedded object or the optimized inserting fails the normal inserting should be done
+ pArgs[1].Name = "CanTryOptimization";
+ pArgs[1].Value <<= !_bCreateEmbedded;
+
+ pArgs[2].Name = "AutoSaveEvent";
+ pArgs[2].Value <<= _bAutoSaveEvent;
+
+ if ( !_bOasisFormat )
+ {
+ // if object has no cached replacement it will use this one
+ pArgs[3].Name = "VisualReplacement";
+ pArgs[3].Value <<= xStream;
+ }
+
+ try
+ {
+ xPersist->storeAsEntry( _xStorage, xPersist->getEntryName(), uno::Sequence< beans::PropertyValue >(), aArgs );
+ }
+ catch (const embed::WrongStateException&)
+ {
+ SAL_WARN("comphelper.container", "failed to store '" << *pIter << "'");
+ }
+ }
+
+ if ( bSwitchBackToLoaded )
+ // switch back to loaded state; that way we have a minimum cache confusion
+ xObj->changeState( embed::EmbedStates::LOADED );
+ }
+ }
+
+ bResult = aCnt.CommitImageSubStorage();
+
+ }
+ catch (const uno::Exception& e)
+ {
+ // TODO/LATER: error handling
+ bResult = false;
+ SAL_WARN("comphelper.container", "failed. Message: " << e);
+ }
+
+ // the old SO6 format does not store graphical replacements
+ if ( !_bOasisFormat && bResult )
+ {
+ try
+ {
+ // the substorage still can not be locked by the embedded object container
+ OUString aObjReplElement( "ObjectReplacements" );
+ if ( _xStorage->hasByName( aObjReplElement ) && _xStorage->isStorageElement( aObjReplElement ) )
+ _xStorage->removeElement( aObjReplElement );
+ }
+ catch (const uno::Exception&)
+ {
+ // TODO/LATER: error handling;
+ bResult = false;
+ }
+ }
+ return bResult;
+}
+
+bool EmbeddedObjectContainer::StoreChildren(bool _bOasisFormat,bool _bObjectsOnly)
+{
+ bool bResult = true;
+ const uno::Sequence < OUString > aNames = GetObjectNames();
+ const OUString* pIter = aNames.getConstArray();
+ const OUString* pEnd = pIter + aNames.getLength();
+ for(;pIter != pEnd;++pIter)
+ {
+ try
+ {
+ uno::Reference < embed::XEmbeddedObject > xObj = GetEmbeddedObject( *pIter );
+ SAL_WARN_IF( !xObj.is(), "comphelper.container", "An empty entry in the embedded objects list!" );
+ if ( xObj.is() )
+ {
+ sal_Int32 nCurState = xObj->getCurrentState();
+ if ( _bOasisFormat && nCurState != embed::EmbedStates::LOADED && nCurState != embed::EmbedStates::RUNNING )
+ {
+ // means that the object is active
+ // the image must be regenerated
+ OUString aMediaType;
+
+ // TODO/LATER: another aspect could be used
+ uno::Reference < io::XInputStream > xStream =
+ GetGraphicReplacementStream(
+ embed::Aspects::MSOLE_CONTENT,
+ xObj,
+ &aMediaType );
+ if ( xStream.is() )
+ {
+ if ( !InsertGraphicStreamDirectly( xStream, *pIter, aMediaType ) )
+ InsertGraphicStream( xStream, *pIter, aMediaType );
+ }
+ }
+
+ // TODO/LATER: currently the object by default does not cache replacement image
+ // that means that if somebody loads SO7 document and store its objects using
+ // this method the images might be lost.
+ // Currently this method is only used on storing to alien formats, that means
+ // that SO7 documents storing does not use it, and all other filters are
+ // based on OASIS format. But if it changes the method must be fixed. The fix
+ // must be done only on demand since it can affect performance.
+
+ uno::Reference< embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY );
+ if ( xPersist.is() )
+ {
+ try
+ {
+ //TODO/LATER: only storing if changed!
+ //xPersist->storeOwn(); //commented, i120168
+
+ // begin:all charts will be persisted as xml format on disk when saving, which is time consuming.
+ // '_bObjectsOnly' mean we are storing to alien formats.
+ // 'isStorageElement' mean current object is NOT a MS OLE format. (may also include in future), i120168
+ if (_bObjectsOnly && (nCurState == embed::EmbedStates::LOADED || nCurState == embed::EmbedStates::RUNNING)
+ && (pImpl->mxStorage->isStorageElement( *pIter ) ))
+ {
+ uno::Reference< util::XModifiable > xModifiable( xObj->getComponent(), uno::UNO_QUERY );
+ if ( xModifiable.is() && xModifiable->isModified())
+ {
+ xPersist->storeOwn();
+ }
+ else
+ {
+ //do nothing. Embedded model is not modified, no need to persist.
+ }
+ }
+ else //the embedded object is in active status, always store back it.
+ {
+ xPersist->storeOwn();
+ }
+ //end i120168
+ }
+ catch (const uno::Exception&)
+ {
+ // TODO/LATER: error handling
+ bResult = false;
+ break;
+ }
+ }
+
+ if ( !_bOasisFormat && !_bObjectsOnly )
+ {
+ // copy replacement images for linked objects
+ try
+ {
+ uno::Reference< embed::XLinkageSupport > xLink( xObj, uno::UNO_QUERY );
+ if ( xLink.is() && xLink->isLink() )
+ {
+ OUString aMediaType;
+ uno::Reference < io::XInputStream > xInStream = GetGraphicStream( xObj, &aMediaType );
+ if ( xInStream.is() )
+ InsertStreamIntoPicturesStorage_Impl( pImpl->mxStorage, xInStream, *pIter );
+ }
+ }
+ catch (const uno::Exception&)
+ {
+ }
+ }
+ }
+ }
+ catch (const uno::Exception&)
+ {
+ // TODO/LATER: error handling
+ }
+ }
+
+ if ( bResult && _bOasisFormat )
+ bResult = CommitImageSubStorage();
+
+ if ( bResult && !_bObjectsOnly )
+ {
+ try
+ {
+ ReleaseImageSubStorage();
+ OUString aObjReplElement( "ObjectReplacements" );
+ if ( !_bOasisFormat && pImpl->mxStorage->hasByName( aObjReplElement ) && pImpl->mxStorage->isStorageElement( aObjReplElement ) )
+ pImpl->mxStorage->removeElement( aObjReplElement );
+ }
+ catch (const uno::Exception&)
+ {
+ // TODO/LATER: error handling
+ bResult = false;
+ }
+ }
+ return bResult;
+}
+
+uno::Reference< io::XInputStream > EmbeddedObjectContainer::GetGraphicReplacementStream(
+ sal_Int64 nViewAspect,
+ const uno::Reference< embed::XEmbeddedObject >& xObj,
+ OUString* pMediaType )
+{
+ uno::Reference< io::XInputStream > xInStream;
+ if ( xObj.is() )
+ {
+ try
+ {
+ // retrieving of the visual representation can switch object to running state
+ embed::VisualRepresentation aRep = xObj->getPreferredVisualRepresentation( nViewAspect );
+ if ( pMediaType )
+ *pMediaType = aRep.Flavor.MimeType;
+
+ uno::Sequence < sal_Int8 > aSeq;
+ aRep.Data >>= aSeq;
+ xInStream = new ::comphelper::SequenceInputStream( aSeq );
+ }
+ catch (const uno::Exception&)
+ {
+ }
+ }
+
+ return xInStream;
+}
+
+bool EmbeddedObjectContainer::SetPersistentEntries(const uno::Reference< embed::XStorage >& _xStorage,bool _bClearModifiedFlag)
+{
+ bool bError = false;
+ const uno::Sequence < OUString > aNames = GetObjectNames();
+ const OUString* pIter = aNames.getConstArray();
+ const OUString* pEnd = pIter + aNames.getLength();
+ for(;pIter != pEnd;++pIter)
+ {
+ uno::Reference < embed::XEmbeddedObject > xObj = GetEmbeddedObject( *pIter );
+ SAL_WARN_IF( !xObj.is(), "comphelper.container", "An empty entry in the embedded objects list!" );
+ if ( xObj.is() )
+ {
+ uno::Reference< embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY );
+ if ( xPersist.is() )
+ {
+ try
+ {
+ xPersist->setPersistentEntry( _xStorage,
+ *pIter,
+ embed::EntryInitModes::NO_INIT,
+ uno::Sequence< beans::PropertyValue >(),
+ uno::Sequence< beans::PropertyValue >() );
+
+ }
+ catch (const uno::Exception&)
+ {
+ // TODO/LATER: error handling
+ bError = true;
+ break;
+ }
+ }
+ if ( _bClearModifiedFlag )
+ {
+ // if this method is used as part of SaveCompleted the object must stay unmodified after execution
+ try
+ {
+ uno::Reference< util::XModifiable > xModif( xObj->getComponent(), uno::UNO_QUERY_THROW );
+ if ( xModif->isModified() )
+ xModif->setModified( false );
+ }
+ catch (const uno::Exception&)
+ {
+ }
+ }
+ }
+ }
+ return bError;
+}
+
+bool EmbeddedObjectContainer::getUserAllowsLinkUpdate() const
+{
+ return pImpl->mbUserAllowsLinkUpdate;
+}
+
+void EmbeddedObjectContainer::setUserAllowsLinkUpdate(bool bNew)
+{
+ if(pImpl->mbUserAllowsLinkUpdate != bNew)
+ {
+ pImpl->mbUserAllowsLinkUpdate = bNew;
+ }
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/container/enumerablemap.cxx b/comphelper/source/container/enumerablemap.cxx
new file mode 100644
index 000000000..6ca7c36d2
--- /dev/null
+++ b/comphelper/source/container/enumerablemap.cxx
@@ -0,0 +1,713 @@
+/* -*- 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 <comphelper/anytostring.hxx>
+#include <comphelper/anycompare.hxx>
+#include <comphelper/componentbase.hxx>
+
+#include <com/sun/star/container/XEnumerableMap.hpp>
+#include <com/sun/star/lang/NoSupportException.hpp>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/ucb/AlreadyInitializedException.hpp>
+#include <com/sun/star/beans/IllegalTypeException.hpp>
+#include <com/sun/star/beans/Pair.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+
+#include <cppuhelper/compbase3.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <typelib/typedescription.hxx>
+
+#include <cmath>
+#include <map>
+#include <memory>
+#include <optional>
+#include <utility>
+
+namespace comphelper
+{
+
+
+ using ::com::sun::star::uno::Reference;
+ using ::com::sun::star::uno::XInterface;
+ using ::com::sun::star::uno::UNO_QUERY;
+ using ::com::sun::star::uno::RuntimeException;
+ using ::com::sun::star::uno::Any;
+ using ::com::sun::star::uno::Sequence;
+ using ::com::sun::star::uno::Type;
+ using ::com::sun::star::container::XEnumerableMap;
+ using ::com::sun::star::lang::NoSupportException;
+ using ::com::sun::star::beans::IllegalTypeException;
+ using ::com::sun::star::container::NoSuchElementException;
+ using ::com::sun::star::lang::IllegalArgumentException;
+ using ::com::sun::star::lang::XInitialization;
+ using ::com::sun::star::ucb::AlreadyInitializedException;
+ using ::com::sun::star::beans::Pair;
+ using ::com::sun::star::uno::TypeClass;
+ using ::com::sun::star::uno::TypeClass_VOID;
+ using ::com::sun::star::uno::TypeClass_UNKNOWN;
+ using ::com::sun::star::uno::TypeClass_ANY;
+ using ::com::sun::star::uno::TypeClass_EXCEPTION;
+ using ::com::sun::star::uno::TypeClass_STRUCT;
+ using ::com::sun::star::uno::TypeClass_FLOAT;
+ using ::com::sun::star::uno::TypeClass_DOUBLE;
+ using ::com::sun::star::uno::TypeClass_INTERFACE;
+ using ::com::sun::star::lang::XServiceInfo;
+ using ::com::sun::star::uno::XComponentContext;
+ using ::com::sun::star::container::XEnumeration;
+ using ::com::sun::star::uno::TypeDescription;
+ using ::com::sun::star::lang::DisposedException;
+
+ namespace {
+
+ class MapEnumerator;
+
+ }
+
+ typedef std::map< Any, Any, LessPredicateAdapter > KeyedValues;
+
+ namespace {
+
+ struct MapData
+ {
+ Type m_aKeyType;
+ Type m_aValueType;
+ std::optional< KeyedValues > m_pValues;
+ std::shared_ptr< IKeyPredicateLess > m_pKeyCompare;
+ bool m_bMutable;
+ std::vector< MapEnumerator* > m_aModListeners;
+
+ MapData()
+ :m_bMutable( true )
+ {
+ }
+
+ MapData( const MapData& _source )
+ :m_aKeyType( _source.m_aKeyType )
+ ,m_aValueType( _source.m_aValueType )
+ ,m_pKeyCompare( _source.m_pKeyCompare )
+ ,m_bMutable( false )
+ {
+ m_pValues.emplace( *_source.m_pValues );
+ }
+ private:
+ MapData& operator=( const MapData& _source ) = delete;
+ };
+
+ }
+
+ static void lcl_registerMapModificationListener( MapData& _mapData, MapEnumerator& _listener )
+ {
+ #if OSL_DEBUG_LEVEL > 0
+ for ( const MapEnumerator* lookup : _mapData.m_aModListeners )
+ {
+ OSL_ENSURE( lookup != &_listener, "lcl_registerMapModificationListener: this listener is already registered!" );
+ }
+ #endif
+ _mapData.m_aModListeners.push_back( &_listener );
+ }
+
+
+ static void lcl_revokeMapModificationListener( MapData& _mapData, MapEnumerator& _listener )
+ {
+ auto lookup = std::find(_mapData.m_aModListeners.begin(), _mapData.m_aModListeners.end(), &_listener);
+ if (lookup != _mapData.m_aModListeners.end())
+ {
+ _mapData.m_aModListeners.erase( lookup );
+ return;
+ }
+ OSL_FAIL( "lcl_revokeMapModificationListener: the listener is not registered!" );
+ }
+
+
+ static void lcl_notifyMapDataListeners_nothrow( const MapData& _mapData );
+
+
+ // EnumerableMap
+
+ typedef ::cppu::WeakAggComponentImplHelper3 < XInitialization
+ , XEnumerableMap
+ , XServiceInfo
+ > Map_IFace;
+
+ namespace {
+
+ class EnumerableMap: public Map_IFace, public ComponentBase
+ {
+ public:
+ EnumerableMap();
+ protected:
+ virtual ~EnumerableMap() override;
+
+ // XInitialization
+ virtual void SAL_CALL initialize( const Sequence< Any >& aArguments ) override;
+
+ // XEnumerableMap
+ virtual css::uno::Reference< css::container::XEnumeration > SAL_CALL createKeyEnumeration( sal_Bool Isolated ) override;
+ virtual css::uno::Reference< css::container::XEnumeration > SAL_CALL createValueEnumeration( sal_Bool Isolated ) override;
+ virtual css::uno::Reference< css::container::XEnumeration > SAL_CALL createElementEnumeration( sal_Bool Isolated ) override;
+
+ // XMap
+ virtual Type SAL_CALL getKeyType() override;
+ virtual Type SAL_CALL getValueType() override;
+ virtual void SAL_CALL clear( ) override;
+ virtual sal_Bool SAL_CALL containsKey( const Any& _key ) override;
+ virtual sal_Bool SAL_CALL containsValue( const Any& _value ) override;
+ virtual Any SAL_CALL get( const Any& _key ) override;
+ virtual Any SAL_CALL put( const Any& _key, const Any& _value ) override;
+ virtual Any SAL_CALL remove( const Any& _key ) override;
+
+ // XElementAccess (base of XMap)
+ virtual Type SAL_CALL getElementType() override;
+ virtual sal_Bool SAL_CALL hasElements() override;
+
+ // XServiceInfo
+ virtual OUString SAL_CALL getImplementationName( ) override;
+ virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+ virtual Sequence< OUString > SAL_CALL getSupportedServiceNames( ) override;
+
+ private:
+ void impl_initValues_throw( const Sequence< Pair< Any, Any > >& _initialValues );
+
+ /// throws an IllegalTypeException if the given value is not compatible with our ValueType
+ void impl_checkValue_throw( const Any& _value ) const;
+ void impl_checkKey_throw( const Any& _key ) const;
+ void impl_checkNaN_throw( const Any& _keyOrValue, const Type& _keyOrValueType ) const;
+ void impl_checkMutable_throw() const;
+
+ private:
+ ::osl::Mutex m_aMutex;
+ MapData m_aData;
+ };
+
+ enum EnumerationType
+ {
+ eKeys, eValues, eBoth
+ };
+
+ class MapEnumerator final
+ {
+ public:
+ MapEnumerator( ::cppu::OWeakObject& _rParent, MapData& _mapData, const EnumerationType _type )
+ :m_rParent( _rParent )
+ ,m_rMapData( _mapData )
+ ,m_eType( _type )
+ ,m_mapPos( _mapData.m_pValues->begin() )
+ ,m_disposed( false )
+ {
+ lcl_registerMapModificationListener( m_rMapData, *this );
+ }
+
+ ~MapEnumerator()
+ {
+ dispose();
+ }
+
+ void dispose()
+ {
+ if ( !m_disposed )
+ {
+ lcl_revokeMapModificationListener( m_rMapData, *this );
+ m_disposed = true;
+ }
+ }
+
+ // noncopyable
+ MapEnumerator(const MapEnumerator&) = delete;
+ const MapEnumerator& operator=(const MapEnumerator&) = delete;
+
+ // XEnumeration equivalents
+ bool hasMoreElements();
+ Any nextElement();
+
+ /// called when the map was modified
+ void mapModified();
+
+ private:
+ ::cppu::OWeakObject& m_rParent;
+ MapData& m_rMapData;
+ const EnumerationType m_eType;
+ KeyedValues::const_iterator m_mapPos;
+ bool m_disposed;
+ };
+
+ }
+
+ static void lcl_notifyMapDataListeners_nothrow( const MapData& _mapData )
+ {
+ for ( MapEnumerator* loop : _mapData.m_aModListeners )
+ {
+ loop->mapModified();
+ }
+ }
+
+ typedef ::cppu::WeakImplHelper < XEnumeration
+ > MapEnumeration_Base;
+
+ namespace {
+
+ class MapEnumeration :public ComponentBase
+ ,public MapEnumeration_Base
+ {
+ public:
+ MapEnumeration( ::cppu::OWeakObject& _parentMap, MapData& _mapData, ::cppu::OBroadcastHelper& _rBHelper,
+ const EnumerationType _type, const bool _isolated )
+ :ComponentBase( _rBHelper, ComponentBase::NoInitializationNeeded() )
+ ,m_xKeepMapAlive( _parentMap )
+ ,m_pMapDataCopy( _isolated ? new MapData( _mapData ) : nullptr )
+ ,m_aEnumerator( *this, _isolated ? *m_pMapDataCopy : _mapData, _type )
+ {
+ }
+
+ // XEnumeration
+ virtual sal_Bool SAL_CALL hasMoreElements( ) override;
+ virtual Any SAL_CALL nextElement( ) override;
+
+ protected:
+ virtual ~MapEnumeration() override
+ {
+ acquire();
+ {
+ ::osl::MutexGuard aGuard( getMutex() );
+ m_aEnumerator.dispose();
+ m_pMapDataCopy.reset();
+ }
+ }
+
+ private:
+ // since we share our mutex with the main map, we need to keep it alive as long as we live
+ Reference< XInterface > m_xKeepMapAlive;
+ std::unique_ptr< MapData > m_pMapDataCopy;
+ MapEnumerator m_aEnumerator;
+ };
+
+ }
+
+ EnumerableMap::EnumerableMap()
+ :Map_IFace( m_aMutex )
+ ,ComponentBase( Map_IFace::rBHelper )
+ {
+ }
+
+
+ EnumerableMap::~EnumerableMap()
+ {
+ if ( !impl_isDisposed() )
+ {
+ acquire();
+ dispose();
+ }
+ }
+
+
+ void SAL_CALL EnumerableMap::initialize( const Sequence< Any >& _arguments )
+ {
+ ComponentMethodGuard aGuard( *this, ComponentMethodGuard::MethodType::WithoutInit );
+ if ( impl_isInitialized_nothrow() )
+ throw AlreadyInitializedException();
+
+ sal_Int32 nArgumentCount = _arguments.getLength();
+ if ( ( nArgumentCount != 2 ) && ( nArgumentCount != 3 ) )
+ throw IllegalArgumentException("wrong number of args", static_cast<cppu::OWeakObject*>(this), 1);
+
+ Type aKeyType, aValueType;
+ if ( !( _arguments[0] >>= aKeyType ) )
+ throw IllegalArgumentException("com.sun.star.uno.Type expected.", *this, 1 );
+ if ( !( _arguments[1] >>= aValueType ) )
+ throw IllegalArgumentException("com.sun.star.uno.Type expected.", *this, 2 );
+
+ Sequence< Pair< Any, Any > > aInitialValues;
+ bool bMutable = true;
+ if ( nArgumentCount == 3 )
+ {
+ if ( !( _arguments[2] >>= aInitialValues ) )
+ throw IllegalArgumentException("[]com.sun.star.beans.Pair<any,any> expected.", *this, 2 );
+ bMutable = false;
+ }
+
+ // for the value, anything is allowed, except VOID
+ if ( ( aValueType.getTypeClass() == TypeClass_VOID ) || ( aValueType.getTypeClass() == TypeClass_UNKNOWN ) )
+ throw IllegalTypeException("Unsupported value type.", *this );
+
+ // create the comparator for the KeyType, and throw if the type is not supported
+ std::unique_ptr< IKeyPredicateLess > pComparator( getStandardLessPredicate( aKeyType, nullptr ) );
+ if (!pComparator)
+ throw IllegalTypeException("Unsupported key type.", *this );
+
+ // init members
+ m_aData.m_aKeyType = aKeyType;
+ m_aData.m_aValueType = aValueType;
+ m_aData.m_pKeyCompare = std::move(pComparator);
+ m_aData.m_pValues.emplace( *m_aData.m_pKeyCompare );
+ m_aData.m_bMutable = bMutable;
+
+ if ( aInitialValues.hasElements() )
+ impl_initValues_throw( aInitialValues );
+
+ setInitialized();
+ }
+
+
+ void EnumerableMap::impl_initValues_throw( const Sequence< Pair< Any, Any > >& _initialValues )
+ {
+ OSL_PRECOND( m_aData.m_pValues && m_aData.m_pValues->empty(), "EnumerableMap::impl_initValues_throw: illegal call!" );
+ if (!m_aData.m_pValues || !m_aData.m_pValues->empty())
+ throw RuntimeException();
+
+ const Pair< Any, Any >* mapping = _initialValues.getConstArray();
+ const Pair< Any, Any >* mappingEnd = mapping + _initialValues.getLength();
+ for ( ; mapping != mappingEnd; ++mapping )
+ {
+ impl_checkValue_throw( mapping->Second );
+ (*m_aData.m_pValues)[ mapping->First ] = mapping->Second;
+ }
+ }
+
+
+ void EnumerableMap::impl_checkValue_throw( const Any& _value ) const
+ {
+ if ( !_value.hasValue() )
+ // nothing to do, NULL values are always allowed, regardless of the ValueType
+ return;
+
+ TypeClass eAllowedTypeClass = m_aData.m_aValueType.getTypeClass();
+ bool bValid = false;
+
+ switch ( eAllowedTypeClass )
+ {
+ default:
+ bValid = ( _value.getValueTypeClass() == eAllowedTypeClass );
+ break;
+ case TypeClass_ANY:
+ bValid = true;
+ break;
+ case TypeClass_INTERFACE:
+ {
+ // special treatment: _value might contain the proper type, but the interface
+ // might actually be NULL. Which is still valid ...
+ if ( m_aData.m_aValueType.isAssignableFrom( _value.getValueType() ) )
+ // this also catches the special case where XFoo is our value type,
+ // and _value contains a NULL-reference to XFoo, or a derived type
+ bValid = true;
+ else
+ {
+ Reference< XInterface > xValue( _value, UNO_QUERY );
+ if ( xValue.is() )
+ // XInterface is not-NULL, but is X(ValueType) not-NULL, too?
+ xValue.set( xValue->queryInterface( m_aData.m_aValueType ), UNO_QUERY );
+ bValid = xValue.is();
+ }
+ }
+ break;
+ case TypeClass_EXCEPTION:
+ case TypeClass_STRUCT:
+ {
+ // values are accepted if and only if their type equals, or is derived from, our value type
+
+ if ( _value.getValueTypeClass() != eAllowedTypeClass )
+ bValid = false;
+ else
+ {
+ const TypeDescription aValueTypeDesc( _value.getValueType() );
+ const TypeDescription aRequiredTypeDesc( m_aData.m_aValueType );
+
+ const _typelib_CompoundTypeDescription* pValueCompoundTypeDesc =
+ reinterpret_cast< const _typelib_CompoundTypeDescription* >( aValueTypeDesc.get() );
+
+ while ( pValueCompoundTypeDesc )
+ {
+ if ( typelib_typedescription_equals( &pValueCompoundTypeDesc->aBase, aRequiredTypeDesc.get() ) )
+ break;
+ pValueCompoundTypeDesc = pValueCompoundTypeDesc->pBaseTypeDescription;
+ }
+ bValid = ( pValueCompoundTypeDesc != nullptr );
+ }
+ }
+ break;
+ }
+
+ if ( !bValid )
+ {
+ throw IllegalTypeException(
+ "Incompatible value type. Found '" + _value.getValueTypeName()
+ + "', where '" + m_aData.m_aValueType.getTypeName()
+ + "' (or compatible type) is expected.",
+ *const_cast< EnumerableMap* >( this ) );
+ }
+
+ impl_checkNaN_throw( _value, m_aData.m_aValueType );
+ }
+
+
+ void EnumerableMap::impl_checkNaN_throw( const Any& _keyOrValue, const Type& _keyOrValueType ) const
+ {
+ if ( ( _keyOrValueType.getTypeClass() == TypeClass_DOUBLE )
+ || ( _keyOrValueType.getTypeClass() == TypeClass_FLOAT )
+ )
+ {
+ double nValue(0);
+ if ( _keyOrValue >>= nValue )
+ if ( std::isnan( nValue ) )
+ throw IllegalArgumentException(
+ "NaN (not-a-number) not supported by this implementation.",
+ *const_cast< EnumerableMap* >( this ), 0 );
+ // (note that the case of _key not containing a float/double value is handled in the
+ // respective IKeyPredicateLess implementation, so there's no need to handle this here.)
+ }
+ }
+
+
+ void EnumerableMap::impl_checkKey_throw( const Any& _key ) const
+ {
+ if ( !_key.hasValue() )
+ throw IllegalArgumentException(
+ "NULL keys not supported by this implementation.",
+ *const_cast< EnumerableMap* >( this ), 0 );
+
+ impl_checkNaN_throw( _key, m_aData.m_aKeyType );
+ }
+
+
+ void EnumerableMap::impl_checkMutable_throw() const
+ {
+ if ( !m_aData.m_bMutable )
+ throw NoSupportException(
+ "The map is immutable.",
+ *const_cast< EnumerableMap* >( this ) );
+ }
+
+
+ Reference< XEnumeration > SAL_CALL EnumerableMap::createKeyEnumeration( sal_Bool Isolated )
+ {
+ ComponentMethodGuard aGuard( *this );
+ return new MapEnumeration( *this, m_aData, getBroadcastHelper(), eKeys, Isolated );
+ }
+
+
+ Reference< XEnumeration > SAL_CALL EnumerableMap::createValueEnumeration( sal_Bool Isolated )
+ {
+ ComponentMethodGuard aGuard( *this );
+ return new MapEnumeration( *this, m_aData, getBroadcastHelper(), eValues, Isolated );
+ }
+
+
+ Reference< XEnumeration > SAL_CALL EnumerableMap::createElementEnumeration( sal_Bool Isolated )
+ {
+ ComponentMethodGuard aGuard( *this );
+ return new MapEnumeration( *this, m_aData, getBroadcastHelper(), eBoth, Isolated );
+ }
+
+
+ Type SAL_CALL EnumerableMap::getKeyType()
+ {
+ ComponentMethodGuard aGuard( *this );
+ return m_aData.m_aKeyType;
+ }
+
+
+ Type SAL_CALL EnumerableMap::getValueType()
+ {
+ ComponentMethodGuard aGuard( *this );
+ return m_aData.m_aValueType;
+ }
+
+
+ void SAL_CALL EnumerableMap::clear( )
+ {
+ ComponentMethodGuard aGuard( *this );
+ impl_checkMutable_throw();
+
+ m_aData.m_pValues->clear();
+
+ lcl_notifyMapDataListeners_nothrow( m_aData );
+ }
+
+
+ sal_Bool SAL_CALL EnumerableMap::containsKey( const Any& _key )
+ {
+ ComponentMethodGuard aGuard( *this );
+ impl_checkKey_throw( _key );
+
+ KeyedValues::const_iterator pos = m_aData.m_pValues->find( _key );
+ return ( pos != m_aData.m_pValues->end() );
+ }
+
+
+ sal_Bool SAL_CALL EnumerableMap::containsValue( const Any& _value )
+ {
+ ComponentMethodGuard aGuard( *this );
+ impl_checkValue_throw( _value );
+ for (auto const& value : *m_aData.m_pValues)
+ {
+ if ( value.second == _value )
+ return true;
+ }
+ return false;
+ }
+
+
+ Any SAL_CALL EnumerableMap::get( const Any& _key )
+ {
+ ComponentMethodGuard aGuard( *this );
+ impl_checkKey_throw( _key );
+
+ KeyedValues::const_iterator pos = m_aData.m_pValues->find( _key );
+ if ( pos == m_aData.m_pValues->end() )
+ throw NoSuchElementException( anyToString( _key ), *this );
+
+ return pos->second;
+ }
+
+
+ Any SAL_CALL EnumerableMap::put( const Any& _key, const Any& _value )
+ {
+ ComponentMethodGuard aGuard( *this );
+ impl_checkMutable_throw();
+ impl_checkKey_throw( _key );
+ impl_checkValue_throw( _value );
+
+ Any previousValue;
+
+ KeyedValues::iterator pos = m_aData.m_pValues->find( _key );
+ if ( pos != m_aData.m_pValues->end() )
+ {
+ previousValue = pos->second;
+ pos->second = _value;
+ }
+ else
+ {
+ (*m_aData.m_pValues)[ _key ] = _value;
+ }
+
+ lcl_notifyMapDataListeners_nothrow( m_aData );
+
+ return previousValue;
+ }
+
+
+ Any SAL_CALL EnumerableMap::remove( const Any& _key )
+ {
+ ComponentMethodGuard aGuard( *this );
+ impl_checkMutable_throw();
+ impl_checkKey_throw( _key );
+
+ Any previousValue;
+
+ KeyedValues::iterator pos = m_aData.m_pValues->find( _key );
+ if ( pos != m_aData.m_pValues->end() )
+ {
+ previousValue = pos->second;
+ m_aData.m_pValues->erase( pos );
+ }
+
+ lcl_notifyMapDataListeners_nothrow( m_aData );
+
+ return previousValue;
+ }
+
+
+ Type SAL_CALL EnumerableMap::getElementType()
+ {
+ return ::cppu::UnoType< Pair< Any, Any > >::get();
+ }
+
+
+ sal_Bool SAL_CALL EnumerableMap::hasElements()
+ {
+ ComponentMethodGuard aGuard( *this );
+ return m_aData.m_pValues->empty();
+ }
+
+
+ OUString SAL_CALL EnumerableMap::getImplementationName( )
+ {
+ return "org.openoffice.comp.comphelper.EnumerableMap";
+ }
+
+ sal_Bool SAL_CALL EnumerableMap::supportsService( const OUString& _serviceName )
+ {
+ return cppu::supportsService(this, _serviceName);
+ }
+
+
+ Sequence< OUString > SAL_CALL EnumerableMap::getSupportedServiceNames( )
+ {
+ return { "com.sun.star.container.EnumerableMap" };
+ }
+
+ bool MapEnumerator::hasMoreElements()
+ {
+ if ( m_disposed )
+ throw DisposedException( OUString(), m_rParent );
+ return m_mapPos != m_rMapData.m_pValues->end();
+ }
+
+
+ Any MapEnumerator::nextElement()
+ {
+ if ( m_disposed )
+ throw DisposedException( OUString(), m_rParent );
+ if ( m_mapPos == m_rMapData.m_pValues->end() )
+ throw NoSuchElementException("No more elements.", m_rParent );
+
+ Any aNextElement;
+ switch ( m_eType )
+ {
+ case eKeys: aNextElement = m_mapPos->first; break;
+ case eValues: aNextElement = m_mapPos->second; break;
+ case eBoth: aNextElement <<= Pair< Any, Any >( m_mapPos->first, m_mapPos->second ); break;
+ }
+ ++m_mapPos;
+ return aNextElement;
+ }
+
+
+ void MapEnumerator::mapModified()
+ {
+ m_disposed = true;
+ }
+
+
+ sal_Bool SAL_CALL MapEnumeration::hasMoreElements( )
+ {
+ ComponentMethodGuard aGuard( *this );
+ return m_aEnumerator.hasMoreElements();
+ }
+
+
+ Any SAL_CALL MapEnumeration::nextElement( )
+ {
+ ComponentMethodGuard aGuard( *this );
+ return m_aEnumerator.nextElement();
+ }
+
+
+} // namespace comphelper
+
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+org_openoffice_comp_comphelper_EnumerableMap(
+ css::uno::XComponentContext*, css::uno::Sequence<css::uno::Any> const&)
+{
+ return cppu::acquire(new comphelper::EnumerableMap());
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/container/enumhelper.cxx b/comphelper/source/container/enumhelper.cxx
new file mode 100644
index 000000000..bc9ae43e4
--- /dev/null
+++ b/comphelper/source/container/enumhelper.cxx
@@ -0,0 +1,280 @@
+/* -*- 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 <comphelper/enumhelper.hxx>
+#include <com/sun/star/lang/XComponent.hpp>
+#include <com/sun/star/container/XIndexAccess.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <utility>
+
+namespace comphelper
+{
+
+OEnumerationByName::OEnumerationByName(css::uno::Reference<css::container::XNameAccess> _xAccess)
+ :m_aNames(_xAccess->getElementNames())
+ ,m_xAccess(_xAccess)
+ ,m_nPos(0)
+ ,m_bListening(false)
+{
+ impl_startDisposeListening();
+}
+
+
+OEnumerationByName::OEnumerationByName(const css::uno::Reference<css::container::XNameAccess> _xAccess,
+ std::vector<OUString> _aNames )
+ :m_aNames(std::move(_aNames))
+ ,m_xAccess(std::move(_xAccess))
+ ,m_nPos(0)
+ ,m_bListening(false)
+{
+ impl_startDisposeListening();
+}
+
+OEnumerationByName::~OEnumerationByName()
+{
+ std::lock_guard aLock(m_aLock);
+
+ impl_stopDisposeListening();
+}
+
+
+sal_Bool SAL_CALL OEnumerationByName::hasMoreElements( )
+{
+ std::lock_guard aLock(m_aLock);
+
+ if (m_xAccess.is() && getLength() > m_nPos)
+ return true;
+
+ if (m_xAccess.is())
+ {
+ impl_stopDisposeListening();
+ m_xAccess.clear();
+ }
+
+ return false;
+}
+
+
+css::uno::Any SAL_CALL OEnumerationByName::nextElement( )
+{
+ std::lock_guard aLock(m_aLock);
+
+ css::uno::Any aRes;
+ if (m_xAccess.is() && m_nPos < getLength())
+ aRes = m_xAccess->getByName(getElement(m_nPos++));
+
+ if (m_xAccess.is() && m_nPos >= getLength())
+ {
+ impl_stopDisposeListening();
+ m_xAccess.clear();
+ }
+
+ if (!aRes.hasValue()) //There are no more elements
+ throw css::container::NoSuchElementException();
+
+ return aRes;
+}
+
+void SAL_CALL OEnumerationByName::disposing(const css::lang::EventObject& aEvent)
+{
+ std::lock_guard aLock(m_aLock);
+
+ if (aEvent.Source == m_xAccess)
+ m_xAccess.clear();
+}
+
+
+void OEnumerationByName::impl_startDisposeListening()
+{
+ if (m_bListening)
+ return;
+
+ osl_atomic_increment(&m_refCount);
+ css::uno::Reference< css::lang::XComponent > xDisposable(m_xAccess, css::uno::UNO_QUERY);
+ if (xDisposable.is())
+ {
+ xDisposable->addEventListener(this);
+ m_bListening = true;
+ }
+ osl_atomic_decrement(&m_refCount);
+}
+
+
+void OEnumerationByName::impl_stopDisposeListening()
+{
+ if (!m_bListening)
+ return;
+
+ osl_atomic_increment(&m_refCount);
+ css::uno::Reference< css::lang::XComponent > xDisposable(m_xAccess, css::uno::UNO_QUERY);
+ if (xDisposable.is())
+ {
+ xDisposable->removeEventListener(this);
+ m_bListening = false;
+ }
+ osl_atomic_decrement(&m_refCount);
+}
+
+sal_Int32 OEnumerationByName::getLength() const
+{
+ if (m_aNames.index() == 0)
+ return std::get<css::uno::Sequence<OUString>>(m_aNames).getLength();
+ else
+ return std::get<std::vector<OUString>>(m_aNames).size();
+}
+
+const OUString& OEnumerationByName::getElement(sal_Int32 nIndex) const
+{
+ if (m_aNames.index() == 0)
+ return std::get<css::uno::Sequence<OUString>>(m_aNames).getConstArray()[nIndex];
+ else
+ return std::get<std::vector<OUString>>(m_aNames)[nIndex];
+}
+
+
+OEnumerationByIndex::OEnumerationByIndex(css::uno::Reference< css::container::XIndexAccess > _xAccess)
+ :m_xAccess(std::move(_xAccess))
+ ,m_nPos(0)
+ ,m_bListening(false)
+{
+ impl_startDisposeListening();
+}
+
+
+OEnumerationByIndex::~OEnumerationByIndex()
+{
+ std::lock_guard aLock(m_aLock);
+
+ impl_stopDisposeListening();
+}
+
+
+sal_Bool SAL_CALL OEnumerationByIndex::hasMoreElements( )
+{
+ std::lock_guard aLock(m_aLock);
+
+ if (m_xAccess.is() && m_xAccess->getCount() > m_nPos)
+ return true;
+
+ if (m_xAccess.is())
+ {
+ impl_stopDisposeListening();
+ m_xAccess.clear();
+ }
+
+ return false;
+}
+
+
+css::uno::Any SAL_CALL OEnumerationByIndex::nextElement( )
+{
+ std::lock_guard aLock(m_aLock);
+
+ css::uno::Any aRes;
+ if (m_xAccess.is() && m_nPos < m_xAccess->getCount())
+ aRes = m_xAccess->getByIndex(m_nPos++);
+
+ if (m_xAccess.is() && m_nPos >= m_xAccess->getCount())
+ {
+ impl_stopDisposeListening();
+ m_xAccess.clear();
+ }
+
+ if (!aRes.hasValue())
+ throw css::container::NoSuchElementException();
+ return aRes;
+}
+
+
+void SAL_CALL OEnumerationByIndex::disposing(const css::lang::EventObject& aEvent)
+{
+ std::lock_guard aLock(m_aLock);
+
+ if (aEvent.Source == m_xAccess)
+ m_xAccess.clear();
+}
+
+
+void OEnumerationByIndex::impl_startDisposeListening()
+{
+ if (m_bListening)
+ return;
+
+ osl_atomic_increment(&m_refCount);
+ css::uno::Reference< css::lang::XComponent > xDisposable(m_xAccess, css::uno::UNO_QUERY);
+ if (xDisposable.is())
+ {
+ xDisposable->addEventListener(this);
+ m_bListening = true;
+ }
+ osl_atomic_decrement(&m_refCount);
+}
+
+
+void OEnumerationByIndex::impl_stopDisposeListening()
+{
+ if (!m_bListening)
+ return;
+
+ osl_atomic_increment(&m_refCount);
+ css::uno::Reference< css::lang::XComponent > xDisposable(m_xAccess, css::uno::UNO_QUERY);
+ if (xDisposable.is())
+ {
+ xDisposable->removeEventListener(this);
+ m_bListening = false;
+ }
+ osl_atomic_decrement(&m_refCount);
+}
+
+OAnyEnumeration::OAnyEnumeration(const css::uno::Sequence< css::uno::Any >& lItems)
+ :m_nPos(0)
+ ,m_lItems(lItems)
+{
+}
+
+
+OAnyEnumeration::~OAnyEnumeration()
+{
+}
+
+
+sal_Bool SAL_CALL OAnyEnumeration::hasMoreElements( )
+{
+ std::lock_guard aLock(m_aLock);
+
+ return (m_lItems.getLength() > m_nPos);
+}
+
+
+css::uno::Any SAL_CALL OAnyEnumeration::nextElement( )
+{
+ if ( ! hasMoreElements())
+ throw css::container::NoSuchElementException();
+
+ std::lock_guard aLock(m_aLock);
+ sal_Int32 nPos = m_nPos;
+ ++m_nPos;
+ return m_lItems[nPos];
+}
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/container/interfacecontainer2.cxx b/comphelper/source/container/interfacecontainer2.cxx
new file mode 100644
index 000000000..9acff0a7f
--- /dev/null
+++ b/comphelper/source/container/interfacecontainer2.cxx
@@ -0,0 +1,421 @@
+/* -*- 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 <comphelper/interfacecontainer2.hxx>
+#include <comphelper/multicontainer2.hxx>
+
+#include <o3tl/safeint.hxx>
+#include <osl/diagnose.h>
+#include <osl/mutex.hxx>
+
+#include <memory>
+
+#include <com/sun/star/lang/XEventListener.hpp>
+
+
+using namespace osl;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::lang;
+
+namespace comphelper
+{
+
+OInterfaceIteratorHelper2::OInterfaceIteratorHelper2( OInterfaceContainerHelper2 & rCont_ )
+ : rCont( rCont_ )
+{
+ MutexGuard aGuard( rCont.rMutex );
+ if( rCont.bInUse )
+ // worst case, two iterators at the same time
+ rCont.copyAndResetInUse();
+ bIsList = rCont_.bIsList;
+ aData = rCont_.aData;
+ if( bIsList )
+ {
+ rCont.bInUse = true;
+ nRemain = aData.pAsVector->size();
+ }
+ else if( aData.pAsInterface )
+ {
+ aData.pAsInterface->acquire();
+ nRemain = 1;
+ }
+ else
+ nRemain = 0;
+}
+
+OInterfaceIteratorHelper2::~OInterfaceIteratorHelper2()
+{
+ bool bShared;
+ {
+ MutexGuard aGuard( rCont.rMutex );
+ // bResetInUse protect the iterator against recursion
+ bShared = aData.pAsVector == rCont.aData.pAsVector && rCont.bIsList;
+ if( bShared )
+ {
+ OSL_ENSURE( rCont.bInUse, "OInterfaceContainerHelper2 must be in use" );
+ rCont.bInUse = false;
+ }
+ }
+
+ if( !bShared )
+ {
+ if( bIsList )
+ // Sequence owned by the iterator
+ delete aData.pAsVector;
+ else if( aData.pAsInterface )
+ // Interface is acquired by the iterator
+ aData.pAsInterface->release();
+ }
+}
+
+XInterface * OInterfaceIteratorHelper2::next()
+{
+ if( nRemain )
+ {
+ nRemain--;
+ if( bIsList )
+ return (*aData.pAsVector)[nRemain].get();
+ else if( aData.pAsInterface )
+ return aData.pAsInterface;
+ }
+ // exception
+ return nullptr;
+}
+
+void OInterfaceIteratorHelper2::remove()
+{
+ if( bIsList )
+ {
+ OSL_ASSERT( nRemain >= 0 &&
+ o3tl::make_unsigned(nRemain) < aData.pAsVector->size() );
+ rCont.removeInterface( (*aData.pAsVector)[nRemain] );
+ }
+ else
+ {
+ OSL_ASSERT( 0 == nRemain );
+ rCont.removeInterface( aData.pAsInterface );
+ }
+}
+
+OInterfaceContainerHelper2::OInterfaceContainerHelper2( Mutex & rMutex_ )
+ : rMutex( rMutex_ )
+ , bInUse( false )
+ , bIsList( false )
+{
+}
+
+OInterfaceContainerHelper2::~OInterfaceContainerHelper2()
+{
+ OSL_ENSURE( !bInUse, "~OInterfaceContainerHelper2 but is in use" );
+ if( bIsList )
+ delete aData.pAsVector;
+ else if( aData.pAsInterface )
+ aData.pAsInterface->release();
+}
+
+sal_Int32 OInterfaceContainerHelper2::getLength() const
+{
+ MutexGuard aGuard( rMutex );
+ if( bIsList )
+ return aData.pAsVector->size();
+ else if( aData.pAsInterface )
+ return 1;
+ return 0;
+}
+
+std::vector< Reference<XInterface> > OInterfaceContainerHelper2::getElements() const
+{
+ std::vector< Reference<XInterface> > rVec;
+ MutexGuard aGuard( rMutex );
+ if( bIsList )
+ rVec = *aData.pAsVector;
+ else if( aData.pAsInterface )
+ {
+ rVec.emplace_back( aData.pAsInterface );
+ }
+ return rVec;
+}
+
+void OInterfaceContainerHelper2::copyAndResetInUse()
+{
+ OSL_ENSURE( bInUse, "OInterfaceContainerHelper2 not in use" );
+ if( bInUse )
+ {
+ // this should be the worst case. If an iterator is active
+ // and a new Listener is added.
+ if( bIsList )
+ aData.pAsVector = new std::vector< Reference< XInterface > >( *aData.pAsVector );
+ else if( aData.pAsInterface )
+ aData.pAsInterface->acquire();
+
+ bInUse = false;
+ }
+}
+
+sal_Int32 OInterfaceContainerHelper2::addInterface( const Reference<XInterface> & rListener )
+{
+ OSL_ASSERT( rListener.is() );
+ MutexGuard aGuard( rMutex );
+ if( bInUse )
+ copyAndResetInUse();
+
+ if( bIsList )
+ {
+ aData.pAsVector->push_back( rListener );
+ return aData.pAsVector->size();
+ }
+ else if( aData.pAsInterface )
+ {
+ std::vector< Reference< XInterface > > * pVec = new std::vector< Reference< XInterface > >( 2 );
+ (*pVec)[0] = aData.pAsInterface;
+ (*pVec)[1] = rListener;
+ aData.pAsInterface->release();
+ aData.pAsVector = pVec;
+ bIsList = true;
+ return 2;
+ }
+ else
+ {
+ aData.pAsInterface = rListener.get();
+ if( rListener.is() )
+ rListener->acquire();
+ return 1;
+ }
+}
+
+sal_Int32 OInterfaceContainerHelper2::removeInterface( const Reference<XInterface> & rListener )
+{
+ OSL_ASSERT( rListener.is() );
+ MutexGuard aGuard( rMutex );
+ if( bInUse )
+ copyAndResetInUse();
+
+ if( bIsList )
+ {
+ // It is not valid to compare the pointer directly, but it's faster.
+ auto it = std::find_if(aData.pAsVector->begin(), aData.pAsVector->end(),
+ [&rListener](const css::uno::Reference<css::uno::XInterface>& rItem) {
+ return rItem.get() == rListener.get(); });
+
+ // interface not found, use the correct compare method
+ if (it == aData.pAsVector->end())
+ it = std::find(aData.pAsVector->begin(), aData.pAsVector->end(), rListener);
+
+ if (it != aData.pAsVector->end())
+ aData.pAsVector->erase(it);
+
+ if( aData.pAsVector->size() == 1 )
+ {
+ XInterface * p = (*aData.pAsVector)[0].get();
+ p->acquire();
+ delete aData.pAsVector;
+ aData.pAsInterface = p;
+ bIsList = false;
+ return 1;
+ }
+ else
+ return aData.pAsVector->size();
+ }
+ else if( aData.pAsInterface && Reference<XInterface>( aData.pAsInterface ) == rListener )
+ {
+ aData.pAsInterface->release();
+ aData.pAsInterface = nullptr;
+ }
+ return aData.pAsInterface ? 1 : 0;
+}
+
+Reference<XInterface> OInterfaceContainerHelper2::getInterface( sal_Int32 nIndex ) const
+{
+ MutexGuard aGuard( rMutex );
+
+ if( bIsList )
+ return (*aData.pAsVector)[nIndex];
+ else if( aData.pAsInterface )
+ {
+ if (nIndex == 0)
+ return aData.pAsInterface;
+ }
+ throw std::out_of_range("index out of range");
+}
+
+void OInterfaceContainerHelper2::disposeAndClear( const EventObject & rEvt )
+{
+ ClearableMutexGuard aGuard( rMutex );
+ OInterfaceIteratorHelper2 aIt( *this );
+ // Release container, in case new entries come while disposing
+ OSL_ENSURE( !bIsList || bInUse, "OInterfaceContainerHelper2 not in use" );
+ if( !bIsList && aData.pAsInterface )
+ aData.pAsInterface->release();
+ // set the member to null, use the iterator to delete the values
+ aData.pAsInterface = nullptr;
+ bIsList = false;
+ bInUse = false;
+ aGuard.clear();
+ while( aIt.hasMoreElements() )
+ {
+ try
+ {
+ Reference<XEventListener > xLst( aIt.next(), UNO_QUERY );
+ if( xLst.is() )
+ xLst->disposing( rEvt );
+ }
+ catch ( RuntimeException & )
+ {
+ // be robust, if e.g. a remote bridge has disposed already.
+ // there is no way to delegate the error to the caller :o(.
+ }
+ }
+}
+
+
+void OInterfaceContainerHelper2::clear()
+{
+ MutexGuard aGuard( rMutex );
+ // Release container, in case new entries come while disposing
+ OSL_ENSURE( !bIsList || bInUse, "OInterfaceContainerHelper2 not in use" );
+ if (bInUse)
+ copyAndResetInUse();
+ if (bIsList)
+ delete aData.pAsVector;
+ else if (aData.pAsInterface)
+ aData.pAsInterface->release();
+ aData.pAsInterface = nullptr;
+ bIsList = false;
+}
+
+
+
+// specialized class for type
+
+OMultiTypeInterfaceContainerHelper2::OMultiTypeInterfaceContainerHelper2( Mutex & rMutex_ )
+ : rMutex( rMutex_ )
+{
+}
+
+OMultiTypeInterfaceContainerHelper2::~OMultiTypeInterfaceContainerHelper2()
+{
+}
+
+std::vector< css::uno::Type > OMultiTypeInterfaceContainerHelper2::getContainedTypes() const
+{
+ ::osl::MutexGuard aGuard( rMutex );
+ std::vector< Type > aInterfaceTypes;
+ aInterfaceTypes.reserve( m_aMap.size() );
+ for (const auto& rItem : m_aMap)
+ {
+ // are interfaces added to this container?
+ if( rItem.second->getLength() )
+ // yes, put the type in the array
+ aInterfaceTypes.push_back(rItem.first);
+ }
+ return aInterfaceTypes;
+}
+
+OMultiTypeInterfaceContainerHelper2::t_type2ptr::iterator OMultiTypeInterfaceContainerHelper2::findType(const Type & rKey )
+{
+ return std::find_if(m_aMap.begin(), m_aMap.end(),
+ [&rKey](const t_type2ptr::value_type& rItem) { return rItem.first == rKey; });
+}
+
+OMultiTypeInterfaceContainerHelper2::t_type2ptr::const_iterator OMultiTypeInterfaceContainerHelper2::findType(const Type & rKey ) const
+{
+ return std::find_if(m_aMap.begin(), m_aMap.end(),
+ [&rKey](const t_type2ptr::value_type& rItem) { return rItem.first == rKey; });
+}
+
+OInterfaceContainerHelper2 * OMultiTypeInterfaceContainerHelper2::getContainer( const Type & rKey ) const
+{
+ ::osl::MutexGuard aGuard( rMutex );
+
+ auto iter = findType( rKey );
+ if( iter != m_aMap.end() )
+ return (*iter).second.get();
+ return nullptr;
+}
+
+sal_Int32 OMultiTypeInterfaceContainerHelper2::addInterface(
+ const Type & rKey, const Reference< XInterface > & rListener )
+{
+ ::osl::MutexGuard aGuard( rMutex );
+ auto iter = findType( rKey );
+ if( iter == m_aMap.end() )
+ {
+ OInterfaceContainerHelper2 * pLC = new OInterfaceContainerHelper2( rMutex );
+ m_aMap.emplace_back(rKey, pLC);
+ return pLC->addInterface( rListener );
+ }
+ return (*iter).second->addInterface( rListener );
+}
+
+sal_Int32 OMultiTypeInterfaceContainerHelper2::removeInterface(
+ const Type & rKey, const Reference< XInterface > & rListener )
+{
+ ::osl::MutexGuard aGuard( rMutex );
+
+ // search container with id nUik
+ auto iter = findType( rKey );
+ // container found?
+ if( iter != m_aMap.end() )
+ return (*iter).second->removeInterface( rListener );
+
+ // no container with this id. Always return 0
+ return 0;
+}
+
+void OMultiTypeInterfaceContainerHelper2::disposeAndClear( const EventObject & rEvt )
+{
+ t_type2ptr::size_type nSize = 0;
+ std::unique_ptr<OInterfaceContainerHelper2 *[]> ppListenerContainers;
+ {
+ ::osl::MutexGuard aGuard( rMutex );
+ nSize = m_aMap.size();
+ if( nSize )
+ {
+ typedef OInterfaceContainerHelper2* ppp;
+ ppListenerContainers.reset(new ppp[nSize]);
+
+ t_type2ptr::size_type i = 0;
+ for (const auto& rItem : m_aMap)
+ {
+ ppListenerContainers[i++] = rItem.second.get();
+ }
+ }
+ }
+
+ // create a copy, because do not fire event in a guarded section
+ for( t_type2ptr::size_type i = 0; i < nSize; i++ )
+ {
+ if( ppListenerContainers[i] )
+ ppListenerContainers[i]->disposeAndClear( rEvt );
+ }
+}
+
+void OMultiTypeInterfaceContainerHelper2::clear()
+{
+ ::osl::MutexGuard aGuard( rMutex );
+
+ for (auto& rItem : m_aMap)
+ rItem.second->clear();
+}
+
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/container/namecontainer.cxx b/comphelper/source/container/namecontainer.cxx
new file mode 100644
index 000000000..c13ee7486
--- /dev/null
+++ b/comphelper/source/container/namecontainer.cxx
@@ -0,0 +1,166 @@
+/* -*- 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 <sal/config.h>
+
+#include <map>
+#include <mutex>
+
+#include <comphelper/namecontainer.hxx>
+#include <comphelper/sequence.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <osl/mutex.hxx>
+#include <com/sun/star/container/XNameContainer.hpp>
+
+typedef std::map<OUString, css::uno::Any> SvGenericNameContainerMapImpl;
+
+namespace comphelper
+{
+ namespace {
+
+ /** this is the base helper class for NameContainer that's also declared in this header. */
+ class NameContainer : public ::cppu::WeakImplHelper< css::container::XNameContainer >
+ {
+ public:
+ explicit NameContainer( const css::uno::Type& aType );
+
+ // XNameContainer
+ virtual void SAL_CALL insertByName( const OUString& aName, const css::uno::Any& aElement ) override;
+ virtual void SAL_CALL removeByName( const OUString& Name ) override;
+
+ // XNameReplace
+ virtual void SAL_CALL replaceByName( const OUString& aName, const css::uno::Any& aElement ) override;
+
+ // XNameAccess
+ virtual css::uno::Any SAL_CALL getByName( const OUString& aName ) override;
+ virtual css::uno::Sequence< OUString > SAL_CALL getElementNames( ) override;
+ virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override;
+
+ // XElementAccess
+ virtual sal_Bool SAL_CALL hasElements( ) override;
+ virtual css::uno::Type SAL_CALL getElementType( ) override;
+
+ private:
+ SvGenericNameContainerMapImpl maProperties;
+ const css::uno::Type maType;
+ std::mutex maMutex;
+ };
+
+ }
+}
+
+using namespace ::comphelper;
+using namespace ::osl;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::lang;
+
+
+NameContainer::NameContainer( const css::uno::Type& aType )
+: maType( aType )
+{
+}
+
+// XNameContainer
+void SAL_CALL NameContainer::insertByName( const OUString& aName, const Any& aElement )
+{
+ std::scoped_lock aGuard( maMutex );
+
+ if( maProperties.find( aName ) != maProperties.end() )
+ throw ElementExistException();
+
+ if( aElement.getValueType() != maType )
+ throw IllegalArgumentException("element is wrong type", static_cast<cppu::OWeakObject*>(this), 2);
+
+ maProperties.emplace(aName,aElement);
+}
+
+void SAL_CALL NameContainer::removeByName( const OUString& Name )
+{
+ std::scoped_lock aGuard( maMutex );
+
+ SvGenericNameContainerMapImpl::iterator aIter = maProperties.find( Name );
+ if( aIter == maProperties.end() )
+ throw NoSuchElementException();
+
+ maProperties.erase( aIter );
+}
+
+// XNameReplace
+
+void SAL_CALL NameContainer::replaceByName( const OUString& aName, const Any& aElement )
+{
+ std::scoped_lock aGuard( maMutex );
+
+ SvGenericNameContainerMapImpl::iterator aIter( maProperties.find( aName ) );
+ if( aIter == maProperties.end() )
+ throw NoSuchElementException();
+
+ if( aElement.getValueType() != maType )
+ throw IllegalArgumentException("element is wrong type", static_cast<cppu::OWeakObject*>(this), 2);
+
+ (*aIter).second = aElement;
+}
+
+// XNameAccess
+
+Any SAL_CALL NameContainer::getByName( const OUString& aName )
+{
+ std::scoped_lock aGuard( maMutex );
+
+ SvGenericNameContainerMapImpl::iterator aIter = maProperties.find( aName );
+ if( aIter == maProperties.end() )
+ throw NoSuchElementException();
+
+ return (*aIter).second;
+}
+
+Sequence< OUString > SAL_CALL NameContainer::getElementNames( )
+{
+ std::scoped_lock aGuard( maMutex );
+
+ return comphelper::mapKeysToSequence(maProperties);
+}
+
+sal_Bool SAL_CALL NameContainer::hasByName( const OUString& aName )
+{
+ std::scoped_lock aGuard( maMutex );
+
+ SvGenericNameContainerMapImpl::iterator aIter = maProperties.find( aName );
+ return aIter != maProperties.end();
+}
+
+sal_Bool SAL_CALL NameContainer::hasElements( )
+{
+ std::scoped_lock aGuard( maMutex );
+
+ return !maProperties.empty();
+}
+
+Type SAL_CALL NameContainer::getElementType()
+{
+ return maType;
+}
+
+Reference< XNameContainer > comphelper::NameContainer_createInstance( const Type& aType )
+{
+ return new NameContainer(aType);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/eventattachermgr/eventattachermgr.cxx b/comphelper/source/eventattachermgr/eventattachermgr.cxx
new file mode 100644
index 000000000..1c9f1a23c
--- /dev/null
+++ b/comphelper/source/eventattachermgr/eventattachermgr.cxx
@@ -0,0 +1,740 @@
+/* -*- 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 <sal/config.h>
+
+#include <o3tl/any.hxx>
+#include <o3tl/safeint.hxx>
+#include <osl/mutex.hxx>
+#include <osl/diagnose.h>
+#include <comphelper/eventattachermgr.hxx>
+#include <comphelper/sequence.hxx>
+#include <com/sun/star/beans/theIntrospection.hpp>
+#include <com/sun/star/io/XObjectInputStream.hpp>
+#include <com/sun/star/io/XPersistObject.hpp>
+#include <com/sun/star/io/XObjectOutputStream.hpp>
+#include <com/sun/star/io/XMarkableStream.hpp>
+#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/reflection/theCoreReflection.hpp>
+#include <com/sun/star/reflection/XIdlClass.hpp>
+#include <com/sun/star/reflection/XIdlReflection.hpp>
+#include <com/sun/star/reflection/XIdlMethod.hpp>
+#include <com/sun/star/script/CannotConvertException.hpp>
+#include <com/sun/star/script/Converter.hpp>
+#include <com/sun/star/script/XEventAttacher2.hpp>
+#include <com/sun/star/script/XEventAttacherManager.hpp>
+#include <com/sun/star/script/XScriptListener.hpp>
+#include <cppuhelper/weak.hxx>
+#include <comphelper/interfacecontainer3.hxx>
+#include <cppuhelper/exc_hlp.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <rtl/ref.hxx>
+
+#include <deque>
+#include <algorithm>
+#include <utility>
+
+using namespace com::sun::star::uno;
+using namespace com::sun::star::io;
+using namespace com::sun::star::lang;
+using namespace com::sun::star::beans;
+using namespace com::sun::star::script;
+using namespace com::sun::star::reflection;
+using namespace cppu;
+using namespace osl;
+
+
+namespace comphelper
+{
+
+namespace {
+
+struct AttachedObject_Impl
+{
+ Reference< XInterface > xTarget;
+ std::vector< Reference< XEventListener > > aAttachedListenerSeq;
+ Any aHelper;
+};
+
+struct AttacherIndex_Impl
+{
+ std::deque< ScriptEventDescriptor > aEventList;
+ std::deque< AttachedObject_Impl > aObjList;
+};
+
+
+class ImplEventAttacherManager
+ : public WeakImplHelper< XEventAttacherManager, XPersistObject >
+{
+ friend class AttacherAllListener_Impl;
+ std::deque< AttacherIndex_Impl > aIndex;
+ Mutex aLock;
+ // Container for the ScriptListener
+ OInterfaceContainerHelper3<XScriptListener> aScriptListeners;
+ // Instance of EventAttacher
+ Reference< XEventAttacher2 > xAttacher;
+ Reference< XComponentContext > mxContext;
+ Reference< XIdlReflection > mxCoreReflection;
+ Reference< XTypeConverter > xConverter;
+ sal_Int16 nVersion;
+public:
+ ImplEventAttacherManager( const Reference< XIntrospection > & rIntrospection,
+ const Reference< XComponentContext >& rContext );
+
+ // Methods of XEventAttacherManager
+ virtual void SAL_CALL registerScriptEvent(sal_Int32 Index, const ScriptEventDescriptor& ScriptEvent) override;
+ virtual void SAL_CALL registerScriptEvents(sal_Int32 Index, const Sequence< ScriptEventDescriptor >& ScriptEvents) override;
+ virtual void SAL_CALL revokeScriptEvent(sal_Int32 Index, const OUString& ListenerType, const OUString& EventMethod, const OUString& removeListenerParam) override;
+ virtual void SAL_CALL revokeScriptEvents(sal_Int32 Index) override;
+ virtual void SAL_CALL insertEntry(sal_Int32 Index) override;
+ virtual void SAL_CALL removeEntry(sal_Int32 Index) override;
+ virtual Sequence< ScriptEventDescriptor > SAL_CALL getScriptEvents(sal_Int32 Index) override;
+ virtual void SAL_CALL attach(sal_Int32 Index, const Reference< XInterface >& Object, const Any& Helper) override;
+ virtual void SAL_CALL detach(sal_Int32 nIndex, const Reference< XInterface >& xObject) override;
+ virtual void SAL_CALL addScriptListener(const Reference< XScriptListener >& aListener) override;
+ virtual void SAL_CALL removeScriptListener(const Reference< XScriptListener >& Listener) override;
+
+ // Methods of XPersistObject
+ virtual OUString SAL_CALL getServiceName() override;
+ virtual void SAL_CALL write(const Reference< XObjectOutputStream >& OutStream) override;
+ virtual void SAL_CALL read(const Reference< XObjectInputStream >& InStream) override;
+
+private:
+ /// @throws Exception
+ Reference< XIdlReflection > getReflection();
+
+ /** checks if <arg>_nIndex</arg> is a valid index, throws an <type>IllegalArgumentException</type> if not
+ @param _nIndex
+ the index to check
+ @return
+ the iterator pointing to the position indicated by the index
+ */
+ std::deque<AttacherIndex_Impl>::iterator implCheckIndex( sal_Int32 _nIndex );
+};
+
+
+// Implementation of an EventAttacher-subclass 'AllListeners', which
+// only passes individual events of the general AllListeners.
+class AttacherAllListener_Impl : public WeakImplHelper< XAllListener >
+{
+ rtl::Reference<ImplEventAttacherManager> mxManager;
+ OUString const aScriptType;
+ OUString const aScriptCode;
+
+ /// @throws CannotConvertException
+ void convertToEventReturn( Any & rRet, const Type & rRetType );
+public:
+ AttacherAllListener_Impl( ImplEventAttacherManager* pManager_, OUString aScriptType_,
+ OUString aScriptCode_ );
+
+ // Methods of XAllListener
+ virtual void SAL_CALL firing(const AllEventObject& Event) override;
+ virtual Any SAL_CALL approveFiring(const AllEventObject& Event) override;
+
+ // Methods of XEventListener
+ virtual void SAL_CALL disposing(const EventObject& Source) override;
+};
+
+}
+
+AttacherAllListener_Impl::AttacherAllListener_Impl
+(
+ ImplEventAttacherManager* pManager_,
+ OUString aScriptType_,
+ OUString aScriptCode_
+)
+ : mxManager( pManager_ )
+ , aScriptType(std::move( aScriptType_ ))
+ , aScriptCode(std::move( aScriptCode_ ))
+{
+}
+
+
+// Methods of XAllListener
+void SAL_CALL AttacherAllListener_Impl::firing(const AllEventObject& Event)
+{
+ ScriptEvent aScriptEvent;
+ aScriptEvent.Source = static_cast<OWeakObject *>(mxManager.get()); // get correct XInterface
+ aScriptEvent.ListenerType = Event.ListenerType;
+ aScriptEvent.MethodName = Event.MethodName;
+ aScriptEvent.Arguments = Event.Arguments;
+ aScriptEvent.Helper = Event.Helper;
+ aScriptEvent.ScriptType = aScriptType;
+ aScriptEvent.ScriptCode = aScriptCode;
+
+ // Iterate over all listeners and pass events.
+ mxManager->aScriptListeners.notifyEach( &XScriptListener::firing, aScriptEvent );
+}
+
+
+// Convert to the standard event return
+void AttacherAllListener_Impl::convertToEventReturn( Any & rRet, const Type & rRetType )
+{
+ // no return value? Set to the specified values
+ if( rRet.getValueType().getTypeClass() == TypeClass_VOID )
+ {
+ switch( rRetType.getTypeClass() )
+ {
+ case TypeClass_INTERFACE:
+ {
+ rRet <<= Reference< XInterface >();
+ }
+ break;
+
+ case TypeClass_BOOLEAN:
+ rRet <<= true;
+ break;
+
+ case TypeClass_STRING:
+ rRet <<= OUString();
+ break;
+
+ case TypeClass_FLOAT: rRet <<= float(0); break;
+ case TypeClass_DOUBLE: rRet <<= 0.0; break;
+ case TypeClass_BYTE: rRet <<= sal_uInt8(0); break;
+ case TypeClass_SHORT: rRet <<= sal_Int16( 0 ); break;
+ case TypeClass_LONG: rRet <<= sal_Int32( 0 ); break;
+ case TypeClass_UNSIGNED_SHORT: rRet <<= sal_uInt16( 0 ); break;
+ case TypeClass_UNSIGNED_LONG: rRet <<= sal_uInt32( 0 ); break;
+
+ default:
+ OSL_ASSERT(false);
+ break;
+ }
+ }
+ else if( !rRet.getValueType().equals( rRetType ) )
+ {
+ if( !mxManager->xConverter.is() )
+ throw CannotConvertException();
+ rRet = mxManager->xConverter->convertTo( rRet, rRetType );
+ }
+}
+
+// Methods of XAllListener
+Any SAL_CALL AttacherAllListener_Impl::approveFiring( const AllEventObject& Event )
+{
+ ScriptEvent aScriptEvent;
+ aScriptEvent.Source = static_cast<OWeakObject *>(mxManager.get()); // get correct XInterface
+ aScriptEvent.ListenerType = Event.ListenerType;
+ aScriptEvent.MethodName = Event.MethodName;
+ aScriptEvent.Arguments = Event.Arguments;
+ aScriptEvent.Helper = Event.Helper;
+ aScriptEvent.ScriptType = aScriptType;
+ aScriptEvent.ScriptCode = aScriptCode;
+
+ Any aRet;
+ // Iterate over all listeners and pass events.
+ OInterfaceIteratorHelper3 aIt( mxManager->aScriptListeners );
+ while( aIt.hasMoreElements() )
+ {
+ aRet = aIt.next()->approveFiring( aScriptEvent );
+ try
+ {
+ Reference< XIdlClass > xListenerType = mxManager->getReflection()->
+ forName( Event.ListenerType.getTypeName() );
+ Reference< XIdlMethod > xMeth = xListenerType->getMethod( Event.MethodName );
+ if( xMeth.is() )
+ {
+ Reference< XIdlClass > xRetType = xMeth->getReturnType();
+ Type aRetType(xRetType->getTypeClass(), xRetType->getName());
+ convertToEventReturn( aRet, aRetType );
+ }
+
+ switch( aRet.getValueType().getTypeClass() )
+ {
+ case TypeClass_INTERFACE:
+ {
+ // Interface not null, return
+ Reference< XInterface > x;
+ aRet >>= x;
+ if( x.is() )
+ return aRet;
+ }
+ break;
+
+ case TypeClass_BOOLEAN:
+ // FALSE -> Return
+ if( !(*o3tl::forceAccess<bool>(aRet)) )
+ return aRet;
+ break;
+
+ case TypeClass_STRING:
+ // none empty string -> return
+ if( !o3tl::forceAccess<OUString>(aRet)->isEmpty() )
+ return aRet;
+ break;
+
+ // none zero number -> return
+ case TypeClass_FLOAT: if( *o3tl::forceAccess<float>(aRet) ) return aRet; break;
+ case TypeClass_DOUBLE: if( *o3tl::forceAccess<double>(aRet) ) return aRet; break;
+ case TypeClass_BYTE: if( *o3tl::forceAccess<sal_Int8>(aRet) ) return aRet; break;
+ case TypeClass_SHORT: if( *o3tl::forceAccess<sal_Int16>(aRet) ) return aRet; break;
+ case TypeClass_LONG: if( *o3tl::forceAccess<sal_Int32>(aRet) ) return aRet; break;
+ case TypeClass_UNSIGNED_SHORT: if( *o3tl::forceAccess<sal_uInt16>(aRet) ) return aRet; break;
+ case TypeClass_UNSIGNED_LONG: if( *o3tl::forceAccess<sal_uInt32>(aRet) ) return aRet; break;
+
+ default:
+ OSL_ASSERT(false);
+ break;
+ }
+ }
+ catch (const CannotConvertException&)
+ {
+ // silent ignore conversions errors from a script call
+ Reference< XIdlClass > xListenerType = mxManager->getReflection()->
+ forName( Event.ListenerType.getTypeName() );
+ Reference< XIdlMethod > xMeth = xListenerType->getMethod( Event.MethodName );
+ if( xMeth.is() )
+ {
+ Reference< XIdlClass > xRetType = xMeth->getReturnType();
+ Type aRetType(xRetType->getTypeClass(), xRetType->getName());
+ aRet.clear();
+ try
+ {
+ convertToEventReturn( aRet, aRetType );
+ }
+ catch (const CannotConvertException& e)
+ {
+ css::uno::Any anyEx = cppu::getCaughtException();
+ throw css::lang::WrappedTargetRuntimeException(
+ "wrapped CannotConvertException " + e.Message,
+ css::uno::Reference<css::uno::XInterface>(), anyEx);
+ }
+ }
+ }
+ }
+ return aRet;
+}
+
+// Methods of XEventListener
+void SAL_CALL AttacherAllListener_Impl::disposing(const EventObject& )
+{
+ // It is up to the container to release the object
+}
+
+// Constructor method for EventAttacherManager
+Reference< XEventAttacherManager > createEventAttacherManager( const Reference< XComponentContext > & rxContext )
+{
+ Reference< XIntrospection > xIntrospection = theIntrospection::get( rxContext );
+ return new ImplEventAttacherManager( xIntrospection, rxContext );
+}
+
+
+ImplEventAttacherManager::ImplEventAttacherManager( const Reference< XIntrospection > & rIntrospection,
+ const Reference< XComponentContext >& rContext )
+ : aScriptListeners( aLock )
+ , mxContext( rContext )
+ , nVersion(0)
+{
+ if ( rContext.is() )
+ {
+ Reference< XInterface > xIFace( rContext->getServiceManager()->createInstanceWithContext(
+ "com.sun.star.script.EventAttacher", rContext) );
+ if ( xIFace.is() )
+ {
+ xAttacher.set( xIFace, UNO_QUERY );
+ }
+ xConverter = Converter::create(rContext);
+ }
+
+ Reference< XInitialization > xInit( xAttacher, UNO_QUERY );
+ if( xInit.is() )
+ {
+ xInit->initialize({ Any(rIntrospection) });
+ }
+}
+
+Reference< XIdlReflection > ImplEventAttacherManager::getReflection()
+{
+ Guard< Mutex > aGuard( aLock );
+ // Do we already have a service? If not, create one.
+ if( !mxCoreReflection.is() )
+ {
+ mxCoreReflection = theCoreReflection::get(mxContext);
+ }
+ return mxCoreReflection;
+}
+
+
+std::deque< AttacherIndex_Impl >::iterator ImplEventAttacherManager::implCheckIndex( sal_Int32 _nIndex )
+{
+ if ( (_nIndex < 0) || (o3tl::make_unsigned(_nIndex) >= aIndex.size()) )
+ throw IllegalArgumentException("wrong index", static_cast<cppu::OWeakObject*>(this), 1);
+
+ std::deque<AttacherIndex_Impl>::iterator aIt = aIndex.begin() + _nIndex;
+ return aIt;
+}
+
+// Methods of XEventAttacherManager
+void SAL_CALL ImplEventAttacherManager::registerScriptEvent
+(
+ sal_Int32 nIndex,
+ const ScriptEventDescriptor& ScriptEvent
+)
+{
+ Guard< Mutex > aGuard( aLock );
+
+ // Examine the index and apply the array
+ std::deque<AttacherIndex_Impl>::iterator aIt = implCheckIndex( nIndex );
+
+ ScriptEventDescriptor aEvt = ScriptEvent;
+ sal_Int32 nLastDot = aEvt.ListenerType.lastIndexOf('.');
+ if (nLastDot != -1)
+ aEvt.ListenerType = aEvt.ListenerType.copy(nLastDot+1);
+ aIt->aEventList.push_back( aEvt );
+
+ // register new Event
+ for( auto& rObj : aIt->aObjList )
+ {
+ Reference< XAllListener > xAll =
+ new AttacherAllListener_Impl( this, ScriptEvent.ScriptType, ScriptEvent.ScriptCode );
+ try
+ {
+ rObj.aAttachedListenerSeq.push_back( xAttacher->attachSingleEventListener( rObj.xTarget, xAll,
+ rObj.aHelper, ScriptEvent.ListenerType,
+ ScriptEvent.AddListenerParam, ScriptEvent.EventMethod ) );
+ }
+ catch( Exception& )
+ {
+ }
+ }
+}
+
+
+void SAL_CALL ImplEventAttacherManager::registerScriptEvents
+(
+ sal_Int32 nIndex,
+ const Sequence< ScriptEventDescriptor >& ScriptEvents
+)
+{
+ Guard< Mutex > aGuard( aLock );
+
+ // Examine the index and apply the array
+ std::deque< AttachedObject_Impl > aList = implCheckIndex( nIndex )->aObjList;
+ for( const auto& rObj : aList )
+ detach( nIndex, rObj.xTarget );
+
+ const ScriptEventDescriptor* pArray = ScriptEvents.getConstArray();
+ sal_Int32 nLen = ScriptEvents.getLength();
+ for( sal_Int32 i = 0 ; i < nLen ; i++ )
+ registerScriptEvent( nIndex, pArray[ i ] );
+
+ for( const auto& rObj : aList )
+ attach( nIndex, rObj.xTarget, rObj.aHelper );
+}
+
+
+void SAL_CALL ImplEventAttacherManager::revokeScriptEvent
+(
+ sal_Int32 nIndex,
+ const OUString& ListenerType,
+ const OUString& EventMethod,
+ const OUString& ToRemoveListenerParam
+)
+{
+ Guard< Mutex > aGuard( aLock );
+
+ std::deque<AttacherIndex_Impl>::iterator aIt = implCheckIndex( nIndex );
+
+ std::deque< AttachedObject_Impl > aList = aIt->aObjList;
+ for( const auto& rObj : aList )
+ detach( nIndex, rObj.xTarget );
+
+ std::u16string_view aLstType = ListenerType;
+ size_t nLastDot = aLstType.rfind('.');
+ if (nLastDot != std::u16string_view::npos)
+ aLstType = aLstType.substr(nLastDot+1);
+
+ auto aEvtIt = std::find_if(aIt->aEventList.begin(), aIt->aEventList.end(),
+ [&aLstType, &EventMethod, &ToRemoveListenerParam](const ScriptEventDescriptor& rEvent) {
+ return aLstType == rEvent.ListenerType
+ && EventMethod == rEvent.EventMethod
+ && ToRemoveListenerParam == rEvent.AddListenerParam;
+ });
+ if (aEvtIt != aIt->aEventList.end())
+ aIt->aEventList.erase( aEvtIt );
+
+ for( const auto& rObj : aList )
+ attach( nIndex, rObj.xTarget, rObj.aHelper );
+}
+
+
+void SAL_CALL ImplEventAttacherManager::revokeScriptEvents(sal_Int32 nIndex )
+{
+ Guard< Mutex > aGuard( aLock );
+ std::deque<AttacherIndex_Impl>::iterator aIt = implCheckIndex( nIndex );
+
+ std::deque< AttachedObject_Impl > aList = aIt->aObjList;
+ for( const auto& rObj : aList )
+ detach( nIndex, rObj.xTarget );
+ aIt->aEventList.clear();
+ for( const auto& rObj : aList )
+ attach( nIndex, rObj.xTarget, rObj.aHelper );
+}
+
+
+void SAL_CALL ImplEventAttacherManager::insertEntry(sal_Int32 nIndex)
+{
+ Guard< Mutex > aGuard( aLock );
+ if( nIndex < 0 )
+ throw IllegalArgumentException("negative index", static_cast<cppu::OWeakObject*>(this), 1);
+
+ if ( o3tl::make_unsigned(nIndex) >= aIndex.size() )
+ aIndex.resize(nIndex+1);
+
+ AttacherIndex_Impl aTmp;
+ aIndex.insert( aIndex.begin() + nIndex, aTmp );
+}
+
+
+void SAL_CALL ImplEventAttacherManager::removeEntry(sal_Int32 nIndex)
+{
+ Guard< Mutex > aGuard( aLock );
+ std::deque<AttacherIndex_Impl>::iterator aIt = implCheckIndex( nIndex );
+
+ std::deque< AttachedObject_Impl > aList = aIt->aObjList;
+ for( const auto& rObj : aList )
+ detach( nIndex, rObj.xTarget );
+
+ aIndex.erase( aIt );
+}
+
+
+Sequence< ScriptEventDescriptor > SAL_CALL ImplEventAttacherManager::getScriptEvents(sal_Int32 nIndex)
+{
+ Guard< Mutex > aGuard( aLock );
+ std::deque<AttacherIndex_Impl>::iterator aIt = implCheckIndex( nIndex );
+ return comphelper::containerToSequence(aIt->aEventList);
+}
+
+
+void SAL_CALL ImplEventAttacherManager::attach(sal_Int32 nIndex, const Reference< XInterface >& xObject, const Any & Helper)
+{
+ Guard< Mutex > aGuard( aLock );
+ if( nIndex < 0 || !xObject.is() )
+ throw IllegalArgumentException("negative index, or null object", static_cast<cppu::OWeakObject*>(this), -1);
+
+ if( o3tl::make_unsigned(nIndex) >= aIndex.size() )
+ {
+ // read older files
+ if( nVersion != 1 )
+ throw IllegalArgumentException();
+ insertEntry( nIndex );
+ attach( nIndex, xObject, Helper );
+ return;
+ }
+
+ std::deque< AttacherIndex_Impl >::iterator aCurrentPosition = aIndex.begin() + nIndex;
+
+ AttachedObject_Impl aTmp;
+ aTmp.xTarget = xObject;
+ aTmp.aHelper = Helper;
+ aCurrentPosition->aObjList.push_back( aTmp );
+
+ AttachedObject_Impl & rCurObj = aCurrentPosition->aObjList.back();
+ rCurObj.aAttachedListenerSeq = std::vector< Reference< XEventListener > >( aCurrentPosition->aEventList.size() );
+
+ if (aCurrentPosition->aEventList.empty())
+ return;
+
+ Sequence<css::script::EventListener> aEvents(aCurrentPosition->aEventList.size());
+ css::script::EventListener* p = aEvents.getArray();
+ size_t i = 0;
+ for (const auto& rEvent : aCurrentPosition->aEventList)
+ {
+ css::script::EventListener aListener;
+ aListener.AllListener =
+ new AttacherAllListener_Impl(this, rEvent.ScriptType, rEvent.ScriptCode);
+ aListener.Helper = rCurObj.aHelper;
+ aListener.ListenerType = rEvent.ListenerType;
+ aListener.EventMethod = rEvent.EventMethod;
+ aListener.AddListenerParam = rEvent.AddListenerParam;
+ p[i++] = aListener;
+ }
+
+ try
+ {
+ rCurObj.aAttachedListenerSeq = comphelper::sequenceToContainer<std::vector<Reference< XEventListener >>>(
+ xAttacher->attachMultipleEventListeners(rCurObj.xTarget, aEvents));
+ }
+ catch (const Exception&)
+ {
+ // Fail gracefully.
+ }
+}
+
+
+void SAL_CALL ImplEventAttacherManager::detach(sal_Int32 nIndex, const Reference< XInterface >& xObject)
+{
+ Guard< Mutex > aGuard( aLock );
+ //return;
+ if( nIndex < 0 || o3tl::make_unsigned(nIndex) >= aIndex.size() || !xObject.is() )
+ throw IllegalArgumentException("bad index or null object", static_cast<cppu::OWeakObject*>(this), 1);
+
+ std::deque< AttacherIndex_Impl >::iterator aCurrentPosition = aIndex.begin() + nIndex;
+ auto aObjIt = std::find_if(aCurrentPosition->aObjList.begin(), aCurrentPosition->aObjList.end(),
+ [&xObject](const AttachedObject_Impl& rObj) { return rObj.xTarget == xObject; });
+ if (aObjIt == aCurrentPosition->aObjList.end())
+ return;
+
+ sal_Int32 i = 0;
+ for( const auto& rEvt : aCurrentPosition->aEventList )
+ {
+ if( aObjIt->aAttachedListenerSeq[i].is() )
+ {
+ try
+ {
+ xAttacher->removeListener( aObjIt->xTarget, rEvt.ListenerType,
+ rEvt.AddListenerParam, aObjIt->aAttachedListenerSeq[i] );
+ }
+ catch( Exception& )
+ {
+ }
+ }
+ ++i;
+ }
+ aCurrentPosition->aObjList.erase( aObjIt );
+}
+
+void SAL_CALL ImplEventAttacherManager::addScriptListener(const Reference< XScriptListener >& aListener)
+{
+ Guard< Mutex > aGuard( aLock );
+ aScriptListeners.addInterface( aListener );
+}
+
+void SAL_CALL ImplEventAttacherManager::removeScriptListener(const Reference< XScriptListener >& aListener)
+{
+ Guard< Mutex > aGuard( aLock );
+ aScriptListeners.removeInterface( aListener );
+}
+
+
+// Methods of XPersistObject
+OUString SAL_CALL ImplEventAttacherManager::getServiceName()
+{
+ return "com.sun.star.uno.script.EventAttacherManager";
+}
+
+void SAL_CALL ImplEventAttacherManager::write(const Reference< XObjectOutputStream >& OutStream)
+{
+ Guard< Mutex > aGuard( aLock );
+ // Don't run without XMarkableStream
+ Reference< XMarkableStream > xMarkStream( OutStream, UNO_QUERY );
+ if( !xMarkStream.is() )
+ return;
+
+ // Write out the version
+ OutStream->writeShort( 2 );
+
+ // Remember position for length
+ sal_Int32 nObjLenMark = xMarkStream->createMark();
+ OutStream->writeLong( 0 );
+
+ OutStream->writeLong( aIndex.size() );
+
+ // Write out sequences
+ for( const auto& rIx : aIndex )
+ {
+ OutStream->writeLong( rIx.aEventList.size() );
+ for( const auto& rDesc : rIx.aEventList )
+ {
+ OutStream->writeUTF( rDesc.ListenerType );
+ OutStream->writeUTF( rDesc.EventMethod );
+ OutStream->writeUTF( rDesc.AddListenerParam );
+ OutStream->writeUTF( rDesc.ScriptType );
+ OutStream->writeUTF( rDesc.ScriptCode );
+ }
+ }
+
+ // The length is now known
+ sal_Int32 nObjLen = xMarkStream->offsetToMark( nObjLenMark ) -4;
+ xMarkStream->jumpToMark( nObjLenMark );
+ OutStream->writeLong( nObjLen );
+ xMarkStream->jumpToFurthest();
+ xMarkStream->deleteMark( nObjLenMark );
+}
+
+void SAL_CALL ImplEventAttacherManager::read(const Reference< XObjectInputStream >& InStream)
+{
+ Guard< Mutex > aGuard( aLock );
+ // Don't run without XMarkableStream
+ Reference< XMarkableStream > xMarkStream( InStream, UNO_QUERY );
+ if( !xMarkStream.is() )
+ return;
+
+ // Read in the version
+ nVersion = InStream->readShort();
+
+ // At first there's the data according to version 1 --
+ // this part needs to be kept in later versions.
+ sal_Int32 nLen = InStream->readLong();
+
+ // Position for comparative purposes
+ sal_Int32 nObjLenMark = xMarkStream->createMark();
+
+ // Number of read sequences
+ sal_Int32 nItemCount = InStream->readLong();
+
+ for( sal_Int32 i = 0 ; i < nItemCount ; i++ )
+ {
+ insertEntry( i );
+ // Read the length of the sequence
+ sal_Int32 nSeqLen = InStream->readLong();
+
+ // Display the sequences and read the descriptions
+ Sequence< ScriptEventDescriptor > aSEDSeq( nSeqLen );
+ ScriptEventDescriptor* pArray = aSEDSeq.getArray();
+ for( sal_Int32 j = 0 ; j < nSeqLen ; j++ )
+ {
+ ScriptEventDescriptor& rDesc = pArray[ j ];
+ rDesc.ListenerType = InStream->readUTF();
+ rDesc.EventMethod = InStream->readUTF();
+ rDesc.AddListenerParam = InStream->readUTF();
+ rDesc.ScriptType = InStream->readUTF();
+ rDesc.ScriptCode = InStream->readUTF();
+ }
+ registerScriptEvents( i, aSEDSeq );
+ }
+
+ // Have we read the specified length?
+ sal_Int32 nRealLen = xMarkStream->offsetToMark( nObjLenMark );
+ if( nRealLen != nLen )
+ {
+ // Only if the StreamVersion is > 1 and the date still follows, can
+ // this be true. Otherwise, something is completely gone.
+ if( nRealLen > nLen || nVersion == 1 )
+ {
+ OSL_FAIL( "ImplEventAttacherManager::read(): Fatal Error, wrong object length" );
+ }
+ else
+ { // TODO: Examine if caching the dates would be useful
+ // But for now, it's easier to skip it.
+ sal_Int32 nSkipCount = nLen - nRealLen;
+ InStream->skipBytes( nSkipCount );
+ }
+ }
+ xMarkStream->jumpToFurthest();
+ xMarkStream->deleteMark( nObjLenMark );
+}
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/AccessibleImplementationHelper.cxx b/comphelper/source/misc/AccessibleImplementationHelper.cxx
new file mode 100644
index 000000000..a45b6e5f3
--- /dev/null
+++ b/comphelper/source/misc/AccessibleImplementationHelper.cxx
@@ -0,0 +1,43 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * 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 <comphelper/AccessibleImplementationHelper.hxx>
+
+#include <com/sun/star/awt/KeyStroke.hpp>
+#include <com/sun/star/uno/Sequence.hxx>
+#include <rtl/ustrbuf.hxx>
+
+using namespace css::awt;
+using namespace css::uno;
+
+namespace comphelper
+{
+OUString GetkeyBindingStrByXkeyBinding(const Sequence<KeyStroke>& keySet)
+{
+ OUStringBuffer buf;
+ for (const auto& k : keySet)
+ {
+ buf.append('\n');
+ buf.append(k.KeyChar);
+ }
+ return buf.makeStringAndClear();
+}
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/comphelper/source/misc/DirectoryHelper.cxx b/comphelper/source/misc/DirectoryHelper.cxx
new file mode 100644
index 000000000..badfe9b62
--- /dev/null
+++ b/comphelper/source/misc/DirectoryHelper.cxx
@@ -0,0 +1,213 @@
+/* -*- 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/.
+ */
+
+#include <comphelper/DirectoryHelper.hxx>
+
+#include <sal/config.h>
+#include <osl/file.hxx>
+#include <rtl/uri.hxx>
+
+#include <memory>
+
+namespace comphelper
+{
+typedef std::shared_ptr<osl::File> FileSharedPtr;
+
+std::u16string_view DirectoryHelper::splitAtLastToken(std::u16string_view rSrc, sal_Unicode aToken,
+ OUString& rRight)
+{
+ const size_t nIndex(rSrc.rfind(aToken));
+ std::u16string_view aRetval;
+
+ if (std::u16string_view::npos == nIndex)
+ {
+ aRetval = rSrc;
+ rRight.clear();
+ }
+ else if (nIndex > 0)
+ {
+ aRetval = rSrc.substr(0, nIndex);
+
+ if (rSrc.size() > nIndex + 1)
+ {
+ rRight = rSrc.substr(nIndex + 1);
+ }
+ }
+
+ return aRetval;
+}
+
+bool DirectoryHelper::fileExists(const OUString& rBaseURL)
+{
+ if (!rBaseURL.isEmpty())
+ {
+ FileSharedPtr aBaseFile = std::make_shared<osl::File>(rBaseURL);
+
+ return (osl::File::E_None == aBaseFile->open(osl_File_OpenFlag_Read));
+ }
+
+ return false;
+}
+
+bool DirectoryHelper::dirExists(const OUString& rDirURL)
+{
+ if (!rDirURL.isEmpty())
+ {
+ osl::Directory aDirectory(rDirURL);
+
+ return (osl::FileBase::E_None == aDirectory.open());
+ }
+
+ return false;
+}
+
+void DirectoryHelper::scanDirsAndFiles(const OUString& rDirURL, std::set<OUString>& rDirs,
+ std::set<std::pair<OUString, OUString>>& rFiles)
+{
+ if (rDirURL.isEmpty())
+ return;
+
+ osl::Directory aDirectory(rDirURL);
+
+ if (osl::FileBase::E_None != aDirectory.open())
+ return;
+
+ auto lcl_encodeUriSegment = [](OUString const& rPath) {
+ return rtl::Uri::encode(rPath, rtl_UriCharClassUricNoSlash, rtl_UriEncodeIgnoreEscapes,
+ RTL_TEXTENCODING_UTF8);
+ };
+
+ osl::DirectoryItem aDirectoryItem;
+
+ while (osl::FileBase::E_None == aDirectory.getNextItem(aDirectoryItem))
+ {
+ osl::FileStatus aFileStatus(osl_FileStatus_Mask_Type | osl_FileStatus_Mask_FileName);
+
+ if (osl::FileBase::E_None == aDirectoryItem.getFileStatus(aFileStatus))
+ {
+ if (aFileStatus.isDirectory())
+ {
+ const OUString aFileName(aFileStatus.getFileName());
+
+ if (!aFileName.isEmpty())
+ {
+ rDirs.insert(lcl_encodeUriSegment(aFileName));
+ }
+ }
+ else if (aFileStatus.isRegular())
+ {
+ OUString aFileName(aFileStatus.getFileName());
+ OUString aExtension;
+ aFileName = splitAtLastToken(aFileName, '.', aExtension);
+
+ if (!aFileName.isEmpty())
+ {
+ rFiles.insert(std::pair<OUString, OUString>(lcl_encodeUriSegment(aFileName),
+ lcl_encodeUriSegment(aExtension)));
+ }
+ }
+ }
+ }
+}
+
+bool DirectoryHelper::deleteDirRecursively(const OUString& rDirURL)
+{
+ std::set<OUString> aDirs;
+ std::set<std::pair<OUString, OUString>> aFiles;
+ bool bError(false);
+
+ scanDirsAndFiles(rDirURL, aDirs, aFiles);
+
+ for (const auto& dir : aDirs)
+ {
+ const OUString aNewDirURL(rDirURL + "/" + dir);
+
+ bError |= deleteDirRecursively(aNewDirURL);
+ }
+
+ for (const auto& file : aFiles)
+ {
+ OUString aNewFileURL(rDirURL + "/" + file.first);
+
+ if (!file.second.isEmpty())
+ {
+ aNewFileURL += "." + file.second;
+ }
+ bError |= (osl::FileBase::E_None != osl::File::remove(aNewFileURL));
+ }
+
+ bError |= (osl::FileBase::E_None != osl::Directory::remove(rDirURL));
+
+ return bError;
+}
+
+// both exist, move content
+bool DirectoryHelper::moveDirContent(const OUString& rSourceDirURL,
+ std::u16string_view rTargetDirURL,
+ const std::set<OUString>& rExcludeList)
+{
+ std::set<OUString> aDirs;
+ std::set<std::pair<OUString, OUString>> aFiles;
+ bool bError(false);
+
+ scanDirsAndFiles(rSourceDirURL, aDirs, aFiles);
+
+ for (const auto& dir : aDirs)
+ {
+ const bool bExcluded(!rExcludeList.empty() && rExcludeList.find(dir) != rExcludeList.end());
+
+ if (!bExcluded)
+ {
+ const OUString aNewSourceDirURL(rSourceDirURL + "/" + dir);
+
+ if (dirExists(aNewSourceDirURL))
+ {
+ const OUString aNewTargetDirURL(OUString::Concat(rTargetDirURL) + "/" + dir);
+
+ if (dirExists(aNewTargetDirURL))
+ {
+ deleteDirRecursively(aNewTargetDirURL);
+ }
+
+ bError |= (osl::FileBase::E_None
+ != osl::File::move(aNewSourceDirURL, aNewTargetDirURL));
+ }
+ }
+ }
+
+ for (const auto& file : aFiles)
+ {
+ OUString aSourceFileURL(rSourceDirURL + "/" + file.first);
+
+ if (!file.second.isEmpty())
+ {
+ aSourceFileURL += "." + file.second;
+ }
+
+ if (fileExists(aSourceFileURL))
+ {
+ OUString aTargetFileURL(OUString::Concat(rTargetDirURL) + "/" + file.first);
+
+ if (!file.second.isEmpty())
+ {
+ aTargetFileURL += "." + file.second;
+ }
+
+ if (fileExists(aTargetFileURL))
+ {
+ osl::File::remove(aTargetFileURL);
+ }
+
+ bError |= (osl::FileBase::E_None != osl::File::move(aSourceFileURL, aTargetFileURL));
+ }
+ }
+
+ return bError;
+}
+}
diff --git a/comphelper/source/misc/SelectionMultiplex.cxx b/comphelper/source/misc/SelectionMultiplex.cxx
new file mode 100644
index 000000000..438eaa80d
--- /dev/null
+++ b/comphelper/source/misc/SelectionMultiplex.cxx
@@ -0,0 +1,111 @@
+/* -*- 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 <comphelper/SelectionMultiplex.hxx>
+#include <com/sun/star/view/XSelectionSupplier.hpp>
+
+namespace comphelper
+{
+
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::view;
+
+OSelectionChangeListener::~OSelectionChangeListener()
+{
+}
+
+
+void OSelectionChangeListener::_disposing(const EventObject&)
+{
+ // nothing to do here
+}
+
+
+OSelectionChangeMultiplexer::OSelectionChangeMultiplexer(OSelectionChangeListener* _pListener, const Reference< XSelectionSupplier>& _rxSet)
+ :m_xSet(_rxSet)
+ ,m_pListener(_pListener)
+ ,m_nLockCount(0)
+{
+ osl_atomic_increment(&m_refCount);
+ {
+ Reference< XSelectionChangeListener> xPreventDelete(this);
+ m_xSet->addSelectionChangeListener(xPreventDelete);
+ }
+ osl_atomic_decrement(&m_refCount);
+}
+
+
+OSelectionChangeMultiplexer::~OSelectionChangeMultiplexer()
+{
+}
+
+
+void OSelectionChangeMultiplexer::lock()
+{
+ ++m_nLockCount;
+}
+
+
+void OSelectionChangeMultiplexer::unlock()
+{
+ --m_nLockCount;
+}
+
+
+// XEventListener
+
+void SAL_CALL OSelectionChangeMultiplexer::disposing( const EventObject& _rSource)
+{
+ if (m_pListener)
+ {
+ // tell the listener
+ if (!locked())
+ m_pListener->_disposing(_rSource);
+ }
+
+ m_pListener = nullptr;
+
+ m_xSet = nullptr;
+}
+
+// XSelectionChangeListener
+
+void SAL_CALL OSelectionChangeMultiplexer::selectionChanged( const EventObject& _rEvent )
+{
+ if (m_pListener && !locked())
+ m_pListener->_selectionChanged(_rEvent);
+}
+
+void OSelectionChangeMultiplexer::dispose()
+{
+ osl_atomic_increment(&m_refCount);
+ {
+ Reference< XSelectionChangeListener> xPreventDelete(this);
+ if(m_xSet.is())
+ m_xSet->removeSelectionChangeListener(xPreventDelete);
+ }
+ osl_atomic_decrement(&m_refCount);
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/accessiblecomponenthelper.cxx b/comphelper/source/misc/accessiblecomponenthelper.cxx
new file mode 100644
index 000000000..2962bbac9
--- /dev/null
+++ b/comphelper/source/misc/accessiblecomponenthelper.cxx
@@ -0,0 +1,177 @@
+/* -*- 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 <comphelper/accessiblecomponenthelper.hxx>
+
+
+namespace comphelper
+{
+
+
+ using namespace ::com::sun::star;
+ using namespace ::com::sun::star::uno;
+ using namespace ::com::sun::star::lang;
+ using namespace ::com::sun::star::accessibility;
+
+ OCommonAccessibleComponent::OCommonAccessibleComponent( )
+ {
+ }
+
+
+ OCommonAccessibleComponent::~OCommonAccessibleComponent( )
+ {
+ }
+
+
+ bool OCommonAccessibleComponent::containsPoint( const awt::Point& _rPoint )
+ {
+ OExternalLockGuard aGuard( this );
+ awt::Rectangle aBounds( implGetBounds() );
+ return ( _rPoint.X >= 0 )
+ && ( _rPoint.Y >= 0 )
+ && ( _rPoint.X < aBounds.Width )
+ && ( _rPoint.Y < aBounds.Height );
+ }
+
+
+ awt::Point OCommonAccessibleComponent::getLocation( )
+ {
+ OExternalLockGuard aGuard( this );
+ awt::Rectangle aBounds( implGetBounds() );
+ return awt::Point( aBounds.X, aBounds.Y );
+ }
+
+
+ awt::Point OCommonAccessibleComponent::getLocationOnScreen( )
+ {
+ OExternalLockGuard aGuard( this );
+
+ awt::Point aScreenLoc( 0, 0 );
+
+ Reference< XAccessibleComponent > xParentComponent( implGetParentContext(), UNO_QUERY );
+ OSL_ENSURE( xParentComponent.is(), "OCommonAccessibleComponent::getLocationOnScreen: no parent component!" );
+ if ( xParentComponent.is() )
+ {
+ awt::Point aParentScreenLoc( xParentComponent->getLocationOnScreen() );
+ awt::Point aOwnRelativeLoc( getLocation() );
+ aScreenLoc.X = aParentScreenLoc.X + aOwnRelativeLoc.X;
+ aScreenLoc.Y = aParentScreenLoc.Y + aOwnRelativeLoc.Y;
+ }
+
+ return aScreenLoc;
+ }
+
+
+ awt::Size OCommonAccessibleComponent::getSize( )
+ {
+ OExternalLockGuard aGuard( this );
+ awt::Rectangle aBounds( implGetBounds() );
+ return awt::Size( aBounds.Width, aBounds.Height );
+ }
+
+
+ awt::Rectangle OCommonAccessibleComponent::getBounds( )
+ {
+ OExternalLockGuard aGuard( this );
+ return implGetBounds();
+ }
+
+ OAccessibleComponentHelper::OAccessibleComponentHelper( )
+ {
+ }
+
+
+ IMPLEMENT_FORWARD_XINTERFACE2( OAccessibleComponentHelper, OCommonAccessibleComponent, OAccessibleComponentHelper_Base )
+ IMPLEMENT_FORWARD_XTYPEPROVIDER2( OAccessibleComponentHelper, OCommonAccessibleComponent, OAccessibleComponentHelper_Base )
+ // (order matters: the first is the class name, the second is the class doing the ref counting)
+
+
+ sal_Bool SAL_CALL OAccessibleComponentHelper::containsPoint( const awt::Point& _rPoint )
+ {
+ return OCommonAccessibleComponent::containsPoint( _rPoint );
+ }
+
+
+ awt::Point SAL_CALL OAccessibleComponentHelper::getLocation( )
+ {
+ return OCommonAccessibleComponent::getLocation( );
+ }
+
+
+ awt::Point SAL_CALL OAccessibleComponentHelper::getLocationOnScreen( )
+ {
+ return OCommonAccessibleComponent::getLocationOnScreen( );
+ }
+
+
+ awt::Size SAL_CALL OAccessibleComponentHelper::getSize( )
+ {
+ return OCommonAccessibleComponent::getSize( );
+ }
+
+
+ awt::Rectangle SAL_CALL OAccessibleComponentHelper::getBounds( )
+ {
+ return OCommonAccessibleComponent::getBounds( );
+ }
+
+ OAccessibleExtendedComponentHelper::OAccessibleExtendedComponentHelper( )
+ {
+ }
+
+
+ IMPLEMENT_FORWARD_XINTERFACE2( OAccessibleExtendedComponentHelper, OCommonAccessibleComponent, OAccessibleExtendedComponentHelper_Base )
+ IMPLEMENT_FORWARD_XTYPEPROVIDER2( OAccessibleExtendedComponentHelper, OCommonAccessibleComponent, OAccessibleExtendedComponentHelper_Base )
+ // (order matters: the first is the class name, the second is the class doing the ref counting)
+
+
+ sal_Bool SAL_CALL OAccessibleExtendedComponentHelper::containsPoint( const awt::Point& _rPoint )
+ {
+ return OCommonAccessibleComponent::containsPoint( _rPoint );
+ }
+
+
+ awt::Point SAL_CALL OAccessibleExtendedComponentHelper::getLocation( )
+ {
+ return OCommonAccessibleComponent::getLocation( );
+ }
+
+
+ awt::Point SAL_CALL OAccessibleExtendedComponentHelper::getLocationOnScreen( )
+ {
+ return OCommonAccessibleComponent::getLocationOnScreen( );
+ }
+
+
+ awt::Size SAL_CALL OAccessibleExtendedComponentHelper::getSize( )
+ {
+ return OCommonAccessibleComponent::getSize( );
+ }
+
+
+ awt::Rectangle SAL_CALL OAccessibleExtendedComponentHelper::getBounds( )
+ {
+ return OCommonAccessibleComponent::getBounds( );
+ }
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/accessiblecontexthelper.cxx b/comphelper/source/misc/accessiblecontexthelper.cxx
new file mode 100644
index 000000000..ad2c63b1a
--- /dev/null
+++ b/comphelper/source/misc/accessiblecontexthelper.cxx
@@ -0,0 +1,248 @@
+/* -*- 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 <comphelper/accessiblecontexthelper.hxx>
+#include <osl/diagnose.h>
+#include <cppuhelper/weakref.hxx>
+#include <com/sun/star/accessibility/IllegalAccessibleComponentStateException.hpp>
+#include <comphelper/accessibleeventnotifier.hxx>
+#include <comphelper/solarmutex.hxx>
+
+
+namespace comphelper
+{
+ using namespace ::com::sun::star::uno;
+ using namespace ::com::sun::star::lang;
+ using namespace ::com::sun::star::accessibility;
+
+ OAccessibleContextHelper::OAccessibleContextHelper( )
+ :OAccessibleContextHelper_Base( GetMutex() )
+ ,m_nClientId( 0 )
+ {
+ }
+
+
+ OAccessibleContextHelper::~OAccessibleContextHelper( )
+ {
+ // this ensures that the lock, which may be already destroyed as part of the derivee,
+ // is not used anymore
+
+ ensureDisposed();
+ }
+
+
+ void SAL_CALL OAccessibleContextHelper::disposing()
+ {
+ // rhbz#1001768: de facto this class is locked by SolarMutex;
+ // do not lock m_Mutex because it may cause deadlock
+ osl::Guard<SolarMutex> aGuard(SolarMutex::get());
+
+ if ( m_nClientId )
+ {
+ AccessibleEventNotifier::revokeClientNotifyDisposing( m_nClientId, *this );
+ m_nClientId=0;
+ }
+ }
+
+
+ void SAL_CALL OAccessibleContextHelper::addAccessibleEventListener( const Reference< XAccessibleEventListener >& _rxListener )
+ {
+ osl::Guard<SolarMutex> aGuard(SolarMutex::get());
+ // don't use the OContextEntryGuard - it will throw an exception if we're not alive
+ // anymore, while the most recent specification for XComponent states that we should
+ // silently ignore the call in such a situation
+ if ( !isAlive() )
+ {
+ if ( _rxListener.is() )
+ _rxListener->disposing( EventObject( *this ) );
+ return;
+ }
+
+ if ( _rxListener.is() )
+ {
+ if ( !m_nClientId )
+ m_nClientId = AccessibleEventNotifier::registerClient( );
+
+ AccessibleEventNotifier::addEventListener( m_nClientId, _rxListener );
+ }
+ }
+
+
+ void SAL_CALL OAccessibleContextHelper::removeAccessibleEventListener( const Reference< XAccessibleEventListener >& _rxListener )
+ {
+ osl::Guard<SolarMutex> aGuard(SolarMutex::get());
+ // don't use the OContextEntryGuard - it will throw an exception if we're not alive
+ // anymore, while the most recent specification for XComponent states that we should
+ // silently ignore the call in such a situation
+ if ( !isAlive() )
+ return;
+
+ if ( !(_rxListener.is() && m_nClientId) )
+ return;
+
+ sal_Int32 nListenerCount = AccessibleEventNotifier::removeEventListener( m_nClientId, _rxListener );
+ if ( !nListenerCount )
+ {
+ // no listeners anymore
+ // -> revoke ourself. This may lead to the notifier thread dying (if we were the last client),
+ // and at least to us not firing any events anymore, in case somebody calls
+ // NotifyAccessibleEvent, again
+ AccessibleEventNotifier::revokeClient( m_nClientId );
+ m_nClientId = 0;
+ }
+ }
+
+
+ void OAccessibleContextHelper::NotifyAccessibleEvent( const sal_Int16 _nEventId,
+ const Any& _rOldValue, const Any& _rNewValue )
+ {
+ if ( !m_nClientId )
+ // if we don't have a client id for the notifier, then we don't have listeners, then
+ // we don't need to notify anything
+ return;
+
+ // build an event object
+ AccessibleEventObject aEvent;
+ aEvent.Source = *this;
+ aEvent.EventId = _nEventId;
+ aEvent.OldValue = _rOldValue;
+ aEvent.NewValue = _rNewValue;
+
+ // let the notifier handle this event
+ AccessibleEventNotifier::addEvent( m_nClientId, aEvent );
+ }
+
+
+ bool OAccessibleContextHelper::isAlive() const
+ {
+ return !rBHelper.bDisposed && !rBHelper.bInDispose;
+ }
+
+
+ void OAccessibleContextHelper::ensureAlive() const
+ {
+ if( !isAlive() )
+ throw DisposedException();
+ }
+
+
+ void OAccessibleContextHelper::ensureDisposed( )
+ {
+ if ( !rBHelper.bDisposed )
+ {
+ OSL_ENSURE( 0 == m_refCount, "OAccessibleContextHelper::ensureDisposed: this method _has_ to be called from without your dtor only!" );
+ acquire();
+ dispose();
+ }
+ }
+
+
+ void OAccessibleContextHelper::lateInit( const Reference< XAccessible >& _rxAccessible )
+ {
+ m_aCreator = _rxAccessible;
+ }
+
+
+ Reference< XAccessible > OAccessibleContextHelper::getAccessibleCreator( ) const
+ {
+ return m_aCreator;
+ }
+
+
+ OUString SAL_CALL OAccessibleContextHelper::getAccessibleId( )
+ {
+ return OUString();
+ }
+
+
+ sal_Int32 SAL_CALL OAccessibleContextHelper::getAccessibleIndexInParent( )
+ {
+ OExternalLockGuard aGuard( this );
+
+ // -1 for child not found/no parent (according to specification)
+ sal_Int32 nRet = -1;
+
+ try
+ {
+
+ Reference< XAccessibleContext > xParentContext( implGetParentContext() );
+
+ // iterate over parent's children and search for this object
+ if ( xParentContext.is() )
+ {
+ // our own XAccessible for comparing with the children of our parent
+ Reference< XAccessible > xCreator( m_aCreator);
+
+ OSL_ENSURE( xCreator.is(), "OAccessibleContextHelper::getAccessibleIndexInParent: invalid creator!" );
+ // two ideas why this could be NULL:
+ // * nobody called our late ctor (init), so we never had a creator at all -> bad
+ // * the creator is already dead. In this case, we should have been disposed, and
+ // never survived the above OContextEntryGuard.
+ // in all other situations the creator should be non-NULL
+
+ if ( xCreator.is() )
+ {
+ sal_Int32 nChildCount = xParentContext->getAccessibleChildCount();
+ for ( sal_Int32 nChild = 0; ( nChild < nChildCount ) && ( -1 == nRet ); ++nChild )
+ {
+ Reference< XAccessible > xChild( xParentContext->getAccessibleChild( nChild ) );
+ if ( xChild.get() == xCreator.get() )
+ nRet = nChild;
+ }
+ }
+ }
+ }
+ catch( const Exception& )
+ {
+ OSL_FAIL( "OAccessibleContextHelper::getAccessibleIndexInParent: caught an exception!" );
+ }
+
+ return nRet;
+ }
+
+
+ Locale SAL_CALL OAccessibleContextHelper::getLocale( )
+ {
+ // simply ask the parent
+ Reference< XAccessible > xParent = getAccessibleParent();
+ Reference< XAccessibleContext > xParentContext;
+ if ( xParent.is() )
+ xParentContext = xParent->getAccessibleContext();
+
+ if ( !xParentContext.is() )
+ throw IllegalAccessibleComponentStateException( OUString(), *this );
+
+ return xParentContext->getLocale();
+ }
+
+
+ Reference< XAccessibleContext > OAccessibleContextHelper::implGetParentContext()
+ {
+ Reference< XAccessible > xParent = getAccessibleParent();
+ Reference< XAccessibleContext > xParentContext;
+ if ( xParent.is() )
+ xParentContext = xParent->getAccessibleContext();
+ return xParentContext;
+ }
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/accessibleeventnotifier.cxx b/comphelper/source/misc/accessibleeventnotifier.cxx
new file mode 100644
index 000000000..f8bd5a117
--- /dev/null
+++ b/comphelper/source/misc/accessibleeventnotifier.cxx
@@ -0,0 +1,274 @@
+/* -*- 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 <comphelper/accessibleeventnotifier.hxx>
+#include <com/sun/star/accessibility/XAccessibleEventListener.hpp>
+#include <comphelper/interfacecontainer4.hxx>
+
+#include <map>
+#include <memory>
+#include <limits>
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::accessibility;
+using namespace ::comphelper;
+
+namespace {
+
+typedef std::pair< AccessibleEventNotifier::TClientId,
+ AccessibleEventObject > ClientEvent;
+
+typedef ::comphelper::OInterfaceContainerHelper4<XAccessibleEventListener> ListenerContainer;
+typedef std::map< AccessibleEventNotifier::TClientId, ListenerContainer* > ClientMap;
+
+/// key is the end of the interval, value is the start of the interval
+typedef std::map<AccessibleEventNotifier::TClientId,
+ AccessibleEventNotifier::TClientId> IntervalMap;
+
+std::mutex& GetLocalMutex()
+{
+ static std::mutex MUTEX;
+ return MUTEX;
+}
+
+ClientMap gaClients;
+
+IntervalMap& GetFreeIntervals()
+{
+ static IntervalMap MAP =
+ []()
+ {
+ IntervalMap map;
+ map.insert(std::make_pair(
+ std::numeric_limits<AccessibleEventNotifier::TClientId>::max(), 1));
+ return map;
+ }();
+ return MAP;
+}
+
+void releaseId(AccessibleEventNotifier::TClientId const nId)
+{
+ IntervalMap & rFreeIntervals(GetFreeIntervals());
+ IntervalMap::iterator const upper(rFreeIntervals.upper_bound(nId));
+ assert(upper != rFreeIntervals.end());
+ assert(nId < upper->second); // second is start of the interval!
+ if (nId + 1 == upper->second)
+ {
+ --upper->second; // add nId to existing interval
+ }
+ else
+ {
+ IntervalMap::iterator const lower(rFreeIntervals.lower_bound(nId));
+ if (lower != rFreeIntervals.end() && lower->first == nId - 1)
+ {
+ // add nId by replacing lower with new merged entry
+ rFreeIntervals.insert(std::make_pair(nId, lower->second));
+ rFreeIntervals.erase(lower);
+ }
+ else // otherwise just add new 1-element interval
+ {
+ rFreeIntervals.insert(std::make_pair(nId, nId));
+ }
+ }
+ // currently it's not checked whether intervals can be merged now
+ // hopefully that won't be a problem in practice
+}
+
+/// generates a new client id
+AccessibleEventNotifier::TClientId generateId()
+{
+ IntervalMap & rFreeIntervals(GetFreeIntervals());
+ assert(!rFreeIntervals.empty());
+ IntervalMap::iterator const iter(rFreeIntervals.begin());
+ AccessibleEventNotifier::TClientId const nFirst = iter->first;
+ AccessibleEventNotifier::TClientId const nFreeId = iter->second;
+ assert(nFreeId <= nFirst);
+ if (nFreeId != nFirst)
+ {
+ ++iter->second; // remove nFreeId from interval
+ }
+ else
+ {
+ rFreeIntervals.erase(iter); // remove 1-element interval
+ }
+
+ assert(gaClients.end() == gaClients.find(nFreeId));
+
+ return nFreeId;
+}
+
+/** looks up a client in our client map, asserts if it cannot find it or
+ no event thread is present
+
+ @precond
+ to be called with our mutex locked
+
+ @param nClient
+ the id of the client to lookup
+ @param rPos
+ out-parameter for the position of the client in the client map
+
+ @return
+ <TRUE/> if and only if the client could be found and
+ <arg>rPos</arg> has been filled with its position
+*/
+bool implLookupClient(
+ const AccessibleEventNotifier::TClientId nClient,
+ ClientMap::iterator& rPos )
+{
+ // look up this client
+ ClientMap &rClients = gaClients;
+ rPos = rClients.find( nClient );
+ assert( rClients.end() != rPos &&
+ "AccessibleEventNotifier::implLookupClient: invalid client id "
+ "(did you register your client?)!" );
+
+ return ( rClients.end() != rPos );
+}
+
+} // anonymous namespace
+
+namespace comphelper {
+
+AccessibleEventNotifier::TClientId AccessibleEventNotifier::registerClient()
+{
+ std::scoped_lock aGuard( GetLocalMutex() );
+
+ // generate a new client id
+ TClientId nNewClientId = generateId( );
+
+ // the event listeners for the new client
+ ListenerContainer * pNewListeners = new ListenerContainer();
+ // add the client
+ gaClients.emplace( nNewClientId, pNewListeners );
+
+ // outta here
+ return nNewClientId;
+}
+
+void AccessibleEventNotifier::revokeClient( const TClientId _nClient )
+{
+ std::scoped_lock aGuard( GetLocalMutex() );
+
+ ClientMap::iterator aClientPos;
+ if ( !implLookupClient( _nClient, aClientPos ) )
+ // already asserted in implLookupClient
+ return;
+
+ // remove it from the clients map
+ delete aClientPos->second;
+ gaClients.erase( aClientPos );
+ releaseId(_nClient);
+}
+
+void AccessibleEventNotifier::revokeClientNotifyDisposing(
+ const TClientId _nClient, const Reference< XInterface >& _rxEventSource )
+{
+ std::unique_lock aGuard( GetLocalMutex() );
+
+ ClientMap::iterator aClientPos;
+ if (!implLookupClient(_nClient, aClientPos))
+ // already asserted in implLookupClient
+ return;
+
+ // notify the listeners
+ std::unique_ptr<ListenerContainer> pListeners(aClientPos->second);
+
+ // we do not need the entry in the clients map anymore
+ // (do this before actually notifying, because some client
+ // implementations have re-entrance problems and call into
+ // revokeClient while we are notifying from here)
+ gaClients.erase(aClientPos);
+ releaseId(_nClient);
+
+ // notify the "disposing" event for this client
+ EventObject aDisposalEvent;
+ aDisposalEvent.Source = _rxEventSource;
+
+ // now really do the notification
+ pListeners->disposeAndClear( aGuard, aDisposalEvent );
+}
+
+sal_Int32 AccessibleEventNotifier::addEventListener(
+ const TClientId _nClient, const Reference< XAccessibleEventListener >& _rxListener )
+{
+ std::unique_lock aGuard( GetLocalMutex() );
+
+ ClientMap::iterator aClientPos;
+ if ( !implLookupClient( _nClient, aClientPos ) )
+ // already asserted in implLookupClient
+ return 0;
+
+ if ( _rxListener.is() )
+ aClientPos->second->addInterface( aGuard, _rxListener );
+
+ return aClientPos->second->getLength(aGuard);
+}
+
+sal_Int32 AccessibleEventNotifier::removeEventListener(
+ const TClientId _nClient, const Reference< XAccessibleEventListener >& _rxListener )
+{
+ std::unique_lock aGuard( GetLocalMutex() );
+
+ ClientMap::iterator aClientPos;
+ if ( !implLookupClient( _nClient, aClientPos ) )
+ // already asserted in implLookupClient
+ return 0;
+
+ if ( _rxListener.is() )
+ aClientPos->second->removeInterface( aGuard, _rxListener );
+
+ return aClientPos->second->getLength(aGuard);
+}
+
+void AccessibleEventNotifier::addEvent( const TClientId _nClient, const AccessibleEventObject& _rEvent )
+{
+ std::vector< Reference< XAccessibleEventListener > > aListeners;
+
+ {
+ std::unique_lock aGuard( GetLocalMutex() );
+
+ ClientMap::iterator aClientPos;
+ if ( !implLookupClient( _nClient, aClientPos ) )
+ // already asserted in implLookupClient
+ return;
+
+ // since we're synchronous, again, we want to notify immediately
+ aListeners = aClientPos->second->getElements(aGuard);
+ }
+
+ // default handling: loop through all listeners, and notify them
+ for ( const auto& rListener : aListeners )
+ {
+ try
+ {
+ rListener->notifyEvent( _rEvent );
+ }
+ catch( const Exception& )
+ {
+ // no assertion, because a broken access remote bridge or something like this
+ // can cause this exception
+ }
+ }
+}
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/accessiblekeybindinghelper.cxx b/comphelper/source/misc/accessiblekeybindinghelper.cxx
new file mode 100644
index 000000000..d1db69b98
--- /dev/null
+++ b/comphelper/source/misc/accessiblekeybindinghelper.cxx
@@ -0,0 +1,97 @@
+/* -*- 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 <sal/config.h>
+
+#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
+#include <comphelper/accessiblekeybindinghelper.hxx>
+#include <o3tl/safeint.hxx>
+
+
+namespace comphelper
+{
+
+
+ using namespace ::com::sun::star; // MT 04/2003: was ::drafts::com::sun::star - otherwise too many changes
+ using namespace ::com::sun::star::uno;
+ using namespace ::com::sun::star::lang;
+ using namespace ::com::sun::star::accessibility;
+
+
+ // OAccessibleKeyBindingHelper
+
+
+ OAccessibleKeyBindingHelper::OAccessibleKeyBindingHelper()
+ {
+ }
+
+
+ OAccessibleKeyBindingHelper::OAccessibleKeyBindingHelper( const OAccessibleKeyBindingHelper& rHelper )
+ : cppu::WeakImplHelper<XAccessibleKeyBinding>( rHelper )
+ , m_aKeyBindings( rHelper.m_aKeyBindings )
+ {
+ }
+
+
+ OAccessibleKeyBindingHelper::~OAccessibleKeyBindingHelper()
+ {
+ }
+
+
+ void OAccessibleKeyBindingHelper::AddKeyBinding( const Sequence< awt::KeyStroke >& rKeyBinding )
+ {
+ std::scoped_lock aGuard( m_aMutex );
+
+ m_aKeyBindings.push_back( rKeyBinding );
+ }
+
+
+ void OAccessibleKeyBindingHelper::AddKeyBinding( const awt::KeyStroke& rKeyStroke )
+ {
+ std::scoped_lock aGuard( m_aMutex );
+ m_aKeyBindings.push_back( { rKeyStroke } );
+ }
+
+
+ // XAccessibleKeyBinding
+
+
+ sal_Int32 OAccessibleKeyBindingHelper::getAccessibleKeyBindingCount()
+ {
+ std::scoped_lock aGuard( m_aMutex );
+
+ return m_aKeyBindings.size();
+ }
+
+
+ Sequence< awt::KeyStroke > OAccessibleKeyBindingHelper::getAccessibleKeyBinding( sal_Int32 nIndex )
+ {
+ std::scoped_lock aGuard( m_aMutex );
+
+ if ( nIndex < 0 || o3tl::make_unsigned(nIndex) >= m_aKeyBindings.size() )
+ throw IndexOutOfBoundsException();
+
+ return m_aKeyBindings[nIndex];
+ }
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/accessibleselectionhelper.cxx b/comphelper/source/misc/accessibleselectionhelper.cxx
new file mode 100644
index 000000000..967c1b079
--- /dev/null
+++ b/comphelper/source/misc/accessibleselectionhelper.cxx
@@ -0,0 +1,172 @@
+/* -*- 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 <comphelper/accessibleselectionhelper.hxx>
+
+
+namespace comphelper
+{
+
+
+ using namespace ::com::sun::star::uno;
+ using namespace ::com::sun::star::awt;
+ using namespace ::com::sun::star::lang;
+ using namespace ::com::sun::star::accessibility;
+
+ OCommonAccessibleSelection::OCommonAccessibleSelection( )
+ {
+ }
+
+ OCommonAccessibleSelection::~OCommonAccessibleSelection() {}
+
+
+ void OCommonAccessibleSelection::selectAccessibleChild( sal_Int32 nChildIndex )
+ {
+ implSelect( nChildIndex, true );
+ }
+
+
+ bool OCommonAccessibleSelection::isAccessibleChildSelected( sal_Int32 nChildIndex )
+ {
+ return implIsSelected( nChildIndex );
+ }
+
+
+ void OCommonAccessibleSelection::clearAccessibleSelection( )
+ {
+ implSelect( ACCESSIBLE_SELECTION_CHILD_ALL, false );
+ }
+
+
+ void OCommonAccessibleSelection::selectAllAccessibleChildren( )
+ {
+ implSelect( ACCESSIBLE_SELECTION_CHILD_ALL, true );
+ }
+
+
+ sal_Int32 OCommonAccessibleSelection::getSelectedAccessibleChildCount( )
+ {
+ sal_Int32 nRet = 0;
+ Reference< XAccessibleContext > xParentContext( implGetAccessibleContext() );
+
+ OSL_ENSURE( xParentContext.is(), "OCommonAccessibleSelection::getSelectedAccessibleChildCount: no parent context!" );
+
+ if( xParentContext.is() )
+ {
+ for( sal_Int32 i = 0, nChildCount = xParentContext->getAccessibleChildCount(); i < nChildCount; i++ )
+ if( implIsSelected( i ) )
+ ++nRet;
+ }
+
+ return nRet;
+ }
+
+
+ Reference< XAccessible > OCommonAccessibleSelection::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex )
+ {
+ Reference< XAccessible > xRet;
+ Reference< XAccessibleContext > xParentContext( implGetAccessibleContext() );
+
+ OSL_ENSURE( xParentContext.is(), "OCommonAccessibleSelection::getSelectedAccessibleChildCount: no parent context!" );
+
+ if( xParentContext.is() )
+ {
+ for( sal_Int32 i = 0, nChildCount = xParentContext->getAccessibleChildCount(), nPos = 0; ( i < nChildCount ) && !xRet.is(); i++ )
+ if( implIsSelected( i ) && ( nPos++ == nSelectedChildIndex ) )
+ xRet = xParentContext->getAccessibleChild( i );
+ }
+
+ return xRet;
+ }
+
+
+ void OCommonAccessibleSelection::deselectAccessibleChild( sal_Int32 nSelectedChildIndex )
+ {
+ implSelect( nSelectedChildIndex, false );
+ }
+
+ OAccessibleSelectionHelper::OAccessibleSelectionHelper()
+ {
+ }
+
+
+ IMPLEMENT_FORWARD_XINTERFACE2( OAccessibleSelectionHelper, OAccessibleComponentHelper, OAccessibleSelectionHelper_Base )
+ IMPLEMENT_FORWARD_XTYPEPROVIDER2( OAccessibleSelectionHelper, OAccessibleComponentHelper, OAccessibleSelectionHelper_Base )
+ // (order matters: the first is the class name, the second is the class doing the ref counting)
+
+
+ Reference< XAccessibleContext > OAccessibleSelectionHelper::implGetAccessibleContext()
+ {
+ return this;
+ }
+
+
+ void SAL_CALL OAccessibleSelectionHelper::selectAccessibleChild( sal_Int32 nChildIndex )
+ {
+ OExternalLockGuard aGuard( this );
+ OCommonAccessibleSelection::selectAccessibleChild( nChildIndex );
+ }
+
+
+ sal_Bool SAL_CALL OAccessibleSelectionHelper::isAccessibleChildSelected( sal_Int32 nChildIndex )
+ {
+ OExternalLockGuard aGuard( this );
+ return OCommonAccessibleSelection::isAccessibleChildSelected( nChildIndex );
+ }
+
+
+ void SAL_CALL OAccessibleSelectionHelper::clearAccessibleSelection( )
+ {
+ OExternalLockGuard aGuard( this );
+ OCommonAccessibleSelection::clearAccessibleSelection();
+ }
+
+
+ void SAL_CALL OAccessibleSelectionHelper::selectAllAccessibleChildren( )
+ {
+ OExternalLockGuard aGuard( this );
+ OCommonAccessibleSelection::selectAllAccessibleChildren();
+ }
+
+
+ sal_Int32 SAL_CALL OAccessibleSelectionHelper::getSelectedAccessibleChildCount( )
+ {
+ OExternalLockGuard aGuard( this );
+ return OCommonAccessibleSelection::getSelectedAccessibleChildCount();
+ }
+
+
+ Reference< XAccessible > SAL_CALL OAccessibleSelectionHelper::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex )
+ {
+ OExternalLockGuard aGuard( this );
+ return OCommonAccessibleSelection::getSelectedAccessibleChild( nSelectedChildIndex );
+ }
+
+
+ void SAL_CALL OAccessibleSelectionHelper::deselectAccessibleChild( sal_Int32 nSelectedChildIndex )
+ {
+ OExternalLockGuard aGuard( this );
+ OCommonAccessibleSelection::deselectAccessibleChild( nSelectedChildIndex );
+ }
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/accessibletexthelper.cxx b/comphelper/source/misc/accessibletexthelper.cxx
new file mode 100644
index 000000000..27747b3bc
--- /dev/null
+++ b/comphelper/source/misc/accessibletexthelper.cxx
@@ -0,0 +1,800 @@
+/* -*- 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 <comphelper/accessibletexthelper.hxx>
+#include <com/sun/star/accessibility/AccessibleTextType.hpp>
+#include <com/sun/star/i18n/BreakIterator.hpp>
+#include <com/sun/star/i18n/CharacterIteratorMode.hpp>
+#include <com/sun/star/i18n/CharacterClassification.hpp>
+#include <com/sun/star/i18n/WordType.hpp>
+#include <com/sun/star/i18n/KCharacterType.hpp>
+#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
+#include <comphelper/processfactory.hxx>
+#include <com/sun/star/accessibility/TextSegment.hpp>
+
+#include <algorithm>
+
+
+namespace comphelper
+{
+
+
+ using namespace ::com::sun::star;
+ using namespace ::com::sun::star::uno;
+ using namespace ::com::sun::star::lang;
+ using namespace ::com::sun::star::beans;
+ using namespace ::com::sun::star::accessibility;
+
+
+ // OCommonAccessibleText
+
+
+ OCommonAccessibleText::OCommonAccessibleText()
+ {
+ }
+
+
+ OCommonAccessibleText::~OCommonAccessibleText()
+ {
+ }
+
+
+ Reference < i18n::XBreakIterator > const & OCommonAccessibleText::implGetBreakIterator()
+ {
+ if ( !m_xBreakIter.is() )
+ {
+ Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext();
+ m_xBreakIter = i18n::BreakIterator::create(xContext);
+ }
+
+ return m_xBreakIter;
+ }
+
+
+ Reference < i18n::XCharacterClassification > const & OCommonAccessibleText::implGetCharacterClassification()
+ {
+ if ( !m_xCharClass.is() )
+ {
+ m_xCharClass = i18n::CharacterClassification::create( ::comphelper::getProcessComponentContext() );
+ }
+
+ return m_xCharClass;
+ }
+
+
+ bool OCommonAccessibleText::implIsValidBoundary( i18n::Boundary const & rBoundary, sal_Int32 nLength )
+ {
+ return ( rBoundary.startPos >= 0 ) && ( rBoundary.startPos < nLength ) && ( rBoundary.endPos >= 0 ) && ( rBoundary.endPos <= nLength );
+ }
+
+
+ bool OCommonAccessibleText::implIsValidIndex( sal_Int32 nIndex, sal_Int32 nLength )
+ {
+ return ( nIndex >= 0 ) && ( nIndex < nLength );
+ }
+
+
+ bool OCommonAccessibleText::implIsValidRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex, sal_Int32 nLength )
+ {
+ return ( nStartIndex >= 0 ) && ( nStartIndex <= nLength ) && ( nEndIndex >= 0 ) && ( nEndIndex <= nLength );
+ }
+
+
+ void OCommonAccessibleText::implGetGlyphBoundary( const OUString& rText, i18n::Boundary& rBoundary, sal_Int32 nIndex )
+ {
+ if ( implIsValidIndex( nIndex, rText.getLength() ) )
+ {
+ Reference < i18n::XBreakIterator > xBreakIter = implGetBreakIterator();
+ if ( xBreakIter.is() )
+ {
+ sal_Int32 nCount = 1;
+ sal_Int32 nDone;
+ sal_Int32 nStartIndex = xBreakIter->previousCharacters( rText, nIndex, implGetLocale(), i18n::CharacterIteratorMode::SKIPCELL, nCount, nDone );
+ if ( nDone != 0 )
+ nStartIndex = xBreakIter->nextCharacters( rText, nStartIndex, implGetLocale(), i18n::CharacterIteratorMode::SKIPCELL, nCount, nDone );
+ sal_Int32 nEndIndex = xBreakIter->nextCharacters( rText, nStartIndex, implGetLocale(), i18n::CharacterIteratorMode::SKIPCELL, nCount, nDone );
+ if ( nDone != 0 )
+ {
+ rBoundary.startPos = nStartIndex;
+ rBoundary.endPos = nEndIndex;
+ }
+ }
+ }
+ else
+ {
+ rBoundary.startPos = nIndex;
+ rBoundary.endPos = nIndex;
+ }
+ }
+
+
+ bool OCommonAccessibleText::implGetWordBoundary( const OUString& rText, i18n::Boundary& rBoundary, sal_Int32 nIndex )
+ {
+ bool bWord = false;
+
+ if ( implIsValidIndex( nIndex, rText.getLength() ) )
+ {
+ Reference < i18n::XBreakIterator > xBreakIter = implGetBreakIterator();
+ if ( xBreakIter.is() )
+ {
+ rBoundary = xBreakIter->getWordBoundary( rText, nIndex, implGetLocale(), i18n::WordType::ANY_WORD, true );
+
+ // it's a word, if the first character is an alpha-numeric character
+ Reference< i18n::XCharacterClassification > xCharClass = implGetCharacterClassification();
+ if ( xCharClass.is() )
+ {
+ sal_Int32 nType = xCharClass->getCharacterType( rText, rBoundary.startPos, implGetLocale() );
+ if ( ( nType & ( i18n::KCharacterType::LETTER | i18n::KCharacterType::DIGIT ) ) != 0 )
+ bWord = true;
+ }
+ }
+ }
+ else
+ {
+ rBoundary.startPos = nIndex;
+ rBoundary.endPos = nIndex;
+ }
+
+ return bWord;
+ }
+
+
+ void OCommonAccessibleText::implGetSentenceBoundary( const OUString& rText, i18n::Boundary& rBoundary, sal_Int32 nIndex )
+ {
+ if ( implIsValidIndex( nIndex, rText.getLength() ) )
+ {
+ Locale aLocale = implGetLocale();
+ Reference < i18n::XBreakIterator > xBreakIter = implGetBreakIterator();
+ if ( xBreakIter.is() )
+ {
+ rBoundary.endPos = xBreakIter->endOfSentence( rText, nIndex, aLocale );
+ rBoundary.startPos = xBreakIter->beginOfSentence( rText, rBoundary.endPos, aLocale );
+ }
+ }
+ else
+ {
+ rBoundary.startPos = nIndex;
+ rBoundary.endPos = nIndex;
+ }
+ }
+
+
+ void OCommonAccessibleText::implGetParagraphBoundary( const OUString& rText, i18n::Boundary& rBoundary, sal_Int32 nIndex )
+ {
+ if ( implIsValidIndex( nIndex, rText.getLength() ) )
+ {
+ rBoundary.startPos = 0;
+ rBoundary.endPos = rText.getLength();
+
+ sal_Int32 nFound = rText.lastIndexOf( '\n', nIndex );
+ if ( nFound != -1 )
+ rBoundary.startPos = nFound + 1;
+
+ nFound = rText.indexOf( '\n', nIndex );
+ if ( nFound != -1 )
+ rBoundary.endPos = nFound + 1;
+ }
+ else
+ {
+ rBoundary.startPos = nIndex;
+ rBoundary.endPos = nIndex;
+ }
+ }
+
+
+ void OCommonAccessibleText::implGetLineBoundary( const OUString& rText, i18n::Boundary& rBoundary, sal_Int32 nIndex )
+ {
+ sal_Int32 nLength = rText.getLength();
+
+ if ( implIsValidIndex( nIndex, nLength ) || nIndex == nLength )
+ {
+ rBoundary.startPos = 0;
+ rBoundary.endPos = nLength;
+ }
+ else
+ {
+ rBoundary.startPos = nIndex;
+ rBoundary.endPos = nIndex;
+ }
+ }
+
+
+ sal_Unicode OCommonAccessibleText::implGetCharacter( std::u16string_view rText, sal_Int32 nIndex )
+ {
+ if ( !implIsValidIndex( nIndex, rText.size() ) )
+ throw IndexOutOfBoundsException();
+
+ return rText[nIndex];
+ }
+
+ OUString OCommonAccessibleText::getSelectedText()
+ {
+ OUString sText;
+ sal_Int32 nStartIndex;
+ sal_Int32 nEndIndex;
+
+ implGetSelection( nStartIndex, nEndIndex );
+
+ try
+ {
+ sText = implGetTextRange( implGetText(), nStartIndex, nEndIndex );
+ }
+ catch ( IndexOutOfBoundsException& )
+ {
+ }
+
+ return sText;
+ }
+
+
+ sal_Int32 OCommonAccessibleText::getSelectionStart()
+ {
+ sal_Int32 nStartIndex;
+ sal_Int32 nEndIndex;
+
+ implGetSelection( nStartIndex, nEndIndex );
+
+ return nStartIndex;
+ }
+
+
+ sal_Int32 OCommonAccessibleText::getSelectionEnd()
+ {
+ sal_Int32 nStartIndex;
+ sal_Int32 nEndIndex;
+
+ implGetSelection( nStartIndex, nEndIndex );
+
+ return nEndIndex;
+ }
+
+
+ OUString OCommonAccessibleText::implGetTextRange( std::u16string_view rText, sal_Int32 nStartIndex, sal_Int32 nEndIndex )
+ {
+
+ if ( !implIsValidRange( nStartIndex, nEndIndex, rText.size() ) )
+ throw IndexOutOfBoundsException();
+
+ sal_Int32 nMinIndex = std::min( nStartIndex, nEndIndex );
+ sal_Int32 nMaxIndex = std::max( nStartIndex, nEndIndex );
+
+ return OUString(rText.substr( nMinIndex, nMaxIndex - nMinIndex ));
+ }
+
+ TextSegment OCommonAccessibleText::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType )
+ {
+ OUString sText( implGetText() );
+ sal_Int32 nLength = sText.getLength();
+
+ if ( !implIsValidIndex( nIndex, nLength ) && nIndex != nLength )
+ throw IndexOutOfBoundsException();
+
+ i18n::Boundary aBoundary;
+ TextSegment aResult;
+ aResult.SegmentStart = -1;
+ aResult.SegmentEnd = -1;
+
+ switch ( aTextType )
+ {
+ case AccessibleTextType::CHARACTER:
+ {
+ if ( implIsValidIndex( nIndex, nLength ) )
+ {
+ aResult.SegmentText = sText.copy( nIndex, 1 );
+ aResult.SegmentStart = nIndex;
+ aResult.SegmentEnd = nIndex+1;
+ }
+ }
+ break;
+ case AccessibleTextType::GLYPH:
+ {
+ // get glyph at index
+ implGetGlyphBoundary( sText, aBoundary, nIndex );
+ if ( implIsValidBoundary( aBoundary, nLength ) )
+ {
+ aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
+ aResult.SegmentStart = aBoundary.startPos;
+ aResult.SegmentEnd = aBoundary.endPos;
+ }
+ }
+ break;
+ case AccessibleTextType::WORD:
+ {
+ // get word at index
+ bool bWord = implGetWordBoundary( sText, aBoundary, nIndex );
+ if ( bWord && implIsValidBoundary( aBoundary, nLength ) )
+ {
+ aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
+ aResult.SegmentStart = aBoundary.startPos;
+ aResult.SegmentEnd = aBoundary.endPos;
+ }
+ }
+ break;
+ case AccessibleTextType::SENTENCE:
+ {
+ // get sentence at index
+ implGetSentenceBoundary( sText, aBoundary, nIndex );
+ if ( implIsValidBoundary( aBoundary, nLength ) )
+ {
+ aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
+ aResult.SegmentStart = aBoundary.startPos;
+ aResult.SegmentEnd = aBoundary.endPos;
+ }
+ }
+ break;
+ case AccessibleTextType::PARAGRAPH:
+ {
+ // get paragraph at index
+ implGetParagraphBoundary( sText, aBoundary, nIndex );
+ if ( implIsValidBoundary( aBoundary, nLength ) )
+ {
+ aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
+ aResult.SegmentStart = aBoundary.startPos;
+ aResult.SegmentEnd = aBoundary.endPos;
+ }
+ }
+ break;
+ case AccessibleTextType::LINE:
+ {
+ // get line at index
+ implGetLineBoundary( sText, aBoundary, nIndex );
+ if ( implIsValidBoundary( aBoundary, nLength ) )
+ {
+ aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
+ aResult.SegmentStart = aBoundary.startPos;
+ aResult.SegmentEnd = aBoundary.endPos;
+ }
+ }
+ break;
+ case AccessibleTextType::ATTRIBUTE_RUN:
+ {
+ // TODO: implGetAttributeRunBoundary() (incompatible!)
+
+ aResult.SegmentText = sText;
+ aResult.SegmentStart = 0;
+ aResult.SegmentEnd = nLength;
+ }
+ break;
+ default:
+ {
+ // unknown text type
+ }
+ }
+
+ return aResult;
+ }
+
+
+ TextSegment OCommonAccessibleText::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType )
+ {
+ OUString sText( implGetText() );
+ sal_Int32 nLength = sText.getLength();
+
+ if ( !implIsValidIndex( nIndex, nLength ) && nIndex != nLength )
+ throw IndexOutOfBoundsException();
+
+ i18n::Boundary aBoundary;
+ TextSegment aResult;
+ aResult.SegmentStart = -1;
+ aResult.SegmentEnd = -1;
+
+ switch ( aTextType )
+ {
+ case AccessibleTextType::CHARACTER:
+ {
+ if ( implIsValidIndex( nIndex - 1, nLength ) )
+ {
+ aResult.SegmentText = sText.copy( nIndex - 1, 1 );
+ aResult.SegmentStart = nIndex-1;
+ aResult.SegmentEnd = nIndex;
+ }
+ }
+ break;
+ case AccessibleTextType::GLYPH:
+ {
+ // get glyph at index
+ implGetGlyphBoundary( sText, aBoundary, nIndex );
+ // get previous glyph
+ if ( aBoundary.startPos > 0 )
+ {
+ implGetGlyphBoundary( sText, aBoundary, aBoundary.startPos - 1 );
+ if ( implIsValidBoundary( aBoundary, nLength ) )
+ {
+ aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
+ aResult.SegmentStart = aBoundary.startPos;
+ aResult.SegmentEnd = aBoundary.endPos;
+ }
+ }
+ }
+ break;
+ case AccessibleTextType::WORD:
+ {
+ // get word at index
+ implGetWordBoundary( sText, aBoundary, nIndex );
+ // get previous word
+ bool bWord = false;
+ while ( !bWord && aBoundary.startPos > 0 )
+ bWord = implGetWordBoundary( sText, aBoundary, aBoundary.startPos - 1 );
+ if ( bWord && implIsValidBoundary( aBoundary, nLength ) )
+ {
+ aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
+ aResult.SegmentStart = aBoundary.startPos;
+ aResult.SegmentEnd = aBoundary.endPos;
+ }
+ }
+ break;
+ case AccessibleTextType::SENTENCE:
+ {
+ // get sentence at index
+ implGetSentenceBoundary( sText, aBoundary, nIndex );
+ // get previous sentence
+ if ( aBoundary.startPos > 0 )
+ {
+ implGetSentenceBoundary( sText, aBoundary, aBoundary.startPos - 1 );
+ if ( implIsValidBoundary( aBoundary, nLength ) )
+ {
+ aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
+ aResult.SegmentStart = aBoundary.startPos;
+ aResult.SegmentEnd = aBoundary.endPos;
+ }
+ }
+ }
+ break;
+ case AccessibleTextType::PARAGRAPH:
+ {
+ // get paragraph at index
+ implGetParagraphBoundary( sText, aBoundary, nIndex );
+ // get previous paragraph
+ if ( aBoundary.startPos > 0 )
+ {
+ implGetParagraphBoundary( sText, aBoundary, aBoundary.startPos - 1 );
+ if ( implIsValidBoundary( aBoundary, nLength ) )
+ {
+ aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
+ aResult.SegmentStart = aBoundary.startPos;
+ aResult.SegmentEnd = aBoundary.endPos;
+ }
+ }
+ }
+ break;
+ case AccessibleTextType::LINE:
+ {
+ // get line at index
+ implGetLineBoundary( sText, aBoundary, nIndex );
+ // get previous line
+ if ( aBoundary.startPos > 0 )
+ {
+ implGetLineBoundary( sText, aBoundary, aBoundary.startPos - 1 );
+ if ( implIsValidBoundary( aBoundary, nLength ) )
+ {
+ aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
+ aResult.SegmentStart = aBoundary.startPos;
+ aResult.SegmentEnd = aBoundary.endPos;
+ }
+ }
+ }
+ break;
+ case AccessibleTextType::ATTRIBUTE_RUN:
+ {
+ // TODO: implGetAttributeRunBoundary() (incompatible!)
+ }
+ break;
+ default:
+ {
+ // unknown text type
+ }
+ }
+
+ return aResult;
+ }
+
+
+ TextSegment OCommonAccessibleText::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType )
+ {
+ OUString sText( implGetText() );
+ sal_Int32 nLength = sText.getLength();
+
+ if ( !implIsValidIndex( nIndex, nLength ) && nIndex != nLength )
+ throw IndexOutOfBoundsException();
+
+ i18n::Boundary aBoundary;
+ TextSegment aResult;
+ aResult.SegmentStart = -1;
+ aResult.SegmentEnd = -1;
+
+ switch ( aTextType )
+ {
+ case AccessibleTextType::CHARACTER:
+ {
+ if ( implIsValidIndex( nIndex + 1, nLength ) )
+ {
+ aResult.SegmentText = sText.copy( nIndex + 1, 1 );
+ aResult.SegmentStart = nIndex+1;
+ aResult.SegmentEnd = nIndex+2;
+ }
+ }
+ break;
+ case AccessibleTextType::GLYPH:
+ {
+ // get glyph at index
+ implGetGlyphBoundary( sText, aBoundary, nIndex );
+ // get next glyph
+ if ( aBoundary.endPos < nLength )
+ {
+ implGetGlyphBoundary( sText, aBoundary, aBoundary.endPos );
+ if ( implIsValidBoundary( aBoundary, nLength ) )
+ {
+ aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
+ aResult.SegmentStart = aBoundary.startPos;
+ aResult.SegmentEnd = aBoundary.endPos;
+ }
+ }
+ }
+ break;
+ case AccessibleTextType::WORD:
+ {
+ // get word at index
+ implGetWordBoundary( sText, aBoundary, nIndex );
+ // get next word
+ bool bWord = false;
+ while ( !bWord && aBoundary.endPos < nLength )
+ bWord = implGetWordBoundary( sText, aBoundary, aBoundary.endPos );
+ if ( bWord && implIsValidBoundary( aBoundary, nLength ) )
+ {
+ aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
+ aResult.SegmentStart = aBoundary.startPos;
+ aResult.SegmentEnd = aBoundary.endPos;
+ }
+ }
+ break;
+ case AccessibleTextType::SENTENCE:
+ {
+ // get sentence at index
+ implGetSentenceBoundary( sText, aBoundary, nIndex );
+ // get next sentence
+ sal_Int32 nEnd = aBoundary.endPos;
+ sal_Int32 nI = aBoundary.endPos;
+ bool bFound = false;
+ while ( !bFound && ++nI < nLength )
+ {
+ implGetSentenceBoundary( sText, aBoundary, nI );
+ bFound = ( aBoundary.endPos > nEnd );
+ }
+ if ( bFound && implIsValidBoundary( aBoundary, nLength ) )
+ {
+ aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
+ aResult.SegmentStart = aBoundary.startPos;
+ aResult.SegmentEnd = aBoundary.endPos;
+ }
+ }
+ break;
+ case AccessibleTextType::PARAGRAPH:
+ {
+ // get paragraph at index
+ implGetParagraphBoundary( sText, aBoundary, nIndex );
+ // get next paragraph
+ if ( aBoundary.endPos < nLength )
+ {
+ implGetParagraphBoundary( sText, aBoundary, aBoundary.endPos );
+ if ( implIsValidBoundary( aBoundary, nLength ) )
+ {
+ aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
+ aResult.SegmentStart = aBoundary.startPos;
+ aResult.SegmentEnd = aBoundary.endPos;
+ }
+ }
+ }
+ break;
+ case AccessibleTextType::LINE:
+ {
+ // get line at index
+ implGetLineBoundary( sText, aBoundary, nIndex );
+ // get next line
+ if ( aBoundary.endPos < nLength )
+ {
+ implGetLineBoundary( sText, aBoundary, aBoundary.endPos );
+ if ( implIsValidBoundary( aBoundary, nLength ) )
+ {
+ aResult.SegmentText = sText.copy( aBoundary.startPos, aBoundary.endPos - aBoundary.startPos );
+ aResult.SegmentStart = aBoundary.startPos;
+ aResult.SegmentEnd = aBoundary.endPos;
+ }
+ }
+ }
+ break;
+ case AccessibleTextType::ATTRIBUTE_RUN:
+ {
+ // TODO: implGetAttributeRunBoundary() (incompatible!)
+ }
+ break;
+ default:
+ {
+ // unknown text type
+ }
+ }
+
+ return aResult;
+ }
+
+
+ bool OCommonAccessibleText::implInitTextChangedEvent(
+ std::u16string_view rOldString,
+ std::u16string_view rNewString,
+ css::uno::Any& rDeleted,
+ css::uno::Any& rInserted) // throw()
+ {
+ size_t nLenOld = rOldString.size();
+ size_t nLenNew = rNewString.size();
+
+ // equal
+ if ((0 == nLenOld) && (0 == nLenNew))
+ return false;
+
+ TextSegment aDeletedText;
+ TextSegment aInsertedText;
+
+ aDeletedText.SegmentStart = -1;
+ aDeletedText.SegmentEnd = -1;
+ aInsertedText.SegmentStart = -1;
+ aInsertedText.SegmentEnd = -1;
+
+ // insert only
+ if ((0 == nLenOld) && (nLenNew > 0))
+ {
+ aInsertedText.SegmentStart = 0;
+ aInsertedText.SegmentEnd = nLenNew;
+ aInsertedText.SegmentText = rNewString.substr( aInsertedText.SegmentStart, aInsertedText.SegmentEnd - aInsertedText.SegmentStart );
+
+ rInserted <<= aInsertedText;
+ return true;
+ }
+
+ // delete only
+ if ((nLenOld > 0) && (0 == nLenNew))
+ {
+ aDeletedText.SegmentStart = 0;
+ aDeletedText.SegmentEnd = nLenOld;
+ aDeletedText.SegmentText = rOldString.substr( aDeletedText.SegmentStart, aDeletedText.SegmentEnd - aDeletedText.SegmentStart );
+
+ rDeleted <<= aDeletedText;
+ return true;
+ }
+
+ auto pFirstDiffOld = rOldString.begin();
+ auto pLastDiffOld = rOldString.end();
+ auto pFirstDiffNew = rNewString.begin();
+ auto pLastDiffNew = rNewString.end();
+
+ // find first difference
+ while ((pFirstDiffOld < pLastDiffOld) && (pFirstDiffNew < pLastDiffNew)
+ && (*pFirstDiffOld == *pFirstDiffNew))
+ {
+ pFirstDiffOld++;
+ pFirstDiffNew++;
+ }
+
+ // equality test
+ if (pFirstDiffOld == pLastDiffOld && pFirstDiffNew == pLastDiffNew)
+ return false;
+
+ // find last difference
+ while ( ( pLastDiffOld > pFirstDiffOld) &&
+ ( pLastDiffNew > pFirstDiffNew) &&
+ (pLastDiffOld[-1] == pLastDiffNew[-1]))
+ {
+ pLastDiffOld--;
+ pLastDiffNew--;
+ }
+
+ if (pFirstDiffOld < pLastDiffOld)
+ {
+ aDeletedText.SegmentStart = pFirstDiffOld - rOldString.begin();
+ aDeletedText.SegmentEnd = pLastDiffOld - rOldString.begin();
+ aDeletedText.SegmentText = rOldString.substr( aDeletedText.SegmentStart, aDeletedText.SegmentEnd - aDeletedText.SegmentStart );
+
+ rDeleted <<= aDeletedText;
+ }
+
+ if (pFirstDiffNew < pLastDiffNew)
+ {
+ aInsertedText.SegmentStart = pFirstDiffNew - rNewString.begin();
+ aInsertedText.SegmentEnd = pLastDiffNew - rNewString.begin();
+ aInsertedText.SegmentText = rNewString.substr( aInsertedText.SegmentStart, aInsertedText.SegmentEnd - aInsertedText.SegmentStart );
+
+ rInserted <<= aInsertedText;
+ }
+ return true;
+ }
+
+
+ // OAccessibleTextHelper
+
+
+ OAccessibleTextHelper::OAccessibleTextHelper( )
+ {
+ }
+
+
+ // XInterface
+
+
+ IMPLEMENT_FORWARD_XINTERFACE2( OAccessibleTextHelper, OAccessibleExtendedComponentHelper, OAccessibleTextHelper_Base )
+
+
+ // XTypeProvider
+
+
+ IMPLEMENT_FORWARD_XTYPEPROVIDER2( OAccessibleTextHelper, OAccessibleExtendedComponentHelper, OAccessibleTextHelper_Base )
+
+
+ // XAccessibleText
+
+
+ OUString OAccessibleTextHelper::getSelectedText()
+ {
+ OExternalLockGuard aGuard( this );
+
+ return OCommonAccessibleText::getSelectedText();
+ }
+
+
+ sal_Int32 OAccessibleTextHelper::getSelectionStart()
+ {
+ OExternalLockGuard aGuard( this );
+
+ return OCommonAccessibleText::getSelectionStart();
+ }
+
+
+ sal_Int32 OAccessibleTextHelper::getSelectionEnd()
+ {
+ OExternalLockGuard aGuard( this );
+
+ return OCommonAccessibleText::getSelectionEnd();
+ }
+
+
+ TextSegment OAccessibleTextHelper::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType )
+ {
+ OExternalLockGuard aGuard( this );
+
+ return OCommonAccessibleText::getTextAtIndex( nIndex, aTextType );
+ }
+
+
+ TextSegment OAccessibleTextHelper::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType )
+ {
+ OExternalLockGuard aGuard( this );
+
+ return OCommonAccessibleText::getTextBeforeIndex( nIndex, aTextType );
+ }
+
+
+ TextSegment OAccessibleTextHelper::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType )
+ {
+ OExternalLockGuard aGuard( this );
+
+ return OCommonAccessibleText::getTextBehindIndex( nIndex, aTextType );
+ }
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/accessiblewrapper.cxx b/comphelper/source/misc/accessiblewrapper.cxx
new file mode 100644
index 000000000..1167f5640
--- /dev/null
+++ b/comphelper/source/misc/accessiblewrapper.cxx
@@ -0,0 +1,616 @@
+/* -*- 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 <comphelper/accessiblewrapper.hxx>
+#include <com/sun/star/accessibility/AccessibleEventId.hpp>
+#include <com/sun/star/accessibility/AccessibleStateType.hpp>
+
+using namespace ::comphelper;
+using namespace ::com::sun::star::accessibility;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+
+
+namespace comphelper
+{
+ OWrappedAccessibleChildrenManager::OWrappedAccessibleChildrenManager( const Reference< XComponentContext >& _rxContext )
+ :m_xContext( _rxContext )
+ ,m_bTransientChildren( true )
+ {
+ }
+
+
+ OWrappedAccessibleChildrenManager::~OWrappedAccessibleChildrenManager( )
+ {
+ }
+
+
+ void OWrappedAccessibleChildrenManager::setTransientChildren( bool _bSet )
+ {
+ m_bTransientChildren = _bSet;
+ }
+
+
+ void OWrappedAccessibleChildrenManager::setOwningAccessible( const Reference< XAccessible >& _rxAcc )
+ {
+ OSL_ENSURE( !m_aOwningAccessible.get().is(), "OWrappedAccessibleChildrenManager::setOwningAccessible: to be called only once!" );
+ m_aOwningAccessible = WeakReference< XAccessible >( _rxAcc );
+ }
+
+
+ void OWrappedAccessibleChildrenManager::removeFromCache( const Reference< XAccessible >& _rxKey )
+ {
+ AccessibleMap::iterator aRemovedPos = m_aChildrenMap.find( _rxKey );
+ if ( m_aChildrenMap.end() != aRemovedPos )
+ { // it was cached
+ // remove ourself as event listener
+ Reference< XComponent > xComp( aRemovedPos->first, UNO_QUERY );
+ if( xComp.is() )
+ xComp->removeEventListener( this );
+ // and remove the entry from the map
+ m_aChildrenMap.erase( aRemovedPos );
+ }
+ }
+
+
+ void OWrappedAccessibleChildrenManager::invalidateAll( )
+ {
+ // remove as event listener from the map elements
+ for( const auto& rChild : m_aChildrenMap )
+ {
+ Reference< XComponent > xComp( rChild.first, UNO_QUERY );
+ if( xComp.is() )
+ xComp->removeEventListener( this );
+ }
+ // clear the map
+ AccessibleMap().swap(m_aChildrenMap);
+ }
+
+
+ Reference< XAccessible > OWrappedAccessibleChildrenManager::getAccessibleWrapperFor(
+ const Reference< XAccessible >& _rxKey )
+ {
+ rtl::Reference< OAccessibleWrapper > xValue;
+
+ if( !_rxKey.is() )
+ {
+ // fprintf( stderr, "It was this path that was crashing stuff\n" );
+ return xValue;
+ }
+
+ // do we have this child in the cache?
+ AccessibleMap::const_iterator aPos = m_aChildrenMap.find( _rxKey );
+ if ( m_aChildrenMap.end() != aPos )
+ {
+ xValue = aPos->second;
+ }
+ else
+ { // not found in the cache, and allowed to create
+ // -> new wrapper
+ xValue = new OAccessibleWrapper( m_xContext, _rxKey, m_aOwningAccessible );
+
+ // see if we do cache children
+ if ( !m_bTransientChildren )
+ {
+ if (!m_aChildrenMap.emplace( _rxKey, xValue ).second)
+ {
+ OSL_FAIL(
+ "OWrappedAccessibleChildrenManager::"
+ "getAccessibleWrapperFor: element was already"
+ " inserted!" );
+ }
+
+ // listen for disposals of inner children - this may happen when the inner context
+ // is the owner for the inner children (it will dispose these children, and of course
+ // not our wrapper for these children)
+ Reference< XComponent > xComp( _rxKey, UNO_QUERY );
+ if ( xComp.is() )
+ xComp->addEventListener( this );
+ }
+ }
+
+ return xValue;
+ }
+
+
+ void OWrappedAccessibleChildrenManager::dispose()
+ {
+ // dispose our children
+ for( const auto& rChild : m_aChildrenMap )
+ {
+ Reference< XComponent > xComp( rChild.first, UNO_QUERY );
+ if( xComp.is() )
+ xComp->removeEventListener( this );
+
+ Reference< XComponent > xContextComponent;
+ if( rChild.second.is() )
+ xContextComponent.set( rChild.second->getContextNoCreate(),
+ ::css::uno::UNO_QUERY );
+ if( xContextComponent.is() )
+ xContextComponent->dispose();
+ }
+
+ // clear our children
+ AccessibleMap().swap(m_aChildrenMap);
+ }
+
+
+ void OWrappedAccessibleChildrenManager::implTranslateChildEventValue( const Any& _rInValue, Any& _rOutValue )
+ {
+ _rOutValue.clear();
+ Reference< XAccessible > xChild;
+ if ( _rInValue >>= xChild )
+ _rOutValue <<= getAccessibleWrapperFor( xChild );
+ }
+
+
+ void OWrappedAccessibleChildrenManager::translateAccessibleEvent( const AccessibleEventObject& _rEvent, AccessibleEventObject& _rTranslatedEvent )
+ {
+ // just in case we can't translate some of the values:
+ _rTranslatedEvent.NewValue = _rEvent.NewValue;
+ _rTranslatedEvent.OldValue = _rEvent.OldValue;
+
+ switch ( _rEvent.EventId )
+ {
+ case AccessibleEventId::CHILD:
+ case AccessibleEventId::ACTIVE_DESCENDANT_CHANGED:
+ case AccessibleEventId::CONTROLLED_BY_RELATION_CHANGED:
+ case AccessibleEventId::CONTROLLER_FOR_RELATION_CHANGED:
+ case AccessibleEventId::LABEL_FOR_RELATION_CHANGED:
+ case AccessibleEventId::LABELED_BY_RELATION_CHANGED:
+ case AccessibleEventId::CONTENT_FLOWS_FROM_RELATION_CHANGED:
+ case AccessibleEventId::CONTENT_FLOWS_TO_RELATION_CHANGED:
+ // these are events where both the old and the new value contain child references
+ implTranslateChildEventValue( _rEvent.OldValue, _rTranslatedEvent.OldValue );
+ implTranslateChildEventValue( _rEvent.NewValue, _rTranslatedEvent.NewValue );
+ break;
+
+ case AccessibleEventId::NAME_CHANGED:
+ case AccessibleEventId::DESCRIPTION_CHANGED:
+ case AccessibleEventId::ACTION_CHANGED:
+ case AccessibleEventId::STATE_CHANGED:
+ case AccessibleEventId::BOUNDRECT_CHANGED:
+ case AccessibleEventId::INVALIDATE_ALL_CHILDREN:
+ case AccessibleEventId::SELECTION_CHANGED:
+ case AccessibleEventId::VISIBLE_DATA_CHANGED:
+ case AccessibleEventId::VALUE_CHANGED:
+ case AccessibleEventId::MEMBER_OF_RELATION_CHANGED:
+ case AccessibleEventId::CARET_CHANGED:
+ case AccessibleEventId::TEXT_CHANGED:
+ case AccessibleEventId::HYPERTEXT_CHANGED:
+ case AccessibleEventId::TABLE_CAPTION_CHANGED:
+ case AccessibleEventId::TABLE_COLUMN_DESCRIPTION_CHANGED:
+ case AccessibleEventId::TABLE_COLUMN_HEADER_CHANGED:
+ case AccessibleEventId::TABLE_MODEL_CHANGED:
+ case AccessibleEventId::TABLE_ROW_DESCRIPTION_CHANGED:
+ case AccessibleEventId::TABLE_ROW_HEADER_CHANGED:
+ case AccessibleEventId::TABLE_SUMMARY_CHANGED:
+ // these Ids are also missed: SUB_WINDOW_OF_RELATION_CHANGED & TEXT_ATTRIBUTE_CHANGED
+ case AccessibleEventId::TEXT_SELECTION_CHANGED:
+ // nothing to translate
+ break;
+
+ default:
+ OSL_FAIL( "OWrappedAccessibleChildrenManager::translateAccessibleEvent: unknown (or unexpected) event id!" );
+ break;
+ }
+ }
+
+
+ void OWrappedAccessibleChildrenManager::handleChildNotification( const AccessibleEventObject& _rEvent )
+ {
+ if ( AccessibleEventId::INVALIDATE_ALL_CHILDREN == _rEvent.EventId )
+ { // clear our child map
+ invalidateAll( );
+ }
+ else if ( AccessibleEventId::CHILD == _rEvent.EventId )
+ {
+ // check if the removed or replaced element is cached
+ Reference< XAccessible > xRemoved;
+ if ( _rEvent.OldValue >>= xRemoved )
+ removeFromCache( xRemoved );
+ }
+ }
+
+
+ void SAL_CALL OWrappedAccessibleChildrenManager::disposing( const EventObject& _rSource )
+ {
+ // this should come from one of the inner XAccessible's of our children
+ Reference< XAccessible > xSource( _rSource.Source, UNO_QUERY );
+ AccessibleMap::iterator aDisposedPos = m_aChildrenMap.find( xSource );
+#if OSL_DEBUG_LEVEL > 0
+ if ( m_aChildrenMap.end() == aDisposedPos )
+ {
+ OSL_FAIL( "OWrappedAccessibleChildrenManager::disposing: where did this come from?" );
+ // helper for diagnostics
+ Reference< XAccessible > xOwningAccessible( m_aOwningAccessible );
+ Reference< XAccessibleContext > xContext;
+ try
+ {
+ if ( xOwningAccessible.is() )
+ xContext = xOwningAccessible->getAccessibleContext();
+ if ( xContext.is() )
+ {
+ //TODO: do something
+ //OUString sName = xContext->getAccessibleName();
+ //OUString sDescription = xContext->getAccessibleDescription();
+ //sal_Int32 nPlaceYourBreakpointHere = 0;
+ }
+ }
+ catch( const Exception& /*e*/ )
+ {
+ // silent this, it's only diagnostics which failed
+ }
+ }
+#endif
+ if ( m_aChildrenMap.end() != aDisposedPos )
+ {
+ m_aChildrenMap.erase( aDisposedPos );
+ }
+ }
+
+ OAccessibleWrapper::OAccessibleWrapper( const Reference< XComponentContext >& _rxContext,
+ const Reference< XAccessible >& _rxInnerAccessible, const Reference< XAccessible >& _rxParentAccessible )
+ :OAccessibleWrapper_Base( )
+ ,OComponentProxyAggregation( _rxContext, Reference< XComponent >( _rxInnerAccessible, UNO_QUERY ) )
+ ,m_xParentAccessible( _rxParentAccessible )
+ ,m_xInnerAccessible( _rxInnerAccessible )
+ {
+ }
+
+
+ OAccessibleWrapper::~OAccessibleWrapper( )
+ {
+ if ( !m_rBHelper.bDisposed )
+ {
+ acquire(); // to prevent duplicate dtor calls
+ dispose();
+ }
+ }
+
+
+ IMPLEMENT_FORWARD_XTYPEPROVIDER2( OAccessibleWrapper, OComponentProxyAggregation, OAccessibleWrapper_Base )
+ IMPLEMENT_FORWARD_REFCOUNT( OAccessibleWrapper, OComponentProxyAggregation )
+
+
+ Any OAccessibleWrapper::queryInterface( const Type& _rType )
+ {
+ // #111089# instead of the inner XAccessible the proxy XAccessible must be returned
+ Any aReturn = OAccessibleWrapper_Base::queryInterface( _rType );
+ if ( !aReturn.hasValue() )
+ aReturn = OComponentProxyAggregation::queryInterface( _rType );
+
+ return aReturn;
+ }
+
+
+ Reference< XAccessibleContext > OAccessibleWrapper::getContextNoCreate( ) const
+ {
+ return m_aContext;
+ }
+
+
+ rtl::Reference<OAccessibleContextWrapper> OAccessibleWrapper::createAccessibleContext( const Reference< XAccessibleContext >& _rxInnerContext )
+ {
+ return new OAccessibleContextWrapper( getComponentContext(), _rxInnerContext, this, m_xParentAccessible );
+ }
+
+
+ Reference< XAccessibleContext > SAL_CALL OAccessibleWrapper::getAccessibleContext( )
+ {
+ // see if the context is still alive (we cache it)
+ Reference< XAccessibleContext > xContext = m_aContext;
+ if ( !xContext.is() )
+ {
+ // create a new context
+ Reference< XAccessibleContext > xInnerContext = m_xInnerAccessible->getAccessibleContext( );
+ if ( xInnerContext.is() )
+ {
+ xContext = createAccessibleContext( xInnerContext );
+ // cache it
+ m_aContext = WeakReference< XAccessibleContext >( xContext );
+ }
+ }
+
+ return xContext;
+ }
+
+ OAccessibleContextWrapperHelper::OAccessibleContextWrapperHelper(
+ const Reference< XComponentContext >& _rxContext,
+ ::cppu::OBroadcastHelper& _rBHelper,
+ const Reference< XAccessibleContext >& _rxInnerAccessibleContext,
+ const Reference< XAccessible >& _rxOwningAccessible,
+ const Reference< XAccessible >& _rxParentAccessible )
+ :OComponentProxyAggregationHelper( _rxContext, _rBHelper )
+ ,m_xInnerContext( _rxInnerAccessibleContext )
+ ,m_xOwningAccessible( _rxOwningAccessible )
+ ,m_xParentAccessible( _rxParentAccessible )
+ // initialize the mapper for our children
+ ,m_xChildMapper( new OWrappedAccessibleChildrenManager( getComponentContext() ) )
+ {
+ // determine if we're allowed to cache children
+ Reference< XAccessibleStateSet > xStates( m_xInnerContext->getAccessibleStateSet( ) );
+ OSL_ENSURE( xStates.is(), "OAccessibleContextWrapperHelper::OAccessibleContextWrapperHelper: no inner state set!" );
+ m_xChildMapper->setTransientChildren( !xStates.is() || xStates->contains( AccessibleStateType::MANAGES_DESCENDANTS) );
+
+ m_xChildMapper->setOwningAccessible( m_xOwningAccessible );
+ }
+
+
+ void OAccessibleContextWrapperHelper::aggregateProxy( oslInterlockedCount& _rRefCount, ::cppu::OWeakObject& _rDelegator )
+ {
+ Reference< XComponent > xInnerComponent( m_xInnerContext, UNO_QUERY );
+ OSL_ENSURE( xInnerComponent.is(), "OComponentProxyAggregation::aggregateProxy: accessible is no XComponent!" );
+ if ( xInnerComponent.is() )
+ componentAggregateProxyFor( xInnerComponent, _rRefCount, _rDelegator );
+
+ // add as event listener to the inner context, because we want to multiplex the AccessibleEvents
+ osl_atomic_increment( &_rRefCount );
+ {
+ Reference< XAccessibleEventBroadcaster > xBroadcaster( m_xInner, UNO_QUERY );
+ if ( xBroadcaster.is() )
+ xBroadcaster->addAccessibleEventListener( this );
+ }
+ osl_atomic_decrement( &_rRefCount );
+ }
+
+
+ OAccessibleContextWrapperHelper::~OAccessibleContextWrapperHelper( )
+ {
+ OSL_ENSURE( m_rBHelper.bDisposed, "OAccessibleContextWrapperHelper::~OAccessibleContextWrapperHelper: you should ensure (in your dtor) that the object is disposed!" );
+ }
+
+
+ Any SAL_CALL OAccessibleContextWrapperHelper::queryInterface( const Type& _rType )
+ {
+ Any aReturn = OComponentProxyAggregationHelper::queryInterface( _rType );
+ if ( !aReturn.hasValue() )
+ aReturn = OAccessibleContextWrapperHelper_Base::queryInterface( _rType );
+ return aReturn;
+ }
+
+
+ IMPLEMENT_FORWARD_XTYPEPROVIDER2( OAccessibleContextWrapperHelper, OComponentProxyAggregationHelper, OAccessibleContextWrapperHelper_Base )
+
+
+ sal_Int32 OAccessibleContextWrapperHelper::baseGetAccessibleChildCount( )
+ {
+ return m_xInnerContext->getAccessibleChildCount();
+ }
+
+
+ Reference< XAccessible > OAccessibleContextWrapperHelper::baseGetAccessibleChild( sal_Int32 i )
+ {
+ // get the child of the wrapped component
+ Reference< XAccessible > xInnerChild = m_xInnerContext->getAccessibleChild( i );
+ return m_xChildMapper->getAccessibleWrapperFor( xInnerChild );
+ }
+
+
+ Reference< XAccessibleRelationSet > OAccessibleContextWrapperHelper::baseGetAccessibleRelationSet( )
+ {
+ return m_xInnerContext->getAccessibleRelationSet();
+ // TODO: if this relation set would contain relations to siblings, we would normally need
+ // to wrap them, too...
+ }
+
+
+ void SAL_CALL OAccessibleContextWrapperHelper::notifyEvent( const AccessibleEventObject& _rEvent )
+ {
+#if OSL_DEBUG_LEVEL > 0
+ if ( AccessibleEventId::STATE_CHANGED == _rEvent.EventId )
+ {
+ bool bChildTransienceChanged = false;
+ sal_Int16 nChangeState = 0;
+ if ( _rEvent.OldValue >>= nChangeState )
+ bChildTransienceChanged = bChildTransienceChanged || AccessibleStateType::MANAGES_DESCENDANTS == nChangeState;
+ if ( _rEvent.NewValue >>= nChangeState )
+ bChildTransienceChanged = bChildTransienceChanged || AccessibleStateType::MANAGES_DESCENDANTS == nChangeState;
+ OSL_ENSURE( !bChildTransienceChanged, "OAccessibleContextWrapperHelper::notifyEvent: MANAGES_DESCENDANTS is not expected to change during runtime!" );
+ // if this asserts, then we would need to update our m_bTransientChildren flag here,
+ // as well as (potentially) our child cache
+ }
+#endif
+ AccessibleEventObject aTranslatedEvent( _rEvent );
+
+ {
+ ::osl::MutexGuard aGuard( m_rBHelper.rMutex );
+
+ // translate the event
+ queryInterface( cppu::UnoType<XInterface>::get() ) >>= aTranslatedEvent.Source;
+ m_xChildMapper->translateAccessibleEvent( _rEvent, aTranslatedEvent );
+
+ // see if any of these notifications affect our child manager
+ m_xChildMapper->handleChildNotification( _rEvent );
+
+ if ( aTranslatedEvent.NewValue == m_xInner )
+ aTranslatedEvent.NewValue <<= aTranslatedEvent.Source;
+ if ( aTranslatedEvent.OldValue == m_xInner )
+ aTranslatedEvent.OldValue <<= aTranslatedEvent.Source;
+ }
+
+ notifyTranslatedEvent( aTranslatedEvent );
+ }
+
+
+ void SAL_CALL OAccessibleContextWrapperHelper::dispose()
+ {
+ ::osl::MutexGuard aGuard( m_rBHelper.rMutex );
+
+ // stop multiplexing events
+ Reference< XAccessibleEventBroadcaster > xBroadcaster( m_xInner, UNO_QUERY );
+ OSL_ENSURE( xBroadcaster.is(), "OAccessibleContextWrapperHelper::disposing(): inner context is no broadcaster!" );
+ if ( xBroadcaster.is() )
+ xBroadcaster->removeAccessibleEventListener( this );
+
+ // dispose the child cache/map
+ m_xChildMapper->dispose();
+
+ // let the base class dispose the inner component
+ OComponentProxyAggregationHelper::dispose();
+ }
+
+
+ void SAL_CALL OAccessibleContextWrapperHelper::disposing( const EventObject& _rEvent )
+ {
+ // simply disambiguate this
+ OComponentProxyAggregationHelper::disposing( _rEvent );
+ }
+
+ IMPLEMENT_FORWARD_XINTERFACE2( OAccessibleContextWrapper, OAccessibleContextWrapper_CBase, OAccessibleContextWrapperHelper )
+
+
+ IMPLEMENT_FORWARD_XTYPEPROVIDER2( OAccessibleContextWrapper, OAccessibleContextWrapper_CBase, OAccessibleContextWrapperHelper )
+
+
+ OAccessibleContextWrapper::OAccessibleContextWrapper( const Reference< XComponentContext >& _rxContext,
+ const Reference< XAccessibleContext >& _rxInnerAccessibleContext, const Reference< XAccessible >& _rxOwningAccessible,
+ const Reference< XAccessible >& _rxParentAccessible )
+ :OAccessibleContextWrapper_CBase( m_aMutex )
+ ,OAccessibleContextWrapperHelper( _rxContext, rBHelper, _rxInnerAccessibleContext, _rxOwningAccessible, _rxParentAccessible )
+ ,m_nNotifierClient( 0 )
+ {
+ aggregateProxy( m_refCount, *this );
+ }
+
+
+ OAccessibleContextWrapper::~OAccessibleContextWrapper()
+ {
+ }
+
+
+ sal_Int32 SAL_CALL OAccessibleContextWrapper::getAccessibleChildCount( )
+ {
+ return baseGetAccessibleChildCount();
+ }
+
+
+ Reference< XAccessible > SAL_CALL OAccessibleContextWrapper::getAccessibleChild( sal_Int32 i )
+ {
+ return baseGetAccessibleChild( i );
+ }
+
+
+ Reference< XAccessible > SAL_CALL OAccessibleContextWrapper::getAccessibleParent( )
+ {
+ return m_xParentAccessible;
+ }
+
+
+ sal_Int32 SAL_CALL OAccessibleContextWrapper::getAccessibleIndexInParent( )
+ {
+ return m_xInnerContext->getAccessibleIndexInParent();
+ }
+
+
+ sal_Int16 SAL_CALL OAccessibleContextWrapper::getAccessibleRole( )
+ {
+ return m_xInnerContext->getAccessibleRole();
+ }
+
+
+ OUString SAL_CALL OAccessibleContextWrapper::getAccessibleDescription( )
+ {
+ return m_xInnerContext->getAccessibleDescription();
+ }
+
+
+ OUString SAL_CALL OAccessibleContextWrapper::getAccessibleName( )
+ {
+ return m_xInnerContext->getAccessibleName();
+ }
+
+
+ Reference< XAccessibleRelationSet > SAL_CALL OAccessibleContextWrapper::getAccessibleRelationSet( )
+ {
+ return baseGetAccessibleRelationSet();
+ }
+
+
+ Reference< XAccessibleStateSet > SAL_CALL OAccessibleContextWrapper::getAccessibleStateSet( )
+ {
+ return m_xInnerContext->getAccessibleStateSet();
+ }
+
+
+ Locale SAL_CALL OAccessibleContextWrapper::getLocale( )
+ {
+ return m_xInnerContext->getLocale();
+ }
+
+
+ void OAccessibleContextWrapper::notifyTranslatedEvent( const AccessibleEventObject& _rEvent )
+ {
+ if ( m_nNotifierClient )
+ AccessibleEventNotifier::addEvent( m_nNotifierClient, _rEvent );
+ }
+
+
+ void SAL_CALL OAccessibleContextWrapper::addAccessibleEventListener( const Reference< XAccessibleEventListener >& _rxListener )
+ {
+ ::osl::MutexGuard aGuard( m_aMutex );
+ if ( !m_nNotifierClient )
+ m_nNotifierClient = AccessibleEventNotifier::registerClient( );
+ AccessibleEventNotifier::addEventListener( m_nNotifierClient, _rxListener );
+ }
+
+
+ void SAL_CALL OAccessibleContextWrapper::removeAccessibleEventListener( const Reference< XAccessibleEventListener >& _rxListener )
+ {
+ ::osl::MutexGuard aGuard( m_aMutex );
+ if ( m_nNotifierClient )
+ {
+ if ( 0 == AccessibleEventNotifier::removeEventListener( m_nNotifierClient, _rxListener ) )
+ {
+ AccessibleEventNotifier::TClientId nId( m_nNotifierClient );
+ m_nNotifierClient = 0;
+ AccessibleEventNotifier::revokeClient( nId );
+ }
+ }
+ }
+
+
+ void SAL_CALL OAccessibleContextWrapper::disposing()
+ {
+ AccessibleEventNotifier::TClientId nClientId( 0 );
+
+ // --- <mutex lock> -----------------------------------------
+ {
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ // prepare notifying our AccessibleListeners
+ if ( m_nNotifierClient )
+ {
+ nClientId = m_nNotifierClient;
+ m_nNotifierClient = 0;
+ }
+ }
+ // --- </mutex lock> -----------------------------------------
+
+ // let the base class do
+ OAccessibleContextWrapperHelper::dispose();
+
+ // notify the disposal
+ if ( nClientId )
+ AccessibleEventNotifier::revokeClientNotifyDisposing( nClientId, *this );
+ }
+} // namespace accessibility
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/accimplaccess.cxx b/comphelper/source/misc/accimplaccess.cxx
new file mode 100644
index 000000000..bcf05c926
--- /dev/null
+++ b/comphelper/source/misc/accimplaccess.cxx
@@ -0,0 +1,54 @@
+/* -*- 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 <comphelper/accimplaccess.hxx>
+#include <comphelper/servicehelper.hxx>
+
+
+namespace comphelper
+{
+
+
+ using ::com::sun::star::uno::Sequence;
+
+ OAccessibleImplementationAccess::OAccessibleImplementationAccess( )
+ {
+ }
+
+
+ OAccessibleImplementationAccess::~OAccessibleImplementationAccess( )
+ {
+ }
+
+ const Sequence<sal_Int8> & OAccessibleImplementationAccess::getUnoTunnelId()
+ {
+ static const comphelper::UnoIdInit implID;
+ return implID.getSeq();
+ }
+
+
+ sal_Int64 SAL_CALL OAccessibleImplementationAccess::getSomething( const Sequence< sal_Int8 >& _rIdentifier )
+ {
+ return comphelper::getSomethingImpl(_rIdentifier, this);
+ }
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/anycompare.cxx b/comphelper/source/misc/anycompare.cxx
new file mode 100644
index 000000000..8a2387723
--- /dev/null
+++ b/comphelper/source/misc/anycompare.cxx
@@ -0,0 +1,453 @@
+/* -*- 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 <memory>
+#include <optional>
+#include <comphelper/anycompare.hxx>
+#include <typelib/typedescription.hxx>
+
+#include <com/sun/star/util/Date.hpp>
+#include <com/sun/star/util/Time.hpp>
+#include <com/sun/star/util/DateTime.hpp>
+
+#include "typedescriptionref.hxx"
+
+namespace comphelper
+{
+ using ::com::sun::star::uno::Reference;
+ using ::com::sun::star::uno::Type;
+ using ::com::sun::star::uno::TypeDescription;
+ using ::com::sun::star::uno::TypeClass_CHAR;
+ using ::com::sun::star::uno::TypeClass_BOOLEAN;
+ using ::com::sun::star::uno::TypeClass_BYTE;
+ using ::com::sun::star::uno::TypeClass_SHORT;
+ using ::com::sun::star::uno::TypeClass_UNSIGNED_SHORT;
+ using ::com::sun::star::uno::TypeClass_LONG;
+ using ::com::sun::star::uno::TypeClass_UNSIGNED_LONG;
+ using ::com::sun::star::uno::TypeClass_HYPER;
+ using ::com::sun::star::uno::TypeClass_UNSIGNED_HYPER;
+ using ::com::sun::star::uno::TypeClass_FLOAT;
+ using ::com::sun::star::uno::TypeClass_DOUBLE;
+ using ::com::sun::star::uno::TypeClass_STRING;
+ using ::com::sun::star::uno::TypeClass_TYPE;
+ using ::com::sun::star::uno::TypeClass_ENUM;
+ using ::com::sun::star::uno::TypeClass_INTERFACE;
+ using ::com::sun::star::uno::TypeClass_STRUCT;
+ using ::com::sun::star::i18n::XCollator;
+ using ::com::sun::star::util::Date;
+ using ::com::sun::star::util::Time;
+ using ::com::sun::star::util::DateTime;
+ using ::comphelper::detail::TypeDescriptionRef;
+
+ namespace {
+
+ class DatePredicateLess : public IKeyPredicateLess
+ {
+ public:
+ virtual bool isLess( css::uno::Any const & _lhs, css::uno::Any const & _rhs ) const override
+ {
+ Date lhs, rhs;
+ if ( !( _lhs >>= lhs )
+ || !( _rhs >>= rhs )
+ )
+ throw css::lang::IllegalArgumentException("bad ordering", css::uno::Reference<css::uno::XInterface>(), -1);
+ // FIXME Timezone?
+
+ if ( lhs.Year < rhs.Year )
+ return true;
+ if ( lhs.Year > rhs.Year )
+ return false;
+
+ if ( lhs.Month < rhs.Month )
+ return true;
+ if ( lhs.Month > rhs.Month )
+ return false;
+
+ if ( lhs.Day < rhs.Day )
+ return true;
+ return false;
+ }
+ };
+
+ class TimePredicateLess : public IKeyPredicateLess
+ {
+ public:
+ virtual bool isLess( css::uno::Any const & _lhs, css::uno::Any const & _rhs ) const override
+ {
+ Time lhs, rhs;
+ if ( !( _lhs >>= lhs )
+ || !( _rhs >>= rhs )
+ )
+ throw css::lang::IllegalArgumentException("bad ordering", css::uno::Reference<css::uno::XInterface>(), -1);
+ // FIXME Timezone?
+
+ if ( lhs.Hours < rhs.Hours )
+ return true;
+ if ( lhs.Hours > rhs.Hours )
+ return false;
+
+ if ( lhs.Minutes < rhs.Minutes )
+ return true;
+ if ( lhs.Minutes > rhs.Minutes )
+ return false;
+
+ if ( lhs.Seconds < rhs.Seconds )
+ return true;
+ if ( lhs.Seconds > rhs.Seconds )
+ return false;
+
+ if ( lhs.NanoSeconds < rhs.NanoSeconds )
+ return true;
+ return false;
+ }
+ };
+
+ class DateTimePredicateLess : public IKeyPredicateLess
+ {
+ public:
+ virtual bool isLess( css::uno::Any const & _lhs, css::uno::Any const & _rhs ) const override
+ {
+ DateTime lhs, rhs;
+ if ( !( _lhs >>= lhs )
+ || !( _rhs >>= rhs )
+ )
+ throw css::lang::IllegalArgumentException("bad ordering", css::uno::Reference<css::uno::XInterface>(), -1);
+ // FIXME Timezone?
+
+ if ( lhs.Year < rhs.Year )
+ return true;
+ if ( lhs.Year > rhs.Year )
+ return false;
+
+ if ( lhs.Month < rhs.Month )
+ return true;
+ if ( lhs.Month > rhs.Month )
+ return false;
+
+ if ( lhs.Day < rhs.Day )
+ return true;
+ if ( lhs.Day > rhs.Day )
+ return false;
+
+ if ( lhs.Hours < rhs.Hours )
+ return true;
+ if ( lhs.Hours > rhs.Hours )
+ return false;
+
+ if ( lhs.Minutes < rhs.Minutes )
+ return true;
+ if ( lhs.Minutes > rhs.Minutes )
+ return false;
+
+ if ( lhs.Seconds < rhs.Seconds )
+ return true;
+ if ( lhs.Seconds > rhs.Seconds )
+ return false;
+
+ if ( lhs.NanoSeconds < rhs.NanoSeconds )
+ return true;
+ return false;
+ }
+ };
+
+ bool anyLess( void const * lhs, typelib_TypeDescriptionReference * lhsType,
+ void const * rhs, typelib_TypeDescriptionReference * rhsType );
+
+ // For compound types we need to compare them member by member until we've
+ // checked them all or found a member that differs. For inequality checks
+ // we need to call anyLess() twice in both directions, this function does that.
+ std::optional<bool> anyCompare( void const * lhs, typelib_TypeDescriptionReference * lhsType,
+ void const * rhs, typelib_TypeDescriptionReference * rhsType )
+ {
+ if( anyLess( lhs, lhsType, rhs, rhsType ))
+ return std::optional( true );
+ if( anyLess( rhs, rhsType, lhs, lhsType ))
+ return std::optional( false );
+ return std::nullopt; // equal, so can't yet tell if anyLess() should return
+ }
+
+ // This is typelib_typedescription_equals(), but returns -1/0/1 values like strcmp().
+ int compareTypes( const typelib_TypeDescription * lhsType,
+ const typelib_TypeDescription * rhsType )
+ {
+ if( lhsType == rhsType )
+ return 0;
+ if( lhsType->eTypeClass != rhsType->eTypeClass )
+ return lhsType->eTypeClass - rhsType->eTypeClass;
+ if( lhsType->pTypeName->length != rhsType->pTypeName->length )
+ return lhsType->pTypeName->length - rhsType->pTypeName->length;
+ return rtl_ustr_compare( lhsType->pTypeName->buffer, rhsType->pTypeName->buffer );
+ }
+
+ bool anyLess( void const * lhs, typelib_TypeDescriptionReference * lhsType,
+ void const * rhs, typelib_TypeDescriptionReference * rhsType )
+ {
+ if (lhsType->eTypeClass != rhsType->eTypeClass)
+ return lhsType->eTypeClass < rhsType->eTypeClass;
+
+ if (lhsType->eTypeClass == typelib_TypeClass_VOID) {
+ return false;
+ }
+ assert(lhs != nullptr);
+ assert(rhs != nullptr);
+
+ switch (lhsType->eTypeClass) {
+ case typelib_TypeClass_INTERFACE:
+ return lhs < rhs;
+ case typelib_TypeClass_STRUCT:
+ case typelib_TypeClass_EXCEPTION: {
+ TypeDescription lhsTypeDescr( lhsType );
+ if (!lhsTypeDescr.is())
+ lhsTypeDescr.makeComplete();
+ if (!lhsTypeDescr.is())
+ throw css::lang::IllegalArgumentException("bad ordering", css::uno::Reference<css::uno::XInterface>(), -1);
+ TypeDescription rhsTypeDescr( rhsType );
+ if (!rhsTypeDescr.is())
+ rhsTypeDescr.makeComplete();
+ if (!rhsTypeDescr.is())
+ throw css::lang::IllegalArgumentException("bad ordering", css::uno::Reference<css::uno::XInterface>(), -1);
+ int compare = compareTypes( lhsTypeDescr.get(), rhsTypeDescr.get());
+ if( compare != 0 )
+ return compare < 0;
+
+ typelib_CompoundTypeDescription * compType =
+ reinterpret_cast< typelib_CompoundTypeDescription * >(
+ lhsTypeDescr.get() );
+ sal_Int32 nDescr = compType->nMembers;
+
+ if (compType->pBaseTypeDescription) {
+ std::optional<bool> subLess = anyCompare(
+ lhs, reinterpret_cast<
+ typelib_TypeDescription * >(
+ compType->pBaseTypeDescription)->pWeakRef,
+ rhs, reinterpret_cast<
+ typelib_TypeDescription * >(
+ compType->pBaseTypeDescription)->pWeakRef);
+ if(subLess.has_value())
+ return *subLess;
+ }
+
+ typelib_TypeDescriptionReference ** ppTypeRefs =
+ compType->ppTypeRefs;
+ sal_Int32 * memberOffsets = compType->pMemberOffsets;
+
+ for ( sal_Int32 nPos = 0; nPos < nDescr; ++nPos )
+ {
+ TypeDescriptionRef memberType( ppTypeRefs[ nPos ] );
+ if (!memberType.is())
+ throw css::lang::IllegalArgumentException("bad ordering", css::uno::Reference<css::uno::XInterface>(), -1);
+ std::optional<bool> subLess = anyCompare(
+ static_cast< char const * >(
+ lhs ) + memberOffsets[ nPos ],
+ memberType->pWeakRef,
+ static_cast< char const * >(
+ rhs ) + memberOffsets[ nPos ],
+ memberType->pWeakRef);
+ if(subLess.has_value())
+ return *subLess;
+ }
+ return false; // equal
+ }
+ case typelib_TypeClass_SEQUENCE: {
+ uno_Sequence * lhsSeq = *static_cast< uno_Sequence * const * >(lhs);
+ uno_Sequence * rhsSeq = *static_cast< uno_Sequence * const * >(rhs);
+ if( lhsSeq->nElements != rhsSeq->nElements)
+ return lhsSeq->nElements < rhsSeq->nElements;
+ sal_Int32 nElements = lhsSeq->nElements;
+
+ TypeDescriptionRef lhsTypeDescr( lhsType );
+ if (!lhsTypeDescr.is())
+ throw css::lang::IllegalArgumentException("bad ordering", css::uno::Reference<css::uno::XInterface>(), -1);
+ TypeDescriptionRef rhsTypeDescr( rhsType );
+ if (!rhsTypeDescr.is())
+ throw css::lang::IllegalArgumentException("bad ordering", css::uno::Reference<css::uno::XInterface>(), -1);
+ int compare = compareTypes( lhsTypeDescr.get(), rhsTypeDescr.get());
+ if( compare != 0 )
+ return compare < 0;
+
+ typelib_TypeDescriptionReference * elementTypeRef =
+ reinterpret_cast< typelib_IndirectTypeDescription * >(lhsTypeDescr.get())->pType;
+ TypeDescriptionRef elementTypeDescr( elementTypeRef );
+ if (!elementTypeDescr.is())
+ throw css::lang::IllegalArgumentException("bad ordering", css::uno::Reference<css::uno::XInterface>(), -1);
+ assert( elementTypeDescr.equals( TypeDescriptionRef(
+ reinterpret_cast< typelib_IndirectTypeDescription * >(lhsTypeDescr.get())->pType )));
+
+ sal_Int32 nElementSize = elementTypeDescr->nSize;
+ if (nElements > 0)
+ {
+ char const * lhsElements = lhsSeq->elements;
+ char const * rhsElements = rhsSeq->elements;
+ for ( sal_Int32 nPos = 0; nPos < nElements; ++nPos )
+ {
+ std::optional<bool> subLess = anyCompare(
+ lhsElements + (nElementSize * nPos),
+ elementTypeDescr->pWeakRef,
+ rhsElements + (nElementSize * nPos),
+ elementTypeDescr->pWeakRef );
+ if(subLess.has_value())
+ return *subLess;
+ }
+ }
+ return false; // equal
+ }
+ case typelib_TypeClass_ANY: {
+ uno_Any const * lhsAny = static_cast< uno_Any const * >(lhs);
+ uno_Any const * rhsAny = static_cast< uno_Any const * >(rhs);
+ return anyLess( lhsAny->pData, lhsAny->pType, rhsAny->pData, rhsAny->pType );
+ }
+ case typelib_TypeClass_TYPE: {
+ OUString const & lhsTypeName = OUString::unacquired(
+ &(*static_cast< typelib_TypeDescriptionReference * const * >(lhs))->pTypeName);
+ OUString const & rhsTypeName = OUString::unacquired(
+ &(*static_cast< typelib_TypeDescriptionReference * const * >(rhs))->pTypeName);
+ return lhsTypeName < rhsTypeName;
+ }
+ case typelib_TypeClass_STRING: {
+ OUString const & lhsStr = OUString::unacquired(
+ static_cast< rtl_uString * const * >(lhs) );
+ OUString const & rhsStr = OUString::unacquired(
+ static_cast< rtl_uString * const * >(rhs) );
+ return lhsStr < rhsStr;
+ }
+ case typelib_TypeClass_ENUM: {
+ TypeDescription lhsTypeDescr( lhsType );
+ if (!lhsTypeDescr.is())
+ lhsTypeDescr.makeComplete();
+ if (!lhsTypeDescr.is())
+ throw css::lang::IllegalArgumentException("bad ordering", css::uno::Reference<css::uno::XInterface>(), -1);
+ TypeDescription rhsTypeDescr( rhsType );
+ if (!rhsTypeDescr.is())
+ rhsTypeDescr.makeComplete();
+ if (!rhsTypeDescr.is())
+ throw css::lang::IllegalArgumentException("bad ordering", css::uno::Reference<css::uno::XInterface>(), -1);
+ int compare = compareTypes( lhsTypeDescr.get(), rhsTypeDescr.get());
+ if( compare != 0 )
+ return compare < 0;
+
+ return *static_cast< int const * >(lhs) < *static_cast< int const * >(rhs);
+ }
+ case typelib_TypeClass_BOOLEAN:
+ return *static_cast< sal_Bool const * >(lhs) < *static_cast< sal_Bool const * >(rhs);
+ case typelib_TypeClass_CHAR:
+ return *static_cast< sal_Unicode const * >(lhs) < *static_cast< sal_Unicode const * >(rhs);
+ case typelib_TypeClass_FLOAT:
+ return *static_cast< float const * >(lhs) < *static_cast< float const * >(rhs);
+ case typelib_TypeClass_DOUBLE:
+ return *static_cast< double const * >(lhs) < *static_cast< double const * >(rhs);
+ case typelib_TypeClass_BYTE:
+ return *static_cast< sal_Int8 const * >(lhs) < *static_cast< sal_Int8 const * >(rhs);
+ case typelib_TypeClass_SHORT:
+ return *static_cast< sal_Int16 const * >(lhs) < *static_cast< sal_Int16 const * >(rhs);
+ case typelib_TypeClass_UNSIGNED_SHORT:
+ return *static_cast< sal_uInt16 const * >(lhs) < *static_cast< sal_uInt16 const * >(rhs);
+ case typelib_TypeClass_LONG:
+ return *static_cast< sal_Int32 const * >(lhs) < *static_cast< sal_Int32 const * >(rhs);
+ case typelib_TypeClass_UNSIGNED_LONG:
+ return *static_cast< sal_uInt32 const * >(lhs) < *static_cast< sal_uInt32 const * >(rhs);
+ case typelib_TypeClass_HYPER:
+ return *static_cast< sal_Int64 const * >(lhs) < *static_cast< sal_Int64 const * >(rhs);
+ case typelib_TypeClass_UNSIGNED_HYPER:
+ return *static_cast< sal_uInt64 const * >(lhs) < *static_cast< sal_uInt64 const * >(rhs);
+ // case typelib_TypeClass_UNKNOWN:
+ // case typelib_TypeClass_SERVICE:
+ // case typelib_TypeClass_MODULE:
+ default:
+ return false;
+ }
+ }
+
+ } // namespace
+
+ std::unique_ptr< IKeyPredicateLess > getStandardLessPredicate( Type const & i_type, Reference< XCollator > const & i_collator )
+ {
+ std::unique_ptr< IKeyPredicateLess > pComparator;
+ switch ( i_type.getTypeClass() )
+ {
+ case TypeClass_CHAR:
+ pComparator.reset( new ScalarPredicateLess< sal_Unicode > );
+ break;
+ case TypeClass_BOOLEAN:
+ pComparator.reset( new ScalarPredicateLess< bool > );
+ break;
+ case TypeClass_BYTE:
+ pComparator.reset( new ScalarPredicateLess< sal_Int8 > );
+ break;
+ case TypeClass_SHORT:
+ pComparator.reset( new ScalarPredicateLess< sal_Int16 > );
+ break;
+ case TypeClass_UNSIGNED_SHORT:
+ pComparator.reset( new ScalarPredicateLess< sal_uInt16 > );
+ break;
+ case TypeClass_LONG:
+ pComparator.reset( new ScalarPredicateLess< sal_Int32 > );
+ break;
+ case TypeClass_UNSIGNED_LONG:
+ pComparator.reset( new ScalarPredicateLess< sal_uInt32 > );
+ break;
+ case TypeClass_HYPER:
+ pComparator.reset( new ScalarPredicateLess< sal_Int64 > );
+ break;
+ case TypeClass_UNSIGNED_HYPER:
+ pComparator.reset( new ScalarPredicateLess< sal_uInt64 > );
+ break;
+ case TypeClass_FLOAT:
+ pComparator.reset( new ScalarPredicateLess< float > );
+ break;
+ case TypeClass_DOUBLE:
+ pComparator.reset( new ScalarPredicateLess< double > );
+ break;
+ case TypeClass_STRING:
+ if ( i_collator.is() )
+ pComparator.reset( new StringCollationPredicateLess( i_collator ) );
+ else
+ pComparator.reset( new StringPredicateLess );
+ break;
+ case TypeClass_TYPE:
+ pComparator.reset( new TypePredicateLess );
+ break;
+ case TypeClass_ENUM:
+ pComparator.reset( new EnumPredicateLess( i_type ) );
+ break;
+ case TypeClass_INTERFACE:
+ pComparator.reset( new InterfacePredicateLess );
+ break;
+ case TypeClass_STRUCT:
+ if ( i_type.equals( ::cppu::UnoType< Date >::get() ) )
+ pComparator.reset( new DatePredicateLess );
+ else if ( i_type.equals( ::cppu::UnoType< Time >::get() ) )
+ pComparator.reset( new TimePredicateLess );
+ else if ( i_type.equals( ::cppu::UnoType< DateTime >::get() ) )
+ pComparator.reset( new DateTimePredicateLess );
+ break;
+ default:
+ break;
+ }
+ return pComparator;
+ }
+
+ bool anyLess( css::uno::Any const & lhs, css::uno::Any const & rhs)
+ {
+ return anyLess( lhs.getValue(), lhs.getValueTypeRef(), rhs.getValue(), rhs.getValueTypeRef());
+ }
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/anytohash.cxx b/comphelper/source/misc/anytohash.cxx
new file mode 100644
index 000000000..4e97ea124
--- /dev/null
+++ b/comphelper/source/misc/anytohash.cxx
@@ -0,0 +1,210 @@
+/* -*- 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 <comphelper/anytohash.hxx>
+
+#include <o3tl/hash_combine.hxx>
+#include <typelib/typedescription.hxx>
+
+#include <com/sun/star/uno/Sequence.hxx>
+
+#include "typedescriptionref.hxx"
+
+using namespace ::com::sun::star;
+using ::com::sun::star::uno::TypeDescription;
+using ::comphelper::detail::TypeDescriptionRef;
+
+namespace comphelper {
+namespace {
+
+std::optional<size_t> hashValue( size_t hash,
+ void const * val, typelib_TypeDescriptionReference * typeRef )
+{
+ o3tl::hash_combine( hash, typeRef->eTypeClass );
+ if (typeRef->eTypeClass == typelib_TypeClass_VOID) {
+ return hash;
+ }
+ assert(val != nullptr);
+
+ switch (typeRef->eTypeClass) {
+ case typelib_TypeClass_INTERFACE: {
+ return std::nullopt; // not implemented
+ }
+ case typelib_TypeClass_STRUCT:
+ case typelib_TypeClass_EXCEPTION: {
+ TypeDescription typeDescr( typeRef );
+ if (!typeDescr.is())
+ typeDescr.makeComplete();
+ if (!typeDescr.is())
+ return std::nullopt;
+
+ typelib_CompoundTypeDescription * compType =
+ reinterpret_cast< typelib_CompoundTypeDescription * >(
+ typeDescr.get() );
+ sal_Int32 nDescr = compType->nMembers;
+
+ if (compType->pBaseTypeDescription) {
+ std::optional<size_t> tmpHash = hashValue(
+ hash, val, reinterpret_cast<
+ typelib_TypeDescription * >(
+ compType->pBaseTypeDescription)->pWeakRef);
+ if(!tmpHash.has_value())
+ return std::nullopt;
+ hash = *tmpHash;
+ }
+
+ typelib_TypeDescriptionReference ** ppTypeRefs =
+ compType->ppTypeRefs;
+ sal_Int32 * memberOffsets = compType->pMemberOffsets;
+
+ for ( sal_Int32 nPos = 0; nPos < nDescr; ++nPos )
+ {
+ TypeDescriptionRef memberType( ppTypeRefs[ nPos ] );
+ if (!memberType.is())
+ return std::nullopt;
+
+ std::optional<size_t> tmpHash = hashValue( hash,
+ static_cast< char const * >(
+ val ) + memberOffsets[ nPos ],
+ memberType->pWeakRef );
+ if(!tmpHash.has_value())
+ return std::nullopt;
+ hash = *tmpHash;
+ }
+ break;
+ }
+ case typelib_TypeClass_SEQUENCE: {
+ TypeDescriptionRef typeDescr( typeRef );
+ if (!typeDescr.is())
+ return std::nullopt;
+
+ typelib_TypeDescriptionReference * elementTypeRef =
+ reinterpret_cast<
+ typelib_IndirectTypeDescription * >(typeDescr.get())->pType;
+ TypeDescriptionRef elementTypeDescr( elementTypeRef );
+ if (!elementTypeDescr.is())
+ return std::nullopt;
+
+ sal_Int32 nElementSize = elementTypeDescr->nSize;
+ uno_Sequence * seq =
+ *static_cast< uno_Sequence * const * >(val);
+ sal_Int32 nElements = seq->nElements;
+
+ if (nElements > 0)
+ {
+ char const * pElements = seq->elements;
+ for ( sal_Int32 nPos = 0; nPos < nElements; ++nPos )
+ {
+ std::optional<size_t> tmpHash = hashValue( hash,
+ pElements + (nElementSize * nPos),
+ elementTypeDescr->pWeakRef );
+ if(!tmpHash.has_value())
+ return std::nullopt;
+ hash = *tmpHash;
+ }
+ }
+ break;
+ }
+ case typelib_TypeClass_ANY: {
+ uno_Any const * pAny = static_cast< uno_Any const * >(val);
+ return hashValue( hash, pAny->pData, pAny->pType );
+ }
+ case typelib_TypeClass_TYPE: {
+ OUString const & str = OUString::unacquired(
+ &(*static_cast<
+ typelib_TypeDescriptionReference * const * >(val)
+ )->pTypeName );
+ o3tl::hash_combine( hash, str.hashCode() );
+ break;
+ }
+ case typelib_TypeClass_STRING: {
+ OUString const & str = OUString::unacquired(
+ static_cast< rtl_uString * const * >(val) );
+ o3tl::hash_combine( hash, str.hashCode() );
+ break;
+ }
+ case typelib_TypeClass_ENUM: {
+ TypeDescription typeDescr( typeRef );
+ if (!typeDescr.is())
+ typeDescr.makeComplete();
+ if (!typeDescr.is())
+ return std::nullopt;
+
+ o3tl::hash_combine( hash, *static_cast< int const * >(val));
+ break;
+ }
+ case typelib_TypeClass_BOOLEAN:
+ if (*static_cast< sal_Bool const * >(val))
+ o3tl::hash_combine( hash, true );
+ else
+ o3tl::hash_combine( hash, false );
+ break;
+ case typelib_TypeClass_CHAR: {
+ o3tl::hash_combine( hash, *static_cast< sal_Unicode const * >(val));
+ break;
+ }
+ case typelib_TypeClass_FLOAT:
+ o3tl::hash_combine( hash, *static_cast< float const * >(val) );
+ break;
+ case typelib_TypeClass_DOUBLE:
+ o3tl::hash_combine( hash, *static_cast< double const * >(val) );
+ break;
+ case typelib_TypeClass_BYTE:
+ o3tl::hash_combine( hash, *static_cast< sal_Int8 const * >(val) );
+ break;
+ case typelib_TypeClass_SHORT:
+ o3tl::hash_combine( hash, *static_cast< sal_Int16 const * >(val) );
+ break;
+ case typelib_TypeClass_UNSIGNED_SHORT:
+ o3tl::hash_combine( hash, *static_cast< sal_uInt16 const * >(val) );
+ break;
+ case typelib_TypeClass_LONG:
+ o3tl::hash_combine( hash, *static_cast< sal_Int32 const * >(val) );
+ break;
+ case typelib_TypeClass_UNSIGNED_LONG:
+ o3tl::hash_combine( hash, *static_cast< sal_uInt32 const * >(val) );
+ break;
+ case typelib_TypeClass_HYPER:
+ o3tl::hash_combine( hash, *static_cast< sal_Int64 const * >(val) );
+ break;
+ case typelib_TypeClass_UNSIGNED_HYPER:
+ o3tl::hash_combine( hash, *static_cast< sal_uInt64 const * >(val) );
+ break;
+// case typelib_TypeClass_UNKNOWN:
+// case typelib_TypeClass_SERVICE:
+// case typelib_TypeClass_MODULE:
+ default:
+ return std::nullopt;
+ }
+ return hash;
+}
+
+} // anon namespace
+
+
+std::optional<size_t> anyToHash( uno::Any const & value )
+{
+ size_t hash = 0;
+ return hashValue( hash, value.getValue(), value.getValueTypeRef());
+}
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/anytostring.cxx b/comphelper/source/misc/anytostring.cxx
new file mode 100644
index 000000000..ebc338b0b
--- /dev/null
+++ b/comphelper/source/misc/anytostring.cxx
@@ -0,0 +1,316 @@
+/* -*- 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 <comphelper/anytostring.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <typelib/typedescription.hxx>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+
+#include "typedescriptionref.hxx"
+
+using namespace ::com::sun::star;
+using ::com::sun::star::uno::TypeDescription;
+using ::comphelper::detail::TypeDescriptionRef;
+
+namespace comphelper {
+namespace {
+
+void appendTypeError(
+ OUStringBuffer & buf, const typelib_TypeDescriptionReference * typeRef )
+{
+ buf.append( "<cannot get type description of type " );
+ buf.append( OUString::unacquired( &typeRef->pTypeName ) );
+ buf.append( '>' );
+}
+
+void appendChar( OUStringBuffer & buf, sal_Unicode c )
+{
+ if (c < ' ' || c > '~') {
+ buf.append( "\\X" );
+ OUString const s(
+ OUString::number( static_cast< sal_Int32 >(c), 16 ) );
+ for ( sal_Int32 f = 4 - s.getLength(); f > 0; --f )
+ buf.append( '0' );
+ buf.append( s );
+ }
+ else {
+ buf.append( c );
+ }
+}
+
+
+void appendValue( OUStringBuffer & buf,
+ void const * val, typelib_TypeDescriptionReference * typeRef,
+ bool prependType )
+{
+ if (typeRef->eTypeClass == typelib_TypeClass_VOID) {
+ buf.append( "void" );
+ return;
+ }
+ assert(val != nullptr);
+
+ if (prependType &&
+ typeRef->eTypeClass != typelib_TypeClass_STRING &&
+ typeRef->eTypeClass != typelib_TypeClass_CHAR &&
+ typeRef->eTypeClass != typelib_TypeClass_BOOLEAN)
+ {
+ buf.append( '(' );
+ buf.append( OUString::unacquired( &typeRef->pTypeName ) );
+ buf.append( ") " );
+ }
+
+ switch (typeRef->eTypeClass) {
+ case typelib_TypeClass_INTERFACE: {
+ buf.append( '@' );
+ buf.append( reinterpret_cast< sal_Int64 >(
+ *static_cast< void * const * >(val) ), 16 );
+ uno::Reference< lang::XServiceInfo > xServiceInfo(
+ *static_cast< uno::XInterface * const * >(val),
+ uno::UNO_QUERY );
+ if (xServiceInfo.is()) {
+ buf.append( " (ImplementationName = \"" );
+ buf.append( xServiceInfo->getImplementationName() );
+ buf.append( "\")" );
+ }
+ break;
+ }
+ case typelib_TypeClass_STRUCT:
+ case typelib_TypeClass_EXCEPTION: {
+ buf.append( "{ " );
+ TypeDescription typeDescr( typeRef );
+ if (!typeDescr.is())
+ typeDescr.makeComplete();
+ if (!typeDescr.is()) {
+ appendTypeError( buf, typeRef );
+ }
+ else {
+ typelib_CompoundTypeDescription * compType =
+ reinterpret_cast< typelib_CompoundTypeDescription * >(
+ typeDescr.get() );
+ sal_Int32 nDescr = compType->nMembers;
+
+ if (compType->pBaseTypeDescription) {
+ appendValue(
+ buf, val, reinterpret_cast<
+ typelib_TypeDescription * >(
+ compType->pBaseTypeDescription)->pWeakRef, false );
+ if (nDescr > 0)
+ buf.append( ", " );
+ }
+
+ typelib_TypeDescriptionReference ** ppTypeRefs =
+ compType->ppTypeRefs;
+ sal_Int32 * memberOffsets = compType->pMemberOffsets;
+ rtl_uString ** ppMemberNames = compType->ppMemberNames;
+
+ for ( sal_Int32 nPos = 0; nPos < nDescr; ++nPos )
+ {
+ buf.append( ppMemberNames[ nPos ] );
+ buf.append( " = " );
+ TypeDescriptionRef memberType( ppTypeRefs[ nPos ] );
+ if (!memberType.is()) {
+ appendTypeError( buf, ppTypeRefs[ nPos ] );
+ }
+ else {
+ appendValue( buf,
+ static_cast< char const * >(
+ val ) + memberOffsets[ nPos ],
+ memberType->pWeakRef, true );
+ }
+ if (nPos < (nDescr - 1))
+ buf.append( ", " );
+ }
+ }
+ buf.append( " }" );
+ break;
+ }
+ case typelib_TypeClass_SEQUENCE: {
+ TypeDescriptionRef typeDescr( typeRef );
+ if (!typeDescr.is()) {
+ appendTypeError( buf,typeRef );
+ }
+ else {
+ typelib_TypeDescriptionReference * elementTypeRef =
+ reinterpret_cast<
+ typelib_IndirectTypeDescription * >(typeDescr.get())->pType;
+ TypeDescriptionRef elementTypeDescr( elementTypeRef );
+ if (!elementTypeDescr.is())
+ {
+ appendTypeError( buf, elementTypeRef );
+ }
+ else
+ {
+ sal_Int32 nElementSize = elementTypeDescr->nSize;
+ uno_Sequence * seq =
+ *static_cast< uno_Sequence * const * >(val);
+ sal_Int32 nElements = seq->nElements;
+
+ if (nElements > 0)
+ {
+ buf.append( "{ " );
+ char const * pElements = seq->elements;
+ for ( sal_Int32 nPos = 0; nPos < nElements; ++nPos )
+ {
+ appendValue(
+ buf, pElements + (nElementSize * nPos),
+ elementTypeDescr->pWeakRef, false );
+ if (nPos < (nElements - 1))
+ buf.append( ", " );
+ }
+ buf.append( " }" );
+ }
+ else
+ {
+ buf.append( "{}" );
+ }
+ }
+ }
+ break;
+ }
+ case typelib_TypeClass_ANY: {
+ buf.append( "{ " );
+ uno_Any const * pAny = static_cast< uno_Any const * >(val);
+ appendValue( buf, pAny->pData, pAny->pType, true );
+ buf.append( " }" );
+ break;
+ }
+ case typelib_TypeClass_TYPE:
+ buf.append( (*static_cast<
+ typelib_TypeDescriptionReference * const * >(val)
+ )->pTypeName );
+ break;
+ case typelib_TypeClass_STRING: {
+ buf.append( '\"' );
+ OUString const & str = OUString::unacquired(
+ static_cast< rtl_uString * const * >(val) );
+ sal_Int32 len = str.getLength();
+ for ( sal_Int32 pos = 0; pos < len; ++pos )
+ {
+ sal_Unicode c = str[ pos ];
+ if (c == '\"')
+ buf.append( "\\\"" );
+ else if (c == '\\')
+ buf.append( "\\\\" );
+ else
+ appendChar( buf, c );
+ }
+ buf.append( '\"' );
+ break;
+ }
+ case typelib_TypeClass_ENUM: {
+ TypeDescription typeDescr( typeRef );
+ if (!typeDescr.is())
+ typeDescr.makeComplete();
+ if (!typeDescr.is()) {
+ appendTypeError( buf, typeRef );
+ }
+ else
+ {
+ sal_Int32 * pValues =
+ reinterpret_cast< typelib_EnumTypeDescription * >(
+ typeDescr.get() )->pEnumValues;
+ sal_Int32 nPos = reinterpret_cast< typelib_EnumTypeDescription * >(
+ typeDescr.get() )->nEnumValues;
+ while (nPos--)
+ {
+ if (pValues[ nPos ] == *static_cast< int const * >(val))
+ break;
+ }
+ if (nPos >= 0)
+ {
+ buf.append( reinterpret_cast< typelib_EnumTypeDescription * >(
+ typeDescr.get() )->ppEnumNames[ nPos ] );
+ }
+ else
+ {
+ buf.append( "?unknown enum value?" );
+ }
+ }
+ break;
+ }
+ case typelib_TypeClass_BOOLEAN:
+ if (*static_cast< sal_Bool const * >(val))
+ buf.append( "true" );
+ else
+ buf.append( "false" );
+ break;
+ case typelib_TypeClass_CHAR: {
+ buf.append( '\'' );
+ sal_Unicode c = *static_cast< sal_Unicode const * >(val);
+ if (c == '\'')
+ buf.append( "\\\'" );
+ else if (c == '\\')
+ buf.append( "\\\\" );
+ else
+ appendChar( buf, c );
+ buf.append( '\'' );
+ break;
+ }
+ case typelib_TypeClass_FLOAT:
+ buf.append( *static_cast< float const * >(val) );
+ break;
+ case typelib_TypeClass_DOUBLE:
+ buf.append( *static_cast< double const * >(val) );
+ break;
+ case typelib_TypeClass_BYTE:
+ buf.append( static_cast< sal_Int32 >(
+ *static_cast< sal_Int8 const * >(val) ) );
+ break;
+ case typelib_TypeClass_SHORT:
+ buf.append( static_cast< sal_Int32 >(
+ *static_cast< sal_Int16 const * >(val) ) );
+ break;
+ case typelib_TypeClass_UNSIGNED_SHORT:
+ buf.append( static_cast< sal_Int32 >(
+ *static_cast< sal_uInt16 const * >(val) ) );
+ break;
+ case typelib_TypeClass_LONG:
+ buf.append( *static_cast< sal_Int32 const * >(val) );
+ break;
+ case typelib_TypeClass_UNSIGNED_LONG:
+ buf.append( static_cast< sal_Int64 >(
+ *static_cast< sal_uInt32 const * >(val) ) );
+ break;
+ case typelib_TypeClass_HYPER:
+ case typelib_TypeClass_UNSIGNED_HYPER:
+ buf.append( *static_cast< sal_Int64 const * >(val) );
+ break;
+// case typelib_TypeClass_UNKNOWN:
+// case typelib_TypeClass_SERVICE:
+// case typelib_TypeClass_MODULE:
+ default:
+ buf.append( '?' );
+ break;
+ }
+}
+
+} // anon namespace
+
+
+OUString anyToString( uno::Any const & value )
+{
+ OUStringBuffer buf;
+ appendValue( buf, value.getValue(), value.getValueTypeRef(), true );
+ return buf.makeStringAndClear();
+}
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/asyncnotification.cxx b/comphelper/source/misc/asyncnotification.cxx
new file mode 100644
index 000000000..cb8a2f251
--- /dev/null
+++ b/comphelper/source/misc/asyncnotification.cxx
@@ -0,0 +1,259 @@
+/* -*- 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 <comphelper/asyncnotification.hxx>
+#include <comphelper/scopeguard.hxx>
+#include <mutex>
+#include <condition_variable>
+
+#include <cassert>
+#include <stdexcept>
+#include <vector>
+#include <algorithm>
+
+namespace comphelper
+{
+ AnyEvent::AnyEvent()
+ {
+ }
+
+ AnyEvent::~AnyEvent()
+ {
+ }
+
+ namespace {
+
+ struct ProcessableEvent
+ {
+ AnyEventRef aEvent;
+ ::rtl::Reference< IEventProcessor > xProcessor;
+ };
+
+ struct EqualProcessor
+ {
+ const ::rtl::Reference< IEventProcessor >& rProcessor;
+ explicit EqualProcessor( const ::rtl::Reference< IEventProcessor >& _rProcessor ) :rProcessor( _rProcessor ) { }
+
+ bool operator()( const ProcessableEvent& _rEvent )
+ {
+ return _rEvent.xProcessor.get() == rProcessor.get();
+ }
+ };
+
+ }
+
+ struct EventNotifierImpl
+ {
+ std::mutex aMutex;
+ std::condition_variable aPendingActions;
+ std::vector< ProcessableEvent > aEvents;
+ bool bTerminate;
+ // only used for AsyncEventNotifierAutoJoin
+ char const* name;
+ std::shared_ptr<AsyncEventNotifierAutoJoin> pKeepThisAlive;
+
+ EventNotifierImpl()
+ : bTerminate(false)
+ , name(nullptr)
+ {
+ }
+ };
+
+ AsyncEventNotifierBase::AsyncEventNotifierBase()
+ : m_xImpl(new EventNotifierImpl)
+ {
+ }
+
+
+ AsyncEventNotifierBase::~AsyncEventNotifierBase()
+ {
+ }
+
+
+ void AsyncEventNotifierBase::removeEventsForProcessor( const ::rtl::Reference< IEventProcessor >& _xProcessor )
+ {
+ std::scoped_lock aGuard( m_xImpl->aMutex );
+
+ // remove all events for this processor
+ m_xImpl->aEvents.erase(std::remove_if( m_xImpl->aEvents.begin(), m_xImpl->aEvents.end(), EqualProcessor( _xProcessor ) ), m_xImpl->aEvents.end());
+ }
+
+
+ void SAL_CALL AsyncEventNotifierBase::terminate()
+ {
+ std::scoped_lock aGuard( m_xImpl->aMutex );
+
+ // remember the termination request
+ m_xImpl->bTerminate = true;
+
+ // awake the thread
+ m_xImpl->aPendingActions.notify_all();
+ }
+
+
+ void AsyncEventNotifierBase::addEvent( const AnyEventRef& _rEvent, const ::rtl::Reference< IEventProcessor >& _xProcessor )
+ {
+ std::scoped_lock aGuard( m_xImpl->aMutex );
+
+ // remember this event
+ m_xImpl->aEvents.emplace_back( ProcessableEvent {_rEvent, _xProcessor} );
+
+ // awake the thread
+ m_xImpl->aPendingActions.notify_all();
+ }
+
+
+ void AsyncEventNotifierBase::execute()
+ {
+ for (;;)
+ {
+ std::vector< ProcessableEvent > aEvents;
+ {
+ std::unique_lock aGuard(m_xImpl->aMutex);
+ m_xImpl->aPendingActions.wait(aGuard,
+ [this] { return m_xImpl->bTerminate || !m_xImpl->aEvents.empty(); } );
+ if (m_xImpl->bTerminate)
+ return;
+ else
+ std::swap(aEvents, m_xImpl->aEvents);
+ }
+ for (ProcessableEvent& rEvent : aEvents)
+ {
+ assert(rEvent.xProcessor.is());
+ rEvent.xProcessor->processEvent(*rEvent.aEvent);
+ }
+ aEvents.clear();
+ }
+ }
+
+ AsyncEventNotifier::AsyncEventNotifier(char const* name)
+ : salhelper::Thread(name)
+ {
+ }
+
+ AsyncEventNotifier::~AsyncEventNotifier()
+ {
+ }
+
+ void AsyncEventNotifier::execute()
+ {
+ return AsyncEventNotifierBase::execute();
+ }
+
+ void AsyncEventNotifier::terminate()
+ {
+ return AsyncEventNotifierBase::terminate();
+ }
+
+ namespace {
+
+ std::mutex& GetTheNotifiersMutex()
+ {
+ static std::mutex MUTEX;
+ return MUTEX;
+ }
+
+ }
+
+ static std::vector<std::weak_ptr<AsyncEventNotifierAutoJoin>> g_Notifiers;
+
+ void JoinAsyncEventNotifiers()
+ {
+ std::vector<std::weak_ptr<AsyncEventNotifierAutoJoin>> notifiers;
+ {
+ std::scoped_lock g(GetTheNotifiersMutex());
+ notifiers = g_Notifiers;
+ }
+ for (std::weak_ptr<AsyncEventNotifierAutoJoin> const& wNotifier : notifiers)
+ {
+ std::shared_ptr<AsyncEventNotifierAutoJoin> const pNotifier(
+ wNotifier.lock());
+ if (pNotifier)
+ {
+ pNotifier->terminate();
+ pNotifier->join();
+ }
+ }
+ // note it's possible that g_Notifiers isn't empty now in case of leaks,
+ // particularly since the UNO service manager isn't disposed yet
+ }
+
+ AsyncEventNotifierAutoJoin::AsyncEventNotifierAutoJoin(char const* name)
+ {
+ m_xImpl->name = name;
+ }
+
+ AsyncEventNotifierAutoJoin::~AsyncEventNotifierAutoJoin()
+ {
+ std::scoped_lock g(GetTheNotifiersMutex());
+ // note: this doesn't happen atomically with the refcount
+ // hence it's possible this deletes > 1 or 0 elements
+ g_Notifiers.erase(
+ std::remove_if(g_Notifiers.begin(), g_Notifiers.end(),
+ [](std::weak_ptr<AsyncEventNotifierAutoJoin> const& w) {
+ return w.expired();
+ } ),
+ g_Notifiers.end());
+ }
+
+ std::shared_ptr<AsyncEventNotifierAutoJoin>
+ AsyncEventNotifierAutoJoin::newAsyncEventNotifierAutoJoin(char const* name)
+ {
+ std::shared_ptr<AsyncEventNotifierAutoJoin> const ret(
+ new AsyncEventNotifierAutoJoin(name));
+ std::scoped_lock g(GetTheNotifiersMutex());
+ g_Notifiers.push_back(ret);
+ return ret;
+ }
+
+ void AsyncEventNotifierAutoJoin::terminate()
+ {
+ return AsyncEventNotifierBase::terminate();
+ }
+
+ void AsyncEventNotifierAutoJoin::launch(std::shared_ptr<AsyncEventNotifierAutoJoin> const& xThis)
+ {
+ // see salhelper::Thread::launch
+ xThis->m_xImpl->pKeepThisAlive = xThis;
+ comphelper::ScopeGuard g([&xThis] { xThis->m_xImpl->pKeepThisAlive.reset(); });
+ if (!xThis->create()) {
+ throw std::runtime_error("osl::Thread::create failed");
+ }
+ g.dismiss();
+ }
+
+ void AsyncEventNotifierAutoJoin::run()
+ {
+ // see salhelper::Thread::run
+ comphelper::ScopeGuard g([this] { onTerminated(); });
+ setName(m_xImpl->name);
+ execute();
+ g.dismiss();
+ }
+
+ void AsyncEventNotifierAutoJoin::onTerminated()
+ {
+ // try to delete "this"
+ m_xImpl->pKeepThisAlive.reset();
+ }
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/asyncquithandler.cxx b/comphelper/source/misc/asyncquithandler.cxx
new file mode 100644
index 000000000..a04534ec9
--- /dev/null
+++ b/comphelper/source/misc/asyncquithandler.cxx
@@ -0,0 +1,44 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * 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 <com/sun/star/frame/Desktop.hpp>
+#include <com/sun/star/frame/XDesktop2.hpp>
+#include <com/sun/star/uno/Reference.hxx>
+
+#include <comphelper/asyncquithandler.hxx>
+#include <comphelper/processfactory.hxx>
+
+AsyncQuitHandler::AsyncQuitHandler() {}
+
+AsyncQuitHandler& AsyncQuitHandler::instance()
+{
+ static AsyncQuitHandler aInst;
+ return aInst;
+}
+
+void AsyncQuitHandler::QuitApplication()
+{
+ css::uno::Reference<css::frame::XDesktop2> xDesktop
+ = css::frame::Desktop::create(comphelper::getProcessComponentContext());
+ xDesktop->terminate();
+}
+
+IMPL_STATIC_LINK_NOARG(AsyncQuitHandler, OnAsyncQuit, void*, void) { QuitApplication(); }
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/automationinvokedzone.cxx b/comphelper/source/misc/automationinvokedzone.cxx
new file mode 100644
index 000000000..4a71c4a51
--- /dev/null
+++ b/comphelper/source/misc/automationinvokedzone.cxx
@@ -0,0 +1,33 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * 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/.
+ */
+
+#include <cassert>
+
+#include <comphelper/automationinvokedzone.hxx>
+
+namespace comphelper::Automation
+{
+thread_local static int nActiveount = 0;
+
+bool AutomationInvokedZone::isActive() { return nActiveount > 0; }
+
+AutomationInvokedZone::AutomationInvokedZone()
+{
+ assert(nActiveount < 1000);
+ nActiveount++;
+}
+
+AutomationInvokedZone::~AutomationInvokedZone()
+{
+ assert(nActiveount > 0);
+ nActiveount--;
+}
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/backupfilehelper.cxx b/comphelper/source/misc/backupfilehelper.cxx
new file mode 100644
index 000000000..e9b173a47
--- /dev/null
+++ b/comphelper/source/misc/backupfilehelper.cxx
@@ -0,0 +1,2504 @@
+/* -*- 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/.
+ */
+
+#include <sal/config.h>
+#include <rtl/ustring.hxx>
+#include <rtl/bootstrap.hxx>
+#include <sal/log.hxx>
+#include <osl/file.hxx>
+#include <comphelper/backupfilehelper.hxx>
+#include <comphelper/DirectoryHelper.hxx>
+#include <rtl/crc.h>
+#include <algorithm>
+#include <deque>
+#include <memory>
+#include <string_view>
+#include <utility>
+#include <vector>
+#include <zlib.h>
+
+#include <comphelper/processfactory.hxx>
+#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
+#include <com/sun/star/ucb/CommandAbortedException.hpp>
+#include <com/sun/star/ucb/CommandFailedException.hpp>
+#include <com/sun/star/uno/Sequence.hxx>
+#include <com/sun/star/uno/Reference.hxx>
+#include <com/sun/star/deployment/DeploymentException.hpp>
+#include <com/sun/star/deployment/ExtensionManager.hpp>
+#include <com/sun/star/xml/dom/XDocumentBuilder.hpp>
+#include <com/sun/star/xml/dom/DocumentBuilder.hpp>
+#include <com/sun/star/xml/dom/XElement.hpp>
+#include <com/sun/star/xml/dom/XNodeList.hpp>
+#include <com/sun/star/xml/dom/XText.hpp>
+#include <com/sun/star/xml/sax/XSAXSerializable.hpp>
+#include <com/sun/star/xml/sax/Writer.hpp>
+#include <com/sun/star/xml/sax/XWriter.hpp>
+#include <com/sun/star/io/XStream.hpp>
+#include <com/sun/star/io/TempFile.hpp>
+#include <com/sun/star/io/XOutputStream.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <cppuhelper/exc_hlp.hxx>
+
+using namespace comphelper;
+using namespace css;
+using namespace css::xml::dom;
+
+const sal_uInt32 BACKUP_FILE_HELPER_BLOCK_SIZE = 16384;
+
+namespace
+{
+ typedef std::shared_ptr< osl::File > FileSharedPtr;
+
+ sal_uInt32 createCrc32(FileSharedPtr const & rCandidate, sal_uInt32 nOffset)
+ {
+ sal_uInt32 nCrc32(0);
+
+ if (rCandidate && osl::File::E_None == rCandidate->open(osl_File_OpenFlag_Read))
+ {
+ sal_uInt8 aArray[BACKUP_FILE_HELPER_BLOCK_SIZE];
+ sal_uInt64 nBytesTransfer(0);
+ sal_uInt64 nSize(0);
+
+ rCandidate->getSize(nSize);
+
+ // set offset in source file - should be zero due to crc32 should
+ // only be needed to be created for new entries, gets loaded with old
+ // ones
+ if (osl::File::E_None == rCandidate->setPos(osl_Pos_Absolut, sal_Int64(nOffset)))
+ {
+ while (nSize != 0)
+ {
+ const sal_uInt64 nToTransfer(std::min(nSize, sal_uInt64(BACKUP_FILE_HELPER_BLOCK_SIZE)));
+
+ if (osl::File::E_None == rCandidate->read(static_cast<void*>(aArray), nToTransfer, nBytesTransfer) && nBytesTransfer == nToTransfer)
+ {
+ // add to crc and reduce size
+ nCrc32 = rtl_crc32(nCrc32, static_cast<void*>(aArray), static_cast<sal_uInt32>(nBytesTransfer));
+ nSize -= nToTransfer;
+ }
+ else
+ {
+ // error - reset to zero again
+ nSize = nCrc32 = 0;
+ }
+ }
+ }
+
+ rCandidate->close();
+ }
+
+ return nCrc32;
+ }
+
+ bool read_sal_uInt32(FileSharedPtr const & rFile, sal_uInt32& rTarget)
+ {
+ sal_uInt8 aArray[4];
+ sal_uInt64 nBaseRead(0);
+
+ // read rTarget
+ if (osl::File::E_None == rFile->read(static_cast<void*>(aArray), 4, nBaseRead) && 4 == nBaseRead)
+ {
+ rTarget = (sal_uInt32(aArray[0]) << 24) + (sal_uInt32(aArray[1]) << 16) + (sal_uInt32(aArray[2]) << 8) + sal_uInt32(aArray[3]);
+ return true;
+ }
+
+ return false;
+ }
+
+ bool write_sal_uInt32(oslFileHandle& rHandle, sal_uInt32 nSource)
+ {
+ sal_uInt8 aArray[4];
+ sal_uInt64 nBaseWritten(0);
+
+ // write nSource
+ aArray[0] = sal_uInt8((nSource & 0xff000000) >> 24);
+ aArray[1] = sal_uInt8((nSource & 0x00ff0000) >> 16);
+ aArray[2] = sal_uInt8((nSource & 0x0000ff00) >> 8);
+ aArray[3] = sal_uInt8(nSource & 0x000000ff);
+
+ return osl_File_E_None == osl_writeFile(rHandle, static_cast<const void*>(aArray), 4, &nBaseWritten) && 4 == nBaseWritten;
+ }
+
+ bool read_OString(FileSharedPtr const & rFile, OString& rTarget)
+ {
+ sal_uInt32 nLength(0);
+
+ if (!read_sal_uInt32(rFile, nLength))
+ {
+ return false;
+ }
+
+ sal_uInt64 nPos;
+ if (osl::File::E_None != rFile->getPos(nPos))
+ return false;
+
+ sal_uInt64 nSize;
+ if (osl::File::E_None != rFile->getSize(nSize))
+ return false;
+
+ const auto nRemainingSize = nSize - nPos;
+ if (nLength > nRemainingSize)
+ return false;
+
+ std::vector<char> aTarget(nLength);
+ sal_uInt64 nBaseRead(0);
+
+ // read rTarget
+ if (osl::File::E_None == rFile->read(static_cast<void*>(aTarget.data()), nLength, nBaseRead) && nLength == nBaseRead)
+ {
+ rTarget = OString(aTarget.data(), static_cast<sal_Int32>(nBaseRead));
+ return true;
+ }
+
+ return false;
+ }
+
+ bool write_OString(oslFileHandle& rHandle, const OString& rSource)
+ {
+ const sal_uInt32 nLength(rSource.getLength());
+
+ if (!write_sal_uInt32(rHandle, nLength))
+ {
+ return false;
+ }
+
+ sal_uInt64 nBaseWritten(0);
+
+ return osl_File_E_None == osl_writeFile(rHandle, static_cast<const void*>(rSource.getStr()), nLength, &nBaseWritten) && nLength == nBaseWritten;
+ }
+
+ OUString createFileURL(
+ std::u16string_view rURL, std::u16string_view rName, std::u16string_view rExt)
+ {
+ OUString aRetval;
+
+ if (!rURL.empty() && !rName.empty())
+ {
+ aRetval = OUString::Concat(rURL) + "/" + rName;
+
+ if (!rExt.empty())
+ {
+ aRetval += OUString::Concat(".") + rExt;
+ }
+ }
+
+ return aRetval;
+ }
+
+ OUString createPackURL(std::u16string_view rURL, std::u16string_view rName)
+ {
+ OUString aRetval;
+
+ if (!rURL.empty() && !rName.empty())
+ {
+ aRetval = OUString::Concat(rURL) + "/" + rName + ".pack";
+ }
+
+ return aRetval;
+ }
+}
+
+namespace
+{
+ enum PackageRepository { USER, SHARED, BUNDLED };
+
+ class ExtensionInfoEntry
+ {
+ private:
+ OString maName; // extension name
+ PackageRepository maRepository; // user|shared|bundled
+ bool mbEnabled; // state
+
+ public:
+ ExtensionInfoEntry()
+ : maRepository(USER),
+ mbEnabled(false)
+ {
+ }
+
+ ExtensionInfoEntry(OString aName, bool bEnabled)
+ : maName(std::move(aName)),
+ maRepository(USER),
+ mbEnabled(bEnabled)
+ {
+ }
+
+ ExtensionInfoEntry(const uno::Reference< deployment::XPackage >& rxPackage)
+ : maName(OUStringToOString(rxPackage->getName(), RTL_TEXTENCODING_ASCII_US)),
+ maRepository(USER),
+ mbEnabled(false)
+ {
+ // check maRepository
+ const OString aRepName(OUStringToOString(rxPackage->getRepositoryName(), RTL_TEXTENCODING_ASCII_US));
+
+ if (aRepName == "shared")
+ {
+ maRepository = SHARED;
+ }
+ else if (aRepName == "bundled")
+ {
+ maRepository = BUNDLED;
+ }
+
+ // check mbEnabled
+ const beans::Optional< beans::Ambiguous< sal_Bool > > option(
+ rxPackage->isRegistered(uno::Reference< task::XAbortChannel >(),
+ uno::Reference< ucb::XCommandEnvironment >()));
+
+ if (option.IsPresent)
+ {
+ ::beans::Ambiguous< sal_Bool > const& reg = option.Value;
+
+ if (!reg.IsAmbiguous)
+ {
+ mbEnabled = reg.Value;
+ }
+ }
+ }
+
+ bool isSameExtension(const ExtensionInfoEntry& rComp) const
+ {
+ return (maRepository == rComp.maRepository && maName == rComp.maName);
+ }
+
+ bool operator<(const ExtensionInfoEntry& rComp) const
+ {
+ if (maRepository == rComp.maRepository)
+ {
+ if (maName == rComp.maName)
+ {
+ return mbEnabled < rComp.mbEnabled;
+ }
+ else
+ {
+ return 0 > maName.compareTo(rComp.maName);
+ }
+ }
+ else
+ {
+ return maRepository < rComp.maRepository;
+ }
+ }
+
+ bool read_entry(FileSharedPtr const & rFile)
+ {
+ // read maName
+ if (!read_OString(rFile, maName))
+ {
+ return false;
+ }
+
+ // read maRepository
+ sal_uInt32 nState(0);
+
+ if (read_sal_uInt32(rFile, nState))
+ {
+ maRepository = static_cast< PackageRepository >(nState);
+ }
+ else
+ {
+ return false;
+ }
+
+ // read mbEnabled
+ if (read_sal_uInt32(rFile, nState))
+ {
+ mbEnabled = static_cast< bool >(nState);
+ }
+ else
+ {
+ return false;
+ }
+
+ return true;
+ }
+
+ bool write_entry(oslFileHandle& rHandle) const
+ {
+ // write maName;
+ if (!write_OString(rHandle, maName))
+ {
+ return false;
+ }
+
+ // write maRepository
+ sal_uInt32 nState(maRepository);
+
+ if (!write_sal_uInt32(rHandle, nState))
+ {
+ return false;
+ }
+
+ // write mbEnabled
+ nState = static_cast< sal_uInt32 >(mbEnabled);
+
+ return write_sal_uInt32(rHandle, nState);
+ }
+
+ const OString& getName() const
+ {
+ return maName;
+ }
+
+ bool isEnabled() const
+ {
+ return mbEnabled;
+ }
+ };
+
+ typedef std::vector< ExtensionInfoEntry > ExtensionInfoEntryVector;
+
+ constexpr OUStringLiteral gaRegPath { u"/registry/com.sun.star.comp.deployment.bundle.PackageRegistryBackend/backenddb.xml" };
+
+ class ExtensionInfo
+ {
+ private:
+ ExtensionInfoEntryVector maEntries;
+
+ public:
+ ExtensionInfo()
+ {
+ }
+
+ const ExtensionInfoEntryVector& getExtensionInfoEntryVector() const
+ {
+ return maEntries;
+ }
+
+ void reset()
+ {
+ // clear all data
+ maEntries.clear();
+ }
+
+ void createUsingXExtensionManager()
+ {
+ // clear all data
+ reset();
+
+ // create content from current extension configuration
+ uno::Sequence< uno::Sequence< uno::Reference< deployment::XPackage > > > xAllPackages;
+ uno::Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext();
+ uno::Reference< deployment::XExtensionManager > m_xExtensionManager = deployment::ExtensionManager::get(xContext);
+
+ try
+ {
+ xAllPackages = m_xExtensionManager->getAllExtensions(uno::Reference< task::XAbortChannel >(),
+ uno::Reference< ucb::XCommandEnvironment >());
+ }
+ catch (const deployment::DeploymentException &)
+ {
+ return;
+ }
+ catch (const ucb::CommandFailedException &)
+ {
+ return;
+ }
+ catch (const ucb::CommandAbortedException &)
+ {
+ return;
+ }
+ catch (const lang::IllegalArgumentException & e)
+ {
+ css::uno::Any anyEx = cppu::getCaughtException();
+ throw css::lang::WrappedTargetRuntimeException( e.Message,
+ e.Context, anyEx );
+ }
+
+ for (const uno::Sequence< uno::Reference< deployment::XPackage > > & xPackageList : std::as_const(xAllPackages))
+ {
+ for (const uno::Reference< deployment::XPackage > & xPackage : xPackageList)
+ {
+ if (xPackage.is())
+ {
+ maEntries.emplace_back(xPackage);
+ }
+ }
+ }
+
+ if (!maEntries.empty())
+ {
+ // sort the list
+ std::sort(maEntries.begin(), maEntries.end());
+ }
+ }
+
+ private:
+ void visitNodesXMLRead(const uno::Reference< xml::dom::XElement >& rElement)
+ {
+ if (!rElement.is())
+ return;
+
+ const OUString aTagName(rElement->getTagName());
+
+ if (aTagName == "extension")
+ {
+ OUString aAttrUrl(rElement->getAttribute("url"));
+ const OUString aAttrRevoked(rElement->getAttribute("revoked"));
+
+ if (!aAttrUrl.isEmpty())
+ {
+ const sal_Int32 nIndex(aAttrUrl.lastIndexOf('/'));
+
+ if (nIndex > 0 && aAttrUrl.getLength() > nIndex + 1)
+ {
+ aAttrUrl = aAttrUrl.copy(nIndex + 1);
+ }
+
+ const bool bEnabled(aAttrRevoked.isEmpty() || !aAttrRevoked.toBoolean());
+ maEntries.emplace_back(
+ OUStringToOString(aAttrUrl, RTL_TEXTENCODING_ASCII_US),
+ bEnabled);
+ }
+ }
+ else
+ {
+ uno::Reference< xml::dom::XNodeList > aList = rElement->getChildNodes();
+
+ if (aList.is())
+ {
+ const sal_Int32 nLength(aList->getLength());
+
+ for (sal_Int32 a(0); a < nLength; a++)
+ {
+ const uno::Reference< xml::dom::XElement > aChild(aList->item(a), uno::UNO_QUERY);
+
+ if (aChild.is())
+ {
+ visitNodesXMLRead(aChild);
+ }
+ }
+ }
+ }
+ }
+
+ public:
+ void createUserExtensionRegistryEntriesFromXML(std::u16string_view rUserConfigWorkURL)
+ {
+ const OUString aPath(
+ OUString::Concat(rUserConfigWorkURL) + "/uno_packages/cache" + gaRegPath);
+ createExtensionRegistryEntriesFromXML(aPath);
+ }
+
+ void createSharedExtensionRegistryEntriesFromXML(std::u16string_view rUserConfigWorkURL)
+ {
+ const OUString aPath(
+ OUString::Concat(rUserConfigWorkURL) + "/extensions/shared" + gaRegPath);
+ createExtensionRegistryEntriesFromXML(aPath);
+ }
+
+ void createBundledExtensionRegistryEntriesFromXML(std::u16string_view rUserConfigWorkURL)
+ {
+ const OUString aPath(
+ OUString::Concat(rUserConfigWorkURL) + "/extensions/bundled" + gaRegPath);
+ createExtensionRegistryEntriesFromXML(aPath);
+ }
+
+
+ void createExtensionRegistryEntriesFromXML(const OUString& aPath)
+ {
+ if (DirectoryHelper::fileExists(aPath))
+ {
+ uno::Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext();
+ uno::Reference< xml::dom::XDocumentBuilder > xBuilder(xml::dom::DocumentBuilder::create(xContext));
+ uno::Reference< xml::dom::XDocument > aDocument = xBuilder->parseURI(aPath);
+
+ if (aDocument.is())
+ {
+ visitNodesXMLRead(aDocument->getDocumentElement());
+ }
+ }
+
+ if (!maEntries.empty())
+ {
+ // sort the list
+ std::sort(maEntries.begin(), maEntries.end());
+ }
+ }
+
+ private:
+ static bool visitNodesXMLChange(
+ const OUString& rTagToSearch,
+ const uno::Reference< xml::dom::XElement >& rElement,
+ const ExtensionInfoEntryVector& rToBeEnabled,
+ const ExtensionInfoEntryVector& rToBeDisabled)
+ {
+ bool bChanged(false);
+
+ if (rElement.is())
+ {
+ const OUString aTagName(rElement->getTagName());
+
+ if (aTagName == rTagToSearch)
+ {
+ const OString aAttrUrl(OUStringToOString(rElement->getAttribute("url"), RTL_TEXTENCODING_ASCII_US));
+ const OUString aAttrRevoked(rElement->getAttribute("revoked"));
+ const bool bEnabled(aAttrRevoked.isEmpty() || !aAttrRevoked.toBoolean());
+
+ if (!aAttrUrl.isEmpty())
+ {
+ for (const auto& enable : rToBeEnabled)
+ {
+ if (-1 != aAttrUrl.indexOf(enable.getName()))
+ {
+ if (!bEnabled)
+ {
+ // needs to be enabled
+ rElement->removeAttribute("revoked");
+ bChanged = true;
+ }
+ }
+ }
+
+ for (const auto& disable : rToBeDisabled)
+ {
+ if (-1 != aAttrUrl.indexOf(disable.getName()))
+ {
+ if (bEnabled)
+ {
+ // needs to be disabled
+ rElement->setAttribute("revoked", "true");
+ bChanged = true;
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ uno::Reference< xml::dom::XNodeList > aList = rElement->getChildNodes();
+
+ if (aList.is())
+ {
+ const sal_Int32 nLength(aList->getLength());
+
+ for (sal_Int32 a(0); a < nLength; a++)
+ {
+ const uno::Reference< xml::dom::XElement > aChild(aList->item(a), uno::UNO_QUERY);
+
+ if (aChild.is())
+ {
+ bChanged |= visitNodesXMLChange(
+ rTagToSearch,
+ aChild,
+ rToBeEnabled,
+ rToBeDisabled);
+ }
+ }
+ }
+ }
+ }
+
+ return bChanged;
+ }
+
+ static void visitNodesXMLChangeOneCase(
+ const OUString& rUnoPackagReg,
+ const OUString& rTagToSearch,
+ const ExtensionInfoEntryVector& rToBeEnabled,
+ const ExtensionInfoEntryVector& rToBeDisabled)
+ {
+ if (!DirectoryHelper::fileExists(rUnoPackagReg))
+ return;
+
+ uno::Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext();
+ uno::Reference< xml::dom::XDocumentBuilder > xBuilder = xml::dom::DocumentBuilder::create(xContext);
+ uno::Reference< xml::dom::XDocument > aDocument = xBuilder->parseURI(rUnoPackagReg);
+
+ if (!aDocument.is())
+ return;
+
+ if (!visitNodesXMLChange(
+ rTagToSearch,
+ aDocument->getDocumentElement(),
+ rToBeEnabled,
+ rToBeDisabled))
+ return;
+
+ // did change - write back
+ uno::Reference< xml::sax::XSAXSerializable > xSerializer(aDocument, uno::UNO_QUERY);
+
+ if (!xSerializer.is())
+ return;
+
+ // create a SAXWriter
+ uno::Reference< xml::sax::XWriter > const xSaxWriter = xml::sax::Writer::create(xContext);
+ uno::Reference< io::XTempFile > xTempFile = io::TempFile::create(xContext);
+ uno::Reference< io::XOutputStream > xOutStrm = xTempFile->getOutputStream();
+
+ // set output stream and do the serialization
+ xSaxWriter->setOutputStream(xOutStrm);
+ xSerializer->serialize(xSaxWriter, uno::Sequence< beans::StringPair >());
+
+ // get URL from temp file
+ OUString aTempURL = xTempFile->getUri();
+
+ // copy back file
+ if (aTempURL.isEmpty() || !DirectoryHelper::fileExists(aTempURL))
+ return;
+
+ if (DirectoryHelper::fileExists(rUnoPackagReg))
+ {
+ osl::File::remove(rUnoPackagReg);
+ }
+
+#if OSL_DEBUG_LEVEL > 1
+ SAL_WARN_IF(osl::FileBase::E_None != osl::File::move(aTempURL, rUnoPackagReg), "comphelper.backupfilehelper", "could not copy back modified Extension configuration file");
+#else
+ osl::File::move(aTempURL, rUnoPackagReg);
+#endif
+ }
+
+ public:
+ static void changeEnableDisableStateInXML(
+ std::u16string_view rUserConfigWorkURL,
+ const ExtensionInfoEntryVector& rToBeEnabled,
+ const ExtensionInfoEntryVector& rToBeDisabled)
+ {
+ static const OUStringLiteral aRegPathFront(u"/uno_packages/cache/registry/com.sun.star.comp.deployment.");
+ static const OUStringLiteral aRegPathBack(u".PackageRegistryBackend/backenddb.xml");
+ // first appearance to check
+ {
+ const OUString aUnoPackagReg(OUString::Concat(rUserConfigWorkURL) + aRegPathFront + "bundle" + aRegPathBack);
+
+ visitNodesXMLChangeOneCase(
+ aUnoPackagReg,
+ "extension",
+ rToBeEnabled,
+ rToBeDisabled);
+ }
+
+ // second appearance to check
+ {
+ const OUString aUnoPackagReg(OUString::Concat(rUserConfigWorkURL) + aRegPathFront + "configuration" + aRegPathBack);
+
+ visitNodesXMLChangeOneCase(
+ aUnoPackagReg,
+ "configuration",
+ rToBeEnabled,
+ rToBeDisabled);
+ }
+
+ // third appearance to check
+ {
+ const OUString aUnoPackagReg(OUString::Concat(rUserConfigWorkURL) + aRegPathFront + "script" + aRegPathBack);
+
+ visitNodesXMLChangeOneCase(
+ aUnoPackagReg,
+ "script",
+ rToBeEnabled,
+ rToBeDisabled);
+ }
+ }
+
+ bool read_entries(FileSharedPtr const & rFile)
+ {
+ // read NumExtensionEntries
+ sal_uInt32 nExtEntries(0);
+
+ if (!read_sal_uInt32(rFile, nExtEntries))
+ {
+ return false;
+ }
+
+ // coverity#1373663 Untrusted loop bound, check file size
+ // isn't utterly broken
+ sal_uInt64 nFileSize(0);
+ rFile->getSize(nFileSize);
+ if (nFileSize < nExtEntries)
+ return false;
+
+ for (sal_uInt32 a(0); a < nExtEntries; a++)
+ {
+ ExtensionInfoEntry aNewEntry;
+
+ if (aNewEntry.read_entry(rFile))
+ {
+ maEntries.push_back(aNewEntry);
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ bool write_entries(oslFileHandle& rHandle) const
+ {
+ const sal_uInt32 nExtEntries(maEntries.size());
+
+ if (!write_sal_uInt32(rHandle, nExtEntries))
+ {
+ return false;
+ }
+
+ for (const auto& a : maEntries)
+ {
+ if (!a.write_entry(rHandle))
+ {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ bool createTempFile(OUString& rTempFileName)
+ {
+ oslFileHandle aHandle;
+ bool bRetval(false);
+
+ // create current configuration
+ if (maEntries.empty())
+ {
+ createUsingXExtensionManager();
+ }
+
+ // open target temp file and write current configuration to it - it exists until deleted
+ if (osl::File::E_None == osl::FileBase::createTempFile(nullptr, &aHandle, &rTempFileName))
+ {
+ bRetval = write_entries(aHandle);
+
+ // close temp file - it exists until deleted
+ osl_closeFile(aHandle);
+ }
+
+ return bRetval;
+ }
+
+ bool areThereEnabledExtensions() const
+ {
+ for (const auto& a : maEntries)
+ {
+ if (a.isEnabled())
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+ };
+}
+
+namespace
+{
+ class PackedFileEntry
+ {
+ private:
+ sal_uInt32 mnFullFileSize; // size in bytes of unpacked original file
+ sal_uInt32 mnPackFileSize; // size in bytes in file backup package (smaller if compressed, same if not)
+ sal_uInt32 mnOffset; // offset in File (zero identifies new file)
+ sal_uInt32 mnCrc32; // checksum
+ FileSharedPtr maFile; // file where to find the data (at offset)
+ bool const mbDoCompress; // flag if this file is scheduled to be compressed when written
+
+ bool copy_content_straight(oslFileHandle& rTargetHandle)
+ {
+ if (!maFile || osl::File::E_None != maFile->open(osl_File_OpenFlag_Read))
+ return false;
+
+ sal_uInt8 aArray[BACKUP_FILE_HELPER_BLOCK_SIZE];
+ sal_uInt64 nBytesTransfer(0);
+ sal_uInt64 nSize(getPackFileSize());
+
+ // set offset in source file - when this is zero, a new file is to be added
+ if (osl::File::E_None == maFile->setPos(osl_Pos_Absolut, sal_Int64(getOffset())))
+ {
+ while (nSize != 0)
+ {
+ const sal_uInt64 nToTransfer(std::min(nSize, sal_uInt64(BACKUP_FILE_HELPER_BLOCK_SIZE)));
+
+ if (osl::File::E_None != maFile->read(static_cast<void*>(aArray), nToTransfer, nBytesTransfer) || nBytesTransfer != nToTransfer)
+ {
+ break;
+ }
+
+ if (osl_File_E_None != osl_writeFile(rTargetHandle, static_cast<const void*>(aArray), nToTransfer, &nBytesTransfer) || nBytesTransfer != nToTransfer)
+ {
+ break;
+ }
+
+ nSize -= nToTransfer;
+ }
+ }
+
+ maFile->close();
+ return (0 == nSize);
+ }
+
+ bool copy_content_compress(oslFileHandle& rTargetHandle)
+ {
+ if (!maFile || osl::File::E_None != maFile->open(osl_File_OpenFlag_Read))
+ return false;
+
+ sal_uInt8 aArray[BACKUP_FILE_HELPER_BLOCK_SIZE];
+ sal_uInt8 aBuffer[BACKUP_FILE_HELPER_BLOCK_SIZE];
+ sal_uInt64 nBytesTransfer(0);
+ sal_uInt64 nSize(getPackFileSize());
+ z_stream zstream;
+ memset(&zstream, 0, sizeof(zstream));
+
+ if (Z_OK == deflateInit(&zstream, Z_BEST_COMPRESSION))
+ {
+ // set offset in source file - when this is zero, a new file is to be added
+ if (osl::File::E_None == maFile->setPos(osl_Pos_Absolut, sal_Int64(getOffset())))
+ {
+ bool bOkay(true);
+
+ while (bOkay && nSize != 0)
+ {
+ const sal_uInt64 nToTransfer(std::min(nSize, sal_uInt64(BACKUP_FILE_HELPER_BLOCK_SIZE)));
+
+ if (osl::File::E_None != maFile->read(static_cast<void*>(aArray), nToTransfer, nBytesTransfer) || nBytesTransfer != nToTransfer)
+ {
+ break;
+ }
+
+ zstream.avail_in = nToTransfer;
+ zstream.next_in = reinterpret_cast<unsigned char*>(aArray);
+
+ do {
+ zstream.avail_out = BACKUP_FILE_HELPER_BLOCK_SIZE;
+ zstream.next_out = reinterpret_cast<unsigned char*>(aBuffer);
+#if !defined Z_PREFIX
+ const sal_Int64 nRetval(deflate(&zstream, nSize == nToTransfer ? Z_FINISH : Z_NO_FLUSH));
+#else
+ const sal_Int64 nRetval(z_deflate(&zstream, nSize == nToTransfer ? Z_FINISH : Z_NO_FLUSH));
+#endif
+ if (Z_STREAM_ERROR == nRetval)
+ {
+ bOkay = false;
+ }
+ else
+ {
+ const sal_uInt64 nAvailable(BACKUP_FILE_HELPER_BLOCK_SIZE - zstream.avail_out);
+
+ if (osl_File_E_None != osl_writeFile(rTargetHandle, static_cast<const void*>(aBuffer), nAvailable, &nBytesTransfer) || nBytesTransfer != nAvailable)
+ {
+ bOkay = false;
+ }
+ }
+ } while (bOkay && 0 == zstream.avail_out);
+
+ if (!bOkay)
+ {
+ break;
+ }
+
+ nSize -= nToTransfer;
+ }
+
+#if !defined Z_PREFIX
+ deflateEnd(&zstream);
+#else
+ z_deflateEnd(&zstream);
+#endif
+ }
+ }
+
+ maFile->close();
+
+ // get compressed size and add to entry
+ if (mnFullFileSize == mnPackFileSize && mnFullFileSize == zstream.total_in)
+ {
+ mnPackFileSize = zstream.total_out;
+ }
+
+ return (0 == nSize);
+ }
+
+ bool copy_content_uncompress(oslFileHandle& rTargetHandle)
+ {
+ if (!maFile || osl::File::E_None != maFile->open(osl_File_OpenFlag_Read))
+ return false;
+
+ sal_uInt8 aArray[BACKUP_FILE_HELPER_BLOCK_SIZE];
+ sal_uInt8 aBuffer[BACKUP_FILE_HELPER_BLOCK_SIZE];
+ sal_uInt64 nBytesTransfer(0);
+ sal_uInt64 nSize(getPackFileSize());
+ z_stream zstream;
+ memset(&zstream, 0, sizeof(zstream));
+
+ if (Z_OK == inflateInit(&zstream))
+ {
+ // set offset in source file - when this is zero, a new file is to be added
+ if (osl::File::E_None == maFile->setPos(osl_Pos_Absolut, sal_Int64(getOffset())))
+ {
+ bool bOkay(true);
+
+ while (bOkay && nSize != 0)
+ {
+ const sal_uInt64 nToTransfer(std::min(nSize, sal_uInt64(BACKUP_FILE_HELPER_BLOCK_SIZE)));
+
+ if (osl::File::E_None != maFile->read(static_cast<void*>(aArray), nToTransfer, nBytesTransfer) || nBytesTransfer != nToTransfer)
+ {
+ break;
+ }
+
+ zstream.avail_in = nToTransfer;
+ zstream.next_in = reinterpret_cast<unsigned char*>(aArray);
+
+ do {
+ zstream.avail_out = BACKUP_FILE_HELPER_BLOCK_SIZE;
+ zstream.next_out = reinterpret_cast<unsigned char*>(aBuffer);
+#if !defined Z_PREFIX
+ const sal_Int64 nRetval(inflate(&zstream, Z_NO_FLUSH));
+#else
+ const sal_Int64 nRetval(z_inflate(&zstream, Z_NO_FLUSH));
+#endif
+ if (Z_STREAM_ERROR == nRetval)
+ {
+ bOkay = false;
+ }
+ else
+ {
+ const sal_uInt64 nAvailable(BACKUP_FILE_HELPER_BLOCK_SIZE - zstream.avail_out);
+
+ if (osl_File_E_None != osl_writeFile(rTargetHandle, static_cast<const void*>(aBuffer), nAvailable, &nBytesTransfer) || nBytesTransfer != nAvailable)
+ {
+ bOkay = false;
+ }
+ }
+ } while (bOkay && 0 == zstream.avail_out);
+
+ if (!bOkay)
+ {
+ break;
+ }
+
+ nSize -= nToTransfer;
+ }
+
+#if !defined Z_PREFIX
+ deflateEnd(&zstream);
+#else
+ z_deflateEnd(&zstream);
+#endif
+ }
+ }
+
+ maFile->close();
+ return (0 == nSize);
+ }
+
+
+ public:
+ // create new, uncompressed entry
+ PackedFileEntry(
+ sal_uInt32 nFullFileSize,
+ sal_uInt32 nCrc32,
+ FileSharedPtr xFile,
+ bool bDoCompress)
+ : mnFullFileSize(nFullFileSize),
+ mnPackFileSize(nFullFileSize),
+ mnOffset(0),
+ mnCrc32(nCrc32),
+ maFile(std::move(xFile)),
+ mbDoCompress(bDoCompress)
+ {
+ }
+
+ // create entry to be loaded as header (read_header)
+ PackedFileEntry()
+ : mnFullFileSize(0),
+ mnPackFileSize(0),
+ mnOffset(0),
+ mnCrc32(0),
+ mbDoCompress(false)
+ {
+ }
+
+ sal_uInt32 getFullFileSize() const
+ {
+ return mnFullFileSize;
+ }
+
+ sal_uInt32 getPackFileSize() const
+ {
+ return mnPackFileSize;
+ }
+
+ sal_uInt32 getOffset() const
+ {
+ return mnOffset;
+ }
+
+ void setOffset(sal_uInt32 nOffset)
+ {
+ mnOffset = nOffset;
+ }
+
+ static sal_uInt32 getEntrySize()
+ {
+ return 12;
+ }
+
+ sal_uInt32 getCrc32() const
+ {
+ return mnCrc32;
+ }
+
+ bool read_header(FileSharedPtr const & rFile)
+ {
+ if (!rFile)
+ {
+ return false;
+ }
+
+ maFile = rFile;
+
+ // read and compute full file size
+ if (!read_sal_uInt32(rFile, mnFullFileSize))
+ {
+ return false;
+ }
+
+ // read and compute entry crc32
+ if (!read_sal_uInt32(rFile, mnCrc32))
+ {
+ return false;
+ }
+
+ // read and compute packed size
+ if (!read_sal_uInt32(rFile, mnPackFileSize))
+ {
+ return false;
+ }
+
+ return true;
+ }
+
+ bool write_header(oslFileHandle& rHandle) const
+ {
+ // write full file size
+ if (!write_sal_uInt32(rHandle, mnFullFileSize))
+ {
+ return false;
+ }
+
+ // write crc32
+ if (!write_sal_uInt32(rHandle, mnCrc32))
+ {
+ return false;
+ }
+
+ // write packed file size
+ if (!write_sal_uInt32(rHandle, mnPackFileSize))
+ {
+ return false;
+ }
+
+ return true;
+ }
+
+ bool copy_content(oslFileHandle& rTargetHandle, bool bUncompress)
+ {
+ if (bUncompress)
+ {
+ if (getFullFileSize() == getPackFileSize())
+ {
+ // not compressed, just copy
+ return copy_content_straight(rTargetHandle);
+ }
+ else
+ {
+ // compressed, need to uncompress on copy
+ return copy_content_uncompress(rTargetHandle);
+ }
+ }
+ else if (0 == getOffset())
+ {
+ if (mbDoCompress)
+ {
+ // compressed wanted, need to compress on copy
+ return copy_content_compress(rTargetHandle);
+ }
+ else
+ {
+ // not compressed, straight copy
+ return copy_content_straight(rTargetHandle);
+ }
+ }
+ else
+ {
+ return copy_content_straight(rTargetHandle);
+ }
+ }
+ };
+}
+
+namespace
+{
+ class PackedFile
+ {
+ private:
+ const OUString maURL;
+ std::deque< PackedFileEntry >
+ maPackedFileEntryVector;
+ bool mbChanged;
+
+ public:
+ PackedFile(const OUString& rURL)
+ : maURL(rURL),
+ mbChanged(false)
+ {
+ FileSharedPtr aSourceFile = std::make_shared<osl::File>(rURL);
+
+ if (osl::File::E_None == aSourceFile->open(osl_File_OpenFlag_Read))
+ {
+ sal_uInt64 nBaseLen(0);
+ aSourceFile->getSize(nBaseLen);
+
+ // we need at least File_ID and num entries -> 8byte
+ if (8 < nBaseLen)
+ {
+ sal_uInt8 aArray[4];
+ sal_uInt64 nBaseRead(0);
+
+ // read and check File_ID
+ if (osl::File::E_None == aSourceFile->read(static_cast< void* >(aArray), 4, nBaseRead) && 4 == nBaseRead)
+ {
+ if ('P' == aArray[0] && 'A' == aArray[1] && 'C' == aArray[2] && 'K' == aArray[3])
+ {
+ // read and compute num entries in this file
+ if (osl::File::E_None == aSourceFile->read(static_cast<void*>(aArray), 4, nBaseRead) && 4 == nBaseRead)
+ {
+ sal_uInt32 nEntries((sal_uInt32(aArray[0]) << 24) + (sal_uInt32(aArray[1]) << 16) + (sal_uInt32(aArray[2]) << 8) + sal_uInt32(aArray[3]));
+
+ // if there are entries (and less than max), read them
+ if (nEntries >= 1 && nEntries <= 10)
+ {
+ for (sal_uInt32 a(0); a < nEntries; a++)
+ {
+ // create new entry, read header (size, crc and PackedSize),
+ // set offset and source file
+ PackedFileEntry aEntry;
+
+ if (aEntry.read_header(aSourceFile))
+ {
+ // add to local data
+ maPackedFileEntryVector.push_back(aEntry);
+ }
+ else
+ {
+ // error
+ nEntries = 0;
+ }
+ }
+
+ if (0 == nEntries)
+ {
+ // on read error clear local data
+ maPackedFileEntryVector.clear();
+ }
+ else
+ {
+ // calculate and set offsets to file binary content
+ sal_uInt32 nHeaderSize(8);
+
+ nHeaderSize += maPackedFileEntryVector.size() * PackedFileEntry::getEntrySize();
+
+ sal_uInt32 nOffset(nHeaderSize);
+
+ for (auto& b : maPackedFileEntryVector)
+ {
+ b.setOffset(nOffset);
+ nOffset += b.getPackFileSize();
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ aSourceFile->close();
+ }
+
+ if (maPackedFileEntryVector.empty())
+ {
+ // on error or no data get rid of pack file
+ osl::File::remove(maURL);
+ }
+ }
+
+ void flush()
+ {
+ bool bRetval(true);
+
+ if (maPackedFileEntryVector.empty())
+ {
+ // get rid of (now?) empty pack file
+ osl::File::remove(maURL);
+ }
+ else if (mbChanged)
+ {
+ // need to create a new pack file, do this in a temp file to which data
+ // will be copied from local file (so keep it here until this is done)
+ oslFileHandle aHandle = nullptr;
+ OUString aTempURL;
+
+ // open target temp file - it exists until deleted
+ if (osl::File::E_None == osl::FileBase::createTempFile(nullptr, &aHandle, &aTempURL))
+ {
+ sal_uInt8 aArray[4];
+ sal_uInt64 nBaseWritten(0);
+
+ aArray[0] = 'P';
+ aArray[1] = 'A';
+ aArray[2] = 'C';
+ aArray[3] = 'K';
+
+ // write File_ID
+ if (osl_File_E_None == osl_writeFile(aHandle, static_cast<const void*>(aArray), 4, &nBaseWritten) && 4 == nBaseWritten)
+ {
+ const sal_uInt32 nSize(maPackedFileEntryVector.size());
+
+ // write number of entries
+ if (write_sal_uInt32(aHandle, nSize))
+ {
+ // write placeholder for headers. Due to the fact that
+ // PackFileSize for newly added files gets set during
+ // writing the content entry, write headers after content
+ // is written. To do so, write placeholders here
+ sal_uInt32 nWriteSize(0);
+
+ nWriteSize += maPackedFileEntryVector.size() * PackedFileEntry::getEntrySize();
+
+ aArray[0] = aArray[1] = aArray[2] = aArray[3] = 0;
+
+ for (sal_uInt32 a(0); bRetval && a < nWriteSize; a++)
+ {
+ if (osl_File_E_None != osl_writeFile(aHandle, static_cast<const void*>(aArray), 1, &nBaseWritten) || 1 != nBaseWritten)
+ {
+ bRetval = false;
+ }
+ }
+
+ if (bRetval)
+ {
+ // write contents - this may adapt PackFileSize for new
+ // files
+ for (auto& candidate : maPackedFileEntryVector)
+ {
+ if (!candidate.copy_content(aHandle, false))
+ {
+ bRetval = false;
+ break;
+ }
+ }
+ }
+
+ if (bRetval)
+ {
+ // seek back to header start (at position 8)
+ if (osl_File_E_None != osl_setFilePos(aHandle, osl_Pos_Absolut, sal_Int64(8)))
+ {
+ bRetval = false;
+ }
+ }
+
+ if (bRetval)
+ {
+ // write headers
+ for (const auto& candidate : maPackedFileEntryVector)
+ {
+ if (!candidate.write_header(aHandle))
+ {
+ // error
+ bRetval = false;
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // close temp file (in all cases) - it exists until deleted
+ osl_closeFile(aHandle);
+
+ if (bRetval)
+ {
+ // copy over existing file by first deleting original
+ // and moving the temp file to old original
+ osl::File::remove(maURL);
+ osl::File::move(aTempURL, maURL);
+ }
+
+ // delete temp file (in all cases - it may be moved already)
+ osl::File::remove(aTempURL);
+ }
+ }
+
+ bool tryPush(FileSharedPtr const & rFileCandidate, bool bCompress)
+ {
+ sal_uInt64 nFileSize(0);
+
+ if (rFileCandidate && osl::File::E_None == rFileCandidate->open(osl_File_OpenFlag_Read))
+ {
+ rFileCandidate->getSize(nFileSize);
+ rFileCandidate->close();
+ }
+
+ if (0 == nFileSize)
+ {
+ // empty file offered
+ return false;
+ }
+
+ bool bNeedToAdd(false);
+ sal_uInt32 nCrc32(0);
+
+ if (maPackedFileEntryVector.empty())
+ {
+ // no backup yet, add as 1st backup
+ bNeedToAdd = true;
+ }
+ else
+ {
+ // already backups there, check if different from last entry
+ const PackedFileEntry& aLastEntry = maPackedFileEntryVector.back();
+
+ // check if file is different
+ if (aLastEntry.getFullFileSize() != static_cast<sal_uInt32>(nFileSize))
+ {
+ // different size, different file
+ bNeedToAdd = true;
+ }
+ else
+ {
+ // same size, check crc32
+ nCrc32 = createCrc32(rFileCandidate, 0);
+
+ if (nCrc32 != aLastEntry.getCrc32())
+ {
+ // different crc, different file
+ bNeedToAdd = true;
+ }
+ }
+ }
+
+ if (bNeedToAdd)
+ {
+ // create crc32 if not yet done
+ if (0 == nCrc32)
+ {
+ nCrc32 = createCrc32(rFileCandidate, 0);
+ }
+
+ // create a file entry for a new file. Offset is set automatically
+ // to 0 to mark the entry as new file entry
+ maPackedFileEntryVector.emplace_back(
+ static_cast< sal_uInt32 >(nFileSize),
+ nCrc32,
+ rFileCandidate,
+ bCompress);
+
+ mbChanged = true;
+ }
+
+ return bNeedToAdd;
+ }
+
+ bool tryPop(oslFileHandle& rHandle)
+ {
+ if (maPackedFileEntryVector.empty())
+ return false;
+
+ // already backups there, check if different from last entry
+ PackedFileEntry& aLastEntry = maPackedFileEntryVector.back();
+
+ // here the uncompress flag has to be determined, true
+ // means to add the file compressed, false means to add it
+ // uncompressed
+ bool bRetval = aLastEntry.copy_content(rHandle, true);
+
+ if (bRetval)
+ {
+ maPackedFileEntryVector.pop_back();
+ mbChanged = true;
+ }
+
+ return bRetval;
+ }
+
+ void tryReduceToNumBackups(sal_uInt16 nNumBackups)
+ {
+ while (maPackedFileEntryVector.size() > nNumBackups)
+ {
+ maPackedFileEntryVector.pop_front();
+ mbChanged = true;
+ }
+ }
+
+ bool empty() const
+ {
+ return maPackedFileEntryVector.empty();
+ }
+ };
+}
+
+namespace comphelper
+{
+ sal_uInt16 BackupFileHelper::mnMaxAllowedBackups = 10;
+ bool BackupFileHelper::mbExitWasCalled = false;
+ bool BackupFileHelper::mbSafeModeDirExists = false;
+ OUString BackupFileHelper::maInitialBaseURL;
+ OUString BackupFileHelper::maUserConfigBaseURL;
+ OUString BackupFileHelper::maUserConfigWorkURL;
+ OUString BackupFileHelper::maRegModName;
+ OUString BackupFileHelper::maExt;
+
+ const OUString& BackupFileHelper::getInitialBaseURL()
+ {
+ if (maInitialBaseURL.isEmpty())
+ {
+ // try to access user layer configuration file URL, the one that
+ // points to registrymodifications.xcu
+ OUString conf("${CONFIGURATION_LAYERS}");
+ rtl::Bootstrap::expandMacros(conf);
+ static const OUStringLiteral aTokenUser(u"user:");
+ sal_Int32 nStart(conf.indexOf(aTokenUser));
+
+ if (-1 != nStart)
+ {
+ nStart += aTokenUser.getLength();
+ sal_Int32 nEnd(conf.indexOf(' ', nStart));
+
+ if (-1 == nEnd)
+ {
+ nEnd = conf.getLength();
+ }
+
+ maInitialBaseURL = conf.copy(nStart, nEnd - nStart);
+ (void)maInitialBaseURL.startsWith("!", &maInitialBaseURL);
+ }
+
+ if (!maInitialBaseURL.isEmpty())
+ {
+ // split URL at extension and at last path separator
+ maUserConfigBaseURL = DirectoryHelper::splitAtLastToken(
+ DirectoryHelper::splitAtLastToken(maInitialBaseURL, '.', maExt), '/',
+ maRegModName);
+ }
+
+ if (!maUserConfigBaseURL.isEmpty())
+ {
+ // check if SafeModeDir exists
+ mbSafeModeDirExists = DirectoryHelper::dirExists(maUserConfigBaseURL + "/" + getSafeModeName());
+ }
+
+ maUserConfigWorkURL = maUserConfigBaseURL;
+
+ if (mbSafeModeDirExists)
+ {
+ // adapt work URL to do all repair op's in the correct directory
+ maUserConfigWorkURL += "/" + getSafeModeName();
+ }
+ }
+
+ return maInitialBaseURL;
+ }
+
+ const OUString& BackupFileHelper::getSafeModeName()
+ {
+ static const OUString aSafeMode("SafeMode");
+
+ return aSafeMode;
+ }
+
+ BackupFileHelper::BackupFileHelper()
+ : mnNumBackups(2),
+ mnMode(1),
+ mbActive(false),
+ mbExtensions(true),
+ mbCompress(true)
+ {
+ OUString sTokenOut;
+
+ // read configuration item 'SecureUserConfig' -> bool on/off
+ if (rtl::Bootstrap::get("SecureUserConfig", sTokenOut))
+ {
+ mbActive = sTokenOut.toBoolean();
+ }
+
+ if (mbActive)
+ {
+ // ensure existence
+ getInitialBaseURL();
+
+ // if not found, we are out of business (maExt may be empty)
+ mbActive = !maInitialBaseURL.isEmpty() && !maUserConfigBaseURL.isEmpty() && !maRegModName.isEmpty();
+ }
+
+ if (mbActive && rtl::Bootstrap::get("SecureUserConfigNumCopies", sTokenOut))
+ {
+ const sal_uInt16 nConfigNumCopies(static_cast<sal_uInt16>(sTokenOut.toUInt32()));
+
+ // limit to range [1..mnMaxAllowedBackups]
+ mnNumBackups = std::clamp(mnNumBackups, nConfigNumCopies, mnMaxAllowedBackups);
+ }
+
+ if (mbActive && rtl::Bootstrap::get("SecureUserConfigMode", sTokenOut))
+ {
+ const sal_uInt16 nMode(static_cast<sal_uInt16>(sTokenOut.toUInt32()));
+
+ // limit to range [0..2]
+ mnMode = std::min(nMode, sal_uInt16(2));
+ }
+
+ if (mbActive && rtl::Bootstrap::get("SecureUserConfigExtensions", sTokenOut))
+ {
+ mbExtensions = sTokenOut.toBoolean();
+ }
+
+ if (mbActive && rtl::Bootstrap::get("SecureUserConfigCompress", sTokenOut))
+ {
+ mbCompress = sTokenOut.toBoolean();
+ }
+ }
+
+ void BackupFileHelper::setExitWasCalled()
+ {
+ mbExitWasCalled = true;
+ }
+
+ bool BackupFileHelper::getExitWasCalled()
+ {
+ return mbExitWasCalled;
+ }
+
+ void BackupFileHelper::reactOnSafeMode(bool bSafeMode)
+ {
+ // ensure existence of needed paths
+ getInitialBaseURL();
+
+ if (maUserConfigBaseURL.isEmpty())
+ return;
+
+ if (bSafeMode)
+ {
+ if (!mbSafeModeDirExists)
+ {
+ std::set< OUString > aExcludeList;
+
+ // do not move SafeMode directory itself
+ aExcludeList.insert(getSafeModeName());
+
+ // init SafeMode by creating the 'SafeMode' directory and moving
+ // all stuff there. All repairs will happen there. Both Dirs have to exist.
+ // extend maUserConfigWorkURL as needed
+ maUserConfigWorkURL = maUserConfigBaseURL + "/" + getSafeModeName();
+
+ osl::Directory::createPath(maUserConfigWorkURL);
+ DirectoryHelper::moveDirContent(maUserConfigBaseURL, maUserConfigWorkURL, aExcludeList);
+
+ // switch local flag, maUserConfigWorkURL is already reset
+ mbSafeModeDirExists = true;
+ }
+ }
+ else
+ {
+ if (mbSafeModeDirExists)
+ {
+ // SafeMode has ended, return to normal mode by moving all content
+ // from 'SafeMode' directory back to UserDirectory and deleting it.
+ // Both Dirs have to exist
+ std::set< OUString > aExcludeList;
+
+ DirectoryHelper::moveDirContent(maUserConfigWorkURL, maUserConfigBaseURL, aExcludeList);
+ osl::Directory::remove(maUserConfigWorkURL);
+
+ // switch local flag and reset maUserConfigWorkURL
+ mbSafeModeDirExists = false;
+ maUserConfigWorkURL = maUserConfigBaseURL;
+ }
+ }
+ }
+
+ void BackupFileHelper::tryPush()
+ {
+ // no push when SafeModeDir exists, it may be Office's exit after SafeMode
+ // where SafeMode flag is already deleted, but SafeModeDir cleanup is not
+ // done yet (is done at next startup)
+ if (!mbActive || mbSafeModeDirExists)
+ return;
+
+ const OUString aPackURL(getPackURL());
+
+ // ensure dir and file vectors
+ fillDirFileInfo();
+
+ // process all files in question recursively
+ if (!maDirs.empty() || !maFiles.empty())
+ {
+ tryPush_Files(
+ maDirs,
+ maFiles,
+ maUserConfigWorkURL,
+ aPackURL);
+ }
+ }
+
+ void BackupFileHelper::tryPushExtensionInfo()
+ {
+ // no push when SafeModeDir exists, it may be Office's exit after SafeMode
+ // where SafeMode flag is already deleted, but SafeModeDir cleanup is not
+ // done yet (is done at next startup)
+ if (mbActive && mbExtensions && !mbSafeModeDirExists)
+ {
+ const OUString aPackURL(getPackURL());
+
+ tryPush_extensionInfo(aPackURL);
+ }
+ }
+
+ bool BackupFileHelper::isPopPossible()
+ {
+ bool bPopPossible(false);
+
+ if (mbActive)
+ {
+ const OUString aPackURL(getPackURL());
+
+ // ensure dir and file vectors
+ fillDirFileInfo();
+
+ // process all files in question recursively
+ if (!maDirs.empty() || !maFiles.empty())
+ {
+ bPopPossible = isPopPossible_files(
+ maDirs,
+ maFiles,
+ maUserConfigWorkURL,
+ aPackURL);
+ }
+ }
+
+ return bPopPossible;
+ }
+
+ void BackupFileHelper::tryPop()
+ {
+ if (!mbActive)
+ return;
+
+ bool bDidPop(false);
+ const OUString aPackURL(getPackURL());
+
+ // ensure dir and file vectors
+ fillDirFileInfo();
+
+ // process all files in question recursively
+ if (!maDirs.empty() || !maFiles.empty())
+ {
+ bDidPop = tryPop_files(
+ maDirs,
+ maFiles,
+ maUserConfigWorkURL,
+ aPackURL);
+ }
+
+ if (bDidPop)
+ {
+ // try removal of evtl. empty directory
+ osl::Directory::remove(aPackURL);
+ }
+ }
+
+ bool BackupFileHelper::isPopPossibleExtensionInfo() const
+ {
+ bool bPopPossible(false);
+
+ if (mbActive && mbExtensions)
+ {
+ const OUString aPackURL(getPackURL());
+
+ bPopPossible = isPopPossible_extensionInfo(aPackURL);
+ }
+
+ return bPopPossible;
+ }
+
+ void BackupFileHelper::tryPopExtensionInfo()
+ {
+ if (!(mbActive && mbExtensions))
+ return;
+
+ bool bDidPop(false);
+ const OUString aPackURL(getPackURL());
+
+ bDidPop = tryPop_extensionInfo(aPackURL);
+
+ if (bDidPop)
+ {
+ // try removal of evtl. empty directory
+ osl::Directory::remove(aPackURL);
+ }
+ }
+
+ bool BackupFileHelper::isTryDisableAllExtensionsPossible()
+ {
+ // check if there are still enabled extension which can be disabled,
+ // but as we are now in SafeMode, use XML infos for this since the
+ // extensions are not loaded from XExtensionManager
+ class ExtensionInfo aExtensionInfo;
+
+ aExtensionInfo.createUserExtensionRegistryEntriesFromXML(maUserConfigWorkURL);
+
+ return aExtensionInfo.areThereEnabledExtensions();
+ }
+
+ void BackupFileHelper::tryDisableAllExtensions()
+ {
+ // disable all still enabled extensions,
+ // but as we are now in SafeMode, use XML infos for this since the
+ // extensions are not loaded from XExtensionManager
+ ExtensionInfo aCurrentExtensionInfo;
+ const ExtensionInfoEntryVector aToBeEnabled{};
+ ExtensionInfoEntryVector aToBeDisabled;
+
+ aCurrentExtensionInfo.createUserExtensionRegistryEntriesFromXML(maUserConfigWorkURL);
+
+ const ExtensionInfoEntryVector& rCurrentVector = aCurrentExtensionInfo.getExtensionInfoEntryVector();
+
+ for (const auto& rCurrentInfo : rCurrentVector)
+ {
+ if (rCurrentInfo.isEnabled())
+ {
+ aToBeDisabled.push_back(rCurrentInfo);
+ }
+ }
+
+ ExtensionInfo::changeEnableDisableStateInXML(maUserConfigWorkURL, aToBeEnabled, aToBeDisabled);
+ }
+
+ bool BackupFileHelper::isTryDeinstallUserExtensionsPossible()
+ {
+ // check if there are User Extensions installed.
+ class ExtensionInfo aExtensionInfo;
+
+ aExtensionInfo.createUserExtensionRegistryEntriesFromXML(maUserConfigWorkURL);
+
+ return !aExtensionInfo.getExtensionInfoEntryVector().empty();
+ }
+
+ void BackupFileHelper::tryDeinstallUserExtensions()
+ {
+ // delete User Extension installs
+ DirectoryHelper::deleteDirRecursively(maUserConfigWorkURL + "/uno_packages");
+ }
+
+ bool BackupFileHelper::isTryResetSharedExtensionsPossible()
+ {
+ // check if there are shared Extensions installed
+ class ExtensionInfo aExtensionInfo;
+
+ aExtensionInfo.createSharedExtensionRegistryEntriesFromXML(maUserConfigWorkURL);
+
+ return !aExtensionInfo.getExtensionInfoEntryVector().empty();
+ }
+
+ void BackupFileHelper::tryResetSharedExtensions()
+ {
+ // reset shared extension info
+ DirectoryHelper::deleteDirRecursively(maUserConfigWorkURL + "/extensions/shared");
+ }
+
+ bool BackupFileHelper::isTryResetBundledExtensionsPossible()
+ {
+ // check if there are shared Extensions installed
+ class ExtensionInfo aExtensionInfo;
+
+ aExtensionInfo.createBundledExtensionRegistryEntriesFromXML(maUserConfigWorkURL);
+
+ return !aExtensionInfo.getExtensionInfoEntryVector().empty();
+ }
+
+ void BackupFileHelper::tryResetBundledExtensions()
+ {
+ // reset shared extension info
+ DirectoryHelper::deleteDirRecursively(maUserConfigWorkURL + "/extensions/bundled");
+ }
+
+ const std::vector< OUString >& BackupFileHelper::getCustomizationDirNames()
+ {
+ static std::vector< OUString > aDirNames =
+ {
+ "config", // UI config stuff
+ "registry", // most of the registry stuff
+ "psprint", // not really needed, can be abandoned
+ "store", // not really needed, can be abandoned
+ "temp", // not really needed, can be abandoned
+ "pack" // own backup dir
+ };
+
+ return aDirNames;
+ }
+
+ const std::vector< OUString >& BackupFileHelper::getCustomizationFileNames()
+ {
+ static std::vector< OUString > aFileNames =
+ {
+ "registrymodifications.xcu" // personal registry stuff
+ };
+
+ return aFileNames;
+ }
+
+ namespace {
+ uno::Reference<XElement> lcl_getConfigElement(const uno::Reference<XDocument>& xDocument, const OUString& rPath,
+ const OUString& rKey, const OUString& rValue)
+ {
+ uno::Reference< XElement > itemElement = xDocument->createElement("item");
+ itemElement->setAttribute("oor:path", rPath);
+
+ uno::Reference< XElement > propElement = xDocument->createElement("prop");
+ propElement->setAttribute("oor:name", rKey);
+ propElement->setAttribute("oor:op", "replace"); // Replace any other options
+
+ uno::Reference< XElement > valueElement = xDocument->createElement("value");
+ uno::Reference< XText > textElement = xDocument->createTextNode(rValue);
+
+ valueElement->appendChild(textElement);
+ propElement->appendChild(valueElement);
+ itemElement->appendChild(propElement);
+
+ return itemElement;
+ }
+ }
+
+ void BackupFileHelper::tryDisableHWAcceleration()
+ {
+ const OUString aRegistryModifications(maUserConfigWorkURL + "/registrymodifications.xcu");
+ if (!DirectoryHelper::fileExists(aRegistryModifications))
+ return;
+
+ uno::Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext();
+ uno::Reference< XDocumentBuilder > xBuilder = DocumentBuilder::create(xContext);
+ uno::Reference< XDocument > xDocument = xBuilder->parseURI(aRegistryModifications);
+ uno::Reference< XElement > xRootElement = xDocument->getDocumentElement();
+
+ xRootElement->appendChild(lcl_getConfigElement(xDocument, "/org.openoffice.Office.Common/VCL",
+ "DisableOpenGL", "true"));
+ xRootElement->appendChild(lcl_getConfigElement(xDocument, "/org.openoffice.Office.Common/Misc",
+ "UseOpenCL", "false"));
+ // Do not disable Skia entirely, just force its CPU-based raster mode.
+ xRootElement->appendChild(lcl_getConfigElement(xDocument, "/org.openoffice.Office.Common/VCL",
+ "ForceSkia", "false"));
+ xRootElement->appendChild(lcl_getConfigElement(xDocument, "/org.openoffice.Office.Common/VCL",
+ "ForceSkiaRaster", "true"));
+
+ OUString aTempURL;
+ {
+ // use the scope to make sure that the temp file gets properly closed before move
+
+ // write back
+ uno::Reference< xml::sax::XSAXSerializable > xSerializer(xDocument, uno::UNO_QUERY);
+
+ if (!xSerializer.is())
+ return;
+
+ // create a SAXWriter
+ uno::Reference< xml::sax::XWriter > const xSaxWriter = xml::sax::Writer::create(xContext);
+ uno::Reference< io::XTempFile > xTempFile = io::TempFile::create(xContext);
+ xTempFile->setRemoveFile(false); // avoid removal of tempfile when leaving the scope
+ uno::Reference< io::XOutputStream > xOutStrm = xTempFile->getOutputStream();
+
+ // set output stream and do the serialization
+ xSaxWriter->setOutputStream(xOutStrm);
+ xSerializer->serialize(xSaxWriter, uno::Sequence< beans::StringPair >());
+
+ // get URL from temp file
+ aTempURL = xTempFile->getUri();
+ }
+
+ // copy back file
+ if (aTempURL.isEmpty() || !DirectoryHelper::fileExists(aTempURL))
+ return;
+
+ if (DirectoryHelper::fileExists(aRegistryModifications))
+ {
+ osl::File::remove(aRegistryModifications);
+ }
+
+ int result = osl::File::move(aTempURL, aRegistryModifications);
+ SAL_WARN_IF(result != osl::FileBase::E_None, "comphelper.backupfilehelper", "could not copy back modified Extension configuration file");
+ }
+
+ bool BackupFileHelper::isTryResetCustomizationsPossible()
+ {
+ // return true if not all of the customization selection dirs or files are deleted
+ const std::vector< OUString >& rDirs = getCustomizationDirNames();
+
+ for (const auto& a : rDirs)
+ {
+ if (DirectoryHelper::dirExists(maUserConfigWorkURL + "/" + a))
+ {
+ return true;
+ }
+ }
+
+ const std::vector< OUString >& rFiles = getCustomizationFileNames();
+
+ for (const auto& b : rFiles)
+ {
+ if (DirectoryHelper::fileExists(maUserConfigWorkURL + "/" + b))
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ void BackupFileHelper::tryResetCustomizations()
+ {
+ // delete all of the customization selection dirs
+ const std::vector< OUString >& rDirs = getCustomizationDirNames();
+
+ for (const auto& a : rDirs)
+ {
+ DirectoryHelper::deleteDirRecursively(maUserConfigWorkURL + "/" + a);
+ }
+
+ const std::vector< OUString >& rFiles = getCustomizationFileNames();
+
+ for (const auto& b : rFiles)
+ {
+ osl::File::remove(maUserConfigWorkURL + "/" + b);
+ }
+ }
+
+ void BackupFileHelper::tryResetUserProfile()
+ {
+ // completely delete the current UserProfile
+ DirectoryHelper::deleteDirRecursively(maUserConfigWorkURL);
+ }
+
+ const OUString& BackupFileHelper::getUserProfileURL()
+ {
+ return maUserConfigBaseURL;
+ }
+
+ const OUString& BackupFileHelper::getUserProfileWorkURL()
+ {
+ return maUserConfigWorkURL;
+ }
+
+ /////////////////// helpers ///////////////////////
+
+ OUString BackupFileHelper::getPackURL()
+ {
+ return OUString(maUserConfigWorkURL + "/pack");
+ }
+
+ /////////////////// file push helpers ///////////////////////
+
+ bool BackupFileHelper::tryPush_Files(
+ const std::set< OUString >& rDirs,
+ const std::set< std::pair< OUString, OUString > >& rFiles,
+ std::u16string_view rSourceURL, // source dir without trailing '/'
+ const OUString& rTargetURL // target dir without trailing '/'
+ )
+ {
+ bool bDidPush(false);
+ osl::Directory::createPath(rTargetURL);
+
+ // process files
+ for (const auto& file : rFiles)
+ {
+ bDidPush |= tryPush_file(
+ rSourceURL,
+ rTargetURL,
+ file.first,
+ file.second);
+ }
+
+ // process dirs
+ for (const auto& dir : rDirs)
+ {
+ OUString aNewSourceURL(OUString::Concat(rSourceURL) + "/" + dir);
+ OUString aNewTargetURL(rTargetURL + "/" + dir);
+ std::set< OUString > aNewDirs;
+ std::set< std::pair< OUString, OUString > > aNewFiles;
+
+ DirectoryHelper::scanDirsAndFiles(
+ aNewSourceURL,
+ aNewDirs,
+ aNewFiles);
+
+ if (!aNewDirs.empty() || !aNewFiles.empty())
+ {
+ bDidPush |= tryPush_Files(
+ aNewDirs,
+ aNewFiles,
+ aNewSourceURL,
+ aNewTargetURL);
+ }
+ }
+
+ if (!bDidPush)
+ {
+ // try removal of evtl. empty directory
+ osl::Directory::remove(rTargetURL);
+ }
+
+ return bDidPush;
+ }
+
+ bool BackupFileHelper::tryPush_file(
+ std::u16string_view rSourceURL, // source dir without trailing '/'
+ std::u16string_view rTargetURL, // target dir without trailing '/'
+ std::u16string_view rName, // filename
+ std::u16string_view rExt // extension (or empty)
+ )
+ {
+ const OUString aFileURL(createFileURL(rSourceURL, rName, rExt));
+
+ if (DirectoryHelper::fileExists(aFileURL))
+ {
+ const OUString aPackURL(createPackURL(rTargetURL, rName));
+ PackedFile aPackedFile(aPackURL);
+ FileSharedPtr aBaseFile = std::make_shared<osl::File>(aFileURL);
+
+ if (aPackedFile.tryPush(aBaseFile, mbCompress))
+ {
+ // reduce to allowed number and flush
+ aPackedFile.tryReduceToNumBackups(mnNumBackups);
+ aPackedFile.flush();
+
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /////////////////// file pop possibilities helper ///////////////////////
+
+ bool BackupFileHelper::isPopPossible_files(
+ const std::set< OUString >& rDirs,
+ const std::set< std::pair< OUString, OUString > >& rFiles,
+ std::u16string_view rSourceURL, // source dir without trailing '/'
+ std::u16string_view rTargetURL // target dir without trailing '/'
+ )
+ {
+ bool bPopPossible(false);
+
+ // process files
+ for (const auto& file : rFiles)
+ {
+ bPopPossible |= isPopPossible_file(
+ rSourceURL,
+ rTargetURL,
+ file.first,
+ file.second);
+ }
+
+ // process dirs
+ for (const auto& dir : rDirs)
+ {
+ OUString aNewSourceURL(OUString::Concat(rSourceURL) + "/" + dir);
+ OUString aNewTargetURL(OUString::Concat(rTargetURL) + "/" + dir);
+ std::set< OUString > aNewDirs;
+ std::set< std::pair< OUString, OUString > > aNewFiles;
+
+ DirectoryHelper::scanDirsAndFiles(
+ aNewSourceURL,
+ aNewDirs,
+ aNewFiles);
+
+ if (!aNewDirs.empty() || !aNewFiles.empty())
+ {
+ bPopPossible |= isPopPossible_files(
+ aNewDirs,
+ aNewFiles,
+ aNewSourceURL,
+ aNewTargetURL);
+ }
+ }
+
+ return bPopPossible;
+ }
+
+ bool BackupFileHelper::isPopPossible_file(
+ std::u16string_view rSourceURL, // source dir without trailing '/'
+ std::u16string_view rTargetURL, // target dir without trailing '/'
+ std::u16string_view rName, // filename
+ std::u16string_view rExt // extension (or empty)
+ )
+ {
+ const OUString aFileURL(createFileURL(rSourceURL, rName, rExt));
+
+ if (DirectoryHelper::fileExists(aFileURL))
+ {
+ const OUString aPackURL(createPackURL(rTargetURL, rName));
+ PackedFile aPackedFile(aPackURL);
+
+ return !aPackedFile.empty();
+ }
+
+ return false;
+ }
+
+ /////////////////// file pop helpers ///////////////////////
+
+ bool BackupFileHelper::tryPop_files(
+ const std::set< OUString >& rDirs,
+ const std::set< std::pair< OUString, OUString > >& rFiles,
+ std::u16string_view rSourceURL, // source dir without trailing '/'
+ const OUString& rTargetURL // target dir without trailing '/'
+ )
+ {
+ bool bDidPop(false);
+
+ // process files
+ for (const auto& file : rFiles)
+ {
+ bDidPop |= tryPop_file(
+ rSourceURL,
+ rTargetURL,
+ file.first,
+ file.second);
+ }
+
+ // process dirs
+ for (const auto& dir : rDirs)
+ {
+ OUString aNewSourceURL(OUString::Concat(rSourceURL) + "/" + dir);
+ OUString aNewTargetURL(rTargetURL + "/" + dir);
+ std::set< OUString > aNewDirs;
+ std::set< std::pair< OUString, OUString > > aNewFiles;
+
+ DirectoryHelper::scanDirsAndFiles(
+ aNewSourceURL,
+ aNewDirs,
+ aNewFiles);
+
+ if (!aNewDirs.empty() || !aNewFiles.empty())
+ {
+ bDidPop |= tryPop_files(
+ aNewDirs,
+ aNewFiles,
+ aNewSourceURL,
+ aNewTargetURL);
+ }
+ }
+
+ if (bDidPop)
+ {
+ // try removal of evtl. empty directory
+ osl::Directory::remove(rTargetURL);
+ }
+
+ return bDidPop;
+ }
+
+ bool BackupFileHelper::tryPop_file(
+ std::u16string_view rSourceURL, // source dir without trailing '/'
+ std::u16string_view rTargetURL, // target dir without trailing '/'
+ std::u16string_view rName, // filename
+ std::u16string_view rExt // extension (or empty)
+ )
+ {
+ const OUString aFileURL(createFileURL(rSourceURL, rName, rExt));
+
+ if (!DirectoryHelper::fileExists(aFileURL))
+ return false;
+
+ // try Pop for base file
+ const OUString aPackURL(createPackURL(rTargetURL, rName));
+ PackedFile aPackedFile(aPackURL);
+
+ if (aPackedFile.empty())
+ return false;
+
+ oslFileHandle aHandle;
+ OUString aTempURL;
+
+ // open target temp file - it exists until deleted
+ if (osl::File::E_None != osl::FileBase::createTempFile(nullptr, &aHandle, &aTempURL))
+ return false;
+
+ bool bRetval(aPackedFile.tryPop(aHandle));
+
+ // close temp file (in all cases) - it exists until deleted
+ osl_closeFile(aHandle);
+
+ if (bRetval)
+ {
+ // copy over existing file by first deleting original
+ // and moving the temp file to old original
+ osl::File::remove(aFileURL);
+ osl::File::move(aTempURL, aFileURL);
+
+ // reduce to allowed number and flush
+ aPackedFile.tryReduceToNumBackups(mnNumBackups);
+ aPackedFile.flush();
+ }
+
+ // delete temp file (in all cases - it may be moved already)
+ osl::File::remove(aTempURL);
+
+ return bRetval;
+ }
+
+ /////////////////// ExtensionInfo helpers ///////////////////////
+
+ bool BackupFileHelper::tryPush_extensionInfo(
+ std::u16string_view rTargetURL // target dir without trailing '/'
+ )
+ {
+ ExtensionInfo aExtensionInfo;
+ OUString aTempURL;
+ bool bRetval(false);
+
+ // create current configuration and write to temp file - it exists until deleted
+ if (aExtensionInfo.createTempFile(aTempURL))
+ {
+ const OUString aPackURL(createPackURL(rTargetURL, u"ExtensionInfo"));
+ PackedFile aPackedFile(aPackURL);
+ FileSharedPtr aBaseFile = std::make_shared<osl::File>(aTempURL);
+
+ if (aPackedFile.tryPush(aBaseFile, mbCompress))
+ {
+ // reduce to allowed number and flush
+ aPackedFile.tryReduceToNumBackups(mnNumBackups);
+ aPackedFile.flush();
+ bRetval = true;
+ }
+ }
+
+ // delete temp file (in all cases)
+ osl::File::remove(aTempURL);
+ return bRetval;
+ }
+
+ bool BackupFileHelper::isPopPossible_extensionInfo(
+ std::u16string_view rTargetURL // target dir without trailing '/'
+ )
+ {
+ // extensionInfo always exists internally, no test needed
+ const OUString aPackURL(createPackURL(rTargetURL, u"ExtensionInfo"));
+ PackedFile aPackedFile(aPackURL);
+
+ return !aPackedFile.empty();
+ }
+
+ bool BackupFileHelper::tryPop_extensionInfo(
+ std::u16string_view rTargetURL // target dir without trailing '/'
+ )
+ {
+ // extensionInfo always exists internally, no test needed
+ const OUString aPackURL(createPackURL(rTargetURL, u"ExtensionInfo"));
+ PackedFile aPackedFile(aPackURL);
+
+ if (aPackedFile.empty())
+ return false;
+
+ oslFileHandle aHandle;
+ OUString aTempURL;
+
+ // open target temp file - it exists until deleted
+ if (osl::File::E_None != osl::FileBase::createTempFile(nullptr, &aHandle, &aTempURL))
+ return false;
+
+ bool bRetval(aPackedFile.tryPop(aHandle));
+
+ // close temp file (in all cases) - it exists until deleted
+ osl_closeFile(aHandle);
+
+ if (bRetval)
+ {
+ // last config is in temp file, load it to ExtensionInfo
+ ExtensionInfo aLoadedExtensionInfo;
+ FileSharedPtr aBaseFile = std::make_shared<osl::File>(aTempURL);
+
+ if (osl::File::E_None == aBaseFile->open(osl_File_OpenFlag_Read))
+ {
+ if (aLoadedExtensionInfo.read_entries(aBaseFile))
+ {
+ // get current extension info, but from XML config files
+ ExtensionInfo aCurrentExtensionInfo;
+
+ aCurrentExtensionInfo.createUserExtensionRegistryEntriesFromXML(maUserConfigWorkURL);
+
+ // now we have loaded last_working (aLoadedExtensionInfo) and
+ // current (aCurrentExtensionInfo) ExtensionInfo and may react on
+ // differences by de/activating these as needed
+ const ExtensionInfoEntryVector& aUserEntries = aCurrentExtensionInfo.getExtensionInfoEntryVector();
+ const ExtensionInfoEntryVector& rLoadedVector = aLoadedExtensionInfo.getExtensionInfoEntryVector();
+ ExtensionInfoEntryVector aToBeDisabled;
+ ExtensionInfoEntryVector aToBeEnabled;
+
+ for (const auto& rCurrentInfo : aUserEntries)
+ {
+ const ExtensionInfoEntry* pLoadedInfo = nullptr;
+
+ for (const auto& rLoadedInfo : rLoadedVector)
+ {
+ if (rCurrentInfo.isSameExtension(rLoadedInfo))
+ {
+ pLoadedInfo = &rLoadedInfo;
+ break;
+ }
+ }
+
+ if (nullptr != pLoadedInfo)
+ {
+ // loaded info contains information about the Extension rCurrentInfo
+ const bool bCurrentEnabled(rCurrentInfo.isEnabled());
+ const bool bLoadedEnabled(pLoadedInfo->isEnabled());
+
+ if (bCurrentEnabled && !bLoadedEnabled)
+ {
+ aToBeDisabled.push_back(rCurrentInfo);
+ }
+ else if (!bCurrentEnabled && bLoadedEnabled)
+ {
+ aToBeEnabled.push_back(rCurrentInfo);
+ }
+ }
+ else
+ {
+ // There is no loaded info about the Extension rCurrentInfo.
+ // It needs to be disabled
+ if (rCurrentInfo.isEnabled())
+ {
+ aToBeDisabled.push_back(rCurrentInfo);
+ }
+ }
+ }
+
+ if (!aToBeDisabled.empty() || !aToBeEnabled.empty())
+ {
+ ExtensionInfo::changeEnableDisableStateInXML(maUserConfigWorkURL, aToBeEnabled, aToBeDisabled);
+ }
+
+ bRetval = true;
+ }
+ }
+
+ // reduce to allowed number and flush
+ aPackedFile.tryReduceToNumBackups(mnNumBackups);
+ aPackedFile.flush();
+ }
+
+ // delete temp file (in all cases - it may be moved already)
+ osl::File::remove(aTempURL);
+
+ return bRetval;
+ }
+
+ /////////////////// FileDirInfo helpers ///////////////////////
+
+ void BackupFileHelper::fillDirFileInfo()
+ {
+ if (!maDirs.empty() || !maFiles.empty())
+ {
+ // already done
+ return;
+ }
+
+ // Information about the configuration and the role/purpose of directories in
+ // the UserConfiguration is taken from: https://wiki.documentfoundation.org/UserProfile
+
+ // fill dir and file info list to work with dependent on work mode
+ switch (mnMode)
+ {
+ case 0:
+ {
+ // simple mode: add just registrymodifications
+ // (the orig file in maInitialBaseURL)
+ maFiles.insert(std::pair< OUString, OUString >(maRegModName, maExt));
+ break;
+ }
+ case 1:
+ {
+ // defined mode: Add a selection of dirs containing User-Defined and thus
+ // valuable configuration information.
+ // This is clearly discussable in every single point and may be adapted/corrected
+ // over time. Main focus is to secure User-Defined/adapted values
+
+ // add registrymodifications (the orig file in maInitialBaseURL)
+ maFiles.insert(std::pair< OUString, OUString >(maRegModName, maExt));
+
+ // User-defined substitution table (Tools/AutoCorrect)
+ maDirs.insert("autocorr");
+
+ // User-Defined AutoText (Edit/AutoText)
+ maDirs.insert("autotext");
+
+ // User-defined Macros
+ maDirs.insert("basic");
+
+ // User-adapted toolbars for modules
+ maDirs.insert("config");
+
+ // Initial and User-defined Databases
+ maDirs.insert("database");
+
+ // most part of registry files
+ maDirs.insert("registry");
+
+ // User-Defined Scripts
+ maDirs.insert("Scripts");
+
+ // Template files
+ maDirs.insert("template");
+
+ // Custom Dictionaries
+ maDirs.insert("wordbook");
+
+ // Questionable - where and how is Extension stuff held and how
+ // does this interact with enabled/disabled states which are extra handled?
+ // Keep out of business until deeper evaluated
+ //
+ // maDirs.insert("extensions");
+ // maDirs.insert("uno-packages");
+ break;
+ }
+ case 2:
+ {
+ // whole directory. To do so, scan directory and exclude some dirs
+ // from which we know they do not need to be secured explicitly. This
+ // should already include registrymodifications, too.
+ DirectoryHelper::scanDirsAndFiles(
+ maUserConfigWorkURL,
+ maDirs,
+ maFiles);
+
+ // should not exist, but for the case an error occurred and it got
+ // copied somehow, avoid further recursive copying/saving
+ maDirs.erase("SafeMode");
+
+ // not really needed, can be abandoned
+ maDirs.erase("psprint");
+
+ // not really needed, can be abandoned
+ maDirs.erase("store");
+
+ // not really needed, can be abandoned
+ maDirs.erase("temp");
+
+ // exclude own backup dir to avoid recursion
+ maDirs.erase("pack");
+
+ break;
+ }
+ }
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/base64.cxx b/comphelper/source/misc/base64.cxx
new file mode 100644
index 000000000..5e3e3ca0a
--- /dev/null
+++ b/comphelper/source/misc/base64.cxx
@@ -0,0 +1,220 @@
+/* -*- 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 <sal/config.h>
+
+#include <cstddef>
+
+#include <comphelper/base64.hxx>
+
+#include <com/sun/star/uno/Sequence.hxx>
+
+#include <o3tl/safeint.hxx>
+#include <osl/diagnose.h>
+
+using namespace com::sun::star;
+
+namespace comphelper {
+
+const
+ char aBase64EncodeTable[] =
+ { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+ 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+ 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };
+
+const
+ sal_uInt8 aBase64DecodeTable[] =
+ { 62,255,255,255, 63, // 43-47
+// + /
+
+ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,255,255,255, 0,255,255, // 48-63
+// 0 1 2 3 4 5 6 7 8 9 =
+
+ 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, // 64-79
+// A B C D E F G H I J K L M N O
+
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,255,255,255,255,255, // 80-95
+// P Q R S T U V W X Y Z
+
+ 0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, // 96-111
+// a b c d e f g h i j k l m n o
+
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51 }; // 112-123
+// p q r s t u v w x y z
+
+
+static void ThreeByteToFourByte(const sal_Int8* pBuffer, const sal_Int32 nStart, const sal_Int32 nFullLen, char* aCharBuffer)
+{
+ sal_Int32 nLen(nFullLen - nStart);
+ if (nLen > 3)
+ nLen = 3;
+ if (nLen == 0)
+ {
+ return;
+ }
+
+ sal_Int32 nBinaer;
+ switch (nLen)
+ {
+ case 1:
+ {
+ nBinaer = static_cast<sal_uInt8>(pBuffer[nStart + 0]) << 16;
+ }
+ break;
+ case 2:
+ {
+ nBinaer = (static_cast<sal_uInt8>(pBuffer[nStart + 0]) << 16) +
+ (static_cast<sal_uInt8>(pBuffer[nStart + 1]) << 8);
+ }
+ break;
+ default:
+ {
+ nBinaer = (static_cast<sal_uInt8>(pBuffer[nStart + 0]) << 16) +
+ (static_cast<sal_uInt8>(pBuffer[nStart + 1]) << 8) +
+ static_cast<sal_uInt8>(pBuffer[nStart + 2]);
+ }
+ break;
+ }
+
+ aCharBuffer[0] = aCharBuffer[1] = aCharBuffer[2] = aCharBuffer[3] = '=';
+
+ sal_uInt8 nIndex (static_cast<sal_uInt8>((nBinaer & 0xFC0000) >> 18));
+ aCharBuffer[0] = aBase64EncodeTable [nIndex];
+
+ nIndex = static_cast<sal_uInt8>((nBinaer & 0x3F000) >> 12);
+ aCharBuffer[1] = aBase64EncodeTable [nIndex];
+ if (nLen > 1)
+ {
+ nIndex = static_cast<sal_uInt8>((nBinaer & 0xFC0) >> 6);
+ aCharBuffer[2] = aBase64EncodeTable [nIndex];
+ if (nLen > 2)
+ {
+ nIndex = static_cast<sal_uInt8>((nBinaer & 0x3F));
+ aCharBuffer[3] = aBase64EncodeTable [nIndex];
+ }
+ }
+}
+
+void Base64::encode(OStringBuffer& aStrBuffer, const uno::Sequence<sal_Int8>& aPass)
+{
+ sal_Int32 i(0);
+ sal_Int32 nBufferLength(aPass.getLength());
+ const sal_Int8* pBuffer = aPass.getConstArray();
+ while (i < nBufferLength)
+ {
+ char aCharBuffer[4];
+ ThreeByteToFourByte(pBuffer, i, nBufferLength, aCharBuffer);
+ aStrBuffer.append(aCharBuffer, std::size(aCharBuffer));
+ i += 3;
+ }
+}
+
+void Base64::encode(OUStringBuffer& aStrBuffer, const uno::Sequence<sal_Int8>& aPass)
+{
+ sal_Int32 i(0);
+ sal_Int32 nBufferLength(aPass.getLength());
+ const sal_Int8* pBuffer = aPass.getConstArray();
+ while (i < nBufferLength)
+ {
+ char aCharBuffer[4];
+ ThreeByteToFourByte(pBuffer, i, nBufferLength, aCharBuffer);
+ aStrBuffer.appendAscii(aCharBuffer, std::size(aCharBuffer));
+ i += 3;
+ }
+}
+
+void Base64::decode(uno::Sequence<sal_Int8>& aBuffer, std::u16string_view sBuffer)
+{
+ std::size_t nCharsDecoded = decodeSomeChars( aBuffer, sBuffer );
+ OSL_ENSURE( nCharsDecoded == sBuffer.size(), "some bytes left in base64 decoding!" );
+}
+
+std::size_t Base64::decodeSomeChars(uno::Sequence<sal_Int8>& rOutBuffer, std::u16string_view rInBuffer)
+{
+ std::size_t nInBufferLen = rInBuffer.size();
+ std::size_t nMinOutBufferLen = (nInBufferLen / 4) * 3;
+ if( o3tl::make_unsigned(rOutBuffer.getLength()) < nMinOutBufferLen )
+ rOutBuffer.realloc( nMinOutBufferLen );
+
+ const sal_Unicode *pInBuffer = rInBuffer.data();
+ sal_Int8 *pOutBuffer = rOutBuffer.getArray();
+ sal_Int8 *pOutBufferStart = pOutBuffer;
+ std::size_t nCharsDecoded = 0;
+
+ sal_uInt8 aDecodeBuffer[4];
+ sal_Int32 nBytesToDecode = 0;
+ sal_Int32 nBytesGotFromDecoding = 3;
+ std::size_t nInBufferPos= 0;
+ while( nInBufferPos < nInBufferLen )
+ {
+ sal_Unicode cChar = *pInBuffer;
+ if( cChar >= '+' && cChar <= 'z' )
+ {
+ sal_uInt8 nByte = aBase64DecodeTable[cChar-'+'];
+ if( nByte != 255 )
+ {
+ // We have found a valid character!
+ aDecodeBuffer[nBytesToDecode++] = nByte;
+
+ // One '=' character at the end means 2 out bytes
+ // Two '=' characters at the end mean 1 out bytes
+ if( '=' == cChar && nBytesToDecode > 2 )
+ nBytesGotFromDecoding--;
+ if( 4 == nBytesToDecode )
+ {
+ // Four characters found, so we may convert now!
+ sal_uInt32 nOut = (aDecodeBuffer[0] << 18) +
+ (aDecodeBuffer[1] << 12) +
+ (aDecodeBuffer[2] << 6) +
+ aDecodeBuffer[3];
+
+ *pOutBuffer++ = static_cast<sal_Int8>((nOut & 0xff0000) >> 16);
+ if( nBytesGotFromDecoding > 1 )
+ *pOutBuffer++ = static_cast<sal_Int8>((nOut & 0xff00) >> 8);
+ if( nBytesGotFromDecoding > 2 )
+ *pOutBuffer++ = static_cast<sal_Int8>(nOut & 0xff);
+ nCharsDecoded = nInBufferPos + 1;
+ nBytesToDecode = 0;
+ nBytesGotFromDecoding = 3;
+ }
+ }
+ else
+ {
+ nCharsDecoded++;
+ }
+ }
+ else
+ {
+ nCharsDecoded++;
+ }
+
+ nInBufferPos++;
+ pInBuffer++;
+ }
+ if( (pOutBuffer - pOutBufferStart) != rOutBuffer.getLength() )
+ rOutBuffer.realloc( pOutBuffer - pOutBufferStart );
+
+ return nCharsDecoded;
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/compbase.cxx b/comphelper/source/misc/compbase.cxx
new file mode 100644
index 000000000..f8a8897b7
--- /dev/null
+++ b/comphelper/source/misc/compbase.cxx
@@ -0,0 +1,231 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * 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/.
+ */
+
+#include <comphelper/compbase.hxx>
+#include <sal/log.hxx>
+#include <osl/diagnose.h>
+
+namespace comphelper
+{
+WeakComponentImplHelperBase::~WeakComponentImplHelperBase() {}
+
+// css::lang::XComponent
+void SAL_CALL WeakComponentImplHelperBase::dispose()
+{
+ std::unique_lock aGuard(m_aMutex);
+ if (m_bDisposed)
+ return;
+ m_bDisposed = true;
+ disposing(aGuard);
+ if (!aGuard.owns_lock())
+ aGuard.lock();
+ css::lang::EventObject aEvt(static_cast<OWeakObject*>(this));
+ maEventListeners.disposeAndClear(aGuard, aEvt);
+}
+
+void WeakComponentImplHelperBase::disposing(std::unique_lock<std::mutex>&) {}
+
+void SAL_CALL WeakComponentImplHelperBase::addEventListener(
+ css::uno::Reference<css::lang::XEventListener> const& rxListener)
+{
+ std::unique_lock aGuard(m_aMutex);
+ if (m_bDisposed)
+ return;
+ maEventListeners.addInterface(aGuard, rxListener);
+}
+
+void SAL_CALL WeakComponentImplHelperBase::removeEventListener(
+ css::uno::Reference<css::lang::XEventListener> const& rxListener)
+{
+ std::unique_lock aGuard(m_aMutex);
+ maEventListeners.removeInterface(aGuard, rxListener);
+}
+
+css::uno::Any SAL_CALL WeakComponentImplHelperBase::queryInterface(css::uno::Type const& rType)
+{
+ css::uno::Any aReturn = ::cppu::queryInterface(rType, static_cast<css::uno::XWeak*>(this),
+ static_cast<css::lang::XComponent*>(this));
+ if (aReturn.hasValue())
+ return aReturn;
+ return OWeakObject::queryInterface(rType);
+}
+
+static void checkInterface(css::uno::Type const& rType)
+{
+ if (css::uno::TypeClass_INTERFACE != rType.getTypeClass())
+ {
+ OUString msg("querying for interface \"" + rType.getTypeName() + "\": no interface type!");
+ SAL_WARN("cppuhelper", msg);
+ throw css::uno::RuntimeException(msg);
+ }
+}
+
+static bool isXInterface(rtl_uString* pStr)
+{
+ return OUString::unacquired(&pStr) == "com.sun.star.uno.XInterface";
+}
+
+static bool td_equals(typelib_TypeDescriptionReference const* pTDR1,
+ typelib_TypeDescriptionReference const* pTDR2)
+{
+ return ((pTDR1 == pTDR2)
+ || OUString::unacquired(&pTDR1->pTypeName) == OUString::unacquired(&pTDR2->pTypeName));
+}
+
+static cppu::type_entry* getTypeEntries(cppu::class_data* cd)
+{
+ cppu::type_entry* pEntries = cd->m_typeEntries;
+ if (!cd->m_storedTypeRefs) // not inited?
+ {
+ static std::mutex aMutex;
+ std::scoped_lock guard(aMutex);
+ if (!cd->m_storedTypeRefs) // not inited?
+ {
+ // get all types
+ for (sal_Int32 n = cd->m_nTypes; n--;)
+ {
+ cppu::type_entry* pEntry = &pEntries[n];
+ css::uno::Type const& rType = (*pEntry->m_type.getCppuType)(nullptr);
+ OSL_ENSURE(rType.getTypeClass() == css::uno::TypeClass_INTERFACE,
+ "### wrong helper init: expected interface!");
+ OSL_ENSURE(
+ !isXInterface(rType.getTypeLibType()->pTypeName),
+ "### want to implement XInterface: template argument is XInterface?!?!?!");
+ if (rType.getTypeClass() != css::uno::TypeClass_INTERFACE)
+ {
+ OUString msg("type \"" + rType.getTypeName() + "\" is no interface type!");
+ SAL_WARN("cppuhelper", msg);
+ throw css::uno::RuntimeException(msg);
+ }
+ // ref is statically held by getCppuType()
+ pEntry->m_type.typeRef = rType.getTypeLibType();
+ }
+ OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
+ cd->m_storedTypeRefs = true;
+ }
+ }
+ else
+ {
+ OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
+ }
+ return pEntries;
+}
+
+static void* makeInterface(sal_IntPtr nOffset, void* that)
+{
+ return (static_cast<char*>(that) + nOffset);
+}
+
+static bool recursivelyFindType(typelib_TypeDescriptionReference const* demandedType,
+ typelib_InterfaceTypeDescription const* type, sal_IntPtr* offset)
+{
+ // This code assumes that the vtables of a multiple-inheritance class (the
+ // offset amount by which to adjust the this pointer) follow one another in
+ // the object layout, and that they contain slots for the inherited classes
+ // in a specific order. In theory, that need not hold for any given
+ // platform; in practice, it seems to work well on all supported platforms:
+next:
+ for (sal_Int32 i = 0; i < type->nBaseTypes; ++i)
+ {
+ if (i > 0)
+ {
+ *offset += sizeof(void*);
+ }
+ typelib_InterfaceTypeDescription const* base = type->ppBaseTypes[i];
+ // ignore XInterface:
+ if (base->nBaseTypes > 0)
+ {
+ if (td_equals(reinterpret_cast<typelib_TypeDescriptionReference const*>(base),
+ demandedType))
+ {
+ return true;
+ }
+ // Profiling showed that it is important to speed up the common case
+ // of only one base:
+ if (type->nBaseTypes == 1)
+ {
+ type = base;
+ goto next;
+ }
+ if (recursivelyFindType(demandedType, base, offset))
+ {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+static void* queryDeepNoXInterface(typelib_TypeDescriptionReference const* pDemandedTDR,
+ cppu::class_data* cd, void* that)
+{
+ cppu::type_entry* pEntries = getTypeEntries(cd);
+ sal_Int32 nTypes = cd->m_nTypes;
+ sal_Int32 n;
+
+ // try top interfaces without getting td
+ for (n = 0; n < nTypes; ++n)
+ {
+ if (td_equals(pEntries[n].m_type.typeRef, pDemandedTDR))
+ {
+ return makeInterface(pEntries[n].m_offset, that);
+ }
+ }
+ // query deep getting td
+ for (n = 0; n < nTypes; ++n)
+ {
+ typelib_TypeDescription* pTD = nullptr;
+ TYPELIB_DANGER_GET(&pTD, pEntries[n].m_type.typeRef);
+ if (pTD)
+ {
+ // exclude top (already tested) and bottom (XInterface) interface
+ OSL_ENSURE(reinterpret_cast<typelib_InterfaceTypeDescription*>(pTD)->nBaseTypes > 0,
+ "### want to implement XInterface:"
+ " template argument is XInterface?!?!?!");
+ sal_IntPtr offset = pEntries[n].m_offset;
+ bool found = recursivelyFindType(
+ pDemandedTDR, reinterpret_cast<typelib_InterfaceTypeDescription*>(pTD), &offset);
+ TYPELIB_DANGER_RELEASE(pTD);
+ if (found)
+ {
+ return makeInterface(offset, that);
+ }
+ }
+ else
+ {
+ OUString msg("cannot get type description for type \""
+ + OUString::unacquired(&pEntries[n].m_type.typeRef->pTypeName) + "\"!");
+ SAL_WARN("cppuhelper", msg);
+ throw css::uno::RuntimeException(msg);
+ }
+ }
+ return nullptr;
+}
+
+css::uno::Any WeakComponentImplHelper_query(css::uno::Type const& rType, cppu::class_data* cd,
+ WeakComponentImplHelperBase* pBase)
+{
+ checkInterface(rType);
+ typelib_TypeDescriptionReference* pTDR = rType.getTypeLibType();
+
+ // shortcut XInterface to WeakComponentImplHelperBase
+ if (!isXInterface(pTDR->pTypeName))
+ {
+ void* p = queryDeepNoXInterface(pTDR, cd, pBase);
+ if (p)
+ {
+ return css::uno::Any(&p, pTDR);
+ }
+ }
+ return pBase->comphelper::WeakComponentImplHelperBase::queryInterface(rType);
+}
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/comphelper/source/misc/componentbase.cxx b/comphelper/source/misc/componentbase.cxx
new file mode 100644
index 000000000..9baec2363
--- /dev/null
+++ b/comphelper/source/misc/componentbase.cxx
@@ -0,0 +1,59 @@
+/* -*- 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 <comphelper/componentbase.hxx>
+
+#include <com/sun/star/lang/NotInitializedException.hpp>
+#include <com/sun/star/lang/DisposedException.hpp>
+
+
+namespace comphelper
+{
+
+
+ using ::com::sun::star::lang::NotInitializedException;
+ using ::com::sun::star::lang::DisposedException;
+ using ::com::sun::star::uno::Reference;
+ using ::com::sun::star::uno::XInterface;
+
+ void ComponentBase::checkDisposed( GuardAccess ) const
+ {
+ if ( m_rBHelper.bDisposed )
+ throw DisposedException( OUString(), getComponent() );
+ }
+
+
+ void ComponentBase::checkInitialized( GuardAccess ) const
+ {
+ if ( !m_bInitialized )
+ throw NotInitializedException( OUString(), getComponent() );
+ }
+
+
+ Reference< XInterface > ComponentBase::getComponent()
+ {
+ return nullptr;
+ }
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/configuration.cxx b/comphelper/source/misc/configuration.cxx
new file mode 100644
index 000000000..59631dbcc
--- /dev/null
+++ b/comphelper/source/misc/configuration.cxx
@@ -0,0 +1,279 @@
+/* -*- 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/.
+ */
+
+#include <sal/config.h>
+
+#include <cassert>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <string_view>
+
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <com/sun/star/configuration/ReadOnlyAccess.hpp>
+#include <com/sun/star/configuration/ReadWriteAccess.hpp>
+#include <com/sun/star/configuration/XReadWriteAccess.hpp>
+#include <com/sun/star/configuration/theDefaultProvider.hpp>
+#include <com/sun/star/container/XHierarchicalNameAccess.hpp>
+#include <com/sun/star/container/XHierarchicalNameReplace.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/lang/XLocalizable.hpp>
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/uno/Reference.hxx>
+#include <comphelper/solarmutex.hxx>
+#include <comphelper/configuration.hxx>
+#include <comphelper/configurationlistener.hxx>
+#include <rtl/ustring.hxx>
+#include <sal/log.hxx>
+#include <i18nlangtag/languagetag.hxx>
+
+namespace com::sun::star::uno { class XComponentContext; }
+
+namespace {
+
+OUString getDefaultLocale(
+ css::uno::Reference< css::uno::XComponentContext > const & context)
+{
+ return LanguageTag(
+ css::uno::Reference< css::lang::XLocalizable >(
+ css::configuration::theDefaultProvider::get(context),
+ css::uno::UNO_QUERY_THROW)->
+ getLocale()).getBcp47(false);
+}
+
+OUString extendLocalizedPath(std::u16string_view path, OUString const & locale) {
+ SAL_WARN_IF(
+ locale.match("*"), "comphelper",
+ "Locale \"" << locale << "\" starts with \"*\"");
+ assert(locale.indexOf('&') == -1);
+ assert(locale.indexOf('"') == -1);
+ assert(locale.indexOf('\'') == -1);
+ return OUString::Concat(path) + "/['*" + locale + "']";
+}
+
+}
+
+std::shared_ptr< comphelper::ConfigurationChanges >
+comphelper::ConfigurationChanges::create()
+{
+ return detail::ConfigurationWrapper::get().createChanges();
+}
+
+comphelper::ConfigurationChanges::~ConfigurationChanges() {}
+
+void comphelper::ConfigurationChanges::commit() const {
+ access_->commitChanges();
+}
+
+comphelper::ConfigurationChanges::ConfigurationChanges(
+ css::uno::Reference< css::uno::XComponentContext > const & context):
+ access_(
+ css::configuration::ReadWriteAccess::create(
+ context, getDefaultLocale(context)))
+{}
+
+void comphelper::ConfigurationChanges::setPropertyValue(
+ OUString const & path, css::uno::Any const & value) const
+{
+ access_->replaceByHierarchicalName(path, value);
+}
+
+css::uno::Reference< css::container::XHierarchicalNameReplace >
+comphelper::ConfigurationChanges::getGroup(OUString const & path) const
+{
+ return css::uno::Reference< css::container::XHierarchicalNameReplace >(
+ access_->getByHierarchicalName(path), css::uno::UNO_QUERY_THROW);
+}
+
+css::uno::Reference< css::container::XNameContainer >
+comphelper::ConfigurationChanges::getSet(OUString const & path) const
+{
+ return css::uno::Reference< css::container::XNameContainer >(
+ access_->getByHierarchicalName(path), css::uno::UNO_QUERY_THROW);
+}
+
+comphelper::detail::ConfigurationWrapper const &
+comphelper::detail::ConfigurationWrapper::get()
+{
+ static comphelper::detail::ConfigurationWrapper WRAPPER;
+ return WRAPPER;
+}
+
+comphelper::detail::ConfigurationWrapper::ConfigurationWrapper():
+ context_(comphelper::getProcessComponentContext()),
+ access_(css::configuration::ReadWriteAccess::create(context_, "*"))
+{}
+
+comphelper::detail::ConfigurationWrapper::~ConfigurationWrapper() {}
+
+bool comphelper::detail::ConfigurationWrapper::isReadOnly(OUString const & path)
+ const
+{
+ return
+ (access_->getPropertyByHierarchicalName(path).Attributes
+ & css::beans::PropertyAttribute::READONLY)
+ != 0;
+}
+
+css::uno::Any comphelper::detail::ConfigurationWrapper::getPropertyValue(std::u16string_view path) const
+{
+ // Cache the configuration access, since some of the keys are used in hot code.
+ // Note that this cache is only used by the officecfg:: auto-generated code, using it for anything
+ // else would be unwise because the cache could end up containing stale entries.
+ static std::mutex gMutex;
+ static std::map<OUString, css::uno::Reference< css::container::XNameAccess >> gAccessMap;
+
+ sal_Int32 idx = path.rfind('/');
+ assert(idx!=-1);
+ OUString parentPath(path.substr(0, idx));
+ OUString childName(path.substr(idx+1));
+
+ std::scoped_lock aGuard(gMutex);
+
+ // check cache
+ auto it = gAccessMap.find(parentPath);
+ if (it == gAccessMap.end())
+ {
+ // not in the cache, look it up
+ css::uno::Reference<css::container::XNameAccess> access(
+ access_->getByHierarchicalName(parentPath), css::uno::UNO_QUERY_THROW);
+ it = gAccessMap.emplace(parentPath, access).first;
+ }
+ return it->second->getByName(childName);
+}
+
+void comphelper::detail::ConfigurationWrapper::setPropertyValue(
+ std::shared_ptr< ConfigurationChanges > const & batch,
+ OUString const & path, css::uno::Any const & value)
+{
+ assert(batch);
+ batch->setPropertyValue(path, value);
+}
+
+css::uno::Any
+comphelper::detail::ConfigurationWrapper::getLocalizedPropertyValue(
+ std::u16string_view path) const
+{
+ return access_->getByHierarchicalName(
+ extendLocalizedPath(path, getDefaultLocale(context_)));
+}
+
+void comphelper::detail::ConfigurationWrapper::setLocalizedPropertyValue(
+ std::shared_ptr< ConfigurationChanges > const & batch,
+ OUString const & path, css::uno::Any const & value)
+{
+ assert(batch);
+ batch->setPropertyValue(path, value);
+}
+
+css::uno::Reference< css::container::XHierarchicalNameAccess >
+comphelper::detail::ConfigurationWrapper::getGroupReadOnly(
+ OUString const & path) const
+{
+ return css::uno::Reference< css::container::XHierarchicalNameAccess >(
+ (css::configuration::ReadOnlyAccess::create(
+ context_, getDefaultLocale(context_))->
+ getByHierarchicalName(path)),
+ css::uno::UNO_QUERY_THROW);
+}
+
+css::uno::Reference< css::container::XHierarchicalNameReplace >
+comphelper::detail::ConfigurationWrapper::getGroupReadWrite(
+ std::shared_ptr< ConfigurationChanges > const & batch,
+ OUString const & path)
+{
+ assert(batch);
+ return batch->getGroup(path);
+}
+
+css::uno::Reference< css::container::XNameAccess >
+comphelper::detail::ConfigurationWrapper::getSetReadOnly(
+ OUString const & path) const
+{
+ return css::uno::Reference< css::container::XNameAccess >(
+ (css::configuration::ReadOnlyAccess::create(
+ context_, getDefaultLocale(context_))->
+ getByHierarchicalName(path)),
+ css::uno::UNO_QUERY_THROW);
+}
+
+css::uno::Reference< css::container::XNameContainer >
+comphelper::detail::ConfigurationWrapper::getSetReadWrite(
+ std::shared_ptr< ConfigurationChanges > const & batch,
+ OUString const & path)
+{
+ assert(batch);
+ return batch->getSet(path);
+}
+
+std::shared_ptr< comphelper::ConfigurationChanges >
+comphelper::detail::ConfigurationWrapper::createChanges() const {
+ return std::shared_ptr< ConfigurationChanges >(
+ new ConfigurationChanges(context_));
+}
+
+void comphelper::ConfigurationListener::addListener(ConfigurationListenerPropertyBase *pListener)
+{
+ maListeners.push_back( pListener );
+ mxConfig->addPropertyChangeListener( pListener->maName, this );
+ pListener->setProperty( mxConfig->getPropertyValue( pListener->maName ) );
+}
+
+void comphelper::ConfigurationListener::removeListener(ConfigurationListenerPropertyBase *pListener)
+{
+ auto it = std::find( maListeners.begin(), maListeners.end(), pListener );
+ if ( it != maListeners.end() )
+ {
+ maListeners.erase( it );
+ mxConfig->removePropertyChangeListener( pListener->maName, this );
+ }
+}
+
+void comphelper::ConfigurationListener::dispose()
+{
+ for (auto const& listener : maListeners)
+ {
+ mxConfig->removePropertyChangeListener( listener->maName, this );
+ listener->dispose();
+ }
+ maListeners.clear();
+ mbDisposed = true;
+}
+
+void SAL_CALL comphelper::ConfigurationListener::disposing(css::lang::EventObject const &)
+{
+ dispose();
+}
+
+void SAL_CALL comphelper::ConfigurationListener::propertyChange(
+ css::beans::PropertyChangeEvent const &rEvt )
+{
+ // Code is commonly used inside the SolarMutexGuard
+ // so to avoid concurrent writes to the property,
+ // and allow fast, lock-less access, guard here.
+ //
+ // Note that we are abusing rtl::Reference here to do acquire/release because,
+ // unlike osl::Guard, it is tolerant of null pointers, and on some code paths, the
+ // SolarMutex does not exist.
+ rtl::Reference<comphelper::SolarMutex> xMutexGuard( comphelper::SolarMutex::get() );
+
+ assert( rEvt.Source == mxConfig );
+ for (auto const& listener : maListeners)
+ {
+ if ( listener->maName == rEvt.PropertyName )
+ {
+ // ignore rEvt.NewValue - in theory it could be stale => not set.
+ css::uno::Any aValue = mxConfig->getPropertyValue( listener->maName );
+ listener->setProperty( aValue );
+ }
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/configurationhelper.cxx b/comphelper/source/misc/configurationhelper.cxx
new file mode 100644
index 000000000..f3853baef
--- /dev/null
+++ b/comphelper/source/misc/configurationhelper.cxx
@@ -0,0 +1,170 @@
+/* -*- 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 <comphelper/configurationhelper.hxx>
+#include <comphelper/sequence.hxx>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/configuration/theDefaultProvider.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/container/XHierarchicalNameAccess.hpp>
+#include <com/sun/star/lang/XSingleServiceFactory.hpp>
+#include <com/sun/star/util/XChangesBatch.hpp>
+
+
+namespace comphelper{
+
+
+css::uno::Reference< css::uno::XInterface > ConfigurationHelper::openConfig(const css::uno::Reference< css::uno::XComponentContext >& rxContext,
+ const OUString& sPackage,
+ EConfigurationModes eMode )
+{
+ css::uno::Reference< css::lang::XMultiServiceFactory > xConfigProvider(
+ css::configuration::theDefaultProvider::get( rxContext ) );
+
+ std::vector< css::uno::Any > lParams;
+ css::beans::PropertyValue aParam ;
+
+ // set root path
+ aParam.Name = "nodepath";
+ aParam.Value <<= sPackage;
+ lParams.emplace_back(aParam);
+
+ // enable all locales mode
+ if (eMode & EConfigurationModes::AllLocales)
+ {
+ aParam.Name = "locale";
+ aParam.Value <<= OUString("*");
+ lParams.emplace_back(aParam);
+ }
+
+ // open it
+ css::uno::Reference< css::uno::XInterface > xCFG;
+
+ bool bReadOnly(eMode & EConfigurationModes::ReadOnly);
+ if (bReadOnly)
+ xCFG = xConfigProvider->createInstanceWithArguments(
+ "com.sun.star.configuration.ConfigurationAccess",
+ comphelper::containerToSequence(lParams));
+ else
+ xCFG = xConfigProvider->createInstanceWithArguments(
+ "com.sun.star.configuration.ConfigurationUpdateAccess",
+ comphelper::containerToSequence(lParams));
+
+ return xCFG;
+}
+
+
+css::uno::Any ConfigurationHelper::readRelativeKey(const css::uno::Reference< css::uno::XInterface >& xCFG ,
+ const OUString& sRelPath,
+ const OUString& sKey )
+{
+ css::uno::Reference< css::container::XHierarchicalNameAccess > xAccess(xCFG, css::uno::UNO_QUERY_THROW);
+
+ css::uno::Reference< css::beans::XPropertySet > xProps;
+ xAccess->getByHierarchicalName(sRelPath) >>= xProps;
+ if (!xProps.is())
+ {
+ throw css::container::NoSuchElementException(
+ "The requested path \"" + sRelPath + "\" does not exist.");
+ }
+ return xProps->getPropertyValue(sKey);
+}
+
+
+void ConfigurationHelper::writeRelativeKey(const css::uno::Reference< css::uno::XInterface >& xCFG ,
+ const OUString& sRelPath,
+ const OUString& sKey ,
+ const css::uno::Any& aValue )
+{
+ css::uno::Reference< css::container::XHierarchicalNameAccess > xAccess(xCFG, css::uno::UNO_QUERY_THROW);
+
+ css::uno::Reference< css::beans::XPropertySet > xProps;
+ xAccess->getByHierarchicalName(sRelPath) >>= xProps;
+ if (!xProps.is())
+ {
+ throw css::container::NoSuchElementException(
+ "The requested path \"" + sRelPath + "\" does not exist.");
+ }
+ xProps->setPropertyValue(sKey, aValue);
+}
+
+
+css::uno::Reference< css::uno::XInterface > ConfigurationHelper::makeSureSetNodeExists(const css::uno::Reference< css::uno::XInterface >& xCFG ,
+ const OUString& sRelPathToSet,
+ const OUString& sSetNode )
+{
+ css::uno::Reference< css::container::XHierarchicalNameAccess > xAccess(xCFG, css::uno::UNO_QUERY_THROW);
+ css::uno::Reference< css::container::XNameAccess > xSet;
+ xAccess->getByHierarchicalName(sRelPathToSet) >>= xSet;
+ if (!xSet.is())
+ {
+ throw css::container::NoSuchElementException(
+ "The requested path \"" + sRelPathToSet + "\" does not exist." );
+ }
+
+ css::uno::Reference< css::uno::XInterface > xNode;
+ if (xSet->hasByName(sSetNode))
+ xSet->getByName(sSetNode) >>= xNode;
+ else
+ {
+ css::uno::Reference< css::lang::XSingleServiceFactory > xNodeFactory(xSet, css::uno::UNO_QUERY_THROW);
+ xNode = xNodeFactory->createInstance();
+ css::uno::Reference< css::container::XNameContainer > xSetReplace(xSet, css::uno::UNO_QUERY_THROW);
+ xSetReplace->insertByName(sSetNode, css::uno::Any(xNode));
+ }
+
+ return xNode;
+}
+
+
+css::uno::Any ConfigurationHelper::readDirectKey(const css::uno::Reference< css::uno::XComponentContext >& rxContext,
+ const OUString& sPackage,
+ const OUString& sRelPath,
+ const OUString& sKey ,
+ EConfigurationModes eMode )
+{
+ css::uno::Reference< css::uno::XInterface > xCFG = ConfigurationHelper::openConfig(rxContext, sPackage, eMode);
+ return ConfigurationHelper::readRelativeKey(xCFG, sRelPath, sKey);
+}
+
+
+void ConfigurationHelper::writeDirectKey(const css::uno::Reference< css::uno::XComponentContext >& rxContext,
+ const OUString& sPackage,
+ const OUString& sRelPath,
+ const OUString& sKey ,
+ const css::uno::Any& aValue ,
+ EConfigurationModes eMode )
+{
+ css::uno::Reference< css::uno::XInterface > xCFG = ConfigurationHelper::openConfig(rxContext, sPackage, eMode);
+ ConfigurationHelper::writeRelativeKey(xCFG, sRelPath, sKey, aValue);
+ ConfigurationHelper::flush(xCFG);
+}
+
+
+void ConfigurationHelper::flush(const css::uno::Reference< css::uno::XInterface >& xCFG)
+{
+ css::uno::Reference< css::util::XChangesBatch > xBatch(xCFG, css::uno::UNO_QUERY_THROW);
+ xBatch->commitChanges();
+}
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/debuggerinfo.cxx b/comphelper/source/misc/debuggerinfo.cxx
new file mode 100644
index 000000000..1e7116a55
--- /dev/null
+++ b/comphelper/source/misc/debuggerinfo.cxx
@@ -0,0 +1,91 @@
+/* -*- 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/.
+ */
+
+#include <comphelper/debuggerinfo.hxx>
+
+#include <cassert>
+#include <cstring>
+#include <ctype.h>
+
+#if defined(_WIN32)
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#elif defined MACOSX
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#elif defined UNX
+#include <unistd.h>
+#include <fcntl.h>
+#endif
+
+namespace comphelper
+{
+#if defined DBG_UTIL
+bool isDebuggerAttached()
+{
+#if defined(_WIN32)
+ return IsDebuggerPresent();
+#elif defined MACOSX
+ // https://developer.apple.com/library/archive/qa/qa1361/_index.html
+ int junk;
+ int mib[4];
+ struct kinfo_proc info;
+ size_t size;
+
+ // Initialize the flags so that, if sysctl fails for some bizarre
+ // reason, we get a predictable result.
+
+ info.kp_proc.p_flag = 0;
+
+ // Initialize mib, which tells sysctl the info we want, in this case
+ // we're looking for information about a specific process ID.
+
+ mib[0] = CTL_KERN;
+ mib[1] = KERN_PROC;
+ mib[2] = KERN_PROC_PID;
+ mib[3] = getpid();
+
+ // Call sysctl.
+
+ size = sizeof(info);
+ junk = sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0);
+ assert(junk == 0);
+
+ // We're being debugged if the P_TRACED flag is set.
+
+ return ((info.kp_proc.p_flag & P_TRACED) != 0);
+#elif defined LINUX
+ char buf[4096];
+ int fd = open("/proc/self/status", O_RDONLY);
+ if (fd < 0)
+ return false;
+ int size = read(fd, buf, sizeof(buf) - 1);
+ close(fd);
+ if (size < 0)
+ return false;
+ assert(size < int(sizeof(buf)) - 1);
+ buf[sizeof(buf) - 1] = '\0';
+ // "TracerPid: <pid>" for pid != 0 means something is attached
+ const char* pos = strstr(buf, "TracerPid:");
+ if (pos == nullptr)
+ return false;
+ pos += strlen("TracerPid:");
+ while (*pos != '\n' && isspace(*pos))
+ ++pos;
+ return *pos != '\n' && *pos != '0';
+#else
+ return false; // feel free to add your platform
+#endif
+}
+#endif
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/dispatchcommand.cxx b/comphelper/source/misc/dispatchcommand.cxx
new file mode 100644
index 000000000..d7b723c72
--- /dev/null
+++ b/comphelper/source/misc/dispatchcommand.cxx
@@ -0,0 +1,81 @@
+/* -*- 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 <comphelper/dispatchcommand.hxx>
+#include <comphelper/processfactory.hxx>
+
+#include <com/sun/star/frame/Desktop.hpp>
+#include <com/sun/star/frame/XDispatch.hpp>
+#include <com/sun/star/frame/XDispatchProvider.hpp>
+#include <com/sun/star/frame/XNotifyingDispatch.hpp>
+#include <com/sun/star/util/URL.hpp>
+#include <com/sun/star/util/URLTransformer.hpp>
+
+using namespace css;
+
+namespace comphelper {
+
+bool dispatchCommand(const OUString& rCommand, const uno::Reference<css::frame::XFrame>& rFrame, const css::uno::Sequence<css::beans::PropertyValue>& rArguments, const uno::Reference<css::frame::XDispatchResultListener>& rListener)
+{
+ uno::Reference<frame::XDispatchProvider> xDispatchProvider(rFrame, uno::UNO_QUERY);
+ if (!xDispatchProvider.is())
+ return false;
+
+ util::URL aCommandURL;
+ aCommandURL.Complete = rCommand;
+ uno::Reference<uno::XComponentContext> xContext = ::comphelper::getProcessComponentContext();
+ uno::Reference<util::XURLTransformer> xParser = util::URLTransformer::create(xContext);
+ xParser->parseStrict(aCommandURL);
+
+ uno::Reference<frame::XDispatch> xDisp = xDispatchProvider->queryDispatch(aCommandURL, OUString(), 0);
+ if (!xDisp.is())
+ return false;
+
+ // And do the work...
+ if (rListener.is())
+ {
+ uno::Reference<frame::XNotifyingDispatch> xNotifyingDisp(xDisp, uno::UNO_QUERY);
+ if (xNotifyingDisp.is())
+ {
+ xNotifyingDisp->dispatchWithNotification(aCommandURL, rArguments, rListener);
+ return true;
+ }
+ }
+
+ xDisp->dispatch(aCommandURL, rArguments);
+
+ return true;
+}
+
+bool dispatchCommand(const OUString& rCommand, const css::uno::Sequence<css::beans::PropertyValue>& rArguments, const uno::Reference<css::frame::XDispatchResultListener>& rListener)
+{
+ // Target where we will execute the .uno: command
+ uno::Reference<uno::XComponentContext> xContext = ::comphelper::getProcessComponentContext();
+ uno::Reference<frame::XDesktop2> xDesktop = frame::Desktop::create(xContext);
+
+ uno::Reference<frame::XFrame> xFrame(xDesktop->getActiveFrame());
+ if (!xFrame.is())
+ xFrame = xDesktop;
+
+ return dispatchCommand(rCommand, xFrame, rArguments, rListener);
+}
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/docpasswordhelper.cxx b/comphelper/source/misc/docpasswordhelper.cxx
new file mode 100644
index 000000000..5edb3949c
--- /dev/null
+++ b/comphelper/source/misc/docpasswordhelper.cxx
@@ -0,0 +1,741 @@
+/* -*- 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 <config_gpgme.h>
+
+#include <algorithm>
+#include <string_view>
+
+#include <comphelper/docpasswordhelper.hxx>
+#include <comphelper/propertyvalue.hxx>
+#include <comphelper/storagehelper.hxx>
+#include <comphelper/hash.hxx>
+#include <comphelper/base64.hxx>
+#include <comphelper/sequence.hxx>
+#include <com/sun/star/beans/NamedValue.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/task/XInteractionHandler.hpp>
+
+#include <osl/diagnose.h>
+#include <sal/log.hxx>
+#include <rtl/digest.h>
+#include <rtl/random.h>
+#include <string.h>
+
+#if HAVE_FEATURE_GPGME
+# include <context.h>
+# include <data.h>
+# include <decryptionresult.h>
+#endif
+
+using ::com::sun::star::uno::Sequence;
+using ::com::sun::star::uno::Exception;
+using ::com::sun::star::uno::Reference;
+using ::com::sun::star::task::PasswordRequestMode;
+using ::com::sun::star::task::PasswordRequestMode_PASSWORD_ENTER;
+using ::com::sun::star::task::PasswordRequestMode_PASSWORD_REENTER;
+using ::com::sun::star::task::XInteractionHandler;
+using ::com::sun::star::task::XInteractionRequest;
+
+using namespace ::com::sun::star;
+
+namespace comphelper {
+
+
+static uno::Sequence< sal_Int8 > GeneratePBKDF2Hash( std::u16string_view aPassword, const uno::Sequence< sal_Int8 >& aSalt, sal_Int32 nCount, sal_Int32 nHashLength )
+{
+ uno::Sequence< sal_Int8 > aResult;
+
+ if ( !aPassword.empty() && aSalt.hasElements() && nCount && nHashLength )
+ {
+ OString aBytePass = OUStringToOString( aPassword, RTL_TEXTENCODING_UTF8 );
+ // FIXME this is subject to the SHA1-bug tdf#114939 - see also
+ // RequestPassword() in filedlghelper.cxx
+ aResult.realloc( 16 );
+ rtl_digest_PBKDF2( reinterpret_cast < sal_uInt8 * > ( aResult.getArray() ),
+ aResult.getLength(),
+ reinterpret_cast < const sal_uInt8 * > ( aBytePass.getStr() ),
+ aBytePass.getLength(),
+ reinterpret_cast < const sal_uInt8 * > ( aSalt.getConstArray() ),
+ aSalt.getLength(),
+ nCount );
+ }
+
+ return aResult;
+}
+
+
+IDocPasswordVerifier::~IDocPasswordVerifier()
+{
+}
+
+
+uno::Sequence< beans::PropertyValue > DocPasswordHelper::GenerateNewModifyPasswordInfo( std::u16string_view aPassword )
+{
+ uno::Sequence< beans::PropertyValue > aResult;
+
+ uno::Sequence< sal_Int8 > aSalt = GenerateRandomByteSequence( 16 );
+ sal_Int32 const nPBKDF2IterationCount = 100000;
+
+ uno::Sequence< sal_Int8 > aNewHash = GeneratePBKDF2Hash(aPassword, aSalt, nPBKDF2IterationCount, 16);
+ if ( aNewHash.hasElements() )
+ {
+ aResult = { comphelper::makePropertyValue("algorithm-name", OUString( "PBKDF2" )),
+ comphelper::makePropertyValue("salt", aSalt),
+ comphelper::makePropertyValue("iteration-count", nPBKDF2IterationCount),
+ comphelper::makePropertyValue("hash", aNewHash) };
+ }
+
+ return aResult;
+}
+
+
+uno::Sequence<beans::PropertyValue>
+DocPasswordHelper::GenerateNewModifyPasswordInfoOOXML(std::u16string_view aPassword)
+{
+ uno::Sequence<beans::PropertyValue> aResult;
+
+ if (!aPassword.empty())
+ {
+ uno::Sequence<sal_Int8> aSalt = GenerateRandomByteSequence(16);
+ OUStringBuffer aBuffer(22);
+ comphelper::Base64::encode(aBuffer, aSalt);
+ OUString sSalt = aBuffer.makeStringAndClear();
+
+ sal_Int32 const nIterationCount = 100000;
+ OUString sAlgorithm("SHA-512");
+
+ const OUString sHash(GetOoxHashAsBase64(OUString(aPassword), sSalt, nIterationCount,
+ comphelper::Hash::IterCount::APPEND, sAlgorithm));
+
+ if (!sHash.isEmpty())
+ {
+ aResult = { comphelper::makePropertyValue("algorithm-name", sAlgorithm),
+ comphelper::makePropertyValue("salt", sSalt),
+ comphelper::makePropertyValue("iteration-count", nIterationCount),
+ comphelper::makePropertyValue("hash", sHash) };
+ }
+ }
+
+ return aResult;
+}
+
+
+uno::Sequence< beans::PropertyValue > DocPasswordHelper::ConvertPasswordInfo( const uno::Sequence< beans::PropertyValue >& aInfo )
+{
+ uno::Sequence< beans::PropertyValue > aResult;
+ OUString sAlgorithm, sHash, sSalt, sCount;
+ sal_Int32 nAlgorithm = 0;
+
+ for ( const auto & prop : aInfo )
+ {
+ if ( prop.Name == "cryptAlgorithmSid" )
+ {
+ prop.Value >>= sAlgorithm;
+ nAlgorithm = sAlgorithm.toInt32();
+ }
+ else if ( prop.Name == "salt" )
+ prop.Value >>= sSalt;
+ else if ( prop.Name == "cryptSpinCount" )
+ prop.Value >>= sCount;
+ else if ( prop.Name == "hash" )
+ prop.Value >>= sHash;
+ }
+
+ if (nAlgorithm == 1)
+ sAlgorithm = "MD2";
+ else if (nAlgorithm == 2)
+ sAlgorithm = "MD4";
+ else if (nAlgorithm == 3)
+ sAlgorithm = "MD5";
+ else if (nAlgorithm == 4)
+ sAlgorithm = "SHA-1";
+ else if (nAlgorithm == 5)
+ sAlgorithm = "MAC";
+ else if (nAlgorithm == 6)
+ sAlgorithm = "RIPEMD";
+ else if (nAlgorithm == 7)
+ sAlgorithm = "RIPEMD-160";
+ else if (nAlgorithm == 9)
+ sAlgorithm = "HMAC";
+ else if (nAlgorithm == 12)
+ sAlgorithm = "SHA-256";
+ else if (nAlgorithm == 13)
+ sAlgorithm = "SHA-384";
+ else if (nAlgorithm == 14)
+ sAlgorithm = "SHA-512";
+
+ if ( !sCount.isEmpty() )
+ {
+ sal_Int32 nCount = sCount.toInt32();
+ aResult = { comphelper::makePropertyValue("algorithm-name", sAlgorithm),
+ comphelper::makePropertyValue("salt", sSalt),
+ comphelper::makePropertyValue("iteration-count", nCount),
+ comphelper::makePropertyValue("hash", sHash) };
+ }
+
+ return aResult;
+}
+
+
+bool DocPasswordHelper::IsModifyPasswordCorrect( std::u16string_view aPassword, const uno::Sequence< beans::PropertyValue >& aInfo )
+{
+ bool bResult = false;
+ if ( !aPassword.empty() && aInfo.hasElements() )
+ {
+ OUString sAlgorithm;
+ uno::Any aSalt, aHash;
+ sal_Int32 nCount = 0;
+
+ for ( const auto & prop : aInfo )
+ {
+ if ( prop.Name == "algorithm-name" )
+ prop.Value >>= sAlgorithm;
+ else if ( prop.Name == "salt" )
+ aSalt = prop.Value;
+ else if ( prop.Name == "iteration-count" )
+ prop.Value >>= nCount;
+ else if ( prop.Name == "hash" )
+ aHash = prop.Value;
+ }
+
+ if ( sAlgorithm == "PBKDF2" )
+ {
+ uno::Sequence<sal_Int8> aIntSalt, aIntHash;
+ aSalt >>= aIntSalt;
+ aHash >>= aIntHash;
+ if (aIntSalt.hasElements() && nCount > 0 && aIntHash.hasElements())
+ {
+ uno::Sequence<sal_Int8> aNewHash
+ = GeneratePBKDF2Hash(aPassword, aIntSalt, nCount, aIntHash.getLength());
+ for (sal_Int32 nInd = 0; nInd < aNewHash.getLength() && nInd < aIntHash.getLength()
+ && aNewHash[nInd] == aIntHash[nInd];
+ nInd++)
+ {
+ if (nInd == aNewHash.getLength() - 1 && nInd == aIntHash.getLength() - 1)
+ bResult = true;
+ }
+ }
+ }
+ else if (nCount > 0)
+ {
+ OUString sSalt, sHash;
+ aSalt >>= sSalt;
+ aHash >>= sHash;
+ if (!sSalt.isEmpty() && !sHash.isEmpty())
+ {
+ const OUString aNewHash(GetOoxHashAsBase64(OUString(aPassword), sSalt, nCount,
+ comphelper::Hash::IterCount::APPEND,
+ sAlgorithm));
+ if (!aNewHash.isEmpty())
+ bResult = aNewHash == sHash;
+ }
+ }
+ }
+
+ return bResult;
+}
+
+
+sal_uInt32 DocPasswordHelper::GetWordHashAsUINT32(
+ std::u16string_view aUString )
+{
+ static const sal_uInt16 pInitialCode[] = {
+ 0xE1F0, // 1
+ 0x1D0F, // 2
+ 0xCC9C, // 3
+ 0x84C0, // 4
+ 0x110C, // 5
+ 0x0E10, // 6
+ 0xF1CE, // 7
+ 0x313E, // 8
+ 0x1872, // 9
+ 0xE139, // 10
+ 0xD40F, // 11
+ 0x84F9, // 12
+ 0x280C, // 13
+ 0xA96A, // 14
+ 0x4EC3 // 15
+ };
+
+ static const sal_uInt16 pEncryptionMatrix[15][7] = {
+ { 0xAEFC, 0x4DD9, 0x9BB2, 0x2745, 0x4E8A, 0x9D14, 0x2A09}, // last-14
+ { 0x7B61, 0xF6C2, 0xFDA5, 0xEB6B, 0xC6F7, 0x9DCF, 0x2BBF}, // last-13
+ { 0x4563, 0x8AC6, 0x05AD, 0x0B5A, 0x16B4, 0x2D68, 0x5AD0}, // last-12
+ { 0x0375, 0x06EA, 0x0DD4, 0x1BA8, 0x3750, 0x6EA0, 0xDD40}, // last-11
+ { 0xD849, 0xA0B3, 0x5147, 0xA28E, 0x553D, 0xAA7A, 0x44D5}, // last-10
+ { 0x6F45, 0xDE8A, 0xAD35, 0x4A4B, 0x9496, 0x390D, 0x721A}, // last-9
+ { 0xEB23, 0xC667, 0x9CEF, 0x29FF, 0x53FE, 0xA7FC, 0x5FD9}, // last-8
+ { 0x47D3, 0x8FA6, 0x8FA6, 0x1EDA, 0x3DB4, 0x7B68, 0xF6D0}, // last-7
+ { 0xB861, 0x60E3, 0xC1C6, 0x93AD, 0x377B, 0x6EF6, 0xDDEC}, // last-6
+ { 0x45A0, 0x8B40, 0x06A1, 0x0D42, 0x1A84, 0x3508, 0x6A10}, // last-5
+ { 0xAA51, 0x4483, 0x8906, 0x022D, 0x045A, 0x08B4, 0x1168}, // last-4
+ { 0x76B4, 0xED68, 0xCAF1, 0x85C3, 0x1BA7, 0x374E, 0x6E9C}, // last-3
+ { 0x3730, 0x6E60, 0xDCC0, 0xA9A1, 0x4363, 0x86C6, 0x1DAD}, // last-2
+ { 0x3331, 0x6662, 0xCCC4, 0x89A9, 0x0373, 0x06E6, 0x0DCC}, // last-1
+ { 0x1021, 0x2042, 0x4084, 0x8108, 0x1231, 0x2462, 0x48C4} // last
+ };
+
+ sal_uInt32 nResult = 0;
+ size_t nLen = aUString.size();
+
+ if ( nLen )
+ {
+ if ( nLen > 15 )
+ nLen = 15;
+
+ sal_uInt16 nHighResult = pInitialCode[nLen - 1];
+ sal_uInt16 nLowResult = 0;
+
+ for ( size_t nInd = 0; nInd < nLen; nInd++ )
+ {
+ // NO Encoding during conversion!
+ // The specification says that the low byte should be used in case it is not NULL
+ char nHighChar = static_cast<char>( aUString[nInd] >> 8 );
+ char nLowChar = static_cast<char>( aUString[nInd] & 0xFF );
+ char nChar = nLowChar ? nLowChar : nHighChar;
+
+ for ( int nMatrixInd = 0; nMatrixInd < 7; ++nMatrixInd )
+ {
+ if ( ( nChar & ( 1 << nMatrixInd ) ) != 0 )
+ nHighResult = nHighResult ^ pEncryptionMatrix[15 - nLen + nInd][nMatrixInd];
+ }
+
+ nLowResult = ( ( ( nLowResult >> 14 ) & 0x0001 ) | ( ( nLowResult << 1 ) & 0x7FFF ) ) ^ nChar;
+ }
+
+ nLowResult = static_cast<sal_uInt16>( ( ( ( nLowResult >> 14 ) & 0x001 ) | ( ( nLowResult << 1 ) & 0x7FF ) ) ^ nLen ^ 0xCE4B );
+
+ nResult = ( nHighResult << 16 ) | nLowResult;
+ }
+
+ return nResult;
+}
+
+
+sal_uInt16 DocPasswordHelper::GetXLHashAsUINT16(
+ std::u16string_view aUString,
+ rtl_TextEncoding nEnc )
+{
+ sal_uInt16 nResult = 0;
+
+ OString aString = OUStringToOString( aUString, nEnc );
+
+ if ( !aString.isEmpty() && aString.getLength() <= SAL_MAX_UINT16 )
+ {
+ for ( sal_Int32 nInd = aString.getLength() - 1; nInd >= 0; nInd-- )
+ {
+ nResult = ( ( nResult >> 14 ) & 0x01 ) | ( ( nResult << 1 ) & 0x7FFF );
+ nResult ^= aString[nInd];
+ }
+
+ nResult = ( ( nResult >> 14 ) & 0x01 ) | ( ( nResult << 1 ) & 0x7FFF );
+ nResult ^= ( 0x8000 | ( 'N' << 8 ) | 'K' );
+ nResult ^= aString.getLength();
+ }
+
+ return nResult;
+}
+
+
+Sequence< sal_Int8 > DocPasswordHelper::GetXLHashAsSequence(
+ std::u16string_view aUString )
+{
+ sal_uInt16 nHash = GetXLHashAsUINT16( aUString );
+ return {sal_Int8(nHash >> 8), sal_Int8(nHash & 0xFF)};
+}
+
+
+std::vector<unsigned char> DocPasswordHelper::GetOoxHashAsVector(
+ const OUString& rPassword,
+ const std::vector<unsigned char>& rSaltValue,
+ sal_uInt32 nSpinCount,
+ comphelper::Hash::IterCount eIterCount,
+ std::u16string_view rAlgorithmName)
+{
+ comphelper::HashType eType;
+ if (rAlgorithmName == u"SHA-512" || rAlgorithmName == u"SHA512")
+ eType = comphelper::HashType::SHA512;
+ else if (rAlgorithmName == u"SHA-256" || rAlgorithmName == u"SHA256")
+ eType = comphelper::HashType::SHA256;
+ else if (rAlgorithmName == u"SHA-1" || rAlgorithmName == u"SHA1") // "SHA1" might be in the wild
+ eType = comphelper::HashType::SHA1;
+ else if (rAlgorithmName == u"MD5")
+ eType = comphelper::HashType::MD5;
+ else
+ return std::vector<unsigned char>();
+
+ return comphelper::Hash::calculateHash( rPassword, rSaltValue, nSpinCount, eIterCount, eType);
+}
+
+
+css::uno::Sequence<sal_Int8> DocPasswordHelper::GetOoxHashAsSequence(
+ const OUString& rPassword,
+ std::u16string_view rSaltValue,
+ sal_uInt32 nSpinCount,
+ comphelper::Hash::IterCount eIterCount,
+ std::u16string_view rAlgorithmName)
+{
+ std::vector<unsigned char> aSaltVec;
+ if (!rSaltValue.empty())
+ {
+ css::uno::Sequence<sal_Int8> aSaltSeq;
+ comphelper::Base64::decode( aSaltSeq, rSaltValue);
+ aSaltVec = comphelper::sequenceToContainer<std::vector<unsigned char>>( aSaltSeq);
+ }
+
+ std::vector<unsigned char> hash( GetOoxHashAsVector( rPassword, aSaltVec, nSpinCount, eIterCount, rAlgorithmName));
+
+ return comphelper::containerToSequence<sal_Int8>( hash);
+}
+
+OUString DocPasswordHelper::GetOoxHashAsBase64(
+ const OUString& rPassword,
+ std::u16string_view rSaltValue,
+ sal_uInt32 nSpinCount,
+ comphelper::Hash::IterCount eIterCount,
+ std::u16string_view rAlgorithmName)
+{
+ css::uno::Sequence<sal_Int8> aSeq( GetOoxHashAsSequence( rPassword, rSaltValue, nSpinCount,
+ eIterCount, rAlgorithmName));
+
+ OUStringBuffer aBuf((aSeq.getLength()+2)/3*4);
+ comphelper::Base64::encode( aBuf, aSeq);
+ return aBuf.makeStringAndClear();
+}
+
+
+/*static*/ uno::Sequence< sal_Int8 > DocPasswordHelper::GenerateRandomByteSequence( sal_Int32 nLength )
+{
+ uno::Sequence< sal_Int8 > aResult( nLength );
+
+ rtlRandomPool aRandomPool = rtl_random_createPool ();
+ rtl_random_getBytes ( aRandomPool, aResult.getArray(), nLength );
+ rtl_random_destroyPool ( aRandomPool );
+
+ return aResult;
+}
+
+
+/*static*/ uno::Sequence< sal_Int8 > DocPasswordHelper::GenerateStd97Key( std::u16string_view aPassword, const uno::Sequence< sal_Int8 >& aDocId )
+{
+ uno::Sequence< sal_Int8 > aResultKey;
+ if ( !aPassword.empty() && aDocId.getLength() == 16 )
+ {
+ sal_uInt16 pPassData[16] = {};
+
+ sal_Int32 nPassLen = std::min< sal_Int32 >( aPassword.size(), 15 );
+ memcpy( pPassData, aPassword.data(), nPassLen * sizeof(pPassData[0]) );
+
+ aResultKey = GenerateStd97Key( pPassData, aDocId );
+ }
+
+ return aResultKey;
+}
+
+
+/*static*/ uno::Sequence< sal_Int8 > DocPasswordHelper::GenerateStd97Key( const sal_uInt16 pPassData[16], const uno::Sequence< sal_Int8 >& aDocId )
+{
+ uno::Sequence< sal_Int8 > aResultKey;
+
+ if ( aDocId.getLength() == 16 )
+ aResultKey = GenerateStd97Key(pPassData, reinterpret_cast<const sal_uInt8*>(aDocId.getConstArray()));
+
+ return aResultKey;
+}
+
+
+/*static*/ uno::Sequence< sal_Int8 > DocPasswordHelper::GenerateStd97Key( const sal_uInt16 pPassData[16], const sal_uInt8 pDocId[16] )
+{
+ uno::Sequence< sal_Int8 > aResultKey;
+ if ( pPassData[0] )
+ {
+ sal_uInt8 pKeyData[64] = {};
+
+ sal_Int32 nInd = 0;
+
+ // Fill PassData into KeyData.
+ for ( nInd = 0; nInd < 16 && pPassData[nInd]; nInd++)
+ {
+ pKeyData[2*nInd] = sal::static_int_cast< sal_uInt8 >( (pPassData[nInd] >> 0) & 0xff );
+ pKeyData[2*nInd + 1] = sal::static_int_cast< sal_uInt8 >( (pPassData[nInd] >> 8) & 0xff );
+ }
+
+ pKeyData[2*nInd] = 0x80;
+ pKeyData[56] = sal::static_int_cast< sal_uInt8 >( nInd << 4 );
+
+ // Fill raw digest of KeyData into KeyData.
+ rtlDigest hDigest = rtl_digest_create ( rtl_Digest_AlgorithmMD5 );
+ (void)rtl_digest_updateMD5 (
+ hDigest, pKeyData, sizeof(pKeyData));
+ (void)rtl_digest_rawMD5 (
+ hDigest, pKeyData, RTL_DIGEST_LENGTH_MD5);
+
+ // Update digest with KeyData and Unique.
+ for ( nInd = 0; nInd < 16; nInd++ )
+ {
+ rtl_digest_updateMD5( hDigest, pKeyData, 5 );
+ rtl_digest_updateMD5( hDigest, pDocId, 16 );
+ }
+
+ // Update digest with padding.
+ pKeyData[16] = 0x80;
+ memset( pKeyData + 17, 0, sizeof(pKeyData) - 17 );
+ pKeyData[56] = 0x80;
+ pKeyData[57] = 0x0a;
+
+ rtl_digest_updateMD5( hDigest, &(pKeyData[16]), sizeof(pKeyData) - 16 );
+
+ // Fill raw digest of above updates
+ aResultKey.realloc( RTL_DIGEST_LENGTH_MD5 );
+ rtl_digest_rawMD5 ( hDigest, reinterpret_cast<sal_uInt8*>(aResultKey.getArray()), aResultKey.getLength() );
+
+ // Erase KeyData array and leave.
+ rtl_secureZeroMemory (pKeyData, sizeof(pKeyData));
+
+ rtl_digest_destroy(hDigest);
+ }
+
+ return aResultKey;
+}
+
+
+/*static*/ css::uno::Sequence< css::beans::NamedValue > DocPasswordHelper::requestAndVerifyDocPassword(
+ IDocPasswordVerifier& rVerifier,
+ const css::uno::Sequence< css::beans::NamedValue >& rMediaEncData,
+ const OUString& rMediaPassword,
+ const Reference< XInteractionHandler >& rxInteractHandler,
+ const OUString& rDocumentUrl,
+ DocPasswordRequestType eRequestType,
+ const std::vector< OUString >* pDefaultPasswords,
+ bool* pbIsDefaultPassword )
+{
+ css::uno::Sequence< css::beans::NamedValue > aEncData;
+ OUString aPassword;
+ DocPasswordVerifierResult eResult = DocPasswordVerifierResult::WrongPassword;
+
+ sal_Int32 nMediaEncDataCount = rMediaEncData.getLength();
+
+ // tdf#93389: if the document is being restored from autorecovery, we need to add encryption
+ // data also for real document type.
+ // TODO: get real filter name here (from CheckPasswd_Impl), to only add necessary data
+ bool bForSalvage = false;
+ if (nMediaEncDataCount)
+ {
+ for (auto& val : rMediaEncData)
+ {
+ if (val.Name == "ForSalvage")
+ {
+ --nMediaEncDataCount; // don't consider this element below
+ val.Value >>= bForSalvage;
+ break;
+ }
+ }
+ }
+
+ // first, try provided default passwords
+ if( pbIsDefaultPassword )
+ *pbIsDefaultPassword = false;
+ if( pDefaultPasswords )
+ {
+ for( const auto& rPassword : *pDefaultPasswords )
+ {
+ OSL_ENSURE( !rPassword.isEmpty(), "DocPasswordHelper::requestAndVerifyDocPassword - unexpected empty default password" );
+ if( !rPassword.isEmpty() )
+ {
+ eResult = rVerifier.verifyPassword( rPassword, aEncData );
+ if (eResult == DocPasswordVerifierResult::OK)
+ {
+ aPassword = rPassword;
+ if (pbIsDefaultPassword)
+ *pbIsDefaultPassword = true;
+ }
+ if( eResult != DocPasswordVerifierResult::WrongPassword )
+ break;
+ }
+ }
+ }
+
+ // try media encryption data (skip, if result is OK or ABORT)
+ if( eResult == DocPasswordVerifierResult::WrongPassword )
+ {
+ if (nMediaEncDataCount)
+ {
+ eResult = rVerifier.verifyEncryptionData( rMediaEncData );
+ if( eResult == DocPasswordVerifierResult::OK )
+ aEncData = rMediaEncData;
+ }
+ }
+
+ // try media password (skip, if result is OK or ABORT)
+ if( eResult == DocPasswordVerifierResult::WrongPassword )
+ {
+ if( !rMediaPassword.isEmpty() )
+ {
+ eResult = rVerifier.verifyPassword( rMediaPassword, aEncData );
+ if (eResult == DocPasswordVerifierResult::OK)
+ aPassword = rMediaPassword;
+ }
+ }
+
+ // request a password (skip, if result is OK or ABORT)
+ if( (eResult == DocPasswordVerifierResult::WrongPassword) && rxInteractHandler.is() ) try
+ {
+ PasswordRequestMode eRequestMode = PasswordRequestMode_PASSWORD_ENTER;
+ while( eResult == DocPasswordVerifierResult::WrongPassword )
+ {
+ rtl::Reference<DocPasswordRequest> pRequest = new DocPasswordRequest( eRequestType, eRequestMode, rDocumentUrl );
+ rxInteractHandler->handle( pRequest );
+ if( pRequest->isPassword() )
+ {
+ if( !pRequest->getPassword().isEmpty() )
+ eResult = rVerifier.verifyPassword( pRequest->getPassword(), aEncData );
+ if (eResult == DocPasswordVerifierResult::OK)
+ aPassword = pRequest->getPassword();
+ }
+ else
+ {
+ eResult = DocPasswordVerifierResult::Abort;
+ }
+ eRequestMode = PasswordRequestMode_PASSWORD_REENTER;
+ }
+ }
+ catch( Exception& )
+ {
+ }
+
+ if (eResult == DocPasswordVerifierResult::OK && !aPassword.isEmpty())
+ {
+ if (std::find_if(std::cbegin(aEncData), std::cend(aEncData),
+ [](const css::beans::NamedValue& val) {
+ return val.Name == PACKAGE_ENCRYPTIONDATA_SHA256UTF8;
+ })
+ == std::cend(aEncData))
+ {
+ // tdf#118639: We need ODF encryption data for autorecovery, where password
+ // will already be unavailable, so generate and append it here
+ aEncData = comphelper::concatSequences(
+ aEncData, OStorageHelper::CreatePackageEncryptionData(aPassword));
+ }
+
+ if (bForSalvage)
+ {
+ // TODO: add individual methods for different target filter, and only call what's needed
+
+ // 1. Prepare binary MS formats encryption data
+ auto aUniqueID = GenerateRandomByteSequence(16);
+ auto aEnc97Key = GenerateStd97Key(aPassword, aUniqueID);
+ // 2. Add MS binary and OOXML encryption data to result
+ aEncData = comphelper::concatSequences(
+ aEncData, std::initializer_list<beans::NamedValue>{
+ { "STD97EncryptionKey", css::uno::Any(aEnc97Key) },
+ { "STD97UniqueID", css::uno::Any(aUniqueID) },
+ { "OOXPassword", css::uno::Any(aPassword) },
+ });
+ }
+ }
+
+ return (eResult == DocPasswordVerifierResult::OK) ? aEncData : uno::Sequence< beans::NamedValue >();
+}
+
+/*static*/ uno::Sequence< css::beans::NamedValue >
+ DocPasswordHelper::decryptGpgSession(
+ const uno::Sequence< uno::Sequence< beans::NamedValue > >& rGpgProperties )
+{
+#if HAVE_FEATURE_GPGME
+ if ( !rGpgProperties.hasElements() )
+ return uno::Sequence< beans::NamedValue >();
+
+ uno::Sequence< beans::NamedValue > aEncryptionData;
+ std::unique_ptr<GpgME::Context> ctx;
+ GpgME::initializeLibrary();
+ GpgME::Error err = GpgME::checkEngine(GpgME::OpenPGP);
+ if (err)
+ throw uno::RuntimeException("The GpgME library failed to initialize for the OpenPGP protocol.");
+
+ ctx.reset( GpgME::Context::createForProtocol(GpgME::OpenPGP) );
+ if (ctx == nullptr)
+ throw uno::RuntimeException("The GpgME library failed to initialize for the OpenPGP protocol.");
+ ctx->setArmor(false);
+
+ const uno::Sequence < beans::NamedValue > *pSequence = rGpgProperties.getConstArray();
+ const sal_Int32 nLength = rGpgProperties.getLength();
+ for ( sal_Int32 i = 0; i < nLength ; i++, pSequence++ )
+ {
+ const beans::NamedValue *pValues = pSequence->getConstArray();
+ if ( pSequence->getLength() == 3 )
+ {
+ // take CipherValue and try to decrypt that - stop after
+ // the first successful decryption
+
+ // ctx is setup now, let's decrypt the lot!
+ uno::Sequence < sal_Int8 > aVector;
+ pValues[2].Value >>= aVector;
+
+ GpgME::Data cipher(
+ reinterpret_cast<const char*>(aVector.getConstArray()),
+ size_t(aVector.getLength()), false);
+ GpgME::Data plain;
+
+ GpgME::DecryptionResult crypt_res = ctx->decrypt(
+ cipher, plain);
+
+ // NO_SECKEY -> skip
+ // BAD_PASSPHRASE -> retry?
+
+ off_t result = plain.seek(0,SEEK_SET);
+ (void) result;
+ assert(result == 0);
+ int len=0, curr=0; char buf;
+ while( (curr=plain.read(&buf, 1)) )
+ len += curr;
+
+ if(crypt_res.error() || !len)
+ continue; // can't use this key, take next one
+
+ uno::Sequence < sal_Int8 > aKeyValue(len);
+ result = plain.seek(0,SEEK_SET);
+ assert(result == 0);
+ if( plain.read(aKeyValue.getArray(), len) != len )
+ throw uno::RuntimeException("The GpgME library failed to read the encrypted value.");
+
+ SAL_INFO("comphelper.crypto", "Extracted gpg session key of length: " << len);
+
+ aEncryptionData = { { PACKAGE_ENCRYPTIONDATA_SHA256UTF8, uno::Any(aKeyValue) } };
+ break;
+ }
+ }
+
+ if ( aEncryptionData.hasElements() )
+ {
+ uno::Sequence< beans::NamedValue > aContainer{
+ { "GpgInfos", uno::Any(rGpgProperties) }, { "EncryptionKey", uno::Any(aEncryptionData) }
+ };
+
+ return aContainer;
+ }
+#else
+ (void)rGpgProperties;
+#endif
+ return uno::Sequence< beans::NamedValue >();
+}
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/docpasswordrequest.cxx b/comphelper/source/misc/docpasswordrequest.cxx
new file mode 100644
index 000000000..6f644336e
--- /dev/null
+++ b/comphelper/source/misc/docpasswordrequest.cxx
@@ -0,0 +1,179 @@
+/* -*- 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 <comphelper/docpasswordrequest.hxx>
+#include <com/sun/star/task/DocumentMSPasswordRequest2.hpp>
+#include <com/sun/star/task/DocumentPasswordRequest2.hpp>
+#include <com/sun/star/task/PasswordRequest.hpp>
+#include <com/sun/star/task/XInteractionAbort.hpp>
+#include <com/sun/star/task/XInteractionPassword2.hpp>
+#include <cppuhelper/implbase.hxx>
+
+using ::com::sun::star::uno::Any;
+using ::com::sun::star::uno::Reference;
+using ::com::sun::star::uno::Sequence;
+using ::com::sun::star::uno::XInterface;
+using ::com::sun::star::task::InteractionClassification_QUERY;
+using ::com::sun::star::task::DocumentMSPasswordRequest2;
+using ::com::sun::star::task::DocumentPasswordRequest2;
+using ::com::sun::star::task::PasswordRequest;
+using ::com::sun::star::task::PasswordRequestMode;
+using ::com::sun::star::task::XInteractionAbort;
+using ::com::sun::star::task::XInteractionContinuation;
+using ::com::sun::star::task::XInteractionPassword2;
+
+namespace comphelper {
+
+namespace {
+
+class AbortContinuation : public ::cppu::WeakImplHelper< XInteractionAbort >
+{
+public:
+ virtual void SAL_CALL select() override {}
+};
+
+}
+
+class PasswordContinuation : public ::cppu::WeakImplHelper< XInteractionPassword2 >
+{
+public:
+ explicit PasswordContinuation() : mbReadOnly( false ), mbSelected( false ) {}
+
+ bool isSelected() const { return mbSelected; }
+
+ virtual void SAL_CALL select() override { mbSelected = true; }
+
+ virtual void SAL_CALL setPassword( const OUString& rPass ) override { maPassword = rPass; }
+ virtual OUString SAL_CALL getPassword() override { return maPassword; }
+
+ virtual void SAL_CALL setPasswordToModify( const OUString& rPass ) override { maModifyPassword = rPass; }
+ virtual OUString SAL_CALL getPasswordToModify() override { return maModifyPassword; }
+
+ virtual void SAL_CALL setRecommendReadOnly( sal_Bool bReadOnly ) override { mbReadOnly = bReadOnly; }
+ virtual sal_Bool SAL_CALL getRecommendReadOnly() override { return mbReadOnly; }
+
+private:
+ OUString maPassword;
+ OUString maModifyPassword;
+ bool mbReadOnly;
+ bool mbSelected;
+};
+
+
+SimplePasswordRequest::SimplePasswordRequest()
+{
+ PasswordRequest aRequest( OUString(), Reference< XInterface >(),
+ InteractionClassification_QUERY, css::task::PasswordRequestMode_PASSWORD_CREATE );
+ maRequest <<= aRequest;
+
+ mxAbort = new AbortContinuation;
+ mxPassword = new PasswordContinuation;
+}
+
+SimplePasswordRequest::~SimplePasswordRequest()
+{
+}
+
+bool SimplePasswordRequest::isPassword() const
+{
+ return mxPassword->isSelected();
+}
+
+OUString SimplePasswordRequest::getPassword() const
+{
+ return mxPassword->getPassword();
+}
+
+Any SAL_CALL SimplePasswordRequest::getRequest()
+{
+ return maRequest;
+}
+
+Sequence< Reference< XInteractionContinuation > > SAL_CALL SimplePasswordRequest::getContinuations()
+{
+ return { mxAbort, mxPassword };
+}
+
+
+DocPasswordRequest::DocPasswordRequest( DocPasswordRequestType eType,
+ PasswordRequestMode eMode, const OUString& rDocumentUrl, bool bPasswordToModify )
+{
+ switch( eType )
+ {
+ case DocPasswordRequestType::Standard:
+ {
+ DocumentPasswordRequest2 aRequest( OUString(), Reference< XInterface >(),
+ InteractionClassification_QUERY, eMode, rDocumentUrl, bPasswordToModify );
+ maRequest <<= aRequest;
+ }
+ break;
+ case DocPasswordRequestType::MS:
+ {
+ DocumentMSPasswordRequest2 aRequest( OUString(), Reference< XInterface >(),
+ InteractionClassification_QUERY, eMode, rDocumentUrl, bPasswordToModify );
+ maRequest <<= aRequest;
+ }
+ break;
+ /* no 'default', so compilers will complain about missing
+ implementation of a new enum value. */
+ }
+
+ mxAbort = new AbortContinuation;
+ mxPassword = new PasswordContinuation;
+}
+
+DocPasswordRequest::~DocPasswordRequest()
+{
+}
+
+bool DocPasswordRequest::isPassword() const
+{
+ return mxPassword->isSelected();
+}
+
+OUString DocPasswordRequest::getPassword() const
+{
+ return mxPassword->getPassword();
+}
+
+OUString DocPasswordRequest::getPasswordToModify() const
+{
+ return mxPassword->getPasswordToModify();
+}
+
+bool DocPasswordRequest::getRecommendReadOnly() const
+{
+ return mxPassword->getRecommendReadOnly();
+}
+
+Any SAL_CALL DocPasswordRequest::getRequest()
+{
+ return maRequest;
+}
+
+Sequence< Reference< XInteractionContinuation > > SAL_CALL DocPasswordRequest::getContinuations()
+{
+ return { mxAbort, mxPassword };
+}
+
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/documentinfo.cxx b/comphelper/source/misc/documentinfo.cxx
new file mode 100644
index 000000000..21425524e
--- /dev/null
+++ b/comphelper/source/misc/documentinfo.cxx
@@ -0,0 +1,177 @@
+/* -*- 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 <comphelper/documentinfo.hxx>
+#include <comphelper/namedvaluecollection.hxx>
+
+#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
+#include <com/sun/star/document/XDocumentProperties.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/frame/XStorable.hpp>
+#include <com/sun/star/frame/XTitle.hpp>
+
+#include <cppuhelper/exc_hlp.hxx>
+
+#include <sal/log.hxx>
+
+namespace comphelper {
+
+
+ using ::com::sun::star::uno::Reference;
+ using ::com::sun::star::uno::UNO_QUERY;
+ using ::com::sun::star::uno::UNO_QUERY_THROW;
+ using ::com::sun::star::uno::Exception;
+ using ::com::sun::star::frame::XModel;
+ using ::com::sun::star::frame::XTitle;
+ using ::com::sun::star::frame::XController;
+ using ::com::sun::star::document::XDocumentPropertiesSupplier;
+ using ::com::sun::star::document::XDocumentProperties;
+ using ::com::sun::star::frame::XStorable;
+ using ::com::sun::star::uno::XInterface;
+ using ::com::sun::star::frame::XFrame;
+
+ namespace
+ {
+ OUString lcl_getTitle( const Reference< XInterface >& _rxComponent )
+ {
+ Reference< XTitle > xTitle( _rxComponent, UNO_QUERY );
+ if ( xTitle.is() )
+ return xTitle->getTitle();
+ return OUString();
+ }
+ }
+
+ OUString DocumentInfo::getDocumentTitle( const Reference< XModel >& _rxDocument )
+ {
+ OUString sTitle;
+
+ if ( !_rxDocument.is() )
+ return sTitle;
+
+ try
+ {
+ // 1. ask the model and the controller for their XTitle::getTitle
+ sTitle = lcl_getTitle( _rxDocument );
+ if ( !sTitle.isEmpty() )
+ return sTitle;
+
+ Reference< XController > xController( _rxDocument->getCurrentController() );
+ sTitle = lcl_getTitle( xController );
+ if ( !sTitle.isEmpty() )
+ return sTitle;
+
+ // work around a problem with embedded objects, which sometimes return
+ // private:object as URL
+ OUString sDocURL = _rxDocument->getURL();
+ if ( sDocURL.startsWithIgnoreAsciiCase( "private:" ) )
+ sDocURL.clear();
+
+ // 2. if the document is not saved, yet, check the frame title
+ if ( sDocURL.isEmpty() )
+ {
+ Reference< XFrame > xFrame;
+ if ( xController.is() )
+ xFrame.set( xController->getFrame() );
+ sTitle = lcl_getTitle( xFrame );
+ if ( !sTitle.isEmpty() )
+ return sTitle;
+ }
+
+ // 3. try the UNO XDocumentProperties
+ Reference< XDocumentPropertiesSupplier > xDPS( _rxDocument, UNO_QUERY );
+ if ( xDPS.is() )
+ {
+ Reference< XDocumentProperties > xDocProps (
+ xDPS->getDocumentProperties(), css::uno::UNO_SET_THROW );
+ sTitle = xDocProps->getTitle();
+ if ( !sTitle.isEmpty() )
+ return sTitle;
+ }
+
+ // 4. try model arguments
+ sTitle = NamedValueCollection::getOrDefault( _rxDocument->getArgs(), u"Title", sTitle );
+ if ( !sTitle.isEmpty() )
+ return sTitle;
+
+ // 5. try the last segment of the document URL
+ // this formerly was an INetURLObject::getName( LAST_SEGMENT, true, DecodeMechanism::WithCharset ),
+ // but since we moved this code to comphelper, we do not have access to an INetURLObject anymore
+ // This heuristics here should be sufficient - finally, we will get a UNO title API in a not
+ // too distant future (hopefully), then this complete class is superfluous)
+ if ( sDocURL.isEmpty() )
+ {
+ Reference< XStorable > xDocStorable( _rxDocument, UNO_QUERY_THROW );
+ sDocURL = xDocStorable->getLocation();
+ }
+ sal_Int32 nLastSepPos = sDocURL.lastIndexOf( '/' );
+ if ( ( nLastSepPos != -1 ) && ( nLastSepPos == sDocURL.getLength() - 1 ) )
+ {
+ sDocURL = sDocURL.copy( 0, nLastSepPos );
+ nLastSepPos = sDocURL.lastIndexOf( '/' );
+ }
+ sTitle = sDocURL.copy( nLastSepPos + 1 );
+
+ if ( !sTitle.isEmpty() )
+ return sTitle;
+
+ // 5.
+ // <-- #i88104# (05-16-08) TKR: use the new XTitle Interface to get the Title -->
+
+ Reference< XTitle > xTitle( _rxDocument, UNO_QUERY );
+ if ( xTitle.is() )
+ {
+ if ( !xTitle->getTitle().isEmpty() )
+ return xTitle->getTitle();
+ }
+ }
+ catch ( const Exception& )
+ {
+ // Cannot use tools::exceptionToString here, because the tools module depends on the comphelper module
+ css::uno::Any caught( ::cppu::getCaughtException() );
+ css::uno::Exception exception;
+ caught >>= exception;
+ SAL_WARN( "comphelper", "caught an exception!\ntype : " << caught.getValueTypeName()
+ << "\nmessage: " << exception
+ << "\nin function:\n" << __func__);
+ }
+
+ return sTitle;
+ }
+
+ void DocumentInfo::notifyMacroEventRead(const css::uno::Reference<css::frame::XModel>& rModel)
+ {
+ if (!rModel.is())
+ return;
+
+ // like BreakMacroSignature of XMLScriptContext use XModel::attachResource
+ // to propagate this notification
+ css::uno::Sequence<css::beans::PropertyValue> aMedDescr = rModel->getArgs();
+ sal_Int32 nNewLen = aMedDescr.getLength() + 1;
+ aMedDescr.realloc(nNewLen);
+ auto pMedDescr = aMedDescr.getArray();
+ pMedDescr[nNewLen-1].Name = "MacroEventRead";
+ pMedDescr[nNewLen-1].Value <<= true;
+ rModel->attachResource(rModel->getURL(), aMedDescr);
+ }
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/evtlistenerhlp.cxx b/comphelper/source/misc/evtlistenerhlp.cxx
new file mode 100644
index 000000000..2eac31580
--- /dev/null
+++ b/comphelper/source/misc/evtlistenerhlp.cxx
@@ -0,0 +1,37 @@
+/* -*- 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 <comphelper/evtlistenerhlp.hxx>
+
+namespace comphelper
+{
+ OEventListenerHelper::OEventListenerHelper(const css::uno::Reference< css::lang::XEventListener>&
+ _rxListener) : m_xListener(_rxListener)
+ {
+ }
+ void SAL_CALL OEventListenerHelper::disposing( const css::lang::EventObject& Source )
+ {
+ css::uno::Reference< css::lang::XEventListener> xRef = m_xListener;
+ if(xRef.is())
+ xRef->disposing(Source);
+ }
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/evtmethodhelper.cxx b/comphelper/source/misc/evtmethodhelper.cxx
new file mode 100644
index 000000000..5f60d92d6
--- /dev/null
+++ b/comphelper/source/misc/evtmethodhelper.cxx
@@ -0,0 +1,59 @@
+/* -*- 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 <comphelper/evtmethodhelper.hxx>
+#include <com/sun/star/uno/Sequence.hxx>
+
+using ::com::sun::star::uno::Sequence;
+using ::com::sun::star::uno::Type;
+
+namespace comphelper
+{
+
+ Sequence< OUString> getEventMethodsForType(const Type& type)
+ {
+ typelib_InterfaceTypeDescription *pType=nullptr;
+ type.getDescription(reinterpret_cast<typelib_TypeDescription**>(&pType));
+
+ if(!pType)
+ return Sequence< OUString>();
+
+ Sequence< OUString> aNames(pType->nMembers);
+ OUString* pNames = aNames.getArray();
+ for(sal_Int32 i=0;i<pType->nMembers;i++,++pNames)
+ {
+ // the description reference
+ typelib_TypeDescriptionReference* pMemberDescriptionReference = pType->ppMembers[i];
+ // the description for the reference
+ typelib_TypeDescription* pMemberDescription = nullptr;
+ typelib_typedescriptionreference_getDescription(&pMemberDescription, pMemberDescriptionReference);
+ if (pMemberDescription)
+ {
+ typelib_InterfaceMemberTypeDescription* pRealMemberDescription =
+ reinterpret_cast<typelib_InterfaceMemberTypeDescription*>(pMemberDescription);
+ *pNames = pRealMemberDescription->pMemberName;
+ }
+ }
+ typelib_typedescription_release( &pType->aBase );
+ return aNames;
+ }
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/fileurl.cxx b/comphelper/source/misc/fileurl.cxx
new file mode 100644
index 000000000..4f361ab4b
--- /dev/null
+++ b/comphelper/source/misc/fileurl.cxx
@@ -0,0 +1,27 @@
+/* -*- 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 <sal/config.h>
+
+#include <comphelper/fileurl.hxx>
+#include <rtl/ustring.hxx>
+
+bool comphelper::isFileUrl(OUString const& url) { return url.startsWithIgnoreAsciiCase("file:"); }
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/getexpandeduri.cxx b/comphelper/source/misc/getexpandeduri.cxx
new file mode 100644
index 000000000..853e5dbd3
--- /dev/null
+++ b/comphelper/source/misc/getexpandeduri.cxx
@@ -0,0 +1,32 @@
+/* -*- 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/.
+ */
+
+#include <sal/config.h>
+
+#include <com/sun/star/uno/Reference.hxx>
+#include <com/sun/star/uri/UriReferenceFactory.hpp>
+#include <com/sun/star/uri/XVndSunStarExpandUrlReference.hpp>
+#include <com/sun/star/util/theMacroExpander.hpp>
+#include <comphelper/getexpandeduri.hxx>
+#include <rtl/ustring.hxx>
+
+namespace com::sun::star::uno { class XComponentContext; }
+
+OUString comphelper::getExpandedUri(
+ css::uno::Reference<css::uno::XComponentContext> const & context,
+ OUString const & uri)
+{
+ css::uno::Reference<css::uri::XVndSunStarExpandUrlReference> ref(
+ css::uri::UriReferenceFactory::create(context)->parse(uri),
+ css::uno::UNO_QUERY);
+ return ref.is()
+ ? ref->expand(css::util::theMacroExpander::get(context)) : uri;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/graphicmimetype.cxx b/comphelper/source/misc/graphicmimetype.cxx
new file mode 100644
index 000000000..bfa7e5c6a
--- /dev/null
+++ b/comphelper/source/misc/graphicmimetype.cxx
@@ -0,0 +1,171 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * 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 <comphelper/graphicmimetype.hxx>
+
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/graphic/GraphicProvider.hpp>
+#include <com/sun/star/graphic/XGraphicProvider.hpp>
+#include <com/sun/star/io/XInputStream.hpp>
+#include <com/sun/star/uno/Reference.hxx>
+
+#include <comphelper/processfactory.hxx>
+#include <comphelper/propertyvalue.hxx>
+
+using namespace css;
+using namespace css::beans;
+using namespace css::graphic;
+using namespace css::io;
+using namespace css::uno;
+
+namespace comphelper
+{
+OUString GraphicMimeTypeHelper::GetMimeTypeForExtension(std::string_view rExt)
+{
+ struct XMLGraphicMimeTypeMapper
+ {
+ const char* pExt;
+ const char* pMimeType;
+ };
+
+ static const XMLGraphicMimeTypeMapper aMapper[]
+ = { { "gif", "image/gif" }, { "png", "image/png" }, { "jpg", "image/jpeg" },
+ { "tif", "image/tiff" }, { "svg", "image/svg+xml" }, { "pdf", "application/pdf" },
+ { "wmf", "image/x-wmf" }, { "emf", "image/x-emf" }, { "eps", "image/x-eps" },
+ { "bmp", "image/bmp" }, { "pct", "image/x-pict" }, { "svm", "image/x-svm" } };
+
+ OUString aMimeType;
+
+ tools::Long const nCount = std::size(aMapper);
+ for (tools::Long i = 0; (i < nCount) && aMimeType.isEmpty(); ++i)
+ {
+ if (rExt == aMapper[i].pExt)
+ aMimeType = OUString(aMapper[i].pMimeType, strlen(aMapper[i].pMimeType),
+ RTL_TEXTENCODING_ASCII_US);
+ }
+
+ return aMimeType;
+}
+
+OUString GraphicMimeTypeHelper::GetMimeTypeForXGraphic(const Reference<XGraphic>& xGraphic)
+{
+ OUString aSourceMimeType;
+ Reference<XPropertySet> const xGraphicPropertySet(xGraphic, UNO_QUERY);
+ if (xGraphicPropertySet.is() && // it's null if it's an external link
+ (xGraphicPropertySet->getPropertyValue("MimeType") >>= aSourceMimeType))
+ {
+ return aSourceMimeType;
+ }
+ return "";
+}
+
+OUString
+GraphicMimeTypeHelper::GetMimeTypeForImageStream(const Reference<XInputStream>& xInputStream)
+{
+ // Create the graphic to retrieve the mimetype from it
+ Reference<XGraphicProvider> xProvider
+ = css::graphic::GraphicProvider::create(comphelper::getProcessComponentContext());
+ Sequence<PropertyValue> aMediaProperties{ comphelper::makePropertyValue("InputStream",
+ xInputStream) };
+ Reference<XGraphic> xGraphic(xProvider->queryGraphic(aMediaProperties));
+
+ return GetMimeTypeForXGraphic(xGraphic);
+}
+
+OUString GraphicMimeTypeHelper::GetMimeTypeForConvertDataFormat(ConvertDataFormat convertDataFormat)
+{
+ switch (convertDataFormat)
+ {
+ case ConvertDataFormat::BMP:
+ return "image/bmp";
+ case ConvertDataFormat::GIF:
+ return "image/gif";
+ case ConvertDataFormat::JPG:
+ return "image/jpeg";
+ case ConvertDataFormat::PCT:
+ return "image/x-pict";
+ case ConvertDataFormat::PNG:
+ return "image/png";
+ case ConvertDataFormat::SVM:
+ return "image/x-svm";
+ case ConvertDataFormat::TIF:
+ return "image/tiff";
+ case ConvertDataFormat::WMF:
+ return "image/x-wmf";
+ case ConvertDataFormat::EMF:
+ return "image/x-emf";
+ case ConvertDataFormat::SVG:
+ return "image/svg+xml";
+ case ConvertDataFormat::MET: // What is this?
+ case ConvertDataFormat::Unknown:
+ default:
+ return "";
+ }
+}
+
+char const* GraphicMimeTypeHelper::GetExtensionForConvertDataFormat(ConvertDataFormat nFormat)
+{
+ char const* pExt = nullptr;
+ // create extension
+ if (nFormat != ConvertDataFormat::Unknown)
+ {
+ switch (nFormat)
+ {
+ case ConvertDataFormat::BMP:
+ pExt = ".bmp";
+ break;
+ case ConvertDataFormat::GIF:
+ pExt = ".gif";
+ break;
+ case ConvertDataFormat::JPG:
+ pExt = ".jpg";
+ break;
+ case ConvertDataFormat::MET:
+ pExt = ".met";
+ break;
+ case ConvertDataFormat::PCT:
+ pExt = ".pct";
+ break;
+ case ConvertDataFormat::PNG:
+ pExt = ".png";
+ break;
+ case ConvertDataFormat::SVM:
+ pExt = ".svm";
+ break;
+ case ConvertDataFormat::TIF:
+ pExt = ".tif";
+ break;
+ case ConvertDataFormat::WMF:
+ pExt = ".wmf";
+ break;
+ case ConvertDataFormat::EMF:
+ pExt = ".emf";
+ break;
+
+ default:
+ pExt = ".grf";
+ break;
+ }
+ }
+ return pExt;
+}
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/hash.cxx b/comphelper/source/misc/hash.cxx
new file mode 100644
index 000000000..50fd8cd0f
--- /dev/null
+++ b/comphelper/source/misc/hash.cxx
@@ -0,0 +1,257 @@
+/* -*- 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/.
+ */
+
+#include <sal/config.h>
+
+#include <com/sun/star/uno/RuntimeException.hpp>
+#include <comphelper/hash.hxx>
+#include <rtl/ustring.hxx>
+#include <rtl/alloc.h>
+#include <osl/endian.h>
+#include <config_oox.h>
+
+#if USE_TLS_NSS
+#include <nss.h>
+#include <sechash.h>
+#elif USE_TLS_OPENSSL
+#include <openssl/evp.h>
+#include <openssl/sha.h>
+#endif // USE_TLS_OPENSSL
+
+namespace comphelper {
+
+struct HashImpl
+{
+
+#if USE_TLS_NSS
+ HASHContext* mpContext;
+
+ HASH_HashType getNSSType() const
+ {
+ switch (meType)
+ {
+ case HashType::MD5:
+ return HASH_AlgMD5;
+ case HashType::SHA1:
+ return HASH_AlgSHA1;
+ case HashType::SHA256:
+ return HASH_AlgSHA256;
+ case HashType::SHA512:
+ return HASH_AlgSHA512;
+ }
+
+ return HASH_AlgNULL;
+ }
+#elif USE_TLS_OPENSSL
+ EVP_MD_CTX* mpContext;
+
+ const EVP_MD* getOpenSSLType() const
+ {
+ switch (meType)
+ {
+ case HashType::MD5:
+ return EVP_md5();
+ case HashType::SHA1:
+ return EVP_sha1();
+ case HashType::SHA256:
+ return EVP_sha256();
+ case HashType::SHA512:
+ return EVP_sha512();
+ }
+
+ return nullptr;
+ }
+#endif
+
+ HashType const meType;
+
+ HashImpl(HashType eType):
+ meType(eType)
+ {
+
+#if USE_TLS_NSS
+ auto const e = NSS_NoDB_Init(nullptr);
+ if (e != SECSuccess) {
+ throw css::uno::RuntimeException("NSS_NoDB_Init failed with " + OUString::number(e));
+ }
+ mpContext = HASH_Create(getNSSType());
+ HASH_Begin(mpContext);
+#elif USE_TLS_OPENSSL
+ mpContext = EVP_MD_CTX_create();
+ EVP_DigestInit_ex(mpContext, getOpenSSLType(), nullptr);
+#endif
+ }
+
+ ~HashImpl()
+ {
+#if USE_TLS_NSS
+ HASH_Destroy(mpContext);
+#elif USE_TLS_OPENSSL
+ EVP_MD_CTX_destroy(mpContext);
+#endif
+ }
+};
+
+Hash::Hash(HashType eType):
+ mpImpl(new HashImpl(eType))
+{
+}
+
+Hash::~Hash()
+{
+}
+
+void Hash::update(const unsigned char* pInput, size_t length)
+{
+#if USE_TLS_NSS
+ HASH_Update(mpImpl->mpContext, pInput, length);
+#elif USE_TLS_OPENSSL
+ EVP_DigestUpdate(mpImpl->mpContext, pInput, length);
+#else
+ (void)pInput;
+ (void)length;
+#endif
+}
+
+std::vector<unsigned char> Hash::finalize()
+{
+ std::vector<unsigned char> hash(getLength(), 0);
+ unsigned int digestWrittenLength;
+#if USE_TLS_NSS
+ HASH_End(mpImpl->mpContext, hash.data(), &digestWrittenLength, getLength());
+#elif USE_TLS_OPENSSL
+ EVP_DigestFinal_ex(mpImpl->mpContext, hash.data(), &digestWrittenLength);
+#else
+ (void)digestWrittenLength;
+#endif
+
+ return hash;
+}
+
+size_t Hash::getLength() const
+{
+ switch (mpImpl->meType)
+ {
+ case HashType::MD5:
+ return MD5_HASH_LENGTH;
+ case HashType::SHA1:
+ return SHA1_HASH_LENGTH;
+ case HashType::SHA256:
+ return SHA256_HASH_LENGTH;
+ case HashType::SHA512:
+ return SHA512_HASH_LENGTH;
+ }
+
+ return 0;
+}
+
+std::vector<unsigned char> Hash::calculateHash(const unsigned char* pInput, size_t length, HashType eType)
+{
+ Hash aHash(eType);
+ aHash.update(pInput, length);
+ return aHash.finalize();
+}
+
+std::vector<unsigned char> Hash::calculateHash(
+ const unsigned char* pInput, size_t nLength,
+ const unsigned char* pSalt, size_t nSaltLen,
+ sal_uInt32 nSpinCount,
+ IterCount eIterCount,
+ HashType eType)
+{
+ if (!pSalt)
+ nSaltLen = 0;
+
+ if (!nSaltLen && !nSpinCount)
+ return calculateHash( pInput, nLength, eType);
+
+ Hash aHash(eType);
+ if (nSaltLen)
+ {
+ std::vector<unsigned char> initialData( nSaltLen + nLength);
+ std::copy( pSalt, pSalt + nSaltLen, initialData.begin());
+ std::copy( pInput, pInput + nLength, initialData.begin() + nSaltLen);
+ aHash.update( initialData.data(), initialData.size());
+ rtl_secureZeroMemory( initialData.data(), initialData.size());
+ }
+ else
+ {
+ aHash.update( pInput, nLength);
+ }
+ std::vector<unsigned char> hash( aHash.finalize());
+
+ if (nSpinCount)
+ {
+ // https://msdn.microsoft.com/en-us/library/dd920692
+ // says the iteration is concatenated after the hash.
+ // https://msdn.microsoft.com/en-us/library/dd924776 and
+ // https://msdn.microsoft.com/en-us/library/dd925430
+ // say the iteration is prepended to the hash.
+ const size_t nAddIter = (eIterCount == IterCount::NONE ? 0 : 4);
+ const size_t nIterPos = (eIterCount == IterCount::APPEND ? hash.size() : 0);
+ const size_t nHashPos = (eIterCount == IterCount::PREPEND ? nAddIter : 0);
+ std::vector<unsigned char> data( hash.size() + nAddIter, 0);
+ for (sal_uInt32 i = 0; i < nSpinCount; ++i)
+ {
+ std::copy( hash.begin(), hash.end(), data.begin() + nHashPos);
+ if (nAddIter)
+ {
+#ifdef OSL_BIGENDIAN
+ sal_uInt32 be = i;
+ sal_uInt8* p = reinterpret_cast<sal_uInt8*>(&be);
+ std::swap( p[0], p[3] );
+ std::swap( p[1], p[2] );
+ memcpy( data.data() + nIterPos, &be, nAddIter);
+#else
+ memcpy( data.data() + nIterPos, &i, nAddIter);
+#endif
+ }
+ /* TODO: isn't there something better than
+ * creating/finalizing/destroying on each iteration? */
+ Hash aReHash(eType);
+ aReHash.update( data.data(), data.size());
+ hash = aReHash.finalize();
+ }
+ }
+
+ return hash;
+}
+
+std::vector<unsigned char> Hash::calculateHash(
+ const OUString& rPassword,
+ const std::vector<unsigned char>& rSaltValue,
+ sal_uInt32 nSpinCount,
+ IterCount eIterCount,
+ HashType eType)
+{
+ const unsigned char* pPassBytes = reinterpret_cast<const unsigned char*>(rPassword.getStr());
+ const size_t nPassBytesLen = rPassword.getLength() * 2;
+#ifdef OSL_BIGENDIAN
+ // Swap UTF16-BE to UTF16-LE
+ std::vector<unsigned char> vPass;
+ if (nPassBytesLen)
+ {
+ vPass.resize( nPassBytesLen);
+ std::copy( pPassBytes, pPassBytes + nPassBytesLen, vPass.begin());
+ unsigned char* p = vPass.data();
+ unsigned char const * const pEnd = p + nPassBytesLen;
+ for ( ; p < pEnd; p += 2 )
+ {
+ std::swap( p[0], p[1] );
+ }
+ pPassBytes = vPass.data();
+ }
+#endif
+ return calculateHash( pPassBytes, nPassBytesLen, rSaltValue.data(), rSaltValue.size(), nSpinCount,
+ eIterCount, eType);
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/instancelocker.cxx b/comphelper/source/misc/instancelocker.cxx
new file mode 100644
index 000000000..84c8054ec
--- /dev/null
+++ b/comphelper/source/misc/instancelocker.cxx
@@ -0,0 +1,445 @@
+/* -*- 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 <cppuhelper/supportsservice.hxx>
+
+#include <com/sun/star/util/CloseVetoException.hpp>
+#include <com/sun/star/util/XCloseBroadcaster.hpp>
+#include <com/sun/star/util/XCloseable.hpp>
+#include <com/sun/star/lang/DisposedException.hpp>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <com/sun/star/frame/XDesktop.hpp>
+#include <com/sun/star/frame/TerminationVetoException.hpp>
+#include <com/sun/star/frame/DoubleInitializationException.hpp>
+#include <com/sun/star/embed/Actions.hpp>
+#include <com/sun/star/embed/XActionsApproval.hpp>
+#include <utility>
+
+#include "instancelocker.hxx"
+
+namespace com::sun::star::uno { class XComponentContext; }
+
+using namespace ::com::sun::star;
+
+
+// OInstanceLocker
+
+
+OInstanceLocker::OInstanceLocker()
+: m_bDisposed( false )
+, m_bInitialized( false )
+{
+}
+
+
+OInstanceLocker::~OInstanceLocker()
+{
+ if ( !m_bDisposed )
+ {
+ osl_atomic_increment(&m_refCount); // to call dispose
+ try {
+ dispose();
+ }
+ catch ( uno::RuntimeException& )
+ {}
+ }
+}
+
+// XComponent
+
+void SAL_CALL OInstanceLocker::dispose()
+{
+ std::unique_lock aGuard( m_aMutex );
+
+ if ( m_bDisposed )
+ throw lang::DisposedException();
+
+ lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >(this) );
+ m_aListenersContainer.disposeAndClear( aGuard, aSource );
+ if ( m_xLockListener.is() )
+ {
+ auto tmp = std::move(m_xLockListener);
+ aGuard.unlock();
+ tmp->Dispose();
+ aGuard.lock();
+ }
+
+ m_bDisposed = true;
+}
+
+
+void SAL_CALL OInstanceLocker::addEventListener( const uno::Reference< lang::XEventListener >& xListener )
+{
+ std::unique_lock aGuard( m_aMutex );
+ if ( m_bDisposed )
+ throw lang::DisposedException(); // TODO
+
+ m_aListenersContainer.addInterface( aGuard, xListener );
+}
+
+
+void SAL_CALL OInstanceLocker::removeEventListener( const uno::Reference< lang::XEventListener >& xListener )
+{
+ std::unique_lock aGuard( m_aMutex );
+ m_aListenersContainer.removeInterface( aGuard, xListener );
+}
+
+// XInitialization
+
+void SAL_CALL OInstanceLocker::initialize( const uno::Sequence< uno::Any >& aArguments )
+{
+ std::unique_lock aGuard( m_aMutex );
+ if ( m_bInitialized )
+ throw frame::DoubleInitializationException();
+
+ if ( m_bDisposed )
+ throw lang::DisposedException(); // TODO
+
+ if ( !m_refCount )
+ throw uno::RuntimeException(); // the object must be refcounted already!
+
+ uno::Reference< uno::XInterface > xInstance;
+ uno::Reference< embed::XActionsApproval > xApproval;
+
+ try
+ {
+ sal_Int32 nLen = aArguments.getLength();
+ if ( nLen < 2 || nLen > 3 )
+ throw lang::IllegalArgumentException(
+ "Wrong count of parameters!",
+ uno::Reference< uno::XInterface >(),
+ 0 );
+
+ if ( !( aArguments[0] >>= xInstance ) || !xInstance.is() )
+ throw lang::IllegalArgumentException(
+ "Nonempty reference is expected as the first argument!",
+ uno::Reference< uno::XInterface >(),
+ 0 );
+
+ sal_Int32 nModes = 0;
+ if (
+ !( aArguments[1] >>= nModes ) ||
+ (
+ !( nModes & embed::Actions::PREVENT_CLOSE ) &&
+ !( nModes & embed::Actions::PREVENT_TERMINATION )
+ )
+ )
+ {
+ throw lang::IllegalArgumentException(
+ "The correct modes set is expected as the second argument!",
+ uno::Reference< uno::XInterface >(),
+ 0 );
+ }
+
+ if ( nLen == 3 && !( aArguments[2] >>= xApproval ) )
+ throw lang::IllegalArgumentException(
+ "If the third argument is provided, it must be XActionsApproval implementation!",
+ uno::Reference< uno::XInterface >(),
+ 0 );
+
+ m_xLockListener = new OLockListener( uno::Reference< lang::XComponent > ( static_cast< lang::XComponent* >( this ) ),
+ xInstance,
+ nModes,
+ xApproval );
+ m_xLockListener->Init();
+ }
+ catch( uno::Exception& )
+ {
+ aGuard.unlock();
+ dispose();
+ throw;
+ }
+
+ m_bInitialized = true;
+}
+
+// XServiceInfo
+OUString SAL_CALL OInstanceLocker::getImplementationName( )
+{
+ return "com.sun.star.comp.embed.InstanceLocker";
+}
+
+sal_Bool SAL_CALL OInstanceLocker::supportsService( const OUString& ServiceName )
+{
+ return cppu::supportsService(this, ServiceName);
+}
+
+uno::Sequence< OUString > SAL_CALL OInstanceLocker::getSupportedServiceNames()
+{
+ return { "com.sun.star.embed.InstanceLocker" };
+}
+
+// OLockListener
+
+
+OLockListener::OLockListener( uno::WeakReference< lang::XComponent > xWrapper,
+ uno::Reference< uno::XInterface > xInstance,
+ sal_Int32 nMode,
+ uno::Reference< embed::XActionsApproval > xApproval )
+: m_xInstance(std::move( xInstance ))
+, m_xApproval(std::move( xApproval ))
+, m_xWrapper(std::move( xWrapper ))
+, m_bDisposed( false )
+, m_bInitialized( false )
+, m_nMode( nMode )
+{
+}
+
+
+OLockListener::~OLockListener()
+{
+}
+
+
+void OLockListener::Dispose()
+{
+ std::unique_lock aGuard( m_aMutex );
+
+ if ( m_bDisposed )
+ return;
+
+ auto xInstance = std::move(m_xInstance);
+ auto nMode = m_nMode;
+ m_bDisposed = true;
+ aGuard.unlock();
+
+ if ( nMode & embed::Actions::PREVENT_CLOSE )
+ {
+ try
+ {
+ uno::Reference< util::XCloseBroadcaster > xCloseBroadcaster( xInstance, uno::UNO_QUERY );
+ if ( xCloseBroadcaster.is() )
+ xCloseBroadcaster->removeCloseListener( static_cast< util::XCloseListener* >( this ) );
+
+ uno::Reference< util::XCloseable > xCloseable( xInstance, uno::UNO_QUERY );
+ if ( xCloseable.is() )
+ xCloseable->close( true );
+ }
+ catch( uno::Exception& )
+ {}
+ }
+
+ if ( nMode & embed::Actions::PREVENT_TERMINATION )
+ {
+ try
+ {
+ uno::Reference< frame::XDesktop > xDesktop( xInstance, uno::UNO_QUERY_THROW );
+ xDesktop->removeTerminateListener( static_cast< frame::XTerminateListener* >( this ) );
+ }
+ catch( uno::Exception& )
+ {}
+ }
+}
+
+// XEventListener
+
+void SAL_CALL OLockListener::disposing( const lang::EventObject& aEvent )
+{
+ std::unique_lock aGuard( m_aMutex );
+
+ // object is disposed
+ if ( aEvent.Source != m_xInstance )
+ return;
+
+ // the object does not listen for anything any more
+ m_nMode = 0;
+
+ // dispose the wrapper;
+ uno::Reference< lang::XComponent > xComponent( m_xWrapper.get(), uno::UNO_QUERY );
+ aGuard.unlock();
+ if ( xComponent.is() )
+ {
+ try { xComponent->dispose(); }
+ catch( uno::Exception& ){}
+ }
+}
+
+
+// XCloseListener
+
+void SAL_CALL OLockListener::queryClosing( const lang::EventObject& aEvent, sal_Bool )
+{
+ // GetsOwnership parameter is always ignored, the user of the service must close the object always
+ std::unique_lock aGuard( m_aMutex );
+ if ( !(!m_bDisposed && aEvent.Source == m_xInstance && ( m_nMode & embed::Actions::PREVENT_CLOSE )) )
+ return;
+
+ try
+ {
+ uno::Reference< embed::XActionsApproval > xApprove = m_xApproval;
+
+ // unlock the mutex here
+ aGuard.unlock();
+
+ if ( xApprove.is() && xApprove->approveAction( embed::Actions::PREVENT_CLOSE ) )
+ throw util::CloseVetoException();
+ }
+ catch( util::CloseVetoException& )
+ {
+ // rethrow this exception
+ throw;
+ }
+ catch( uno::Exception& )
+ {
+ // no action should be done
+ }
+}
+
+
+void SAL_CALL OLockListener::notifyClosing( const lang::EventObject& aEvent )
+{
+ std::unique_lock aGuard( m_aMutex );
+
+ // object is closed, no reason to listen
+ if ( aEvent.Source != m_xInstance )
+ return;
+
+ uno::Reference< util::XCloseBroadcaster > xCloseBroadcaster( aEvent.Source, uno::UNO_QUERY );
+ if ( !xCloseBroadcaster.is() )
+ return;
+
+ xCloseBroadcaster->removeCloseListener( static_cast< util::XCloseListener* >( this ) );
+ m_nMode &= ~embed::Actions::PREVENT_CLOSE;
+ if ( !m_nMode )
+ {
+ // dispose the wrapper;
+ uno::Reference< lang::XComponent > xComponent( m_xWrapper.get(), uno::UNO_QUERY );
+ aGuard.unlock();
+ if ( xComponent.is() )
+ {
+ try { xComponent->dispose(); }
+ catch( uno::Exception& ){}
+ }
+ }
+}
+
+
+// XTerminateListener
+
+void SAL_CALL OLockListener::queryTermination( const lang::EventObject& aEvent )
+{
+ std::unique_lock aGuard( m_aMutex );
+ if ( !(aEvent.Source == m_xInstance && ( m_nMode & embed::Actions::PREVENT_TERMINATION )) )
+ return;
+
+ try
+ {
+ uno::Reference< embed::XActionsApproval > xApprove = m_xApproval;
+
+ // unlock the mutex here
+ aGuard.unlock();
+
+ if ( xApprove.is() && xApprove->approveAction( embed::Actions::PREVENT_TERMINATION ) )
+ throw frame::TerminationVetoException();
+ }
+ catch( frame::TerminationVetoException& )
+ {
+ // rethrow this exception
+ throw;
+ }
+ catch( uno::Exception& )
+ {
+ // no action should be done
+ }
+}
+
+
+void SAL_CALL OLockListener::notifyTermination( const lang::EventObject& aEvent )
+{
+ std::unique_lock aGuard( m_aMutex );
+
+ // object is terminated, no reason to listen
+ if ( aEvent.Source != m_xInstance )
+ return;
+
+ uno::Reference< frame::XDesktop > xDesktop( aEvent.Source, uno::UNO_QUERY );
+ if ( !xDesktop.is() )
+ return;
+
+ try
+ {
+ xDesktop->removeTerminateListener( static_cast< frame::XTerminateListener* >( this ) );
+ m_nMode &= ~embed::Actions::PREVENT_TERMINATION;
+ if ( !m_nMode )
+ {
+ // dispose the wrapper;
+ uno::Reference< lang::XComponent > xComponent( m_xWrapper.get(), uno::UNO_QUERY );
+ aGuard.unlock();
+ if ( xComponent.is() )
+ {
+ try { xComponent->dispose(); }
+ catch( uno::Exception& ){}
+ }
+ }
+ }
+ catch( uno::Exception& )
+ {}
+}
+
+
+// XInitialization
+
+void OLockListener::Init()
+{
+ std::unique_lock aGuard( m_aMutex );
+
+ if ( m_bDisposed || m_bInitialized )
+ return;
+
+ try
+ {
+ if ( m_nMode & embed::Actions::PREVENT_CLOSE )
+ {
+ uno::Reference< util::XCloseBroadcaster > xCloseBroadcaster( m_xInstance, uno::UNO_QUERY_THROW );
+ xCloseBroadcaster->addCloseListener( static_cast< util::XCloseListener* >( this ) );
+ }
+
+ if ( m_nMode & embed::Actions::PREVENT_TERMINATION )
+ {
+ uno::Reference< frame::XDesktop > xDesktop( m_xInstance, uno::UNO_QUERY_THROW );
+ xDesktop->addTerminateListener( static_cast< frame::XTerminateListener* >( this ) );
+ }
+ }
+ catch( uno::Exception& )
+ {
+ // dispose the wrapper;
+ uno::Reference< lang::XComponent > xComponent( m_xWrapper.get(), uno::UNO_QUERY );
+ aGuard.unlock();
+ if ( xComponent.is() )
+ {
+ try { xComponent->dispose(); }
+ catch( uno::Exception& ){}
+ }
+
+ throw;
+ }
+
+ m_bInitialized = true;
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_embed_InstanceLocker(
+ css::uno::XComponentContext *,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new OInstanceLocker());
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/instancelocker.hxx b/comphelper/source/misc/instancelocker.hxx
new file mode 100644
index 000000000..6a050c7f4
--- /dev/null
+++ b/comphelper/source/misc/instancelocker.hxx
@@ -0,0 +1,111 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <com/sun/star/lang/XComponent.hpp>
+#include <com/sun/star/util/XCloseListener.hpp>
+#include <com/sun/star/frame/XTerminateListener.hpp>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <comphelper/interfacecontainer4.hxx>
+#include <cppuhelper/weakref.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <rtl/ref.hxx>
+#include <mutex>
+
+namespace com::sun::star::embed { class XActionsApproval; }
+
+
+class OLockListener;
+
+// the service is implemented as a wrapper to be able to die by refcount
+// the disposing mechanics is required for java related scenarios
+class OInstanceLocker : public ::cppu::WeakImplHelper< css::lang::XComponent,
+ css::lang::XInitialization,
+ css::lang::XServiceInfo >
+{
+ std::mutex m_aMutex;
+
+ rtl::Reference< OLockListener > m_xLockListener;
+
+ comphelper::OInterfaceContainerHelper4<css::lang::XEventListener> m_aListenersContainer; // list of listeners
+
+ bool m_bDisposed;
+ bool m_bInitialized;
+
+public:
+ explicit OInstanceLocker();
+ virtual ~OInstanceLocker() override;
+
+// XComponent
+ virtual void SAL_CALL dispose() override;
+ virtual void SAL_CALL addEventListener( const css::uno::Reference< css::lang::XEventListener >& xListener ) override;
+ virtual void SAL_CALL removeEventListener( const css::uno::Reference< css::lang::XEventListener >& aListener ) override;
+
+// XInitialization
+ virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) override;
+
+// XServiceInfo
+ virtual OUString SAL_CALL getImplementationName( ) override;
+ virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+ virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames( ) override;
+
+};
+
+
+class OLockListener : public ::cppu::WeakImplHelper< css::util::XCloseListener,
+ css::frame::XTerminateListener >
+{
+ std::mutex m_aMutex;
+ css::uno::Reference< css::uno::XInterface > m_xInstance;
+ css::uno::Reference< css::embed::XActionsApproval > m_xApproval;
+
+ css::uno::WeakReference< css::lang::XComponent > m_xWrapper;
+
+ bool m_bDisposed;
+ bool m_bInitialized;
+
+ sal_Int32 m_nMode;
+
+public:
+ OLockListener( css::uno::WeakReference< css::lang::XComponent > xWrapper,
+ css::uno::Reference< css::uno::XInterface > xInstance,
+ sal_Int32 nMode,
+ css::uno::Reference< css::embed::XActionsApproval > xApproval );
+
+ virtual ~OLockListener() override;
+
+ void Init();
+ void Dispose();
+
+// XEventListener
+ virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
+
+// XCloseListener
+ virtual void SAL_CALL queryClosing( const css::lang::EventObject& Source, sal_Bool GetsOwnership ) override;
+ virtual void SAL_CALL notifyClosing( const css::lang::EventObject& Source ) override;
+
+// XTerminateListener
+ virtual void SAL_CALL queryTermination( const css::lang::EventObject& Event ) override;
+ virtual void SAL_CALL notifyTermination( const css::lang::EventObject& Event ) override;
+
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/interaction.cxx b/comphelper/source/misc/interaction.cxx
new file mode 100644
index 000000000..9e7b1706d
--- /dev/null
+++ b/comphelper/source/misc/interaction.cxx
@@ -0,0 +1,71 @@
+/* -*- 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 <comphelper/interaction.hxx>
+
+#include <comphelper/sequence.hxx>
+#include <utility>
+#include <osl/diagnose.h>
+
+
+namespace comphelper
+{
+
+
+ using namespace ::com::sun::star::uno;
+ using namespace ::com::sun::star::task;
+
+ OInteractionRequest::OInteractionRequest(Any _aRequestDescription)
+ :m_aRequest(std::move(_aRequestDescription))
+ {
+ }
+
+ OInteractionRequest::OInteractionRequest(Any aRequestDescription,
+ std::vector<Reference<XInteractionContinuation>>&& rContinuations)
+ : m_aRequest(std::move(aRequestDescription))
+ , m_aContinuations(std::move(rContinuations))
+ {
+ }
+
+ void OInteractionRequest::addContinuation(const Reference< XInteractionContinuation >& _rxContinuation)
+ {
+ OSL_ENSURE(_rxContinuation.is(), "OInteractionRequest::addContinuation: invalid argument!");
+ if (_rxContinuation.is())
+ {
+ m_aContinuations.push_back(_rxContinuation);
+ }
+ }
+
+
+ Any SAL_CALL OInteractionRequest::getRequest( )
+ {
+ return m_aRequest;
+ }
+
+
+ Sequence< Reference< XInteractionContinuation > > SAL_CALL OInteractionRequest::getContinuations( )
+ {
+ return comphelper::containerToSequence(m_aContinuations);
+ }
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/logging.cxx b/comphelper/source/misc/logging.cxx
new file mode 100644
index 000000000..b656389de
--- /dev/null
+++ b/comphelper/source/misc/logging.cxx
@@ -0,0 +1,159 @@
+/* -*- 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 <comphelper/logging.hxx>
+
+#include <com/sun/star/logging/LoggerPool.hpp>
+
+#include <osl/diagnose.h>
+
+
+namespace comphelper
+{
+ using ::com::sun::star::uno::Reference;
+ using ::com::sun::star::uno::XComponentContext;
+ using ::com::sun::star::logging::XLoggerPool;
+ using ::com::sun::star::logging::LoggerPool;
+ using ::com::sun::star::logging::XLogger;
+ using ::com::sun::star::uno::Exception;
+
+ class EventLogger_Impl
+ {
+ private:
+ Reference< XComponentContext > m_aContext;
+ Reference< XLogger > m_xLogger;
+
+ public:
+ EventLogger_Impl( const Reference< XComponentContext >& _rxContext, const OUString& _rLoggerName );
+
+ bool isValid() const { return m_xLogger.is(); }
+ const Reference< XLogger >& getLogger() const { return m_xLogger; }
+ };
+
+ EventLogger_Impl::EventLogger_Impl( const Reference< XComponentContext >& _rxContext, const OUString& _rLoggerName )
+ :m_aContext( _rxContext )
+ {
+ try
+ {
+ Reference< XLoggerPool > xPool( LoggerPool::get( m_aContext ) );
+ if ( !_rLoggerName.isEmpty() )
+ m_xLogger = xPool->getNamedLogger( _rLoggerName );
+ else
+ m_xLogger = xPool->getDefaultLogger();
+ }
+ catch( const Exception& )
+ {
+ OSL_FAIL( "EventLogger_Impl::impl_createLogger_nothrow: caught an exception!" );
+ }
+ }
+
+ EventLogger::EventLogger( const Reference< XComponentContext >& _rxContext, const char* _pAsciiLoggerName )
+ :m_pImpl( std::make_shared<EventLogger_Impl>( _rxContext, OUString::createFromAscii( _pAsciiLoggerName ) ) )
+ {
+ }
+
+ bool EventLogger::isLoggable( const sal_Int32 _nLogLevel ) const
+ {
+ if ( !m_pImpl->isValid() )
+ return false;
+
+ try
+ {
+ return m_pImpl->getLogger()->isLoggable( _nLogLevel );
+ }
+ catch( const Exception& )
+ {
+ OSL_FAIL( "EventLogger::isLoggable: caught an exception!" );
+ }
+
+ return false;
+ }
+
+ const css::uno::Reference<css::logging::XLogger> & EventLogger::getLogger() const
+ {
+ return m_pImpl->getLogger();
+ }
+
+
+ namespace
+ {
+ void lcl_replaceParameter( OUString& _inout_Message, const char* _rPlaceHolder, std::u16string_view _rReplacement )
+ {
+ sal_Int32 nPlaceholderPosition = _inout_Message.indexOfAsciiL( _rPlaceHolder, strlen(_rPlaceHolder) );
+ OSL_ENSURE( nPlaceholderPosition >= 0, "lcl_replaceParameter: placeholder not found!" );
+ if ( nPlaceholderPosition < 0 )
+ return;
+
+ _inout_Message = _inout_Message.replaceAt( nPlaceholderPosition, strlen(_rPlaceHolder), _rReplacement );
+ }
+ }
+
+
+ void EventLogger::impl_log( const sal_Int32 _nLogLevel,
+ const char* _pSourceClass, const char* _pSourceMethod, const OUString& _rMessage,
+ const OptionalString& _rArgument1, const OptionalString& _rArgument2,
+ const OptionalString& _rArgument3, const OptionalString& _rArgument4,
+ const OptionalString& _rArgument5, const OptionalString& _rArgument6 ) const
+ {
+ OUString sMessage( _rMessage );
+ if ( !!_rArgument1 )
+ lcl_replaceParameter( sMessage, "$1$", *_rArgument1 );
+
+ if ( !!_rArgument2 )
+ lcl_replaceParameter( sMessage, "$2$", *_rArgument2 );
+
+ if ( !!_rArgument3 )
+ lcl_replaceParameter( sMessage, "$3$", *_rArgument3 );
+
+ if ( !!_rArgument4 )
+ lcl_replaceParameter( sMessage, "$4$", *_rArgument4 );
+
+ if ( !!_rArgument5 )
+ lcl_replaceParameter( sMessage, "$5$", *_rArgument5 );
+
+ if ( !!_rArgument6 )
+ lcl_replaceParameter( sMessage, "$6$", *_rArgument6 );
+
+ try
+ {
+ Reference< XLogger > xLogger( m_pImpl->getLogger() );
+ OSL_PRECOND( xLogger.is(), "EventLogger::impl_log: should never be called without a logger!" );
+ if ( _pSourceClass && _pSourceMethod )
+ {
+ xLogger->logp(
+ _nLogLevel,
+ OUString::createFromAscii( _pSourceClass ),
+ OUString::createFromAscii( _pSourceMethod ),
+ sMessage
+ );
+ }
+ else
+ {
+ xLogger->log( _nLogLevel, sMessage );
+ }
+ }
+ catch( const Exception& )
+ {
+ OSL_FAIL( "EventLogger::impl_log: caught an exception!" );
+ }
+ }
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/lok.cxx b/comphelper/source/misc/lok.cxx
new file mode 100644
index 000000000..b11bf4e83
--- /dev/null
+++ b/comphelper/source/misc/lok.cxx
@@ -0,0 +1,287 @@
+/* -*- 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/.
+ */
+
+#include <comphelper/lok.hxx>
+#include <i18nlangtag/languagetag.hxx>
+#include <sal/log.hxx>
+
+#include <iostream>
+
+namespace comphelper::LibreOfficeKit
+{
+
+static bool g_bActive(false);
+
+static bool g_bPartInInvalidation(false);
+
+static bool g_bTiledPainting(false);
+
+static bool g_bDialogPainting(false);
+
+static bool g_bTiledAnnotations(true);
+
+static bool g_bRangeHeaders(false);
+
+static bool g_bViewIdForVisCursorInvalidation(false);
+
+static bool g_bLocalRendering(false);
+
+static Compat g_eCompatFlags(Compat::none);
+
+namespace
+{
+
+class LanguageAndLocale
+{
+private:
+ LanguageTag maLanguageTag;
+ LanguageTag maLocaleLanguageTag;
+
+public:
+
+ LanguageAndLocale()
+ : maLanguageTag(LANGUAGE_NONE)
+ , maLocaleLanguageTag(LANGUAGE_NONE)
+ {}
+
+ const LanguageTag& getLanguage() const
+ {
+ return maLanguageTag;
+ }
+
+ void setLanguage(const LanguageTag& rLanguageTag)
+ {
+ if (maLanguageTag != rLanguageTag)
+ {
+ SAL_INFO("comphelper.lok", "Setting language from " << maLanguageTag.getBcp47() << " to " << rLanguageTag.getBcp47());
+ maLanguageTag = rLanguageTag;
+ }
+ }
+
+ const LanguageTag& getLocale() const
+ {
+ return maLocaleLanguageTag;
+ }
+
+ void setLocale(const LanguageTag& rLocaleLanguageTag)
+ {
+ if (maLocaleLanguageTag != rLocaleLanguageTag)
+ {
+ SAL_INFO("comphelper.lok", "Setting locale from " << maLocaleLanguageTag.getBcp47() << " to " << rLocaleLanguageTag.getBcp47());
+ maLocaleLanguageTag = rLocaleLanguageTag;
+ }
+ }
+
+};
+
+}
+
+static LanguageAndLocale g_aLanguageAndLocale;
+
+/// Scaling of the cairo canvas painting for hi-dpi
+static double g_fDPIScale(1.0);
+
+void setActive(bool bActive)
+{
+ g_bActive = bActive;
+}
+
+bool isActive()
+{
+ return g_bActive;
+}
+
+void setPartInInvalidation(bool bPartInInvalidation)
+{
+ g_bPartInInvalidation = bPartInInvalidation;
+}
+
+bool isPartInInvalidation()
+{
+ return g_bPartInInvalidation;
+}
+
+void setTiledPainting(bool bTiledPainting)
+{
+ g_bTiledPainting = bTiledPainting;
+}
+
+bool isTiledPainting()
+{
+ return g_bTiledPainting;
+}
+
+void setDialogPainting(bool bDialogPainting)
+{
+ g_bDialogPainting = bDialogPainting;
+}
+
+bool isDialogPainting()
+{
+ return g_bDialogPainting;
+}
+
+void setDPIScale(double fDPIScale)
+{
+ g_fDPIScale = fDPIScale;
+}
+
+double getDPIScale()
+{
+ return g_fDPIScale;
+}
+
+void setTiledAnnotations(bool bTiledAnnotations)
+{
+ g_bTiledAnnotations = bTiledAnnotations;
+}
+
+bool isTiledAnnotations()
+{
+ return g_bTiledAnnotations;
+}
+
+void setRangeHeaders(bool bRangeHeaders)
+{
+ g_bRangeHeaders = bRangeHeaders;
+}
+
+void setViewIdForVisCursorInvalidation(bool bViewIdForVisCursorInvalidation)
+{
+ g_bViewIdForVisCursorInvalidation = bViewIdForVisCursorInvalidation;
+}
+
+bool isViewIdForVisCursorInvalidation()
+{
+ return g_bViewIdForVisCursorInvalidation;
+}
+
+bool isRangeHeaders()
+{
+ return g_bRangeHeaders;
+}
+
+void setLocalRendering(bool bLocalRendering)
+{
+ g_bLocalRendering = bLocalRendering;
+}
+
+bool isLocalRendering()
+{
+ return g_bLocalRendering;
+}
+
+void setCompatFlag(Compat flag) { g_eCompatFlags = static_cast<Compat>(g_eCompatFlags | flag); }
+
+bool isCompatFlagSet(Compat flag) { return (g_eCompatFlags & flag) == flag; }
+
+void setLocale(const LanguageTag& rLanguageTag)
+{
+ g_aLanguageAndLocale.setLocale(rLanguageTag);
+}
+
+const LanguageTag& getLocale()
+{
+ const LanguageTag& rLocale = g_aLanguageAndLocale.getLocale();
+ SAL_INFO_IF(rLocale.getLanguageType() == LANGUAGE_NONE, "comphelper.lok", "Locale not set");
+ return rLocale;
+}
+
+void setLanguageTag(const LanguageTag& rLanguageTag)
+{
+ g_aLanguageAndLocale.setLanguage(rLanguageTag);
+}
+
+const LanguageTag& getLanguageTag()
+{
+ const LanguageTag& rLanguage = g_aLanguageAndLocale.getLanguage();
+ SAL_INFO_IF(rLanguage.getLanguageType() == LANGUAGE_NONE, "comphelper.lok", "Language not set");
+ return rLanguage;
+}
+
+bool isAllowlistedLanguage(const OUString& lang)
+{
+ if (!isActive())
+ return true;
+
+#if defined ANDROID || defined IOS
+ (void) lang;
+ return true;
+#else
+ static const std::vector<OUString> aAllowlist = [] {
+ std::vector<OUString> aList;
+ // coverity[tainted_data] - we trust the contents of this variable
+ const char* pAllowlist = getenv("LOK_ALLOWLIST_LANGUAGES");
+ if (pAllowlist)
+ {
+ std::stringstream stream(pAllowlist);
+ std::string s;
+
+ std::cerr << "Allowlisted languages: ";
+ while (getline(stream, s, ' ')) {
+ if (s.length() == 0)
+ continue;
+
+ std::cerr << s << " ";
+ aList.emplace_back(OStringToOUString(s.c_str(), RTL_TEXTENCODING_UTF8));
+ }
+ std::cerr << std::endl;
+ }
+
+ if (aList.empty())
+ std::cerr << "No language allowlisted, turning off the language support." << std::endl;
+
+ return aList;
+ }();
+
+ if (aAllowlist.empty())
+ return false;
+
+ for (const auto& entry : aAllowlist)
+ {
+ if (lang.startsWith(entry))
+ return true;
+ if (lang.startsWith(entry.replace('_', '-')))
+ return true;
+ }
+
+ return false;
+#endif
+}
+
+static void (*pStatusIndicatorCallback)(void *data, statusIndicatorCallbackType type, int percent, const char* pText)(nullptr);
+static void *pStatusIndicatorCallbackData(nullptr);
+
+void setStatusIndicatorCallback(void (*callback)(void *data, statusIndicatorCallbackType type, int percent, const char* pText), void *data)
+{
+ pStatusIndicatorCallback = callback;
+ pStatusIndicatorCallbackData = data;
+}
+
+void statusIndicatorStart(const OUString& sText)
+{
+ if (pStatusIndicatorCallback)
+ pStatusIndicatorCallback(pStatusIndicatorCallbackData, statusIndicatorCallbackType::Start, 0, sText.toUtf8().getStr());
+}
+
+void statusIndicatorSetValue(int percent)
+{
+ if (pStatusIndicatorCallback)
+ pStatusIndicatorCallback(pStatusIndicatorCallbackData, statusIndicatorCallbackType::SetValue, percent, nullptr);
+}
+
+void statusIndicatorFinish()
+{
+ if (pStatusIndicatorCallback)
+ pStatusIndicatorCallback(pStatusIndicatorCallbackData, statusIndicatorCallbackType::Finish, 0, nullptr);
+}
+
+} // namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/mimeconfighelper.cxx b/comphelper/source/misc/mimeconfighelper.cxx
new file mode 100644
index 000000000..7f402b635
--- /dev/null
+++ b/comphelper/source/misc/mimeconfighelper.cxx
@@ -0,0 +1,909 @@
+/* -*- 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 <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/configuration/theDefaultProvider.hpp>
+#include <com/sun/star/container/XContainerQuery.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/embed/VerbDescriptor.hpp>
+#include <com/sun/star/document/XTypeDetection.hpp>
+
+#include <osl/diagnose.h>
+
+#include <comphelper/fileformat.h>
+#include <comphelper/mimeconfighelper.hxx>
+#include <comphelper/classids.hxx>
+#include <comphelper/sequenceashashmap.hxx>
+#include <comphelper/documentconstants.hxx>
+#include <comphelper/propertysequence.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <utility>
+
+
+using namespace ::com::sun::star;
+using namespace comphelper;
+
+
+MimeConfigurationHelper::MimeConfigurationHelper( uno::Reference< uno::XComponentContext > xContext )
+: m_xContext(std::move( xContext ))
+{
+ if ( !m_xContext.is() )
+ throw uno::RuntimeException();
+}
+
+
+OUString MimeConfigurationHelper::GetStringClassIDRepresentation( const uno::Sequence< sal_Int8 >& aClassID )
+{
+ OUStringBuffer aResult;
+
+ if ( aClassID.getLength() == 16 )
+ {
+ for ( sal_Int32 nInd = 0; nInd < aClassID.getLength(); nInd++ )
+ {
+ if ( nInd == 4 || nInd == 6 || nInd == 8 || nInd == 10 )
+ aResult.append("-");
+
+ sal_Int32 nDigit1 = static_cast<sal_Int32>( static_cast<sal_uInt8>(aClassID[nInd]) / 16 );
+ sal_Int32 nDigit2 = static_cast<sal_uInt8>(aClassID[nInd]) % 16;
+ aResult.append( OUString::number(nDigit1, 16) + OUString::number( nDigit2, 16 ) );
+ }
+ }
+
+ return aResult.makeStringAndClear();
+}
+
+
+static sal_uInt8 GetDigit_Impl( char aChar )
+{
+ if ( aChar >= '0' && aChar <= '9' )
+ return aChar - '0';
+ else if ( aChar >= 'a' && aChar <= 'f' )
+ return aChar - 'a' + 10;
+ else if ( aChar >= 'A' && aChar <= 'F' )
+ return aChar - 'A' + 10;
+ else
+ return 16;
+}
+
+
+uno::Sequence< sal_Int8 > MimeConfigurationHelper::GetSequenceClassIDRepresentation( std::u16string_view aClassID )
+{
+ size_t nLength = aClassID.size();
+ if ( nLength == 36 )
+ {
+ OString aCharClassID = OUStringToOString( aClassID, RTL_TEXTENCODING_ASCII_US );
+ uno::Sequence< sal_Int8 > aResult( 16 );
+ auto pResult = aResult.getArray();
+
+ size_t nStrPointer = 0;
+ sal_Int32 nSeqInd = 0;
+ while( nSeqInd < 16 && nStrPointer + 1U < nLength )
+ {
+ sal_uInt8 nDigit1 = GetDigit_Impl( aCharClassID[nStrPointer++] );
+ sal_uInt8 nDigit2 = GetDigit_Impl( aCharClassID[nStrPointer++] );
+
+ if ( nDigit1 > 15 || nDigit2 > 15 )
+ break;
+
+ pResult[nSeqInd++] = static_cast<sal_Int8>( nDigit1 * 16 + nDigit2 );
+
+ if ( nStrPointer < nLength && aCharClassID[nStrPointer] == '-' )
+ nStrPointer++;
+ }
+
+ if ( nSeqInd == 16 && nStrPointer == nLength )
+ return aResult;
+ }
+
+ return uno::Sequence< sal_Int8 >();
+}
+
+
+uno::Reference< container::XNameAccess > MimeConfigurationHelper::GetConfigurationByPathImpl( const OUString& aPath )
+{
+ uno::Reference< container::XNameAccess > xConfig;
+
+ try
+ {
+ if ( !m_xConfigProvider.is() )
+ m_xConfigProvider = configuration::theDefaultProvider::get( m_xContext );
+
+ uno::Sequence<uno::Any> aArgs(comphelper::InitAnyPropertySequence(
+ {
+ {"nodepath", uno::Any(aPath)}
+ }));
+ xConfig.set( m_xConfigProvider->createInstanceWithArguments(
+ "com.sun.star.configuration.ConfigurationAccess",
+ aArgs ),
+ uno::UNO_QUERY );
+ }
+ catch( uno::Exception& )
+ {}
+
+ return xConfig;
+}
+
+
+uno::Reference< container::XNameAccess > MimeConfigurationHelper::GetObjConfiguration()
+{
+ std::unique_lock aGuard( m_aMutex );
+
+ if ( !m_xObjectConfig.is() )
+ m_xObjectConfig = GetConfigurationByPathImpl(
+ "/org.openoffice.Office.Embedding/Objects" );
+
+ return m_xObjectConfig;
+}
+
+
+uno::Reference< container::XNameAccess > MimeConfigurationHelper::GetVerbsConfiguration()
+{
+ std::unique_lock aGuard( m_aMutex );
+
+ if ( !m_xVerbsConfig.is() )
+ m_xVerbsConfig = GetConfigurationByPathImpl(
+ "/org.openoffice.Office.Embedding/Verbs");
+
+ return m_xVerbsConfig;
+}
+
+
+uno::Reference< container::XNameAccess > MimeConfigurationHelper::GetMediaTypeConfiguration()
+{
+ std::unique_lock aGuard( m_aMutex );
+
+ if ( !m_xMediaTypeConfig.is() )
+ m_xMediaTypeConfig = GetConfigurationByPathImpl(
+ "/org.openoffice.Office.Embedding/MimeTypeClassIDRelations");
+
+ return m_xMediaTypeConfig;
+}
+
+
+uno::Reference< container::XNameAccess > MimeConfigurationHelper::GetFilterFactory()
+{
+ std::unique_lock aGuard( m_aMutex );
+
+ if ( !m_xFilterFactory.is() )
+ m_xFilterFactory.set(
+ m_xContext->getServiceManager()->createInstanceWithContext("com.sun.star.document.FilterFactory", m_xContext),
+ uno::UNO_QUERY );
+
+ return m_xFilterFactory;
+}
+
+
+OUString MimeConfigurationHelper::GetDocServiceNameFromFilter( const OUString& aFilterName )
+{
+ OUString aDocServiceName;
+
+ try
+ {
+ uno::Reference< container::XNameAccess > xFilterFactory(
+ GetFilterFactory(),
+ uno::UNO_SET_THROW );
+
+ uno::Any aFilterAnyData = xFilterFactory->getByName( aFilterName );
+ uno::Sequence< beans::PropertyValue > aFilterData;
+ if ( aFilterAnyData >>= aFilterData )
+ {
+ for ( const auto & prop : std::as_const(aFilterData) )
+ if ( prop.Name == "DocumentService" )
+ prop.Value >>= aDocServiceName;
+ }
+ }
+ catch( uno::Exception& )
+ {}
+
+ return aDocServiceName;
+}
+
+
+OUString MimeConfigurationHelper::GetDocServiceNameFromMediaType( const OUString& aMediaType )
+{
+ uno::Reference< container::XContainerQuery > xTypeCFG(
+ m_xContext->getServiceManager()->createInstanceWithContext("com.sun.star.document.TypeDetection", m_xContext),
+ uno::UNO_QUERY );
+
+ if ( xTypeCFG.is() )
+ {
+ try
+ {
+ // make query for all types matching the properties
+ uno::Sequence < beans::NamedValue > aSeq { { "MediaType", css::uno::Any(aMediaType) } };
+
+ uno::Reference < container::XEnumeration > xEnum = xTypeCFG->createSubSetEnumerationByProperties( aSeq );
+ while ( xEnum->hasMoreElements() )
+ {
+ uno::Sequence< beans::PropertyValue > aType;
+ if ( xEnum->nextElement() >>= aType )
+ {
+ for ( const auto & prop : std::as_const(aType) )
+ {
+ OUString aFilterName;
+ if ( prop.Name == "PreferredFilter"
+ && ( prop.Value >>= aFilterName ) && !aFilterName.isEmpty() )
+ {
+ OUString aDocumentName = GetDocServiceNameFromFilter( aFilterName );
+ if ( !aDocumentName.isEmpty() )
+ return aDocumentName;
+ }
+ }
+ }
+ }
+ }
+ catch( uno::Exception& )
+ {}
+ }
+
+ return OUString();
+}
+
+
+bool MimeConfigurationHelper::GetVerbByShortcut( const OUString& aVerbShortcut,
+ embed::VerbDescriptor& aDescriptor )
+{
+ bool bResult = false;
+
+ uno::Reference< container::XNameAccess > xVerbsConfig = GetVerbsConfiguration();
+ uno::Reference< container::XNameAccess > xVerbsProps;
+ try
+ {
+ if ( xVerbsConfig.is() && ( xVerbsConfig->getByName( aVerbShortcut ) >>= xVerbsProps ) && xVerbsProps.is() )
+ {
+ embed::VerbDescriptor aTempDescr;
+ static constexpr OUStringLiteral sVerbID = u"VerbID";
+ static constexpr OUStringLiteral sVerbUIName = u"VerbUIName";
+ static constexpr OUStringLiteral sVerbFlags = u"VerbFlags";
+ static constexpr OUStringLiteral sVerbAttributes = u"VerbAttributes";
+ if ( ( xVerbsProps->getByName(sVerbID) >>= aTempDescr.VerbID )
+ && ( xVerbsProps->getByName(sVerbUIName) >>= aTempDescr.VerbName )
+ && ( xVerbsProps->getByName(sVerbFlags) >>= aTempDescr.VerbFlags )
+ && ( xVerbsProps->getByName(sVerbAttributes) >>= aTempDescr.VerbAttributes ) )
+ {
+ aDescriptor = aTempDescr;
+ bResult = true;
+ }
+ }
+ }
+ catch( uno::Exception& )
+ {
+ }
+
+ return bResult;
+}
+
+
+uno::Sequence< beans::NamedValue > MimeConfigurationHelper::GetObjPropsFromConfigEntry(
+ const uno::Sequence< sal_Int8 >& aClassID,
+ const uno::Reference< container::XNameAccess >& xObjectProps )
+{
+ uno::Sequence< beans::NamedValue > aResult;
+
+ if ( aClassID.getLength() == 16 )
+ {
+ try
+ {
+ const uno::Sequence< OUString > aObjPropNames = xObjectProps->getElementNames();
+
+ aResult.realloc( aObjPropNames.getLength() + 1 );
+ auto pResult = aResult.getArray();
+ pResult[0].Name = "ClassID";
+ pResult[0].Value <<= aClassID;
+
+ for ( sal_Int32 nInd = 0; nInd < aObjPropNames.getLength(); nInd++ )
+ {
+ pResult[nInd + 1].Name = aObjPropNames[nInd];
+
+ if ( aObjPropNames[nInd] == "ObjectVerbs" )
+ {
+ uno::Sequence< OUString > aVerbShortcuts;
+ if ( !(xObjectProps->getByName( aObjPropNames[nInd] ) >>= aVerbShortcuts) )
+ throw uno::RuntimeException();
+ uno::Sequence< embed::VerbDescriptor > aVerbDescriptors( aVerbShortcuts.getLength() );
+ auto aVerbDescriptorsRange = asNonConstRange(aVerbDescriptors);
+ for ( sal_Int32 nVerbI = 0; nVerbI < aVerbShortcuts.getLength(); nVerbI++ )
+ if ( !GetVerbByShortcut( aVerbShortcuts[nVerbI], aVerbDescriptorsRange[nVerbI] ) )
+ throw uno::RuntimeException();
+
+ pResult[nInd+1].Value <<= aVerbDescriptors;
+ }
+ else
+ pResult[nInd+1].Value = xObjectProps->getByName( aObjPropNames[nInd] );
+ }
+ }
+ catch( uno::Exception& )
+ {
+ aResult.realloc( 0 );
+ }
+ }
+
+ return aResult;
+}
+
+
+OUString MimeConfigurationHelper::GetExplicitlyRegisteredObjClassID( const OUString& aMediaType )
+{
+ OUString aStringClassID;
+
+ uno::Reference< container::XNameAccess > xMediaTypeConfig = GetMediaTypeConfiguration();
+ try
+ {
+ if ( xMediaTypeConfig.is() )
+ xMediaTypeConfig->getByName( aMediaType ) >>= aStringClassID;
+ }
+ catch( uno::Exception& )
+ {
+ }
+
+ return aStringClassID;
+
+}
+
+
+uno::Sequence< beans::NamedValue > MimeConfigurationHelper::GetObjectPropsByStringClassID(
+ const OUString& aStringClassID )
+{
+ uno::Sequence< beans::NamedValue > aObjProps;
+
+ uno::Sequence< sal_Int8 > aClassID = GetSequenceClassIDRepresentation( aStringClassID );
+ if ( ClassIDsEqual( aClassID, GetSequenceClassID( SO3_DUMMY_CLASSID ) ) )
+ {
+ aObjProps = { { "ObjectFactory",
+ uno::Any(OUString("com.sun.star.embed.OOoSpecialEmbeddedObjectFactory")) },
+ { "ClassID", uno::Any(aClassID) } };
+ return aObjProps;
+ }
+
+ if ( aClassID.getLength() == 16 )
+ {
+ uno::Reference< container::XNameAccess > xObjConfig = GetObjConfiguration();
+ uno::Reference< container::XNameAccess > xObjectProps;
+ try
+ {
+ // TODO/LATER: allow to provide ClassID string in any format, only digits are counted
+ if ( xObjConfig.is() && ( xObjConfig->getByName( aStringClassID.toAsciiUpperCase() ) >>= xObjectProps ) && xObjectProps.is() )
+ aObjProps = GetObjPropsFromConfigEntry( aClassID, xObjectProps );
+ }
+ catch( uno::Exception& )
+ {
+ }
+ }
+
+ return aObjProps;
+}
+
+
+uno::Sequence< beans::NamedValue > MimeConfigurationHelper::GetObjectPropsByClassID(
+ const uno::Sequence< sal_Int8 >& aClassID )
+{
+ uno::Sequence< beans::NamedValue > aObjProps;
+ if ( ClassIDsEqual( aClassID, GetSequenceClassID( SO3_DUMMY_CLASSID ) ) )
+ {
+ aObjProps = { { "ObjectFactory",
+ uno::Any(OUString("com.sun.star.embed.OOoSpecialEmbeddedObjectFactory")) },
+ { "ClassID", uno::Any(aClassID) } };
+ }
+
+ OUString aStringClassID = GetStringClassIDRepresentation( aClassID );
+ if ( !aStringClassID.isEmpty() )
+ {
+ uno::Reference< container::XNameAccess > xObjConfig = GetObjConfiguration();
+ uno::Reference< container::XNameAccess > xObjectProps;
+ try
+ {
+ if ( xObjConfig.is() && ( xObjConfig->getByName( aStringClassID.toAsciiUpperCase() ) >>= xObjectProps ) && xObjectProps.is() )
+ aObjProps = GetObjPropsFromConfigEntry( aClassID, xObjectProps );
+ }
+ catch( uno::Exception& )
+ {
+ }
+ }
+
+ return aObjProps;
+}
+
+
+uno::Sequence< beans::NamedValue > MimeConfigurationHelper::GetObjectPropsByMediaType( const OUString& aMediaType )
+{
+ uno::Sequence< beans::NamedValue > aObject =
+ GetObjectPropsByStringClassID( GetExplicitlyRegisteredObjClassID( aMediaType ) );
+ if ( aObject.hasElements() )
+ return aObject;
+
+ OUString aDocumentName = GetDocServiceNameFromMediaType( aMediaType );
+ if ( !aDocumentName.isEmpty() )
+ return GetObjectPropsByDocumentName( aDocumentName );
+
+ return uno::Sequence< beans::NamedValue >();
+}
+
+
+uno::Sequence< beans::NamedValue > MimeConfigurationHelper::GetObjectPropsByFilter( const OUString& aFilterName )
+{
+ OUString aDocumentName = GetDocServiceNameFromFilter( aFilterName );
+ if ( !aDocumentName.isEmpty() )
+ return GetObjectPropsByDocumentName( aDocumentName );
+
+ return uno::Sequence< beans::NamedValue >();
+}
+
+
+uno::Sequence< beans::NamedValue > MimeConfigurationHelper::GetObjectPropsByDocumentName( std::u16string_view aDocName )
+{
+ if ( !aDocName.empty() )
+ {
+ uno::Reference< container::XNameAccess > xObjConfig = GetObjConfiguration();
+ if ( xObjConfig.is() )
+ {
+ try
+ {
+ const uno::Sequence< OUString > aClassIDs = xObjConfig->getElementNames();
+ for ( const OUString & id : aClassIDs )
+ {
+ uno::Reference< container::XNameAccess > xObjectProps;
+ OUString aEntryDocName;
+
+ if ( ( xObjConfig->getByName( id ) >>= xObjectProps ) && xObjectProps.is()
+ && ( xObjectProps->getByName("ObjectDocumentServiceName") >>= aEntryDocName )
+ && aEntryDocName == aDocName )
+ {
+ return GetObjPropsFromConfigEntry( GetSequenceClassIDRepresentation( id ),
+ xObjectProps );
+ }
+ }
+ }
+ catch( uno::Exception& )
+ {}
+ }
+ }
+
+ return uno::Sequence< beans::NamedValue >();
+}
+
+
+OUString MimeConfigurationHelper::GetFactoryNameByClassID( const uno::Sequence< sal_Int8 >& aClassID )
+{
+ return GetFactoryNameByStringClassID( GetStringClassIDRepresentation( aClassID ) );
+}
+
+
+OUString MimeConfigurationHelper::GetFactoryNameByStringClassID( const OUString& aStringClassID )
+{
+ OUString aResult;
+
+ if ( !aStringClassID.isEmpty() )
+ {
+ uno::Reference< container::XNameAccess > xObjConfig = GetObjConfiguration();
+ uno::Reference< container::XNameAccess > xObjectProps;
+ try
+ {
+ if ( xObjConfig.is() && ( xObjConfig->getByName( aStringClassID.toAsciiUpperCase() ) >>= xObjectProps ) && xObjectProps.is() )
+ xObjectProps->getByName("ObjectFactory") >>= aResult;
+ }
+ catch( uno::Exception& )
+ {
+ uno::Sequence< sal_Int8 > aClassID = GetSequenceClassIDRepresentation( aStringClassID );
+ if ( ClassIDsEqual( aClassID, GetSequenceClassID( SO3_DUMMY_CLASSID ) ) )
+ return "com.sun.star.embed.OOoSpecialEmbeddedObjectFactory";
+ }
+ }
+
+ return aResult;
+}
+
+
+OUString MimeConfigurationHelper::GetFactoryNameByDocumentName( std::u16string_view aDocName )
+{
+ OUString aResult;
+
+ if ( !aDocName.empty() )
+ {
+ uno::Reference< container::XNameAccess > xObjConfig = GetObjConfiguration();
+ if ( xObjConfig.is() )
+ {
+ try
+ {
+ const uno::Sequence< OUString > aClassIDs = xObjConfig->getElementNames();
+ for ( const OUString & id : aClassIDs )
+ {
+ uno::Reference< container::XNameAccess > xObjectProps;
+ OUString aEntryDocName;
+
+ if ( ( xObjConfig->getByName( id ) >>= xObjectProps ) && xObjectProps.is()
+ && ( xObjectProps->getByName( "ObjectDocumentServiceName" ) >>= aEntryDocName )
+ && aEntryDocName == aDocName )
+ {
+ xObjectProps->getByName("ObjectFactory") >>= aResult;
+ break;
+ }
+ }
+ }
+ catch( uno::Exception& )
+ {}
+ }
+ }
+
+ return aResult;
+}
+
+
+OUString MimeConfigurationHelper::GetFactoryNameByMediaType( const OUString& aMediaType )
+{
+ OUString aResult = GetFactoryNameByStringClassID( GetExplicitlyRegisteredObjClassID( aMediaType ) );
+
+ if ( aResult.isEmpty() )
+ {
+ OUString aDocumentName = GetDocServiceNameFromMediaType( aMediaType );
+ if ( !aDocumentName.isEmpty() )
+ aResult = GetFactoryNameByDocumentName( aDocumentName );
+ }
+
+ return aResult;
+}
+
+
+OUString MimeConfigurationHelper::UpdateMediaDescriptorWithFilterName(
+ uno::Sequence< beans::PropertyValue >& aMediaDescr,
+ bool bIgnoreType )
+{
+ OUString aFilterName;
+
+ for ( const auto & prop : std::as_const(aMediaDescr) )
+ if ( prop.Name == "FilterName" )
+ prop.Value >>= aFilterName;
+
+ if ( aFilterName.isEmpty() )
+ {
+ // filter name is not specified, so type detection should be done
+
+ uno::Reference< document::XTypeDetection > xTypeDetection(
+ m_xContext->getServiceManager()->createInstanceWithContext("com.sun.star.document.TypeDetection", m_xContext),
+ uno::UNO_QUERY_THROW );
+
+ // typedetection can change the mode, add a stream and so on, thus a copy should be used
+ uno::Sequence< beans::PropertyValue > aTempMD( aMediaDescr );
+
+ // get TypeName
+ OUString aTypeName = xTypeDetection->queryTypeByDescriptor( aTempMD, true );
+
+ // get FilterName
+ for ( const auto & prop : std::as_const(aTempMD) )
+ if ( prop.Name == "FilterName" )
+ prop.Value >>= aFilterName;
+
+ if ( !aFilterName.isEmpty() )
+ {
+ sal_Int32 nOldLen = aMediaDescr.getLength();
+ aMediaDescr.realloc( nOldLen + 1 );
+ auto pMediaDescr = aMediaDescr.getArray();
+ pMediaDescr[nOldLen].Name = "FilterName";
+ pMediaDescr[ nOldLen ].Value <<= aFilterName;
+
+ }
+ else if ( !aTypeName.isEmpty() && !bIgnoreType )
+ {
+ uno::Reference< container::XNameAccess > xNameAccess( xTypeDetection, uno::UNO_QUERY );
+ uno::Sequence< beans::PropertyValue > aTypes;
+
+ if ( xNameAccess.is() && ( xNameAccess->getByName( aTypeName ) >>= aTypes ) )
+ {
+ for ( const auto & prop : std::as_const(aTypes) )
+ {
+ if ( prop.Name == "PreferredFilter" && ( prop.Value >>= aFilterName ) )
+ {
+ sal_Int32 nOldLen = aMediaDescr.getLength();
+ aMediaDescr.realloc( nOldLen + 1 );
+ auto pMediaDescr = aMediaDescr.getArray();
+ pMediaDescr[nOldLen].Name = "FilterName";
+ pMediaDescr[ nOldLen ].Value = prop.Value;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ return aFilterName;
+}
+
+OUString MimeConfigurationHelper::UpdateMediaDescriptorWithFilterName(
+ uno::Sequence< beans::PropertyValue >& aMediaDescr,
+ uno::Sequence< beans::NamedValue >& aObject )
+{
+ OUString aDocName;
+ for ( const auto & nv : std::as_const(aObject) )
+ if ( nv.Name == "ObjectDocumentServiceName" )
+ {
+ nv.Value >>= aDocName;
+ break;
+ }
+
+ OSL_ENSURE( !aDocName.isEmpty(), "The name must exist at this point!" );
+
+
+ bool bNeedsAddition = true;
+ for ( sal_Int32 nMedInd = 0; nMedInd < aMediaDescr.getLength(); nMedInd++ )
+ if ( aMediaDescr[nMedInd].Name == "DocumentService" )
+ {
+ aMediaDescr.getArray()[nMedInd].Value <<= aDocName;
+ bNeedsAddition = false;
+ break;
+ }
+
+ if ( bNeedsAddition )
+ {
+ sal_Int32 nOldLen = aMediaDescr.getLength();
+ aMediaDescr.realloc( nOldLen + 1 );
+ auto pMediaDescr = aMediaDescr.getArray();
+ pMediaDescr[nOldLen].Name = "DocumentService";
+ pMediaDescr[nOldLen].Value <<= aDocName;
+ }
+
+ return UpdateMediaDescriptorWithFilterName( aMediaDescr, true );
+}
+
+#ifdef _WIN32
+
+SfxFilterFlags MimeConfigurationHelper::GetFilterFlags( const OUString& aFilterName )
+{
+ SfxFilterFlags nFlags = SfxFilterFlags::NONE;
+ try
+ {
+ if ( !aFilterName.isEmpty() )
+ {
+ uno::Reference< container::XNameAccess > xFilterFactory(
+ GetFilterFactory(),
+ uno::UNO_SET_THROW );
+
+ uno::Any aFilterAny = xFilterFactory->getByName( aFilterName );
+ uno::Sequence< beans::PropertyValue > aData;
+ if ( aFilterAny >>= aData )
+ {
+ SequenceAsHashMap aFilterHM( aData );
+ nFlags = static_cast<SfxFilterFlags>(aFilterHM.getUnpackedValueOrDefault( "Flags", sal_Int32(0) ));
+ }
+ }
+ } catch( uno::Exception& )
+ {}
+
+ return nFlags;
+}
+
+bool MimeConfigurationHelper::AddFilterNameCheckOwnFile(
+ uno::Sequence< beans::PropertyValue >& aMediaDescr )
+{
+ OUString aFilterName = UpdateMediaDescriptorWithFilterName( aMediaDescr, false );
+ if ( !aFilterName.isEmpty() )
+ {
+ SfxFilterFlags nFlags = GetFilterFlags( aFilterName );
+ // check the OWN flag
+ return bool(nFlags & SfxFilterFlags::OWN);
+ }
+
+ return false;
+}
+
+#endif
+
+OUString MimeConfigurationHelper::GetDefaultFilterFromServiceName( const OUString& aServiceName, sal_Int32 nVersion )
+{
+ OUString aResult;
+
+ if ( !aServiceName.isEmpty() && nVersion )
+ try
+ {
+ uno::Reference< container::XContainerQuery > xFilterQuery(
+ GetFilterFactory(),
+ uno::UNO_QUERY_THROW );
+
+ uno::Sequence< beans::NamedValue > aSearchRequest
+ {
+ { "DocumentService", css::uno::Any(aServiceName) },
+ { "FileFormatVersion", css::uno::Any(nVersion) }
+ };
+
+ uno::Reference< container::XEnumeration > xFilterEnum =
+ xFilterQuery->createSubSetEnumerationByProperties( aSearchRequest );
+
+ // use the first filter that is found
+ if ( xFilterEnum.is() )
+ while ( xFilterEnum->hasMoreElements() )
+ {
+ uno::Sequence< beans::PropertyValue > aProps;
+ if ( xFilterEnum->nextElement() >>= aProps )
+ {
+ SfxFilterFlags nFlags = SfxFilterFlags::NONE;
+ OUString sName;
+ for (const auto & rPropVal : aProps)
+ {
+ if (rPropVal.Name == "Flags")
+ {
+ sal_Int32 nTmp(0);
+ if (rPropVal.Value >>= nTmp)
+ nFlags = static_cast<SfxFilterFlags>(nTmp);
+ }
+ else if (rPropVal.Name == "Name")
+ rPropVal.Value >>= sName;
+ }
+
+ // that should be import, export, own filter and not a template filter ( TemplatePath flag )
+ SfxFilterFlags const nRequired = SfxFilterFlags::OWN
+ // fdo#78159 for OOoXML, there is code to convert
+ // to ODF in OCommonEmbeddedObject::store*
+ // so accept it even though there's no export
+ | (SOFFICE_FILEFORMAT_60 == nVersion ? SfxFilterFlags::NONE : SfxFilterFlags::EXPORT)
+ | SfxFilterFlags::IMPORT;
+ if ( ( ( nFlags & nRequired ) == nRequired ) && !( nFlags & SfxFilterFlags::TEMPLATEPATH ) )
+ {
+ // if there are more than one filter the preferred one should be used
+ // if there is no preferred filter the first one will be used
+ if ( aResult.isEmpty() || ( nFlags & SfxFilterFlags::PREFERED ) )
+ aResult = sName;
+ if ( nFlags & SfxFilterFlags::PREFERED )
+ break; // the preferred filter was found
+ }
+ }
+ }
+ }
+ catch( uno::Exception& )
+ {}
+
+ return aResult;
+}
+
+
+OUString MimeConfigurationHelper::GetExportFilterFromImportFilter( const OUString& aImportFilterName )
+{
+ OUString aExportFilterName;
+
+ try
+ {
+ if ( !aImportFilterName.isEmpty() )
+ {
+ uno::Reference< container::XNameAccess > xFilterFactory(
+ GetFilterFactory(),
+ uno::UNO_SET_THROW );
+
+ uno::Any aImpFilterAny = xFilterFactory->getByName( aImportFilterName );
+ uno::Sequence< beans::PropertyValue > aImpData;
+ if ( aImpFilterAny >>= aImpData )
+ {
+ SequenceAsHashMap aImpFilterHM( aImpData );
+ SfxFilterFlags nFlags = static_cast<SfxFilterFlags>(aImpFilterHM.getUnpackedValueOrDefault( "Flags", sal_Int32(0) ));
+
+ if ( !( nFlags & SfxFilterFlags::IMPORT ) )
+ {
+ OSL_FAIL( "This is no import filter!" );
+ throw uno::Exception("this is no import filter", nullptr);
+ }
+
+ if ( nFlags & SfxFilterFlags::EXPORT )
+ {
+ aExportFilterName = aImportFilterName;
+ }
+ else
+ {
+ OUString aDocumentServiceName = aImpFilterHM.getUnpackedValueOrDefault( "DocumentService", OUString() );
+ OUString aTypeName = aImpFilterHM.getUnpackedValueOrDefault( "Type", OUString() );
+
+ OSL_ENSURE( !aDocumentServiceName.isEmpty() && !aTypeName.isEmpty(), "Incomplete filter data!" );
+ if ( !(aDocumentServiceName.isEmpty() || aTypeName.isEmpty()) )
+ {
+ uno::Sequence< beans::NamedValue > aSearchRequest
+ {
+ { "Type", css::uno::Any(aTypeName) },
+ { "DocumentService", css::uno::Any(aDocumentServiceName) }
+ };
+
+ uno::Sequence< beans::PropertyValue > aExportFilterProps = SearchForFilter(
+ uno::Reference< container::XContainerQuery >( xFilterFactory, uno::UNO_QUERY_THROW ),
+ aSearchRequest,
+ SfxFilterFlags::EXPORT,
+ SfxFilterFlags::INTERNAL );
+
+ if ( aExportFilterProps.hasElements() )
+ {
+ SequenceAsHashMap aExpPropsHM( aExportFilterProps );
+ aExportFilterName = aExpPropsHM.getUnpackedValueOrDefault( "Name", OUString() );
+ }
+ }
+ }
+ }
+ }
+ }
+ catch( uno::Exception& )
+ {}
+
+ return aExportFilterName;
+}
+
+
+// static
+uno::Sequence< beans::PropertyValue > MimeConfigurationHelper::SearchForFilter(
+ const uno::Reference< container::XContainerQuery >& xFilterQuery,
+ const uno::Sequence< beans::NamedValue >& aSearchRequest,
+ SfxFilterFlags nMustFlags,
+ SfxFilterFlags nDontFlags )
+{
+ uno::Sequence< beans::PropertyValue > aFilterProps;
+ uno::Reference< container::XEnumeration > xFilterEnum =
+ xFilterQuery->createSubSetEnumerationByProperties( aSearchRequest );
+
+ // the first default filter will be taken,
+ // if there is no filter with flag default the first acceptable filter will be taken
+ if ( xFilterEnum.is() )
+ {
+ while ( xFilterEnum->hasMoreElements() )
+ {
+ uno::Sequence< beans::PropertyValue > aProps;
+ if ( xFilterEnum->nextElement() >>= aProps )
+ {
+ SequenceAsHashMap aPropsHM( aProps );
+ SfxFilterFlags nFlags = static_cast<SfxFilterFlags>(aPropsHM.getUnpackedValueOrDefault("Flags",
+ sal_Int32(0) ));
+ if ( ( ( nFlags & nMustFlags ) == nMustFlags ) && !( nFlags & nDontFlags ) )
+ {
+ if ( ( nFlags & SfxFilterFlags::DEFAULT ) == SfxFilterFlags::DEFAULT )
+ {
+ aFilterProps = aProps;
+ break;
+ }
+ else if ( !aFilterProps.hasElements() )
+ aFilterProps = aProps;
+ }
+ }
+ }
+ }
+
+ return aFilterProps;
+}
+
+
+bool MimeConfigurationHelper::ClassIDsEqual( const uno::Sequence< sal_Int8 >& aClassID1, const uno::Sequence< sal_Int8 >& aClassID2 )
+{
+ return aClassID1 == aClassID2;
+}
+
+
+uno::Sequence< sal_Int8 > MimeConfigurationHelper::GetSequenceClassID( sal_uInt32 n1, sal_uInt16 n2, sal_uInt16 n3,
+ sal_uInt8 b8, sal_uInt8 b9, sal_uInt8 b10, sal_uInt8 b11,
+ sal_uInt8 b12, sal_uInt8 b13, sal_uInt8 b14, sal_uInt8 b15 )
+{
+ uno::Sequence< sal_Int8 > aResult{ /* [ 0] */ static_cast<sal_Int8>( n1 >> 24 ),
+ /* [ 1] */ static_cast<sal_Int8>( ( n1 << 8 ) >> 24 ),
+ /* [ 2] */ static_cast<sal_Int8>( ( n1 << 16 ) >> 24 ),
+ /* [ 3] */ static_cast<sal_Int8>( ( n1 << 24 ) >> 24 ),
+ /* [ 4] */ static_cast<sal_Int8>( n2 >> 8 ),
+ /* [ 5] */ static_cast<sal_Int8>( ( n2 << 8 ) >> 8 ),
+ /* [ 6] */ static_cast<sal_Int8>( n3 >> 8 ),
+ /* [ 7] */ static_cast<sal_Int8>( ( n3 << 8 ) >> 8 ),
+ /* [ 8] */ static_cast<sal_Int8>( b8 ),
+ /* [ 9] */ static_cast<sal_Int8>( b9 ),
+ /* [10] */ static_cast<sal_Int8>( b10 ),
+ /* [11] */ static_cast<sal_Int8>( b11 ),
+ /* [12] */ static_cast<sal_Int8>( b12 ),
+ /* [13] */ static_cast<sal_Int8>( b13 ),
+ /* [14] */ static_cast<sal_Int8>( b14 ),
+ /* [15] */ static_cast<sal_Int8>( b15 ) };
+
+ return aResult;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/namedvaluecollection.cxx b/comphelper/source/misc/namedvaluecollection.cxx
new file mode 100644
index 000000000..11ef15b30
--- /dev/null
+++ b/comphelper/source/misc/namedvaluecollection.cxx
@@ -0,0 +1,308 @@
+/* -*- 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 <comphelper/namedvaluecollection.hxx>
+
+#include <com/sun/star/beans/NamedValue.hpp>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <com/sun/star/beans/PropertyState.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+
+#include <sal/log.hxx>
+
+#include <algorithm>
+#include <unordered_map>
+
+namespace comphelper
+{
+
+
+ using ::com::sun::star::uno::Any;
+ using ::com::sun::star::uno::Sequence;
+ using ::com::sun::star::beans::PropertyValue;
+ using ::com::sun::star::beans::NamedValue;
+ using ::com::sun::star::uno::Type;
+ using ::com::sun::star::uno::cpp_acquire;
+ using ::com::sun::star::uno::cpp_release;
+ using ::com::sun::star::uno::cpp_queryInterface;
+ using ::com::sun::star::lang::IllegalArgumentException;
+ using ::com::sun::star::beans::PropertyState_DIRECT_VALUE;
+
+ NamedValueCollection::NamedValueCollection( const Any& _rElements )
+ {
+ impl_assign( _rElements );
+ }
+
+
+ NamedValueCollection::NamedValueCollection( const Sequence< Any >& _rArguments )
+ {
+ impl_assign( _rArguments );
+ }
+
+
+ NamedValueCollection::NamedValueCollection( const Sequence< PropertyValue >& _rArguments )
+ {
+ impl_assign( _rArguments );
+ }
+
+
+ NamedValueCollection::NamedValueCollection( const Sequence< NamedValue >& _rArguments )
+ {
+ impl_assign( _rArguments );
+ }
+
+
+ bool NamedValueCollection::canExtractFrom( css::uno::Any const & i_value )
+ {
+ Type const & aValueType = i_value.getValueType();
+ return aValueType.equals( ::cppu::UnoType< PropertyValue >::get() )
+ || aValueType.equals( ::cppu::UnoType< NamedValue >::get() )
+ || aValueType.equals( ::cppu::UnoType< Sequence< PropertyValue > >::get() )
+ || aValueType.equals( ::cppu::UnoType< Sequence< NamedValue > >::get() );
+ }
+
+
+ NamedValueCollection& NamedValueCollection::merge( const NamedValueCollection& _rAdditionalValues, bool _bOverwriteExisting )
+ {
+ for (auto const& value : _rAdditionalValues.maValues)
+ {
+ if ( _bOverwriteExisting || !impl_has( value.first ) )
+ impl_put( value.first, value.second );
+ }
+
+ return *this;
+ }
+
+
+ size_t NamedValueCollection::size() const
+ {
+ return maValues.size();
+ }
+
+
+ bool NamedValueCollection::empty() const
+ {
+ return maValues.empty();
+ }
+
+
+ std::vector< OUString > NamedValueCollection::getNames() const
+ {
+ std::vector< OUString > aNames;
+ for (auto const& value : maValues)
+ {
+ aNames.push_back( value.first );
+ }
+ return aNames;
+ }
+
+
+ void NamedValueCollection::impl_assign( const Any& i_rWrappedElements )
+ {
+ Sequence< NamedValue > aNamedValues;
+ Sequence< PropertyValue > aPropertyValues;
+ NamedValue aNamedValue;
+ PropertyValue aPropertyValue;
+
+ if ( i_rWrappedElements >>= aNamedValues )
+ impl_assign( aNamedValues );
+ else if ( i_rWrappedElements >>= aPropertyValues )
+ impl_assign( aPropertyValues );
+ else if ( i_rWrappedElements >>= aNamedValue )
+ impl_assign( Sequence< NamedValue >( &aNamedValue, 1 ) );
+ else if ( i_rWrappedElements >>= aPropertyValue )
+ impl_assign( Sequence< PropertyValue >( &aPropertyValue, 1 ) );
+ else
+ SAL_WARN_IF( i_rWrappedElements.hasValue(), "comphelper", "NamedValueCollection::impl_assign(Any): unsupported type!" );
+ }
+
+
+ void NamedValueCollection::impl_assign( const Sequence< Any >& _rArguments )
+ {
+ maValues.clear();
+
+ PropertyValue aPropertyValue;
+ NamedValue aNamedValue;
+
+ for ( auto const & argument : _rArguments )
+ {
+ if ( argument >>= aPropertyValue )
+ maValues[ aPropertyValue.Name ] = aPropertyValue.Value;
+ else if ( argument >>= aNamedValue )
+ maValues[ aNamedValue.Name ] = aNamedValue.Value;
+ else
+ {
+ SAL_WARN_IF(
+ argument.hasValue(), "comphelper",
+ ("NamedValueCollection::impl_assign: encountered a value"
+ " type which I cannot handle: "
+ + argument.getValueTypeName()));
+ }
+ }
+ }
+
+
+ void NamedValueCollection::impl_assign( const Sequence< PropertyValue >& _rArguments )
+ {
+ maValues.clear();
+
+ for ( auto const & argument : _rArguments )
+ maValues[ argument.Name ] = argument.Value;
+ }
+
+
+ void NamedValueCollection::impl_assign( const Sequence< NamedValue >& _rArguments )
+ {
+ maValues.clear();
+
+ for ( auto const & argument : _rArguments )
+ maValues[ argument.Name ] = argument.Value;
+ }
+
+
+ bool NamedValueCollection::get_ensureType( const OUString& _rValueName, void* _pValueLocation, const Type& _rExpectedValueType ) const
+ {
+ auto pos = maValues.find( _rValueName );
+ if ( pos == maValues.end() )
+ // argument does not exist
+ return false;
+
+ if ( uno_type_assignData(
+ _pValueLocation, _rExpectedValueType.getTypeLibType(),
+ const_cast< void* >( pos->second.getValue() ), pos->second.getValueType().getTypeLibType(),
+ reinterpret_cast< uno_QueryInterfaceFunc >( cpp_queryInterface ),
+ reinterpret_cast< uno_AcquireFunc >( cpp_acquire ),
+ reinterpret_cast< uno_ReleaseFunc >( cpp_release )
+ ) )
+ // argument exists, and could be extracted
+ return true;
+
+ // argument exists, but is of wrong type
+ throw IllegalArgumentException(
+ "Invalid value type for '" + _rValueName
+ + "'.\nExpected: " + _rExpectedValueType.getTypeName()
+ + "\nFound: " + pos->second.getValueType().getTypeName(),
+ nullptr, 0 );
+ }
+
+ // static
+ bool NamedValueCollection::get_ensureType( const css::uno::Sequence<css::beans::PropertyValue>& rPropSeq,
+ std::u16string_view _rValueName, void* _pValueLocation, const Type& _rExpectedValueType )
+ {
+ for (const css::beans::PropertyValue& rPropVal : rPropSeq)
+ {
+ if (rPropVal.Name == _rValueName)
+ {
+ if ( uno_type_assignData(
+ _pValueLocation, _rExpectedValueType.getTypeLibType(),
+ const_cast< void* >( rPropVal.Value.getValue() ), rPropVal.Value.getValueType().getTypeLibType(),
+ reinterpret_cast< uno_QueryInterfaceFunc >( cpp_queryInterface ),
+ reinterpret_cast< uno_AcquireFunc >( cpp_acquire ),
+ reinterpret_cast< uno_ReleaseFunc >( cpp_release )
+ ) )
+ // argument exists, and could be extracted
+ return true;
+
+ // argument exists, but is of wrong type
+ throw IllegalArgumentException(
+ OUString::Concat("Invalid value type for '") + _rValueName
+ + "'.\nExpected: " + _rExpectedValueType.getTypeName()
+ + "\nFound: " + rPropVal.Value.getValueType().getTypeName(),
+ nullptr, 0 );
+ }
+ }
+ // argument does not exist
+ return false;
+ }
+
+ // static
+ const css::uno::Any& NamedValueCollection::get( const css::uno::Sequence<css::beans::PropertyValue>& rPropSeq,
+ std::u16string_view _rValueName )
+ {
+ static const Any theEmptyDefault;
+ for (const css::beans::PropertyValue& rPropVal : rPropSeq)
+ {
+ if (rPropVal.Name == _rValueName)
+ {
+ return rPropVal.Value;
+ }
+ }
+ return theEmptyDefault;
+ }
+
+ const Any& NamedValueCollection::impl_get( const OUString& _rValueName ) const
+ {
+ static const Any theEmptyDefault;
+ auto pos = maValues.find( _rValueName );
+ if ( pos != maValues.end() )
+ return pos->second;
+
+ return theEmptyDefault;
+ }
+
+
+ bool NamedValueCollection::impl_has( const OUString& _rValueName ) const
+ {
+ auto pos = maValues.find( _rValueName );
+ return ( pos != maValues.end() );
+ }
+
+
+ bool NamedValueCollection::impl_put( const OUString& _rValueName, const Any& _rValue )
+ {
+ bool bHas = impl_has( _rValueName );
+ maValues[ _rValueName ] = _rValue;
+ return bHas;
+ }
+
+
+ bool NamedValueCollection::impl_remove( const OUString& _rValueName )
+ {
+ auto pos = maValues.find( _rValueName );
+ if ( pos == maValues.end() )
+ return false;
+ maValues.erase( pos );
+ return true;
+ }
+
+
+ sal_Int32 NamedValueCollection::operator >>= ( Sequence< PropertyValue >& _out_rValues ) const
+ {
+ _out_rValues.realloc( maValues.size() );
+ std::transform( maValues.begin(), maValues.end(), _out_rValues.getArray(),
+ [](const std::pair< OUString, css::uno::Any >& _rValue)
+ { return PropertyValue( _rValue.first, 0, _rValue.second, PropertyState_DIRECT_VALUE ); } );
+ return _out_rValues.getLength();
+ }
+
+
+ sal_Int32 NamedValueCollection::operator >>= ( Sequence< NamedValue >& _out_rValues ) const
+ {
+ _out_rValues.realloc( maValues.size() );
+ std::transform( maValues.begin(), maValues.end(), _out_rValues.getArray(),
+ [](const std::pair< OUString, css::uno::Any >& _rValue)
+ { return NamedValue( _rValue.first, _rValue.second ); } );
+ return _out_rValues.getLength();
+ }
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/numberedcollection.cxx b/comphelper/source/misc/numberedcollection.cxx
new file mode 100644
index 000000000..80d33776c
--- /dev/null
+++ b/comphelper/source/misc/numberedcollection.cxx
@@ -0,0 +1,213 @@
+/* -*- 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 <algorithm>
+#include <comphelper/numberedcollection.hxx>
+#include <com/sun/star/frame/UntitledNumbersConst.hpp>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+
+namespace comphelper{
+
+constexpr OUStringLiteral ERRMSG_INVALID_COMPONENT_PARAM = u"NULL as component reference not allowed.";
+
+
+NumberedCollection::NumberedCollection()
+{
+}
+
+
+NumberedCollection::~NumberedCollection()
+{
+}
+
+
+void NumberedCollection::setOwner(const css::uno::Reference< css::uno::XInterface >& xOwner)
+{
+ // SYNCHRONIZED ->
+ std::scoped_lock aLock(m_aMutex);
+
+ m_xOwner = xOwner;
+
+ // <- SYNCHRONIZED
+}
+
+
+void NumberedCollection::setUntitledPrefix(const OUString& sPrefix)
+{
+ // SYNCHRONIZED ->
+ std::scoped_lock aLock(m_aMutex);
+
+ m_sUntitledPrefix = sPrefix;
+
+ // <- SYNCHRONIZED
+}
+
+
+::sal_Int32 SAL_CALL NumberedCollection::leaseNumber(const css::uno::Reference< css::uno::XInterface >& xComponent)
+{
+ // SYNCHRONIZED ->
+ std::scoped_lock aLock(m_aMutex);
+
+ if ( ! xComponent.is ())
+ throw css::lang::IllegalArgumentException(ERRMSG_INVALID_COMPONENT_PARAM, m_xOwner.get(), 1);
+
+ sal_IntPtr pComponent = reinterpret_cast<sal_IntPtr>( xComponent.get() );
+ TNumberedItemHash::const_iterator pIt = m_lComponents.find (pComponent);
+
+ // a) component already exists - return its number directly
+ if (pIt != m_lComponents.end())
+ return pIt->second.nNumber;
+
+ // b) component must be added new to this container
+
+ // b1) collection is full - no further components possible
+ // -> return INVALID_NUMBER
+ ::sal_Int32 nFreeNumber = impl_searchFreeNumber();
+ if (nFreeNumber == css::frame::UntitledNumbersConst::INVALID_NUMBER)
+ return css::frame::UntitledNumbersConst::INVALID_NUMBER;
+
+ // b2) add component to collection and return its number
+ TNumberedItem aItem;
+ aItem.xItem = css::uno::WeakReference< css::uno::XInterface >(xComponent);
+ aItem.nNumber = nFreeNumber;
+ m_lComponents[pComponent] = aItem;
+
+ return nFreeNumber;
+
+ // <- SYNCHRONIZED
+}
+
+
+void SAL_CALL NumberedCollection::releaseNumber(::sal_Int32 nNumber)
+{
+ // SYNCHRONIZED ->
+ std::scoped_lock aLock(m_aMutex);
+
+ if (nNumber == css::frame::UntitledNumbersConst::INVALID_NUMBER)
+ throw css::lang::IllegalArgumentException ("Special value INVALID_NUMBER not allowed as input parameter.", m_xOwner.get(), 1);
+
+ TDeadItemList lDeadItems;
+ TNumberedItemHash::iterator pComponent;
+
+ for ( pComponent = m_lComponents.begin ();
+ pComponent != m_lComponents.end ();
+ ++pComponent )
+ {
+ const TNumberedItem& rItem = pComponent->second;
+ const css::uno::Reference< css::uno::XInterface > xItem = rItem.xItem.get();
+
+ if ( ! xItem.is ())
+ {
+ lDeadItems.push_back(pComponent->first);
+ continue;
+ }
+
+ if (rItem.nNumber == nNumber)
+ {
+ m_lComponents.erase (pComponent);
+ break;
+ }
+ }
+
+ impl_cleanUpDeadItems(m_lComponents, lDeadItems);
+
+ // <- SYNCHRONIZED
+}
+
+
+void SAL_CALL NumberedCollection::releaseNumberForComponent(const css::uno::Reference< css::uno::XInterface >& xComponent)
+{
+ // SYNCHRONIZED ->
+ std::scoped_lock aLock(m_aMutex);
+
+ if ( ! xComponent.is ())
+ throw css::lang::IllegalArgumentException(ERRMSG_INVALID_COMPONENT_PARAM, m_xOwner.get(), 1);
+
+ sal_IntPtr pComponent = reinterpret_cast<sal_IntPtr>( xComponent.get() );
+ TNumberedItemHash::iterator pIt = m_lComponents.find (pComponent);
+
+ // a) component exists and will be removed
+ if (pIt != m_lComponents.end())
+ m_lComponents.erase(pIt);
+
+ // else
+ // b) component does not exists - nothing todo here (ignore request!)
+
+ // <- SYNCHRONIZED
+}
+
+
+OUString SAL_CALL NumberedCollection::getUntitledPrefix()
+{
+ // SYNCHRONIZED ->
+ std::scoped_lock aLock(m_aMutex);
+
+ return m_sUntitledPrefix;
+
+ // <- SYNCHRONIZED
+}
+
+
+/** create an ordered list of all possible numbers ...
+ e.g. {1,2,3,...,N} Max size of these list will be
+ current size of component list + 1 .
+
+ "+1" ... because in case all numbers in range 1..n
+ are in use we need a new number n+1 :-)
+
+ Every item which is already used as unique number
+ will be removed. At the end a list of e.g. {3,6,...,M}
+ exists where the first item represent the lowest free
+ number (in this example 3).
+ */
+::sal_Int32 NumberedCollection::impl_searchFreeNumber ()
+{
+ // create bitset, where each position represents one possible number.
+ std::vector<bool> aUsedNumbers((m_lComponents.size() * 2) + 1, false);
+
+ for (const auto& rPair : m_lComponents)
+ {
+ // numbers start at 1
+ sal_Int32 pos = rPair.second.nNumber - 1;
+ if (pos >= static_cast<sal_Int32>(aUsedNumbers.size()))
+ aUsedNumbers.resize(pos * 2, false); // should be rare
+ aUsedNumbers[pos] = true;
+ }
+
+ // a) non free numbers ... return INVALID_NUMBER
+ auto it = std::find(aUsedNumbers.begin(), aUsedNumbers.end(), false);
+ if (it == aUsedNumbers.end())
+ return css::frame::UntitledNumbersConst::INVALID_NUMBER;
+
+ // b) return first free number
+ return it - aUsedNumbers.begin() + 1;
+}
+
+void NumberedCollection::impl_cleanUpDeadItems ( TNumberedItemHash& lItems ,
+ const TDeadItemList& lDeadItems)
+{
+ for (const sal_IntPtr& rDeadItem : lDeadItems)
+ {
+ lItems.erase(rDeadItem);
+ }
+}
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/numbers.cxx b/comphelper/source/misc/numbers.cxx
new file mode 100644
index 000000000..f3b609392
--- /dev/null
+++ b/comphelper/source/misc/numbers.cxx
@@ -0,0 +1,120 @@
+/* -*- 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 <comphelper/numbers.hxx>
+#include <osl/diagnose.h>
+#include <sal/log.hxx>
+#include <com/sun/star/util/NumberFormat.hpp>
+#include <com/sun/star/util/XNumberFormatter.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+
+
+namespace comphelper
+{
+
+sal_Int16 getNumberFormatType(const css::uno::Reference<css::util::XNumberFormats>& xFormats, sal_Int32 nKey)
+{
+ sal_Int16 nReturn(css::util::NumberFormat::UNDEFINED);
+ if (xFormats.is())
+ {
+ try
+ {
+ css::uno::Reference<css::beans::XPropertySet> xFormat(xFormats->getByKey(nKey));
+ if (xFormat.is())
+ xFormat->getPropertyValue("Type") >>= nReturn;
+ }
+ catch(...)
+ {
+ SAL_WARN("comphelper", "getNumberFormatType : invalid key! (maybe created with another formatter ?)");
+ }
+ }
+ return nReturn;
+}
+
+
+sal_Int16 getNumberFormatType(const css::uno::Reference<css::util::XNumberFormatter>& xFormatter, sal_Int32 nKey)
+{
+ OSL_ENSURE(xFormatter.is(), "getNumberFormatType : the formatter isn't valid !");
+ css::uno::Reference<css::util::XNumberFormatsSupplier> xSupplier( xFormatter->getNumberFormatsSupplier());
+ OSL_ENSURE(xSupplier.is(), "getNumberFormatType : the formatter doesn't implement a supplier !");
+ css::uno::Reference<css::util::XNumberFormats> xFormats( xSupplier->getNumberFormats());
+ return getNumberFormatType(xFormats, nKey);
+}
+
+
+css::uno::Any getNumberFormatDecimals(const css::uno::Reference<css::util::XNumberFormats>& xFormats, sal_Int32 nKey)
+{
+ if (xFormats.is())
+ {
+ try
+ {
+ css::uno::Reference<css::beans::XPropertySet> xFormat( xFormats->getByKey(nKey));
+ if (xFormat.is())
+ {
+ return xFormat->getPropertyValue( "Decimals" );
+ }
+ }
+ catch(...)
+ {
+ SAL_WARN("comphelper", "getNumberFormatDecimals : invalid key! (may be created with another formatter ?)");
+ }
+ }
+ return css::uno::Any(sal_Int16(0));
+}
+
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::beans;
+
+
+Any getNumberFormatProperty( const Reference< XNumberFormatter >& _rxFormatter, sal_Int32 _nKey, const OUString& _rPropertyName )
+{
+ Any aReturn;
+
+ OSL_ENSURE( _rxFormatter.is() && !_rPropertyName.isEmpty(), "getNumberFormatProperty: invalid arguments!" );
+ try
+ {
+ Reference< XNumberFormatsSupplier > xSupplier;
+ Reference< XNumberFormats > xFormats;
+ Reference< XPropertySet > xFormatProperties;
+
+ if ( _rxFormatter.is() )
+ xSupplier = _rxFormatter->getNumberFormatsSupplier();
+ if ( xSupplier.is() )
+ xFormats = xSupplier->getNumberFormats();
+ if ( xFormats.is() )
+ xFormatProperties = xFormats->getByKey( _nKey );
+
+ if ( xFormatProperties.is() )
+ aReturn = xFormatProperties->getPropertyValue( _rPropertyName );
+ }
+ catch( const Exception& )
+ {
+ OSL_FAIL( "::getNumberFormatProperty: caught an exception (did you create the key with another formatter?)!" );
+ }
+
+ return aReturn;
+}
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/officerestartmanager.cxx b/comphelper/source/misc/officerestartmanager.cxx
new file mode 100644
index 000000000..39c61a4e5
--- /dev/null
+++ b/comphelper/source/misc/officerestartmanager.cxx
@@ -0,0 +1,157 @@
+/* -*- 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 <com/sun/star/lang/XMultiComponentFactory.hpp>
+#include <com/sun/star/awt/XRequestCallback.hpp>
+#include <com/sun/star/frame/Desktop.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+
+#include <cppuhelper/supportsservice.hxx>
+#include "officerestartmanager.hxx"
+
+using namespace ::com::sun::star;
+
+namespace comphelper
+{
+
+// XRestartManager
+
+void SAL_CALL OOfficeRestartManager::requestRestart( const uno::Reference< task::XInteractionHandler >& /* xInteractionHandler */ )
+{
+ if ( !m_xContext.is() )
+ throw uno::RuntimeException();
+
+ {
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ // if the restart already running there is no need to trigger it again
+ if ( m_bRestartRequested )
+ return;
+
+ m_bRestartRequested = true;
+
+ // the office is still not initialized, no need to terminate, changing the state is enough
+ if ( !m_bOfficeInitialized )
+ return;
+ }
+
+ // TODO: use InteractionHandler to report errors
+ try
+ {
+ // register itself as a job that should be executed asynchronously
+ uno::Reference< lang::XMultiComponentFactory > xFactory( m_xContext->getServiceManager(), uno::UNO_SET_THROW );
+
+ uno::Reference< awt::XRequestCallback > xRequestCallback(
+ xFactory->createInstanceWithContext(
+ "com.sun.star.awt.AsyncCallback",
+ m_xContext ),
+ uno::UNO_QUERY_THROW );
+
+ xRequestCallback->addCallback( this, uno::Any() );
+ }
+ catch ( uno::Exception& )
+ {
+ // the try to request restart has failed
+ m_bRestartRequested = false;
+ }
+}
+
+
+sal_Bool SAL_CALL OOfficeRestartManager::isRestartRequested( sal_Bool bOfficeInitialized )
+{
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ if ( bOfficeInitialized && !m_bOfficeInitialized )
+ m_bOfficeInitialized = bOfficeInitialized;
+
+ return m_bRestartRequested;
+}
+
+// XCallback
+
+void SAL_CALL OOfficeRestartManager::notify( const uno::Any& /* aData */ )
+{
+ try
+ {
+ bool bSuccess = false;
+
+ if ( m_xContext.is() )
+ {
+ uno::Reference< frame::XDesktop2 > xDesktop = frame::Desktop::create(m_xContext);
+
+ // Turn Quickstarter veto off
+ uno::Reference< beans::XPropertySet > xPropertySet( xDesktop, uno::UNO_QUERY_THROW );
+ OUString aVetoPropName( "SuspendQuickstartVeto" );
+ uno::Any aValue;
+ aValue <<= true;
+ xPropertySet->setPropertyValue( aVetoPropName, aValue );
+
+ try
+ {
+ bSuccess = xDesktop->terminate();
+ } catch( uno::Exception& )
+ {}
+
+ if ( !bSuccess )
+ {
+ aValue <<= false;
+ xPropertySet->setPropertyValue( aVetoPropName, aValue );
+ }
+ }
+
+ if ( !bSuccess )
+ m_bRestartRequested = false;
+ }
+ catch( uno::Exception& )
+ {
+ // the try to restart has failed
+ m_bRestartRequested = false;
+ }
+}
+
+// XServiceInfo
+
+OUString SAL_CALL OOfficeRestartManager::getImplementationName()
+{
+ return "com.sun.star.comp.task.OfficeRestartManager";
+}
+
+sal_Bool SAL_CALL OOfficeRestartManager::supportsService( const OUString& aServiceName )
+{
+ return cppu::supportsService(this, aServiceName);
+}
+
+uno::Sequence< OUString > SAL_CALL OOfficeRestartManager::getSupportedServiceNames()
+{
+ return { "com.sun.star.comp.task.OfficeRestartManager" };
+}
+
+} // namespace comphelper
+
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_task_OfficeRestartManager(
+ css::uno::XComponentContext *context,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new comphelper::OOfficeRestartManager(context));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/officerestartmanager.hxx b/comphelper/source/misc/officerestartmanager.hxx
new file mode 100644
index 000000000..bc95668b9
--- /dev/null
+++ b/comphelper/source/misc/officerestartmanager.hxx
@@ -0,0 +1,67 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <com/sun/star/task/XRestartManager.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/awt/XCallback.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+
+#include <osl/mutex.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <utility>
+
+namespace comphelper
+{
+
+class OOfficeRestartManager : public ::cppu::WeakImplHelper< css::task::XRestartManager
+ , css::awt::XCallback
+ , css::lang::XServiceInfo >
+{
+ ::osl::Mutex m_aMutex;
+ css::uno::Reference< css::uno::XComponentContext > m_xContext;
+
+ bool m_bOfficeInitialized;
+ bool m_bRestartRequested;
+
+public:
+ explicit OOfficeRestartManager( css::uno::Reference< css::uno::XComponentContext > xContext )
+ : m_xContext(std::move( xContext ))
+ , m_bOfficeInitialized( false )
+ , m_bRestartRequested( false )
+ {}
+
+// XRestartManager
+ virtual void SAL_CALL requestRestart( const css::uno::Reference< css::task::XInteractionHandler >& xInteractionHandler ) override;
+ virtual sal_Bool SAL_CALL isRestartRequested( sal_Bool bInitialized ) override;
+
+// XCallback
+ virtual void SAL_CALL notify( const css::uno::Any& aData ) override;
+
+// XServiceInfo
+ virtual OUString SAL_CALL getImplementationName( ) override;
+ virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+ virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames( ) override;
+
+};
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/proxyaggregation.cxx b/comphelper/source/misc/proxyaggregation.cxx
new file mode 100644
index 000000000..db580bea4
--- /dev/null
+++ b/comphelper/source/misc/proxyaggregation.cxx
@@ -0,0 +1,243 @@
+/* -*- 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 <sal/config.h>
+
+#include <cassert>
+
+#include <comphelper/proxyaggregation.hxx>
+#include <com/sun/star/reflection/ProxyFactory.hpp>
+
+
+namespace comphelper
+{
+
+
+ using namespace ::com::sun::star::uno;
+ using namespace ::com::sun::star::lang;
+ using namespace ::com::sun::star::reflection;
+
+ OProxyAggregation::OProxyAggregation( const Reference< XComponentContext >& _rxContext )
+ :m_xContext( _rxContext )
+ {
+ }
+
+
+ void OProxyAggregation::baseAggregateProxyFor( const Reference< XInterface >& _rxComponent, oslInterlockedCount& _rRefCount,
+ ::cppu::OWeakObject& _rDelegator )
+ {
+ // first a factory for the proxy
+ Reference< XProxyFactory > xFactory = ProxyFactory::create( m_xContext );
+
+ // then the proxy itself
+ { // i36686 OJ: achieve the destruction of the temporary -> otherwise it leads to _rRefCount -= 2
+ m_xProxyAggregate = xFactory->createProxy( _rxComponent );
+ }
+ if ( m_xProxyAggregate.is() )
+ m_xProxyAggregate->queryAggregation( cppu::UnoType<decltype(m_xProxyTypeAccess)>::get() ) >>= m_xProxyTypeAccess;
+
+ // aggregate the proxy
+ osl_atomic_increment( &_rRefCount );
+ if ( m_xProxyAggregate.is() )
+ {
+ // At this point in time, the proxy has a ref count of exactly two - in m_xControlContextProxy,
+ // and in m_xProxyTypeAccess.
+ // Remember to _not_ reset these members unless the delegator of the proxy has been reset, too!
+ m_xProxyAggregate->setDelegator( _rDelegator );
+ }
+ osl_atomic_decrement( &_rRefCount );
+ }
+
+
+ Any SAL_CALL OProxyAggregation::queryAggregation( const Type& _rType )
+ {
+ return m_xProxyAggregate.is() ? m_xProxyAggregate->queryAggregation( _rType ) : Any();
+ }
+
+
+ Sequence< Type > SAL_CALL OProxyAggregation::getTypes( )
+ {
+ Sequence< Type > aTypes;
+ if ( m_xProxyAggregate.is() )
+ {
+ if ( m_xProxyTypeAccess.is() )
+ aTypes = m_xProxyTypeAccess->getTypes();
+ }
+ return aTypes;
+ }
+
+
+ OProxyAggregation::~OProxyAggregation()
+ {
+ if ( m_xProxyAggregate.is() )
+ m_xProxyAggregate->setDelegator( nullptr );
+ m_xProxyAggregate.clear();
+ m_xProxyTypeAccess.clear();
+ // this should remove the _two_only_ "real" references (means not delegated to
+ // ourself) to this proxy, and thus delete it
+ }
+
+ OComponentProxyAggregationHelper::OComponentProxyAggregationHelper( const Reference< XComponentContext >& _rxContext,
+ ::cppu::OBroadcastHelper& _rBHelper )
+ :OProxyAggregation( _rxContext )
+ ,m_rBHelper( _rBHelper )
+ {
+ OSL_ENSURE( _rxContext.is(), "OComponentProxyAggregationHelper::OComponentProxyAggregationHelper: invalid arguments!" );
+ }
+
+
+ void OComponentProxyAggregationHelper::componentAggregateProxyFor(
+ const Reference< XComponent >& _rxComponent, oslInterlockedCount& _rRefCount,
+ ::cppu::OWeakObject& _rDelegator )
+ {
+ OSL_ENSURE( _rxComponent.is(), "OComponentProxyAggregationHelper::componentAggregateProxyFor: invalid inner component!" );
+ m_xInner = _rxComponent;
+
+ // aggregate a proxy for the object
+ baseAggregateProxyFor( m_xInner, _rRefCount, _rDelegator );
+
+ // add as event listener to the inner context, because we want to be notified of disposals
+ osl_atomic_increment( &_rRefCount );
+ {
+ if ( m_xInner.is() )
+ m_xInner->addEventListener( this );
+ }
+ osl_atomic_decrement( &_rRefCount );
+ }
+
+
+ Any SAL_CALL OComponentProxyAggregationHelper::queryInterface( const Type& _rType )
+ {
+ Any aReturn( BASE::queryInterface( _rType ) );
+ if ( !aReturn.hasValue() )
+ aReturn = OProxyAggregation::queryAggregation( _rType );
+ return aReturn;
+ }
+
+
+ IMPLEMENT_FORWARD_XTYPEPROVIDER2( OComponentProxyAggregationHelper, BASE, OProxyAggregation )
+
+
+ OComponentProxyAggregationHelper::~OComponentProxyAggregationHelper( )
+ {
+ OSL_ENSURE( m_rBHelper.bDisposed, "OComponentProxyAggregationHelper::~OComponentProxyAggregationHelper: you should dispose your derived class in the dtor, if necessary!" );
+ // if this asserts, add the following to your derived class dtor:
+
+ // if ( !m_rBHelper.bDisposed )
+ // {
+ // acquire(); // to prevent duplicate dtor calls
+ // dispose();
+ // }
+
+ m_xInner.clear();
+ }
+
+
+ void SAL_CALL OComponentProxyAggregationHelper::disposing( const EventObject& _rSource )
+ {
+ if ( _rSource.Source == m_xInner )
+ { // it's our inner context which is dying -> dispose ourself
+ if ( !m_rBHelper.bDisposed && !m_rBHelper.bInDispose )
+ { // (if necessary only, of course)
+ dispose();
+ }
+ }
+ }
+
+
+ void SAL_CALL OComponentProxyAggregationHelper::dispose()
+ {
+ ::osl::MutexGuard aGuard( m_rBHelper.rMutex );
+
+ // dispose our inner context
+ // before we do this, remove ourself as listener - else in disposing( EventObject ), we
+ // would dispose ourself a second time
+ if ( m_xInner.is() )
+ {
+ m_xInner->removeEventListener( this );
+ m_xInner->dispose();
+ m_xInner.clear();
+ }
+ }
+
+ OComponentProxyAggregation::OComponentProxyAggregation( const Reference< XComponentContext >& _rxContext,
+ const Reference< XComponent >& _rxComponent )
+ :WeakComponentImplHelperBase( m_aMutex )
+ ,OComponentProxyAggregationHelper( _rxContext, rBHelper )
+ {
+ OSL_ENSURE( _rxComponent.is(), "OComponentProxyAggregation::OComponentProxyAggregation: accessible is no XComponent!" );
+ if ( _rxComponent.is() )
+ componentAggregateProxyFor( _rxComponent, m_refCount, *this );
+ }
+
+
+ OComponentProxyAggregation::~OComponentProxyAggregation()
+ {
+ if ( !rBHelper.bDisposed )
+ {
+ acquire(); // to prevent duplicate dtor calls
+ dispose();
+ }
+ }
+
+
+ IMPLEMENT_FORWARD_XINTERFACE2( OComponentProxyAggregation, WeakComponentImplHelperBase, OComponentProxyAggregationHelper )
+
+
+ IMPLEMENT_GET_IMPLEMENTATION_ID( OComponentProxyAggregation )
+
+
+ Sequence< Type > SAL_CALL OComponentProxyAggregation::getTypes( )
+ {
+ return comphelper::concatSequences(
+ OComponentProxyAggregationHelper::getTypes(),
+ // append XComponent, coming from WeakComponentImplHelperBase
+ Sequence { cppu::UnoType<XComponent>::get() });
+ }
+
+
+ void SAL_CALL OComponentProxyAggregation::disposing( const EventObject& _rSource )
+ {
+ // Simply disambiguate---this is necessary for MSVC to distinguish
+ // "disposing(EventObject)" from "disposing()"; but it is also a good
+ // place to check for recursive calls that would be caused by an object
+ // being registered as an XEventListener at itself (cf. rhbz#928568):
+ assert(_rSource.Source != static_cast< cppu::OWeakObject * >(this));
+ OComponentProxyAggregationHelper::disposing( _rSource );
+ }
+
+
+ void SAL_CALL OComponentProxyAggregation::disposing()
+ {
+ // call the dispose-functionality of the base, which will dispose our aggregated component
+ OComponentProxyAggregationHelper::dispose();
+ }
+
+
+ void SAL_CALL OComponentProxyAggregation::dispose()
+ {
+ // simply disambiguate
+ WeakComponentImplHelperBase::dispose();
+ }
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/random.cxx b/comphelper/source/misc/random.cxx
new file mode 100644
index 000000000..96d466641
--- /dev/null
+++ b/comphelper/source/misc/random.cxx
@@ -0,0 +1,123 @@
+/* -*- 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/.
+ *
+ * Contributor(s):
+ * Copyright (C) 2012 Tino Kluge <tino.kluge@hrz.tu-chemnitz.de>
+ */
+
+#include <comphelper/random.hxx>
+#include <sal/log.hxx>
+#include <assert.h>
+#include <time.h>
+#include <mutex>
+#include <random>
+#include <stdexcept>
+#if defined HAVE_VALGRIND_HEADERS
+#include <valgrind/memcheck.h>
+#endif
+
+// this is nothing but a simple wrapper around
+// the std::random generators
+
+namespace comphelper::rng
+{
+// underlying random number generator
+// std::mt19937 implements the Mersenne twister algorithm which
+// is fast and has good statistical properties, it produces integers
+// in the range of [0, 2^32-1] internally
+// memory requirement: 625*sizeof(uint32_t)
+// http://en.wikipedia.org/wiki/Mersenne_twister
+#define STD_RNG_ALGO std::mt19937
+
+namespace
+{
+struct RandomNumberGenerator
+{
+ std::mutex mutex;
+ STD_RNG_ALGO global_rng;
+ RandomNumberGenerator()
+ {
+ // make RR easier to use, breaks easily without the RNG being repeatable
+ bool bRepeatable = (getenv("SAL_RAND_REPEATABLE") != nullptr) || (getenv("RR") != nullptr);
+ // valgrind on some platforms (e.g.Ubuntu16.04) does not support the new Intel RDRAND instructions,
+ // which leads to "Illegal Opcode" errors, so just turn off randomness.
+#if defined HAVE_VALGRIND_HEADERS
+ if (RUNNING_ON_VALGRIND)
+ bRepeatable = true;
+#endif
+ if (bRepeatable)
+ {
+ global_rng.seed(42);
+ return;
+ }
+
+ try
+ {
+ std::random_device rd;
+ // initialises the state of the global random number generator
+ // should only be called once.
+ // (note, a few std::variate_generator<> (like normal) have their
+ // own state which would need a reset as well to guarantee identical
+ // sequence of numbers, e.g. via myrand.distribution().reset())
+ global_rng.seed(rd() ^ time(nullptr));
+ }
+ catch (std::runtime_error& e)
+ {
+ SAL_WARN("comphelper", "Using std::random_device failed: " << e.what());
+ global_rng.seed(time(nullptr));
+ }
+ }
+};
+
+RandomNumberGenerator& GetTheRandomNumberGenerator()
+{
+ static RandomNumberGenerator RANDOM;
+ return RANDOM;
+}
+}
+
+// uniform ints [a,b] distribution
+int uniform_int_distribution(int a, int b)
+{
+ std::uniform_int_distribution<int> dist(a, b);
+ auto& gen = GetTheRandomNumberGenerator();
+ std::scoped_lock<std::mutex> g(gen.mutex);
+ return dist(gen.global_rng);
+}
+
+// uniform ints [a,b] distribution
+unsigned int uniform_uint_distribution(unsigned int a, unsigned int b)
+{
+ std::uniform_int_distribution<unsigned int> dist(a, b);
+ auto& gen = GetTheRandomNumberGenerator();
+ std::scoped_lock<std::mutex> g(gen.mutex);
+ return dist(gen.global_rng);
+}
+
+// uniform size_t [a,b] distribution
+size_t uniform_size_distribution(size_t a, size_t b)
+{
+ std::uniform_int_distribution<size_t> dist(a, b);
+ auto& gen = GetTheRandomNumberGenerator();
+ std::scoped_lock<std::mutex> g(gen.mutex);
+ return dist(gen.global_rng);
+}
+
+// uniform size_t [a,b) distribution
+double uniform_real_distribution(double a, double b)
+{
+ assert(a < b);
+ std::uniform_real_distribution<double> dist(a, b);
+ auto& gen = GetTheRandomNumberGenerator();
+ std::scoped_lock<std::mutex> g(gen.mutex);
+ return dist(gen.global_rng);
+}
+
+} // namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/sequenceashashmap.cxx b/comphelper/source/misc/sequenceashashmap.cxx
new file mode 100644
index 000000000..34a6a0c8a
--- /dev/null
+++ b/comphelper/source/misc/sequenceashashmap.cxx
@@ -0,0 +1,378 @@
+/* -*- 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 <sal/config.h>
+
+#include <boost/property_tree/json_parser.hpp>
+
+#include <com/sun/star/beans/NamedValue.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <com/sun/star/reflection/XIdlField.hpp>
+#include <com/sun/star/reflection/theCoreReflection.hpp>
+#include <comphelper/sequenceashashmap.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/propertysequence.hxx>
+#include <sal/log.hxx>
+#include <o3tl/string_view.hxx>
+
+using namespace com::sun::star;
+
+namespace
+{
+uno::Any jsonToUnoAny(const boost::property_tree::ptree& aTree)
+{
+ uno::Any aAny;
+ uno::Any aValue;
+ sal_Int32 nFields;
+ uno::Reference<reflection::XIdlField> aField;
+ boost::property_tree::ptree aNodeNull, aNodeValue, aNodeField;
+ const std::string& rType = aTree.get<std::string>("type", "");
+ const std::string& rValue = aTree.get<std::string>("value", "");
+ uno::Sequence<uno::Reference<reflection::XIdlField>> aFields;
+ uno::Reference<reflection::XIdlClass> xIdlClass
+ = css::reflection::theCoreReflection::get(comphelper::getProcessComponentContext())
+ ->forName(OUString::fromUtf8(rType.c_str()));
+ if (xIdlClass.is())
+ {
+ uno::TypeClass aTypeClass = xIdlClass->getTypeClass();
+ xIdlClass->createObject(aAny);
+ aFields = xIdlClass->getFields();
+ nFields = aFields.getLength();
+ aNodeValue = aTree.get_child("value", aNodeNull);
+ if (nFields > 0 && aNodeValue != aNodeNull)
+ {
+ for (sal_Int32 itField = 0; itField < nFields; ++itField)
+ {
+ aField = aFields[itField];
+ aNodeField = aNodeValue.get_child(aField->getName().toUtf8().getStr(), aNodeNull);
+ if (aNodeField != aNodeNull)
+ {
+ aValue = jsonToUnoAny(aNodeField);
+ aField->set(aAny, aValue);
+ }
+ }
+ }
+ else if (!rValue.empty())
+ {
+ if (aTypeClass == uno::TypeClass_VOID)
+ aAny.clear();
+ else if (aTypeClass == uno::TypeClass_BYTE)
+ aAny <<= static_cast<sal_Int8>(o3tl::toInt32(rValue));
+ else if (aTypeClass == uno::TypeClass_BOOLEAN)
+ aAny <<= OString(rValue.c_str()).toBoolean();
+ else if (aTypeClass == uno::TypeClass_SHORT)
+ aAny <<= static_cast<sal_Int16>(o3tl::toInt32(rValue));
+ else if (aTypeClass == uno::TypeClass_UNSIGNED_SHORT)
+ aAny <<= static_cast<sal_uInt16>(o3tl::toUInt32(rValue));
+ else if (aTypeClass == uno::TypeClass_LONG)
+ aAny <<= o3tl::toInt32(rValue);
+ else if (aTypeClass == uno::TypeClass_UNSIGNED_LONG)
+ aAny <<= static_cast<sal_uInt32>(o3tl::toInt32(rValue));
+ else if (aTypeClass == uno::TypeClass_FLOAT)
+ aAny <<= OString(rValue.c_str()).toFloat();
+ else if (aTypeClass == uno::TypeClass_DOUBLE)
+ aAny <<= o3tl::toDouble(rValue);
+ else if (aTypeClass == uno::TypeClass_STRING)
+ aAny <<= OUString::fromUtf8(rValue.c_str());
+ }
+ }
+ return aAny;
+}
+}
+
+namespace comphelper{
+
+SequenceAsHashMap::SequenceAsHashMap()
+{
+}
+
+SequenceAsHashMap::SequenceAsHashMap(const css::uno::Any& aSource)
+{
+ (*this) << aSource;
+}
+
+
+SequenceAsHashMap::SequenceAsHashMap(const css::uno::Sequence< css::uno::Any >& lSource)
+{
+ (*this) << lSource;
+}
+
+SequenceAsHashMap::SequenceAsHashMap(const css::uno::Sequence< css::beans::PropertyValue >& lSource)
+{
+ (*this) << lSource;
+}
+
+SequenceAsHashMap::SequenceAsHashMap(const css::uno::Sequence< css::beans::NamedValue >& lSource)
+{
+ (*this) << lSource;
+}
+
+void SequenceAsHashMap::operator<<(const css::uno::Any& aSource)
+{
+ // An empty Any reset this instance!
+ if (!aSource.hasValue())
+ {
+ clear();
+ return;
+ }
+
+ css::uno::Sequence< css::beans::NamedValue > lN;
+ if (aSource >>= lN)
+ {
+ (*this) << lN;
+ return;
+ }
+
+ css::uno::Sequence< css::beans::PropertyValue > lP;
+ if (aSource >>= lP)
+ {
+ (*this) << lP;
+ return;
+ }
+
+ throw css::lang::IllegalArgumentException(
+ "Any contains wrong type.", css::uno::Reference<css::uno::XInterface>(),
+ -1);
+}
+
+
+void SequenceAsHashMap::operator<<(const css::uno::Sequence< css::uno::Any >& lSource)
+{
+ sal_Int32 c = lSource.getLength();
+ sal_Int32 i = 0;
+
+ m_aMap.reserve(c);
+ for (i=0; i<c; ++i)
+ {
+ css::beans::PropertyValue lP;
+ if (lSource[i] >>= lP)
+ {
+ if (
+ (lP.Name.isEmpty()) ||
+ (!lP.Value.hasValue())
+ )
+ throw css::lang::IllegalArgumentException(
+ "PropertyValue struct contains no useful information.",
+ css::uno::Reference<css::uno::XInterface>(), -1);
+ (*this)[lP.Name] = lP.Value;
+ continue;
+ }
+
+ css::beans::NamedValue lN;
+ if (lSource[i] >>= lN)
+ {
+ if (
+ (lN.Name.isEmpty()) ||
+ (!lN.Value.hasValue())
+ )
+ throw css::lang::IllegalArgumentException(
+ "NamedValue struct contains no useful information.",
+ css::uno::Reference<css::uno::XInterface>(), -1);
+ (*this)[lN.Name] = lN.Value;
+ continue;
+ }
+
+ // ignore VOID Any ... but reject wrong filled ones!
+ if (lSource[i].hasValue())
+ throw css::lang::IllegalArgumentException(
+ "Any contains wrong type.",
+ css::uno::Reference<css::uno::XInterface>(), -1);
+ }
+}
+
+void SequenceAsHashMap::operator<<(const css::uno::Sequence< css::beans::PropertyValue >& lSource)
+{
+ clear();
+
+ sal_Int32 c = lSource.getLength();
+ const css::beans::PropertyValue* pSource = lSource.getConstArray();
+
+ m_aMap.reserve(c);
+ for (sal_Int32 i=0; i<c; ++i)
+ (*this)[pSource[i].Name] = pSource[i].Value;
+}
+
+void SequenceAsHashMap::operator<<(const css::uno::Sequence< css::beans::NamedValue >& lSource)
+{
+ clear();
+
+ sal_Int32 c = lSource.getLength();
+ const css::beans::NamedValue* pSource = lSource.getConstArray();
+
+ m_aMap.reserve(c);
+ for (sal_Int32 i=0; i<c; ++i)
+ (*this)[pSource[i].Name] = pSource[i].Value;
+}
+
+void SequenceAsHashMap::operator>>(css::uno::Sequence< css::beans::PropertyValue >& lDestination) const
+{
+ sal_Int32 c = static_cast<sal_Int32>(size());
+ lDestination.realloc(c);
+ css::beans::PropertyValue* pDestination = lDestination.getArray();
+
+ sal_Int32 i = 0;
+ for (const_iterator pThis = begin();
+ pThis != end() ;
+ ++pThis )
+ {
+ pDestination[i].Name = pThis->first.maString;
+ pDestination[i].Value = pThis->second;
+ ++i;
+ }
+}
+
+void SequenceAsHashMap::operator>>(css::uno::Sequence< css::beans::NamedValue >& lDestination) const
+{
+ sal_Int32 c = static_cast<sal_Int32>(size());
+ lDestination.realloc(c);
+ css::beans::NamedValue* pDestination = lDestination.getArray();
+
+ sal_Int32 i = 0;
+ for (const_iterator pThis = begin();
+ pThis != end() ;
+ ++pThis )
+ {
+ pDestination[i].Name = pThis->first.maString;
+ pDestination[i].Value = pThis->second;
+ ++i;
+ }
+}
+
+css::uno::Any SequenceAsHashMap::getAsConstAny(bool bAsPropertyValueList) const
+{
+ css::uno::Any aDestination;
+ if (bAsPropertyValueList)
+ aDestination <<= getAsConstPropertyValueList();
+ else
+ aDestination <<= getAsConstNamedValueList();
+ return aDestination;
+}
+
+css::uno::Sequence< css::beans::NamedValue > SequenceAsHashMap::getAsConstNamedValueList() const
+{
+ css::uno::Sequence< css::beans::NamedValue > lReturn;
+ (*this) >> lReturn;
+ return lReturn;
+}
+
+css::uno::Sequence< css::beans::PropertyValue > SequenceAsHashMap::getAsConstPropertyValueList() const
+{
+ css::uno::Sequence< css::beans::PropertyValue > lReturn;
+ (*this) >> lReturn;
+ return lReturn;
+}
+
+bool SequenceAsHashMap::match(const SequenceAsHashMap& rCheck) const
+{
+ for (auto const& elem : rCheck)
+ {
+ const OUString& sCheckName = elem.first.maString;
+ const css::uno::Any& aCheckValue = elem.second;
+ const_iterator pFound = find(sCheckName);
+
+ if (pFound == end())
+ return false;
+
+ const css::uno::Any& aFoundValue = pFound->second;
+ if (aFoundValue != aCheckValue)
+ return false;
+ }
+
+ return true;
+}
+
+void SequenceAsHashMap::update(const SequenceAsHashMap& rUpdate)
+{
+ m_aMap.reserve(std::max(size(), rUpdate.size()));
+ for (auto const& elem : rUpdate.m_aMap)
+ {
+ m_aMap[elem.first] = elem.second;
+ }
+}
+
+std::vector<css::beans::PropertyValue> JsonToPropertyValues(const OString& rJson)
+{
+ std::vector<beans::PropertyValue> aArguments;
+ boost::property_tree::ptree aTree, aNodeNull, aNodeValue;
+ std::stringstream aStream(rJson.getStr());
+ boost::property_tree::read_json(aStream, aTree);
+
+ for (const auto& rPair : aTree)
+ {
+ const std::string& rType = rPair.second.get<std::string>("type", "");
+ const std::string& rValue = rPair.second.get<std::string>("value", "");
+
+ beans::PropertyValue aValue;
+ aValue.Name = OUString::fromUtf8(rPair.first.c_str());
+ if (rType == "string")
+ aValue.Value <<= OUString::fromUtf8(rValue.c_str());
+ else if (rType == "boolean")
+ aValue.Value <<= OString(rValue.c_str()).toBoolean();
+ else if (rType == "float")
+ aValue.Value <<= OString(rValue.c_str()).toFloat();
+ else if (rType == "long")
+ aValue.Value <<= o3tl::toInt32(rValue);
+ else if (rType == "short")
+ aValue.Value <<= sal_Int16(o3tl::toInt32(rValue));
+ else if (rType == "unsigned short")
+ aValue.Value <<= sal_uInt16(o3tl::toUInt32(rValue));
+ else if (rType == "int64")
+ aValue.Value <<= o3tl::toInt64(rValue);
+ else if (rType == "int32")
+ aValue.Value <<= o3tl::toInt32(rValue);
+ else if (rType == "int16")
+ aValue.Value <<= sal_Int16(o3tl::toInt32(rValue));
+ else if (rType == "uint64")
+ aValue.Value <<= OString(rValue.c_str()).toUInt64();
+ else if (rType == "uint32")
+ aValue.Value <<= o3tl::toUInt32(rValue);
+ else if (rType == "uint16")
+ aValue.Value <<= sal_uInt16(o3tl::toUInt32(rValue));
+ else if (rType == "[]byte")
+ {
+ aNodeValue = rPair.second.get_child("value", aNodeNull);
+ if (aNodeValue != aNodeNull && aNodeValue.size() == 0)
+ {
+ uno::Sequence<sal_Int8> aSeqByte(reinterpret_cast<const sal_Int8*>(rValue.c_str()),
+ rValue.size());
+ aValue.Value <<= aSeqByte;
+ }
+ }
+ else if (rType == "[]any")
+ {
+ aNodeValue = rPair.second.get_child("value", aNodeNull);
+ if (aNodeValue != aNodeNull && !aNodeValue.empty())
+ {
+ uno::Sequence<uno::Any> aSeq(aNodeValue.size());
+ std::transform(aNodeValue.begin(), aNodeValue.end(), aSeq.getArray(),
+ [](const auto& rSeqPair) { return jsonToUnoAny(rSeqPair.second); });
+ aValue.Value <<= aSeq;
+ }
+ }
+ else
+ SAL_WARN("comphelper", "JsonToPropertyValues: unhandled type '" << rType << "'");
+ aArguments.push_back(aValue);
+ }
+ return aArguments;
+}
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/servicedecl.cxx b/comphelper/source/misc/servicedecl.cxx
new file mode 100644
index 000000000..2b16539d1
--- /dev/null
+++ b/comphelper/source/misc/servicedecl.cxx
@@ -0,0 +1,161 @@
+/* -*- 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 <comphelper/servicedecl.hxx>
+#include <o3tl/string_view.hxx>
+#include <rtl/string.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <comphelper/sequence.hxx>
+#include <com/sun/star/lang/XSingleComponentFactory.hpp>
+#include <cassert>
+#include <vector>
+
+using namespace com::sun::star;
+
+namespace comphelper::service_decl {
+
+const char cDelim = ';';
+
+class ServiceDecl::Factory :
+ public cppu::WeakImplHelper<lang::XSingleComponentFactory,
+ lang::XServiceInfo>
+{
+public:
+ explicit Factory( ServiceDecl const& rServiceDecl )
+ : m_rServiceDecl(rServiceDecl) {}
+ // noncopyable
+ Factory(const Factory&) = delete;
+ const Factory& operator=(const Factory&) = delete;
+
+ // XServiceInfo:
+ virtual OUString SAL_CALL getImplementationName() override;
+ virtual sal_Bool SAL_CALL supportsService( OUString const& name ) override;
+ virtual uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override;
+ // XSingleComponentFactory:
+ virtual uno::Reference<uno::XInterface> SAL_CALL createInstanceWithContext(
+ uno::Reference<uno::XComponentContext> const& xContext ) override;
+ virtual uno::Reference<uno::XInterface> SAL_CALL
+ createInstanceWithArgumentsAndContext(
+ uno::Sequence<uno::Any> const& args,
+ uno::Reference<uno::XComponentContext> const& xContext ) override;
+
+private:
+ virtual ~Factory() override;
+
+ ServiceDecl const& m_rServiceDecl;
+};
+
+ServiceDecl::Factory::~Factory()
+{
+}
+
+// XServiceInfo:
+OUString ServiceDecl::Factory::getImplementationName()
+{
+ return m_rServiceDecl.getImplementationName();
+}
+
+sal_Bool ServiceDecl::Factory::supportsService( OUString const& name )
+{
+ return m_rServiceDecl.supportsService(name);
+}
+
+uno::Sequence<OUString> ServiceDecl::Factory::getSupportedServiceNames()
+{
+ return m_rServiceDecl.getSupportedServiceNames();
+}
+
+// XSingleComponentFactory:
+uno::Reference<uno::XInterface> ServiceDecl::Factory::createInstanceWithContext(
+ uno::Reference<uno::XComponentContext> const& xContext )
+{
+ return m_rServiceDecl.m_createFunc(
+ m_rServiceDecl, uno::Sequence<uno::Any>(), xContext );
+}
+
+uno::Reference<uno::XInterface>
+ServiceDecl::Factory::createInstanceWithArgumentsAndContext(
+ uno::Sequence<uno::Any > const& args,
+ uno::Reference<uno::XComponentContext> const& xContext )
+{
+ return m_rServiceDecl.m_createFunc(
+ m_rServiceDecl, args, xContext );
+}
+
+void * ServiceDecl::getFactory( char const* pImplName ) const
+{
+ if (rtl_str_compare(m_pImplName, pImplName) == 0) {
+ lang::XSingleComponentFactory * const pFac( new Factory(*this) );
+ pFac->acquire();
+ return pFac;
+ }
+ return nullptr;
+}
+
+uno::Sequence<OUString> ServiceDecl::getSupportedServiceNames() const
+{
+ std::vector<OUString> vec;
+
+ OString const str(m_pServiceNames);
+ sal_Int32 nIndex = 0;
+ do {
+ std::string_view const token( o3tl::getToken(str, 0, cDelim, nIndex ) );
+ vec.emplace_back( token.data(), token.size(),
+ RTL_TEXTENCODING_ASCII_US );
+ }
+ while (nIndex >= 0);
+
+ return comphelper::containerToSequence(vec);
+}
+
+bool ServiceDecl::supportsService( std::u16string_view name ) const
+{
+ OString const str(m_pServiceNames);
+ sal_Int32 nIndex = 0;
+ do {
+ std::string_view const token( o3tl::getToken(str, 0, cDelim, nIndex ) );
+ if (o3tl::equalsAscii(name, token))
+ return true;
+ }
+ while (nIndex >= 0);
+ return false;
+}
+
+OUString ServiceDecl::getImplementationName() const
+{
+ return OUString::createFromAscii(m_pImplName);
+}
+
+void* component_getFactoryHelper( const char* pImplName,
+ std::initializer_list<ServiceDecl const *> args )
+{
+ for (auto const i: args) {
+ assert(i != nullptr);
+ void * fac = i->getFactory(pImplName);
+ if (fac != nullptr) {
+ return fac;
+ }
+ }
+ return nullptr;
+}
+
+} // namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/sharedmutex.cxx b/comphelper/source/misc/sharedmutex.cxx
new file mode 100644
index 000000000..58ae35df5
--- /dev/null
+++ b/comphelper/source/misc/sharedmutex.cxx
@@ -0,0 +1,42 @@
+/* -*- 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 <comphelper/sharedmutex.hxx>
+#include <comphelper/refcountedmutex.hxx>
+
+
+namespace comphelper
+{
+
+ SharedMutex::SharedMutex()
+ :m_pMutexImpl( std::make_shared<::osl::Mutex >())
+ {
+ }
+
+
+ RefCountedMutex::~RefCountedMutex()
+ {
+ }
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/simplefileaccessinteraction.cxx b/comphelper/source/misc/simplefileaccessinteraction.cxx
new file mode 100644
index 000000000..8cd77af7d
--- /dev/null
+++ b/comphelper/source/misc/simplefileaccessinteraction.cxx
@@ -0,0 +1,120 @@
+/* -*- 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/.
+ */
+
+#include <comphelper/simplefileaccessinteraction.hxx>
+#include <com/sun/star/task/XInteractionAbort.hpp>
+#include <com/sun/star/task/XInteractionApprove.hpp>
+#include <com/sun/star/ucb/AuthenticationRequest.hpp>
+#include <com/sun/star/ucb/CertificateValidationRequest.hpp>
+#include <com/sun/star/ucb/InteractiveIOException.hpp>
+#include <com/sun/star/ucb/InteractiveNetworkException.hpp>
+#include <com/sun/star/ucb/UnsupportedDataSinkException.hpp>
+
+namespace comphelper
+{
+/// Will handle com::sun::star::ucb::InteractiveIOException and derived classes
+const sal_Int32 HANDLE_INTERACTIVEIOEXCEPTION = 0;
+/// Will handle com::sun::star::ucb::UnsupportedDataSinkException
+const sal_Int32 HANDLE_UNSUPPORTEDDATASINKEXCEPTION = 1;
+/// Will handle com::sun::star::ucb::InteractiveNetworkException
+const sal_Int32 HANDLE_INTERACTIVENETWORKEXCEPTION = 2;
+/// Will handle com::sun::star::ucb::CertificateValidationRequest
+const sal_Int32 HANDLE_CERTIFICATEREQUEST = 3;
+/// Will handle com::sun::star::ucb::AuthenticationRequest
+const sal_Int32 HANDLE_AUTHENTICATIONREQUEST = 4;
+
+SimpleFileAccessInteraction::SimpleFileAccessInteraction(
+ const css::uno::Reference<css::task::XInteractionHandler>& xHandler)
+{
+ std::vector<::ucbhelper::InterceptedInteraction::InterceptedRequest> lInterceptions{
+ { //intercept standard IO error exception (local file and WebDAV)
+ css::uno::Any(css::ucb::InteractiveIOException()),
+ cppu::UnoType<css::task::XInteractionAbort>::get(), HANDLE_INTERACTIVEIOEXCEPTION },
+ { //intercept internal error
+ css::uno::Any(css::ucb::UnsupportedDataSinkException()),
+ cppu::UnoType<css::task::XInteractionAbort>::get(), HANDLE_UNSUPPORTEDDATASINKEXCEPTION },
+ {
+ //intercept network error exception (WebDAV ucp provider)
+ css::uno::Any(css::ucb::InteractiveNetworkException()),
+ cppu::UnoType<css::task::XInteractionAbort>::get(),
+ HANDLE_INTERACTIVENETWORKEXCEPTION,
+ },
+ { //intercept certificate validation request (WebDAV ucp provider)
+ css::uno::Any(css::ucb::CertificateValidationRequest()),
+ cppu::UnoType<css::task::XInteractionAbort>::get(), HANDLE_CERTIFICATEREQUEST },
+ { //intercept authentication request (WebDAV ucp provider)
+ css::uno::Any(css::ucb::AuthenticationRequest()),
+ cppu::UnoType<css::task::XInteractionApprove>::get(), HANDLE_AUTHENTICATIONREQUEST }
+ };
+
+ setInterceptedHandler(xHandler);
+ setInterceptions(std::move(lInterceptions));
+}
+
+SimpleFileAccessInteraction::~SimpleFileAccessInteraction() {}
+
+ucbhelper::InterceptedInteraction::EInterceptionState SimpleFileAccessInteraction::intercepted(
+ const ::ucbhelper::InterceptedInteraction::InterceptedRequest& aRequest,
+ const css::uno::Reference<css::task::XInteractionRequest>& xRequest)
+{
+ bool bAbort = false;
+ switch (aRequest.Handle)
+ {
+ case HANDLE_UNSUPPORTEDDATASINKEXCEPTION:
+ case HANDLE_INTERACTIVENETWORKEXCEPTION:
+ case HANDLE_INTERACTIVEIOEXCEPTION:
+ {
+ bAbort = true;
+ }
+ break;
+
+ case HANDLE_CERTIFICATEREQUEST:
+ {
+ // use default internal handler.
+ if (m_xInterceptedHandler.is())
+ {
+ m_xInterceptedHandler->handle(xRequest);
+ return ::ucbhelper::InterceptedInteraction::E_INTERCEPTED;
+ }
+ else
+ bAbort = true;
+ break;
+ }
+
+ case HANDLE_AUTHENTICATIONREQUEST:
+ {
+ // use default internal handler.
+ if (m_xInterceptedHandler.is())
+ {
+ m_xInterceptedHandler->handle(xRequest);
+ return ::ucbhelper::InterceptedInteraction::E_INTERCEPTED;
+ }
+ else //simply abort
+ bAbort = true;
+ }
+ break;
+ }
+
+ // handle interaction by ourself, by not doing
+ // any selection...
+ if (bAbort)
+ {
+ css::uno::Reference<css::task::XInteractionContinuation> xAbort
+ = ::ucbhelper::InterceptedInteraction::extractContinuation(
+ xRequest->getContinuations(), cppu::UnoType<css::task::XInteractionAbort>::get());
+ if (!xAbort.is())
+ return ::ucbhelper::InterceptedInteraction::E_NO_CONTINUATION_FOUND;
+ return ::ucbhelper::InterceptedInteraction::E_INTERCEPTED;
+ }
+
+ return ::ucbhelper::InterceptedInteraction::E_INTERCEPTED;
+}
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/solarmutex.cxx b/comphelper/source/misc/solarmutex.cxx
new file mode 100644
index 000000000..5d1052327
--- /dev/null
+++ b/comphelper/source/misc/solarmutex.cxx
@@ -0,0 +1,103 @@
+/* -*- 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 <sal/config.h>
+
+#include <comphelper/solarmutex.hxx>
+#include <osl/thread.hxx>
+
+#include <assert.h>
+#include <cstdlib>
+
+namespace comphelper {
+
+namespace {
+ SolarMutex* g_pSolarMutex = nullptr;
+}
+
+SolarMutex *SolarMutex::get()
+{
+ return g_pSolarMutex;
+}
+
+SolarMutex::SolarMutex()
+ : m_nCount( 0 )
+ , m_nThreadId( 0 )
+ , m_aBeforeReleaseHandler( nullptr )
+{
+ assert(!g_pSolarMutex);
+ g_pSolarMutex = this;
+}
+
+SolarMutex::~SolarMutex()
+{
+ g_pSolarMutex = nullptr;
+}
+
+void SolarMutex::doAcquire( const sal_uInt32 nLockCount )
+{
+ for ( sal_uInt32 n = nLockCount; n ; --n )
+ m_aMutex.acquire();
+ m_nThreadId = osl::Thread::getCurrentIdentifier();
+ m_nCount += nLockCount;
+}
+
+sal_uInt32 SolarMutex::doRelease( bool bUnlockAll )
+{
+ if ( !IsCurrentThread() )
+ std::abort();
+ if ( m_nCount == 0 )
+ std::abort();
+
+ const sal_uInt32 nCount = bUnlockAll ? m_nCount : 1;
+ m_nCount -= nCount;
+
+ if ( 0 == m_nCount )
+ {
+ if ( m_aBeforeReleaseHandler )
+ m_aBeforeReleaseHandler();
+ m_nThreadId = 0;
+ }
+
+ for ( sal_uInt32 n = nCount ; n ; --n )
+ m_aMutex.release();
+
+ return nCount;
+}
+
+bool SolarMutex::IsCurrentThread() const
+{
+ return m_nThreadId == osl::Thread::getCurrentIdentifier();
+}
+
+bool SolarMutex::tryToAcquire()
+{
+ if ( m_aMutex.tryToAcquire() )
+ {
+ m_nThreadId = osl::Thread::getCurrentIdentifier();
+ m_nCount++;
+ return true;
+ }
+ else
+ return false;
+}
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/stillreadwriteinteraction.cxx b/comphelper/source/misc/stillreadwriteinteraction.cxx
new file mode 100644
index 000000000..88bc25bc4
--- /dev/null
+++ b/comphelper/source/misc/stillreadwriteinteraction.cxx
@@ -0,0 +1,156 @@
+/* -*- 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 <comphelper/stillreadwriteinteraction.hxx>
+
+#include <com/sun/star/ucb/InteractiveIOException.hpp>
+
+#include <com/sun/star/task/XInteractionAbort.hpp>
+
+#include <com/sun/star/task/XInteractionApprove.hpp>
+
+#include <com/sun/star/ucb/UnsupportedDataSinkException.hpp>
+
+#include <com/sun/star/ucb/AuthenticationRequest.hpp>
+
+#include <com/sun/star/ucb/CertificateValidationRequest.hpp>
+#include <utility>
+
+namespace comphelper{
+
+StillReadWriteInteraction::StillReadWriteInteraction(const css::uno::Reference< css::task::XInteractionHandler >& xHandler,
+ css::uno::Reference< css::task::XInteractionHandler > xAuxiliaryHandler)
+ : m_bUsed (false)
+ , m_bHandledByMySelf (false)
+ , m_xAuxiliaryHandler(std::move(xAuxiliaryHandler))
+{
+ std::vector< ::ucbhelper::InterceptedInteraction::InterceptedRequest > lInterceptions;
+ lInterceptions.reserve(4);
+ ::ucbhelper::InterceptedInteraction::InterceptedRequest aInterceptedRequest;
+
+ aInterceptedRequest.Handle = HANDLE_INTERACTIVEIOEXCEPTION;
+ aInterceptedRequest.Request <<= css::ucb::InteractiveIOException();
+ aInterceptedRequest.Continuation = cppu::UnoType<css::task::XInteractionAbort>::get();
+ lInterceptions.push_back(aInterceptedRequest);
+
+ aInterceptedRequest.Handle = HANDLE_UNSUPPORTEDDATASINKEXCEPTION;
+ aInterceptedRequest.Request <<= css::ucb::UnsupportedDataSinkException();
+ aInterceptedRequest.Continuation = cppu::UnoType<css::task::XInteractionAbort>::get();
+ lInterceptions.push_back(aInterceptedRequest);
+
+ aInterceptedRequest.Handle = HANDLE_AUTHENTICATIONREQUESTEXCEPTION;
+ aInterceptedRequest.Request <<= css::ucb::AuthenticationRequest();
+ aInterceptedRequest.Continuation = cppu::UnoType<css::task::XInteractionApprove>::get();
+ lInterceptions.push_back(aInterceptedRequest);
+
+ aInterceptedRequest.Handle = HANDLE_CERTIFICATEVALIDATIONREQUESTEXCEPTION;
+ aInterceptedRequest.Request <<= css::ucb::CertificateValidationRequest();
+ aInterceptedRequest.Continuation = cppu::UnoType<css::task::XInteractionApprove>::get();
+ lInterceptions.push_back(aInterceptedRequest);
+
+ setInterceptedHandler(xHandler);
+ setInterceptions(std::move(lInterceptions));
+}
+
+void StillReadWriteInteraction::resetInterceptions()
+{
+ setInterceptions(std::vector< ::ucbhelper::InterceptedInteraction::InterceptedRequest >());
+}
+
+void StillReadWriteInteraction::resetErrorStates()
+{
+ m_bUsed = false;
+ m_bHandledByMySelf = false;
+}
+
+
+ucbhelper::InterceptedInteraction::EInterceptionState StillReadWriteInteraction::intercepted(const ::ucbhelper::InterceptedInteraction::InterceptedRequest& aRequest,
+ const css::uno::Reference< css::task::XInteractionRequest >& xRequest)
+{
+ // we are used!
+ m_bUsed = true;
+
+ // check if it's a real interception - might some parameters are not the right ones ...
+ bool bAbort = false;
+ switch(aRequest.Handle)
+ {
+ case HANDLE_INTERACTIVEIOEXCEPTION:
+ {
+ css::ucb::InteractiveIOException exIO;
+ xRequest->getRequest() >>= exIO;
+ bAbort = (
+ (exIO.Code == css::ucb::IOErrorCode_ACCESS_DENIED )
+ || (exIO.Code == css::ucb::IOErrorCode_LOCKING_VIOLATION )
+ || (exIO.Code == css::ucb::IOErrorCode_NOT_EXISTING )
+ // At least on Linux, a request to open some fuse-mounted file O_RDWR may fail with
+ // EOPNOTSUPP (mapped to osl_File_E_NOSYS to IOErrorCode_NOT_SUPPORTED) when opening
+ // it O_RDONLY would succeed:
+ || (exIO.Code == css::ucb::IOErrorCode_NOT_SUPPORTED )
+#ifdef MACOSX
+ // this is a workaround for MAC, on this platform if the file is locked
+ // the returned error code looks to be wrong
+ || (exIO.Code == css::ucb::IOErrorCode_GENERAL )
+#endif
+ );
+ }
+ break;
+
+ case HANDLE_UNSUPPORTEDDATASINKEXCEPTION:
+ {
+ bAbort = true;
+ }
+ break;
+ case HANDLE_CERTIFICATEVALIDATIONREQUESTEXCEPTION:
+ case HANDLE_AUTHENTICATIONREQUESTEXCEPTION:
+ {
+//use internal auxiliary handler and return
+ if (m_xAuxiliaryHandler.is())
+ {
+ m_xAuxiliaryHandler->handle(xRequest);
+ return ::ucbhelper::InterceptedInteraction::E_INTERCEPTED;
+ }
+ else //simply abort
+ bAbort = true;
+ }
+ break;
+ }
+
+ // handle interaction by ourself
+ if (bAbort)
+ {
+ m_bHandledByMySelf = true;
+ css::uno::Reference< css::task::XInteractionContinuation > xAbort = ::ucbhelper::InterceptedInteraction::extractContinuation(
+ xRequest->getContinuations(),
+ cppu::UnoType<css::task::XInteractionAbort>::get() );
+ if (!xAbort.is())
+ return ::ucbhelper::InterceptedInteraction::E_NO_CONTINUATION_FOUND;
+ xAbort->select();
+ return ::ucbhelper::InterceptedInteraction::E_INTERCEPTED;
+ }
+
+ // Otherwise use internal handler.
+ if (m_xInterceptedHandler.is())
+ {
+ m_xInterceptedHandler->handle(xRequest);
+ }
+ return ::ucbhelper::InterceptedInteraction::E_INTERCEPTED;
+}
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/storagehelper.cxx b/comphelper/source/misc/storagehelper.cxx
new file mode 100644
index 000000000..5f8527bcf
--- /dev/null
+++ b/comphelper/source/misc/storagehelper.cxx
@@ -0,0 +1,713 @@
+/* -*- 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 <config_gpgme.h>
+
+#include <com/sun/star/embed/ElementModes.hpp>
+#include <com/sun/star/embed/XEncryptionProtectedStorage.hpp>
+#include <com/sun/star/embed/XStorage.hpp>
+#include <com/sun/star/embed/XTransactedObject.hpp>
+#include <com/sun/star/embed/StorageFactory.hpp>
+#include <com/sun/star/embed/FileSystemStorageFactory.hpp>
+#include <com/sun/star/io/IOException.hpp>
+#include <com/sun/star/lang/XSingleServiceFactory.hpp>
+#include <com/sun/star/lang/XUnoTunnel.hpp>
+#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
+#include <com/sun/star/ucb/SimpleFileAccess.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/beans/NamedValue.hpp>
+#include <com/sun/star/beans/IllegalTypeException.hpp>
+#include <com/sun/star/xml/crypto/NSSInitializer.hpp>
+#include <com/sun/star/xml/crypto/XDigestContext.hpp>
+#include <com/sun/star/xml/crypto/DigestID.hpp>
+#include <com/sun/star/security/DocumentDigitalSignatures.hpp>
+#include <com/sun/star/security/XCertificate.hpp>
+
+#include <vector>
+
+#include <rtl/digest.h>
+#include <rtl/random.h>
+#include <osl/diagnose.h>
+#include <sal/log.hxx>
+
+#include <ucbhelper/content.hxx>
+
+#include <comphelper/bytereader.hxx>
+#include <comphelper/fileformat.h>
+#include <comphelper/hash.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/documentconstants.hxx>
+#include <comphelper/propertyvalue.hxx>
+#include <comphelper/storagehelper.hxx>
+#include <comphelper/sequence.hxx>
+#include <cppuhelper/exc_hlp.hxx>
+#include <o3tl/string_view.hxx>
+
+#if HAVE_FEATURE_GPGME
+# include <context.h>
+# include <encryptionresult.h>
+# include <key.h>
+# include <data.h>
+#endif
+
+using namespace ::com::sun::star;
+
+namespace comphelper {
+
+
+uno::Reference< lang::XSingleServiceFactory > OStorageHelper::GetStorageFactory(
+ const uno::Reference< uno::XComponentContext >& rxContext )
+{
+ uno::Reference< uno::XComponentContext> xContext = rxContext.is() ? rxContext : ::comphelper::getProcessComponentContext();
+
+ return embed::StorageFactory::create( xContext );
+}
+
+
+uno::Reference< lang::XSingleServiceFactory > OStorageHelper::GetFileSystemStorageFactory(
+ const uno::Reference< uno::XComponentContext >& rxContext )
+{
+ return embed::FileSystemStorageFactory::create(rxContext);
+}
+
+
+uno::Reference< embed::XStorage > OStorageHelper::GetTemporaryStorage(
+ const uno::Reference< uno::XComponentContext >& rxContext )
+{
+ uno::Reference< embed::XStorage > xTempStorage( GetStorageFactory( rxContext )->createInstance(),
+ uno::UNO_QUERY_THROW );
+ return xTempStorage;
+}
+
+
+uno::Reference< embed::XStorage > OStorageHelper::GetStorageFromURL(
+ const OUString& aURL,
+ sal_Int32 nStorageMode,
+ const uno::Reference< uno::XComponentContext >& rxContext )
+{
+ uno::Sequence< uno::Any > aArgs{ uno::Any(aURL), uno::Any(nStorageMode) };
+ uno::Reference< embed::XStorage > xTempStorage( GetStorageFactory( rxContext )->createInstanceWithArguments( aArgs ),
+ uno::UNO_QUERY_THROW );
+ return xTempStorage;
+}
+
+
+uno::Reference< embed::XStorage > OStorageHelper::GetStorageFromURL2(
+ const OUString& aURL,
+ sal_Int32 nStorageMode,
+ const uno::Reference< uno::XComponentContext >& rxContext )
+{
+ uno::Sequence< uno::Any > aArgs{ uno::Any(aURL), uno::Any(nStorageMode) };
+
+ uno::Reference< lang::XSingleServiceFactory > xFact;
+ css::uno::Any anyEx;
+ try {
+ ::ucbhelper::Content aCntnt( aURL,
+ uno::Reference< css::ucb::XCommandEnvironment > (),
+ getProcessComponentContext() );
+ if (aCntnt.isDocument()) {
+ xFact = GetStorageFactory( rxContext );
+ } else {
+ xFact = GetFileSystemStorageFactory( rxContext );
+ }
+ } catch (uno::Exception &)
+ {
+ anyEx = cppu::getCaughtException();
+ }
+
+ if (!xFact.is())
+ {
+ if (anyEx.hasValue())
+ throw css::lang::WrappedTargetRuntimeException( "", nullptr, anyEx );
+ else
+ throw uno::RuntimeException();
+ }
+
+ uno::Reference< embed::XStorage > xTempStorage(
+ xFact->createInstanceWithArguments( aArgs ), uno::UNO_QUERY_THROW );
+ return xTempStorage;
+}
+
+
+uno::Reference< embed::XStorage > OStorageHelper::GetStorageFromInputStream(
+ const uno::Reference < io::XInputStream >& xStream,
+ const uno::Reference< uno::XComponentContext >& rxContext )
+{
+ uno::Sequence< uno::Any > aArgs{ uno::Any(xStream), uno::Any(embed::ElementModes::READ) };
+ uno::Reference< embed::XStorage > xTempStorage( GetStorageFactory( rxContext )->createInstanceWithArguments( aArgs ),
+ uno::UNO_QUERY_THROW );
+ return xTempStorage;
+}
+
+
+uno::Reference< embed::XStorage > OStorageHelper::GetStorageFromStream(
+ const uno::Reference < io::XStream >& xStream,
+ sal_Int32 nStorageMode,
+ const uno::Reference< uno::XComponentContext >& rxContext )
+{
+ uno::Sequence< uno::Any > aArgs{ uno::Any(xStream), uno::Any(nStorageMode) };
+ uno::Reference< embed::XStorage > xTempStorage( GetStorageFactory( rxContext )->createInstanceWithArguments( aArgs ),
+ uno::UNO_QUERY_THROW );
+ return xTempStorage;
+}
+
+
+void OStorageHelper::CopyInputToOutput(
+ const uno::Reference< io::XInputStream >& xInput,
+ const uno::Reference< io::XOutputStream >& xOutput )
+{
+ static const sal_Int32 nConstBufferSize = 32000;
+
+ uno::Reference< css::lang::XUnoTunnel > xInputTunnel( xInput, uno::UNO_QUERY );
+ comphelper::ByteReader* pByteReader = nullptr;
+ comphelper::ByteWriter* pByteWriter = nullptr;
+ if (xInputTunnel)
+ pByteReader = reinterpret_cast< comphelper::ByteReader* >( xInputTunnel->getSomething( comphelper::ByteReader::getUnoTunnelId() ) );
+ if (pByteReader)
+ {
+ uno::Reference< css::lang::XUnoTunnel > xOutputTunnel( xOutput, uno::UNO_QUERY );
+ if (xOutputTunnel)
+ pByteWriter = reinterpret_cast< comphelper::ByteWriter* >( xOutputTunnel->getSomething( comphelper::ByteWriter::getUnoTunnelId() ) );
+ }
+
+ if (pByteWriter)
+ {
+ sal_Int32 nRead;
+ sal_Int8 aTempBuf[ nConstBufferSize ];
+ do
+ {
+ nRead = pByteReader->readSomeBytes ( aTempBuf, nConstBufferSize );
+ pByteWriter->writeSomeBytes ( aTempBuf, nRead );
+ }
+ while ( nRead == nConstBufferSize );
+ }
+ else
+ {
+ sal_Int32 nRead;
+ uno::Sequence < sal_Int8 > aSequence ( nConstBufferSize );
+
+ do
+ {
+ nRead = xInput->readBytes ( aSequence, nConstBufferSize );
+ if ( nRead < nConstBufferSize )
+ {
+ uno::Sequence < sal_Int8 > aTempBuf ( aSequence.getConstArray(), nRead );
+ xOutput->writeBytes ( aTempBuf );
+ }
+ else
+ xOutput->writeBytes ( aSequence );
+ }
+ while ( nRead == nConstBufferSize );
+ }
+}
+
+
+uno::Reference< io::XInputStream > OStorageHelper::GetInputStreamFromURL(
+ const OUString& aURL,
+ const uno::Reference< uno::XComponentContext >& context )
+{
+ uno::Reference< io::XInputStream > xInputStream = ucb::SimpleFileAccess::create(context)->openFileRead( aURL );
+ if ( !xInputStream.is() )
+ throw uno::RuntimeException();
+
+ return xInputStream;
+}
+
+
+void OStorageHelper::SetCommonStorageEncryptionData(
+ const uno::Reference< embed::XStorage >& xStorage,
+ const uno::Sequence< beans::NamedValue >& aEncryptionData )
+{
+ uno::Reference< embed::XEncryptionProtectedStorage > xEncrSet( xStorage, uno::UNO_QUERY );
+ if ( !xEncrSet.is() )
+ throw io::IOException("no XEncryptionProtectedStorage"); // TODO
+
+ if ( aEncryptionData.getLength() == 2 &&
+ aEncryptionData[0].Name == "GpgInfos" &&
+ aEncryptionData[1].Name == "EncryptionKey" )
+ {
+ xEncrSet->setGpgProperties(
+ aEncryptionData[0].Value.get< uno::Sequence< uno::Sequence< beans::NamedValue > > >() );
+ xEncrSet->setEncryptionData(
+ aEncryptionData[1].Value.get< uno::Sequence< beans::NamedValue > >() );
+ }
+ else
+ xEncrSet->setEncryptionData( aEncryptionData );
+}
+
+
+sal_Int32 OStorageHelper::GetXStorageFormat(
+ const uno::Reference< embed::XStorage >& xStorage )
+{
+ uno::Reference< beans::XPropertySet > xStorProps( xStorage, uno::UNO_QUERY_THROW );
+
+ OUString aMediaType;
+ xStorProps->getPropertyValue("MediaType") >>= aMediaType;
+
+ sal_Int32 nResult = 0;
+
+ // TODO/LATER: the filter configuration could be used to detect it later, or better a special service
+ if (
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_VND_SUN_XML_WRITER_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_VND_SUN_XML_WRITER_WEB_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_VND_SUN_XML_WRITER_GLOBAL_ASCII) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_VND_SUN_XML_DRAW_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_VND_SUN_XML_IMPRESS_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_VND_SUN_XML_CALC_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_VND_SUN_XML_CHART_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_VND_SUN_XML_MATH_ASCII )
+ )
+ {
+ nResult = SOFFICE_FILEFORMAT_60;
+ }
+ else if (
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_OASIS_OPENDOCUMENT_TEXT_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_OASIS_OPENDOCUMENT_TEXT_WEB_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_OASIS_OPENDOCUMENT_TEXT_GLOBAL_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_OASIS_OPENDOCUMENT_DRAWING_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_OASIS_OPENDOCUMENT_PRESENTATION_ASCII) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_OASIS_OPENDOCUMENT_SPREADSHEET_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_OASIS_OPENDOCUMENT_CHART_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_OASIS_OPENDOCUMENT_FORMULA_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_OASIS_OPENDOCUMENT_DATABASE_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_OASIS_OPENDOCUMENT_REPORT_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_OASIS_OPENDOCUMENT_REPORT_CHART_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_OASIS_OPENDOCUMENT_TEXT_TEMPLATE_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_OASIS_OPENDOCUMENT_TEXT_GLOBAL_TEMPLATE_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_OASIS_OPENDOCUMENT_DRAWING_TEMPLATE_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_OASIS_OPENDOCUMENT_PRESENTATION_TEMPLATE_ASCII) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_OASIS_OPENDOCUMENT_SPREADSHEET_TEMPLATE_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_OASIS_OPENDOCUMENT_CHART_TEMPLATE_ASCII ) ||
+ aMediaType.equalsIgnoreAsciiCase(MIMETYPE_OASIS_OPENDOCUMENT_FORMULA_TEMPLATE_ASCII )
+ )
+ {
+ nResult = SOFFICE_FILEFORMAT_8;
+ }
+ else
+ {
+ // the mediatype is not known
+ OUString aMsg = __func__
+ + OUString::Concat(u":")
+ + OUString::number(__LINE__)
+ + ": unknown media type '"
+ + aMediaType
+ + "'";
+ throw beans::IllegalTypeException(aMsg);
+ }
+
+ return nResult;
+}
+
+
+uno::Reference< embed::XStorage > OStorageHelper::GetStorageOfFormatFromURL(
+ const OUString& aFormat,
+ const OUString& aURL,
+ sal_Int32 nStorageMode,
+ const uno::Reference< uno::XComponentContext >& rxContext )
+{
+ uno::Sequence< beans::PropertyValue > aProps{ comphelper::makePropertyValue("StorageFormat",
+ aFormat) };
+
+ uno::Sequence< uno::Any > aArgs{ uno::Any(aURL), uno::Any(nStorageMode), uno::Any(aProps) };
+ uno::Reference< embed::XStorage > xTempStorage( GetStorageFactory( rxContext )->createInstanceWithArguments( aArgs ),
+ uno::UNO_QUERY_THROW );
+ return xTempStorage;
+}
+
+
+uno::Reference< embed::XStorage > OStorageHelper::GetStorageOfFormatFromInputStream(
+ const OUString& aFormat,
+ const uno::Reference < io::XInputStream >& xStream,
+ const uno::Reference< uno::XComponentContext >& rxContext,
+ bool bRepairStorage )
+{
+ uno::Sequence< beans::PropertyValue > aProps( bRepairStorage ? 2 : 1 );
+ auto pProps = aProps.getArray();
+ pProps[0].Name = "StorageFormat";
+ pProps[0].Value <<= aFormat;
+ if ( bRepairStorage )
+ {
+ pProps[1].Name = "RepairPackage";
+ pProps[1].Value <<= bRepairStorage;
+ }
+
+ uno::Sequence< uno::Any > aArgs{ uno::Any(xStream), uno::Any(embed::ElementModes::READ), uno::Any(aProps) };
+ uno::Reference< embed::XStorage > xTempStorage( GetStorageFactory( rxContext )->createInstanceWithArguments( aArgs ),
+ uno::UNO_QUERY_THROW );
+ return xTempStorage;
+}
+
+
+uno::Reference< embed::XStorage > OStorageHelper::GetStorageOfFormatFromStream(
+ const OUString& aFormat,
+ const uno::Reference < io::XStream >& xStream,
+ sal_Int32 nStorageMode,
+ const uno::Reference< uno::XComponentContext >& rxContext,
+ bool bRepairStorage )
+{
+ uno::Sequence< beans::PropertyValue > aProps( bRepairStorage ? 2 : 1 );
+ auto pProps = aProps.getArray();
+ pProps[0].Name = "StorageFormat";
+ pProps[0].Value <<= aFormat;
+ if ( bRepairStorage )
+ {
+ pProps[1].Name = "RepairPackage";
+ pProps[1].Value <<= bRepairStorage;
+ }
+
+ uno::Sequence< uno::Any > aArgs{ uno::Any(xStream), uno::Any(nStorageMode), uno::Any(aProps) };
+ uno::Reference< embed::XStorage > xTempStorage( GetStorageFactory( rxContext )->createInstanceWithArguments( aArgs ),
+ uno::UNO_QUERY_THROW );
+ return xTempStorage;
+}
+
+
+uno::Sequence< beans::NamedValue > OStorageHelper::CreatePackageEncryptionData( std::u16string_view aPassword )
+{
+ // TODO/LATER: Should not the method be part of DocPasswordHelper?
+ uno::Sequence< beans::NamedValue > aEncryptionData;
+ if ( !aPassword.empty() )
+ {
+ sal_Int32 nSha1Ind = 0;
+ // generate SHA256 start key
+ try
+ {
+ uno::Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext();
+
+ uno::Reference< css::xml::crypto::XNSSInitializer > xDigestContextSupplier = css::xml::crypto::NSSInitializer::create(xContext);
+ uno::Reference< css::xml::crypto::XDigestContext > xDigestContext( xDigestContextSupplier->getDigestContext( css::xml::crypto::DigestID::SHA256, uno::Sequence< beans::NamedValue >() ), uno::UNO_SET_THROW );
+
+ OString aUTF8Password( OUStringToOString( aPassword, RTL_TEXTENCODING_UTF8 ) );
+ xDigestContext->updateDigest( uno::Sequence< sal_Int8 >( reinterpret_cast< const sal_Int8* >( aUTF8Password.getStr() ), aUTF8Password.getLength() ) );
+ uno::Sequence< sal_Int8 > aDigest = xDigestContext->finalizeDigestAndDispose();
+
+ ++nSha1Ind;
+ aEncryptionData = { { PACKAGE_ENCRYPTIONDATA_SHA256UTF8, uno::Any(aDigest) } };
+ }
+ catch ( uno::Exception& )
+ {
+ OSL_ENSURE( false, "Can not create SHA256 digest!" );
+ }
+
+ // MS_1252 encoding was used for SO60 document format password encoding,
+ // this encoding supports only a minor subset of nonascii characters,
+ // but for compatibility reasons it has to be used for old document formats
+ aEncryptionData.realloc( nSha1Ind + 3 );
+ auto pEncryptionData = aEncryptionData.getArray();
+ // these are StarOffice not-quite-SHA1
+ pEncryptionData[nSha1Ind].Name = PACKAGE_ENCRYPTIONDATA_SHA1UTF8;
+ pEncryptionData[nSha1Ind + 1].Name = PACKAGE_ENCRYPTIONDATA_SHA1MS1252;
+
+ rtl_TextEncoding const pEncoding[2] = { RTL_TEXTENCODING_UTF8, RTL_TEXTENCODING_MS_1252 };
+
+ for ( sal_Int32 nInd = 0; nInd < 2; nInd++ )
+ {
+ OString aByteStrPass = OUStringToOString( aPassword, pEncoding[nInd] );
+
+ sal_uInt8 pBuffer[RTL_DIGEST_LENGTH_SHA1];
+ rtlDigestError nError = rtl_digest_SHA1( aByteStrPass.getStr(),
+ aByteStrPass.getLength(),
+ pBuffer,
+ RTL_DIGEST_LENGTH_SHA1 );
+
+ if ( nError != rtl_Digest_E_None )
+ {
+ aEncryptionData.realloc( nSha1Ind );
+ return aEncryptionData;
+ }
+
+ // coverity[overrun-buffer-arg : FALSE] - coverity has difficulty with css::uno::Sequence
+ pEncryptionData[nSha1Ind+nInd].Value <<= uno::Sequence< sal_Int8 >( reinterpret_cast<sal_Int8*>(pBuffer), RTL_DIGEST_LENGTH_SHA1 );
+ }
+
+ // actual SHA1
+ pEncryptionData[nSha1Ind + 2].Name = PACKAGE_ENCRYPTIONDATA_SHA1CORRECT;
+ OString aByteStrPass = OUStringToOString(aPassword, RTL_TEXTENCODING_UTF8);
+ std::vector<unsigned char> const sha1(::comphelper::Hash::calculateHash(
+ reinterpret_cast<unsigned char const*>(aByteStrPass.getStr()), aByteStrPass.getLength(),
+ ::comphelper::HashType::SHA1));
+ pEncryptionData[nSha1Ind + 2].Value <<= uno::Sequence<sal_Int8>(
+ reinterpret_cast<sal_Int8 const*>(sha1.data()), sha1.size());
+ }
+
+ return aEncryptionData;
+}
+
+uno::Sequence< beans::NamedValue > OStorageHelper::CreateGpgPackageEncryptionData()
+{
+#if HAVE_FEATURE_GPGME
+ // generate session key
+ // --------------------
+
+ rtlRandomPool aRandomPool = rtl_random_createPool();
+
+ // get 32 random chars out of it
+ uno::Sequence < sal_Int8 > aVector(32);
+ rtl_random_getBytes( aRandomPool, aVector.getArray(), aVector.getLength() );
+
+ rtl_random_destroyPool(aRandomPool);
+
+ std::vector< uno::Sequence< beans::NamedValue > > aGpgEncryptions;
+
+ uno::Reference< security::XDocumentDigitalSignatures > xSigner(
+ // here none of the version-dependent methods are called
+ security::DocumentDigitalSignatures::createDefault(
+ comphelper::getProcessComponentContext()));
+
+ // fire up certificate chooser dialog - user can multi-select!
+ const uno::Sequence< uno::Reference< security::XCertificate > > xSignCertificates=
+ xSigner->chooseEncryptionCertificate();
+
+ if (!xSignCertificates.hasElements())
+ return uno::Sequence< beans::NamedValue >(); // user cancelled
+
+ // generate one encrypted key entry for each recipient
+ // ---------------------------------------------------
+
+ std::unique_ptr<GpgME::Context> ctx;
+ GpgME::Error err = GpgME::checkEngine(GpgME::OpenPGP);
+ if (err)
+ throw uno::RuntimeException("The GpgME library failed to initialize for the OpenPGP protocol.");
+
+ ctx.reset( GpgME::Context::createForProtocol(GpgME::OpenPGP) );
+ if (ctx == nullptr)
+ throw uno::RuntimeException("The GpgME library failed to initialize for the OpenPGP protocol.");
+ ctx->setArmor(false);
+
+ for (const auto & cert : xSignCertificates)
+ {
+ uno::Sequence < sal_Int8 > aKeyID;
+ if (cert.is())
+ aKeyID = cert->getSHA1Thumbprint();
+
+ std::vector<GpgME::Key> keys
+ {
+ ctx->key(
+ reinterpret_cast<const char*>(aKeyID.getConstArray()),
+ err, false)
+ };
+
+ // ctx is setup now, let's encrypt the lot!
+ GpgME::Data plain(
+ reinterpret_cast<const char*>(aVector.getConstArray()),
+ size_t(aVector.getLength()), false);
+ GpgME::Data cipher;
+
+ GpgME::EncryptionResult crypt_res = ctx->encrypt(
+ keys, plain,
+ cipher, GpgME::Context::NoCompress);
+
+ off_t result = cipher.seek(0,SEEK_SET);
+ (void) result;
+ assert(result == 0);
+ int len=0, curr=0; char buf;
+ while( (curr=cipher.read(&buf, 1)) )
+ len += curr;
+
+ if(crypt_res.error() || !len)
+ throw lang::IllegalArgumentException(
+ "Not a suitable key, or failed to encrypt.",
+ css::uno::Reference<css::uno::XInterface>(), -1);
+
+ uno::Sequence < sal_Int8 > aCipherValue(len);
+ result = cipher.seek(0,SEEK_SET);
+ assert(result == 0);
+ if( cipher.read(aCipherValue.getArray(), len) != len )
+ throw uno::RuntimeException("The GpgME library failed to read the encrypted value.");
+
+ SAL_INFO("comphelper.crypto", "Generated gpg crypto of length: " << len);
+
+ uno::Sequence< beans::NamedValue > aGpgEncryptionEntry{
+ { "KeyId", uno::Any(aKeyID) },
+ { "KeyPacket", uno::Any(aKeyID) },
+ { "CipherValue", uno::Any(aCipherValue) }
+ };
+
+ aGpgEncryptions.push_back(aGpgEncryptionEntry);
+ }
+
+ uno::Sequence<beans::NamedValue> aEncryptionData
+ = { { PACKAGE_ENCRYPTIONDATA_SHA256UTF8, uno::Any(aVector) } };
+
+ uno::Sequence<beans::NamedValue> aContainer
+ = { { "GpgInfos", uno::Any(comphelper::containerToSequence(aGpgEncryptions)) },
+ { "EncryptionKey", uno::Any(aEncryptionData) } };
+
+ return aContainer;
+#else
+ return uno::Sequence< beans::NamedValue >();
+#endif
+}
+
+bool OStorageHelper::IsValidZipEntryFileName( std::u16string_view aName, bool bSlashAllowed )
+{
+ return IsValidZipEntryFileName( aName.data(), aName.size(), bSlashAllowed );
+}
+
+
+bool OStorageHelper::IsValidZipEntryFileName(
+ const sal_Unicode *pChar, sal_Int32 nLength, bool bSlashAllowed )
+{
+ for ( sal_Int32 i = 0; i < nLength; i++ )
+ {
+ switch ( pChar[i] )
+ {
+ case '\\':
+ case '?':
+ case '<':
+ case '>':
+ case '\"':
+ case '|':
+ case ':':
+ return false;
+ case '/':
+ if ( !bSlashAllowed )
+ return false;
+ break;
+ default:
+ if ( pChar[i] < 32 || (pChar[i] >= 0xD800 && pChar[i] <= 0xDFFF) )
+ return false;
+ }
+ }
+ return true;
+}
+
+
+bool OStorageHelper::PathHasSegment( std::u16string_view aPath, std::u16string_view aSegment )
+{
+ bool bResult = false;
+ const size_t nPathLen = aPath.size();
+ const size_t nSegLen = aSegment.size();
+
+ if ( !aSegment.empty() && nPathLen >= nSegLen )
+ {
+ OUString aEndSegment = OUString::Concat("/") + aSegment;
+ OUString aInternalSegment = aEndSegment + "/";
+
+ if ( aPath.find( aInternalSegment ) != std::u16string_view::npos )
+ bResult = true;
+
+ if ( !bResult && o3tl::starts_with(aPath, aSegment ) )
+ {
+ if ( nPathLen == nSegLen || aPath[nSegLen] == '/' )
+ bResult = true;
+ }
+
+ if ( !bResult && nPathLen > nSegLen && aPath.substr( nPathLen - nSegLen - 1, nSegLen + 1 ) == aEndSegment )
+ bResult = true;
+ }
+
+ return bResult;
+}
+
+class LifecycleProxy::Impl
+ : public std::vector< uno::Reference< embed::XStorage > > {};
+LifecycleProxy::LifecycleProxy()
+ : m_xBadness( new Impl ) { }
+LifecycleProxy::~LifecycleProxy() { }
+
+void LifecycleProxy::commitStorages()
+{
+ std::for_each(m_xBadness->rbegin(), m_xBadness->rend(), // reverse order (outwards)
+ [](Impl::reference rxItem) {
+ uno::Reference<embed::XTransactedObject> const xTransaction(rxItem, uno::UNO_QUERY);
+ if (xTransaction.is())
+ {
+ xTransaction->commit();
+ }
+ });
+}
+
+static void splitPath( std::vector<OUString> &rElems, std::u16string_view rPath )
+{
+ for (sal_Int32 i = 0; i >= 0;)
+ rElems.push_back( OUString(o3tl::getToken(rPath, 0, '/', i )) );
+}
+
+static uno::Reference< embed::XStorage > LookupStorageAtPath(
+ const uno::Reference< embed::XStorage > &xParentStorage,
+ std::vector<OUString> &rElems, sal_uInt32 nOpenMode,
+ LifecycleProxy const &rNastiness )
+{
+ uno::Reference< embed::XStorage > xStorage( xParentStorage );
+ rNastiness.m_xBadness->push_back( xStorage );
+ for( size_t i = 0; i < rElems.size() && xStorage.is(); i++ )
+ {
+ xStorage = xStorage->openStorageElement( rElems[i], nOpenMode );
+ rNastiness.m_xBadness->push_back( xStorage );
+ }
+ return xStorage;
+}
+
+uno::Reference< embed::XStorage > OStorageHelper::GetStorageAtPath(
+ const uno::Reference< embed::XStorage > &xStorage,
+ std::u16string_view rPath, sal_uInt32 nOpenMode,
+ LifecycleProxy const &rNastiness )
+{
+ std::vector<OUString> aElems;
+ splitPath( aElems, rPath );
+ return LookupStorageAtPath( xStorage, aElems, nOpenMode, rNastiness );
+}
+
+uno::Reference< io::XStream > OStorageHelper::GetStreamAtPath(
+ const uno::Reference< embed::XStorage > &xParentStorage,
+ std::u16string_view rPath, sal_uInt32 nOpenMode,
+ LifecycleProxy const &rNastiness )
+{
+ std::vector<OUString> aElems;
+ splitPath( aElems, rPath );
+ OUString aName( aElems.back() );
+ aElems.pop_back();
+ sal_uInt32 nStorageMode = nOpenMode & ~embed::ElementModes::TRUNCATE;
+ uno::Reference< embed::XStorage > xStorage(
+ LookupStorageAtPath( xParentStorage, aElems, nStorageMode, rNastiness ),
+ uno::UNO_SET_THROW );
+ return xStorage->openStreamElement( aName, nOpenMode );
+}
+
+uno::Reference< io::XStream > OStorageHelper::GetStreamAtPackageURL(
+ uno::Reference< embed::XStorage > const& xParentStorage,
+ const OUString& rURL, sal_uInt32 const nOpenMode,
+ LifecycleProxy const & rNastiness)
+{
+ OUString path;
+ if (rURL.startsWithIgnoreAsciiCase("vnd.sun.star.Package:", &path))
+ {
+ return GetStreamAtPath(xParentStorage, path, nOpenMode, rNastiness);
+ }
+ return nullptr;
+}
+
+OUString OStorageHelper::GetODFVersionFromStorage(const uno::Reference<embed::XStorage>& xStorage)
+{
+ OUString aODFVersion;
+ try
+ {
+ uno::Reference<beans::XPropertySet> xPropSet(xStorage, uno::UNO_QUERY_THROW);
+ xPropSet->getPropertyValue("Version") >>= aODFVersion;
+ }
+ catch (uno::Exception&)
+ {
+ }
+ return aODFVersion;
+}
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/string.cxx b/comphelper/source/misc/string.cxx
new file mode 100644
index 000000000..d40b9136b
--- /dev/null
+++ b/comphelper/source/misc/string.cxx
@@ -0,0 +1,623 @@
+/* -*- 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 <sal/config.h>
+
+#include <cstddef>
+#include <string_view>
+#include <utility>
+#include <vector>
+#include <algorithm>
+
+#include <o3tl/safeint.hxx>
+#include <o3tl/string_view.hxx>
+#include <rtl/character.hxx>
+#include <rtl/ustring.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <rtl/string.hxx>
+#include <rtl/strbuf.hxx>
+#include <sal/types.h>
+
+#include <comphelper/string.hxx>
+#include <comphelper/stl_types.hxx>
+#include <comphelper/sequence.hxx>
+
+#include <com/sun/star/i18n/BreakIterator.hpp>
+#include <com/sun/star/i18n/CharType.hpp>
+#include <com/sun/star/i18n/Collator.hpp>
+
+
+namespace comphelper::string {
+
+namespace
+{
+ template <typename T, typename C> T tmpl_stripStart(const T &rIn,
+ const C cRemove)
+ {
+ if (rIn.empty())
+ return rIn;
+
+ typename T::size_type i = 0;
+
+ while (i < rIn.size())
+ {
+ if (rIn[i] != cRemove)
+ break;
+ ++i;
+ }
+
+ return rIn.substr(i);
+ }
+ template <typename T, typename C> T tmpl_stripStartString(const T &rIn,
+ const C cRemove)
+ {
+ if (rIn.isEmpty())
+ return rIn;
+
+ sal_Int32 i = 0;
+
+ while (i < rIn.getLength())
+ {
+ if (rIn[i] != cRemove)
+ break;
+ ++i;
+ }
+
+ return rIn.copy(i);
+ }
+}
+
+OString stripStart(const OString& rIn, char c)
+{
+ return tmpl_stripStartString<OString, char>(rIn, c);
+}
+
+std::string_view stripStart(std::string_view rIn, char c)
+{
+ return tmpl_stripStart<std::string_view, char>(rIn, c);
+}
+
+OUString stripStart(const OUString& rIn, sal_Unicode c)
+{
+ return tmpl_stripStartString<OUString, sal_Unicode>(rIn, c);
+}
+
+std::u16string_view stripStart(std::u16string_view rIn, sal_Unicode c)
+{
+ return tmpl_stripStart<std::u16string_view, sal_Unicode>(rIn, c);
+}
+
+namespace
+{
+ template <typename T, typename C> T tmpl_stripEnd(const T &rIn,
+ const C cRemove)
+ {
+ if (rIn.empty())
+ return rIn;
+
+ typename T::size_type i = rIn.size();
+
+ while (i > 0)
+ {
+ if (rIn[i-1] != cRemove)
+ break;
+ --i;
+ }
+
+ return rIn.substr(0, i);
+ }
+ template <typename T, typename C> T tmpl_stripEndString(const T &rIn,
+ const C cRemove)
+ {
+ if (rIn.isEmpty())
+ return rIn;
+
+ sal_Int32 i = rIn.getLength();
+
+ while (i > 0)
+ {
+ if (rIn[i-1] != cRemove)
+ break;
+ --i;
+ }
+
+ return rIn.copy(0, i);
+ }
+}
+
+OString stripEnd(const OString& rIn, char c)
+{
+ return tmpl_stripEndString<OString, char>(rIn, c);
+}
+
+std::string_view stripEnd(std::string_view rIn, char c)
+{
+ return tmpl_stripEnd<std::string_view, char>(rIn, c);
+}
+
+OUString stripEnd(const OUString& rIn, sal_Unicode c)
+{
+ return tmpl_stripEndString<OUString, sal_Unicode>(rIn, c);
+}
+
+std::u16string_view stripEnd(std::u16string_view rIn, sal_Unicode c)
+{
+ return tmpl_stripEnd<std::u16string_view, sal_Unicode>(rIn, c);
+}
+
+OString strip(const OString& rIn, char c)
+{
+ auto x = tmpl_stripStartString<OString, char>(rIn, c);
+ return stripEnd(x, c);
+}
+
+std::string_view strip(std::string_view rIn, char c)
+{
+ auto x = tmpl_stripStart<std::string_view, char>(rIn, c);
+ return stripEnd(x, c);
+}
+
+OUString strip(const OUString& rIn, sal_Unicode c)
+{
+ auto x = tmpl_stripStartString<OUString, sal_Unicode>(rIn, c);
+ return stripEnd(x, c);
+}
+
+std::u16string_view strip(std::u16string_view rIn, sal_Unicode c)
+{
+ auto x = tmpl_stripStart<std::u16string_view, sal_Unicode>(rIn, c);
+ return stripEnd(x, c);
+}
+
+namespace
+{
+ template <typename T, typename C> sal_Int32 tmpl_getTokenCount( T rIn,
+ C cTok)
+ {
+ // Empty String: TokenCount by Definition is 0
+ if (rIn.empty())
+ return 0;
+
+ sal_Int32 nTokCount = 1;
+ for (typename T::size_type i = 0; i < rIn.size(); ++i)
+ {
+ if (rIn[i] == cTok)
+ ++nTokCount;
+ }
+ return nTokCount;
+ }
+}
+
+sal_Int32 getTokenCount(std::string_view rIn, char cTok)
+{
+ return tmpl_getTokenCount<std::string_view, char>(rIn, cTok);
+}
+
+sal_Int32 getTokenCount(std::u16string_view rIn, sal_Unicode cTok)
+{
+ return tmpl_getTokenCount<std::u16string_view, sal_Unicode>(rIn, cTok);
+}
+
+static sal_uInt32 decimalStringToNumber(
+ OUString const & str, sal_Int32 nStart, sal_Int32 nLength )
+{
+ sal_uInt32 result = 0;
+ for( sal_Int32 i = nStart; i < nStart + nLength; )
+ {
+ sal_uInt32 c = str.iterateCodePoints(&i);
+ sal_uInt32 value = 0;
+ if( c <= 0x0039) // ASCII decimal digits, most common
+ value = c - 0x0030;
+ else if( c >= 0x1D7F6 ) // mathematical monospace digits
+ value = c - 0x1D7F6;
+ else if( c >= 0x1D7EC ) // mathematical sans-serif bold digits
+ value = c - 0x1D7EC;
+ else if( c >= 0x1D7E2 ) // mathematical sans-serif digits
+ value = c - 0x1D7E2;
+ else if( c >= 0x1D7D8 ) // mathematical double-struck digits
+ value = c - 0x1D7D8;
+ else if( c >= 0x1D7CE ) // mathematical bold digits
+ value = c - 0x1D7CE;
+ else if( c >= 0x11066 ) // brahmi digits
+ value = c - 0x11066;
+ else if( c >= 0x104A0 ) // osmanya digits
+ value = c - 0x104A0;
+ else if( c >= 0xFF10 ) // fullwidth digits
+ value = c - 0xFF10;
+ else if( c >= 0xABF0 ) // meetei mayek digits
+ value = c - 0xABF0;
+ else if( c >= 0xAA50 ) // cham digits
+ value = c - 0xAA50;
+ else if( c >= 0xA9D0 ) // javanese digits
+ value = c - 0xA9D0;
+ else if( c >= 0xA900 ) // kayah li digits
+ value = c - 0xA900;
+ else if( c >= 0xA8D0 ) // saurashtra digits
+ value = c - 0xA8D0;
+ else if( c >= 0xA620 ) // vai digits
+ value = c - 0xA620;
+ else if( c >= 0x1C50 ) // ol chiki digits
+ value = c - 0x1C50;
+ else if( c >= 0x1C40 ) // lepcha digits
+ value = c - 0x1C40;
+ else if( c >= 0x1BB0 ) // sundanese digits
+ value = c - 0x1BB0;
+ else if( c >= 0x1B50 ) // balinese digits
+ value = c - 0x1B50;
+ else if( c >= 0x1A90 ) // tai tham tham digits
+ value = c - 0x1A90;
+ else if( c >= 0x1A80 ) // tai tham hora digits
+ value = c - 0x1A80;
+ else if( c >= 0x19D0 ) // new tai lue digits
+ value = c - 0x19D0;
+ else if( c >= 0x1946 ) // limbu digits
+ value = c - 0x1946;
+ else if( c >= 0x1810 ) // mongolian digits
+ value = c - 0x1810;
+ else if( c >= 0x17E0 ) // khmer digits
+ value = c - 0x17E0;
+ else if( c >= 0x1090 ) // myanmar shan digits
+ value = c - 0x1090;
+ else if( c >= 0x1040 ) // myanmar digits
+ value = c - 0x1040;
+ else if( c >= 0x0F20 ) // tibetan digits
+ value = c - 0x0F20;
+ else if( c >= 0x0ED0 ) // lao digits
+ value = c - 0x0ED0;
+ else if( c >= 0x0E50 ) // thai digits
+ value = c - 0x0E50;
+ else if( c >= 0x0D66 ) // malayalam digits
+ value = c - 0x0D66;
+ else if( c >= 0x0CE6 ) // kannada digits
+ value = c - 0x0CE6;
+ else if( c >= 0x0C66 ) // telugu digits
+ value = c - 0x0C66;
+ else if( c >= 0x0BE6 ) // tamil digits
+ value = c - 0x0BE6;
+ else if( c >= 0x0B66 ) // odia digits
+ value = c - 0x0B66;
+ else if( c >= 0x0AE6 ) // gujarati digits
+ value = c - 0x0AE6;
+ else if( c >= 0x0A66 ) // gurmukhi digits
+ value = c - 0x0A66;
+ else if( c >= 0x09E6 ) // bengali digits
+ value = c - 0x09E6;
+ else if( c >= 0x0966 ) // devanagari digit
+ value = c - 0x0966;
+ else if( c >= 0x07C0 ) // nko digits
+ value = c - 0x07C0;
+ else if( c >= 0x06F0 ) // extended arabic-indic digits
+ value = c - 0x06F0;
+ else if( c >= 0x0660 ) // arabic-indic digits
+ value = c - 0x0660;
+ result = result * 10 + value;
+ }
+ return result;
+}
+
+sal_uInt32 decimalStringToNumber(
+ OUString const & str )
+{
+ return decimalStringToNumber(str, 0, str.getLength());
+}
+
+using namespace ::com::sun::star;
+
+// convert between sequence of string and comma separated string
+
+OUString convertCommaSeparated(
+ uno::Sequence< OUString > const& i_rSeq)
+{
+ OUStringBuffer buf;
+ ::comphelper::intersperse(
+ i_rSeq.begin(), i_rSeq.end(), ::comphelper::OUStringBufferAppender(buf), OUString( ", " ));
+ return buf.makeStringAndClear();
+}
+
+std::vector<OUString>
+ split(std::u16string_view rStr, sal_Unicode cSeparator)
+{
+ std::vector< OUString > vec;
+ std::size_t idx = 0;
+ do
+ {
+ std::u16string_view kw = o3tl::getToken(rStr, cSeparator, idx);
+ kw = o3tl::trim(kw);
+ if (!kw.empty())
+ {
+ vec.push_back(OUString(kw));
+ }
+
+ } while (idx != std::u16string_view::npos);
+
+ return vec;
+}
+
+uno::Sequence< OUString >
+ convertCommaSeparated( std::u16string_view i_rString )
+{
+ std::vector< OUString > vec = split(i_rString, ',');
+ return comphelper::containerToSequence(vec);
+}
+
+OString join(std::string_view rSeparator, const std::vector<OString>& rSequence)
+{
+ OStringBuffer aBuffer;
+ for (size_t i = 0; i < rSequence.size(); ++i)
+ {
+ if (i != 0)
+ aBuffer.append(rSeparator);
+ aBuffer.append(rSequence[i]);
+ }
+ return aBuffer.makeStringAndClear();
+}
+
+sal_Int32 compareNatural( const OUString & rLHS, const OUString & rRHS,
+ const uno::Reference< i18n::XCollator > &rCollator,
+ const uno::Reference< i18n::XBreakIterator > &rBI,
+ const lang::Locale &rLocale )
+{
+ sal_Int32 nRet = 0;
+
+ sal_Int32 nLHSLastNonDigitPos = 0;
+ sal_Int32 nRHSLastNonDigitPos = 0;
+ sal_Int32 nLHSFirstDigitPos = 0;
+ sal_Int32 nRHSFirstDigitPos = 0;
+
+ // Check if the string starts with a digit
+ sal_Int32 nStartsDigitLHS = rBI->endOfCharBlock(rLHS, nLHSFirstDigitPos, rLocale, i18n::CharType::DECIMAL_DIGIT_NUMBER);
+ sal_Int32 nStartsDigitRHS = rBI->endOfCharBlock(rRHS, nRHSFirstDigitPos, rLocale, i18n::CharType::DECIMAL_DIGIT_NUMBER);
+
+ if (nStartsDigitLHS > 0 && nStartsDigitRHS > 0)
+ {
+ sal_uInt32 nLHS = comphelper::string::decimalStringToNumber(rLHS, 0, nStartsDigitLHS);
+ sal_uInt32 nRHS = comphelper::string::decimalStringToNumber(rRHS, 0, nStartsDigitRHS);
+
+ if (nLHS != nRHS)
+ return nLHS < nRHS ? -1 : 1;
+ nLHSLastNonDigitPos = nStartsDigitLHS;
+ nRHSLastNonDigitPos = nStartsDigitRHS;
+ }
+ else if (nStartsDigitLHS > 0)
+ return -1;
+ else if (nStartsDigitRHS > 0)
+ return 1;
+
+ while (nLHSFirstDigitPos < rLHS.getLength() || nRHSFirstDigitPos < rRHS.getLength())
+ {
+ sal_Int32 nLHSChunkLen;
+ sal_Int32 nRHSChunkLen;
+
+ //Compare non digit block as normal strings
+ nLHSFirstDigitPos = rBI->nextCharBlock(rLHS, nLHSLastNonDigitPos, rLocale, i18n::CharType::DECIMAL_DIGIT_NUMBER);
+ nRHSFirstDigitPos = rBI->nextCharBlock(rRHS, nRHSLastNonDigitPos, rLocale, i18n::CharType::DECIMAL_DIGIT_NUMBER);
+
+ if (nLHSFirstDigitPos == -1)
+ nLHSFirstDigitPos = rLHS.getLength();
+
+ if (nRHSFirstDigitPos == -1)
+ nRHSFirstDigitPos = rRHS.getLength();
+
+ nLHSChunkLen = nLHSFirstDigitPos - nLHSLastNonDigitPos;
+ nRHSChunkLen = nRHSFirstDigitPos - nRHSLastNonDigitPos;
+
+ nRet = rCollator->compareSubstring(rLHS, nLHSLastNonDigitPos, nLHSChunkLen, rRHS, nRHSLastNonDigitPos, nRHSChunkLen);
+ if (nRet != 0)
+ break;
+
+ //Compare digit block as one number vs another
+ nLHSLastNonDigitPos = rBI->endOfCharBlock(rLHS, nLHSFirstDigitPos, rLocale, i18n::CharType::DECIMAL_DIGIT_NUMBER);
+ nRHSLastNonDigitPos = rBI->endOfCharBlock(rRHS, nRHSFirstDigitPos, rLocale, i18n::CharType::DECIMAL_DIGIT_NUMBER);
+ if (nLHSLastNonDigitPos == -1)
+ nLHSLastNonDigitPos = rLHS.getLength();
+ if (nRHSLastNonDigitPos == -1)
+ nRHSLastNonDigitPos = rRHS.getLength();
+ nLHSChunkLen = nLHSLastNonDigitPos - nLHSFirstDigitPos;
+ nRHSChunkLen = nRHSLastNonDigitPos - nRHSFirstDigitPos;
+
+ //To-Do: Possibly scale down those unicode codepoints that relate to
+ //numbers outside of the normal 0-9 range, e.g. see GetLocalizedChar in
+ //vcl
+
+ sal_uInt32 nLHS = comphelper::string::decimalStringToNumber(rLHS, nLHSFirstDigitPos, nLHSChunkLen);
+ sal_uInt32 nRHS = comphelper::string::decimalStringToNumber(rRHS, nRHSFirstDigitPos, nRHSChunkLen);
+
+ if (nLHS != nRHS)
+ {
+ nRet = (nLHS < nRHS) ? -1 : 1;
+ break;
+ }
+ }
+
+ return nRet;
+}
+
+NaturalStringSorter::NaturalStringSorter(
+ const uno::Reference< uno::XComponentContext > &rContext,
+ lang::Locale aLocale) : m_aLocale(std::move(aLocale))
+{
+ m_xCollator = i18n::Collator::create( rContext );
+ m_xCollator->loadDefaultCollator(m_aLocale, 0);
+ m_xBI = i18n::BreakIterator::create( rContext );
+}
+
+bool isdigitAsciiString(std::string_view rString)
+{
+ return std::all_of(
+ rString.data(), rString.data() + rString.size(),
+ [](unsigned char c){ return rtl::isAsciiDigit(c); });
+}
+
+bool isdigitAsciiString(std::u16string_view rString)
+{
+ return std::all_of(
+ rString.data(), rString.data() + rString.size(),
+ [](sal_Unicode c){ return rtl::isAsciiDigit(c); });
+}
+
+namespace
+{
+ template <typename T, typename I, typename O> T tmpl_reverseString(I rIn)
+ {
+ if (rIn.empty())
+ return T();
+
+ typename I::size_type i = rIn.size();
+ O sBuf(static_cast<sal_Int32>(i));
+ while (i)
+ sBuf.append(rIn[--i]);
+ return sBuf.makeStringAndClear();
+ }
+}
+
+OUString reverseString(std::u16string_view rStr)
+{
+ return tmpl_reverseString<OUString, std::u16string_view, OUStringBuffer>(rStr);
+}
+
+OString reverseString(std::string_view rStr)
+{
+ return tmpl_reverseString<OString, std::string_view, OStringBuffer>(rStr);
+}
+
+OUString reverseCodePoints(OUString const & str) {
+ auto const len = str.getLength();
+ OUStringBuffer buf(len);
+ for (auto i = len; i != 0;) {
+ buf.appendUtf32(str.iterateCodePoints(&i, -1));
+ }
+ return buf.makeStringAndClear();
+}
+
+sal_Int32 indexOfAny(std::u16string_view rIn,
+ sal_Unicode const*const pChars, sal_Int32 const nPos)
+{
+ for (std::u16string_view::size_type i = nPos; i < rIn.size(); ++i)
+ {
+ sal_Unicode const c = rIn[i];
+ for (sal_Unicode const* pChar = pChars; *pChar; ++pChar)
+ {
+ if (c == *pChar)
+ {
+ return i;
+ }
+ }
+ }
+ return -1;
+}
+
+OUString removeAny(std::u16string_view rIn,
+ sal_Unicode const*const pChars)
+{
+ OUStringBuffer buf;
+ bool isFound(false);
+ for (std::u16string_view::size_type i = 0; i < rIn.size(); ++i)
+ {
+ sal_Unicode const c = rIn[i];
+ bool removeC(false);
+ for (sal_Unicode const* pChar = pChars; *pChar; ++pChar)
+ {
+ if (c == *pChar)
+ {
+ removeC = true;
+ break;
+ }
+ }
+ if (removeC)
+ {
+ if (!isFound)
+ {
+ if (i > 0)
+ {
+ buf.append(rIn.substr(0, i));
+ }
+ isFound = true;
+ }
+ }
+ else if (isFound)
+ {
+ buf.append(c);
+ }
+ }
+ return isFound ? buf.makeStringAndClear() : OUString(rIn);
+}
+
+OUString setToken(const OUString& rIn, sal_Int32 nToken, sal_Unicode cTok,
+ std::u16string_view rNewToken)
+{
+ sal_Int32 nLen = rIn.getLength();
+ sal_Int32 nTok = 0;
+ sal_Int32 nFirstChar = 0;
+ sal_Int32 i = 0;
+
+ // Determine token position and length
+ while ( i < nLen )
+ {
+ // Increase token count if match
+ if (rIn[i] == cTok)
+ {
+ ++nTok;
+
+ if (nTok == nToken)
+ nFirstChar = i+1;
+ else if (nTok > nToken)
+ break;
+ }
+
+ ++i;
+ }
+
+ if (nTok >= nToken)
+ return rIn.replaceAt(nFirstChar, i-nFirstChar, rNewToken);
+ return rIn;
+}
+
+/** Similar to OUString::replaceAt, but for an OUStringBuffer.
+
+ Replace n = count characters
+ from position index in this string with newStr.
+ */
+void replaceAt(OUStringBuffer& rIn, sal_Int32 nIndex, sal_Int32 nCount, std::u16string_view newStr )
+{
+ assert(nIndex >= 0 && nIndex <= rIn.getLength());
+ assert(nCount >= 0);
+ assert(nCount <= rIn.getLength() - nIndex);
+
+ /* Append? */
+ const sal_Int32 nOldLength = rIn.getLength();
+ if ( nIndex == nOldLength )
+ {
+ rIn.append(newStr);
+ return;
+ }
+
+ sal_Int32 nNewLength = nOldLength + newStr.size() - nCount;
+ if (newStr.size() > o3tl::make_unsigned(nCount))
+ rIn.ensureCapacity(nOldLength + newStr.size() - nCount);
+
+ sal_Unicode* pStr = const_cast<sal_Unicode*>(rIn.getStr());
+ memmove(pStr + nIndex + newStr.size(), pStr + nIndex + nCount, nOldLength - nIndex + nCount);
+ memcpy(pStr + nIndex, newStr.data(), newStr.size());
+
+ rIn.setLength(nNewLength);
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/synchronousdispatch.cxx b/comphelper/source/misc/synchronousdispatch.cxx
new file mode 100644
index 000000000..1602c8963
--- /dev/null
+++ b/comphelper/source/misc/synchronousdispatch.cxx
@@ -0,0 +1,81 @@
+/* -*- 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 <com/sun/star/frame/XDispatchProvider.hpp>
+#include <com/sun/star/frame/XSynchronousDispatch.hpp>
+#include <com/sun/star/lang/XComponent.hpp>
+#include <com/sun/star/util/URLTransformer.hpp>
+
+#include <comphelper/synchronousdispatch.hxx>
+#include <comphelper/processfactory.hxx>
+#include <sal/log.hxx>
+
+namespace comphelper
+{
+
+
+using namespace ::com::sun::star;
+
+uno::Reference< lang::XComponent > SynchronousDispatch::dispatch(
+ const uno::Reference< uno::XInterface > &xStartPoint,
+ const OUString &sURL,
+ const OUString &sTarget,
+ const uno::Sequence< beans::PropertyValue > &lArguments )
+{
+ util::URL aURL;
+ aURL.Complete = sURL;
+ uno::Reference < util::XURLTransformer > xTrans = util::URLTransformer::create( ::comphelper::getProcessComponentContext() );
+ xTrans->parseStrict( aURL );
+
+ uno::Reference < frame::XDispatch > xDispatcher;
+ uno::Reference < frame::XDispatchProvider > xProvider( xStartPoint, uno::UNO_QUERY );
+
+ if ( xProvider.is() )
+ xDispatcher = xProvider->queryDispatch( aURL, sTarget, 0 );
+
+ uno::Reference < lang::XComponent > aComponent;
+
+ if ( xDispatcher.is() )
+ {
+ try
+ {
+ uno::Any aRet;
+ uno::Reference < frame::XSynchronousDispatch > xSyncDisp( xDispatcher, uno::UNO_QUERY_THROW );
+
+ aRet = xSyncDisp->dispatchWithReturnValue( aURL, lArguments );
+
+ aRet >>= aComponent;
+ }
+ catch ( uno::Exception& )
+ {
+ // can't use TOOLS_WARN_EXCEPTION, as comphelper is used by libtl!
+ SAL_WARN("comphelper", "SynchronousDispatch::dispatch(): error while dispatching '"
+ << sURL << "' for '" << sTarget << "'!");
+ }
+ }
+
+ return aComponent;
+}
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/syntaxhighlight.cxx b/comphelper/source/misc/syntaxhighlight.cxx
new file mode 100644
index 000000000..3ce8086e6
--- /dev/null
+++ b/comphelper/source/misc/syntaxhighlight.cxx
@@ -0,0 +1,740 @@
+/* -*- 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 <sal/config.h>
+
+#include <cassert>
+
+#include <rtl/character.hxx>
+#include <unicode/uchar.h>
+#include <comphelper/syntaxhighlight.hxx>
+#include <o3tl/typed_flags_set.hxx>
+
+namespace {
+
+// Flags for character properties
+enum class CharFlags {
+ StartIdentifier = 0x0001,
+ InIdentifier = 0x0002,
+ StartNumber = 0x0004,
+ InNumber = 0x0008,
+ InHexNumber = 0x0010,
+ InOctNumber = 0x0020,
+ StartString = 0x0040,
+ Operator = 0x0080,
+ Space = 0x0100,
+ EOL = 0x0200
+};
+
+}
+
+namespace o3tl {
+ template<> struct typed_flags<CharFlags> : is_typed_flags<CharFlags, 0x03ff> {};
+}
+
+// ##########################################################################
+// ATTENTION: all these words need to be in lower case
+// ##########################################################################
+static const char* strListBasicKeyWords[] = {
+ "access",
+ "alias",
+ "and",
+ "any",
+ "append",
+ "as",
+ "attribute",
+ "base",
+ "binary",
+ "boolean",
+ "byref",
+ "byte",
+ "byval",
+ "call",
+ "case",
+ "cdecl",
+ "classmodule",
+ "close",
+ "compare",
+ "compatible",
+ "const",
+ "currency",
+ "date",
+ "declare",
+ "defbool",
+ "defcur",
+ "defdate",
+ "defdbl",
+ "deferr",
+ "defint",
+ "deflng",
+ "defobj",
+ "defsng",
+ "defstr",
+ "defvar",
+ "dim",
+ "do",
+ "doevents",
+ "double",
+ "each",
+ "else",
+ "elseif",
+ "end",
+ "end enum",
+ "end function",
+ "end if",
+ "end property",
+ "end select",
+ "end sub",
+ "end type",
+ "endif",
+ "enum",
+ "eqv",
+ "erase",
+ "error",
+ "exit",
+ "explicit",
+ "for",
+ "function",
+ "get",
+ "global",
+ "gosub",
+ "goto",
+ "if",
+ "imp",
+ "implements",
+ "in",
+ "input",
+ "integer",
+ "is",
+ "let",
+ "lib",
+ "like",
+ "line",
+ "line input",
+ "local",
+ "lock",
+ "long",
+ "loop",
+ "lprint",
+ "lset",
+ "mod",
+ "name",
+ "new",
+ "next",
+ "not",
+ "object",
+ "on",
+ "open",
+ "option",
+ "optional",
+ "or",
+ "output",
+ "paramarray",
+ "preserve",
+ "print",
+ "private",
+ "property",
+ "public",
+ "random",
+ "read",
+ "redim",
+ "rem",
+ "resume",
+ "return",
+ "rset",
+ "select",
+ "set",
+ "shared",
+ "single",
+ "static",
+ "step",
+ "stop",
+ "string",
+ "sub",
+ "system",
+ "text",
+ "then",
+ "to",
+ "type",
+ "typeof",
+ "until",
+ "variant",
+ "vbasupport",
+ "wend",
+ "while",
+ "with",
+ "withevents",
+ "write",
+ "xor"
+};
+
+
+static const char* strListSqlKeyWords[] = {
+ "all",
+ "and",
+ "any",
+ "as",
+ "asc",
+ "avg",
+ "between",
+ "by",
+ "cast",
+ "corresponding",
+ "count",
+ "create",
+ "cross",
+ "delete",
+ "desc",
+ "distinct",
+ "drop",
+ "escape",
+ "except",
+ "exists",
+ "false",
+ "from",
+ "full",
+ "global",
+ "group",
+ "having",
+ "in",
+ "inner",
+ "insert",
+ "intersect",
+ "into",
+ "is",
+ "join",
+ "left",
+ "like",
+ "limit",
+ "local",
+ "match",
+ "max",
+ "min",
+ "natural",
+ "not",
+ "null",
+ "on",
+ "or",
+ "order",
+ "outer",
+ "right",
+ "select",
+ "set",
+ "some",
+ "sum",
+ "table",
+ "temporary",
+ "true",
+ "union",
+ "unique",
+ "unknown",
+ "update",
+ "using",
+ "values",
+ "where"
+};
+
+
+extern "C" {
+
+static int compare_strings( const void *arg1, const void *arg2 )
+{
+ return strcmp( static_cast<char const *>(arg1), *static_cast<char * const *>(arg2) );
+}
+
+}
+
+namespace
+{
+ bool isAlpha(sal_Unicode c)
+ {
+ if (rtl::isAsciiAlpha(c))
+ return true;
+ return u_isalpha(c);
+ }
+}
+
+class SyntaxHighlighter::Tokenizer
+{
+ // Character information tables
+ CharFlags aCharTypeTab[256] = {};
+
+ // Auxiliary function: testing of the character flags
+ bool testCharFlags(sal_Unicode c, CharFlags nTestFlags) const;
+
+ // Get new token, EmptyString == nothing more over there
+ bool getNextToken(std::u16string_view::const_iterator& pos, std::u16string_view::const_iterator end, /*out*/TokenType& reType,
+ /*out*/std::u16string_view::const_iterator& rpStartPos, /*out*/std::u16string_view::const_iterator& rpEndPos) const;
+
+ const char** ppListKeyWords;
+ sal_uInt16 nKeyWordCount;
+
+public:
+ HighlighterLanguage const aLanguage;
+
+ explicit Tokenizer( HighlighterLanguage aLang );
+
+ void getHighlightPortions(std::u16string_view rLine,
+ /*out*/std::vector<HighlightPortion>& portions) const;
+ void setKeyWords( const char** ppKeyWords, sal_uInt16 nCount );
+};
+
+// Helper function: test character flag
+bool SyntaxHighlighter::Tokenizer::testCharFlags(sal_Unicode c, CharFlags nTestFlags) const
+{
+ bool bRet = false;
+ if( c != 0 && c <= 255 )
+ {
+ bRet = bool(aCharTypeTab[c] & nTestFlags);
+ }
+ else if( c > 255 )
+ {
+ bRet = (( CharFlags::StartIdentifier | CharFlags::InIdentifier ) & nTestFlags)
+ && isAlpha(c);
+ }
+ return bRet;
+}
+
+void SyntaxHighlighter::Tokenizer::setKeyWords( const char** ppKeyWords, sal_uInt16 nCount )
+{
+ ppListKeyWords = ppKeyWords;
+ nKeyWordCount = nCount;
+}
+
+bool SyntaxHighlighter::Tokenizer::getNextToken(std::u16string_view::const_iterator& pos, std::u16string_view::const_iterator end,
+ /*out*/TokenType& reType,
+ /*out*/std::u16string_view::const_iterator& rpStartPos, /*out*/std::u16string_view::const_iterator& rpEndPos) const
+{
+ reType = TokenType::Unknown;
+
+ rpStartPos = pos;
+
+ if( pos == end )
+ return false;
+
+ sal_Unicode c = *pos;
+ ++pos;
+
+ //*** Go through all possibilities ***
+ // Space?
+ if ( testCharFlags( c, CharFlags::Space ) )
+ {
+ while( pos != end && testCharFlags( *pos, CharFlags::Space ) )
+ ++pos;
+
+ reType = TokenType::Whitespace;
+ }
+
+ // Identifier?
+ else if ( testCharFlags( c, CharFlags::StartIdentifier ) )
+ {
+ bool bIdentifierChar;
+ do
+ {
+ if (pos == end)
+ break;
+ // Fetch next character
+ c = *pos;
+ bIdentifierChar = testCharFlags( c, CharFlags::InIdentifier );
+ if( bIdentifierChar )
+ ++pos;
+ }
+ while( bIdentifierChar );
+
+ reType = TokenType::Identifier;
+
+ // Keyword table
+ if (ppListKeyWords != nullptr)
+ {
+ int nCount = pos - rpStartPos;
+
+ // No keyword if string contains char > 255
+ bool bCanBeKeyword = true;
+ for( int i = 0 ; i < nCount ; i++ )
+ {
+ if( rpStartPos[i] > 255 )
+ {
+ bCanBeKeyword = false;
+ break;
+ }
+ }
+
+ if( bCanBeKeyword )
+ {
+ std::u16string_view aKWString(&*rpStartPos, nCount);
+ OString aByteStr = OUStringToOString(aKWString,
+ RTL_TEXTENCODING_ASCII_US).toAsciiLowerCase();
+ if ( bsearch( aByteStr.getStr(), ppListKeyWords, nKeyWordCount, sizeof( char* ),
+ compare_strings ) )
+ {
+ reType = TokenType::Keywords;
+
+ if( aByteStr == "rem" )
+ {
+ // Remove all characters until end of line or EOF
+ for (;;)
+ {
+ if (pos == end)
+ break;
+ sal_Unicode cPeek = *pos;
+ if ( testCharFlags( cPeek, CharFlags::EOL ) )
+ break;
+ ++pos;
+ }
+
+ reType = TokenType::Comment;
+ }
+ }
+ }
+ }
+ }
+
+ // Operator?
+ // only for BASIC '\'' should be a comment, otherwise it is a normal string and handled there
+ else if ( testCharFlags( c, CharFlags::Operator ) || ( (c == '\'') && (aLanguage==HighlighterLanguage::Basic)) )
+ {
+ // parameters for SQL view
+ if (((c==':') || (c=='?')) && (aLanguage == HighlighterLanguage::SQL))
+ {
+ if (c!='?')
+ {
+ bool bIdentifierChar;
+ do
+ {
+ // Get next character
+ if (pos == end)
+ break;
+ c = *pos;
+ bIdentifierChar = isAlpha(c);
+ if( bIdentifierChar )
+ ++pos;
+ }
+ while( bIdentifierChar );
+ }
+ reType = TokenType::Parameter;
+ }
+ else if ((c=='-') && (aLanguage == HighlighterLanguage::SQL))
+ {
+ if (pos != end && *pos=='-')
+ {
+ // Remove all characters until end of line or EOF
+ while( pos != end && !testCharFlags( *pos, CharFlags::EOL ) )
+ {
+ ++pos;
+ }
+ reType = TokenType::Comment;
+ }
+ else
+ reType = TokenType::Operator;
+ }
+ else if ((c=='/') && (aLanguage == HighlighterLanguage::SQL))
+ {
+ if (pos != end && *pos=='/')
+ {
+ // Remove all characters until end of line or EOF
+ while( pos != end && !testCharFlags( *pos, CharFlags::EOL ) )
+ {
+ ++pos;
+ }
+ reType = TokenType::Comment;
+ }
+ else
+ reType = TokenType::Operator;
+ }
+ else
+ {
+ // Apostrophe is Basic comment
+ if (( c == '\'') && (aLanguage == HighlighterLanguage::Basic))
+ {
+ // Skip all characters until end of input or end of line:
+ for (;;) {
+ if (pos == end)
+ break;
+ c = *pos;
+ if (testCharFlags(c, CharFlags::EOL)) {
+ break;
+ }
+ ++pos;
+ }
+
+ reType = TokenType::Comment;
+ }
+
+ // The real operator; can be easily used since not the actual
+ // operator (e.g. +=) is concerned, but the fact that it is one
+ if( reType != TokenType::Comment )
+ {
+ reType = TokenType::Operator;
+ }
+
+ }
+ }
+
+ // Object separator? Must be handled before Number
+ else if( c == '.' && ( pos == end || *pos < '0' || *pos > '9' ) )
+ {
+ reType = TokenType::Operator;
+ }
+
+ // Number?
+ else if( testCharFlags( c, CharFlags::StartNumber ) )
+ {
+ reType = TokenType::Number;
+
+ // Number system, 10 = normal, it is changed for Oct/Hex
+ int nRadix = 10;
+
+ // Is it an Oct or a Hex number?
+ if( c == '&' )
+ {
+ // Octal?
+ if( pos != end && (*pos == 'o' || *pos == 'O' ))
+ {
+ // remove o
+ ++pos;
+ nRadix = 8; // Octal base
+
+ // Read all numbers
+ while( pos != end && testCharFlags( *pos, CharFlags::InOctNumber ) )
+ ++pos;
+ }
+ // Hexadecimal?
+ else if( pos != end && (*pos == 'h' || *pos == 'H' ))
+ {
+ // remove x
+ ++pos;
+ nRadix = 16; // Hexadecimal base
+
+ // Read all numbers
+ while( pos != end && testCharFlags( *pos, CharFlags::InHexNumber ) )
+ ++pos;
+ }
+ else
+ {
+ reType = TokenType::Operator;
+ }
+ }
+
+ // When it is not Oct or Hex, then it is double
+ if( reType == TokenType::Number && nRadix == 10 )
+ {
+ // Flag if the last character is an exponent
+ bool bAfterExpChar = false;
+
+ // Read all numbers
+ while( pos != end && (testCharFlags( *pos, CharFlags::InNumber ) ||
+ (bAfterExpChar && *pos == '+' ) ||
+ (bAfterExpChar && *pos == '-' ) ))
+ // After exponent +/- are OK, too
+ {
+ c = *pos++;
+ bAfterExpChar = ( c == 'e' || c == 'E' );
+ }
+ }
+ }
+
+ // String?
+ else if( testCharFlags( c, CharFlags::StartString ) )
+ {
+ // Remember which character has opened the string
+ sal_Unicode cEndString = c;
+ if( c == '[' )
+ cEndString = ']';
+
+ // Read all characters
+ while( pos == end || *pos != cEndString )
+ {
+ // Detect EOF before reading next char, so we do not lose EOF
+ if( pos == end )
+ {
+ // ERROR: unterminated string literal
+ reType = TokenType::Error;
+ break;
+ }
+ c = *pos++;
+ if( testCharFlags( c, CharFlags::EOL ) )
+ {
+ // ERROR: unterminated string literal
+ reType = TokenType::Error;
+ break;
+ }
+ }
+
+ if( reType != TokenType::Error )
+ {
+ ++pos;
+ if( cEndString == ']' )
+ reType = TokenType::Identifier;
+ else
+ reType = TokenType::String;
+ }
+ }
+
+ // End of line?
+ else if( testCharFlags( c, CharFlags::EOL ) )
+ {
+ // If another EOL character comes, read it
+ if (pos != end)
+ {
+ sal_Unicode cNext = *pos;
+ if( cNext != c && testCharFlags( cNext, CharFlags::EOL ) )
+ ++pos;
+ }
+
+ reType = TokenType::EOL;
+ }
+
+ // All other will remain TokenType::Unknown
+
+ // Save end position
+ rpEndPos = pos;
+ return true;
+}
+
+SyntaxHighlighter::Tokenizer::Tokenizer( HighlighterLanguage aLang ): aLanguage(aLang)
+{
+ // Fill character table
+ sal_uInt16 i;
+
+ // Allowed characters for identifiers
+ CharFlags nHelpMask = CharFlags::StartIdentifier | CharFlags::InIdentifier;
+ for( i = 'a' ; i <= 'z' ; i++ )
+ aCharTypeTab[i] |= nHelpMask;
+ for( i = 'A' ; i <= 'Z' ; i++ )
+ aCharTypeTab[i] |= nHelpMask;
+ aCharTypeTab[int('_')] |= nHelpMask;
+ aCharTypeTab[int('$')] |= nHelpMask;
+
+ // Digit (can be identifier and number)
+ nHelpMask = CharFlags::InIdentifier | CharFlags::StartNumber |
+ CharFlags::InNumber | CharFlags::InHexNumber;
+ for( i = '0' ; i <= '9' ; i++ )
+ aCharTypeTab[i] |= nHelpMask;
+
+ // Add e, E, . and & here manually
+ aCharTypeTab[int('e')] |= CharFlags::InNumber;
+ aCharTypeTab[int('E')] |= CharFlags::InNumber;
+ aCharTypeTab[int('.')] |= CharFlags::InNumber | CharFlags::StartNumber;
+ aCharTypeTab[int('&')] |= CharFlags::StartNumber;
+
+ // Hexadecimal digit
+ for( i = 'a' ; i <= 'f' ; i++ )
+ aCharTypeTab[i] |= CharFlags::InHexNumber;
+ for( i = 'A' ; i <= 'F' ; i++ )
+ aCharTypeTab[i] |= CharFlags::InHexNumber;
+
+ // Octal digit
+ for( i = '0' ; i <= '7' ; i++ )
+ aCharTypeTab[i] |= CharFlags::InOctNumber;
+
+ // String literal start/end characters
+ aCharTypeTab[int('\'')] |= CharFlags::StartString;
+ aCharTypeTab[int('\"')] |= CharFlags::StartString;
+ aCharTypeTab[int('[')] |= CharFlags::StartString;
+ aCharTypeTab[int('`')] |= CharFlags::StartString;
+
+ // Operator characters
+ aCharTypeTab[int('!')] |= CharFlags::Operator;
+ aCharTypeTab[int('%')] |= CharFlags::Operator;
+ // aCharTypeTab[(int)'&'] |= CharFlags::Operator; Removed because of #i14140
+ aCharTypeTab[int('(')] |= CharFlags::Operator;
+ aCharTypeTab[int(')')] |= CharFlags::Operator;
+ aCharTypeTab[int('*')] |= CharFlags::Operator;
+ aCharTypeTab[int('+')] |= CharFlags::Operator;
+ aCharTypeTab[int(',')] |= CharFlags::Operator;
+ aCharTypeTab[int('-')] |= CharFlags::Operator;
+ aCharTypeTab[int('/')] |= CharFlags::Operator;
+ aCharTypeTab[int(':')] |= CharFlags::Operator;
+ aCharTypeTab[int('<')] |= CharFlags::Operator;
+ aCharTypeTab[int('=')] |= CharFlags::Operator;
+ aCharTypeTab[int('>')] |= CharFlags::Operator;
+ aCharTypeTab[int('?')] |= CharFlags::Operator;
+ aCharTypeTab[int('^')] |= CharFlags::Operator;
+ aCharTypeTab[int('|')] |= CharFlags::Operator;
+ aCharTypeTab[int('~')] |= CharFlags::Operator;
+ aCharTypeTab[int('{')] |= CharFlags::Operator;
+ aCharTypeTab[int('}')] |= CharFlags::Operator;
+ // aCharTypeTab[(int)'['] |= CharFlags::Operator; Removed because of #i17826
+ aCharTypeTab[int(']')] |= CharFlags::Operator;
+ aCharTypeTab[int(';')] |= CharFlags::Operator;
+
+ // Space
+ aCharTypeTab[int(' ') ] |= CharFlags::Space;
+ aCharTypeTab[int('\t')] |= CharFlags::Space;
+
+ // End of line characters
+ aCharTypeTab[int('\r')] |= CharFlags::EOL;
+ aCharTypeTab[int('\n')] |= CharFlags::EOL;
+
+ ppListKeyWords = nullptr;
+ nKeyWordCount = 0;
+}
+
+void SyntaxHighlighter::Tokenizer::getHighlightPortions(std::u16string_view rLine,
+ /*out*/std::vector<HighlightPortion>& portions) const
+{
+ // Set the position to the beginning of the source string
+ auto pos = rLine.begin();
+
+ // Variables for the out parameter
+ TokenType eType;
+ std::u16string_view::const_iterator pStartPos;
+ std::u16string_view::const_iterator pEndPos;
+
+ // Loop over all the tokens
+ while( getNextToken( pos, rLine.end(), eType, pStartPos, pEndPos ) )
+ {
+ portions.emplace_back(
+ pStartPos - rLine.begin(), pEndPos - rLine.begin(), eType);
+ }
+}
+
+
+SyntaxHighlighter::SyntaxHighlighter(HighlighterLanguage language):
+ m_tokenizer(new SyntaxHighlighter::Tokenizer(language))
+{
+ switch (language)
+ {
+ case HighlighterLanguage::Basic:
+ m_tokenizer->setKeyWords( strListBasicKeyWords,
+ std::size( strListBasicKeyWords ));
+ break;
+ case HighlighterLanguage::SQL:
+ m_tokenizer->setKeyWords( strListSqlKeyWords,
+ std::size( strListSqlKeyWords ));
+ break;
+ default:
+ assert(false); // this cannot happen
+ }
+}
+
+SyntaxHighlighter::~SyntaxHighlighter() {}
+
+void SyntaxHighlighter::getHighlightPortions(std::u16string_view rLine,
+ /*out*/std::vector<HighlightPortion>& portions) const
+{
+ m_tokenizer->getHighlightPortions( rLine, portions );
+}
+
+HighlighterLanguage SyntaxHighlighter::GetLanguage() const
+{
+ return m_tokenizer->aLanguage;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/threadpool.cxx b/comphelper/source/misc/threadpool.cxx
new file mode 100644
index 000000000..f0a71eb05
--- /dev/null
+++ b/comphelper/source/misc/threadpool.cxx
@@ -0,0 +1,394 @@
+/* -*- 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/.
+ */
+
+#include <comphelper/threadpool.hxx>
+
+#include <com/sun/star/uno/Exception.hpp>
+#include <config_options.h>
+#include <o3tl/safeint.hxx>
+#include <sal/config.h>
+#include <sal/log.hxx>
+#include <salhelper/thread.hxx>
+#include <algorithm>
+#include <memory>
+#include <thread>
+#include <chrono>
+#include <cstddef>
+#include <comphelper/debuggerinfo.hxx>
+#include <utility>
+
+#if defined HAVE_VALGRIND_HEADERS
+#include <valgrind/memcheck.h>
+#endif
+
+#if defined(_WIN32)
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#endif
+
+namespace comphelper {
+
+/** prevent waiting for a task from inside a task */
+#if defined DBG_UTIL && (defined LINUX || defined _WIN32)
+static thread_local bool gbIsWorkerThread;
+#endif
+
+// used to group thread-tasks for waiting in waitTillDone()
+class ThreadTaskTag
+{
+ std::mutex maMutex;
+ sal_Int32 mnTasksWorking;
+ std::condition_variable maTasksComplete;
+
+public:
+ ThreadTaskTag();
+ bool isDone();
+ void waitUntilDone();
+ void onTaskWorkerDone();
+ void onTaskPushed();
+};
+
+
+class ThreadPool::ThreadWorker : public salhelper::Thread
+{
+ ThreadPool *mpPool;
+public:
+
+ explicit ThreadWorker( ThreadPool *pPool ) :
+ salhelper::Thread("thread-pool"),
+ mpPool( pPool )
+ {
+ }
+
+ virtual void execute() override
+ {
+#if defined DBG_UTIL && (defined LINUX || defined _WIN32)
+ gbIsWorkerThread = true;
+#endif
+ std::unique_lock< std::mutex > aGuard( mpPool->maMutex );
+
+ while( !mpPool->mbTerminate )
+ {
+ std::unique_ptr<ThreadTask> pTask = mpPool->popWorkLocked( aGuard, true );
+ if( pTask )
+ {
+ std::shared_ptr<ThreadTaskTag> pTag(pTask->mpTag);
+ mpPool->incBusyWorker();
+ aGuard.unlock();
+
+ pTask->exec();
+ pTask.reset();
+
+ aGuard.lock();
+ mpPool->decBusyWorker();
+ pTag->onTaskWorkerDone();
+ }
+ }
+ }
+};
+
+ThreadPool::ThreadPool(std::size_t nWorkers)
+ : mbTerminate(true)
+ , mnMaxWorkers(nWorkers)
+ , mnBusyWorkers(0)
+{
+}
+
+ThreadPool::~ThreadPool()
+{
+ // note: calling shutdown from global variable dtor blocks forever on Win7
+ // note2: there isn't enough MSVCRT left on exit to call assert() properly
+ // so these asserts just print something to stderr but exit status is
+ // still 0, but hopefully they will be more helpful on non-WNT platforms
+ assert(mbTerminate);
+ assert(maTasks.empty());
+ assert(mnBusyWorkers == 0);
+}
+
+namespace {
+
+std::shared_ptr< ThreadPool >& GetStaticThreadPool()
+{
+ static std::shared_ptr< ThreadPool > POOL =
+ []()
+ {
+ const std::size_t nThreads = ThreadPool::getPreferredConcurrency();
+ return std::make_shared< ThreadPool >( nThreads );
+ }();
+ return POOL;
+}
+
+}
+
+ThreadPool& ThreadPool::getSharedOptimalPool()
+{
+ return *GetStaticThreadPool();
+}
+
+std::size_t ThreadPool::getPreferredConcurrency()
+{
+ static std::size_t ThreadCount = []()
+ {
+ const std::size_t nHardThreads = o3tl::clamp_to_unsigned<std::size_t>(
+ std::max(std::thread::hardware_concurrency(), 1U));
+ std::size_t nThreads = nHardThreads;
+ const char *pEnv = getenv("MAX_CONCURRENCY");
+ if (pEnv != nullptr)
+ {
+ // Override with user/admin preference.
+ nThreads = o3tl::clamp_to_unsigned<std::size_t>(rtl_str_toInt32(pEnv, 10));
+ }
+
+ nThreads = std::min(nHardThreads, nThreads);
+ return std::max<std::size_t>(nThreads, 1);
+ }();
+
+ return ThreadCount;
+}
+
+// Used to order shutdown, and to ensure there are no lingering
+// threads after LibreOfficeKit pre-init.
+void ThreadPool::shutdown()
+{
+// if (mbTerminate)
+// return;
+
+ std::unique_lock< std::mutex > aGuard( maMutex );
+ shutdownLocked(aGuard);
+}
+
+void ThreadPool::shutdownLocked(std::unique_lock<std::mutex>& aGuard)
+{
+ if( maWorkers.empty() )
+ { // no threads at all -> execute the work in-line
+ std::unique_ptr<ThreadTask> pTask;
+ while ( ( pTask = popWorkLocked(aGuard, false) ) )
+ {
+ std::shared_ptr<ThreadTaskTag> pTag(pTask->mpTag);
+ pTask->exec();
+ pTag->onTaskWorkerDone();
+ }
+ }
+ else
+ {
+ while( !maTasks.empty() )
+ {
+ maTasksChanged.wait( aGuard );
+ // In the (unlikely but possible?) case pushTask() gets called meanwhile,
+ // its notify_one() call is meant to wake a up a thread and process the task.
+ // But if this code gets woken up instead, it could lead to a deadlock.
+ // Pass on the notification.
+ maTasksChanged.notify_one();
+ }
+ }
+ assert( maTasks.empty() );
+
+ // coverity[missing_lock] - on purpose
+ mbTerminate = true;
+
+ maTasksChanged.notify_all();
+
+ decltype(maWorkers) aWorkers;
+ std::swap(maWorkers, aWorkers);
+ aGuard.unlock();
+
+ while (!aWorkers.empty())
+ {
+ rtl::Reference<ThreadWorker> xWorker = aWorkers.back();
+ aWorkers.pop_back();
+ assert(std::find(aWorkers.begin(), aWorkers.end(), xWorker)
+ == aWorkers.end());
+ {
+ xWorker->join();
+ xWorker.clear();
+ }
+ }
+}
+
+void ThreadPool::pushTask( std::unique_ptr<ThreadTask> pTask )
+{
+ std::scoped_lock< std::mutex > aGuard( maMutex );
+
+ mbTerminate = false;
+
+ // Worked on tasks are already removed from maTasks, so include the count of busy workers.
+ if (maWorkers.size() < mnMaxWorkers && maWorkers.size() <= maTasks.size() + mnBusyWorkers)
+ {
+ maWorkers.push_back( new ThreadWorker( this ) );
+ maWorkers.back()->launch();
+ }
+
+ pTask->mpTag->onTaskPushed();
+ maTasks.insert( maTasks.begin(), std::move(pTask) );
+
+ maTasksChanged.notify_one();
+}
+
+std::unique_ptr<ThreadTask> ThreadPool::popWorkLocked( std::unique_lock< std::mutex > & rGuard, bool bWait )
+{
+ do
+ {
+ if( !maTasks.empty() )
+ {
+ std::unique_ptr<ThreadTask> pTask = std::move(maTasks.back());
+ maTasks.pop_back();
+ return pTask;
+ }
+ else if (!bWait || mbTerminate)
+ return nullptr;
+
+ maTasksChanged.wait( rGuard );
+
+ } while (!mbTerminate);
+
+ return nullptr;
+}
+
+void ThreadPool::incBusyWorker()
+{
+ ++mnBusyWorkers;
+}
+
+void ThreadPool::decBusyWorker()
+{
+ assert(mnBusyWorkers >= 1);
+ --mnBusyWorkers;
+}
+
+void ThreadPool::waitUntilDone(const std::shared_ptr<ThreadTaskTag>& rTag, bool bJoin)
+{
+#if defined DBG_UTIL && (defined LINUX || defined _WIN32)
+ assert(!gbIsWorkerThread && "cannot wait for tasks from inside a task");
+#endif
+ {
+ std::unique_lock< std::mutex > aGuard( maMutex );
+
+ if( maWorkers.empty() )
+ { // no threads at all -> execute the work in-line
+ while (!rTag->isDone())
+ {
+ std::unique_ptr<ThreadTask> pTask = popWorkLocked(aGuard, false);
+ if (!pTask)
+ break;
+ std::shared_ptr<ThreadTaskTag> pTag(pTask->mpTag);
+ pTask->exec();
+ pTag->onTaskWorkerDone();
+ }
+ }
+ }
+
+ rTag->waitUntilDone();
+
+ if (bJoin)
+ joinThreadsIfIdle();
+}
+
+void ThreadPool::joinThreadsIfIdle()
+{
+ std::unique_lock< std::mutex > aGuard( maMutex );
+ if (isIdle()) // check if there are still tasks from another tag
+ {
+ shutdownLocked(aGuard);
+ }
+}
+
+std::shared_ptr<ThreadTaskTag> ThreadPool::createThreadTaskTag()
+{
+ return std::make_shared<ThreadTaskTag>();
+}
+
+bool ThreadPool::isTaskTagDone(const std::shared_ptr<ThreadTaskTag>& pTag)
+{
+ return pTag->isDone();
+}
+
+ThreadTask::ThreadTask(std::shared_ptr<ThreadTaskTag> xTag)
+ : mpTag(std::move(xTag))
+{
+}
+
+void ThreadTask::exec()
+{
+ try {
+ doWork();
+ }
+ catch (const std::exception &e)
+ {
+ SAL_WARN("comphelper", "exception in thread worker while calling doWork(): " << e.what());
+ }
+ catch (const css::uno::Exception &e)
+ {
+ SAL_WARN("comphelper", "exception in thread worker while calling doWork(): " << e);
+ }
+ catch (...)
+ {
+ SAL_WARN("comphelper", "unknown exception in thread worker while calling doWork()");
+ }
+}
+
+ThreadTaskTag::ThreadTaskTag() : mnTasksWorking(0)
+{
+}
+
+void ThreadTaskTag::onTaskPushed()
+{
+ std::scoped_lock< std::mutex > aGuard( maMutex );
+ mnTasksWorking++;
+ assert( mnTasksWorking < 65536 ); // sanity checking
+}
+
+void ThreadTaskTag::onTaskWorkerDone()
+{
+ std::scoped_lock< std::mutex > aGuard( maMutex );
+ mnTasksWorking--;
+ assert(mnTasksWorking >= 0);
+ if (mnTasksWorking == 0)
+ maTasksComplete.notify_all();
+}
+
+bool ThreadTaskTag::isDone()
+{
+ std::scoped_lock< std::mutex > aGuard( maMutex );
+ return mnTasksWorking == 0;
+}
+
+void ThreadTaskTag::waitUntilDone()
+{
+ std::unique_lock< std::mutex > aGuard( maMutex );
+ while( mnTasksWorking > 0 )
+ {
+#if defined DBG_UTIL && !defined NDEBUG
+ // 10 minute timeout in debug mode, unless the code is built with
+ // sanitizers or debugged in valgrind or gdb, in which case the threads
+ // should not time out in the middle of a debugging session
+ int maxTimeout = 10 * 60;
+#if !ENABLE_RUNTIME_OPTIMIZATIONS
+ maxTimeout = 30 * 60;
+#endif
+#if defined HAVE_VALGRIND_HEADERS
+ if( RUNNING_ON_VALGRIND )
+ maxTimeout = 30 * 60;
+#endif
+ if( isDebuggerAttached())
+ maxTimeout = 300 * 60;
+ std::cv_status result = maTasksComplete.wait_for(
+ aGuard, std::chrono::seconds( maxTimeout ));
+ assert(result != std::cv_status::timeout);
+#else
+ // 10 minute timeout in production so the app eventually throws some kind of error
+ if (maTasksComplete.wait_for(
+ aGuard, std::chrono::seconds( 10 * 60 )) == std::cv_status::timeout)
+ throw std::runtime_error("timeout waiting for threadpool tasks");
+#endif
+ }
+}
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/traceevent.cxx b/comphelper/source/misc/traceevent.cxx
new file mode 100644
index 000000000..fb07e1caa
--- /dev/null
+++ b/comphelper/source/misc/traceevent.cxx
@@ -0,0 +1,144 @@
+/* -*- 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/.
+ */
+
+#include <sal/config.h>
+
+#include <atomic>
+#include <mutex>
+#include <iostream>
+
+#include <comphelper/profilezone.hxx>
+#include <comphelper/sequence.hxx>
+#include <comphelper/traceevent.hxx>
+
+namespace comphelper
+{
+#ifdef DBG_UTIL
+std::atomic<bool> TraceEvent::s_bRecording = (getenv("TRACE_EVENT_RECORDING") != nullptr);
+#else
+std::atomic<bool> TraceEvent::s_bRecording = false;
+#endif
+
+std::size_t TraceEvent::s_nBufferSize = 0;
+void (*TraceEvent::s_pBufferFullCallback)() = nullptr;
+
+int AsyncEvent::s_nIdCounter = 0;
+
+static thread_local int nProfileZoneNesting = 0; // Level of Nested Profile Zones
+
+namespace
+{
+std::vector<OUString> g_aRecording; // recorded data
+std::mutex g_aMutex;
+}
+
+void TraceEvent::addRecording(const OUString& sObject)
+{
+ std::lock_guard aGuard(g_aMutex);
+
+ g_aRecording.emplace_back(sObject);
+
+ if (s_nBufferSize > 0 && g_aRecording.size() >= s_nBufferSize)
+ {
+ if (s_pBufferFullCallback != nullptr)
+ (*s_pBufferFullCallback)();
+ }
+}
+
+void TraceEvent::addInstantEvent(const char* sName, const std::map<OUString, OUString>& args)
+{
+ long long nNow = getNow();
+
+ int nPid = 0;
+ oslProcessInfo aProcessInfo;
+ aProcessInfo.Size = sizeof(oslProcessInfo);
+ if (osl_getProcessInfo(nullptr, osl_Process_IDENTIFIER, &aProcessInfo) == osl_Process_E_None)
+ nPid = aProcessInfo.Ident;
+
+ addRecording("{"
+ "\"name:\""
+ + OUString(sName, strlen(sName), RTL_TEXTENCODING_UTF8)
+ + "\","
+ "\"ph\":\"i\""
+ + createArgsString(args) + ",\"ts\":" + OUString::number(nNow)
+ + ","
+ "\"pid\":"
+ + OUString::number(nPid)
+ + ","
+ "\"tid\":"
+ + OUString::number(osl_getThreadIdentifier(nullptr)) + "},");
+}
+
+void TraceEvent::startRecording()
+{
+ std::lock_guard aGuard(g_aMutex);
+ s_bRecording = true;
+}
+
+void TraceEvent::stopRecording() { s_bRecording = false; }
+
+void TraceEvent::setBufferSizeAndCallback(std::size_t bufferSize, void (*bufferFullCallback)())
+{
+ s_nBufferSize = bufferSize;
+ s_pBufferFullCallback = bufferFullCallback;
+}
+
+std::vector<OUString> TraceEvent::getEventVectorAndClear()
+{
+ bool bRecording;
+ std::vector<OUString> aRecording;
+ {
+ std::lock_guard aGuard(g_aMutex);
+ bRecording = s_bRecording;
+ stopRecording();
+ aRecording.swap(g_aRecording);
+ }
+ // reset start time and nesting level
+ if (bRecording)
+ startRecording();
+ return aRecording;
+}
+
+css::uno::Sequence<OUString> TraceEvent::getRecordingAndClear()
+{
+ return comphelper::containerToSequence(getEventVectorAndClear());
+}
+
+void ProfileZone::addRecording()
+{
+ assert(s_bRecording);
+
+ long long nNow = getNow();
+
+ // Generate a single "Complete Event" (type X)
+ TraceEvent::addRecording("{"
+ "\"name\":\""
+ + OUString(m_sName, strlen(m_sName), RTL_TEXTENCODING_UTF8)
+ + "\","
+ "\"ph\":\"X\","
+ "\"ts\":"
+ + OUString::number(m_nCreateTime)
+ + ","
+ "\"dur\":"
+ + OUString::number(nNow - m_nCreateTime) + m_sArgs
+ + ","
+ "\"pid\":"
+ + OUString::number(m_nPid)
+ + ","
+ "\"tid\":"
+ + OUString::number(osl_getThreadIdentifier(nullptr)) + "},");
+}
+
+int ProfileZone::getNestingLevel() { return nProfileZoneNesting; }
+
+void ProfileZone::setNestingLevel(int nNestingLevel) { nProfileZoneNesting = nNestingLevel; }
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/typedescriptionref.hxx b/comphelper/source/misc/typedescriptionref.hxx
new file mode 100644
index 000000000..f4580cb2e
--- /dev/null
+++ b/comphelper/source/misc/typedescriptionref.hxx
@@ -0,0 +1,51 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <typelib/typedescription.h>
+
+namespace comphelper::detail
+{
+// This is like com::sun::star::uno::TypeDescription, but it uses TYPELIB_DANGER_GET
+// (which the code used originally, but it's easier to have a class to handle ownership).
+class TypeDescriptionRef
+{
+public:
+ TypeDescriptionRef(typelib_TypeDescriptionReference* typeDef)
+ {
+ TYPELIB_DANGER_GET(&typeDescr, typeDef);
+ }
+ ~TypeDescriptionRef() { TYPELIB_DANGER_RELEASE(typeDescr); }
+ typelib_TypeDescription* get() { return typeDescr; }
+ typelib_TypeDescription* operator->() { return typeDescr; }
+ bool is() { return typeDescr != nullptr; }
+ bool equals(const TypeDescriptionRef& other) const
+ {
+ return typeDescr && other.typeDescr
+ && typelib_typedescription_equals(typeDescr, other.typeDescr);
+ }
+
+private:
+ typelib_TypeDescription* typeDescr = nullptr;
+};
+
+} // namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/types.cxx b/comphelper/source/misc/types.cxx
new file mode 100644
index 000000000..8887d5b5a
--- /dev/null
+++ b/comphelper/source/misc/types.cxx
@@ -0,0 +1,146 @@
+/* -*- 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 <comphelper/types.hxx>
+#include <comphelper/extract.hxx>
+#include <com/sun/star/awt/FontUnderline.hpp>
+#include <com/sun/star/awt/FontStrikeout.hpp>
+#include <com/sun/star/awt/FontDescriptor.hpp>
+#include <o3tl/any.hxx>
+#include <osl/diagnose.h>
+#include <typelib/typedescription.hxx>
+#include <sal/log.hxx>
+
+namespace comphelper
+{
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::awt;
+using namespace ::com::sun::star::lang;
+
+sal_Int64 getINT64(const Any& _rAny)
+{
+ sal_Int64 nReturn = 0;
+ if (!(_rAny >>= nReturn))
+ SAL_WARN("comphelper", "conversion from Any to sal_Int64 failed");
+ return nReturn;
+}
+
+sal_Int32 getINT32(const Any& _rAny)
+{
+ sal_Int32 nReturn = 0;
+ if (!(_rAny >>= nReturn))
+ SAL_WARN("comphelper", "conversion from Any to sal_Int32 failed");
+ return nReturn;
+}
+
+sal_Int16 getINT16(const Any& _rAny)
+{
+ sal_Int16 nReturn = 0;
+ if (!(_rAny >>= nReturn))
+ SAL_WARN("comphelper", "conversion from Any to sal_Int16 failed");
+ return nReturn;
+}
+
+double getDouble(const Any& _rAny)
+{
+ double nReturn = 0.0;
+ if (!(_rAny >>= nReturn))
+ SAL_WARN("comphelper", "conversion from Any to double failed");
+ return nReturn;
+}
+
+float getFloat(const Any& _rAny)
+{
+ float nReturn = 0.0;
+ if (!(_rAny >>= nReturn))
+ SAL_WARN("comphelper", "conversion from Any to float failed");
+ return nReturn;
+}
+
+OUString getString(const Any& _rAny)
+{
+ OUString nReturn;
+ if (!(_rAny >>= nReturn))
+ SAL_WARN("comphelper", "conversion from Any to OUString failed");
+ return nReturn;
+}
+
+bool getBOOL(const Any& _rAny)
+{
+ bool bReturn = false;
+ if (auto b = o3tl::tryAccess<bool>(_rAny))
+ bReturn = *b;
+ else
+ OSL_FAIL("comphelper::getBOOL : invalid argument !");
+ return bReturn;
+}
+
+sal_Int32 getEnumAsINT32(const Any& _rAny)
+{
+ sal_Int32 nReturn = 0;
+ if (!::cppu::enum2int(nReturn, _rAny))
+ throw IllegalArgumentException("enum2int failed",
+ css::uno::Reference<css::uno::XInterface>(), -1);
+ return nReturn;
+}
+
+FontDescriptor getDefaultFont()
+{
+ FontDescriptor aReturn;
+ aReturn.Slant = FontSlant_DONTKNOW;
+ aReturn.Underline = FontUnderline::DONTKNOW;
+ aReturn.Strikeout = com::sun::star::awt::FontStrikeout::DONTKNOW;
+ return aReturn;
+}
+
+bool isAssignableFrom(const Type& _rAssignable, const Type& _rFrom)
+{
+ // get the type lib descriptions
+ typelib_TypeDescription* pAssignable = nullptr;
+ _rAssignable.getDescription(&pAssignable);
+
+ typelib_TypeDescription* pFrom = nullptr;
+ _rFrom.getDescription(&pFrom);
+
+ // and ask the type lib
+ return typelib_typedescription_isAssignableFrom(pAssignable, pFrom);
+}
+
+Type getSequenceElementType(const Type& _rSequenceType)
+{
+ OSL_ENSURE(_rSequenceType.getTypeClass() == TypeClass_SEQUENCE,
+ "getSequenceElementType: must be called with a sequence type!");
+
+ if (_rSequenceType.getTypeClass() != TypeClass_SEQUENCE)
+ return Type();
+
+ TypeDescription aTD(_rSequenceType);
+ typelib_IndirectTypeDescription* pSequenceTD
+ = reinterpret_cast<typelib_IndirectTypeDescription*>(aTD.get());
+
+ OSL_ASSERT(pSequenceTD && pSequenceTD->pType);
+ if (pSequenceTD && pSequenceTD->pType)
+ return Type(pSequenceTD->pType);
+
+ return Type();
+}
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/weak.cxx b/comphelper/source/misc/weak.cxx
new file mode 100644
index 000000000..02cf40e2b
--- /dev/null
+++ b/comphelper/source/misc/weak.cxx
@@ -0,0 +1,57 @@
+/* -*- 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 <comphelper/weak.hxx>
+
+using namespace com::sun::star::uno;
+using namespace com::sun::star::lang;
+
+namespace comphelper
+{
+
+OWeakTypeObject::OWeakTypeObject()
+{
+}
+
+OWeakTypeObject::~OWeakTypeObject()
+{
+}
+
+Any SAL_CALL OWeakTypeObject::queryInterface(const Type & rType )
+{
+ if( rType == cppu::UnoType<XTypeProvider>::get() )
+ return Any( Reference< XTypeProvider >(this) );
+ else
+ return ::cppu::OWeakObject::queryInterface( rType );
+}
+
+Sequence< Type > SAL_CALL OWeakTypeObject::getTypes( )
+{
+ return Sequence< Type >();
+}
+
+Sequence< ::sal_Int8 > SAL_CALL OWeakTypeObject::getImplementationId( )
+{
+ return Sequence< ::sal_Int8 >();
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/weakeventlistener.cxx b/comphelper/source/misc/weakeventlistener.cxx
new file mode 100644
index 000000000..e8ce46590
--- /dev/null
+++ b/comphelper/source/misc/weakeventlistener.cxx
@@ -0,0 +1,74 @@
+/* -*- 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 <comphelper/weakeventlistener.hxx>
+#include <osl/diagnose.h>
+
+
+namespace comphelper
+{
+
+
+ using namespace ::com::sun::star::uno;
+ using namespace ::com::sun::star::lang;
+
+ OWeakListenerAdapterBase::~OWeakListenerAdapterBase()
+ {
+ }
+
+ OWeakEventListenerAdapter::OWeakEventListenerAdapter( Reference< XWeak > const & _rxListener, Reference< XComponent > const & _rxBroadcaster )
+ :OWeakEventListenerAdapter_Base( _rxListener, _rxBroadcaster )
+ {
+ // add ourself as listener to the broadcaster
+ OSL_ENSURE( _rxBroadcaster.is(), "OWeakEventListenerAdapter::OWeakEventListenerAdapter: invalid broadcaster!" );
+ if ( _rxBroadcaster.is() )
+ {
+ osl_atomic_increment( &m_refCount );
+ {
+ _rxBroadcaster->addEventListener( this );
+ }
+ osl_atomic_decrement( &m_refCount );
+ OSL_ENSURE( m_refCount > 0, "OWeakEventListenerAdapter::OWeakEventListenerAdapter: oops - not to be used with implementations which hold their listeners weak!" );
+ // the one and only reason for this adapter class (A) is to add as listener to a component (C) which
+ // holds its listeners hard, and forward all calls then to another listener (L) which is
+ // held weak by A.
+ // Now if C holds listeners weak, then we do not need A, we can add L directly to C.
+ }
+
+ OSL_ENSURE( getListener().is(), "OWeakEventListenerAdapter::OWeakEventListenerAdapter: invalid listener (does not support the XEventListener interface)!" );
+ }
+
+
+ void SAL_CALL OWeakEventListenerAdapter::disposing( )
+ {
+ Reference< XComponent > xBroadcaster( getBroadcaster( ), UNO_QUERY );
+ OSL_ENSURE( xBroadcaster.is(), "OWeakEventListenerAdapter::disposing: broadcaster is invalid in the meantime! How this?" );
+ if ( xBroadcaster.is() )
+ {
+ xBroadcaster->removeEventListener( this );
+ }
+
+ resetListener();
+ }
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/misc/xmlsechelper.cxx b/comphelper/source/misc/xmlsechelper.cxx
new file mode 100644
index 000000000..5b1a438ab
--- /dev/null
+++ b/comphelper/source/misc/xmlsechelper.cxx
@@ -0,0 +1,319 @@
+/* -*- 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 <comphelper/xmlsechelper.hxx>
+
+#include <rtl/ustrbuf.hxx>
+#include <osl/diagnose.h>
+#include <o3tl/string_view.hxx>
+
+#include <utility>
+#include <vector>
+
+namespace comphelper::xmlsec
+{
+ OUString GetCertificateKind( const css::security::CertificateKind &rKind )
+ {
+ switch (rKind)
+ {
+ case css::security::CertificateKind_X509:
+ return "X.509";
+ case css::security::CertificateKind_OPENPGP:
+ return "OpenPGP";
+ default:
+ return OUString();
+ }
+ }
+
+ /*
+ Creates two strings based on the distinguished name which are displayed in the
+ certificate details view. The first string contains only the values of the attribute
+ and values pairs, which are separated by commas. All escape characters ('"') are
+ removed.
+ The second string is for the details view at the bottom. It shows the attribute/value
+ pairs on different lines. All escape characters ('"') are removed.
+ */
+ std::pair< OUString, OUString> GetDNForCertDetailsView( std::u16string_view rRawString)
+ {
+ std::vector< std::pair< OUString, OUString > > vecAttrValueOfDN = parseDN(rRawString);
+ OUStringBuffer s1, s2;
+ for (auto i = vecAttrValueOfDN.cbegin(); i < vecAttrValueOfDN.cend(); ++i)
+ {
+ if (i != vecAttrValueOfDN.cbegin())
+ {
+ s1.append(',');
+ s2.append('\n');
+ }
+ s1.append(i->second);
+ s2.append(i->first + " = " + i->second);
+ }
+ return std::make_pair(s1.makeStringAndClear(), s2.makeStringAndClear());
+ }
+
+/*
+ Whenever the attribute value contains special characters, such as '"' or ',' (without '')
+ then the value will be enclosed in double quotes by the respective Windows or NSS function
+ which we use to retrieve, for example, the subject name. If double quotes appear in the value then
+ they are escaped with a double quote. This function removes the escape characters.
+*/
+#ifdef _WIN32
+std::vector< std::pair< OUString, OUString> > parseDN(std::u16string_view rRawString)
+{
+ std::vector< std::pair<OUString, OUString> > retVal;
+ bool bInEscape = false;
+ bool bInValue = false;
+ bool bInType = true;
+ sal_Int32 nTypeNameStart = 0;
+ std::u16string_view sType;
+ OUStringBuffer sbufValue;
+ size_t length = rRawString.size();
+
+ for (size_t i = 0; i < length; i++)
+ {
+ sal_Unicode c = rRawString[i];
+
+ if (c == '=')
+ {
+ if (! bInValue)
+ {
+ sType = rRawString.substr(nTypeNameStart, i - nTypeNameStart);
+ sType = o3tl::trim(sType);
+ bInType = false;
+ }
+ else
+ {
+ sbufValue.append(c);
+ }
+ }
+ else if (c == '"')
+ {
+ if (!bInEscape)
+ {
+ //If this is the quote is the first of the couple which enclose the
+ //whole value, because the value contains special characters
+ //then we just drop it. That is, this character must be followed by
+ //a character which is not '"'.
+ if ( i + 1 < length && rRawString[i+1] == '"')
+ bInEscape = true;
+ else
+ bInValue = !bInValue; //value is enclosed in " "
+ }
+ else
+ {
+ //This quote is escaped by a preceding quote and therefore is
+ //part of the value
+ sbufValue.append(c);
+ bInEscape = false;
+ }
+ }
+ else if (c == ',' || c == '+')
+ {
+ //The comma separate the attribute value pairs.
+ //If the comma is not part of a value (the value would then be enclosed in '"'),
+ //then we have reached the end of the value
+ if (!bInValue)
+ {
+ OSL_ASSERT(!sType.empty());
+ retVal.push_back(std::make_pair(OUString(sType), sbufValue.makeStringAndClear()));
+ sType = {};
+ //The next char is the start of the new type
+ nTypeNameStart = i + 1;
+ bInType = true;
+ }
+ else
+ {
+ //The whole string is enclosed because it contains special characters.
+ //The enclosing '"' are not part of certificate but will be added by
+ //the function (Windows or NSS) which retrieves DN
+ sbufValue.append(c);
+ }
+ }
+ else
+ {
+ if (!bInType)
+ sbufValue.append(c);
+ }
+ }
+ if (sbufValue.getLength())
+ {
+ OSL_ASSERT(!sType.empty());
+ retVal.push_back(std::make_pair(OUString(sType), sbufValue.makeStringAndClear()));
+ }
+ return retVal;
+ }
+#else
+std::vector< std::pair< OUString, OUString> > parseDN(std::u16string_view rRawString)
+ {
+ std::vector< std::pair<OUString, OUString> > retVal;
+ //bInEscape == true means that the preceding character is an escape character
+ bool bInEscape = false;
+ bool bInValue = false;
+ bool bInType = true;
+ sal_Int32 nTypeNameStart = 0;
+ std::u16string_view sType;
+ OUStringBuffer sbufValue;
+ size_t length = rRawString.size();
+
+ for (size_t i = 0; i < length; i++)
+ {
+ sal_Unicode c = rRawString[i];
+
+ if (c == '=')
+ {
+ if (! bInValue)
+ {
+ sType = rRawString.substr(nTypeNameStart, i - nTypeNameStart);
+ sType = o3tl::trim(sType);
+ bInType = false;
+ }
+ else
+ {
+ sbufValue.append(c);
+ }
+ }
+ else if (c == '\\')
+ {
+ if (!bInEscape)
+ {
+ bInEscape = true;
+ }
+ else
+ { // bInEscape is true
+ sbufValue.append(c);
+ bInEscape = false;
+ }
+ }
+ else if (c == '"')
+ {
+ //an unescaped '"' is either at the beginning or end of the value
+ if (!bInEscape)
+ {
+ if ( !bInValue)
+ bInValue = true;
+ else if (bInValue)
+ bInValue = false;
+ }
+ else
+ {
+ //This quote is escaped by a preceding quote and therefore is
+ //part of the value
+ sbufValue.append(c);
+ bInEscape = false;
+ }
+ }
+ else if (c == ',' || c == '+')
+ {
+ //The comma separate the attribute value pairs.
+ //If the comma is not part of a value (the value would then be enclosed in '"'),
+ //then we have reached the end of the value
+ if (!bInValue)
+ {
+ OSL_ASSERT(!sType.empty());
+ retVal.emplace_back(sType, sbufValue.makeStringAndClear());
+ sType = {};
+ //The next char is the start of the new type
+ nTypeNameStart = i + 1;
+ bInType = true;
+ }
+ else
+ {
+ //The whole string is enclosed because it contains special characters.
+ //The enclosing '"' are not part of certificate but will be added by
+ //the function (Windows or NSS) which retrieves DN
+ sbufValue.append(c);
+ }
+ }
+ else
+ {
+ if (!bInType)
+ {
+ sbufValue.append(c);
+ bInEscape = false;
+ }
+ }
+ }
+ if (!sbufValue.isEmpty())
+ {
+ OSL_ASSERT(!sType.empty());
+ retVal.emplace_back(sType, sbufValue.makeStringAndClear());
+ }
+ return retVal;
+ }
+
+#endif
+
+ OUString GetContentPart( const OUString& _rRawString, const css::security::CertificateKind &rKind )
+ {
+ char const * aIDs[] = { "CN", "OU", "O", "E", nullptr };
+
+ // tdf#131733 Don't process OpenPGP certs, only X509
+ if (rKind == css::security::CertificateKind_OPENPGP )
+ return _rRawString;
+
+ OUString retVal;
+ int i = 0;
+ std::vector< std::pair< OUString, OUString > > vecAttrValueOfDN = parseDN(_rRawString);
+ while ( aIDs[i] )
+ {
+ OUString sPartId = OUString::createFromAscii( aIDs[i++] );
+ auto idn = std::find_if(vecAttrValueOfDN.cbegin(), vecAttrValueOfDN.cend(),
+ [&sPartId](const std::pair< OUString, OUString >& dn) { return dn.first == sPartId; });
+ if (idn != vecAttrValueOfDN.cend())
+ retVal = idn->second;
+ if (!retVal.isEmpty())
+ break;
+ }
+ return retVal.isEmpty() ? _rRawString : retVal;
+ }
+
+ OUString GetHexString( const css::uno::Sequence< sal_Int8 >& _rSeq, const char* _pSep, sal_uInt16 _nLineBreak )
+ {
+ const sal_Int8* pSerNumSeq = _rSeq.getConstArray();
+ int nCnt = _rSeq.getLength();
+ OUStringBuffer aStr;
+ const char pHexDigs[ 17 ] = "0123456789ABCDEF";
+ char pBuffer[ 3 ] = " ";
+ sal_uInt8 nNum;
+ sal_uInt16 nBreakStart = _nLineBreak? _nLineBreak : 1;
+ sal_uInt16 nBreak = nBreakStart;
+ for( int i = 0 ; i < nCnt ; ++i )
+ {
+ nNum = sal_uInt8( pSerNumSeq[ i ] );
+
+ // exchange the buffer[0] and buffer[1], which make it consistent with Mozilla and Windows
+ pBuffer[ 1 ] = pHexDigs[ nNum & 0x0F ];
+ nNum >>= 4;
+ pBuffer[ 0 ] = pHexDigs[ nNum ];
+ aStr.appendAscii( pBuffer );
+
+ --nBreak;
+ if( nBreak )
+ aStr.appendAscii( _pSep );
+ else
+ {
+ nBreak = nBreakStart;
+ aStr.append( '\n' );
+ }
+ }
+
+ return aStr.makeStringAndClear();
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/officeinstdir/officeinstallationdirectories.cxx b/comphelper/source/officeinstdir/officeinstallationdirectories.cxx
new file mode 100644
index 000000000..4cb3eb5e3
--- /dev/null
+++ b/comphelper/source/officeinstdir/officeinstallationdirectories.cxx
@@ -0,0 +1,249 @@
+/* -*- 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 <config_folders.h>
+
+#include <cppuhelper/supportsservice.hxx>
+
+/**************************************************************************
+ TODO
+ **************************************************************************
+
+ *************************************************************************/
+
+#include <osl/file.hxx>
+#include <com/sun/star/util/theMacroExpander.hpp>
+#include <comphelper/fileurl.hxx>
+#include <utility>
+
+#include "officeinstallationdirectories.hxx"
+
+using namespace com::sun::star;
+
+static bool makeCanonicalFileURL( OUString & rURL )
+{
+ OSL_ENSURE(comphelper::isFileUrl(rURL), "File URL expected!");
+
+ OUString aNormalizedURL;
+ if ( osl::FileBase::getAbsoluteFileURL( OUString(),
+ rURL,
+ aNormalizedURL )
+ != osl::DirectoryItem::E_None )
+ return false;
+
+ osl::DirectoryItem aDirItem;
+ if ( osl::DirectoryItem::get( aNormalizedURL, aDirItem )
+ != osl::DirectoryItem::E_None )
+ return false;
+
+ osl::FileStatus aFileStatus( osl_FileStatus_Mask_FileURL );
+
+ if ( aDirItem.getFileStatus( aFileStatus )
+ == osl::DirectoryItem::E_None )
+ {
+ aNormalizedURL = aFileStatus.getFileURL();
+
+ if ( !aNormalizedURL.isEmpty() )
+ {
+ if ( !aNormalizedURL.endsWith("/") )
+ rURL = aNormalizedURL;
+ else
+ rURL = aNormalizedURL
+ .copy( 0, aNormalizedURL.getLength() - 1 );
+
+ return true;
+ }
+ }
+ return false;
+}
+
+namespace comphelper {
+
+constexpr OUStringLiteral g_aOfficeBrandDirMacro(u"$(brandbaseurl)");
+constexpr OUStringLiteral g_aUserDirMacro(u"$(userdataurl)");
+
+OfficeInstallationDirectories::OfficeInstallationDirectories(
+ uno::Reference< uno::XComponentContext > xCtx )
+: m_xCtx(std::move( xCtx ))
+{
+}
+
+
+// virtual
+OfficeInstallationDirectories::~OfficeInstallationDirectories()
+{
+}
+
+
+// util::XOfficeInstallationDirectories
+
+
+// virtual
+OUString SAL_CALL
+OfficeInstallationDirectories::getOfficeInstallationDirectoryURL()
+{
+ initDirs();
+ return *m_xOfficeBrandDir;
+}
+
+
+// virtual
+OUString SAL_CALL
+OfficeInstallationDirectories::getOfficeUserDataDirectoryURL()
+{
+ initDirs();
+ return *m_xUserDir;
+}
+
+
+
+// virtual
+OUString SAL_CALL
+OfficeInstallationDirectories::makeRelocatableURL( const OUString& URL )
+{
+ if ( !URL.isEmpty() )
+ {
+ initDirs();
+
+ OUString aCanonicalURL( URL );
+ makeCanonicalFileURL( aCanonicalURL );
+
+ sal_Int32 nIndex = aCanonicalURL.indexOf( *m_xOfficeBrandDir );
+ if ( nIndex != -1 )
+ {
+ return
+ aCanonicalURL.replaceAt( nIndex,
+ m_xOfficeBrandDir->getLength(),
+ g_aOfficeBrandDirMacro );
+ }
+ else
+ {
+ nIndex = aCanonicalURL.indexOf( *m_xUserDir );
+ if ( nIndex != -1 )
+ {
+ return
+ aCanonicalURL.replaceAt( nIndex,
+ m_xUserDir->getLength(),
+ g_aUserDirMacro );
+ }
+ }
+ }
+ return URL;
+}
+
+
+// virtual
+OUString SAL_CALL
+OfficeInstallationDirectories::makeAbsoluteURL( const OUString& URL )
+{
+ if ( !URL.isEmpty() )
+ {
+ sal_Int32 nIndex = URL.indexOf( g_aOfficeBrandDirMacro );
+ if ( nIndex != -1 )
+ {
+ initDirs();
+
+ return
+ URL.replaceAt( nIndex,
+ g_aOfficeBrandDirMacro.getLength(),
+ *m_xOfficeBrandDir );
+ }
+ else
+ {
+ nIndex = URL.indexOf( g_aUserDirMacro );
+ if ( nIndex != -1 )
+ {
+ initDirs();
+
+ return
+ URL.replaceAt( nIndex,
+ g_aUserDirMacro.getLength(),
+ *m_xUserDir );
+ }
+ }
+ }
+ return URL;
+}
+
+
+// lang::XServiceInfo
+
+
+// virtual
+OUString SAL_CALL
+OfficeInstallationDirectories::getImplementationName()
+{
+ return "com.sun.star.comp.util.OfficeInstallationDirectories";
+}
+
+// virtual
+sal_Bool SAL_CALL
+OfficeInstallationDirectories::supportsService( const OUString& ServiceName )
+{
+ return cppu::supportsService(this, ServiceName);
+}
+
+// virtual
+uno::Sequence< OUString > SAL_CALL
+OfficeInstallationDirectories::getSupportedServiceNames()
+{
+ return { "com.sun.star.util.OfficeInstallationDirectories" };
+}
+
+void OfficeInstallationDirectories::initDirs()
+{
+ if ( m_xOfficeBrandDir)
+ return;
+
+ osl::MutexGuard aGuard( m_aMutex );
+ if ( m_xOfficeBrandDir )
+ return;
+
+ uno::Reference< util::XMacroExpander > xExpander = util::theMacroExpander::get(m_xCtx);
+
+ m_xOfficeBrandDir = xExpander->expandMacros( "$BRAND_BASE_DIR" );
+
+ OSL_ENSURE( !m_xOfficeBrandDir->isEmpty(),
+ "Unable to obtain office brand installation directory!" );
+
+ makeCanonicalFileURL( *m_xOfficeBrandDir );
+
+ m_xUserDir =
+ xExpander->expandMacros(
+ "${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE( "bootstrap" ) ":UserInstallation}" );
+
+ OSL_ENSURE( !m_xUserDir->isEmpty(),
+ "Unable to obtain office user data directory!" );
+
+ makeCanonicalFileURL( *m_xUserDir );
+}
+
+}
+
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_util_OfficeInstallationDirectories(
+ css::uno::XComponentContext *context,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(
+ new comphelper::OfficeInstallationDirectories(context));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/officeinstdir/officeinstallationdirectories.hxx b/comphelper/source/officeinstdir/officeinstallationdirectories.hxx
new file mode 100644
index 000000000..cc0881c23
--- /dev/null
+++ b/comphelper/source/officeinstdir/officeinstallationdirectories.hxx
@@ -0,0 +1,75 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/basemutex.hxx>
+
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/util/XOfficeInstallationDirectories.hpp>
+
+#include <optional>
+
+namespace com::sun::star::uno { class XComponentContext; }
+
+namespace comphelper {
+
+
+
+typedef cppu::WeakImplHelper<
+ css::util::XOfficeInstallationDirectories,
+ css::lang::XServiceInfo > UnoImplBase;
+
+class OfficeInstallationDirectories : public cppu::BaseMutex, public UnoImplBase
+{
+public:
+ explicit OfficeInstallationDirectories(
+ css::uno::Reference< css::uno::XComponentContext > xCtx );
+ virtual ~OfficeInstallationDirectories() override;
+
+ // XOfficeInstallationDirectories
+ virtual OUString SAL_CALL
+ getOfficeInstallationDirectoryURL() override;
+ virtual OUString SAL_CALL
+ getOfficeUserDataDirectoryURL() override;
+ virtual OUString SAL_CALL
+ makeRelocatableURL( const OUString& URL ) override;
+ virtual OUString SAL_CALL
+ makeAbsoluteURL( const OUString& URL ) override;
+
+ // XServiceInfo
+ virtual OUString SAL_CALL
+ getImplementationName() override;
+ virtual sal_Bool SAL_CALL
+ supportsService( const OUString& ServiceName ) override;
+ virtual css::uno::Sequence< OUString > SAL_CALL
+ getSupportedServiceNames() override;
+
+private:
+ void initDirs();
+
+ css::uno::Reference< css::uno::XComponentContext > m_xCtx;
+ std::optional<OUString> m_xOfficeBrandDir;
+ std::optional<OUString> m_xUserDir;
+};
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/processfactory/processfactory.cxx b/comphelper/source/processfactory/processfactory.cxx
new file mode 100644
index 000000000..fc8586471
--- /dev/null
+++ b/comphelper/source/processfactory/processfactory.cxx
@@ -0,0 +1,117 @@
+/* -*- 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 <mutex>
+#include <comphelper/processfactory.hxx>
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/uno/DeploymentException.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+
+namespace com::sun::star::uno { class XComponentContext; }
+
+using namespace ::com::sun::star;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::lang;
+using namespace osl;
+
+namespace comphelper
+{
+
+namespace {
+
+class LocalProcessFactory {
+public:
+ void set( const Reference< XMultiServiceFactory >& xSMgr )
+ {
+ std::unique_lock aGuard( maMutex );
+
+ xProcessFactory = xSMgr;
+ }
+
+ Reference< XMultiServiceFactory > get() const
+ {
+ std::unique_lock aGuard( maMutex );
+
+ return xProcessFactory;
+ }
+
+private:
+ mutable std::mutex maMutex;
+ Reference< XMultiServiceFactory > xProcessFactory;
+};
+
+/*
+ This var preserves only that the above xProcessFactory variable will not be create when
+ the library is loaded.
+*/
+LocalProcessFactory localProcessFactory;
+
+}
+
+void setProcessServiceFactory(const Reference< XMultiServiceFactory >& xSMgr)
+{
+ localProcessFactory.set( xSMgr );
+}
+
+Reference< XMultiServiceFactory > getProcessServiceFactory()
+{
+ Reference< XMultiServiceFactory> xReturn = localProcessFactory.get();
+ if ( !xReturn.is() )
+ {
+ throw DeploymentException( "null process service factory" );
+ }
+ return xReturn;
+}
+
+Reference< XComponentContext > getComponentContext(
+ Reference< XMultiServiceFactory > const & factory)
+{
+ Reference< XComponentContext > xRet;
+ uno::Reference<beans::XPropertySet> const xProps( factory, uno::UNO_QUERY );
+ if (xProps.is()) {
+ static constexpr OUStringLiteral DEFAULT_CONTEXT = u"DefaultContext";
+ try {
+ xRet.set( xProps->getPropertyValue(DEFAULT_CONTEXT),
+ uno::UNO_QUERY );
+ }
+ catch (beans::UnknownPropertyException & e) {
+ throw DeploymentException(
+ "unknown service factory DefaultContext property: " + e.Message,
+ Reference<XInterface>(factory, UNO_QUERY) );
+ }
+ }
+ if ( !xRet.is() )
+ {
+ throw DeploymentException(
+ "no service factory DefaultContext",
+ Reference<XInterface>(factory, UNO_QUERY) );
+ }
+ return xRet;
+}
+
+Reference< XComponentContext > getProcessComponentContext()
+{
+ return getComponentContext( getProcessServiceFactory() );
+}
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/property/ChainablePropertySet.cxx b/comphelper/source/property/ChainablePropertySet.cxx
new file mode 100644
index 000000000..0805afe72
--- /dev/null
+++ b/comphelper/source/property/ChainablePropertySet.cxx
@@ -0,0 +1,239 @@
+/* -*- 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 <comphelper/ChainablePropertySet.hxx>
+#include <comphelper/ChainablePropertySetInfo.hxx>
+#include <comphelper/solarmutex.hxx>
+
+
+#include <memory>
+#include <optional>
+
+using namespace ::comphelper;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::beans;
+
+ChainablePropertySet::ChainablePropertySet( comphelper::ChainablePropertySetInfo* pInfo, comphelper::SolarMutex* pMutex )
+ noexcept
+: mpMutex ( pMutex )
+, mxInfo ( pInfo )
+{
+}
+
+ChainablePropertySet::~ChainablePropertySet()
+ noexcept
+{
+}
+
+// XPropertySet
+Reference< XPropertySetInfo > SAL_CALL ChainablePropertySet::getPropertySetInfo( )
+{
+ return mxInfo;
+}
+
+void SAL_CALL ChainablePropertySet::setPropertyValue( const OUString& rPropertyName, const Any& rValue )
+{
+ // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
+ std::optional< osl::Guard< comphelper::SolarMutex > > xMutexGuard;
+ if (mpMutex)
+ xMutexGuard.emplace( mpMutex );
+
+ PropertyInfoHash::const_iterator aIter = mxInfo->maMap.find ( rPropertyName );
+
+ if( aIter == mxInfo->maMap.end())
+ throw UnknownPropertyException( rPropertyName, static_cast< XPropertySet* >( this ) );
+
+ _preSetValues();
+ _setSingleValue( *((*aIter).second), rValue );
+ _postSetValues();
+}
+
+Any SAL_CALL ChainablePropertySet::getPropertyValue( const OUString& rPropertyName )
+{
+ // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
+ std::optional< osl::Guard< comphelper::SolarMutex > > xMutexGuard;
+ if (mpMutex)
+ xMutexGuard.emplace( mpMutex );
+
+ PropertyInfoHash::const_iterator aIter = mxInfo->maMap.find ( rPropertyName );
+
+ if( aIter == mxInfo->maMap.end())
+ throw UnknownPropertyException( rPropertyName, static_cast< XPropertySet* >( this ) );
+
+ Any aAny;
+ _preGetValues ();
+ _getSingleValue( *((*aIter).second), aAny );
+ _postGetValues ();
+
+ return aAny;
+}
+
+void SAL_CALL ChainablePropertySet::addPropertyChangeListener( const OUString&, const Reference< XPropertyChangeListener >& )
+{
+ // todo
+}
+
+void SAL_CALL ChainablePropertySet::removePropertyChangeListener( const OUString&, const Reference< XPropertyChangeListener >& )
+{
+ // todo
+}
+
+void SAL_CALL ChainablePropertySet::addVetoableChangeListener( const OUString&, const Reference< XVetoableChangeListener >& )
+{
+ // todo
+}
+
+void SAL_CALL ChainablePropertySet::removeVetoableChangeListener( const OUString&, const Reference< XVetoableChangeListener >& )
+{
+ // todo
+}
+
+// XMultiPropertySet
+void SAL_CALL ChainablePropertySet::setPropertyValues(const Sequence< OUString >& rPropertyNames, const Sequence< Any >& rValues)
+{
+ // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
+ std::optional< osl::Guard< comphelper::SolarMutex > > xMutexGuard;
+ if (mpMutex)
+ xMutexGuard.emplace( mpMutex );
+
+ const sal_Int32 nCount = rPropertyNames.getLength();
+
+ if( nCount != rValues.getLength() )
+ throw IllegalArgumentException("lengths do not match", static_cast<cppu::OWeakObject*>(this), -1);
+
+ if( !nCount )
+ return;
+
+ _preSetValues();
+
+ const Any * pAny = rValues.getConstArray();
+ const OUString * pString = rPropertyNames.getConstArray();
+ PropertyInfoHash::const_iterator aEnd = mxInfo->maMap.end(), aIter;
+
+ for ( sal_Int32 i = 0; i < nCount; ++i, ++pString, ++pAny )
+ {
+ aIter = mxInfo->maMap.find ( *pString );
+ if ( aIter == aEnd )
+ throw RuntimeException( *pString, static_cast< XPropertySet* >( this ) );
+
+ _setSingleValue ( *((*aIter).second), *pAny );
+ }
+
+ _postSetValues();
+}
+
+Sequence< Any > SAL_CALL ChainablePropertySet::getPropertyValues(const Sequence< OUString >& rPropertyNames)
+{
+ // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
+ std::optional< osl::Guard< comphelper::SolarMutex > > xMutexGuard;
+ if (mpMutex)
+ xMutexGuard.emplace( mpMutex );
+
+ const sal_Int32 nCount = rPropertyNames.getLength();
+
+ Sequence < Any > aValues ( nCount );
+
+ if( nCount )
+ {
+ _preGetValues();
+
+ Any * pAny = aValues.getArray();
+ const OUString * pString = rPropertyNames.getConstArray();
+ PropertyInfoHash::const_iterator aEnd = mxInfo->maMap.end(), aIter;
+
+ for ( sal_Int32 i = 0; i < nCount; ++i, ++pString, ++pAny )
+ {
+ aIter = mxInfo->maMap.find ( *pString );
+ if ( aIter == aEnd )
+ throw RuntimeException( *pString, static_cast< XPropertySet* >( this ) );
+
+ _getSingleValue ( *((*aIter).second), *pAny );
+ }
+
+ _postGetValues();
+ }
+ return aValues;
+}
+
+void SAL_CALL ChainablePropertySet::addPropertiesChangeListener( const Sequence< OUString >&, const Reference< XPropertiesChangeListener >& )
+{
+ // todo
+}
+
+void SAL_CALL ChainablePropertySet::removePropertiesChangeListener( const Reference< XPropertiesChangeListener >& )
+{
+ // todo
+}
+
+void SAL_CALL ChainablePropertySet::firePropertiesChangeEvent( const Sequence< OUString >&, const Reference< XPropertiesChangeListener >& )
+{
+ // todo
+}
+
+// XPropertyState
+PropertyState SAL_CALL ChainablePropertySet::getPropertyState( const OUString& PropertyName )
+{
+ PropertyInfoHash::const_iterator aIter = mxInfo->maMap.find( PropertyName );
+ if( aIter == mxInfo->maMap.end())
+ throw UnknownPropertyException( PropertyName, static_cast< XPropertySet* >( this ) );
+
+ return PropertyState_AMBIGUOUS_VALUE;
+}
+
+Sequence< PropertyState > SAL_CALL ChainablePropertySet::getPropertyStates( const Sequence< OUString >& rPropertyNames )
+{
+ const sal_Int32 nCount = rPropertyNames.getLength();
+
+ Sequence< PropertyState > aStates( nCount );
+ if( nCount )
+ {
+ PropertyState * pState = aStates.getArray();
+ const OUString * pString = rPropertyNames.getConstArray();
+ PropertyInfoHash::const_iterator aEnd = mxInfo->maMap.end(), aIter;
+
+ for ( sal_Int32 i = 0; i < nCount; ++i, ++pString, ++pState )
+ {
+ aIter = mxInfo->maMap.find ( *pString );
+ if ( aIter == aEnd )
+ throw UnknownPropertyException( *pString, static_cast< XPropertySet* >( this ) );
+ }
+ }
+ return aStates;
+}
+
+void SAL_CALL ChainablePropertySet::setPropertyToDefault( const OUString& rPropertyName )
+{
+ PropertyInfoHash::const_iterator aIter = mxInfo->maMap.find ( rPropertyName );
+
+ if( aIter == mxInfo->maMap.end())
+ throw UnknownPropertyException( rPropertyName, static_cast< XPropertySet* >( this ) );
+}
+
+Any SAL_CALL ChainablePropertySet::getPropertyDefault( const OUString& rPropertyName )
+{
+ PropertyInfoHash::const_iterator aIter = mxInfo->maMap.find ( rPropertyName );
+
+ if( aIter == mxInfo->maMap.end())
+ throw UnknownPropertyException( rPropertyName, static_cast< XPropertySet* >( this ) );
+ return Any();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/property/ChainablePropertySetInfo.cxx b/comphelper/source/property/ChainablePropertySetInfo.cxx
new file mode 100644
index 000000000..10b4d5fda
--- /dev/null
+++ b/comphelper/source/property/ChainablePropertySetInfo.cxx
@@ -0,0 +1,95 @@
+/* -*- 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 <comphelper/ChainablePropertySetInfo.hxx>
+#include <sal/log.hxx>
+
+using ::comphelper::PropertyInfo;
+using ::comphelper::ChainablePropertySetInfo;
+using ::com::sun::star::uno::Sequence;
+using ::com::sun::star::beans::Property;
+using ::com::sun::star::beans::UnknownPropertyException;
+
+ChainablePropertySetInfo::ChainablePropertySetInfo( PropertyInfo const * pMap )
+{
+ for( ; !pMap->maName.isEmpty(); ++pMap )
+ {
+ SAL_WARN_IF(
+ maMap.find(pMap->maName) != maMap.end(),
+ "comphelper", "Duplicate property name \"" << pMap->maName << "\"");
+ maMap[pMap->maName] = pMap;
+ }
+}
+
+ChainablePropertySetInfo::~ChainablePropertySetInfo()
+ noexcept
+{
+}
+
+void ChainablePropertySetInfo::remove( const OUString& aName )
+{
+ maMap.erase ( aName );
+ if ( maProperties.hasElements() )
+ maProperties.realloc( 0 );
+}
+
+Sequence< ::Property > SAL_CALL ChainablePropertySetInfo::getProperties()
+{
+ sal_Int32 nSize = maMap.size();
+ if( maProperties.getLength() != nSize )
+ {
+ maProperties.realloc ( nSize );
+ Property* pProperties = maProperties.getArray();
+
+ for (auto const& elem : maMap)
+ {
+ PropertyInfo const * pInfo = elem.second;
+
+ pProperties->Name = pInfo->maName;
+ pProperties->Handle = pInfo->mnHandle;
+ pProperties->Type = pInfo->maType;
+ pProperties->Attributes = pInfo->mnAttributes;
+ ++pProperties;
+ }
+ }
+ return maProperties;
+}
+
+Property SAL_CALL ChainablePropertySetInfo::getPropertyByName( const OUString& rName )
+{
+ PropertyInfoHash::iterator aIter = maMap.find( rName );
+
+ if ( maMap.end() == aIter )
+ throw UnknownPropertyException( rName, *this );
+
+ PropertyInfo const *pInfo = (*aIter).second;
+ Property aProperty;
+ aProperty.Name = pInfo->maName;
+ aProperty.Handle = pInfo->mnHandle;
+ aProperty.Type = pInfo->maType;
+ aProperty.Attributes = pInfo->mnAttributes;
+ return aProperty;
+}
+
+sal_Bool SAL_CALL ChainablePropertySetInfo::hasPropertyByName( const OUString& rName )
+{
+ return maMap.find ( rName ) != maMap.end();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/property/MasterPropertySet.cxx b/comphelper/source/property/MasterPropertySet.cxx
new file mode 100644
index 000000000..922a4c1c6
--- /dev/null
+++ b/comphelper/source/property/MasterPropertySet.cxx
@@ -0,0 +1,398 @@
+/* -*- 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 <comphelper/MasterPropertySet.hxx>
+#include <comphelper/MasterPropertySetInfo.hxx>
+#include <comphelper/ChainablePropertySet.hxx>
+#include <comphelper/ChainablePropertySetInfo.hxx>
+#include <comphelper/solarmutex.hxx>
+
+
+#include <memory>
+#include <vector>
+#include <optional>
+
+namespace {
+
+class AutoOGuardArray
+{
+ std::vector<std::optional< osl::Guard< comphelper::SolarMutex > >> maGuardArray;
+
+public:
+ explicit AutoOGuardArray( sal_Int32 nNumElements );
+
+ std::optional< osl::Guard< comphelper::SolarMutex > > & operator[] ( sal_Int32 i ) { return maGuardArray[i]; }
+};
+
+}
+
+AutoOGuardArray::AutoOGuardArray( sal_Int32 nNumElements ) : maGuardArray(nNumElements)
+{
+}
+
+
+using namespace ::comphelper;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::beans;
+
+
+SlaveData::SlaveData ( ChainablePropertySet *pSlave)
+: mxSlave ( pSlave )
+, mbInit ( false )
+{
+}
+
+MasterPropertySet::MasterPropertySet( comphelper::MasterPropertySetInfo* pInfo, comphelper::SolarMutex* pMutex )
+ noexcept
+: mpMutex ( pMutex )
+, mnLastId ( 0 )
+, mxInfo ( pInfo )
+{
+}
+
+MasterPropertySet::~MasterPropertySet()
+ noexcept
+{
+ for( const auto& rSlave : maSlaveMap )
+ delete rSlave.second;
+}
+
+// XPropertySet
+Reference< XPropertySetInfo > SAL_CALL MasterPropertySet::getPropertySetInfo( )
+{
+ return mxInfo;
+}
+
+void MasterPropertySet::registerSlave ( ChainablePropertySet *pNewSet )
+ noexcept
+{
+ maSlaveMap [ ++mnLastId ] = new SlaveData ( pNewSet );
+ mxInfo->add ( pNewSet->mxInfo->maMap, mnLastId );
+}
+
+void SAL_CALL MasterPropertySet::setPropertyValue( const OUString& rPropertyName, const Any& rValue )
+{
+ // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
+ std::optional< osl::Guard< comphelper::SolarMutex > > xMutexGuard;
+ if (mpMutex)
+ xMutexGuard.emplace( mpMutex );
+
+ PropertyDataHash::const_iterator aIter = mxInfo->maMap.find ( rPropertyName );
+
+ if( aIter == mxInfo->maMap.end())
+ throw UnknownPropertyException( rPropertyName, static_cast< XPropertySet* >( this ) );
+
+ if ( (*aIter).second->mnMapId == 0 ) // 0 means it's one of ours !
+ {
+ _preSetValues();
+ _setSingleValue( *((*aIter).second->mpInfo), rValue );
+ _postSetValues();
+ }
+ else
+ {
+ ChainablePropertySet * pSlave = maSlaveMap [ (*aIter).second->mnMapId ]->mxSlave.get();
+
+ // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
+ std::optional< osl::Guard< comphelper::SolarMutex > > xMutexGuard2;
+ if (pSlave->mpMutex)
+ xMutexGuard2.emplace( pSlave->mpMutex );
+
+ pSlave->_preSetValues();
+ pSlave->_setSingleValue( *((*aIter).second->mpInfo), rValue );
+ pSlave->_postSetValues();
+ }
+}
+
+Any SAL_CALL MasterPropertySet::getPropertyValue( const OUString& rPropertyName )
+{
+ // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
+ std::optional< osl::Guard< comphelper::SolarMutex > > xMutexGuard;
+ if (mpMutex)
+ xMutexGuard.emplace( mpMutex );
+
+ PropertyDataHash::const_iterator aIter = mxInfo->maMap.find ( rPropertyName );
+
+ if( aIter == mxInfo->maMap.end())
+ throw UnknownPropertyException( rPropertyName, static_cast< XPropertySet* >( this ) );
+
+ Any aAny;
+ if ( (*aIter).second->mnMapId == 0 ) // 0 means it's one of ours !
+ {
+ _preGetValues();
+ _getSingleValue( *((*aIter).second->mpInfo), aAny );
+ _postGetValues();
+ }
+ else
+ {
+ ChainablePropertySet * pSlave = maSlaveMap [ (*aIter).second->mnMapId ]->mxSlave.get();
+
+ // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
+ std::optional< osl::Guard< comphelper::SolarMutex > > xMutexGuard2;
+ if (pSlave->mpMutex)
+ xMutexGuard2.emplace( pSlave->mpMutex );
+
+ pSlave->_preGetValues();
+ pSlave->_getSingleValue( *((*aIter).second->mpInfo), aAny );
+ pSlave->_postGetValues();
+ }
+ return aAny;
+}
+
+void SAL_CALL MasterPropertySet::addPropertyChangeListener( const OUString&, const Reference< XPropertyChangeListener >& )
+{
+ // todo
+}
+
+void SAL_CALL MasterPropertySet::removePropertyChangeListener( const OUString&, const Reference< XPropertyChangeListener >& )
+{
+ // todo
+}
+
+void SAL_CALL MasterPropertySet::addVetoableChangeListener( const OUString&, const Reference< XVetoableChangeListener >& )
+{
+ // todo
+}
+
+void SAL_CALL MasterPropertySet::removeVetoableChangeListener( const OUString&, const Reference< XVetoableChangeListener >& )
+{
+ // todo
+}
+
+// XMultiPropertySet
+void SAL_CALL MasterPropertySet::setPropertyValues( const Sequence< OUString >& aPropertyNames, const Sequence< Any >& aValues )
+{
+ // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
+ std::optional< osl::Guard< comphelper::SolarMutex > > xMutexGuard;
+ if (mpMutex)
+ xMutexGuard.emplace( mpMutex );
+
+ const sal_Int32 nCount = aPropertyNames.getLength();
+
+ if( nCount != aValues.getLength() )
+ throw IllegalArgumentException();
+
+ if( !nCount )
+ return;
+
+ _preSetValues();
+
+ const Any * pAny = aValues.getConstArray();
+ const OUString * pString = aPropertyNames.getConstArray();
+ PropertyDataHash::const_iterator aEnd = mxInfo->maMap.end(), aIter;
+
+ //!! have a unique_ptr to an array of OGuards in order to have the
+ //!! allocated memory properly freed (exception safe!).
+ //!! Since the array itself has unique_ptrs as members we have to use a
+ //!! helper class 'AutoOGuardArray' in order to have
+ //!! the acquired locks properly released.
+ AutoOGuardArray aOGuardArray( nCount );
+
+ for ( sal_Int32 i = 0; i < nCount; ++i, ++pString, ++pAny )
+ {
+ aIter = mxInfo->maMap.find ( *pString );
+ if ( aIter == aEnd )
+ throw RuntimeException( *pString, static_cast< XPropertySet* >( this ) );
+
+ if ( (*aIter).second->mnMapId == 0 ) // 0 means it's one of ours !
+ _setSingleValue( *((*aIter).second->mpInfo), *pAny );
+ else
+ {
+ SlaveData * pSlave = maSlaveMap [ (*aIter).second->mnMapId ];
+ if (!pSlave->IsInit())
+ {
+ // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
+ if (pSlave->mxSlave->mpMutex)
+ aOGuardArray[i].emplace( pSlave->mxSlave->mpMutex );
+
+ pSlave->mxSlave->_preSetValues();
+ pSlave->SetInit ( true );
+ }
+ pSlave->mxSlave->_setSingleValue( *((*aIter).second->mpInfo), *pAny );
+ }
+ }
+
+ _postSetValues();
+ for( const auto& rSlave : maSlaveMap )
+ {
+ if( rSlave.second->IsInit() )
+ {
+ rSlave.second->mxSlave->_postSetValues();
+ rSlave.second->SetInit( false );
+ }
+ }
+}
+
+Sequence< Any > SAL_CALL MasterPropertySet::getPropertyValues( const Sequence< OUString >& aPropertyNames )
+{
+ // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
+ std::optional< osl::Guard< comphelper::SolarMutex > > xMutexGuard;
+ if (mpMutex)
+ xMutexGuard.emplace( mpMutex );
+
+ const sal_Int32 nCount = aPropertyNames.getLength();
+
+ Sequence < Any > aValues ( nCount );
+
+ if( nCount )
+ {
+ _preGetValues();
+
+ Any * pAny = aValues.getArray();
+ const OUString * pString = aPropertyNames.getConstArray();
+ PropertyDataHash::const_iterator aEnd = mxInfo->maMap.end(), aIter;
+
+ //!! have a unique_ptr to an array of OGuards in order to have the
+ //!! allocated memory properly freed (exception safe!).
+ //!! Since the array itself has unique_ptrs as members we have to use a
+ //!! helper class 'AutoOGuardArray' in order to have
+ //!! the acquired locks properly released.
+ AutoOGuardArray aOGuardArray( nCount );
+
+ for ( sal_Int32 i = 0; i < nCount; ++i, ++pString, ++pAny )
+ {
+ aIter = mxInfo->maMap.find ( *pString );
+ if ( aIter == aEnd )
+ throw RuntimeException( *pString, static_cast< XPropertySet* >( this ) );
+
+ if ( (*aIter).second->mnMapId == 0 ) // 0 means it's one of ours !
+ _getSingleValue( *((*aIter).second->mpInfo), *pAny );
+ else
+ {
+ SlaveData * pSlave = maSlaveMap [ (*aIter).second->mnMapId ];
+ if (!pSlave->IsInit())
+ {
+ // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
+ if (pSlave->mxSlave->mpMutex)
+ aOGuardArray[i].emplace( pSlave->mxSlave->mpMutex );
+
+ pSlave->mxSlave->_preGetValues();
+ pSlave->SetInit ( true );
+ }
+ pSlave->mxSlave->_getSingleValue( *((*aIter).second->mpInfo), *pAny );
+ }
+ }
+
+ _postSetValues();
+ for( const auto& rSlave : maSlaveMap )
+ {
+ if( rSlave.second->IsInit() )
+ {
+ rSlave.second->mxSlave->_postSetValues();
+ rSlave.second->SetInit( false );
+ }
+ }
+ }
+ return aValues;
+}
+
+void SAL_CALL MasterPropertySet::addPropertiesChangeListener( const Sequence< OUString >&, const Reference< XPropertiesChangeListener >& )
+{
+ // todo
+}
+
+void SAL_CALL MasterPropertySet::removePropertiesChangeListener( const Reference< XPropertiesChangeListener >& )
+{
+ // todo
+}
+
+void SAL_CALL MasterPropertySet::firePropertiesChangeEvent( const Sequence< OUString >&, const Reference< XPropertiesChangeListener >& )
+{
+ // todo
+}
+
+// XPropertyState
+PropertyState SAL_CALL MasterPropertySet::getPropertyState( const OUString& PropertyName )
+{
+ PropertyDataHash::const_iterator aIter = mxInfo->maMap.find( PropertyName );
+ if( aIter == mxInfo->maMap.end())
+ throw UnknownPropertyException( PropertyName, static_cast< XPropertySet* >( this ) );
+
+ // 0 means it's one of ours !
+ if ( (*aIter).second->mnMapId != 0 )
+ {
+ ChainablePropertySet * pSlave = maSlaveMap [ (*aIter).second->mnMapId ]->mxSlave.get();
+
+ // acquire mutex in c-tor and releases it in the d-tor (exception safe!).
+ std::optional< osl::Guard< comphelper::SolarMutex > > xMutexGuard;
+ if (pSlave->mpMutex)
+ xMutexGuard.emplace( pSlave->mpMutex );
+ }
+
+ return PropertyState_AMBIGUOUS_VALUE;
+}
+
+Sequence< PropertyState > SAL_CALL MasterPropertySet::getPropertyStates( const Sequence< OUString >& rPropertyNames )
+{
+ const sal_Int32 nCount = rPropertyNames.getLength();
+
+ Sequence< PropertyState > aStates( nCount );
+ if( nCount )
+ {
+ PropertyState * pState = aStates.getArray();
+ const OUString * pString = rPropertyNames.getConstArray();
+ PropertyDataHash::const_iterator aEnd = mxInfo->maMap.end(), aIter;
+
+ for ( sal_Int32 i = 0; i < nCount; ++i, ++pString, ++pState )
+ {
+ aIter = mxInfo->maMap.find ( *pString );
+ if ( aIter == aEnd )
+ throw UnknownPropertyException( *pString, static_cast< XPropertySet* >( this ) );
+
+ // 0 means it's one of ours !
+ if ( (*aIter).second->mnMapId != 0 )
+ {
+ SlaveData * pSlave = maSlaveMap [ (*aIter).second->mnMapId ];
+ if (!pSlave->IsInit())
+ {
+ pSlave->SetInit ( true );
+ }
+ }
+ }
+ for( const auto& rSlave : maSlaveMap )
+ {
+ if( rSlave.second->IsInit() )
+ {
+ rSlave.second->SetInit( false );
+ }
+ }
+ }
+ return aStates;
+}
+
+void SAL_CALL MasterPropertySet::setPropertyToDefault( const OUString& rPropertyName )
+{
+ PropertyDataHash::const_iterator aIter = mxInfo->maMap.find ( rPropertyName );
+
+ if( aIter == mxInfo->maMap.end())
+ throw UnknownPropertyException( rPropertyName, static_cast< XPropertySet* >( this ) );
+}
+
+Any SAL_CALL MasterPropertySet::getPropertyDefault( const OUString& rPropertyName )
+{
+ PropertyDataHash::const_iterator aIter = mxInfo->maMap.find ( rPropertyName );
+
+ if( aIter == mxInfo->maMap.end())
+ throw UnknownPropertyException( rPropertyName, static_cast< XPropertySet* >( this ) );
+ return Any();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/property/MasterPropertySetInfo.cxx b/comphelper/source/property/MasterPropertySetInfo.cxx
new file mode 100644
index 000000000..db8ddb769
--- /dev/null
+++ b/comphelper/source/property/MasterPropertySetInfo.cxx
@@ -0,0 +1,105 @@
+/* -*- 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 <comphelper/MasterPropertySetInfo.hxx>
+#include <sal/log.hxx>
+
+using ::comphelper::PropertyInfo;
+using ::comphelper::MasterPropertySetInfo;
+using ::com::sun::star::uno::Sequence;
+using ::com::sun::star::beans::Property;
+using ::com::sun::star::beans::UnknownPropertyException;
+
+MasterPropertySetInfo::MasterPropertySetInfo( PropertyInfo const * pMap )
+{
+ for ( ; !pMap->maName.isEmpty(); ++pMap )
+ {
+ SAL_WARN_IF(
+ maMap.find(pMap->maName) != maMap.end(),
+ "comphelper", "Duplicate property name \"" << pMap->maName << "\"");
+ maMap[pMap->maName] = new PropertyData ( 0, pMap );
+ }
+}
+
+MasterPropertySetInfo::~MasterPropertySetInfo()
+ noexcept
+{
+ for( const auto& rObj : maMap )
+ delete rObj.second;
+}
+
+void MasterPropertySetInfo::add( PropertyInfoHash &rHash, sal_uInt8 nMapId )
+{
+ if( maProperties.hasElements() )
+ maProperties.realloc( 0 );
+
+ for( const auto& rObj : rHash )
+ {
+ SAL_WARN_IF(
+ maMap.find(rObj.first) != maMap.end(),
+ "comphelper", "Duplicate property name \"" << rObj.first << "\"");
+ maMap[rObj.first] = new PropertyData ( nMapId, rObj.second );
+ }
+}
+
+Sequence< ::Property > SAL_CALL MasterPropertySetInfo::getProperties()
+{
+ sal_Int32 nSize = maMap.size();
+ if( maProperties.getLength() != nSize )
+ {
+ maProperties.realloc ( nSize );
+ Property* pProperties = maProperties.getArray();
+
+ for (auto const& elem : maMap)
+ {
+ PropertyInfo const * pInfo = elem.second->mpInfo;
+
+ pProperties->Name = pInfo->maName;
+ pProperties->Handle = pInfo->mnHandle;
+ pProperties->Type = pInfo->maType;
+ pProperties->Attributes = pInfo->mnAttributes;
+ ++pProperties;
+ }
+ }
+ return maProperties;
+}
+
+Property SAL_CALL MasterPropertySetInfo::getPropertyByName( const OUString& rName )
+{
+ PropertyDataHash::iterator aIter = maMap.find( rName );
+
+ if ( maMap.end() == aIter )
+ throw UnknownPropertyException( rName, *this );
+
+ PropertyInfo const *pInfo = (*aIter).second->mpInfo;
+ Property aProperty;
+ aProperty.Name = pInfo->maName;
+ aProperty.Handle = pInfo->mnHandle;
+ aProperty.Type = pInfo->maType;
+
+ aProperty.Attributes = pInfo->mnAttributes;
+ return aProperty;
+}
+
+sal_Bool SAL_CALL MasterPropertySetInfo::hasPropertyByName( const OUString& rName )
+{
+ return maMap.find ( rName ) != maMap.end();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/property/genericpropertyset.cxx b/comphelper/source/property/genericpropertyset.cxx
new file mode 100644
index 000000000..b459de64c
--- /dev/null
+++ b/comphelper/source/property/genericpropertyset.cxx
@@ -0,0 +1,247 @@
+/* -*- 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 <sal/config.h>
+
+#include <map>
+
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/lang/XTypeProvider.hpp>
+#include <cppuhelper/weakagg.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <comphelper/multiinterfacecontainer4.hxx>
+#include <comphelper/propertysethelper.hxx>
+#include <mutex>
+#include <rtl/ref.hxx>
+#include <comphelper/genericpropertyset.hxx>
+#include <comphelper/propertysetinfo.hxx>
+
+using namespace ::osl;
+using namespace ::cppu;
+using namespace ::comphelper;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::lang;
+
+namespace comphelper
+{
+ namespace {
+
+ class GenericPropertySet : public OWeakAggObject,
+ public XServiceInfo,
+ public XTypeProvider,
+ public PropertySetHelper
+ {
+ private:
+ std::map<OUString, Any> maAnyMap;
+ std::mutex maMutex;
+ comphelper::OMultiTypeInterfaceContainerHelperVar4<OUString, XPropertyChangeListener> m_aListener;
+
+ protected:
+ virtual void _setPropertyValues( const PropertyMapEntry** ppEntries, const Any* pValues ) override;
+ virtual void _getPropertyValues( const PropertyMapEntry** ppEntries, Any* pValue ) override;
+
+ public:
+ explicit GenericPropertySet( PropertySetInfo* pInfo ) noexcept;
+
+ // XInterface
+ virtual Any SAL_CALL queryAggregation( const Type & rType ) override;
+ virtual Any SAL_CALL queryInterface( const Type & rType ) override;
+ virtual void SAL_CALL acquire() noexcept override;
+ virtual void SAL_CALL release() noexcept override;
+
+ // XTypeProvider
+ virtual Sequence< Type > SAL_CALL getTypes( ) override;
+ virtual Sequence< sal_Int8 > SAL_CALL getImplementationId( ) override;
+
+ // XServiceInfo
+ virtual OUString SAL_CALL getImplementationName() override;
+ virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+ virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
+
+ // XPropertySet
+ virtual void SAL_CALL addPropertyChangeListener( const OUString& aPropertyName, const css::uno::Reference< css::beans::XPropertyChangeListener >& xListener ) override;
+ virtual void SAL_CALL removePropertyChangeListener( const OUString& aPropertyName, const css::uno::Reference< css::beans::XPropertyChangeListener >& aListener ) override;
+ };
+
+ }
+}
+
+
+GenericPropertySet::GenericPropertySet( PropertySetInfo* pInfo ) noexcept
+: PropertySetHelper( pInfo )
+{
+}
+
+void SAL_CALL GenericPropertySet::addPropertyChangeListener( const OUString& aPropertyName, const Reference< XPropertyChangeListener >& xListener )
+{
+ Reference < XPropertySetInfo > xInfo = getPropertySetInfo( );
+ if ( !xInfo.is() )
+ return;
+
+ std::unique_lock aGuard(maMutex);
+ if ( aPropertyName.isEmpty() )
+ {
+ Sequence< Property> aSeq = xInfo->getProperties();
+ const Property* pIter = aSeq.getConstArray();
+ const Property* pEnd = pIter + aSeq.getLength();
+ for( ; pIter != pEnd ; ++pIter)
+ {
+ m_aListener.addInterface(aGuard, pIter->Name,xListener);
+ }
+ }
+ else if ( xInfo->hasPropertyByName(aPropertyName) )
+ m_aListener.addInterface(aGuard, aPropertyName,xListener);
+ else
+ throw UnknownPropertyException( aPropertyName, *this );
+}
+
+void SAL_CALL GenericPropertySet::removePropertyChangeListener( const OUString& aPropertyName, const Reference< XPropertyChangeListener >& xListener )
+{
+ Reference < XPropertySetInfo > xInfo = getPropertySetInfo( );
+ if ( !xInfo.is() )
+ return;
+
+ std::unique_lock aGuard(maMutex);
+ if ( aPropertyName.isEmpty() )
+ {
+ Sequence< Property> aSeq = xInfo->getProperties();
+ const Property* pIter = aSeq.getConstArray();
+ const Property* pEnd = pIter + aSeq.getLength();
+ for( ; pIter != pEnd ; ++pIter)
+ {
+ m_aListener.removeInterface(aGuard, pIter->Name,xListener);
+ }
+ }
+ else if ( xInfo->hasPropertyByName(aPropertyName) )
+ m_aListener.removeInterface(aGuard, aPropertyName,xListener);
+ else
+ throw UnknownPropertyException( aPropertyName, *this );
+}
+
+void GenericPropertySet::_setPropertyValues( const PropertyMapEntry** ppEntries, const Any* pValues )
+{
+ std::unique_lock aGuard(maMutex);
+
+ while( *ppEntries )
+ {
+ OInterfaceContainerHelper4<XPropertyChangeListener> * pHelper = m_aListener.getContainer((*ppEntries)->maName);
+
+ maAnyMap[ (*ppEntries)->maName ] = *pValues;
+
+ if ( pHelper )
+ {
+ PropertyChangeEvent aEvt;
+ aEvt.PropertyName = (*ppEntries)->maName;
+ aEvt.NewValue = *pValues;
+ pHelper->notifyEach( aGuard, &XPropertyChangeListener::propertyChange, aEvt );
+ aGuard.lock();
+ }
+
+ ppEntries++;
+ pValues++;
+ }
+}
+
+void GenericPropertySet::_getPropertyValues( const comphelper::PropertyMapEntry** ppEntries, Any* pValue )
+{
+ std::unique_lock aGuard(maMutex);
+
+ while( *ppEntries )
+ {
+ *pValue = maAnyMap[ (*ppEntries)->maName ];
+
+ ppEntries++;
+ pValue++;
+ }
+}
+
+// XInterface
+
+Any SAL_CALL GenericPropertySet::queryInterface( const Type & rType )
+{
+ return OWeakAggObject::queryInterface( rType );
+}
+
+Any SAL_CALL GenericPropertySet::queryAggregation( const Type & rType )
+{
+ Any aAny;
+
+ if( rType == cppu::UnoType<XServiceInfo>::get())
+ aAny <<= Reference< XServiceInfo >(this);
+ else if( rType == cppu::UnoType<XTypeProvider>::get())
+ aAny <<= Reference< XTypeProvider >(this);
+ else if( rType == cppu::UnoType<XPropertySet>::get())
+ aAny <<= Reference< XPropertySet >(this);
+ else if( rType == cppu::UnoType<XMultiPropertySet>::get())
+ aAny <<= Reference< XMultiPropertySet >(this);
+ else
+ aAny = OWeakAggObject::queryAggregation( rType );
+
+ return aAny;
+}
+
+void SAL_CALL GenericPropertySet::acquire() noexcept
+{
+ OWeakAggObject::acquire();
+}
+
+void SAL_CALL GenericPropertySet::release() noexcept
+{
+ OWeakAggObject::release();
+}
+
+uno::Sequence< uno::Type > SAL_CALL GenericPropertySet::getTypes()
+{
+ return uno::Sequence {
+ cppu::UnoType<XAggregation>::get(),
+ cppu::UnoType<XServiceInfo>::get(),
+ cppu::UnoType<XTypeProvider>::get(),
+ cppu::UnoType<XPropertySet>::get(),
+ cppu::UnoType<XMultiPropertySet>::get() };
+}
+
+uno::Sequence< sal_Int8 > SAL_CALL GenericPropertySet::getImplementationId()
+{
+ return css::uno::Sequence<sal_Int8>();
+}
+
+// XServiceInfo
+sal_Bool SAL_CALL GenericPropertySet::supportsService( const OUString& ServiceName )
+{
+ return cppu::supportsService(this, ServiceName);
+}
+
+OUString SAL_CALL GenericPropertySet::getImplementationName()
+{
+ return "com.sun.star.comp.comphelper.GenericPropertySet";
+}
+
+Sequence< OUString > SAL_CALL GenericPropertySet::getSupportedServiceNames( )
+{
+ return { "com.sun.star.beans.XPropertySet" };
+}
+
+css::uno::Reference< css::beans::XPropertySet > comphelper::GenericPropertySet_CreateInstance( comphelper::PropertySetInfo* pInfo )
+{
+ return static_cast<XPropertySet*>(new GenericPropertySet( pInfo ));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/property/opropertybag.cxx b/comphelper/source/property/opropertybag.cxx
new file mode 100644
index 000000000..e0b389c19
--- /dev/null
+++ b/comphelper/source/property/opropertybag.cxx
@@ -0,0 +1,540 @@
+/* -*- 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 "opropertybag.hxx"
+
+#include <com/sun/star/beans/IllegalTypeException.hpp>
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <com/sun/star/beans/Property.hpp>
+
+#include <comphelper/namedvaluecollection.hxx>
+#include <cppuhelper/supportsservice.hxx>
+
+#include <cppuhelper/exc_hlp.hxx>
+
+#include <algorithm>
+
+namespace com::sun::star::uno { class XComponentContext; }
+
+using namespace ::com::sun::star;
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_comphelper_OPropertyBag (
+ css::uno::XComponentContext *,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new comphelper::OPropertyBag());
+}
+
+namespace comphelper
+{
+
+
+ using namespace ::com::sun::star::uno;
+ using namespace ::com::sun::star::lang;
+ using namespace ::com::sun::star::beans;
+ using namespace ::com::sun::star::util;
+ using namespace ::com::sun::star::container;
+
+ OPropertyBag::OPropertyBag()
+ :OPropertyBag_PBase( GetBroadcastHelper(), this )
+ ,::cppu::IEventNotificationHook()
+ ,m_bAutoAddProperties( false )
+ ,m_NotifyListeners(m_aMutex)
+ ,m_isModified(false)
+
+ {
+ }
+
+
+ OPropertyBag::~OPropertyBag()
+ {
+ }
+
+
+ IMPLEMENT_FORWARD_XINTERFACE2( OPropertyBag, OPropertyBag_Base, OPropertyBag_PBase )
+ IMPLEMENT_FORWARD_XTYPEPROVIDER2( OPropertyBag, OPropertyBag_Base, OPropertyBag_PBase )
+
+ void SAL_CALL OPropertyBag::initialize( const Sequence< Any >& _rArguments )
+ {
+ Sequence< Type > aTypes;
+ bool AllowEmptyPropertyName(false);
+ bool AutomaticAddition(false);
+
+ if (_rArguments.getLength() == 3
+ && (_rArguments[0] >>= aTypes)
+ && (_rArguments[1] >>= AllowEmptyPropertyName)
+ && (_rArguments[2] >>= AutomaticAddition))
+ {
+ m_aAllowedTypes.insert(std::cbegin(aTypes), std::cend(aTypes));
+ m_bAutoAddProperties = AutomaticAddition;
+
+ } else {
+ ::comphelper::NamedValueCollection aArguments( _rArguments );
+
+ if ( aArguments.get_ensureType( "AllowedTypes", aTypes ) )
+ m_aAllowedTypes.insert(std::cbegin(aTypes), std::cend(aTypes));
+
+ aArguments.get_ensureType( "AutomaticAddition", m_bAutoAddProperties );
+ aArguments.get_ensureType( "AllowEmptyPropertyName",
+ AllowEmptyPropertyName );
+ }
+ if (AllowEmptyPropertyName) {
+ m_aDynamicProperties.setAllowEmptyPropertyName(
+ AllowEmptyPropertyName);
+ }
+ }
+
+ OUString SAL_CALL OPropertyBag::getImplementationName()
+ {
+ return "com.sun.star.comp.comphelper.OPropertyBag";
+ }
+
+ sal_Bool SAL_CALL OPropertyBag::supportsService( const OUString& rServiceName )
+ {
+ return cppu::supportsService(this, rServiceName);
+ }
+
+ Sequence< OUString > SAL_CALL OPropertyBag::getSupportedServiceNames( )
+ {
+ return { "com.sun.star.beans.PropertyBag" };
+ }
+
+ void OPropertyBag::fireEvents(
+ sal_Int32 * /*pnHandles*/,
+ sal_Int32 nCount,
+ sal_Bool bVetoable,
+ bool bIgnoreRuntimeExceptionsWhileFiring)
+ {
+ if (nCount && !bVetoable) {
+ setModifiedImpl(true, bIgnoreRuntimeExceptionsWhileFiring);
+ }
+ }
+
+ void OPropertyBag::setModifiedImpl(bool bModified,
+ bool bIgnoreRuntimeExceptionsWhileFiring)
+ {
+ { // do not lock mutex while notifying (#i93514#) to prevent deadlock
+ ::osl::MutexGuard aGuard( m_aMutex );
+ m_isModified = bModified;
+ }
+ if (!bModified)
+ return;
+
+ try {
+ Reference<XInterface> xThis(*this);
+ EventObject event(xThis);
+ m_NotifyListeners.notifyEach(
+ &XModifyListener::modified, event);
+ } catch (RuntimeException &) {
+ if (!bIgnoreRuntimeExceptionsWhileFiring) {
+ throw;
+ }
+ } catch (Exception &) {
+ // ignore
+ }
+ }
+
+
+ sal_Bool SAL_CALL OPropertyBag::isModified()
+ {
+ ::osl::MutexGuard aGuard( m_aMutex );
+ return m_isModified;
+ }
+
+ void SAL_CALL OPropertyBag::setModified( sal_Bool bModified )
+ {
+ setModifiedImpl(bModified, false);
+ }
+
+ void SAL_CALL OPropertyBag::addModifyListener(
+ const Reference< XModifyListener > & xListener)
+ {
+ m_NotifyListeners.addInterface(xListener);
+ }
+
+ void SAL_CALL OPropertyBag::removeModifyListener(
+ const Reference< XModifyListener > & xListener)
+ {
+ m_NotifyListeners.removeInterface(xListener);
+ }
+
+
+ Reference< XPropertySetInfo > SAL_CALL OPropertyBag::getPropertySetInfo( )
+ {
+ return createPropertySetInfo( getInfoHelper() );
+ }
+
+
+ sal_Bool SAL_CALL OPropertyBag::has( const Any& /*aElement*/ )
+ {
+ // XSet is only a workaround for addProperty not being able to add default-void properties.
+ // So, everything of XSet except insert is implemented empty
+ return false;
+ }
+
+
+ void SAL_CALL OPropertyBag::insert( const Any& _element )
+ {
+ // This is a workaround for addProperty not being able to add default-void properties.
+ // If we ever have a smarter XPropertyContainer::addProperty interface, we can remove this, ehm, well, hack.
+ Property aProperty;
+ if ( !( _element >>= aProperty ) )
+ throw IllegalArgumentException( "element is not Property", *this, 1 );
+
+ {
+ osl::MutexGuard g(m_aMutex);
+
+ // check whether the type is allowed, everything else will be checked
+ // by m_aDynamicProperties
+ if (!m_aAllowedTypes.empty()
+ && m_aAllowedTypes.find(aProperty.Type) == m_aAllowedTypes.end())
+ throw IllegalArgumentException("not in list of allowed types", *this, 1);
+
+ m_aDynamicProperties.addVoidProperty(aProperty.Name, aProperty.Type, findFreeHandle(),
+ aProperty.Attributes);
+
+ // our property info is dirty
+ m_pArrayHelper.reset();
+ }
+ setModified(true);
+ }
+
+
+ void SAL_CALL OPropertyBag::remove( const Any& /*aElement*/ )
+ {
+ // XSet is only a workaround for addProperty not being able to add default-void properties.
+ // So, everything of XSet except insert is implemented empty
+ throw NoSuchElementException( OUString(), *this );
+ }
+
+
+ Reference< XEnumeration > SAL_CALL OPropertyBag::createEnumeration( )
+ {
+ // XSet is only a workaround for addProperty not being able to add default-void properties.
+ // So, everything of XSet except insert is implemented empty
+ return nullptr;
+ }
+
+
+ Type SAL_CALL OPropertyBag::getElementType( )
+ {
+ // XSet is only a workaround for addProperty not being able to add default-void properties.
+ // So, everything of XSet except insert is implemented empty
+ return Type();
+ }
+
+
+ sal_Bool SAL_CALL OPropertyBag::hasElements( )
+ {
+ // XSet is only a workaround for addProperty not being able to add default-void properties.
+ // So, everything of XSet except insert is implemented empty
+ return false;
+ }
+
+
+ void SAL_CALL OPropertyBag::getFastPropertyValue( Any& _rValue, sal_Int32 _nHandle ) const
+ {
+ m_aDynamicProperties.getFastPropertyValue( _nHandle, _rValue );
+ }
+
+ sal_Bool SAL_CALL OPropertyBag::convertFastPropertyValue( Any& _rConvertedValue, Any& _rOldValue, sal_Int32 _nHandle, const Any& _rValue )
+ {
+ return m_aDynamicProperties.convertFastPropertyValue( _nHandle, _rValue, _rConvertedValue, _rOldValue );
+ }
+
+ void SAL_CALL OPropertyBag::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const Any& rValue )
+ {
+ m_aDynamicProperties.setFastPropertyValue( nHandle, rValue );
+ }
+
+
+ ::cppu::IPropertyArrayHelper& SAL_CALL OPropertyBag::getInfoHelper()
+ {
+ if (!m_pArrayHelper)
+ {
+ Sequence< Property > aProperties;
+ m_aDynamicProperties.describeProperties( aProperties );
+ m_pArrayHelper.reset( new ::cppu::OPropertyArrayHelper( aProperties ) );
+ }
+ return *m_pArrayHelper;
+
+ }
+
+
+ sal_Int32 OPropertyBag::findFreeHandle() const
+ {
+ const sal_Int32 nPrime = 1009;
+ const sal_Int32 nSeed = 11;
+
+ sal_Int32 nCheck = nSeed;
+ while ( m_aDynamicProperties.hasPropertyByHandle( nCheck ) && ( nCheck != 1 ) )
+ {
+ nCheck = ( nCheck * nSeed ) % nPrime;
+ }
+
+ if ( nCheck == 1 )
+ { // uh ... we already have 1008 handles used up
+ // -> simply count upwards
+ while ( m_aDynamicProperties.hasPropertyByHandle( nCheck ) )
+ ++nCheck;
+ }
+
+ return nCheck;
+ }
+
+
+ void SAL_CALL OPropertyBag::addProperty( const OUString& _rName, ::sal_Int16 _nAttributes, const Any& _rInitialValue )
+ {
+ {
+ osl::MutexGuard g(m_aMutex);
+
+ // check whether the type is allowed, everything else will be checked
+ // by m_aDynamicProperties
+ const Type& aPropertyType = _rInitialValue.getValueType();
+ if (_rInitialValue.hasValue() && !m_aAllowedTypes.empty()
+ && m_aAllowedTypes.find(aPropertyType) == m_aAllowedTypes.end())
+ throw IllegalTypeException(OUString(), *this);
+
+ m_aDynamicProperties.addProperty(_rName, findFreeHandle(), _nAttributes,
+ _rInitialValue);
+
+ // our property info is dirty
+ m_pArrayHelper.reset();
+ }
+ setModified(true);
+ }
+
+
+ void SAL_CALL OPropertyBag::removeProperty( const OUString& _rName )
+ {
+ {
+ osl::MutexGuard g(m_aMutex);
+
+ m_aDynamicProperties.removeProperty(_rName);
+
+ // our property info is dirty
+ m_pArrayHelper.reset();
+ }
+ setModified(true);
+ }
+
+
+ namespace
+ {
+ struct ComparePropertyValueByName
+ {
+ bool operator()( const PropertyValue& _rLHS, const PropertyValue& _rRHS )
+ {
+ return _rLHS.Name < _rRHS.Name;
+ }
+ };
+
+ template< typename CLASS >
+ struct TransformPropertyToName
+ {
+ const OUString& operator()( const CLASS& _rProp )
+ {
+ return _rProp.Name;
+ }
+ };
+
+ struct ExtractPropertyValue
+ {
+ const Any& operator()( const PropertyValue& _rProp )
+ {
+ return _rProp.Value;
+ }
+ };
+ }
+
+
+ Sequence< PropertyValue > SAL_CALL OPropertyBag::getPropertyValues( )
+ {
+ ::osl::MutexGuard aGuard( m_aMutex );
+
+ // all registered properties
+ Sequence< Property > aProperties;
+ m_aDynamicProperties.describeProperties( aProperties );
+
+ // their names
+ Sequence< OUString > aNames( aProperties.getLength() );
+ std::transform(
+ std::cbegin(aProperties),
+ std::cend(aProperties),
+ aNames.getArray(),
+ TransformPropertyToName< Property >()
+ );
+
+ // their values
+ Sequence< Any > aValues;
+ try
+ {
+ aValues = OPropertyBag_PBase::getPropertyValues( aNames );
+ if ( aValues.getLength() != aNames.getLength() )
+ throw RuntimeException();
+ }
+ catch( const RuntimeException& )
+ {
+ throw;
+ }
+ catch( const Exception& )
+ {
+ // ignore
+ }
+
+ // merge names and values, and retrieve the state/handle
+ ::cppu::IPropertyArrayHelper& rPropInfo = getInfoHelper();
+
+ Sequence< PropertyValue > aPropertyValues( aNames.getLength() );
+ const OUString* pName = aNames.getConstArray();
+ const OUString* pNamesEnd = aNames.getConstArray() + aNames.getLength();
+ const Any* pValue = aValues.getArray();
+ PropertyValue* pPropertyValue = aPropertyValues.getArray();
+
+ for ( ; pName != pNamesEnd; ++pName, ++pValue, ++pPropertyValue )
+ {
+ pPropertyValue->Name = *pName;
+ pPropertyValue->Handle = rPropInfo.getHandleByName( *pName );
+ pPropertyValue->Value = *pValue;
+ pPropertyValue->State = getPropertyStateByHandle( pPropertyValue->Handle );
+ }
+
+ return aPropertyValues;
+ }
+
+
+ void OPropertyBag::impl_setPropertyValues_throw( const Sequence< PropertyValue >& _rProps )
+ {
+ // sort (the XMultiPropertySet interface requires this)
+ Sequence< PropertyValue > aProperties( _rProps );
+ auto [begin, end] = asNonConstRange(aProperties);
+ std::sort(
+ begin,
+ end,
+ ComparePropertyValueByName()
+ );
+
+ // a sequence of names
+ Sequence< OUString > aNames( aProperties.getLength() );
+ std::transform(
+ std::cbegin(aProperties),
+ std::cend(aProperties),
+ aNames.getArray(),
+ TransformPropertyToName< PropertyValue >()
+ );
+
+ try
+ {
+ // check for unknown properties
+ // we cannot simply rely on the XMultiPropertySet::setPropertyValues
+ // implementation of our base class, since it does not throw
+ // an UnknownPropertyException. More precise, XMultiPropertySet::setPropertyValues
+ // does not allow to throw this exception, while XPropertyAccess::setPropertyValues
+ // requires it
+ sal_Int32 nCount = aNames.getLength();
+
+ Sequence< sal_Int32 > aHandles( nCount );
+ sal_Int32* pHandle = aHandles.getArray();
+ const PropertyValue* pProperty = aProperties.getConstArray();
+ for ( const OUString* pName = aNames.getConstArray();
+ pName != aNames.getConstArray() + aNames.getLength();
+ ++pName, ++pHandle, ++pProperty
+ )
+ {
+ ::cppu::IPropertyArrayHelper& rPropInfo = getInfoHelper();
+ *pHandle = rPropInfo.getHandleByName( *pName );
+ if ( *pHandle != -1 )
+ continue;
+
+ // there's a property requested which we do not know
+ if ( m_bAutoAddProperties )
+ {
+ // add the property
+ sal_Int16 const nAttributes = PropertyAttribute::BOUND | PropertyAttribute::REMOVABLE | PropertyAttribute::MAYBEDEFAULT;
+ addProperty( *pName, nAttributes, pProperty->Value );
+ continue;
+ }
+
+ // no way out
+ throw UnknownPropertyException( *pName, *this );
+ }
+
+ // a sequence of values
+ Sequence< Any > aValues( aProperties.getLength() );
+ std::transform(
+ std::cbegin(aProperties),
+ std::cend(aProperties),
+ aValues.getArray(),
+ ExtractPropertyValue()
+ );
+
+ setFastPropertyValues( nCount, aHandles.getArray(), aValues.getConstArray(), nCount );
+ }
+ catch( const PropertyVetoException& ) { throw; }
+ catch( const IllegalArgumentException& ) { throw; }
+ catch( const WrappedTargetException& ) { throw; }
+ catch( const RuntimeException& ) { throw; }
+ catch( const UnknownPropertyException& ) { throw; }
+ catch( const Exception& )
+ {
+ throw WrappedTargetException( OUString(), *this, ::cppu::getCaughtException() );
+ }
+ }
+
+
+ void SAL_CALL OPropertyBag::setPropertyValues( const Sequence< PropertyValue >& _rProps )
+ {
+ ::osl::MutexGuard aGuard( m_aMutex );
+ impl_setPropertyValues_throw( _rProps );
+ }
+
+
+ PropertyState OPropertyBag::getPropertyStateByHandle( sal_Int32 _nHandle )
+ {
+ // for properties which do not support the MAYBEDEFAULT attribute, don't rely on the base class, but
+ // assume they're always in DIRECT state.
+ // (Note that this probably would belong into the base class. However, this would mean we would need
+ // to check all existent usages of the base class, where MAYBEDEFAULT is *not* set, but
+ // a default is nonetheless supplied/used. This is hard to accomplish reliably, in the
+ // current phase. #i78593#
+
+ ::cppu::IPropertyArrayHelper& rPropInfo = getInfoHelper();
+ sal_Int16 nAttributes(0);
+ OSL_VERIFY( rPropInfo.fillPropertyMembersByHandle( nullptr, &nAttributes, _nHandle ) );
+ if ( ( nAttributes & PropertyAttribute::MAYBEDEFAULT ) == 0 )
+ return PropertyState_DIRECT_VALUE;
+
+ return OPropertyBag_PBase::getPropertyStateByHandle( _nHandle );
+ }
+
+
+ Any OPropertyBag::getPropertyDefaultByHandle( sal_Int32 _nHandle ) const
+ {
+ Any aDefault;
+ m_aDynamicProperties.getPropertyDefaultByHandle( _nHandle, aDefault );
+ return aDefault;
+ }
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/property/opropertybag.hxx b/comphelper/source/property/opropertybag.hxx
new file mode 100644
index 000000000..28333901c
--- /dev/null
+++ b/comphelper/source/property/opropertybag.hxx
@@ -0,0 +1,218 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/util/XModifiable.hpp>
+#include <com/sun/star/beans/XPropertyBag.hpp>
+#include <com/sun/star/container/XSet.hpp>
+
+#include <cppuhelper/implbase5.hxx>
+#include <comphelper/interfacecontainer3.hxx>
+#include <comphelper/propstate.hxx>
+#include <comphelper/broadcasthelper.hxx>
+#include <comphelper/propertybag.hxx>
+#include <comphelper/uno3.hxx>
+
+#include <map>
+#include <set>
+#include <memory>
+
+
+namespace comphelper
+{
+
+
+ struct UnoTypeLess
+ {
+ bool operator()( const css::uno::Type& _rLHS, const css::uno::Type& _rRHS ) const
+ {
+ return rtl_ustr_compare(
+ _rLHS.getTypeLibType()->pTypeName->buffer,
+ _rRHS.getTypeLibType()->pTypeName->buffer
+ ) < 0;
+ }
+ };
+
+ typedef std::map< sal_Int32, css::uno::Any > MapInt2Any;
+ typedef std::set< css::uno::Type, UnoTypeLess > TypeBag;
+
+ typedef ::cppu::WeakAggImplHelper5 < css::beans::XPropertyBag
+ , css::util::XModifiable
+ , css::lang::XServiceInfo
+ , css::lang::XInitialization
+ , css::container::XSet
+ > OPropertyBag_Base;
+ typedef ::comphelper::OPropertyStateHelper OPropertyBag_PBase;
+
+ class OPropertyBag final : public ::comphelper::OMutexAndBroadcastHelper // must be before OPropertyBag_PBase
+ ,public OPropertyBag_PBase
+ ,public OPropertyBag_Base
+ ,public ::cppu::IEventNotificationHook
+ {
+ private:
+ /// our IPropertyArrayHelper implementation
+ std::unique_ptr< ::cppu::OPropertyArrayHelper >
+ m_pArrayHelper;
+ ::comphelper::PropertyBag
+ m_aDynamicProperties;
+ /// set of allowed property types
+ TypeBag m_aAllowedTypes;
+ /// should we automatically add properties which are tried to set, if they don't exist previously?
+ bool m_bAutoAddProperties;
+
+ /// for notification
+ ::comphelper::OInterfaceContainerHelper3<css::util::XModifyListener> m_NotifyListeners;
+ /// modify flag
+ bool m_isModified;
+
+ public:
+ //noncopyable
+ OPropertyBag(const OPropertyBag&) = delete;
+ const OPropertyBag& operator=(const OPropertyBag&) = delete;
+ OPropertyBag();
+ virtual ~OPropertyBag() override;
+
+ private:
+ DECLARE_XINTERFACE()
+ DECLARE_XTYPEPROVIDER()
+
+ /** === begin UNO interface implementations == **/
+ // XInitialization
+ virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) override;
+
+ // XServiceInfo
+ virtual OUString SAL_CALL getImplementationName( ) override;
+ virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+ virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames( ) override;
+
+ // XModifiable:
+ virtual sal_Bool SAL_CALL isModified( ) override;
+ virtual void SAL_CALL setModified( sal_Bool bModified ) override;
+
+ // XModifyBroadcaster
+ virtual void SAL_CALL addModifyListener(
+ const css::uno::Reference<
+ css::util::XModifyListener > & xListener) override;
+ virtual void SAL_CALL removeModifyListener(
+ const css::uno::Reference<
+ css::util::XModifyListener > & xListener) override;
+
+ // XPropertyContainer
+ virtual void SAL_CALL addProperty( const OUString& Name, ::sal_Int16 Attributes, const css::uno::Any& DefaultValue ) override;
+ virtual void SAL_CALL removeProperty( const OUString& Name ) override;
+
+ // XPropertyAccess
+ virtual css::uno::Sequence< css::beans::PropertyValue > SAL_CALL getPropertyValues( ) override;
+ virtual void SAL_CALL setPropertyValues( const css::uno::Sequence< css::beans::PropertyValue >& aProps ) override;
+
+ // XPropertySet
+ virtual css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL getPropertySetInfo( ) override;
+ virtual void SAL_CALL setPropertyValue(const OUString& p1, const css::uno::Any& p2) override
+ { OPropertyBag_PBase::setPropertyValue(p1, p2); }
+ virtual css::uno::Any SAL_CALL getPropertyValue(const OUString& p1) override
+ { return OPropertyBag_PBase::getPropertyValue(p1); }
+ virtual void SAL_CALL addPropertyChangeListener(const OUString& p1, const css::uno::Reference<css::beans::XPropertyChangeListener>& p2) override
+ { OPropertyBag_PBase::addPropertyChangeListener(p1, p2); }
+ virtual void SAL_CALL removePropertyChangeListener(const OUString& p1, const css::uno::Reference<css::beans::XPropertyChangeListener>& p2) override
+ { OPropertyBag_PBase::removePropertyChangeListener(p1, p2); }
+ virtual void SAL_CALL addVetoableChangeListener(const OUString& p1, const css::uno::Reference<css::beans::XVetoableChangeListener>& p2) override
+ { OPropertyBag_PBase::addVetoableChangeListener(p1, p2); }
+ virtual void SAL_CALL removeVetoableChangeListener(const OUString& p1, const css::uno::Reference<css::beans::XVetoableChangeListener>& p2) override
+ { OPropertyBag_PBase::removeVetoableChangeListener(p1, p2); }
+
+ // XSet
+ virtual sal_Bool SAL_CALL has( const css::uno::Any& aElement ) override;
+ virtual void SAL_CALL insert( const css::uno::Any& aElement ) override;
+ virtual void SAL_CALL remove( const css::uno::Any& aElement ) override;
+
+ // XEnumerationAccess (base of XSet)
+ virtual css::uno::Reference< css::container::XEnumeration > SAL_CALL createEnumeration( ) override;
+
+ // XElementAccess (base of XEnumerationAccess)
+ virtual css::uno::Type SAL_CALL getElementType( ) override;
+ virtual sal_Bool SAL_CALL hasElements( ) override;
+ // UNO interface implementations
+
+ // XPropertyState
+ virtual css::uno::Any getPropertyDefaultByHandle( sal_Int32 _nHandle ) const override;
+
+ // OPropertyStateHelper
+ virtual css::beans::PropertyState getPropertyStateByHandle( sal_Int32 _nHandle ) override;
+
+ // OPropertySetHelper
+ virtual void SAL_CALL getFastPropertyValue( css::uno::Any& rValue, sal_Int32 nHandle ) const override;
+ virtual sal_Bool SAL_CALL convertFastPropertyValue( css::uno::Any & rConvertedValue, css::uno::Any & rOldValue, sal_Int32 nHandle, const css::uno::Any& rValue ) override;
+ virtual void SAL_CALL setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const css::uno::Any& rValue ) override;
+ virtual ::cppu::IPropertyArrayHelper& SAL_CALL getInfoHelper() override;
+
+ // IEventNotificationHook
+ virtual void fireEvents(
+ sal_Int32 * pnHandles,
+ sal_Int32 nCount,
+ sal_Bool bVetoable,
+ bool bIgnoreRuntimeExceptionsWhileFiring) override;
+
+ void setModifiedImpl( bool bModified,
+ bool bIgnoreRuntimeExceptionsWhileFiring);
+
+ /** finds a free property handle
+ @precond
+ our mutex is locked
+ */
+ sal_Int32 findFreeHandle() const;
+
+ /** implements the setPropertyValues method
+ @param _rProps
+ the property values to set
+
+ @throws PropertyVetoException
+ if the XMultiPropertySet::setPropertyValues call does so
+
+ @throws css::lang::IllegalArgumentException
+ if the XMultiPropertySet::setPropertyValues call does so
+
+ @throws css::lang::WrappedTargetException
+ if the XMultiPropertySet::setPropertyValues call does so
+
+ @throws css::uno::RuntimeException
+ if the XMultiPropertySet::setPropertyValues call does so
+
+ @throws css::beans::UnknownPropertyException
+ if the XMultiPropertySet::setPropertyValues call does so, and <arg>_bTolerateUnknownProperties</arg>
+ was set to <FALSE/>
+
+ @throws css::lang::WrappedTargetException
+ if the XMultiPropertySet::setPropertyValues call did throw an exception not listed
+ above
+ */
+ void impl_setPropertyValues_throw( const css::uno::Sequence< css::beans::PropertyValue >& _rProps );
+
+ using ::cppu::OPropertySetHelper::getPropertyValues;
+ using ::cppu::OPropertySetHelper::setPropertyValues;
+ using ::cppu::OPropertySetHelper::getFastPropertyValue;
+ };
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/property/propagg.cxx b/comphelper/source/property/propagg.cxx
new file mode 100644
index 000000000..0d8ea6a10
--- /dev/null
+++ b/comphelper/source/property/propagg.cxx
@@ -0,0 +1,870 @@
+/* -*- 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 <comphelper/propagg.hxx>
+#include <comphelper/property.hxx>
+#include <comphelper/sequence.hxx>
+#include <cppuhelper/queryinterface.hxx>
+#include <osl/diagnose.h>
+#include <sal/log.hxx>
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <o3tl/sorted_vector.hxx>
+#include <typeinfo>
+#include <algorithm>
+#include <cstddef>
+#include <unordered_set>
+#include <memory>
+
+
+namespace comphelper
+{
+
+
+ using namespace ::com::sun::star::uno;
+ using namespace ::com::sun::star::lang;
+ using namespace ::com::sun::star::beans;
+
+ using namespace internal;
+
+
+ namespace
+ {
+ const Property* lcl_findPropertyByName( const std::vector< Property >& _rProps, const OUString& _rName )
+ {
+ Property aNameProp(_rName, 0, Type(), 0);
+ auto pResult = std::lower_bound(_rProps.begin(), _rProps.end(), aNameProp, PropertyCompareByName());
+ if ( pResult == _rProps.end() || pResult->Name != _rName )
+ return nullptr;
+
+ return &*pResult;
+ }
+ }
+
+OPropertyArrayAggregationHelper::OPropertyArrayAggregationHelper(
+ const Sequence< Property >& _rProperties, const Sequence< Property >& _rAggProperties,
+ IPropertyInfoService* _pInfoService, sal_Int32 _nFirstAggregateId )
+{
+ // if properties are present both at the delegatee and the aggregate, then the former are supposed to win
+ // merge and sort properties by name, delete duplicates (stable sort ensures delegator properties win)
+ m_aProperties.insert( m_aProperties.end(), _rProperties.begin(), _rProperties.end() );
+ m_aProperties.insert( m_aProperties.end(), _rAggProperties.begin(), _rAggProperties.end() );
+ std::stable_sort( m_aProperties.begin(), m_aProperties.end(), PropertyCompareByName() );
+ m_aProperties.erase( std::unique(m_aProperties.begin(), m_aProperties.end(),
+ []( const css::beans::Property& x, const css::beans::Property& y ) -> bool { return x.Name == y.Name; } ),
+ m_aProperties.end() );
+ m_aProperties.shrink_to_fit();
+
+ // fill aDelegatorProps with names from _rProperties for a fast existence check
+ // different kinds of properties are processed differently
+ std::unordered_set< OUString > aDelegatorProps;
+ aDelegatorProps.reserve( _rProperties.getLength() );
+ for( auto &delegateProp: _rProperties )
+ {
+ const auto inserted = aDelegatorProps.insert( delegateProp.Name );
+ OSL_ENSURE( inserted.second,
+ "OPropertyArrayAggregationHelper::OPropertyArrayAggregationHelper: duplicate delegatee property!" );
+ }
+
+ std::unordered_set< sal_Int32 > existingHandles;
+ existingHandles.reserve( m_aProperties.size() );
+ sal_Int32 nAggregateHandle = _nFirstAggregateId;
+ for ( std::size_t nMPLoop = 0; nMPLoop < m_aProperties.size(); ++nMPLoop )
+ {
+ auto &prop = m_aProperties[ nMPLoop ];
+ if ( aDelegatorProps.find( prop.Name ) != aDelegatorProps.end() )
+ {
+ m_aPropertyAccessors.insert_or_assign(
+ prop.Handle, OPropertyAccessor( -1, nMPLoop, false ));
+ existingHandles.insert( prop.Handle );
+ }
+ else
+ {
+ // determine the handle for the property which we will expose to the outside world
+ sal_Int32 nHandle = -1;
+ // ask the info service first
+ if ( _pInfoService )
+ nHandle = _pInfoService->getPreferredPropertyId( prop.Name );
+
+ if ( ( -1 == nHandle ) || ( existingHandles.find( nHandle ) != existingHandles.end() ) )
+ {
+ // 1. no handle from the info service -> default
+ // 2. conflicts -> use another one (which we don't check anymore, assuming _nFirstAggregateId was large enough)
+ nHandle = nAggregateHandle++;
+ }
+ else
+ {
+ existingHandles.insert( nHandle );
+ }
+
+ // remember the accessor for this property
+ m_aPropertyAccessors.insert_or_assign(
+ nHandle, OPropertyAccessor( prop.Handle, nMPLoop, true ));
+ prop.Handle = nHandle;
+ }
+ }
+}
+
+
+OPropertyArrayAggregationHelper::PropertyOrigin OPropertyArrayAggregationHelper::classifyProperty( const OUString& _rName )
+{
+ PropertyOrigin eOrigin = PropertyOrigin::Unknown;
+ // look up the name
+ const Property* pPropertyDescriptor = lcl_findPropertyByName( m_aProperties, _rName );
+ if ( pPropertyDescriptor )
+ {
+ // look up the handle for this name
+ auto aPos = m_aPropertyAccessors.find( pPropertyDescriptor->Handle );
+ OSL_ENSURE( m_aPropertyAccessors.end() != aPos, "OPropertyArrayAggregationHelper::classifyProperty: should have this handle in my map!" );
+ if ( m_aPropertyAccessors.end() != aPos )
+ {
+ eOrigin = aPos->second.bAggregate ? PropertyOrigin::Aggregate : PropertyOrigin::Delegator;
+ }
+ }
+ return eOrigin;
+}
+
+
+Property OPropertyArrayAggregationHelper::getPropertyByName( const OUString& _rPropertyName )
+{
+ const Property* pProperty = findPropertyByName( _rPropertyName );
+
+ if ( !pProperty )
+ throw UnknownPropertyException(_rPropertyName);
+
+ return *pProperty;
+}
+
+
+sal_Bool OPropertyArrayAggregationHelper::hasPropertyByName(const OUString& _rPropertyName)
+{
+ return nullptr != findPropertyByName( _rPropertyName );
+}
+
+
+const Property* OPropertyArrayAggregationHelper::findPropertyByName(const OUString& _rName ) const
+{
+ return lcl_findPropertyByName( m_aProperties, _rName );
+}
+
+
+sal_Int32 OPropertyArrayAggregationHelper::getHandleByName(const OUString& _rPropertyName)
+{
+ const Property* pProperty = findPropertyByName( _rPropertyName );
+ return pProperty ? pProperty->Handle : -1;
+}
+
+
+sal_Bool OPropertyArrayAggregationHelper::fillPropertyMembersByHandle(
+ OUString* _pPropName, sal_Int16* _pAttributes, sal_Int32 _nHandle)
+{
+ auto i = m_aPropertyAccessors.find(_nHandle);
+ bool bRet = i != m_aPropertyAccessors.end();
+ if (bRet)
+ {
+ const css::beans::Property& rProperty = m_aProperties[(*i).second.nPos];
+ if (_pPropName)
+ *_pPropName = rProperty.Name;
+ if (_pAttributes)
+ *_pAttributes = rProperty.Attributes;
+ }
+ return bRet;
+}
+
+
+bool OPropertyArrayAggregationHelper::getPropertyByHandle( sal_Int32 _nHandle, Property& _rProperty ) const
+{
+ auto pos = m_aPropertyAccessors.find(_nHandle);
+ if ( pos != m_aPropertyAccessors.end() )
+ {
+ _rProperty = m_aProperties[ pos->second.nPos ];
+ return true;
+ }
+ return false;
+}
+
+
+bool OPropertyArrayAggregationHelper::fillAggregatePropertyInfoByHandle(
+ OUString* _pPropName, sal_Int32* _pOriginalHandle, sal_Int32 _nHandle) const
+{
+ auto i = m_aPropertyAccessors.find(_nHandle);
+ bool bRet = i != m_aPropertyAccessors.end() && (*i).second.bAggregate;
+ if (bRet)
+ {
+ if (_pOriginalHandle)
+ *_pOriginalHandle = (*i).second.nOriginalHandle;
+ if (_pPropName)
+ {
+ OSL_ENSURE((*i).second.nPos < m_aProperties.size(),"Invalid index for sequence!");
+ const css::beans::Property& rProperty = m_aProperties[(*i).second.nPos];
+ *_pPropName = rProperty.Name;
+ }
+ }
+ return bRet;
+}
+
+
+css::uno::Sequence< css::beans::Property> OPropertyArrayAggregationHelper::getProperties()
+{
+ return comphelper::containerToSequence(m_aProperties);
+}
+
+
+sal_Int32 OPropertyArrayAggregationHelper::fillHandles(
+ sal_Int32* _pHandles, const css::uno::Sequence< OUString >& _rPropNames )
+{
+ sal_Int32 nHitCount = 0;
+ const OUString* pReqProps = _rPropNames.getConstArray();
+ sal_Int32 nReqLen = _rPropNames.getLength();
+
+ Property aNameProp;
+ for( sal_Int32 i = 0; i < nReqLen; ++i )
+ {
+ aNameProp.Name = pReqProps[i];
+ auto findIter = std::lower_bound(m_aProperties.begin(), m_aProperties.end(), aNameProp, PropertyCompareByName());
+ if ( findIter != m_aProperties.end() && findIter->Name == pReqProps[i] )
+ {
+ _pHandles[i] = findIter->Handle;
+ nHitCount++;
+ }
+ }
+ return nHitCount;
+}
+
+namespace internal
+{
+ class PropertyForwarder
+ {
+ private:
+ OPropertySetAggregationHelper& m_rAggregationHelper;
+ o3tl::sorted_vector< sal_Int32 > m_aProperties;
+ sal_Int32 m_nCurrentlyForwarding;
+
+ public:
+ explicit PropertyForwarder( OPropertySetAggregationHelper& _rAggregationHelper );
+
+ /** declares that the forwarder should be responsible for the given property
+
+ @param _nHandle
+ the public handle (<em>not</em> the original handle!) of the property
+ */
+ void takeResponsibilityFor( sal_Int32 _nHandle );
+
+ /** checks whether the forwarder is responsible for the given property
+ */
+ bool isResponsibleFor( sal_Int32 _nHandle ) const;
+
+ /// actually forwards a property value to the aggregate
+ ///
+ /// @throws Exception
+ void doForward( sal_Int32 _nHandle, const Any& _rValue );
+
+ sal_Int32 getCurrentlyForwardedProperty( ) const { return m_nCurrentlyForwarding; }
+ };
+
+
+ PropertyForwarder::PropertyForwarder( OPropertySetAggregationHelper& _rAggregationHelper )
+ :m_rAggregationHelper( _rAggregationHelper )
+ ,m_nCurrentlyForwarding( -1 )
+ {
+ }
+
+
+ void PropertyForwarder::takeResponsibilityFor( sal_Int32 _nHandle )
+ {
+ m_aProperties.insert( _nHandle );
+ }
+
+
+ bool PropertyForwarder::isResponsibleFor( sal_Int32 _nHandle ) const
+ {
+ return m_aProperties.find( _nHandle ) != m_aProperties.end();
+ }
+
+
+ void PropertyForwarder::doForward( sal_Int32 _nHandle, const Any& _rValue )
+ {
+ OSL_ENSURE( m_rAggregationHelper.m_xAggregateSet.is(), "PropertyForwarder::doForward: no property set!" );
+ if ( !m_rAggregationHelper.m_xAggregateSet.is() )
+ return;
+
+ m_rAggregationHelper.forwardingPropertyValue( _nHandle );
+
+ OSL_ENSURE( m_nCurrentlyForwarding == -1, "PropertyForwarder::doForward: reentrance?" );
+ m_nCurrentlyForwarding = _nHandle;
+
+ try
+ {
+ m_rAggregationHelper.m_xAggregateSet->setPropertyValue( m_rAggregationHelper.getPropertyName( _nHandle ), _rValue );
+ // TODO: cache the property name? (it's a O(log n) search)
+ }
+ catch( const Exception& )
+ {
+ m_rAggregationHelper.forwardedPropertyValue( _nHandle );
+ throw;
+ }
+
+ m_nCurrentlyForwarding = -1;
+
+ m_rAggregationHelper.forwardedPropertyValue( _nHandle );
+ }
+}
+
+OPropertySetAggregationHelper::OPropertySetAggregationHelper( ::cppu::OBroadcastHelper& rBHlp )
+ :OPropertyStateHelper( rBHlp )
+ ,m_bListening( false )
+{
+ m_pForwarder.reset( new PropertyForwarder( *this ) );
+}
+
+
+OPropertySetAggregationHelper::~OPropertySetAggregationHelper()
+{
+}
+
+
+css::uno::Any SAL_CALL OPropertySetAggregationHelper::queryInterface(const css::uno::Type& _rType)
+{
+ css::uno::Any aReturn = OPropertyStateHelper::queryInterface(_rType);
+
+ if ( !aReturn.hasValue() )
+ aReturn = cppu::queryInterface(_rType
+ ,static_cast< css::beans::XPropertiesChangeListener*>(this)
+ ,static_cast< css::beans::XVetoableChangeListener*>(this)
+ ,static_cast< css::lang::XEventListener*>(static_cast< css::beans::XPropertiesChangeListener*>(this))
+ );
+
+ return aReturn;
+}
+
+
+void OPropertySetAggregationHelper::disposing()
+{
+ osl::MutexGuard aGuard(rBHelper.rMutex);
+
+ if ( m_xAggregateSet.is() && m_bListening )
+ {
+ // register as a single listener
+ m_xAggregateMultiSet->removePropertiesChangeListener(this);
+ m_xAggregateSet->removeVetoableChangeListener(OUString(), this);
+ m_bListening = false;
+ }
+
+ OPropertyStateHelper::disposing();
+}
+
+
+void SAL_CALL OPropertySetAggregationHelper::disposing(const css::lang::EventObject& _rSource)
+{
+ OSL_ENSURE(m_xAggregateSet.is(), "OPropertySetAggregationHelper::disposing : don't have an aggregate anymore !");
+ if (_rSource.Source == m_xAggregateSet)
+ m_bListening = false;
+}
+
+
+void SAL_CALL OPropertySetAggregationHelper::propertiesChange(const css::uno::Sequence< css::beans::PropertyChangeEvent>& _rEvents)
+{
+ OSL_ENSURE(m_xAggregateSet.is(), "OPropertySetAggregationHelper::propertiesChange : have no aggregate !");
+
+ sal_Int32 nLen = _rEvents.getLength();
+ cppu::IPropertyArrayHelper& rPH = getInfoHelper();
+
+ if (1 == nLen)
+ {
+ const css::beans::PropertyChangeEvent& evt = _rEvents.getConstArray()[0];
+ OSL_ENSURE(!evt.PropertyName.isEmpty(), "OPropertySetAggregationHelper::propertiesChange : invalid event !");
+ // we had a bug where this assertion would have us saved a whole day :) (72514)
+ sal_Int32 nHandle = rPH.getHandleByName( evt.PropertyName );
+
+ // If nHandle is -1 the event marks a (aggregate) property which we hide to callers
+ // If isCurrentlyForwardingProperty( nHandle ) is <TRUE/>, then we ourself triggered
+ // setting this property. In this case, it will be notified later (by the OPropertySetHelper
+ // implementation)
+
+ if ( ( nHandle != -1 ) && !isCurrentlyForwardingProperty( nHandle ) )
+ fire(&nHandle, &evt.NewValue, &evt.OldValue, 1, false);
+ }
+ else
+ {
+ std::unique_ptr<sal_Int32[]> pHandles(new sal_Int32[nLen]);
+ std::unique_ptr< css::uno::Any[]> pNewValues(new css::uno::Any[nLen]);
+ std::unique_ptr< css::uno::Any[]> pOldValues(new css::uno::Any[nLen]);
+
+ sal_Int32 nDest = 0;
+ for (const css::beans::PropertyChangeEvent& rEvent : _rEvents)
+ {
+ sal_Int32 nHandle = rPH.getHandleByName(rEvent.PropertyName);
+ if ( ( nHandle != -1 ) && !isCurrentlyForwardingProperty( nHandle ) )
+ { // same as above : -1 is valid (73247) ...
+ pHandles[nDest] = nHandle;
+ pNewValues[nDest] = rEvent.NewValue;
+ pOldValues[nDest] = rEvent.OldValue;
+ ++nDest;
+ }
+ }
+
+ if (nDest)
+ fire(pHandles.get(), pNewValues.get(), pOldValues.get(), nDest, false);
+ }
+}
+
+
+void SAL_CALL OPropertySetAggregationHelper::vetoableChange(const css::beans::PropertyChangeEvent& _rEvent)
+{
+ OSL_ENSURE(m_xAggregateSet.is(), "OPropertySetAggregationHelper::vetoableChange : have no aggregate !");
+
+ cppu::IPropertyArrayHelper& rPH = getInfoHelper();
+
+ sal_Int32 nHandle = rPH.getHandleByName(_rEvent.PropertyName);
+ fire(&nHandle, &_rEvent.NewValue, &_rEvent.OldValue, 1, true);
+}
+
+
+void OPropertySetAggregationHelper::setAggregation(const css::uno::Reference< css::uno::XInterface >& _rxDelegate)
+{
+ osl::MutexGuard aGuard(rBHelper.rMutex);
+
+ if (m_bListening && m_xAggregateSet.is())
+ {
+ m_xAggregateMultiSet->removePropertiesChangeListener(this);
+ m_xAggregateSet->removeVetoableChangeListener(OUString(), this);
+ m_bListening = false;
+ }
+
+ m_xAggregateState.set(_rxDelegate, css::uno::UNO_QUERY);
+ m_xAggregateSet.set(_rxDelegate, css::uno::UNO_QUERY);
+ m_xAggregateMultiSet.set(_rxDelegate, css::uno::UNO_QUERY);
+ m_xAggregateFastSet.set(_rxDelegate, css::uno::UNO_QUERY);
+
+ // must support XPropertySet and XMultiPropertySet
+ if ( m_xAggregateSet.is() && !m_xAggregateMultiSet.is() )
+ throw css::lang::IllegalArgumentException();
+}
+
+
+void OPropertySetAggregationHelper::startListening()
+{
+ osl::MutexGuard aGuard(rBHelper.rMutex);
+
+ if (!m_bListening && m_xAggregateSet.is())
+ {
+ // register as a single listener
+ css::uno::Sequence< OUString > aPropertyNames;
+ m_xAggregateMultiSet->addPropertiesChangeListener(aPropertyNames, this);
+ m_xAggregateSet->addVetoableChangeListener(OUString(), this);
+
+ m_bListening = true;
+ }
+}
+
+
+void SAL_CALL OPropertySetAggregationHelper::addVetoableChangeListener(const OUString& _rPropertyName,
+ const css::uno::Reference< css::beans::XVetoableChangeListener>& _rxListener)
+{
+ OPropertySetHelper::addVetoableChangeListener(_rPropertyName, _rxListener);
+ if (!m_bListening)
+ startListening();
+}
+
+
+void SAL_CALL OPropertySetAggregationHelper::addPropertyChangeListener(const OUString& _rPropertyName,
+ const css::uno::Reference< css::beans::XPropertyChangeListener>& _rxListener)
+{
+ OPropertySetHelper::addPropertyChangeListener(_rPropertyName, _rxListener);
+ if (!m_bListening)
+ startListening();
+}
+
+
+void SAL_CALL OPropertySetAggregationHelper::addPropertiesChangeListener(const css::uno::Sequence< OUString >& _rPropertyNames,
+ const css::uno::Reference< css::beans::XPropertiesChangeListener>& _rxListener)
+{
+ OPropertySetHelper::addPropertiesChangeListener(_rPropertyNames, _rxListener);
+ if (!m_bListening)
+ startListening();
+}
+
+
+sal_Int32 OPropertySetAggregationHelper::getOriginalHandle(sal_Int32 nHandle) const
+{
+ OPropertyArrayAggregationHelper& rPH = static_cast<OPropertyArrayAggregationHelper&>( const_cast<OPropertySetAggregationHelper*>(this)->getInfoHelper() );
+ sal_Int32 nOriginalHandle = -1;
+ (void)rPH.fillAggregatePropertyInfoByHandle(nullptr, &nOriginalHandle, nHandle);
+ return nOriginalHandle;
+}
+
+
+OUString OPropertySetAggregationHelper::getPropertyName( sal_Int32 _nHandle ) const
+{
+ OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( const_cast<OPropertySetAggregationHelper*>(this)->getInfoHelper() );
+ Property aProperty;
+ OSL_VERIFY( rPH.getPropertyByHandle( _nHandle, aProperty ) );
+ return aProperty.Name;
+}
+
+
+void SAL_CALL OPropertySetAggregationHelper::setFastPropertyValue(sal_Int32 _nHandle, const css::uno::Any& _rValue)
+{
+ OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
+ OUString aPropName;
+ sal_Int32 nOriginalHandle = -1;
+
+ // does the handle belong to the aggregation ?
+ if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, _nHandle))
+ if (m_xAggregateFastSet.is())
+ m_xAggregateFastSet->setFastPropertyValue(nOriginalHandle, _rValue);
+ else
+ m_xAggregateSet->setPropertyValue(aPropName, _rValue);
+ else
+ OPropertySetHelper::setFastPropertyValue(_nHandle, _rValue);
+}
+
+
+void OPropertySetAggregationHelper::getFastPropertyValue( css::uno::Any& rValue, sal_Int32 nHandle) const
+{
+ OPropertyArrayAggregationHelper& rPH = static_cast<OPropertyArrayAggregationHelper&>( const_cast<OPropertySetAggregationHelper*>(this)->getInfoHelper() );
+ OUString aPropName;
+ sal_Int32 nOriginalHandle = -1;
+
+ if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, nHandle))
+ {
+ if (m_xAggregateFastSet.is())
+ rValue = m_xAggregateFastSet->getFastPropertyValue(nOriginalHandle);
+ else
+ rValue = m_xAggregateSet->getPropertyValue(aPropName);
+ }
+ else if ( m_pForwarder->isResponsibleFor( nHandle ) )
+ {
+ // this is a property which has been "overwritten" in our instance (thus
+ // fillAggregatePropertyInfoByHandle didn't find it)
+ rValue = m_xAggregateSet->getPropertyValue( getPropertyName( nHandle ) );
+ }
+}
+
+
+css::uno::Any SAL_CALL OPropertySetAggregationHelper::getFastPropertyValue(sal_Int32 nHandle)
+{
+ OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
+ OUString aPropName;
+ sal_Int32 nOriginalHandle = -1;
+ css::uno::Any aValue;
+
+ if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, nHandle))
+ {
+ if (m_xAggregateFastSet.is())
+ aValue = m_xAggregateFastSet->getFastPropertyValue(nOriginalHandle);
+ else
+ aValue = m_xAggregateSet->getPropertyValue(aPropName);
+ }
+ else
+ aValue = OPropertySetHelper::getFastPropertyValue(nHandle);
+
+ return aValue;
+}
+
+
+void SAL_CALL OPropertySetAggregationHelper::setPropertyValues(
+ const Sequence< OUString >& _rPropertyNames, const Sequence< Any >& _rValues )
+{
+ OSL_ENSURE( !rBHelper.bInDispose, "OPropertySetAggregationHelper::setPropertyValues : do not use within the dispose call !");
+ OSL_ENSURE( !rBHelper.bDisposed, "OPropertySetAggregationHelper::setPropertyValues : object is disposed" );
+
+ // check where the properties come from
+ if (!m_xAggregateSet.is())
+ OPropertySetHelper::setPropertyValues(_rPropertyNames, _rValues);
+ else if (_rPropertyNames.getLength() == 1) // use the more efficient way
+ {
+ try
+ {
+ setPropertyValue( _rPropertyNames[0], _rValues[0] );
+ }
+ catch( const UnknownPropertyException& )
+ {
+ // by definition of XMultiPropertySet::setPropertyValues, unknown properties are to be ignored
+ SAL_WARN( "comphelper", "OPropertySetAggregationHelper::setPropertyValues: unknown property: '"
+ << _rPropertyNames[0] << "', implementation: " << typeid( *this ).name() );
+ }
+ }
+ else
+ {
+ OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
+
+ // determine which properties belong to the aggregate, and which ones to the delegator
+ sal_Int32 nAggCount(0);
+ sal_Int32 nLen(_rPropertyNames.getLength());
+
+ for ( const OUString& rName : _rPropertyNames )
+ {
+ OPropertyArrayAggregationHelper::PropertyOrigin ePropOrg = rPH.classifyProperty( rName );
+ if ( OPropertyArrayAggregationHelper::PropertyOrigin::Unknown == ePropOrg )
+ throw WrappedTargetException( OUString(), static_cast< XMultiPropertySet* >( this ), Any( UnknownPropertyException( ) ) );
+ // due to a flaw in the API design, this method is not allowed to throw an UnknownPropertyException
+ // so we wrap it into a WrappedTargetException
+
+ if ( OPropertyArrayAggregationHelper::PropertyOrigin::Aggregate == ePropOrg )
+ ++nAggCount;
+ }
+
+ // all properties belong to the aggregate
+ if (nAggCount == nLen)
+ m_xAggregateMultiSet->setPropertyValues(_rPropertyNames, _rValues);
+
+ // all properties belong to the aggregating object
+ else if (nAggCount == 0)
+ OPropertySetHelper::setPropertyValues(_rPropertyNames, _rValues);
+
+ // mixed
+ else
+ {
+ const css::uno::Any* pValues = _rValues.getConstArray();
+
+ // dividing the Names and _rValues
+
+ // aggregate's names
+ Sequence< OUString > AggPropertyNames( nAggCount );
+ OUString* pAggNames = AggPropertyNames.getArray();
+ // aggregate's values
+ Sequence< Any > AggValues( nAggCount );
+ Any* pAggValues = AggValues.getArray();
+
+ // delegator names
+ Sequence< OUString > DelPropertyNames( nLen - nAggCount );
+ OUString* pDelNames = DelPropertyNames.getArray();
+
+ // delegator values
+ Sequence< Any > DelValues( nLen - nAggCount );
+ Any* pDelValues = DelValues.getArray();
+
+ for ( const OUString& rName : _rPropertyNames )
+ {
+ if ( OPropertyArrayAggregationHelper::PropertyOrigin::Aggregate == rPH.classifyProperty( rName ) )
+ {
+ *pAggNames++ = rName;
+ *pAggValues++ = *pValues++;
+ }
+ else
+ {
+ *pDelNames++ = rName;
+ *pDelValues++ = *pValues++;
+ }
+ }
+
+ // reset, needed below
+ pDelValues = DelValues.getArray();
+
+ std::unique_ptr<sal_Int32[]> pHandles(new sal_Int32[ nLen - nAggCount ]);
+
+ // get the map table
+ cppu::IPropertyArrayHelper& rPH2 = getInfoHelper();
+
+ // fill the handle array
+ sal_Int32 nHitCount = rPH2.fillHandles( pHandles.get(), DelPropertyNames );
+ if (nHitCount != 0)
+ {
+ std::unique_ptr< css::uno::Any[]> pConvertedValues(new css::uno::Any[ nHitCount ]);
+ std::unique_ptr< css::uno::Any[]> pOldValues(new css::uno::Any[ nHitCount ]);
+ nHitCount = 0;
+ sal_Int32 i;
+
+ {
+ // must lock the mutex outside the loop. So all values are consistent.
+ osl::MutexGuard aGuard( rBHelper.rMutex );
+ for( i = 0; i < (nLen - nAggCount); ++i )
+ {
+ if( pHandles[i] != -1 )
+ {
+ sal_Int16 nAttributes;
+ rPH2.fillPropertyMembersByHandle( nullptr, &nAttributes, pHandles[i] );
+ if( nAttributes & css::beans::PropertyAttribute::READONLY )
+ throw css::beans::PropertyVetoException();
+ // Will the property change?
+ if( convertFastPropertyValue( pConvertedValues[ nHitCount ], pOldValues[nHitCount],
+ pHandles[i], pDelValues[i] ) )
+ {
+ // only increment if the property really change
+ pHandles[nHitCount] = pHandles[i];
+ nHitCount++;
+ }
+ }
+ }
+ // release guard to fire events
+ }
+
+ // fire vetoable events
+ fire( pHandles.get(), pConvertedValues.get(), pOldValues.get(), nHitCount, true );
+
+ // setting the agg Properties
+ m_xAggregateMultiSet->setPropertyValues(AggPropertyNames, AggValues);
+
+ {
+ // must lock the mutex outside the loop.
+ osl::MutexGuard aGuard( rBHelper.rMutex );
+ // Loop over all changed properties
+ for( i = 0; i < nHitCount; i++ )
+ {
+ // Will the property change?
+ setFastPropertyValue_NoBroadcast( pHandles[i], pConvertedValues[i] );
+ }
+ // release guard to fire events
+ }
+
+ // fire change events
+ fire( pHandles.get(), pConvertedValues.get(), pOldValues.get(), nHitCount, false );
+ }
+ else
+ m_xAggregateMultiSet->setPropertyValues(AggPropertyNames, AggValues);
+ }
+ }
+}
+
+// XPropertyState
+
+css::beans::PropertyState SAL_CALL OPropertySetAggregationHelper::getPropertyState(const OUString& _rPropertyName)
+{
+ OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
+ sal_Int32 nHandle = rPH.getHandleByName( _rPropertyName );
+
+ if (nHandle == -1)
+ {
+ throw css::beans::UnknownPropertyException(_rPropertyName);
+ }
+
+ OUString aPropName;
+ sal_Int32 nOriginalHandle = -1;
+ if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, nHandle))
+ {
+ if (m_xAggregateState.is())
+ return m_xAggregateState->getPropertyState(_rPropertyName);
+ else
+ return css::beans::PropertyState_DIRECT_VALUE;
+ }
+ else
+ return getPropertyStateByHandle(nHandle);
+}
+
+
+void SAL_CALL OPropertySetAggregationHelper::setPropertyToDefault(const OUString& _rPropertyName)
+{
+ OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
+ sal_Int32 nHandle = rPH.getHandleByName(_rPropertyName);
+ if (nHandle == -1)
+ {
+ throw css::beans::UnknownPropertyException(_rPropertyName);
+ }
+
+ OUString aPropName;
+ sal_Int32 nOriginalHandle = -1;
+ if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, nHandle))
+ {
+ if (m_xAggregateState.is())
+ m_xAggregateState->setPropertyToDefault(_rPropertyName);
+ }
+ else
+ {
+ try
+ {
+ setPropertyToDefaultByHandle( nHandle );
+ }
+ catch( const UnknownPropertyException& ) { throw; }
+ catch( const RuntimeException& ) { throw; }
+ catch( const Exception& )
+ {
+ OSL_FAIL( "OPropertySetAggregationHelper::setPropertyToDefault: caught an exception which is not allowed to leave here!" );
+ }
+ }
+}
+
+
+css::uno::Any SAL_CALL OPropertySetAggregationHelper::getPropertyDefault(const OUString& aPropertyName)
+{
+ OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
+ sal_Int32 nHandle = rPH.getHandleByName( aPropertyName );
+
+ if ( nHandle == -1 )
+ throw css::beans::UnknownPropertyException(aPropertyName);
+
+ OUString aPropName;
+ sal_Int32 nOriginalHandle = -1;
+ if (rPH.fillAggregatePropertyInfoByHandle(&aPropName, &nOriginalHandle, nHandle))
+ {
+ if (m_xAggregateState.is())
+ return m_xAggregateState->getPropertyDefault(aPropertyName);
+ else
+ return css::uno::Any();
+ }
+ else
+ return getPropertyDefaultByHandle(nHandle);
+}
+
+sal_Bool SAL_CALL OPropertySetAggregationHelper::convertFastPropertyValue( Any& _rConvertedValue, Any& _rOldValue, sal_Int32 _nHandle, const Any& _rValue )
+{
+ bool bModified = false;
+
+ OSL_ENSURE( m_pForwarder->isResponsibleFor( _nHandle ), "OPropertySetAggregationHelper::convertFastPropertyValue: this is no forwarded property - did you use declareForwardedProperty for it?" );
+ if ( m_pForwarder->isResponsibleFor( _nHandle ) )
+ {
+ // need to determine the type of the property for conversion
+ OPropertyArrayAggregationHelper& rPH = static_cast< OPropertyArrayAggregationHelper& >( getInfoHelper() );
+ Property aProperty;
+ OSL_VERIFY( rPH.getPropertyByHandle( _nHandle, aProperty ) );
+
+ Any aCurrentValue;
+ getFastPropertyValue( aCurrentValue, _nHandle );
+ bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, aCurrentValue, aProperty.Type );
+ }
+
+ return bModified;
+}
+
+void SAL_CALL OPropertySetAggregationHelper::setFastPropertyValue_NoBroadcast( sal_Int32 _nHandle, const Any& _rValue )
+{
+ OSL_ENSURE( m_pForwarder->isResponsibleFor( _nHandle ), "OPropertySetAggregationHelper::setFastPropertyValue_NoBroadcast: this is no forwarded property - did you use declareForwardedProperty for it?" );
+ if ( m_pForwarder->isResponsibleFor( _nHandle ) )
+ m_pForwarder->doForward( _nHandle, _rValue );
+}
+
+
+void OPropertySetAggregationHelper::declareForwardedProperty( sal_Int32 _nHandle )
+{
+ OSL_ENSURE( !m_pForwarder->isResponsibleFor( _nHandle ), "OPropertySetAggregationHelper::declareForwardedProperty: already declared!" );
+ m_pForwarder->takeResponsibilityFor( _nHandle );
+}
+
+
+void OPropertySetAggregationHelper::forwardingPropertyValue( sal_Int32 )
+{
+ // not interested in
+}
+
+
+void OPropertySetAggregationHelper::forwardedPropertyValue( sal_Int32 )
+{
+ // not interested in
+}
+
+
+bool OPropertySetAggregationHelper::isCurrentlyForwardingProperty( sal_Int32 _nHandle ) const
+{
+ return m_pForwarder->getCurrentlyForwardedProperty() == _nHandle;
+}
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/property/property.cxx b/comphelper/source/property/property.cxx
new file mode 100644
index 000000000..49a7a108f
--- /dev/null
+++ b/comphelper/source/property/property.cxx
@@ -0,0 +1,203 @@
+/* -*- 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 <comphelper/property.hxx>
+#include <comphelper/sequence.hxx>
+#include <osl/diagnose.h>
+#include <sal/log.hxx>
+
+#if OSL_DEBUG_LEVEL > 0
+ #include <cppuhelper/exc_hlp.hxx>
+ #include <com/sun/star/lang/XServiceInfo.hpp>
+ #include <typeinfo>
+#endif
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <rtl/ustrbuf.hxx>
+#include <algorithm>
+
+
+namespace comphelper
+{
+
+ using ::com::sun::star::uno::Reference;
+ using ::com::sun::star::beans::XPropertySet;
+ using ::com::sun::star::beans::XPropertySetInfo;
+ using ::com::sun::star::beans::Property;
+ using ::com::sun::star::uno::Sequence;
+ using ::com::sun::star::uno::Exception;
+ using ::com::sun::star::uno::Any;
+ using ::com::sun::star::uno::Type;
+ using ::com::sun::star::uno::cpp_queryInterface;
+ using ::com::sun::star::uno::cpp_acquire;
+ using ::com::sun::star::uno::cpp_release;
+#if OSL_DEBUG_LEVEL > 0
+ using ::com::sun::star::lang::XServiceInfo;
+#endif
+ using ::com::sun::star::uno::UNO_QUERY;
+
+ namespace PropertyAttribute = ::com::sun::star::beans::PropertyAttribute;
+
+
+void copyProperties(const Reference<XPropertySet>& _rxSource,
+ const Reference<XPropertySet>& _rxDest)
+{
+ if (!_rxSource.is() || !_rxDest.is())
+ {
+ OSL_FAIL("copyProperties: invalid arguments !");
+ return;
+ }
+
+ Reference< XPropertySetInfo > xSourceProps = _rxSource->getPropertySetInfo();
+ Reference< XPropertySetInfo > xDestProps = _rxDest->getPropertySetInfo();
+
+ const Sequence< Property > aSourceProps = xSourceProps->getProperties();
+ Property aDestProp;
+ for (const Property& rSourceProp : aSourceProps)
+ {
+ if ( xDestProps->hasPropertyByName(rSourceProp.Name) )
+ {
+ try
+ {
+ aDestProp = xDestProps->getPropertyByName(rSourceProp.Name);
+ if (0 == (aDestProp.Attributes & PropertyAttribute::READONLY) )
+ {
+ const Any aSourceValue = _rxSource->getPropertyValue(rSourceProp.Name);
+ if ( 0 != (aDestProp.Attributes & PropertyAttribute::MAYBEVOID) || aSourceValue.hasValue() )
+ _rxDest->setPropertyValue(rSourceProp.Name, aSourceValue);
+ }
+ }
+ catch (Exception&)
+ {
+#if OSL_DEBUG_LEVEL > 0
+ OUStringBuffer aBuffer;
+ aBuffer.append( "::comphelper::copyProperties: could not copy property '" );
+ aBuffer.append(rSourceProp.Name );
+ aBuffer.append( "' to the destination set (a '" );
+
+ Reference< XServiceInfo > xSI( _rxDest, UNO_QUERY );
+ if ( xSI.is() )
+ {
+ aBuffer.append( xSI->getImplementationName() );
+ }
+ else
+ {
+ aBuffer.append( OUString::createFromAscii(typeid( *_rxDest ).name()) );
+ }
+ aBuffer.append( "' implementation).\n" );
+
+ Any aException( ::cppu::getCaughtException() );
+ aBuffer.append( "Caught an exception of type '" );
+ aBuffer.append( aException.getValueTypeName() );
+ aBuffer.append( "'" );
+
+ Exception aBaseException;
+ if ( ( aException >>= aBaseException ) && !aBaseException.Message.isEmpty() )
+ {
+ aBuffer.append( ", saying '" );
+ aBuffer.append( aBaseException.Message );
+ aBuffer.append( "'" );
+ }
+ aBuffer.append( "." );
+
+ SAL_WARN( "comphelper", aBuffer.makeStringAndClear() );
+#endif
+ }
+ }
+ }
+}
+
+
+bool hasProperty(const OUString& _rName, const Reference<XPropertySet>& _rxSet)
+{
+ if (_rxSet.is())
+ {
+ // XPropertySetInfoRef xInfo(rxSet->getPropertySetInfo());
+ return _rxSet->getPropertySetInfo()->hasPropertyByName(_rName);
+ }
+ return false;
+}
+
+
+void RemoveProperty(Sequence<Property>& _rProps, const OUString& _rPropName)
+{
+ // binary search
+ Property aNameProp(_rPropName, 0, Type(), 0);
+ const Property* pResult = std::lower_bound(std::cbegin(_rProps), std::cend(_rProps), aNameProp, PropertyCompareByName());
+
+ if ( pResult != std::cend(_rProps) && pResult->Name == _rPropName)
+ {
+ removeElementAt(_rProps, pResult - std::cbegin(_rProps));
+ }
+}
+
+
+void ModifyPropertyAttributes(Sequence<Property>& seqProps, const OUString& sPropName, sal_Int16 nAddAttrib, sal_Int16 nRemoveAttrib)
+{
+ // binary search
+ auto [begin, end] = asNonConstRange(seqProps);
+ Property aNameProp(sPropName, 0, Type(), 0);
+ Property* pResult = std::lower_bound(begin, end, aNameProp, PropertyCompareByName());
+
+ if ( (pResult != end) && (pResult->Name == sPropName) )
+ {
+ pResult->Attributes |= nAddAttrib;
+ pResult->Attributes &= ~nRemoveAttrib;
+ }
+}
+
+
+bool tryPropertyValue(Any& _rConvertedValue, Any& _rOldValue, const Any& _rValueToSet, const Any& _rCurrentValue, const Type& _rExpectedType)
+{
+ bool bModified(false);
+ if (_rCurrentValue.getValue() != _rValueToSet.getValue())
+ {
+ if ( _rValueToSet.hasValue() && ( !_rExpectedType.equals( _rValueToSet.getValueType() ) ) )
+ {
+ _rConvertedValue = Any( nullptr, _rExpectedType.getTypeLibType() );
+
+ if ( !uno_type_assignData(
+ const_cast< void* >( _rConvertedValue.getValue() ), _rConvertedValue.getValueType().getTypeLibType(),
+ const_cast< void* >( _rValueToSet.getValue() ), _rValueToSet.getValueType().getTypeLibType(),
+ reinterpret_cast< uno_QueryInterfaceFunc >(
+ cpp_queryInterface),
+ reinterpret_cast< uno_AcquireFunc >(cpp_acquire),
+ reinterpret_cast< uno_ReleaseFunc >(cpp_release)
+ )
+ )
+ throw css::lang::IllegalArgumentException();
+ }
+ else
+ _rConvertedValue = _rValueToSet;
+
+ if ( _rCurrentValue != _rConvertedValue )
+ {
+ _rOldValue = _rCurrentValue;
+ bModified = true;
+ }
+ }
+ return bModified;
+}
+
+
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/property/propertybag.cxx b/comphelper/source/property/propertybag.cxx
new file mode 100644
index 000000000..02e6f78c1
--- /dev/null
+++ b/comphelper/source/property/propertybag.cxx
@@ -0,0 +1,206 @@
+/* -*- 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 <comphelper/propertybag.hxx>
+#include <osl/diagnose.h>
+
+#include <com/sun/star/beans/IllegalTypeException.hpp>
+#include <com/sun/star/beans/PropertyExistException.hpp>
+#include <com/sun/star/container/ElementExistException.hpp>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <com/sun/star/beans/NotRemoveableException.hpp>
+#include <com/sun/star/beans/UnknownPropertyException.hpp>
+
+#include <map>
+#include <string_view>
+
+namespace comphelper
+{
+
+
+ using ::com::sun::star::uno::Any;
+ using ::com::sun::star::uno::Type;
+ using ::com::sun::star::uno::TypeClass_VOID;
+ using ::com::sun::star::beans::IllegalTypeException;
+ using ::com::sun::star::beans::PropertyExistException;
+ using ::com::sun::star::container::ElementExistException;
+ using ::com::sun::star::lang::IllegalArgumentException;
+ using ::com::sun::star::beans::Property;
+ using ::com::sun::star::beans::NotRemoveableException;
+ using ::com::sun::star::beans::UnknownPropertyException;
+
+ namespace PropertyAttribute = ::com::sun::star::beans::PropertyAttribute;
+
+ PropertyBag::PropertyBag()
+ : m_bAllowEmptyPropertyName(false)
+ {
+ }
+
+ PropertyBag::~PropertyBag()
+ {
+ }
+
+
+ void PropertyBag::setAllowEmptyPropertyName( bool i_isAllowed )
+ {
+ m_bAllowEmptyPropertyName = i_isAllowed;
+ }
+
+
+ namespace
+ {
+ void lcl_checkForEmptyName( const bool _allowEmpty, std::u16string_view _name )
+ {
+ if ( !_allowEmpty && _name.empty() )
+ throw IllegalArgumentException(
+ "The property name must not be empty.",
+ // TODO: resource
+ nullptr,
+ 1
+ );
+ }
+
+ void lcl_checkNameAndHandle_PropertyExistException( const OUString& _name, const sal_Int32 _handle, const PropertyBag& _container )
+ {
+ if ( _container.hasPropertyByName( _name ) || _container.hasPropertyByHandle( _handle ) )
+ throw PropertyExistException(
+ "Property name or handle already used.",
+ nullptr );
+
+ }
+
+ void lcl_checkNameAndHandle_ElementExistException( const OUString& _name, const sal_Int32 _handle, const PropertyBag& _container )
+ {
+ if ( _container.hasPropertyByName( _name ) || _container.hasPropertyByHandle( _handle ) )
+ throw ElementExistException(
+ "Property name or handle already used.",
+ nullptr );
+
+ }
+
+ }
+
+
+ void PropertyBag::addVoidProperty( const OUString& _rName, const Type& _rType, sal_Int32 _nHandle, sal_Int32 _nAttributes )
+ {
+ if ( _rType.getTypeClass() == TypeClass_VOID )
+ throw IllegalArgumentException(
+ "Illegal property type: VOID",
+ // TODO: resource
+ nullptr,
+ 1
+ );
+
+ // check name/handle sanity
+ lcl_checkForEmptyName( m_bAllowEmptyPropertyName, _rName );
+ lcl_checkNameAndHandle_ElementExistException( _rName, _nHandle, *this );
+
+ // register the property
+ OSL_ENSURE( _nAttributes & PropertyAttribute::MAYBEVOID, "PropertyBag::addVoidProperty: this is for default-void properties only!" );
+ registerPropertyNoMember( _rName, _nHandle, _nAttributes | PropertyAttribute::MAYBEVOID, _rType, css::uno::Any() );
+
+ // remember the default
+ aDefaults.emplace( _nHandle, Any() );
+ }
+
+
+ void PropertyBag::addProperty( const OUString& _rName, sal_Int32 _nHandle, sal_Int32 _nAttributes, const Any& _rInitialValue )
+ {
+ // check type sanity
+ const Type& aPropertyType = _rInitialValue.getValueType();
+ if ( aPropertyType.getTypeClass() == TypeClass_VOID )
+ throw IllegalTypeException(
+ "The initial value must be non-NULL to determine the property type.",
+ // TODO: resource
+ nullptr );
+
+ // check name/handle sanity
+ lcl_checkForEmptyName( m_bAllowEmptyPropertyName, _rName );
+ lcl_checkNameAndHandle_PropertyExistException( _rName, _nHandle, *this );
+
+ // register the property
+ registerPropertyNoMember( _rName, _nHandle, _nAttributes, aPropertyType,
+ _rInitialValue );
+
+ // remember the default
+ aDefaults.emplace( _nHandle, _rInitialValue );
+ }
+
+
+ void PropertyBag::removeProperty( const OUString& _rName )
+ {
+ const Property& rProp = getProperty( _rName );
+ // will throw an UnknownPropertyException if necessary
+ if ( ( rProp.Attributes & PropertyAttribute::REMOVABLE ) == 0 )
+ throw NotRemoveableException( OUString(), nullptr );
+ const sal_Int32 nHandle = rProp.Handle;
+
+ revokeProperty( nHandle );
+
+ aDefaults.erase( nHandle );
+ }
+
+
+ void PropertyBag::getFastPropertyValue( sal_Int32 _nHandle, Any& _out_rValue ) const
+ {
+ if ( !hasPropertyByHandle( _nHandle ) )
+ throw UnknownPropertyException(OUString::number(_nHandle));
+
+ OPropertyContainerHelper::getFastPropertyValue( _out_rValue, _nHandle );
+ }
+
+
+ bool PropertyBag::convertFastPropertyValue( sal_Int32 _nHandle, const Any& _rNewValue, Any& _out_rConvertedValue, Any& _out_rCurrentValue ) const
+ {
+ if ( !hasPropertyByHandle( _nHandle ) )
+ throw UnknownPropertyException(OUString::number(_nHandle));
+
+ return const_cast< PropertyBag* >( this )->OPropertyContainerHelper::convertFastPropertyValue(
+ _out_rConvertedValue, _out_rCurrentValue, _nHandle, _rNewValue );
+ }
+
+
+ void PropertyBag::setFastPropertyValue( sal_Int32 _nHandle, const Any& _rValue )
+ {
+ if ( !hasPropertyByHandle( _nHandle ) )
+ throw UnknownPropertyException(OUString::number(_nHandle));
+
+ OPropertyContainerHelper::setFastPropertyValue( _nHandle, _rValue );
+ }
+
+
+ void PropertyBag::getPropertyDefaultByHandle( sal_Int32 _nHandle, Any& _out_rValue ) const
+ {
+ if ( !hasPropertyByHandle( _nHandle ) )
+ throw UnknownPropertyException(OUString::number(_nHandle));
+
+ auto pos = aDefaults.find( _nHandle );
+ OSL_ENSURE( pos != aDefaults.end(), "PropertyBag::getPropertyDefaultByHandle: inconsistency!" );
+ if ( pos != aDefaults.end() )
+ _out_rValue = pos->second;
+ else
+ _out_rValue.clear();
+ }
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/property/propertycontainer.cxx b/comphelper/source/property/propertycontainer.cxx
new file mode 100644
index 000000000..2b5685405
--- /dev/null
+++ b/comphelper/source/property/propertycontainer.cxx
@@ -0,0 +1,76 @@
+/* -*- 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 <comphelper/propertycontainer.hxx>
+#include <cppuhelper/typeprovider.hxx>
+
+
+namespace comphelper
+{
+
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::beans;
+
+OPropertyContainer::OPropertyContainer(::cppu::OBroadcastHelper& _rBHelper)
+ :OPropertySetHelper(_rBHelper)
+{
+}
+
+
+OPropertyContainer::~OPropertyContainer()
+{
+}
+
+
+Sequence< Type > OPropertyContainer::getBaseTypes()
+{
+ // just the types from our one and only base class
+ ::cppu::OTypeCollection aTypes(
+ cppu::UnoType<XPropertySet>::get(),
+ cppu::UnoType<XFastPropertySet>::get(),
+ cppu::UnoType<XMultiPropertySet>::get()
+ );
+ return aTypes.getTypes();
+}
+
+sal_Bool OPropertyContainer::convertFastPropertyValue(
+ Any& _rConvertedValue, Any& _rOldValue, sal_Int32 _nHandle, const Any& _rValue )
+{
+ return OPropertyContainerHelper::convertFastPropertyValue( _rConvertedValue, _rOldValue, _nHandle, _rValue );
+}
+
+
+void OPropertyContainer::setFastPropertyValue_NoBroadcast(sal_Int32 _nHandle, const Any& _rValue)
+{
+ OPropertyContainerHelper::setFastPropertyValue( _nHandle, _rValue );
+}
+
+
+void OPropertyContainer::getFastPropertyValue(Any& _rValue, sal_Int32 _nHandle) const
+{
+ OPropertyContainerHelper::getFastPropertyValue( _rValue, _nHandle );
+}
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/property/propertycontainerhelper.cxx b/comphelper/source/property/propertycontainerhelper.cxx
new file mode 100644
index 000000000..ee81100ae
--- /dev/null
+++ b/comphelper/source/property/propertycontainerhelper.cxx
@@ -0,0 +1,494 @@
+/* -*- 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 <comphelper/propertycontainerhelper.hxx>
+#include <comphelper/property.hxx>
+#include <osl/diagnose.h>
+#include <uno/data.h>
+#include <com/sun/star/uno/Sequence.hxx>
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <com/sun/star/beans/UnknownPropertyException.hpp>
+
+#include <algorithm>
+#include <utility>
+
+
+namespace comphelper
+{
+
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::beans;
+
+
+namespace
+{
+ // comparing two property descriptions
+ struct PropertyDescriptionHandleCompare
+ {
+ bool operator() (const PropertyDescription& x, const PropertyDescription& y) const
+ {
+ return x.aProperty.Handle < y.aProperty.Handle;
+ }
+ };
+ // comparing two property descriptions (by name)
+ struct PropertyDescriptionNameMatch
+ {
+ OUString const m_rCompare;
+ explicit PropertyDescriptionNameMatch( OUString _aCompare ) : m_rCompare(std::move( _aCompare )) { }
+
+ bool operator() (const PropertyDescription& x ) const
+ {
+ return x.aProperty.Name == m_rCompare;
+ }
+ };
+}
+
+OPropertyContainerHelper::OPropertyContainerHelper()
+{
+}
+
+
+OPropertyContainerHelper::~OPropertyContainerHelper()
+{
+}
+
+
+void OPropertyContainerHelper::registerProperty(const OUString& _rName, sal_Int32 _nHandle,
+ sal_Int32 _nAttributes, void* _pPointerToMember, const Type& _rMemberType)
+{
+ OSL_ENSURE((_nAttributes & PropertyAttribute::MAYBEVOID) == 0,
+ "OPropertyContainerHelper::registerProperty: don't use this for properties which may be void ! There is a method called \"registerMayBeVoidProperty\" for this !");
+ OSL_ENSURE(!_rMemberType.equals(cppu::UnoType<Any>::get()),
+ "OPropertyContainerHelper::registerProperty: don't give my the type of a uno::Any ! Really can't handle this !");
+ OSL_ENSURE(_pPointerToMember,
+ "OPropertyContainerHelper::registerProperty: you gave me nonsense : the pointer must be non-NULL");
+
+ PropertyDescription aNewProp;
+ aNewProp.aProperty = Property( _rName, _nHandle, _rMemberType, static_cast<sal_Int16>(_nAttributes) );
+ aNewProp.eLocated = PropertyDescription::LocationType::DerivedClassRealType;
+ aNewProp.aLocation.pDerivedClassMember = _pPointerToMember;
+
+ implPushBackProperty(aNewProp);
+}
+
+
+void OPropertyContainerHelper::revokeProperty( sal_Int32 _nHandle )
+{
+ PropertiesIterator aPos = searchHandle( _nHandle );
+ if ( aPos == m_aProperties.end() )
+ throw UnknownPropertyException(OUString::number(_nHandle));
+ m_aProperties.erase( aPos );
+}
+
+
+void OPropertyContainerHelper::registerMayBeVoidProperty(const OUString& _rName, sal_Int32 _nHandle, sal_Int32 _nAttributes,
+ Any* _pPointerToMember, const Type& _rExpectedType)
+{
+ OSL_ENSURE((_nAttributes & PropertyAttribute::MAYBEVOID) != 0,
+ "OPropertyContainerHelper::registerMayBeVoidProperty: why calling this when the attributes say nothing about may-be-void ?");
+ OSL_ENSURE(!_rExpectedType.equals(cppu::UnoType<Any>::get()),
+ "OPropertyContainerHelper::registerMayBeVoidProperty: don't give my the type of a uno::Any ! Really can't handle this !");
+ OSL_ENSURE(_pPointerToMember,
+ "OPropertyContainerHelper::registerMayBeVoidProperty: you gave me nonsense : the pointer must be non-NULL");
+
+ _nAttributes |= PropertyAttribute::MAYBEVOID;
+
+ PropertyDescription aNewProp;
+ aNewProp.aProperty = Property( _rName, _nHandle, _rExpectedType, static_cast<sal_Int16>(_nAttributes) );
+ aNewProp.eLocated = PropertyDescription::LocationType::DerivedClassAnyType;
+ aNewProp.aLocation.pDerivedClassMember = _pPointerToMember;
+
+ implPushBackProperty(aNewProp);
+}
+
+
+void OPropertyContainerHelper::registerPropertyNoMember(const OUString& _rName, sal_Int32 _nHandle, sal_Int32 _nAttributes,
+ const Type& _rType, css::uno::Any const & _pInitialValue)
+{
+ OSL_ENSURE(!_rType.equals(cppu::UnoType<Any>::get()),
+ "OPropertyContainerHelper::registerPropertyNoMember : don't give my the type of a uno::Any ! Really can't handle this !");
+ OSL_ENSURE(
+ (_pInitialValue.isExtractableTo(_rType)
+ || (!_pInitialValue.hasValue()
+ && (_nAttributes & PropertyAttribute::MAYBEVOID) != 0)),
+ "bad initial value");
+
+ PropertyDescription aNewProp;
+ aNewProp.aProperty = Property( _rName, _nHandle, _rType, static_cast<sal_Int16>(_nAttributes) );
+ aNewProp.eLocated = PropertyDescription::LocationType::HoldMyself;
+ aNewProp.aLocation.nOwnClassVectorIndex = m_aHoldProperties.size();
+ m_aHoldProperties.push_back(_pInitialValue);
+
+ implPushBackProperty(aNewProp);
+}
+
+
+bool OPropertyContainerHelper::isRegisteredProperty( sal_Int32 _nHandle ) const
+{
+ return const_cast< OPropertyContainerHelper* >( this )->searchHandle( _nHandle ) != m_aProperties.end();
+}
+
+
+bool OPropertyContainerHelper::isRegisteredProperty( const OUString& _rName ) const
+{
+ // TODO: the current structure is from a time where properties were
+ // static, not dynamic. Since we allow that properties are also dynamic,
+ // i.e. registered and revoked even though the XPropertySet has already been
+ // accessed, a vector is not really the best data structure anymore ...
+
+ return std::any_of(
+ m_aProperties.begin(),
+ m_aProperties.end(),
+ PropertyDescriptionNameMatch( _rName )
+ );
+}
+
+
+namespace
+{
+ struct ComparePropertyHandles
+ {
+ bool operator()( const PropertyDescription& _rLHS, const PropertyDescription& _nRHS ) const
+ {
+ return _rLHS.aProperty.Handle < _nRHS.aProperty.Handle;
+ }
+ };
+}
+
+
+void OPropertyContainerHelper::implPushBackProperty(const PropertyDescription& _rProp)
+{
+#ifdef DBG_UTIL
+ for (const auto& checkConflicts : m_aProperties)
+ {
+ OSL_ENSURE(checkConflicts.aProperty.Name != _rProp.aProperty.Name, "OPropertyContainerHelper::implPushBackProperty: name already exists!");
+ OSL_ENSURE(checkConflicts.aProperty.Handle != _rProp.aProperty.Handle, "OPropertyContainerHelper::implPushBackProperty: handle already exists!");
+ }
+#endif
+
+ PropertiesIterator pos = std::lower_bound(
+ m_aProperties.begin(), m_aProperties.end(),
+ _rProp, ComparePropertyHandles() );
+
+ m_aProperties.insert( pos, _rProp );
+}
+
+
+namespace
+{
+ void lcl_throwIllegalPropertyValueTypeException( const PropertyDescription& _rProperty, const Any& _rValue )
+ {
+ throw IllegalArgumentException(
+ "The given value cannot be converted to the required property type."
+ " (property name \"" + _rProperty.aProperty.Name
+ + "\", found value type \"" + _rValue.getValueType().getTypeName()
+ + "\", required property type \"" + _rProperty.aProperty.Type.getTypeName()
+ + "\")",
+ nullptr, 4 );
+ }
+}
+
+
+bool OPropertyContainerHelper::convertFastPropertyValue(
+ Any& _rConvertedValue, Any& _rOldValue, sal_Int32 _nHandle, const Any& _rValue )
+{
+ bool bModified = false;
+
+ // get the property somebody is asking for
+ PropertiesIterator aPos = searchHandle(_nHandle);
+ if (aPos == m_aProperties.end())
+ {
+ OSL_FAIL( "OPropertyContainerHelper::convertFastPropertyValue: unknown handle!" );
+ // should not happen if the derived class has built a correct property set info helper to be used by
+ // our base class OPropertySetHelper
+ return bModified;
+ }
+
+ switch (aPos->eLocated)
+ {
+ // similar handling for the two cases where the value is stored in an any
+ case PropertyDescription::LocationType::HoldMyself:
+ case PropertyDescription::LocationType::DerivedClassAnyType:
+ {
+ bool bMayBeVoid = ((aPos->aProperty.Attributes & PropertyAttribute::MAYBEVOID) != 0);
+
+
+ // non modifiable version of the value-to-be-set
+ Any aNewRequestedValue( _rValue );
+
+ // normalization
+ // #i29490#
+ if ( !aNewRequestedValue.getValueType().equals( aPos->aProperty.Type ) )
+ { // the actually given value is not of the same type as the one required
+ Any aProperlyTyped( nullptr, aPos->aProperty.Type.getTypeLibType() );
+
+ if ( uno_type_assignData(
+ const_cast< void* >( aProperlyTyped.getValue() ), aProperlyTyped.getValueType().getTypeLibType(),
+ const_cast< void* >( aNewRequestedValue.getValue() ), aNewRequestedValue.getValueType().getTypeLibType(),
+ reinterpret_cast< uno_QueryInterfaceFunc >( cpp_queryInterface ),
+ reinterpret_cast< uno_AcquireFunc >( cpp_acquire ),
+ reinterpret_cast< uno_ReleaseFunc >( cpp_release )
+ )
+ )
+ {
+ // we were able to query the given XInterface-derivee for the interface
+ // which is required for this property
+ aNewRequestedValue = aProperlyTyped;
+ }
+ }
+
+ // argument check
+ if ( ! ( (bMayBeVoid && !aNewRequestedValue.hasValue()) // void is allowed if the attribute says so
+ || (aNewRequestedValue.getValueType().equals(aPos->aProperty.Type)) // else the types have to be equal
+ )
+ )
+ {
+ lcl_throwIllegalPropertyValueTypeException( *aPos, _rValue );
+ }
+
+ Any* pPropContainer = nullptr;
+ // the pointer to the any which holds the property value, no matter if located in the derived class
+ // or in out vector
+
+ if (PropertyDescription::LocationType::HoldMyself == aPos->eLocated)
+ {
+ OSL_ENSURE(aPos->aLocation.nOwnClassVectorIndex < m_aHoldProperties.size(),
+ "OPropertyContainerHelper::convertFastPropertyValue: invalid position !");
+ auto aIter = m_aHoldProperties.begin() + aPos->aLocation.nOwnClassVectorIndex;
+ pPropContainer = &(*aIter);
+ }
+ else
+ pPropContainer = static_cast<Any*>(aPos->aLocation.pDerivedClassMember);
+
+ // check if the new value differs from the current one
+ if (!pPropContainer->hasValue() || !aNewRequestedValue.hasValue())
+ bModified = pPropContainer->hasValue() != aNewRequestedValue.hasValue();
+ else
+ bModified = !uno_type_equalData(
+ const_cast< void* >( pPropContainer->getValue() ), aPos->aProperty.Type.getTypeLibType(),
+ const_cast< void* >( aNewRequestedValue.getValue() ), aPos->aProperty.Type.getTypeLibType(),
+ reinterpret_cast< uno_QueryInterfaceFunc >( cpp_queryInterface ),
+ reinterpret_cast< uno_ReleaseFunc >( cpp_release )
+ );
+
+ if (bModified)
+ {
+ _rOldValue = *pPropContainer;
+ _rConvertedValue = aNewRequestedValue;
+ }
+ }
+ break;
+ case PropertyDescription::LocationType::DerivedClassRealType:
+ // let the UNO runtime library do any possible conversion
+ // this may include a change of the type - for instance, if a LONG is required,
+ // but a short is given, then this is valid, as it can be converted without any potential
+ // data loss
+
+ Any aProperlyTyped;
+ const Any* pNewValue = &_rValue;
+
+ if (!_rValue.getValueType().equals(aPos->aProperty.Type))
+ {
+ bool bConverted = false;
+
+ // a temporary any of the correct (required) type
+ aProperlyTyped = Any( nullptr, aPos->aProperty.Type.getTypeLibType() );
+ // (need this as we do not want to overwrite the derived class member here)
+
+ if ( uno_type_assignData(
+ const_cast<void*>(aProperlyTyped.getValue()), aProperlyTyped.getValueType().getTypeLibType(),
+ const_cast<void*>(_rValue.getValue()), _rValue.getValueType().getTypeLibType(),
+ reinterpret_cast< uno_QueryInterfaceFunc >( cpp_queryInterface ),
+ reinterpret_cast< uno_AcquireFunc >( cpp_acquire ),
+ reinterpret_cast< uno_ReleaseFunc >( cpp_release )
+ )
+ )
+ {
+ // could query for the requested interface
+ bConverted = true;
+ pNewValue = &aProperlyTyped;
+ }
+
+ if ( !bConverted )
+ lcl_throwIllegalPropertyValueTypeException( *aPos, _rValue );
+ }
+
+ // from here on, we should have the proper type
+ OSL_ENSURE( pNewValue->getValueType() == aPos->aProperty.Type,
+ "OPropertyContainerHelper::convertFastPropertyValue: conversion failed!" );
+ bModified = !uno_type_equalData(
+ aPos->aLocation.pDerivedClassMember, aPos->aProperty.Type.getTypeLibType(),
+ const_cast<void*>(pNewValue->getValue()), aPos->aProperty.Type.getTypeLibType(),
+ reinterpret_cast< uno_QueryInterfaceFunc >( cpp_queryInterface ),
+ reinterpret_cast< uno_ReleaseFunc >( cpp_release )
+ );
+
+ if (bModified)
+ {
+ _rOldValue.setValue(aPos->aLocation.pDerivedClassMember, aPos->aProperty.Type);
+ _rConvertedValue = *pNewValue;
+ }
+ break;
+ }
+
+ return bModified;
+}
+
+
+void OPropertyContainerHelper::setFastPropertyValue(sal_Int32 _nHandle, const Any& _rValue)
+{
+ // get the property somebody is asking for
+ PropertiesIterator aPos = searchHandle(_nHandle);
+ if (aPos == m_aProperties.end())
+ {
+ OSL_FAIL( "OPropertyContainerHelper::setFastPropertyValue: unknown handle!" );
+ // should not happen if the derived class has built a correct property set info helper to be used by
+ // our base class OPropertySetHelper
+ return;
+ }
+
+ bool bSuccess = true;
+
+ switch (aPos->eLocated)
+ {
+ case PropertyDescription::LocationType::HoldMyself:
+ m_aHoldProperties[aPos->aLocation.nOwnClassVectorIndex] = _rValue;
+ break;
+
+ case PropertyDescription::LocationType::DerivedClassAnyType:
+ *static_cast< Any* >(aPos->aLocation.pDerivedClassMember) = _rValue;
+ break;
+
+ case PropertyDescription::LocationType::DerivedClassRealType:
+ // copy the data from the to-be-set value
+ bSuccess = uno_type_assignData(
+ aPos->aLocation.pDerivedClassMember, aPos->aProperty.Type.getTypeLibType(),
+ const_cast< void* >( _rValue.getValue() ), _rValue.getValueType().getTypeLibType(),
+ reinterpret_cast< uno_QueryInterfaceFunc >( cpp_queryInterface ),
+ reinterpret_cast< uno_AcquireFunc >( cpp_acquire ),
+ reinterpret_cast< uno_ReleaseFunc >( cpp_release ) );
+
+ OSL_ENSURE( bSuccess,
+ "OPropertyContainerHelper::setFastPropertyValue: ooops... the value could not be assigned!");
+
+ break;
+ }
+}
+
+void OPropertyContainerHelper::getFastPropertyValue(Any& _rValue, sal_Int32 _nHandle) const
+{
+ // get the property somebody is asking for
+ PropertiesIterator aPos = const_cast<OPropertyContainerHelper*>(this)->searchHandle(_nHandle);
+ if (aPos == m_aProperties.end())
+ {
+ OSL_FAIL( "OPropertyContainerHelper::getFastPropertyValue: unknown handle!" );
+ // should not happen if the derived class has built a correct property set info helper to be used by
+ // our base class OPropertySetHelper
+ return;
+ }
+
+ switch (aPos->eLocated)
+ {
+ case PropertyDescription::LocationType::HoldMyself:
+ OSL_ENSURE(aPos->aLocation.nOwnClassVectorIndex < m_aHoldProperties.size(),
+ "OPropertyContainerHelper::convertFastPropertyValue: invalid position !");
+ _rValue = m_aHoldProperties[aPos->aLocation.nOwnClassVectorIndex];
+ break;
+ case PropertyDescription::LocationType::DerivedClassAnyType:
+ _rValue = *static_cast<Any*>(aPos->aLocation.pDerivedClassMember);
+ break;
+ case PropertyDescription::LocationType::DerivedClassRealType:
+ _rValue.setValue(aPos->aLocation.pDerivedClassMember, aPos->aProperty.Type);
+ break;
+ }
+}
+
+
+OPropertyContainerHelper::PropertiesIterator OPropertyContainerHelper::searchHandle(sal_Int32 _nHandle)
+{
+ PropertyDescription aHandlePropDesc;
+ aHandlePropDesc.aProperty.Handle = _nHandle;
+ // search a lower bound
+ PropertiesIterator aLowerBound = std::lower_bound(
+ m_aProperties.begin(),
+ m_aProperties.end(),
+ aHandlePropDesc,
+ PropertyDescriptionHandleCompare());
+
+ // check for identity
+ if ((aLowerBound != m_aProperties.end()) && aLowerBound->aProperty.Handle != _nHandle)
+ aLowerBound = m_aProperties.end();
+
+ return aLowerBound;
+}
+
+
+const Property& OPropertyContainerHelper::getProperty( const OUString& _rName ) const
+{
+ ConstPropertiesIterator pos = std::find_if(
+ m_aProperties.begin(),
+ m_aProperties.end(),
+ PropertyDescriptionNameMatch( _rName )
+ );
+ if ( pos == m_aProperties.end() )
+ throw UnknownPropertyException( _rName );
+
+ return pos->aProperty;
+}
+
+
+void OPropertyContainerHelper::describeProperties(Sequence< Property >& _rProps) const
+{
+ Sequence< Property > aOwnProps(m_aProperties.size());
+ Property* pOwnProps = aOwnProps.getArray();
+
+ for (const auto& rProp : m_aProperties)
+ {
+ pOwnProps->Name = rProp.aProperty.Name;
+ pOwnProps->Handle = rProp.aProperty.Handle;
+ pOwnProps->Attributes = rProp.aProperty.Attributes;
+ pOwnProps->Type = rProp.aProperty.Type;
+ ++pOwnProps;
+ }
+
+ // as our property vector is sorted by handles, not by name, we have to sort aOwnProps
+ auto [begin, end] = asNonConstRange(aOwnProps);
+ std::sort(begin, end, PropertyCompareByName());
+
+ // unfortunately the STL merge function does not allow the output range to overlap one of the input ranges,
+ // so we need an extra sequence
+ Sequence< Property > aOutput(_rProps.getLength() + aOwnProps.getLength());
+ // do the merge
+ std::merge( std::cbegin(_rProps), std::cend(_rProps), // input 1
+ std::cbegin(aOwnProps), std::cend(aOwnProps), // input 2
+ aOutput.getArray(), // output
+ PropertyCompareByName() // compare operator
+ );
+
+ // copy the output
+ _rProps = aOutput;
+}
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/property/propertysethelper.cxx b/comphelper/source/property/propertysethelper.cxx
new file mode 100644
index 000000000..519b0705f
--- /dev/null
+++ b/comphelper/source/property/propertysethelper.cxx
@@ -0,0 +1,271 @@
+/* -*- 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 <comphelper/propertysetinfo.hxx>
+#include <comphelper/propertysethelper.hxx>
+#include <osl/diagnose.h>
+#include <rtl/ref.hxx>
+
+#include <memory>
+#include <utility>
+
+using namespace ::comphelper;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::lang;
+
+static PropertyMapEntry const * find( const rtl::Reference<PropertySetInfo>& mxInfo, const OUString& aName ) noexcept
+{
+ PropertyMap::const_iterator aIter = mxInfo->getPropertyMap().find( aName );
+
+ if( mxInfo->getPropertyMap().end() != aIter )
+ return (*aIter).second;
+ else
+ return nullptr;
+}
+
+
+PropertySetHelper::PropertySetHelper( rtl::Reference<comphelper::PropertySetInfo> xInfo ) noexcept
+ : mxInfo(std::move(xInfo))
+{
+}
+
+PropertySetHelper::~PropertySetHelper() noexcept
+{
+}
+
+// XPropertySet
+Reference< XPropertySetInfo > SAL_CALL PropertySetHelper::getPropertySetInfo( )
+{
+ return mxInfo;
+}
+
+void SAL_CALL PropertySetHelper::setPropertyValue( const OUString& aPropertyName, const Any& aValue )
+{
+ PropertyMapEntry const * aEntries[2];
+ aEntries[0] = find( mxInfo, aPropertyName );
+
+ if( nullptr == aEntries[0] )
+ throw UnknownPropertyException( aPropertyName, static_cast< XPropertySet* >( this ) );
+
+ aEntries[1] = nullptr;
+
+ _setPropertyValues( aEntries, &aValue );
+}
+
+Any SAL_CALL PropertySetHelper::getPropertyValue( const OUString& PropertyName )
+{
+ PropertyMapEntry const * aEntries[2];
+ aEntries[0] = find( mxInfo, PropertyName );
+
+ if( nullptr == aEntries[0] )
+ throw UnknownPropertyException( PropertyName, static_cast< XPropertySet* >( this ) );
+
+ aEntries[1] = nullptr;
+
+ Any aAny;
+ _getPropertyValues( aEntries, &aAny );
+
+ return aAny;
+}
+
+void SAL_CALL PropertySetHelper::addPropertyChangeListener( const OUString&, const Reference< XPropertyChangeListener >& )
+{
+ // todo
+}
+
+void SAL_CALL PropertySetHelper::removePropertyChangeListener( const OUString&, const Reference< XPropertyChangeListener >& )
+{
+ // todo
+}
+
+void SAL_CALL PropertySetHelper::addVetoableChangeListener( const OUString&, const Reference< XVetoableChangeListener >& )
+{
+ // todo
+}
+
+void SAL_CALL PropertySetHelper::removeVetoableChangeListener( const OUString&, const Reference< XVetoableChangeListener >& )
+{
+ // todo
+}
+
+// XMultiPropertySet
+void SAL_CALL PropertySetHelper::setPropertyValues( const Sequence< OUString >& rPropertyNames, const Sequence< Any >& rValues )
+{
+ const sal_Int32 nCount = rPropertyNames.getLength();
+
+ if( nCount != rValues.getLength() )
+ throw IllegalArgumentException("lengths do not match", uno::Reference<uno::XInterface>(), -1);
+
+ if( !nCount )
+ return;
+
+ std::unique_ptr<PropertyMapEntry const *[]> pEntries(new PropertyMapEntry const *[nCount+1]);
+ pEntries[nCount] = nullptr;
+ const OUString* pNames = rPropertyNames.getConstArray();
+
+ bool bUnknown = false;
+ sal_Int32 n;
+ for( n = 0; !bUnknown && ( n < nCount ); n++, pNames++ )
+ {
+ pEntries[n] = find( mxInfo, *pNames );
+ bUnknown = nullptr == pEntries[n];
+ }
+
+ if( !bUnknown )
+ _setPropertyValues( pEntries.get(), rValues.getConstArray() );
+
+ if( bUnknown )
+ throw RuntimeException( *pNames, static_cast< XPropertySet* >( this ) );
+}
+
+Sequence< Any > SAL_CALL PropertySetHelper::getPropertyValues(const Sequence< OUString >& rPropertyNames)
+{
+ const sal_Int32 nCount = rPropertyNames.getLength();
+
+ if( !nCount )
+ return Sequence< Any >();
+
+ std::unique_ptr<PropertyMapEntry const *[]> pEntries(new PropertyMapEntry const *[nCount+1]);
+ const OUString* pNames = rPropertyNames.getConstArray();
+
+ bool bUnknown = false;
+ sal_Int32 n;
+ for( n = 0; !bUnknown && ( n < nCount ); n++, pNames++ )
+ {
+ pEntries[n] = find( mxInfo, *pNames );
+ bUnknown = nullptr == pEntries[n];
+ }
+
+ if( bUnknown )
+ throw RuntimeException( *pNames, static_cast< XPropertySet* >( this ) );
+
+ pEntries[nCount] = nullptr;
+ Sequence< Any > aValues(nCount);
+ aValues.realloc(nCount);
+ _getPropertyValues( pEntries.get(), aValues.getArray() );
+ return aValues;
+
+}
+
+void SAL_CALL PropertySetHelper::addPropertiesChangeListener( const Sequence< OUString >&, const Reference< XPropertiesChangeListener >& )
+{
+ // todo
+}
+
+void SAL_CALL PropertySetHelper::removePropertiesChangeListener( const Reference< XPropertiesChangeListener >& )
+{
+ // todo
+}
+
+void SAL_CALL PropertySetHelper::firePropertiesChangeEvent( const Sequence< OUString >&, const Reference< XPropertiesChangeListener >& )
+{
+ // todo
+}
+
+// XPropertyState
+PropertyState SAL_CALL PropertySetHelper::getPropertyState( const OUString& PropertyName )
+{
+ PropertyMapEntry const * aEntries[2];
+
+ aEntries[0] = find( mxInfo, PropertyName );
+ if( aEntries[0] == nullptr )
+ throw UnknownPropertyException( PropertyName, static_cast< XPropertySet* >( this ) );
+
+ aEntries[1] = nullptr;
+
+ PropertyState aState(PropertyState_AMBIGUOUS_VALUE);
+ _getPropertyStates( aEntries, &aState );
+
+ return aState;
+}
+
+Sequence< PropertyState > SAL_CALL PropertySetHelper::getPropertyStates( const Sequence< OUString >& aPropertyName )
+{
+ const sal_Int32 nCount = aPropertyName.getLength();
+
+ Sequence< PropertyState > aStates( nCount );
+
+ if( nCount )
+ {
+ const OUString* pNames = aPropertyName.getConstArray();
+
+ bool bUnknown = false;
+
+ std::unique_ptr<PropertyMapEntry const *[]> pEntries(new PropertyMapEntry const *[nCount+1]);
+
+ sal_Int32 n;
+ for( n = 0; !bUnknown && (n < nCount); n++, pNames++ )
+ {
+ pEntries[n] = find( mxInfo, *pNames );
+ bUnknown = nullptr == pEntries[n];
+ }
+
+ pEntries[nCount] = nullptr;
+
+ if( !bUnknown )
+ _getPropertyStates( pEntries.get(), aStates.getArray() );
+
+ if( bUnknown )
+ throw UnknownPropertyException( *pNames, static_cast< XPropertySet* >( this ) );
+ }
+
+ return aStates;
+}
+
+void SAL_CALL PropertySetHelper::setPropertyToDefault( const OUString& PropertyName )
+{
+ PropertyMapEntry const *pEntry = find(mxInfo, PropertyName );
+ if( nullptr == pEntry )
+ throw UnknownPropertyException( PropertyName, static_cast< XPropertySet* >( this ) );
+
+ _setPropertyToDefault( pEntry );
+}
+
+Any SAL_CALL PropertySetHelper::getPropertyDefault( const OUString& aPropertyName )
+{
+ PropertyMapEntry const * pEntry = find(mxInfo, aPropertyName );
+ if( nullptr == pEntry )
+ throw UnknownPropertyException( aPropertyName, static_cast< XPropertySet* >( this ) );
+
+ return _getPropertyDefault( pEntry );
+}
+
+void PropertySetHelper::_getPropertyStates(
+ const comphelper::PropertyMapEntry**, PropertyState*)
+{
+ OSL_FAIL( "you have to implement this yourself!");
+}
+
+void
+PropertySetHelper::_setPropertyToDefault(const comphelper::PropertyMapEntry*)
+{
+ OSL_FAIL( "you have to implement this yourself!");
+}
+
+Any PropertySetHelper::_getPropertyDefault(const comphelper::PropertyMapEntry*)
+{
+ OSL_FAIL( "you have to implement this yourself!");
+
+ Any aAny;
+ return aAny;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/property/propertysetinfo.cxx b/comphelper/source/property/propertysetinfo.cxx
new file mode 100644
index 000000000..206129c5f
--- /dev/null
+++ b/comphelper/source/property/propertysetinfo.cxx
@@ -0,0 +1,120 @@
+/* -*- 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 <comphelper/propertysetinfo.hxx>
+#include <comphelper/sequence.hxx>
+
+
+using namespace ::comphelper;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::lang;
+
+PropertySetInfo::PropertySetInfo() noexcept
+{
+}
+
+PropertySetInfo::PropertySetInfo( o3tl::span<const PropertyMapEntry> pMap ) noexcept
+{
+ maPropertyMap.reserve(pMap.size());
+ for (const auto & rEntry : pMap)
+ {
+ // check for duplicates
+ assert(maPropertyMap.find(rEntry.maName) == maPropertyMap.end());
+ // Make sure there are no accidental empty entries left at the end of the array from
+ // when this method used to take a empty-terminated array.
+ assert(!rEntry.maName.isEmpty());
+
+ maPropertyMap.emplace(rEntry.maName, &rEntry);
+ }
+}
+
+PropertySetInfo::~PropertySetInfo() noexcept
+{
+}
+
+void PropertySetInfo::add( o3tl::span<PropertyMapEntry const> pMap ) noexcept
+{
+ maPropertyMap.reserve(maPropertyMap.size() + pMap.size());
+ for (const auto & rEntry : pMap)
+ {
+ // check for duplicates
+ assert(maPropertyMap.find(rEntry.maName) == maPropertyMap.end());
+ // Make sure there are no accidental empty entries left at the end of the array from
+ // when this method used to take a empty-terminated array.
+ assert(!rEntry.maName.isEmpty());
+
+ maPropertyMap.emplace(rEntry.maName, &rEntry);
+ }
+
+ // clear cache
+ maProperties.realloc(0);
+}
+
+void PropertySetInfo::remove( const OUString& aName ) noexcept
+{
+ maPropertyMap.erase( aName );
+ maProperties.realloc(0);
+}
+
+Sequence< css::beans::Property > SAL_CALL PropertySetInfo::getProperties()
+{
+ // maybe we have to generate the properties after
+ // a change in the property map or at first call
+ // to getProperties
+ if( maProperties.size() != maPropertyMap.size() )
+ {
+ maProperties.realloc( maPropertyMap.size() );
+ auto propIter = maProperties.getArray();
+
+ for( const auto& rProperty : maPropertyMap )
+ {
+ PropertyMapEntry const * pEntry = rProperty.second;
+
+ propIter->Name = pEntry->maName;
+ propIter->Handle = pEntry->mnHandle;
+ propIter->Type = pEntry->maType;
+ propIter->Attributes = pEntry->mnAttributes;
+
+ ++propIter;
+ }
+ }
+ return maProperties;
+}
+
+Property SAL_CALL PropertySetInfo::getPropertyByName( const OUString& aName )
+{
+ PropertyMap::iterator aIter = maPropertyMap.find( aName );
+
+ if( maPropertyMap.end() == aIter )
+ throw UnknownPropertyException( aName );
+
+ PropertyMapEntry const * pEntry = (*aIter).second;
+
+ return Property( aName, pEntry->mnHandle, pEntry->maType, pEntry->mnAttributes );
+}
+
+sal_Bool SAL_CALL PropertySetInfo::hasPropertyByName( const OUString& aName )
+{
+ return maPropertyMap.find( aName ) != maPropertyMap.end();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/property/propertystatecontainer.cxx b/comphelper/source/property/propertystatecontainer.cxx
new file mode 100644
index 000000000..e19e78733
--- /dev/null
+++ b/comphelper/source/property/propertystatecontainer.cxx
@@ -0,0 +1,183 @@
+/* -*- 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 <sal/config.h>
+
+#include <string_view>
+
+#include <comphelper/propertystatecontainer.hxx>
+
+
+namespace comphelper
+{
+
+
+ using namespace ::com::sun::star::uno;
+ using namespace ::com::sun::star::beans;
+ using namespace ::com::sun::star::lang;
+
+ namespace
+ {
+ OUString lcl_getUnknownPropertyErrorMessage( std::u16string_view _rPropertyName )
+ {
+ // TODO: perhaps it's time to think about resources in the comphelper module?
+ // Would be nice to have localized exception strings (a simply resource file containing
+ // strings only would suffice, and could be realized with a UNO service, so we do not
+ // need the dependency to the Tools project)
+ return OUString::Concat("The property \"") + _rPropertyName + "\" is unknown.";
+ }
+ }
+
+ OPropertyStateContainer::OPropertyStateContainer( ::cppu::OBroadcastHelper& _rBHelper )
+ :OPropertyContainer( _rBHelper )
+ {
+ }
+
+
+ Any SAL_CALL OPropertyStateContainer::queryInterface( const Type& _rType )
+ {
+ Any aReturn = OPropertyContainer::queryInterface( _rType );
+ if ( !aReturn.hasValue() )
+ aReturn = OPropertyStateContainer_TBase::queryInterface( _rType );
+ return aReturn;
+ }
+
+
+ IMPLEMENT_FORWARD_XTYPEPROVIDER2( OPropertyStateContainer, OPropertyContainer, OPropertyStateContainer_TBase )
+
+
+ sal_Int32 OPropertyStateContainer::getHandleForName( const OUString& _rPropertyName )
+ {
+ // look up the handle for the name
+ ::cppu::IPropertyArrayHelper& rPH = getInfoHelper();
+ sal_Int32 nHandle = rPH.getHandleByName( _rPropertyName );
+
+ if ( -1 == nHandle )
+ throw UnknownPropertyException( lcl_getUnknownPropertyErrorMessage( _rPropertyName ), static_cast< XPropertyState* >( this ) );
+
+ return nHandle;
+ }
+
+
+ PropertyState SAL_CALL OPropertyStateContainer::getPropertyState( const OUString& _rPropertyName )
+ {
+ return getPropertyStateByHandle( getHandleForName( _rPropertyName ) );
+ }
+
+
+ Sequence< PropertyState > SAL_CALL OPropertyStateContainer::getPropertyStates( const Sequence< OUString >& _rPropertyNames )
+ {
+ sal_Int32 nProperties = _rPropertyNames.getLength();
+ Sequence< PropertyState> aStates( nProperties );
+ if ( !nProperties )
+ return aStates;
+
+#ifdef DBG_UTIL
+ // precondition: property sequence is sorted (the algorithm below relies on this)
+ {
+ const OUString* pNames = _rPropertyNames.getConstArray();
+ const OUString* pNamesCompare = pNames + 1;
+ const OUString* pNamesEnd = _rPropertyNames.getConstArray() + _rPropertyNames.getLength();
+ for ( ; pNamesCompare != pNamesEnd; ++pNames, ++pNamesCompare )
+ OSL_PRECOND( pNames->compareTo( *pNamesCompare ) < 0,
+ "OPropertyStateContainer::getPropertyStates: property sequence not sorted!" );
+ }
+#endif
+
+ const OUString* pLookup = _rPropertyNames.getConstArray();
+ const OUString* pLookupEnd = pLookup + nProperties;
+ PropertyState* pStates = aStates.getArray();
+
+ cppu::IPropertyArrayHelper& rHelper = getInfoHelper();
+ Sequence< Property> aAllProperties = rHelper.getProperties();
+ sal_Int32 nAllProperties = aAllProperties.getLength();
+ const Property* pAllProperties = aAllProperties.getConstArray();
+ const Property* pAllPropertiesEnd = pAllProperties + nAllProperties;
+
+ osl::MutexGuard aGuard( rBHelper.rMutex );
+ for ( ; ( pAllProperties != pAllPropertiesEnd ) && ( pLookup != pLookupEnd ); ++pAllProperties )
+ {
+#ifdef DBG_UTIL
+ if ( pAllProperties < pAllPropertiesEnd - 1 )
+ OSL_ENSURE( pAllProperties->Name.compareTo( (pAllProperties + 1)->Name ) < 0,
+ "OPropertyStateContainer::getPropertyStates: all-properties not sorted!" );
+#endif
+ if ( pAllProperties->Name == *pLookup )
+ {
+ *pStates++ = getPropertyState( *pLookup );
+ ++pLookup;
+ }
+ }
+
+ if ( pLookup != pLookupEnd )
+ // we run out of properties from the IPropertyArrayHelper, but still have properties to lookup
+ // -> we were asked for a nonexistent property
+ throw UnknownPropertyException( lcl_getUnknownPropertyErrorMessage( *pLookup ), static_cast< XPropertyState* >( this ) );
+
+ return aStates;
+ }
+
+
+ void SAL_CALL OPropertyStateContainer::setPropertyToDefault( const OUString& _rPropertyName )
+ {
+ setPropertyToDefaultByHandle( getHandleForName( _rPropertyName ) );
+ }
+
+
+ Any SAL_CALL OPropertyStateContainer::getPropertyDefault( const OUString& _rPropertyName )
+ {
+ Any aDefault;
+ getPropertyDefaultByHandle( getHandleForName( _rPropertyName ), aDefault );
+ return aDefault;
+ }
+
+
+ PropertyState OPropertyStateContainer::getPropertyStateByHandle( sal_Int32 _nHandle ) const
+ {
+ // simply compare the current and the default value
+ Any aCurrentValue;
+ getFastPropertyValue( aCurrentValue, _nHandle );
+ Any aDefaultValue;
+ getPropertyDefaultByHandle( _nHandle, aDefaultValue );
+
+ bool bEqual = uno_type_equalData(
+ const_cast< void* >( aCurrentValue.getValue() ), aCurrentValue.getValueType().getTypeLibType(),
+ const_cast< void* >( aDefaultValue.getValue() ), aDefaultValue.getValueType().getTypeLibType(),
+ reinterpret_cast< uno_QueryInterfaceFunc >(cpp_queryInterface),
+ reinterpret_cast< uno_ReleaseFunc >(cpp_release)
+ );
+ if ( bEqual )
+ return PropertyState_DEFAULT_VALUE;
+ else
+ return PropertyState_DIRECT_VALUE;
+ }
+
+
+ void OPropertyStateContainer::setPropertyToDefaultByHandle( sal_Int32 _nHandle )
+ {
+ Any aDefault;
+ getPropertyDefaultByHandle( _nHandle, aDefault );
+ setFastPropertyValue( _nHandle, aDefault );
+ }
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/property/propmultiplex.cxx b/comphelper/source/property/propmultiplex.cxx
new file mode 100644
index 000000000..66a1545f8
--- /dev/null
+++ b/comphelper/source/property/propmultiplex.cxx
@@ -0,0 +1,153 @@
+/* -*- 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 <com/sun/star/beans/XPropertySet.hpp>
+#include <comphelper/propmultiplex.hxx>
+#include <osl/diagnose.h>
+
+
+namespace comphelper
+{
+
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::beans;
+
+OPropertyChangeListener::~OPropertyChangeListener()
+{
+ if (m_xAdapter.is())
+ m_xAdapter->dispose();
+}
+
+
+void OPropertyChangeListener::_disposing(const EventObject&)
+{
+ // nothing to do here
+}
+
+
+void OPropertyChangeListener::disposeAdapter()
+{
+ if ( m_xAdapter.is() )
+ m_xAdapter->dispose();
+
+ // will automatically set a new adapter
+ OSL_ENSURE( !m_xAdapter.is(), "OPropertyChangeListener::disposeAdapter: what did dispose do?" );
+}
+
+
+void OPropertyChangeListener::setAdapter(OPropertyChangeMultiplexer* pAdapter)
+{
+ ::osl::MutexGuard aGuard(m_rMutex);
+ m_xAdapter = pAdapter;
+}
+
+OPropertyChangeMultiplexer::OPropertyChangeMultiplexer(OPropertyChangeListener* _pListener, const Reference< XPropertySet>& _rxSet, bool _bAutoReleaseSet)
+ :m_xSet(_rxSet)
+ ,m_pListener(_pListener)
+ ,m_nLockCount(0)
+ ,m_bListening(false)
+ ,m_bAutoSetRelease(_bAutoReleaseSet)
+{
+ m_pListener->setAdapter(this);
+}
+
+
+OPropertyChangeMultiplexer::~OPropertyChangeMultiplexer()
+{
+}
+
+
+void OPropertyChangeMultiplexer::lock()
+{
+ ++m_nLockCount;
+}
+
+
+void OPropertyChangeMultiplexer::unlock()
+{
+ --m_nLockCount;
+}
+
+
+void OPropertyChangeMultiplexer::dispose()
+{
+ if (!m_bListening)
+ return;
+
+ Reference< XPropertyChangeListener> xPreventDelete(this);
+
+ for (const OUString& rProp : m_aProperties)
+ m_xSet->removePropertyChangeListener(rProp, static_cast< XPropertyChangeListener*>(this));
+
+ m_pListener->setAdapter(nullptr);
+
+ m_pListener = nullptr;
+ m_bListening = false;
+
+ if (m_bAutoSetRelease)
+ m_xSet = nullptr;
+}
+
+// XEventListener
+
+void SAL_CALL OPropertyChangeMultiplexer::disposing( const EventObject& _rSource)
+{
+ if (m_pListener)
+ {
+ // tell the listener
+ if (!locked())
+ m_pListener->_disposing(_rSource);
+ // disconnect the listener
+ if (m_pListener) // may have been reset whilst calling into _disposing
+ m_pListener->setAdapter(nullptr);
+ }
+
+ m_pListener = nullptr;
+ m_bListening = false;
+
+ if (m_bAutoSetRelease)
+ m_xSet = nullptr;
+}
+
+// XPropertyChangeListener
+
+void SAL_CALL OPropertyChangeMultiplexer::propertyChange( const PropertyChangeEvent& _rEvent )
+{
+ if (m_pListener && !locked())
+ m_pListener->_propertyChanged(_rEvent);
+}
+
+
+void OPropertyChangeMultiplexer::addProperty(const OUString& _sPropertyName)
+{
+ if (m_xSet.is())
+ {
+ m_xSet->addPropertyChangeListener(_sPropertyName, static_cast< XPropertyChangeListener*>(this));
+ m_aProperties.push_back(_sPropertyName);
+ m_bListening = true;
+ }
+}
+
+
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/property/propstate.cxx b/comphelper/source/property/propstate.cxx
new file mode 100644
index 000000000..183f51efc
--- /dev/null
+++ b/comphelper/source/property/propstate.cxx
@@ -0,0 +1,228 @@
+/* -*- 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 <comphelper/propstate.hxx>
+#include <cppuhelper/queryinterface.hxx>
+#include <comphelper/sequence.hxx>
+
+namespace comphelper
+{
+
+
+ using ::com::sun::star::uno::Type;
+ using ::com::sun::star::uno::Sequence;
+ using ::com::sun::star::lang::XTypeProvider;
+ using ::com::sun::star::uno::Any;
+ using ::com::sun::star::uno::cpp_queryInterface;
+ using ::com::sun::star::uno::cpp_release;
+ using ::com::sun::star::beans::PropertyState_DEFAULT_VALUE;
+ using ::com::sun::star::beans::PropertyState_DIRECT_VALUE;
+
+
+ // OPropertyStateHelper
+
+
+ css::uno::Any SAL_CALL OPropertyStateHelper::queryInterface(const css::uno::Type& _rType)
+ {
+ css::uno::Any aReturn = OPropertySetHelper2::queryInterface(_rType);
+ // our own ifaces
+ if ( !aReturn.hasValue() )
+ aReturn = ::cppu::queryInterface(_rType, static_cast< css::beans::XPropertyState*>(this));
+
+ return aReturn;
+ }
+
+
+ css::uno::Sequence<css::uno::Type> OPropertyStateHelper::getTypes()
+ {
+ return {
+ cppu::UnoType<css::beans::XPropertySet>::get(),
+ cppu::UnoType<css::beans::XMultiPropertySet>::get(),
+ cppu::UnoType<css::beans::XFastPropertySet>::get(),
+ cppu::UnoType<css::beans::XPropertySetOption>::get(),
+ cppu::UnoType<css::beans::XPropertyState>::get()};
+ }
+
+ OPropertyStateHelper::OPropertyStateHelper(
+ ::cppu::OBroadcastHelper& rBHlp,
+ ::cppu::IEventNotificationHook *i_pFireEvents)
+ : ::cppu::OPropertySetHelper2(rBHlp, i_pFireEvents) { }
+
+ OPropertyStateHelper::~OPropertyStateHelper() {}
+
+
+ void OPropertyStateHelper::firePropertyChange(sal_Int32 nHandle, const css::uno::Any& aNewValue, const css::uno::Any& aOldValue)
+ {
+ fire(&nHandle, &aNewValue, &aOldValue, 1, false);
+ }
+
+ // XPropertyState
+
+ css::beans::PropertyState SAL_CALL OPropertyStateHelper::getPropertyState(const OUString& _rsName)
+ {
+ cppu::IPropertyArrayHelper& rPH = getInfoHelper();
+ sal_Int32 nHandle = rPH.getHandleByName(_rsName);
+
+ if (nHandle == -1)
+ throw css::beans::UnknownPropertyException(_rsName);
+
+ return getPropertyStateByHandle(nHandle);
+ }
+
+
+ void SAL_CALL OPropertyStateHelper::setPropertyToDefault(const OUString& _rsName)
+ {
+ cppu::IPropertyArrayHelper& rPH = getInfoHelper();
+ sal_Int32 nHandle = rPH.getHandleByName(_rsName);
+
+ if (nHandle == -1)
+ throw css::beans::UnknownPropertyException(_rsName);
+
+ setPropertyToDefaultByHandle(nHandle);
+ }
+
+
+ css::uno::Any SAL_CALL OPropertyStateHelper::getPropertyDefault(const OUString& _rsName)
+ {
+ cppu::IPropertyArrayHelper& rPH = getInfoHelper();
+ sal_Int32 nHandle = rPH.getHandleByName(_rsName);
+
+ if (nHandle == -1)
+ throw css::beans::UnknownPropertyException(_rsName);
+
+ return getPropertyDefaultByHandle(nHandle);
+ }
+
+
+ css::uno::Sequence< css::beans::PropertyState> SAL_CALL OPropertyStateHelper::getPropertyStates(const css::uno::Sequence< OUString >& _rPropertyNames)
+ {
+ sal_Int32 nLen = _rPropertyNames.getLength();
+ css::uno::Sequence< css::beans::PropertyState> aRet(nLen);
+ css::beans::PropertyState* pValues = aRet.getArray();
+ const OUString* pNames = _rPropertyNames.getConstArray();
+
+ cppu::IPropertyArrayHelper& rHelper = getInfoHelper();
+
+ css::uno::Sequence< css::beans::Property> aProps = rHelper.getProperties();
+ const css::beans::Property* pProps = aProps.getConstArray();
+ sal_Int32 nPropCount = aProps.getLength();
+
+ osl::MutexGuard aGuard(rBHelper.rMutex);
+ for (sal_Int32 i=0, j=0; i<nPropCount && j<nLen; ++i, ++pProps)
+ {
+ // get the values only for valid properties
+ if (pProps->Name == *pNames)
+ {
+ *pValues = getPropertyState(*pNames);
+ ++pValues;
+ ++pNames;
+ ++j;
+ }
+ }
+
+ return aRet;
+ }
+
+
+ css::beans::PropertyState OPropertyStateHelper::getPropertyStateByHandle( sal_Int32 _nHandle )
+ {
+ // simply compare the current and the default value
+ Any aCurrentValue = getPropertyDefaultByHandle( _nHandle );
+ Any aDefaultValue;
+ getFastPropertyValue( aDefaultValue, _nHandle );
+
+ bool bEqual = uno_type_equalData(
+ const_cast< void* >( aCurrentValue.getValue() ), aCurrentValue.getValueType().getTypeLibType(),
+ const_cast< void* >( aDefaultValue.getValue() ), aDefaultValue.getValueType().getTypeLibType(),
+ reinterpret_cast< uno_QueryInterfaceFunc >(cpp_queryInterface),
+ reinterpret_cast< uno_ReleaseFunc >(cpp_release)
+ );
+ return bEqual ? PropertyState_DEFAULT_VALUE : PropertyState_DIRECT_VALUE;
+ }
+
+
+ void OPropertyStateHelper::setPropertyToDefaultByHandle( sal_Int32 _nHandle )
+ {
+ setFastPropertyValue( _nHandle, getPropertyDefaultByHandle( _nHandle ) );
+ }
+
+
+ css::uno::Any OPropertyStateHelper::getPropertyDefaultByHandle( sal_Int32 ) const
+ {
+ return css::uno::Any();
+ }
+
+
+ // OStatefulPropertySet
+
+
+ OStatefulPropertySet::OStatefulPropertySet()
+ :OPropertyStateHelper( GetBroadcastHelper() )
+ {
+ }
+
+
+ OStatefulPropertySet::~OStatefulPropertySet()
+ {
+ }
+
+
+ Sequence< Type > SAL_CALL OStatefulPropertySet::getTypes()
+ {
+ return concatSequences(
+ Sequence {
+ cppu::UnoType<XWeak>::get(),
+ cppu::UnoType<XTypeProvider>::get() },
+ OPropertyStateHelper::getTypes()
+ );
+ }
+
+ Sequence< sal_Int8 > SAL_CALL OStatefulPropertySet::getImplementationId()
+ {
+ return css::uno::Sequence<sal_Int8>();
+ }
+
+
+ Any SAL_CALL OStatefulPropertySet::queryInterface( const Type& _rType )
+ {
+ Any aReturn = OWeakObject::queryInterface( _rType );
+ if ( !aReturn.hasValue() )
+ aReturn = ::cppu::queryInterface( _rType, static_cast< XTypeProvider* >( this ) );
+ if ( !aReturn.hasValue() )
+ aReturn = OPropertyStateHelper::queryInterface( _rType );
+ return aReturn;
+ }
+
+
+ void SAL_CALL OStatefulPropertySet::acquire() noexcept
+ {
+ ::cppu::OWeakObject::acquire();
+ }
+
+
+ void SAL_CALL OStatefulPropertySet::release() noexcept
+ {
+ ::cppu::OWeakObject::release();
+ }
+
+
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/streaming/basicio.cxx b/comphelper/source/streaming/basicio.cxx
new file mode 100644
index 000000000..b8c0c96e2
--- /dev/null
+++ b/comphelper/source/streaming/basicio.cxx
@@ -0,0 +1,182 @@
+/* -*- 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 <comphelper/basicio.hxx>
+#include <comphelper/bytereader.hxx>
+#include <comphelper/servicehelper.hxx>
+#include <com/sun/star/awt/FontDescriptor.hpp>
+
+namespace comphelper
+{
+
+
+const css::uno::Reference<css::io::XObjectOutputStream>& operator << (
+ const css::uno::Reference<css::io::XObjectOutputStream>& _rxOutStream,
+ const css::awt::FontDescriptor& _rFont)
+{
+ _rxOutStream->writeUTF( _rFont.Name );
+ _rxOutStream->writeShort( _rFont.Height );
+ _rxOutStream->writeShort( _rFont.Width );
+ _rxOutStream->writeUTF( _rFont.StyleName );
+ _rxOutStream->writeShort( _rFont.Family );
+ _rxOutStream->writeShort( _rFont.CharSet );
+ _rxOutStream->writeShort( _rFont.Pitch );
+ _rxOutStream->writeDouble( _rFont.CharacterWidth );
+ _rxOutStream->writeDouble( _rFont.Weight );
+ _rxOutStream->writeShort( static_cast< sal_Int16 >(_rFont.Slant) );
+ _rxOutStream->writeShort( _rFont.Underline );
+ _rxOutStream->writeShort( _rFont.Strikeout );
+ _rxOutStream->writeDouble( _rFont.Orientation );
+ _rxOutStream->writeBoolean( _rFont.Kerning );
+ _rxOutStream->writeBoolean( _rFont.WordLineMode );
+ _rxOutStream->writeShort( _rFont.Type );
+ return _rxOutStream;
+}
+
+// FontDescriptor
+
+const css::uno::Reference<css::io::XObjectInputStream>& operator >> (
+ const css::uno::Reference<css::io::XObjectInputStream>& _rxInStream,
+ css::awt::FontDescriptor& _rFont)
+{
+ // writing the FontDescriptor
+ _rFont.Name = _rxInStream->readUTF();
+ _rFont.Height = _rxInStream->readShort();
+ _rFont.Width = _rxInStream->readShort();
+ _rFont.StyleName = _rxInStream->readUTF();
+ _rFont.Family = _rxInStream->readShort();
+ _rFont.CharSet = _rxInStream->readShort();
+ _rFont.Pitch = _rxInStream->readShort();
+ _rFont.CharacterWidth = static_cast< float >(_rxInStream->readDouble());
+ _rFont.Weight = static_cast< float >(_rxInStream->readDouble());
+ _rFont.Slant = static_cast<css::awt::FontSlant>(_rxInStream->readShort());
+ _rFont.Underline = _rxInStream->readShort();
+ _rFont.Strikeout = _rxInStream->readShort();
+ _rFont.Orientation = static_cast< float >(_rxInStream->readDouble());
+ _rFont.Kerning = _rxInStream->readBoolean() != 0;
+ _rFont.WordLineMode = _rxInStream->readBoolean() != 0;
+ _rFont.Type = _rxInStream->readShort();
+ return _rxInStream;
+}
+
+
+const css::uno::Reference<css::io::XObjectInputStream>& operator >> (const css::uno::Reference<css::io::XObjectInputStream>& _rxInStream, bool& _rVal)
+{
+ _rVal = _rxInStream->readBoolean();
+ return _rxInStream;
+}
+
+
+const css::uno::Reference<css::io::XObjectOutputStream>& operator << (const css::uno::Reference<css::io::XObjectOutputStream>& _rxOutStream, bool _bVal)
+{
+ _rxOutStream->writeBoolean(_bVal);
+ return _rxOutStream;
+}
+
+
+const css::uno::Reference<css::io::XObjectInputStream>& operator >> (const css::uno::Reference<css::io::XObjectInputStream>& _rxInStream, OUString& rStr)
+{
+ rStr = _rxInStream->readUTF();
+ return _rxInStream;
+}
+
+
+const css::uno::Reference<css::io::XObjectOutputStream>& operator << (const css::uno::Reference<css::io::XObjectOutputStream>& _rxOutStream, const OUString& rStr)
+{
+ _rxOutStream->writeUTF(rStr);
+ return _rxOutStream;
+}
+
+
+const css::uno::Reference<css::io::XObjectInputStream>& operator >> (const css::uno::Reference<css::io::XObjectInputStream>& _rxInStream, sal_Int16& _rValue)
+{
+ _rValue = _rxInStream->readShort();
+ return _rxInStream;
+}
+
+
+const css::uno::Reference<css::io::XObjectOutputStream>& operator << (const css::uno::Reference<css::io::XObjectOutputStream>& _rxOutStream, sal_Int16 _nValue)
+{
+ _rxOutStream->writeShort(_nValue);
+ return _rxOutStream;
+}
+
+
+const css::uno::Reference<css::io::XObjectInputStream>& operator >> (const css::uno::Reference<css::io::XObjectInputStream>& _rxInStream, sal_uInt16& _rValue)
+{
+ _rValue = _rxInStream->readShort();
+ return _rxInStream;
+}
+
+
+const css::uno::Reference<css::io::XObjectOutputStream>& operator << (const css::uno::Reference<css::io::XObjectOutputStream>& _rxOutStream, sal_uInt16 _nValue)
+{
+ _rxOutStream->writeShort(_nValue);
+ return _rxOutStream;
+}
+
+
+const css::uno::Reference<css::io::XObjectInputStream>& operator >> (const css::uno::Reference<css::io::XObjectInputStream>& _rxInStream, sal_uInt32& _rValue)
+{
+ _rValue = _rxInStream->readLong();
+ return _rxInStream;
+}
+
+
+const css::uno::Reference<css::io::XObjectOutputStream>& operator << (const css::uno::Reference<css::io::XObjectOutputStream>& _rxOutStream, sal_uInt32 _nValue)
+{
+ _rxOutStream->writeLong(_nValue);
+ return _rxOutStream;
+}
+
+
+const css::uno::Reference<css::io::XObjectInputStream>& operator >> (const css::uno::Reference<css::io::XObjectInputStream>& _rxInStream, sal_Int32& _rValue)
+{
+ _rValue = _rxInStream->readLong();
+ return _rxInStream;
+}
+
+
+const css::uno::Reference<css::io::XObjectOutputStream>& operator << (const css::uno::Reference<css::io::XObjectOutputStream>& _rxOutStream, sal_Int32 _nValue)
+{
+ _rxOutStream->writeLong(_nValue);
+ return _rxOutStream;
+}
+
+ByteReader::~ByteReader() {}
+
+const css::uno::Sequence< sal_Int8 > & ByteReader::getUnoTunnelId()
+{
+ static const comphelper::UnoIdInit implId;
+ return implId.getSeq();
+}
+
+ByteWriter::~ByteWriter() {}
+
+const css::uno::Sequence< sal_Int8 > & ByteWriter::getUnoTunnelId()
+{
+ static const comphelper::UnoIdInit implId;
+ return implId.getSeq();
+}
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/streaming/memorystream.cxx b/comphelper/source/streaming/memorystream.cxx
new file mode 100644
index 000000000..8bf3c3e90
--- /dev/null
+++ b/comphelper/source/streaming/memorystream.cxx
@@ -0,0 +1,286 @@
+/* -*- 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 <algorithm>
+#include <memory>
+
+#include <boost/core/noinit_adaptor.hpp>
+
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/lang/XUnoTunnel.hpp>
+#include <com/sun/star/io/IOException.hpp>
+#include <com/sun/star/io/XStream.hpp>
+#include <com/sun/star/io/XSeekableInputStream.hpp>
+#include <com/sun/star/io/XTruncate.hpp>
+//#include <com/sun/star/uno/XComponentContext.hpp>
+#include <comphelper/bytereader.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <o3tl/safeint.hxx>
+#include <osl/diagnose.h>
+
+#include <string.h>
+#include <vector>
+
+namespace com::sun::star::uno { class XComponentContext; }
+
+using ::cppu::OWeakObject;
+using ::cppu::WeakImplHelper;
+using namespace ::com::sun::star::io;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::osl;
+
+namespace comphelper
+{
+
+namespace {
+
+class UNOMemoryStream :
+ public WeakImplHelper<XServiceInfo, XStream, XSeekableInputStream, XOutputStream, XTruncate, XUnoTunnel>,
+ public comphelper::ByteWriter
+{
+public:
+ UNOMemoryStream();
+
+ // XServiceInfo
+ virtual OUString SAL_CALL getImplementationName() override;
+ virtual sal_Bool SAL_CALL supportsService(const OUString& ServiceName) override;
+ virtual css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override;
+
+ // XStream
+ virtual Reference< XInputStream > SAL_CALL getInputStream( ) override;
+ virtual Reference< XOutputStream > SAL_CALL getOutputStream( ) override;
+
+ // XInputStream
+ virtual sal_Int32 SAL_CALL readBytes( Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead ) override;
+ virtual sal_Int32 SAL_CALL readSomeBytes( Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead ) override;
+ virtual void SAL_CALL skipBytes( sal_Int32 nBytesToSkip ) override;
+ virtual sal_Int32 SAL_CALL available() override;
+ virtual void SAL_CALL closeInput() override;
+
+ // XSeekable
+ virtual void SAL_CALL seek( sal_Int64 location ) override;
+ virtual sal_Int64 SAL_CALL getPosition() override;
+ virtual sal_Int64 SAL_CALL getLength() override;
+
+ // XOutputStream
+ virtual void SAL_CALL writeBytes( const Sequence< sal_Int8 >& aData ) override;
+ virtual void SAL_CALL flush() override;
+ virtual void SAL_CALL closeOutput() override;
+
+ // XTruncate
+ virtual void SAL_CALL truncate() override;
+
+ // XUnoTunnel
+ virtual sal_Int64 SAL_CALL getSomething( const css::uno::Sequence< sal_Int8 >& aIdentifier ) override;
+
+ // comphelper::ByteWriter
+ virtual sal_Int32 writeSomeBytes(const sal_Int8* aData, sal_Int32 nBytesToWrite) override;
+
+private:
+ std::vector< sal_Int8, boost::noinit_adaptor<std::allocator<sal_Int8>> > maData;
+ sal_Int32 mnCursor;
+};
+
+}
+
+UNOMemoryStream::UNOMemoryStream()
+: mnCursor(0)
+{
+ maData.reserve(1 * 1024 * 1024);
+}
+
+// XServiceInfo
+OUString SAL_CALL UNOMemoryStream::getImplementationName()
+{
+ return "com.sun.star.comp.MemoryStream";
+}
+
+sal_Bool SAL_CALL UNOMemoryStream::supportsService(const OUString& ServiceName)
+{
+ return cppu::supportsService(this, ServiceName);
+}
+
+css::uno::Sequence<OUString> SAL_CALL UNOMemoryStream::getSupportedServiceNames()
+{
+ return { "com.sun.star.comp.MemoryStream" };
+}
+
+// XStream
+Reference< XInputStream > SAL_CALL UNOMemoryStream::getInputStream( )
+{
+ return this;
+}
+
+Reference< XOutputStream > SAL_CALL UNOMemoryStream::getOutputStream( )
+{
+ return this;
+}
+
+// XInputStream
+sal_Int32 SAL_CALL UNOMemoryStream::readBytes( Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead )
+{
+ if( nBytesToRead < 0 )
+ throw IOException("nBytesToRead < 0");
+
+ nBytesToRead = std::min( nBytesToRead, available() );
+ aData.realloc( nBytesToRead );
+
+ if( nBytesToRead )
+ {
+ sal_Int8* pData = &(*maData.begin());
+ sal_Int8* pCursor = &(pData[mnCursor]);
+ memcpy( aData.getArray(), pCursor, nBytesToRead );
+
+ mnCursor += nBytesToRead;
+ }
+
+ return nBytesToRead;
+}
+
+sal_Int32 SAL_CALL UNOMemoryStream::readSomeBytes( Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead )
+{
+ return readBytes( aData, nMaxBytesToRead );
+}
+
+void SAL_CALL UNOMemoryStream::skipBytes( sal_Int32 nBytesToSkip )
+{
+ if( nBytesToSkip < 0 )
+ throw IOException("nBytesToSkip < 0");
+
+ mnCursor += std::min( nBytesToSkip, available() );
+}
+
+sal_Int32 SAL_CALL UNOMemoryStream::available()
+{
+ return std::min<sal_Int64>( SAL_MAX_INT32, maData.size() - mnCursor);
+}
+
+void SAL_CALL UNOMemoryStream::closeInput()
+{
+ mnCursor = 0;
+}
+
+// XSeekable
+void SAL_CALL UNOMemoryStream::seek( sal_Int64 location )
+{
+ if( (location < 0) || (location > SAL_MAX_INT32) )
+ throw IllegalArgumentException("this implementation does not support more than 2GB!", static_cast<OWeakObject*>(this), 0 );
+
+ // seek operation should be able to resize the stream
+ if ( o3tl::make_unsigned(location) > maData.size() )
+ maData.resize( static_cast< sal_Int32 >( location ) );
+
+ mnCursor = static_cast< sal_Int32 >( location );
+}
+
+sal_Int64 SAL_CALL UNOMemoryStream::getPosition()
+{
+ return static_cast< sal_Int64 >( mnCursor );
+}
+
+sal_Int64 SAL_CALL UNOMemoryStream::getLength()
+{
+ return static_cast< sal_Int64 >( maData.size() );
+}
+
+// XOutputStream
+void SAL_CALL UNOMemoryStream::writeBytes( const Sequence< sal_Int8 >& aData )
+{
+ const sal_Int32 nBytesToWrite( aData.getLength() );
+ if( !nBytesToWrite )
+ return;
+
+ sal_Int64 nNewSize = static_cast<sal_Int64>(mnCursor) + nBytesToWrite;
+ if( nNewSize > SAL_MAX_INT32 )
+ {
+ OSL_ASSERT(false);
+ throw IOException("this implementation does not support more than 2GB!", static_cast<OWeakObject*>(this) );
+ }
+
+ if( static_cast< sal_Int32 >( nNewSize ) > static_cast< sal_Int32 >( maData.size() ) )
+ maData.resize( nNewSize );
+
+ sal_Int8* pData = &(*maData.begin());
+ sal_Int8* pCursor = &(pData[mnCursor]);
+ memcpy(pCursor, aData.getConstArray(), nBytesToWrite);
+
+ mnCursor += nBytesToWrite;
+}
+
+sal_Int32 UNOMemoryStream::writeSomeBytes( const sal_Int8* pInData, sal_Int32 nBytesToWrite )
+{
+ if( !nBytesToWrite )
+ return 0;
+
+ sal_Int64 nNewSize = static_cast<sal_Int64>(mnCursor) + nBytesToWrite;
+ if( nNewSize > SAL_MAX_INT32 )
+ {
+ OSL_ASSERT(false);
+ throw IOException("this implementation does not support more than 2GB!", static_cast<OWeakObject*>(this) );
+ }
+
+ if( static_cast< sal_Int32 >( nNewSize ) > static_cast< sal_Int32 >( maData.size() ) )
+ maData.resize( nNewSize );
+
+ sal_Int8* pData = &(*maData.begin());
+ sal_Int8* pCursor = &(pData[mnCursor]);
+ // cast to avoid -Werror=class-memaccess
+ memcpy(pCursor, pInData, nBytesToWrite);
+
+ mnCursor += nBytesToWrite;
+ return nBytesToWrite;
+}
+
+void SAL_CALL UNOMemoryStream::flush()
+{
+}
+
+void SAL_CALL UNOMemoryStream::closeOutput()
+{
+ mnCursor = 0;
+}
+
+//XTruncate
+void SAL_CALL UNOMemoryStream::truncate()
+{
+ maData.clear();
+ mnCursor = 0;
+}
+
+sal_Int64 SAL_CALL UNOMemoryStream::getSomething( const css::uno::Sequence< sal_Int8 >& rIdentifier )
+{
+ if (rIdentifier == comphelper::ByteWriter::getUnoTunnelId())
+ return reinterpret_cast<sal_Int64>(static_cast<comphelper::ByteWriter*>(this));
+ return 0;
+}
+
+} // namespace comphelper
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_MemoryStream(
+ css::uno::XComponentContext *,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new ::comphelper::UNOMemoryStream());
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/streaming/oslfile2streamwrap.cxx b/comphelper/source/streaming/oslfile2streamwrap.cxx
new file mode 100644
index 000000000..243634610
--- /dev/null
+++ b/comphelper/source/streaming/oslfile2streamwrap.cxx
@@ -0,0 +1,171 @@
+/* -*- 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 <sal/config.h>
+
+#include <com/sun/star/io/BufferSizeExceededException.hpp>
+#include <com/sun/star/io/NotConnectedException.hpp>
+#include <comphelper/oslfile2streamwrap.hxx>
+#include <o3tl/safeint.hxx>
+#include <osl/file.hxx>
+
+#include <algorithm>
+
+namespace comphelper
+{
+ using namespace osl;
+
+
+OSLInputStreamWrapper::OSLInputStreamWrapper( File& _rFile )
+ : m_pFile(&_rFile)
+{
+}
+
+
+OSLInputStreamWrapper::~OSLInputStreamWrapper()
+{
+}
+
+
+sal_Int32 SAL_CALL OSLInputStreamWrapper::readBytes(css::uno::Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead)
+{
+ if (!m_pFile)
+ throw css::io::NotConnectedException(OUString(), static_cast<css::uno::XWeak*>(this));
+
+ if (nBytesToRead < 0)
+ throw css::io::BufferSizeExceededException(OUString(),static_cast<css::uno::XWeak*>(this));
+
+ aData.realloc(nBytesToRead);
+
+ std::scoped_lock aGuard( m_aMutex );
+
+ sal_uInt64 nRead = 0;
+ FileBase::RC eError = m_pFile->read(static_cast<void*>(aData.getArray()), nBytesToRead, nRead);
+ if (eError != FileBase::E_None)
+ throw css::io::BufferSizeExceededException(OUString(),static_cast<css::uno::XWeak*>(this));
+
+ // If the read character < MaxLength, adjust css::uno::Sequence
+ if (nRead < o3tl::make_unsigned(nBytesToRead))
+ aData.realloc( sal::static_int_cast< sal_Int32 >(nRead) );
+
+ return sal::static_int_cast< sal_Int32 >(nRead);
+}
+
+sal_Int32 SAL_CALL OSLInputStreamWrapper::readSomeBytes(css::uno::Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead)
+{
+ if (!m_pFile)
+ throw css::io::NotConnectedException(OUString(), static_cast<css::uno::XWeak*>(this));
+
+ if (nMaxBytesToRead < 0)
+ throw css::io::BufferSizeExceededException(OUString(),static_cast<css::uno::XWeak*>(this));
+
+ return readBytes(aData, nMaxBytesToRead);
+}
+
+void SAL_CALL OSLInputStreamWrapper::skipBytes(sal_Int32 nBytesToSkip)
+{
+ std::scoped_lock aGuard( m_aMutex );
+ if (!m_pFile)
+ throw css::io::NotConnectedException(OUString(), static_cast<css::uno::XWeak*>(this));
+
+ sal_uInt64 nCurrentPos;
+ FileBase::RC eError = m_pFile->getPos(nCurrentPos);
+ if (eError != FileBase::E_None)
+ throw css::io::NotConnectedException(OUString(), static_cast<css::uno::XWeak*>(this));
+
+ sal_uInt64 nNewPos = nCurrentPos + nBytesToSkip;
+ eError = m_pFile->setPos(osl_Pos_Absolut, nNewPos);
+ if (eError != FileBase::E_None)
+ throw css::io::NotConnectedException(OUString(), static_cast<css::uno::XWeak*>(this));
+}
+
+sal_Int32 SAL_CALL OSLInputStreamWrapper::available()
+{
+ std::scoped_lock aGuard( m_aMutex );
+ if (!m_pFile)
+ throw css::io::NotConnectedException(OUString(), static_cast<css::uno::XWeak*>(this));
+
+ sal_uInt64 nPos;
+ FileBase::RC eError = m_pFile->getPos(nPos);
+ if (eError != FileBase::E_None)
+ throw css::io::NotConnectedException(OUString(), static_cast<css::uno::XWeak*>(this));
+
+ eError = m_pFile->setPos(osl_Pos_End, 0);
+ if (eError != FileBase::E_None)
+ throw css::io::NotConnectedException(OUString(),static_cast<css::uno::XWeak*>(this));
+
+ sal_uInt64 nAvailable;
+ eError = m_pFile->getPos(nAvailable);
+ if (eError != FileBase::E_None)
+ throw css::io::NotConnectedException(OUString(),static_cast<css::uno::XWeak*>(this));
+
+ nAvailable = nAvailable - nPos;
+ eError = m_pFile->setPos(osl_Pos_Absolut, nPos);
+ if (eError != FileBase::E_None)
+ throw css::io::NotConnectedException(OUString(),static_cast<css::uno::XWeak*>(this));
+ return std::min<sal_Int64>(nAvailable, SAL_MAX_INT32);
+}
+
+
+void SAL_CALL OSLInputStreamWrapper::closeInput()
+{
+ if (!m_pFile)
+ throw css::io::NotConnectedException(OUString(), static_cast<css::uno::XWeak*>(this));
+
+ m_pFile->close();
+
+ m_pFile = nullptr;
+}
+
+/*************************************************************************/
+// css::io::XOutputStream
+
+
+OSLOutputStreamWrapper::OSLOutputStreamWrapper(osl::File & _rFile):
+ rFile(_rFile)
+{}
+
+OSLOutputStreamWrapper::~OSLOutputStreamWrapper() {}
+
+void SAL_CALL OSLOutputStreamWrapper::writeBytes(const css::uno::Sequence< sal_Int8 >& aData)
+{
+ sal_uInt64 nWritten;
+ FileBase::RC eError = rFile.write(aData.getConstArray(),aData.getLength(), nWritten);
+ if (eError != FileBase::E_None
+ || nWritten != sal::static_int_cast< sal_uInt32 >(aData.getLength()))
+ {
+ throw css::io::BufferSizeExceededException(OUString(),static_cast<css::uno::XWeak*>(this));
+ }
+}
+
+
+void SAL_CALL OSLOutputStreamWrapper::flush()
+{
+}
+
+
+void SAL_CALL OSLOutputStreamWrapper::closeOutput()
+{
+ rFile.close();
+}
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/streaming/seekableinput.cxx b/comphelper/source/streaming/seekableinput.cxx
new file mode 100644
index 000000000..3508f933e
--- /dev/null
+++ b/comphelper/source/streaming/seekableinput.cxx
@@ -0,0 +1,233 @@
+/* -*- 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 <sal/config.h>
+
+#include <com/sun/star/io/IOException.hpp>
+#include <com/sun/star/io/NotConnectedException.hpp>
+#include <com/sun/star/io/TempFile.hpp>
+#include <com/sun/star/io/XOutputStream.hpp>
+
+
+#include <comphelper/seekableinput.hxx>
+#include <utility>
+
+using namespace ::com::sun::star;
+
+namespace comphelper
+{
+
+const sal_Int32 nConstBufferSize = 32000;
+
+
+static void copyInputToOutput_Impl( const uno::Reference< io::XInputStream >& xIn,
+ const uno::Reference< io::XOutputStream >& xOut )
+{
+ sal_Int32 nRead;
+ uno::Sequence< sal_Int8 > aSequence( nConstBufferSize );
+
+ do
+ {
+ nRead = xIn->readBytes( aSequence, nConstBufferSize );
+ if ( nRead < nConstBufferSize )
+ {
+ uno::Sequence< sal_Int8 > aTempBuf( aSequence.getConstArray(), nRead );
+ xOut->writeBytes( aTempBuf );
+ }
+ else
+ xOut->writeBytes( aSequence );
+ }
+ while ( nRead == nConstBufferSize );
+}
+
+
+OSeekableInputWrapper::OSeekableInputWrapper(
+ uno::Reference< io::XInputStream > xInStream,
+ uno::Reference< uno::XComponentContext > xContext )
+: m_xContext(std::move( xContext ))
+, m_xOriginalStream(std::move( xInStream ))
+{
+ if ( !m_xContext.is() )
+ throw uno::RuntimeException();
+}
+
+
+OSeekableInputWrapper::~OSeekableInputWrapper()
+{
+}
+
+
+uno::Reference< io::XInputStream > OSeekableInputWrapper::CheckSeekableCanWrap(
+ const uno::Reference< io::XInputStream >& xInStream,
+ const uno::Reference< uno::XComponentContext >& rxContext )
+{
+ // check that the stream is seekable and just wrap it if it is not
+ uno::Reference< io::XSeekable > xSeek( xInStream, uno::UNO_QUERY );
+ if ( xSeek.is() )
+ return xInStream;
+
+ return new OSeekableInputWrapper(xInStream, rxContext);
+}
+
+
+void OSeekableInputWrapper::PrepareCopy_Impl()
+{
+ if ( !m_xCopyInput.is() )
+ {
+ if ( !m_xContext.is() )
+ throw uno::RuntimeException();
+
+ uno::Reference< io::XOutputStream > xTempOut(
+ io::TempFile::create(m_xContext),
+ uno::UNO_QUERY_THROW );
+
+ copyInputToOutput_Impl( m_xOriginalStream, xTempOut );
+ xTempOut->closeOutput();
+
+ uno::Reference< io::XSeekable > xTempSeek( xTempOut, uno::UNO_QUERY );
+ if ( xTempSeek.is() )
+ {
+ xTempSeek->seek( 0 );
+ m_xCopyInput.set( xTempOut, uno::UNO_QUERY );
+ if ( m_xCopyInput.is() )
+ m_xCopySeek = xTempSeek;
+ }
+ }
+
+ if ( !m_xCopyInput.is() )
+ throw io::IOException("no m_xCopyInput");
+}
+
+// XInputStream
+
+sal_Int32 SAL_CALL OSeekableInputWrapper::readBytes( uno::Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead )
+{
+ std::scoped_lock aGuard( m_aMutex );
+
+ if ( !m_xOriginalStream.is() )
+ throw io::NotConnectedException();
+
+ PrepareCopy_Impl();
+
+ return m_xCopyInput->readBytes( aData, nBytesToRead );
+}
+
+
+sal_Int32 SAL_CALL OSeekableInputWrapper::readSomeBytes( uno::Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead )
+{
+ std::scoped_lock aGuard( m_aMutex );
+
+ if ( !m_xOriginalStream.is() )
+ throw io::NotConnectedException();
+
+ PrepareCopy_Impl();
+
+ return m_xCopyInput->readSomeBytes( aData, nMaxBytesToRead );
+}
+
+
+void SAL_CALL OSeekableInputWrapper::skipBytes( sal_Int32 nBytesToSkip )
+{
+ std::scoped_lock aGuard( m_aMutex );
+
+ if ( !m_xOriginalStream.is() )
+ throw io::NotConnectedException();
+
+ PrepareCopy_Impl();
+
+ m_xCopyInput->skipBytes( nBytesToSkip );
+}
+
+
+sal_Int32 SAL_CALL OSeekableInputWrapper::available()
+{
+ std::scoped_lock aGuard( m_aMutex );
+
+ if ( !m_xOriginalStream.is() )
+ throw io::NotConnectedException();
+
+ PrepareCopy_Impl();
+
+ return m_xCopyInput->available();
+}
+
+
+void SAL_CALL OSeekableInputWrapper::closeInput()
+{
+ std::scoped_lock aGuard( m_aMutex );
+
+ if ( !m_xOriginalStream.is() )
+ throw io::NotConnectedException();
+
+ m_xOriginalStream->closeInput();
+ m_xOriginalStream.clear();
+
+ if ( m_xCopyInput.is() )
+ {
+ m_xCopyInput->closeInput();
+ m_xCopyInput.clear();
+ }
+
+ m_xCopySeek.clear();
+}
+
+
+// XSeekable
+
+void SAL_CALL OSeekableInputWrapper::seek( sal_Int64 location )
+{
+ std::scoped_lock aGuard( m_aMutex );
+
+ if ( !m_xOriginalStream.is() )
+ throw io::NotConnectedException();
+
+ PrepareCopy_Impl();
+
+ m_xCopySeek->seek( location );
+}
+
+
+sal_Int64 SAL_CALL OSeekableInputWrapper::getPosition()
+{
+ std::scoped_lock aGuard( m_aMutex );
+
+ if ( !m_xOriginalStream.is() )
+ throw io::NotConnectedException();
+
+ PrepareCopy_Impl();
+
+ return m_xCopySeek->getPosition();
+}
+
+
+sal_Int64 SAL_CALL OSeekableInputWrapper::getLength()
+{
+ std::scoped_lock aGuard( m_aMutex );
+
+ if ( !m_xOriginalStream.is() )
+ throw io::NotConnectedException();
+
+ PrepareCopy_Impl();
+
+ return m_xCopySeek->getLength();
+}
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/streaming/seqinputstreamserv.cxx b/comphelper/source/streaming/seqinputstreamserv.cxx
new file mode 100644
index 000000000..5d10029a5
--- /dev/null
+++ b/comphelper/source/streaming/seqinputstreamserv.cxx
@@ -0,0 +1,215 @@
+/* -*- 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 <sal/config.h>
+
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <comphelper/seqstream.hxx>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/io/NotConnectedException.hpp>
+#include <com/sun/star/io/XSeekableInputStream.hpp>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/frame/DoubleInitializationException.hpp>
+#include <mutex>
+
+namespace com::sun::star::uno { class XComponentContext; }
+
+using namespace ::com::sun::star;
+
+namespace {
+
+class SequenceInputStreamService:
+ public ::cppu::WeakImplHelper<
+ lang::XServiceInfo,
+ io::XSeekableInputStream,
+ lang::XInitialization>
+{
+public:
+ explicit SequenceInputStreamService();
+
+ // noncopyable
+ SequenceInputStreamService(const SequenceInputStreamService&) = delete;
+ const SequenceInputStreamService& operator=(const SequenceInputStreamService&) = delete;
+
+ // css::lang::XServiceInfo:
+ virtual OUString SAL_CALL getImplementationName() override;
+ virtual sal_Bool SAL_CALL supportsService( const OUString & ServiceName ) override;
+ virtual uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
+
+ // css::io::XInputStream:
+ virtual ::sal_Int32 SAL_CALL readBytes( uno::Sequence< ::sal_Int8 > & aData, ::sal_Int32 nBytesToRead ) override;
+ virtual ::sal_Int32 SAL_CALL readSomeBytes( uno::Sequence< ::sal_Int8 > & aData, ::sal_Int32 nMaxBytesToRead ) override;
+ virtual void SAL_CALL skipBytes( ::sal_Int32 nBytesToSkip ) override;
+ virtual ::sal_Int32 SAL_CALL available() override;
+ virtual void SAL_CALL closeInput() override;
+
+ // css::io::XSeekable:
+ virtual void SAL_CALL seek( ::sal_Int64 location ) override;
+ virtual ::sal_Int64 SAL_CALL getPosition() override;
+ virtual ::sal_Int64 SAL_CALL getLength() override;
+
+ // css::lang::XInitialization:
+ virtual void SAL_CALL initialize( const uno::Sequence< css::uno::Any > & aArguments ) override;
+
+private:
+ virtual ~SequenceInputStreamService() override {}
+
+
+ std::mutex m_aMutex;
+ bool m_bInitialized;
+ uno::Reference< io::XInputStream > m_xInputStream;
+ uno::Reference< io::XSeekable > m_xSeekable;
+};
+
+SequenceInputStreamService::SequenceInputStreamService()
+: m_bInitialized( false )
+{}
+
+// com.sun.star.uno.XServiceInfo:
+OUString SAL_CALL SequenceInputStreamService::getImplementationName()
+{
+ return "com.sun.star.comp.SequenceInputStreamService";
+}
+
+sal_Bool SAL_CALL SequenceInputStreamService::supportsService( OUString const & serviceName )
+{
+ return cppu::supportsService(this, serviceName);
+}
+
+uno::Sequence< OUString > SAL_CALL SequenceInputStreamService::getSupportedServiceNames()
+{
+ return { "com.sun.star.io.SequenceInputStream" };
+}
+
+// css::io::XInputStream:
+::sal_Int32 SAL_CALL SequenceInputStreamService::readBytes( uno::Sequence< ::sal_Int8 > & aData, ::sal_Int32 nBytesToRead )
+{
+ std::scoped_lock aGuard( m_aMutex );
+ if ( !m_xInputStream.is() )
+ throw io::NotConnectedException();
+
+ return m_xInputStream->readBytes( aData, nBytesToRead );
+}
+
+::sal_Int32 SAL_CALL SequenceInputStreamService::readSomeBytes( uno::Sequence< ::sal_Int8 > & aData, ::sal_Int32 nMaxBytesToRead )
+{
+ std::scoped_lock aGuard( m_aMutex );
+ if ( !m_xInputStream.is() )
+ throw io::NotConnectedException();
+
+ return m_xInputStream->readSomeBytes( aData, nMaxBytesToRead );
+}
+
+void SAL_CALL SequenceInputStreamService::skipBytes( ::sal_Int32 nBytesToSkip )
+{
+ std::scoped_lock aGuard( m_aMutex );
+ if ( !m_xInputStream.is() )
+ throw io::NotConnectedException();
+
+ return m_xInputStream->skipBytes( nBytesToSkip );
+}
+
+::sal_Int32 SAL_CALL SequenceInputStreamService::available()
+{
+ std::scoped_lock aGuard( m_aMutex );
+ if ( !m_xInputStream.is() )
+ throw io::NotConnectedException();
+
+ return m_xInputStream->available();
+}
+
+void SAL_CALL SequenceInputStreamService::closeInput()
+{
+ std::scoped_lock aGuard( m_aMutex );
+ if ( !m_xInputStream.is() )
+ throw io::NotConnectedException();
+
+ m_xInputStream->closeInput();
+ m_xInputStream.clear();
+ m_xSeekable.clear();
+}
+
+// css::io::XSeekable:
+void SAL_CALL SequenceInputStreamService::seek( ::sal_Int64 location )
+{
+ std::scoped_lock aGuard( m_aMutex );
+ if ( !m_xSeekable.is() )
+ throw io::NotConnectedException();
+
+ m_xSeekable->seek( location );
+}
+
+::sal_Int64 SAL_CALL SequenceInputStreamService::getPosition()
+{
+ std::scoped_lock aGuard( m_aMutex );
+ if ( !m_xSeekable.is() )
+ throw io::NotConnectedException();
+
+ return m_xSeekable->getPosition();
+}
+
+::sal_Int64 SAL_CALL SequenceInputStreamService::getLength()
+{
+ std::scoped_lock aGuard( m_aMutex );
+ if ( !m_xSeekable.is() )
+ throw io::NotConnectedException();
+
+ return m_xSeekable->getLength();
+}
+
+// css::lang::XInitialization:
+void SAL_CALL SequenceInputStreamService::initialize( const uno::Sequence< css::uno::Any > & aArguments )
+{
+ std::scoped_lock aGuard( m_aMutex );
+ if ( m_bInitialized )
+ throw frame::DoubleInitializationException();
+
+ if ( aArguments.getLength() != 1 )
+ throw lang::IllegalArgumentException( "Wrong number of arguments!",
+ static_cast< ::cppu::OWeakObject* >(this),
+ 1 );
+
+ uno::Sequence< sal_Int8 > aSeq;
+ if ( !(aArguments[0] >>= aSeq) )
+ throw lang::IllegalArgumentException( "Unexpected type of argument!",
+ static_cast< ::cppu::OWeakObject* >(this),
+ 1 );
+
+ uno::Reference< io::XInputStream > xInputStream(
+ static_cast< ::cppu::OWeakObject* >( new ::comphelper::SequenceInputStream( aSeq ) ),
+ uno::UNO_QUERY_THROW );
+ uno::Reference< io::XSeekable > xSeekable( xInputStream, uno::UNO_QUERY_THROW );
+ m_xInputStream = xInputStream;
+ m_xSeekable = xSeekable;
+ m_bInitialized = true;
+}
+
+} // anonymous namespace
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_SequenceInputStreamService(
+ css::uno::XComponentContext *,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new SequenceInputStreamService());
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/streaming/seqoutputstreamserv.cxx b/comphelper/source/streaming/seqoutputstreamserv.cxx
new file mode 100644
index 000000000..19ef79002
--- /dev/null
+++ b/comphelper/source/streaming/seqoutputstreamserv.cxx
@@ -0,0 +1,144 @@
+/* -*- 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 <sal/config.h>
+
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <comphelper/seqstream.hxx>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/io/NotConnectedException.hpp>
+#include <com/sun/star/io/XSequenceOutputStream.hpp>
+#include <mutex>
+
+namespace com::sun::star::uno { class XComponentContext; }
+
+using namespace ::com::sun::star;
+
+
+namespace {
+
+class SequenceOutputStreamService:
+ public cppu::WeakImplHelper<lang::XServiceInfo, io::XSequenceOutputStream>
+{
+public:
+ explicit SequenceOutputStreamService();
+
+ // noncopyable
+ SequenceOutputStreamService(const SequenceOutputStreamService&) = delete;
+ const SequenceOutputStreamService& operator=(const SequenceOutputStreamService&) = delete;
+
+ // css::lang::XServiceInfo:
+ virtual OUString SAL_CALL getImplementationName() override;
+ virtual sal_Bool SAL_CALL supportsService( const OUString & ServiceName ) override;
+ virtual uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
+
+ // css::io::XOutputStream:
+ virtual void SAL_CALL writeBytes( const uno::Sequence< ::sal_Int8 > & aData ) override;
+ virtual void SAL_CALL flush() override;
+ virtual void SAL_CALL closeOutput() override;
+
+ // css::io::XSequenceOutputStream:
+ virtual uno::Sequence< ::sal_Int8 > SAL_CALL getWrittenBytes( ) override;
+
+private:
+ virtual ~SequenceOutputStreamService() override {};
+
+
+ std::mutex m_aMutex;
+ // WARNING: dtor of m_xOutputStream writes into m_aSequence so that must live longer!
+ uno::Sequence< ::sal_Int8 > m_aSequence;
+ uno::Reference< io::XOutputStream > m_xOutputStream;
+};
+SequenceOutputStreamService::SequenceOutputStreamService()
+{
+ m_xOutputStream.set( static_cast < ::cppu::OWeakObject* >( new ::comphelper::OSequenceOutputStream( m_aSequence ) ), uno::UNO_QUERY_THROW );
+}
+
+// com.sun.star.uno.XServiceInfo:
+OUString SAL_CALL SequenceOutputStreamService::getImplementationName()
+{
+ return "com.sun.star.comp.SequenceOutputStreamService";
+}
+
+sal_Bool SAL_CALL SequenceOutputStreamService::supportsService( OUString const & serviceName )
+{
+ return cppu::supportsService(this, serviceName);
+}
+
+uno::Sequence< OUString > SAL_CALL SequenceOutputStreamService::getSupportedServiceNames()
+{
+ return { "com.sun.star.io.SequenceOutputStream" };
+}
+
+// css::io::XOutputStream:
+void SAL_CALL SequenceOutputStreamService::writeBytes( const uno::Sequence< ::sal_Int8 > & aData )
+{
+ std::scoped_lock aGuard( m_aMutex );
+ if ( !m_xOutputStream.is() )
+ throw io::NotConnectedException();
+
+ m_xOutputStream->writeBytes( aData );
+}
+
+void SAL_CALL SequenceOutputStreamService::flush()
+{
+ std::scoped_lock aGuard( m_aMutex );
+ if ( !m_xOutputStream.is() )
+ throw io::NotConnectedException();
+
+ m_xOutputStream->flush();
+};
+
+void SAL_CALL SequenceOutputStreamService::closeOutput()
+{
+ std::scoped_lock aGuard( m_aMutex );
+ if ( !m_xOutputStream.is() )
+ throw io::NotConnectedException();
+
+ m_xOutputStream->flush();
+ m_xOutputStream->closeOutput();
+ m_xOutputStream.clear();
+}
+
+// css::io::XSequenceOutputStream:
+uno::Sequence< ::sal_Int8 > SAL_CALL SequenceOutputStreamService::getWrittenBytes()
+{
+ std::scoped_lock aGuard( m_aMutex );
+
+ if (m_xOutputStream.is())
+ {
+ m_xOutputStream->flush();
+ }
+ // else: no exception, just return the finished sequence
+
+ return m_aSequence;
+}
+
+} // anonymous namespace
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_SequenceOutputStreamService(
+ css::uno::XComponentContext *,
+ css::uno::Sequence<css::uno::Any> const &)
+{
+ return cppu::acquire(new SequenceOutputStreamService());
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/streaming/seqstream.cxx b/comphelper/source/streaming/seqstream.cxx
new file mode 100644
index 000000000..1f37a7967
--- /dev/null
+++ b/comphelper/source/streaming/seqstream.cxx
@@ -0,0 +1,247 @@
+/* -*- 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 <sal/config.h>
+
+#include <com/sun/star/io/BufferSizeExceededException.hpp>
+#include <com/sun/star/io/NotConnectedException.hpp>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <comphelper/seqstream.hxx>
+
+#include <osl/diagnose.h>
+
+namespace comphelper
+{
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::io;
+using namespace ::com::sun::star::uno;
+using namespace ::osl;
+
+
+
+
+SequenceInputStream::SequenceInputStream(
+ css::uno::Sequence<sal_Int8> const & rData)
+: m_aData(rData)
+, m_nPos(0)
+{
+}
+
+// checks if closed, returns available size, not mutex-protected
+
+inline sal_Int32 SequenceInputStream::avail()
+{
+ if (m_nPos == -1)
+ throw NotConnectedException(OUString(), *this);
+
+ return m_aData.getLength() - m_nPos;
+}
+
+// css::io::XInputStream
+
+sal_Int32 SAL_CALL SequenceInputStream::readBytes( Sequence<sal_Int8>& aData, sal_Int32 nBytesToRead )
+{
+ if (nBytesToRead < 0)
+ throw BufferSizeExceededException(OUString(),*this);
+
+ std::scoped_lock aGuard( m_aMutex );
+
+ sal_Int32 nAvail = avail();
+
+ if (nAvail < nBytesToRead)
+ nBytesToRead = nAvail;
+
+ aData.realloc(nBytesToRead);
+ memcpy(aData.getArray(), m_aData.getConstArray() + m_nPos, nBytesToRead);
+ m_nPos += nBytesToRead;
+
+ return nBytesToRead;
+}
+
+sal_Int32 SequenceInputStream::readSomeBytes( sal_Int8* pData, sal_Int32 nBytesToRead )
+{
+ if (nBytesToRead < 0)
+ throw BufferSizeExceededException(OUString(),*this);
+
+ std::scoped_lock aGuard( m_aMutex );
+
+ sal_Int32 nAvail = avail();
+
+ if (nAvail < nBytesToRead)
+ nBytesToRead = nAvail;
+
+ memcpy(pData, m_aData.getConstArray() + m_nPos, nBytesToRead);
+ m_nPos += nBytesToRead;
+
+ return nBytesToRead;
+}
+
+sal_Int64 SAL_CALL SequenceInputStream::getSomething( const css::uno::Sequence< sal_Int8 >& rIdentifier )
+{
+ if (rIdentifier == comphelper::ByteReader::getUnoTunnelId())
+ return reinterpret_cast<sal_Int64>(static_cast<comphelper::ByteReader*>(this));
+ return 0;
+}
+
+sal_Int32 SAL_CALL SequenceInputStream::readSomeBytes( Sequence<sal_Int8>& aData, sal_Int32 nMaxBytesToRead )
+{
+ // all data is available at once
+ return readBytes(aData, nMaxBytesToRead);
+}
+
+
+void SAL_CALL SequenceInputStream::skipBytes( sal_Int32 nBytesToSkip )
+{
+ if (nBytesToSkip < 0)
+ throw BufferSizeExceededException(OUString(),*this);
+
+ std::scoped_lock aGuard( m_aMutex );
+
+ sal_Int32 nAvail = avail();
+
+ if (nAvail < nBytesToSkip)
+ nBytesToSkip = nAvail;
+
+ m_nPos += nBytesToSkip;
+}
+
+
+sal_Int32 SAL_CALL SequenceInputStream::available( )
+{
+ std::scoped_lock aGuard( m_aMutex );
+
+ return avail();
+}
+
+
+void SAL_CALL SequenceInputStream::closeInput( )
+{
+ std::scoped_lock aGuard( m_aMutex );
+
+ if (m_nPos == -1)
+ throw NotConnectedException(OUString(), *this);
+
+ m_nPos = -1;
+}
+
+void SAL_CALL SequenceInputStream::seek( sal_Int64 location )
+{
+ if ( location > m_aData.getLength() || location < 0 || location > SAL_MAX_INT32 )
+ throw IllegalArgumentException("bad location", static_cast<cppu::OWeakObject*>(this), 1);
+ std::scoped_lock aGuard( m_aMutex );
+ m_nPos = static_cast<sal_Int32>(location);
+}
+
+sal_Int64 SAL_CALL SequenceInputStream::getPosition()
+{
+ std::scoped_lock aGuard( m_aMutex );
+ return m_nPos;
+}
+
+sal_Int64 SAL_CALL SequenceInputStream::getLength( )
+{
+ std::scoped_lock aGuard( m_aMutex );
+ return m_aData.getLength();
+}
+
+
+OSequenceOutputStream::OSequenceOutputStream(Sequence< sal_Int8 >& _rSeq, double _nResizeFactor, sal_Int32 _nMinimumResize)
+ :m_rSequence(_rSeq)
+ ,m_nResizeFactor(_nResizeFactor)
+ ,m_nMinimumResize(_nMinimumResize)
+ ,m_nSize(0) // starting at position 0
+ ,m_bConnected(true)
+{
+ OSL_ENSURE(m_nResizeFactor > 1, "OSequenceOutputStream::OSequenceOutputStream : invalid resize factor !");
+
+ if (m_nResizeFactor <= 1)
+ m_nResizeFactor = 1.3;
+}
+
+
+void SAL_CALL OSequenceOutputStream::writeBytes( const Sequence< sal_Int8 >& _rData )
+{
+ std::scoped_lock aGuard(m_aMutex);
+ if (!m_bConnected)
+ throw NotConnectedException();
+
+ // ensure the sequence has enough space left
+ if (m_nSize + _rData.getLength() > m_rSequence.getLength())
+ {
+ sal_Int32 nCurrentLength = m_rSequence.getLength();
+ sal_Int32 nNewLength = static_cast< sal_Int32 >(
+ nCurrentLength * m_nResizeFactor);
+
+ if (m_nMinimumResize > nNewLength - nCurrentLength)
+ // we have a minimum so it's not too inefficient for small sequences and small write requests
+ nNewLength = nCurrentLength + m_nMinimumResize;
+
+ if (nNewLength < m_nSize + _rData.getLength())
+ { // it's not enough... the data would not fit
+
+ // let's take the double amount of the length of the data to be written, as the next write
+ // request could be as large as this one
+ sal_Int32 nNewGrowth = _rData.getLength() * 2;
+ nNewLength = nCurrentLength + nNewGrowth;
+ }
+
+ // round it off to the next multiple of 4...
+ nNewLength = (nNewLength + 3) / 4 * 4;
+
+ m_rSequence.realloc(nNewLength);
+ }
+
+ OSL_ENSURE(m_rSequence.getLength() >= m_nSize + _rData.getLength(),
+ "ooops ... the realloc algorithm seems to be wrong :( !");
+
+ memcpy(m_rSequence.getArray() + m_nSize, _rData.getConstArray(), _rData.getLength());
+ m_nSize += _rData.getLength();
+}
+
+
+void SAL_CALL OSequenceOutputStream::flush( )
+{
+ std::scoped_lock aGuard(m_aMutex);
+ if (!m_bConnected)
+ throw NotConnectedException();
+
+ // cut the sequence to the real size
+ m_rSequence.realloc(m_nSize);
+}
+
+void OSequenceOutputStream::finalizeOutput()
+{
+ // cut the sequence to the real size
+ m_rSequence.realloc(m_nSize);
+ // and don't allow any further accesses
+ m_bConnected = false;
+}
+
+void SAL_CALL OSequenceOutputStream::closeOutput()
+{
+ std::scoped_lock aGuard(m_aMutex);
+ if (!m_bConnected)
+ throw NotConnectedException();
+
+ finalizeOutput();
+}
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/streaming/streamsection.cxx b/comphelper/source/streaming/streamsection.cxx
new file mode 100644
index 000000000..b03df8ab7
--- /dev/null
+++ b/comphelper/source/streaming/streamsection.cxx
@@ -0,0 +1,91 @@
+/* -*- 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 <comphelper/streamsection.hxx>
+#include <com/sun/star/io/XMarkableStream.hpp>
+#include <com/sun/star/io/XDataInputStream.hpp>
+#include <com/sun/star/io/XDataOutputStream.hpp>
+#include <osl/diagnose.h>
+
+namespace comphelper
+{
+
+
+OStreamSection::OStreamSection(const css::uno::Reference< css::io::XDataInputStream >& _rxInput)
+ :m_xMarkStream(_rxInput, css::uno::UNO_QUERY)
+ ,m_xInStream(_rxInput)
+ ,m_nBlockStart(-1)
+ ,m_nBlockLen(-1)
+{
+ OSL_ENSURE(m_xInStream.is() && m_xMarkStream.is(), "OStreamSection::OStreamSection : invalid argument !");
+ if (m_xInStream.is() && m_xMarkStream.is())
+ {
+ m_nBlockLen = _rxInput->readLong();
+ m_nBlockStart = m_xMarkStream->createMark();
+ }
+}
+
+
+OStreamSection::OStreamSection(const css::uno::Reference< css::io::XDataOutputStream >& _rxOutput)
+ :m_xMarkStream(_rxOutput, css::uno::UNO_QUERY)
+ ,m_xOutStream(_rxOutput)
+ ,m_nBlockStart(-1)
+ ,m_nBlockLen(-1)
+{
+ OSL_ENSURE(m_xOutStream.is() && m_xMarkStream.is(), "OStreamSection::OStreamSection : invalid argument !");
+ if (m_xOutStream.is() && m_xMarkStream.is())
+ {
+ m_nBlockStart = m_xMarkStream->createMark();
+ m_nBlockLen = 0;
+ m_xOutStream->writeLong(m_nBlockLen);
+ }
+}
+
+
+OStreamSection::~OStreamSection()
+{
+ try
+ { // don't allow any exceptions to leave this block, this may be called during the stack unwinding of an exception
+ // handling routing
+ if (m_xInStream.is() && m_xMarkStream.is())
+ { // we're working on an input stream
+ m_xMarkStream->jumpToMark(m_nBlockStart);
+ m_xInStream->skipBytes(m_nBlockLen);
+ m_xMarkStream->deleteMark(m_nBlockStart);
+ }
+ else if (m_xOutStream.is() && m_xMarkStream.is())
+ {
+ sal_Int32 nRealBlockLength = m_xMarkStream->offsetToMark(m_nBlockStart) - sizeof(m_nBlockLen);
+ m_nBlockLen = nRealBlockLength;
+ m_xMarkStream->jumpToMark(m_nBlockStart);
+ m_xOutStream->writeLong(m_nBlockLen);
+ m_xMarkStream->jumpToFurthest();
+ m_xMarkStream->deleteMark(m_nBlockStart);
+ }
+ }
+ catch(const css::uno::Exception&)
+ {
+ }
+}
+
+
+} // namespace comphelper
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/windows/windows_process.cxx b/comphelper/source/windows/windows_process.cxx
new file mode 100644
index 000000000..7588bae02
--- /dev/null
+++ b/comphelper/source/windows/windows_process.cxx
@@ -0,0 +1,262 @@
+/* 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/. */
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+#include <cstring>
+#include <wchar.h>
+
+#include <comphelper/windowsStart.hxx>
+
+// Needed for CreateEnvironmentBlock
+#include <userenv.h>
+#pragma comment(lib, "userenv.lib")
+
+/**
+ * Get the length that the string will take and takes into account the
+ * additional length if the string needs to be quoted and if characters need to
+ * be escaped.
+ */
+static int ArgStrLen(const wchar_t *s)
+{
+ int i = wcslen(s);
+ bool hasDoubleQuote = wcschr(s, L'"') != nullptr;
+ // Only add doublequotes if the string contains a space or a tab
+ bool addDoubleQuotes = wcspbrk(s, L" \t") != nullptr;
+
+ if (addDoubleQuotes)
+ {
+ i += 2; // initial and final doublequote
+ }
+
+ if (hasDoubleQuote)
+ {
+ int backslashes = 0;
+ while (*s)
+ {
+ if (*s == '\\')
+ {
+ ++backslashes;
+ }
+ else
+ {
+ if (*s == '"')
+ {
+ // Escape the doublequote and all backslashes preceding the doublequote
+ i += backslashes + 1;
+ }
+
+ backslashes = 0;
+ }
+
+ ++s;
+ }
+ }
+
+ return i;
+}
+
+/**
+ * Copy string "s" to string "d", quoting the argument as appropriate and
+ * escaping doublequotes along with any backslashes that immediately precede
+ * doublequotes.
+ * The CRT parses this to retrieve the original argc/argv that we meant,
+ * see STDARGV.C in the MSVC CRT sources.
+ *
+ * @return the end of the string
+ */
+static wchar_t* ArgToString(wchar_t *d, const wchar_t *s)
+{
+ bool hasDoubleQuote = wcschr(s, L'"') != nullptr;
+ // Only add doublequotes if the string contains a space or a tab
+ bool addDoubleQuotes = wcspbrk(s, L" \t") != nullptr;
+
+ if (addDoubleQuotes)
+ {
+ *d = '"'; // initial doublequote
+ ++d;
+ }
+
+ if (hasDoubleQuote)
+ {
+ int backslashes = 0;
+ while (*s)
+ {
+ if (*s == '\\')
+ {
+ ++backslashes;
+ }
+ else
+ {
+ if (*s == '"')
+ {
+ // Escape the doublequote and all backslashes preceding the doublequote
+ for (int i = 0; i <= backslashes; ++i)
+ {
+ *d = '\\';
+ ++d;
+ }
+ }
+
+ backslashes = 0;
+ }
+
+ *d = *s;
+ ++d;
+ ++s;
+ }
+ }
+ else
+ {
+ wcscpy(d, s);
+ d += wcslen(s);
+ }
+
+ if (addDoubleQuotes)
+ {
+ *d = '"'; // final doublequote
+ ++d;
+ }
+
+ return d;
+}
+
+/**
+ * Creates a command line from a list of arguments. The returned
+ * string is allocated with "malloc" and should be "free"d.
+ *
+ * argv is UTF8
+ */
+wchar_t*
+MakeCommandLine(int argc, wchar_t **argv)
+{
+ int i;
+ int len = 0;
+
+ // The + 1 of the last argument handles the allocation for null termination
+ for (i = 0; i < argc && argv[i]; ++i)
+ len += ArgStrLen(argv[i]) + 1;
+
+ // Protect against callers that pass 0 arguments
+ if (len == 0)
+ len = 1;
+
+ wchar_t *s = static_cast<wchar_t*>(malloc(len * sizeof(wchar_t)));
+ if (!s)
+ return nullptr;
+
+ wchar_t *c = s;
+ for (i = 0; i < argc && argv[i]; ++i)
+ {
+ c = ArgToString(c, argv[i]);
+ if (i + 1 != argc)
+ {
+ *c = ' ';
+ ++c;
+ }
+ }
+
+ *c = '\0';
+
+ return s;
+}
+
+BOOL
+WinLaunchChild(const wchar_t *exePath,
+ int argc,
+ wchar_t **argv,
+ HANDLE userToken,
+ HANDLE *hProcess)
+{
+ wchar_t *cl;
+ bool ok;
+
+ cl = MakeCommandLine(argc, argv);
+ if (!cl)
+ {
+ return FALSE;
+ }
+
+ STARTUPINFOW si;
+ std::memset(&si, 0, sizeof si);
+ si.cb = sizeof(STARTUPINFOW);
+ si.lpDesktop = const_cast<LPWSTR>(L"winsta0\\Default");
+ PROCESS_INFORMATION pi;
+ std::memset(&pi, 0, sizeof pi);
+
+ if (userToken == nullptr)
+ {
+ ok = CreateProcessW(exePath,
+ cl,
+ nullptr, // no special security attributes
+ nullptr, // no special thread attributes
+ FALSE, // don't inherit filehandles
+ 0, // creation flags
+ nullptr, // inherit my environment
+ nullptr, // use my current directory
+ &si,
+ &pi);
+ }
+ else
+ {
+ // Create an environment block for the process we're about to start using
+ // the user's token.
+ LPVOID environmentBlock = nullptr;
+ if (!CreateEnvironmentBlock(&environmentBlock, userToken, TRUE))
+ {
+ environmentBlock = nullptr;
+ }
+
+ ok = CreateProcessAsUserW(userToken,
+ exePath,
+ cl,
+ nullptr, // no special security attributes
+ nullptr, // no special thread attributes
+ FALSE, // don't inherit filehandles
+ 0, // creation flags
+ environmentBlock,
+ nullptr, // use my current directory
+ &si,
+ &pi);
+
+ if (environmentBlock)
+ {
+ DestroyEnvironmentBlock(environmentBlock);
+ }
+ }
+
+ if (ok)
+ {
+ if (hProcess)
+ {
+ *hProcess = pi.hProcess; // the caller now owns the HANDLE
+ }
+ else
+ {
+ CloseHandle(pi.hProcess);
+ }
+ CloseHandle(pi.hThread);
+ }
+ else
+ {
+ LPVOID lpMsgBuf = nullptr;
+ FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+ FORMAT_MESSAGE_FROM_SYSTEM |
+ FORMAT_MESSAGE_IGNORE_INSERTS,
+ nullptr,
+ GetLastError(),
+ MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+ reinterpret_cast<LPWSTR>(&lpMsgBuf),
+ 0,
+ nullptr);
+ wprintf(L"Error restarting: %s\n", lpMsgBuf ? lpMsgBuf : L"(null)");
+ if (lpMsgBuf)
+ HeapFree(GetProcessHeap(), 0, lpMsgBuf);
+ }
+
+ free(cl);
+
+ return ok;
+}
diff --git a/comphelper/source/xml/attributelist.cxx b/comphelper/source/xml/attributelist.cxx
new file mode 100644
index 000000000..a02c82f69
--- /dev/null
+++ b/comphelper/source/xml/attributelist.cxx
@@ -0,0 +1,73 @@
+/* -*- 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 <comphelper/attributelist.hxx>
+
+using namespace osl;
+using namespace com::sun::star;
+
+
+namespace comphelper {
+
+OUString SAL_CALL AttributeList::getTypeByName( const OUString& sName )
+{
+ for (auto const& attribute : mAttributes)
+ {
+ if( attribute.sName == sName ) {
+ return attribute.sType;
+ }
+ }
+ return OUString();
+}
+
+OUString SAL_CALL AttributeList::getValueByName(const OUString& sName)
+{
+ for (auto const& attribute : mAttributes)
+ {
+ if( attribute.sName == sName ) {
+ return attribute.sValue;
+ }
+ }
+ return OUString();
+}
+
+AttributeList::AttributeList()
+{
+ // performance improvement during adding
+ mAttributes.reserve(20);
+}
+
+AttributeList::AttributeList(const AttributeList &r)
+ : cppu::WeakImplHelper<XAttributeList, XCloneable>(r)
+{
+ mAttributes = r.mAttributes;
+}
+
+AttributeList::~AttributeList()
+{
+}
+
+css::uno::Reference< css::util::XCloneable > AttributeList::createClone()
+{
+ return new AttributeList( *this );
+}
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/xml/ofopxmlhelper.cxx b/comphelper/source/xml/ofopxmlhelper.cxx
new file mode 100644
index 000000000..52f6c6356
--- /dev/null
+++ b/comphelper/source/xml/ofopxmlhelper.cxx
@@ -0,0 +1,493 @@
+/* -*- 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 <comphelper/ofopxmlhelper.hxx>
+#include <comphelper/attributelist.hxx>
+
+#include <cppuhelper/implbase.hxx>
+#include <rtl/ref.hxx>
+
+#include <com/sun/star/beans/StringPair.hpp>
+#include <com/sun/star/xml/sax/Parser.hpp>
+#include <com/sun/star/xml/sax/XDocumentHandler.hpp>
+#include <com/sun/star/xml/sax/SAXException.hpp>
+#include <com/sun/star/xml/sax/Writer.hpp>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <vector>
+
+#define RELATIONINFO_FORMAT 0
+#define CONTENTTYPE_FORMAT 1
+#define FORMAT_MAX_ID CONTENTTYPE_FORMAT
+
+using namespace ::com::sun::star;
+
+namespace comphelper {
+
+namespace {
+
+// this helper class is designed to allow to parse ContentType- and Relationship-related information from OfficeOpenXML format
+class OFOPXMLHelper_Impl
+ : public cppu::WeakImplHelper< css::xml::sax::XDocumentHandler >
+{
+ sal_uInt16 const m_nFormat; // which format to parse
+
+ css::uno::Sequence< css::uno::Sequence< css::beans::StringPair > > m_aResultSeq;
+ std::vector< OUString > m_aElementsSeq; // stack of elements being parsed
+
+
+public:
+ css::uno::Sequence< css::uno::Sequence< css::beans::StringPair > > const & GetParsingResult() const;
+
+ explicit OFOPXMLHelper_Impl( sal_uInt16 nFormat ); // must not be created directly
+
+ // XDocumentHandler
+ virtual void SAL_CALL startDocument() override;
+ virtual void SAL_CALL endDocument() override;
+ virtual void SAL_CALL startElement( const OUString& aName, const css::uno::Reference< css::xml::sax::XAttributeList >& xAttribs ) override;
+ virtual void SAL_CALL endElement( const OUString& aName ) override;
+ virtual void SAL_CALL characters( const OUString& aChars ) override;
+ virtual void SAL_CALL ignorableWhitespace( const OUString& aWhitespaces ) override;
+ virtual void SAL_CALL processingInstruction( const OUString& aTarget, const OUString& aData ) override;
+ virtual void SAL_CALL setDocumentLocator( const css::uno::Reference< css::xml::sax::XLocator >& xLocator ) override;
+};
+
+}
+
+namespace OFOPXMLHelper {
+
+/// @throws css::uno::Exception
+static uno::Sequence<uno::Sequence< beans::StringPair>> ReadSequence_Impl(
+ const uno::Reference<io::XInputStream>& xInStream,
+ const OUString& aStringID, sal_uInt16 nFormat,
+ const uno::Reference<uno::XComponentContext>& xContext);
+
+uno::Sequence< uno::Sequence< beans::StringPair > > ReadRelationsInfoSequence(
+ const uno::Reference< io::XInputStream >& xInStream,
+ std::u16string_view aStreamName,
+ const uno::Reference< uno::XComponentContext >& rContext )
+{
+ OUString aStringID = OUString::Concat("_rels/") + aStreamName;
+ return ReadSequence_Impl( xInStream, aStringID, RELATIONINFO_FORMAT, rContext );
+}
+
+
+uno::Sequence< uno::Sequence< beans::StringPair > > ReadContentTypeSequence(
+ const uno::Reference< io::XInputStream >& xInStream,
+ const uno::Reference< uno::XComponentContext >& rContext )
+{
+ return ReadSequence_Impl( xInStream, "[Content_Types].xml", CONTENTTYPE_FORMAT, rContext );
+}
+
+OUString GetContentTypeByName(
+ const css::uno::Sequence<css::uno::Sequence<css::beans::StringPair>>& rContentTypes,
+ const OUString& rFilename)
+{
+ if (rContentTypes.getLength() < 2)
+ {
+ return OUString();
+ }
+
+ const uno::Sequence<beans::StringPair>& rDefaults = rContentTypes[0];
+ const uno::Sequence<beans::StringPair>& rOverrides = rContentTypes[1];
+
+ // Find the extension and use it to get the type.
+ const sal_Int32 nDotOffset = rFilename.lastIndexOf('.');
+ const OUString aExt = (nDotOffset >= 0 ? rFilename.copy(nDotOffset + 1) : rFilename); // Skip the dot.
+
+ const std::vector<OUString> aNames = { aExt, "/" + rFilename };
+ for (const OUString& aName : aNames)
+ {
+ const auto it1 = std::find_if(rOverrides.begin(), rOverrides.end(), [&aName](const beans::StringPair& rPair)
+ { return rPair.First == aName; });
+ if (it1 != rOverrides.end())
+ return it1->Second;
+
+ const auto it2 = std::find_if(rDefaults.begin(), rDefaults.end(), [&aName](const beans::StringPair& rPair)
+ { return rPair.First == aName; });
+ if (it2 != rDefaults.end())
+ return it2->Second;
+ }
+
+ return OUString();
+}
+
+void WriteRelationsInfoSequence(
+ const uno::Reference< io::XOutputStream >& xOutStream,
+ const uno::Sequence< uno::Sequence< beans::StringPair > >& aSequence,
+ const uno::Reference< uno::XComponentContext >& rContext )
+{
+ if ( !xOutStream.is() )
+ throw uno::RuntimeException();
+
+ uno::Reference< css::xml::sax::XWriter > xWriter = css::xml::sax::Writer::create(rContext);
+
+ xWriter->setOutputStream( xOutStream );
+
+ OUString aRelListElement( "Relationships" );
+ OUString aRelElement( "Relationship" );
+ OUString aCDATAString( "CDATA" );
+ OUString aWhiteSpace( " " );
+
+ // write the namespace
+ rtl::Reference<AttributeList> pRootAttrList = new AttributeList;
+ pRootAttrList->AddAttribute(
+ "xmlns",
+ aCDATAString,
+ "http://schemas.openxmlformats.org/package/2006/relationships" );
+
+ xWriter->startDocument();
+ xWriter->startElement( aRelListElement, pRootAttrList );
+
+ for ( const auto & i : aSequence )
+ {
+ rtl::Reference<AttributeList> pAttrList = new AttributeList;
+ for( const beans::StringPair & pair : i )
+ {
+ if ( !(pair.First == "Id"
+ || pair.First == "Type"
+ || pair.First == "TargetMode"
+ || pair.First == "Target") )
+ {
+ // TODO/LATER: should the extensions be allowed?
+ throw lang::IllegalArgumentException();
+ }
+ pAttrList->AddAttribute( pair.First, aCDATAString, pair.Second );
+ }
+
+ xWriter->startElement( aRelElement, pAttrList );
+ xWriter->ignorableWhitespace( aWhiteSpace );
+ xWriter->endElement( aRelElement );
+ }
+
+ xWriter->ignorableWhitespace( aWhiteSpace );
+ xWriter->endElement( aRelListElement );
+ xWriter->endDocument();
+}
+
+
+void WriteContentSequence(
+ const uno::Reference< io::XOutputStream >& xOutStream,
+ const uno::Sequence< beans::StringPair >& aDefaultsSequence,
+ const uno::Sequence< beans::StringPair >& aOverridesSequence,
+ const uno::Reference< uno::XComponentContext >& rContext )
+{
+ if ( !xOutStream.is() )
+ throw uno::RuntimeException();
+
+ uno::Reference< css::xml::sax::XWriter > xWriter = css::xml::sax::Writer::create(rContext);
+
+ xWriter->setOutputStream( xOutStream );
+
+ static constexpr OUStringLiteral aTypesElement(u"Types");
+ static constexpr OUStringLiteral aDefaultElement(u"Default");
+ static constexpr OUStringLiteral aOverrideElement(u"Override");
+ static constexpr OUStringLiteral aContentTypeAttr(u"ContentType");
+ static constexpr OUStringLiteral aCDATAString(u"CDATA");
+ static constexpr OUStringLiteral aWhiteSpace(u" ");
+
+ // write the namespace
+ rtl::Reference<AttributeList> pRootAttrList = new AttributeList;
+ pRootAttrList->AddAttribute(
+ "xmlns",
+ aCDATAString,
+ "http://schemas.openxmlformats.org/package/2006/content-types" );
+
+ xWriter->startDocument();
+ xWriter->startElement( aTypesElement, pRootAttrList );
+
+ for ( const beans::StringPair & pair : aDefaultsSequence )
+ {
+ rtl::Reference<AttributeList> pAttrList = new AttributeList;
+ pAttrList->AddAttribute( "Extension", aCDATAString, pair.First );
+ pAttrList->AddAttribute( aContentTypeAttr, aCDATAString, pair.Second );
+
+ xWriter->startElement( aDefaultElement, pAttrList );
+ xWriter->ignorableWhitespace( aWhiteSpace );
+ xWriter->endElement( aDefaultElement );
+ }
+
+ for ( const beans::StringPair & pair : aOverridesSequence )
+ {
+ rtl::Reference<AttributeList> pAttrList = new AttributeList;
+ pAttrList->AddAttribute( "PartName", aCDATAString, pair.First );
+ pAttrList->AddAttribute( aContentTypeAttr, aCDATAString, pair.Second );
+
+ xWriter->startElement( aOverrideElement, pAttrList );
+ xWriter->ignorableWhitespace( aWhiteSpace );
+ xWriter->endElement( aOverrideElement );
+ }
+
+ xWriter->ignorableWhitespace( aWhiteSpace );
+ xWriter->endElement( aTypesElement );
+ xWriter->endDocument();
+
+}
+
+uno::Sequence< uno::Sequence< beans::StringPair > > ReadSequence_Impl(
+ const uno::Reference< io::XInputStream >& xInStream,
+ const OUString& aStringID, sal_uInt16 nFormat,
+ const uno::Reference< uno::XComponentContext >& rContext )
+{
+ if ( !rContext.is() || !xInStream.is() || nFormat > FORMAT_MAX_ID )
+ throw uno::RuntimeException();
+
+ uno::Reference< css::xml::sax::XParser > xParser = css::xml::sax::Parser::create( rContext );
+
+ rtl::Reference<OFOPXMLHelper_Impl> pHelper = new OFOPXMLHelper_Impl( nFormat );
+ css::xml::sax::InputSource aParserInput;
+ aParserInput.aInputStream = xInStream;
+ aParserInput.sSystemId = aStringID;
+ xParser->setDocumentHandler( pHelper );
+ xParser->parseStream( aParserInput );
+ xParser->setDocumentHandler( uno::Reference < css::xml::sax::XDocumentHandler > () );
+
+ return pHelper->GetParsingResult();
+}
+
+} // namespace OFOPXMLHelper
+
+// Relations info related strings
+constexpr OUStringLiteral g_aRelListElement(u"Relationships");
+constexpr OUStringLiteral g_aRelElement( u"Relationship" );
+constexpr OUStringLiteral g_aIDAttr( u"Id" );
+constexpr OUStringLiteral g_aTypeAttr( u"Type" );
+constexpr OUStringLiteral g_aTargetModeAttr( u"TargetMode" );
+constexpr OUStringLiteral g_aTargetAttr( u"Target" );
+
+// ContentType related strings
+constexpr OUStringLiteral g_aTypesElement( u"Types" );
+constexpr OUStringLiteral g_aDefaultElement( u"Default" );
+constexpr OUStringLiteral g_aOverrideElement( u"Override" );
+constexpr OUStringLiteral g_aExtensionAttr( u"Extension" );
+constexpr OUStringLiteral g_aPartNameAttr( u"PartName" );
+constexpr OUStringLiteral g_aContentTypeAttr( u"ContentType" );
+
+OFOPXMLHelper_Impl::OFOPXMLHelper_Impl( sal_uInt16 nFormat )
+: m_nFormat( nFormat )
+{
+}
+
+uno::Sequence< uno::Sequence< beans::StringPair > > const & OFOPXMLHelper_Impl::GetParsingResult() const
+{
+ if ( !m_aElementsSeq.empty() )
+ throw uno::RuntimeException(); // the parsing has still not finished!
+
+ return m_aResultSeq;
+}
+
+
+void SAL_CALL OFOPXMLHelper_Impl::startDocument()
+{
+}
+
+
+void SAL_CALL OFOPXMLHelper_Impl::endDocument()
+{
+}
+
+
+void SAL_CALL OFOPXMLHelper_Impl::startElement( const OUString& aName, const uno::Reference< css::xml::sax::XAttributeList >& xAttribs )
+{
+ if ( m_nFormat == RELATIONINFO_FORMAT )
+ {
+ if ( aName == g_aRelListElement )
+ {
+ sal_Int32 nNewLength = m_aElementsSeq.size() + 1;
+
+ if ( nNewLength != 1 )
+ throw css::xml::sax::SAXException(); // TODO: this element must be the first level element
+
+ m_aElementsSeq.push_back( aName );
+
+ return; // nothing to do
+ }
+ else if ( aName == g_aRelElement )
+ {
+ sal_Int32 nNewLength = m_aElementsSeq.size() + 1;
+ if ( nNewLength != 2 )
+ throw css::xml::sax::SAXException(); // TODO: this element must be the second level element
+
+ m_aElementsSeq.push_back( aName );
+
+ sal_Int32 nNewEntryNum = m_aResultSeq.getLength() + 1;
+ m_aResultSeq.realloc( nNewEntryNum );
+ auto pResultSeq = m_aResultSeq.getArray();
+ sal_Int32 nAttrNum = 0;
+ pResultSeq[nNewEntryNum-1].realloc( 4 ); // the maximal expected number of arguments is 4
+ auto pAttrs = pResultSeq[nNewEntryNum-1].getArray();
+
+ OUString aIDValue = xAttribs->getValueByName( g_aIDAttr );
+ if ( aIDValue.isEmpty() )
+ throw css::xml::sax::SAXException(); // TODO: the ID value must present
+
+ OUString aTypeValue = xAttribs->getValueByName( g_aTypeAttr );
+ OUString aTargetValue = xAttribs->getValueByName( g_aTargetAttr );
+ OUString aTargetModeValue = xAttribs->getValueByName( g_aTargetModeAttr );
+
+ pAttrs[++nAttrNum - 1].First = g_aIDAttr;
+ pAttrs[nAttrNum - 1].Second = aIDValue;
+
+ if ( !aTypeValue.isEmpty() )
+ {
+ pAttrs[++nAttrNum - 1].First = g_aTypeAttr;
+ pAttrs[nAttrNum - 1].Second = aTypeValue;
+ }
+
+ if ( !aTargetValue.isEmpty() )
+ {
+ pAttrs[++nAttrNum - 1].First = g_aTargetAttr;
+ pAttrs[nAttrNum - 1].Second = aTargetValue;
+ }
+
+ if ( !aTargetModeValue.isEmpty() )
+ {
+ pAttrs[++nAttrNum - 1].First = g_aTargetModeAttr;
+ pAttrs[nAttrNum - 1].Second = aTargetModeValue;
+ }
+
+ pResultSeq[nNewEntryNum-1].realloc( nAttrNum );
+ }
+ else
+ throw css::xml::sax::SAXException(); // TODO: no other elements expected!
+ }
+ else if ( m_nFormat == CONTENTTYPE_FORMAT )
+ {
+ if ( aName == g_aTypesElement )
+ {
+ sal_Int32 nNewLength = m_aElementsSeq.size() + 1;
+
+ if ( nNewLength != 1 )
+ throw css::xml::sax::SAXException(); // TODO: this element must be the first level element
+
+ m_aElementsSeq.push_back( aName );
+
+ if ( !m_aResultSeq.hasElements() )
+ m_aResultSeq.realloc( 2 );
+
+ return; // nothing to do
+ }
+ else if ( aName == g_aDefaultElement )
+ {
+ sal_Int32 nNewLength = m_aElementsSeq.size() + 1;
+ if ( nNewLength != 2 )
+ throw css::xml::sax::SAXException(); // TODO: this element must be the second level element
+
+ m_aElementsSeq.push_back( aName );
+
+ if ( !m_aResultSeq.hasElements() )
+ m_aResultSeq.realloc( 2 );
+
+ if ( m_aResultSeq.getLength() != 2 )
+ throw uno::RuntimeException();
+
+ auto pResultSeq = m_aResultSeq.getArray();
+
+ const OUString aExtensionValue = xAttribs->getValueByName( g_aExtensionAttr );
+ if ( aExtensionValue.isEmpty() )
+ throw css::xml::sax::SAXException(); // TODO: the Extension value must present
+
+ const OUString aContentTypeValue = xAttribs->getValueByName( g_aContentTypeAttr );
+ if ( aContentTypeValue.isEmpty() )
+ throw css::xml::sax::SAXException(); // TODO: the ContentType value must present
+
+ const sal_Int32 nNewResultLen = m_aResultSeq[0].getLength() + 1;
+ pResultSeq[0].realloc( nNewResultLen );
+ auto pSeq = pResultSeq[0].getArray();
+
+ pSeq[nNewResultLen-1].First = aExtensionValue;
+ pSeq[nNewResultLen-1].Second = aContentTypeValue;
+ }
+ else if ( aName == g_aOverrideElement )
+ {
+ sal_Int32 nNewLength = m_aElementsSeq.size() + 1;
+ if ( nNewLength != 2 )
+ throw css::xml::sax::SAXException(); // TODO: this element must be the second level element
+
+ m_aElementsSeq.push_back( aName );
+
+ if ( !m_aResultSeq.hasElements() )
+ m_aResultSeq.realloc( 2 );
+
+ if ( m_aResultSeq.getLength() != 2 )
+ throw uno::RuntimeException();
+
+ auto pResultSeq = m_aResultSeq.getArray();
+
+ OUString aPartNameValue = xAttribs->getValueByName( g_aPartNameAttr );
+ if ( aPartNameValue.isEmpty() )
+ throw css::xml::sax::SAXException(); // TODO: the PartName value must present
+
+ OUString aContentTypeValue = xAttribs->getValueByName( g_aContentTypeAttr );
+ if ( aContentTypeValue.isEmpty() )
+ throw css::xml::sax::SAXException(); // TODO: the ContentType value must present
+
+ sal_Int32 nNewResultLen = m_aResultSeq[1].getLength() + 1;
+ pResultSeq[1].realloc( nNewResultLen );
+ auto pSeq = pResultSeq[1].getArray();
+
+ pSeq[nNewResultLen-1].First = aPartNameValue;
+ pSeq[nNewResultLen-1].Second = aContentTypeValue;
+ }
+ else
+ throw css::xml::sax::SAXException(); // TODO: no other elements expected!
+ }
+ else
+ throw css::xml::sax::SAXException(); // TODO: no other elements expected!
+}
+
+
+void SAL_CALL OFOPXMLHelper_Impl::endElement( const OUString& aName )
+{
+ if ( m_nFormat == RELATIONINFO_FORMAT || m_nFormat == CONTENTTYPE_FORMAT )
+ {
+ sal_Int32 nLength = m_aElementsSeq.size();
+ if ( nLength <= 0 )
+ throw css::xml::sax::SAXException(); // TODO: no other end elements expected!
+
+ if ( m_aElementsSeq[nLength-1] != aName )
+ throw css::xml::sax::SAXException(); // TODO: unexpected element ended
+
+ m_aElementsSeq.resize( nLength - 1 );
+ }
+}
+
+
+void SAL_CALL OFOPXMLHelper_Impl::characters( const OUString& /*aChars*/ )
+{
+}
+
+
+void SAL_CALL OFOPXMLHelper_Impl::ignorableWhitespace( const OUString& /*aWhitespaces*/ )
+{
+}
+
+
+void SAL_CALL OFOPXMLHelper_Impl::processingInstruction( const OUString& /*aTarget*/, const OUString& /*aData*/ )
+{
+}
+
+
+void SAL_CALL OFOPXMLHelper_Impl::setDocumentLocator( const uno::Reference< css::xml::sax::XLocator >& /*xLocator*/ )
+{
+}
+
+} // namespace comphelper
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/comphelper/source/xml/xmltools.cxx b/comphelper/source/xml/xmltools.cxx
new file mode 100644
index 000000000..1b10964b1
--- /dev/null
+++ b/comphelper/source/xml/xmltools.cxx
@@ -0,0 +1,99 @@
+/* -*- 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/.
+ */
+
+#include <comphelper/xmltools.hxx>
+#include <rtl/random.h>
+#include <tools/Guid.hxx>
+#include <vector>
+
+using namespace com::sun::star;
+
+namespace
+{
+ //Will be inside an xml comment, so can't use '-' in case '--' appears in
+ //output, etc. Despite what *is* legal in an xml comment, just using the
+ //base-64 subset to avoid pain with simplistic third-party parsers
+ const sal_uInt8 aChaffEncoder[] =
+ {
+ 'A', 'Q', 'g', 'w', 'B', 'R', 'h', 'x',
+ 'C', 'S', 'i', 'y', 'D', 'T', 'j', 'z',
+ 'E', 'U', 'k', '0', 'F', 'V', 'l', '1',
+ 'G', 'W', 'm', '2', 'H', 'X', 'n', '3',
+ 'I', 'Y', 'o', '4', 'J', 'Z', 'p', '5',
+ 'K', 'a', 'q', '6', 'L', 'b', 'r', '7',
+ 'M', 'c', 's', '8', 'N', 'd', 't', '9',
+ 'O', 'e', 'u', '+', 'P', 'f', 'v', '/',
+
+ 'A', 'Q', 'g', 'w', 'B', 'R', 'h', 'x',
+ 'C', 'S', 'i', 'y', 'D', 'T', 'j', 'z',
+ 'E', 'U', 'k', '0', 'F', 'V', 'l', '1',
+ 'G', 'W', 'm', '2', 'H', 'X', 'n', '3',
+ 'I', 'Y', 'o', '4', 'J', 'Z', 'p', '5',
+ 'K', 'a', 'q', '6', 'L', 'b', 'r', '7',
+ 'M', 'c', 's', '8', 'N', 'd', 't', '9',
+ 'O', 'e', 'u', '+', 'P', 'f', 'v', '/',
+
+ 'A', 'Q', 'g', 'w', 'B', 'R', 'h', 'x',
+ 'C', 'S', 'i', 'y', 'D', 'T', 'j', 'z',
+ 'E', 'U', 'k', '0', 'F', 'V', 'l', '1',
+ 'G', 'W', 'm', '2', 'H', 'X', 'n', '3',
+ 'I', 'Y', 'o', '4', 'J', 'Z', 'p', '5',
+ 'K', 'a', 'q', '6', 'L', 'b', 'r', '7',
+ 'M', 'c', 's', '8', 'N', 'd', 't', '9',
+ 'O', 'e', 'u', '+', 'P', 'f', 'v', '/',
+
+ 'A', 'Q', 'g', 'w', 'B', 'R', 'h', 'x',
+ 'C', 'S', 'i', 'y', 'D', 'T', 'j', 'z',
+ 'E', 'U', 'k', '0', 'F', 'V', 'l', '1',
+ 'G', 'W', 'm', '2', 'H', 'X', 'n', '3',
+ 'I', 'Y', 'o', '4', 'J', 'Z', 'p', '5',
+ 'K', 'a', 'q', '6', 'L', 'b', 'r', '7',
+ 'M', 'c', 's', '8', 'N', 'd', 't', '9',
+ 'O', 'e', 'u', '+', 'P', 'f', 'v', '/'
+ };
+
+ void encodeChaff(std::vector<sal_uInt8> &rChaff)
+ {
+ static_assert(sizeof(aChaffEncoder) == 256, "this has to cover all chars");
+
+ for (auto & elem : rChaff)
+ {
+ elem = aChaffEncoder[elem];
+ }
+ }
+}
+
+namespace comphelper::xml
+{
+ OString makeXMLChaff()
+ {
+ rtlRandomPool pool = rtl_random_createPool();
+
+ sal_Int8 n;
+ rtl_random_getBytes(pool, &n, 1);
+
+ sal_Int32 nLength = 1024+n;
+ // coverity[tainted_data] - 1024 deliberate random minus max -127/plus max 128
+ std::vector<sal_uInt8> aChaff(nLength);
+ rtl_random_getBytes(pool, aChaff.data(), nLength);
+
+ rtl_random_destroyPool(pool);
+
+ encodeChaff(aChaff);
+
+ return OString(reinterpret_cast<const char*>(aChaff.data()), nLength);
+ }
+
+ OString generateGUIDString()
+ {
+ tools::Guid aGuid(tools::Guid::Generate);
+ return aGuid.getString();
+ }
+}
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */