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