writerfilter/source/ooxml/OOXMLPropertySetImpl.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: OOXMLPropertySetImpl.cxx,v $
  10  * $Revision: 1.27 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "OOXMLPropertySetImpl.hxx"
  32 #include <stdio.h>
  33 #include <iostream>
  34 #include <resourcemodel/QNameToString.hxx>
  35 #include <com/sun/star/drawing/XShape.hpp>
  36
  37 //#define DEBUG_RESOLVE
  38
  39 namespace writerfilter {
  40 namespace ooxml
  41 {
  42 using namespace ::std;
  43
  44 static ::rtl::OUString strue(RTL_CONSTASCII_USTRINGPARAM("true"));
  45 static ::rtl::OUString sTrue(RTL_CONSTASCII_USTRINGPARAM("True"));
  46 static ::rtl::OUString s1(RTL_CONSTASCII_USTRINGPARAM("1"));
  47 static ::rtl::OUString sOn(RTL_CONSTASCII_USTRINGPARAM("On"));
  48 static ::rtl::OUString son(RTL_CONSTASCII_USTRINGPARAM("on"));
  49
  50 OOXMLProperty::~OOXMLProperty()
  51 {
  52 }
  53
  54 OOXMLPropertySet::~OOXMLPropertySet()
  55 {
  56 }
  57
  58 OOXMLTable::~OOXMLTable()
  59 {
  60 }
  61
  62 OOXMLPropertyImpl::OOXMLPropertyImpl(Id id, OOXMLValue::Pointer_t pValue,
  63                                      OOXMLPropertyImpl::Type_t eType)
  64 : mId(id), mpValue(pValue), meType(eType)
  65 {
  66 }
  67
  68 OOXMLPropertyImpl::OOXMLPropertyImpl(const OOXMLPropertyImpl & rSprm)
  69 : OOXMLProperty(), mId(rSprm.mId), mpValue(rSprm.mpValue), meType(rSprm.meType)
  70 {
  71 }
  72
  73 OOXMLPropertyImpl::~OOXMLPropertyImpl()
  74 {
  75 }
  76
  77 sal_uInt32 OOXMLPropertyImpl::getId() const
  78 {
  79     return mId;
  80 }
  81
  82 Value::Pointer_t OOXMLPropertyImpl::getValue()
  83 {
  84     Value::Pointer_t pResult;
  85
  86     if (mpValue.get() != NULL)
  87         pResult = Value::Pointer_t(mpValue->clone());
  88     else
  89         pResult = Value::Pointer_t(new OOXMLValue());
  90
  91     return pResult;
  92 }
  93
  94 writerfilter::Reference<BinaryObj>::Pointer_t OOXMLPropertyImpl::getBinary()
  95 {
  96     writerfilter::Reference<BinaryObj>::Pointer_t pResult;
  97
  98     if (mpValue.get() != NULL)
  99         pResult = mpValue->getBinary();
 100
 101     return pResult;
 102 }
 103
 104 writerfilter::Reference<Stream>::Pointer_t OOXMLPropertyImpl::getStream()
 105 {
 106     writerfilter::Reference<Stream>::Pointer_t pResult;
 107
 108     if (mpValue.get() != NULL)
 109         pResult = mpValue->getStream();
 110
 111     return pResult;
 112 }
 113
 114 writerfilter::Reference<Properties>::Pointer_t OOXMLPropertyImpl::getProps()
 115 {
 116     writerfilter::Reference<Properties>::Pointer_t pResult;
 117
 118     if (mpValue.get() != NULL)
 119         pResult = mpValue->getProperties();
 120
 121     return pResult;
 122 }
 123
 124 string OOXMLPropertyImpl::getName() const
 125 {
 126     string sResult = (*QNameToString::Instance())(mId);
 127
 128     if (sResult.length() == 0)
 129         sResult = (*SprmIdToString::Instance())(mId);
 130
 131     return sResult;
 132 }
 133
 134 string OOXMLPropertyImpl::toString() const
 135 {
 136     string sResult = "(";
 137
 138     sResult += getName();
 139     sResult += ", ";
 140     if (mpValue.get() != NULL)
 141         sResult += mpValue->toString();
 142     else
 143         sResult +="(null)";
 144     sResult +=")";
 145
 146     return sResult;
 147 }
 148
 149 Sprm::Kind OOXMLPropertyImpl::getKind()
 150 {
 151     return SprmKind(getId());
 152 }
 153
 154 Sprm * OOXMLPropertyImpl::clone()
 155 {
 156     return new OOXMLPropertyImpl(*this);
 157 }
 158
 159 void OOXMLPropertyImpl::resolve(writerfilter::Properties & rProperties)
 160 {
 161     switch (meType)
 162     {
 163     case SPRM:
 164         if (mId != 0x0)
 165             rProperties.sprm(*this);
 166         break;
 167     case ATTRIBUTE:
 168         rProperties.attribute(mId, *getValue());
 169         break;
 170     }
 171 }
 172
 173 /*
 174    class OOXMLValue
 175 */
 176
 177 OOXMLValue::OOXMLValue()
 178 {
 179 }
 180
 181 OOXMLValue::OOXMLValue(const rtl::OUString & /*rValue*/)
 182 {
 183 }
 184
 185 OOXMLValue::~OOXMLValue()
 186 {
 187 }
 188
 189 bool OOXMLValue::getBool() const
 190 {
 191     return false;
 192 }
 193
 194 int OOXMLValue::getInt() const
 195 {
 196     return 0;
 197 }
 198
 199 ::rtl::OUString OOXMLValue::getString() const
 200 {
 201     return ::rtl::OUString();
 202 }
 203
 204 uno::Any OOXMLValue::getAny() const
 205 {
 206     return uno::Any();
 207 }
 208
 209 writerfilter::Reference<Properties>::Pointer_t OOXMLValue::getProperties()
 210 {
 211     return writerfilter::Reference<Properties>::Pointer_t();
 212 }
 213
 214 writerfilter::Reference<Stream>::Pointer_t OOXMLValue::getStream()
 215 {
 216     return writerfilter::Reference<Stream>::Pointer_t();
 217 }
 218
 219 writerfilter::Reference<BinaryObj>::Pointer_t OOXMLValue::getBinary()
 220 {
 221     return writerfilter::Reference<BinaryObj>::Pointer_t();
 222 }
 223
 224 string OOXMLValue::toString() const
 225 {
 226     return "OOXMLValue";
 227 }
 228
 229 OOXMLValue * OOXMLValue::clone() const
 230 {
 231     return new OOXMLValue(*this);
 232 }
 233
 234 /*
 235   class OOXMLBinaryValue
 236  */
 237
 238 OOXMLBinaryValue::OOXMLBinaryValue(OOXMLBinaryObjectReference::Pointer_t
 239                                    pBinaryObj)
 240 : mpBinaryObj(pBinaryObj)
 241 {
 242 }
 243
 244 OOXMLBinaryValue::~OOXMLBinaryValue()
 245 {
 246 }
 247
 248 writerfilter::Reference<BinaryObj>::Pointer_t OOXMLBinaryValue::getBinary()
 249 {
 250     return mpBinaryObj;
 251 }
 252
 253 string OOXMLBinaryValue::toString() const
 254 {
 255     return "BinaryObj";
 256 }
 257
 258 OOXMLValue * OOXMLBinaryValue::clone() const
 259 {
 260     return new OOXMLBinaryValue(mpBinaryObj);
 261 }
 262
 263 /*
 264   class OOXMLBooleanValue
 265 */
 266
 267 OOXMLBooleanValue::OOXMLBooleanValue(bool bValue)
 268 : mbValue(bValue)
 269 {
 270 }
 271
 272 OOXMLBooleanValue::OOXMLBooleanValue(const rtl::OUString & rValue)
 273 : mbValue(false)
 274 {
 275     if (strue.compareTo(rValue) == 0
 276         || sTrue.compareTo(rValue) == 0
 277         || s1.compareTo(rValue) == 0
 278         || son.compareTo(rValue) == 0
 279         || sOn.compareTo(rValue) == 0)
 280         mbValue = true;
 281      else
 282         mbValue = false;
 283 }
 284
 285 OOXMLBooleanValue::~OOXMLBooleanValue()
 286 {
 287 }
 288
 289 bool OOXMLBooleanValue::getBool() const
 290 {
 291     return mbValue;
 292 }
 293
 294 int OOXMLBooleanValue::getInt() const
 295 {
 296     return mbValue ? 1 : 0;
 297 }
 298
 299 uno::Any OOXMLBooleanValue::getAny() const
 300 {
 301     uno::Any aResult(mbValue);
 302
 303     return aResult;
 304 }
 305
 306 string OOXMLBooleanValue::toString() const
 307 {
 308     return mbValue ? "true" : "false";
 309 }
 310
 311 OOXMLValue * OOXMLBooleanValue::clone() const
 312 {
 313     return new OOXMLBooleanValue(*this);
 314 }
 315
 316 /*
 317   class OOXMLStringValue
 318 */
 319
 320 OOXMLStringValue::OOXMLStringValue(const rtl::OUString & rStr)
 321 : mStr(rStr)
 322 {
 323 }
 324
 325 OOXMLStringValue::~OOXMLStringValue()
 326 {
 327 }
 328
 329 uno::Any OOXMLStringValue::getAny() const
 330 {
 331     uno::Any aAny(mStr);
 332
 333     return aAny;
 334 }
 335
 336 rtl::OUString OOXMLStringValue::getString() const
 337 {
 338     return mStr;
 339 }
 340
 341 string OOXMLStringValue::toString() const
 342 {
 343     return OUStringToOString(mStr, RTL_TEXTENCODING_ASCII_US).getStr();
 344 }
 345
 346 OOXMLValue * OOXMLStringValue::clone() const
 347 {
 348     return new OOXMLStringValue(*this);
 349 }
 350
 351 /*
 352   class OOXMLInputStreamValue
 353  */
 354 OOXMLInputStreamValue::OOXMLInputStreamValue(uno::Reference<io::XInputStream> xInputStream)
 355 : mxInputStream(xInputStream)
 356 {
 357 }
 358
 359 OOXMLInputStreamValue::~OOXMLInputStreamValue()
 360 {
 361 }
 362
 363 uno::Any OOXMLInputStreamValue::getAny() const
 364 {
 365     uno::Any aAny(mxInputStream);
 366
 367     return aAny;
 368 }
 369
 370 string OOXMLInputStreamValue::toString() const
 371 {
 372     return "InputStream";
 373 }
 374
 375 OOXMLValue * OOXMLInputStreamValue::clone() const
 376 {
 377     return new OOXMLInputStreamValue(mxInputStream);
 378 }
 379
 380 /*
 381   struct OOXMLPropertySetImplCompare
 382  */
 383
 384 bool OOXMLPropertySetImplCompare::operator()(const OOXMLProperty::Pointer_t x,
 385                                              const OOXMLProperty::Pointer_t y) const
 386 {
 387     bool bResult = false;
 388
 389     if (x.get() == NULL && y.get() != NULL)
 390         bResult = true;
 391     else if (x.get() != NULL && y.get() != NULL)
 392         bResult = x->getId() < y->getId();
 393
 394     return bResult;
 395 }
 396
 397 /**
 398    class OOXMLPropertySetImpl
 399 */
 400
 401 OOXMLPropertySetImpl::OOXMLPropertySetImpl()
 402 : msType("OOXMLPropertySetImpl")
 403 {
 404 }
 405
 406 OOXMLPropertySetImpl::~OOXMLPropertySetImpl()
 407 {
 408 }
 409
 410 void OOXMLPropertySetImpl::resolve(Properties & rHandler)
 411 {
 412     OOXMLProperties_t::iterator aIt = begin();
 413     while (aIt != end())
 414     {
 415         OOXMLProperty::Pointer_t pProp = *aIt;
 416
 417         if (pProp.get() != NULL)
 418             pProp->resolve(rHandler);
 419 #ifdef DEBUG_RESOLVE
 420         else
 421         {
 422             debug_logger->startElement("error");
 423             debug_logger->chars("zero-property");
 424             debug_logger->endElement("error");
 425 #endif
 426
 427         aIt++;
 428     }
 429 }
 430
 431 OOXMLPropertySetImpl::OOXMLProperties_t::iterator OOXMLPropertySetImpl::begin()
 432 {
 433     return mProperties.begin();
 434 }
 435
 436 OOXMLPropertySetImpl::OOXMLProperties_t::iterator OOXMLPropertySetImpl::end()
 437 {
 438     return mProperties.end();
 439 }
 440
 441 OOXMLPropertySetImpl::OOXMLProperties_t::const_iterator
 442 OOXMLPropertySetImpl::begin() const
 443 {
 444     return mProperties.begin();
 445 }
 446
 447 OOXMLPropertySetImpl::OOXMLProperties_t::const_iterator
 448 OOXMLPropertySetImpl::end() const
 449 {
 450     return mProperties.end();
 451 }
 452
 453 string OOXMLPropertySetImpl::getType() const
 454 {
 455     return msType;
 456 }
 457
 458 void OOXMLPropertySetImpl::add(OOXMLProperty::Pointer_t pProperty)
 459 {
 460     if (pProperty.get() != NULL && pProperty->getId() != 0x0)
 461         mProperties.push_back(pProperty);
 462 }
 463
 464 void OOXMLPropertySetImpl::add(OOXMLPropertySet::Pointer_t pPropertySet)
 465 {
 466     if (pPropertySet.get() != NULL)
 467     {
 468         OOXMLPropertySetImpl * pSet =
 469             dynamic_cast<OOXMLPropertySetImpl *>(pPropertySet.get());
 470
 471         if (pSet != NULL)
 472         {
 473             mProperties.resize(mProperties.size() + pSet->mProperties.size());
 474             for (OOXMLProperties_t::iterator aIt = pSet->mProperties.begin();
 475                  aIt != pSet->mProperties.end(); aIt++)
 476                 add(*aIt);
 477         }
 478     }
 479 }
 480
 481 OOXMLPropertySet * OOXMLPropertySetImpl::clone() const
 482 {
 483     return new OOXMLPropertySetImpl(*this);
 484 }
 485
 486 void OOXMLPropertySetImpl::setType(const string & rsType)
 487 {
 488     msType = rsType;
 489 }
 490
 491 string OOXMLPropertySetImpl::toString()
 492 {
 493     string sResult = "[";
 494     char sBuffer[256];
 495     snprintf(sBuffer, sizeof(sBuffer), "%p", this);
 496     sResult += sBuffer;
 497     sResult += ":";
 498
 499     OOXMLProperties_t::iterator aItBegin = begin();
 500     OOXMLProperties_t::iterator aItEnd = end();
 501
 502     for (OOXMLProperties_t::iterator aIt = aItBegin; aIt != aItEnd; aIt++)
 503     {
 504         if (aIt != aItBegin)
 505             sResult += ", ";
 506
 507         if ((*aIt).get() != NULL)
 508             sResult += (*aIt)->toString();
 509         else
 510             sResult += "0x0";
 511     }
 512
 513     sResult += "]";
 514
 515     return sResult;
 516 }
 517
 518 /*
 519   class OOXMLPropertySetValue
 520 */
 521
 522 OOXMLPropertySetValue::OOXMLPropertySetValue
 523 (OOXMLPropertySet::Pointer_t pPropertySet)
 524 : mpPropertySet(pPropertySet)
 525 {
 526 }
 527
 528 OOXMLPropertySetValue::~OOXMLPropertySetValue()
 529 {
 530 }
 531
 532 writerfilter::Reference<Properties>::Pointer_t OOXMLPropertySetValue::getProperties()
 533 {
 534     return writerfilter::Reference<Properties>::Pointer_t
 535         (mpPropertySet->clone());
 536 }
 537
 538 string OOXMLPropertySetValue::toString() const
 539 {
 540     char sBuffer[256];
 541
 542     snprintf(sBuffer, sizeof(sBuffer), "t:%p, m:%p", this, mpPropertySet.get());
 543
 544     return "OOXMLPropertySetValue(" + string(sBuffer) + ")";
 545 }
 546
 547 OOXMLValue * OOXMLPropertySetValue::clone() const
 548 {
 549     return new OOXMLPropertySetValue(*this);
 550 }
 551
 552 /*
 553   class OOXMLIntegerValue
 554 */
 555
 556 OOXMLIntegerValue::OOXMLIntegerValue(sal_Int32 nValue)
 557 : mnValue(nValue)
 558 {
 559 }
 560
 561 OOXMLIntegerValue::OOXMLIntegerValue(const rtl::OUString & rValue)
 562 : mnValue(0)
 563 {
 564     mnValue = rValue.toInt32();
 565 }
 566
 567 OOXMLIntegerValue::~OOXMLIntegerValue()
 568 {
 569 }
 570
 571 int OOXMLIntegerValue::getInt() const
 572 {
 573     return mnValue;
 574 }
 575
 576 uno::Any OOXMLIntegerValue::getAny() const
 577 {
 578     uno::Any aResult(mnValue);
 579
 580     return aResult;
 581 }
 582
 583 OOXMLValue * OOXMLIntegerValue::clone() const
 584 {
 585     return new OOXMLIntegerValue(*this);
 586 }
 587
 588 string OOXMLIntegerValue::toString() const
 589 {
 590     char buffer[256];
 591     snprintf(buffer, sizeof(buffer), "%" SAL_PRIdINT32, mnValue);
 592
 593     return buffer;
 594 }
 595
 596 /*
 597   class OOXMLHexValue
 598 */
 599
 600 OOXMLHexValue::OOXMLHexValue(sal_uInt32 nValue)
 601 : mnValue(nValue)
 602 {
 603 }
 604
 605 OOXMLHexValue::OOXMLHexValue(const rtl::OUString & rValue)
 606 {
 607     mnValue = static_cast<sal_uInt32>(rValue.toInt32(16));
 608 }
 609
 610 OOXMLHexValue::~OOXMLHexValue()
 611 {
 612 }
 613
 614 int OOXMLHexValue::getInt() const
 615 {
 616     return mnValue;
 617 }
 618
 619 OOXMLValue * OOXMLHexValue::clone() const
 620 {
 621     return new OOXMLHexValue(*this);
 622 }
 623
 624 string OOXMLHexValue::toString() const
 625 {
 626     char buffer[256];
 627     snprintf(buffer, sizeof(buffer), "0x%" SAL_PRIxUINT32, mnValue);
 628
 629     return buffer;
 630 }
 631
 632 /*
 633   class OOXMLListValue
 634 */
 635 OOXMLListValue::OOXMLListValue()
 636 : OOXMLIntegerValue(0)
 637 {
 638 }
 639
 640 OOXMLListValue::OOXMLListValue(sal_Int32 nValue)
 641 : OOXMLIntegerValue(nValue)
 642 {
 643 }
 644
 645
 646 OOXMLListValue::~OOXMLListValue()
 647 {
 648 }
 649
 650 /*
 651   class OOXMLShapeValue
 652  */
 653
 654
 655 OOXMLShapeValue::OOXMLShapeValue(uno::Reference<XShape> rShape)
 656 : mrShape(rShape)
 657 {
 658 }
 659
 660 OOXMLShapeValue::~OOXMLShapeValue()
 661 {
 662 }
 663
 664 uno::Any OOXMLShapeValue::getAny() const
 665 {
 666     return uno::Any(mrShape);
 667 }
 668
 669 string OOXMLShapeValue::toString() const
 670 {
 671     return "Shape";
 672 }
 673
 674 OOXMLValue * OOXMLShapeValue::clone() const
 675 {
 676     return new OOXMLShapeValue(mrShape);
 677 }
 678
 679 /*
 680   class OOXMLTableImpl
 681  */
 682
 683 OOXMLTableImpl::OOXMLTableImpl()
 684 {
 685 }
 686
 687 OOXMLTableImpl::~OOXMLTableImpl()
 688 {
 689 }
 690
 691 void OOXMLTableImpl::resolve(Table & rTable)
 692 {
 693     int nPos = 0;
 694
 695     PropertySets_t::iterator it = mPropertySets.begin();
 696     PropertySets_t::iterator itEnd = mPropertySets.end();
 697
 698     while (it != itEnd)
 699     {
 700         writerfilter::Reference<Properties>::Pointer_t pProperties
 701             ((*it)->getProperties());
 702
 703         if (pProperties.get() != NULL)
 704             rTable.entry(nPos, pProperties);
 705
 706         ++nPos;
 707         it++;
 708     }
 709 }
 710
 711 void OOXMLTableImpl::add(ValuePointer_t pPropertySet)
 712 {
 713     if (pPropertySet.get() != NULL)
 714         mPropertySets.push_back(pPropertySet);
 715 }
 716
 717 string OOXMLTableImpl::getType() const
 718 {
 719     return "OOXMLTableImpl";
 720 }
 721
 722 OOXMLTable * OOXMLTableImpl::clone() const
 723 {
 724     return new OOXMLTableImpl(*this);
 725 }
 726
 727 /*
 728   class: OOXMLPropertySetEntryToString
 729 */
 730
 731 OOXMLPropertySetEntryToString::OOXMLPropertySetEntryToString(Id nId)
 732 : mnId(nId)
 733 {
 734 }
 735
 736 OOXMLPropertySetEntryToString::~OOXMLPropertySetEntryToString()
 737 {
 738 }
 739
 740 void OOXMLPropertySetEntryToString::sprm(Sprm & /*rSprm*/)
 741 {
 742 }
 743
 744 void OOXMLPropertySetEntryToString::attribute(Id nId, Value & rValue)
 745 {
 746     if (nId == mnId)
 747         mStr = rValue.getString();
 748 }
 749
 750 const ::rtl::OUString & OOXMLPropertySetEntryToString::getString() const
 751 {
 752     return mStr;
 753 }
 754
 755 OOXMLPropertySetEntryToInteger::OOXMLPropertySetEntryToInteger(Id nId)
 756 : mnId(nId)
 757 {
 758 }
 759
 760 OOXMLPropertySetEntryToInteger::~OOXMLPropertySetEntryToInteger()
 761 {
 762 }
 763
 764 void OOXMLPropertySetEntryToInteger::sprm(Sprm & /*rSprm*/)
 765 {
 766 }
 767
 768 void OOXMLPropertySetEntryToInteger::attribute(Id nId, Value & rValue)
 769 {
 770     if (nId == mnId)
 771         mnValue = rValue.getInt();
 772 }
 773
 774 int OOXMLPropertySetEntryToInteger::getValue() const
 775 {
 776     return mnValue;
 777 }
 778
 779 }}