xref: /trunk/main/unotools/source/config/fltrcfg.cxx (revision b5088357)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_unotools.hxx"
26 
27 #include <unotools/fltrcfg.hxx>
28 #include <tools/debug.hxx>
29 
30 #include <rtl/logfile.hxx>
31 #include <com/sun/star/uno/Any.hxx>
32 #include <com/sun/star/uno/Sequence.hxx>
33 
34 using namespace utl;
35 using namespace rtl;
36 using namespace com::sun::star::uno;
37 
38 #define C2U(cChar) OUString::createFromAscii(cChar)
39 
40 // -----------------------------------------------------------------------
41 #define FILTERCFG_WORD_CODE 			0x0001
42 #define FILTERCFG_WORD_STORAGE 			0x0002
43 #define FILTERCFG_EXCEL_CODE 			0x0004
44 #define FILTERCFG_EXCEL_STORAGE 		0x0008
45 #define FILTERCFG_PPOINT_CODE 			0x0010
46 #define FILTERCFG_PPOINT_STORAGE 		0x0020
47 #define FILTERCFG_MATH_LOAD				0x0100
48 #define FILTERCFG_MATH_SAVE				0x0200
49 #define FILTERCFG_WRITER_LOAD			0x0400
50 #define FILTERCFG_WRITER_SAVE			0x0800
51 #define FILTERCFG_CALC_LOAD				0x1000
52 #define FILTERCFG_CALC_SAVE				0x2000
53 #define FILTERCFG_IMPRESS_LOAD			0x4000
54 #define FILTERCFG_IMPRESS_SAVE			0x8000
55 #define FILTERCFG_EXCEL_EXECTBL			0x10000
56 #define FILTERCFG_ENABLE_PPT_PREVIEW    0x20000
57 #define FILTERCFG_ENABLE_EXCEL_PREVIEW  0x40000
58 #define FILTERCFG_ENABLE_WORD_PREVIEW   0x80000
59 #define FILTERCFG_USE_ENHANCED_FIELDS	0x100000
60 
61 static SvtFilterOptions* pOptions=0;
62 
63 /* -----------------------------22.01.01 10:23--------------------------------
64 
65  ---------------------------------------------------------------------------*/
66 class SvtAppFilterOptions_Impl : public utl::ConfigItem
67 {
68 	sal_Bool				bLoadVBA;
69 	sal_Bool				bSaveVBA;
70 public:
SvtAppFilterOptions_Impl(const OUString & rRoot)71 	SvtAppFilterOptions_Impl(const OUString& rRoot) :
72 		utl::ConfigItem(rRoot),
73 		bLoadVBA(sal_False),
74 		bSaveVBA(sal_False)	 {}
75 	~SvtAppFilterOptions_Impl();
76 	virtual void			Commit();
77 	virtual void    		Notify( const com::sun::star::uno::Sequence<rtl::OUString>& aPropertyNames);
78 	void					Load();
79 
IsLoad() const80 	sal_Bool				IsLoad() const {return bLoadVBA;}
SetLoad(sal_Bool bSet)81 	void					SetLoad(sal_Bool bSet)
82 							{
83 								if(bSet != bLoadVBA)
84 									SetModified();
85 								bLoadVBA = bSet;
86 							}
IsSave() const87 	sal_Bool				IsSave() const {return bSaveVBA;}
SetSave(sal_Bool bSet)88 	void					SetSave(sal_Bool bSet)
89 							{
90 								if(bSet != bSaveVBA)
91 									SetModified();
92 								bSaveVBA = bSet;
93 							}
94 };
95 
96 /* -----------------------------22.01.01 11:08--------------------------------
97 
98  ---------------------------------------------------------------------------*/
~SvtAppFilterOptions_Impl()99 SvtAppFilterOptions_Impl::~SvtAppFilterOptions_Impl()
100 {
101 	if(IsModified())
102 		Commit();
103 }
104 /* -----------------------------22.01.01 10:38--------------------------------
105 
106  ---------------------------------------------------------------------------*/
Commit()107 void	SvtAppFilterOptions_Impl::Commit()
108 {
109 	Sequence<OUString> aNames(2);
110 	OUString* pNames = aNames.getArray();
111 	pNames[0] = C2U("Load");
112 	pNames[1] = C2U("Save");
113 	Sequence<Any> aValues(aNames.getLength());
114 	Any* pValues = aValues.getArray();
115 
116 	const Type& rType = ::getBooleanCppuType();
117 	pValues[0].setValue(&bLoadVBA, rType);
118 	pValues[1].setValue(&bSaveVBA, rType);
119 
120 	PutProperties(aNames, aValues);
121 }
122 
Notify(const Sequence<rtl::OUString> &)123 void SvtAppFilterOptions_Impl::Notify( const Sequence< rtl::OUString >&  )
124 {
125 	// no listeners supported yet
126 }
127 
128 
129 /* -----------------------------22.01.01 10:38--------------------------------
130 
131  ---------------------------------------------------------------------------*/
Load()132 void	SvtAppFilterOptions_Impl::Load()
133 {
134 	Sequence<OUString> aNames(2);
135 	OUString* pNames = aNames.getArray();
136 	pNames[0] = C2U("Load");
137 	pNames[1] = C2U("Save");
138 
139 	Sequence<Any> aValues = GetProperties(aNames);
140 	const Any* pValues = aValues.getConstArray();
141 
142 	if(pValues[0].hasValue())
143 		bLoadVBA = *(sal_Bool*)pValues[0].getValue();
144 	if(pValues[1].hasValue())
145 		bSaveVBA = *(sal_Bool*)pValues[1].getValue();
146 }
147 
148 // -----------------------------------------------------------------------
149 class SvtCalcFilterOptions_Impl : public SvtAppFilterOptions_Impl
150 {
151 	sal_Bool				bLoadExecutable;
152 public:
SvtCalcFilterOptions_Impl(const OUString & rRoot)153 	SvtCalcFilterOptions_Impl(const OUString& rRoot) :
154 		SvtAppFilterOptions_Impl(rRoot),
155 		bLoadExecutable(sal_False)
156 	{}
157 	virtual void			Commit();
158 	void					Load();
159 
IsLoadExecutable() const160 	sal_Bool				IsLoadExecutable() const {return bLoadExecutable;}
SetLoadExecutable(sal_Bool bSet)161 	void					SetLoadExecutable(sal_Bool bSet)
162 							{
163 								if(bSet != bLoadExecutable)
164 									SetModified();
165 								bLoadExecutable = bSet;
166 							}
167 };
168 
Commit()169 void SvtCalcFilterOptions_Impl::Commit()
170 {
171 	SvtAppFilterOptions_Impl::Commit();
172 
173 	Sequence<OUString> aNames(1);
174 	aNames[0] = C2U("Executable");
175 	Sequence<Any> aValues(1);
176 	aValues[0] <<= bLoadExecutable;
177 
178 	PutProperties(aNames, aValues);
179 }
180 
Load()181 void SvtCalcFilterOptions_Impl::Load()
182 {
183 	SvtAppFilterOptions_Impl::Load();
184 
185 	Sequence<OUString> aNames(1);
186 	aNames[0] = C2U("Executable");
187 
188 	Sequence<Any> aValues = GetProperties(aNames);
189 	const Any* pValues = aValues.getConstArray();
190 	if(pValues[0].hasValue())
191 		bLoadExecutable = *(sal_Bool*)pValues[0].getValue();
192 }
193 
194 /* -----------------------------22.01.01 10:32--------------------------------
195 
196  ---------------------------------------------------------------------------*/
197 struct SvtFilterOptions_Impl
198 {
199     sal_uLong nFlags;
200     SvtAppFilterOptions_Impl aWriterCfg;
201     SvtCalcFilterOptions_Impl aCalcCfg;
202     SvtAppFilterOptions_Impl aImpressCfg;
203 
SvtFilterOptions_ImplSvtFilterOptions_Impl204     SvtFilterOptions_Impl() :
205         aWriterCfg(C2U("Office.Writer/Filter/Import/VBA")),
206         aCalcCfg(C2U("Office.Calc/Filter/Import/VBA")),
207         aImpressCfg(C2U("Office.Impress/Filter/Import/VBA"))
208     {
209         nFlags = FILTERCFG_WORD_CODE |
210             FILTERCFG_WORD_STORAGE |
211             FILTERCFG_EXCEL_CODE |
212             FILTERCFG_EXCEL_STORAGE |
213             FILTERCFG_PPOINT_CODE |
214             FILTERCFG_PPOINT_STORAGE |
215             FILTERCFG_MATH_LOAD |
216             FILTERCFG_MATH_SAVE |
217             FILTERCFG_WRITER_LOAD |
218             FILTERCFG_WRITER_SAVE |
219             FILTERCFG_CALC_LOAD |
220             FILTERCFG_CALC_SAVE |
221             FILTERCFG_IMPRESS_LOAD |
222             FILTERCFG_IMPRESS_SAVE |
223             FILTERCFG_USE_ENHANCED_FIELDS;
224         Load();
225     }
226 
227     void SetFlag( sal_uLong nFlag, sal_Bool bSet );
228     sal_Bool IsFlag( sal_uLong nFlag ) const;
LoadSvtFilterOptions_Impl229     void Load()
230     {
231         aWriterCfg.Load();
232         aCalcCfg.Load();
233         aImpressCfg.Load();
234     }
235 };
236 /* -----------------------------22.01.01 10:34--------------------------------
237 
238  ---------------------------------------------------------------------------*/
SetFlag(sal_uLong nFlag,sal_Bool bSet)239 void SvtFilterOptions_Impl::SetFlag( sal_uLong nFlag, sal_Bool bSet )
240 {
241 	switch(nFlag)
242 	{
243 		case FILTERCFG_WORD_CODE:		aWriterCfg.SetLoad(bSet);break;
244 		case FILTERCFG_WORD_STORAGE:	aWriterCfg.SetSave(bSet);break;
245 		case FILTERCFG_EXCEL_CODE:		aCalcCfg.SetLoad(bSet);break;
246 		case FILTERCFG_EXCEL_STORAGE:	aCalcCfg.SetSave(bSet);break;
247 		case FILTERCFG_EXCEL_EXECTBL:	aCalcCfg.SetLoadExecutable(bSet);break;
248 		case FILTERCFG_PPOINT_CODE:		aImpressCfg.SetLoad(bSet);break;
249 		case FILTERCFG_PPOINT_STORAGE:	aImpressCfg.SetSave(bSet);break;
250 		default:
251 			if( bSet )
252 				nFlags |= nFlag;
253 			else
254 				nFlags &= ~nFlag;
255 	}
256 }
257 /* -----------------------------22.01.01 10:35--------------------------------
258 
259  ---------------------------------------------------------------------------*/
IsFlag(sal_uLong nFlag) const260 sal_Bool SvtFilterOptions_Impl::IsFlag( sal_uLong nFlag ) const
261 {
262 	sal_Bool bRet;
263 	switch(nFlag)
264 	{
265 		case FILTERCFG_WORD_CODE 		: bRet = aWriterCfg.IsLoad();break;
266 		case FILTERCFG_WORD_STORAGE   	: bRet = aWriterCfg.IsSave();break;
267 		case FILTERCFG_EXCEL_CODE 	    : bRet = aCalcCfg.IsLoad();break;
268 		case FILTERCFG_EXCEL_STORAGE    : bRet = aCalcCfg.IsSave();break;
269 		case FILTERCFG_EXCEL_EXECTBL	: bRet = aCalcCfg.IsLoadExecutable();break;
270 		case FILTERCFG_PPOINT_CODE 	 	: bRet = aImpressCfg.IsLoad();break;
271 		case FILTERCFG_PPOINT_STORAGE	: bRet = aImpressCfg.IsSave();break;
272 		default:
273 			bRet = 0 != (nFlags & nFlag );
274 	}
275 	return bRet;
276 }
277 
278 // -----------------------------------------------------------------------
279 
SvtFilterOptions()280 SvtFilterOptions::SvtFilterOptions() :
281 	ConfigItem( C2U("Office.Common/Filter/Microsoft") ),
282 	pImp(new SvtFilterOptions_Impl)
283 {
284     RTL_LOGFILE_CONTEXT(aLog, "unotools SvtFilterOptions::SvtFilterOptions()");
285 	EnableNotification(GetPropertyNames());
286 	Load();
287 }
288 // -----------------------------------------------------------------------
~SvtFilterOptions()289 SvtFilterOptions::~SvtFilterOptions()
290 {
291 	delete pImp;
292 }
293 /* -----------------------------22.01.01 08:45--------------------------------
294 
295  ---------------------------------------------------------------------------*/
GetPropertyNames()296 const Sequence<OUString>& SvtFilterOptions::GetPropertyNames()
297 {
298 	static Sequence<OUString> aNames;
299 	if(!aNames.getLength())
300 	{
301 		int nCount = 12;
302 		aNames.realloc(nCount);
303 		static const char* aPropNames[] =
304 		{
305 			"Import/MathTypeToMath",			//  0
306 			"Import/WinWordToWriter",			//  1
307 			"Import/PowerPointToImpress",		//  2
308 			"Import/ExcelToCalc",				//  3
309 			"Export/MathToMathType",            //  4
310 			"Export/WriterToWinWord",           //  5
311 			"Export/ImpressToPowerPoint",       //  6
312 			"Export/CalcToExcel",            	//  7
313 			"Export/EnablePowerPointPreview",	//	8
314 			"Export/EnableExcelPreview",		//	9
315 			"Export/EnableWordPreview",			// 10
316 			"Import/ImportWWFieldsAsEnhancedFields" // 11
317 		};
318 		OUString* pNames = aNames.getArray();
319 		for(int i = 0; i < nCount; i++)
320 			pNames[i] = C2U(aPropNames[i]);
321 	}
322 	return aNames;
323 }
324 //-----------------------------------------------------------------------
lcl_GetFlag(sal_Int32 nProp)325 static sal_uLong lcl_GetFlag(sal_Int32 nProp)
326 {
327 	sal_uLong nFlag = 0;
328 	switch(nProp)
329 	{
330 		case  0: nFlag = FILTERCFG_MATH_LOAD; break;
331 		case  1: nFlag = FILTERCFG_WRITER_LOAD; break;
332 		case  2: nFlag = FILTERCFG_IMPRESS_LOAD; break;
333 		case  3: nFlag = FILTERCFG_CALC_LOAD; break;
334 		case  4: nFlag = FILTERCFG_MATH_SAVE; break;
335 		case  5: nFlag = FILTERCFG_WRITER_SAVE; break;
336 		case  6: nFlag = FILTERCFG_IMPRESS_SAVE; break;
337 		case  7: nFlag = FILTERCFG_CALC_SAVE; break;
338 		case  8: nFlag = FILTERCFG_ENABLE_PPT_PREVIEW; break;
339 		case  9: nFlag = FILTERCFG_ENABLE_EXCEL_PREVIEW; break;
340 		case 10: nFlag = FILTERCFG_ENABLE_WORD_PREVIEW; break;
341 		case 11: nFlag = FILTERCFG_USE_ENHANCED_FIELDS; break;
342 
343 		default: DBG_ERROR("illegal value");
344 	}
345 	return nFlag;
346 }
347 /*-- 22.01.01 08:53:03---------------------------------------------------
348 
349   -----------------------------------------------------------------------*/
Notify(const Sequence<OUString> &)350 void SvtFilterOptions::Notify( const Sequence<OUString>& )
351 {
352 	Load();
353 }
354 /*-- 22.01.01 08:53:04---------------------------------------------------
355 
356   -----------------------------------------------------------------------*/
Commit()357 void SvtFilterOptions::Commit()
358 {
359 	const Sequence<OUString>& aNames = GetPropertyNames();
360 	Sequence<Any> aValues(aNames.getLength());
361 	Any* pValues = aValues.getArray();
362 
363 	const Type& rType = ::getBooleanCppuType();
364 	for(int nProp = 0; nProp < aNames.getLength(); nProp++)
365 	{
366 		sal_uLong nFlag = lcl_GetFlag(nProp);
367 		sal_Bool bVal = pImp->IsFlag( nFlag);
368 		pValues[nProp].setValue(&bVal, rType);
369 
370 	}
371 	PutProperties(aNames, aValues);
372 }
373 /*-- 22.01.01 08:53:04---------------------------------------------------
374 
375   -----------------------------------------------------------------------*/
Load()376 void SvtFilterOptions::Load()
377 {
378 	pImp->Load();
379 	const Sequence<OUString>& rNames = GetPropertyNames();
380 	Sequence<Any> aValues = GetProperties(rNames);
381 	const Any* pValues = aValues.getConstArray();
382 	DBG_ASSERT(aValues.getLength() == rNames.getLength(), "GetProperties failed");
383 	if(aValues.getLength() == rNames.getLength())
384 	{
385 		for(int nProp = 0; nProp < rNames.getLength(); nProp++)
386 		{
387 			if(pValues[nProp].hasValue())
388 			{
389 				sal_Bool bVal = *(sal_Bool*)pValues[nProp].getValue();
390 				sal_uLong nFlag = lcl_GetFlag(nProp);
391 				pImp->SetFlag( nFlag, bVal);
392 			}
393 		}
394 	}
395 }
396 // -----------------------------------------------------------------------
397 
SetLoadWordBasicCode(sal_Bool bFlag)398 void SvtFilterOptions::SetLoadWordBasicCode( sal_Bool bFlag )
399 {
400 	pImp->SetFlag( FILTERCFG_WORD_CODE, bFlag );
401 	SetModified();
402 }
403 
IsLoadWordBasicCode() const404 sal_Bool SvtFilterOptions::IsLoadWordBasicCode() const
405 {
406 	return pImp->IsFlag( FILTERCFG_WORD_CODE );
407 }
408 
SetLoadWordBasicStorage(sal_Bool bFlag)409 void SvtFilterOptions::SetLoadWordBasicStorage( sal_Bool bFlag )
410 {
411 	pImp->SetFlag( FILTERCFG_WORD_STORAGE, bFlag );
412 	SetModified();
413 }
414 
IsLoadWordBasicStorage() const415 sal_Bool SvtFilterOptions::IsLoadWordBasicStorage() const
416 {
417 	return pImp->IsFlag( FILTERCFG_WORD_STORAGE );
418 }
419 
420 // -----------------------------------------------------------------------
421 
SetLoadExcelBasicCode(sal_Bool bFlag)422 void SvtFilterOptions::SetLoadExcelBasicCode( sal_Bool bFlag )
423 {
424 	pImp->SetFlag( FILTERCFG_EXCEL_CODE, bFlag );
425 	SetModified();
426 }
427 
IsLoadExcelBasicCode() const428 sal_Bool SvtFilterOptions::IsLoadExcelBasicCode() const
429 {
430 	return pImp->IsFlag( FILTERCFG_EXCEL_CODE );
431 }
432 
SetLoadExcelBasicExecutable(sal_Bool bFlag)433 void SvtFilterOptions::SetLoadExcelBasicExecutable( sal_Bool bFlag )
434 {
435 	pImp->SetFlag( FILTERCFG_EXCEL_EXECTBL, bFlag );
436 	SetModified();
437 }
438 
IsLoadExcelBasicExecutable() const439 sal_Bool SvtFilterOptions::IsLoadExcelBasicExecutable() const
440 {
441 	return pImp->IsFlag( FILTERCFG_EXCEL_EXECTBL );
442 }
443 
SetLoadExcelBasicStorage(sal_Bool bFlag)444 void SvtFilterOptions::SetLoadExcelBasicStorage( sal_Bool bFlag )
445 {
446 	pImp->SetFlag( FILTERCFG_EXCEL_STORAGE, bFlag );
447 	SetModified();
448 }
449 
IsLoadExcelBasicStorage() const450 sal_Bool SvtFilterOptions::IsLoadExcelBasicStorage() const
451 {
452 	return pImp->IsFlag( FILTERCFG_EXCEL_STORAGE );
453 }
454 
455 // -----------------------------------------------------------------------
456 
SetLoadPPointBasicCode(sal_Bool bFlag)457 void SvtFilterOptions::SetLoadPPointBasicCode( sal_Bool bFlag )
458 {
459 	pImp->SetFlag( FILTERCFG_PPOINT_CODE, bFlag );
460 	SetModified();
461 }
462 
IsLoadPPointBasicCode() const463 sal_Bool SvtFilterOptions::IsLoadPPointBasicCode() const
464 {
465 	return pImp->IsFlag( FILTERCFG_PPOINT_CODE );
466 }
467 
SetLoadPPointBasicStorage(sal_Bool bFlag)468 void SvtFilterOptions::SetLoadPPointBasicStorage( sal_Bool bFlag )
469 {
470 	pImp->SetFlag( FILTERCFG_PPOINT_STORAGE, bFlag );
471 	SetModified();
472 }
473 
IsLoadPPointBasicStorage() const474 sal_Bool SvtFilterOptions::IsLoadPPointBasicStorage() const
475 {
476 	return pImp->IsFlag( FILTERCFG_PPOINT_STORAGE );
477 }
478 
479 // -----------------------------------------------------------------------
480 
IsMathType2Math() const481 sal_Bool SvtFilterOptions::IsMathType2Math() const
482 {
483 	return pImp->IsFlag( FILTERCFG_MATH_LOAD );
484 }
485 
SetMathType2Math(sal_Bool bFlag)486 void SvtFilterOptions::SetMathType2Math( sal_Bool bFlag )
487 {
488 	pImp->SetFlag( FILTERCFG_MATH_LOAD, bFlag );
489 	SetModified();
490 }
491 
IsMath2MathType() const492 sal_Bool SvtFilterOptions::IsMath2MathType() const
493 {
494 	return pImp->IsFlag( FILTERCFG_MATH_SAVE );
495 }
496 
SetMath2MathType(sal_Bool bFlag)497 void SvtFilterOptions::SetMath2MathType( sal_Bool bFlag )
498 {
499 	pImp->SetFlag( FILTERCFG_MATH_SAVE, bFlag );
500 	SetModified();
501 }
502 
503 
504 // -----------------------------------------------------------------------
IsWinWord2Writer() const505 sal_Bool SvtFilterOptions::IsWinWord2Writer() const
506 {
507 	return pImp->IsFlag( FILTERCFG_WRITER_LOAD );
508 }
509 
SetWinWord2Writer(sal_Bool bFlag)510 void SvtFilterOptions::SetWinWord2Writer( sal_Bool bFlag )
511 {
512 	pImp->SetFlag( FILTERCFG_WRITER_LOAD, bFlag );
513 	SetModified();
514 }
515 
IsWriter2WinWord() const516 sal_Bool SvtFilterOptions::IsWriter2WinWord() const
517 {
518 	return pImp->IsFlag( FILTERCFG_WRITER_SAVE );
519 }
520 
SetWriter2WinWord(sal_Bool bFlag)521 void SvtFilterOptions::SetWriter2WinWord( sal_Bool bFlag )
522 {
523 	pImp->SetFlag( FILTERCFG_WRITER_SAVE, bFlag );
524 	SetModified();
525 }
526 
IsUseEnhancedFields() const527 sal_Bool SvtFilterOptions::IsUseEnhancedFields() const
528 {
529     return false; // disable for now;
530 //    return pImp->IsFlag( FILTERCFG_USE_ENHANCED_FIELDS );
531 }
532 
SetUseEnhancedFields(sal_Bool bFlag)533 void SvtFilterOptions::SetUseEnhancedFields( sal_Bool bFlag )
534 {
535 	pImp->SetFlag( FILTERCFG_USE_ENHANCED_FIELDS, bFlag );
536 	SetModified();
537 }
538 
539 // -----------------------------------------------------------------------
IsExcel2Calc() const540 sal_Bool SvtFilterOptions::IsExcel2Calc() const
541 {
542 	return pImp->IsFlag( FILTERCFG_CALC_LOAD );
543 }
544 
SetExcel2Calc(sal_Bool bFlag)545 void SvtFilterOptions::SetExcel2Calc( sal_Bool bFlag )
546 {
547 	pImp->SetFlag( FILTERCFG_CALC_LOAD, bFlag );
548 	SetModified();
549 }
550 
IsCalc2Excel() const551 sal_Bool SvtFilterOptions::IsCalc2Excel() const
552 {
553 	return pImp->IsFlag( FILTERCFG_CALC_SAVE );
554 }
555 
SetCalc2Excel(sal_Bool bFlag)556 void SvtFilterOptions::SetCalc2Excel( sal_Bool bFlag )
557 {
558 	pImp->SetFlag( FILTERCFG_CALC_SAVE, bFlag );
559 	SetModified();
560 }
561 
562 
563 // -----------------------------------------------------------------------
IsPowerPoint2Impress() const564 sal_Bool SvtFilterOptions::IsPowerPoint2Impress() const
565 {
566 	return pImp->IsFlag( FILTERCFG_IMPRESS_LOAD );
567 }
568 
SetPowerPoint2Impress(sal_Bool bFlag)569 void SvtFilterOptions::SetPowerPoint2Impress( sal_Bool bFlag )
570 {
571 	pImp->SetFlag( FILTERCFG_IMPRESS_LOAD, bFlag );
572 	SetModified();
573 }
574 
IsImpress2PowerPoint() const575 sal_Bool SvtFilterOptions::IsImpress2PowerPoint() const
576 {
577 	return pImp->IsFlag( FILTERCFG_IMPRESS_SAVE );
578 }
579 
SetImpress2PowerPoint(sal_Bool bFlag)580 void SvtFilterOptions::SetImpress2PowerPoint( sal_Bool bFlag )
581 {
582 	pImp->SetFlag( FILTERCFG_IMPRESS_SAVE, bFlag );
583 	SetModified();
584 }
585 
Get()586 SvtFilterOptions* SvtFilterOptions::Get()
587 {
588 	if ( !pOptions )
589 		pOptions = new SvtFilterOptions;
590 	return pOptions;
591 }
592 
593 // -----------------------------------------------------------------------
594 
IsEnablePPTPreview() const595 sal_Bool SvtFilterOptions::IsEnablePPTPreview() const
596 {
597 	return pImp->IsFlag( FILTERCFG_ENABLE_PPT_PREVIEW );
598 }
599 
600 
IsEnableCalcPreview() const601 sal_Bool SvtFilterOptions::IsEnableCalcPreview() const
602 {
603 	return pImp->IsFlag( FILTERCFG_ENABLE_EXCEL_PREVIEW );
604 }
605 
606 
IsEnableWordPreview() const607 sal_Bool SvtFilterOptions::IsEnableWordPreview() const
608 {
609 	return pImp->IsFlag( FILTERCFG_ENABLE_WORD_PREVIEW );
610 }
611 
612 
613