sd/source/ui/unoidl/UnoDocumentSettings.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <memory>
  23 #include <utility>
  24 #include <com/sun/star/embed/XStorage.hpp>
  25 #include <com/sun/star/embed/ElementModes.hpp>
  26 #include <com/sun/star/embed/XTransactedObject.hpp>
  27 #include <com/sun/star/lang/XServiceInfo.hpp>
  28 #include <com/sun/star/beans/XPropertySet.hpp>
  29 #include <com/sun/star/beans/XMultiPropertySet.hpp>
  30 #include <com/sun/star/i18n/XForbiddenCharacters.hpp>
  31 #include <cppuhelper/implbase.hxx>
  32 #include <cppuhelper/supportsservice.hxx>
  33 #include <comphelper/propertysethelper.hxx>
  34 #include <comphelper/propertysetinfo.hxx>
  35 #include <o3tl/string_view.hxx>
  36 #include <tools/debug.hxx>
  37 #include <tools/urlobj.hxx>
  38 #include <svx/xtable.hxx>
  39 #include <vcl/svapp.hxx>
  40
  41 #include <drawdoc.hxx>
  42 #include <DrawDocShell.hxx>
  43 #include "UnoDocumentSettings.hxx"
  44 #include <unomodel.hxx>
  45
  46 #include <optsitem.hxx>
  47 #include <sfx2/printer.hxx>
  48 #include <sfx2/sfxsids.hrc>
  49 #include <sdattr.hrc>
  50 #include <sdmod.hxx>
  51 #include <Outliner.hxx>
  52 #include <xmloff/settingsstore.hxx>
  53 #include <editeng/editstat.hxx>
  54 #include <svx/unoapi.hxx>
  55
  56 using namespace ::comphelper;
  57 using namespace ::cppu;
  58 using namespace ::com::sun::star;
  59 using namespace ::com::sun::star::uno;
  60 using namespace ::com::sun::star::util;
  61 using namespace ::com::sun::star::lang;
  62 using namespace ::com::sun::star::document;
  63 using namespace ::com::sun::star::beans;
  64 using namespace ::com::sun::star::i18n;
  65
  66 namespace sd
  67 {
  68     namespace {
  69
  70     class DocumentSettings : public cppu::WeakImplHelper< XPropertySet, XMultiPropertySet, XServiceInfo >,
  71                              public comphelper::PropertySetHelper,
  72                              public DocumentSettingsSerializer
  73     {
  74     public:
  75         explicit DocumentSettings( SdXImpressDocument* pModel );
  76
  77         // XInterface
  78         virtual Any SAL_CALL queryInterface( const Type& aType ) override;
  79         virtual void SAL_CALL acquire(  ) noexcept override;
  80         virtual void SAL_CALL release(  ) noexcept override;
  81
  82         // XPropertySet
  83         virtual css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL getPropertySetInfo(  ) override;
  84         virtual void SAL_CALL setPropertyValue( const OUString& aPropertyName, const css::uno::Any& aValue ) override;
  85         virtual css::uno::Any SAL_CALL getPropertyValue( const OUString& PropertyName ) override;
  86         virtual void SAL_CALL addPropertyChangeListener( const OUString& aPropertyName, const css::uno::Reference< css::beans::XPropertyChangeListener >& xListener ) override;
  87         virtual void SAL_CALL removePropertyChangeListener( const OUString& aPropertyName, const css::uno::Reference< css::beans::XPropertyChangeListener >& aListener ) override;
  88         virtual void SAL_CALL addVetoableChangeListener( const OUString& PropertyName, const css::uno::Reference< css::beans::XVetoableChangeListener >& aListener ) override;
  89         virtual void SAL_CALL removeVetoableChangeListener( const OUString& PropertyName, const css::uno::Reference< css::beans::XVetoableChangeListener >& aListener ) override;
  90
  91         // XMultiPropertySet
  92         virtual void SAL_CALL setPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Sequence< css::uno::Any >& aValues ) override;
  93         virtual css::uno::Sequence< css::uno::Any > SAL_CALL getPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames ) override;
  94         virtual void SAL_CALL addPropertiesChangeListener( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Reference< css::beans::XPropertiesChangeListener >& xListener ) override;
  95         virtual void SAL_CALL removePropertiesChangeListener( const css::uno::Reference< css::beans::XPropertiesChangeListener >& xListener ) override;
  96         virtual void SAL_CALL firePropertiesChangeEvent( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Reference< css::beans::XPropertiesChangeListener >& xListener ) override;
  97
  98         // XServiceInfo
  99         virtual OUString SAL_CALL getImplementationName(  ) override;
 100         virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
 101         virtual Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) override;
 102
 103         // DocumentSettingsSerializer cf. xmloff
 104         virtual uno::Sequence<beans::PropertyValue>
 105                 filterStreamsFromStorage(OUString const & referer,
 106                                          const uno::Reference< embed::XStorage > &xStorage,
 107                                          const uno::Sequence<beans::PropertyValue>& aConfigProps ) override;
 108         virtual uno::Sequence<beans::PropertyValue>
 109                 filterStreamsToStorage(const uno::Reference< embed::XStorage > &xStorage,
 110                                        const uno::Sequence<beans::PropertyValue>& aConfigProps ) override;
 111
 112     protected:
 113         virtual void _setPropertyValues( const comphelper::PropertyMapEntry** ppEntries, const css::uno::Any* pValues ) override;
 114         virtual void _getPropertyValues( const comphelper::PropertyMapEntry** ppEntries, css::uno::Any* pValue ) override;
 115
 116     private:
 117         bool LoadList( XPropertyListType t, const OUString &rPath,
 118                        const OUString &rReferer,
 119                        const uno::Reference< embed::XStorage > &xStorage );
 120         void AssignURL( XPropertyListType t, const Any* pValue, bool *pOk, bool *pChanged );
 121         void ExtractURL( XPropertyListType t, Any* pValue );
 122         rtl::Reference<SdXImpressDocument> mxModel;
 123     };
 124
 125     }
 126
 127     Reference< XInterface > DocumentSettings_createInstance( SdXImpressDocument* pModel )
 128         noexcept
 129     {
 130         DBG_ASSERT( pModel, "I need a model for the DocumentSettings!" );
 131         return static_cast<XWeak*>(new DocumentSettings( pModel ));
 132     }
 133
 134 namespace {
 135
 136 enum SdDocumentSettingsPropertyHandles
 137 {
 138     HANDLE_PRINTDRAWING, HANDLE_PRINTNOTES, HANDLE_PRINTHANDOUT, HANDLE_PRINTOUTLINE, HANDLE_MEASUREUNIT, HANDLE_SCALE_NUM,
 139     HANDLE_SCALE_DOM, HANDLE_TABSTOP, HANDLE_PRINTPAGENAME, HANDLE_PRINTDATE, HANDLE_PRINTTIME,
 140     HANDLE_PRINTHIDDENPAGES, HANDLE_PRINTFITPAGE, HANDLE_PRINTTILEPAGE, HANDLE_PRINTBOOKLET, HANDLE_PRINTBOOKLETFRONT,
 141     HANDLE_PRINTBOOKLETBACK, HANDLE_PRINTQUALITY, HANDLE_COLORTABLEURL, HANDLE_DASHTABLEURL, HANDLE_LINEENDTABLEURL, HANDLE_HATCHTABLEURL,
 142     HANDLE_GRADIENTTABLEURL, HANDLE_BITMAPTABLEURL, HANDLE_FORBIDDENCHARS, HANDLE_APPLYUSERDATA, HANDLE_SAVETHUMBNAIL, HANDLE_PAGENUMFMT,
 143     HANDLE_PRINTERNAME, HANDLE_PRINTERJOB, HANDLE_PRINTERPAPERSIZE, HANDLE_PARAGRAPHSUMMATION, HANDLE_CHARCOMPRESS, HANDLE_ASIANPUNCT,
 144     HANDLE_UPDATEFROMTEMPLATE, HANDLE_PRINTER_INDEPENDENT_LAYOUT
 145     // #i33095#
 146     ,HANDLE_LOAD_READONLY, HANDLE_MODIFY_PASSWD, HANDLE_SAVE_VERSION
 147     ,HANDLE_SLIDESPERHANDOUT, HANDLE_HANDOUTHORIZONTAL,
 148     HANDLE_EMBED_FONTS, HANDLE_EMBED_USED_FONTS,
 149     HANDLE_EMBED_LATIN_SCRIPT_FONTS, HANDLE_EMBED_ASIAN_SCRIPT_FONTS, HANDLE_EMBED_COMPLEX_SCRIPT_FONTS,
 150     HANDLE_IMAGE_PREFERRED_DPI
 151 };
 152
 153 }
 154
 155 #define MID_PRINTER 1
 156
 157     static rtl::Reference<PropertySetInfo> createSettingsInfoImpl( bool bIsDraw )
 158     {
 159         static PropertyMapEntry const aImpressSettingsInfoMap[] =
 160         {
 161             { u"IsPrintDrawing"_ustr,        HANDLE_PRINTDRAWING,        cppu::UnoType<bool>::get(),                0,  MID_PRINTER },
 162             { u"IsPrintNotes"_ustr,          HANDLE_PRINTNOTES,          cppu::UnoType<bool>::get(),                0,  MID_PRINTER },
 163             { u"IsPrintHandout"_ustr,        HANDLE_PRINTHANDOUT,        cppu::UnoType<bool>::get(),                0,  MID_PRINTER },
 164             { u"IsPrintOutline"_ustr,        HANDLE_PRINTOUTLINE,        cppu::UnoType<bool>::get(),                0,  MID_PRINTER },
 165             { u"SlidesPerHandout"_ustr,      HANDLE_SLIDESPERHANDOUT,    ::cppu::UnoType<sal_Int16>::get(),    0,  MID_PRINTER },
 166             { u"HandoutsHorizontal"_ustr,    HANDLE_HANDOUTHORIZONTAL,   cppu::UnoType<bool>::get(),                0,  MID_PRINTER },
 167         };
 168
 169         static PropertyMapEntry const aDrawSettingsInfoMap[] =
 170         {
 171             { u"MeasureUnit"_ustr,           HANDLE_MEASUREUNIT,         ::cppu::UnoType<sal_Int16>::get(),    0,  0 },
 172             { u"ScaleNumerator"_ustr,        HANDLE_SCALE_NUM,           ::cppu::UnoType<sal_Int32>::get(),    0,  0 },
 173             { u"ScaleDenominator"_ustr,      HANDLE_SCALE_DOM,           ::cppu::UnoType<sal_Int32>::get(),    0,  0 },
 174         };
 175
 176         static PropertyMapEntry const aCommonSettingsInfoMap[] =
 177         {
 178             { u"DefaultTabStop"_ustr,        HANDLE_TABSTOP,             ::cppu::UnoType<sal_Int32>::get(),    0,  0 },
 179             { u"PrinterName"_ustr,           HANDLE_PRINTERNAME,         ::cppu::UnoType<OUString>::get(),     0,  0 },
 180             { u"PrinterSetup"_ustr,          HANDLE_PRINTERJOB,          cppu::UnoType<uno::Sequence < sal_Int8 >>::get(),  0, MID_PRINTER },
 181             { u"PrinterPaperFromSetup"_ustr, HANDLE_PRINTERPAPERSIZE,    cppu::UnoType<bool>::get(),                0,  MID_PRINTER },
 182
 183             { u"IsPrintPageName"_ustr,       HANDLE_PRINTPAGENAME,       cppu::UnoType<bool>::get(),                0,  MID_PRINTER },
 184             { u"IsPrintDate"_ustr,           HANDLE_PRINTDATE,           cppu::UnoType<bool>::get(),                0,  MID_PRINTER },
 185             { u"IsPrintTime"_ustr,           HANDLE_PRINTTIME,           cppu::UnoType<bool>::get(),                0,  MID_PRINTER },
 186             { u"IsPrintHiddenPages"_ustr,    HANDLE_PRINTHIDDENPAGES,    cppu::UnoType<bool>::get(),                0,  MID_PRINTER },
 187             { u"IsPrintFitPage"_ustr,        HANDLE_PRINTFITPAGE,        cppu::UnoType<bool>::get(),                0,  MID_PRINTER },
 188             { u"IsPrintTilePage"_ustr,       HANDLE_PRINTTILEPAGE,       cppu::UnoType<bool>::get(),                0,  MID_PRINTER },
 189             { u"IsPrintBooklet"_ustr,        HANDLE_PRINTBOOKLET,        cppu::UnoType<bool>::get(),                0,  MID_PRINTER },
 190             { u"IsPrintBookletFront"_ustr,   HANDLE_PRINTBOOKLETFRONT,   cppu::UnoType<bool>::get(),                0,  MID_PRINTER },
 191             { u"IsPrintBookletBack"_ustr,    HANDLE_PRINTBOOKLETBACK,    cppu::UnoType<bool>::get(),                0,  MID_PRINTER },
 192             { u"PrintQuality"_ustr,          HANDLE_PRINTQUALITY,        ::cppu::UnoType<sal_Int32>::get(),    0,  MID_PRINTER },
 193             { u"ColorTableURL"_ustr,         HANDLE_COLORTABLEURL,       ::cppu::UnoType<OUString>::get(),     0,  0 },
 194             { u"DashTableURL"_ustr,          HANDLE_DASHTABLEURL,        ::cppu::UnoType<OUString>::get(),     0,  0 },
 195             { u"LineEndTableURL"_ustr,       HANDLE_LINEENDTABLEURL,     ::cppu::UnoType<OUString>::get(),     0,  0 },
 196             { u"HatchTableURL"_ustr,         HANDLE_HATCHTABLEURL,       ::cppu::UnoType<OUString>::get(),     0,  0 },
 197             { u"GradientTableURL"_ustr,      HANDLE_GRADIENTTABLEURL,    ::cppu::UnoType<OUString>::get(),     0,  0 },
 198             { u"BitmapTableURL"_ustr,        HANDLE_BITMAPTABLEURL,      ::cppu::UnoType<OUString>::get(),     0,  0 },
 199
 200             { u"ForbiddenCharacters"_ustr,   HANDLE_FORBIDDENCHARS,      cppu::UnoType<XForbiddenCharacters>::get(),    0, 0 },
 201             { u"ApplyUserData"_ustr,         HANDLE_APPLYUSERDATA,       cppu::UnoType<bool>::get(),                0,  0 },
 202             { u"SaveThumbnail"_ustr,         HANDLE_SAVETHUMBNAIL,       cppu::UnoType<bool>::get(),                0,  0 },
 203
 204             { u"PageNumberFormat"_ustr,      HANDLE_PAGENUMFMT,          ::cppu::UnoType<sal_Int32>::get(),    0,  0 },
 205             { u"ParagraphSummation"_ustr,    HANDLE_PARAGRAPHSUMMATION,  cppu::UnoType<bool>::get(),                0,  0 },
 206             { u"CharacterCompressionType"_ustr,HANDLE_CHARCOMPRESS,      ::cppu::UnoType<sal_Int16>::get(),          0,  0 },
 207             { u"IsKernAsianPunctuation"_ustr,HANDLE_ASIANPUNCT,          cppu::UnoType<bool>::get(),                0,  0 },
 208             { u"UpdateFromTemplate"_ustr,    HANDLE_UPDATEFROMTEMPLATE,  cppu::UnoType<bool>::get(),                0,  0 },
 209             { u"PrinterIndependentLayout"_ustr,HANDLE_PRINTER_INDEPENDENT_LAYOUT,::cppu::UnoType<sal_Int16>::get(), 0,  0 },
 210             // --> #i33095#
 211             { u"LoadReadonly"_ustr,          HANDLE_LOAD_READONLY,       cppu::UnoType<bool>::get(),                0,  0 },
 212             { u"ModifyPasswordInfo"_ustr,    HANDLE_MODIFY_PASSWD,       cppu::UnoType<uno::Sequence < beans::PropertyValue >>::get(),  0,  0 },
 213             { u"SaveVersionOnClose"_ustr,    HANDLE_SAVE_VERSION,        cppu::UnoType<bool>::get(),                0,  0 },
 214             { u"EmbedFonts"_ustr,              HANDLE_EMBED_FONTS,                cppu::UnoType<bool>::get(), 0,  0 },
 215             { u"EmbedOnlyUsedFonts"_ustr,      HANDLE_EMBED_USED_FONTS,           cppu::UnoType<bool>::get(), 0,  0 },
 216             { u"EmbedLatinScriptFonts"_ustr,   HANDLE_EMBED_LATIN_SCRIPT_FONTS,   cppu::UnoType<bool>::get(), 0,  0 },
 217             { u"EmbedAsianScriptFonts"_ustr,   HANDLE_EMBED_ASIAN_SCRIPT_FONTS,   cppu::UnoType<bool>::get(), 0,  0 },
 218             { u"EmbedComplexScriptFonts"_ustr, HANDLE_EMBED_COMPLEX_SCRIPT_FONTS, cppu::UnoType<bool>::get(), 0,  0 },
 219             { u"ImagePreferredDPI"_ustr, HANDLE_IMAGE_PREFERRED_DPI, cppu::UnoType<sal_Int32>::get(), 0,  0 },
 220         };
 221
 222         rtl::Reference<PropertySetInfo> xInfo = new PropertySetInfo( aCommonSettingsInfoMap );
 223         if (bIsDraw)
 224             xInfo->add( aDrawSettingsInfoMap );
 225         else
 226             xInfo->add( aImpressSettingsInfoMap );
 227
 228         return xInfo;
 229     }
 230 }
 231
 232 using namespace ::sd;
 233
 234 DocumentSettings::DocumentSettings( SdXImpressDocument* pModel )
 235 :   PropertySetHelper( createSettingsInfoImpl( !pModel->IsImpressDocument() ) ),
 236     mxModel( pModel )
 237 {
 238 }
 239
 240 bool DocumentSettings::LoadList( XPropertyListType t, const OUString &rInPath,
 241                                  const OUString &rReferer,
 242                                  const uno::Reference< embed::XStorage > &xStorage )
 243 {
 244     SdDrawDocument* pDoc = mxModel->GetDoc();
 245
 246     sal_Int32 nSlash = rInPath.lastIndexOf('/');
 247     OUString aPath, aName;
 248     if (nSlash < 0)
 249         aName = rInPath;
 250     else {
 251         aName = rInPath.copy( nSlash + 1 );
 252         aPath = rInPath.copy( 0, nSlash );
 253     }
 254
 255     XPropertyListRef pList = XPropertyList::CreatePropertyList(
 256         t, aPath, rReferer );
 257     pList->SetName( aName );
 258
 259     if( pList->LoadFrom( xStorage, rInPath, rReferer ) )
 260     {
 261         pDoc->SetPropertyList( pList );
 262         return true;
 263     }
 264
 265     return false;
 266 }
 267
 268 void DocumentSettings::AssignURL( XPropertyListType t, const Any* pValue,
 269                                   bool *pOk, bool *pChanged )
 270 {
 271     OUString aURL;
 272     if( !( *pValue >>= aURL ) )
 273         return;
 274
 275     if( LoadList( t, aURL, u""_ustr/*TODO?*/, uno::Reference< embed::XStorage >() ) )
 276         *pOk = *pChanged = true;
 277 }
 278
 279 struct {
 280     const char *pName;
 281     XPropertyListType t;
 282 } const aURLPropertyNames[] = {
 283     { "ColorTableURL", XPropertyListType::Color },
 284     { "DashTableURL", XPropertyListType::Dash },
 285     { "LineEndTableURL", XPropertyListType::LineEnd },
 286     { "HatchTableURL", XPropertyListType::Hatch },
 287     { "GradientTableURL", XPropertyListType::Gradient },
 288     { "BitmapTableURL", XPropertyListType::Bitmap }
 289 };
 290
 291 static XPropertyListType getTypeOfName( std::u16string_view aName )
 292 {
 293     for(const auto & rURLPropertyName : aURLPropertyNames) {
 294         if( o3tl::equalsAscii( aName, rURLPropertyName.pName ) )
 295             return rURLPropertyName.t;
 296     }
 297     return XPropertyListType::Unknown;
 298 }
 299
 300 static OUString getNameOfType( XPropertyListType t )
 301 {
 302     for(const auto & rURLPropertyName : aURLPropertyNames) {
 303         if( t == rURLPropertyName.t )
 304             return OUString( rURLPropertyName.pName,
 305                                   strlen( rURLPropertyName.pName ) - 3,
 306                                   RTL_TEXTENCODING_ASCII_US );
 307     }
 308     return OUString();
 309 }
 310
 311 uno::Sequence<beans::PropertyValue>
 312         DocumentSettings::filterStreamsFromStorage(
 313                 OUString const & referer,
 314                 const uno::Reference< embed::XStorage > &xStorage,
 315                 const uno::Sequence<beans::PropertyValue>& aConfigProps )
 316 {
 317     uno::Sequence<beans::PropertyValue> aRet( aConfigProps.getLength() );
 318     auto aRetRange = asNonConstRange(aRet);
 319     int nRet = 0;
 320     for( const auto& rConfigProp : aConfigProps )
 321     {
 322         XPropertyListType t = getTypeOfName( rConfigProp.Name );
 323         if (t == XPropertyListType::Unknown)
 324             aRetRange[nRet++] = rConfigProp;
 325         else
 326         {
 327             OUString aURL;
 328             rConfigProp.Value >>= aURL;
 329             LoadList( t, aURL, referer, xStorage );
 330         }
 331     }
 332     aRet.realloc( nRet );
 333     return aRet;
 334 }
 335
 336 uno::Sequence<beans::PropertyValue>
 337         DocumentSettings::filterStreamsToStorage(
 338                 const uno::Reference< embed::XStorage > &xStorage,
 339                 const uno::Sequence<beans::PropertyValue>& aConfigProps )
 340 {
 341     uno::Sequence<beans::PropertyValue> aRet( aConfigProps.getLength() );
 342
 343     bool bHasEmbed = false;
 344     SdDrawDocument* pDoc = mxModel->GetDoc();
 345     for( size_t i = 0; i < SAL_N_ELEMENTS( aURLPropertyNames ); i++ )
 346     {
 347         const XPropertyListRef& pList = pDoc->GetPropertyList( static_cast<XPropertyListType>(i) );
 348         bHasEmbed = pList.is() && pList->IsEmbedInDocument();
 349         if( bHasEmbed )
 350             break;
 351     }
 352     if( !bHasEmbed )
 353         return aConfigProps;
 354
 355     try {
 356         // create Settings/ sub storage.
 357         uno::Reference< embed::XStorage > xSubStorage = xStorage->openStorageElement( u"Settings"_ustr ,
 358             embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE );
 359         if( !xSubStorage.is() )
 360             return aRet;
 361
 362         auto aRetRange = asNonConstRange(aRet);
 363         // now populate it
 364         for( sal_Int32 i = 0; i < aConfigProps.getLength(); i++ )
 365         {
 366             XPropertyListType t = getTypeOfName( aConfigProps[i].Name );
 367             aRetRange[i] = aConfigProps[i];
 368             if (t != XPropertyListType::Unknown) {
 369                 const XPropertyListRef& pList = pDoc->GetPropertyList( t );
 370                 if( !pList.is() || !pList->IsEmbedInDocument() )
 371                     continue; // no change ...
 372                 else
 373                 {
 374                     // Such specific path construction is grim.
 375
 376                     OUString aName( getNameOfType( t ) );
 377                     OUString aResult;
 378                     if( pList->SaveTo( xSubStorage, aName, &aResult ) )
 379                     {
 380                         OUString aRealPath = "Settings/" + aResult;
 381                         aRetRange[i].Value <<= aRealPath;
 382                     }
 383                 }
 384             }
 385         }
 386
 387         // surprisingly difficult to make it really exist
 388         uno::Reference< embed::XTransactedObject > xTrans( xSubStorage, UNO_QUERY );
 389         if( xTrans.is() )
 390             xTrans->commit();
 391         if( xSubStorage.is() )
 392             xSubStorage->dispose();
 393     } catch (const uno::Exception &) {
 394 //        fprintf (stderr, "saving etc. exception '%s'\n",
 395 //                 OUStringToOString(e.Message, RTL_TEXTENCODING_UTF8).getStr());
 396     }
 397
 398     return aRet;
 399 }
 400
 401 // Most of the code reading/writing UNO document settings is the same in
 402 // sd, sc and sw and it is mostly copy-pasted back and forth.
 403 // TODO: Move _setPropertyValues and _getPropertyValues to some shared
 404 // place, at least for the settings that are common to sd, sc and sw
 405 void
 406 DocumentSettings::_setPropertyValues(const PropertyMapEntry** ppEntries,
 407         const Any* pValues)
 408 {
 409     ::SolarMutexGuard aGuard;
 410
 411     SdDrawDocument* pDoc = mxModel->GetDoc();
 412     ::sd::DrawDocShell* pDocSh = mxModel->GetDocShell();
 413     if( nullptr == pDoc || nullptr == pDocSh )
 414     {
 415         throw RuntimeException(u"Document or Shell missing"_ustr,
 416                 static_cast<OWeakObject *>(this));
 417     }
 418
 419     bool bValue = false;
 420     bool bOk, bChanged = false, bOptionsChanged = false;
 421
 422     SdOptionsPrintItem aOptionsPrintItem;
 423
 424     VclPtr<SfxPrinter> pPrinter = pDocSh->GetPrinter( false );
 425     if( pPrinter )
 426     {
 427         SdOptionsPrintItem const * pPrinterOptions = pPrinter->GetOptions().GetItemIfSet( ATTR_OPTIONS_PRINT, false );
 428         if(pPrinterOptions)
 429             aOptionsPrintItem.GetOptionsPrint() = pPrinterOptions->GetOptionsPrint();
 430     }
 431     else
 432     {
 433         aOptionsPrintItem.SetOptions(SdModule::get()->GetSdOptions(pDoc->GetDocumentType()));
 434     }
 435     SdOptionsPrint& aPrintOpts = aOptionsPrintItem.GetOptionsPrint();
 436
 437     for( ; *ppEntries; ppEntries++, pValues++ )
 438     {
 439         bOk = false;
 440
 441         switch( (*ppEntries)->mnHandle )
 442         {
 443             case HANDLE_COLORTABLEURL:
 444                 AssignURL( XPropertyListType::Color, pValues, &bOk, &bChanged );
 445                 break;
 446
 447             case HANDLE_DASHTABLEURL:
 448                 AssignURL( XPropertyListType::Dash, pValues, &bOk, &bChanged );
 449                 break;
 450
 451             case HANDLE_LINEENDTABLEURL:
 452                 AssignURL( XPropertyListType::LineEnd, pValues, &bOk, &bChanged );
 453                 break;
 454
 455             case HANDLE_HATCHTABLEURL:
 456                 AssignURL( XPropertyListType::Hatch, pValues, &bOk, &bChanged );
 457                 break;
 458
 459             case HANDLE_GRADIENTTABLEURL:
 460                 AssignURL( XPropertyListType::Gradient, pValues, &bOk, &bChanged );
 461                 break;
 462
 463             case HANDLE_BITMAPTABLEURL:
 464                 AssignURL( XPropertyListType::Bitmap, pValues, &bOk, &bChanged );
 465                 break;
 466
 467             case HANDLE_FORBIDDENCHARS:
 468                 bOk = true;
 469                 break;
 470
 471             case HANDLE_APPLYUSERDATA:
 472                 {
 473                     bool bApplyUserData = false;
 474                     if( *pValues >>= bApplyUserData )
 475                     {
 476                         bChanged = ( bApplyUserData != pDocSh->IsUseUserData() );
 477                         pDocSh->SetUseUserData( bApplyUserData );
 478                         bOk = true;
 479                     }
 480                 }
 481                 break;
 482             case HANDLE_SAVETHUMBNAIL:
 483                 {
 484                     bool bSaveThumbnail = false;
 485                     if (*pValues >>= bSaveThumbnail)
 486                     {
 487                          bChanged = (bSaveThumbnail != pDocSh->IsUseThumbnailSave());
 488                          pDocSh->SetUseThumbnailSave(bSaveThumbnail);
 489                          bOk = true;
 490                     }
 491                 }
 492                 break;
 493
 494             case HANDLE_PRINTDRAWING:
 495                 if( *pValues >>= bValue )
 496                 {
 497                     if( aPrintOpts.IsDraw() != bValue )
 498                     {
 499                         aPrintOpts.SetDraw( bValue );
 500                         bOptionsChanged = true;
 501                     }
 502
 503                     bOk = true;
 504                 }
 505                 break;
 506             case HANDLE_PRINTNOTES:
 507                 if( *pValues >>= bValue )
 508                 {
 509                     if( aPrintOpts.IsNotes() != bValue )
 510                     {
 511                         aPrintOpts.SetNotes( bValue );
 512                         bOptionsChanged = true;
 513                     }
 514
 515                     bOk = true;
 516                 }
 517                 break;
 518             case HANDLE_PRINTHANDOUT:
 519                 if( *pValues >>= bValue )
 520                 {
 521                     if( aPrintOpts.IsHandout() != bValue)
 522                     {
 523                         aPrintOpts.SetHandout( bValue );
 524                         bOptionsChanged = true;
 525                     }
 526
 527                     bOk = true;
 528                 }
 529                 break;
 530             case HANDLE_PRINTOUTLINE:
 531                 if( *pValues >>= bValue )
 532                 {
 533                     if( aPrintOpts.IsOutline() != bValue)
 534                     {
 535                         aPrintOpts.SetOutline( bValue );
 536                         bOptionsChanged = true;
 537                     }
 538                     bOk = true;
 539                 }
 540                 break;
 541             case HANDLE_SLIDESPERHANDOUT:
 542                 {
 543                     sal_Int16 nValue = 0;
 544                     if( (*pValues >>= nValue) && (nValue >= 1) && (nValue <= 9) )
 545                     {
 546                         if( static_cast<sal_Int16>( aPrintOpts.GetHandoutPages() ) != nValue )
 547                         {
 548                             aPrintOpts.SetHandoutPages( static_cast< sal_uInt16 >( nValue ) );
 549                             bOptionsChanged = true;
 550                         }
 551                         bOk = true;
 552                     }
 553                 }
 554                 break;
 555             case HANDLE_HANDOUTHORIZONTAL:
 556                 if( *pValues >>= bValue )
 557                 {
 558                     if( aPrintOpts.IsHandoutHorizontal() != bValue )
 559                     {
 560                         aPrintOpts.SetHandoutHorizontal( bValue );
 561                         bOptionsChanged = true;
 562                     }
 563                     bOk = true;
 564                 }
 565                 break;
 566
 567             case HANDLE_PRINTPAGENAME:
 568                 if( *pValues >>= bValue )
 569                 {
 570                     if( aPrintOpts.IsPagename() != bValue)
 571                     {
 572                         aPrintOpts.SetPagename( bValue );
 573                         bOptionsChanged = true;
 574                     }
 575                     bOk = true;
 576                 }
 577                 break;
 578             case HANDLE_PRINTDATE:
 579                 if( *pValues >>= bValue )
 580                 {
 581                     if( aPrintOpts.IsDate() != bValue)
 582                     {
 583                         aPrintOpts.SetDate( bValue );
 584                         bOptionsChanged = true;
 585                     }
 586                     bOk = true;
 587                 }
 588                 break;
 589             case HANDLE_PRINTTIME:
 590                 if( *pValues >>= bValue )
 591                 {
 592                     if( aPrintOpts.IsDate() != bValue)
 593                     {
 594                         aPrintOpts.SetTime( bValue );
 595                         bOptionsChanged = true;
 596                     }
 597                     bOk = true;
 598                 }
 599                 break;
 600             case HANDLE_PRINTHIDDENPAGES:
 601                 if( *pValues >>= bValue )
 602                 {
 603                     if( aPrintOpts.IsHiddenPages() != bValue)
 604                     {
 605                         aPrintOpts.SetHiddenPages( bValue );
 606                         bOptionsChanged = true;
 607                     }
 608                     bOk = true;
 609                 }
 610                 break;
 611             case HANDLE_PRINTFITPAGE:
 612                 if( *pValues >>= bValue )
 613                 {
 614                     if( aPrintOpts.IsPagesize() != bValue)
 615                     {
 616                         aPrintOpts.SetPagesize( bValue );
 617                         bOptionsChanged = true;
 618                     }
 619                     bOk = true;
 620                 }
 621                 break;
 622             case HANDLE_PRINTTILEPAGE:
 623                 if( *pValues >>= bValue )
 624                 {
 625                     if( aPrintOpts.IsPagetile() != bValue)
 626                     {
 627                         aPrintOpts.SetPagetile( bValue );
 628                         bOptionsChanged = true;
 629                     }
 630                     bOk = true;
 631                 }
 632                 break;
 633             case HANDLE_PRINTBOOKLET:
 634                 if( *pValues >>= bValue )
 635                 {
 636                     if( aPrintOpts.IsBooklet() != bValue)
 637                     {
 638                         aPrintOpts.SetBooklet( bValue );
 639                         bOptionsChanged = true;
 640                     }
 641                     bOk = true;
 642                 }
 643                 break;
 644             case HANDLE_PRINTBOOKLETFRONT:
 645                 if( *pValues >>= bValue )
 646                 {
 647                     if( aPrintOpts.IsFrontPage() != bValue)
 648                     {
 649                         aPrintOpts.SetFrontPage( bValue );
 650                         bOptionsChanged = true;
 651                     }
 652                     bOk = true;
 653                 }
 654                 break;
 655             case HANDLE_PRINTBOOKLETBACK:
 656                 if( *pValues >>= bValue )
 657                 {
 658                     if( aPrintOpts.IsBackPage() != bValue)
 659                     {
 660                         aPrintOpts.SetBackPage( bValue );
 661                         bOptionsChanged = true;
 662                     }
 663                     bOk = true;
 664                 }
 665                 break;
 666             case HANDLE_PRINTQUALITY:
 667                 {
 668                     sal_Int32 nValue = 0;
 669                     if( *pValues >>= nValue )
 670                     {
 671                         if( aPrintOpts.GetOutputQuality() != nValue)
 672                         {
 673                             aPrintOpts.SetOutputQuality( static_cast<sal_uInt16>(nValue) );
 674                             bOptionsChanged = true;
 675                         }
 676                         bOk = true;
 677                     }
 678                 }
 679                 break;
 680             case HANDLE_MEASUREUNIT:
 681                 {
 682                     sal_Int16 nValue = 0;
 683                     if( *pValues >>= nValue )
 684                     {
 685                         FieldUnit nFieldUnit;
 686                         if( SvxMeasureUnitToFieldUnit( nValue, nFieldUnit ) )
 687                         {
 688                             pDoc->SetUIUnit( nFieldUnit );
 689                             bOk = true;
 690                         }
 691                     }
 692                 }
 693                 break;
 694             case HANDLE_SCALE_NUM:
 695                 {
 696                     sal_Int32 nValue = 0;
 697                     if( *pValues >>= nValue )
 698                     {
 699                         Fraction aFract( nValue, pDoc->GetUIScale().GetDenominator() );
 700                         pDoc->SetUIScale( aFract );
 701                         bOk = true;
 702                         bChanged = true;
 703                     }
 704                 }
 705                 break;
 706             case HANDLE_SCALE_DOM:
 707                 {
 708                     sal_Int32 nValue = 0;
 709                     if( *pValues >>= nValue )
 710                     {
 711                         auto nNumerator = pDoc->GetUIScale().GetNumerator();
 712                         assert(nNumerator != 0);
 713                         Fraction aFract(nNumerator, nValue);
 714                         pDoc->SetUIScale( aFract );
 715                         bOk = true;
 716                         bChanged = true;
 717                     }
 718                 }
 719                 break;
 720
 721             case HANDLE_TABSTOP:
 722                 {
 723                     sal_Int32 nValue = 0;
 724                     if( (*pValues >>= nValue) && (nValue >= 0) )
 725                     {
 726                         pDoc->SetDefaultTabulator(static_cast<sal_uInt16>(nValue));
 727                         bOk = true;
 728                         bChanged = true;
 729                     }
 730                 }
 731                 break;
 732             case HANDLE_PAGENUMFMT:
 733                 {
 734                     sal_Int32 nValue = 0;
 735                     if( (*pValues >>= nValue ) && (nValue >= css::style::NumberingType::CHARS_UPPER_LETTER ) && (nValue <= css::style::NumberingType::PAGE_DESCRIPTOR) )
 736                     {
 737                         pDoc->SetPageNumType(static_cast<SvxNumType>(nValue));
 738                         bOk = true;
 739                         bChanged = true;
 740                     }
 741                 }
 742                 break;
 743             case HANDLE_PRINTERNAME:
 744                 {
 745                     OUString aPrinterName;
 746                     if( *pValues >>= aPrinterName )
 747                     {
 748                         bOk = true;
 749                         if( !aPrinterName.isEmpty() && pDocSh->GetCreateMode() != SfxObjectCreateMode::EMBEDDED )
 750                         {
 751                             SfxPrinter *pTempPrinter = pDocSh->GetPrinter( true );
 752                             if (pTempPrinter)
 753                             {
 754                                 VclPtr<SfxPrinter> pNewPrinter = VclPtr<SfxPrinter>::Create( pTempPrinter->GetOptions().Clone(), aPrinterName );
 755                                 pDocSh->SetPrinter( pNewPrinter );
 756                             }
 757                         }
 758                     }
 759                 }
 760                 break;
 761             case HANDLE_PRINTERJOB:
 762                 {
 763                     Sequence < sal_Int8 > aSequence;
 764                     if ( *pValues >>= aSequence )
 765                     {
 766                         bOk = true;
 767                         sal_uInt32 nSize = aSequence.getLength();
 768                         if( nSize )
 769                         {
 770                             SvMemoryStream aStream (aSequence.getArray(), nSize, StreamMode::READ );
 771                             aStream.Seek ( STREAM_SEEK_TO_BEGIN );
 772                             std::unique_ptr<SfxItemSet> pItemSet;
 773
 774                             bool bPreferPrinterPapersize = false;
 775                             if( pPrinter )
 776                             {
 777                                 pItemSet = pPrinter->GetOptions().Clone();
 778                                 bPreferPrinterPapersize = pPrinter->GetPrinterSettingsPreferred();
 779                             }
 780                             else
 781                             {
 782                                 pItemSet = std::make_unique<SfxItemSetFixed
 783                                             <SID_PRINTER_NOTFOUND_WARN,  SID_PRINTER_NOTFOUND_WARN,
 784                                             SID_PRINTER_CHANGESTODOC,   SID_PRINTER_CHANGESTODOC,
 785                                             ATTR_OPTIONS_PRINT,         ATTR_OPTIONS_PRINT>>(pDoc->GetPool());
 786                             }
 787
 788                             pPrinter = SfxPrinter::Create ( aStream, std::move(pItemSet) );
 789                             pPrinter->SetPrinterSettingsPreferred( bPreferPrinterPapersize );
 790
 791                             MapMode aMM (pPrinter->GetMapMode());
 792                             aMM.SetMapUnit(MapUnit::Map100thMM);
 793                             pPrinter->SetMapMode(aMM);
 794
 795                             pDocSh->SetPrinter( pPrinter );
 796
 797                             pPrinter = nullptr;
 798                         }
 799                     }
 800                 }
 801                 break;
 802
 803             case HANDLE_PRINTERPAPERSIZE:
 804                 {
 805                     bool bPreferPrinterPapersize;
 806                     if( *pValues >>= bPreferPrinterPapersize )
 807                     {
 808                         bOk = true;
 809                         if( pDocSh->GetCreateMode() != SfxObjectCreateMode::EMBEDDED )
 810                         {
 811                             SfxPrinter *pTempPrinter = pDocSh->GetPrinter( true );
 812                             if (pTempPrinter)
 813                                 pTempPrinter->SetPrinterSettingsPreferred( bPreferPrinterPapersize );
 814                         }
 815                     }
 816                 }
 817                 break;
 818
 819             case HANDLE_PARAGRAPHSUMMATION :
 820             {
 821                 bool bIsSummationOfParagraphs = false;
 822                 if ( *pValues >>= bIsSummationOfParagraphs )
 823                 {
 824                     bOk = true;
 825                     bChanged = true;
 826                     if ( pDoc->GetDocumentType() == DocumentType::Impress )
 827                     {
 828                         EEControlBits nSum = bIsSummationOfParagraphs ? EEControlBits::ULSPACESUMMATION : EEControlBits::NONE;
 829                         EEControlBits nCntrl;
 830
 831                         pDoc->SetSummationOfParagraphs( bIsSummationOfParagraphs );
 832                         SdDrawDocument* pDocument = pDocSh->GetDoc();
 833                         SdrOutliner& rOutl = pDocument->GetDrawOutliner();
 834                         nCntrl = rOutl.GetControlWord() &~ EEControlBits::ULSPACESUMMATION;
 835                         rOutl.SetControlWord( nCntrl | nSum );
 836                         SdOutliner* pOutl = pDocument->GetOutliner( false );
 837                         if( pOutl )
 838                         {
 839                             nCntrl = pOutl->GetControlWord() &~ EEControlBits::ULSPACESUMMATION;
 840                             pOutl->SetControlWord( nCntrl | nSum );
 841                         }
 842                         pOutl = pDocument->GetInternalOutliner( false );
 843                         if( pOutl )
 844                         {
 845                             nCntrl = pOutl->GetControlWord() &~ EEControlBits::ULSPACESUMMATION;
 846                             pOutl->SetControlWord( nCntrl | nSum );
 847                         }
 848                     }
 849                 }
 850             }
 851             break;
 852
 853             case HANDLE_CHARCOMPRESS:
 854             {
 855                 sal_Int16 nCharCompressType = 0;
 856                 if( *pValues >>= nCharCompressType )
 857                 {
 858                     bOk = true;
 859
 860                     pDoc->SetCharCompressType( static_cast<CharCompressType>(nCharCompressType) );
 861                     SdDrawDocument* pDocument = pDocSh->GetDoc();
 862                     SdrOutliner& rOutl = pDocument->GetDrawOutliner();
 863                     rOutl.SetAsianCompressionMode( static_cast<CharCompressType>(nCharCompressType) );
 864                     SdOutliner* pOutl = pDocument->GetOutliner( false );
 865                     if( pOutl )
 866                     {
 867                         pOutl->SetAsianCompressionMode( static_cast<CharCompressType>(nCharCompressType) );
 868                     }
 869                     pOutl = pDocument->GetInternalOutliner( false );
 870                     if( pOutl )
 871                     {
 872                         pOutl->SetAsianCompressionMode( static_cast<CharCompressType>(nCharCompressType) );
 873                     }
 874                 }
 875                 break;
 876
 877             }
 878             case HANDLE_ASIANPUNCT:
 879             {
 880                 bool bAsianPunct = false;
 881                 if( *pValues >>= bAsianPunct )
 882                 {
 883                     bOk = true;
 884
 885                     pDoc->SetKernAsianPunctuation( bAsianPunct );
 886                     SdDrawDocument* pDocument = pDocSh->GetDoc();
 887                     SdrOutliner& rOutl = pDocument->GetDrawOutliner();
 888                     rOutl.SetKernAsianPunctuation( bAsianPunct );
 889                     SdOutliner* pOutl = pDocument->GetOutliner( false );
 890                     if( pOutl )
 891                     {
 892                         pOutl->SetKernAsianPunctuation( bAsianPunct );
 893                     }
 894                     pOutl = pDocument->GetInternalOutliner( false );
 895                     if( pOutl )
 896                     {
 897                         pOutl->SetKernAsianPunctuation( bAsianPunct );
 898                     }
 899                 }
 900                 break;
 901
 902             }
 903             case HANDLE_UPDATEFROMTEMPLATE:
 904             {
 905                 bool value = false;
 906                 if( *pValues >>= value )
 907                 {
 908                     bChanged = ( value != pDocSh->IsQueryLoadTemplate() );
 909                     pDocSh->SetQueryLoadTemplate( value );
 910                     bOk = true;
 911                 }
 912             }
 913             break;
 914
 915             case HANDLE_PRINTER_INDEPENDENT_LAYOUT:
 916             {
 917                 // Just propagate the new printer independent layout mode to
 918                 // the document and determine it really differs from the old
 919                 // one.
 920                 sal_Int16 nOldValue =
 921                     static_cast<sal_Int16>(pDoc->GetPrinterIndependentLayout ());
 922                 sal_Int16 nValue = 0;
 923                 if (*pValues >>= nValue)
 924                 {
 925                     pDoc->SetPrinterIndependentLayout (nValue);
 926                     bChanged = (nValue != nOldValue);
 927                     bOk = true;
 928                 }
 929             }
 930             break;
 931
 932             // --> #i33095#
 933             case HANDLE_LOAD_READONLY:
 934             {
 935                 bool bNewValue = false;
 936                 if ( *pValues >>= bNewValue )
 937                 {
 938                     bChanged = ( pDocSh->IsLoadReadonly() != bNewValue );
 939                     pDocSh->SetLoadReadonly( bNewValue );
 940                     bOk = true;
 941                 }
 942             }
 943             break;
 944
 945             case HANDLE_MODIFY_PASSWD:
 946             {
 947                 uno::Sequence< beans::PropertyValue > aInfo;
 948                 if ( !( *pValues >>= aInfo ) )
 949                     throw lang::IllegalArgumentException(
 950                         u"Value of type Sequence<PropertyValue> expected!"_ustr,
 951                         uno::Reference< uno::XInterface >(),
 952                         2 );
 953
 954                 if ( !pDocSh->SetModifyPasswordInfo( aInfo ) )
 955                     throw beans::PropertyVetoException(
 956                         u"The hash is not allowed to be changed now!"_ustr );
 957
 958                 bOk = true
 959 ;
 960
 961             }
 962             break;
 963
 964             case HANDLE_SAVE_VERSION:
 965             {
 966                 bool bNewValue = false;
 967                 if ( *pValues >>= bNewValue )
 968                 {
 969                     bChanged = ( pDocSh->IsSaveVersionOnClose() != bNewValue );
 970                     pDocSh->SetSaveVersionOnClose( bNewValue );
 971                     bOk = true;
 972                 }
 973             }
 974             break;
 975
 976             case HANDLE_EMBED_FONTS:
 977             {
 978                 if (pValues->has<bool>())
 979                 {
 980                     bool bNewValue = pValues->get<bool>();
 981                     bChanged = (pDoc->IsEmbedFonts() != bNewValue);
 982                     pDoc->SetEmbedFonts(bNewValue);
 983                     bOk = true;
 984                 }
 985             }
 986             break;
 987
 988             case HANDLE_EMBED_USED_FONTS:
 989             {
 990                 if (pValues->has<bool>())
 991                 {
 992                     bool bNewValue = pValues->get<bool>();
 993                     bChanged = (pDoc->IsEmbedUsedFontsOnly() != bNewValue);
 994                     pDoc->SetEmbedUsedFontsOnly(bNewValue);
 995                     bOk = true;
 996                 }
 997             }
 998             break;
 999
1000             case HANDLE_EMBED_LATIN_SCRIPT_FONTS:
1001             {
1002                 if (pValues->has<bool>())
1003                 {
1004                     bool bNewValue = pValues->get<bool>();
1005                     bChanged = (pDoc->IsEmbedFontScriptLatin() != bNewValue);
1006                     pDoc->SetEmbedFontScriptLatin(bNewValue);
1007                     bOk = true;
1008                 }
1009             }
1010             break;
1011
1012             case HANDLE_EMBED_ASIAN_SCRIPT_FONTS:
1013             {
1014                 if (pValues->has<bool>())
1015                 {
1016                     bool bNewValue = pValues->get<bool>();
1017                     bChanged = (pDoc->IsEmbedFontScriptAsian() != bNewValue);
1018                     pDoc->SetEmbedFontScriptAsian(bNewValue);
1019                     bOk = true;
1020                 }
1021             }
1022             break;
1023
1024             case HANDLE_EMBED_COMPLEX_SCRIPT_FONTS:
1025             {
1026                 if (pValues->has<bool>())
1027                 {
1028                     bool bNewValue = pValues->get<bool>();
1029                     bChanged = (pDoc->IsEmbedFontScriptComplex() != bNewValue);
1030                     pDoc->SetEmbedFontScriptComplex(bNewValue);
1031                     bOk = true;
1032                 }
1033             }
1034             break;
1035
1036             case HANDLE_IMAGE_PREFERRED_DPI:
1037             {
1038                 if (pValues->has<sal_Int32>())
1039                 {
1040                     auto nNewValue = pValues->get<sal_Int32>();
1041                     bChanged = (pDoc->getImagePreferredDPI() != nNewValue);
1042                     pDoc->setImagePreferredDPI(nNewValue);
1043                     bOk = true;
1044                 }
1045             }
1046             break;
1047
1048             default:
1049                 throw UnknownPropertyException( OUString::number((*ppEntries)->mnHandle), static_cast<cppu::OWeakObject*>(this));
1050         }
1051
1052         if( !bOk )
1053             throw IllegalArgumentException();
1054     }
1055
1056     if( bOptionsChanged )
1057     {
1058         if( !pPrinter )
1059             pPrinter = pDocSh->GetPrinter( true );
1060         SfxItemSet aNewOptions( pPrinter->GetOptions() );
1061         aNewOptions.Put( aOptionsPrintItem );
1062         pPrinter->SetOptions( aNewOptions );
1063     }
1064
1065     if( bChanged || bOptionsChanged )
1066         mxModel->SetModified();
1067 }
1068
1069 void DocumentSettings::ExtractURL( XPropertyListType t, Any* pValue )
1070 {
1071     XPropertyListRef pList = mxModel->GetDoc()->GetPropertyList( t );
1072     if( !pList.is() )
1073         return;
1074
1075     INetURLObject aPathURL( pList->GetPath() );
1076     aPathURL.insertName( pList->GetName() );
1077     aPathURL.setExtension( pList->GetDefaultExt() );
1078     OUString aPath( aPathURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
1079     *pValue <<= aPath;
1080 }
1081
1082 void
1083 DocumentSettings::_getPropertyValues(
1084         const PropertyMapEntry** ppEntries, Any* pValue)
1085 {
1086     ::SolarMutexGuard aGuard;
1087
1088     SdDrawDocument* pDoc = mxModel->GetDoc();
1089     ::sd::DrawDocShell* pDocSh = mxModel->GetDocShell();
1090     if( nullptr == pDoc || nullptr == pDocSh )
1091     {
1092         throw RuntimeException(u"Document or Shell missing"_ustr,
1093                 static_cast<OWeakObject *>(this));
1094     }
1095
1096     SdOptionsPrintItem aOptionsPrintItem;
1097
1098     SfxPrinter* pPrinter = pDocSh->GetPrinter( false );
1099     if( pPrinter )
1100     {
1101         SdOptionsPrintItem const * pPrinterOptions = pPrinter->GetOptions().GetItemIfSet( ATTR_OPTIONS_PRINT, false );
1102         if (pPrinterOptions)
1103             aOptionsPrintItem.GetOptionsPrint() = pPrinterOptions->GetOptionsPrint();
1104     }
1105     else
1106     {
1107         aOptionsPrintItem.SetOptions(SdModule::get()->GetSdOptions(pDoc->GetDocumentType()));
1108     }
1109     SdOptionsPrint& aPrintOpts = aOptionsPrintItem.GetOptionsPrint();
1110
1111     for( ; *ppEntries; ppEntries++, pValue++ )
1112     {
1113         switch( (*ppEntries)->mnHandle )
1114         {
1115             case HANDLE_COLORTABLEURL:
1116                 ExtractURL( XPropertyListType::Color, pValue );
1117                 break;
1118             case HANDLE_DASHTABLEURL:
1119                 ExtractURL( XPropertyListType::Dash, pValue );
1120                 break;
1121             case HANDLE_LINEENDTABLEURL:
1122                 ExtractURL( XPropertyListType::LineEnd, pValue );
1123                 break;
1124             case HANDLE_HATCHTABLEURL:
1125                 ExtractURL( XPropertyListType::Hatch, pValue );
1126                 break;
1127             case HANDLE_GRADIENTTABLEURL:
1128                 ExtractURL( XPropertyListType::Gradient, pValue );
1129                 break;
1130             case HANDLE_BITMAPTABLEURL:
1131                 ExtractURL( XPropertyListType::Bitmap, pValue );
1132                 break;
1133             case HANDLE_FORBIDDENCHARS:
1134                 *pValue <<= mxModel->getForbiddenCharsTable();
1135                 break;
1136             case HANDLE_APPLYUSERDATA:
1137                 *pValue <<= pDocSh->IsUseUserData();
1138                 break;
1139             case HANDLE_SAVETHUMBNAIL:
1140                 *pValue <<= pDocSh->IsUseThumbnailSave();
1141                 break;
1142             case HANDLE_PRINTDRAWING:
1143                 *pValue <<= aPrintOpts.IsDraw();
1144                 break;
1145             case HANDLE_PRINTNOTES:
1146                 *pValue <<= aPrintOpts.IsNotes();
1147                 break;
1148             case HANDLE_PRINTHANDOUT:
1149                 *pValue <<= aPrintOpts.IsHandout();
1150                 break;
1151             case HANDLE_PRINTOUTLINE:
1152                 *pValue <<= aPrintOpts.IsOutline();
1153                 break;
1154             case HANDLE_SLIDESPERHANDOUT:
1155                 *pValue <<= static_cast<sal_Int16>(aPrintOpts.GetHandoutPages());
1156                 break;
1157             case HANDLE_HANDOUTHORIZONTAL:
1158                 *pValue <<= aPrintOpts.IsHandoutHorizontal();
1159                 break;
1160             case HANDLE_PRINTPAGENAME:
1161                 *pValue <<= aPrintOpts.IsPagename();
1162                 break;
1163             case HANDLE_PRINTDATE:
1164                 *pValue <<= aPrintOpts.IsDate();
1165                 break;
1166             case HANDLE_PRINTTIME:
1167                 *pValue <<= aPrintOpts.IsTime();
1168                 break;
1169             case HANDLE_PRINTHIDDENPAGES:
1170                 *pValue <<= aPrintOpts.IsHiddenPages();
1171                 break;
1172             case HANDLE_PRINTFITPAGE:
1173                 *pValue <<= aPrintOpts.IsPagesize();
1174                 break;
1175             case HANDLE_PRINTTILEPAGE:
1176                 *pValue <<= aPrintOpts.IsPagetile();
1177                 break;
1178             case HANDLE_PRINTBOOKLET:
1179                 *pValue <<= aPrintOpts.IsBooklet();
1180                 break;
1181             case HANDLE_PRINTBOOKLETFRONT:
1182                 *pValue <<= aPrintOpts.IsFrontPage();
1183                 break;
1184             case HANDLE_PRINTBOOKLETBACK:
1185                 *pValue <<= aPrintOpts.IsBackPage();
1186                 break;
1187             case HANDLE_PRINTQUALITY:
1188                 *pValue <<= static_cast<sal_Int32>(aPrintOpts.GetOutputQuality());
1189                 break;
1190             case HANDLE_MEASUREUNIT:
1191                 {
1192                     short nMeasure;
1193                     SvxFieldUnitToMeasureUnit( pDoc->GetUIUnit(), nMeasure );
1194                     *pValue <<= static_cast<sal_Int16>(nMeasure);
1195                 }
1196                 break;
1197             case HANDLE_SCALE_NUM:
1198                 *pValue <<= pDoc->GetUIScale().GetNumerator();
1199                 break;
1200             case HANDLE_SCALE_DOM:
1201                 *pValue <<= pDoc->GetUIScale().GetDenominator();
1202                 break;
1203             case HANDLE_TABSTOP:
1204                 *pValue <<= static_cast<sal_Int32>(pDoc->GetDefaultTabulator());
1205                 break;
1206             case HANDLE_PAGENUMFMT:
1207                 *pValue <<= static_cast<sal_Int32>(pDoc->GetPageNumType());
1208                 break;
1209             case HANDLE_PRINTERNAME:
1210                 {
1211                     SfxPrinter *pTempPrinter = pDocSh->GetPrinter( false );
1212                     *pValue <<= pTempPrinter ? pTempPrinter->GetName() : OUString();
1213                 }
1214                 break;
1215             case HANDLE_PRINTERJOB:
1216                 {
1217                     SfxPrinter *pTempPrinter = pDocSh->GetPrinter( false );
1218                     if (pTempPrinter)
1219                     {
1220                         SvMemoryStream aStream;
1221                         pTempPrinter->Store( aStream );
1222                         *pValue <<= Sequence< sal_Int8 >( static_cast< const sal_Int8* >( aStream.GetData() ),
1223                                                         aStream.TellEnd() );
1224                     }
1225                     else
1226                     {
1227                         Sequence < sal_Int8 > aSequence;
1228                         *pValue <<= aSequence;
1229                     }
1230                 }
1231                 break;
1232
1233             case HANDLE_PRINTERPAPERSIZE:
1234                 {
1235                     SfxPrinter *pTempPrinter = pDocSh->GetPrinter( false );
1236                     *pValue <<= pTempPrinter && pTempPrinter->GetPrinterSettingsPreferred();
1237                 }
1238                 break;
1239
1240             case HANDLE_PARAGRAPHSUMMATION :
1241             {
1242                 bool bIsSummationOfParagraphs = pDoc->IsSummationOfParagraphs();
1243                 *pValue <<= bIsSummationOfParagraphs;
1244             }
1245             break;
1246
1247             case HANDLE_CHARCOMPRESS:
1248             {
1249                 *pValue <<= static_cast<sal_Int16>(pDoc->GetCharCompressType());
1250                 break;
1251             }
1252
1253             case HANDLE_ASIANPUNCT:
1254             {
1255                 *pValue <<= pDoc->IsKernAsianPunctuation();
1256                 break;
1257             }
1258
1259             case HANDLE_UPDATEFROMTEMPLATE:
1260             {
1261                 *pValue <<= pDocSh->IsQueryLoadTemplate();
1262             }
1263             break;
1264
1265             case HANDLE_PRINTER_INDEPENDENT_LAYOUT:
1266             {
1267                 sal_Int16 nPrinterIndependentLayout =
1268                     static_cast<sal_Int16>(pDoc->GetPrinterIndependentLayout());
1269                 *pValue <<= nPrinterIndependentLayout;
1270             }
1271             break;
1272
1273             // --> #i33095#
1274             case HANDLE_LOAD_READONLY:
1275             {
1276                 *pValue <<= pDocSh->IsLoadReadonly();
1277             }
1278             break;
1279
1280             case HANDLE_MODIFY_PASSWD:
1281             {
1282                 *pValue <<= pDocSh->GetModifyPasswordInfo();
1283             }
1284             break;
1285
1286             case HANDLE_SAVE_VERSION:
1287             {
1288                 *pValue <<= pDocSh->IsSaveVersionOnClose();
1289             }
1290             break;
1291
1292             case HANDLE_EMBED_FONTS:
1293             {
1294                 *pValue <<= pDoc->IsEmbedFonts();
1295             }
1296             break;
1297
1298             case HANDLE_EMBED_USED_FONTS:
1299             {
1300                 *pValue <<= pDoc->IsEmbedUsedFontsOnly();
1301             }
1302             break;
1303
1304             case HANDLE_EMBED_LATIN_SCRIPT_FONTS:
1305             {
1306                 *pValue <<= pDoc->IsEmbedFontScriptLatin();
1307             }
1308             break;
1309
1310             case HANDLE_EMBED_ASIAN_SCRIPT_FONTS:
1311             {
1312                 *pValue <<= pDoc->IsEmbedFontScriptAsian();
1313             }
1314             break;
1315
1316             case HANDLE_EMBED_COMPLEX_SCRIPT_FONTS:
1317             {
1318                 *pValue <<= pDoc->IsEmbedFontScriptComplex();
1319             }
1320             break;
1321
1322             case HANDLE_IMAGE_PREFERRED_DPI:
1323             {
1324                 *pValue <<= pDoc->getImagePreferredDPI();
1325             }
1326             break;
1327
1328             default:
1329                 throw UnknownPropertyException( OUString::number((*ppEntries)->mnHandle), static_cast<cppu::OWeakObject*>(this));
1330         }
1331     }
1332 }
1333
1334 // XInterface
1335 Any SAL_CALL DocumentSettings::queryInterface( const Type& aType )
1336 {
1337     return WeakImplHelper< XPropertySet, XMultiPropertySet, XServiceInfo >::queryInterface( aType );
1338 }
1339
1340 void SAL_CALL DocumentSettings::acquire(  ) noexcept
1341 {
1342     WeakImplHelper< XPropertySet, XMultiPropertySet, XServiceInfo >::acquire();
1343 }
1344
1345 void SAL_CALL DocumentSettings::release(  ) noexcept
1346 {
1347     WeakImplHelper< XPropertySet, XMultiPropertySet, XServiceInfo >::release();
1348 }
1349
1350 // XPropertySet
1351 Reference< XPropertySetInfo > SAL_CALL DocumentSettings::getPropertySetInfo(  )
1352 {
1353     return PropertySetHelper::getPropertySetInfo();
1354 }
1355
1356 void SAL_CALL DocumentSettings::setPropertyValue( const OUString& aPropertyName, const Any& aValue )
1357 {
1358     PropertySetHelper::setPropertyValue( aPropertyName, aValue );
1359 }
1360
1361 Any SAL_CALL DocumentSettings::getPropertyValue( const OUString& PropertyName )
1362 {
1363     return PropertySetHelper::getPropertyValue( PropertyName );
1364 }
1365
1366 void SAL_CALL DocumentSettings::addPropertyChangeListener( const OUString& aPropertyName, const Reference< XPropertyChangeListener >& xListener )
1367 {
1368     PropertySetHelper::addPropertyChangeListener( aPropertyName, xListener );
1369 }
1370
1371 void SAL_CALL DocumentSettings::removePropertyChangeListener( const OUString& aPropertyName, const Reference< XPropertyChangeListener >& aListener )
1372 {
1373     PropertySetHelper::removePropertyChangeListener( aPropertyName, aListener );
1374 }
1375
1376 void SAL_CALL DocumentSettings::addVetoableChangeListener( const OUString& PropertyName, const Reference< XVetoableChangeListener >& aListener )
1377 {
1378     PropertySetHelper::addVetoableChangeListener( PropertyName, aListener );
1379 }
1380
1381 void SAL_CALL DocumentSettings::removeVetoableChangeListener( const OUString& PropertyName, const Reference< XVetoableChangeListener >& aListener )
1382 {
1383     PropertySetHelper::removeVetoableChangeListener( PropertyName, aListener );
1384 }
1385
1386 // XMultiPropertySet
1387 void SAL_CALL DocumentSettings::setPropertyValues( const Sequence< OUString >& aPropertyNames, const Sequence< Any >& aValues )
1388 {
1389     PropertySetHelper::setPropertyValues( aPropertyNames, aValues );
1390 }
1391
1392 Sequence< Any > SAL_CALL DocumentSettings::getPropertyValues( const Sequence< OUString >& aPropertyNames )
1393 {
1394     return PropertySetHelper::getPropertyValues( aPropertyNames );
1395 }
1396
1397 void SAL_CALL DocumentSettings::addPropertiesChangeListener( const Sequence< OUString >& aPropertyNames, const Reference< XPropertiesChangeListener >& xListener )
1398 {
1399     PropertySetHelper::addPropertiesChangeListener( aPropertyNames, xListener );
1400 }
1401
1402 void SAL_CALL DocumentSettings::removePropertiesChangeListener( const Reference< XPropertiesChangeListener >& xListener )
1403 {
1404     PropertySetHelper::removePropertiesChangeListener( xListener );
1405 }
1406
1407 void SAL_CALL DocumentSettings::firePropertiesChangeEvent( const Sequence< OUString >& aPropertyNames, const Reference< XPropertiesChangeListener >& xListener )
1408 {
1409     PropertySetHelper::firePropertiesChangeEvent( aPropertyNames, xListener );
1410 }
1411
1412 // XServiceInfo
1413 OUString SAL_CALL DocumentSettings::getImplementationName(  )
1414 {
1415     return u"com.sun.star.comp.Draw.DocumentSettings"_ustr;
1416 }
1417
1418 sal_Bool SAL_CALL DocumentSettings::supportsService( const OUString& ServiceName )
1419 {
1420     return cppu::supportsService(this, ServiceName);
1421 }
1422
1423 Sequence< OUString > SAL_CALL DocumentSettings::getSupportedServiceNames(  )
1424 {
1425     return {  u"com.sun.star.document.Settings"_ustr ,
1426               mxModel->IsImpressDocument()?u"com.sun.star.presentation.DocumentSettings"_ustr:u"com.sun.star.drawing.DocumentSettings"_ustr };
1427 }
1428
1429 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */