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
1692         writerfilter::Reference<Table>::Pointer_t pListTable = getListTable();
1693
1694         if (pListTable.get() != NULL)
1695             rStream.table(NS_rtf::LN_LISTTABLE, pListTable);
1696
1697         writerfilter::Reference<Table>::Pointer_t pLFOTable = getLFOTable();
1698
1699         if (pLFOTable.get() != NULL)
1700             rStream.table(NS_rtf::LN_LFOTABLE, pLFOTable);
1701
1702         writerfilter::Reference<Table>::Pointer_t pFontTable = getFontTable();
1703
1704         if (pFontTable.get() != NULL)
1705             rStream.table(NS_rtf::LN_FONTTABLE, pFontTable);
1706
1707         try
1708         {
1709             writerfilter::Reference<Table>::Pointer_t pStyleSheet = getStyleSheet();
1710
1711             if (pStyleSheet.get() != NULL)
1712                 rStream.table(NS_rtf::LN_STYLESHEET, pStyleSheet);
1713         }
1714         catch (Exception e)
1715         {
1716             clog << e.getText() << endl;
1717         }
1718     }
1719
1720     WW8DocumentIterator::Pointer_t pIt = begin();
1721     WW8DocumentIterator::Pointer_t pItEnd = end();
1722
1723     mbInParagraphGroup = false;
1724     mbInCharacterGroup = false;
1725     mbInSection = false;
1726
1727     sal_uInt32 nSectionIndex = 0;
1728
1729     rStream.info(pIt->toString());
1730     rStream.info(pItEnd->toString());
1731
1732     while (! pIt->equal(*pItEnd))
1733     {
1734         writerfilter::Reference<Properties>::Pointer_t
1735             pProperties(pIt->getProperties());
1736
1737         switch (pIt->getPropertyType())
1738         {
1739         case PROP_FOOTNOTE:
1740             {
1741                 rStream.info(pIt->toString());
1742                 writerfilter::Reference<Stream>::Pointer_t
1743                     pFootnote(pIt->getSubDocument());
1744
1745                 if (pFootnote.get() != NULL)
1746                 {
1747 #ifdef DEBUG_ELEMENT
1748                     debug_logger->startElement("substream");
1749 #endif
1750                     rStream.substream(NS_rtf::LN_footnote, pFootnote);
1751 #ifdef DEBUG_ELEMENT
1752                     debug_logger->endElement("substream");
1753 #endif
1754                 }
1755             }
1756             break;
1757         case PROP_ENDNOTE:
1758             {
1759                 rStream.info(pIt->toString());
1760                 writerfilter::Reference<Stream>::Pointer_t
1761                     pEndnote(pIt->getSubDocument());
1762
1763                 if (pEndnote.get() != NULL)
1764                 {
1765 #ifdef DEBUG_ELEMENT
1766                     debug_logger->startElement("substream");
1767 #endif
1768                     rStream.substream(NS_rtf::LN_endnote, pEndnote);
1769 #ifdef DEBUG_ELEMENT
1770                     debug_logger->endElement("substream");
1771 #endif
1772                 }
1773             }
1774             break;
1775         case PROP_ANNOTATION:
1776             {
1777                 rStream.info(pIt->toString());
1778                 writerfilter::Reference<Stream>::Pointer_t
1779                     pAnnotation(pIt->getSubDocument());
1780
1781                 if (pAnnotation.get() != NULL)
1782                 {
1783 #ifdef DEBUG_ELEMENT
1784                     debug_logger->startElement("substream");
1785 #endif
1786                     rStream.substream(NS_rtf::LN_annotation, pAnnotation);
1787 #ifdef DEBUG_ELEMENT
1788                     debug_logger->endElement("substream");
1789 #endif
1790                 }
1791             }
1792             break;
1793         case PROP_CHP:
1794             {
1795                 startCharacterGroup(rStream);
1796             }
1797
1798             break;
1799         case PROP_PAP:
1800             {
1801                 startParagraphGroup(rStream);
1802                 rStream.info(pIt->toString());
1803             }
1804
1805             break;
1806         case PROP_SEC:
1807             {
1808                 startSectionGroup(rStream);
1809                 rStream.info(pIt->toString());
1810
1811                 sal_uInt32 nHeaderStartIndex = 6 + nSectionIndex * 6;
1812                 sal_uInt32 nHeaderEndIndex = nHeaderStartIndex + 6;
1813
1814                 if (nHeaderStartIndex >= getHeaderCount())
1815                     nHeaderStartIndex = getHeaderCount();
1816
1817                 if (nHeaderEndIndex >= getHeaderCount())
1818                     nHeaderEndIndex = getHeaderCount();
1819
1820                 for (sal_uInt32 n = nHeaderStartIndex; n < nHeaderEndIndex; ++n)
1821                 {
1822                     writerfilter::Reference<Stream>::Pointer_t
1823                         pHeader(getHeader(n));
1824
1825                     Id qName = lcl_headerQName(n);
1826
1827                     if (pHeader.get() != NULL)
1828                         rStream.substream(qName, pHeader);
1829                 }
1830
1831                 ++nSectionIndex;
1832             }
1833
1834             break;
1835         default:
1836             rStream.info(pIt->toString());
1837         }
1838
1839         if (pProperties.get() != NULL)
1840         {
1841 #ifdef DEBUG_PROPERTIES
1842             PropertySetToTagHandler aHandler(IdToString::Pointer_t(new WW8IdToString()));
1843             pProperties->resolve(aHandler);
1844             debug_logger->addTag(aHandler.getTag());
1845 #endif
1846
1847             rStream.props(pProperties);
1848         }
1849
1850         if (pIt->getPropertyType() == PROP_PAP)
1851         {
1852             startCharacterGroup(rStream);
1853         }
1854
1855         resolveText(pIt, rStream);
1856
1857         ++(*pIt);
1858     }
1859
1860     if (mbInCharacterGroup)
1861         endCharacterGroup(rStream);
1862
1863     if (mbInParagraphGroup)
1864         endParagraphGroup(rStream);
1865
1866     if (mbInSection)
1867         endSectionGroup(rStream);
1868
1869 }
1870
1871 WW8Stream::Pointer_t
1872 WW8DocumentFactory::createStream(uno::Reference<uno::XComponentContext> rContext,
1873                                  uno::Reference<io::XInputStream> rStream)
1874 {
1875     return WW8Stream::Pointer_t(new WW8StreamImpl(rContext, rStream));
1876 }
1877
1878 WW8Document *
1879 WW8DocumentFactory::createDocument(WW8Stream::Pointer_t rpStream)
1880 {
1881     return new WW8DocumentImpl(rpStream);
1882 }
1883
1884 writerfilter::Reference<Properties>::Pointer_t
1885 WW8SED::get_sepx()
1886 {
1887     writerfilter::Reference<Properties>::Pointer_t pResult;
1888
1889     if (get_fcSepx() != 0xffffffff)
1890     {
1891         WW8StructBase aTmp(*mpDoc->getDocStream(), get_fcSepx(), 2);
1892         pResult = writerfilter::Reference<Properties>::Pointer_t
1893             (new WW8PropertySetImpl
1894              (*mpDoc->getDocStream(), get_fcSepx() + 2,
1895               (sal_uInt32) aTmp.getU16(0), false));
1896     }
1897
1898     return pResult;
1899 }
1900
1901 void WW8DocumentImpl::insertCpAndFc(const CpAndFc & rCpAndFc)
1902 {
1903     mCpAndFcs.insert(rCpAndFc);
1904 }
1905
1906 string propertyTypeToString(PropertyType nType)
1907 {
1908     string result;
1909
1910     switch (nType)
1911     {
1912     case PROP_SHP:
1913         result = "SHP";
1914
1915         break;
1916     case PROP_FLD:
1917         result = "FLD";
1918
1919         break;
1920     case PROP_BOOKMARKSTART:
1921         result = "BOOKMARKSTART";
1922
1923         break;
1924     case PROP_BOOKMARKEND:
1925         result = "BOOKMARKEND";
1926
1927         break;
1928     case PROP_ENDNOTE:
1929         result = "ENDNOTE";
1930
1931         break;
1932     case PROP_FOOTNOTE:
1933         result = "FOOTNOTE";
1934
1935         break;
1936     case PROP_ANNOTATION:
1937         result = "ANNOTATION";
1938
1939         break;
1940     case PROP_DOC:
1941         result = "DOC";
1942
1943         break;
1944
1945     case PROP_SEC:
1946         result = "SEC";
1947
1948         break;
1949
1950     case PROP_PAP:
1951         result = "PAP";
1952
1953         break;
1954
1955     case PROP_CHP:
1956         result = "CHP";
1957
1958         break;
1959     default:
1960         break;
1961     }
1962
1963     return result;
1964 }
1965
1966 string CpAndFc::toString() const
1967 {
1968     string result;
1969
1970     result += "(";
1971     result += getCp().toString();
1972     result += ", ";
1973     result += getFc().toString();
1974     result += ", ";
1975
1976     result += propertyTypeToString(getType());
1977
1978     result += ")";
1979
1980     return result;
1981 }
1982
1983
1984 // Bookmark
1985
1986 Bookmark::Bookmark(writerfilter::Reference<Properties>::Pointer_t pBKF,
1987                    rtl::OUString & rName)
1988 : mpBKF(pBKF), mName(rName)
1989 {
1990 }
1991
1992 void Bookmark::resolve(Properties & rHandler)
1993 {
1994     mpBKF->resolve(rHandler);
1995
1996     WW8Value::Pointer_t pValue = createValue(mName);
1997     rHandler.attribute(NS_rtf::LN_BOOKMARKNAME, *pValue);
1998 }
1999
2000 string Bookmark::getType() const
2001 {
2002     return "Bookmark";
2003 }
2004
2005 // BookmarkHelper
2006
2007 CpAndFc BookmarkHelper::getStartCpAndFc(sal_uInt32 nPos)
2008 {
2009     Cp aCp(mpStartCps->getFc(nPos));
2010     Fc aFc(mpPieceTable->cp2fc(aCp));
2011     CpAndFc aCpAndFc(aCp, aFc, PROP_BOOKMARKSTART);
2012
2013     return aCpAndFc;
2014 }
2015
2016 CpAndFc BookmarkHelper::getEndCpAndFc(sal_uInt32 nPos)
2017 {
2018     Cp aCp(mpEndCps->getU32(nPos * 4));
2019     Fc aFc(mpPieceTable->cp2fc(aCp));
2020     CpAndFc aCpAndFc(aCp, aFc, PROP_BOOKMARKEND);
2021
2022     return aCpAndFc;
2023 }
2024
2025 rtl::OUString BookmarkHelper::getName(sal_uInt32 nPos)
2026 {
2027     return mpNames->getEntry(nPos);
2028 }
2029
2030 sal_uInt32 BookmarkHelper::getIndex(const CpAndFc & rCpAndFc)
2031 {
2032     sal_uInt32 nResult = mpStartCps->getEntryCount();
2033
2034     sal_uInt32 nCp = rCpAndFc.getCp().get();
2035
2036     sal_uInt32 n;
2037     switch (rCpAndFc.getType())
2038     {
2039     case PROP_BOOKMARKSTART:
2040         {
2041             sal_uInt32 nStartsCount = mpStartCps->getEntryCount();
2042
2043             for (n = 0; n < nStartsCount; ++n)
2044             {
2045                 if (nCp == mpStartCps->getFc(n))
2046                 {
2047                     nResult = n;
2048
2049                     break;
2050                 }
2051             }
2052
2053             if (n == nStartsCount)
2054                 throw ExceptionNotFound("BookmarkHelper::getIndex");
2055         }
2056
2057         break;
2058
2059     case PROP_BOOKMARKEND:
2060         {
2061             sal_uInt32 nEndsCount = mpEndCps->getCount() / 4;
2062             sal_uInt32 nIndex = nEndsCount;
2063
2064             for (n = 0; n < nEndsCount; ++n)
2065             {
2066                 if (nCp == mpEndCps->getU16(n * 4))
2067                 {
2068                     nIndex = n;
2069
2070                     break;
2071                 }
2072             }
2073
2074             if (n == nEndsCount)
2075                 throw ExceptionNotFound("BookmarkHelper::getIndex");
2076
2077             {
2078                 {
2079                     sal_uInt32 nStartsCount = mpStartCps->getEntryCount();
2080                     for (n = 0; n < nStartsCount; ++n)
2081                     {
2082                         WW8BKF::Pointer_t pBKF(mpStartCps->getEntry(n));
2083
2084                         if (pBKF->get_ibkl() ==
2085                             sal::static_int_cast<sal_Int32>(nIndex))
2086                         {
2087                             nResult = n;
2088
2089                             break;
2090                         }
2091                     }
2092
2093                     if (n == nStartsCount)
2094                         throw ExceptionNotFound("BookmarkHelper::getIndex");
2095                 }
2096             }
2097         }
2098
2099         break;
2100     default:
2101         break;
2102     }
2103
2104     return nResult;
2105 }
2106
2107 void BookmarkHelper::init()
2108 {
2109     {
2110         sal_uInt32 nStartsCount = mpStartCps->getEntryCount();
2111
2112         for (sal_uInt32 n = 0; n < nStartsCount; ++n)
2113             mpDoc->insertCpAndFc(getStartCpAndFc(n));
2114     }
2115
2116     {
2117         sal_uInt32 nEndsCount = mpEndCps->getCount() / 4;
2118
2119         for (sal_uInt32 n = 0; n < nEndsCount; ++n)
2120             mpDoc->insertCpAndFc(getEndCpAndFc(n));
2121     }
2122 }
2123
2124 writerfilter::Reference<Properties>::Pointer_t
2125 BookmarkHelper::getBKF(const CpAndFc & rCpAndFc)
2126 {
2127     sal_uInt32 nIndex = getIndex(rCpAndFc);
2128
2129     return writerfilter::Reference<Properties>::Pointer_t
2130         (mpStartCps->getEntryPointer(nIndex));
2131 }
2132
2133 writerfilter::Reference<Properties>::Pointer_t
2134 BookmarkHelper::getBookmark(const CpAndFc & rCpAndFc)
2135 {
2136     writerfilter::Reference<Properties>::Pointer_t pResult;
2137
2138     try
2139     {
2140         rtl::OUString aName = getName(rCpAndFc);
2141
2142         pResult = writerfilter::Reference<Properties>::Pointer_t
2143             (new Bookmark(getBKF(rCpAndFc), aName));
2144     }
2145     catch (ExceptionNotFound e)
2146     {
2147         clog << e.getText() << endl;
2148     }
2149
2150     return pResult;
2151 }
2152
2153 rtl::OUString BookmarkHelper::getName(const CpAndFc & rCpAndFc)
2154 {
2155     rtl::OUString sResult;
2156
2157     sal_uInt32 nIndex = getIndex(rCpAndFc);
2158
2159     sResult = getName(nIndex);
2160
2161     return sResult;
2162 }
2163
2164 template <class T, class Helper>
2165 struct ProcessPLCF2Map
2166 {
2167     void process(typename PLCF<T>::Pointer_t pPlcf,
2168                  typename Helper::Map_t & rMap,
2169                  PropertyType type,
2170                  WW8DocumentImpl * pDoc)
2171     {
2172         if (pPlcf.get() != NULL)
2173         {
2174             sal_uInt32 nCount = pPlcf->getEntryCount();
2175
2176             for (sal_uInt32 n = 0; n < nCount; n++)
2177             {
2178                 Cp aCp(pPlcf->getFc(n));
2179                 CpAndFc aCpAndFc(pDoc->getCpAndFc(aCp, type));
2180                 typename T::Pointer_t pT = pPlcf->getEntry(n);
2181
2182                 rMap[aCpAndFc] = pT;
2183             }
2184         }
2185     }
2186 };
2187
2188 FieldHelper::FieldHelper(PLCF<WW8FLD>::Pointer_t pPlcffldMom,
2189                          WW8DocumentImpl * pDoc)
2190 : mpDoc(pDoc)
2191 {
2192     ProcessPLCF2Map<WW8FLD, FieldHelper> process;
2193     process.process(pPlcffldMom, mMap, PROP_FLD, pDoc);
2194 }
2195
2196 void FieldHelper::init()
2197 {
2198     Map_t::iterator aIt;
2199
2200     for (aIt = mMap.begin(); aIt != mMap.end(); aIt++)
2201     {
2202         mpDoc->insertCpAndFc(aIt->first);
2203     }
2204 }
2205
2206 WW8FLD::Pointer_t FieldHelper::getWW8FLD(const CpAndFc & rCpAndFc)
2207 {
2208     WW8FLD::Pointer_t pFld = mMap[rCpAndFc];
2209
2210     return pFld;
2211 }
2212
2213 writerfilter::Reference<Properties>::Pointer_t
2214 FieldHelper::getField(const CpAndFc & rCpAndFc)
2215 {
2216     WW8FLD::Pointer_t pFLD = getWW8FLD(rCpAndFc);
2217
2218     return writerfilter::Reference<Properties>::Pointer_t
2219         (new WW8FLD(*pFLD));
2220 }
2221
2222 ShapeHelper::ShapeHelper(PLCF<WW8FSPA>::Pointer_t pPlcspaMom,
2223                          PLCF<WW8FSPA>::Pointer_t pPlcspaHdr,
2224                          WW8DocumentImpl * pDoc)
2225 : mpDoc(pDoc)
2226 {
2227     ProcessPLCF2Map<WW8FSPA, ShapeHelper> process;
2228     process.process(pPlcspaMom, mMap, PROP_SHP, pDoc);
2229     process.process(pPlcspaHdr, mMap, PROP_SHP, pDoc);
2230 }
2231
2232 void ShapeHelper::init()
2233 {
2234     Map_t::iterator aIt;
2235
2236     for (aIt = mMap.begin(); aIt != mMap.end(); aIt++)
2237     {
2238         mpDoc->insertCpAndFc(aIt->first);
2239         aIt->second->setDocument(mpDoc);
2240     }
2241 }
2242
2243 writerfilter::Reference<Properties>::Pointer_t
2244 ShapeHelper::getShape(const CpAndFc & rCpAndFc)
2245 {
2246     WW8FSPA::Pointer_t pFSPA = mMap[rCpAndFc];
2247
2248     return writerfilter::Reference<Properties>::Pointer_t
2249         (new WW8FSPA(*pFSPA));
2250 }
2251
2252 BreakHelper::BreakHelper(PLCF<WW8BKD>::Pointer_t pPlcfbkdMom,
2253                          WW8DocumentImpl * pDoc)
2254 : mpDoc(pDoc)
2255 {
2256     ProcessPLCF2Map<WW8BKD, BreakHelper> process;
2257     process.process(pPlcfbkdMom, mMap, PROP_BRK, pDoc);
2258 }
2259
2260 void BreakHelper::init()
2261 {
2262     Map_t::iterator aIt;
2263
2264     for (aIt = mMap.begin(); aIt != mMap.end(); aIt++)
2265     {
2266         mpDoc->insertCpAndFc(aIt->first);
2267     }
2268 }
2269
2270 writerfilter::Reference<Properties>::Pointer_t
2271 BreakHelper::getBreak(const CpAndFc & rCpAndFc)
2272 {
2273     WW8BKD::Pointer_t pBKD = mMap[rCpAndFc];
2274
2275     return writerfilter::Reference<Properties>::Pointer_t
2276         (new WW8BKD(*pBKD));
2277 }
2278
2279
2280 }}