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