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