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