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