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