unotools/source/config/fltrcfg.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 <o3tl/any.hxx>
  21 #include <o3tl/typed_flags_set.hxx>
  22 #include <unotools/fltrcfg.hxx>
  23 #include <tools/debug.hxx>
  24 #include <osl/diagnose.h>
  25
  26 #include <com/sun/star/uno/Sequence.hxx>
  27
  28 using namespace utl;
  29 using namespace com::sun::star::uno;
  30
  31 enum class ConfigFlags {
  32     NONE                         = 0x0000000,
  33     WordCode                     = 0x0000001,
  34     WordStorage                  = 0x0000002,
  35     ExcelCode                    = 0x0000004,
  36     ExcelStorage                 = 0x0000008,
  37     PowerPointCode               = 0x0000010,
  38     PowerPointStorage            = 0x0000020,
  39     MathLoad                     = 0x0000100,
  40     MathSave                     = 0x0000200,
  41     WriterLoad                   = 0x0000400,
  42     WriterSave                   = 0x0000800,
  43     CalcLoad                     = 0x0001000,
  44     CalcSave                     = 0x0002000,
  45     ImpressLoad                  = 0x0004000,
  46     ImpressSave                  = 0x0008000,
  47     ExcelExecTbl                 = 0x0010000,
  48     EnablePowerPointPreview      = 0x0020000,
  49     EnableExcelPreview           = 0x0040000,
  50     EnableWordPreview            = 0x0080000,
  51     UseEnhancedFields            = 0x0100000,
  52     WordWbctbl                   = 0x0200000,
  53     SmartArtShapeLoad            = 0x0400000,
  54     CharBackgroundToHighlighting = 0x8000000,
  55     CreateMSOLockFiles           = 0x2000000,
  56     VisioLoad                    = 0x4000000,
  57 };
  58 namespace o3tl {
  59     template<> struct typed_flags<ConfigFlags> : is_typed_flags<ConfigFlags, 0xe7fff3f> {};
  60 }
  61
  62 class SvtAppFilterOptions_Impl : public utl::ConfigItem
  63 {
  64 private:
  65     bool                bLoadVBA;
  66     bool                bSaveVBA;
  67
  68 protected:
  69     virtual void            ImplCommit() override;
  70
  71 public:
  72     explicit SvtAppFilterOptions_Impl(const OUString& rRoot) :
  73         utl::ConfigItem(rRoot),
  74         bLoadVBA(false),
  75         bSaveVBA(false)  {}
  76     virtual ~SvtAppFilterOptions_Impl() override;
  77     virtual void            Notify( const css::uno::Sequence<OUString>& aPropertyNames) override;
  78     void                    Load();
  79
  80     bool                IsLoad() const {return bLoadVBA;}
  81     void                    SetLoad(bool bSet)
  82                             {
  83                                 if(bSet != bLoadVBA)
  84                                     SetModified();
  85                                 bLoadVBA = bSet;
  86                             }
  87     bool                IsSave() const {return bSaveVBA;}
  88     void                    SetSave(bool bSet)
  89                             {
  90                                 if(bSet != bSaveVBA)
  91                                     SetModified();
  92                                 bSaveVBA = bSet;
  93                             }
  94 };
  95
  96 SvtAppFilterOptions_Impl::~SvtAppFilterOptions_Impl()
  97 {
  98     assert(!IsModified()); // should have been committed
  99 }
 100
 101 void    SvtAppFilterOptions_Impl::ImplCommit()
 102 {
 103     PutProperties(
 104         {"Load", "Save"}, {css::uno::Any(bLoadVBA), css::uno::Any(bSaveVBA)});
 105 }
 106
 107 void SvtAppFilterOptions_Impl::Notify( const Sequence< OUString >&  )
 108 {
 109     // no listeners supported yet
 110 }
 111
 112 void    SvtAppFilterOptions_Impl::Load()
 113 {
 114     Sequence<OUString> aNames(2);
 115     OUString* pNames = aNames.getArray();
 116     pNames[0] = "Load";
 117     pNames[1] = "Save";
 118
 119     Sequence<Any> aValues = GetProperties(aNames);
 120     const Any* pValues = aValues.getConstArray();
 121
 122     if(pValues[0].hasValue())
 123         bLoadVBA = *o3tl::doAccess<bool>(pValues[0]);
 124     if(pValues[1].hasValue())
 125         bSaveVBA = *o3tl::doAccess<bool>(pValues[1]);
 126 }
 127
 128 class SvtWriterFilterOptions_Impl : public SvtAppFilterOptions_Impl
 129 {
 130 private:
 131     bool                bLoadExecutable;
 132
 133     virtual void            ImplCommit() override;
 134
 135 public:
 136     explicit SvtWriterFilterOptions_Impl(const OUString& rRoot) :
 137         SvtAppFilterOptions_Impl(rRoot),
 138         bLoadExecutable(false)
 139     {}
 140     void                    Load();
 141
 142     bool                IsLoadExecutable() const {return bLoadExecutable;}
 143     void                    SetLoadExecutable(bool bSet)
 144                             {
 145                                 if(bSet != bLoadExecutable)
 146                                     SetModified();
 147                                 bLoadExecutable = bSet;
 148                             }
 149 };
 150
 151 void SvtWriterFilterOptions_Impl::ImplCommit()
 152 {
 153     SvtAppFilterOptions_Impl::ImplCommit();
 154
 155     Sequence<OUString> aNames { "Executable" };
 156     Sequence<Any> aValues(1);
 157     aValues[0] <<= bLoadExecutable;
 158
 159     PutProperties(aNames, aValues);
 160 }
 161
 162 void SvtWriterFilterOptions_Impl::Load()
 163 {
 164     SvtAppFilterOptions_Impl::Load();
 165
 166     Sequence<OUString> aNames { "Executable" };
 167
 168     Sequence<Any> aValues = GetProperties(aNames);
 169     const Any* pValues = aValues.getConstArray();
 170     if(pValues[0].hasValue())
 171         bLoadExecutable = *o3tl::doAccess<bool>(pValues[0]);
 172 }
 173
 174 class SvtCalcFilterOptions_Impl : public SvtAppFilterOptions_Impl
 175 {
 176 private:
 177     bool                bLoadExecutable;
 178
 179     virtual void            ImplCommit() override;
 180
 181 public:
 182     explicit SvtCalcFilterOptions_Impl(const OUString& rRoot) :
 183         SvtAppFilterOptions_Impl(rRoot),
 184         bLoadExecutable(false)
 185     {}
 186     void                    Load();
 187
 188     bool                IsLoadExecutable() const {return bLoadExecutable;}
 189     void                    SetLoadExecutable(bool bSet)
 190                             {
 191                                 if(bSet != bLoadExecutable)
 192                                     SetModified();
 193                                 bLoadExecutable = bSet;
 194                             }
 195 };
 196
 197 void SvtCalcFilterOptions_Impl::ImplCommit()
 198 {
 199     SvtAppFilterOptions_Impl::ImplCommit();
 200
 201     Sequence<OUString> aNames { "Executable" };
 202     Sequence<Any> aValues(1);
 203     aValues[0] <<= bLoadExecutable;
 204
 205     PutProperties(aNames, aValues);
 206 }
 207
 208 void SvtCalcFilterOptions_Impl::Load()
 209 {
 210     SvtAppFilterOptions_Impl::Load();
 211
 212     Sequence<OUString> aNames { "Executable" };
 213
 214     Sequence<Any> aValues = GetProperties(aNames);
 215     const Any* pValues = aValues.getConstArray();
 216     if(pValues[0].hasValue())
 217         bLoadExecutable = *o3tl::doAccess<bool>(pValues[0]);
 218 }
 219
 220 struct SvtFilterOptions_Impl
 221 {
 222     ConfigFlags nFlags;
 223     SvtWriterFilterOptions_Impl aWriterCfg;
 224     SvtCalcFilterOptions_Impl aCalcCfg;
 225     SvtAppFilterOptions_Impl aImpressCfg;
 226
 227     SvtFilterOptions_Impl() :
 228         aWriterCfg("Office.Writer/Filter/Import/VBA"),
 229         aCalcCfg("Office.Calc/Filter/Import/VBA"),
 230         aImpressCfg("Office.Impress/Filter/Import/VBA")
 231     {
 232         nFlags = ConfigFlags::WordCode |
 233             ConfigFlags::WordStorage |
 234             ConfigFlags::ExcelCode |
 235             ConfigFlags::ExcelStorage |
 236             ConfigFlags::PowerPointCode |
 237             ConfigFlags::PowerPointStorage |
 238             ConfigFlags::MathLoad |
 239             ConfigFlags::MathSave |
 240             ConfigFlags::WriterLoad |
 241             ConfigFlags::WriterSave |
 242             ConfigFlags::CalcLoad |
 243             ConfigFlags::CalcSave |
 244             ConfigFlags::ImpressLoad |
 245             ConfigFlags::ImpressSave |
 246             ConfigFlags::UseEnhancedFields |
 247             ConfigFlags::SmartArtShapeLoad |
 248             ConfigFlags::CharBackgroundToHighlighting|
 249             ConfigFlags::CreateMSOLockFiles;
 250         Load();
 251     }
 252
 253     void SetFlag( ConfigFlags nFlag, bool bSet );
 254     bool IsFlag( ConfigFlags nFlag ) const;
 255     void Load()
 256     {
 257         aWriterCfg.Load();
 258         aCalcCfg.Load();
 259         aImpressCfg.Load();
 260     }
 261 };
 262
 263 void SvtFilterOptions_Impl::SetFlag( ConfigFlags nFlag, bool bSet )
 264 {
 265     switch(nFlag)
 266     {
 267         case ConfigFlags::WordCode:       aWriterCfg.SetLoad(bSet);break;
 268         case ConfigFlags::WordStorage:    aWriterCfg.SetSave(bSet);break;
 269         case ConfigFlags::WordWbctbl: aWriterCfg.SetLoadExecutable(bSet);break;
 270         case ConfigFlags::ExcelCode:      aCalcCfg.SetLoad(bSet);break;
 271         case ConfigFlags::ExcelStorage:   aCalcCfg.SetSave(bSet);break;
 272         case ConfigFlags::ExcelExecTbl:   aCalcCfg.SetLoadExecutable(bSet);break;
 273         case ConfigFlags::PowerPointCode:     aImpressCfg.SetLoad(bSet);break;
 274         case ConfigFlags::PowerPointStorage:  aImpressCfg.SetSave(bSet);break;
 275         default:
 276             if( bSet )
 277                 nFlags |= nFlag;
 278             else
 279                 nFlags &= ~nFlag;
 280     }
 281 }
 282
 283 bool SvtFilterOptions_Impl::IsFlag( ConfigFlags nFlag ) const
 284 {
 285     bool bRet;
 286     switch(nFlag)
 287     {
 288         case ConfigFlags::WordCode        : bRet = aWriterCfg.IsLoad();break;
 289         case ConfigFlags::WordStorage     : bRet = aWriterCfg.IsSave();break;
 290         case ConfigFlags::WordWbctbl      : bRet = aWriterCfg.IsLoadExecutable();break;
 291         case ConfigFlags::ExcelCode       : bRet = aCalcCfg.IsLoad();break;
 292         case ConfigFlags::ExcelStorage    : bRet = aCalcCfg.IsSave();break;
 293         case ConfigFlags::ExcelExecTbl    : bRet = aCalcCfg.IsLoadExecutable();break;
 294         case ConfigFlags::PowerPointCode      : bRet = aImpressCfg.IsLoad();break;
 295         case ConfigFlags::PowerPointStorage   : bRet = aImpressCfg.IsSave();break;
 296         default:
 297             bRet = bool(nFlags & nFlag );
 298     }
 299     return bRet;
 300 }
 301
 302 namespace {
 303
 304 const Sequence<OUString>& GetPropertyNames()
 305 {
 306     static Sequence<OUString> const aNames
 307     {
 308             "Import/MathTypeToMath",            //  0
 309             "Import/WinWordToWriter",           //  1
 310             "Import/PowerPointToImpress",       //  2
 311             "Import/ExcelToCalc",               //  3
 312             "Export/MathToMathType",            //  4
 313             "Export/WriterToWinWord",           //  5
 314             "Export/ImpressToPowerPoint",       //  6
 315             "Export/CalcToExcel",               //  7
 316             "Export/EnablePowerPointPreview",   //  8
 317             "Export/EnableExcelPreview",        //  9
 318             "Export/EnableWordPreview",         // 10
 319             "Import/ImportWWFieldsAsEnhancedFields", // 11
 320             "Import/SmartArtToShapes",          // 12
 321             "Export/CharBackgroundToHighlighting",   // 13
 322             "Import/CreateMSOLockFiles",        // 14
 323             "Import/VisioToDraw"                // 15
 324     };
 325     return aNames;
 326 }
 327
 328 }
 329
 330 SvtFilterOptions::SvtFilterOptions() :
 331     ConfigItem( "Office.Common/Filter/Microsoft" ),
 332     pImpl(new SvtFilterOptions_Impl)
 333 {
 334     EnableNotification(GetPropertyNames());
 335     Load();
 336 }
 337
 338 SvtFilterOptions::~SvtFilterOptions()
 339 {
 340 }
 341
 342 static ConfigFlags lcl_GetFlag(sal_Int32 nProp)
 343 {
 344     ConfigFlags nFlag = ConfigFlags::NONE;
 345     switch(nProp)
 346     {
 347         case  0: nFlag = ConfigFlags::MathLoad; break;
 348         case  1: nFlag = ConfigFlags::WriterLoad; break;
 349         case  2: nFlag = ConfigFlags::ImpressLoad; break;
 350         case  3: nFlag = ConfigFlags::CalcLoad; break;
 351         case  4: nFlag = ConfigFlags::MathSave; break;
 352         case  5: nFlag = ConfigFlags::WriterSave; break;
 353         case  6: nFlag = ConfigFlags::ImpressSave; break;
 354         case  7: nFlag = ConfigFlags::CalcSave; break;
 355         case  8: nFlag = ConfigFlags::EnablePowerPointPreview; break;
 356         case  9: nFlag = ConfigFlags::EnableExcelPreview; break;
 357         case 10: nFlag = ConfigFlags::EnableWordPreview; break;
 358         case 11: nFlag = ConfigFlags::UseEnhancedFields; break;
 359         case 12: nFlag = ConfigFlags::SmartArtShapeLoad; break;
 360         case 13: nFlag = ConfigFlags::CharBackgroundToHighlighting; break;
 361         case 14: nFlag = ConfigFlags::CreateMSOLockFiles; break;
 362         case 15:
 363             nFlag = ConfigFlags::VisioLoad;
 364             break;
 365
 366         default: OSL_FAIL("illegal value");
 367     }
 368     return nFlag;
 369 }
 370
 371 void SvtFilterOptions::Notify( const Sequence<OUString>& )
 372 {
 373     Load();
 374 }
 375
 376 void SvtFilterOptions::ImplCommit()
 377 {
 378     const Sequence<OUString>& aNames = GetPropertyNames();
 379     Sequence<Any> aValues(aNames.getLength());
 380     Any* pValues = aValues.getArray();
 381
 382     for(int nProp = 0; nProp < aNames.getLength(); nProp++)
 383     {
 384         ConfigFlags nFlag = lcl_GetFlag(nProp);
 385         pValues[nProp] <<= pImpl->IsFlag(nFlag);
 386
 387     }
 388     PutProperties(aNames, aValues);
 389 }
 390
 391 void SvtFilterOptions::Load()
 392 {
 393     pImpl->Load();
 394     const Sequence<OUString>& rNames = GetPropertyNames();
 395     Sequence<Any> aValues = GetProperties(rNames);
 396     const Any* pValues = aValues.getConstArray();
 397     DBG_ASSERT(aValues.getLength() == rNames.getLength(), "GetProperties failed");
 398     if(aValues.getLength() == rNames.getLength())
 399     {
 400         for(int nProp = 0; nProp < rNames.getLength(); nProp++)
 401         {
 402             if(pValues[nProp].hasValue())
 403             {
 404                 bool bVal = *o3tl::doAccess<bool>(pValues[nProp]);
 405                 ConfigFlags nFlag = lcl_GetFlag(nProp);
 406                 pImpl->SetFlag( nFlag, bVal);
 407             }
 408         }
 409     }
 410 }
 411
 412 void SvtFilterOptions::SetLoadWordBasicCode( bool bFlag )
 413 {
 414     pImpl->SetFlag( ConfigFlags::WordCode, bFlag );
 415     SetModified();
 416 }
 417
 418 bool SvtFilterOptions::IsLoadWordBasicCode() const
 419 {
 420     return pImpl->IsFlag( ConfigFlags::WordCode );
 421 }
 422
 423 void SvtFilterOptions::SetLoadWordBasicExecutable( bool bFlag )
 424 {
 425     pImpl->SetFlag( ConfigFlags::WordWbctbl, bFlag );
 426     SetModified();
 427 }
 428
 429 bool SvtFilterOptions::IsLoadWordBasicExecutable() const
 430 {
 431     return pImpl->IsFlag( ConfigFlags::WordWbctbl );
 432 }
 433
 434 void SvtFilterOptions::SetLoadWordBasicStorage( bool bFlag )
 435 {
 436     pImpl->SetFlag( ConfigFlags::WordStorage, bFlag );
 437     SetModified();
 438 }
 439
 440 bool SvtFilterOptions::IsLoadWordBasicStorage() const
 441 {
 442     return pImpl->IsFlag( ConfigFlags::WordStorage );
 443 }
 444
 445 void SvtFilterOptions::SetLoadExcelBasicCode( bool bFlag )
 446 {
 447     pImpl->SetFlag( ConfigFlags::ExcelCode, bFlag );
 448     SetModified();
 449 }
 450
 451 bool SvtFilterOptions::IsLoadExcelBasicCode() const
 452 {
 453     return pImpl->IsFlag( ConfigFlags::ExcelCode );
 454 }
 455
 456 void SvtFilterOptions::SetLoadExcelBasicExecutable( bool bFlag )
 457 {
 458     pImpl->SetFlag( ConfigFlags::ExcelExecTbl, bFlag );
 459     SetModified();
 460 }
 461
 462 bool SvtFilterOptions::IsLoadExcelBasicExecutable() const
 463 {
 464     return pImpl->IsFlag( ConfigFlags::ExcelExecTbl );
 465 }
 466
 467 void SvtFilterOptions::SetLoadExcelBasicStorage( bool bFlag )
 468 {
 469     pImpl->SetFlag( ConfigFlags::ExcelStorage, bFlag );
 470     SetModified();
 471 }
 472
 473 bool SvtFilterOptions::IsLoadExcelBasicStorage() const
 474 {
 475     return pImpl->IsFlag( ConfigFlags::ExcelStorage );
 476 }
 477
 478 void SvtFilterOptions::SetLoadPPointBasicCode( bool bFlag )
 479 {
 480     pImpl->SetFlag( ConfigFlags::PowerPointCode, bFlag );
 481     SetModified();
 482 }
 483
 484 bool SvtFilterOptions::IsLoadPPointBasicCode() const
 485 {
 486     return pImpl->IsFlag( ConfigFlags::PowerPointCode );
 487 }
 488
 489 void SvtFilterOptions::SetLoadPPointBasicStorage( bool bFlag )
 490 {
 491     pImpl->SetFlag( ConfigFlags::PowerPointStorage, bFlag );
 492     SetModified();
 493 }
 494
 495 bool SvtFilterOptions::IsLoadPPointBasicStorage() const
 496 {
 497     return pImpl->IsFlag( ConfigFlags::PowerPointStorage );
 498 }
 499
 500 bool SvtFilterOptions::IsMathType2Math() const
 501 {
 502     return pImpl->IsFlag( ConfigFlags::MathLoad );
 503 }
 504
 505 void SvtFilterOptions::SetMathType2Math( bool bFlag )
 506 {
 507     pImpl->SetFlag( ConfigFlags::MathLoad, bFlag );
 508     SetModified();
 509 }
 510
 511 bool SvtFilterOptions::IsMath2MathType() const
 512 {
 513     return pImpl->IsFlag( ConfigFlags::MathSave );
 514 }
 515
 516 void SvtFilterOptions::SetMath2MathType( bool bFlag )
 517 {
 518     pImpl->SetFlag( ConfigFlags::MathSave, bFlag );
 519     SetModified();
 520 }
 521
 522 bool SvtFilterOptions::IsWinWord2Writer() const
 523 {
 524     return pImpl->IsFlag( ConfigFlags::WriterLoad );
 525 }
 526
 527 void SvtFilterOptions::SetWinWord2Writer( bool bFlag )
 528 {
 529     pImpl->SetFlag( ConfigFlags::WriterLoad, bFlag );
 530     SetModified();
 531 }
 532
 533 bool SvtFilterOptions::IsWriter2WinWord() const
 534 {
 535     return pImpl->IsFlag( ConfigFlags::WriterSave );
 536 }
 537
 538 void SvtFilterOptions::SetWriter2WinWord( bool bFlag )
 539 {
 540     pImpl->SetFlag( ConfigFlags::WriterSave, bFlag );
 541     SetModified();
 542 }
 543
 544 bool SvtFilterOptions::IsUseEnhancedFields() const
 545 {
 546     return pImpl->IsFlag( ConfigFlags::UseEnhancedFields );
 547 }
 548
 549 bool SvtFilterOptions::IsExcel2Calc() const
 550 {
 551     return pImpl->IsFlag( ConfigFlags::CalcLoad );
 552 }
 553
 554 void SvtFilterOptions::SetExcel2Calc( bool bFlag )
 555 {
 556     pImpl->SetFlag( ConfigFlags::CalcLoad, bFlag );
 557     SetModified();
 558 }
 559
 560 bool SvtFilterOptions::IsCalc2Excel() const
 561 {
 562     return pImpl->IsFlag( ConfigFlags::CalcSave );
 563 }
 564
 565 void SvtFilterOptions::SetCalc2Excel( bool bFlag )
 566 {
 567     pImpl->SetFlag( ConfigFlags::CalcSave, bFlag );
 568     SetModified();
 569 }
 570
 571 bool SvtFilterOptions::IsPowerPoint2Impress() const
 572 {
 573     return pImpl->IsFlag( ConfigFlags::ImpressLoad );
 574 }
 575
 576 void SvtFilterOptions::SetPowerPoint2Impress( bool bFlag )
 577 {
 578     pImpl->SetFlag( ConfigFlags::ImpressLoad, bFlag );
 579     SetModified();
 580 }
 581
 582 bool SvtFilterOptions::IsImpress2PowerPoint() const
 583 {
 584     return pImpl->IsFlag( ConfigFlags::ImpressSave );
 585 }
 586
 587 void SvtFilterOptions::SetImpress2PowerPoint( bool bFlag )
 588 {
 589     pImpl->SetFlag( ConfigFlags::ImpressSave, bFlag );
 590     SetModified();
 591 }
 592
 593 bool SvtFilterOptions::IsSmartArt2Shape() const
 594 {
 595     return pImpl->IsFlag( ConfigFlags::SmartArtShapeLoad );
 596 }
 597
 598 void SvtFilterOptions::SetSmartArt2Shape( bool bFlag )
 599 {
 600     pImpl->SetFlag( ConfigFlags::SmartArtShapeLoad, bFlag );
 601     SetModified();
 602 }
 603
 604 bool SvtFilterOptions::IsVisio2Draw() const { return pImpl->IsFlag(ConfigFlags::VisioLoad); }
 605
 606 void SvtFilterOptions::SetVisio2Draw(bool bFlag)
 607 {
 608     pImpl->SetFlag(ConfigFlags::VisioLoad, bFlag);
 609     SetModified();
 610 }
 611
 612 namespace
 613 {
 614     class theFilterOptions
 615          : public rtl::Static<SvtFilterOptions, theFilterOptions>
 616     {
 617     };
 618 }
 619
 620 SvtFilterOptions& SvtFilterOptions::Get()
 621 {
 622     return theFilterOptions::get();
 623 }
 624
 625 bool SvtFilterOptions::IsEnablePPTPreview() const
 626 {
 627     return pImpl->IsFlag( ConfigFlags::EnablePowerPointPreview );
 628 }
 629
 630 bool SvtFilterOptions::IsEnableCalcPreview() const
 631 {
 632     return pImpl->IsFlag( ConfigFlags::EnableExcelPreview );
 633 }
 634
 635 bool SvtFilterOptions::IsEnableWordPreview() const
 636 {
 637     return pImpl->IsFlag( ConfigFlags::EnableWordPreview );
 638 }
 639
 640 bool SvtFilterOptions::IsCharBackground2Highlighting() const
 641 {
 642     return pImpl->IsFlag( ConfigFlags::CharBackgroundToHighlighting );
 643 }
 644
 645 bool SvtFilterOptions::IsCharBackground2Shading() const
 646 {
 647     return !pImpl->IsFlag( ConfigFlags::CharBackgroundToHighlighting );
 648 }
 649
 650 void SvtFilterOptions::SetCharBackground2Highlighting()
 651 {
 652     pImpl->SetFlag( ConfigFlags::CharBackgroundToHighlighting, true );
 653     SetModified();
 654 }
 655
 656 void SvtFilterOptions::SetCharBackground2Shading()
 657 {
 658     pImpl->SetFlag( ConfigFlags::CharBackgroundToHighlighting, false );
 659     SetModified();
 660 }
 661
 662 bool SvtFilterOptions::IsMSOLockFileCreationIsEnabled() const
 663 {
 664     return pImpl->IsFlag( ConfigFlags::CreateMSOLockFiles );
 665 }
 666
 667 void SvtFilterOptions::EnableMSOLockFileCreation(bool bEnable)
 668 {
 669     pImpl->SetFlag( ConfigFlags::CreateMSOLockFiles, bEnable );
 670     SetModified();
 671 }
 672
 673 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */