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