writerfilter/source/ooxml/OOXMLPropertySet.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 "OOXMLPropertySet.hxx"
  21 #include <stdio.h>
  22 #include <iostream>
  23 #include <ooxml/QNameToString.hxx>
  24 #include <com/sun/star/drawing/XShape.hpp>
  25 #include <sax/tools/converter.hxx>
  26 #include <tools/color.hxx>
  27 #include <o3tl/string_view.hxx>
  28 #include <utility>
  29
  30 namespace writerfilter::ooxml
  31 {
  32 using namespace com::sun::star;
  33
  34 OOXMLProperty::OOXMLProperty(Id id, OOXMLValue::Pointer_t pValue,
  35                              OOXMLProperty::Type_t eType)
  36     : mId(id), mpValue(std::move(pValue)), meType(eType)
  37 {
  38 }
  39
  40 OOXMLProperty::~OOXMLProperty()
  41 {
  42 }
  43
  44 sal_uInt32 OOXMLProperty::getId() const
  45 {
  46     return mId;
  47 }
  48
  49 Value::Pointer_t OOXMLProperty::getValue()
  50 {
  51     Value::Pointer_t pResult;
  52
  53     if (mpValue)
  54         pResult = Value::Pointer_t(mpValue->clone());
  55     else
  56         pResult = Value::Pointer_t(new OOXMLValue());
  57
  58     return pResult;
  59 }
  60
  61 writerfilter::Reference<Properties>::Pointer_t OOXMLProperty::getProps()
  62 {
  63     writerfilter::Reference<Properties>::Pointer_t pResult;
  64
  65     if (mpValue)
  66         pResult = mpValue->getProperties();
  67
  68     return pResult;
  69 }
  70
  71 #ifdef DBG_UTIL
  72 std::string OOXMLProperty::getName() const
  73 {
  74     std::string sResult(QNameToString(mId));
  75
  76     if (sResult.length() == 0)
  77         sResult = fastTokenToId(mId);
  78
  79     if (sResult.length() == 0)
  80     {
  81         static char sBuffer[256];
  82
  83         snprintf(sBuffer, sizeof(sBuffer), "%" SAL_PRIxUINT32, mId);
  84         sResult = sBuffer;
  85     }
  86
  87     return sResult;
  88 }
  89 #endif
  90
  91 #ifdef DBG_UTIL
  92 std::string OOXMLProperty::toString() const
  93 {
  94     std::string sResult = "(";
  95
  96     sResult += getName();
  97     sResult += ", ";
  98     if (mpValue)
  99         sResult += mpValue->toString();
 100     else
 101         sResult +="(null)";
 102     sResult +=")";
 103
 104     return sResult;
 105 }
 106 #endif
 107
 108 void OOXMLProperty::resolve(writerfilter::Properties & rProperties)
 109 {
 110     switch (meType)
 111     {
 112     case SPRM:
 113         if (mId != 0x0)
 114             rProperties.sprm(*this);
 115         break;
 116     case ATTRIBUTE:
 117         rProperties.attribute(mId, *getValue());
 118         break;
 119     }
 120 }
 121
 122 /*
 123    class OOXMLValue
 124 */
 125
 126 OOXMLValue::OOXMLValue()
 127 {
 128 }
 129
 130 OOXMLValue::~OOXMLValue()
 131 {
 132 }
 133
 134 int OOXMLValue::getInt() const
 135 {
 136     return 0;
 137 }
 138
 139 OUString OOXMLValue::getString() const
 140 {
 141     return OUString();
 142 }
 143
 144 uno::Any OOXMLValue::getAny() const
 145 {
 146     return uno::Any();
 147 }
 148
 149 writerfilter::Reference<Properties>::Pointer_t OOXMLValue::getProperties()
 150 {
 151     return writerfilter::Reference<Properties>::Pointer_t();
 152 }
 153
 154 writerfilter::Reference<BinaryObj>::Pointer_t OOXMLValue::getBinary()
 155 {
 156     return writerfilter::Reference<BinaryObj>::Pointer_t();
 157 }
 158
 159 #ifdef DBG_UTIL
 160 std::string OOXMLValue::toString() const
 161 {
 162     return "OOXMLValue";
 163 }
 164 #endif
 165
 166 OOXMLValue * OOXMLValue::clone() const
 167 {
 168     return new OOXMLValue(*this);
 169 }
 170
 171 /*
 172   class OOXMLBinaryValue
 173  */
 174
 175 OOXMLBinaryValue::OOXMLBinaryValue(OOXMLBinaryObjectReference::Pointer_t pBinaryObj)
 176 : mpBinaryObj(std::move(pBinaryObj))
 177 {
 178 }
 179
 180 OOXMLBinaryValue::~OOXMLBinaryValue()
 181 {
 182 }
 183
 184 writerfilter::Reference<BinaryObj>::Pointer_t OOXMLBinaryValue::getBinary()
 185 {
 186     return mpBinaryObj;
 187 }
 188
 189 #ifdef DBG_UTIL
 190 std::string OOXMLBinaryValue::toString() const
 191 {
 192     return "BinaryObj";
 193 }
 194 #endif
 195
 196 OOXMLValue * OOXMLBinaryValue::clone() const
 197 {
 198     return new OOXMLBinaryValue(mpBinaryObj);
 199 }
 200
 201 /*
 202   class OOXMLBooleanValue
 203 */
 204
 205 static bool GetBooleanValue(std::string_view pValue)
 206 {
 207     return pValue == "true"
 208            || pValue == "True"
 209            || pValue == "1"
 210            || pValue == "on"
 211            || pValue == "On";
 212 }
 213
 214 OOXMLValue::Pointer_t const & OOXMLBooleanValue::Create(bool bValue)
 215 {
 216     static OOXMLValue::Pointer_t False(new OOXMLBooleanValue (false));
 217     static OOXMLValue::Pointer_t True(new OOXMLBooleanValue (true));
 218
 219     return bValue ? True : False;
 220 }
 221
 222 OOXMLValue::Pointer_t const & OOXMLBooleanValue::Create(std::string_view pValue)
 223 {
 224     return Create (GetBooleanValue(pValue));
 225 }
 226
 227 OOXMLBooleanValue::OOXMLBooleanValue(bool bValue)
 228 : mbValue(bValue)
 229 {
 230 }
 231
 232 OOXMLBooleanValue::~OOXMLBooleanValue()
 233 {
 234 }
 235
 236 int OOXMLBooleanValue::getInt() const
 237 {
 238     return mbValue ? 1 : 0;
 239 }
 240
 241 uno::Any OOXMLBooleanValue::getAny() const
 242 {
 243     return uno::Any(mbValue);
 244 }
 245
 246 #ifdef DBG_UTIL
 247 std::string OOXMLBooleanValue::toString() const
 248 {
 249     return mbValue ? "true" : "false";
 250 }
 251 #endif
 252
 253 OOXMLValue * OOXMLBooleanValue::clone() const
 254 {
 255     return new OOXMLBooleanValue(*this);
 256 }
 257
 258 /*
 259   class OOXMLStringValue
 260 */
 261
 262 OOXMLStringValue::OOXMLStringValue(OUString sStr)
 263 : mStr(std::move(sStr))
 264 {
 265 }
 266
 267 OOXMLStringValue::~OOXMLStringValue()
 268 {
 269 }
 270
 271 uno::Any OOXMLStringValue::getAny() const
 272 {
 273     return uno::Any(mStr);
 274 }
 275
 276 OUString OOXMLStringValue::getString() const
 277 {
 278     return mStr;
 279 }
 280
 281 #ifdef DBG_UTIL
 282 std::string OOXMLStringValue::toString() const
 283 {
 284     return std::string(OUStringToOString(mStr, RTL_TEXTENCODING_ASCII_US));
 285 }
 286 #endif
 287
 288 OOXMLValue * OOXMLStringValue::clone() const
 289 {
 290     return new OOXMLStringValue(*this);
 291 }
 292
 293 /*
 294   class OOXMLInputStreamValue
 295  */
 296 OOXMLInputStreamValue::OOXMLInputStreamValue(uno::Reference<io::XInputStream> xInputStream)
 297 : mxInputStream(std::move(xInputStream))
 298 {
 299 }
 300
 301 OOXMLInputStreamValue::~OOXMLInputStreamValue()
 302 {
 303 }
 304
 305 uno::Any OOXMLInputStreamValue::getAny() const
 306 {
 307     return uno::Any(mxInputStream);
 308 }
 309
 310 #ifdef DBG_UTIL
 311 std::string OOXMLInputStreamValue::toString() const
 312 {
 313     return "InputStream";
 314 }
 315 #endif
 316
 317 OOXMLValue * OOXMLInputStreamValue::clone() const
 318 {
 319     return new OOXMLInputStreamValue(mxInputStream);
 320 }
 321
 322 /**
 323    class OOXMLPropertySet
 324 */
 325
 326 OOXMLPropertySet::OOXMLPropertySet()
 327 {
 328 }
 329
 330 OOXMLPropertySet::~OOXMLPropertySet()
 331 {
 332 }
 333
 334 void OOXMLPropertySet::resolve(Properties & rHandler)
 335 {
 336     // The pProp->resolve(rHandler) call below can cause elements to
 337     // be appended to mProperties. I don't think it can cause elements
 338     // to be deleted. But let's check with < here just to be safe that
 339     // the indexing below works.
 340     for (size_t nIt = 0; nIt < mProperties.size(); ++nIt)
 341     {
 342         OOXMLProperty::Pointer_t pProp = mProperties[nIt];
 343
 344         if (pProp)
 345             pProp->resolve(rHandler);
 346     }
 347 }
 348
 349 OOXMLPropertySet::OOXMLProperties_t::iterator OOXMLPropertySet::begin()
 350 {
 351     return mProperties.begin();
 352 }
 353
 354 OOXMLPropertySet::OOXMLProperties_t::iterator OOXMLPropertySet::end()
 355 {
 356     return mProperties.end();
 357 }
 358
 359 OOXMLPropertySet::OOXMLProperties_t::const_iterator
 360 OOXMLPropertySet::begin() const
 361 {
 362     return mProperties.begin();
 363 }
 364
 365 OOXMLPropertySet::OOXMLProperties_t::const_iterator
 366 OOXMLPropertySet::end() const
 367 {
 368     return mProperties.end();
 369 }
 370
 371 void OOXMLPropertySet::add(const OOXMLProperty::Pointer_t& pProperty)
 372 {
 373     if (pProperty && pProperty->getId() != 0x0)
 374     {
 375         mProperties.push_back(pProperty);
 376     }
 377 }
 378
 379 void OOXMLPropertySet::add(Id id, const OOXMLValue::Pointer_t& pValue, OOXMLProperty::Type_t eType)
 380 {
 381     OOXMLProperty::Pointer_t pProperty(new OOXMLProperty(id, pValue, eType));
 382     add(pProperty);
 383 }
 384
 385 void OOXMLPropertySet::add(const OOXMLPropertySet::Pointer_t& pPropertySet)
 386 {
 387     const OOXMLPropertySet * pSet = pPropertySet.get();
 388
 389     if (pSet != nullptr)
 390     {
 391         mProperties.insert( mProperties.end(), pSet->mProperties.begin(), pSet->mProperties.end() );
 392     }
 393 }
 394
 395 OOXMLPropertySet * OOXMLPropertySet::clone() const
 396 {
 397     return new OOXMLPropertySet(*this);
 398 }
 399
 400 #ifdef DBG_UTIL
 401 std::string OOXMLPropertySet::toString()
 402 {
 403     std::string sResult = "[";
 404     char sBuffer[256];
 405     snprintf(sBuffer, sizeof(sBuffer), "%p", this);
 406     sResult += sBuffer;
 407     sResult += ":";
 408
 409     OOXMLProperties_t::iterator aItBegin = begin();
 410     OOXMLProperties_t::iterator aItEnd = end();
 411
 412     for (OOXMLProperties_t::iterator aIt = aItBegin; aIt != aItEnd; ++aIt)
 413     {
 414         if (aIt != aItBegin)
 415             sResult += ", ";
 416
 417         if (*aIt)
 418             sResult += (*aIt)->toString();
 419         else
 420             sResult += "0x0";
 421     }
 422
 423     sResult += "]";
 424
 425     return sResult;
 426 }
 427 #endif
 428
 429 /*
 430   class OOXMLPropertySetValue
 431 */
 432
 433 OOXMLPropertySetValue::OOXMLPropertySetValue(OOXMLPropertySet::Pointer_t pPropertySet)
 434     : mpPropertySet(std::move(pPropertySet))
 435 {
 436 }
 437
 438 OOXMLPropertySetValue::~OOXMLPropertySetValue()
 439 {
 440 }
 441
 442 writerfilter::Reference<Properties>::Pointer_t OOXMLPropertySetValue::getProperties()
 443 {
 444     return writerfilter::Reference<Properties>::Pointer_t
 445         (mpPropertySet->clone());
 446 }
 447
 448 #ifdef DBG_UTIL
 449 std::string OOXMLPropertySetValue::toString() const
 450 {
 451     char sBuffer[256];
 452
 453     snprintf(sBuffer, sizeof(sBuffer), "t:%p, m:%p", this, mpPropertySet.get());
 454
 455     return "OOXMLPropertySetValue(" + std::string(sBuffer) + ")";
 456 }
 457 #endif
 458
 459 OOXMLValue * OOXMLPropertySetValue::clone() const
 460 {
 461     return new OOXMLPropertySetValue(*this);
 462 }
 463
 464 /*
 465   class OOXMLIntegerValue
 466 */
 467
 468 OOXMLValue::Pointer_t OOXMLIntegerValue::Create(sal_Int32 nValue)
 469 {
 470     static OOXMLValue::Pointer_t Zero(new OOXMLIntegerValue (0));
 471     static OOXMLValue::Pointer_t One(new OOXMLIntegerValue (1));
 472     static OOXMLValue::Pointer_t Two(new OOXMLIntegerValue (2));
 473     static OOXMLValue::Pointer_t Three(new OOXMLIntegerValue (3));
 474     static OOXMLValue::Pointer_t Four(new OOXMLIntegerValue (4));
 475     static OOXMLValue::Pointer_t Five(new OOXMLIntegerValue (5));
 476     static OOXMLValue::Pointer_t Six(new OOXMLIntegerValue (6));
 477     static OOXMLValue::Pointer_t Seven(new OOXMLIntegerValue (7));
 478     static OOXMLValue::Pointer_t Eight(new OOXMLIntegerValue (8));
 479     static OOXMLValue::Pointer_t Nine(new OOXMLIntegerValue (9));
 480
 481     switch (nValue) {
 482     case 0: return Zero;
 483     case 1: return One;
 484     case 2: return Two;
 485     case 3: return Three;
 486     case 4: return Four;
 487     case 5: return Five;
 488     case 6: return Six;
 489     case 7: return Seven;
 490     case 8: return Eight;
 491     case 9: return Nine;
 492     default: break;
 493     }
 494
 495     OOXMLValue::Pointer_t value(new OOXMLIntegerValue(nValue));
 496
 497     return value;
 498 }
 499
 500 OOXMLIntegerValue::OOXMLIntegerValue(sal_Int32 nValue)
 501 : mnValue(nValue)
 502 {
 503 }
 504
 505 OOXMLIntegerValue::~OOXMLIntegerValue()
 506 {
 507 }
 508
 509 int OOXMLIntegerValue::getInt() const
 510 {
 511     return mnValue;
 512 }
 513
 514 uno::Any OOXMLIntegerValue::getAny() const
 515 {
 516     return uno::Any(mnValue);
 517 }
 518
 519 OOXMLValue * OOXMLIntegerValue::clone() const
 520 {
 521     return new OOXMLIntegerValue(*this);
 522 }
 523
 524 #ifdef DBG_UTIL
 525 std::string OOXMLIntegerValue::toString() const
 526 {
 527     char buffer[256];
 528     snprintf(buffer, sizeof(buffer), "%" SAL_PRIdINT32, mnValue);
 529
 530     return buffer;
 531 }
 532 #endif
 533
 534 /*
 535   class OOXMLHexValue
 536 */
 537
 538 OOXMLHexValue::OOXMLHexValue(sal_uInt32 nValue)
 539 : mnValue(nValue)
 540 {
 541 }
 542
 543 OOXMLHexValue::OOXMLHexValue(std::string_view pValue)
 544 : mnValue(o3tl::toUInt32(pValue, 16))
 545 {
 546 }
 547
 548 OOXMLHexValue::~OOXMLHexValue()
 549 {
 550 }
 551
 552 int OOXMLHexValue::getInt() const
 553 {
 554     return mnValue;
 555 }
 556
 557 OOXMLValue * OOXMLHexValue::clone() const
 558 {
 559     return new OOXMLHexValue(*this);
 560 }
 561
 562 #ifdef DBG_UTIL
 563 std::string OOXMLHexValue::toString() const
 564 {
 565     char buffer[256];
 566     snprintf(buffer, sizeof(buffer), "0x%" SAL_PRIxUINT32, mnValue);
 567
 568     return buffer;
 569 }
 570 #endif
 571
 572 /*
 573   class OOXMLHexColorValue
 574 */
 575 OOXMLHexColorValue::OOXMLHexColorValue(std::string_view pValue)
 576     : OOXMLHexValue(sal_uInt32(COL_AUTO))
 577 {
 578     if (pValue == "auto")
 579         return;
 580
 581     mnValue = o3tl::toUInt32(pValue, 16);
 582
 583     // Convert hash-encoded values (like #FF0080)
 584     const sal_Int32 nLen = pValue.size();
 585     if ( !mnValue && nLen > 1 && pValue[0] == '#' )
 586     {
 587         sal_Int32 nColor(COL_AUTO);
 588         // Word appears to require strict 6 digit length, else it ignores it
 589         if ( nLen == 7 )
 590         {
 591             const OUString sHashColor(pValue.data(), nLen, RTL_TEXTENCODING_ASCII_US);
 592             sax::Converter::convertColor( nColor, sHashColor );
 593         }
 594         mnValue = nColor;
 595     }
 596 }
 597
 598 // OOXMLUniversalMeasureValue
 599 // ECMA-376 5th ed. Part 1 , 22.9.2.15
 600 OOXMLUniversalMeasureValue::OOXMLUniversalMeasureValue(std::string_view pValue, sal_uInt32 npPt)
 601 {
 602     double val = o3tl::toDouble(pValue); // will ignore the trailing unit
 603
 604     int nLen = pValue.size();
 605     if (nLen > 2 &&
 606         pValue[nLen-2] == 'p' &&
 607         pValue[nLen-1] == 't')
 608     {
 609         mnValue = static_cast<int>(val * npPt);
 610     }
 611     else if (nLen > 2 &&
 612         pValue[nLen - 2] == 'c' &&
 613         pValue[nLen - 1] == 'm')
 614     {
 615         mnValue = static_cast<int>(val * npPt * 72 / 2.54);
 616     }
 617     else if (nLen > 2 &&
 618         pValue[nLen - 2] == 'm' &&
 619         pValue[nLen - 1] == 'm')
 620     {
 621         mnValue = static_cast<int>(val * npPt * 72 / 25.4);
 622     }
 623     else if (nLen > 2 &&
 624         pValue[nLen - 2] == 'i' &&
 625         pValue[nLen - 1] == 'n')
 626     {
 627         mnValue = static_cast<int>(val * npPt * 72);
 628     }
 629     else if (nLen > 2 &&
 630         pValue[nLen - 2] == 'p' &&
 631         ( pValue[nLen - 1] == 'c' || pValue[nLen - 1] == 'i' ))
 632     {
 633         mnValue = static_cast<int>(val * npPt * 12);
 634     }
 635     else
 636     {
 637         mnValue = static_cast<int>(val);
 638     }
 639 }
 640
 641 OOXMLUniversalMeasureValue::~OOXMLUniversalMeasureValue()
 642 {
 643 }
 644
 645 int OOXMLUniversalMeasureValue::getInt() const
 646 {
 647     return mnValue;
 648 }
 649
 650 #ifdef DBG_UTIL
 651 std::string OOXMLUniversalMeasureValue::toString() const
 652 {
 653     return std::string(OString::number(mnValue));
 654 }
 655 #endif
 656
 657 // OOXMLMeasurementOrPercentValue
 658 // ECMA-376 5th ed. Part 1 , 17.18.107; 17.18.11
 659 OOXMLMeasurementOrPercentValue::OOXMLMeasurementOrPercentValue(std::string_view pValue)
 660 {
 661     double val = o3tl::toDouble(pValue); // will ignore the trailing unit
 662
 663     int nLen = pValue.size();
 664     if (nLen > 1 &&
 665         pValue[nLen - 1] == '%')
 666     {
 667         mnValue = static_cast<int>(val * 50);
 668     }
 669     else
 670     {
 671         mnValue = OOXMLTwipsMeasureValue(pValue).getInt();
 672     }
 673 }
 674
 675 int OOXMLMeasurementOrPercentValue::getInt() const
 676 {
 677     return mnValue;
 678 }
 679
 680 #ifdef DBG_UTIL
 681 std::string OOXMLMeasurementOrPercentValue::toString() const
 682 {
 683     return std::string(OString::number(mnValue));
 684 }
 685 #endif
 686
 687 /*
 688   class OOXMLShapeValue
 689  */
 690
 691
 692 OOXMLShapeValue::OOXMLShapeValue(uno::Reference<drawing::XShape> xShape)
 693 : mrShape(std::move(xShape))
 694 {
 695 }
 696
 697 OOXMLShapeValue::~OOXMLShapeValue()
 698 {
 699 }
 700
 701 uno::Any OOXMLShapeValue::getAny() const
 702 {
 703     return uno::Any(mrShape);
 704 }
 705
 706 #ifdef DBG_UTIL
 707 std::string OOXMLShapeValue::toString() const
 708 {
 709     return "Shape";
 710 }
 711 #endif
 712
 713 OOXMLValue * OOXMLShapeValue::clone() const
 714 {
 715     return new OOXMLShapeValue(mrShape);
 716 }
 717
 718 /*
 719   class OOXMLStarMathValue
 720  */
 721
 722
 723 OOXMLStarMathValue::OOXMLStarMathValue( uno::Reference< embed::XEmbeddedObject > c )
 724 : m_component(std::move(c))
 725 {
 726 }
 727
 728 OOXMLStarMathValue::~OOXMLStarMathValue()
 729 {
 730 }
 731
 732 uno::Any OOXMLStarMathValue::getAny() const
 733 {
 734     return uno::Any(m_component);
 735 }
 736
 737 #ifdef DBG_UTIL
 738 std::string OOXMLStarMathValue::toString() const
 739 {
 740     return "StarMath";
 741 }
 742 #endif
 743
 744 OOXMLValue * OOXMLStarMathValue::clone() const
 745 {
 746     return new OOXMLStarMathValue( m_component );
 747 }
 748
 749 /*
 750   class OOXMLTableImpl
 751  */
 752
 753 OOXMLTable::OOXMLTable()
 754 {
 755 }
 756
 757 OOXMLTable::~OOXMLTable()
 758 {
 759 }
 760
 761
 762 void OOXMLTable::resolve(Table & rTable)
 763 {
 764     Table * pTable = &rTable;
 765
 766     int nPos = 0;
 767
 768     for (const auto& rPropSet : mPropertySets)
 769     {
 770         writerfilter::Reference<Properties>::Pointer_t pProperties
 771             (rPropSet->getProperties());
 772
 773         if (pProperties)
 774             pTable->entry(nPos, pProperties);
 775
 776         ++nPos;
 777     }
 778 }
 779
 780 void OOXMLTable::add(const ValuePointer_t& pPropertySet)
 781 {
 782     if (pPropertySet)
 783         mPropertySets.push_back(pPropertySet);
 784 }
 785
 786 OOXMLTable * OOXMLTable::clone() const
 787 {
 788     return new OOXMLTable(*this);
 789 }
 790
 791 /*
 792   class: OOXMLPropertySetEntryToString
 793 */
 794
 795 OOXMLPropertySetEntryToString::OOXMLPropertySetEntryToString(Id nId)
 796 : mnId(nId)
 797 {
 798 }
 799
 800 OOXMLPropertySetEntryToString::~OOXMLPropertySetEntryToString()
 801 {
 802 }
 803
 804 void OOXMLPropertySetEntryToString::sprm(Sprm & /*rSprm*/)
 805 {
 806 }
 807
 808 void OOXMLPropertySetEntryToString::attribute(Id nId, Value & rValue)
 809 {
 810     if (nId == mnId)
 811         mStr = rValue.getString();
 812 }
 813
 814 /*
 815   class: OOXMLPropertySetEntryToInteger
 816 */
 817
 818 OOXMLPropertySetEntryToInteger::OOXMLPropertySetEntryToInteger(Id nId)
 819 : mnId(nId), mnValue(0)
 820 {
 821 }
 822
 823 OOXMLPropertySetEntryToInteger::~OOXMLPropertySetEntryToInteger()
 824 {
 825 }
 826
 827 void OOXMLPropertySetEntryToInteger::sprm(Sprm & /*rSprm*/)
 828 {
 829 }
 830
 831 void OOXMLPropertySetEntryToInteger::attribute(Id nId, Value & rValue)
 832 {
 833     if (nId == mnId)
 834         mnValue = rValue.getInt();
 835 }
 836
 837 /*
 838   class: OOXMLPropertySetEntryToBool
 839 */
 840
 841 OOXMLPropertySetEntryToBool::OOXMLPropertySetEntryToBool(Id nId)
 842     : mnId(nId), mValue(false)
 843 {}
 844
 845 OOXMLPropertySetEntryToBool::~OOXMLPropertySetEntryToBool() {}
 846
 847 void OOXMLPropertySetEntryToBool::sprm(Sprm & /*rSprm*/) {}
 848
 849 void OOXMLPropertySetEntryToBool::attribute(Id nId, Value & rValue)
 850 {
 851     if (nId == mnId)
 852         mValue = (rValue.getInt() != 0);
 853 }
 854
 855 }
 856
 857 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */