unotools/source/config/saveopt.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 <sal/log.hxx>
  23 #include <unotools/saveopt.hxx>
  24 #include <rtl/instance.hxx>
  25 #include <unotools/configmgr.hxx>
  26 #include <unotools/configitem.hxx>
  27 #include <tools/debug.hxx>
  28 #include <com/sun/star/uno/Any.hxx>
  29 #include <com/sun/star/uno/Sequence.hxx>
  30
  31 #include <osl/diagnose.h>
  32 #include <osl/mutex.hxx>
  33 #include <officecfg/Office/Recovery.hxx>
  34
  35 using namespace utl;
  36 using namespace com::sun::star::uno;
  37
  38 class SvtSaveOptions_Impl;
  39 class SvtLoadOptions_Impl;
  40
  41 #define CFG_READONLY_DEFAULT    false
  42
  43 struct SvtLoadSaveOptions_Impl
  44 {
  45     std::unique_ptr<SvtSaveOptions_Impl> pSaveOpt;
  46     std::unique_ptr<SvtLoadOptions_Impl> pLoadOpt;
  47 };
  48
  49 static std::unique_ptr<SvtLoadSaveOptions_Impl> pOptions;
  50 static sal_Int32           nRefCount = 0;
  51
  52 class SvtSaveOptions_Impl : public utl::ConfigItem
  53 {
  54     sal_Int32                           nAutoSaveTime;
  55     bool                            bUseUserData,
  56                                         bBackup,
  57                                         bAutoSave,
  58                                         bAutoSavePrompt,
  59                                         bUserAutoSave,
  60                                         bDocInfSave,
  61                                         bSaveWorkingSet,
  62                                         bSaveDocView,
  63                                         bSaveRelINet,
  64                                         bSaveRelFSys,
  65                                         bDoPrettyPrinting,
  66                                         bWarnAlienFormat,
  67                                         bLoadDocPrinter;
  68
  69     SvtSaveOptions::ODFDefaultVersion   eODFDefaultVersion;
  70
  71     bool                            bROAutoSaveTime,
  72                                         bROUseUserData,
  73                                         bROBackup,
  74                                         bROAutoSave,
  75                                         bROAutoSavePrompt,
  76                                         bROUserAutoSave,
  77                                         bRODocInfSave,
  78                                         bROSaveWorkingSet,
  79                                         bROSaveDocView,
  80                                         bROSaveRelINet,
  81                                         bROSaveRelFSys,
  82                                         bROWarnAlienFormat,
  83                                         bRODoPrettyPrinting,
  84                                         bROLoadDocPrinter,
  85                                         bROODFDefaultVersion;
  86
  87     virtual void            ImplCommit() override;
  88
  89 public:
  90                             SvtSaveOptions_Impl();
  91
  92     virtual void            Notify( const css::uno::Sequence< OUString >& aPropertyNames ) override;
  93
  94     sal_Int32               GetAutoSaveTime() const             { return nAutoSaveTime; }
  95     bool                    IsUseUserData() const               { return bUseUserData; }
  96     bool                    IsBackup() const                    { return bBackup; }
  97     bool                    IsAutoSave() const                  { return bAutoSave; }
  98     bool                    IsAutoSavePrompt() const            { return bAutoSavePrompt; }
  99     bool                    IsUserAutoSave() const              { return bUserAutoSave; }
 100     bool                    IsDocInfoSave() const               { return bDocInfSave; }
 101     bool                    IsSaveWorkingSet() const            { return bSaveWorkingSet;         }
 102     bool                    IsSaveDocView() const               { return bSaveDocView; }
 103     bool                    IsSaveRelINet() const               { return bSaveRelINet; }
 104     bool                    IsSaveRelFSys() const               { return bSaveRelFSys; }
 105     bool                IsPrettyPrintingEnabled( ) const    { return bDoPrettyPrinting; }
 106     bool                IsWarnAlienFormat() const           { return bWarnAlienFormat; }
 107     bool                IsLoadDocPrinter() const            { return bLoadDocPrinter; }
 108
 109     SvtSaveOptions::ODFDefaultVersion
 110                             GetODFDefaultVersion() const        { return eODFDefaultVersion; }
 111
 112     void                    SetAutoSaveTime( sal_Int32 n );
 113     void                    SetUseUserData( bool b );
 114     void                    SetBackup( bool b );
 115     void                    SetAutoSave( bool b );
 116     void                    SetAutoSavePrompt( bool b );
 117     void                    SetUserAutoSave( bool b );
 118     void                    SetDocInfoSave( bool b );
 119     void                    SetSaveWorkingSet( bool b );
 120     void                    SetSaveDocView( bool b );
 121     void                    SetSaveRelINet( bool b );
 122     void                    SetSaveRelFSys( bool b );
 123     void                    EnablePrettyPrinting( bool _bDoPP );
 124     void                    SetWarnAlienFormat( bool _bDoPP );
 125     void                    SetLoadDocPrinter( bool bNew );
 126     void                    SetODFDefaultVersion( SvtSaveOptions::ODFDefaultVersion eNew );
 127
 128     bool                IsReadOnly( SvtSaveOptions::EOption eOption ) const;
 129 };
 130
 131 void SvtSaveOptions_Impl::SetAutoSaveTime( sal_Int32 n )
 132 {
 133     if (!bROAutoSaveTime && nAutoSaveTime!=n)
 134     {
 135         nAutoSaveTime = n;
 136         SetModified();
 137         Commit();
 138     }
 139 }
 140
 141 void SvtSaveOptions_Impl::SetUseUserData( bool b )
 142 {
 143     if (!bROUseUserData && bUseUserData!=b)
 144     {
 145         bUseUserData = b;
 146         SetModified();
 147     }
 148 }
 149
 150 void SvtSaveOptions_Impl::SetBackup( bool b )
 151 {
 152     if (!bROBackup && bBackup!=b)
 153     {
 154         bBackup = b;
 155         SetModified();
 156     }
 157 }
 158
 159 void SvtSaveOptions_Impl::SetAutoSave( bool b )
 160 {
 161     if (!bROAutoSave && bAutoSave!=b)
 162     {
 163         bAutoSave = b;
 164         SetModified();
 165         Commit();
 166     }
 167 }
 168
 169 void SvtSaveOptions_Impl::SetAutoSavePrompt( bool b )
 170 {
 171     if (!bROAutoSavePrompt && bAutoSavePrompt!=b)
 172     {
 173         bAutoSavePrompt = b;
 174         SetModified();
 175     }
 176 }
 177
 178 void SvtSaveOptions_Impl::SetUserAutoSave( bool b )
 179 {
 180     if (!bROUserAutoSave && bUserAutoSave!=b)
 181     {
 182         bUserAutoSave = b;
 183         SetModified();
 184         Commit();
 185     }
 186 }
 187
 188 void SvtSaveOptions_Impl::SetDocInfoSave(bool b)
 189 {
 190     if (!bRODocInfSave && bDocInfSave!=b)
 191     {
 192         bDocInfSave = b;
 193         SetModified();
 194     }
 195 }
 196
 197 void SvtSaveOptions_Impl::SetSaveWorkingSet( bool b )
 198 {
 199     if (!bROSaveWorkingSet && bSaveWorkingSet!=b)
 200     {
 201         bSaveWorkingSet = b;
 202         SetModified();
 203     }
 204 }
 205
 206 void SvtSaveOptions_Impl::SetSaveDocView( bool b )
 207 {
 208     if (!bROSaveDocView && bSaveDocView!=b)
 209     {
 210         bSaveDocView = b;
 211         SetModified();
 212     }
 213 }
 214
 215 void SvtSaveOptions_Impl::SetSaveRelINet( bool b )
 216 {
 217     if (!bROSaveRelINet && bSaveRelINet!=b)
 218     {
 219         bSaveRelINet = b;
 220         SetModified();
 221     }
 222 }
 223
 224 void SvtSaveOptions_Impl::SetSaveRelFSys( bool b )
 225 {
 226     if (!bROSaveRelFSys && bSaveRelFSys!=b)
 227     {
 228         bSaveRelFSys = b;
 229         SetModified();
 230     }
 231 }
 232
 233 void SvtSaveOptions_Impl::EnablePrettyPrinting( bool _bDoPP )
 234 {
 235     if (!bRODoPrettyPrinting && bDoPrettyPrinting!=_bDoPP)
 236     {
 237         bDoPrettyPrinting = _bDoPP;
 238         SetModified();
 239     }
 240 }
 241
 242 void SvtSaveOptions_Impl::SetWarnAlienFormat( bool _bDoPP )
 243 {
 244     if (!bROWarnAlienFormat && bWarnAlienFormat!=_bDoPP)
 245     {
 246         bWarnAlienFormat = _bDoPP;
 247         SetModified();
 248     }
 249 }
 250
 251 void SvtSaveOptions_Impl::SetLoadDocPrinter( bool bNew )
 252 {
 253     if ( !bROLoadDocPrinter && bLoadDocPrinter != bNew )
 254     {
 255         bLoadDocPrinter = bNew;
 256         SetModified();
 257     }
 258 }
 259
 260 void SvtSaveOptions_Impl::SetODFDefaultVersion( SvtSaveOptions::ODFDefaultVersion eNew )
 261 {
 262     if ( !bROODFDefaultVersion && eODFDefaultVersion != eNew )
 263     {
 264         eODFDefaultVersion = eNew;
 265         SetModified();
 266     }
 267 }
 268
 269 bool SvtSaveOptions_Impl::IsReadOnly( SvtSaveOptions::EOption eOption ) const
 270 {
 271     bool bReadOnly = CFG_READONLY_DEFAULT;
 272     switch(eOption)
 273     {
 274         case SvtSaveOptions::EOption::AutoSaveTime :
 275             bReadOnly = bROAutoSaveTime;
 276             break;
 277         case SvtSaveOptions::EOption::UseUserData :
 278             bReadOnly = bROUseUserData;
 279             break;
 280         case SvtSaveOptions::EOption::Backup :
 281             bReadOnly = bROBackup;
 282             break;
 283         case SvtSaveOptions::EOption::AutoSave :
 284             bReadOnly = bROAutoSave;
 285             break;
 286         case SvtSaveOptions::EOption::AutoSavePrompt :
 287             bReadOnly = bROAutoSavePrompt;
 288             break;
 289         case SvtSaveOptions::EOption::UserAutoSave :
 290             bReadOnly = bROUserAutoSave;
 291             break;
 292         case SvtSaveOptions::EOption::DocInfSave :
 293             bReadOnly = bRODocInfSave;
 294             break;
 295         case SvtSaveOptions::EOption::SaveWorkingSet :
 296             bReadOnly = bROSaveWorkingSet;
 297             break;
 298         case SvtSaveOptions::EOption::SaveDocView :
 299             bReadOnly = bROSaveDocView;
 300             break;
 301         case SvtSaveOptions::EOption::SaveRelInet :
 302             bReadOnly = bROSaveRelINet;
 303             break;
 304         case SvtSaveOptions::EOption::SaveRelFsys :
 305             bReadOnly = bROSaveRelFSys;
 306             break;
 307         case SvtSaveOptions::EOption::DoPrettyPrinting :
 308             bReadOnly = bRODoPrettyPrinting;
 309             break;
 310         case SvtSaveOptions::EOption::WarnAlienFormat :
 311             bReadOnly = bROWarnAlienFormat;
 312             break;
 313         case SvtSaveOptions::EOption::LoadDocPrinter :
 314             bReadOnly = bROLoadDocPrinter;
 315             break;
 316         case SvtSaveOptions::EOption::OdfDefaultVersion :
 317             bReadOnly = bROLoadDocPrinter;
 318             break;
 319     }
 320     return bReadOnly;
 321 }
 322
 323 #define FORMAT              0
 324 #define TIMEINTERVALL       1
 325 #define USEUSERDATA         2
 326 #define CREATEBACKUP        3
 327 #define AUTOSAVE            4
 328 #define PROMPT              5
 329 #define EDITPROPERTY        6
 330 #define SAVEVIEWINFO        7
 331 #define PRETTYPRINTING      8
 332 #define WARNALIENFORMAT     9
 333 #define LOADDOCPRINTER      10
 334 #define FILESYSTEM          11
 335 #define INTERNET            12
 336 #define SAVEWORKINGSET      13
 337 #define ODFDEFAULTVERSION   14
 338
 339 static Sequence< OUString > GetPropertyNames()
 340 {
 341     static const char* aPropNames[] =
 342     {
 343         "Graphic/Format",
 344         "Document/AutoSaveTimeIntervall",
 345         "Document/UseUserData",
 346         "Document/CreateBackup",
 347         "Document/AutoSave",
 348         "Document/AutoSavePrompt",
 349         "Document/EditProperty",
 350         "Document/ViewInfo",
 351         "Document/PrettyPrinting",
 352         "Document/WarnAlienFormat",
 353         "Document/LoadPrinter",
 354         "URL/FileSystem",
 355         "URL/Internet",
 356         "WorkingSet",
 357         "ODF/DefaultVersion"
 358     };
 359
 360     const int nCount = SAL_N_ELEMENTS( aPropNames );
 361     Sequence< OUString > aNames( nCount );
 362     OUString* pNames = aNames.getArray();
 363     for ( int i = 0; i < nCount; i++ )
 364         pNames[i] = OUString::createFromAscii( aPropNames[i] );
 365
 366     return aNames;
 367 }
 368
 369 SvtSaveOptions_Impl::SvtSaveOptions_Impl()
 370     : ConfigItem( "Office.Common/Save" )
 371     , nAutoSaveTime( 0 )
 372     , bUseUserData( false )
 373     , bBackup( false )
 374     , bAutoSave( false )
 375     , bAutoSavePrompt( false )
 376     , bUserAutoSave( false )
 377     , bDocInfSave( false )
 378     , bSaveWorkingSet( false )
 379     , bSaveDocView( false )
 380     , bSaveRelINet( false )
 381     , bSaveRelFSys( false )
 382     , bDoPrettyPrinting( false )
 383     , bWarnAlienFormat( true )
 384     , bLoadDocPrinter( true )
 385     , eODFDefaultVersion( SvtSaveOptions::ODFVER_LATEST )
 386     , bROAutoSaveTime( CFG_READONLY_DEFAULT )
 387     , bROUseUserData( CFG_READONLY_DEFAULT )
 388     , bROBackup( CFG_READONLY_DEFAULT )
 389     , bROAutoSave( CFG_READONLY_DEFAULT )
 390     , bROAutoSavePrompt( CFG_READONLY_DEFAULT )
 391     , bROUserAutoSave( CFG_READONLY_DEFAULT )
 392     , bRODocInfSave( CFG_READONLY_DEFAULT )
 393     , bROSaveWorkingSet( CFG_READONLY_DEFAULT )
 394     , bROSaveDocView( CFG_READONLY_DEFAULT )
 395     , bROSaveRelINet( CFG_READONLY_DEFAULT )
 396     , bROSaveRelFSys( CFG_READONLY_DEFAULT )
 397     , bROWarnAlienFormat( CFG_READONLY_DEFAULT )
 398     , bRODoPrettyPrinting( CFG_READONLY_DEFAULT )
 399     , bROLoadDocPrinter( CFG_READONLY_DEFAULT )
 400     , bROODFDefaultVersion( CFG_READONLY_DEFAULT )
 401 {
 402     Sequence< OUString > aNames = GetPropertyNames();
 403     Sequence< Any > aValues = GetProperties( aNames );
 404     Sequence< sal_Bool > aROStates = GetReadOnlyStates( aNames );
 405     EnableNotification( aNames );
 406     const Any* pValues = aValues.getConstArray();
 407     const sal_Bool* pROStates = aROStates.getConstArray();
 408     DBG_ASSERT( aValues.getLength() == aNames.getLength(), "GetProperties failed" );
 409     DBG_ASSERT( aROStates.getLength() == aNames.getLength(), "GetReadOnlyStates failed" );
 410     if ( aValues.getLength() == aNames.getLength() && aROStates.getLength() == aNames.getLength() )
 411     {
 412         for ( int nProp = 0; nProp < aNames.getLength(); nProp++ )
 413         {
 414             if ( pValues[nProp].hasValue() )
 415             {
 416                 sal_Int32 nTemp = 0;
 417                 switch ( nProp )
 418                 {
 419                     case FORMAT:
 420                         // not supported anymore
 421                         break;
 422
 423                     case TIMEINTERVALL :
 424                         if ( pValues[nProp] >>= nTemp )
 425                             nAutoSaveTime = nTemp;
 426                         else {
 427                             OSL_FAIL( "Wrong Type!" );
 428                         };
 429                         bROAutoSaveTime = pROStates[nProp];
 430                         break;
 431
 432                     case ODFDEFAULTVERSION :
 433                     {
 434                         sal_Int16 nTmp = 0;
 435                         if ( pValues[nProp] >>= nTmp )
 436                         {
 437                             if( nTmp == 3 )
 438                                 eODFDefaultVersion = SvtSaveOptions::ODFVER_LATEST;
 439                             else
 440                                 eODFDefaultVersion = SvtSaveOptions::ODFDefaultVersion( nTmp );
 441                         }
 442                         else {
 443                             SAL_WARN( "unotools.config", "SvtSaveOptions_Impl::SvtSaveOptions_Impl(): Wrong Type!" );
 444                         };
 445                         bROODFDefaultVersion = pROStates[nProp];
 446                         break;
 447                     }
 448
 449                     default:
 450                     {
 451                         bool bTemp = bool();
 452                         if ( pValues[nProp] >>= bTemp )
 453                         {
 454                             switch ( nProp )
 455                             {
 456                                 case USEUSERDATA :
 457                                     bUseUserData = bTemp;
 458                                     bROUseUserData = pROStates[nProp];
 459                                     break;
 460                                 case CREATEBACKUP :
 461                                     bBackup = bTemp;
 462                                     bROBackup = pROStates[nProp];
 463                                     break;
 464                                 case AUTOSAVE :
 465                                     bAutoSave = bTemp;
 466                                     bROAutoSave = pROStates[nProp];
 467                                     break;
 468                                 case PROMPT :
 469                                     bAutoSavePrompt = bTemp;
 470                                     bROAutoSavePrompt = pROStates[nProp];
 471                                     break;
 472                                 case EDITPROPERTY :
 473                                     bDocInfSave = bTemp;
 474                                     bRODocInfSave = pROStates[nProp];
 475                                     break;
 476                                 case SAVEWORKINGSET :
 477                                     bSaveWorkingSet = bTemp;
 478                                     bROSaveWorkingSet = pROStates[nProp];
 479                                     break;
 480                                 case SAVEVIEWINFO :
 481                                     bSaveDocView = bTemp;
 482                                     bROSaveDocView = pROStates[nProp];
 483                                     break;
 484                                 case FILESYSTEM :
 485                                     bSaveRelFSys = bTemp;
 486                                     bROSaveRelFSys = pROStates[nProp];
 487                                     break;
 488                                 case INTERNET :
 489                                     bSaveRelINet = bTemp;
 490                                     bROSaveRelINet = pROStates[nProp];
 491                                     break;
 492
 493                                 case PRETTYPRINTING:
 494                                     bDoPrettyPrinting = bTemp;
 495                                     bRODoPrettyPrinting = pROStates[nProp];
 496                                     break;
 497
 498                                 case WARNALIENFORMAT:
 499                                     bWarnAlienFormat = bTemp;
 500                                     bROWarnAlienFormat = pROStates[nProp];
 501                                     break;
 502
 503                                 case LOADDOCPRINTER:
 504                                     bLoadDocPrinter = bTemp;
 505                                     bROLoadDocPrinter = pROStates[nProp];
 506                                     break;
 507
 508                                 default :
 509                                     SAL_WARN( "unotools.config", "invalid index to load a path" );
 510                             }
 511                         }
 512                         else
 513                         {
 514                             OSL_FAIL( "Wrong Type!" );
 515                         }
 516                     }
 517                 }
 518             }
 519         }
 520     }
 521
 522     if (!utl::ConfigManager::IsFuzzing())
 523     {
 524         bAutoSave = officecfg::Office::Recovery::AutoSave::Enabled::get();
 525         nAutoSaveTime = officecfg::Office::Recovery::AutoSave::TimeIntervall::get();
 526         bUserAutoSave = officecfg::Office::Recovery::AutoSave::UserAutoSaveEnabled::get();
 527     }
 528     else
 529     {
 530         bAutoSave = false;
 531         nAutoSaveTime = 0;
 532         bUserAutoSave = false;
 533     }
 534 }
 535
 536 void SvtSaveOptions_Impl::ImplCommit()
 537 {
 538     Sequence< OUString > aOrgNames = GetPropertyNames();
 539     OUString* pOrgNames = aOrgNames.getArray();
 540     sal_Int32 nOrgCount = aOrgNames.getLength();
 541
 542     Sequence< OUString > aNames( nOrgCount );
 543     Sequence< Any > aValues( nOrgCount );
 544     OUString* pNames = aNames.getArray();
 545     Any* pValues = aValues.getArray();
 546     sal_Int32 nRealCount = 0;
 547
 548     for (sal_Int32 i=0; i<nOrgCount; ++i)
 549     {
 550         switch (i)
 551         {
 552             case FORMAT:
 553                 // not supported anymore
 554                 break;
 555             case TIMEINTERVALL :
 556                 if (!bROAutoSaveTime)
 557                 {
 558                     pValues[nRealCount] <<= nAutoSaveTime;
 559                     pNames[nRealCount] = pOrgNames[i];
 560                     ++nRealCount;
 561                 }
 562                 break;
 563             case USEUSERDATA :
 564                 if (!bROUseUserData)
 565                 {
 566                     pValues[nRealCount] <<= bUseUserData;
 567                     pNames[nRealCount] = pOrgNames[i];
 568                     ++nRealCount;
 569                 }
 570                 break;
 571             case CREATEBACKUP :
 572                 if (!bROBackup)
 573                 {
 574                     pValues[nRealCount] <<= bBackup;
 575                     pNames[nRealCount] = pOrgNames[i];
 576                     ++nRealCount;
 577                 }
 578                 break;
 579             case AUTOSAVE :
 580                 if (!bROAutoSave)
 581                 {
 582                     pValues[nRealCount] <<= bAutoSave;
 583                     pNames[nRealCount] = pOrgNames[i];
 584                     ++nRealCount;
 585                 }
 586                 break;
 587             case PROMPT :
 588                 if (!bROAutoSavePrompt)
 589                 {
 590                     pValues[nRealCount] <<= bAutoSavePrompt;
 591                     pNames[nRealCount] = pOrgNames[i];
 592                     ++nRealCount;
 593                 }
 594                 break;
 595             case EDITPROPERTY :
 596                 if (!bRODocInfSave)
 597                 {
 598                     pValues[nRealCount] <<= bDocInfSave;
 599                     pNames[nRealCount] = pOrgNames[i];
 600                     ++nRealCount;
 601                 }
 602                 break;
 603             case SAVEWORKINGSET :
 604                 if (!bROSaveWorkingSet)
 605                 {
 606                     pValues[nRealCount] <<= bSaveWorkingSet;
 607                     pNames[nRealCount] = pOrgNames[i];
 608                     ++nRealCount;
 609                 }
 610                 break;
 611             case SAVEVIEWINFO :
 612                 if (!bROSaveDocView)
 613                 {
 614                     pValues[nRealCount] <<= bSaveDocView;
 615                     pNames[nRealCount] = pOrgNames[i];
 616                     ++nRealCount;
 617                 }
 618                 break;
 619             case FILESYSTEM :
 620                 if (!bROSaveRelFSys)
 621                 {
 622                     pValues[nRealCount] <<= bSaveRelFSys;
 623                     pNames[nRealCount] = pOrgNames[i];
 624                     ++nRealCount;
 625                 }
 626                 break;
 627             case INTERNET :
 628                 if (!bROSaveRelINet)
 629                 {
 630                     pValues[nRealCount] <<= bSaveRelINet;
 631                     pNames[nRealCount] = pOrgNames[i];
 632                     ++nRealCount;
 633                 }
 634                 break;
 635             case PRETTYPRINTING:
 636                 if (!bRODoPrettyPrinting)
 637                 {
 638                     pValues[nRealCount] <<= bDoPrettyPrinting;
 639                     pNames[nRealCount] = pOrgNames[i];
 640                     ++nRealCount;
 641                 }
 642                 break;
 643             case WARNALIENFORMAT:
 644                 if (!bROWarnAlienFormat)
 645                 {
 646                     pValues[nRealCount] <<= bWarnAlienFormat;
 647                     pNames[nRealCount] = pOrgNames[i];
 648                     ++nRealCount;
 649                 }
 650                 break;
 651             case LOADDOCPRINTER:
 652                 if (!bROLoadDocPrinter)
 653                 {
 654                     pValues[nRealCount] <<= bLoadDocPrinter;
 655                     pNames[nRealCount] = pOrgNames[i];
 656                     ++nRealCount;
 657                 }
 658                 break;
 659             case ODFDEFAULTVERSION:
 660                 if (!bROODFDefaultVersion)
 661                 {
 662                     pValues[nRealCount] <<= (eODFDefaultVersion == SvtSaveOptions::ODFVER_LATEST) ? sal_Int16( 3 ) : sal_Int16( eODFDefaultVersion );
 663                     pNames[nRealCount] = pOrgNames[i];
 664                     ++nRealCount;
 665                 }
 666                 break;
 667
 668             default:
 669                 SAL_WARN( "unotools.config", "invalid index to save a path" );
 670         }
 671     }
 672
 673     aNames.realloc(nRealCount);
 674     aValues.realloc(nRealCount);
 675     PutProperties( aNames, aValues );
 676
 677     std::shared_ptr< comphelper::ConfigurationChanges > batch(
 678     comphelper::ConfigurationChanges::create());
 679     officecfg::Office::Recovery::AutoSave::TimeIntervall::set(nAutoSaveTime, batch);
 680     officecfg::Office::Recovery::AutoSave::Enabled::set(bAutoSave, batch);
 681     officecfg::Office::Recovery::AutoSave::UserAutoSaveEnabled::set(bUserAutoSave, batch);
 682     batch->commit();
 683 }
 684
 685 void SvtSaveOptions_Impl::Notify( const Sequence<OUString>& )
 686 {
 687 }
 688
 689 class SvtLoadOptions_Impl : public utl::ConfigItem
 690 {
 691 private:
 692     bool                            bLoadUserDefinedSettings;
 693
 694     virtual void            ImplCommit() override;
 695
 696 public:
 697                             SvtLoadOptions_Impl();
 698
 699     virtual void            Notify( const css::uno::Sequence< OUString >& aPropertyNames ) override;
 700
 701     void                    SetLoadUserSettings(bool b){bLoadUserDefinedSettings = b; SetModified();}
 702     bool                IsLoadUserSettings() const {return bLoadUserDefinedSettings;}
 703 };
 704
 705 const sal_Char cUserDefinedSettings[] = "UserDefinedSettings";
 706
 707 SvtLoadOptions_Impl::SvtLoadOptions_Impl()
 708     : ConfigItem( "Office.Common/Load" )
 709     , bLoadUserDefinedSettings( false )
 710 {
 711     Sequence< OUString > aNames { cUserDefinedSettings };
 712     Sequence< Any > aValues = GetProperties( aNames );
 713     EnableNotification( aNames );
 714     const Any* pValues = aValues.getConstArray();
 715     DBG_ASSERT( aValues.getLength() == aNames.getLength(), "GetProperties failed" );
 716     pValues[0] >>= bLoadUserDefinedSettings;
 717 }
 718
 719 void SvtLoadOptions_Impl::ImplCommit()
 720 {
 721     PutProperties(
 722         {cUserDefinedSettings}, {css::uno::Any(bLoadUserDefinedSettings)});
 723 }
 724
 725 void SvtLoadOptions_Impl::Notify( const Sequence<OUString>& )
 726 {
 727     SAL_WARN( "unotools.config", "properties have been changed" );
 728 }
 729
 730 namespace
 731 {
 732     class LocalSingleton : public rtl::Static< osl::Mutex, LocalSingleton >
 733     {
 734     };
 735 }
 736
 737 SvtSaveOptions::SvtSaveOptions()
 738 {
 739     // Global access, must be guarded (multithreading)
 740     ::osl::MutexGuard aGuard( LocalSingleton::get() );
 741     if ( !pOptions )
 742     {
 743         pOptions.reset(new SvtLoadSaveOptions_Impl);
 744         pOptions->pSaveOpt.reset(new SvtSaveOptions_Impl);
 745         pOptions->pLoadOpt.reset( new SvtLoadOptions_Impl);
 746     }
 747     ++nRefCount;
 748     pImp = pOptions.get();
 749 }
 750
 751 SvtSaveOptions::~SvtSaveOptions()
 752 {
 753     // Global access, must be guarded (multithreading)
 754     ::osl::MutexGuard aGuard( LocalSingleton::get() );
 755     if ( !--nRefCount )
 756     {
 757         if ( pOptions->pSaveOpt->IsModified() )
 758             pOptions->pSaveOpt->Commit();
 759         if ( pOptions->pLoadOpt->IsModified() )
 760             pOptions->pLoadOpt->Commit();
 761
 762         pOptions.reset();
 763     }
 764 }
 765
 766 void SvtSaveOptions::SetAutoSaveTime( sal_Int32 n )
 767 {
 768     pImp->pSaveOpt->SetAutoSaveTime( n );
 769 }
 770
 771 sal_Int32 SvtSaveOptions::GetAutoSaveTime() const
 772 {
 773     return pImp->pSaveOpt->GetAutoSaveTime();
 774 }
 775
 776 void SvtSaveOptions::SetUseUserData( bool b )
 777 {
 778     pImp->pSaveOpt->SetUseUserData( b );
 779 }
 780
 781 bool SvtSaveOptions::IsUseUserData() const
 782 {
 783     return pImp->pSaveOpt->IsUseUserData();
 784 }
 785
 786 void SvtSaveOptions::SetBackup( bool b )
 787 {
 788     pImp->pSaveOpt->SetBackup( b );
 789 }
 790
 791 bool SvtSaveOptions::IsBackup() const
 792 {
 793     return pImp->pSaveOpt->IsBackup();
 794 }
 795
 796 void SvtSaveOptions::SetAutoSave( bool b )
 797 {
 798     pImp->pSaveOpt->SetAutoSave( b );
 799 }
 800
 801 bool SvtSaveOptions::IsAutoSave() const
 802 {
 803     return pImp->pSaveOpt->IsAutoSave();
 804 }
 805
 806 void SvtSaveOptions::SetAutoSavePrompt( bool b )
 807 {
 808     pImp->pSaveOpt->SetAutoSavePrompt( b );
 809 }
 810
 811 bool SvtSaveOptions::IsAutoSavePrompt() const
 812 {
 813     return pImp->pSaveOpt->IsAutoSavePrompt();
 814 }
 815
 816 void SvtSaveOptions::SetUserAutoSave( bool b )
 817 {
 818     pImp->pSaveOpt->SetUserAutoSave( b );
 819 }
 820
 821 bool SvtSaveOptions::IsUserAutoSave() const
 822 {
 823     return pImp->pSaveOpt->IsUserAutoSave();
 824 }
 825
 826 void SvtSaveOptions::SetDocInfoSave(bool b)
 827 {
 828     pImp->pSaveOpt->SetDocInfoSave( b );
 829 }
 830
 831 bool SvtSaveOptions::IsDocInfoSave() const
 832 {
 833     return pImp->pSaveOpt->IsDocInfoSave();
 834 }
 835
 836 void SvtSaveOptions::SetSaveWorkingSet( bool b )
 837 {
 838     pImp->pSaveOpt->SetSaveWorkingSet( b );
 839 }
 840
 841 bool SvtSaveOptions::IsSaveWorkingSet() const
 842 {
 843     return pImp->pSaveOpt->IsSaveWorkingSet();
 844 }
 845
 846 void SvtSaveOptions::SetSaveDocView( bool b )
 847 {
 848     pImp->pSaveOpt->SetSaveDocView( b );
 849 }
 850
 851 bool SvtSaveOptions::IsSaveDocView() const
 852 {
 853     return pImp->pSaveOpt->IsSaveDocView();
 854 }
 855
 856 void SvtSaveOptions::SetSaveRelINet( bool b )
 857 {
 858     pImp->pSaveOpt->SetSaveRelINet( b );
 859 }
 860
 861 bool SvtSaveOptions::IsSaveRelINet() const
 862 {
 863     return pImp->pSaveOpt->IsSaveRelINet();
 864 }
 865
 866 void SvtSaveOptions::SetSaveRelFSys( bool b )
 867 {
 868     pImp->pSaveOpt->SetSaveRelFSys( b );
 869 }
 870
 871 bool SvtSaveOptions::IsSaveRelFSys() const
 872 {
 873     return pImp->pSaveOpt->IsSaveRelFSys();
 874 }
 875
 876 void SvtSaveOptions::SetLoadUserSettings(bool b)
 877 {
 878     pImp->pLoadOpt->SetLoadUserSettings(b);
 879 }
 880
 881 bool   SvtSaveOptions::IsLoadUserSettings() const
 882 {
 883     return pImp->pLoadOpt->IsLoadUserSettings();
 884 }
 885
 886 void SvtSaveOptions::SetPrettyPrinting( bool _bEnable )
 887 {
 888     pImp->pSaveOpt->EnablePrettyPrinting( _bEnable );
 889 }
 890
 891 bool SvtSaveOptions::IsPrettyPrinting() const
 892 {
 893     return pImp->pSaveOpt->IsPrettyPrintingEnabled();
 894 }
 895
 896 void SvtSaveOptions::SetWarnAlienFormat( bool _bEnable )
 897 {
 898     pImp->pSaveOpt->SetWarnAlienFormat( _bEnable );
 899 }
 900
 901 bool SvtSaveOptions::IsWarnAlienFormat() const
 902 {
 903     return pImp->pSaveOpt->IsWarnAlienFormat();
 904 }
 905
 906 void SvtSaveOptions::SetLoadDocumentPrinter( bool _bEnable )
 907 {
 908     pImp->pSaveOpt->SetLoadDocPrinter( _bEnable );
 909 }
 910
 911 bool SvtSaveOptions::IsLoadDocumentPrinter() const
 912 {
 913     return pImp->pSaveOpt->IsLoadDocPrinter();
 914 }
 915
 916 void SvtSaveOptions::SetODFDefaultVersion( SvtSaveOptions::ODFDefaultVersion eVersion )
 917 {
 918     pImp->pSaveOpt->SetODFDefaultVersion( eVersion );
 919 }
 920
 921 SvtSaveOptions::ODFDefaultVersion SvtSaveOptions::GetODFDefaultVersion() const
 922 {
 923     return pImp->pSaveOpt->GetODFDefaultVersion();
 924 }
 925
 926 SvtSaveOptions::ODFSaneDefaultVersion SvtSaveOptions::GetODFSaneDefaultVersion() const
 927 {
 928     switch (pImp->pSaveOpt->GetODFDefaultVersion())
 929     {
 930         default:
 931             assert(!"map new ODFDefaultVersion to ODFSaneDefaultVersion");
 932             break;
 933         case ODFVER_UNKNOWN:
 934         case ODFVER_LATEST:
 935             return ODFSVER_LATEST_EXTENDED;
 936         case ODFVER_010:
 937             return ODFSVER_010;
 938         case ODFVER_011:
 939             return ODFSVER_011;
 940         case ODFVER_012:
 941             return ODFSVER_012;
 942         case ODFVER_012_EXT_COMPAT:
 943             return ODFSVER_012_EXT_COMPAT;
 944     }
 945     return ODFSVER_LATEST_EXTENDED;
 946 }
 947
 948 bool SvtSaveOptions::IsReadOnly( SvtSaveOptions::EOption eOption ) const
 949 {
 950     return pImp->pSaveOpt->IsReadOnly(eOption);
 951 }
 952
 953 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */