xref: /trunk/main/xmloff/source/style/xmlbahdl.cxx (revision 1ecadb572e7010ff3b3382ad9bf179dbc6efadbb) 
1 /*************************************************************************
2  *
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * Copyright 2000, 2010 Oracle and/or its affiliates.
6  *
7  * OpenOffice.org - a multi-platform office productivity suite
8  *
9  * This file is part of OpenOffice.org.
10  *
11  * OpenOffice.org is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU Lesser General Public License version 3
13  * only, as published by the Free Software Foundation.
14  *
15  * OpenOffice.org is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU Lesser General Public License version 3 for more details
19  * (a copy is included in the LICENSE file that accompanied this code).
20  *
21  * You should have received a copy of the GNU Lesser General Public License
22  * version 3 along with OpenOffice.org.  If not, see
23  * <http://www.openoffice.org/license.html>
24  * for a copy of the LGPLv3 License.
25  *
26  ************************************************************************/
27 
28 // MARKER(update_precomp.py): autogen include statement, do not remove
29 #include "precompiled_xmloff.hxx"
30 #include <tools/debug.hxx>
31 #include <xmlbahdl.hxx>
32 #include <xmloff/xmluconv.hxx>
33 #include <com/sun/star/uno/Any.hxx>
34 #include <xmloff/xmltoken.hxx>
35 
36 using ::rtl::OUString;
37 using ::rtl::OUStringBuffer;
38 
39 using namespace ::com::sun::star::uno;
40 using namespace ::xmloff::token;
41 
42 void lcl_xmloff_setAny( Any& rValue, sal_Int32 nValue, sal_Int8 nBytes )
43 {
44     switch( nBytes )
45     {
46     case 1:
47         if( nValue < SCHAR_MIN )
48             nValue = SCHAR_MIN;
49         else if( nValue > SCHAR_MAX )
50             nValue = SCHAR_MAX;
51         rValue <<= (sal_Int8)nValue;
52         break;
53     case 2:
54         if( nValue < SHRT_MIN )
55             nValue = SHRT_MIN;
56         else if( nValue > SHRT_MAX )
57             nValue = SHRT_MAX;
58         rValue <<= (sal_Int16)nValue;
59         break;
60     case 4:
61         rValue <<= nValue;
62         break;
63     }
64 }
65 
66 sal_Bool lcl_xmloff_getAny( const Any& rValue, sal_Int32& nValue,
67                             sal_Int8 nBytes )
68 {
69     sal_Bool bRet = sal_False;
70 
71     switch( nBytes )
72     {
73     case 1:
74         {
75             sal_Int8 nValue8 = 0;
76             bRet = rValue >>= nValue8;
77             nValue = nValue8;
78         }
79         break;
80     case 2:
81         {
82             sal_Int16 nValue16 = 0;
83             bRet = rValue >>= nValue16;
84             nValue = nValue16;
85         }
86         break;
87     case 4:
88         bRet = rValue >>= nValue;
89         break;
90     }
91 
92     return bRet;
93 }
94 
95 ///////////////////////////////////////////////////////////////////////////////
96 //
97 // class XMLNumberPropHdl
98 //
99 
100 XMLNumberPropHdl::~XMLNumberPropHdl()
101 {
102     // nothing to do
103 }
104 
105 sal_Bool XMLNumberPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
106 {
107     sal_Bool bRet = sal_False;
108 
109     sal_Int32 nValue = 0;
110     bRet = SvXMLUnitConverter::convertNumber( nValue, rStrImpValue );
111     lcl_xmloff_setAny( rValue, nValue, nBytes );
112 
113     return bRet;
114 }
115 
116 sal_Bool XMLNumberPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
117 {
118     sal_Bool bRet = sal_False;
119     sal_Int32 nValue;
120     OUStringBuffer aOut;
121 
122     if( lcl_xmloff_getAny( rValue, nValue, nBytes ) )
123     {
124         SvXMLUnitConverter::convertNumber( aOut, nValue );
125         rStrExpValue = aOut.makeStringAndClear();
126 
127         bRet = sal_True;
128     }
129 
130     return bRet;
131 }
132 
133 ///////////////////////////////////////////////////////////////////////////////
134 // class XMLNumberNonePropHdl
135 //
136 
137 XMLNumberNonePropHdl::XMLNumberNonePropHdl( sal_Int8 nB ) :
138     sZeroStr( GetXMLToken(XML_NO_LIMIT) ),
139     nBytes( nB )
140 {
141 }
142 
143 XMLNumberNonePropHdl::XMLNumberNonePropHdl( enum XMLTokenEnum eZeroString, sal_Int8 nB ) :
144     sZeroStr( GetXMLToken( eZeroString ) ),
145     nBytes( nB )
146 {
147 }
148 
149 XMLNumberNonePropHdl::~XMLNumberNonePropHdl()
150 {
151     // nothing to do
152 }
153 
154 sal_Bool XMLNumberNonePropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
155 {
156     sal_Bool bRet = sal_False;
157 
158     sal_Int32 nValue = 0;
159     if( rStrImpValue == sZeroStr )
160     {
161         bRet = sal_True;
162     }
163     else
164     {
165         bRet = SvXMLUnitConverter::convertNumber( nValue, rStrImpValue );
166     }
167     lcl_xmloff_setAny( rValue, nValue, nBytes );
168 
169     return bRet;
170 }
171 
172 sal_Bool XMLNumberNonePropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
173 {
174     sal_Bool bRet = sal_False;
175     sal_Int32 nValue;
176 
177     if( lcl_xmloff_getAny( rValue, nValue, nBytes ) )
178     {
179         OUStringBuffer aOut;
180 
181         if( nValue == 0 )
182         {
183             aOut.append( sZeroStr );
184         }
185         else
186         {
187             SvXMLUnitConverter::convertNumber( aOut, nValue );
188         }
189 
190         rStrExpValue = aOut.makeStringAndClear();
191 
192         bRet = sal_True;
193     }
194 
195     return bRet;
196 }
197 
198 ///////////////////////////////////////////////////////////////////////////////
199 //
200 // class XMLMeasurePropHdl
201 //
202 
203 XMLMeasurePropHdl::~XMLMeasurePropHdl()
204 {
205     // nothing to do
206 }
207 
208 sal_Bool XMLMeasurePropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
209 {
210     sal_Bool bRet = sal_False;
211 
212     sal_Int32 nValue = 0;
213     bRet = rUnitConverter.convertMeasure( nValue, rStrImpValue );
214     lcl_xmloff_setAny( rValue, nValue, nBytes );
215 
216     return bRet;
217 }
218 
219 sal_Bool XMLMeasurePropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
220 {
221     sal_Bool bRet = sal_False;
222     sal_Int32 nValue;
223     OUStringBuffer aOut;
224 
225     if( lcl_xmloff_getAny( rValue, nValue, nBytes ) )
226     {
227         rUnitConverter.convertMeasure( aOut, nValue );
228         rStrExpValue = aOut.makeStringAndClear();
229 
230         bRet = sal_True;
231     }
232 
233     return bRet;
234 }
235 
236 ///////////////////////////////////////////////////////////////////////////////
237 //
238 // class XMLBoolPropHdl
239 //
240 
241 XMLBoolPropHdl::~XMLBoolPropHdl()
242 {
243     // nothing to do
244 }
245 
246 sal_Bool XMLBoolPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
247 {
248     sal_Bool bRet = sal_False;
249 
250     sal_Bool bValue;
251     bRet = SvXMLUnitConverter::convertBool( bValue, rStrImpValue );
252     rValue <<= sal_Bool(bValue);
253 
254     return bRet;
255 }
256 
257 sal_Bool XMLBoolPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
258 {
259     sal_Bool bRet = sal_False;
260     OUStringBuffer aOut;
261     sal_Bool bValue = sal_Bool();
262 
263     if (rValue >>= bValue)
264     {
265         SvXMLUnitConverter::convertBool( aOut, bValue );
266         rStrExpValue = aOut.makeStringAndClear();
267 
268         bRet = sal_True;
269     }
270 
271     return bRet;
272 }
273 
274 ///////////////////////////////////////////////////////////////////////////////
275 //
276 // class XMLNBoolPropHdl
277 //
278 
279 XMLNBoolPropHdl::~XMLNBoolPropHdl()
280 {
281     // nothing to do
282 }
283 
284 sal_Bool XMLNBoolPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
285 {
286     sal_Bool bRet = sal_False;
287 
288     sal_Bool bValue;
289     bRet = SvXMLUnitConverter::convertBool( bValue, rStrImpValue );
290     rValue <<= sal_Bool(!bValue);
291 
292     return bRet;
293 }
294 
295 sal_Bool XMLNBoolPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
296 {
297     sal_Bool bRet = sal_False;
298     OUStringBuffer aOut;
299     sal_Bool bValue = sal_Bool();
300 
301     if (rValue >>= bValue)
302     {
303         SvXMLUnitConverter::convertBool( aOut, !bValue );
304         rStrExpValue = aOut.makeStringAndClear();
305 
306         bRet = sal_True;
307     }
308 
309     return bRet;
310 }
311 
312 ///////////////////////////////////////////////////////////////////////////////
313 //
314 // class XMLPercentPropHdl
315 //
316 
317 XMLPercentPropHdl::~XMLPercentPropHdl()
318 {
319     // nothing to do
320 }
321 
322 sal_Bool XMLPercentPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
323 {
324     sal_Bool bRet = sal_False;
325 
326     sal_Int32 nValue = 0;
327     bRet = SvXMLUnitConverter::convertPercent( nValue, rStrImpValue );
328     lcl_xmloff_setAny( rValue, nValue, nBytes );
329 
330     return bRet;
331 }
332 
333 sal_Bool XMLPercentPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
334 {
335     sal_Bool bRet = sal_False;
336     sal_Int32 nValue;
337     OUStringBuffer aOut;
338 
339     if( lcl_xmloff_getAny( rValue, nValue, nBytes ) )
340     {
341         SvXMLUnitConverter::convertPercent( aOut, nValue );
342         rStrExpValue = aOut.makeStringAndClear();
343 
344         bRet = sal_True;
345     }
346 
347     return bRet;
348 }
349 
350 ///////////////////////////////////////////////////////////////////////////////
351 //
352 // class XMLDoublePercentPropHdl
353 //
354 
355 sal_Bool XMLDoublePercentPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
356 {
357     sal_Bool bRet = sal_False;
358 
359     double fValue = 1.0;
360 
361     if( rStrImpValue.indexOf( (sal_Unicode)'%' ) == -1 )
362     {
363         fValue = rStrImpValue.toDouble();
364     }
365     else
366     {
367         sal_Int32 nValue = 0;
368         bRet = SvXMLUnitConverter::convertPercent( nValue, rStrImpValue );
369         fValue = ((double)nValue) / 100.0;
370     }
371     rValue <<= fValue;
372 
373     return bRet;
374 }
375 
376 sal_Bool XMLDoublePercentPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
377 {
378     sal_Bool bRet = sal_False;
379     double fValue = 0;
380 
381     if( rValue >>= fValue )
382     {
383         fValue *= 100.0;
384         if( fValue > 0 ) fValue += 0.5; else    fValue -= 0.5;
385 
386         sal_Int32 nValue = (sal_Int32)fValue;
387 
388         OUStringBuffer aOut;
389         SvXMLUnitConverter::convertPercent( aOut, nValue );
390         rStrExpValue = aOut.makeStringAndClear();
391 
392         bRet = sal_True;
393     }
394 
395     return bRet;
396 }
397 
398 
399 ///////////////////////////////////////////////////////////////////////////////
400 //
401 // class XMLNegPercentPropHdl
402 //
403 
404 XMLNegPercentPropHdl::~XMLNegPercentPropHdl()
405 {
406     // nothing to do
407 }
408 
409 sal_Bool XMLNegPercentPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
410 {
411     sal_Bool bRet = sal_False;
412 
413     sal_Int32 nValue = 0;
414     bRet = SvXMLUnitConverter::convertPercent( nValue, rStrImpValue );
415     lcl_xmloff_setAny( rValue, 100-nValue, nBytes );
416 
417     return bRet;
418 }
419 
420 sal_Bool XMLNegPercentPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
421 {
422     sal_Bool bRet = sal_False;
423     sal_Int32 nValue;
424     OUStringBuffer aOut;
425 
426     if( lcl_xmloff_getAny( rValue, nValue, nBytes ) )
427     {
428         SvXMLUnitConverter::convertPercent( aOut, 100-nValue );
429         rStrExpValue = aOut.makeStringAndClear();
430 
431         bRet = sal_True;
432     }
433 
434     return bRet;
435 }
436 
437 
438 ///////////////////////////////////////////////////////////////////////////////
439 //
440 // class XMLMeasurePxPropHdl
441 //
442 
443 XMLMeasurePxPropHdl::~XMLMeasurePxPropHdl()
444 {
445     // nothing to do
446 }
447 
448 sal_Bool XMLMeasurePxPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
449 {
450     sal_Bool bRet = sal_False;
451 
452     sal_Int32 nValue = 0;
453     bRet = SvXMLUnitConverter::convertMeasurePx( nValue, rStrImpValue );
454     lcl_xmloff_setAny( rValue, nValue, nBytes );
455 
456     return bRet;
457 }
458 
459 sal_Bool XMLMeasurePxPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
460 {
461     sal_Bool bRet = sal_False;
462     sal_Int32 nValue;
463     OUStringBuffer aOut;
464 
465     if( lcl_xmloff_getAny( rValue, nValue, nBytes ) )
466     {
467         SvXMLUnitConverter::convertMeasurePx( aOut, nValue );
468         rStrExpValue = aOut.makeStringAndClear();
469 
470         bRet = sal_True;
471     }
472 
473     return bRet;
474 }
475 
476 ///////////////////////////////////////////////////////////////////////////////
477 //
478 // class XMLColorPropHdl
479 //
480 
481 XMLColorPropHdl::~XMLColorPropHdl()
482 {
483     // Nothing to do
484 }
485 
486 sal_Bool XMLColorPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
487 {
488     sal_Bool bRet = sal_False;
489     Color aColor;
490 
491     const OUString astrHSL( RTL_CONSTASCII_USTRINGPARAM( "hsl" ) );
492     if( rStrImpValue.matchIgnoreAsciiCase( astrHSL ) )
493     {
494         sal_Int32 nOpen = rStrImpValue.indexOf( '(' );
495         sal_Int32 nClose = rStrImpValue.lastIndexOf( ')' );
496 
497         if( (nOpen != -1) && (nClose > nOpen) )
498         {
499             const OUString aTmp( rStrImpValue.copy( nOpen+1, nClose - nOpen-1) );
500 
501             sal_Int32 nIndex = 0;
502 
503             Sequence< double > aHSL(3);
504             aHSL[0] = aTmp.getToken( 0, ',', nIndex ).toDouble();
505             aHSL[1] = aTmp.getToken( 0, ',', nIndex ).toDouble() / 100.0;
506             aHSL[2] = aTmp.getToken( 0, ',', nIndex ).toDouble() / 100.0;
507             rValue <<= aHSL;
508             bRet = true;
509         }
510     }
511     else
512     {
513         bRet = SvXMLUnitConverter::convertColor( aColor, rStrImpValue );
514         rValue <<= (sal_Int32)( aColor.GetColor() );
515     }
516 
517     return bRet;
518 }
519 
520 sal_Bool XMLColorPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
521 {
522     sal_Bool bRet = sal_False;
523     Color aColor;
524     sal_Int32 nColor = 0;
525 
526     OUStringBuffer aOut;
527     if( rValue >>= nColor )
528     {
529         aColor.SetColor( nColor );
530 
531         SvXMLUnitConverter::convertColor( aOut, aColor );
532         rStrExpValue = aOut.makeStringAndClear();
533 
534         bRet = sal_True;
535     }
536     else
537     {
538         Sequence< double > aHSL;
539         if( (rValue >>= aHSL) && (aHSL.getLength() == 3) )
540         {
541             aOut.append( OUString::createFromAscii("hsl(") );
542             aOut.append( aHSL[0] );
543             aOut.append( OUString::createFromAscii(",") );
544             aOut.append( aHSL[1] * 100.0 );
545             aOut.append( OUString::createFromAscii("%,") );
546             aOut.append( aHSL[2] * 100.0 );
547             aOut.append( OUString::createFromAscii("%)") );
548             rStrExpValue = aOut.makeStringAndClear();
549 
550             bRet = sal_True;
551         }
552     }
553 
554     return bRet;
555 }
556 
557 ///////////////////////////////////////////////////////////////////////////////
558 //
559 // class XMLStringPropHdl
560 //
561 
562 XMLStringPropHdl::~XMLStringPropHdl()
563 {
564     // Nothing to do
565 }
566 
567 sal_Bool XMLStringPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
568 {
569     sal_Bool bRet = sal_False;
570 
571     rValue <<= rStrImpValue;
572     bRet = sal_True;
573 
574     return bRet;
575 }
576 
577 sal_Bool XMLStringPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
578 {
579     sal_Bool bRet = sal_False;
580 
581     if( rValue >>= rStrExpValue )
582         bRet = sal_True;
583 
584     return bRet;
585 }
586 
587 ///////////////////////////////////////////////////////////////////////////////
588 //
589 // class XMLStyleNamePropHdl
590 //
591 
592 XMLStyleNamePropHdl::~XMLStyleNamePropHdl()
593 {
594     // Nothing to do
595 }
596 
597 sal_Bool XMLStyleNamePropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
598 {
599     sal_Bool bRet = sal_False;
600 
601     if( rValue >>= rStrExpValue )
602     {
603         rStrExpValue = rUnitConverter.encodeStyleName( rStrExpValue );
604         bRet = sal_True;
605     }
606 
607     return bRet;
608 }
609 
610 
611 ///////////////////////////////////////////////////////////////////////////////
612 //
613 // class XMLDoublePropHdl
614 //
615 
616 XMLDoublePropHdl::~XMLDoublePropHdl()
617 {
618     // Nothing to do
619 }
620 
621 sal_Bool XMLDoublePropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
622 {
623     double fDblValue;
624     sal_Bool bRet = SvXMLUnitConverter::convertDouble( fDblValue, rStrImpValue );
625     rValue <<= fDblValue;
626     return bRet;
627 }
628 
629 sal_Bool XMLDoublePropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
630 {
631     sal_Bool bRet = sal_False;
632 
633     double fValue = 0;
634 
635     if( rValue >>= fValue )
636     {
637         OUStringBuffer aOut;
638         SvXMLUnitConverter::convertDouble( aOut, fValue );
639         rStrExpValue = aOut.makeStringAndClear();
640         bRet = sal_True;
641     }
642 
643     return bRet;
644 }
645 
646 ///////////////////////////////////////////////////////////////////////////////
647 //
648 // class XMLColorTransparentPropHdl
649 //
650 
651 XMLColorTransparentPropHdl::XMLColorTransparentPropHdl(
652     enum XMLTokenEnum eTransparent ) :
653     sTransparent( GetXMLToken(
654         eTransparent != XML_TOKEN_INVALID ? eTransparent : XML_TRANSPARENT ) )
655 {
656     // Nothing to do
657 }
658 
659 XMLColorTransparentPropHdl::~XMLColorTransparentPropHdl()
660 {
661     // Nothing to do
662 }
663 
664 sal_Bool XMLColorTransparentPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
665 {
666     sal_Bool bRet = sal_False;
667 
668     if( rStrImpValue != sTransparent )
669     {
670         Color aColor;
671         bRet = SvXMLUnitConverter::convertColor( aColor, rStrImpValue );
672         rValue <<= (sal_Int32)( aColor.GetColor() );
673     }
674 
675     return bRet;
676 }
677 
678 sal_Bool XMLColorTransparentPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
679 {
680     sal_Bool bRet = sal_False;
681     sal_Int32 nColor = 0;
682 
683     if( rStrExpValue == sTransparent )
684         bRet = sal_False;
685     else if( rValue >>= nColor )
686     {
687         Color aColor( nColor );
688         OUStringBuffer aOut;
689         SvXMLUnitConverter::convertColor( aOut, aColor );
690         rStrExpValue = aOut.makeStringAndClear();
691 
692         bRet = sal_True;
693     }
694 
695     return bRet;
696 }
697 
698 
699 ///////////////////////////////////////////////////////////////////////////////
700 //
701 // class XMLIsTransparentPropHdl
702 //
703 
704 XMLIsTransparentPropHdl::XMLIsTransparentPropHdl(
705     enum XMLTokenEnum eTransparent, sal_Bool bTransPropVal ) :
706     sTransparent( GetXMLToken(
707         eTransparent != XML_TOKEN_INVALID ? eTransparent : XML_TRANSPARENT ) ),
708     bTransPropValue( bTransPropVal )
709 {
710 }
711 
712 XMLIsTransparentPropHdl::~XMLIsTransparentPropHdl()
713 {
714     // Nothing to do
715 }
716 
717 sal_Bool XMLIsTransparentPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
718 {
719     sal_Bool bValue = ( (rStrImpValue == sTransparent) == bTransPropValue);
720     rValue.setValue( &bValue, ::getBooleanCppuType() );
721 
722     return sal_True;
723 }
724 
725 sal_Bool XMLIsTransparentPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
726 {
727     sal_Bool bRet = sal_False;
728 
729     // MIB: This looks a bit strange, because bTransPropValue == bValue should
730     // do the same, but this only applies if 'true' is represented by the same
731     // 8 bit value in bValue and bTransPropValue. Who will ensure this?
732     sal_Bool bValue = *(sal_Bool *)rValue.getValue();
733     sal_Bool bIsTrans = bTransPropValue ? bValue : !bValue;
734 
735     if( bIsTrans )
736     {
737         rStrExpValue = sTransparent;
738         bRet = sal_True;
739     }
740 
741     return bRet;
742 }
743 
744 ///////////////////////////////////////////////////////////////////////////////
745 //
746 // class XMLColorAutoPropHdl
747 //
748 
749 XMLColorAutoPropHdl::XMLColorAutoPropHdl()
750 {
751     // Nothing to do
752 }
753 
754 XMLColorAutoPropHdl::~XMLColorAutoPropHdl()
755 {
756     // Nothing to do
757 }
758 
759 sal_Bool XMLColorAutoPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
760 {
761     sal_Bool bRet = sal_False;
762 
763     // This is a multi property: the value might be set to AUTO_COLOR
764     // already by the XMLIsAutoColorPropHdl!
765     sal_Int32 nColor = 0;
766     if( !(rValue >>= nColor) || -1 != nColor )
767     {
768         Color aColor;
769         bRet = SvXMLUnitConverter::convertColor( aColor, rStrImpValue );
770         if( bRet )
771             rValue <<= (sal_Int32)( aColor.GetColor() );
772     }
773 
774     return bRet;
775 }
776 
777 sal_Bool XMLColorAutoPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
778 {
779     sal_Bool bRet = sal_False;
780 
781     sal_Int32 nColor = 0;
782     if( (rValue >>= nColor) && -1 != nColor )
783     {
784         Color aColor( nColor );
785         OUStringBuffer aOut;
786         SvXMLUnitConverter::convertColor( aOut, aColor );
787         rStrExpValue = aOut.makeStringAndClear();
788 
789         bRet = sal_True;
790     }
791 
792     return bRet;
793 }
794 
795 ///////////////////////////////////////////////////////////////////////////////
796 //
797 // class XMLIsAutoColorPropHdl
798 //
799 
800 XMLIsAutoColorPropHdl::XMLIsAutoColorPropHdl()
801 {
802 }
803 
804 XMLIsAutoColorPropHdl::~XMLIsAutoColorPropHdl()
805 {
806     // Nothing to do
807 }
808 
809 sal_Bool XMLIsAutoColorPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
810 {
811     sal_Bool bValue;
812 
813     // An auto color overrides any other color set!
814     sal_Bool bRet = SvXMLUnitConverter::convertBool( bValue, rStrImpValue );
815     if( bRet && bValue )
816         rValue <<= (sal_Int32)-1;
817 
818     return sal_True;
819 }
820 
821 sal_Bool XMLIsAutoColorPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
822 {
823     sal_Bool bRet = sal_False;
824     sal_Int32 nColor = 0;
825 
826     if( (rValue >>= nColor) && -1 == nColor )
827     {
828         OUStringBuffer aOut;
829         SvXMLUnitConverter::convertBool( aOut, sal_True );
830         rStrExpValue = aOut.makeStringAndClear();
831 
832         bRet = sal_True;
833     }
834 
835     return bRet;
836 }
837 
838 ///////////////////////////////////////////////////////////////////////////////
839 //
840 // class XMLCompareOnlyPropHdl
841 //
842 
843 XMLCompareOnlyPropHdl::~XMLCompareOnlyPropHdl()
844 {
845     // Nothing to do
846 }
847 
848 sal_Bool XMLCompareOnlyPropHdl::importXML( const OUString&, Any&, const SvXMLUnitConverter& ) const
849 {
850     DBG_ASSERT( !this, "importXML called for compare-only-property" );
851     return sal_False;
852 }
853 
854 sal_Bool XMLCompareOnlyPropHdl::exportXML( OUString&, const Any&, const SvXMLUnitConverter& ) const
855 {
856     DBG_ASSERT( !this, "exportXML called for compare-only-property" );
857     return sal_False;
858 }
859 
860 ///////////////////////////////////////////////////////////////////////////////
861 // class XMLNumberWithoutZeroPropHdl
862 //
863 
864 XMLNumberWithoutZeroPropHdl::XMLNumberWithoutZeroPropHdl( sal_Int8 nB ) :
865     nBytes( nB )
866 {
867 }
868 
869 XMLNumberWithoutZeroPropHdl::~XMLNumberWithoutZeroPropHdl()
870 {
871 }
872 
873 sal_Bool XMLNumberWithoutZeroPropHdl::importXML(
874     const OUString& rStrImpValue,
875     Any& rValue,
876     const SvXMLUnitConverter& ) const
877 {
878     sal_Int32 nValue = 0;
879     sal_Bool bRet = SvXMLUnitConverter::convertNumber( nValue, rStrImpValue );
880     if( bRet )
881         lcl_xmloff_setAny( rValue, nValue, nBytes );
882     return bRet;
883 }
884 
885 sal_Bool XMLNumberWithoutZeroPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
886 {
887 
888     sal_Int32 nValue = 0;
889     sal_Bool bRet = lcl_xmloff_getAny( rValue, nValue, nBytes );
890     bRet &= nValue != 0;
891 
892     if( bRet )
893     {
894         OUStringBuffer aBuffer;
895         SvXMLUnitConverter::convertNumber( aBuffer, nValue );
896         rStrExpValue = aBuffer.makeStringAndClear();
897     }
898 
899     return bRet;
900 }
901 
902 ///////////////////////////////////////////////////////////////////////////////
903 // class XMLNumberWithAutoInsteadZeroPropHdl
904 //
905 
906 XMLNumberWithAutoInsteadZeroPropHdl::~XMLNumberWithAutoInsteadZeroPropHdl()
907 {
908 }
909 
910 sal_Bool XMLNumberWithAutoInsteadZeroPropHdl::importXML(
911     const OUString& rStrImpValue,
912     Any& rValue,
913     const SvXMLUnitConverter& ) const
914 {
915     sal_Int32 nValue = 0;
916     sal_Bool bRet = SvXMLUnitConverter::convertNumber( nValue, rStrImpValue );
917     if( bRet )
918         lcl_xmloff_setAny( rValue, nValue, 2 );
919     else if( rStrImpValue == GetXMLToken( XML_AUTO ) )
920     {
921         rValue <<= (sal_Int16)nValue;
922         bRet = sal_True;
923     }
924     return bRet;
925 }
926 
927 sal_Bool XMLNumberWithAutoInsteadZeroPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
928 {
929 
930     sal_Int32 nValue = 0;
931     lcl_xmloff_getAny( rValue, nValue, 2 );
932 
933     if( 0 == nValue )
934         rStrExpValue = GetXMLToken( XML_AUTO );
935     else
936     {
937         OUStringBuffer aBuffer;
938         SvXMLUnitConverter::convertNumber( aBuffer, nValue );
939         rStrExpValue = aBuffer.makeStringAndClear();
940     }
941 
942     return sal_True;
943 }
944 
945