xmloff/source/style/xmlbahdl.cxx

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