writerfilter/source/doctok/Dff.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: Dff.cxx,v $
  10  * $Revision: 1.13 $
  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 <stdio.h>
  32 #include "Dff.hxx"
  33 #include <doctok/resourceids.hxx>
  34 #include <resourcemodel/WW8ResourceModel.hxx>
  35 #include "resources.hxx"
  36
  37 namespace writerfilter {
  38 namespace doctok {
  39
  40 typedef boost::shared_ptr<WW8Value> WW8ValueSharedPointer_t;
  41
  42 DffRecord::DffRecord(WW8Stream & rStream, sal_uInt32 nOffset,
  43                      sal_uInt32 nCount)
  44 : WW8StructBase(rStream, nOffset, nCount), bInitialized(false)
  45 {
  46 }
  47
  48 DffRecord::DffRecord(WW8StructBase * pParent, sal_uInt32 nOffset,
  49                      sal_uInt32 nCount)
  50 : WW8StructBase(pParent, nOffset, nCount), bInitialized(false)
  51 {
  52 }
  53
  54 Records_t::iterator DffRecord::begin()
  55 {
  56     if (! bInitialized)
  57         initChildren();
  58
  59     return mRecords.begin();
  60 }
  61
  62 Records_t::iterator DffRecord::end()
  63 {
  64     if (! bInitialized)
  65         initChildren();
  66
  67     return mRecords.end();
  68 }
  69
  70 bool DffRecord::isContainer() const
  71 {
  72     return getVersion() == 0xf;
  73 }
  74
  75 sal_uInt32 DffRecord::calcSize() const
  76 {
  77     sal_uInt32 nResult = 0;
  78
  79     switch (getRecordType())
  80     {
  81     case 0xf000:
  82     case 0xf001:
  83     case 0xf002:
  84     case 0xf003:
  85     case 0xf004:
  86         nResult = getU32(0x4) + 8;
  87
  88         break;
  89     case 0xf700:
  90         nResult = 8;
  91
  92         break;
  93     default:
  94         nResult = getU32(0x4);
  95
  96         if (! isContainer())
  97             nResult += 8;
  98         break;
  99     }
 100
 101     return nResult;
 102 }
 103
 104 sal_uInt32 DffRecord::getVersion() const
 105 {
 106     return getU8(0x0) & 0xf;
 107 }
 108
 109 sal_uInt32 DffRecord::getInstance() const
 110 {
 111     return (getU16(0x0) & 0xfff0) >> 4;
 112 }
 113
 114 sal_uInt32 DffRecord::getRecordType() const
 115 {
 116     return getU16(0x2);
 117 }
 118
 119 void DffRecord::initChildren()
 120 {
 121     if (isContainer())
 122     {
 123         sal_uInt32 nOffset = 8;
 124         sal_uInt32 nCount = calcSize();
 125
 126         while (nCount - nOffset >= 8)
 127         {
 128             sal_uInt32 nSize = 0;
 129             boost::shared_ptr<DffRecord> pRec
 130                 (createDffRecord(this, nOffset, &nSize));
 131
 132             if (nSize == 0)
 133                 break;
 134
 135             mRecords.push_back(pRec);
 136
 137             nOffset += nSize;
 138         }
 139     }
 140
 141     bInitialized = true;
 142 }
 143
 144 Records_t DffRecord::findRecords(sal_uInt32 nType, bool bRecursive, bool bAny)
 145 {
 146     Records_t aResult;
 147
 148     findRecords(nType, aResult, bRecursive, bAny);
 149
 150     return aResult;
 151 }
 152
 153 void DffRecord::findRecords
 154 (sal_uInt32 nType, Records_t & rRecords, bool bRecursive, bool bAny)
 155 {
 156     Records_t::iterator aIt = begin();
 157
 158     while (aIt != end())
 159     {
 160         Pointer_t pPointer = *aIt;
 161         if (bAny || pPointer->getRecordType() == nType)
 162             rRecords.push_back(pPointer);
 163
 164         if (bRecursive)
 165             pPointer->findRecords(nType, rRecords, bRecursive,
 166                                       bAny);
 167
 168         ++aIt;
 169     }
 170 }
 171
 172 void DffRecord::resolveChildren(Properties & rHandler)
 173 {
 174     Records_t::iterator aIt;
 175     for (aIt = begin(); aIt != end(); ++aIt)
 176     {
 177         rHandler.sprm(**aIt);
 178     }
 179 }
 180
 181 void DffRecord::resolveLocal(Properties &)
 182 {
 183 }
 184
 185 void DffRecord::resolve(Properties & rHandler)
 186 {
 187     WW8Value::Pointer_t pVal = createValue(getRecordType());
 188     rHandler.attribute(NS_rtf::LN_dfftype, *pVal);
 189
 190     pVal = createValue(getInstance());
 191     rHandler.attribute(NS_rtf::LN_dffinstance, *pVal);
 192
 193     pVal = createValue(getVersion());
 194     rHandler.attribute(NS_rtf::LN_dffversion, *pVal);
 195
 196     pVal = createValue(getU32(0x0));
 197     rHandler.attribute(NS_rtf::LN_dffheader, *pVal);
 198
 199     if (isContainer())
 200     {
 201         resolveChildren(rHandler);
 202     }
 203
 204     resolveLocal(rHandler);
 205
 206 #if 1
 207     WW8BinaryObjReference::Pointer_t pBinObjRef
 208         (new WW8BinaryObjReference(this, 0, getCount()));
 209     WW8Sprm aSprm(pBinObjRef);
 210
 211     rHandler.sprm(aSprm);
 212 #endif
 213 }
 214
 215 sal_uInt32 DffRecord::getShapeType()
 216 {
 217     sal_uInt32 nResult = 0;
 218
 219     Records_t aRecords = findRecords(0xf00a);
 220
 221     if (aRecords.size() > 0)
 222     {
 223         DffFSP * pDffFSP = dynamic_cast<DffFSP*>((*aRecords.begin()).get());
 224         nResult = pDffFSP->get_shptype();
 225     }
 226
 227     return nResult;
 228 }
 229
 230 sal_uInt32 DffRecord::getShapeId()
 231 {
 232     sal_uInt32 nResult = 0;
 233
 234     Records_t aRecords = findRecords(0xf00a);
 235
 236     if (aRecords.size() > 0)
 237     {
 238         DffFSP * pDffFSP = dynamic_cast<DffFSP*>((*aRecords.begin()).get());
 239         nResult = pDffFSP->get_shpid();
 240     }
 241
 242     return nResult;
 243 }
 244
 245 class DffOPTHandler : public Properties
 246 {
 247     map<int, WW8ValueSharedPointer_t> mMap;
 248     int nId;
 249
 250 public:
 251     DffOPTHandler() : nId(0) {}
 252     virtual ~DffOPTHandler() {}
 253
 254     virtual void attribute(Id name, Value & val)
 255     {
 256         switch (name)
 257         {
 258         case NS_rtf::LN_shppid:
 259             nId = val.getInt();
 260             break;
 261         case NS_rtf::LN_shpvalue:
 262             {
 263                 WW8Value & rTmpVal = dynamic_cast<WW8Value &>(val);
 264                 WW8ValueSharedPointer_t
 265                     pVal(dynamic_cast<WW8Value *>(rTmpVal.clone()));
 266                 mMap[nId] = pVal;
 267             }
 268         }
 269     }
 270
 271     virtual void sprm(Sprm & /*sprm_*/)
 272     {
 273     }
 274
 275     WW8ValueSharedPointer_t & getValue(int nId_)
 276     {
 277         return mMap[nId_];
 278     }
 279
 280 };
 281
 282 sal_uInt32 DffRecord::getShapeBid()
 283 {
 284     sal_uInt32 nResult = 0;
 285
 286     if (getShapeType() == 75)
 287     {
 288         Records_t aRecords = findRecords(0xf00b);
 289
 290         if (aRecords.size() > 0)
 291         {
 292             DffOPTHandler aHandler;
 293             DffOPT * pOpts = dynamic_cast<DffOPT*>((*aRecords.begin()).get());
 294
 295             sal_uInt32 nCount = pOpts->get_property_count();
 296
 297             for (sal_uInt32 n = 0; n < nCount; ++n)
 298             {
 299                 pOpts->get_property(n)->resolve(aHandler);
 300             }
 301
 302             WW8ValueSharedPointer_t pVal = aHandler.getValue(260);
 303
 304             if (pVal.get() != NULL)
 305                 nResult = pVal->getInt();
 306         }
 307     }
 308
 309     return nResult;
 310 }
 311
 312 string DffRecord::getType() const
 313 {
 314     return "DffRecord";
 315 }
 316
 317 Value::Pointer_t DffRecord::getValue()
 318 {
 319     return Value::Pointer_t();
 320 }
 321
 322 writerfilter::Reference<BinaryObj>::Pointer_t DffRecord::getBinary()
 323 {
 324     return writerfilter::Reference<BinaryObj>::Pointer_t();
 325 }
 326
 327 writerfilter::Reference<Stream>::Pointer_t DffRecord::getStream()
 328 {
 329     return writerfilter::Reference<Stream>::Pointer_t();
 330 }
 331
 332 writerfilter::Reference<Properties>::Pointer_t DffRecord::getProps()
 333 {
 334     return writerfilter::Reference<Properties>::Pointer_t(this->clone());
 335 }
 336
 337 string DffRecord::toString() const
 338 {
 339     char sBuffer[1024];
 340
 341     snprintf(sBuffer, sizeof(sBuffer),
 342              "<dffrecord type=\"%" SAL_PRIuUINT32 "\" instance=\"%" SAL_PRIuUINT32 "\" version=\"%" SAL_PRIuUINT32 "\">\n",
 343              getRecordType(), getInstance(), getVersion());
 344     string aResult = sBuffer;
 345
 346
 347     if (!isContainer())
 348         aResult += mSequence.toString();
 349     else
 350     {
 351         WW8StructBase::Sequence aSeq(mSequence, 0, 8);
 352         aResult += aSeq.toString();
 353     }
 354
 355     aResult += "</dffrecord>";
 356
 357     return aResult;
 358 }
 359
 360 string DffRecord::getName() const
 361 {
 362     return "";
 363 }
 364
 365 Sprm::Kind DffRecord::getKind()
 366 {
 367     return Sprm::UNKNOWN;
 368 }
 369
 370 DffBlock::DffBlock(WW8Stream & rStream, sal_uInt32 nOffset,
 371                    sal_uInt32 nCount, sal_uInt32 nPadding)
 372 : WW8StructBase(rStream, nOffset, nCount), bInitialized(false),
 373   mnPadding(nPadding)
 374 {
 375 }
 376
 377 DffBlock::DffBlock(WW8StructBase * pParent, sal_uInt32 nOffset,
 378                    sal_uInt32 nCount, sal_uInt32 nPadding)
 379 : WW8StructBase(pParent, nOffset, nCount), bInitialized(false),
 380   mnPadding(nPadding)
 381 {
 382 }
 383
 384 DffBlock::DffBlock(const DffBlock & rSrc)
 385 : WW8StructBase(rSrc), writerfilter::Reference<Properties>(rSrc),
 386   bInitialized(false), mnPadding(rSrc.mnPadding)
 387 {
 388 }
 389
 390 void DffBlock::initChildren()
 391 {
 392     sal_uInt32 nOffset = 0;
 393     sal_uInt32 nCount = getCount();
 394
 395     while (nOffset < nCount)
 396     {
 397         sal_uInt32 nSize = 0;
 398         DffRecord::Pointer_t pDffRecord
 399             (createDffRecord(this, nOffset, &nSize));
 400
 401         if (nSize == 0)
 402             break;
 403
 404         mRecords.push_back(pDffRecord);
 405
 406         nOffset +=  nSize + mnPadding;
 407     }
 408
 409     bInitialized = true;
 410 }
 411
 412 Records_t DffBlock::findRecords(sal_uInt32 nType, bool bRecursive, bool bAny)
 413 {
 414     Records_t aResult;
 415
 416     findRecords(nType, aResult, bRecursive, bAny);
 417
 418     return aResult;
 419 }
 420
 421 void DffBlock::findRecords
 422 (sal_uInt32 nType, Records_t & rRecords, bool bRecursive, bool bAny)
 423 {
 424     Records_t::iterator aIt = begin();
 425
 426     while (aIt != end())
 427     {
 428         DffRecord::Pointer_t pPointer(*aIt);
 429
 430         if (bAny || pPointer->getRecordType() == nType)
 431             rRecords.push_back(pPointer);
 432
 433         if (bRecursive)
 434             pPointer->findRecords(nType, rRecords, bRecursive,
 435                                   bAny);
 436
 437         ++aIt;
 438     }
 439 }
 440
 441 void DffBlock::resolve(Properties & rHandler)
 442 {
 443     Records_t::iterator aIt;
 444
 445     for (aIt = begin(); aIt != end(); ++aIt)
 446     {
 447         DffRecord * pDff = aIt->get();
 448         rHandler.sprm(*pDff);
 449     }
 450 }
 451
 452 DffRecord::Pointer_t DffBlock::getShape(sal_uInt32 nSpid)
 453 {
 454     DffRecord::Pointer_t pResult;
 455
 456     Records_t aRecords = findRecords(0xf004);
 457     Records_t::iterator aIt;
 458     for (aIt = aRecords.begin(); aIt != aRecords.end(); ++aIt)
 459     {
 460         DffRecord::Pointer_t pPointer = *aIt;
 461
 462         Records_t aFSPs = pPointer->findRecords(0xf00a);
 463         Records_t::iterator aItFSP = aFSPs.begin();
 464
 465         if (aItFSP != aFSPs.end())
 466         {
 467             DffFSP * pFSP = dynamic_cast<DffFSP *>((*aItFSP).get());
 468
 469             if (pFSP->get_shpid() == nSpid)
 470             {
 471                 pResult = pPointer;
 472
 473                 break;
 474             }
 475         }
 476     }
 477
 478     return pResult;
 479 }
 480
 481 DffRecord::Pointer_t DffBlock::getBlip(sal_uInt32 nBlip)
 482 {
 483     DffRecord::Pointer_t pResult;
 484
 485     if (nBlip > 0)
 486     {
 487         nBlip--;
 488
 489         Records_t aRecords = findRecords(0xf007);
 490
 491         if (nBlip < aRecords.size())
 492         {
 493             pResult = aRecords[nBlip];
 494         }
 495     }
 496
 497     return pResult;
 498 }
 499
 500 Records_t::iterator DffBlock::begin()
 501 {
 502     if (! bInitialized)
 503         initChildren();
 504
 505     return mRecords.begin();
 506 }
 507
 508 Records_t::iterator DffBlock::end()
 509 {
 510     if (! bInitialized)
 511         initChildren();
 512
 513     return mRecords.end();
 514 }
 515
 516 string DffBlock::getType() const
 517 {
 518     return "DffBlock";
 519 }
 520
 521 }}