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