xmloff/source/style/xmlbahdl.cxx

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