writerfilter/source/doctok/WW8DocumentImpl.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: WW8DocumentImpl.cxx,v $
  10  * $Revision: 1.20 $
  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 <resourcemodel/exceptions.hxx>
  32 #include <resourcemodel/QNameToString.hxx>
  33 #include <WW8DocumentImpl.hxx>
  34 #include <WW8FKPImpl.hxx>
  35 #include <WW8PieceTableImpl.hxx>
  36 #include <WW8BinTableImpl.hxx>
  37 #include <WW8StreamImpl.hxx>
  38 #include <WW8Sttbf.hxx>
  39 #include <Dff.hxx>
  40 #include <iterator>
  41 #include <XNoteHelperImpl.hxx>
  42 #include <rtl/ustring.hxx>
  43 #include <rtl/ustrbuf.hxx>
  44 #include <doctokLoggers.hxx>
  45
  46 namespace writerfilter {
  47 namespace doctok
  48 {
  49
  50 using namespace ::std;
  51
  52 template <class T>
  53 struct PLCFHelper
  54 {
  55     static void processPLCFCpAndFcs(WW8DocumentImpl & rDoc,
  56                                     WW8PieceTable::Pointer_t pPieceTable,
  57                                     typename PLCF<T>::Pointer_t pPLCF,
  58                                     PropertyType eType,
  59                                     sal_uInt32 nOffset)
  60     {
  61         sal_uInt32 nCount = pPLCF->getEntryCount();
  62         for (sal_uInt32 n = 0; n < nCount; ++n)
  63         {
  64             Cp aCp(pPLCF->getFc(n) + nOffset);
  65             CpAndFc aCpAndFc = pPieceTable->createCpAndFc(aCp, eType);
  66
  67             rDoc.insertCpAndFc(aCpAndFc);
  68         }
  69     }
  70 };
  71
  72 // WW8DocumentIteratorImpl
  73 bool operator == (const WW8DocumentIterator & rA,
  74                   const WW8DocumentIterator & rB)
  75 {
  76     return rA.equal(rB);
  77 }
  78
  79 WW8DocumentIterator::~WW8DocumentIterator()
  80 {
  81 }
  82
  83 WW8DocumentIteratorImpl::~WW8DocumentIteratorImpl()
  84 {
  85 }
  86
  87 WW8DocumentIterator & WW8DocumentIteratorImpl::operator++()
  88 {
  89     mCpAndFc = mpDocument->getNextCp(mCpAndFc);
  90
  91     return *this;
  92 }
  93
  94 WW8DocumentIterator & WW8DocumentIteratorImpl::operator--()
  95 {
  96     mCpAndFc = mpDocument->getPrevCp(mCpAndFc);
  97
  98     return *this;
  99 }
 100
 101 bool WW8DocumentIteratorImpl::equal(const WW8DocumentIterator & rIt_) const
 102 {
 103     const WW8DocumentIteratorImpl & rIt =
 104         dynamic_cast<const WW8DocumentIteratorImpl &>(rIt_);
 105
 106     return mCpAndFc == rIt.mCpAndFc && mpDocument == rIt.mpDocument;
 107 }
 108
 109 writerfilter::Reference<Properties>::Pointer_t
 110 WW8DocumentIteratorImpl::getProperties() const
 111 {
 112     return mpDocument->getProperties(mCpAndFc);
 113 }
 114
 115 writerfilter::Reference<Stream>::Pointer_t
 116 WW8DocumentIteratorImpl::getSubDocument() const
 117 {
 118     return mpDocument->getSubDocument(mCpAndFc);
 119 }
 120
 121 WW8SED * WW8DocumentIteratorImpl::getSED() const
 122 {
 123     return mpDocument->getSED(mCpAndFc);
 124 }
 125
 126 WW8Stream::Sequence WW8DocumentIteratorImpl::getText()
 127 {
 128     return mpDocument->getText(mCpAndFc);
 129 }
 130
 131 writerfilter::Reference<Properties>::Pointer_t
 132 WW8DocumentIteratorImpl::getShape() const
 133 {
 134     return mpDocument->getShape(mCpAndFc);
 135 }
 136
 137 PropertyType WW8DocumentIteratorImpl::getPropertyType() const
 138 {
 139     return mCpAndFc.getType();
 140 }
 141
 142 bool WW8DocumentIteratorImpl::isComplex() const
 143 {
 144     return mCpAndFc.isComplex();
 145 }
 146
 147 void WW8DocumentIteratorImpl::dump(ostream & o) const
 148 {
 149     o << mCpAndFc;
 150 }
 151
 152 string WW8DocumentIteratorImpl::toString() const
 153 {
 154     return mCpAndFc.toString();
 155 }
 156
 157 // WW8DocumentImpl
 158
 159 WW8Document::~WW8Document()
 160 {
 161 }
 162
 163 class WW8IdToString : public IdToString
 164 {
 165 public:
 166     WW8IdToString() : IdToString() {}
 167     virtual ~WW8IdToString() {}
 168
 169     virtual string toString(const Id & rId) const
 170     {
 171         string s((*SprmIdToString::Instance())(rId));
 172
 173         if (s.size() == 0)
 174             s = (*QNameToString::Instance())(rId);
 175
 176         return s;
 177     }
 178 };
 179
 180 WW8DocumentImpl::~WW8DocumentImpl()
 181 {
 182 }
 183
 184 WW8DocumentImpl::WW8DocumentImpl(WW8Stream::Pointer_t rpStream)
 185 : bSubDocument(false), mfcPicLoc(0), mbPicIsData(false), mpStream(rpStream),
 186 mbInSection(false), mbInParagraphGroup(false), mbInCharacterGroup(false)
 187 {
 188     mpDocStream = getSubStream(::rtl::OUString::createFromAscii
 189                                ("WordDocument"));
 190
 191     try
 192     {
 193         mpDataStream = getSubStream(::rtl::OUString::createFromAscii
 194                                     ("Data"));
 195     }
 196     catch (ExceptionNotFound e)
 197     {
 198     }
 199
 200     try
 201     {
 202         mpCompObjStream = getSubStream(::rtl::OUString::createFromAscii
 203                                        ("\1CompObj"));
 204     }
 205     catch (ExceptionNotFound e)
 206     {
 207     }
 208
 209     mpCHPFKPCache =
 210         WW8FKPCache::Pointer_t(new WW8CHPFKPCacheImpl(mpDocStream, 5));
 211     mpPAPFKPCache =
 212         WW8FKPCache::Pointer_t(new WW8PAPFKPCacheImpl(mpDocStream, 5));
 213
 214     mpFib = WW8Fib::Pointer_t(new WW8Fib(*mpDocStream));
 215
 216     switch (mpFib->get_fWhichTblStm())
 217     {
 218     case 0:
 219         mpTableStream = getSubStream(::rtl::OUString::createFromAscii
 220                                      ("0Table"));
 221
 222         break;
 223
 224     case 1:
 225         mpTableStream = getSubStream(::rtl::OUString::createFromAscii
 226                                      ("1Table"));
 227
 228         break;
 229
 230     default:
 231         break;
 232     }
 233
 234     if (mpTableStream.get() == NULL)
 235         throw ExceptionNotFound("Table stream not found.");
 236
 237     mpPieceTable =
 238         WW8PieceTable::Pointer_t
 239         (new WW8PieceTableImpl(*mpTableStream, mpFib->get_fcClx(),
 240                                mpFib->get_lcbClx()));
 241
 242     {
 243         Cp aCp(mpPieceTable->getLastCp());
 244         Fc aFc(mpPieceTable->getLastFc());
 245         CpAndFc aCpAndFc(aCp, aFc, PROP_DOC);
 246         mCpAndFcs.insert(aCpAndFc);
 247     }
 248
 249     {
 250         Cp aCp(mpFib->get_ccpText());
 251
 252         mDocumentEndCpAndFc = CpAndFc(aCp, mpPieceTable->cp2fc(aCp),
 253                                       PROP_DOC);
 254         mCpAndFcs.insert(mDocumentEndCpAndFc);
 255
 256         aCp += mpFib->get_ccpFtn();
 257         mFootnoteEndCpAndFc = CpAndFc(aCp, mpPieceTable->cp2fc(aCp),
 258                                       PROP_DOC);
 259         mCpAndFcs.insert(mFootnoteEndCpAndFc);
 260
 261         aCp += mpFib->get_ccpHdd();
 262         mHeaderEndCpAndFc = CpAndFc(aCp, mpPieceTable->cp2fc(aCp),
 263                                     PROP_DOC);
 264         mCpAndFcs.insert(mHeaderEndCpAndFc);
 265
 266         aCp += mpFib->get_ccpAtn();
 267         mAnnotationEndCpAndFc = CpAndFc(aCp, mpPieceTable->cp2fc(aCp),
 268                                         PROP_DOC);
 269         mCpAndFcs.insert(mAnnotationEndCpAndFc);
 270
 271         aCp += mpFib->get_ccpEdn();
 272         mEndnoteEndCpAndFc = CpAndFc(aCp, mpPieceTable->cp2fc(aCp),
 273                                      PROP_DOC);
 274         mCpAndFcs.insert(mEndnoteEndCpAndFc);
 275
 276         aCp += mpFib->get_ccpTxbx();
 277         mTextboxEndCpAndFc = CpAndFc(aCp, mpPieceTable->cp2fc(aCp),
 278                                      PROP_DOC);
 279         mCpAndFcs.insert(mTextboxEndCpAndFc);
 280
 281         aCp += mpFib->get_ccpHdrTxbx();
 282         mTextboxHeaderEndCpAndFc = CpAndFc(aCp, mpPieceTable->cp2fc(aCp),
 283                                            PROP_DOC);
 284         mCpAndFcs.insert(mTextboxHeaderEndCpAndFc);
 285     }
 286
 287     mpBinTablePAPX =
 288         WW8BinTable::Pointer_t(new WW8BinTableImpl
 289                                (*mpTableStream,
 290                                 mpFib->get_fcPlcfbtePapx(),
 291                                 mpFib->get_lcbPlcfbtePapx()));
 292
 293     //clog << "BinTable(PAP):" << mpBinTablePAPX->toString();
 294
 295     parseBinTableCpAndFcs(*mpBinTablePAPX, PROP_PAP);
 296
 297     mpBinTableCHPX =
 298         WW8BinTable::Pointer_t(new WW8BinTableImpl
 299                                (*mpTableStream,
 300                                 mpFib->get_fcPlcfbteChpx(),
 301                                 mpFib->get_lcbPlcfbteChpx()));
 302
 303     //clog << "BinTable(CHP):" << mpBinTableCHPX->toString();
 304
 305     parseBinTableCpAndFcs(*mpBinTableCHPX, PROP_CHP);
 306
 307     mpSEDs = PLCF<WW8SED>::Pointer_t(new PLCF<WW8SED>
 308                                      (*mpTableStream,
 309                                       mpFib->get_fcPlcfsed(),
 310                                       mpFib->get_lcbPlcfsed()));
 311
 312     //mpSEDs->dump(clog);
 313
 314     {
 315         PLCFHelper<WW8SED>::processPLCFCpAndFcs
 316             (*this, mpPieceTable, mpSEDs, PROP_SEC, 0);
 317     }
 318
 319     sal_uInt32 nHeaders = getHeaderCount();
 320
 321     if (nHeaders > 0)
 322     {
 323         mpHeaderOffsets = WW8StructBase::Pointer_t
 324             (new WW8StructBase(*mpTableStream,
 325                                mpFib->get_fcPlcfhdd(),
 326                                mpFib->get_lcbPlcfhdd()));
 327
 328         {
 329             for (sal_uInt32 n = 0; n <= nHeaders; ++n)
 330             {
 331                 CpAndFc aCpAndFc(getHeaderCpAndFc(n));
 332
 333                 mCpAndFcs.insert(aCpAndFc);
 334             }
 335         }
 336     }
 337
 338     if (mpFib->get_lcbPlcffndTxt() > 0)
 339     {
 340         WW8StructBase::Pointer_t pCps
 341             (new WW8StructBase(*mpTableStream,
 342                                mpFib->get_fcPlcffndTxt(),
 343                                mpFib->get_lcbPlcffndTxt()));
 344
 345         PLCF<WW8FRD>::Pointer_t pRefs
 346             (new PLCF<WW8FRD>(*mpTableStream,
 347                                mpFib->get_fcPlcffndRef(),
 348                                mpFib->get_lcbPlcffndRef()));
 349
 350         mpFootnoteHelper = XNoteHelper<WW8FRD>::Pointer_t
 351             (new XNoteHelper<WW8FRD>(pCps, pRefs, mpPieceTable, this,
 352                              PROP_FOOTNOTE, getDocumentEndCp()));
 353
 354         mpFootnoteHelper->init();
 355     }
 356
 357     if (mpFib->get_lcbPlcfendTxt() > 0)
 358     {
 359         WW8StructBase::Pointer_t pCps
 360             (new WW8StructBase(*mpTableStream,
 361                                mpFib->get_fcPlcfendTxt(),
 362                                mpFib->get_lcbPlcfendTxt()));
 363
 364         PLCF<WW8FRD>::Pointer_t pRefs
 365             (new PLCF<WW8FRD>(*mpTableStream,
 366                                mpFib->get_fcPlcfendRef(),
 367                                mpFib->get_lcbPlcfendRef()));
 368
 369         mpEndnoteHelper = XNoteHelper<WW8FRD>::Pointer_t
 370             (new XNoteHelper<WW8FRD>(pCps, pRefs, mpPieceTable, this,
 371                              PROP_ENDNOTE, getAnnotationEndCp()));
 372
 373         mpEndnoteHelper->init();
 374     }
 375
 376     if (mpFib->get_lcbPlcfandTxt() > 0)
 377     {
 378         WW8StructBase::Pointer_t pCps
 379             (new WW8StructBase(*mpTableStream,
 380                                mpFib->get_fcPlcfandTxt(),
 381                                mpFib->get_lcbPlcfandTxt()));
 382
 383         PLCF<WW8ATRD>::Pointer_t pRefs
 384             (new PLCF<WW8ATRD>(*mpTableStream,
 385                                mpFib->get_fcPlcfandRef(),
 386                                mpFib->get_lcbPlcfandRef()));
 387
 388         mpAnnotationHelper = XNoteHelper<WW8ATRD>::Pointer_t
 389             (new XNoteHelper<WW8ATRD>(pCps, pRefs, mpPieceTable, this,
 390                                    PROP_ANNOTATION, getHeaderEndCp()));
 391
 392         mpAnnotationHelper->init();
 393     }
 394
 395     if (mpFib->get_lcbSttbfbkmk() > 0)
 396     {
 397         PLCF<WW8BKF>::Pointer_t pStartCps
 398             (new PLCF<WW8BKF>(*mpTableStream, mpFib->get_fcPlcfbkf(),
 399                               mpFib->get_lcbPlcfbkf()));
 400
 401         WW8StructBase::Pointer_t pEndCps
 402             (new WW8StructBase(*mpTableStream, mpFib->get_fcPlcfbkl(),
 403                                mpFib->get_lcbPlcfbkl()));
 404
 405         WW8Sttbf::Pointer_t pNames
 406             (new WW8Sttbf(*mpTableStream, mpFib->get_fcSttbfbkmk(),
 407                           mpFib->get_lcbSttbfbkmk()));
 408
 409         mpBookmarkHelper = BookmarkHelper::Pointer_t
 410             (new BookmarkHelper(pStartCps, pEndCps, pNames, mpPieceTable, this));
 411
 412         mpBookmarkHelper->init();
 413     }
 414
 415     {
 416         PLCF<WW8FLD>::Pointer_t pPlcffldMom;
 417
 418         if (mpFib->get_lcbPlcffldMom() > 0)
 419         {
 420             pPlcffldMom = PLCF<WW8FLD>::Pointer_t
 421                 (new PLCF<WW8FLD>(*mpTableStream,
 422                                   mpFib->get_fcPlcffldMom(),
 423                                   mpFib->get_lcbPlcffldMom()));
 424
 425             mpFieldHelper = FieldHelper::Pointer_t
 426                 (new FieldHelper(pPlcffldMom,
 427                                  this));
 428
 429             mpFieldHelper->init();
 430         }
 431     }
 432
 433     PLCF<WW8FSPA>::Pointer_t pPlcspaMom;
 434     if (mpFib->get_lcbPlcspaMom() > 0)
 435     {
 436         pPlcspaMom = PLCF<WW8FSPA>::Pointer_t
 437             (new PLCF<WW8FSPA>
 438              (*mpTableStream, mpFib->get_fcPlcspaMom(),
 439               mpFib->get_lcbPlcspaMom()));
 440     }
 441
 442     PLCF<WW8FSPA>::Pointer_t pPlcspaHdr;
 443     if (mpFib->get_lcbPlcspaHdr() > 0)
 444     {
 445         pPlcspaHdr = PLCF<WW8FSPA>::Pointer_t
 446             (new PLCF<WW8FSPA>
 447              (*mpTableStream, mpFib->get_fcPlcspaHdr(),
 448               mpFib->get_lcbPlcspaHdr()));
 449     }
 450
 451     mpShapeHelper = ShapeHelper::Pointer_t
 452         (new ShapeHelper(pPlcspaMom, pPlcspaHdr, this));
 453
 454     mpShapeHelper->init();
 455
 456     PLCF<WW8BKD>::Pointer_t pPlcbkdMother;
 457     if (mpFib->get_fcBkdMother() > 0 && mpFib->get_lcbBkdMother() > 0)
 458     {
 459         pPlcbkdMother = PLCF<WW8BKD>::Pointer_t
 460             (new PLCF<WW8BKD>
 461              (*mpTableStream, mpFib->get_fcBkdMother(),
 462               mpFib->get_lcbBkdMother()));
 463     }
 464
 465     mpBreakHelper = BreakHelper::Pointer_t
 466         (new BreakHelper(pPlcbkdMother, this));
 467
 468     mpBreakHelper->init();
 469
 470     if (mpFib->get_fcDggInfo() != 0 && mpFib->get_lcbDggInfo() > 0)
 471     {
 472         mpDffBlock = DffBlock::Pointer_t
 473             (new DffBlock(*mpTableStream, mpFib->get_fcDggInfo(),
 474                          mpFib->get_lcbDggInfo(), 1));
 475
 476         mpDffBlock->setDocument(this);
 477     }
 478
 479     if (mpFib->get_lcbPlcftxbxTxt() > 0)
 480     {
 481         mpTextBoxStories = PLCF<WW8FTXBXS>::Pointer_t
 482             (new PLCF<WW8FTXBXS>(*mpTableStream,
 483                                  mpFib->get_fcPlcftxbxTxt(),
 484                                  mpFib->get_lcbPlcftxbxTxt()));
 485
 486         PLCFHelper<WW8FTXBXS>::processPLCFCpAndFcs
 487             (*this, mpPieceTable, mpTextBoxStories, PROP_DOC,
 488              mEndnoteEndCpAndFc.getCp().get());
 489     }
 490
 491     if (mCpAndFcs.size() > 0)
 492     {
 493         mCpAndFcStart = *mCpAndFcs.begin();
 494         mCpAndFcEnd = getDocumentEndCp();
 495     }
 496 }
 497
 498 bool WW8DocumentImpl::isSpecial(sal_uInt32 nChar)
 499 {
 500     bool bResult = false;
 501
 502     if (nChar <= 8)
 503         bResult = true;
 504     else if (nChar >= 10)
 505     {
 506         if (nChar == 12)
 507             bResult= true;
 508         else if (nChar <= 16)
 509             bResult = true;
 510         else if (nChar >= 22)
 511         {
 512             if (nChar <= 30)
 513                 bResult = true;
 514             else if (nChar >= 33)
 515             {
 516                 if (nChar <= 39)
 517                     bResult = true;
 518                 else if (nChar == 41)
 519                     bResult = true;
 520             }
 521         }
 522     }
 523
 524     return bResult;
 525 }
 526
 527 WW8DocumentImpl::WW8DocumentImpl(const WW8DocumentImpl & rSrc,
 528                                  const CpAndFc & rStart, const CpAndFc & rEnd)
 529 : bSubDocument(true), mfcPicLoc(0), mbPicIsData(false)
 530 {
 531     Assign(rSrc);
 532
 533     mCpAndFcStart = rStart;
 534     mCpAndFcEnd = rEnd;
 535 }
 536
 537 WW8DocumentImpl & WW8DocumentImpl::Assign(const WW8DocumentImpl & rSrc)
 538 {
 539     mCpAndFcs = rSrc.mCpAndFcs;
 540
 541     mpCHPFKPCache = rSrc.mpCHPFKPCache;
 542     mpPAPFKPCache = rSrc.mpPAPFKPCache;
 543
 544     mpStream = rSrc.mpStream;
 545     mpTableStream = rSrc.mpTableStream;
 546     mpDataStream = rSrc.mpDataStream;
 547     mpDocStream = rSrc.mpDocStream;
 548     mpCompObjStream = rSrc.mpCompObjStream;
 549
 550     mpPieceTable = rSrc.mpPieceTable;
 551
 552     mpBinTableCHPX = rSrc.mpBinTableCHPX;
 553     mpBinTablePAPX = rSrc.mpBinTablePAPX;
 554
 555     mpSEDs = rSrc.mpSEDs;
 556
 557     mpFib = rSrc.mpFib;
 558
 559     mpHeaderOffsets = rSrc.mpHeaderOffsets;
 560     mpFootnoteHelper = rSrc.mpFootnoteHelper;
 561     mpEndnoteHelper = rSrc.mpEndnoteHelper;
 562     mpAnnotationHelper = rSrc.mpAnnotationHelper;
 563     mpShapeHelper = rSrc.mpShapeHelper;
 564     mpBreakHelper = rSrc.mpBreakHelper;
 565
 566     mpBookmarkHelper = rSrc.mpBookmarkHelper;
 567
 568     mpDffBlock = rSrc.mpDffBlock;
 569     mpTextBoxStories = rSrc.mpTextBoxStories;
 570
 571     mDocumentEndCpAndFc = rSrc.mDocumentEndCpAndFc;
 572     mFootnoteEndCpAndFc = rSrc.mFootnoteEndCpAndFc;
 573
 574     return *this;
 575 }
 576
 577 string WW8DocumentImpl::getType() const
 578 {
 579     return "WW8DocumentImpl";
 580 }
 581
 582 void WW8DocumentImpl::parseBinTableCpAndFcs(WW8BinTable & rTable,
 583                                             PropertyType eType_)
 584 {
 585     //clog << "<bintable type=\"" << propertyTypeToString(eType_) << "\">" << endl;
 586     for (sal_uInt32 i = 0; i < rTable.getEntryCount(); i++)
 587     {
 588 #if 0
 589         char sBuffer[255];
 590         snprintf(sBuffer, 255, "%ld", i);
 591         char sBufferPageNum[255];
 592         snprintf(sBufferPageNum, 255, "%ld", rTable.getPageNumber(i));
 593 #endif
 594         Fc aFcFromTable(rTable.getFc(i));
 595
 596         if (aFcFromTable < mpPieceTable->getFirstFc())
 597             aFcFromTable = mpPieceTable->getFirstFc();
 598
 599         bool bComplex = mpPieceTable->isComplex(aFcFromTable);
 600         aFcFromTable.setComplex(bComplex);
 601
 602         //clog << "<entry fc=\"" << aFcFromTable.toString() << "\">" << endl;
 603
 604         try
 605         {
 606             Cp aCpFromTable(mpPieceTable->fc2cp(aFcFromTable));
 607             CpAndFc aCpAndFcFromTable(aCpFromTable, aFcFromTable, eType_);
 608
 609             mCpAndFcs.insert(aCpAndFcFromTable);
 610
 611             WW8FKP::Pointer_t pFKP;
 612
 613             switch (eType_)
 614             {
 615             case PROP_CHP:
 616                 pFKP = getFKPCHPX(rTable.getPageNumber(i),
 617                                   aCpAndFcFromTable.isComplex());
 618
 619                 break;
 620
 621             case PROP_PAP:
 622                 pFKP = getFKPPAPX(rTable.getPageNumber(i),
 623                                   aCpAndFcFromTable.isComplex());
 624
 625                 break;
 626             default:
 627                 break;
 628             }
 629
 630             for (sal_uInt32 n = 0; n < pFKP->getEntryCount(); n++)
 631             {
 632                 Fc aFc = pFKP->getFc(n);
 633
 634                 if (aFc < mpPieceTable->getFirstFc())
 635                     aFc = mpPieceTable->getFirstFc();
 636
 637                 bool bComplexFKP = mpPieceTable->isComplex(aFc);
 638                 aFc.setComplex(bComplexFKP);
 639
 640                 //clog << "<fkpentry fc=\"" << aFc.toString() << "\"/>" << endl;
 641
 642                 try
 643                 {
 644                     Cp aCp = mpPieceTable->fc2cp(aFc);
 645
 646                     CpAndFc aCpAndFc(aCp, aFc, eType_);
 647
 648                     mCpAndFcs.insert(aCpAndFc);
 649
 650                     //clog << aCpAndFc << endl;
 651                 }
 652                 catch (ExceptionNotFound e)
 653                 {
 654                     clog << e.getText() << endl;
 655                 }
 656             }
 657         }
 658         catch (ExceptionNotFound e)
 659         {
 660             clog << e.getText() << endl;
 661         }
 662
 663         //clog << "</entry>" << endl;
 664     }
 665
 666     //clog << "</bintable>" << endl;
 667 }
 668
 669 WW8Stream::Pointer_t WW8DocumentImpl::getSubStream
 670 (const ::rtl::OUString & sId) const
 671 {
 672     return mpStream->getSubStream(sId);
 673 }
 674
 675 WW8Document::Pointer_t WW8DocumentImpl::getSubDocument(SubDocumentId /*nId*/)
 676 {
 677     return WW8Document::Pointer_t(new WW8DocumentImpl(*this));
 678 }
 679
 680 WW8DocumentIterator::Pointer_t
 681 WW8DocumentImpl::getIterator(const CpAndFc & rCpAndFc)
 682 {
 683     return WW8DocumentIterator::Pointer_t
 684         (new WW8DocumentIteratorImpl(this, rCpAndFc));
 685 }
 686
 687 WW8DocumentIterator::Pointer_t WW8DocumentImpl::begin()
 688 {
 689     return getIterator(getFirstCp());
 690 }
 691
 692 WW8DocumentIterator::Pointer_t WW8DocumentImpl::end()
 693 {
 694     return getIterator(getLastCp());
 695 }
 696
 697 WW8Stream::Pointer_t WW8DocumentImpl::getDocStream() const
 698 {
 699     return mpDocStream;
 700 }
 701
 702 WW8Stream::Pointer_t WW8DocumentImpl::getDataStream() const
 703 {
 704     return mpDataStream;
 705 }
 706
 707 sal_uInt32 WW8DocumentImpl::getByteLength(const CpAndFc & rCpAndFc) const
 708 {
 709     CpAndFc aEnd = getNextCp(rCpAndFc);
 710
 711     sal_uInt32 nResult = 3;
 712
 713     if (rCpAndFc < aEnd)
 714         nResult = (aEnd - rCpAndFc) *
 715             (mpPieceTable->isComplex(rCpAndFc.getCp()) ? 1 : 2);
 716
 717     return nResult;
 718 }
 719
 720 WW8Stream::Sequence
 721 WW8DocumentImpl::getText(const CpAndFc & rStart)
 722 {
 723     return mpDocStream->get(rStart.getFc().get(), getByteLength(rStart));
 724 }
 725
 726 const CpAndFc & WW8DocumentImpl::getFirstCp() const
 727 {
 728     return mCpAndFcStart;
 729 }
 730
 731 const CpAndFc & WW8DocumentImpl::getLastCp() const
 732 {
 733     return mCpAndFcEnd;
 734 }
 735
 736 CpAndFc WW8DocumentImpl::getDocumentEndCp() const
 737 {
 738     return mDocumentEndCpAndFc;
 739 }
 740
 741 CpAndFc WW8DocumentImpl::getFootnodeEndCp() const
 742 {
 743     return mFootnoteEndCpAndFc;
 744 }
 745
 746 CpAndFc WW8DocumentImpl::getHeaderEndCp() const
 747 {
 748     return mHeaderEndCpAndFc;
 749 }
 750
 751 CpAndFc WW8DocumentImpl::getAnnotationEndCp() const
 752 {
 753     return mAnnotationEndCpAndFc;
 754 }
 755
 756 CpAndFc WW8DocumentImpl::getEndnoteEndCp() const
 757 {
 758     return mEndnoteEndCpAndFc;
 759 }
 760
 761 CpAndFc WW8DocumentImpl::getTextboxEndCp() const
 762 {
 763     return mTextboxEndCpAndFc;
 764 }
 765
 766 CpAndFc WW8DocumentImpl::getTextboxHeaderEndCp() const
 767 {
 768     return mTextboxHeaderEndCpAndFc;
 769 }
 770
 771 CpAndFc WW8DocumentImpl::getNextCp(const CpAndFc & rCpAndFc) const
 772 {
 773     CpAndFc aResult = mCpAndFcEnd;
 774     CpAndFcs::const_iterator aIt = mCpAndFcs.find(rCpAndFc);
 775
 776     if (aIt != mCpAndFcs.end())
 777     {
 778         aIt++;
 779
 780         if (aIt != mCpAndFcs.end())
 781             aResult = *aIt;
 782     }
 783     else
 784         throw ExceptionNotFound("getNextCp: " + rCpAndFc.toString());
 785
 786     return aResult;
 787 }
 788
 789 CpAndFc WW8DocumentImpl::getPrevCp(const CpAndFc & rCpAndFc) const
 790 {
 791     CpAndFc aResult = mCpAndFcStart;
 792
 793     CpAndFcs::const_iterator aIt = mCpAndFcs.find(CpAndFc(rCpAndFc));
 794
 795     if (aIt != mCpAndFcs.end() && aIt != mCpAndFcs.begin())
 796     {
 797         aIt--;
 798
 799         aResult = *aIt;
 800     }
 801     else
 802         throw ExceptionNotFound("getPrevCp: " + rCpAndFc.toString());
 803
 804     return aResult;
 805 }
 806
 807 WW8FKP::Pointer_t WW8DocumentImpl::getFKP(const CpAndFc & rCpAndFc)
 808 {
 809     WW8FKP::Pointer_t pResult;
 810
 811     sal_uInt32 nPageNumber = 0;
 812
 813     switch (rCpAndFc.getType())
 814     {
 815     case PROP_PAP:
 816         {
 817             nPageNumber =
 818                 mpBinTablePAPX->getPageNumber(rCpAndFc.getFc());
 819
 820             pResult = getFKPPAPX(nPageNumber, rCpAndFc.isComplex());
 821         }
 822         break;
 823     case PROP_CHP:
 824         {
 825             nPageNumber =
 826                 mpBinTableCHPX->getPageNumber(rCpAndFc.getFc());
 827
 828             pResult = getFKPCHPX(nPageNumber, rCpAndFc.isComplex());
 829         }
 830         break;
 831     default:
 832         break;
 833     }
 834
 835     if (pResult.get() != NULL)
 836         pResult->setDocument(this);
 837
 838     return pResult;
 839 }
 840
 841 WW8FKP::Pointer_t WW8DocumentImpl::getFKPCHPX(sal_uInt32 nIndex,
 842                                               bool bComplex)
 843 {
 844     return mpCHPFKPCache->get(nIndex, bComplex);
 845 }
 846
 847 WW8FKP::Pointer_t WW8DocumentImpl::getFKPPAPX(sal_uInt32 nIndex,
 848                                               bool bComplex)
 849 {
 850     return mpPAPFKPCache->get(nIndex, bComplex);
 851 }
 852
 853 writerfilter::Reference<Properties>::Pointer_t WW8DocumentImpl::getProperties
 854 (const CpAndFc & rCpAndFc)
 855 {
 856     writerfilter::Reference<Properties>::Pointer_t pResult;
 857
 858     switch (rCpAndFc.getType())
 859     {
 860     case PROP_CHP:
 861     case PROP_PAP:
 862         {
 863             try
 864             {
 865                 WW8FKP::Pointer_t pFKP = getFKP(rCpAndFc);
 866
 867                 pResult = pFKP->getProperties(rCpAndFc.getFc());
 868             }
 869             catch (ExceptionOutOfBounds e)
 870             {
 871             }
 872         }
 873
 874         break;
 875
 876     case PROP_SEC:
 877         {
 878             pResult = writerfilter::Reference<Properties>::Pointer_t
 879                 (getSED(rCpAndFc));
 880         }
 881
 882         break;
 883
 884     case PROP_FOOTNOTE:
 885         {
 886             pResult = writerfilter::Reference<Properties>::Pointer_t
 887                 (mpFootnoteHelper->getRef(rCpAndFc));
 888         }
 889         break;
 890
 891     case PROP_ENDNOTE:
 892         {
 893             pResult = writerfilter::Reference<Properties>::Pointer_t
 894                 (mpEndnoteHelper->getRef(rCpAndFc));
 895         }
 896         break;
 897
 898     case PROP_ANNOTATION:
 899         {
 900             pResult = writerfilter::Reference<Properties>::Pointer_t
 901                 (mpAnnotationHelper->getRef(rCpAndFc));
 902         }
 903         break;
 904
 905     case PROP_BOOKMARKSTART:
 906     case PROP_BOOKMARKEND:
 907         {
 908             pResult = getBookmark(rCpAndFc);
 909         }
 910
 911         break;
 912     case PROP_FLD:
 913         {
 914             pResult = getField(rCpAndFc);
 915
 916             mpFLD = mpFieldHelper->getWW8FLD(rCpAndFc);
 917         }
 918
 919         break;
 920     case PROP_SHP:
 921         {
 922             pResult = getShape(rCpAndFc);
 923         }
 924         break;
 925     case PROP_BRK:
 926         {
 927             pResult = getBreak(rCpAndFc);
 928         }
 929         break;
 930     default:
 931         break;
 932     }
 933
 934     return pResult;
 935 }
 936
 937 writerfilter::Reference<Stream>::Pointer_t
 938 WW8DocumentImpl::getSubDocument(const CpAndFc & rCpAndFc)
 939 {
 940     writerfilter::Reference<Stream>::Pointer_t pResult;
 941
 942     switch (rCpAndFc.getType())
 943     {
 944     case PROP_FOOTNOTE:
 945         pResult = getFootnote(rCpAndFc);
 946         break;
 947
 948     case PROP_ENDNOTE:
 949         pResult = getEndnote(rCpAndFc);
 950         break;
 951
 952     case PROP_ANNOTATION:
 953         pResult = getAnnotation(rCpAndFc);
 954         break;
 955
 956     default:
 957         break;
 958     }
 959
 960     return pResult;
 961 }
 962
 963 WW8SED * WW8DocumentImpl::getSED(const CpAndFc & rCpAndFc) const
 964 {
 965     WW8SED * pResult = mpSEDs->getEntryByFc(rCpAndFc.getCp().get());
 966
 967     pResult->setDoc(const_cast<const WW8DocumentImpl *>(this));
 968
 969     return pResult;
 970 }
 971
 972 writerfilter::Reference<Table>::Pointer_t WW8DocumentImpl::getListTable() const
 973 {
 974     writerfilter::Reference<Table>::Pointer_t pResult;
 975
 976     if (mpFib->get_fcPlcfLst() != 0 && mpFib->get_lcbPlcfLst() > 0)
 977     {
 978         WW8ListTable * pList = new WW8ListTable(*mpTableStream,
 979                                                 mpFib->get_fcPlcfLst(),
 980                                                 mpFib->get_fcPlfLfo() -
 981                                                 mpFib->get_fcPlcfLst());
 982
 983         pList->setPayloadOffset(mpFib->get_lcbPlcfLst());
 984         pList->initPayload();
 985
 986         pResult = writerfilter::Reference<Table>::Pointer_t(pList);
 987     }
 988
 989     return pResult;
 990 }
 991
 992 writerfilter::Reference<Table>::Pointer_t WW8DocumentImpl::getLFOTable() const
 993 {
 994     writerfilter::Reference<Table>::Pointer_t pResult;
 995
 996     if (mpFib->get_fcPlfLfo() != 0 && mpFib->get_lcbPlfLfo() > 0)
 997     {
 998         try
 999         {
1000             WW8LFOTable * pLFOs = new WW8LFOTable(*mpTableStream,
1001                                                   mpFib->get_fcPlfLfo(),
1002                                                   mpFib->get_lcbPlfLfo());
1003
1004             pLFOs->setPayloadOffset(mpFib->get_lcbPlcfLst());
1005             pLFOs->initPayload();
1006
1007             pResult = writerfilter::Reference<Table>::Pointer_t(pLFOs);
1008         }
1009         catch (Exception e)
1010         {
1011             clog << e.getText() << endl;
1012         }
1013     }
1014
1015     return pResult;
1016 }
1017
1018 writerfilter::Reference<Table>::Pointer_t WW8DocumentImpl::getFontTable() const
1019 {
1020     writerfilter::Reference<Table>::Pointer_t pResult;
1021
1022     if (mpFib->get_fcSttbfffn() != 0 && mpFib->get_lcbSttbfffn() > 0)
1023     {
1024         WW8FontTable * pFonts = new WW8FontTable(*mpTableStream,
1025                                                  mpFib->get_fcSttbfffn(),
1026                                                  mpFib->get_lcbSttbfffn());
1027
1028         pFonts->initPayload();
1029
1030         pResult = writerfilter::Reference<Table>::Pointer_t(pFonts);
1031     }
1032
1033     return pResult;
1034 }
1035
1036 writerfilter::Reference<Table>::Pointer_t WW8DocumentImpl::getStyleSheet() const
1037 {
1038     writerfilter::Reference<Table>::Pointer_t pResult;
1039
1040     if (mpFib->get_lcbStshf() > 0)
1041     {
1042         WW8StyleSheet * pStyles = new WW8StyleSheet(*mpTableStream,
1043                                                     mpFib->get_fcStshf(),
1044                                                     mpFib->get_lcbStshf());
1045
1046         pStyles->initPayload();
1047
1048         pResult = writerfilter::Reference<Table>::Pointer_t(pStyles);
1049     }
1050
1051     return pResult;
1052 }
1053
1054 sal_uInt32 WW8DocumentImpl::getHeaderCount() const
1055 {
1056     sal_uInt32 nResult = 0;
1057     sal_uInt32 nLcbPlcfhdd = mpFib->get_lcbPlcfhdd();
1058
1059     if (nLcbPlcfhdd > 4)
1060         nResult = (nLcbPlcfhdd / 4) - 1;
1061
1062     return nResult;
1063 }
1064
1065 CpAndFc WW8DocumentImpl::getHeaderCpAndFc(sal_uInt32 nPos)
1066 {
1067     sal_uInt32 nCount = getHeaderCount();
1068
1069     // There are getHeaderCount() + 1 entries in mpHeaderOffsets => greater
1070     if (nPos > nCount)
1071         throw ExceptionNotFound("getHeaderCpAndFc");
1072
1073     if (nPos == nCount)
1074         return mHeaderEndCpAndFc;
1075     else
1076     {
1077         Cp aCp(getFootnodeEndCp().getCp() + mpHeaderOffsets->getU32(nPos * 4));
1078         Fc aFc(mpPieceTable->cp2fc(aCp));
1079         CpAndFc aCpAndFc(aCp, aFc, PROP_DOC);
1080
1081         return aCpAndFc;
1082     }
1083
1084 }
1085
1086 writerfilter::Reference<Stream>::Pointer_t WW8DocumentImpl::getHeader(sal_uInt32 nPos)
1087 {
1088     // There are getHeaderCount() headers => greater or equal
1089     if (nPos >= getHeaderCount())
1090         throw ExceptionNotFound("getHeader");
1091
1092     writerfilter::Reference<Stream>::Pointer_t pResult;
1093
1094     CpAndFc aCpAndFcStart(getHeaderCpAndFc(nPos));
1095     CpAndFc aCpAndFcEnd(getHeaderCpAndFc(nPos + 1));
1096
1097 #if 0
1098     sal_uInt32 nEquals = 1;
1099     while (aCpAndFcEnd == aCpAndFcStart && nPos + nEquals < getHeaderCount())
1100     {
1101         ++nEquals;
1102
1103         aCpAndFcEnd = getHeaderCpAndFc(nPos + nEquals);
1104     }
1105 #endif
1106
1107     if (aCpAndFcStart < aCpAndFcEnd)
1108         pResult = writerfilter::Reference<Stream>::Pointer_t
1109             (new WW8DocumentImpl(*this, aCpAndFcStart, aCpAndFcEnd));
1110
1111     return pResult;
1112 }
1113
1114 sal_uInt32 WW8DocumentImpl::getFootnoteCount() const
1115 {
1116     return (mpFootnoteHelper.get() != NULL) ? mpFootnoteHelper->getCount() : 0;
1117 }
1118
1119 writerfilter::Reference<Stream>::Pointer_t
1120 WW8DocumentImpl::getFootnote(sal_uInt32 nPos)
1121 {
1122     writerfilter::Reference<Stream>::Pointer_t pResult;
1123
1124     if (! bSubDocument)
1125         pResult = mpFootnoteHelper->get(nPos);
1126
1127     return pResult;
1128 }
1129
1130 writerfilter::Reference<Stream>::Pointer_t
1131 WW8DocumentImpl::getFootnote(const CpAndFc & rCpAndFc)
1132 {
1133     writerfilter::Reference<Stream>::Pointer_t pResult;
1134
1135     if (! bSubDocument)
1136         pResult = mpFootnoteHelper->get(rCpAndFc);
1137
1138     return pResult;
1139 }
1140
1141 sal_uInt32 WW8DocumentImpl::getEndnoteCount() const
1142 {
1143     return mpEndnoteHelper.get() != NULL ? mpEndnoteHelper->getCount() : 0;
1144 }
1145
1146 writerfilter::Reference<Stream>::Pointer_t
1147 WW8DocumentImpl::getEndnote(sal_uInt32 nPos)
1148 {
1149     writerfilter::Reference<Stream>::Pointer_t pResult;
1150
1151     if (! bSubDocument)
1152         pResult = mpEndnoteHelper->get(nPos);
1153
1154     return pResult;
1155 }
1156
1157 writerfilter::Reference<Stream>::Pointer_t
1158 WW8DocumentImpl::getEndnote(const CpAndFc & rCpAndFc)
1159 {
1160     writerfilter::Reference<Stream>::Pointer_t pResult;
1161
1162     if (! bSubDocument)
1163         pResult = mpEndnoteHelper->get(rCpAndFc);
1164
1165     return pResult;
1166 }
1167
1168 sal_uInt32 WW8DocumentImpl::getAnnotationCount() const
1169 {
1170     return mpAnnotationHelper.get() != NULL ?
1171         mpAnnotationHelper->getCount() : 0;
1172 }
1173
1174 writerfilter::Reference<Stream>::Pointer_t
1175 WW8DocumentImpl::getAnnotation(sal_uInt32 nPos)
1176 {
1177     writerfilter::Reference<Stream>::Pointer_t pResult;
1178
1179     if (! bSubDocument)
1180         pResult = mpAnnotationHelper->get(nPos);
1181
1182     return pResult;
1183 }
1184
1185 writerfilter::Reference<Stream>::Pointer_t
1186 WW8DocumentImpl::getAnnotation(const CpAndFc & rCpAndFc)
1187 {
1188     writerfilter::Reference<Stream>::Pointer_t pResult;
1189
1190     if (! bSubDocument)
1191         pResult = mpAnnotationHelper->get(rCpAndFc);
1192
1193     return pResult;
1194 }
1195
1196 writerfilter::Reference<Properties>::Pointer_t
1197 WW8DocumentImpl::getBookmark(const CpAndFc & rCpAndFc) const
1198 {
1199     return mpBookmarkHelper->getBookmark(rCpAndFc);
1200 }
1201
1202 writerfilter::Reference<Properties>::Pointer_t
1203 WW8DocumentImpl::getShape(const CpAndFc & rCpAndFc) const
1204 {
1205     return mpShapeHelper->getShape(rCpAndFc);
1206 }
1207
1208 writerfilter::Reference<Properties>::Pointer_t
1209 WW8DocumentImpl::getShape(sal_uInt32 nSpid)
1210 {
1211     writerfilter::Reference<Properties>::Pointer_t pResult;
1212     DffRecord::Pointer_t pShape = mpDffBlock->getShape(nSpid);
1213
1214     if (pShape.get() != NULL)
1215     {
1216         DffSpContainer * pTmp = new DffSpContainer(*pShape);
1217         pTmp->setDocument(this);
1218
1219         pResult = writerfilter::Reference<Properties>::Pointer_t(pTmp);
1220     }
1221
1222     return pResult;
1223 }
1224
1225 writerfilter::Reference<Properties>::Pointer_t
1226 WW8DocumentImpl::getBreak(const CpAndFc & rCpAndFc) const
1227 {
1228     return mpBreakHelper->getBreak(rCpAndFc);
1229 }
1230
1231 writerfilter::Reference<Properties>::Pointer_t
1232 WW8DocumentImpl::getBlip(sal_uInt32 nBid)
1233 {
1234     writerfilter::Reference<Properties>::Pointer_t pResult;
1235
1236     if (mpDffBlock != NULL)
1237     {
1238         DffRecord::Pointer_t pDffRecord(mpDffBlock->getBlip(nBid));
1239
1240         if (pDffRecord.get() != NULL)
1241         {
1242             DffBSE * pBlip = new DffBSE(*pDffRecord);
1243
1244             if (pBlip != NULL)
1245             pResult = writerfilter::Reference<Properties>::Pointer_t(pBlip);
1246         }
1247     }
1248
1249     return pResult;
1250 }
1251
1252 writerfilter::Reference<Properties>::Pointer_t
1253 WW8DocumentImpl::getField(const CpAndFc & rCpAndFc) const
1254 {
1255     return mpFieldHelper->getField(rCpAndFc);
1256 }
1257
1258 WW8FLD::Pointer_t WW8DocumentImpl::getCurrentFLD() const
1259 {
1260     return mpFLD;
1261 }
1262
1263 sal_uInt32 WW8DocumentImpl::getPicLocation() const
1264 {
1265     return mfcPicLoc;
1266 }
1267
1268 void WW8DocumentImpl::setPicLocation(sal_uInt32 fcPicLoc)
1269 {
1270     mfcPicLoc = fcPicLoc;
1271 }
1272
1273 bool WW8DocumentImpl::isPicData()
1274 {
1275     return mbPicIsData;
1276 }
1277
1278 void WW8DocumentImpl::setPicIsData(bool bPicIsData)
1279 {
1280     mbPicIsData = bPicIsData;
1281 }
1282
1283 writerfilter::Reference<Stream>::Pointer_t
1284 WW8DocumentImpl::getTextboxText(sal_uInt32 nShpId) const
1285 {
1286     writerfilter::Reference<Stream>::Pointer_t pResult;
1287
1288     if (mpTextBoxStories.get() != NULL)
1289     {
1290         sal_uInt32 nCount = mpTextBoxStories->getEntryCount();
1291
1292         sal_uInt32 n = 0;
1293         while (n < nCount)
1294         {
1295             WW8FTXBXS * pTextboxStory = mpTextBoxStories->getEntryPointer(n);
1296
1297             if (pTextboxStory->get_lid() == nShpId)
1298                 break;
1299
1300             ++n;
1301         }
1302
1303         if (n < nCount)
1304         {
1305             Cp aCpStart(mpTextBoxStories->getFc(n));
1306             aCpStart += getEndnoteEndCp().getCp().get();
1307             CpAndFc aCpAndFcStart =
1308                 mpPieceTable->createCpAndFc(aCpStart, PROP_DOC);
1309             Cp aCpEnd(mpTextBoxStories->getFc(n + 1));
1310             aCpEnd += getEndnoteEndCp().getCp().get();
1311             CpAndFc aCpAndFcEnd = mpPieceTable->createCpAndFc(aCpEnd, PROP_DOC);
1312
1313             pResult = writerfilter::Reference<Stream>::Pointer_t
1314                 (new WW8DocumentImpl(*this, aCpAndFcStart, aCpAndFcEnd));
1315         }
1316     }
1317
1318     return pResult;
1319 }
1320
1321 Id lcl_headerQName(sal_uInt32 nIndex)
1322 {
1323     Id qName = NS_rtf::LN_header;
1324
1325     if (nIndex > 5)
1326     {
1327         switch ((nIndex - 6) % 6)
1328         {
1329         case 0:
1330             qName = NS_rtf::LN_headerl;
1331
1332             break;
1333         case 1:
1334             qName = NS_rtf::LN_headerr;
1335
1336             break;
1337         case 2:
1338             qName = NS_rtf::LN_footerl;
1339
1340             break;
1341         case 3:
1342             qName = NS_rtf::LN_footerr;
1343
1344             break;
1345         case 4:
1346             qName = NS_rtf::LN_headerf;
1347
1348             break;
1349         case 5:
1350             qName = NS_rtf::LN_footerf;
1351
1352             break;
1353         }
1354     }
1355
1356     return qName;
1357 }
1358
1359 Fc WW8DocumentImpl::cp2fc(const Cp & cp) const
1360 {
1361     return mpPieceTable->cp2fc(cp);
1362 }
1363
1364 Cp WW8DocumentImpl::fc2cp(const Fc & fc) const
1365 {
1366     return mpPieceTable->fc2cp(fc);
1367 }
1368
1369 CpAndFc WW8DocumentImpl::getCpAndFc(const Cp & cp, PropertyType type) const
1370 {
1371     Fc aFc = cp2fc(cp);
1372
1373     return CpAndFc(cp, aFc, type);
1374 }
1375
1376 CpAndFc WW8DocumentImpl::getCpAndFc(const Fc & fc, PropertyType type) const
1377 {
1378     Cp aCp = fc2cp(fc);
1379
1380     return CpAndFc(aCp, fc, type);
1381 }
1382
1383 void WW8DocumentImpl::resolvePicture(Stream & rStream)
1384 {
1385     WW8Stream::Pointer_t pStream = getDataStream();
1386
1387     if (pStream.get() != NULL)
1388     {
1389         WW8StructBase aStruct(*pStream, mfcPicLoc, 4);
1390         sal_uInt32 nCount = aStruct.getU32(0);
1391
1392         {
1393             WW8PICF * pPicf = new WW8PICF(*pStream, mfcPicLoc, nCount);
1394             pPicf->setDocument(this);
1395
1396             writerfilter::Reference<Properties>::Pointer_t pProps(pPicf);
1397
1398             rStream.props(pProps);
1399         }
1400     }
1401 }
1402
1403 void WW8DocumentImpl::resolveSpecialChar(sal_uInt32 nChar, Stream & rStream)
1404 {
1405     switch (nChar)
1406     {
1407     case 0x1:
1408         resolvePicture(rStream);
1409         break;
1410     default:
1411         break;
1412     }
1413 }
1414
1415 void WW8DocumentImpl::text(Stream & rStream, const sal_uInt8 * data, size_t len)
1416 {
1417 #ifdef DEBUG_ELEMENT
1418     ::rtl::OUString sText( (const sal_Char*) data, len, RTL_TEXTENCODING_MS_1252 );
1419     debug_logger->startElement("text");
1420     debug_logger->chars(OUStringToOString(sText, RTL_TEXTENCODING_ASCII_US).getStr());
1421     debug_logger->endElement("text");
1422 #endif
1423     rStream.text(data, len);
1424 }
1425
1426 void WW8DocumentImpl::utext(Stream & rStream, const sal_uInt8 * data, size_t len)
1427 {
1428 #ifdef DEBUG_ELEMENT
1429     debug_logger->startElement("utext");
1430
1431     ::rtl::OUString sText;
1432     ::rtl::OUStringBuffer aBuffer = ::rtl:: OUStringBuffer(len);
1433     aBuffer.append( (const sal_Unicode *) data, len);
1434     sText = aBuffer.makeStringAndClear();
1435
1436     debug_logger->chars(OUStringToOString(sText, RTL_TEXTENCODING_ASCII_US).getStr());
1437     debug_logger->endElement("utext");
1438 #endif
1439     rStream.text(data, len);
1440 }
1441
1442
1443 void WW8DocumentImpl::resolveText(WW8DocumentIterator::Pointer_t pIt,
1444                                   Stream & rStream)
1445 {
1446     WW8Stream::Sequence aSeq = pIt->getText();
1447
1448     sal_uInt32 nCount = aSeq.getCount();
1449     bool bComplex = pIt->isComplex();
1450
1451     /*
1452       Assumption: Special characters are always at the beginning or end of a
1453       run.
1454      */
1455     if (nCount > 0)
1456     {
1457         if (nCount == 1)
1458             bComplex = true;
1459
1460         if (bComplex)
1461         {
1462             sal_uInt32 nStartIndex = 0;
1463             sal_uInt32 nEndIndex = nCount - 1;
1464
1465             sal_uInt32 nCharFirst = aSeq[0];
1466             sal_uInt32 nCharLast = aSeq[nEndIndex];
1467
1468             if (isSpecial(nCharFirst))
1469             {
1470                 nStartIndex += 1;
1471                 resolveSpecialChar(nCharFirst, rStream);
1472                 text(rStream, &aSeq[0], 1);
1473             }
1474
1475             if (!isSpecial(nCharLast))
1476                 nEndIndex += 1;
1477
1478             if (nStartIndex < nEndIndex)
1479             {
1480                 sal_uInt32 nChars = nEndIndex - nStartIndex;
1481                 text(rStream, &aSeq[nStartIndex], nChars);
1482
1483                 if (isSpecial(nCharLast))
1484                 {
1485                     resolveSpecialChar(nCharLast, rStream);
1486                     text(rStream, &aSeq[nEndIndex], 1);
1487                 }
1488             }
1489         }
1490         else
1491         {
1492             sal_uInt32 nStartIndex = 0;
1493             sal_uInt32 nEndIndex = nCount - 2;
1494
1495             sal_uInt32 nCharFirst = aSeq[0] + (aSeq[1] << 8);
1496             sal_uInt32 nCharLast = aSeq[nEndIndex] + (aSeq[nEndIndex + 1]);
1497
1498             if (isSpecial(nCharFirst))
1499             {
1500                 nStartIndex += 2;
1501                 resolveSpecialChar(nCharFirst, rStream);
1502                 utext(rStream, &aSeq[0], 1);
1503             }
1504
1505             if (!isSpecial(nCharLast))
1506                 nEndIndex += 2;
1507
1508             if (nStartIndex < nEndIndex)
1509             {
1510                 sal_uInt32 nChars = (nEndIndex - nStartIndex) / 2;
1511                 utext(rStream, &aSeq[nStartIndex], nChars);
1512
1513                 if (isSpecial(nCharLast))
1514                 {
1515                     resolveSpecialChar(nCharLast, rStream);
1516                     utext(rStream, &aSeq[nEndIndex], 1);
1517                 }
1518             }
1519         }
1520     }
1521 }
1522
1523 void WW8DocumentImpl::startCharacterGroup(Stream & rStream)
1524 {
1525     if (mbInCharacterGroup)
1526         endCharacterGroup(rStream);
1527
1528 #ifdef DEBUG_ELEMENT
1529     debug_logger->startElement("charactergroup");
1530 #endif
1531
1532     rStream.startCharacterGroup();
1533     mbInCharacterGroup = true;
1534 }
1535
1536 void WW8DocumentImpl::endCharacterGroup(Stream & rStream)
1537 {
1538 #ifdef DEBUG_ELEMENT
1539     debug_logger->endElement("charactergroup");
1540 #endif
1541
1542     rStream.endCharacterGroup();
1543     mbInCharacterGroup = false;
1544 }
1545
1546 void WW8DocumentImpl::startParagraphGroup(Stream & rStream)
1547 {
1548     if (mbInParagraphGroup)
1549         endParagraphGroup(rStream);
1550
1551 #ifdef DEBUG_ELEMENT
1552     debug_logger->startElement("paragraphgroup");
1553 #endif
1554
1555     rStream.startParagraphGroup();
1556     mbInParagraphGroup = true;
1557 }
1558
1559 void WW8DocumentImpl::endParagraphGroup(Stream & rStream)
1560 {
1561     if (mbInCharacterGroup)
1562         endCharacterGroup(rStream);
1563
1564 #ifdef DEBUG_ELEMENT
1565     debug_logger->endElement("paragraphgroup");
1566 #endif
1567     rStream.endParagraphGroup();
1568     mbInParagraphGroup = false;
1569 }
1570
1571 void WW8DocumentImpl::startSectionGroup(Stream & rStream)
1572 {
1573     if (mbInSection)
1574         endSectionGroup(rStream);
1575
1576 #ifdef DEBUG_ELEMENT
1577     debug_logger->startElement("sectiongroup");
1578 #endif
1579
1580     rStream.startSectionGroup();
1581     mbInSection = true;
1582 }
1583
1584 void WW8DocumentImpl::endSectionGroup(Stream & rStream)
1585 {
1586     if (mbInParagraphGroup)
1587         endParagraphGroup(rStream);
1588
1589 #ifdef DEBUG_ELEMENT
1590     debug_logger->endElement("sectiongroup");
1591 #endif
1592     rStream.endSectionGroup();
1593     mbInSection = false;
1594 }
1595
1596 void WW8DocumentImpl::resolve(Stream & rStream)
1597 {
1598     if (! bSubDocument)
1599     {
1600
1601         //mpPieceTable->dump(clog);
1602
1603         //copy(mCpAndFcs.begin(), mCpAndFcs.end(), ostream_iterator<CpAndFc>(clog, ", "));
1604
1605         //mpDocStream->dump(output);
1606
1607         //output.addItem(mTextboxHeaderEndCpAndFc.toString());
1608
1609 #if 0
1610         output.addItem("<substream-names>");
1611         output.addItem(mpStream->getSubStreamNames());
1612         output.addItem("</substream-names>");
1613
1614         if (mpDocStream.get() != NULL)
1615         {
1616             mpDocStream->dump(output);
1617         }
1618 #endif
1619
1620         writerfilter::Reference<Properties>::Pointer_t pFib
1621             (new WW8Fib(*mpFib));
1622         rStream.props(pFib);
1623
1624 #if 0
1625         if (mpTextBoxStories.get() != NULL)
1626         {
1627             output.addItem("<textbox.boxes>");
1628             mpTextBoxStories->dump(output);
1629             output.addItem("</textbox.boxes>");
1630         }
1631 #endif
1632         if (mpFib->get_lcbPlcftxbxBkd() > 0)
1633         {
1634             PLCF<WW8BKD> aPLCF(*mpTableStream,
1635                                mpFib->get_fcPlcftxbxBkd(),
1636                                mpFib->get_lcbPlcftxbxBkd());
1637 #if 0
1638             output.addItem("<textbox.breaks>");
1639             aPLCF.dump(output);
1640             output.addItem("</textbox.breaks>");
1641 #endif
1642         }
1643
1644         if (mpDffBlock.get() != NULL)
1645         {
1646             DffBlock * pTmp = new DffBlock(*mpDffBlock);
1647             //pTmp->dump(clog);
1648             writerfilter::Reference<Properties>::Pointer_t pDffBlock =
1649                 writerfilter::Reference<Properties>::Pointer_t(pTmp);
1650
1651             rStream.props(pDffBlock);
1652         }
1653
1654         {
1655             rStream.info("headers");
1656             sal_uInt32 nHeaderCount = getHeaderCount();
1657             for (sal_uInt32 n = 0; n < nHeaderCount; ++n)
1658             {
1659                 rStream.info(getHeaderCpAndFc(n).toString());
1660             }
1661             rStream.info("/headers");
1662         }
1663
1664 #if 0
1665         {
1666             sal_uInt32 nFootnoteCount = getFootnoteCount();
1667             for (sal_uInt32 n = 0; n < nFootnoteCount; ++n)
1668             {
1669                 //clog << "<footnote num=\"" << n << "\"/>" << endl;
1670
1671                 writerfilter::Reference<Stream>::Pointer_t pFootnote(getFootnote(n));
1672
1673                 if (pFootnote.get() != NULL)
1674                     rStream.substream(NS_rtf::LN_footnote, pFootnote);
1675             }
1676         }
1677         {
1678             sal_uInt32 nEndnoteCount = getEndnoteCount();
1679             for (sal_uInt32 n = 0; n < nEndnoteCount; ++n)
1680             {
1681                 //clog << "<endnote num=\"" << n << "\"/>" << endl;
1682
1683                 writerfilter::Reference<Stream>::Pointer_t pEndnote(getEndnote(n));
1684
1685                 if (pEndnote.get() != NULL)
1686                     rStream.substream(NS_rtf::LN_endnote, pEndnote);
1687             }
1688         }
1689 #endif
1690
1691         writerfilter::Reference<Table>::Pointer_t pFontTable = getFontTable();
1692
1693         if (pFontTable.get() != NULL)
1694             rStream.table(NS_rtf::LN_FONTTABLE, pFontTable);
1695
1696         try
1697         {
1698             writerfilter::Reference<Table>::Pointer_t pStyleSheet = getStyleSheet();
1699
1700             if (pStyleSheet.get() != NULL)
1701                 rStream.table(NS_rtf::LN_STYLESHEET, pStyleSheet);
1702         }
1703         catch (Exception e)
1704         {
1705             clog << e.getText() << endl;
1706         }
1707
1708         writerfilter::Reference<Table>::Pointer_t pListTable = getListTable();
1709
1710         if (pListTable.get() != NULL)
1711             rStream.table(NS_rtf::LN_LISTTABLE, pListTable);
1712
1713         writerfilter::Reference<Table>::Pointer_t pLFOTable = getLFOTable();
1714
1715         if (pLFOTable.get() != NULL)
1716             rStream.table(NS_rtf::LN_LFOTABLE, pLFOTable);
1717     }
1718
1719     WW8DocumentIterator::Pointer_t pIt = begin();
1720     WW8DocumentIterator::Pointer_t pItEnd = end();
1721
1722     mbInParagraphGroup = false;
1723     mbInCharacterGroup = false;
1724     mbInSection = false;
1725
1726     sal_uInt32 nSectionIndex = 0;
1727
1728     rStream.info(pIt->toString());
1729     rStream.info(pItEnd->toString());
1730
1731     while (! pIt->equal(*pItEnd))
1732     {
1733         writerfilter::Reference<Properties>::Pointer_t
1734             pProperties(pIt->getProperties());
1735
1736         switch (pIt->getPropertyType())
1737         {
1738         case PROP_FOOTNOTE:
1739             {
1740                 rStream.info(pIt->toString());
1741                 writerfilter::Reference<Stream>::Pointer_t
1742                     pFootnote(pIt->getSubDocument());
1743
1744                 if (pFootnote.get() != NULL)
1745                 {
1746 #ifdef DEBUG_ELEMENT
1747                     debug_logger->startElement("substream");
1748 #endif
1749                     rStream.substream(NS_rtf::LN_footnote, pFootnote);
1750 #ifdef DEBUG_ELEMENT
1751                     debug_logger->endElement("substream");
1752 #endif
1753                 }
1754             }
1755             break;
1756         case PROP_ENDNOTE:
1757             {
1758                 rStream.info(pIt->toString());
1759                 writerfilter::Reference<Stream>::Pointer_t
1760                     pEndnote(pIt->getSubDocument());
1761
1762                 if (pEndnote.get() != NULL)
1763                 {
1764 #ifdef DEBUG_ELEMENT
1765                     debug_logger->startElement("substream");
1766 #endif
1767                     rStream.substream(NS_rtf::LN_endnote, pEndnote);
1768 #ifdef DEBUG_ELEMENT
1769                     debug_logger->endElement("substream");
1770 #endif
1771                 }
1772             }
1773             break;
1774         case PROP_ANNOTATION:
1775             {
1776                 rStream.info(pIt->toString());
1777                 writerfilter::Reference<Stream>::Pointer_t
1778                     pAnnotation(pIt->getSubDocument());
1779
1780                 if (pAnnotation.get() != NULL)
1781                 {
1782 #ifdef DEBUG_ELEMENT
1783                     debug_logger->startElement("substream");
1784 #endif
1785                     rStream.substream(NS_rtf::LN_annotation, pAnnotation);
1786 #ifdef DEBUG_ELEMENT
1787                     debug_logger->endElement("substream");
1788 #endif
1789                 }
1790             }
1791             break;
1792         case PROP_CHP:
1793             {
1794                 startCharacterGroup(rStream);
1795             }
1796
1797             break;
1798         case PROP_PAP:
1799             {
1800                 startParagraphGroup(rStream);
1801                 rStream.info(pIt->toString());
1802             }
1803
1804             break;
1805         case PROP_SEC:
1806             {
1807                 startSectionGroup(rStream);
1808                 rStream.info(pIt->toString());
1809
1810                 sal_uInt32 nHeaderStartIndex = 6 + nSectionIndex * 6;
1811                 sal_uInt32 nHeaderEndIndex = nHeaderStartIndex + 6;
1812
1813                 if (nHeaderStartIndex >= getHeaderCount())
1814                     nHeaderStartIndex = getHeaderCount();
1815
1816                 if (nHeaderEndIndex >= getHeaderCount())
1817                     nHeaderEndIndex = getHeaderCount();
1818
1819                 for (sal_uInt32 n = nHeaderStartIndex; n < nHeaderEndIndex; ++n)
1820                 {
1821                     writerfilter::Reference<Stream>::Pointer_t
1822                         pHeader(getHeader(n));
1823
1824                     Id qName = lcl_headerQName(n);
1825
1826                     if (pHeader.get() != NULL)
1827                         rStream.substream(qName, pHeader);
1828                 }
1829
1830                 ++nSectionIndex;
1831             }
1832
1833             break;
1834         default:
1835             rStream.info(pIt->toString());
1836         }
1837
1838         if (pProperties.get() != NULL)
1839         {
1840 #ifdef DEBUG_PROPERTIES
1841             PropertySetToTagHandler aHandler(IdToString::Pointer_t(new WW8IdToString()));
1842             pProperties->resolve(aHandler);
1843             debug_logger->addTag(aHandler.getTag());
1844 #endif
1845
1846             rStream.props(pProperties);
1847         }
1848
1849         if (pIt->getPropertyType() == PROP_PAP)
1850         {
1851             startCharacterGroup(rStream);
1852         }
1853
1854         resolveText(pIt, rStream);
1855
1856         ++(*pIt);
1857     }
1858
1859     if (mbInCharacterGroup)
1860         endCharacterGroup(rStream);
1861
1862     if (mbInParagraphGroup)
1863         endParagraphGroup(rStream);
1864
1865     if (mbInSection)
1866         endSectionGroup(rStream);
1867
1868 }
1869
1870 WW8Stream::Pointer_t
1871 WW8DocumentFactory::createStream(uno::Reference<uno::XComponentContext> rContext,
1872                                  uno::Reference<io::XInputStream> rStream)
1873 {
1874     return WW8Stream::Pointer_t(new WW8StreamImpl(rContext, rStream));
1875 }
1876
1877 WW8Document *
1878 WW8DocumentFactory::createDocument(WW8Stream::Pointer_t rpStream)
1879 {
1880     return new WW8DocumentImpl(rpStream);
1881 }
1882
1883 writerfilter::Reference<Properties>::Pointer_t
1884 WW8SED::get_sepx()
1885 {
1886     writerfilter::Reference<Properties>::Pointer_t pResult;
1887
1888     if (get_fcSepx() != 0xffffffff)
1889     {
1890         WW8StructBase aTmp(*mpDoc->getDocStream(), get_fcSepx(), 2);
1891         pResult = writerfilter::Reference<Properties>::Pointer_t
1892             (new WW8PropertySetImpl
1893              (*mpDoc->getDocStream(), get_fcSepx() + 2,
1894               (sal_uInt32) aTmp.getU16(0), false));
1895     }
1896
1897     return pResult;
1898 }
1899
1900 void WW8DocumentImpl::insertCpAndFc(const CpAndFc & rCpAndFc)
1901 {
1902     mCpAndFcs.insert(rCpAndFc);
1903 }
1904
1905 string propertyTypeToString(PropertyType nType)
1906 {
1907     string result;
1908
1909     switch (nType)
1910     {
1911     case PROP_SHP:
1912         result = "SHP";
1913
1914         break;
1915     case PROP_FLD:
1916         result = "FLD";
1917
1918         break;
1919     case PROP_BOOKMARKSTART:
1920         result = "BOOKMARKSTART";
1921
1922         break;
1923     case PROP_BOOKMARKEND:
1924         result = "BOOKMARKEND";
1925
1926         break;
1927     case PROP_ENDNOTE:
1928         result = "ENDNOTE";
1929
1930         break;
1931     case PROP_FOOTNOTE:
1932         result = "FOOTNOTE";
1933
1934         break;
1935     case PROP_ANNOTATION:
1936         result = "ANNOTATION";
1937
1938         break;
1939     case PROP_DOC:
1940         result = "DOC";
1941
1942         break;
1943
1944     case PROP_SEC:
1945         result = "SEC";
1946
1947         break;
1948
1949     case PROP_PAP:
1950         result = "PAP";
1951
1952         break;
1953
1954     case PROP_CHP:
1955         result = "CHP";
1956
1957         break;
1958     default:
1959         break;
1960     }
1961
1962     return result;
1963 }
1964
1965 string CpAndFc::toString() const
1966 {
1967     string result;
1968
1969     result += "(";
1970     result += getCp().toString();
1971     result += ", ";
1972     result += getFc().toString();
1973     result += ", ";
1974
1975     result += propertyTypeToString(getType());
1976
1977     result += ")";
1978
1979     return result;
1980 }
1981
1982
1983 // Bookmark
1984
1985 Bookmark::Bookmark(writerfilter::Reference<Properties>::Pointer_t pBKF,
1986                    rtl::OUString & rName)
1987 : mpBKF(pBKF), mName(rName)
1988 {
1989 }
1990
1991 void Bookmark::resolve(Properties & rHandler)
1992 {
1993     mpBKF->resolve(rHandler);
1994
1995     WW8Value::Pointer_t pValue = createValue(mName);
1996     rHandler.attribute(NS_rtf::LN_BOOKMARKNAME, *pValue);
1997 }
1998
1999 string Bookmark::getType() const
2000 {
2001     return "Bookmark";
2002 }
2003
2004 // BookmarkHelper
2005
2006 CpAndFc BookmarkHelper::getStartCpAndFc(sal_uInt32 nPos)
2007 {
2008     Cp aCp(mpStartCps->getFc(nPos));
2009     Fc aFc(mpPieceTable->cp2fc(aCp));
2010     CpAndFc aCpAndFc(aCp, aFc, PROP_BOOKMARKSTART);
2011
2012     return aCpAndFc;
2013 }
2014
2015 CpAndFc BookmarkHelper::getEndCpAndFc(sal_uInt32 nPos)
2016 {
2017     Cp aCp(mpEndCps->getU32(nPos * 4));
2018     Fc aFc(mpPieceTable->cp2fc(aCp));
2019     CpAndFc aCpAndFc(aCp, aFc, PROP_BOOKMARKEND);
2020
2021     return aCpAndFc;
2022 }
2023
2024 rtl::OUString BookmarkHelper::getName(sal_uInt32 nPos)
2025 {
2026     return mpNames->getEntry(nPos);
2027 }
2028
2029 sal_uInt32 BookmarkHelper::getIndex(const CpAndFc & rCpAndFc)
2030 {
2031     sal_uInt32 nResult = mpStartCps->getEntryCount();
2032
2033     sal_uInt32 nCp = rCpAndFc.getCp().get();
2034
2035     sal_uInt32 n;
2036     switch (rCpAndFc.getType())
2037     {
2038     case PROP_BOOKMARKSTART:
2039         {
2040             sal_uInt32 nStartsCount = mpStartCps->getEntryCount();
2041
2042             for (n = 0; n < nStartsCount; ++n)
2043             {
2044                 if (nCp == mpStartCps->getFc(n))
2045                 {
2046                     nResult = n;
2047
2048                     break;
2049                 }
2050             }
2051
2052             if (n == nStartsCount)
2053                 throw ExceptionNotFound("BookmarkHelper::getIndex");
2054         }
2055
2056         break;
2057
2058     case PROP_BOOKMARKEND:
2059         {
2060             sal_uInt32 nEndsCount = mpEndCps->getCount() / 4;
2061             sal_uInt32 nIndex = nEndsCount;
2062
2063             for (n = 0; n < nEndsCount; ++n)
2064             {
2065                 if (nCp == mpEndCps->getU16(n * 4))
2066                 {
2067                     nIndex = n;
2068
2069                     break;
2070                 }
2071             }
2072
2073             if (n == nEndsCount)
2074                 throw ExceptionNotFound("BookmarkHelper::getIndex");
2075
2076             {
2077                 {
2078                     sal_uInt32 nStartsCount = mpStartCps->getEntryCount();
2079                     for (n = 0; n < nStartsCount; ++n)
2080                     {
2081                         WW8BKF::Pointer_t pBKF(mpStartCps->getEntry(n));
2082
2083                         if (pBKF->get_ibkl() ==
2084                             sal::static_int_cast<sal_Int32>(nIndex))
2085                         {
2086                             nResult = n;
2087
2088                             break;
2089                         }
2090                     }
2091
2092                     if (n == nStartsCount)
2093                         throw ExceptionNotFound("BookmarkHelper::getIndex");
2094                 }
2095             }
2096         }
2097
2098         break;
2099     default:
2100         break;
2101     }
2102
2103     return nResult;
2104 }
2105
2106 void BookmarkHelper::init()
2107 {
2108     {
2109         sal_uInt32 nStartsCount = mpStartCps->getEntryCount();
2110
2111         for (sal_uInt32 n = 0; n < nStartsCount; ++n)
2112             mpDoc->insertCpAndFc(getStartCpAndFc(n));
2113     }
2114
2115     {
2116         sal_uInt32 nEndsCount = mpEndCps->getCount() / 4;
2117
2118         for (sal_uInt32 n = 0; n < nEndsCount; ++n)
2119             mpDoc->insertCpAndFc(getEndCpAndFc(n));
2120     }
2121 }
2122
2123 writerfilter::Reference<Properties>::Pointer_t
2124 BookmarkHelper::getBKF(const CpAndFc & rCpAndFc)
2125 {
2126     sal_uInt32 nIndex = getIndex(rCpAndFc);
2127
2128     return writerfilter::Reference<Properties>::Pointer_t
2129         (mpStartCps->getEntryPointer(nIndex));
2130 }
2131
2132 writerfilter::Reference<Properties>::Pointer_t
2133 BookmarkHelper::getBookmark(const CpAndFc & rCpAndFc)
2134 {
2135     writerfilter::Reference<Properties>::Pointer_t pResult;
2136
2137     try
2138     {
2139         rtl::OUString aName = getName(rCpAndFc);
2140
2141         pResult = writerfilter::Reference<Properties>::Pointer_t
2142             (new Bookmark(getBKF(rCpAndFc), aName));
2143     }
2144     catch (ExceptionNotFound e)
2145     {
2146         clog << e.getText() << endl;
2147     }
2148
2149     return pResult;
2150 }
2151
2152 rtl::OUString BookmarkHelper::getName(const CpAndFc & rCpAndFc)
2153 {
2154     rtl::OUString sResult;
2155
2156     sal_uInt32 nIndex = getIndex(rCpAndFc);
2157
2158     sResult = getName(nIndex);
2159
2160     return sResult;
2161 }
2162
2163 template <class T, class Helper>
2164 struct ProcessPLCF2Map
2165 {
2166     void process(typename PLCF<T>::Pointer_t pPlcf,
2167                  typename Helper::Map_t & rMap,
2168                  PropertyType type,
2169                  WW8DocumentImpl * pDoc)
2170     {
2171         if (pPlcf.get() != NULL)
2172         {
2173             sal_uInt32 nCount = pPlcf->getEntryCount();
2174
2175             for (sal_uInt32 n = 0; n < nCount; n++)
2176             {
2177                 Cp aCp(pPlcf->getFc(n));
2178                 CpAndFc aCpAndFc(pDoc->getCpAndFc(aCp, type));
2179                 typename T::Pointer_t pT = pPlcf->getEntry(n);
2180
2181                 rMap[aCpAndFc] = pT;
2182             }
2183         }
2184     }
2185 };
2186
2187 FieldHelper::FieldHelper(PLCF<WW8FLD>::Pointer_t pPlcffldMom,
2188                          WW8DocumentImpl * pDoc)
2189 : mpDoc(pDoc)
2190 {
2191     ProcessPLCF2Map<WW8FLD, FieldHelper> process;
2192     process.process(pPlcffldMom, mMap, PROP_FLD, pDoc);
2193 }
2194
2195 void FieldHelper::init()
2196 {
2197     Map_t::iterator aIt;
2198
2199     for (aIt = mMap.begin(); aIt != mMap.end(); aIt++)
2200     {
2201         mpDoc->insertCpAndFc(aIt->first);
2202     }
2203 }
2204
2205 WW8FLD::Pointer_t FieldHelper::getWW8FLD(const CpAndFc & rCpAndFc)
2206 {
2207     WW8FLD::Pointer_t pFld = mMap[rCpAndFc];
2208
2209     return pFld;
2210 }
2211
2212 writerfilter::Reference<Properties>::Pointer_t
2213 FieldHelper::getField(const CpAndFc & rCpAndFc)
2214 {
2215     WW8FLD::Pointer_t pFLD = getWW8FLD(rCpAndFc);
2216
2217     return writerfilter::Reference<Properties>::Pointer_t
2218         (new WW8FLD(*pFLD));
2219 }
2220
2221 ShapeHelper::ShapeHelper(PLCF<WW8FSPA>::Pointer_t pPlcspaMom,
2222                          PLCF<WW8FSPA>::Pointer_t pPlcspaHdr,
2223                          WW8DocumentImpl * pDoc)
2224 : mpDoc(pDoc)
2225 {
2226     ProcessPLCF2Map<WW8FSPA, ShapeHelper> process;
2227     process.process(pPlcspaMom, mMap, PROP_SHP, pDoc);
2228     process.process(pPlcspaHdr, mMap, PROP_SHP, pDoc);
2229 }
2230
2231 void ShapeHelper::init()
2232 {
2233     Map_t::iterator aIt;
2234
2235     for (aIt = mMap.begin(); aIt != mMap.end(); aIt++)
2236     {
2237         mpDoc->insertCpAndFc(aIt->first);
2238         aIt->second->setDocument(mpDoc);
2239     }
2240 }
2241
2242 writerfilter::Reference<Properties>::Pointer_t
2243 ShapeHelper::getShape(const CpAndFc & rCpAndFc)
2244 {
2245     WW8FSPA::Pointer_t pFSPA = mMap[rCpAndFc];
2246
2247     return writerfilter::Reference<Properties>::Pointer_t
2248         (new WW8FSPA(*pFSPA));
2249 }
2250
2251 BreakHelper::BreakHelper(PLCF<WW8BKD>::Pointer_t pPlcfbkdMom,
2252                          WW8DocumentImpl * pDoc)
2253 : mpDoc(pDoc)
2254 {
2255     ProcessPLCF2Map<WW8BKD, BreakHelper> process;
2256     process.process(pPlcfbkdMom, mMap, PROP_BRK, pDoc);
2257 }
2258
2259 void BreakHelper::init()
2260 {
2261     Map_t::iterator aIt;
2262
2263     for (aIt = mMap.begin(); aIt != mMap.end(); aIt++)
2264     {
2265         mpDoc->insertCpAndFc(aIt->first);
2266     }
2267 }
2268
2269 writerfilter::Reference<Properties>::Pointer_t
2270 BreakHelper::getBreak(const CpAndFc & rCpAndFc)
2271 {
2272     WW8BKD::Pointer_t pBKD = mMap[rCpAndFc];
2273
2274     return writerfilter::Reference<Properties>::Pointer_t
2275         (new WW8BKD(*pBKD));
2276 }
2277
2278
2279 }}