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