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