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