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

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

26 files changed, 5819 insertions, 0 deletions

diff --git a/sdext/source/minimizer/configurationaccess.cxx b/sdext/source/minimizer/configurationaccess.cxx
new file mode 100644
index 000000000..3479918c2
--- /dev/null
+++ b/sdext/source/minimizer/configurationaccess.cxx
@@ -0,0 +1,458 @@
+/* -*- 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 "configurationaccess.hxx"
+#include <com/sun/star/container/XHierarchicalNameAccess.hpp>
+#include <com/sun/star/configuration/theDefaultProvider.hpp>
+#include <com/sun/star/util/XChangesBatch.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/lang/XSingleServiceFactory.hpp>
+#include <comphelper/propertysequence.hxx>
+#include <comphelper/propertyvalue.hxx>
+#include <sal/macros.h>
+#include <sal/log.hxx>
+#include <tools/diagnose_ex.h>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::container;
+
+static OUString GetPathToConfigurationRoot()
+{
+    return "org.openoffice.Office.PresentationMinimizer";
+}
+
+void OptimizerSettings::LoadSettingsFromConfiguration( const Reference< XNameAccess >& rSettings )
+{
+    if ( !rSettings.is() )
+        return;
+
+    const Sequence< OUString > aElements( rSettings->getElementNames() );
+    for ( const OUString& aPropertyName : aElements )
+    {
+        try
+        {
+            Any aValue( rSettings->getByName( aPropertyName ) );
+            switch( TKGet( aPropertyName ) )
+            {
+                case TK_Name :                      aValue >>= maName; break;
+                case TK_JPEGCompression :           aValue >>= mbJPEGCompression; break;
+                case TK_JPEGQuality :               aValue >>= mnJPEGQuality; break;
+                case TK_RemoveCropArea :            aValue >>= mbRemoveCropArea; break;
+                case TK_ImageResolution :           aValue >>= mnImageResolution; break;
+                case TK_EmbedLinkedGraphics :       aValue >>= mbEmbedLinkedGraphics; break;
+                case TK_OLEOptimization :           aValue >>= mbOLEOptimization; break;
+                case TK_OLEOptimizationType :       aValue >>= mnOLEOptimizationType; break;
+                case TK_DeleteUnusedMasterPages :   aValue >>= mbDeleteUnusedMasterPages; break;
+                case TK_DeleteHiddenSlides :        aValue >>= mbDeleteHiddenSlides; break;
+                case TK_DeleteNotesPages :          aValue >>= mbDeleteNotesPages ;break;
+                case TK_SaveAs :                    aValue >>= mbSaveAs; break;
+//                  case TK_SaveAsURL :                 aValue >>= maSaveAsURL; break;      // URL is not saved to configuration
+//                  case TK_FilterName :                aValue >>= maFilterName; break;     // URL is not saved to configuration
+                case TK_OpenNewDocument :           aValue >>= mbOpenNewDocument; break;
+                default: break;
+            }
+        }
+        catch (const Exception&)
+        {
+        }
+    }
+}
+
+void OptimizerSettings::SaveSettingsToConfiguration( const Reference< XNameReplace >& rSettings )
+{
+    if ( !rSettings.is() )
+        return;
+
+    OUString pNames[] = {
+        OUString("Name"),
+        OUString("JPEGCompression"),
+        OUString("JPEGQuality"),
+        OUString("RemoveCropArea"),
+        OUString("ImageResolution"),
+        OUString("EmbedLinkedGraphics"),
+        OUString("OLEOptimization"),
+        OUString("OLEOptimizationType"),
+        OUString("DeleteUnusedMasterPages"),
+        OUString("DeleteHiddenSlides"),
+        OUString("DeleteNotesPages"),
+        OUString("SaveAs"),
+//          OUString("SaveAsURL"),
+//          OUString("FilterName"),
+        OUString("OpenNewDocument") };
+
+    Any pValues[] = {
+        Any( maName ),
+        Any( mbJPEGCompression ),
+        Any( mnJPEGQuality ),
+        Any( mbRemoveCropArea ),
+        Any( mnImageResolution ),
+        Any( mbEmbedLinkedGraphics ),
+        Any( mbOLEOptimization ),
+        Any( mnOLEOptimizationType ),
+        Any( mbDeleteUnusedMasterPages ),
+        Any( mbDeleteHiddenSlides ),
+        Any( mbDeleteNotesPages ),
+        Any( mbSaveAs ),
+//          Any( maSaveAsURL ),
+//          Any( maFilterName ),
+        Any( mbOpenNewDocument ) };
+
+    for ( int i = 0; i < int(SAL_N_ELEMENTS( pNames )); i++ )
+    {
+        try
+        {
+            rSettings->replaceByName( pNames[ i ], pValues[ i ] );
+        }
+        catch (const Exception&)
+        {
+        }
+    }
+}
+
+bool OptimizerSettings::operator==( const OptimizerSettings& rOptimizerSettings ) const
+{
+    return ( rOptimizerSettings.mbJPEGCompression == mbJPEGCompression )
+        && ( rOptimizerSettings.mnJPEGQuality == mnJPEGQuality )
+        && ( rOptimizerSettings.mbRemoveCropArea == mbRemoveCropArea )
+        && ( rOptimizerSettings.mnImageResolution == mnImageResolution )
+        && ( rOptimizerSettings.mbEmbedLinkedGraphics == mbEmbedLinkedGraphics )
+        && ( rOptimizerSettings.mbOLEOptimization == mbOLEOptimization )
+        && ( rOptimizerSettings.mnOLEOptimizationType == mnOLEOptimizationType )
+        && ( rOptimizerSettings.mbDeleteUnusedMasterPages == mbDeleteUnusedMasterPages )
+        && ( rOptimizerSettings.mbDeleteHiddenSlides == mbDeleteHiddenSlides )
+        && ( rOptimizerSettings.mbDeleteNotesPages == mbDeleteNotesPages );
+//      && ( rOptimizerSettings.mbOpenNewDocument == mbOpenNewDocument );
+}
+
+
+ConfigurationAccess::ConfigurationAccess( const Reference< uno::XComponentContext >& rxContext ) :
+    mxContext( rxContext )
+{
+    LoadStrings();
+    maSettings.emplace_back( );
+    maSettings.back().maName = "LastUsedSettings";
+    LoadConfiguration();
+};
+
+ConfigurationAccess::~ConfigurationAccess()
+{
+}
+
+OUString ConfigurationAccess::getString( const PPPOptimizerTokenEnum eToken ) const
+{
+    std::map< PPPOptimizerTokenEnum, OUString >::const_iterator aIter( maStrings.find( eToken ) );
+    return aIter != maStrings.end() ? ((*aIter).second) : OUString();
+}
+
+void ConfigurationAccess::LoadStrings()
+{
+    try
+    {
+        do
+        {
+            Reference< XInterface > xRoot( OpenConfiguration( true ) );
+            if ( !xRoot.is() )
+                break;
+            Reference< container::XNameAccess > xSet( GetConfigurationNode( xRoot, "Strings" ), UNO_QUERY );
+            if ( xSet.is() )
+            {
+                const Sequence< OUString > aElements( xSet->getElementNames() );
+                for ( const auto& rElement : aElements )
+                {
+                    try
+                    {
+                        OUString aString, aPropertyName( rElement );
+                        if ( xSet->getByName( aPropertyName ) >>= aString )
+                            maStrings[ TKGet( aPropertyName ) ] = aString;
+                    }
+                    catch (const Exception&)
+                    {
+                    }
+                }
+            }
+        }
+        while( false );
+    }
+    catch (const Exception&)
+    {
+    }
+}
+
+void ConfigurationAccess::LoadConfiguration()
+{
+    try
+    {
+        do
+        {
+            Reference< XInterface > xRoot( OpenConfiguration( true ) );
+            if ( !xRoot.is() )
+                break;
+            Reference< container::XNameAccess > xSet( GetConfigurationNode( xRoot, "LastUsedSettings" ), UNO_QUERY );
+            if ( xSet.is() )
+            {
+                OptimizerSettings& rCurrent( maSettings.front() );
+                rCurrent.LoadSettingsFromConfiguration( xSet );
+            }
+            xSet.set( GetConfigurationNode( xRoot, "Settings/Templates" ), UNO_QUERY );
+            if ( xSet.is() )
+            {
+                const Sequence< OUString > aElements( xSet->getElementNames() );
+                for ( const auto& rElement : aElements )
+                {
+                    try
+                    {
+                        OUString aPath( "Settings/Templates/" + rElement );
+                        Reference< container::XNameAccess > xTemplates( GetConfigurationNode( xRoot, aPath ), UNO_QUERY );
+                        if ( xTemplates.is() )
+                        {
+                            maSettings.emplace_back( );
+                            maSettings.back().LoadSettingsFromConfiguration( xTemplates );
+                        }
+                    }
+                    catch (const Exception&)
+                    {
+                    }
+                }
+            }
+        }
+        while( false );
+    }
+    catch (const Exception&)
+    {
+    }
+}
+
+void ConfigurationAccess::SaveConfiguration()
+{
+    try
+    {
+        do
+        {
+            Reference<util::XChangesBatch> xRoot( OpenConfiguration( false ), UNO_QUERY_THROW );
+
+            // storing the last used settings
+            Reference< container::XNameReplace > xSet( GetConfigurationNode( xRoot, "LastUsedSettings" ), UNO_QUERY_THROW );
+            OptimizerSettings& rCurrent( maSettings.front() );
+            rCurrent.SaveSettingsToConfiguration( xSet );
+
+            // updating template elements
+            xSet.set( GetConfigurationNode( xRoot, "Settings/Templates" ), UNO_QUERY_THROW );
+            Reference< container::XNameContainer > xNameContainer( xSet, UNO_QUERY_THROW );
+
+            const Sequence< OUString > aElements( xSet->getElementNames() );
+            for( const auto& rElement : aElements )
+                xNameContainer->removeByName( rElement );
+
+            for( std::vector<OptimizerSettings>::size_type k = 1; k < maSettings.size(); k++ )
+            {
+                OptimizerSettings& rSettings( maSettings[ k ] );
+                OUString aElementName( "Template" + OUString::number( k ) );
+                Reference< lang::XSingleServiceFactory > xChildFactory ( xSet, UNO_QUERY_THROW );
+                Reference< container::XNameReplace > xChild( xChildFactory->createInstance(), UNO_QUERY_THROW );
+                xNameContainer->insertByName( aElementName, Any( xChild ) );
+
+                OUString aPath( "Settings/Templates/" + aElementName );
+                Reference< container::XNameReplace > xTemplates( GetConfigurationNode( xRoot, aPath ), UNO_QUERY );
+                rSettings.SaveSettingsToConfiguration( xTemplates );
+            }
+            xRoot->commitChanges();
+        }
+        while( false );
+    }
+    catch (const Exception&)
+    {
+    }
+}
+
+Reference< XInterface > ConfigurationAccess::OpenConfiguration( bool bReadOnly )
+{
+    Reference< XInterface > xRoot;
+    try
+    {
+        Reference< lang::XMultiServiceFactory > xProvider = configuration::theDefaultProvider::get( mxContext );
+        uno::Sequence<uno::Any> aCreationArguments(comphelper::InitAnyPropertySequence(
+        {
+            {"nodepath",  uno::Any(GetPathToConfigurationRoot())}
+        }));
+        OUString sAccessService;
+        if ( bReadOnly )
+            sAccessService = "com.sun.star.configuration.ConfigurationAccess";
+        else
+            sAccessService =
+                "com.sun.star.configuration.ConfigurationUpdateAccess";
+
+        xRoot = xProvider->createInstanceWithArguments(
+            sAccessService, aCreationArguments );
+    }
+    catch (const Exception&)
+    {
+    }
+    return xRoot;
+}
+
+Reference< XInterface > ConfigurationAccess::GetConfigurationNode(
+    const Reference< XInterface >& xRoot,
+    const OUString& sPathToNode )
+{
+    Reference< XInterface > xNode;
+    try
+    {
+        if ( sPathToNode.isEmpty() )
+            xNode = xRoot;
+        else
+        {
+            Reference< XHierarchicalNameAccess > xHierarchy( xRoot, UNO_QUERY );
+            if ( xHierarchy.is() )
+            {
+                xHierarchy->getByHierarchicalName( sPathToNode ) >>= xNode;
+            }
+        }
+    }
+    catch (const Exception&)
+    {
+        TOOLS_WARN_EXCEPTION("sdext.minimizer", "caught exception while getting configuration node "
+                  << sPathToNode);
+    }
+    return xNode;
+}
+
+css::uno::Any ConfigurationAccess::GetConfigProperty( const PPPOptimizerTokenEnum ePropertyToken ) const
+{
+    Any aRetValue;
+    const OptimizerSettings& rSettings( maSettings.front() );
+    try
+    {
+        switch( ePropertyToken )
+        {
+            case TK_Name :                      aRetValue <<= rSettings.maName; break;
+            case TK_JPEGCompression :           aRetValue <<= rSettings.mbJPEGCompression; break;
+            case TK_JPEGQuality :               aRetValue <<= rSettings.mnJPEGQuality; break;
+            case TK_RemoveCropArea :            aRetValue <<= rSettings.mbRemoveCropArea; break;
+            case TK_ImageResolution :           aRetValue <<= rSettings.mnImageResolution; break;
+            case TK_EmbedLinkedGraphics :       aRetValue <<= rSettings.mbEmbedLinkedGraphics; break;
+            case TK_OLEOptimization :           aRetValue <<= rSettings.mbOLEOptimization; break;
+            case TK_OLEOptimizationType :       aRetValue <<= rSettings.mnOLEOptimizationType; break;
+            case TK_DeleteUnusedMasterPages :   aRetValue <<= rSettings.mbDeleteUnusedMasterPages; break;
+            case TK_DeleteHiddenSlides :        aRetValue <<= rSettings.mbDeleteHiddenSlides; break;
+            case TK_DeleteNotesPages :          aRetValue <<= rSettings.mbDeleteNotesPages; break;
+            case TK_SaveAs :                    aRetValue <<= rSettings.mbSaveAs; break;
+            case TK_SaveAsURL :                 aRetValue <<= rSettings.maSaveAsURL; break;
+            case TK_FilterName :                aRetValue <<= rSettings.maFilterName; break;
+            case TK_OpenNewDocument :           aRetValue <<= rSettings.mbOpenNewDocument; break;
+            case TK_EstimatedFileSize :         aRetValue <<= rSettings.mnEstimatedFileSize; break;
+            default:
+                break;
+        }
+    }
+    catch (const Exception&)
+    {
+    }
+    return aRetValue;
+}
+
+void ConfigurationAccess::SetConfigProperty( const PPPOptimizerTokenEnum ePropertyToken, const css::uno::Any& rValue )
+{
+    OptimizerSettings& rSettings( maSettings.front() );
+    try
+    {
+        switch( ePropertyToken )
+        {
+            case TK_Name :                      rValue >>= rSettings.maName; break;
+            case TK_JPEGCompression :           rValue >>= rSettings.mbJPEGCompression; break;
+            case TK_JPEGQuality :               rValue >>= rSettings.mnJPEGQuality; break;
+            case TK_RemoveCropArea :            rValue >>= rSettings.mbRemoveCropArea; break;
+            case TK_ImageResolution :           rValue >>= rSettings.mnImageResolution; break;
+            case TK_EmbedLinkedGraphics :       rValue >>= rSettings.mbEmbedLinkedGraphics; break;
+            case TK_OLEOptimization :           rValue >>= rSettings.mbOLEOptimization; break;
+            case TK_OLEOptimizationType :       rValue >>= rSettings.mnOLEOptimizationType; break;
+            case TK_DeleteUnusedMasterPages :   rValue >>= rSettings.mbDeleteUnusedMasterPages; break;
+            case TK_DeleteHiddenSlides :        rValue >>= rSettings.mbDeleteHiddenSlides; break;
+            case TK_DeleteNotesPages :          rValue >>= rSettings.mbDeleteNotesPages; break;
+            case TK_CustomShowName :            rValue >>= rSettings.maCustomShowName; break;
+            case TK_SaveAs :                    rValue >>= rSettings.mbSaveAs; break;
+            case TK_SaveAsURL :                 rValue >>= rSettings.maSaveAsURL; break;
+            case TK_FilterName :                rValue >>= rSettings.maFilterName; break;
+            case TK_OpenNewDocument :           rValue >>= rSettings.mbOpenNewDocument; break;
+            case TK_EstimatedFileSize :         rValue >>= rSettings.mnEstimatedFileSize; break;
+            default:
+                break;
+        }
+    }
+    catch (const Exception&)
+    {
+    }
+}
+
+bool ConfigurationAccess::GetConfigProperty( const PPPOptimizerTokenEnum ePropertyToken, const bool bDefault ) const
+{
+    bool bRetValue = bDefault;
+    if ( ! ( GetConfigProperty( ePropertyToken ) >>= bRetValue ) )
+        bRetValue = bDefault;
+    return bRetValue;
+}
+
+sal_Int16 ConfigurationAccess::GetConfigProperty( const PPPOptimizerTokenEnum ePropertyToken, const sal_Int16 nDefault ) const
+{
+    sal_Int16 nRetValue = nDefault;
+    if ( ! ( GetConfigProperty( ePropertyToken ) >>= nRetValue ) )
+        nRetValue = nDefault;
+    return nRetValue;
+}
+
+sal_Int32 ConfigurationAccess::GetConfigProperty( const PPPOptimizerTokenEnum ePropertyToken, const sal_Int32 nDefault ) const
+{
+    sal_Int32 nRetValue = nDefault;
+    if ( ! ( GetConfigProperty( ePropertyToken ) >>= nRetValue ) )
+        nRetValue = nDefault;
+    return nRetValue;
+}
+
+Sequence< PropertyValue > ConfigurationAccess::GetConfigurationSequence()
+{
+    OptimizerSettings& rSettings( maSettings.front() );
+    Sequence< PropertyValue > aRet{
+        comphelper::makePropertyValue("JPEGCompression", rSettings.mbJPEGCompression),
+        comphelper::makePropertyValue("JPEGQuality", rSettings.mnJPEGQuality),
+        comphelper::makePropertyValue("RemoveCropArea", rSettings.mbRemoveCropArea),
+        comphelper::makePropertyValue("ImageResolution", rSettings.mnImageResolution),
+        comphelper::makePropertyValue("EmbedLinkedGraphics", rSettings.mbEmbedLinkedGraphics),
+        comphelper::makePropertyValue("OLEOptimization", rSettings.mbOLEOptimization),
+        comphelper::makePropertyValue("OLEOptimizationType", rSettings.mnOLEOptimizationType),
+        comphelper::makePropertyValue("DeleteUnusedMasterPages", rSettings.mbDeleteUnusedMasterPages),
+        comphelper::makePropertyValue("DeleteHiddenSlides", rSettings.mbDeleteHiddenSlides),
+        comphelper::makePropertyValue("DeleteNotesPages", rSettings.mbDeleteNotesPages),
+        comphelper::makePropertyValue("CustomShowName", rSettings.maCustomShowName),
+        comphelper::makePropertyValue("SaveAsURL", rSettings.maSaveAsURL),
+        comphelper::makePropertyValue("FilterName", rSettings.maFilterName),
+        comphelper::makePropertyValue("OpenNewDocument", rSettings.mbOpenNewDocument),
+        comphelper::makePropertyValue("EstimatedFileSize", rSettings.mnEstimatedFileSize)
+    };
+    return aRet;
+}
+
+std::vector< OptimizerSettings >::iterator ConfigurationAccess::GetOptimizerSettingsByName( const OUString& rName )
+{
+    return std::find_if(maSettings.begin() + 1, maSettings.end(),
+        [&rName](const OptimizerSettings& rSettings) { return rSettings.maName == rName; });
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/configurationaccess.hxx b/sdext/source/minimizer/configurationaccess.hxx
new file mode 100644
index 000000000..d4d4c4d3f
--- /dev/null
+++ b/sdext/source/minimizer/configurationaccess.hxx
@@ -0,0 +1,116 @@
+/* -*- 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 .
+ */
+
+#ifndef INCLUDED_SDEXT_SOURCE_MINIMIZER_CONFIGURATIONACCESS_HXX
+#define INCLUDED_SDEXT_SOURCE_MINIMIZER_CONFIGURATIONACCESS_HXX
+
+#include <vector>
+#include "pppoptimizertoken.hxx"
+#include <com/sun/star/uno/Any.h>
+#include <com/sun/star/uno/Reference.h>
+#include <com/sun/star/uno/XInterface.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/container/XNameReplace.hpp>
+#include <map>
+
+struct OptimizerSettings
+{
+    OUString   maName;
+    bool        mbJPEGCompression;
+    sal_Int32       mnJPEGQuality;
+    bool        mbRemoveCropArea;
+    sal_Int32       mnImageResolution;
+    bool        mbEmbedLinkedGraphics;
+    bool        mbOLEOptimization;
+    sal_Int16       mnOLEOptimizationType;
+    bool        mbDeleteUnusedMasterPages;
+    bool        mbDeleteHiddenSlides;
+    bool        mbDeleteNotesPages;
+    OUString   maCustomShowName;
+    bool        mbSaveAs;
+    OUString   maSaveAsURL;
+    OUString   maFilterName;
+    bool        mbOpenNewDocument;
+    sal_Int64       mnEstimatedFileSize;
+
+    OptimizerSettings() :
+        mbJPEGCompression( false ),
+        mnJPEGQuality( 90 ),
+        mbRemoveCropArea( false ),
+        mnImageResolution( 0 ),
+        mbEmbedLinkedGraphics( false ),
+        mbOLEOptimization( false ),
+        mnOLEOptimizationType( 0 ),
+        mbDeleteUnusedMasterPages( false ),
+        mbDeleteHiddenSlides( false ),
+        mbDeleteNotesPages( false ),
+        mbSaveAs( true ),
+        mbOpenNewDocument( true ),
+        mnEstimatedFileSize( 0 ){};
+
+        void LoadSettingsFromConfiguration( const css::uno::Reference< css::container::XNameAccess >& rSettings );
+        void SaveSettingsToConfiguration( const css::uno::Reference< css::container::XNameReplace >& rSettings );
+
+        bool operator==( const OptimizerSettings& rOptimizerSettings ) const;
+
+};
+class ConfigurationAccess
+{
+    public:
+
+        explicit ConfigurationAccess( const css::uno::Reference< css::uno::XComponentContext >& rXFactory );
+        ~ConfigurationAccess();
+        void SaveConfiguration();
+
+        OUString getString( const PPPOptimizerTokenEnum ) const;
+
+        // access to current OptimizerSettings (stored in the first entry of maSettings)
+        css::uno::Any GetConfigProperty( const PPPOptimizerTokenEnum ) const;
+        void SetConfigProperty( const PPPOptimizerTokenEnum, const css::uno::Any& aValue );
+
+        bool GetConfigProperty( const PPPOptimizerTokenEnum, const bool bDefault ) const;
+        sal_Int16 GetConfigProperty( const PPPOptimizerTokenEnum, const sal_Int16 nDefault ) const;
+        sal_Int32 GetConfigProperty( const PPPOptimizerTokenEnum, const sal_Int32 nDefault ) const;
+
+        css::uno::Sequence< css::beans::PropertyValue > GetConfigurationSequence();
+
+        // getting access to the OptimizerSettings list
+        std::vector< OptimizerSettings >& GetOptimizerSettings() { return maSettings; };
+        std::vector< OptimizerSettings >::iterator GetOptimizerSettingsByName( const OUString& rName );
+
+    private:
+
+        std::map < PPPOptimizerTokenEnum, OUString > maStrings;
+
+        std::vector< OptimizerSettings > maSettings;
+
+        css::uno::Reference< css::uno::XComponentContext > mxContext;
+
+        void LoadStrings();
+        void LoadConfiguration();
+        css::uno::Reference< css::uno::XInterface > OpenConfiguration( bool bReadOnly );
+        static css::uno::Reference< css::uno::XInterface > GetConfigurationNode(
+            const css::uno::Reference< css::uno::XInterface >& xRoot, const OUString& sPathToNode );
+};
+
+#endif // INCLUDED_SDEXT_SOURCE_MINIMIZER_CONFIGURATIONACCESS_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/fileopendialog.cxx b/sdext/source/minimizer/fileopendialog.cxx
new file mode 100644
index 000000000..ef0dbf4b4
--- /dev/null
+++ b/sdext/source/minimizer/fileopendialog.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 "fileopendialog.hxx"
+#include <sal/types.h>
+#include "pppoptimizertoken.hxx"
+#include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
+#include <com/sun/star/ui/dialogs/FilePicker.hpp>
+#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
+#include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp>
+#include <com/sun/star/ui/dialogs/XFilterManager.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/container/XEnumeration.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/view/XControlAccess.hpp>
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::view;
+using namespace ::com::sun::star::ui::dialogs;
+
+FileOpenDialog::FileOpenDialog( const Reference< XComponentContext >& rxContext )
+{
+    mxFilePicker = FilePicker::createWithMode( rxContext, TemplateDescription::FILESAVE_AUTOEXTENSION);
+    mxFilePicker->setMultiSelectionMode( false );
+
+    Reference< XFilePickerControlAccess > xAccess( mxFilePicker, UNO_QUERY );
+    if ( xAccess.is() )
+    {
+        try
+        {
+            xAccess->setValue( ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION, 0, Any( true ) );
+        }
+        catch( css::uno::Exception& )
+        {}
+    }
+
+    // collecting a list of impress filters
+    Reference< XNameAccess > xFilters( rxContext->getServiceManager()->createInstanceWithContext(
+        "com.sun.star.document.FilterFactory", rxContext ), UNO_QUERY_THROW );
+    const Sequence< OUString > aFilterList( xFilters->getElementNames() );
+    for ( const auto& rFilter : aFilterList )
+    {
+        try
+        {
+            Sequence< PropertyValue > aFilterProperties;
+            if ( xFilters->getByName( rFilter ) >>= aFilterProperties )
+            {
+                FilterEntry aFilterEntry;
+                bool bImpressFilter = false;
+                for ( const PropertyValue& rProperty : std::as_const(aFilterProperties) )
+                {
+                    bool bStop = false;
+                    switch( TKGet( rProperty.Name ) )
+                    {
+                        case TK_DocumentService :
+                        {
+                            OUString sDocumentService;
+                            rProperty.Value >>= sDocumentService;
+                            if ( sDocumentService == "com.sun.star.presentation.PresentationDocument" )
+                                bImpressFilter = true;
+                            else
+                                bStop = true;
+                        }
+                        break;
+                        case TK_Name :      rProperty.Value >>= aFilterEntry.maFilterEntryName; break;
+                        case TK_UIName :    rProperty.Value >>= aFilterEntry.maUIName; break;
+                        case TK_Type :      rProperty.Value >>= aFilterEntry.maType; break;
+                        case TK_Flags :     rProperty.Value >>= aFilterEntry.maFlags; break;
+                        default : break;
+                    }
+
+                    if (bStop)
+                        break;
+                }
+                if ( bImpressFilter && ( ( aFilterEntry.maFlags & 3 ) == 3 ) )
+                {
+                    aFilterEntryList.push_back( aFilterEntry );
+                }
+            }
+        }
+        catch( Exception& )
+        {
+        }
+    }
+
+    Reference< XNameAccess > xTypes( rxContext->getServiceManager()->createInstanceWithContext(
+        "com.sun.star.document.TypeDetection", rxContext ), UNO_QUERY_THROW );
+
+    for (auto& rFilterEntry : aFilterEntryList)
+    {
+        Sequence< PropertyValue > aTypeProperties;
+        try
+        {
+            if ( xTypes->getByName( rFilterEntry.maType ) >>= aTypeProperties )
+            {
+                Sequence< OUString > aExtensions;
+                auto pProp = std::find_if(std::cbegin(aTypeProperties), std::cend(aTypeProperties),
+                    [](const PropertyValue& rProp) { return rProp.Name == "Extensions"; });
+                if (pProp != std::cend(aTypeProperties))
+                    pProp->Value >>= aExtensions;
+                if ( aExtensions.hasElements() )
+                {
+                    // The filter title must be formed in the same way it is currently done in the
+                    // internal implementation (see sfx2::appendFiltersForSave). And we will look
+                    // for the same string returned from the dialog, so save it to maUIName:
+                    OUString aTitle(
+                        rFilterEntry.maUIName + " (." + aExtensions[0] + ")");
+                    rFilterEntry.maUIName = aTitle;
+                    OUString aFilter("*." + aExtensions[0]);
+                    mxFilePicker->appendFilter(aTitle, aFilter);
+                    if ( rFilterEntry.maFlags & 0x100 )
+                        mxFilePicker->setCurrentFilter(aTitle);
+                }
+            }
+        }
+        catch ( const Exception& )
+        {
+        }
+    }
+}
+FileOpenDialog::~FileOpenDialog()
+{
+}
+sal_Int16 FileOpenDialog::execute()
+{
+    return mxFilePicker->execute();
+}
+void FileOpenDialog::setDefaultName( const OUString& rDefaultName )
+{
+    mxFilePicker->setDefaultName( rDefaultName );
+}
+OUString FileOpenDialog::getURL() const
+{
+    Sequence< OUString > aFileSeq( mxFilePicker->getSelectedFiles() );
+    return aFileSeq.hasElements() ? aFileSeq[ 0 ] : OUString();
+};
+OUString FileOpenDialog::getFilterName() const
+{
+    OUString aFilterName;
+    Reference< XFilterManager > xFilterManager( mxFilePicker, UNO_QUERY_THROW );
+    OUString aUIName( xFilterManager->getCurrentFilter() );
+    auto aIter = std::find_if(aFilterEntryList.begin(), aFilterEntryList.end(),
+        [&aUIName](const FilterEntry& rFilterEntry) { return rFilterEntry.maUIName == aUIName; });
+    if (aIter != aFilterEntryList.end())
+        aFilterName = aIter->maFilterEntryName;
+    return aFilterName;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/fileopendialog.hxx b/sdext/source/minimizer/fileopendialog.hxx
new file mode 100644
index 000000000..176fe155e
--- /dev/null
+++ b/sdext/source/minimizer/fileopendialog.hxx
@@ -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 .
+ */
+
+
+#ifndef INCLUDED_SDEXT_SOURCE_MINIMIZER_FILEOPENDIALOG_HXX
+#define INCLUDED_SDEXT_SOURCE_MINIMIZER_FILEOPENDIALOG_HXX
+
+#include <vector>
+#include <com/sun/star/ui/dialogs/XFilePicker3.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+
+class FileOpenDialog
+{
+    // a list of filters that are provided within the SaveDialog
+    struct FilterEntry
+    {
+        OUString maFilterEntryName;
+        OUString maType;
+        OUString maUIName;
+        sal_Int32 maFlags;
+
+        FilterEntry() : maFlags( 0 ) {}
+    };
+    css::uno::Reference < css::ui::dialogs::XFilePicker3 > mxFilePicker;
+
+    std::vector< FilterEntry > aFilterEntryList;
+
+public:
+        explicit FileOpenDialog( const css::uno::Reference< css::uno::XComponentContext >& rxContext );
+        ~FileOpenDialog();
+
+        sal_Int16 execute();
+
+        void setDefaultName( const OUString& );
+//      void setDefaultDirectory( const OUString& );
+
+        OUString getURL() const;
+        OUString getFilterName() const;
+};
+
+#endif // INCLUDED_SDEXT_SOURCE_MINIMIZER_FILEOPENDIALOG_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/graphiccollector.cxx b/sdext/source/minimizer/graphiccollector.cxx
new file mode 100644
index 000000000..c307b04b0
--- /dev/null
+++ b/sdext/source/minimizer/graphiccollector.cxx
@@ -0,0 +1,423 @@
+/* -*- 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 "graphiccollector.hxx"
+#include <com/sun/star/awt/XDevice.hpp>
+#include <com/sun/star/frame/Desktop.hpp>
+#include <com/sun/star/drawing/FillStyle.hpp>
+#include <com/sun/star/drawing/BitmapMode.hpp>
+#include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
+#include <com/sun/star/presentation/XPresentationPage.hpp>
+#include <com/sun/star/drawing/XMasterPagesSupplier.hpp>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::awt;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::graphic;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::presentation;
+
+const DeviceInfo& GraphicCollector::GetDeviceInfo( const Reference< XComponentContext >& rxFact )
+{
+    static DeviceInfo aDeviceInfo;
+    if( !aDeviceInfo.Width )
+    {
+        try
+        {
+            Reference< XDesktop2 > xDesktop = Desktop::create( rxFact );
+            Reference< XFrame > xFrame( xDesktop->getActiveFrame() );
+            Reference< XWindow > xWindow( xFrame->getContainerWindow() );
+            Reference< XDevice > xDevice( xWindow, UNO_QUERY_THROW );
+            aDeviceInfo = xDevice->getInfo();
+        }
+        catch( Exception& )
+        {
+        }
+    }
+    return aDeviceInfo;
+}
+
+static void ImpAddEntity( std::vector< GraphicCollector::GraphicEntity >& rGraphicEntities, const GraphicSettings& rGraphicSettings, const GraphicCollector::GraphicUser& rUser )
+{
+    if ( !rGraphicSettings.mbEmbedLinkedGraphics )
+        return;
+
+    auto aIter = std::find_if(rGraphicEntities.begin(), rGraphicEntities.end(),
+        [&rUser](const GraphicCollector::GraphicEntity& rGraphicEntity) {
+            return rGraphicEntity.maUser[ 0 ].mxGraphic == rUser.mxGraphic;
+        });
+    if ( aIter == rGraphicEntities.end() )
+    {
+        GraphicCollector::GraphicEntity aEntity( rUser );
+        rGraphicEntities.push_back( aEntity );
+    }
+    else
+    {
+        if ( rUser.maLogicalSize.Width > aIter->maLogicalSize.Width )
+            aIter->maLogicalSize.Width = rUser.maLogicalSize.Width;
+        if ( rUser.maLogicalSize.Height > aIter->maLogicalSize.Height )
+            aIter->maLogicalSize.Height = rUser.maLogicalSize.Height;
+        aIter->maUser.push_back( rUser );
+    }
+}
+
+static void ImpAddGraphicEntity( const Reference< XComponentContext >& rxMSF, Reference< XShape > const & rxShape, const GraphicSettings& rGraphicSettings, std::vector< GraphicCollector::GraphicEntity >& rGraphicEntities )
+{
+    Reference< XGraphic > xGraphic;
+    Reference< XPropertySet > xShapePropertySet( rxShape, UNO_QUERY_THROW );
+    if ( !(xShapePropertySet->getPropertyValue( "Graphic" ) >>= xGraphic) )
+        return;
+
+    text::GraphicCrop aGraphicCropLogic( 0, 0, 0, 0 );
+
+    GraphicCollector::GraphicUser aUser;
+    aUser.mxShape = rxShape;
+    aUser.mbFillBitmap = false;
+    aUser.mxGraphic = xGraphic;
+    xShapePropertySet->getPropertyValue( "GraphicCrop" ) >>= aGraphicCropLogic;
+    awt::Size aLogicalSize( rxShape->getSize() );
+
+    // calculating the logical size, as if there were no cropping
+    if ( aGraphicCropLogic.Left || aGraphicCropLogic.Right || aGraphicCropLogic.Top || aGraphicCropLogic.Bottom )
+    {
+        awt::Size aSize100thMM( GraphicCollector::GetOriginalSize( rxMSF, xGraphic ) );
+        if ( aSize100thMM.Width && aSize100thMM.Height )
+        {
+            awt::Size aCropSize( aSize100thMM.Width - ( aGraphicCropLogic.Left + aGraphicCropLogic.Right ),
+                                 aSize100thMM.Height - ( aGraphicCropLogic.Top + aGraphicCropLogic.Bottom ));
+            if ( aCropSize.Width && aCropSize.Height )
+            {
+                awt::Size aNewLogSize( static_cast< sal_Int32 >( static_cast< double >( aSize100thMM.Width * aLogicalSize.Width ) / aCropSize.Width ),
+                    static_cast< sal_Int32 >( static_cast< double >( aSize100thMM.Height * aLogicalSize.Height ) / aCropSize.Height ) );
+                aLogicalSize = aNewLogSize;
+            }
+        }
+    }
+    aUser.maGraphicCropLogic = aGraphicCropLogic;
+    aUser.maLogicalSize = aLogicalSize;
+    ImpAddEntity( rGraphicEntities, rGraphicSettings, aUser );
+}
+
+static void ImpAddFillBitmapEntity( const Reference< XComponentContext >& rxMSF, const Reference< XPropertySet >& rxPropertySet, const awt::Size& rLogicalSize,
+    std::vector< GraphicCollector::GraphicEntity >& rGraphicEntities, const GraphicSettings& rGraphicSettings, const Reference< XPropertySet >& rxPagePropertySet )
+{
+    try
+    {
+        FillStyle eFillStyle;
+        if ( rxPropertySet->getPropertyValue( "FillStyle" ) >>= eFillStyle )
+        {
+            if ( eFillStyle == FillStyle_BITMAP )
+            {
+                Reference< XBitmap > xFillBitmap;
+                if ( rxPropertySet->getPropertyValue( "FillBitmap" ) >>= xFillBitmap )
+                {
+                    Reference< XGraphic > xGraphic( xFillBitmap, UNO_QUERY_THROW );
+                    awt::Size aLogicalSize( rLogicalSize );
+                    Reference< XPropertySetInfo > axPropSetInfo( rxPropertySet->getPropertySetInfo() );
+                    if ( axPropSetInfo.is() )
+                    {
+                        if ( axPropSetInfo->hasPropertyByName( "FillBitmapMode" ) )
+                        {
+                            BitmapMode eBitmapMode;
+                            if ( rxPropertySet->getPropertyValue( "FillBitmapMode" ) >>= eBitmapMode )
+                            {
+                                if ( ( eBitmapMode == BitmapMode_REPEAT ) || ( eBitmapMode == BitmapMode_NO_REPEAT ) )
+                                {
+                                    bool bLogicalSize = false;
+                                    awt::Size aSize( 0, 0 );
+                                    if ( ( rxPropertySet->getPropertyValue( "FillBitmapLogicalSize" ) >>= bLogicalSize )
+                                      && ( rxPropertySet->getPropertyValue( "FillBitmapSizeX" ) >>= aSize.Width )
+                                      && ( rxPropertySet->getPropertyValue( "FillBitmapSizeY" ) >>= aSize.Height ) )
+                                    {
+                                        if ( bLogicalSize )
+                                        {
+                                            if ( !aSize.Width || !aSize.Height )
+                                            {
+                                                awt::Size aSize100thMM( GraphicCollector::GetOriginalSize( rxMSF, xGraphic ) );
+                                                if ( aSize100thMM.Width && aSize100thMM.Height )
+                                                    aLogicalSize = aSize100thMM;
+                                            }
+                                            else
+                                                aLogicalSize = aSize;
+                                        }
+                                        else
+                                        {
+                                            aLogicalSize.Width = sal::static_int_cast< sal_Int32 >( ( static_cast< double >( aLogicalSize.Width ) * aSize.Width ) / -100.0 );
+                                            aLogicalSize.Height = sal::static_int_cast< sal_Int32 >( ( static_cast< double >( aLogicalSize.Height ) * aSize.Height ) / -100.0 );
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    GraphicCollector::GraphicUser aUser;
+                    aUser.mxPropertySet = rxPropertySet;
+                    aUser.mxGraphic = xGraphic;
+                    aUser.mbFillBitmap = true;
+                    aUser.maLogicalSize = aLogicalSize;
+                    aUser.mxPagePropertySet = rxPagePropertySet;
+                    ImpAddEntity( rGraphicEntities, rGraphicSettings, aUser );
+                }
+            }
+        }
+    }
+    catch( Exception& )
+    {
+    }
+}
+
+static void ImpCollectBackgroundGraphic( const Reference< XComponentContext >& rxMSF, const Reference< XDrawPage >& rxDrawPage, const GraphicSettings& rGraphicSettings, std::vector< GraphicCollector::GraphicEntity >& rGraphicEntities )
+{
+    try
+    {
+        awt::Size aLogicalSize( 28000, 21000 );
+        Reference< XPropertySet > xPropertySet( rxDrawPage, UNO_QUERY_THROW );
+        xPropertySet->getPropertyValue( "Width" ) >>= aLogicalSize.Width;
+        xPropertySet->getPropertyValue( "Height" ) >>= aLogicalSize.Height;
+
+        Reference< XPropertySet > xBackgroundPropSet;
+        if ( xPropertySet->getPropertyValue( "Background" ) >>= xBackgroundPropSet )
+            ImpAddFillBitmapEntity( rxMSF, xBackgroundPropSet, aLogicalSize, rGraphicEntities, rGraphicSettings, xPropertySet );
+    }
+    catch( Exception& )
+    {
+    }
+}
+
+static void ImpCollectGraphicObjects( const Reference< XComponentContext >& rxMSF, const Reference< XShapes >& rxShapes, const GraphicSettings& rGraphicSettings, std::vector< GraphicCollector::GraphicEntity >& rGraphicEntities )
+{
+    for ( sal_Int32 i = 0; i < rxShapes->getCount(); i++ )
+    {
+        try
+        {
+            Reference< XShape > xShape( rxShapes->getByIndex( i ), UNO_QUERY_THROW );
+            const OUString sShapeType( xShape->getShapeType() );
+            if ( sShapeType == "com.sun.star.drawing.GroupShape" )
+            {
+                Reference< XShapes > xShapes( xShape, UNO_QUERY_THROW );
+                ImpCollectGraphicObjects( rxMSF, xShapes, rGraphicSettings, rGraphicEntities );
+                continue;
+            }
+
+            if ( sShapeType == "com.sun.star.drawing.GraphicObjectShape" ||
+                 sShapeType == "com.sun.star.presentation.GraphicObjectShape" )
+                ImpAddGraphicEntity( rxMSF, xShape, rGraphicSettings, rGraphicEntities );
+
+            // now check for a fillstyle
+            Reference< XPropertySet > xEmptyPagePropSet;
+            Reference< XPropertySet > xShapePropertySet( xShape, UNO_QUERY_THROW );
+            awt::Size aLogicalSize( xShape->getSize() );
+            ImpAddFillBitmapEntity( rxMSF, xShapePropertySet, aLogicalSize, rGraphicEntities, rGraphicSettings, xEmptyPagePropSet );
+        }
+        catch( Exception& )
+        {
+        }
+    }
+}
+
+awt::Size GraphicCollector::GetOriginalSize( const Reference< XComponentContext >& rxMSF, const Reference< XGraphic >& rxGraphic )
+{
+    awt::Size aSize100thMM( 0, 0 );
+    Reference< XPropertySet > xGraphicPropertySet( rxGraphic, UNO_QUERY_THROW );
+    if ( xGraphicPropertySet->getPropertyValue( "Size100thMM" ) >>= aSize100thMM )
+    {
+        if ( !aSize100thMM.Width && !aSize100thMM.Height )
+        {   // MAPMODE_PIXEL USED :-(
+            awt::Size aSourceSizePixel( 0, 0 );
+            if ( xGraphicPropertySet->getPropertyValue( "SizePixel" ) >>= aSourceSizePixel )
+            {
+                const DeviceInfo& rDeviceInfo( GraphicCollector::GetDeviceInfo( rxMSF ) );
+                if ( rDeviceInfo.PixelPerMeterX && rDeviceInfo.PixelPerMeterY )
+                {
+                    aSize100thMM.Width = static_cast< sal_Int32 >( ( aSourceSizePixel.Width * 100000.0 ) / rDeviceInfo.PixelPerMeterX );
+                    aSize100thMM.Height = static_cast< sal_Int32 >( ( aSourceSizePixel.Height * 100000.0 ) / rDeviceInfo.PixelPerMeterY );
+                }
+            }
+        }
+    }
+    return aSize100thMM;
+}
+
+void GraphicCollector::CollectGraphics( const Reference< XComponentContext >& rxMSF, const Reference< XModel >& rxModel,
+        const GraphicSettings& rGraphicSettings, std::vector< GraphicCollector::GraphicEntity >& rGraphicList )
+{
+    try
+    {
+        sal_Int32 i;
+        Reference< XDrawPagesSupplier > xDrawPagesSupplier( rxModel, UNO_QUERY_THROW );
+        Reference< XDrawPages > xDrawPages( xDrawPagesSupplier->getDrawPages(), UNO_SET_THROW );
+        for ( i = 0; i < xDrawPages->getCount(); i++ )
+        {
+            Reference< XDrawPage > xDrawPage( xDrawPages->getByIndex( i ), UNO_QUERY_THROW );
+            ImpCollectBackgroundGraphic( rxMSF, xDrawPage, rGraphicSettings, rGraphicList );
+            ImpCollectGraphicObjects( rxMSF, xDrawPage, rGraphicSettings, rGraphicList );
+
+            Reference< XPresentationPage > xPresentationPage( xDrawPage, UNO_QUERY_THROW );
+            Reference< XDrawPage > xNotesPage( xPresentationPage->getNotesPage() );
+            ImpCollectBackgroundGraphic( rxMSF, xNotesPage, rGraphicSettings, rGraphicList );
+            ImpCollectGraphicObjects( rxMSF, xNotesPage, rGraphicSettings, rGraphicList );
+        }
+        Reference< XMasterPagesSupplier > xMasterPagesSupplier( rxModel, UNO_QUERY_THROW );
+        Reference< XDrawPages > xMasterPages( xMasterPagesSupplier->getMasterPages(), UNO_SET_THROW );
+        for ( i = 0; i < xMasterPages->getCount(); i++ )
+        {
+            Reference< XDrawPage > xMasterPage( xMasterPages->getByIndex( i ), UNO_QUERY_THROW );
+            ImpCollectBackgroundGraphic( rxMSF, xMasterPage, rGraphicSettings, rGraphicList );
+            ImpCollectGraphicObjects( rxMSF, xMasterPage, rGraphicSettings, rGraphicList );
+        }
+
+        for( auto& rGraphic : rGraphicList )
+        {
+            // check if it is possible to remove the crop area
+            rGraphic.mbRemoveCropArea = rGraphicSettings.mbRemoveCropArea;
+            if ( rGraphic.mbRemoveCropArea )
+            {
+                std::vector< GraphicCollector::GraphicUser >::iterator aGUIter( rGraphic.maUser.begin() );
+                while( rGraphic.mbRemoveCropArea && ( aGUIter != rGraphic.maUser.end() ) )
+                {
+                    if ( aGUIter->maGraphicCropLogic.Left || aGUIter->maGraphicCropLogic.Top
+                        || aGUIter->maGraphicCropLogic.Right || aGUIter->maGraphicCropLogic.Bottom )
+                    {
+                        if ( aGUIter == rGraphic.maUser.begin() )
+                            rGraphic.maGraphicCropLogic = aGUIter->maGraphicCropLogic;
+                        else if ( ( rGraphic.maGraphicCropLogic.Left != aGUIter->maGraphicCropLogic.Left )
+                            || ( rGraphic.maGraphicCropLogic.Top != aGUIter->maGraphicCropLogic.Top )
+                            || ( rGraphic.maGraphicCropLogic.Right != aGUIter->maGraphicCropLogic.Right )
+                            || ( rGraphic.maGraphicCropLogic.Bottom != aGUIter->maGraphicCropLogic.Bottom ) )
+                        {
+                            rGraphic.mbRemoveCropArea = false;
+                        }
+                    }
+                    else
+                        rGraphic.mbRemoveCropArea = false;
+                    ++aGUIter;
+                }
+            }
+            if ( !rGraphic.mbRemoveCropArea )
+                rGraphic.maGraphicCropLogic = text::GraphicCrop( 0, 0, 0, 0 );
+        }
+    }
+    catch ( Exception& )
+    {
+    }
+}
+
+static void ImpCountGraphicObjects( const Reference< XComponentContext >& rxMSF, const Reference< XShapes >& rxShapes, const GraphicSettings& rGraphicSettings, sal_Int32& rnGraphics )
+{
+    for ( sal_Int32 i = 0; i < rxShapes->getCount(); i++ )
+    {
+        try
+        {
+            Reference< XShape > xShape( rxShapes->getByIndex( i ), UNO_QUERY_THROW );
+            const OUString sShapeType( xShape->getShapeType() );
+            if ( sShapeType == "com.sun.star.drawing.GroupShape" )
+            {
+                Reference< XShapes > xShapes( xShape, UNO_QUERY_THROW );
+                ImpCountGraphicObjects( rxMSF, xShapes, rGraphicSettings, rnGraphics );
+                continue;
+            }
+
+            if ( sShapeType == "com.sun.star.drawing.GraphicObjectShape" ||
+                 sShapeType == "com.sun.star.presentation.GraphicObjectShape" )
+            {
+                rnGraphics++;
+            }
+
+            // now check for a fillstyle
+            Reference< XPropertySet > xShapePropertySet( xShape, UNO_QUERY_THROW );
+            FillStyle eFillStyle;
+            if ( xShapePropertySet->getPropertyValue( "FillStyle" ) >>= eFillStyle )
+            {
+                if ( eFillStyle == FillStyle_BITMAP )
+                {
+                    rnGraphics++;
+                }
+            }
+        }
+        catch( Exception& )
+        {
+        }
+    }
+}
+
+static void ImpCountBackgroundGraphic(
+    const Reference< XDrawPage >& rxDrawPage, sal_Int32& rnGraphics )
+{
+    try
+    {
+        awt::Size aLogicalSize( 28000, 21000 );
+        Reference< XPropertySet > xPropertySet( rxDrawPage, UNO_QUERY_THROW );
+        xPropertySet->getPropertyValue( "Width" ) >>= aLogicalSize.Width;
+        xPropertySet->getPropertyValue( "Height" ) >>= aLogicalSize.Height;
+
+        Reference< XPropertySet > xBackgroundPropSet;
+        if ( xPropertySet->getPropertyValue( "Background" ) >>= xBackgroundPropSet )
+        {
+            FillStyle eFillStyle;
+            if ( xBackgroundPropSet->getPropertyValue( "FillStyle" ) >>= eFillStyle )
+            {
+                if ( eFillStyle == FillStyle_BITMAP )
+                {
+                    rnGraphics++;
+                }
+            }
+        }
+    }
+    catch( Exception& )
+    {
+    }
+}
+
+void GraphicCollector::CountGraphics( const Reference< XComponentContext >& rxMSF, const Reference< XModel >& rxModel,
+        const GraphicSettings& rGraphicSettings, sal_Int32& rnGraphics )
+{
+    try
+    {
+        sal_Int32 i;
+        Reference< XDrawPagesSupplier > xDrawPagesSupplier( rxModel, UNO_QUERY_THROW );
+        Reference< XDrawPages > xDrawPages( xDrawPagesSupplier->getDrawPages(), UNO_SET_THROW );
+        for ( i = 0; i < xDrawPages->getCount(); i++ )
+        {
+            Reference< XDrawPage > xDrawPage( xDrawPages->getByIndex( i ), UNO_QUERY_THROW );
+            ImpCountBackgroundGraphic( xDrawPage, rnGraphics );
+            ImpCountGraphicObjects( rxMSF, xDrawPage, rGraphicSettings, rnGraphics );
+
+            Reference< XPresentationPage > xPresentationPage( xDrawPage, UNO_QUERY_THROW );
+            Reference< XDrawPage > xNotesPage( xPresentationPage->getNotesPage() );
+            ImpCountBackgroundGraphic( xNotesPage, rnGraphics );
+            ImpCountGraphicObjects( rxMSF, xNotesPage, rGraphicSettings, rnGraphics );
+        }
+        Reference< XMasterPagesSupplier > xMasterPagesSupplier( rxModel, UNO_QUERY_THROW );
+        Reference< XDrawPages > xMasterPages( xMasterPagesSupplier->getMasterPages(), UNO_SET_THROW );
+        for ( i = 0; i < xMasterPages->getCount(); i++ )
+        {
+            Reference< XDrawPage > xMasterPage( xMasterPages->getByIndex( i ), UNO_QUERY_THROW );
+            ImpCountBackgroundGraphic( xMasterPage, rnGraphics );
+            ImpCountGraphicObjects( rxMSF, xMasterPage, rGraphicSettings, rnGraphics );
+        }
+    }
+    catch ( Exception& )
+    {
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/graphiccollector.hxx b/sdext/source/minimizer/graphiccollector.hxx
new file mode 100644
index 000000000..f989a95ad
--- /dev/null
+++ b/sdext/source/minimizer/graphiccollector.hxx
@@ -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 .
+ */
+
+#ifndef INCLUDED_SDEXT_SOURCE_MINIMIZER_GRAPHICCOLLECTOR_HXX
+#define INCLUDED_SDEXT_SOURCE_MINIMIZER_GRAPHICCOLLECTOR_HXX
+
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <com/sun/star/awt/DeviceInfo.hpp>
+#include <com/sun/star/text/GraphicCrop.hpp>
+#include <com/sun/star/drawing/XShape.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/awt/Size.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <vector>
+
+
+struct GraphicSettings
+{
+    bool    mbJPEGCompression;
+    sal_Int32   mnJPEGQuality;
+    bool    mbRemoveCropArea;
+    sal_Int32   mnImageResolution;
+    bool    mbEmbedLinkedGraphics;
+
+    GraphicSettings( bool bJPEGCompression, sal_Int32 nJPEGQuality, bool bRemoveCropArea,
+                        sal_Int32 nImageResolution, bool bEmbedLinkedGraphics )
+    : mbJPEGCompression( bJPEGCompression )
+    , mnJPEGQuality( nJPEGQuality )
+    , mbRemoveCropArea( bRemoveCropArea )
+    , mnImageResolution( nImageResolution )
+    , mbEmbedLinkedGraphics( bEmbedLinkedGraphics ) {};
+};
+
+class GraphicCollector
+{
+    public:
+
+    struct GraphicUser
+    {
+        css::uno::Reference< css::drawing::XShape >       mxShape;            // if mbFillBitmap is false the xShape has
+        css::uno::Reference< css::beans::XPropertySet >   mxPropertySet;      // to be used otherwise the PropertySet
+        css::uno::Reference< css::beans::XPropertySet >   mxPagePropertySet;
+        css::uno::Reference< css::graphic::XGraphic > mxGraphic;
+
+        css::text::GraphicCrop         maGraphicCropLogic;
+        css::awt::Size                 maLogicalSize;
+        bool                            mbFillBitmap;
+
+        GraphicUser() : mxShape(), maGraphicCropLogic( 0, 0, 0, 0 ), mbFillBitmap( false ) {};
+    };
+
+    struct GraphicEntity
+    {
+        css::awt::Size                              maLogicalSize;                          // the biggest logical size the graphic will be displayed
+        bool                                        mbRemoveCropArea;
+        css::text::GraphicCrop                      maGraphicCropLogic;
+        std::vector< GraphicUser >                      maUser;
+
+        explicit GraphicEntity( const GraphicUser& rUser )
+            : maLogicalSize( rUser.maLogicalSize ), mbRemoveCropArea( false ), maGraphicCropLogic( 0, 0, 0, 0 ) { maUser.push_back( rUser ); };
+    };
+
+    static const css::awt::DeviceInfo& GetDeviceInfo( const css::uno::Reference< css::uno::XComponentContext >& rxFact );
+    static css::awt::Size GetOriginalSize( const css::uno::Reference< css::uno::XComponentContext >& rxMSF,
+                const css::uno::Reference< css::graphic::XGraphic >& rxGraphic );
+
+    // collecting graphic instances, the downside of this method is that every graphic is swapped in
+    static void CollectGraphics( const css::uno::Reference< css::uno::XComponentContext >& rxMSF, const css::uno::Reference< css::frame::XModel >& rxModel,
+        const GraphicSettings& rGraphicSettings, std::vector< GraphicEntity >& io_rGraphicList );
+    // counting graphics without swapping in graphics
+    static void CountGraphics( const css::uno::Reference< css::uno::XComponentContext >& rxMSF, const css::uno::Reference< css::frame::XModel >& rxModel,
+        const GraphicSettings& rGraphicSettings, sal_Int32& rGraphics );
+};
+
+
+#endif // INCLUDED_SDEXT_SOURCE_MINIMIZER_GRAPHICCOLLECTOR_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/impoptimizer.cxx b/sdext/source/minimizer/impoptimizer.cxx
new file mode 100644
index 000000000..7de159177
--- /dev/null
+++ b/sdext/source/minimizer/impoptimizer.cxx
@@ -0,0 +1,702 @@
+/* -*- 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 "impoptimizer.hxx"
+#include "pppoptimizer.hxx"
+#include "graphiccollector.hxx"
+#include "pagecollector.hxx"
+#include "informationdialog.hxx"
+
+#include <vector>
+#include <com/sun/star/util/URL.hpp>
+#include <com/sun/star/util/XURLTransformer.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/awt/Size.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/frame/Desktop.hpp>
+#include <com/sun/star/awt/XWindow.hpp>
+#include <com/sun/star/frame/XStorable.hpp>
+#include <com/sun/star/frame/FrameSearchFlag.hpp>
+#include <com/sun/star/frame/XDispatchProvider.hpp>
+#include <com/sun/star/graphic/GraphicProvider.hpp>
+#include <com/sun/star/graphic/XGraphicProvider.hpp>
+#include <com/sun/star/drawing/XShapes.hpp>
+#include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
+#include <com/sun/star/drawing/XMasterPagesSupplier.hpp>
+#include <com/sun/star/presentation/XPresentationPage.hpp>
+#include <com/sun/star/document/XFilter.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/graphic/GraphicType.hpp>
+#include <com/sun/star/io/XStream.hpp>
+#include <com/sun/star/io/XSeekable.hpp>
+#include <com/sun/star/io/TempFile.hpp>
+#include <com/sun/star/frame/XComponentLoader.hpp>
+#include <com/sun/star/util/URLTransformer.hpp>
+
+#include <comphelper/propertyvalue.hxx>
+
+using namespace ::std;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::io;
+using namespace ::com::sun::star::awt;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::graphic;
+using namespace ::com::sun::star::document;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::presentation;
+
+static void ImpExtractCustomShow( const Reference< XModel >& rxModel, std::u16string_view rCustomShowName )
+{
+    vector< Reference< XDrawPage > > vNonUsedPageList;
+    try
+    {
+        PageCollector::CollectNonCustomShowPages( rxModel, rCustomShowName, vNonUsedPageList );
+        Reference< XDrawPagesSupplier > xDrawPagesSupplier( rxModel, UNO_QUERY_THROW );
+        Reference< XDrawPages > xDrawPages( xDrawPagesSupplier->getDrawPages(), UNO_SET_THROW );
+        for( const auto& rxPage : vNonUsedPageList )
+            xDrawPages->remove( rxPage );
+    }
+    catch( Exception& )
+    {
+
+    }
+}
+
+static void ImpDeleteUnusedMasterPages( const Reference< XModel >& rxModel )
+{
+    vector< PageCollector::MasterPageEntity > aMasterPageList;
+    PageCollector::CollectMasterPages( rxModel, aMasterPageList );
+
+    // now master pages that are not marked can be deleted
+    Reference< XMasterPagesSupplier > xMasterPagesSupplier( rxModel, UNO_QUERY_THROW );
+    Reference< XDrawPages > xMasterPages( xMasterPagesSupplier->getMasterPages(), UNO_SET_THROW );
+    for( const auto& rMasterPage : aMasterPageList )
+    {
+        if ( !rMasterPage.bUsed )
+            xMasterPages->remove( rMasterPage.xMasterPage );
+    }
+}
+
+static void ImpDeleteHiddenSlides(  const Reference< XModel >& rxModel )
+{
+    try
+    {
+        Reference< XDrawPagesSupplier > xDrawPagesSupplier( rxModel, UNO_QUERY_THROW );
+        Reference< XDrawPages > xDrawPages( xDrawPagesSupplier->getDrawPages(), UNO_SET_THROW );
+        for( sal_Int32 i = 0; i < xDrawPages->getCount(); i++ )
+        {
+            Reference< XDrawPage > xDrawPage( xDrawPages->getByIndex( i ), UNO_QUERY_THROW );
+            Reference< XPropertySet > xPropSet( xDrawPage, UNO_QUERY_THROW );
+
+            bool bVisible = true;
+            if ( xPropSet->getPropertyValue( "Visible" ) >>= bVisible )
+            {
+                if (!bVisible )
+                {
+                    xDrawPages->remove( xDrawPage );
+                    i--;
+                }
+            }
+        }
+    }
+    catch( Exception& )
+    {
+    }
+}
+
+static void ImpDeleteNotesPages( const Reference< XModel >& rxModel )
+{
+    try
+    {
+        Reference< XDrawPagesSupplier > xDrawPagesSupplier( rxModel, UNO_QUERY_THROW );
+        Reference< XDrawPages > xDrawPages( xDrawPagesSupplier->getDrawPages(), UNO_SET_THROW );
+        sal_Int32 i, nPages = xDrawPages->getCount();
+        for( i = 0; i < nPages; i++ )
+        {
+            Reference< XPresentationPage > xPresentationPage( xDrawPages->getByIndex( i ), UNO_QUERY_THROW );
+            Reference< XPropertySet > xPropSet( xPresentationPage->getNotesPage(), UNO_QUERY_THROW );
+            Reference< XShapes > xShapes( xPropSet, UNO_QUERY_THROW );
+            while( xShapes->getCount() )
+                xShapes->remove( Reference< XShape >( xShapes->getByIndex( xShapes->getCount() - 1 ), UNO_QUERY_THROW ) );
+
+            xPropSet->setPropertyValue( "Layout", Any( sal_Int16(21) ) );
+        }
+    }
+    catch( Exception& )
+    {
+    }
+}
+
+static void ImpConvertOLE( const Reference< XModel >& rxModel, sal_Int32 nOLEOptimizationType )
+{
+    try
+    {
+        Reference< XDrawPagesSupplier > xDrawPagesSupplier( rxModel, UNO_QUERY_THROW );
+        Reference< XDrawPages > xDrawPages( xDrawPagesSupplier->getDrawPages(), UNO_SET_THROW );
+        for ( sal_Int32 i = 0; i < xDrawPages->getCount(); i++ )
+        {
+            Reference< XShapes > xShapes( xDrawPages->getByIndex( i ), UNO_QUERY_THROW );
+            for ( sal_Int32 j = 0; j < xShapes->getCount(); j++ )
+            {
+                Reference< XShape > xShape( xShapes->getByIndex( j ), UNO_QUERY_THROW );
+                if ( xShape->getShapeType() == "com.sun.star.drawing.OLE2Shape" )
+                {
+                    Reference< XPropertySet > xPropSet( xShape, UNO_QUERY_THROW );
+
+                    bool bConvertOLE = nOLEOptimizationType == 0;
+                    if ( nOLEOptimizationType == 1 )
+                    {
+                        bool bIsInternal = true;
+                        xPropSet->getPropertyValue( "IsInternal" ) >>= bIsInternal;
+                        bConvertOLE = !bIsInternal;
+                    }
+                    if ( bConvertOLE )
+                    {
+                        Reference< XGraphic > xGraphic;
+                        if ( xPropSet->getPropertyValue( "Graphic" ) >>= xGraphic )
+                        {
+                            Reference< XMultiServiceFactory > xFact( rxModel, UNO_QUERY_THROW );
+                            Reference< XShape > xShape2( xFact->createInstance( "com.sun.star.drawing.GraphicObjectShape" ), UNO_QUERY_THROW );
+                            xShapes->add( xShape2 );
+                            xShape2->setPosition( xShape->getPosition() );
+                            xShape2->setSize( xShape->getSize() );
+                            Reference< XPropertySet > xPropSet2( xShape2, UNO_QUERY_THROW );
+                            xPropSet2->setPropertyValue( "Graphic", Any( xGraphic ) );
+                            xShapes->remove( xShape );
+                            xPropSet2->setPropertyValue( "ZOrder", Any( j ) );
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch( Exception& )
+    {
+    }
+}
+
+static void ImpCompressGraphic( Reference< XGraphicProvider > const & rxGraphicProvider, const Reference< XGraphic >& rxGraphic, Reference< XOutputStream > const & rxOutputStream,
+    const OUString& rDestMimeType, const awt::Size& rLogicalSize, sal_Int32 nJPEGQuality, sal_Int32 nImageResolution, bool bRemoveCropping, const text::GraphicCrop& rGraphicCropLogic )
+{
+    try
+    {
+        if ( rxGraphicProvider.is() && rxOutputStream.is() )
+        {
+            Sequence< PropertyValue > aFilterData{
+                comphelper::makePropertyValue("ImageResolution", nImageResolution),
+                comphelper::makePropertyValue("ColorMode", sal_Int32(0)), // todo: jpeg color mode (0->true color, 1->greyscale)
+                comphelper::makePropertyValue("Quality", nJPEGQuality), // quality that is used if we export to jpeg
+                comphelper::makePropertyValue("Compression", sal_Int32(6)), // compression that is used if we export to png
+                comphelper::makePropertyValue("Interlaced", sal_Int32(0)), // interlaced is turned off if we export to png
+                comphelper::makePropertyValue("LogicalSize", rLogicalSize),
+                comphelper::makePropertyValue("RemoveCropArea", bRemoveCropping),
+                comphelper::makePropertyValue("GraphicCropLogic", rGraphicCropLogic)
+            };
+
+            Sequence< PropertyValue > aArgs{
+                comphelper::makePropertyValue("MimeType", rDestMimeType), // the GraphicProvider is using "MimeType", the GraphicExporter "MediaType"...
+                comphelper::makePropertyValue("OutputStream", rxOutputStream),
+                comphelper::makePropertyValue("FilterData", aFilterData)
+            };
+
+            rxGraphicProvider->storeGraphic( rxGraphic, aArgs );
+        }
+    }
+    catch( Exception& )
+    {
+    }
+}
+
+static Reference< XGraphic > ImpCompressGraphic( const Reference< XComponentContext >& rxContext,
+    const Reference< XGraphic >& xGraphic, const awt::Size& aLogicalSize, const text::GraphicCrop& aGraphicCropLogic,
+        const GraphicSettings& rGraphicSettings )
+{
+    Reference< XGraphic > xNewGraphic;
+    try
+    {
+        OUString aSourceMimeType;
+        Reference< XPropertySet > xGraphicPropertySet( xGraphic, UNO_QUERY_THROW );
+        if ( xGraphicPropertySet->getPropertyValue( "MimeType" ) >>= aSourceMimeType )
+        {
+            sal_Int8 nGraphicType( xGraphic->getType() );
+            if ( nGraphicType == css::graphic::GraphicType::PIXEL )
+            {
+                bool bTransparent = false;
+                bool bAlpha       = false;
+                bool bAnimated    = false;
+
+                awt::Size aSourceSizePixel( 0, 0 );
+                text::GraphicCrop aGraphicCropPixel( 0, 0, 0, 0 );
+
+                if ( ( xGraphicPropertySet->getPropertyValue( "SizePixel" ) >>= aSourceSizePixel ) &&
+                    ( xGraphicPropertySet->getPropertyValue( "Transparent" ) >>= bTransparent ) &&
+                    ( xGraphicPropertySet->getPropertyValue( "Alpha" ) >>= bAlpha ) &&
+                    ( xGraphicPropertySet->getPropertyValue( "Animated" ) >>= bAnimated ) )
+                {
+                    awt::Size aDestSizePixel( aSourceSizePixel );
+                    if ( !bAnimated )
+                    {
+                        bool bNeedsOptimizing = false;
+                        bool bRemoveCropArea( rGraphicSettings.mbRemoveCropArea );
+
+                        // cropping has to be removed from SourceSizePixel
+                        if ( aGraphicCropLogic.Left || aGraphicCropLogic.Top || aGraphicCropLogic.Right || aGraphicCropLogic.Bottom )
+                        {
+                            const awt::Size aSize100thMM( GraphicCollector::GetOriginalSize( rxContext, xGraphic ) );
+
+                            if ( bRemoveCropArea )
+                                bNeedsOptimizing = true;
+
+                            if ( aSize100thMM.Width && aSize100thMM.Height )
+                            {
+                                aGraphicCropPixel.Left = static_cast< sal_Int32 >( ( static_cast<double>(aSourceSizePixel.Width) * aGraphicCropLogic.Left ) / aSize100thMM.Width );
+                                aGraphicCropPixel.Top = static_cast< sal_Int32 >( ( static_cast<double>(aSourceSizePixel.Height)* aGraphicCropLogic.Top ) / aSize100thMM.Height );
+                                aGraphicCropPixel.Right = static_cast< sal_Int32 >( ( static_cast<double>(aSourceSizePixel.Width) * ( aSize100thMM.Width - aGraphicCropLogic.Right ) ) / aSize100thMM.Width );
+                                aGraphicCropPixel.Bottom = static_cast< sal_Int32 >( ( static_cast<double>(aSourceSizePixel.Height)* ( aSize100thMM.Height - aGraphicCropLogic.Bottom ) ) / aSize100thMM.Height );
+
+                                // first calculating new SourceSizePixel by removing the cropped area
+                                aSourceSizePixel.Width = aGraphicCropPixel.Right - aGraphicCropPixel.Left;
+                                aSourceSizePixel.Height= aGraphicCropPixel.Bottom - aGraphicCropPixel.Top;
+                            }
+                            else
+                            {
+                                bRemoveCropArea = false;
+                            }
+                        }
+                        if ( ( aSourceSizePixel.Width > 0 ) && ( aSourceSizePixel.Height > 0 ) )
+                        {
+                            OUString aDestMimeType( "image/png"  );
+                            if (rGraphicSettings.mbJPEGCompression && !bTransparent && !bAlpha)
+                            {
+                                aDestMimeType = "image/jpeg";
+//                                      if( aSourceMimeType != aDestMimeType )
+                                bNeedsOptimizing = true;
+                            }
+                            if ( bRemoveCropArea )
+                                aDestSizePixel = aSourceSizePixel;
+                            if ( rGraphicSettings.mnImageResolution && aLogicalSize.Width && aLogicalSize.Height )
+                            {
+                                const double fSourceDPIX = static_cast<double>(aSourceSizePixel.Width) / (static_cast<double>(aLogicalSize.Width) / 2540.0 );
+                                const double fSourceDPIY = static_cast<double>(aSourceSizePixel.Height)/ (static_cast<double>(aLogicalSize.Height)/ 2540.0 );
+
+                                // check, if the bitmap DPI exceeds the maximum DPI
+                                if( ( fSourceDPIX > rGraphicSettings.mnImageResolution ) || ( fSourceDPIY > rGraphicSettings.mnImageResolution ) )
+                                {
+                                    const double fNewSizePixelX = (static_cast<double>(aDestSizePixel.Width) * rGraphicSettings.mnImageResolution ) / fSourceDPIX;
+                                    const double fNewSizePixelY = (static_cast<double>(aDestSizePixel.Height)* rGraphicSettings.mnImageResolution ) / fSourceDPIY;
+
+                                    aDestSizePixel = awt::Size( static_cast<sal_Int32>(fNewSizePixelX), static_cast<sal_Int32>(fNewSizePixelY) );
+                                    bNeedsOptimizing = true;
+                                }
+                            }
+                            if ( bNeedsOptimizing && aDestSizePixel.Width && aDestSizePixel.Height )
+                            {
+                                Reference< XStream > xTempFile( io::TempFile::create(rxContext), UNO_QUERY_THROW );
+                                Reference< XOutputStream > xOutputStream( xTempFile->getOutputStream() );
+                                Reference< XGraphicProvider > xGraphicProvider( GraphicProvider::create( rxContext ) );
+
+                                ImpCompressGraphic( xGraphicProvider, xGraphic, xOutputStream, aDestMimeType, aLogicalSize, rGraphicSettings.mnJPEGQuality, rGraphicSettings.mnImageResolution, bRemoveCropArea, aGraphicCropLogic );
+                                Reference< XInputStream > xInputStream( xTempFile->getInputStream() );
+                                Reference< XSeekable > xSeekable( xInputStream, UNO_QUERY_THROW );
+                                xSeekable->seek( 0 );
+                                Sequence< PropertyValue > aArgs{ comphelper::makePropertyValue(
+                                    "InputStream", xInputStream) };
+                                xNewGraphic = xGraphicProvider->queryGraphic( aArgs );
+                            }
+                        }
+                    }
+                }
+            }
+            else // this is a metafile
+            {
+                const OUString& aDestMimeType( aSourceMimeType );
+                Reference< XStream > xTempFile( io::TempFile::create(rxContext), UNO_QUERY_THROW );
+                Reference< XOutputStream > xOutputStream( xTempFile->getOutputStream() );
+                Reference< XGraphicProvider > xGraphicProvider( GraphicProvider::create( rxContext ) );
+                ImpCompressGraphic( xGraphicProvider, xGraphic, xOutputStream, aDestMimeType, aLogicalSize, rGraphicSettings.mnJPEGQuality, rGraphicSettings.mnImageResolution, false, aGraphicCropLogic );
+                Reference< XInputStream > xInputStream( xTempFile->getInputStream() );
+                Reference< XSeekable > xSeekable( xInputStream, UNO_QUERY_THROW );
+                xSeekable->seek( 0 );
+                Sequence< PropertyValue > aArgs{ comphelper::makePropertyValue("InputStream",
+                                                                               xInputStream) };
+                xNewGraphic = xGraphicProvider->queryGraphic( aArgs );
+            }
+        }
+    }
+    catch( Exception& )
+    {
+    }
+    return xNewGraphic;
+}
+
+static void CompressGraphics( ImpOptimizer& rOptimizer, const Reference< XComponentContext >& rxContext, const GraphicSettings& rGraphicSettings,
+    std::vector< GraphicCollector::GraphicEntity >& rGraphicList )
+{
+    try
+    {
+        double i = 0;
+        for( auto& rGraphic : rGraphicList )
+        {
+            i++;
+            sal_Int32 nProgress = static_cast< sal_Int32 >( 40.0 * ( i / static_cast< double >( rGraphicList.size() ) ) ) + 50;
+            rOptimizer.SetStatusValue( TK_Progress, Any( nProgress ) );
+            rOptimizer.DispatchStatus();
+
+            if ( !rGraphic.maUser.empty() )
+            {
+                GraphicSettings aGraphicSettings( rGraphicSettings );
+                aGraphicSettings.mbRemoveCropArea = rGraphic.mbRemoveCropArea;
+
+                Reference< XGraphic > xGraphic;
+                if ( rGraphic.maUser[ 0 ].mbFillBitmap && rGraphic.maUser[ 0 ].mxPropertySet.is() )
+                {
+                    Reference< XBitmap > xFillBitmap;
+                    if ( rGraphic.maUser[ 0 ].mxPropertySet->getPropertyValue( "FillBitmap" ) >>= xFillBitmap )
+                        xGraphic.set( xFillBitmap, UNO_QUERY_THROW );
+                }
+                else if ( rGraphic.maUser[ 0 ].mxShape.is() )
+                {
+                    Reference< XPropertySet > xShapePropertySet( rGraphic.maUser[ 0 ].mxShape, UNO_QUERY_THROW );
+                    xShapePropertySet->getPropertyValue( "Graphic" ) >>= xGraphic;
+                }
+                if ( xGraphic.is() )
+                {
+                    Reference< XPropertySet > xNewGraphicPropertySet( xGraphic, UNO_QUERY_THROW );
+                    awt::Size aSize100thMM( GraphicCollector::GetOriginalSize( rxContext, xGraphic ) );
+                    Reference< XGraphic > xNewGraphic( ImpCompressGraphic( rxContext, xGraphic, rGraphic.maLogicalSize, rGraphic.maGraphicCropLogic, aGraphicSettings ) );
+                    if ( xNewGraphic.is() )
+                    {
+                        // applying graphic to each user
+                        for( auto& rGraphicUser : rGraphic.maUser )
+                        {
+                            if ( rGraphicUser.mxShape.is() )
+                            {
+                                Reference< XPropertySet > xShapePropertySet( rGraphicUser.mxShape, UNO_QUERY_THROW );
+                                xShapePropertySet->setPropertyValue( "Graphic", Any( xNewGraphic ) );
+
+                                if ( rGraphicUser.maGraphicCropLogic.Left || rGraphicUser.maGraphicCropLogic.Top
+                                || rGraphicUser.maGraphicCropLogic.Right || rGraphicUser.maGraphicCropLogic.Bottom )
+                                {   // removing crop area was not possible or shouldn't been applied
+                                    text::GraphicCrop aGraphicCropLogic( 0, 0, 0, 0 );
+                                    if ( !aGraphicSettings.mbRemoveCropArea )
+                                    {
+                                        awt::Size aNewSize( GraphicCollector::GetOriginalSize( rxContext, xNewGraphic ) );
+                                        aGraphicCropLogic.Left = static_cast<sal_Int32>(static_cast<double>(rGraphicUser.maGraphicCropLogic.Left) * (static_cast<double>(aNewSize.Width) / static_cast<double>(aSize100thMM.Width)));
+                                        aGraphicCropLogic.Top = static_cast<sal_Int32>(static_cast<double>(rGraphicUser.maGraphicCropLogic.Top) * (static_cast<double>(aNewSize.Height) / static_cast<double>(aSize100thMM.Height)));
+                                        aGraphicCropLogic.Right = static_cast<sal_Int32>(static_cast<double>(rGraphicUser.maGraphicCropLogic.Right) * (static_cast<double>(aNewSize.Width) / static_cast<double>(aSize100thMM.Width)));
+                                        aGraphicCropLogic.Bottom = static_cast<sal_Int32>(static_cast<double>(rGraphicUser.maGraphicCropLogic.Bottom) * (static_cast<double>(aNewSize.Height) / static_cast<double>(aSize100thMM.Height)));
+                                    }
+                                    xShapePropertySet->setPropertyValue( "GraphicCrop", Any( aGraphicCropLogic ) );
+                                }
+                            }
+                            else if ( rGraphicUser.mxPropertySet.is() )
+                            {
+                                Reference< XBitmap > xFillBitmap( xNewGraphic, UNO_QUERY );
+                                if ( xFillBitmap.is() )
+                                {
+                                    awt::Size aSize;
+                                    bool bLogicalSize;
+
+                                    Reference< XPropertySet >& rxPropertySet( rGraphicUser.mxPropertySet );
+                                    rxPropertySet->setPropertyValue( "FillBitmap", Any( xFillBitmap ) );
+                                    if ( ( rxPropertySet->getPropertyValue( "FillBitmapLogicalSize" ) >>= bLogicalSize )
+                                        && ( rxPropertySet->getPropertyValue( "FillBitmapSizeX" ) >>= aSize.Width )
+                                        && ( rxPropertySet->getPropertyValue( "FillBitmapSizeY" ) >>= aSize.Height ) )
+                                    {
+                                        if ( !aSize.Width || !aSize.Height )
+                                        {
+                                            rxPropertySet->setPropertyValue( "FillBitmapLogicalSize", Any( true ) );
+                                            rxPropertySet->setPropertyValue( "FillBitmapSizeX", Any( rGraphicUser.maLogicalSize.Width ) );
+                                            rxPropertySet->setPropertyValue( "FillBitmapSizeY", Any( rGraphicUser.maLogicalSize.Height ) );
+                                        }
+                                    }
+                                    if ( rGraphicUser.mxPagePropertySet.is() )
+                                        rGraphicUser.mxPagePropertySet->setPropertyValue( "Background", Any( rxPropertySet ) );
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch ( Exception& )
+    {
+    }
+}
+
+
+ImpOptimizer::ImpOptimizer( const Reference< XComponentContext >& rxContext, const Reference< XModel >& rxModel ) :
+    mxContext                   ( rxContext ),
+    mxModel                     ( rxModel ),
+    mbJPEGCompression           ( false ),
+    mnJPEGQuality               ( 90 ),
+    mbRemoveCropArea            ( false ),
+    mnImageResolution           ( 0 ),
+    mbEmbedLinkedGraphics       ( true ),
+    mbOLEOptimization           ( false ),
+    mnOLEOptimizationType       ( 0 ),
+    mbDeleteUnusedMasterPages   ( false ),
+    mbDeleteHiddenSlides        ( false ),
+    mbDeleteNotesPages          ( false ),
+    mbOpenNewDocument           ( true )
+{
+}
+
+
+ImpOptimizer::~ImpOptimizer()
+{
+}
+
+
+void ImpOptimizer::DispatchStatus()
+{
+    if ( mxStatusDispatcher.is() )
+    {
+        URL aURL;
+        aURL.Protocol = "vnd.com.sun.star.comp.PresentationMinimizer:";
+        aURL.Path = "statusupdate";
+        mxStatusDispatcher->dispatch( aURL, GetStatusSequence() );
+    }
+}
+
+
+void ImpOptimizer::Optimize()
+{
+
+    if ( !maCustomShowName.isEmpty() )
+        ImpExtractCustomShow( mxModel, maCustomShowName );
+
+    if ( mbDeleteHiddenSlides )
+    {
+        SetStatusValue( TK_Progress, Any( static_cast< sal_Int32 >( 40 ) ) );
+        SetStatusValue( TK_Status, Any( OUString("STR_DELETING_SLIDES") ) );
+        DispatchStatus();
+        ImpDeleteHiddenSlides( mxModel );
+    }
+
+    if ( mbDeleteNotesPages )
+    {
+        SetStatusValue( TK_Status, Any( OUString("STR_DELETING_SLIDES") ) );
+        DispatchStatus();
+        ImpDeleteNotesPages( mxModel );
+    }
+
+    if ( mbDeleteUnusedMasterPages )
+    {
+        SetStatusValue( TK_Progress, Any( static_cast< sal_Int32 >( 40 ) ) );
+        SetStatusValue( TK_Status, Any( OUString("STR_DELETING_SLIDES") ) );
+        DispatchStatus();
+        ImpDeleteUnusedMasterPages( mxModel );
+    }
+
+    if ( mbOLEOptimization )
+    {
+        SetStatusValue( TK_Progress, Any( static_cast< sal_Int32 >( 45 ) ) );
+        SetStatusValue( TK_Status, Any( OUString("STR_CREATING_OLE_REPLACEMENTS") ) );
+        DispatchStatus();
+        ImpConvertOLE( mxModel, mnOLEOptimizationType );
+    }
+
+    if ( mbJPEGCompression || mbRemoveCropArea || mnImageResolution )
+    {
+        SetStatusValue( TK_Progress, Any( static_cast< sal_Int32 >( 50 ) ) );
+        SetStatusValue( TK_Status, Any( OUString("STR_OPTIMIZING_GRAPHICS") ) );
+        DispatchStatus();
+
+        std::vector< GraphicCollector::GraphicEntity > aGraphicList;
+        GraphicSettings aGraphicSettings( mbJPEGCompression, mnJPEGQuality, mbRemoveCropArea, mnImageResolution, mbEmbedLinkedGraphics );
+        GraphicCollector::CollectGraphics( mxContext, mxModel, aGraphicSettings, aGraphicList );
+        CompressGraphics( *this, mxContext, aGraphicSettings, aGraphicList );
+    }
+    SetStatusValue( TK_Progress, Any( static_cast< sal_Int32 >( 100 ) ) );
+    DispatchStatus();
+}
+
+static void DispatchURL( const Reference< XComponentContext >& xContext, const OUString& sURL, const Reference< XFrame >& xFrame )
+{
+    try
+    {
+        Reference< XURLTransformer > xURLTransformer( URLTransformer::create(xContext) );
+        util::URL aUrl;
+        aUrl.Complete = sURL;
+        xURLTransformer->parseStrict( aUrl );
+        Sequence< PropertyValue > aArgs;
+        Reference< XDispatchProvider > xDispatchProvider( xFrame, UNO_QUERY_THROW );
+        Reference< XDispatch > xDispatch = xDispatchProvider->queryDispatch( aUrl, OUString(), 0 );  // "_self"
+        if ( xDispatch.is() )
+            xDispatch->dispatch( aUrl, aArgs );
+    }
+    catch( Exception& )
+    {
+    }
+}
+
+
+void ImpOptimizer::Optimize( const Sequence< PropertyValue >& rArguments )
+{
+    if ( !mxModel.is() )
+        return;
+
+    sal_Int64 nEstimatedFileSize = 0;
+    SetStatusValue( TK_Progress, Any( static_cast< sal_Int32 >( 0 ) ) );
+    DispatchStatus();
+
+    for ( const auto& rArgument : rArguments )
+    {
+        switch( TKGet( rArgument.Name ) )
+        {
+            case TK_StatusDispatcher : rArgument.Value >>= mxStatusDispatcher; break;
+            case TK_InformationDialog: rArgument.Value >>= mxInformationDialog; break;
+            case TK_Settings :
+            {
+                css::uno::Sequence< css::beans::PropertyValue > aSettings;
+                rArgument.Value >>= aSettings;
+                for ( const auto& rSetting : std::as_const(aSettings) )
+                {
+                    switch( TKGet( rSetting.Name ) )
+                    {
+                        case TK_JPEGCompression         : rSetting.Value >>= mbJPEGCompression; break;
+                        case TK_JPEGQuality             : rSetting.Value >>= mnJPEGQuality; break;
+                        case TK_RemoveCropArea          : rSetting.Value >>= mbRemoveCropArea; break;
+                        case TK_ImageResolution         : rSetting.Value >>= mnImageResolution; break;
+                        case TK_EmbedLinkedGraphics     : rSetting.Value >>= mbEmbedLinkedGraphics; break;
+                        case TK_OLEOptimization         : rSetting.Value >>= mbOLEOptimization; break;
+                        case TK_OLEOptimizationType     : rSetting.Value >>= mnOLEOptimizationType; break;
+                        case TK_CustomShowName          : rSetting.Value >>= maCustomShowName; break;
+                        case TK_DeleteUnusedMasterPages : rSetting.Value >>= mbDeleteUnusedMasterPages; break;
+                        case TK_DeleteHiddenSlides      : rSetting.Value >>= mbDeleteHiddenSlides; break;
+                        case TK_DeleteNotesPages        : rSetting.Value >>= mbDeleteNotesPages; break;
+                        case TK_SaveAsURL               : rSetting.Value >>= maSaveAsURL; break;
+                        case TK_FilterName              : rSetting.Value >>= maFilterName; break;
+                        case TK_OpenNewDocument         : rSetting.Value >>= mbOpenNewDocument; break;
+                        case TK_EstimatedFileSize       : rSetting.Value >>= nEstimatedFileSize; break;
+                        default: break;
+                    }
+                }
+            }
+            break;
+            default: break;
+        }
+    }
+
+    sal_Int64 nSourceSize = 0;
+    sal_Int64 nDestSize = 0;
+
+    Reference< XFrame > xSelf;
+    if ( !maSaveAsURL.isEmpty() )
+    {
+
+        SetStatusValue( TK_Progress, Any( static_cast< sal_Int32 >( 10 ) ) );
+        SetStatusValue( TK_Status, Any( OUString("STR_DUPLICATING_PRESENTATION") ) );
+        DispatchStatus();
+
+        Reference< XStorable >xStorable( mxModel, UNO_QUERY );
+        if ( xStorable.is() )
+        {
+            if ( xStorable->hasLocation() )
+                nSourceSize = PPPOptimizer::GetFileSize( xStorable->getLocation() );
+
+            Sequence< PropertyValue > aArguments;
+            if ( !maFilterName.isEmpty() )
+            {
+                int nLength = aArguments.getLength();
+                aArguments.realloc( nLength + 1 );
+                auto pArguments = aArguments.getArray();
+                pArguments[ nLength ].Name = "FilterName";
+                pArguments[ nLength ].Value <<= maFilterName;
+            }
+            xStorable->storeToURL( maSaveAsURL, aArguments );
+            if ( !nSourceSize )
+                nSourceSize = PPPOptimizer::GetFileSize( maSaveAsURL );
+
+            SetStatusValue( TK_Progress, Any( static_cast< sal_Int32 >( 30 ) ) );
+            SetStatusValue( TK_Status, Any( OUString("STR_DUPLICATING_PRESENTATION") ) );
+            DispatchStatus();
+
+            Reference< XDesktop2 > xDesktop = Desktop::create( mxContext );
+            xSelf = xDesktop->findFrame( "_blank", FrameSearchFlag::CREATE );
+            Reference< XComponentLoader > xComponentLoader( xSelf, UNO_QUERY );
+
+            Sequence< PropertyValue > aLoadProps{ comphelper::makePropertyValue("Hidden", true) };
+            mxModel.set( xComponentLoader->loadComponentFromURL(
+                maSaveAsURL, "_self", 0, aLoadProps ), UNO_QUERY );
+        }
+    }
+
+    // check if the document is ReadOnly -> error
+    Reference< XStorable > xStorable( mxModel, UNO_QUERY );
+    if ( xStorable.is() && !xStorable->isReadonly() )
+    {
+        mxModel->lockControllers();
+        Optimize();
+        mxModel->unlockControllers();
+
+        // clearing undo stack:
+        Reference< XFrame > xFrame( xSelf.is() ? xSelf : mxInformationDialog );
+        if ( xFrame.is() )
+        {
+            DispatchURL(mxContext, ".uno:ClearUndoStack", xFrame);
+        }
+    }
+
+    if ( !maSaveAsURL.isEmpty() )
+    {
+        if ( xStorable.is() )
+        {
+            xStorable->store();
+            nDestSize = PPPOptimizer::GetFileSize( maSaveAsURL );
+        }
+    }
+
+    if ( mxInformationDialog.is() )
+    {
+        InformationDialog aInformationDialog( mxContext, mxInformationDialog, maSaveAsURL, mbOpenNewDocument, nSourceSize, nDestSize, nEstimatedFileSize );
+        aInformationDialog.execute();
+        SetStatusValue( TK_OpenNewDocument, Any( mbOpenNewDocument ) );
+        DispatchStatus();
+    }
+
+    if ( !maSaveAsURL.isEmpty() )
+    {
+        if ( mbOpenNewDocument && xSelf.is() )
+        {
+            Reference< awt::XWindow > xContainerWindow( xSelf->getContainerWindow() );
+            xContainerWindow->setVisible( true );
+        }
+        else
+        {
+            mxModel->dispose();
+        }
+    }
+    if ( nSourceSize && nDestSize )
+    {
+        SetStatusValue( TK_FileSizeSource, Any( nSourceSize ) );
+        SetStatusValue( TK_FileSizeDestination, Any( nDestSize ) );
+        DispatchStatus();
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/impoptimizer.hxx b/sdext/source/minimizer/impoptimizer.hxx
new file mode 100644
index 000000000..6a52e9498
--- /dev/null
+++ b/sdext/source/minimizer/impoptimizer.hxx
@@ -0,0 +1,70 @@
+/* -*- 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 .
+ */
+
+#ifndef INCLUDED_SDEXT_SOURCE_MINIMIZER_IMPOPTIMIZER_HXX
+#define INCLUDED_SDEXT_SOURCE_MINIMIZER_IMPOPTIMIZER_HXX
+
+#include "optimizationstats.hxx"
+#include <com/sun/star/uno/Sequence.h>
+#include <com/sun/star/frame/XDispatch.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+
+
+class ImpOptimizer : public OptimizationStats
+{
+private:
+
+    css::uno::Reference< css::uno::XComponentContext >    mxContext;
+    css::uno::Reference< css::frame::XModel >             mxModel;
+    css::uno::Reference< css::frame::XDispatch >          mxStatusDispatcher;
+
+    bool        mbJPEGCompression;
+    sal_Int32   mnJPEGQuality;
+    bool        mbRemoveCropArea;
+    sal_Int32   mnImageResolution;
+    bool        mbEmbedLinkedGraphics;
+    bool        mbOLEOptimization;
+    sal_Int32   mnOLEOptimizationType;
+    OUString    maCustomShowName;
+    bool        mbDeleteUnusedMasterPages;
+    bool        mbDeleteHiddenSlides;
+    bool        mbDeleteNotesPages;
+    OUString    maSaveAsURL;
+    OUString    maFilterName;
+    bool        mbOpenNewDocument;
+
+    css::uno::Reference< css::frame::XFrame > mxInformationDialog;
+
+    void Optimize();
+
+public:
+
+        ImpOptimizer( const css::uno::Reference< css::uno::XComponentContext >& rXFactory,
+            const css::uno::Reference< css::frame::XModel >& rxModel );
+        ~ImpOptimizer();
+
+        void     Optimize( const css::uno::Sequence< css::beans::PropertyValue >& rArguments );
+        void     DispatchStatus();
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/informationdialog.cxx b/sdext/source/minimizer/informationdialog.cxx
new file mode 100644
index 000000000..0797e7856
--- /dev/null
+++ b/sdext/source/minimizer/informationdialog.cxx
@@ -0,0 +1,350 @@
+/* -*- 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 "informationdialog.hxx"
+#include <com/sun/star/awt/PushButtonType.hpp>
+#include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp>
+#include <com/sun/star/util/URL.hpp>
+#include <com/sun/star/util/URLTransformer.hpp>
+#include <com/sun/star/util/XURLTransformer.hpp>
+#include <rtl/ustrbuf.hxx>
+#include <sal/macros.h>
+
+#define DIALOG_WIDTH    240
+#define DIALOG_HEIGHT   80
+#define PAGE_POS_X      35
+#define PAGE_WIDTH      ( DIALOG_WIDTH - PAGE_POS_X ) - 6
+
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::ui;
+using namespace ::com::sun::star::awt;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::container;
+
+
+OUString InsertFixedText( UnoDialog& rInformationDialog, const OUString& rControlName, const OUString& rLabel,
+                                sal_Int32 nXPos, sal_Int32 nYPos, sal_Int32 nWidth, sal_Int32 nHeight, bool bMultiLine, sal_Int16 nTabIndex )
+{
+    OUString pNames[] = {
+        OUString("Height"),
+        OUString("Label"),
+        OUString("MultiLine"),
+        OUString("PositionX"),
+        OUString("PositionY"),
+        OUString("Step"),
+        OUString("TabIndex"),
+        OUString("Width") };
+
+    Any pValues[] = {
+        Any( nHeight ),
+        Any( rLabel ),
+        Any( bMultiLine ),
+        Any( nXPos ),
+        Any( nYPos ),
+        Any( sal_Int16(0) ),
+        Any( nTabIndex ),
+        Any( nWidth ) };
+
+    sal_Int32 nCount = SAL_N_ELEMENTS( pNames );
+
+    Sequence< OUString >   aNames( pNames, nCount );
+    Sequence< Any >             aValues( pValues, nCount );
+
+    rInformationDialog.insertFixedText( rControlName, aNames, aValues );
+    return rControlName;
+}
+
+OUString InsertImage(
+    UnoDialog& rInformationDialog,
+    const OUString& rControlName,
+    const OUString& rURL,
+    sal_Int32 nPosX,
+    sal_Int32 nPosY,
+    sal_Int32 nWidth,
+    sal_Int32 nHeight,
+    bool bScale )
+{
+    OUString pNames[] = {
+        OUString("Border"),
+        OUString("Height"),
+        OUString("ImageURL"),
+        OUString("PositionX"),
+        OUString("PositionY"),
+        OUString("ScaleImage"),
+        OUString("Width") };
+
+    Any pValues[] = {
+        Any( sal_Int16( 0 ) ),
+        Any( nHeight ),
+        Any( rURL ),
+        Any( nPosX ),
+        Any( nPosY ),
+        Any( bScale ),
+        Any( nWidth ) };
+    sal_Int32 nCount = SAL_N_ELEMENTS( pNames );
+
+    Sequence< OUString >   aNames( pNames, nCount );
+    Sequence< Any >             aValues( pValues, nCount );
+
+    rInformationDialog.insertImage( rControlName, aNames, aValues );
+    return rControlName;
+}
+
+OUString InsertCheckBox( UnoDialog& rInformationDialog, const OUString& rControlName,
+    const Reference< XItemListener >& rItemListener, const OUString& rLabel,
+    sal_Int32 nXPos, sal_Int32 nYPos, sal_Int32 nWidth, sal_Int16 nTabIndex )
+{
+    sal_Int32 nHeight = 8;
+    OUString pNames[] = {
+        OUString("Enabled"),
+        OUString("Height"),
+        OUString("Label"),
+        OUString("PositionX"),
+        OUString("PositionY"),
+        OUString("Step"),
+        OUString("TabIndex"),
+        OUString("Width") };
+
+    Any pValues[] = {
+        Any( true ),
+        Any( nHeight ),
+        Any( rLabel ),
+        Any( nXPos ),
+        Any( nYPos ),
+        Any( sal_Int16(0) ),
+        Any( nTabIndex ),
+        Any( nWidth ) };
+
+    sal_Int32 nCount = SAL_N_ELEMENTS( pNames );
+
+    Sequence< OUString >   aNames( pNames, nCount );
+    Sequence< Any >             aValues( pValues, nCount );
+
+    Reference< XCheckBox > xCheckBox( rInformationDialog.insertCheckBox( rControlName, aNames, aValues ) );
+    if ( rItemListener.is() )
+        xCheckBox->addItemListener( rItemListener );
+    return rControlName;
+}
+
+OUString InsertButton( UnoDialog& rInformationDialog, const OUString& rControlName, Reference< XActionListener > const & xActionListener,
+    sal_Int32 nXPos, sal_Int32 nYPos, sal_Int32 nWidth, sal_Int16 nTabIndex, const OUString& rText )
+{
+    sal_Int32 nHeight = 14;
+    OUString pNames[] = {
+        OUString("Enabled"),
+        OUString("Height"),
+        OUString("Label"),
+        OUString("PositionX"),
+        OUString("PositionY"),
+        OUString("PushButtonType"),
+        OUString("Step"),
+        OUString("TabIndex"),
+        OUString("Width") };
+
+    Any pValues[] = {
+        Any( true ),
+        Any( nHeight ),
+        Any( rText ),
+        Any( nXPos ),
+        Any( nYPos ),
+        Any( static_cast< sal_Int16 >( PushButtonType_OK ) ),
+        Any( sal_Int16(0) ),
+        Any( nTabIndex ),
+        Any( nWidth ) };
+
+
+    sal_Int32 nCount = SAL_N_ELEMENTS( pNames );
+
+    Sequence< OUString >   aNames( pNames, nCount );
+    Sequence< Any >             aValues( pValues, nCount );
+
+    rInformationDialog.insertButton( rControlName, xActionListener, aNames, aValues );
+    return rControlName;
+}
+
+
+static OUString ImpValueOfInMB( sal_Int64 rVal )
+{
+    double fVal( static_cast<double>( rVal ) );
+    fVal /= ( 1 << 20 );
+    fVal += 0.05;
+    OUStringBuffer aVal( OUString::number( fVal ) );
+    sal_Int32 nX( aVal.indexOf( '.' ) );
+    if ( nX > 0 )
+        aVal.setLength( nX + 2 );
+    return aVal.makeStringAndClear();
+}
+
+void InformationDialog::InitDialog()
+{
+    sal_Int32 nDialogHeight = DIALOG_HEIGHT;
+    if ( maSaveAsURL.isEmpty() )
+        nDialogHeight -= 22;
+
+   // setting the dialog properties
+    OUString pNames[] = {
+        OUString("Closeable"),
+        OUString("Height"),
+        OUString("Moveable"),
+        OUString("PositionX"),
+        OUString("PositionY"),
+        OUString("Title"),
+        OUString("Width") };
+
+    Any pValues[] = {
+        Any( true ),
+        Any( nDialogHeight ),
+        Any( true ),
+        Any( sal_Int32( 245 ) ),
+        Any( sal_Int32( 115 ) ),
+        Any( getString( STR_SUN_OPTIMIZATION_WIZARD2 ) ),
+        Any( sal_Int32( DIALOG_WIDTH ) ) };
+
+    sal_Int32 nCount = SAL_N_ELEMENTS( pNames );
+
+    Sequence< OUString >   aNames( pNames, nCount );
+    Sequence< Any >             aValues( pValues, nCount );
+
+    setPropertyValues(aNames, aValues);
+
+    sal_Int64 nSource = mnSourceSize;
+    sal_Int64 nDest   = mnDestSize;
+
+    PPPOptimizerTokenEnum eInfoString( STR_INFO_1 );
+    if ( mnSourceSize )
+    {
+        if ( mnDestSize )
+            eInfoString = STR_INFO_1;
+        else
+        {
+            eInfoString = STR_INFO_2;
+            nDest = mnApproxSize;
+        }
+    }
+    else if ( mnDestSize )
+        eInfoString = STR_INFO_3;
+    else
+    {
+        eInfoString = STR_INFO_4;
+        nDest = mnApproxSize;
+    }
+
+    OUString aTitle;
+    if ( !maSaveAsURL.isEmpty() )
+    {
+        Reference< XURLTransformer > xURLTransformer( URLTransformer::create(UnoDialog::mxContext) );
+        util::URL aURL, aPresentationURL;
+        aURL.Complete = maSaveAsURL;
+        xURLTransformer->parseSmart( aURL, OUString() );
+
+        static const OUStringLiteral sFileProtocol( u"file:///" );
+        aPresentationURL.Complete = sFileProtocol + aURL.Name;
+        aTitle = xURLTransformer->getPresentation( aPresentationURL, false );
+
+        if ( aTitle.match( sFileProtocol ) )
+            aTitle = aTitle.replaceAt( 0, sFileProtocol.getLength(), u"" );
+    }
+
+    OUString aInfoString( getString( eInfoString ) );
+    static const OUStringLiteral aOldSizePlaceholder( u"%OLDFILESIZE"  );
+    static const OUStringLiteral aNewSizePlaceholder( u"%NEWFILESIZE"  );
+    const OUString aTitlePlaceholder( !aTitle.isEmpty() ? OUString("%TITLE"  )
+                                                         : OUString("'%TITLE'") );
+
+    sal_Int32 i = aInfoString.indexOf( aOldSizePlaceholder );
+    if ( i >= 0 )
+        aInfoString = aInfoString.replaceAt( i, aOldSizePlaceholder.getLength(), ImpValueOfInMB( nSource ) );
+
+    sal_Int32 j = aInfoString.indexOf( aNewSizePlaceholder );
+    if ( j >= 0 )
+        aInfoString = aInfoString.replaceAt( j, aNewSizePlaceholder.getLength(), ImpValueOfInMB( nDest ) );
+
+    sal_Int32 k = aInfoString.indexOf( aTitlePlaceholder );
+    if ( k >= 0 )
+        aInfoString = aInfoString.replaceAt( k, aTitlePlaceholder.getLength(), aTitle );
+
+    css::uno::Reference< css::awt::XItemListener > xItemListener;
+    InsertImage( *this,
+                 "aboutimage",
+                 "private:standardimage/query",
+                 5, 5, 25, 25, false );
+    InsertFixedText( *this, "fixedtext", aInfoString, PAGE_POS_X, 6, PAGE_WIDTH, 24, true, 0 );
+    if ( !maSaveAsURL.isEmpty() )
+        InsertCheckBox(  *this, "OpenNewDocument", xItemListener, getString( STR_AUTOMATICALLY_OPEN ), PAGE_POS_X, 42, PAGE_WIDTH, 1 );
+    InsertButton( *this, "button", mxActionListener, DIALOG_WIDTH / 2 - 25, nDialogHeight - 20, 50, 2, getString( STR_OK ) );
+
+    bool bOpenNewDocument = mrbOpenNewDocument;
+    setControlProperty( "OpenNewDocument", "State", Any( static_cast<sal_Int16>(bOpenNewDocument) ) );
+}
+
+
+InformationDialog::InformationDialog( const Reference< XComponentContext > &rxContext, Reference< XFrame > const & rxFrame, const OUString& rSaveAsURL, bool& rbOpenNewDocument, sal_Int64 rSourceSize, sal_Int64 rDestSize, sal_Int64 rApproxSize ) :
+    UnoDialog( rxContext, rxFrame ),
+    ConfigurationAccess( rxContext ),
+    mxActionListener( new OKActionListener( *this ) ),
+    mnSourceSize( rSourceSize ),
+    mnDestSize( rDestSize ),
+    mnApproxSize( rApproxSize ),
+    mrbOpenNewDocument( rbOpenNewDocument ),
+    maSaveAsURL( rSaveAsURL )
+{
+    InitDialog();
+}
+
+
+InformationDialog::~InformationDialog()
+{
+}
+
+
+void InformationDialog::execute()
+{
+    UnoDialog::execute();
+
+    if ( !maSaveAsURL.isEmpty() )
+    {
+        sal_Int16 nInt16 = 0;
+        Any aAny( getControlProperty( "OpenNewDocument", "State" ) );
+        if ( aAny >>= nInt16 )
+        {
+            bool bOpenNewDocument = static_cast< bool >( nInt16 );
+            mrbOpenNewDocument = bOpenNewDocument;
+        }
+    }
+}
+
+
+void OKActionListener::actionPerformed( const ActionEvent& rEvent )
+{
+    if ( rEvent.ActionCommand == "button" )
+    {
+        mrDialog.endExecute( true );
+    }
+}
+void OKActionListener::disposing( const css::lang::EventObject& /* Source */ )
+{
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/informationdialog.hxx b/sdext/source/minimizer/informationdialog.hxx
new file mode 100644
index 000000000..761a40e01
--- /dev/null
+++ b/sdext/source/minimizer/informationdialog.hxx
@@ -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 .
+ */
+
+#ifndef INCLUDED_SDEXT_SOURCE_MINIMIZER_INFORMATIONDIALOG_HXX
+#define INCLUDED_SDEXT_SOURCE_MINIMIZER_INFORMATIONDIALOG_HXX
+
+#include "unodialog.hxx"
+#include "configurationaccess.hxx"
+#include <com/sun/star/awt/XItemListener.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <cppuhelper/implbase.hxx>
+
+OUString InsertFixedText( UnoDialog& rInformationDialog, const OUString& rControlName, const OUString& rLabel,
+                                sal_Int32 nXPos, sal_Int32 nYPos, sal_Int32 nWidth, sal_Int32 nHeight, bool bMultiLine, sal_Int16 nTabIndex );
+
+OUString InsertImage( UnoDialog& rInformationDialog, const OUString& rControlName, const OUString& rURL,
+    sal_Int32 nPosX, sal_Int32 nPosY, sal_Int32 nWidth, sal_Int32 nHeight, bool bScale );
+
+OUString InsertCheckBox( UnoDialog& rInformationDialog, const OUString& rControlName,
+    const css::uno::Reference< css::awt::XItemListener >& rItemListener, const OUString& rLabel,
+    sal_Int32 nXPos, sal_Int32 nYPos, sal_Int32 nWidth, sal_Int16 nTabIndex );
+
+OUString InsertButton( UnoDialog& rInformationDialog, const OUString& rControlName,
+    css::uno::Reference< css::awt::XActionListener > const & xActionListener, sal_Int32 nXPos, sal_Int32 nYPos,
+    sal_Int32 nWidth, sal_Int16 nTabIndex, const OUString& rText );
+
+class InformationDialog : public UnoDialog, public ConfigurationAccess
+{
+public:
+
+    InformationDialog( const css::uno::Reference< css::uno::XComponentContext >& rxContext,
+                       css::uno::Reference< css::frame::XFrame > const & rxFrame, const OUString& rSaveAsURL,
+                       bool& bOpenNewDocument, sal_Int64 nSourceSize, sal_Int64 nDestSize, sal_Int64 nApproxDest );
+    ~InformationDialog();
+
+    void                execute();
+
+private:
+
+    css::uno::Reference< css::awt::XActionListener >  mxActionListener;
+
+    void InitDialog();
+
+    sal_Int64 mnSourceSize;
+    sal_Int64 mnDestSize;
+    sal_Int64 mnApproxSize;
+    bool& mrbOpenNewDocument;
+    const OUString& maSaveAsURL;
+};
+
+class OKActionListener : public ::cppu::WeakImplHelper< css::awt::XActionListener >
+{
+public:
+    explicit OKActionListener( UnoDialog& rDialog ) : mrDialog( rDialog ){}
+
+    virtual void SAL_CALL actionPerformed( const css::awt::ActionEvent& Event ) override;
+    virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
+private:
+
+    UnoDialog& mrDialog;
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/minimizer.component b/sdext/source/minimizer/minimizer.component
new file mode 100644
index 000000000..63f92cbbd
--- /dev/null
+++ b/sdext/source/minimizer/minimizer.component
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * 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/.
+ *
+-->
+<component loader="com.sun.star.loader.SharedLibrary" environment="@CPPU_ENV@"
+	xmlns="http://openoffice.org/2010/uno-components">
+    <implementation name="com.sun.star.comp.PresentationMinimizerImp"
+        constructor="sdext_PPPOptimizerDialog_get_implementation">
+        <service name="com.sun.star.comp.PresentationMinimizer"/>
+    </implementation>
+</component>
diff --git a/sdext/source/minimizer/optimizationstats.cxx b/sdext/source/minimizer/optimizationstats.cxx
new file mode 100644
index 000000000..1deef26ac
--- /dev/null
+++ b/sdext/source/minimizer/optimizationstats.cxx
@@ -0,0 +1,86 @@
+/* -*- 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 "optimizationstats.hxx"
+#include <com/sun/star/awt/Size.hpp>
+#include <com/sun/star/drawing/XShapes.hpp>
+#include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
+
+#include <comphelper/propertyvalue.hxx>
+
+#include <algorithm>
+
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::beans;
+
+
+OptimizationStats::OptimizationStats()
+{
+}
+
+
+void OptimizationStats::SetStatusValue( const PPPOptimizerTokenEnum eStat, const uno::Any& rStatValue )
+{
+    maStats[ eStat ] = rStatValue;
+}
+
+
+const uno::Any* OptimizationStats::GetStatusValue( const PPPOptimizerTokenEnum eStat ) const
+{
+    std::map< PPPOptimizerTokenEnum, uno::Any >::const_iterator aIter( maStats.find( eStat ) );
+    return aIter != maStats.end() ? &((*aIter).second) : nullptr;
+}
+
+
+css::beans::PropertyValues OptimizationStats::GetStatusSequence()
+{
+    uno::Sequence< PropertyValue > aStatsSequence( maStats.size() );
+    std::transform(maStats.begin(), maStats.end(), aStatsSequence.getArray(),
+                   [](const auto& rEntry)
+                   { return comphelper::makePropertyValue(TKGet( rEntry.first ), rEntry.second); });
+    return aStatsSequence;
+}
+
+
+void OptimizationStats::InitializeStatusValues( const uno::Sequence< PropertyValue >& rOptimizationStats )
+{
+    for( const auto& rStat : rOptimizationStats )
+        maStats[ TKGet( rStat.Name ) ] = rStat.Value;
+}
+
+
+void OptimizationStats::InitializeStatusValuesFromDocument( const Reference< XModel >& rxModel )
+{
+    try
+    {
+        Reference< XDrawPagesSupplier > xDrawPagesSupplier( rxModel, UNO_QUERY_THROW );
+        Reference< XDrawPages > xDrawPages( xDrawPagesSupplier->getDrawPages(), UNO_SET_THROW );
+        SetStatusValue( TK_Pages, Any( awt::Size( 0, xDrawPages->getCount() ) ) );
+    }
+    catch ( Exception& )
+    {
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/optimizationstats.hxx b/sdext/source/minimizer/optimizationstats.hxx
new file mode 100644
index 000000000..a1af8f30e
--- /dev/null
+++ b/sdext/source/minimizer/optimizationstats.hxx
@@ -0,0 +1,45 @@
+/* -*- 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/uno/Sequence.h>
+#include <com/sun/star/beans/PropertyValues.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include "pppoptimizertoken.hxx"
+#include <map>
+
+class OptimizationStats
+{
+    std::map < PPPOptimizerTokenEnum, css::uno::Any > maStats;
+
+    public:
+
+        OptimizationStats();
+
+        void SetStatusValue( const PPPOptimizerTokenEnum eStat, const css::uno::Any& rStatValue );
+        const css::uno::Any* GetStatusValue( const PPPOptimizerTokenEnum eStat ) const;
+
+        void InitializeStatusValuesFromDocument( const css::uno::Reference< css::frame::XModel >& rxModel );
+        void InitializeStatusValues( const css::uno::Sequence< css::beans::PropertyValue >& rOptimizationStats );
+
+        css::beans::PropertyValues GetStatusSequence();
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/optimizerdialog.cxx b/sdext/source/minimizer/optimizerdialog.cxx
new file mode 100644
index 000000000..3112c6f22
--- /dev/null
+++ b/sdext/source/minimizer/optimizerdialog.cxx
@@ -0,0 +1,780 @@
+/* -*- 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 "optimizerdialog.hxx"
+#include "impoptimizer.hxx"
+#include "fileopendialog.hxx"
+#include <com/sun/star/awt/XItemEventBroadcaster.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/container/XIndexContainer.hpp>
+#include <com/sun/star/frame/XStorable.hpp>
+#include <com/sun/star/frame/XTitle.hpp>
+#include <com/sun/star/lang/XSingleServiceFactory.hpp>
+#include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp>
+#include <com/sun/star/ucb/XSimpleFileAccess.hpp>
+#include <com/sun/star/io/IOException.hpp>
+#include <com/sun/star/util/XModifiable.hpp>
+
+#include <comphelper/propertyvalue.hxx>
+#include <sal/macros.h>
+#include <osl/time.h>
+#include <vcl/errinf.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+#include <svtools/sfxecode.hxx>
+#include <svtools/ehdl.hxx>
+#include <tools/urlobj.hxx>
+#include <o3tl/string_view.hxx>
+#include <bitmaps.hlst>
+
+using namespace ::com::sun::star::io;
+using namespace ::com::sun::star::ui;
+using namespace ::com::sun::star::awt;
+using namespace ::com::sun::star::ucb;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::container;
+
+
+void OptimizerDialog::InitDialog()
+{
+   // setting the dialog properties
+    OUString pNames[] = {
+        OUString("Closeable"),
+        OUString("Height"),
+        OUString("Moveable"),
+        OUString("PositionX"),
+        OUString("PositionY"),
+        OUString("Title"),
+        OUString("Width") };
+
+    Any pValues[] = {
+        Any( true ),
+        Any( sal_Int32( DIALOG_HEIGHT ) ),
+        Any( true ),
+        Any( sal_Int32( 200 ) ),
+        Any( sal_Int32( 52 ) ),
+        Any( getString( STR_SUN_OPTIMIZATION_WIZARD2 ) ),
+        Any( sal_Int32( OD_DIALOG_WIDTH ) ) };
+
+    sal_Int32 nCount = SAL_N_ELEMENTS( pNames );
+
+    Sequence< OUString >   aNames( pNames, nCount );
+    Sequence< Any >             aValues( pValues, nCount );
+
+    setPropertyValues(aNames, aValues);
+}
+
+
+void OptimizerDialog::InitRoadmap()
+{
+    try
+    {
+        OUString pNames[] = {
+            OUString("Height"),
+            OUString("PositionX"),
+            OUString("PositionY"),
+            OUString("Step"),
+            OUString("TabIndex"),
+            OUString("Width") };
+
+        Any pValues[] = {
+            Any( sal_Int32( DIALOG_HEIGHT - 26 ) ),
+            Any( sal_Int32( 0 ) ),
+            Any( sal_Int32( 0 ) ),
+            Any( sal_Int32( 0 ) ),
+            Any( mnTabIndex++ ),
+            Any( sal_Int32( 85 ) ) };
+
+        sal_Int32 nCount = SAL_N_ELEMENTS( pNames );
+
+        Sequence< OUString >   aNames( pNames, nCount );
+        Sequence< Any >        aValues( pValues, nCount );
+
+        mxRoadmapControlModel = insertControlModel( "com.sun.star.awt.UnoControlRoadmapModel",
+                                                              "rdmNavi", aNames, aValues  );
+
+        Reference< XPropertySet > xPropertySet( mxRoadmapControlModel, UNO_QUERY_THROW );
+        xPropertySet->setPropertyValue( "Name", Any( OUString("rdmNavi") ) );
+        mxRoadmapControl = getControl( "rdmNavi" );
+        InsertRoadmapItem( 0, getString( STR_INTRODUCTION ), ITEM_ID_INTRODUCTION );
+        InsertRoadmapItem( 1, getString( STR_SLIDES ), ITEM_ID_SLIDES );
+        InsertRoadmapItem( 2, getString( STR_IMAGE_OPTIMIZATION ), ITEM_ID_GRAPHIC_OPTIMIZATION );
+        InsertRoadmapItem( 3, getString( STR_OLE_OBJECTS ), ITEM_ID_OLE_OPTIMIZATION );
+        InsertRoadmapItem( 4, getString( STR_SUMMARY ), ITEM_ID_SUMMARY );
+
+        xPropertySet->setPropertyValue( "ImageURL", Any( OUString("private:graphicrepository/" BMP_PRESENTATION_MINIMIZER) ) );
+        xPropertySet->setPropertyValue( "Activated", Any( true ) );
+        xPropertySet->setPropertyValue( "Complete", Any( true ) );
+        xPropertySet->setPropertyValue( "CurrentItemID", Any( sal_Int16(ITEM_ID_INTRODUCTION) ) );
+        xPropertySet->setPropertyValue( "Text", Any( getString( STR_STEPS ) ) );
+    }
+    catch( Exception& )
+    {
+    }
+}
+
+
+void OptimizerDialog::InsertRoadmapItem( const sal_Int32 nIndex, const OUString& rLabel, const sal_Int32 nItemID )
+{
+    try
+    {
+        Reference< XSingleServiceFactory > xSFRoadmap( mxRoadmapControlModel, UNO_QUERY_THROW );
+        Reference< XIndexContainer > aIndexContainerRoadmap( mxRoadmapControlModel, UNO_QUERY_THROW );
+        Reference< XInterface > xRoadmapItem( xSFRoadmap->createInstance(), UNO_SET_THROW );
+        Reference< XPropertySet > xPropertySet( xRoadmapItem, UNO_QUERY_THROW );
+        xPropertySet->setPropertyValue( "Label", Any( rLabel ) );
+        xPropertySet->setPropertyValue( "Enabled", Any( true ) );
+        xPropertySet->setPropertyValue( "ID", Any( nItemID ) );
+        aIndexContainerRoadmap->insertByIndex( nIndex, Any( xRoadmapItem ) );
+    }
+    catch( Exception& )
+    {
+
+    }
+}
+
+
+void OptimizerDialog::UpdateConfiguration()
+{
+    sal_Int16   nInt16 = 0;
+    Any         aAny;
+
+    Sequence< sal_Int16 > aSelectedItems;
+    Sequence< OUString > aStringItemList;
+
+    // page0
+    aAny = getControlProperty( "ListBox0Pg0", "SelectedItems" );
+    if ( aAny >>= aSelectedItems )
+    {
+        if ( aSelectedItems.hasElements() )
+        {
+            sal_Int16 nSelectedItem = aSelectedItems[ 0 ];
+            aAny = getControlProperty( "ListBox0Pg0", "StringItemList" );
+            if ( aAny >>= aStringItemList )
+            {
+                if ( aStringItemList.getLength() > nSelectedItem )
+                    SetConfigProperty( TK_Name, Any( aStringItemList[ nSelectedItem ] ) );
+            }
+        }
+    }
+
+    aAny = getControlProperty( "CheckBox3Pg3", "State" );
+    if ( !((aAny >>= nInt16) && nInt16) )
+        return;
+
+    aAny = getControlProperty( "ListBox0Pg3", "SelectedItems" );
+    if ( !(aAny >>= aSelectedItems) )
+        return;
+
+    if ( aSelectedItems.hasElements() )
+    {
+        sal_Int16 nSelectedItem = aSelectedItems[ 0 ];
+        aAny = getControlProperty( "ListBox0Pg3", "StringItemList" );
+        if ( aAny >>= aStringItemList )
+        {
+            if ( aStringItemList.getLength() > nSelectedItem )
+                SetConfigProperty( TK_CustomShowName, Any( aStringItemList[ nSelectedItem ] ) );
+        }
+    }
+}
+
+
+OptimizerDialog::OptimizerDialog( const Reference< XComponentContext > &rxContext, Reference< XFrame > const & rxFrame, Reference< XDispatch > const & rxStatusDispatcher ) :
+    UnoDialog( rxContext, rxFrame ),
+    ConfigurationAccess( rxContext ),
+    mnCurrentStep( 0 ),
+    mnTabIndex( 0 ),
+    mxFrame( rxFrame ),
+    mxItemListener( new ItemListener( *this ) ),
+    mxActionListener( new ActionListener( *this ) ),
+    mxActionListenerListBox0Pg0( new ActionListenerListBox0Pg0( *this ) ),
+    mxTextListenerFormattedField0Pg1( new TextListenerFormattedField0Pg1( *this ) ),
+    mxTextListenerComboBox0Pg1( new TextListenerComboBox0Pg1( *this ) ),
+    mxSpinListenerFormattedField0Pg1( new SpinListenerFormattedField0Pg1( *this ) ),
+    mxStatusDispatcher( rxStatusDispatcher )
+{
+    Reference< XStorable > xStorable( mxController->getModel(), UNO_QUERY_THROW );
+    mbIsReadonly = xStorable->isReadonly();
+
+    InitDialog();
+    InitRoadmap();
+    InitNavigationBar();
+    InitPage0();
+    InitPage1();
+    InitPage2();
+    InitPage3();
+    InitPage4();
+    ActivatePage( 0 );
+
+    OptimizationStats aStats;
+    aStats.InitializeStatusValuesFromDocument( mxController->getModel() );
+    Sequence< PropertyValue > aStatusSequence( aStats.GetStatusSequence() );
+    UpdateStatus( aStatusSequence );
+}
+
+
+OptimizerDialog::~OptimizerDialog()
+{
+    // not saving configuration if the dialog has been finished via cancel or close window
+    if ( endStatus() )
+        SaveConfiguration();
+}
+
+
+void OptimizerDialog::execute()
+{
+    Reference< XItemEventBroadcaster > xRoadmapBroadcaster( mxRoadmapControl, UNO_QUERY_THROW );
+    xRoadmapBroadcaster->addItemListener( mxItemListener );
+    UnoDialog::execute();
+    UpdateConfiguration();          // taking actual control settings for the configuration
+    xRoadmapBroadcaster->removeItemListener( mxItemListener );
+}
+
+
+void OptimizerDialog::SwitchPage( sal_Int16 nNewStep )
+{
+    if ( !(( nNewStep != mnCurrentStep ) && ( nNewStep <= MAX_STEP ) && ( nNewStep >= 0 )) )
+        return;
+
+    sal_Int16 nOldStep = mnCurrentStep;
+    if ( nNewStep == 0 )
+        disableControl( "btnNavBack" );
+    else if ( nOldStep == 0 )
+        enableControl( "btnNavBack" );
+
+    if ( nNewStep == MAX_STEP )
+        disableControl( "btnNavNext" );
+    else if ( nOldStep == MAX_STEP )
+        enableControl( "btnNavNext" );
+
+    setControlProperty( "rdmNavi", "CurrentItemID", Any( nNewStep ) );
+
+    DeactivatePage( nOldStep );
+    UpdateControlStates( nNewStep );
+
+    ActivatePage( nNewStep );
+    mnCurrentStep = nNewStep;
+}
+
+void OptimizerDialog::UpdateControlStates( sal_Int16 nPage )
+{
+    switch( nPage )
+    {
+        case 0 : UpdateControlStatesPage0(); break;
+        case 1 : UpdateControlStatesPage1(); break;
+        case 2 : UpdateControlStatesPage2(); break;
+        case 3 : UpdateControlStatesPage3(); break;
+        case 4 : UpdateControlStatesPage4(); break;
+        default:
+        {
+            UpdateControlStatesPage0();
+            UpdateControlStatesPage1();
+            UpdateControlStatesPage2();
+            UpdateControlStatesPage3();
+            UpdateControlStatesPage4();
+        }
+    }
+}
+
+
+OUString OptimizerDialog::GetSelectedString( OUString const & token )
+{
+    OUString aSelectedItem;
+    Sequence< sal_Int16 > sSelectedItems;
+    Sequence< OUString >  sItemList;
+
+    if ( ( getControlProperty( token, "SelectedItems" ) >>= sSelectedItems ) &&
+            ( getControlProperty( token, "StringItemList" ) >>= sItemList ) )
+    {
+        if ( sSelectedItems.getLength() == 1 )
+        {
+            sal_Int16 nSelectedItem = sSelectedItems[ 0 ];
+            if ( nSelectedItem < sItemList.getLength() )
+                aSelectedItem = sItemList[ nSelectedItem ];
+        }
+    }
+    return aSelectedItem;
+}
+
+
+void OptimizerDialog::UpdateStatus( const css::uno::Sequence< css::beans::PropertyValue >& rStatus )
+{
+    maStats.InitializeStatusValues( rStatus );
+    const Any* pVal( maStats.GetStatusValue( TK_Status ) );
+    if ( pVal )
+    {
+        OUString sStatus;
+        if ( *pVal >>= sStatus )
+        {
+            setControlProperty( "FixedText1Pg4", "Enabled", Any( true ) );
+            setControlProperty( "FixedText1Pg4", "Label", Any( getString( TKGet( sStatus ) ) ) );
+        }
+    }
+    pVal = maStats.GetStatusValue( TK_Progress );
+    if ( pVal )
+    {
+        sal_Int32 nProgress = 0;
+        if ( *pVal >>= nProgress )
+            setControlProperty( "Progress", "ProgressValue", Any( nProgress ) );
+    }
+    pVal = maStats.GetStatusValue( TK_OpenNewDocument );
+    if ( pVal )
+        SetConfigProperty( TK_OpenNewDocument, *pVal );
+
+    reschedule();
+}
+
+
+void ItemListener::itemStateChanged( const ItemEvent& Event )
+{
+    try
+    {
+        sal_Int16 nState;
+        Reference< XControl > xControl;
+        Any aSource( Event.Source );
+        if ( aSource >>= xControl )
+        {
+            Reference< XPropertySet > xPropertySet( xControl->getModel(), UNO_QUERY_THROW );
+            OUString aControlName;
+            xPropertySet->getPropertyValue( "Name" ) >>= aControlName;
+            PPPOptimizerTokenEnum eControl( TKGet( aControlName ) );
+            switch( eControl )
+            {
+                case TK_rdmNavi :
+                {
+                    mrOptimizerDialog.SwitchPage( static_cast< sal_Int16 >( Event.ItemId ) );
+                }
+                break;
+                case TK_CheckBox1Pg1 :
+                {
+                    if ( xPropertySet->getPropertyValue( "State" ) >>= nState )
+                        mrOptimizerDialog.SetConfigProperty( TK_RemoveCropArea, Any( nState != 0 ) );
+                }
+                break;
+                case TK_CheckBox2Pg1 :
+                {
+                    if ( xPropertySet->getPropertyValue( "State" ) >>= nState )
+                        mrOptimizerDialog.SetConfigProperty( TK_EmbedLinkedGraphics, Any( nState != 0 ) );
+                }
+                break;
+                case TK_CheckBox0Pg2 :
+                {
+                    if ( xPropertySet->getPropertyValue( "State" ) >>= nState )
+                    {
+                        mrOptimizerDialog.SetConfigProperty( TK_OLEOptimization, Any( nState != 0 ) );
+                        mrOptimizerDialog.setControlProperty( "RadioButton0Pg2", "Enabled", Any( nState != 0 ) );
+                        mrOptimizerDialog.setControlProperty( "RadioButton1Pg2", "Enabled", Any( nState != 0 ) );
+                    }
+                }
+                break;
+                case TK_RadioButton0Pg1 :
+                {
+                    sal_Int16 nInt16 = 0;
+                    if ( xPropertySet->getPropertyValue( "State" ) >>= nInt16 )
+                    {
+                        nInt16 ^= 1;
+                        mrOptimizerDialog.SetConfigProperty( TK_JPEGCompression, Any( nInt16 != 0 ) );
+                        mrOptimizerDialog.setControlProperty( "FixedText1Pg1", "Enabled", Any( nInt16 != 0 ) );
+                        mrOptimizerDialog.setControlProperty( "FormattedField0Pg1", "Enabled", Any( nInt16 != 0 ) );
+                    }
+                }
+                break;
+                case TK_RadioButton1Pg1 :
+                {
+                    if ( xPropertySet->getPropertyValue( "State" ) >>= nState )
+                    {
+                        mrOptimizerDialog.SetConfigProperty( TK_JPEGCompression, Any( nState != 0 ) );
+                        mrOptimizerDialog.setControlProperty( "FixedText1Pg1", "Enabled", Any( nState != 0 ) );
+                        mrOptimizerDialog.setControlProperty( "FormattedField0Pg1", "Enabled", Any( nState != 0 ) );
+                    }
+                }
+                break;
+                case TK_RadioButton0Pg2 :
+                {
+                    sal_Int16 nInt16;
+                    if ( xPropertySet->getPropertyValue( "State" ) >>= nInt16 )
+                    {
+                        nInt16 ^= 1;
+                        mrOptimizerDialog.SetConfigProperty( TK_OLEOptimizationType, Any( nInt16 ) );
+                    }
+                }
+                break;
+                case TK_RadioButton1Pg2 :
+                {
+                    if ( xPropertySet->getPropertyValue( "State" ) >>= nState )
+                        mrOptimizerDialog.SetConfigProperty( TK_OLEOptimizationType, Any( nState ) );
+                }
+                break;
+                case TK_CheckBox0Pg3 :
+                {
+                    if ( xPropertySet->getPropertyValue( "State" ) >>= nState )
+                        mrOptimizerDialog.SetConfigProperty( TK_DeleteUnusedMasterPages, Any( nState != 0 ) );
+                }
+                break;
+                case TK_CheckBox1Pg3 :
+                {
+                    if ( xPropertySet->getPropertyValue( "State" ) >>= nState )
+                        mrOptimizerDialog.SetConfigProperty( TK_DeleteNotesPages, Any( nState != 0 ) );
+                }
+                break;
+                case TK_CheckBox2Pg3 :
+                {
+                    if ( xPropertySet->getPropertyValue( "State" ) >>= nState )
+                        mrOptimizerDialog.SetConfigProperty( TK_DeleteHiddenSlides, Any( nState != 0 ) );
+                }
+                break;
+                case TK_CheckBox3Pg3 :
+                {
+                    if ( xPropertySet->getPropertyValue( "State" ) >>= nState )
+                        mrOptimizerDialog.setControlProperty( "ListBox0Pg3", "Enabled", Any( nState != 0 ) );
+                }
+                break;
+                case TK_CheckBox1Pg4 :
+                {
+                    if ( xPropertySet->getPropertyValue( "State" ) >>= nState )
+                        mrOptimizerDialog.setControlProperty( "ComboBox0Pg4", "Enabled", Any( nState != 0 ) );
+                }
+                break;
+                case TK_RadioButton0Pg4 :
+                case TK_RadioButton1Pg4 :
+                {
+                    if ( xPropertySet->getPropertyValue( "State" ) >>= nState )
+                        mrOptimizerDialog.SetConfigProperty( TK_SaveAs, Any( eControl == TK_RadioButton1Pg4 ? nState != 0 : nState == 0 ) );
+                }
+                break;
+                default:
+                break;
+            }
+        }
+    }
+    catch ( Exception& )
+    {
+
+    }
+}
+void ItemListener::disposing( const css::lang::EventObject& /* Source */ )
+{
+}
+
+void ActionListener::actionPerformed( const ActionEvent& rEvent )
+{
+    switch( TKGet( rEvent.ActionCommand ) )
+    {
+        case TK_btnNavBack :    mrOptimizerDialog.SwitchPage( mrOptimizerDialog.mnCurrentStep - 1 ); break;
+        case TK_btnNavNext :    mrOptimizerDialog.SwitchPage( mrOptimizerDialog.mnCurrentStep + 1 ); break;
+        case TK_btnNavFinish :
+        {
+            mrOptimizerDialog.UpdateConfiguration();
+
+            mrOptimizerDialog.SwitchPage( ITEM_ID_SUMMARY );
+            mrOptimizerDialog.DisablePage( ITEM_ID_SUMMARY );
+            mrOptimizerDialog.setControlProperty( "btnNavBack", "Enabled", Any( false ) );
+            mrOptimizerDialog.setControlProperty( "btnNavNext", "Enabled", Any( false ) );
+            mrOptimizerDialog.setControlProperty( "btnNavFinish", "Enabled", Any( false ) );
+            mrOptimizerDialog.setControlProperty( "btnNavCancel", "Enabled", Any( false ) );
+            mrOptimizerDialog.setControlProperty( "FixedText0Pg4", "Enabled", Any( true ) );
+
+            // check if we have to open the FileDialog
+            bool    bSuccessfullyExecuted = true;
+            sal_Int16   nInt16 = 0;
+            mrOptimizerDialog.getControlProperty( "RadioButton1Pg4", "State" ) >>= nInt16;
+            if ( nInt16 )
+            {
+                // Duplicate presentation before applying changes
+                OUString aSaveAsURL;
+                FileOpenDialog aFileOpenDialog( mrOptimizerDialog.GetComponentContext() );
+
+                // generating default file name
+                OUString aName;
+                Reference< XStorable > xStorable( mrOptimizerDialog.controller()->getModel(), UNO_QUERY );
+                if ( xStorable.is() && xStorable->hasLocation() )
+                {
+                    INetURLObject aURLObj( xStorable->getLocation() );
+                    if ( !aURLObj.hasFinalSlash() )
+                    {
+                        // tdf#105382 uri-decode file name
+                        aURLObj.removeExtension(INetURLObject::LAST_SEGMENT, false);
+                        aName = aURLObj.getName(INetURLObject::LAST_SEGMENT, false,
+                                                INetURLObject::DecodeMechanism::WithCharset);
+                    }
+                }
+                else
+                {
+                    // If no filename, try to use model title ("Untitled 1" or something like this)
+                    Reference<XTitle> xTitle(
+                        mrOptimizerDialog.GetFrame()->getController()->getModel(), UNO_QUERY);
+                    aName = xTitle->getTitle();
+                }
+
+                if (!aName.isEmpty())
+                {
+                    aName += " " + mrOptimizerDialog.getString(STR_FILENAME_SUFFIX);
+                    aFileOpenDialog.setDefaultName(aName);
+                }
+
+                if (aFileOpenDialog.execute() == dialogs::ExecutableDialogResults::OK)
+                {
+                    aSaveAsURL = aFileOpenDialog.getURL();
+                    mrOptimizerDialog.SetConfigProperty( TK_SaveAsURL, Any( aSaveAsURL ) );
+                    mrOptimizerDialog.SetConfigProperty( TK_FilterName, Any( aFileOpenDialog.getFilterName() ) );
+                }
+                if ( aSaveAsURL.isEmpty() )
+                {
+                    // something goes wrong...
+                    bSuccessfullyExecuted = false;
+                }
+
+                // waiting for 500ms
+                mrOptimizerDialog.reschedule();
+                for ( sal_uInt32 i = osl_getGlobalTimer(); ( i + 500 ) > ( osl_getGlobalTimer() ); )
+                mrOptimizerDialog.reschedule();
+            }
+            else
+            {
+                // Apply changes to current presentation
+                Reference<XModifiable> xModifiable(mrOptimizerDialog.controller()->getModel(),
+                                                   UNO_QUERY_THROW );
+                if ( xModifiable->isModified() )
+                {
+                    SolarMutexGuard aSolarGuard;
+                    std::unique_ptr<weld::MessageDialog> popupDlg(Application::CreateMessageDialog(
+                        nullptr, VclMessageType::Question, VclButtonsType::YesNo,
+                        mrOptimizerDialog.getString(STR_WARN_UNSAVED_PRESENTATION)));
+                    if (popupDlg->run() != RET_YES)
+                    {
+                        // Selected not "yes" ("no" or dialog was cancelled) so return to previous step
+                        mrOptimizerDialog.setControlProperty("btnNavBack", "Enabled",
+                                                                  Any(true));
+                        mrOptimizerDialog.setControlProperty("btnNavNext", "Enabled", Any(false));
+                        mrOptimizerDialog.setControlProperty("btnNavFinish", "Enabled", Any(true));
+                        mrOptimizerDialog.setControlProperty("btnNavCancel", "Enabled", Any(true));
+                        mrOptimizerDialog.EnablePage(ITEM_ID_SUMMARY);
+                        return;
+                    }
+                }
+            }
+            if ( bSuccessfullyExecuted )
+            {   // now check if we have to store a session template
+                nInt16 = 0;
+                OUString aSettingsName;
+                mrOptimizerDialog.getControlProperty( "CheckBox1Pg4", "State" ) >>= nInt16;
+                mrOptimizerDialog.getControlProperty( "ComboBox0Pg4", "Text" ) >>= aSettingsName;
+                if ( nInt16 && !aSettingsName.isEmpty() )
+                {
+                    std::vector< OptimizerSettings >::iterator aIter( mrOptimizerDialog.GetOptimizerSettingsByName( aSettingsName ) );
+                    std::vector< OptimizerSettings >& rSettings( mrOptimizerDialog.GetOptimizerSettings() );
+                    OptimizerSettings aNewSettings( rSettings[ 0 ] );
+                    aNewSettings.maName = aSettingsName;
+                    if ( aIter == rSettings.end() )
+                        rSettings.push_back( aNewSettings );
+                    else
+                        *aIter = aNewSettings;
+                }
+            }
+            if ( bSuccessfullyExecuted )
+            {
+                URL aURL;
+                aURL.Protocol = "vnd.com.sun.star.comp.PPPOptimizer:";
+                aURL.Path = "optimize";
+
+                Sequence< PropertyValue > lArguments{
+                    comphelper::makePropertyValue("Settings", mrOptimizerDialog.GetConfigurationSequence()),
+                    comphelper::makePropertyValue("StatusDispatcher", mrOptimizerDialog.GetStatusDispatcher()),
+                    comphelper::makePropertyValue("InformationDialog", mrOptimizerDialog.GetFrame())
+                };
+
+                ErrCode errorCode;
+                try
+                {
+                    ImpOptimizer aOptimizer(
+                        mrOptimizerDialog.GetComponentContext(),
+                        mrOptimizerDialog.GetFrame()->getController()->getModel());
+                    aOptimizer.Optimize(lArguments);
+                }
+                catch (css::io::IOException&)
+                {
+                    // We always receive just ERRCODE_IO_CANTWRITE in case of problems, so no need to bother
+                    // about extracting error code from exception text
+                    errorCode = ERRCODE_IO_CANTWRITE;
+                }
+                catch (css::uno::Exception&)
+                {
+                    // Other general exception
+                    errorCode = ERRCODE_IO_GENERAL;
+                }
+
+                if (errorCode != ERRCODE_NONE)
+                {
+                    // Restore wizard controls
+                    mrOptimizerDialog.maStats.SetStatusValue(TK_Progress,
+                                                             Any(static_cast<sal_Int32>(0)));
+                    mrOptimizerDialog.setControlProperty("btnNavBack", "Enabled", Any(true));
+                    mrOptimizerDialog.setControlProperty("btnNavNext", "Enabled", Any(false));
+                    mrOptimizerDialog.setControlProperty("btnNavFinish", "Enabled", Any(true));
+                    mrOptimizerDialog.setControlProperty("btnNavCancel", "Enabled", Any(true));
+
+                    OUString aFileName;
+                    mrOptimizerDialog.GetConfigProperty(TK_SaveAsURL) >>= aFileName;
+                    SfxErrorContext aEc(ERRCTX_SFX_SAVEASDOC, aFileName);
+                    ErrorHandler::HandleError(errorCode);
+                    break;
+                }
+
+                mrOptimizerDialog.endExecute( bSuccessfullyExecuted );
+            }
+            else
+            {
+                mrOptimizerDialog.setControlProperty( "btnNavBack", "Enabled", Any( true ) );
+                mrOptimizerDialog.setControlProperty( "btnNavNext", "Enabled", Any( false ) );
+                mrOptimizerDialog.setControlProperty( "btnNavFinish", "Enabled", Any( true ) );
+                mrOptimizerDialog.setControlProperty( "btnNavCancel", "Enabled", Any( true ) );
+                mrOptimizerDialog.EnablePage( ITEM_ID_SUMMARY );
+            }
+        }
+        break;
+        case TK_btnNavCancel :  mrOptimizerDialog.endExecute( false ); break;
+        case TK_Button0Pg0 :    // delete configuration
+        {
+            OUString aSelectedItem( mrOptimizerDialog.GetSelectedString( "ListBox0Pg0" ) );
+            if ( !aSelectedItem.isEmpty() )
+            {
+                std::vector< OptimizerSettings >::iterator aIter( mrOptimizerDialog.GetOptimizerSettingsByName( aSelectedItem ) );
+                std::vector< OptimizerSettings >& rList( mrOptimizerDialog.GetOptimizerSettings() );
+                if ( aIter != rList.end() )
+                {
+                    rList.erase( aIter );
+                    mrOptimizerDialog.UpdateControlStates();
+                }
+            }
+        }
+        break;
+        default: break;
+    }
+}
+void ActionListener::disposing( const css::lang::EventObject& /* Source */ )
+{
+}
+
+
+void ActionListenerListBox0Pg0::actionPerformed( const ActionEvent& rEvent )
+{
+    if ( !rEvent.ActionCommand.isEmpty() )
+    {
+        std::vector< OptimizerSettings >::iterator aIter( mrOptimizerDialog.GetOptimizerSettingsByName( rEvent.ActionCommand ) );
+        std::vector< OptimizerSettings >& rList( mrOptimizerDialog.GetOptimizerSettings() );
+        if ( aIter != rList.end() )
+            rList[ 0 ] = *aIter;
+    }
+    mrOptimizerDialog.UpdateControlStates();
+}
+void ActionListenerListBox0Pg0::disposing( const css::lang::EventObject& /* Source */ )
+{
+}
+
+
+void TextListenerFormattedField0Pg1::textChanged( const TextEvent& /* rEvent */ )
+{
+    double fDouble = 0;
+    Any aAny = mrOptimizerDialog.getControlProperty( "FormattedField0Pg1", "EffectiveValue" );
+    if ( aAny >>= fDouble )
+        mrOptimizerDialog.SetConfigProperty( TK_JPEGQuality, Any( static_cast<sal_Int32>(fDouble) ) );
+}
+void TextListenerFormattedField0Pg1::disposing( const css::lang::EventObject& /* Source */ )
+{
+}
+
+namespace
+{
+
+bool lcl_mapResolution(OUString& rResolution, std::u16string_view rImageResolution)
+{
+    if (o3tl::getToken(rImageResolution, 1, ';')!=rResolution)
+        return false;
+    rResolution = o3tl::getToken(rImageResolution, 0, ';');
+    return true;
+}
+
+}
+
+void TextListenerComboBox0Pg1::textChanged( const TextEvent& /* rEvent */ )
+{
+    OUString aString;
+    Any aAny = mrOptimizerDialog.getControlProperty( "ComboBox0Pg1", "Text" );
+    if ( !(aAny >>= aString) )
+        return;
+
+    for (int nIR{ STR_IMAGE_RESOLUTION_0 }; nIR <= STR_IMAGE_RESOLUTION_3; ++nIR)
+    {
+        if (lcl_mapResolution(aString, mrOptimizerDialog.getString(static_cast<PPPOptimizerTokenEnum>(nIR))))
+            break;
+    }
+
+    mrOptimizerDialog.SetConfigProperty( TK_ImageResolution, Any( aString.toInt32() ) );
+}
+void TextListenerComboBox0Pg1::disposing( const css::lang::EventObject& /* Source */ )
+{
+}
+
+
+void SpinListenerFormattedField0Pg1::up( const SpinEvent& /* rEvent */ )
+{
+    double fDouble;
+    Any aAny = mrOptimizerDialog.getControlProperty( "FormattedField0Pg1", "EffectiveValue" );
+    if ( aAny >>= fDouble )
+    {
+        fDouble += 9;
+        if ( fDouble > 100 )
+            fDouble = 100;
+        mrOptimizerDialog.setControlProperty( "FormattedField0Pg1", "EffectiveValue", Any( fDouble ) );
+        mrOptimizerDialog.SetConfigProperty( TK_JPEGQuality, Any( static_cast<sal_Int32>(fDouble) ) );
+    }
+}
+void SpinListenerFormattedField0Pg1::down( const SpinEvent& /* rEvent */ )
+{
+    double fDouble;
+    Any aAny = mrOptimizerDialog.getControlProperty( "FormattedField0Pg1", "EffectiveValue" );
+    if ( aAny >>= fDouble )
+    {
+        fDouble -= 9;
+        if ( fDouble < 0 )
+            fDouble = 0;
+        mrOptimizerDialog.setControlProperty( "FormattedField0Pg1", "EffectiveValue", Any( fDouble ) );
+        mrOptimizerDialog.SetConfigProperty( TK_JPEGQuality, Any( static_cast<sal_Int32>(fDouble) ) );
+    }
+}
+void SpinListenerFormattedField0Pg1::first( const SpinEvent& /* rEvent */ )
+{
+    mrOptimizerDialog.setControlProperty( "FormattedField0Pg1", "EffectiveValue", Any( static_cast< double >( 0 ) ) );
+    mrOptimizerDialog.SetConfigProperty( TK_JPEGQuality, Any( sal_Int32(0) ) );
+}
+void SpinListenerFormattedField0Pg1::last( const SpinEvent& /* rEvent */ )
+{
+    mrOptimizerDialog.setControlProperty( "FormattedField0Pg1", "EffectiveValue", Any( static_cast< double >( 100 ) ) );
+    mrOptimizerDialog.SetConfigProperty( TK_JPEGQuality, Any( sal_Int32(100) ) );
+}
+void SpinListenerFormattedField0Pg1::disposing( const css::lang::EventObject& /* Source */ )
+{
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/optimizerdialog.hxx b/sdext/source/minimizer/optimizerdialog.hxx
new file mode 100644
index 000000000..4ea28eb75
--- /dev/null
+++ b/sdext/source/minimizer/optimizerdialog.hxx
@@ -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 .
+ */
+
+#ifndef INCLUDED_SDEXT_SOURCE_MINIMIZER_OPTIMIZERDIALOG_HXX
+#define INCLUDED_SDEXT_SOURCE_MINIMIZER_OPTIMIZERDIALOG_HXX
+#include <vector>
+#include "unodialog.hxx"
+#include "optimizationstats.hxx"
+#include "configurationaccess.hxx"
+#include <com/sun/star/awt/XItemListener.hpp>
+#include <com/sun/star/awt/XSpinListener.hpp>
+#include <com/sun/star/awt/XTextListener.hpp>
+#include <com/sun/star/uno/Sequence.h>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <com/sun/star/frame/XDispatch.hpp>
+#include <cppuhelper/implbase.hxx>
+
+#define MAX_STEP        4
+#define OD_DIALOG_WIDTH 330
+#define DIALOG_HEIGHT   210
+#define BUTTON_WIDTH    50
+#define BUTTON_HEIGHT   14
+#define BUTTON_POS_Y    DIALOG_HEIGHT - BUTTON_HEIGHT - 6
+
+#define PAGE_POS_X      91
+#define PAGE_POS_Y      8
+#define PAGE_WIDTH      OD_DIALOG_WIDTH - PAGE_POS_X
+
+#define ITEM_ID_INTRODUCTION            0
+#define ITEM_ID_SLIDES                  1
+#define ITEM_ID_GRAPHIC_OPTIMIZATION    2
+#define ITEM_ID_OLE_OPTIMIZATION        3
+#define ITEM_ID_SUMMARY                 4
+
+class OptimizerDialog : public UnoDialog, public ConfigurationAccess
+{
+public:
+
+    OptimizerDialog( const css::uno::Reference< css::uno::XComponentContext >& rxContext, css::uno::Reference< css::frame::XFrame > const & rxFrame,
+        css::uno::Reference< css::frame::XDispatch > const & rxStatusDispatcher );
+    ~OptimizerDialog();
+
+    void                execute();
+
+    sal_Int16               mnCurrentStep;
+    sal_Int16               mnTabIndex;
+    bool                mbIsReadonly;
+
+private:
+    css::uno::Reference< css::frame::XFrame >         mxFrame;
+
+    css::uno::Reference< css::uno::XInterface >       mxRoadmapControl;
+    css::uno::Reference< css::uno::XInterface >       mxRoadmapControlModel;
+
+    css::uno::Reference< css::awt::XItemListener >    mxItemListener;
+    css::uno::Reference< css::awt::XActionListener >  mxActionListener;
+    css::uno::Reference< css::awt::XActionListener >  mxActionListenerListBox0Pg0;
+    css::uno::Reference< css::awt::XTextListener >    mxTextListenerFormattedField0Pg1;
+    css::uno::Reference< css::awt::XTextListener >    mxTextListenerComboBox0Pg1;
+    css::uno::Reference< css::awt::XSpinListener >    mxSpinListenerFormattedField0Pg1;
+    css::uno::Reference< css::frame::XDispatch >      mxStatusDispatcher;
+
+    std::vector< std::vector< OUString > > maControlPages;
+
+    void InitDialog();
+    void InitRoadmap();
+    void InitNavigationBar();
+    void InitPage0();
+    void InitPage1();
+    void InitPage2();
+    void InitPage3();
+    void InitPage4();
+    void UpdateControlStatesPage0();
+    void UpdateControlStatesPage1();
+    void UpdateControlStatesPage2();
+    void UpdateControlStatesPage3();
+    void UpdateControlStatesPage4();
+
+    void ActivatePage( sal_Int16 nStep );
+    void DeactivatePage( sal_Int16 nStep );
+    void InsertRoadmapItem( const sal_Int32 nIndex, const OUString& rLabel, const sal_Int32 nItemID );
+
+public:
+
+    OptimizationStats maStats;
+
+    void UpdateStatus( const css::uno::Sequence< css::beans::PropertyValue >& rStatus );
+
+    // the ConfigurationAccess is updated to actual control settings
+    void UpdateConfiguration();
+
+    void EnablePage( sal_Int16 nStep );
+    void DisablePage( sal_Int16 nStep );
+
+    void SwitchPage( sal_Int16 nNewStep );
+    void UpdateControlStates( sal_Int16 nStep = -1 );
+
+    OUString GetSelectedString( OUString const & token );
+    css::uno::Reference< css::frame::XDispatch >& GetStatusDispatcher() { return mxStatusDispatcher; };
+    css::uno::Reference< css::frame::XFrame>& GetFrame() { return mxFrame; };
+    const css::uno::Reference< css::uno::XComponentContext >& GetComponentContext() const { return UnoDialog::mxContext; };
+};
+
+
+class ItemListener : public ::cppu::WeakImplHelper< css::awt::XItemListener >
+{
+public:
+    explicit ItemListener( OptimizerDialog& rOptimizerDialog ) : mrOptimizerDialog( rOptimizerDialog ){}
+
+    virtual void SAL_CALL itemStateChanged( const css::awt::ItemEvent& Event ) override;
+    virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
+private:
+
+    OptimizerDialog& mrOptimizerDialog;
+};
+
+
+class ActionListener : public ::cppu::WeakImplHelper< css::awt::XActionListener >
+{
+public:
+    explicit ActionListener( OptimizerDialog& rOptimizerDialog ) : mrOptimizerDialog( rOptimizerDialog ){}
+
+    virtual void SAL_CALL actionPerformed( const css::awt::ActionEvent& Event ) override;
+    virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
+private:
+
+    OptimizerDialog& mrOptimizerDialog;
+};
+
+
+class ActionListenerListBox0Pg0 : public ::cppu::WeakImplHelper< css::awt::XActionListener >
+{
+public:
+    explicit ActionListenerListBox0Pg0( OptimizerDialog& rOptimizerDialog ) : mrOptimizerDialog( rOptimizerDialog ){}
+
+    virtual void SAL_CALL actionPerformed( const css::awt::ActionEvent& Event ) override;
+    virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
+private:
+
+    OptimizerDialog& mrOptimizerDialog;
+};
+
+
+class TextListenerFormattedField0Pg1 : public ::cppu::WeakImplHelper< css::awt::XTextListener >
+{
+public:
+    explicit TextListenerFormattedField0Pg1( OptimizerDialog& rOptimizerDialog ) : mrOptimizerDialog( rOptimizerDialog ){}
+
+    virtual void SAL_CALL textChanged( const css::awt::TextEvent& Event ) override;
+    virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
+private:
+
+    OptimizerDialog& mrOptimizerDialog;
+};
+
+
+class TextListenerComboBox0Pg1 : public ::cppu::WeakImplHelper< css::awt::XTextListener >
+{
+public:
+    explicit TextListenerComboBox0Pg1( OptimizerDialog& rOptimizerDialog ) : mrOptimizerDialog( rOptimizerDialog ){}
+
+    virtual void SAL_CALL textChanged( const css::awt::TextEvent& Event ) override;
+    virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
+private:
+
+    OptimizerDialog& mrOptimizerDialog;
+};
+
+
+class SpinListenerFormattedField0Pg1 : public ::cppu::WeakImplHelper< css::awt::XSpinListener >
+{
+public:
+    explicit SpinListenerFormattedField0Pg1( OptimizerDialog& rOptimizerDialog ) : mrOptimizerDialog( rOptimizerDialog ){}
+
+    virtual void SAL_CALL up( const css::awt::SpinEvent& Event ) override;
+    virtual void SAL_CALL down( const css::awt::SpinEvent& Event ) override;
+    virtual void SAL_CALL first( const css::awt::SpinEvent& Event ) override;
+    virtual void SAL_CALL last( const css::awt::SpinEvent& Event ) override;
+    virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
+private:
+
+    OptimizerDialog& mrOptimizerDialog;
+};
+
+#endif // INCLUDED_SDEXT_SOURCE_MINIMIZER_OPTIMIZERDIALOG_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/optimizerdialogcontrols.cxx b/sdext/source/minimizer/optimizerdialogcontrols.cxx
new file mode 100644
index 000000000..4ab29d969
--- /dev/null
+++ b/sdext/source/minimizer/optimizerdialogcontrols.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 "optimizerdialog.hxx"
+
+
+#include "pppoptimizer.hxx"
+#include "graphiccollector.hxx"
+#include "pagecollector.hxx"
+#include <com/sun/star/awt/PushButtonType.hpp>
+#include <com/sun/star/awt/XSpinField.hpp>
+#include <com/sun/star/awt/XTextComponent.hpp>
+#include <com/sun/star/presentation/XCustomPresentationSupplier.hpp>
+#include <com/sun/star/drawing/XMasterPagesSupplier.hpp>
+#include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
+#include <com/sun/star/awt/FontDescriptor.hpp>
+#include <com/sun/star/awt/FontWeight.hpp>
+#include <com/sun/star/frame/XStorable.hpp>
+#include <rtl/ustrbuf.hxx>
+#include <sal/macros.h>
+#include <o3tl/string_view.hxx>
+
+using namespace ::com::sun::star::awt;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::presentation;
+
+
+static void SetBold( OptimizerDialog& rOptimizerDialog, const OUString& rControl )
+{
+    FontDescriptor aFontDescriptor;
+    if ( rOptimizerDialog.getControlProperty( rControl, "FontDescriptor" ) >>= aFontDescriptor )
+    {
+        aFontDescriptor.Weight = com::sun::star::awt::FontWeight::BOLD;
+        rOptimizerDialog.setControlProperty( rControl, "FontDescriptor", Any( aFontDescriptor ) );
+    }
+}
+
+
+static OUString InsertSeparator( OptimizerDialog& rOptimizerDialog, const OUString& rControlName, sal_Int32 nOrientation,
+                        sal_Int32 nPosX, sal_Int32 nPosY, sal_Int32 nWidth, sal_Int32 nHeight )
+{
+    OUString pNames[] = {
+        OUString("Height"),
+        OUString("Orientation"),
+        OUString("PositionX"),
+        OUString("PositionY"),
+        OUString("Step"),
+        OUString("Width") };
+
+    Any pValues[] = {
+        Any( nHeight ),
+        Any( nOrientation ),
+        Any( nPosX ),
+        Any( nPosY ),
+        Any( sal_Int16( 0 ) ),
+        Any( nWidth ) };
+
+    sal_Int32 nCount = SAL_N_ELEMENTS( pNames );
+
+    Sequence< OUString >   aNames( pNames, nCount );
+    Sequence< Any >             aValues( pValues, nCount );
+
+    rOptimizerDialog.insertControlModel( "com.sun.star.awt.UnoControlFixedLineModel",
+        rControlName, aNames, aValues );
+    return rControlName;
+}
+
+
+static OUString InsertButton( OptimizerDialog& rOptimizerDialog, const OUString& rControlName, Reference< XActionListener > const & xActionListener,
+    sal_Int32 nXPos, sal_Int32 nYPos, sal_Int32 nWidth, sal_Int16 nTabIndex, bool bEnabled, PPPOptimizerTokenEnum nResID, css::awt::PushButtonType nPushButtonType )
+{
+    sal_Int32 nHeight = BUTTON_HEIGHT;
+    OUString pNames[] = {
+        OUString("Enabled"),
+        OUString("Height"),
+        OUString("Label"),
+        OUString("PositionX"),
+        OUString("PositionY"),
+        OUString("PushButtonType"),
+        OUString("Step"),
+        OUString("TabIndex"),
+        OUString("Width") };
+
+    Any pValues[] = {
+        Any( bEnabled  ),
+        Any( nHeight ),
+        Any( rOptimizerDialog.getString( nResID ) ),
+        Any( nXPos ),
+        Any( nYPos ),
+        Any( static_cast< sal_Int16 >(nPushButtonType) ),
+        Any( sal_Int16(0) ),
+        Any( nTabIndex ),
+        Any( nWidth ) };
+
+
+    sal_Int32 nCount = SAL_N_ELEMENTS( pNames );
+
+    Sequence< OUString >   aNames( pNames, nCount );
+    Sequence< Any >             aValues( pValues, nCount );
+
+    rOptimizerDialog.insertButton( rControlName, xActionListener, aNames, aValues );
+    return rControlName;
+}
+
+
+static OUString InsertFixedText( OptimizerDialog& rOptimizerDialog, const OUString& rControlName, const OUString& rLabel,
+                                sal_Int32 nXPos, sal_Int32 nYPos, sal_Int32 nWidth, sal_Int32 nHeight, bool bMultiLine, bool bBold, sal_Int16 nTabIndex )
+{
+    OUString pNames[] = {
+        OUString("Height"),
+        OUString("Label"),
+        OUString("MultiLine"),
+        OUString("PositionX"),
+        OUString("PositionY"),
+        OUString("Step"),
+        OUString("TabIndex"),
+        OUString("Width") };
+
+    Any pValues[] = {
+        Any( nHeight ),
+        Any( rLabel ),
+        Any( bMultiLine ),
+        Any( nXPos ),
+        Any( nYPos ),
+        Any( sal_Int16(0) ),
+        Any( nTabIndex ),
+        Any( nWidth ) };
+
+    sal_Int32 nCount = SAL_N_ELEMENTS( pNames );
+
+    Sequence< OUString >   aNames( pNames, nCount );
+    Sequence< Any >             aValues( pValues, nCount );
+
+    rOptimizerDialog.insertFixedText( rControlName, aNames, aValues );
+    if ( bBold )
+        SetBold( rOptimizerDialog, rControlName );
+    return rControlName;
+}
+
+
+static OUString InsertCheckBox( OptimizerDialog& rOptimizerDialog, const OUString& rControlName,
+    const Reference< XItemListener >& xItemListener, const OUString& rLabel,
+        sal_Int32 nXPos, sal_Int32 nYPos, sal_Int32 nWidth, sal_Int16 nTabIndex )
+{
+    sal_Int32 nHeight = 8;
+    OUString pNames[] = {
+        OUString("Enabled"),
+        OUString("Height"),
+        OUString("Label"),
+        OUString("PositionX"),
+        OUString("PositionY"),
+        OUString("Step"),
+        OUString("TabIndex"),
+        OUString("Width") };
+
+    Any pValues[] = {
+        Any( true ),
+        Any( nHeight ),
+        Any( rLabel ),
+        Any( nXPos ),
+        Any( nYPos ),
+        Any( sal_Int16(0) ),
+        Any( nTabIndex ),
+        Any( nWidth ) };
+
+    sal_Int32 nCount = SAL_N_ELEMENTS( pNames );
+
+    Sequence< OUString >   aNames( pNames, nCount );
+    Sequence< Any >             aValues( pValues, nCount );
+
+    Reference< XCheckBox > xCheckBox( rOptimizerDialog.insertCheckBox( rControlName, aNames, aValues ) );
+    if ( xItemListener.is() )
+        xCheckBox->addItemListener( xItemListener );
+    return rControlName;
+}
+
+
+static OUString InsertFormattedField( OptimizerDialog& rOptimizerDialog, const OUString& rControlName,
+        const Reference< XTextListener >& xTextListener, const Reference< XSpinListener >& xSpinListener, sal_Int32 nXPos, sal_Int32 nYPos,
+        double fEffectiveMin, double fEffectiveMax, sal_Int16 nTabIndex )
+{
+    sal_Int32 nWidth = 50;
+    OUString pNames[] = {
+        OUString("EffectiveMax"),
+        OUString("EffectiveMin"),
+        OUString("Enabled"),
+        OUString("Height"),
+        OUString("PositionX"),
+        OUString("PositionY"),
+        OUString("Repeat"),
+        OUString("Spin"),
+        OUString("Step"),
+        OUString("TabIndex"),
+        OUString("Width") };
+
+    Any pValues[] = {
+        Any( fEffectiveMax ),
+        Any( fEffectiveMin ),
+        Any( true ),
+        Any( sal_Int32(12) ),
+        Any( nXPos ),
+        Any( nYPos ),
+        Any( true ),
+        Any( true ),
+        Any( sal_Int16(0) ),
+        Any( nTabIndex ),
+        Any( nWidth ) };
+
+    sal_Int32 nCount = SAL_N_ELEMENTS( pNames );
+
+    Sequence< OUString >   aNames( pNames, nCount );
+    Sequence< Any >             aValues( pValues, nCount );
+
+    Reference< XTextComponent > xTextComponent( rOptimizerDialog.insertFormattedField( rControlName, aNames, aValues ), UNO_QUERY_THROW );
+    if ( xTextListener.is() )
+        xTextComponent->addTextListener( xTextListener );
+    if ( xSpinListener.is() )
+    {
+        Reference< XSpinField > xSpinField( xTextComponent, UNO_QUERY_THROW );
+        xSpinField->addSpinListener( xSpinListener );
+    }
+    return rControlName;
+}
+
+
+static OUString InsertComboBox( OptimizerDialog& rOptimizerDialog, const OUString& rControlName,
+    const Reference< XTextListener >& rTextListener, const bool bEnabled, const Sequence< OUString >& rItemList,
+        sal_Int32 nXPos, sal_Int32 nYPos, sal_Int16 nTabIndex )
+{
+    sal_Int32 nHeight = 12;
+    sal_Int32 nWidth = 100;
+    OUString pNames[] = {
+        OUString("Dropdown"),
+        OUString("Enabled"),
+        OUString("Height"),
+        OUString("LineCount"),
+        OUString("PositionX"),
+        OUString("PositionY"),
+        OUString("Step"),
+        OUString("StringItemList"),
+        OUString("TabIndex"),
+        OUString("Width") };
+
+    Any pValues[] = {
+        Any( true ),
+        Any( bEnabled ),
+        Any( nHeight ),
+        Any( sal_Int16(8)),
+        Any( nXPos ),
+        Any( nYPos ),
+        Any( sal_Int16(0) ),
+        Any( rItemList ),
+        Any( nTabIndex ),
+        Any( nWidth ) };
+
+    sal_Int32 nCount = SAL_N_ELEMENTS( pNames );
+
+    Sequence< OUString >   aNames( pNames, nCount );
+    Sequence< Any >             aValues( pValues, nCount );
+
+    Reference< XTextComponent > xTextComponent( rOptimizerDialog.insertComboBox( rControlName, aNames, aValues ), UNO_QUERY_THROW );
+    if ( rTextListener.is() )
+        xTextComponent->addTextListener( rTextListener );
+    return rControlName;
+}
+
+
+static OUString InsertRadioButton( OptimizerDialog& rOptimizerDialog, const OUString& rControlName, const Reference< XItemListener >& rItemListener,
+    const OUString& rLabel, sal_Int32 nXPos, sal_Int32 nYPos, sal_Int32 nWidth, sal_Int16 nTabIndex )
+{
+    sal_Int32 nHeight = 8;
+    OUString pNames[] = {
+        OUString("Height"),
+        OUString("Label"),
+        OUString("MultiLine"),
+        OUString("PositionX"),
+        OUString("PositionY"),
+        OUString("Step"),
+        OUString("TabIndex"),
+        OUString("Width") };
+
+    Any pValues[] = {
+        Any( nHeight ),
+        Any( rLabel ),
+        Any( false ), // bMultiLine
+        Any( nXPos ),
+        Any( nYPos ),
+        Any( sal_Int16(0) ),
+        Any( nTabIndex ),
+        Any( nWidth ) };
+
+    sal_Int32 nCount = SAL_N_ELEMENTS( pNames );
+
+    Sequence< OUString >   aNames( pNames, nCount );
+    Sequence< Any >             aValues( pValues, nCount );
+
+    Reference< XRadioButton > xRadioButton( rOptimizerDialog.insertRadioButton( rControlName, aNames, aValues ) );
+    if ( rItemListener.is() )
+        xRadioButton->addItemListener( rItemListener );
+    return rControlName;
+}
+
+
+static OUString InsertListBox( OptimizerDialog& rOptimizerDialog, const OUString& rControlName,
+    const Reference< XActionListener >& rActionListener, const bool bEnabled, const Sequence< OUString >& rItemList,
+        sal_Int32 nXPos, sal_Int32 nYPos, sal_Int32 nWidth, sal_Int16 nTabIndex )
+{
+    sal_Int32 nHeight = 12;
+    OUString pNames[] = {
+        OUString("Dropdown"),
+        OUString("Enabled"),
+        OUString("Height"),
+        OUString("LineCount"),
+        OUString("MultiSelection"),
+        OUString("PositionX"),
+        OUString("PositionY"),
+        OUString("Step"),
+        OUString("StringItemList"),
+        OUString("TabIndex"),
+        OUString("Width") };
+
+    Any pValues[] = {
+        Any( true ),
+        Any( bEnabled ),
+        Any( nHeight ),
+        Any( sal_Int16(8)),
+        Any( false ),
+        Any( nXPos ),
+        Any( nYPos ),
+        Any( sal_Int16(0) ),
+        Any( rItemList ),
+        Any( nTabIndex ),
+        Any( nWidth ) };
+
+    sal_Int32 nCount = SAL_N_ELEMENTS( pNames );
+
+    Sequence< OUString >   aNames( pNames, nCount );
+    Sequence< Any >             aValues( pValues, nCount );
+
+    Reference< XListBox > xListBox( rOptimizerDialog.insertListBox( rControlName, aNames, aValues ) );
+    if ( xListBox.is() )
+        xListBox->addActionListener( rActionListener );
+    return rControlName;
+}
+
+
+void OptimizerDialog::InitNavigationBar()
+{
+    sal_Int32   nCancelPosX = OD_DIALOG_WIDTH - BUTTON_WIDTH - 6;
+    sal_Int32   nFinishPosX = nCancelPosX - 6 - BUTTON_WIDTH;
+    sal_Int32   nNextPosX = nFinishPosX - 6 - BUTTON_WIDTH;
+    sal_Int32   nBackPosX = nNextPosX - 3 - BUTTON_WIDTH;
+
+    InsertSeparator( *this, "lnNavSep1", 0, 0, DIALOG_HEIGHT - 26, OD_DIALOG_WIDTH, 1 );
+    InsertSeparator( *this, "lnNavSep2", 1, 85, 0, 1, BUTTON_POS_Y - 6 );
+
+    InsertButton( *this, "btnNavBack", mxActionListener, nBackPosX, BUTTON_POS_Y, BUTTON_WIDTH, mnTabIndex++, false, STR_BACK, PushButtonType_STANDARD );
+    InsertButton( *this, "btnNavNext", mxActionListener, nNextPosX, BUTTON_POS_Y, BUTTON_WIDTH, mnTabIndex++, true, STR_NEXT, PushButtonType_STANDARD );
+    InsertButton( *this, "btnNavFinish", mxActionListener, nFinishPosX, BUTTON_POS_Y, BUTTON_WIDTH, mnTabIndex++, true, STR_FINISH, PushButtonType_STANDARD );
+    InsertButton( *this, "btnNavCancel", mxActionListener, nCancelPosX, BUTTON_POS_Y, BUTTON_WIDTH, mnTabIndex++, true, STR_CANCEL, PushButtonType_STANDARD );
+
+    setControlProperty( "btnNavNext", "DefaultButton", Any( true ) );
+}
+
+
+void OptimizerDialog::UpdateControlStatesPage0()
+{
+    short nSelectedItem = -1;
+    Sequence< OUString > aItemList;
+    const std::vector< OptimizerSettings >& rList( GetOptimizerSettings() );
+    if ( rList.size() > 1 ) // the first session in the list is the actual one -> skipping first one
+    {
+        aItemList.realloc( rList.size() - 1 );
+        auto pItemList = aItemList.getArray();
+        for ( std::vector<OptimizerSettings>::size_type i = 1; i < rList.size(); i++ )
+        {
+            pItemList[ i - 1 ] = rList[ i ].maName;
+            if ( nSelectedItem < 0 )
+            {
+                if ( rList[ i ] == rList[ 0 ] )
+                    nSelectedItem = static_cast< short >( i - 1 );
+            }
+        }
+    }
+    bool bRemoveButtonEnabled = false;
+    Sequence< short > aSelectedItems;
+    if ( nSelectedItem >= 0 )
+    {
+        aSelectedItems = { nSelectedItem };
+        if ( nSelectedItem > 2 )    // only allowing to delete custom themes, the first can|t be deleted
+            bRemoveButtonEnabled = true;
+    }
+    setControlProperty( "ListBox0Pg0", "StringItemList", Any( aItemList ) );
+    setControlProperty( "ListBox0Pg0", "SelectedItems", Any( aSelectedItems ) );
+    setControlProperty( "Button0Pg0", "Enabled", Any( bRemoveButtonEnabled ) );
+}
+void OptimizerDialog::InitPage0()
+{
+    Sequence< OUString > aItemList;
+    std::vector< OUString > aControlList
+    {
+        InsertFixedText( *this, "FixedText0Pg0", getString( STR_INTRODUCTION ), PAGE_POS_X, PAGE_POS_Y, PAGE_WIDTH, 8, false, true, mnTabIndex++ ),
+        InsertFixedText( *this, "FixedText1Pg0", getString( STR_INTRODUCTION_T ), PAGE_POS_X + 6, PAGE_POS_Y + 14, PAGE_WIDTH - 12, 100, true, false, mnTabIndex++ ),
+        InsertSeparator( *this, "Separator1Pg0", 0, PAGE_POS_X + 6, DIALOG_HEIGHT - 66, PAGE_WIDTH - 12, 1 ),
+        InsertFixedText( *this, "FixedText2Pg0", getString( STR_CHOSE_SETTINGS ), PAGE_POS_X + 6, DIALOG_HEIGHT - 60, PAGE_WIDTH - 12, 8, true, false, mnTabIndex++ ),
+        InsertListBox(  *this, "ListBox0Pg0", mxActionListenerListBox0Pg0, true, aItemList, PAGE_POS_X + 6, DIALOG_HEIGHT - 48, ( OD_DIALOG_WIDTH - 50 ) - ( PAGE_POS_X + 6 ), mnTabIndex++ ),
+        InsertButton( *this, "Button0Pg0", mxActionListener, OD_DIALOG_WIDTH - 46, DIALOG_HEIGHT - 49, 40, mnTabIndex++, true, STR_REMOVE, PushButtonType_STANDARD )
+    };
+    maControlPages.push_back( aControlList );
+    DeactivatePage( 0 );
+    UpdateControlStatesPage0();
+}
+
+
+void OptimizerDialog::UpdateControlStatesPage1()
+{
+    bool bDeleteUnusedMasterPages( GetConfigProperty( TK_DeleteUnusedMasterPages, false ) );
+    bool bDeleteHiddenSlides( GetConfigProperty( TK_DeleteHiddenSlides, false ) );
+    bool bDeleteNotesPages( GetConfigProperty( TK_DeleteNotesPages, false ) );
+
+    setControlProperty( "CheckBox0Pg3", "State", Any( static_cast<sal_Int16>(bDeleteUnusedMasterPages) ) );
+    setControlProperty( "CheckBox1Pg3", "State", Any( static_cast<sal_Int16>(bDeleteNotesPages) ) );
+    setControlProperty( "CheckBox2Pg3", "State", Any( static_cast<sal_Int16>(bDeleteHiddenSlides) ) );
+}
+void OptimizerDialog::InitPage1()
+{
+    Sequence< OUString > aCustomShowList;
+    Reference< XModel > xModel( mxController->getModel() );
+    if ( xModel.is() )
+    {
+        Reference< XCustomPresentationSupplier > aXCPSup( xModel, UNO_QUERY_THROW );
+        Reference< XNameContainer > aXCont( aXCPSup->getCustomPresentations() );
+        if ( aXCont.is() )
+            aCustomShowList = aXCont->getElementNames();
+    }
+    std::vector< OUString > aControlList
+    {
+        InsertFixedText( *this, "FixedText0Pg3", getString( STR_CHOOSE_SLIDES ), PAGE_POS_X, PAGE_POS_Y, PAGE_WIDTH, 8, false, true, mnTabIndex++ ),
+        InsertCheckBox(  *this, "CheckBox0Pg3", mxItemListener, getString( STR_DELETE_MASTER_PAGES ), PAGE_POS_X + 6, PAGE_POS_Y + 14, PAGE_WIDTH - 12, mnTabIndex++ ),
+        InsertCheckBox(  *this, "CheckBox2Pg3", mxItemListener, getString( STR_DELETE_HIDDEN_SLIDES ), PAGE_POS_X + 6, PAGE_POS_Y + 28, PAGE_WIDTH - 12, mnTabIndex++ ),
+        InsertCheckBox(  *this, "CheckBox3Pg3", mxItemListener, getString( STR_CUSTOM_SHOW ), PAGE_POS_X + 6, PAGE_POS_Y + 42, PAGE_WIDTH - 12, mnTabIndex++ ),
+        InsertListBox(  *this, "ListBox0Pg3", mxActionListener, true, aCustomShowList, PAGE_POS_X + 14, PAGE_POS_Y + 54, 150, mnTabIndex++ ),
+        InsertCheckBox(  *this, "CheckBox1Pg3", mxItemListener, getString( STR_DELETE_NOTES_PAGES ), PAGE_POS_X + 6, PAGE_POS_Y + 70, PAGE_WIDTH - 12, mnTabIndex++ )
+    };
+    maControlPages.push_back( aControlList );
+    DeactivatePage( 1 );
+
+    setControlProperty( "CheckBox3Pg3", "State", Any( false ) );
+    setControlProperty( "CheckBox3Pg3", "Enabled", Any( aCustomShowList.hasElements() ) );
+    setControlProperty( "ListBox0Pg3", "Enabled", Any( false ) );
+
+    UpdateControlStatesPage1();
+}
+
+namespace
+{
+
+bool lcl_getResolutionText(OUString& rResolutionText, std::u16string_view rImageResolution, sal_Int32 nTargetRes)
+{
+    sal_Int32 nIdx{ 0 };
+    if (o3tl::toInt32(o3tl::getToken(rImageResolution, 0, ';', nIdx))!=nTargetRes)
+        return false;
+    rResolutionText = o3tl::getToken(rImageResolution, 0, ';', nIdx);
+    return true;
+}
+
+}
+
+void OptimizerDialog::UpdateControlStatesPage2()
+{
+    bool bJPEGCompression( GetConfigProperty( TK_JPEGCompression, false ) );
+    bool bRemoveCropArea( GetConfigProperty( TK_RemoveCropArea, false ) );
+    bool bEmbedLinkedGraphics( GetConfigProperty( TK_EmbedLinkedGraphics, true ) );
+    sal_Int32 nJPEGQuality( GetConfigProperty( TK_JPEGQuality, sal_Int32(90) ) );
+
+    sal_Int32 nImageResolution( GetConfigProperty( TK_ImageResolution, sal_Int32(0) ) );
+
+    OUString aResolutionText;
+    for (int nIR{ STR_IMAGE_RESOLUTION_0 }; nIR<=STR_IMAGE_RESOLUTION_3; ++nIR)
+    {
+        if (lcl_getResolutionText(aResolutionText, getString(static_cast<PPPOptimizerTokenEnum>(nIR)), nImageResolution))
+            break;
+    }
+    if ( aResolutionText.isEmpty() )
+        aResolutionText = OUString::number( nImageResolution );
+
+    setControlProperty( "RadioButton0Pg1", "State", Any( static_cast<sal_Int16>( !bJPEGCompression ) ) );
+    setControlProperty( "RadioButton1Pg1", "State", Any( static_cast<sal_Int16>(bJPEGCompression) ) );
+    setControlProperty( "FixedText1Pg1", "Enabled", Any( bJPEGCompression ) );
+    setControlProperty( "FormattedField0Pg1", "Enabled", Any( bJPEGCompression ) );
+    setControlProperty( "FormattedField0Pg1", "EffectiveValue", Any( static_cast<double>(nJPEGQuality) ) );
+    setControlProperty( "CheckBox1Pg1", "State", Any( static_cast<sal_Int16>(bRemoveCropArea) ) );
+    setControlProperty( "ComboBox0Pg1", "Text", Any( aResolutionText ) );
+    setControlProperty( "CheckBox2Pg1", "State", Any( static_cast<sal_Int16>(bEmbedLinkedGraphics) ) );
+}
+void OptimizerDialog::InitPage2()
+{
+    Sequence< OUString > aResolutionItemList{
+        getString( STR_IMAGE_RESOLUTION_0 ).getToken( 1, ';' ),
+        getString( STR_IMAGE_RESOLUTION_1 ).getToken( 1, ';' ),
+        getString( STR_IMAGE_RESOLUTION_2 ).getToken( 1, ';' ),
+        getString( STR_IMAGE_RESOLUTION_3 ).getToken( 1, ';' )
+    };
+
+    std::vector< OUString > aControlList
+    {
+        InsertFixedText( *this, "FixedText0Pg1", getString( STR_GRAPHIC_OPTIMIZATION ), PAGE_POS_X, PAGE_POS_Y, PAGE_WIDTH, 8, false, true, mnTabIndex++ ),
+        InsertRadioButton( *this, "RadioButton0Pg1", mxItemListener, getString( STR_LOSSLESS_COMPRESSION ), PAGE_POS_X + 6, PAGE_POS_Y + 14, PAGE_WIDTH - 12, mnTabIndex++ ),
+        InsertRadioButton( *this, "RadioButton1Pg1", mxItemListener, getString( STR_JPEG_COMPRESSION ), PAGE_POS_X + 6, PAGE_POS_Y + 28, PAGE_WIDTH - 12, mnTabIndex++ ),
+        InsertFixedText( *this, "FixedText1Pg1", getString( STR_QUALITY ), PAGE_POS_X + 20, PAGE_POS_Y + 40, 72, 8, false, false, mnTabIndex++ ),
+        InsertFormattedField( *this, "FormattedField0Pg1", mxTextListenerFormattedField0Pg1, mxSpinListenerFormattedField0Pg1, PAGE_POS_X + 106, PAGE_POS_Y + 38, 0, 100, mnTabIndex++ ),
+        InsertFixedText( *this, "FixedText2Pg1", getString( STR_IMAGE_RESOLUTION ), PAGE_POS_X + 6, PAGE_POS_Y + 54, 94, 8, false, false, mnTabIndex++ ),
+        InsertComboBox(  *this, "ComboBox0Pg1", mxTextListenerComboBox0Pg1, true, aResolutionItemList, PAGE_POS_X + 106, PAGE_POS_Y + 52, mnTabIndex++ ),
+        InsertCheckBox(  *this, "CheckBox1Pg1", mxItemListener, getString( STR_REMOVE_CROP_AREA ), PAGE_POS_X + 6, PAGE_POS_Y + 68, PAGE_WIDTH - 12, mnTabIndex++ ),
+        InsertCheckBox(  *this, "CheckBox2Pg1", mxItemListener, getString( STR_EMBED_LINKED_GRAPHICS ), PAGE_POS_X + 6, PAGE_POS_Y + 82, PAGE_WIDTH - 12, mnTabIndex++ )
+    };
+    maControlPages.push_back( aControlList );
+    DeactivatePage( 2 );
+    UpdateControlStatesPage2();
+}
+
+
+void OptimizerDialog::UpdateControlStatesPage3()
+{
+    bool bConvertOLEObjects( GetConfigProperty( TK_OLEOptimization, false ) );
+    sal_Int16 nOLEOptimizationType( GetConfigProperty( TK_OLEOptimizationType, sal_Int16(0) ) );
+
+    setControlProperty( "CheckBox0Pg2", "State", Any( static_cast<sal_Int16>(bConvertOLEObjects) ) );
+    setControlProperty( "RadioButton0Pg2", "Enabled", Any( bConvertOLEObjects ) );
+    setControlProperty( "RadioButton0Pg2", "State", Any( static_cast<sal_Int16>( nOLEOptimizationType == 0 ) ) );
+    setControlProperty( "RadioButton1Pg2", "Enabled", Any( bConvertOLEObjects ) );
+    setControlProperty( "RadioButton1Pg2", "State", Any( static_cast<sal_Int16>( nOLEOptimizationType == 1 ) ) );
+}
+void OptimizerDialog::InitPage3()
+{
+    int nOLECount = 0;
+    Reference< XModel > xModel( mxController->getModel() );
+    Reference< XDrawPagesSupplier > xDrawPagesSupplier( xModel, UNO_QUERY_THROW );
+    Reference< XDrawPages > xDrawPages( xDrawPagesSupplier->getDrawPages(), UNO_SET_THROW );
+    for ( sal_Int32 i = 0; i < xDrawPages->getCount(); i++ )
+    {
+        Reference< XShapes > xShapes( xDrawPages->getByIndex( i ), UNO_QUERY_THROW );
+        for ( sal_Int32 j = 0; j < xShapes->getCount(); j++ )
+        {
+            Reference< XShape > xShape( xShapes->getByIndex( j ), UNO_QUERY_THROW );
+            if ( xShape->getShapeType() == "com.sun.star.drawing.OLE2Shape" )
+                nOLECount++;
+        }
+    }
+
+    std::vector< OUString > aControlList
+    {
+        InsertFixedText( *this, "FixedText0Pg2", getString( STR_OLE_OPTIMIZATION ), PAGE_POS_X, PAGE_POS_Y, PAGE_WIDTH, 8, false, true, mnTabIndex++ ),
+        InsertCheckBox(  *this, "CheckBox0Pg2", mxItemListener, getString( STR_OLE_REPLACE ), PAGE_POS_X + 6, PAGE_POS_Y + 14, PAGE_WIDTH - 12, mnTabIndex++ ),
+        InsertRadioButton( *this, "RadioButton0Pg2", mxItemListener, getString( STR_ALL_OLE_OBJECTS ), PAGE_POS_X + 14, PAGE_POS_Y + 28, PAGE_WIDTH - 22, mnTabIndex++ ),
+        InsertRadioButton( *this, "RadioButton1Pg2", mxItemListener, getString( STR_ALIEN_OLE_OBJECTS_ONLY ), PAGE_POS_X + 14, PAGE_POS_Y + 40, PAGE_WIDTH - 22, mnTabIndex++ ),
+        InsertFixedText( *this, "FixedText1Pg2", nOLECount ? getString( STR_OLE_OBJECTS_DESC ) : getString( STR_NO_OLE_OBJECTS_DESC ), PAGE_POS_X + 6, PAGE_POS_Y + 64, PAGE_WIDTH - 22, 50, true, false, mnTabIndex++ )
+    };
+    maControlPages.push_back( aControlList );
+    DeactivatePage( 3 );
+    UpdateControlStatesPage3();
+}
+
+
+static OUString ImpValueOfInMB( sal_Int64 rVal, sal_Unicode nSeparator )
+{
+    double fVal( static_cast<double>( rVal ) );
+    fVal /= ( 1 << 20 );
+    fVal += 0.05;
+    OUStringBuffer aVal( OUString::number( fVal ) );
+    sal_Int32 nX( aVal.indexOf( '.' ) );
+    if ( nX >= 0 )
+    {
+        aVal.setLength( nX + 2 );
+        aVal[nX] = nSeparator;
+    }
+    aVal.append( " MB" );
+    return aVal.makeStringAndClear();
+}
+
+void OptimizerDialog::UpdateControlStatesPage4()
+{
+    bool bSaveAs( GetConfigProperty( TK_SaveAs, true ) );
+    if ( mbIsReadonly )
+    {
+        setControlProperty( "RadioButton0Pg4", "State", Any( sal_Int16(false) ) );
+        setControlProperty( "RadioButton1Pg4", "State", Any( sal_Int16(true) ) );
+    }
+    else
+    {
+        setControlProperty( "RadioButton0Pg4", "State", Any( static_cast<sal_Int16>( !bSaveAs ) ) );
+        setControlProperty( "RadioButton1Pg4", "State", Any( static_cast<sal_Int16>(bSaveAs) ) );
+    }
+    setControlProperty( "ComboBox0Pg4", "Enabled", Any( false ) );
+
+    Sequence< OUString > aItemList;
+    const std::vector< OptimizerSettings >& rList( GetOptimizerSettings() );
+    if ( rList.size() > 1 ) // the first session in the list is the actual one -> skipping first one
+    {
+        aItemList.realloc( rList.size() - 1 );
+        auto pItemList = aItemList.getArray();
+        for ( std::vector<OptimizerSettings>::size_type w = 1; w < rList.size(); w++ )
+            pItemList[ w - 1 ] = rList[ w ].maName;
+    }
+    setControlProperty( "ComboBox0Pg4", "StringItemList", Any( aItemList ) );
+
+    // now check if it is sensible to enable the combo box
+    bool bSaveSettingsEnabled = true;
+    if ( rList.size() > 1 ) // the first session in the list is the actual one -> skipping first one
+    {
+        for ( std::vector<OptimizerSettings>::size_type w = 1; w < rList.size(); w++ )
+        {
+            if ( rList[ w ] == rList[ 0 ] )
+            {
+                bSaveSettingsEnabled = false;
+                break;
+            }
+        }
+    }
+    sal_Int16 nInt16 = 0;
+    getControlProperty( "CheckBox1Pg4", "State" ) >>= nInt16;
+    setControlProperty( "CheckBox1Pg4", "Enabled", Any( bSaveSettingsEnabled ) );
+    setControlProperty( "ComboBox0Pg4", "Enabled", Any( bSaveSettingsEnabled && nInt16 ) );
+
+    std::vector< OUString > aSummaryStrings;
+
+    // taking care of deleted slides
+    sal_Int32 nDeletedSlides = 0;
+    if ( getControlProperty( "CheckBox3Pg3", "State" ) >>= nInt16 )
+    {
+        if ( nInt16 )
+        {
+            Sequence< short > aSelectedItems;
+            Sequence< OUString > aStringItemList;
+            Any aAny = getControlProperty( "ListBox0Pg3", "SelectedItems" );
+            if ( aAny >>= aSelectedItems )
+            {
+                if ( aSelectedItems.hasElements() )
+                {
+                    sal_Int16 nSelectedItem = aSelectedItems[ 0 ];
+                    aAny = getControlProperty( "ListBox0Pg3", "StringItemList" );
+                    if ( aAny >>= aStringItemList )
+                    {
+                        if ( aStringItemList.getLength() > nSelectedItem )
+                            SetConfigProperty( TK_CustomShowName, Any( aStringItemList[ nSelectedItem ] ) );
+                    }
+                }
+            }
+        }
+    }
+    if ( GetConfigProperty( TK_DeleteHiddenSlides, false ) )
+    {
+        Reference< XDrawPagesSupplier > xDrawPagesSupplier( mxController->getModel(), UNO_QUERY_THROW );
+        Reference< XDrawPages > xDrawPages( xDrawPagesSupplier->getDrawPages(), UNO_SET_THROW );
+        for( sal_Int32 i = 0; i < xDrawPages->getCount(); i++ )
+        {
+            Reference< XDrawPage > xDrawPage( xDrawPages->getByIndex( i ), UNO_QUERY_THROW );
+            Reference< XPropertySet > xPropSet( xDrawPage, UNO_QUERY_THROW );
+
+            bool bVisible = true;
+            if ( xPropSet->getPropertyValue( "Visible" ) >>= bVisible )
+            {
+                if (!bVisible )
+                    nDeletedSlides++;
+            }
+        }
+    }
+    if ( GetConfigProperty( TK_DeleteUnusedMasterPages, false ) )
+    {
+        std::vector< PageCollector::MasterPageEntity > aMasterPageList;
+        PageCollector::CollectMasterPages( mxController->getModel(), aMasterPageList );
+        Reference< XMasterPagesSupplier > xMasterPagesSupplier( mxController->getModel(), UNO_QUERY_THROW );
+        Reference< XDrawPages > xMasterPages( xMasterPagesSupplier->getMasterPages(), UNO_SET_THROW );
+        nDeletedSlides += std::count_if(aMasterPageList.begin(), aMasterPageList.end(),
+            [](const PageCollector::MasterPageEntity& rEntity) { return !rEntity.bUsed; });
+    }
+    if ( nDeletedSlides > 1 )
+    {
+        OUString aStr( getString( STR_DELETE_SLIDES ) );
+        OUString aPlaceholder( "%SLIDES"  );
+        sal_Int32 i = aStr.indexOf( aPlaceholder );
+        if ( i >= 0 )
+            aStr = aStr.replaceAt( i, aPlaceholder.getLength(), OUString::number( nDeletedSlides ) );
+        aSummaryStrings.push_back( aStr );
+    }
+
+// generating graphic compression info
+    sal_Int32 nGraphics = 0;
+    bool bJPEGCompression( GetConfigProperty( TK_JPEGCompression, false ) );
+    sal_Int32 nJPEGQuality( GetConfigProperty( TK_JPEGQuality, sal_Int32(90) ) );
+    sal_Int32 nImageResolution( GetConfigProperty( TK_ImageResolution, sal_Int32(0) ) );
+    GraphicSettings aGraphicSettings( bJPEGCompression, nJPEGQuality, GetConfigProperty( TK_RemoveCropArea, false ),
+                                        nImageResolution, GetConfigProperty( TK_EmbedLinkedGraphics, true ) );
+    GraphicCollector::CountGraphics( UnoDialog::mxContext, mxController->getModel(), aGraphicSettings, nGraphics );
+    if ( nGraphics > 1 )
+    {
+        OUString aStr( getString( STR_OPTIMIZE_IMAGES ) );
+        OUString aImagePlaceholder( "%IMAGES"  );
+        OUString aQualityPlaceholder( "%QUALITY"  );
+        OUString aResolutionPlaceholder( "%RESOLUTION"  );
+        sal_Int32 i = aStr.indexOf( aImagePlaceholder );
+        if ( i >= 0 )
+            aStr = aStr.replaceAt( i, aImagePlaceholder.getLength(), OUString::number( nGraphics ) );
+
+        sal_Int32 j = aStr.indexOf( aQualityPlaceholder );
+        if ( j >= 0 )
+            aStr = aStr.replaceAt( j, aQualityPlaceholder.getLength(), OUString::number( nJPEGQuality ) );
+
+        sal_Int32 k = aStr.indexOf( aResolutionPlaceholder );
+        if ( k >= 0 )
+            aStr = aStr.replaceAt( k, aResolutionPlaceholder.getLength(), OUString::number( nImageResolution ) );
+
+        aSummaryStrings.push_back( aStr );
+    }
+
+    if ( GetConfigProperty( TK_OLEOptimization, false ) )
+    {
+        sal_Int32 nOLEReplacements = 0;
+        Reference< XDrawPagesSupplier > xDrawPagesSupplier( mxController->getModel(), UNO_QUERY_THROW );
+        Reference< XDrawPages > xDrawPages( xDrawPagesSupplier->getDrawPages(), UNO_SET_THROW );
+        for ( sal_Int32 i = 0; i < xDrawPages->getCount(); i++ )
+        {
+            Reference< XShapes > xShapes( xDrawPages->getByIndex( i ), UNO_QUERY_THROW );
+            for ( sal_Int32 j = 0; j < xShapes->getCount(); j++ )
+            {
+                Reference< XShape > xShape( xShapes->getByIndex( j ), UNO_QUERY_THROW );
+                if ( xShape->getShapeType() == "com.sun.star.drawing.OLE2Shape" )
+                    nOLEReplacements++;
+            }
+        }
+        if ( nOLEReplacements > 1 )
+        {
+            OUString aStr( getString( STR_CREATE_REPLACEMENT ) );
+            OUString aPlaceholder( "%OLE"  );
+            sal_Int32 i = aStr.indexOf( aPlaceholder );
+            if ( i >= 0 )
+                aStr = aStr.replaceAt( i, aPlaceholder.getLength(), OUString::number( nOLEReplacements ) );
+            aSummaryStrings.push_back( aStr );
+        }
+    }
+    while( aSummaryStrings.size() < 3 )
+        aSummaryStrings.emplace_back( );
+    setControlProperty( "FixedText4Pg4", "Label", Any( aSummaryStrings[ 0 ] ) );
+    setControlProperty( "FixedText5Pg4", "Label", Any( aSummaryStrings[ 1 ] ) );
+    setControlProperty( "FixedText6Pg4", "Label", Any( aSummaryStrings[ 2 ] ) );
+
+    sal_Int64 nCurrentFileSize = 0;
+    sal_Int64 nEstimatedFileSize = 0;
+    Reference< XStorable > xStorable( mxController->getModel(), UNO_QUERY );
+    if ( xStorable.is() && xStorable->hasLocation() )
+        nCurrentFileSize = PPPOptimizer::GetFileSize( xStorable->getLocation() );
+
+    if ( nCurrentFileSize )
+    {
+        double fE = static_cast< double >( nCurrentFileSize );
+        if ( nImageResolution )
+        {
+            double v = ( static_cast< double >( nImageResolution ) + 75.0 ) / 300.0;
+            if ( v < 1.0 )
+                fE *= v;
+        }
+        if ( bJPEGCompression )
+        {
+            double v = 0.75 - ( ( 100.0 - static_cast< double >( nJPEGQuality ) ) / 400.0 ) ;
+            fE *= v;
+        }
+        nEstimatedFileSize = static_cast< sal_Int64 >( fE );
+    }
+    sal_Unicode nSeparator = '.';
+    OUString aStr( getString( STR_FILESIZESEPARATOR ) );
+    if ( !aStr.isEmpty() )
+        nSeparator = aStr[ 0 ];
+    setControlProperty( "FixedText7Pg4", "Label", Any( ImpValueOfInMB( nCurrentFileSize, nSeparator ) ) );
+    setControlProperty( "FixedText8Pg4", "Label", Any( ImpValueOfInMB( nEstimatedFileSize, nSeparator ) ) );
+    SetConfigProperty( TK_EstimatedFileSize, Any( nEstimatedFileSize ) );
+}
+
+void OptimizerDialog::InitPage4()
+{
+    {   // creating progress bar:
+        OUString pNames[] = {
+            OUString("Height"),
+            OUString("Name"),
+            OUString("PositionX"),
+            OUString("PositionY"),
+            OUString("ProgressValue"),
+            OUString("ProgressValueMax"),
+            OUString("ProgressValueMin"),
+            OUString("Width") };
+
+        Any pValues[] = {
+            Any( sal_Int32(12) ),
+            Any( OUString("STR_SAVE_AS") ),
+            Any( sal_Int32( PAGE_POS_X + 6 ) ),
+            Any( sal_Int32( DIALOG_HEIGHT - 75 ) ),
+            Any( sal_Int32(0) ),
+            Any( sal_Int32(100) ),
+            Any( sal_Int32(0) ),
+            Any( sal_Int32( PAGE_WIDTH - 12 ) ) };
+
+        sal_Int32 nCount = SAL_N_ELEMENTS( pNames );
+
+        Sequence< OUString >   aNames( pNames, nCount );
+        Sequence< Any >             aValues( pValues, nCount );
+
+        insertControlModel( "com.sun.star.awt.UnoControlProgressBarModel",
+            "Progress", aNames, aValues );
+    }
+    Reference< XTextListener > xTextListener;
+    Sequence< OUString > aItemList;
+    std::vector< OUString > aControlList
+    {
+        InsertFixedText( *this, "FixedText0Pg4", getString( STR_SUMMARY_TITLE ), PAGE_POS_X, PAGE_POS_Y, PAGE_WIDTH, 8, false, true, mnTabIndex++ ),
+        //  InsertSeparator( *this, "Separator0Pg4", 0, PAGE_POS_X + 6, PAGE_POS_Y + 90, PAGE_WIDTH - 12, 1 ),
+
+        InsertFixedText( *this, "FixedText4Pg4", OUString(), PAGE_POS_X + 6, PAGE_POS_Y + 14, PAGE_WIDTH - 12, 8, false, false, mnTabIndex++ ),
+        InsertFixedText( *this, "FixedText5Pg4", OUString(), PAGE_POS_X + 6, PAGE_POS_Y + 22, PAGE_WIDTH - 12, 8, false, false, mnTabIndex++ ),
+        InsertFixedText( *this, "FixedText6Pg4", OUString(), PAGE_POS_X + 6, PAGE_POS_Y + 30, PAGE_WIDTH - 12, 8, false, false, mnTabIndex++ ),
+
+        InsertFixedText( *this, "FixedText2Pg4", getString( STR_CURRENT_FILESIZE ), PAGE_POS_X + 6, PAGE_POS_Y + 50, 88, 8, false, false, mnTabIndex++ ),
+        InsertFixedText( *this, "FixedText7Pg4", OUString(), PAGE_POS_X + 100, PAGE_POS_Y + 50, 30, 8, false, false, mnTabIndex++ )
+    };
+    setControlProperty( "FixedText7Pg4", "Align", Any( static_cast< short >( 2 ) ) );
+    aControlList.push_back( InsertFixedText( *this, "FixedText3Pg4", getString( STR_ESTIMATED_FILESIZE ), PAGE_POS_X + 6, PAGE_POS_Y + 58, 88, 8, false, false, mnTabIndex++ ) );
+    aControlList.push_back( InsertFixedText( *this, "FixedText8Pg4", OUString(), PAGE_POS_X + 100, PAGE_POS_Y + 58, 30, 8, false, false, mnTabIndex++ ) );
+    setControlProperty( "FixedText8Pg4", "Align", Any( static_cast< short >( 2 ) ) );
+
+    aControlList.push_back( InsertRadioButton( *this, "RadioButton0Pg4", mxItemListener, getString(  STR_APPLY_TO_CURRENT ), PAGE_POS_X + 6, PAGE_POS_Y + 78, PAGE_WIDTH - 12, mnTabIndex++ ) );
+    aControlList.push_back( InsertRadioButton( *this, "RadioButton1Pg4", mxItemListener, getString( STR_SAVE_AS ), PAGE_POS_X + 6, PAGE_POS_Y + 90, PAGE_WIDTH - 12, mnTabIndex++ ) );
+    aControlList.push_back( InsertFixedText( *this, "FixedText1Pg4", OUString(), PAGE_POS_X + 6, DIALOG_HEIGHT - 87, PAGE_WIDTH - 12, 8, true, false, mnTabIndex++ ) );
+    aControlList.emplace_back("Progress" );
+    aControlList.push_back( InsertSeparator( *this, "Separator1Pg4", 0, PAGE_POS_X + 6, DIALOG_HEIGHT - 58, PAGE_WIDTH - 12, 1 ) );
+    aControlList.push_back( InsertCheckBox(  *this, "CheckBox1Pg4", mxItemListener, getString( STR_SAVE_SETTINGS ), PAGE_POS_X + 6, DIALOG_HEIGHT - 47, 100, mnTabIndex++ ) );
+    aControlList.push_back( InsertComboBox(  *this, "ComboBox0Pg4", xTextListener, true, aItemList, PAGE_POS_X + 106, DIALOG_HEIGHT - 48, mnTabIndex++ ) );
+    maControlPages.push_back( aControlList );
+    DeactivatePage( 4 );
+
+    // creating a default session name that hasn't been used yet
+    OUString aSettingsName;
+    OUString aDefault( getString( STR_MY_SETTINGS ) );
+    sal_Int32 nSession = 1;
+    std::vector<OptimizerSettings>::size_type i;
+    const std::vector< OptimizerSettings >& rList( GetOptimizerSettings() );
+    do
+    {
+        OUString aTemp = aDefault + OUString::number( nSession++ );
+        for ( i = 1; i < rList.size(); i++ )
+        {
+            if ( rList[ i ].maName == aTemp )
+                break;
+        }
+        if ( i == rList.size() )
+            aSettingsName = aTemp;
+    }
+    while( aSettingsName.isEmpty() );
+
+    setControlProperty( "ComboBox0Pg4", "Text", Any( aSettingsName ) );
+    setControlProperty( "RadioButton0Pg4", "Enabled", Any( !mbIsReadonly ) );
+    setControlProperty( "RadioButton1Pg4", "Enabled", Any( !mbIsReadonly ) );
+
+    UpdateControlStatesPage4();
+}
+
+
+void OptimizerDialog::EnablePage( sal_Int16 nStep )
+{
+    for( const auto& rItem : maControlPages[ nStep ] )
+        setControlProperty( rItem, "Enabled", Any( true ) );
+}
+void OptimizerDialog::DisablePage( sal_Int16 nStep )
+{
+    for( const auto& rItem : maControlPages[ nStep ] )
+        setControlProperty( rItem, "Enabled", Any( false ) );
+}
+void OptimizerDialog::ActivatePage( sal_Int16 nStep )
+{
+    for( const auto& rItem : maControlPages[ nStep ] )
+        setVisible( rItem, true );
+}
+void OptimizerDialog::DeactivatePage( sal_Int16 nStep )
+{
+    for( const auto& rItem : maControlPages[ nStep ] )
+        setVisible( rItem, false );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/pagecollector.cxx b/sdext/source/minimizer/pagecollector.cxx
new file mode 100644
index 000000000..f42c7d271
--- /dev/null
+++ b/sdext/source/minimizer/pagecollector.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 "pagecollector.hxx"
+#include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
+#include <com/sun/star/drawing/XMasterPagesSupplier.hpp>
+#include <com/sun/star/drawing/XMasterPageTarget.hpp>
+#include <com/sun/star/presentation/XCustomPresentationSupplier.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/container/XIndexContainer.hpp>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::awt;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::presentation;
+
+void PageCollector::CollectCustomShowPages( const css::uno::Reference< css::frame::XModel >& rxModel, std::u16string_view rCustomShowName, std::vector< Reference< XDrawPage > >& rUsedPageList )
+{
+    try
+    {
+        Reference< XCustomPresentationSupplier > aXCPSup( rxModel, UNO_QUERY_THROW );
+        Reference< XNameContainer > aXCont( aXCPSup->getCustomPresentations() );
+        if ( aXCont.is() )
+        {
+            // creating a list of every page that is used within our customshow
+            const Sequence< OUString> aNameSeq( aXCont->getElementNames() );
+            for ( OUString const & i :aNameSeq )
+            {
+                if ( i == rCustomShowName )
+                {
+                    Reference< container::XIndexContainer > aXIC( aXCont->getByName( i ), UNO_QUERY_THROW );
+                    sal_Int32 j, nSlideCount = aXIC->getCount();
+                    for ( j = 0; j < nSlideCount; j++ )
+                    {
+                        Reference< XDrawPage > xDrawPage( aXIC->getByIndex( j ), UNO_QUERY_THROW );
+                        auto aIter = std::find(rUsedPageList.begin(), rUsedPageList.end(), xDrawPage);
+                        if ( aIter == rUsedPageList.end() )
+                            rUsedPageList.push_back( xDrawPage );
+                    }
+                }
+            }
+        }
+    }
+    catch( Exception& )
+    {
+
+    }
+}
+
+void PageCollector::CollectNonCustomShowPages( const css::uno::Reference< css::frame::XModel >& rxModel, std::u16string_view rCustomShowName, std::vector< Reference< XDrawPage > >& rNonUsedPageList )
+{
+    try
+    {
+        std::vector< Reference< XDrawPage > > vUsedPageList;
+        PageCollector::CollectCustomShowPages( rxModel, rCustomShowName, vUsedPageList );
+        if ( !vUsedPageList.empty() )
+        {
+            Reference< XDrawPagesSupplier > xDrawPagesSupplier( rxModel, UNO_QUERY_THROW );
+            Reference< XDrawPages > xDrawPages( xDrawPagesSupplier->getDrawPages(), UNO_SET_THROW );
+            for ( sal_Int32 j = 0; j < xDrawPages->getCount(); j++ )
+            {
+                Reference< XDrawPage > xDrawPage( xDrawPages->getByIndex( j ), UNO_QUERY_THROW );
+                auto aIter = std::find(vUsedPageList.begin(), vUsedPageList.end(), xDrawPage);
+                if ( aIter == vUsedPageList.end() )
+                    rNonUsedPageList.push_back( xDrawPage );
+            }
+        }
+    }
+    catch( Exception& )
+    {
+    }
+}
+
+
+void PageCollector::CollectMasterPages( const Reference< XModel >& rxModel, std::vector< PageCollector::MasterPageEntity >& rMasterPageList )
+{
+    try
+    {
+        // generating list of all master pages
+        Reference< XMasterPagesSupplier > xMasterPagesSupplier( rxModel, UNO_QUERY_THROW );
+        Reference< XDrawPages > xMasterPages( xMasterPagesSupplier->getMasterPages(), UNO_SET_THROW );
+        for ( sal_Int32 i = 0; i < xMasterPages->getCount(); i++ )
+        {
+            Reference< XDrawPage > xMasterPage( xMasterPages->getByIndex( i ), UNO_QUERY_THROW );
+            auto aIter = std::find_if(rMasterPageList.begin(), rMasterPageList.end(),
+                [&xMasterPage](const MasterPageEntity& rEntity) { return rEntity.xMasterPage == xMasterPage; });
+            if ( aIter == rMasterPageList.end() )
+            {
+                MasterPageEntity aMasterPageEntity;
+                aMasterPageEntity.xMasterPage = xMasterPage;
+                aMasterPageEntity.bUsed = false;
+                rMasterPageList.push_back( aMasterPageEntity );
+            }
+        }
+
+        // mark masterpages which are referenced by drawpages
+        Reference< XDrawPagesSupplier > xDrawPagesSupplier( rxModel, UNO_QUERY_THROW );
+        Reference< XDrawPages > xDrawPages( xDrawPagesSupplier->getDrawPages(), UNO_SET_THROW );
+        for ( sal_Int32 j = 0; j < xDrawPages->getCount(); j++ )
+        {
+            Reference< XMasterPageTarget > xMasterPageTarget( xDrawPages->getByIndex( j ), UNO_QUERY_THROW );
+            Reference< XDrawPage > xMasterPage( xMasterPageTarget->getMasterPage(), UNO_SET_THROW );
+            auto aIter = std::find_if(rMasterPageList.begin(), rMasterPageList.end(),
+                [&xMasterPage](const MasterPageEntity& rEntity) { return rEntity.xMasterPage == xMasterPage; });
+            if ( aIter == rMasterPageList.end() )
+                throw uno::RuntimeException();
+            aIter->bUsed = true;
+        }
+    }
+    catch( Exception& )
+    {
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/pagecollector.hxx b/sdext/source/minimizer/pagecollector.hxx
new file mode 100644
index 000000000..d2cc48d9e
--- /dev/null
+++ b/sdext/source/minimizer/pagecollector.hxx
@@ -0,0 +1,43 @@
+/* -*- 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 .
+ */
+
+#ifndef INCLUDED_SDEXT_SOURCE_MINIMIZER_PAGECOLLECTOR_HXX
+#define INCLUDED_SDEXT_SOURCE_MINIMIZER_PAGECOLLECTOR_HXX
+
+#include <com/sun/star/drawing/XDrawPage.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <vector>
+
+class PageCollector
+{
+    public:
+
+    struct MasterPageEntity
+    {
+        css::uno::Reference< css::drawing::XDrawPage > xMasterPage;
+        bool bUsed;
+    };
+    static void CollectCustomShowPages( const css::uno::Reference< css::frame::XModel >&, std::u16string_view rCustomShow, std::vector< css::uno::Reference< css::drawing::XDrawPage > >& );
+    static void CollectNonCustomShowPages( const css::uno::Reference< css::frame::XModel >&, std::u16string_view rCustomShow, std::vector< css::uno::Reference< css::drawing::XDrawPage > >& );
+    static void CollectMasterPages( const css::uno::Reference< css::frame::XModel >&, std::vector< MasterPageEntity >& );
+};
+
+#endif // INCLUDED_SDEXT_SOURCE_MINIMIZER_PAGECOLLECTOR_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/pppoptimizer.cxx b/sdext/source/minimizer/pppoptimizer.cxx
new file mode 100644
index 000000000..c869f7218
--- /dev/null
+++ b/sdext/source/minimizer/pppoptimizer.cxx
@@ -0,0 +1,39 @@
+/* -*- 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 "pppoptimizer.hxx"
+#include <osl/file.hxx>
+
+// returning filesize, on error zero is returned
+sal_Int64 PPPOptimizer::GetFileSize(const OUString& rURL)
+{
+    sal_Int64 nFileSize = 0;
+    osl::DirectoryItem aItem;
+    if (osl::DirectoryItem::get(rURL, aItem) == osl::FileBase::E_None)
+    {
+        osl::FileStatus aStatus(osl_FileStatus_Mask_FileSize);
+        if (aItem.getFileStatus(aStatus) == osl::FileBase::E_None)
+        {
+            nFileSize = aStatus.getFileSize();
+        }
+    }
+    return nFileSize;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/pppoptimizer.hxx b/sdext/source/minimizer/pppoptimizer.hxx
new file mode 100644
index 000000000..60b191a7b
--- /dev/null
+++ b/sdext/source/minimizer/pppoptimizer.hxx
@@ -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/.
+ *
+ * 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 .
+ */
+
+#ifndef INCLUDED_SDEXT_SOURCE_MINIMIZER_PPPOPTIMIZER_HXX
+#define INCLUDED_SDEXT_SOURCE_MINIMIZER_PPPOPTIMIZER_HXX
+
+#include <rtl/ustring.hxx>
+
+struct PPPOptimizer
+{
+    static sal_Int64 GetFileSize(const OUString& rURL);
+};
+
+#endif // INCLUDED_SDEXT_SOURCE_MINIMIZER_PPPOPTIMIZER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/pppoptimizerdialog.cxx b/sdext/source/minimizer/pppoptimizerdialog.cxx
new file mode 100644
index 000000000..74a89bfba
--- /dev/null
+++ b/sdext/source/minimizer/pppoptimizerdialog.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 "pppoptimizerdialog.hxx"
+#include "optimizerdialog.hxx"
+#include <sal/log.hxx>
+#include <cppuhelper/supportsservice.hxx>
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::beans;
+
+PPPOptimizerDialog::PPPOptimizerDialog( const Reference< XComponentContext > &xContext ) :
+    mxContext( xContext ),
+    mpOptimizerDialog( nullptr )
+{
+}
+
+PPPOptimizerDialog::~PPPOptimizerDialog()
+{
+}
+
+void SAL_CALL PPPOptimizerDialog::initialize( const Sequence< Any >& aArguments )
+{
+    if( aArguments.getLength() != 1 )
+        throw IllegalArgumentException();
+
+    aArguments[ 0 ] >>= mxFrame;
+    if ( mxFrame.is() )
+        mxController = mxFrame->getController();
+}
+
+OUString SAL_CALL PPPOptimizerDialog::getImplementationName()
+{
+    return "com.sun.star.comp.PresentationMinimizerImp";
+}
+
+sal_Bool SAL_CALL PPPOptimizerDialog::supportsService( const OUString& ServiceName )
+{
+    return cppu::supportsService(this, ServiceName);
+}
+
+Sequence< OUString > SAL_CALL PPPOptimizerDialog::getSupportedServiceNames()
+{
+    return { "com.sun.star.comp.PresentationMinimizer" };
+}
+
+Reference< css::frame::XDispatch > SAL_CALL PPPOptimizerDialog::queryDispatch(
+    const URL& aURL, const OUString& /* aTargetFrameName */, sal_Int32 /* nSearchFlags */ )
+{
+    Reference < XDispatch > xRet;
+    if ( aURL.Protocol.equalsIgnoreAsciiCase( "vnd.com.sun.star.comp.PresentationMinimizer:" ) )
+        xRet = this;
+
+    return xRet;
+}
+
+Sequence< Reference< css::frame::XDispatch > > SAL_CALL PPPOptimizerDialog::queryDispatches(
+    const Sequence< css::frame::DispatchDescriptor >& aDescripts )
+{
+    Sequence< Reference< css::frame::XDispatch> > aReturn( aDescripts.getLength() );
+    std::transform(aDescripts.begin(), aDescripts.end(), aReturn.getArray(),
+        [this](const css::frame::DispatchDescriptor& rDescr) -> Reference<css::frame::XDispatch> {
+            return queryDispatch(rDescr.FeatureURL, rDescr.FrameName, rDescr.SearchFlags); });
+    return aReturn;
+}
+
+void SAL_CALL PPPOptimizerDialog::dispatch( const URL& rURL,
+                                            const Sequence< PropertyValue >& rArguments )
+{
+
+    if ( !(mxController.is() && rURL.Protocol.equalsIgnoreAsciiCase( "vnd.com.sun.star.comp.PresentationMinimizer:" )) )
+        return;
+
+    if ( rURL.Path == "execute" )
+    {
+        try
+        {
+            sal_Int64 nFileSizeSource = 0;
+            sal_Int64 nFileSizeDest = 0;
+            mpOptimizerDialog = new OptimizerDialog( mxContext, mxFrame, this );
+            mpOptimizerDialog->execute();
+
+            const Any* pVal( mpOptimizerDialog->maStats.GetStatusValue( TK_FileSizeSource ) );
+            if ( pVal )
+                *pVal >>= nFileSizeSource;
+            pVal = mpOptimizerDialog->maStats.GetStatusValue( TK_FileSizeDestination );
+            if ( pVal )
+                *pVal >>= nFileSizeDest;
+
+            if ( nFileSizeSource && nFileSizeDest )
+            {
+                OUString sResult = "Your Presentation has been minimized from:" +
+                    OUString::number( nFileSizeSource >> 10 ) +
+                    "KB to " +
+                    OUString::number( nFileSizeDest >> 10 ) +
+                    "KB.";
+                SAL_INFO("sdext.minimizer", sResult );
+            }
+        }
+        catch( ... )
+        {
+        }
+        delete mpOptimizerDialog;
+        mpOptimizerDialog = nullptr;
+    }
+    else if ( rURL.Path == "statusupdate" )
+    {
+        if ( mpOptimizerDialog )
+            mpOptimizerDialog->UpdateStatus( rArguments );
+    }
+}
+
+void SAL_CALL PPPOptimizerDialog::addStatusListener( const Reference< XStatusListener >&, const URL& )
+{
+    // TODO
+    // OSL_FAIL( "PPPOptimizerDialog::addStatusListener()\nNot implemented yet!" );
+}
+
+void SAL_CALL PPPOptimizerDialog::removeStatusListener( const Reference< XStatusListener >&, const URL& )
+{
+    // TODO
+    // OSL_FAIL( "PPPOptimizerDialog::removeStatusListener()\nNot implemented yet!" );
+}
+
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+sdext_PPPOptimizerDialog_get_implementation(
+    css::uno::XComponentContext* context , css::uno::Sequence<css::uno::Any> const&)
+{
+    return cppu::acquire(new PPPOptimizerDialog(context));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/pppoptimizerdialog.hxx b/sdext/source/minimizer/pppoptimizerdialog.hxx
new file mode 100644
index 000000000..1d1042f64
--- /dev/null
+++ b/sdext/source/minimizer/pppoptimizerdialog.hxx
@@ -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 .
+ */
+
+#ifndef INCLUDED_SDEXT_SOURCE_MINIMIZER_PPPOPTIMIZERDIALOG_HXX
+#define INCLUDED_SDEXT_SOURCE_MINIMIZER_PPPOPTIMIZERDIALOG_HXX
+
+#include <com/sun/star/uno/Sequence.h>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/frame/XController.hpp>
+#include <com/sun/star/frame/XDispatch.hpp>
+#include <com/sun/star/frame/XDispatchProvider.hpp>
+#include <cppuhelper/implbase.hxx>
+
+
+class OptimizerDialog;
+class PPPOptimizerDialog : public   ::cppu::WeakImplHelper<
+                                    css::lang::XInitialization,
+                                    css::lang::XServiceInfo,
+                                    css::frame::XDispatchProvider,
+                                    css::frame::XDispatch >
+{
+    css::uno::Reference< css::uno::XComponentContext > mxContext;
+    css::uno::Reference< css::frame::XFrame > mxFrame;
+    css::uno::Reference< css::frame::XController > mxController;
+
+    OptimizerDialog*    mpOptimizerDialog;
+
+public:
+
+    explicit PPPOptimizerDialog( const css::uno::Reference< css::uno::XComponentContext >& xContext );
+    virtual ~PPPOptimizerDialog() override;
+
+    // XInitialization
+    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& sServiceName ) override;
+
+    virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
+
+    // XDispatchProvider
+    virtual css::uno::Reference< css::frame::XDispatch > SAL_CALL queryDispatch(
+        const css::util::URL& aURL, const OUString& aTargetFrameName, sal_Int32 nSearchFlags ) override;
+
+    virtual css::uno::Sequence< css::uno::Reference< css::frame::XDispatch > > SAL_CALL queryDispatches(
+        const css::uno::Sequence< css::frame::DispatchDescriptor >& aDescripts ) override;
+
+    // XDispatch
+    virtual void SAL_CALL dispatch( const css::util::URL& aURL,
+                                        const css::uno::Sequence< css::beans::PropertyValue >& lArguments ) override;
+
+    virtual void SAL_CALL addStatusListener( const css::uno::Reference< css::frame::XStatusListener >& xListener,
+                                                const css::util::URL& aURL ) override;
+    virtual void SAL_CALL removeStatusListener( const css::uno::Reference< css::frame::XStatusListener >& xListener,
+                                                const css::util::URL& aURL ) override;
+};
+
+#endif // INCLUDED_SDEXT_SOURCE_MINIMIZER_PPPOPTIMIZERDIALOG_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/pppoptimizertoken.cxx b/sdext/source/minimizer/pppoptimizertoken.cxx
new file mode 100644
index 000000000..1e020bc02
--- /dev/null
+++ b/sdext/source/minimizer/pppoptimizertoken.cxx
@@ -0,0 +1,198 @@
+/* -*- 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 "pppoptimizertoken.hxx"
+
+#include <sal/macros.h>
+#include <unordered_map>
+#include <memory>
+#include <mutex>
+
+typedef std::unordered_map< const char*, PPPOptimizerTokenEnum, rtl::CStringHash, rtl::CStringEqual> TypeNameHashMap;
+static TypeNameHashMap* pHashMap = nullptr;
+static std::mutex& getHashMapMutex()
+{
+    static std::mutex s_aHashMapProtection;
+    return s_aHashMapProtection;
+}
+
+namespace {
+
+struct TokenTable
+{
+    const char*                         pS;
+    PPPOptimizerTokenEnum               pE;
+};
+
+}
+
+const TokenTable pTokenTableArray[] =
+{
+    { "rdmNavi",            TK_rdmNavi },
+    { "btnNavBack",         TK_btnNavBack },
+    { "btnNavNext",         TK_btnNavNext },
+    { "btnNavFinish",       TK_btnNavFinish },
+    { "btnNavCancel",       TK_btnNavCancel },
+
+    { "Button0Pg0",         TK_Button0Pg0 },
+    { "RadioButton0Pg1",    TK_RadioButton0Pg1 },
+    { "RadioButton1Pg1",    TK_RadioButton1Pg1 },
+    { "CheckBox1Pg1",       TK_CheckBox1Pg1 },
+    { "CheckBox2Pg1",       TK_CheckBox2Pg1 },
+    { "CheckBox0Pg2",       TK_CheckBox0Pg2 },
+    { "RadioButton0Pg2",    TK_RadioButton0Pg2 },
+    { "RadioButton1Pg2",    TK_RadioButton1Pg2 },
+    { "CheckBox0Pg3",       TK_CheckBox0Pg3 },
+    { "CheckBox1Pg3",       TK_CheckBox1Pg3 },
+    { "CheckBox2Pg3",       TK_CheckBox2Pg3 },
+    { "CheckBox3Pg3",       TK_CheckBox3Pg3 },
+    { "RadioButton0Pg4",    TK_RadioButton0Pg4 },
+    { "RadioButton1Pg4",    TK_RadioButton1Pg4 },
+    { "CheckBox1Pg4",       TK_CheckBox1Pg4 },
+
+    { "DocumentService",    TK_DocumentService },
+    { "FileSizeDestination",TK_FileSizeDestination },
+    { "FileSizeSource",     TK_FileSizeSource },
+    { "FilterName",         TK_FilterName },
+    { "Flags",              TK_Flags },
+    { "InformationDialog",  TK_InformationDialog },
+    { "Name",               TK_Name },
+    { "Progress",           TK_Progress },
+    { "Settings",           TK_Settings },
+    { "StatusDispatcher",   TK_StatusDispatcher },
+    { "Type",               TK_Type },
+    { "UIName",             TK_UIName },
+
+    { "JPEGCompression",    TK_JPEGCompression },
+    { "JPEGQuality",        TK_JPEGQuality },
+    { "RemoveCropArea",     TK_RemoveCropArea },
+    { "ImageResolution",    TK_ImageResolution },
+    { "EmbedLinkedGraphics",TK_EmbedLinkedGraphics },
+    { "OLEOptimization",    TK_OLEOptimization },
+    { "OLEOptimizationType",TK_OLEOptimizationType },
+    { "DeleteUnusedMasterPages", TK_DeleteUnusedMasterPages },
+    { "DeleteHiddenSlides", TK_DeleteHiddenSlides },
+    { "DeleteNotesPages",   TK_DeleteNotesPages },
+    { "CustomShowName",     TK_CustomShowName },
+    { "SaveAs",             TK_SaveAs },
+    { "SaveAsURL",          TK_SaveAsURL },
+    { "OpenNewDocument",    TK_OpenNewDocument },
+    { "EstimatedFileSize",  TK_EstimatedFileSize },
+
+    { "Status",             TK_Status },
+    { "Pages",              TK_Pages },
+
+    { "STR_SUN_OPTIMIZATION_WIZARD2",STR_SUN_OPTIMIZATION_WIZARD2 },
+    { "STR_STEPS",                  STR_STEPS },
+    { "STR_BACK",                   STR_BACK },
+    { "STR_NEXT",                   STR_NEXT },
+    { "STR_FINISH",                 STR_FINISH },
+    { "STR_CANCEL",                 STR_CANCEL },
+    { "STR_INTRODUCTION",           STR_INTRODUCTION },
+    { "STR_INTRODUCTION_T",         STR_INTRODUCTION_T },
+    { "STR_CHOSE_SETTINGS",         STR_CHOSE_SETTINGS },
+    { "STR_REMOVE",                 STR_REMOVE },
+    { "STR_GRAPHIC_OPTIMIZATION",   STR_GRAPHIC_OPTIMIZATION },
+    { "STR_IMAGE_OPTIMIZATION",     STR_IMAGE_OPTIMIZATION },
+    { "STR_LOSSLESS_COMPRESSION",   STR_LOSSLESS_COMPRESSION },
+    { "STR_JPEG_COMPRESSION",       STR_JPEG_COMPRESSION },
+    { "STR_QUALITY",                STR_QUALITY },
+    { "STR_REMOVE_CROP_AREA",       STR_REMOVE_CROP_AREA },
+    { "STR_IMAGE_RESOLUTION",       STR_IMAGE_RESOLUTION },
+    { "STR_IMAGE_RESOLUTION_0",     STR_IMAGE_RESOLUTION_0 },
+    { "STR_IMAGE_RESOLUTION_1",     STR_IMAGE_RESOLUTION_1 },
+    { "STR_IMAGE_RESOLUTION_2",     STR_IMAGE_RESOLUTION_2 },
+    { "STR_IMAGE_RESOLUTION_3",     STR_IMAGE_RESOLUTION_3 },
+    { "STR_EMBED_LINKED_GRAPHICS",  STR_EMBED_LINKED_GRAPHICS },
+    { "STR_OLE_OBJECTS",            STR_OLE_OBJECTS },
+    { "STR_OLE_OPTIMIZATION",       STR_OLE_OPTIMIZATION },
+    { "STR_OLE_REPLACE",            STR_OLE_REPLACE },
+    { "STR_ALL_OLE_OBJECTS",        STR_ALL_OLE_OBJECTS },
+    { "STR_ALIEN_OLE_OBJECTS_ONLY", STR_ALIEN_OLE_OBJECTS_ONLY },
+    { "STR__OLE_OBJECTS_DESC",      STR_OLE_OBJECTS_DESC },
+    { "STR_NO_OLE_OBJECTS_DESC",    STR_NO_OLE_OBJECTS_DESC },
+    { "STR_SLIDES",                 STR_SLIDES },
+    { "STR_CHOOSE_SLIDES",          STR_CHOOSE_SLIDES },
+    { "STR_DELETE_MASTER_PAGES",    STR_DELETE_MASTER_PAGES },
+    { "STR_DELETE_NOTES_PAGES",     STR_DELETE_NOTES_PAGES },
+    { "STR_DELETE_HIDDEN_SLIDES",   STR_DELETE_HIDDEN_SLIDES },
+    { "STR_CUSTOM_SHOW",            STR_CUSTOM_SHOW },
+    { "STR_SUMMARY",                STR_SUMMARY },
+    { "STR_SUMMARY_TITLE",          STR_SUMMARY_TITLE },
+    { "STR_APPLY_TO_CURRENT",       STR_APPLY_TO_CURRENT },
+    { "STR_AUTOMATICALLY_OPEN",     STR_AUTOMATICALLY_OPEN },
+    { "STR_SAVE_SETTINGS",          STR_SAVE_SETTINGS },
+    { "STR_SAVE_AS",                STR_SAVE_AS },
+    { "STR_DELETE_SLIDES",          STR_DELETE_SLIDES },
+    { "STR_OPTIMIZE_IMAGES",        STR_OPTIMIZE_IMAGES },
+    { "STR_CREATE_REPLACEMENT",     STR_CREATE_REPLACEMENT },
+    { "STR_CURRENT_FILESIZE",       STR_CURRENT_FILESIZE },
+    { "STR_ESTIMATED_FILESIZE",     STR_ESTIMATED_FILESIZE },
+    { "MY_SETTINGS",                STR_MY_SETTINGS },
+    { "STR_OK",                     STR_OK },
+    { "STR_INFO_1",                 STR_INFO_1 },
+    { "STR_INFO_2",                 STR_INFO_2 },
+    { "STR_INFO_3",                 STR_INFO_3 },
+    { "STR_INFO_4",                 STR_INFO_4 },
+    { "STR_DUPLICATING_PRESENTATION",STR_DUPLICATING_PRESENTATION },
+    { "STR_DELETING_SLIDES",        STR_DELETING_SLIDES },
+    { "STR_OPTIMIZING_GRAPHICS",    STR_OPTIMIZING_GRAPHICS },
+    { "STR_CREATING_OLE_REPLACEMENTS",STR_CREATING_OLE_REPLACEMENTS },
+    { "STR_FileSizeSeparator",      STR_FILESIZESEPARATOR },
+    { "STR_FILENAME_SUFFIX",        STR_FILENAME_SUFFIX },
+    { "STR_WARN_UNSAVED_PRESENTATION", STR_WARN_UNSAVED_PRESENTATION },
+
+
+    { "NotFound",           TK_NotFound }
+};
+
+PPPOptimizerTokenEnum TKGet( const OUString& rToken )
+{
+    if ( !pHashMap )
+    {   // init hash map
+        std::scoped_lock aGuard( getHashMapMutex() );
+        if ( !pHashMap )
+        {
+            TypeNameHashMap* pH = new TypeNameHashMap;
+            const TokenTable* pPtr = pTokenTableArray;
+            const TokenTable* pEnd = pPtr + SAL_N_ELEMENTS( pTokenTableArray );
+            for ( ; pPtr < pEnd; pPtr++ )
+                (*pH)[ pPtr->pS ] = pPtr->pE;
+            pHashMap = pH;
+        }
+    }
+    PPPOptimizerTokenEnum eRetValue = TK_NotFound;
+    int i, nLen = rToken.getLength();
+    std::unique_ptr<char[]> pBuf(new char[ nLen + 1 ]);
+    for ( i = 0; i < nLen; i++ )
+        pBuf[ i ] = static_cast<char>(rToken[ i ]);
+    pBuf[ i ] = 0;
+    TypeNameHashMap::iterator aHashIter( pHashMap->find( pBuf.get() ) );
+    if ( aHashIter != pHashMap->end() )
+        eRetValue = (*aHashIter).second;
+    return eRetValue;
+}
+
+OUString TKGet( const PPPOptimizerTokenEnum eToken )
+{
+    return OUString::createFromAscii( pTokenTableArray[ eToken ].pS );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/pppoptimizertoken.hxx b/sdext/source/minimizer/pppoptimizertoken.hxx
new file mode 100644
index 000000000..d0ae65ed7
--- /dev/null
+++ b/sdext/source/minimizer/pppoptimizertoken.hxx
@@ -0,0 +1,148 @@
+/* -*- 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 .
+ */
+
+#ifndef INCLUDED_SDEXT_SOURCE_MINIMIZER_PPPOPTIMIZERTOKEN_HXX
+#define INCLUDED_SDEXT_SOURCE_MINIMIZER_PPPOPTIMIZERTOKEN_HXX
+
+#include <rtl/ustring.hxx>
+
+enum PPPOptimizerTokenEnum
+{
+    TK_rdmNavi,
+    TK_btnNavBack,
+    TK_btnNavNext,
+    TK_btnNavFinish,
+    TK_btnNavCancel,
+
+    TK_Button0Pg0,
+    TK_RadioButton0Pg1,
+    TK_RadioButton1Pg1,
+    TK_CheckBox1Pg1,
+    TK_CheckBox2Pg1,
+    TK_CheckBox0Pg2,
+    TK_RadioButton0Pg2,
+    TK_RadioButton1Pg2,
+    TK_CheckBox0Pg3,
+    TK_CheckBox1Pg3,
+    TK_CheckBox2Pg3,
+    TK_CheckBox3Pg3,
+    TK_RadioButton0Pg4,
+    TK_RadioButton1Pg4,
+    TK_CheckBox1Pg4,
+
+    TK_DocumentService,
+    TK_FileSizeDestination,
+    TK_FileSizeSource,
+    TK_FilterName,
+    TK_Flags,
+    TK_InformationDialog,
+    TK_Name,
+    TK_Progress,
+    TK_Settings,
+    TK_StatusDispatcher,
+    TK_Type,
+    TK_UIName,
+
+    TK_JPEGCompression,
+    TK_JPEGQuality,
+    TK_RemoveCropArea,
+    TK_ImageResolution,
+    TK_EmbedLinkedGraphics,
+    TK_OLEOptimization,
+    TK_OLEOptimizationType,
+    TK_DeleteUnusedMasterPages,
+    TK_DeleteHiddenSlides,
+    TK_DeleteNotesPages,
+    TK_CustomShowName,
+    TK_SaveAs,
+    TK_SaveAsURL,
+    TK_OpenNewDocument,
+    TK_EstimatedFileSize,
+
+    TK_Status,
+    TK_Pages,
+
+    STR_SUN_OPTIMIZATION_WIZARD2,
+    STR_STEPS,
+    STR_BACK,
+    STR_NEXT,
+    STR_FINISH,
+    STR_CANCEL,
+    STR_INTRODUCTION,
+    STR_INTRODUCTION_T,
+    STR_CHOSE_SETTINGS,
+    STR_REMOVE,
+    STR_GRAPHIC_OPTIMIZATION,
+    STR_IMAGE_OPTIMIZATION,
+    STR_LOSSLESS_COMPRESSION,
+    STR_JPEG_COMPRESSION,
+    STR_QUALITY,
+    STR_REMOVE_CROP_AREA,
+    STR_IMAGE_RESOLUTION,
+    STR_IMAGE_RESOLUTION_0,
+    STR_IMAGE_RESOLUTION_1,
+    STR_IMAGE_RESOLUTION_2,
+    STR_IMAGE_RESOLUTION_3,
+    STR_EMBED_LINKED_GRAPHICS,
+    STR_OLE_OBJECTS,
+    STR_OLE_OPTIMIZATION,
+    STR_OLE_REPLACE,
+    STR_ALL_OLE_OBJECTS,
+    STR_ALIEN_OLE_OBJECTS_ONLY,
+    STR_OLE_OBJECTS_DESC,
+    STR_NO_OLE_OBJECTS_DESC,
+    STR_SLIDES,
+    STR_CHOOSE_SLIDES,
+    STR_DELETE_MASTER_PAGES,
+    STR_DELETE_NOTES_PAGES,
+    STR_DELETE_HIDDEN_SLIDES,
+    STR_CUSTOM_SHOW,
+    STR_SUMMARY,
+    STR_SUMMARY_TITLE,
+    STR_APPLY_TO_CURRENT,
+    STR_AUTOMATICALLY_OPEN,
+    STR_SAVE_SETTINGS,
+    STR_SAVE_AS,
+    STR_DELETE_SLIDES,
+    STR_OPTIMIZE_IMAGES,
+    STR_CREATE_REPLACEMENT,
+    STR_CURRENT_FILESIZE,
+    STR_ESTIMATED_FILESIZE,
+    STR_MY_SETTINGS,
+    STR_OK,
+    STR_INFO_1,
+    STR_INFO_2,
+    STR_INFO_3,
+    STR_INFO_4,
+    STR_DUPLICATING_PRESENTATION,
+    STR_DELETING_SLIDES,
+    STR_OPTIMIZING_GRAPHICS,
+    STR_CREATING_OLE_REPLACEMENTS,
+    STR_FILESIZESEPARATOR,
+    STR_FILENAME_SUFFIX,
+    STR_WARN_UNSAVED_PRESENTATION,
+    TK_NotFound
+};
+
+PPPOptimizerTokenEnum TKGet(const OUString&);
+OUString TKGet(const PPPOptimizerTokenEnum);
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/unodialog.cxx b/sdext/source/minimizer/unodialog.cxx
new file mode 100644
index 000000000..a635d102e
--- /dev/null
+++ b/sdext/source/minimizer/unodialog.cxx
@@ -0,0 +1,309 @@
+/* -*- 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 "unodialog.hxx"
+
+#include <com/sun/star/awt/Toolkit.hpp>
+#include <com/sun/star/awt/UnoControlDialog.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/view/XSelectionSupplier.hpp>
+
+
+using namespace ::com::sun::star::awt;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::view;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::beans;
+
+UnoDialog::UnoDialog( const Reference< XComponentContext > &rxContext, Reference< XFrame > const & rxFrame ) :
+    mxContext( rxContext ),
+    mxController( rxFrame->getController() ),
+    mxDialogModel( mxContext->getServiceManager()->createInstanceWithContext(
+        "com.sun.star.awt.UnoControlDialogModel", mxContext ), UNO_SET_THROW ),
+    mxDialogModelMultiPropertySet( mxDialogModel, UNO_QUERY_THROW ),
+    mxDialogModelMSF( mxDialogModel, UNO_QUERY_THROW ),
+    mxDialogModelNameContainer( mxDialogModel, UNO_QUERY_THROW ),
+    mxDialogModelNameAccess( mxDialogModel, UNO_QUERY_THROW ),
+    mxControlModel( mxDialogModel, UNO_QUERY_THROW ),
+    mxDialog( UnoControlDialog::create(rxContext) ),
+    mxControl( mxDialog, UNO_QUERY_THROW ),
+    mbStatus( false )
+{
+    mxControl->setModel( mxControlModel );
+
+    Reference< XFrame > xFrame( mxController->getFrame() );
+    Reference< XWindow > xContainerWindow( xFrame->getContainerWindow() );
+    Reference< XWindowPeer > xWindowPeer( xContainerWindow, UNO_QUERY_THROW );
+
+    // set the main loop handle to update GUI while busy
+    Reference< XToolkit > xToolkit( Toolkit::create( mxContext ), UNO_QUERY_THROW  );
+    mxReschedule.set( xToolkit, UNO_QUERY );
+
+    // allocate the real window resources
+    mxDialog->createPeer(xToolkit,
+        xWindowPeer.is() ? xWindowPeer : xToolkit->getDesktopWindow());
+}
+
+UnoDialog::~UnoDialog()
+{
+    // free the resources
+    Reference<XComponent> xDialogComponent(mxDialog, UNO_QUERY_THROW);
+    xDialogComponent->dispose();
+}
+
+void UnoDialog::execute()
+{
+    mxDialog->setEnable( true );
+    mxDialog->setVisible( true );
+    mxDialog->execute();
+}
+
+void UnoDialog::endExecute( bool bStatus )
+{
+    mbStatus = bStatus;
+    mxDialog->endExecute();
+}
+
+Reference< XInterface > UnoDialog::insertControlModel( const OUString& rServiceName, const OUString& rName,
+                                                        const Sequence< OUString >& rPropertyNames, const Sequence< Any >& rPropertyValues )
+{
+    Reference< XInterface > xControlModel;
+    try
+    {
+        xControlModel = mxDialogModelMSF->createInstance( rServiceName );
+        Reference< XMultiPropertySet > xMultiPropSet( xControlModel, UNO_QUERY_THROW );
+        xMultiPropSet->setPropertyValues( rPropertyNames, rPropertyValues );
+        mxDialogModelNameContainer->insertByName( rName, Any( xControlModel ) );
+    }
+    catch( Exception& )
+    {
+    }
+    return xControlModel;
+}
+
+
+void UnoDialog::setVisible( const OUString& rName, bool bVisible )
+{
+    try
+    {
+        Reference< XInterface > xControl( mxDialog->getControl( rName ), UNO_QUERY_THROW );
+        Reference< XWindow > xWindow( xControl, UNO_QUERY_THROW );
+        xWindow->setVisible( bVisible );
+    }
+    catch ( Exception& )
+    {
+    }
+}
+
+
+Reference< XButton > UnoDialog::insertButton( const OUString& rName, const Reference< XActionListener >& xActionListener,
+            const Sequence< OUString >& rPropertyNames, const Sequence< Any >& rPropertyValues )
+{
+    Reference< XButton > xButton;
+    try
+    {
+        Reference< XInterface > xButtonModel( insertControlModel( "com.sun.star.awt.UnoControlButtonModel",
+            rName, rPropertyNames, rPropertyValues ) );
+        Reference< XPropertySet > xPropertySet( xButtonModel, UNO_QUERY_THROW );
+        xPropertySet->setPropertyValue("Name", Any( rName ) );
+        xButton.set( mxDialog->getControl( rName ), UNO_QUERY_THROW );
+
+        if ( xActionListener.is() )
+        {
+            xButton->addActionListener( xActionListener );
+            xButton->setActionCommand( rName );
+        }
+        return xButton;
+    }
+    catch( Exception& )
+    {
+    }
+    return xButton;
+}
+
+
+Reference< XFixedText > UnoDialog::insertFixedText( const OUString& rName, const Sequence< OUString >& rPropertyNames, const Sequence< Any >& rPropertyValues )
+{
+    Reference< XFixedText > xFixedText;
+    try
+    {
+        Reference< XPropertySet > xPropertySet( insertControlModel( "com.sun.star.awt.UnoControlFixedTextModel",
+            rName, rPropertyNames, rPropertyValues ), UNO_QUERY_THROW );
+        xPropertySet->setPropertyValue("Name", Any( rName ) );
+        xFixedText.set( mxDialog->getControl( rName ), UNO_QUERY_THROW );
+    }
+    catch ( Exception& )
+    {
+    }
+    return xFixedText;
+}
+
+
+Reference< XCheckBox > UnoDialog::insertCheckBox( const OUString& rName, const Sequence< OUString >& rPropertyNames, const Sequence< Any >& rPropertyValues )
+{
+    Reference< XCheckBox > xCheckBox;
+    try
+    {
+        Reference< XPropertySet > xPropertySet( insertControlModel( "com.sun.star.awt.UnoControlCheckBoxModel",
+            rName, rPropertyNames, rPropertyValues ), UNO_QUERY_THROW );
+        xPropertySet->setPropertyValue("Name", Any( rName ) );
+        xCheckBox.set( mxDialog->getControl( rName ), UNO_QUERY_THROW );
+    }
+    catch ( Exception& )
+    {
+    }
+    return xCheckBox;
+}
+
+
+Reference< XControl > UnoDialog::insertFormattedField( const OUString& rName, const Sequence< OUString >& rPropertyNames, const Sequence< Any >& rPropertyValues )
+{
+    Reference< XControl > xControl;
+    try
+    {
+        Reference< XPropertySet > xPropertySet( insertControlModel( "com.sun.star.awt.UnoControlFormattedFieldModel",
+            rName, rPropertyNames, rPropertyValues ), UNO_QUERY_THROW );
+        xPropertySet->setPropertyValue("Name", Any( rName ) );
+        xControl.set( mxDialog->getControl( rName ), UNO_SET_THROW );
+    }
+    catch ( Exception& )
+    {
+    }
+    return xControl;
+}
+
+
+Reference< XComboBox > UnoDialog::insertComboBox( const OUString& rName, const Sequence< OUString >& rPropertyNames, const Sequence< Any >& rPropertyValues )
+{
+    Reference< XComboBox > xControl;
+    try
+    {
+        Reference< XPropertySet > xPropertySet( insertControlModel( "com.sun.star.awt.UnoControlComboBoxModel",
+            rName, rPropertyNames, rPropertyValues ), UNO_QUERY_THROW );
+        xPropertySet->setPropertyValue("Name", Any( rName ) );
+        xControl.set( mxDialog->getControl( rName ), UNO_QUERY_THROW );
+    }
+    catch ( Exception& )
+    {
+    }
+    return xControl;
+}
+
+
+Reference< XRadioButton > UnoDialog::insertRadioButton( const OUString& rName, const Sequence< OUString >& rPropertyNames, const Sequence< Any >& rPropertyValues )
+{
+    Reference< XRadioButton > xControl;
+    try
+    {
+        Reference< XPropertySet > xPropertySet( insertControlModel( "com.sun.star.awt.UnoControlRadioButtonModel",
+            rName, rPropertyNames, rPropertyValues ), UNO_QUERY_THROW );
+        xPropertySet->setPropertyValue("Name", Any( rName ) );
+        xControl.set( mxDialog->getControl( rName ), UNO_QUERY_THROW );
+    }
+    catch ( Exception& )
+    {
+    }
+    return xControl;
+}
+
+
+Reference< XListBox > UnoDialog::insertListBox( const OUString& rName, const Sequence< OUString >& rPropertyNames, const Sequence< Any >& rPropertyValues )
+{
+    Reference< XListBox > xControl;
+    try
+    {
+        Reference< XPropertySet > xPropertySet( insertControlModel( "com.sun.star.awt.UnoControlListBoxModel",
+            rName, rPropertyNames, rPropertyValues ), UNO_QUERY_THROW );
+        xPropertySet->setPropertyValue("Name", Any( rName ) );
+        xControl.set( mxDialog->getControl( rName ), UNO_QUERY_THROW );
+    }
+    catch ( Exception& )
+    {
+    }
+    return xControl;
+}
+
+
+Reference< XControl > UnoDialog::insertImage( const OUString& rName, const Sequence< OUString >& rPropertyNames, const Sequence< Any >& rPropertyValues )
+{
+    Reference< XControl > xControl;
+    try
+    {
+        Reference< XPropertySet > xPropertySet( insertControlModel( "com.sun.star.awt.UnoControlImageControlModel",
+            rName, rPropertyNames, rPropertyValues ), UNO_QUERY_THROW );
+        xPropertySet->setPropertyValue("Name", Any( rName ) );
+        xControl.set( mxDialog->getControl( rName ), UNO_SET_THROW );
+    }
+    catch ( Exception& )
+    {
+    }
+    return xControl;
+}
+
+
+void UnoDialog::setControlProperty( const OUString& rControlName, const OUString& rPropertyName, const Any& rPropertyValue )
+{
+    try
+    {
+        if ( mxDialogModelNameAccess->hasByName( rControlName ) )
+        {
+            Reference< XPropertySet > xPropertySet( mxDialogModelNameAccess->getByName( rControlName ), UNO_QUERY_THROW );
+            xPropertySet->setPropertyValue( rPropertyName, rPropertyValue );
+        }
+    }
+    catch ( Exception& )
+    {
+    }
+}
+
+
+Any UnoDialog::getControlProperty( const OUString& rControlName, const OUString& rPropertyName )
+{
+    Any aRet;
+    try
+    {
+        if ( mxDialogModelNameAccess->hasByName( rControlName ) )
+        {
+            Reference< XPropertySet > xPropertySet( mxDialogModelNameAccess->getByName( rControlName ), UNO_QUERY_THROW );
+            aRet = xPropertySet->getPropertyValue( rPropertyName );
+        }
+    }
+    catch ( Exception& )
+    {
+    }
+    return aRet;
+}
+
+
+void UnoDialog::enableControl( const OUString& rControlName )
+{
+    setControlProperty( rControlName, "Enabled", Any( true ) );
+}
+
+
+void UnoDialog::disableControl( const OUString& rControlName )
+{
+    setControlProperty( rControlName, "Enabled", Any( false ) );
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sdext/source/minimizer/unodialog.hxx b/sdext/source/minimizer/unodialog.hxx
new file mode 100644
index 000000000..3bf908cf1
--- /dev/null
+++ b/sdext/source/minimizer/unodialog.hxx
@@ -0,0 +1,118 @@
+/* -*- 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 .
+ */
+
+#ifndef INCLUDED_SDEXT_SOURCE_MINIMIZER_UNODIALOG_HXX
+#define INCLUDED_SDEXT_SOURCE_MINIMIZER_UNODIALOG_HXX
+
+#include <com/sun/star/uno/Sequence.h>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/frame/XController.hpp>
+#include <com/sun/star/frame/XFrame.hpp>
+#include <com/sun/star/beans/XMultiPropertySet.hpp>
+#include <com/sun/star/awt/XControl.hpp>
+#include <com/sun/star/awt/XControlModel.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <com/sun/star/awt/XActionListener.hpp>
+#include <com/sun/star/awt/XButton.hpp>
+#include <com/sun/star/awt/XCheckBox.hpp>
+#include <com/sun/star/awt/XComboBox.hpp>
+#include <com/sun/star/awt/XRadioButton.hpp>
+#include <com/sun/star/awt/XListBox.hpp>
+#include <com/sun/star/awt/XFixedText.hpp>
+#include <com/sun/star/awt/XUnoControlDialog.hpp>
+#include <com/sun/star/awt/XReschedule.hpp>
+
+
+class UnoDialog
+{
+public:
+
+    UnoDialog( const css::uno::Reference< css::uno::XComponentContext >& rxMSF, css::uno::Reference< css::frame::XFrame > const & rxFrame );
+    ~UnoDialog();
+
+    void execute();
+    void endExecute( bool bStatus );
+
+    css::uno::Reference< css::uno::XInterface > insertControlModel( const OUString& rServiceName, const OUString& rName,
+        const css::uno::Sequence< OUString >& rPropertyNames, const css::uno::Sequence< css::uno::Any >& rPropertyValues );
+
+    void setVisible( const OUString& rName, bool bVisible );
+
+    css::uno::Reference< css::awt::XButton > insertButton( const OUString& rName,
+        const css::uno::Reference< css::awt::XActionListener >& xActionListener, const css::uno::Sequence< OUString >& rPropertyNames,
+            const css::uno::Sequence< css::uno::Any >& rPropertyValues );
+
+    css::uno::Reference< css::awt::XFixedText > insertFixedText( const OUString& rName,
+        const css::uno::Sequence< OUString >& rPropertyNames, const css::uno::Sequence< css::uno::Any >& rPropertyValues );
+
+    css::uno::Reference< css::awt::XCheckBox > insertCheckBox( const OUString& rName,
+        const css::uno::Sequence< OUString >& rPropertyNames, const css::uno::Sequence< css::uno::Any >& rPropertyValues );
+
+    css::uno::Reference< css::awt::XControl > insertFormattedField( const OUString& rName,
+        const css::uno::Sequence< OUString >& rPropertyNames, const css::uno::Sequence< css::uno::Any >& rPropertyValues );
+
+    css::uno::Reference< css::awt::XComboBox > insertComboBox( const OUString& rName,
+        const css::uno::Sequence< OUString >& rPropertyNames, const css::uno::Sequence< css::uno::Any >& rPropertyValues );
+
+    css::uno::Reference< css::awt::XRadioButton > insertRadioButton( const OUString& rName,
+        const css::uno::Sequence< OUString >& rPropertyNames, const css::uno::Sequence< css::uno::Any >& rPropertyValues );
+
+    css::uno::Reference< css::awt::XListBox > insertListBox( const OUString& rName,
+        const css::uno::Sequence< OUString >& rPropertyNames, const css::uno::Sequence< css::uno::Any >& rPropertyValues );
+
+    css::uno::Reference< css::awt::XControl > insertImage( const OUString& rName,
+        const css::uno::Sequence< OUString >& rPropertyNames, const css::uno::Sequence< css::uno::Any >& rPropertyValues );
+
+    void setControlProperty( const OUString& rControlName, const OUString& rPropertyName, const css::uno::Any& rPropertyValue );
+    css::uno::Any getControlProperty( const OUString& rControlName, const OUString& rPropertyName );
+
+    void enableControl( const OUString& rControlName );
+    void disableControl( const OUString& rControlName );
+
+    void reschedule() const { mxReschedule->reschedule(); }
+    bool endStatus() const { return mbStatus; }
+    css::uno::Reference<css::awt::XControl> getControl(const OUString& rControlName) const { return mxDialog->getControl(rControlName); }
+    const css::uno::Reference<css::frame::XController>& controller() const { return mxController; }
+    void setPropertyValues(const css::uno::Sequence<OUString>& rNameSeq, const css::uno::Sequence<css::uno::Any>& rValueSeq)
+        { mxDialogModelMultiPropertySet->setPropertyValues(rNameSeq, rValueSeq); }
+
+protected:
+    css::uno::Reference< css::uno::XComponentContext >        mxContext;
+    css::uno::Reference< css::frame::XController >            mxController;
+
+private:
+    css::uno::Reference< css::awt::XReschedule >              mxReschedule;
+    css::uno::Reference< css::uno::XInterface >               mxDialogModel;
+    css::uno::Reference< css::beans::XMultiPropertySet >      mxDialogModelMultiPropertySet;
+    css::uno::Reference< css::lang::XMultiServiceFactory >    mxDialogModelMSF;
+    css::uno::Reference< css::container::XNameContainer >     mxDialogModelNameContainer;
+    css::uno::Reference< css::container::XNameAccess >        mxDialogModelNameAccess;
+
+    css::uno::Reference< css::awt::XControlModel >            mxControlModel;
+
+    css::uno::Reference< css::awt::XUnoControlDialog >        mxDialog;
+    css::uno::Reference< css::awt::XControl >                 mxControl;
+    bool                                                                        mbStatus;
+};
+
+#endif // INCLUDED_SDEXT_SOURCE_MINIMIZER_UNODIALOG_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */