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