sw/source/filter/ww1/w1class.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27 #include <tools/string.hxx>
  28 #include <tools/debug.hxx>
  29
  30 // local
  31 #ifndef _W1STRUCT_HXX
  32 #include <w1struct.hxx>
  33 #endif
  34
  35 #ifdef DUMP
  36 #include <fstream.h>
  37 #endif
  38
  39 #include <ostream>
  40
  41 using std::ostream;
  42
  43 class SvxFontItem;
  44 class SvxBorderLine;
  45 class SvxBoxItem;
  46 class SvStream;
  47 class SwField;
  48 class Ww1Annotation;
  49 class Ww1AtnText;
  50 class Ww1Chp;
  51 class Ww1DocText;
  52 class Ww1Dop;
  53 class Ww1Fib;
  54 class Ww1Fkp;
  55 class Ww1FkpChp;
  56 class Ww1FkpPap;
  57 class Ww1Fonts;
  58 class Ww1Manager;
  59 class Ww1McrText;
  60 class Ww1Pap;
  61 class Ww1PlainText;
  62 class Ww1Plc;
  63 class Ww1PlcAnnotationRef;
  64 class Ww1PlcAnnotationTxt;
  65 class Ww1PlcChp;
  66 class Ww1PlcFields;
  67 class Ww1PlcFootnoteRef;
  68 class Ww1PlcFootnoteTxt;
  69 class Ww1PlcGlossary;
  70 class Ww1PlcHdd;
  71 class Ww1PlcPap;
  72 class Ww1PlcSep;
  73 class Ww1Shell;
  74 class Ww1Sprm;
  75 class Ww1SprmPapx;
  76 class Ww1SprmSep;
  77 class Ww1Style;
  78 class Ww1StyleSheet;
  79
  80 ///////////////////////////////////////////////////////////////////////
  81 //
  82 // nach moeglichkeit wurden in diesem modul methoden aehnlicher
  83 // funktionalitaet gleich benannt. Die namen wurden wenn moeglich vom
  84 // ww-filter uebernommen.
  85 // Where() gibt die position eines elements. dies kann sowohl eine
  86 // seek-position im stream als auch ein relativer offset sein, da dies
  87 // bei word durcheinander geht.  die methoden sind durch kommentare
  88 // gekennzeichnet, ob sie sich auf positionen in der datei oder
  89 // innerhalb des textes beziehen. vorsicht: innerhalb des textes kann
  90 // verschiedene texte in der datei bedeuten.
  91 // Count() gibt die anzahl der elemente zurueck. vorsicht bei
  92 // n/n-1-feldern (word speichert strukturen gern in doppel-arrays, in
  93 // denen das erste n elemente, das zweite jedoch n-1 elemente
  94 // enthaelt.
  95 // Fill() fuellt uebergebene referenzen mit daten aus den
  96 // word-strukturen.
  97 // GetData() gibt zeiger auf den datenbereich zurueck
  98 // GetError() gibt zurueck, ob fehler aufgetreten ist
  99 // Start(), Stop(), Out(), op<< siehe modul w1filter
 100 // Dump() siehe modul w1dump
 101 //
 102
 103 /////////////////////////////////////////////////////////////////// Fib
 104 //
 105 // file information block: wurzel des uebels: steht am beginn der
 106 // datei (seek(0)) und enthaelt alle positionen der strukturen der
 107 // datei
 108 //
 109 class Ww1Fib
 110 {
 111     W1_FIB aFib;
 112     BOOL bOK;
 113     SvStream& rStream;
 114 public:
 115     Ww1Fib(SvStream&);
 116     friend ostream& operator <<(ostream&, Ww1Fib&);
 117     W1_FIB& GetFIB()        { return aFib; }
 118     BOOL GetError()         { return !bOK; }
 119     SvStream& GetStream()   { return rStream; }
 120 };
 121
 122 /////////////////////////////////////////////////////////////////// Dop
 123 //
 124 // document property: eigenschaften des gesamten dokuments
 125 //
 126 class Ww1Dop
 127 {
 128     W1_DOP aDop;
 129     Ww1Fib& rFib;
 130     BOOL bOK;
 131 public:
 132     Ww1Dop(Ww1Fib&);
 133     BOOL GetError() {
 134         return !bOK; }
 135     W1_DOP& GetDOP() {
 136         return aDop; }
 137     friend ostream& operator <<(ostream&, Ww1Dop&);
 138     void Out(Ww1Shell&);
 139 };
 140
 141 ///////////////////////////////////////////////////////////// PlainText
 142 //
 143 // ww-dateien koennen mehrere textbloecke enthalten (main-text,
 144 // fusznoten etc). PlainText vereinigt die gemeinsamkeiten
 145 //
 146 class Ww1PlainText
 147 {
 148 protected:
 149     Ww1Fib& rFib;
 150     ULONG ulFilePos;
 151     ULONG ulCountBytes;
 152     ULONG ulSeek;
 153     BOOL bOK;
 154 public:
 155     Ww1PlainText(Ww1Fib& rWwFib, ULONG nFilePos, ULONG nCountBytes);
 156     // innerhalb des textes
 157     ULONG Where() const                 { return ulSeek; }
 158     void Seek( ULONG ulNew )
 159         {
 160             DBG_ASSERT(ulNew < ulCountBytes, "Ww1PlainText");
 161             if (ulNew < ulCountBytes)
 162                 ulSeek = ulNew;
 163         }
 164
 165     ULONG Count() const                 { return ulCountBytes; }
 166     void SetCount(ULONG ulNew)
 167         {
 168             ulNew += ulSeek;
 169             if (ulCountBytes > ulNew)
 170                 ulCountBytes = ulNew;
 171         }
 172     void operator++(int)
 173     {
 174         DBG_ASSERT(ulSeek+1<ulCountBytes, "Ww1PlainText");
 175         ulSeek++;
 176     }
 177     BOOL GetError()                     { return !bOK; }
 178     sal_Unicode Out( Ww1Shell&, ULONG& );
 179     sal_Unicode Out( String&, ULONG=0xffffffff);
 180     sal_Unicode Out( sal_Unicode& );
 181     friend ostream& operator <<(ostream&, Ww1PlainText&);
 182     String& Fill( String&, ULONG=0, ULONG=0xffffffff );
 183     sal_Unicode operator []( ULONG );
 184     String GetText( ULONG ulOffset, ULONG nLen ) const;
 185
 186     enum Consts { MinChar = 32 };
 187     static BOOL IsChar( sal_Unicode c )     { return c >= MinChar; }
 188 };
 189
 190 /////////////////////////////////////////////////////////////// DocText
 191 class Ww1DocText : public Ww1PlainText
 192 {
 193 public:
 194     Ww1DocText(Ww1Fib& rFibL) :
 195         Ww1PlainText(rFibL, rFibL.GetFIB().fcMinGet(),
 196          rFibL.GetFIB().ccpTextGet()) {
 197         }
 198 };
 199
 200 /////////////////////////////////////////////////////////////// FtnText
 201 class Ww1FtnText : public Ww1PlainText
 202 {
 203 public:
 204     ULONG Offset(Ww1Fib& rFibL) {
 205         return rFibL.GetFIB().ccpTextGet(); }
 206     Ww1FtnText(Ww1Fib& rFibL) :
 207         Ww1PlainText(rFibL, rFibL.GetFIB().fcMinGet() +
 208          Offset(rFibL), rFibL.GetFIB().ccpFtnGet()) {
 209         }
 210 };
 211
 212 /////////////////////////////////////////////////////////////// HddText
 213 class Ww1HddText : public Ww1PlainText
 214 {
 215 public:
 216     ULONG Offset(Ww1Fib& rFibL) {
 217         return rFibL.GetFIB().ccpTextGet() + rFibL.GetFIB().ccpFtnGet(); }
 218     Ww1HddText(Ww1Fib& rFibL) :
 219         Ww1PlainText(rFibL, rFibL.GetFIB().fcMinGet() +
 220          Offset(rFibL), rFibL.GetFIB().ccpHddGet()) {
 221         }
 222 };
 223
 224 /////////////////////////////////////////////////////////////// McrText
 225 class Ww1McrText : public Ww1PlainText
 226 {
 227 public:
 228     ULONG Offset(Ww1Fib& rFibL) {
 229         return rFibL.GetFIB().ccpTextGet() + rFibL.GetFIB().ccpFtnGet()
 230          + rFibL.GetFIB().ccpHddGet(); }
 231     Ww1McrText(Ww1Fib& rFibL) :
 232         Ww1PlainText(rFibL, rFibL.GetFIB().fcMinGet() +
 233          Offset(rFibL), rFibL.GetFIB().ccpMcrGet()) {
 234         }
 235 };
 236
 237 /////////////////////////////////////////////////////////////// AtnText
 238 class Ww1AtnText : public Ww1PlainText
 239 {
 240 public:
 241     ULONG Offset(Ww1Fib& rFibL) {
 242         return rFibL.GetFIB().ccpTextGet() + rFibL.GetFIB().ccpFtnGet()
 243          + rFibL.GetFIB().ccpHddGet() + rFibL.GetFIB().ccpMcrGet(); }
 244     Ww1AtnText(Ww1Fib& rFibL) :
 245         Ww1PlainText(rFibL, rFibL.GetFIB().fcMinGet() +
 246          Offset(rFibL), rFibL.GetFIB().ccpAtnGet()) {
 247         }
 248 };
 249
 250 ///////////////////////////////////////////////////////////////// Style
 251 //
 252 // ein einzelner style oder vorlage
 253 //
 254 class Ww1Style
 255 {
 256     String aName;
 257     W1_CHP aChpx;
 258     Ww1SprmPapx* pPapx;
 259     Ww1StyleSheet* pParent;
 260     BYTE stcBase;
 261     BYTE stcNext;
 262     BOOL bUsed;
 263 public:
 264     Ww1Style();
 265     ~Ww1Style();
 266     BOOL IsUsed() const                 { return bUsed; }
 267     void SetDefaults(BYTE);
 268     void SetParent(Ww1StyleSheet* newParent)    { pParent = newParent; }
 269     void SetName(const String& rName)   { bUsed = TRUE; aName = rName; }
 270     const String& GetName() const       { return aName; }
 271 //  Ww1Style& GetNext();
 272     Ww1Style& GetBase();
 273     USHORT GetnBase() const             { return stcBase; }
 274     USHORT GetnNext() const             { return stcNext; }
 275     USHORT ReadName(BYTE*&, USHORT&, USHORT stc);
 276     USHORT ReadChpx(BYTE*&, USHORT&);
 277     USHORT ReadPapx(BYTE*&, USHORT&);
 278     USHORT ReadEstcp(BYTE*&, USHORT&);
 279     friend ostream& operator <<(ostream&, Ww1Style&);
 280     void Out(Ww1Shell&, Ww1Manager&);
 281 };
 282
 283 //////////////////////////////////////////////////////////// StyleSheet
 284 //
 285 // die sammlung aller vorlagen (max. 256)
 286 //
 287 class Ww1StyleSheet
 288 {
 289     Ww1Style aStyles[256];
 290     USHORT cstcStd; // count style code standard
 291     Ww1Fib& rFib;
 292     BOOL bOK;
 293     USHORT ReadNames(BYTE*&, USHORT&);
 294     USHORT ReadChpx(BYTE*&, USHORT&);
 295     USHORT ReadPapx(BYTE*&, USHORT&);
 296     USHORT ReadEstcp(BYTE*&, USHORT&);
 297
 298     void OutDefaults(Ww1Shell& rOut, Ww1Manager& rMan, USHORT stc);
 299     void OutOne(Ww1Shell& rOut, Ww1Manager& rMan, USHORT stc);
 300     void OutOneWithBase(Ww1Shell& rOut, Ww1Manager& rMan, USHORT stc,
 301                         BYTE* pbStopRecur );
 302 public:
 303     Ww1StyleSheet(Ww1Fib& rFib);
 304     Ww1Style& GetStyle(USHORT stc) {
 305         return aStyles[stc]; }
 306     USHORT Count() {
 307         return 256; }
 308     friend ostream& operator <<(ostream&, Ww1StyleSheet&);
 309     void Out(Ww1Shell&, Ww1Manager&);
 310     friend class Ww1Style;
 311     BOOL GetError() {
 312         return !bOK; }
 313 };
 314
 315 ///////////////////////////////////////////////////////////////// Fonts
 316 //
 317 // ww kennt nur font-nummern beim formatieren. nebenher gibts ein
 318 // array von fonts, damit man aus der nummer einen konkreten font
 319 // machen kann.
 320 //
 321 class Ww1Fonts
 322 {
 323 protected:
 324     W1_FFN** pFontA; // Array of Pointers to Font Description
 325     Ww1Fib& rFib;
 326     ULONG nFieldFlags;
 327     USHORT nMax; // Array-Groesse
 328     BOOL bOK;
 329 public:
 330     Ww1Fonts(Ww1Fib&, ULONG nFieldFlgs);
 331     ~Ww1Fonts() {
 332         if (pFontA)
 333             DELETEZ(pFontA[0]);
 334         DELETEZ(pFontA); }
 335     W1_FFN* GetFFN(USHORT nNum);
 336     USHORT Count() {
 337         return nMax; }
 338     friend ostream& operator <<(ostream&, Ww1Fonts&);
 339     BOOL GetError() {
 340         return !bOK; }
 341     SvxFontItem GetFont(USHORT);
 342 };
 343
 344 //////////////////////////////////////////////////////////// SingleSprm
 345 //
 346 // diese klassen ersetzen die aSprmTab etc des ww6-filters. die
 347 // funktionspointer sind hier virtuale methoden, fuer die typen (byte,
 348 // word, var-sized etc) gibt es abgeleitete klassen. diese haben
 349 // methoden zum bestimmen der groesze, dumpen und shell-ausgeben der
 350 // Sprms.
 351 // die klassen werden mit new (in InitTab()) erzeugt und nach ihrem
 352 // code in die tabelle gestellt. zum aktivieren ruft man nun nur noch
 353 // die entsprechende methode des objektes in der tabelle auf.
 354 // wohlgemerkt: SingleSprms sind die _beschreibung_ und _funktion_ der
 355 // Sprms, nicht deren inhalt. dieser musz uebergeben werden an die
 356 // einzelnen methoden wie Size, Dump und Start/Stop.
 357 //
 358 class Ww1SingleSprm
 359 {
 360 public:
 361 #ifdef DUMP
 362 //
 363 // allein die virtuellen methoden stehen in der vtab, also je nachdem,
 364 // ob fuer dumper oder filter uebersetzt wird ausblenden: das spart
 365 // platz. ausserdem stehen die methoden fuer dumper bzw filter in
 366 // verschiedenen modulen, die im jeweils anderen projekt nicht
 367 // uebersetzt werden. das diese dann beim linken nicht zur verfuegung
 368 // stehen faellt dann auch nicht auf. Der Namensstring ist nur im
 369 // Dumper noetig: weg damit im Filter.
 370 //
 371     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 372     void Stop(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 373     virtual ostream& Dump(ostream&, BYTE*, USHORT);
 374     const sal_Char* sName;
 375 #else
 376     virtual void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 377     virtual void Stop(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 378     ostream& Dump(ostream&, BYTE*, USHORT);
 379 #endif
 380     virtual USHORT Size(BYTE*);
 381     USHORT nCountBytes;
 382
 383     Ww1SingleSprm(USHORT nBytes, const sal_Char* /*pName*/ = 0 )
 384         : nCountBytes(nBytes)
 385 #ifdef DUMP
 386         , sName( pName)
 387 #endif
 388         {
 389         }
 390 };
 391
 392 class Ww1SingleSprmByteSized : public Ww1SingleSprm {
 393 public:
 394 //  ostream& Dump(ostream&, BYTE*, USHORT);
 395     USHORT Size(BYTE*);
 396     Ww1SingleSprmByteSized(USHORT nBytes, sal_Char* sName = 0) :
 397         Ww1SingleSprm(nBytes, sName) {
 398         }
 399 };
 400
 401 class Ww1SingleSprmWordSized : public Ww1SingleSprm {
 402 public:
 403 //  ostream& Dump(ostream&, BYTE*, USHORT);
 404     USHORT Size(BYTE*);
 405     Ww1SingleSprmWordSized(USHORT nBytes, sal_Char* sName = 0) :
 406         Ww1SingleSprm(nBytes, sName) {
 407         }
 408 };
 409
 410 class Ww1SingleSprmByte : public Ww1SingleSprm {
 411 public:
 412     ostream& Dump(ostream&, BYTE*, USHORT);
 413 //  USHORT Size(BYTE*);
 414     Ww1SingleSprmByte(sal_Char* sName = 0) :
 415         Ww1SingleSprm(1, sName) {
 416         }
 417 };
 418
 419 class Ww1SingleSprmBool : public Ww1SingleSprmByte {
 420 public:
 421     ostream& Dump(ostream&, BYTE*, USHORT);
 422 //  USHORT Size(BYTE*);
 423     Ww1SingleSprmBool(sal_Char* sName = 0) :
 424         Ww1SingleSprmByte(sName) {
 425         }
 426 };
 427
 428 class Ww1SingleSprm4State : public Ww1SingleSprmByte {
 429 public:
 430     ostream& Dump(ostream&, BYTE*, USHORT);
 431 //  USHORT Size(BYTE*);
 432     Ww1SingleSprm4State(sal_Char* sName = 0) :
 433         Ww1SingleSprmByte(sName) {
 434         }
 435 };
 436
 437 class Ww1SingleSprmWord : public Ww1SingleSprm {
 438 public:
 439     ostream& Dump(ostream&, BYTE*, USHORT);
 440 //  USHORT Size(BYTE*);
 441     Ww1SingleSprmWord(sal_Char* sName = 0)
 442     : Ww1SingleSprm(2, sName) {}
 443 };
 444
 445 class Ww1SingleSprmLong : public Ww1SingleSprm {
 446 public:
 447     ostream& Dump(ostream&, BYTE*, USHORT);
 448 //  USHORT Size(BYTE*);
 449     Ww1SingleSprmLong(sal_Char* sName = 0) :
 450         Ww1SingleSprm(4, sName) {
 451         }
 452 };
 453
 454 class Ww1SingleSprmTab : public Ww1SingleSprm {
 455 public:
 456     ostream& Dump(ostream&, BYTE*, USHORT);
 457     USHORT Size(BYTE*);
 458     Ww1SingleSprmTab(USHORT nBytes, sal_Char* sName = 0) :
 459         Ww1SingleSprm(nBytes, sName) {
 460         }
 461 };
 462
 463 class Ww1SingleSprmPJc : public Ww1SingleSprmByte {
 464 public:
 465     Ww1SingleSprmPJc(sal_Char* sName) :
 466         Ww1SingleSprmByte(sName) {
 467         }
 468     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 469     void Stop(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 470 };
 471
 472 class Ww1SingleSprmPDxa : public Ww1SingleSprmWord {
 473 public:
 474     Ww1SingleSprmPDxa(sal_Char* sName) :
 475         Ww1SingleSprmWord(sName) {
 476         }
 477     void Stop(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 478 };
 479
 480 class Ww1SingleSprmPDxaRight : public Ww1SingleSprmPDxa {
 481 public:
 482     Ww1SingleSprmPDxaRight(sal_Char* sName) :
 483         Ww1SingleSprmPDxa(sName) {
 484         }
 485     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 486 };
 487
 488 class Ww1SingleSprmPDxaLeft : public Ww1SingleSprmPDxa {
 489 public:
 490     Ww1SingleSprmPDxaLeft(sal_Char* sName) :
 491         Ww1SingleSprmPDxa(sName) {
 492         }
 493     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 494 };
 495
 496 class Ww1SingleSprmPDxaLeft1 : public Ww1SingleSprmPDxa {
 497 public:
 498     Ww1SingleSprmPDxaLeft1(sal_Char* sName) :
 499         Ww1SingleSprmPDxa(sName) {
 500         }
 501     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 502 };
 503
 504 class Ww1SingleSprmPFKeep : public Ww1SingleSprmBool {
 505 public:
 506     Ww1SingleSprmPFKeep(sal_Char* sName) :
 507         Ww1SingleSprmBool(sName) {
 508         }
 509     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 510     void Stop(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 511 };
 512
 513 class Ww1SingleSprmPFKeepFollow : public Ww1SingleSprmBool {
 514 public:
 515     Ww1SingleSprmPFKeepFollow(sal_Char* sName) :
 516         Ww1SingleSprmBool(sName) {
 517         }
 518     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 519     void Stop(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 520 };
 521
 522 class Ww1SingleSprmPPageBreakBefore : public Ww1SingleSprmBool {
 523 public:
 524     Ww1SingleSprmPPageBreakBefore(sal_Char* sName) :
 525         Ww1SingleSprmBool(sName) {
 526         }
 527     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 528     void Stop(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 529 };
 530
 531 class Ww1SingleSprmPBrc : public Ww1SingleSprmWord {
 532 protected:
 533 //  SvxBorderLine* SetBorder(SvxBorderLine*, W1_BRC*);
 534     // spezielle start-routine, je nach sprm verschieden versorgt
 535     // mit einem BoxItem.
 536     void Start(Ww1Shell&, BYTE, W1_BRC10*, USHORT, Ww1Manager&, SvxBoxItem&);
 537     void Start(Ww1Shell&, BYTE, W1_BRC*, USHORT, Ww1Manager&, SvxBoxItem&);
 538
 539     using Ww1SingleSprm::Start;
 540
 541 public:
 542     Ww1SingleSprmPBrc(sal_Char* sName) :
 543         Ww1SingleSprmWord(sName) {
 544         }
 545     void Stop(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 546     // SetBorder() wird auch fuer Tabellen gebraucht, deshalb public
 547     static SvxBorderLine* SetBorder(SvxBorderLine*, W1_BRC10*);
 548 };
 549
 550 #define BRC_TOP ((USHORT)0)
 551 #define BRC_LEFT ((USHORT)1)
 552 #define BRC_BOTTOM ((USHORT)2)
 553 #define BRC_RIGHT ((USHORT)3)
 554 #define BRC_ANZ ((USHORT)BRC_RIGHT-BRC_TOP+1)
 555
 556 // Die BRC-struktur fuer 1.0 versionen von word sind verschieden von
 557 // denen der folgenden versionen. diese werden zum glueck aber auch
 558 // von anderen sprms abgerufen.
 559 // SH: Ab sofort alle 4 Umrandungen ueber nur 1 Klasse.
 560 class Ww1SingleSprmPBrc10 : public Ww1SingleSprmPBrc
 561 {
 562     USHORT nLine;   // BRC_TOP, BRC_LEFT, ...
 563
 564     using Ww1SingleSprmPBrc::Start;
 565
 566 public:
 567     Ww1SingleSprmPBrc10(USHORT nL, sal_Char* sName)
 568     : Ww1SingleSprmPBrc(sName), nLine(nL) {}
 569
 570     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 571 };
 572
 573 class Ww1SingleSprmParaSpace : public Ww1SingleSprmWord {
 574 public:
 575     Ww1SingleSprmParaSpace(sal_Char* sName)
 576     : Ww1SingleSprmWord(sName) {}
 577     void Stop(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 578 };
 579
 580 class Ww1SingleSprmPDyaBefore : public Ww1SingleSprmParaSpace {
 581 public:
 582     Ww1SingleSprmPDyaBefore(sal_Char* sName)
 583     : Ww1SingleSprmParaSpace(sName) {}
 584     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 585 };
 586
 587 class Ww1SingleSprmPDyaAfter : public Ww1SingleSprmParaSpace {
 588 public:
 589     Ww1SingleSprmPDyaAfter(sal_Char* sName) :
 590         Ww1SingleSprmParaSpace(sName) {
 591         }
 592     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 593 };
 594
 595 class Ww1SingleSprmPDyaLine : public Ww1SingleSprmWord {
 596 public:
 597     Ww1SingleSprmPDyaLine(sal_Char* sName) :
 598         Ww1SingleSprmWord(sName) {
 599         }
 600     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 601     void Stop(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 602 };
 603
 604 class Ww1SingleSprmPChgTabsPapx : public Ww1SingleSprmByteSized {
 605 public:
 606     Ww1SingleSprmPChgTabsPapx(sal_Char* sName) :
 607         Ww1SingleSprmByteSized(0, sName) {
 608         }
 609   // Size() ist noch nicht aktiviert !!
 610     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 611     void Stop(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 612 };
 613
 614 class Ww1SingleSprmSGprfIhdt : public Ww1SingleSprmByte {
 615 public:
 616     Ww1SingleSprmSGprfIhdt(sal_Char* sName) :
 617         Ww1SingleSprmByte(sName) {
 618         }
 619     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 620 };
 621
 622 class Ww1SingleSprmSColumns : public Ww1SingleSprmWord {
 623 public:
 624     Ww1SingleSprmSColumns(sal_Char* sName) :
 625         Ww1SingleSprmWord(sName) {
 626         }
 627     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 628 };
 629
 630 class Ww1SingleSprmPFInTable : public Ww1SingleSprmBool {
 631 public:
 632     Ww1SingleSprmPFInTable(sal_Char* sName) :
 633         Ww1SingleSprmBool(sName) {
 634         }
 635     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 636     void Stop(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 637 };
 638
 639 class Ww1SingleSprmPTtp : public Ww1SingleSprmBool {
 640 public:
 641     Ww1SingleSprmPTtp(sal_Char* sName) :
 642         Ww1SingleSprmBool(sName) {
 643         }
 644     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 645     void Stop(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 646 };
 647
 648 class Ww1SingleSprmTJc : public Ww1SingleSprmWord {
 649 public:
 650     Ww1SingleSprmTJc(sal_Char* sName)
 651     : Ww1SingleSprmWord(sName) {}
 652 };
 653
 654 //class Ww1SingleSprmTDxaLeft : public Ww1SingleSprmWord {
 655 //public:
 656 //  Ww1SingleSprmTDxaLeft(sal_Char* sName) :
 657 //      Ww1SingleSprmWord(sName) {
 658 //      }
 659 //  void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 660 //};
 661
 662 class Ww1SingleSprmTDxaGapHalf : public Ww1SingleSprmWord {
 663 public:
 664     Ww1SingleSprmTDxaGapHalf(sal_Char* sName) :
 665         Ww1SingleSprmWord(sName) {
 666         }
 667     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 668 };
 669
 670 class Ww1SingleSprmTDefTable10 : public Ww1SingleSprmWordSized {
 671 public:
 672     Ww1SingleSprmTDefTable10(sal_Char* sName) :
 673         Ww1SingleSprmWordSized(0, sName) {
 674         }
 675     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 676 };
 677
 678 class Ww1SingleSprmTDyaRowHeight : public Ww1SingleSprmWord {
 679 public:
 680     Ww1SingleSprmTDyaRowHeight(sal_Char* sName) :
 681         Ww1SingleSprmWord(sName) {
 682         }
 683     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 684 };
 685
 686 // Klassendefinitionen fuer Tabellen-Fastsave-Attribute
 687 // Da wir kein Fastsave unterstuetzen, brauchen wir's nicht
 688
 689 #if 0
 690
 691 class Ww1SingleSprmTInsert : public Ww1SingleSprm {
 692 public:
 693     Ww1SingleSprmTInsert(sal_Char* sName) :
 694         Ww1SingleSprm(4, sName) {
 695         }
 696     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 697 };
 698
 699 class Ww1SingleSprmTDelete : public Ww1SingleSprmWord {
 700 public:
 701     Ww1SingleSprmTDelete(sal_Char* sName) :
 702         Ww1SingleSprmWord(sName) {
 703         }
 704     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 705 };
 706
 707 class Ww1SingleSprmTDxaCol : public Ww1SingleSprm {
 708 public:
 709     Ww1SingleSprmTDxaCol(sal_Char* sName) :
 710         Ww1SingleSprm(4, sName) {
 711         }
 712     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 713 };
 714
 715 class Ww1SingleSprmTMerge : public Ww1SingleSprmWord {
 716 public:
 717     Ww1SingleSprmTMerge(sal_Char* sName) :
 718         Ww1SingleSprmWord(sName) {
 719         }
 720     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 721 };
 722
 723 class Ww1SingleSprmTSplit : public Ww1SingleSprmWord {
 724 public:
 725     Ww1SingleSprmTSplit(sal_Char* sName) :
 726         Ww1SingleSprmWord(sName) {
 727         }
 728     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 729 };
 730
 731 class Ww1SingleSprmTSetBrc10 : public Ww1SingleSprm {
 732 public:
 733     Ww1SingleSprmTSetBrc10(sal_Char* sName) :
 734         Ww1SingleSprm(5, sName) {
 735         }
 736     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 737 };
 738 #endif // 0
 739
 740 // Klassendefinitionen fuer Apos ( == Flys )
 741
 742 class Ww1SingleSprmPpc : public Ww1SingleSprmByte {
 743 public:
 744     Ww1SingleSprmPpc(sal_Char* sName) :
 745         Ww1SingleSprmByte(sName) {
 746         }
 747     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 748 };
 749
 750 class Ww1SingleSprmPDxaAbs : public Ww1SingleSprmWord {
 751 public:
 752     Ww1SingleSprmPDxaAbs(sal_Char* sName) :
 753         Ww1SingleSprmWord(sName) {
 754         }
 755     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 756 };
 757
 758 class Ww1SingleSprmPDyaAbs : public Ww1SingleSprmWord {
 759 public:
 760     Ww1SingleSprmPDyaAbs(sal_Char* sName) :
 761         Ww1SingleSprmWord(sName) {
 762         }
 763     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 764 };
 765
 766 class Ww1SingleSprmPDxaWidth : public Ww1SingleSprmWord {
 767 public:
 768     Ww1SingleSprmPDxaWidth(sal_Char* sName) :
 769         Ww1SingleSprmWord(sName) {
 770         }
 771     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 772 };
 773
 774 class Ww1SingleSprmPFromText : public Ww1SingleSprmWord {
 775 public:
 776     Ww1SingleSprmPFromText(sal_Char* sName) :
 777         Ww1SingleSprmWord(sName) {
 778         }
 779     void Start(Ww1Shell&, BYTE, BYTE*, USHORT, Ww1Manager&);
 780 };
 781
 782 ////////////////////////////////////////////////////////////////// Sprm
 783 //
 784 // der tatsaechlich in der datei auftretende datentyp Sprm
 785 //
 786 class Ww1Sprm
 787 {
 788     BOOL ReCalc();
 789     static Ww1SingleSprm* aTab[256];
 790     static Ww1SingleSprm* pSingleSprm;
 791 protected:
 792     static void InitTab();
 793     Ww1SingleSprm& GetTab(USHORT nId)
 794     {
 795         if( !pSingleSprm )
 796             InitTab();
 797         return aTab[ nId ] ? *aTab[nId] : *pSingleSprm;
 798     }
 799
 800     BYTE* p;
 801     USHORT nCountBytes;
 802     BOOL bOK;
 803     USHORT* pArr;
 804     USHORT count;
 805 // ohne Token, mit laengen-byte/word
 806     USHORT GetSize(BYTE nId, BYTE* pSprm);
 807 // mit Token und LaengenByte
 808     USHORT GetSizeBrutto(BYTE* pSprm) {
 809         BYTE nId = *pSprm++;
 810         return GetSize(nId, pSprm) + 1; }
 811 // gibt fuer nTh element id, size & zeiger auf daten:
 812 //  BOOL Fill(USHORT, BYTE&, USHORT&, BYTE*&);
 813 public:
 814 // SH: brauche ich public
 815 // gibt fuer nTh element id, size & zeiger auf daten:
 816     BOOL Fill(USHORT, BYTE&, USHORT&, BYTE*&);
 817
 818     Ww1Sprm(BYTE*, USHORT);
 819     Ww1Sprm(SvStream&, ULONG);
 820     ~Ww1Sprm();
 821     friend ostream& operator <<(ostream&, Ww1Sprm&);
 822     void Start(Ww1Shell&, Ww1Manager&);
 823     void Start(Ww1Shell&, Ww1Manager&, USHORT);
 824     void Stop(Ww1Shell&, Ww1Manager&);
 825     BOOL IsUsed() {
 826         return nCountBytes != 255; }
 827     USHORT Count() {
 828         return count; }
 829     BOOL GetError() {
 830         return !bOK; }
 831     static void DeinitTab();
 832 };
 833
 834 /////////////////////////////////////////////////////////////// Picture
 835 //
 836 // der wrapper um den datentyp PIC, eine struktur, die am beginn eines
 837 // bild-dateinamens oder eines eingebetteten bildes steht.
 838 //
 839 class Ww1Picture
 840 {
 841     BOOL bOK;
 842     W1_PIC* pPic;
 843 public:
 844     Ww1Picture(SvStream&, ULONG);
 845     ~Ww1Picture() {
 846         }
 847     BOOL GetError() {
 848         return !bOK; }
 849     friend ostream& operator <<(ostream&, Ww1Picture&);
 850     void Out(Ww1Shell&, Ww1Manager&);
 851     void WriteBmp(SvStream&);
 852 };
 853
 854 /////////////////////////////////////////////////////////////////// Plc
 855 //
 856 // eine der wichtigen array-strukturen der ww-dateien. sie beinhalten
 857 // n+1 dateipositionen und n attribute, die zwischen den
 858 // dateipositionen gelten.
 859 //
 860 class Ww1Plc
 861 {
 862     BYTE* p;
 863     USHORT nCountBytes;
 864     USHORT iMac;
 865     USHORT nItemSize;
 866     BOOL bOK;
 867 protected:
 868     Ww1Fib& rFib;
 869     BYTE* GetData(USHORT);
 870 public:
 871     Ww1Plc(Ww1Fib&, ULONG, USHORT, USHORT);
 872     ~Ww1Plc();
 873     friend ostream& operator <<(ostream&, Ww1Plc&);
 874     ULONG Where(USHORT); // wie im jeweiligen plc
 875     void Seek(ULONG, USHORT&);
 876     void Fill(USHORT nIndex, ULONG& begin, ULONG& end) {
 877         begin = Where(nIndex);
 878         end = Where(nIndex+1); }
 879     USHORT Count() {
 880         return iMac; }
 881     BOOL GetError() {
 882         return !bOK; }
 883 };
 884
 885 // Size Tabs from Sven:
 886 //    CHP, PAP, SEP, HED, FNR, FNT
 887 //Plc 2,   2,   6,   0,   2,   0
 888 //Fkp 1,   1,   0,   0,   0,   0
 889
 890 /////////////////////////////////////////////////////////// PlcGlossary
 891 class Ww1PlcGlossary : public Ww1Plc
 892 {
 893 public:
 894     Ww1PlcGlossary(Ww1Fib& rFibL) :
 895         Ww1Plc(rFibL, rFibL.GetFIB().fcPlcfglsyGet(),
 896          rFibL.GetFIB().cbPlcfglsyGet(), 0) {
 897         }
 898 };
 899
 900 ////////////////////////////////////////////////////// PlcAnnotationRef
 901 class Ww1PlcAnnotationRef : public Ww1Plc
 902 {
 903 public:
 904     Ww1PlcAnnotationRef(Ww1Fib& rFibL) :
 905         Ww1Plc(rFibL, rFibL.GetFIB().fcPlcfandRefGet(),
 906          rFibL.GetFIB().cbPlcfandRefGet(), 0) {
 907         }
 908 };
 909
 910 ////////////////////////////////////////////////////// PlcAnnotationTxt
 911 class Ww1PlcAnnotationTxt : public Ww1Plc
 912 {
 913 public:
 914     Ww1PlcAnnotationTxt(Ww1Fib& rFibL) :
 915         Ww1Plc(rFibL, rFibL.GetFIB().fcPlcfandTxtGet(),
 916          rFibL.GetFIB().cbPlcfandTxtGet(), 0) {
 917         }
 918 };
 919
 920 ///////////////////////////////////////////////////////// PlcAnnotation
 921 class Ww1Annotation {
 922     Ww1PlcAnnotationRef aRef;
 923     Ww1PlcAnnotationTxt aTxt;
 924 public:
 925     Ww1Annotation(Ww1Fib& rFib) :
 926         aRef(rFib),
 927         aTxt(rFib) {
 928         }
 929     friend ostream& operator <<(ostream&, Ww1Annotation&);
 930 };
 931
 932 //////////////////////////////////////////////////////////////// PlcSep
 933 class Ww1PlcSep : public Ww1Plc
 934 {
 935 public:
 936     Ww1PlcSep(Ww1Fib& rFibL):
 937         Ww1Plc(rFibL, rFibL.GetFIB().fcPlcfsedGet(),
 938          rFibL.GetFIB().cbPlcfsedGet(), 6) {
 939         }
 940     friend ostream& operator <<(ostream&, Ww1PlcSep&);
 941 };
 942
 943 //////////////////////////////////////////////////////////////// PlcChp
 944 class Ww1PlcChp : public Ww1Plc
 945 {
 946 public:
 947     Ww1PlcChp(Ww1Fib& rFibL) :
 948         Ww1Plc(rFibL, rFibL.GetFIB().fcPlcfbteChpxGet(),
 949          rFibL.GetFIB().cbPlcfbteChpxGet(), 2) {
 950         }
 951     friend ostream& operator <<(ostream&, Ww1PlcChp&);
 952 };
 953
 954 //////////////////////////////////////////////////////////////// PlcPap
 955 class Ww1PlcPap : public Ww1Plc
 956 {
 957 public:
 958     Ww1PlcPap(Ww1Fib& rFibL) :
 959         Ww1Plc(rFibL, rFibL.GetFIB().fcPlcfbtePapxGet(),
 960          rFibL.GetFIB().cbPlcfbtePapxGet(), 2) {
 961         }
 962     friend ostream& operator <<(ostream&, Ww1PlcPap&);
 963 };
 964
 965 //////////////////////////////////////////////////////// PlcFootnoteRef
 966 class Ww1PlcFootnoteRef : public Ww1Plc
 967 {
 968 public:
 969     Ww1PlcFootnoteRef(Ww1Fib& rFibL) :
 970         Ww1Plc(rFibL, rFibL.GetFIB().fcPlcffndRefGet(),
 971          rFibL.GetFIB().cbPlcffndRefGet(), 2) {
 972         }
 973     friend ostream& operator <<(ostream&, Ww1PlcFootnoteRef&);
 974 };
 975
 976 //////////////////////////////////////////////////////// PlcFootnoteTxt
 977 class Ww1PlcFootnoteTxt : public Ww1Plc
 978 {
 979 public:
 980     Ww1PlcFootnoteTxt(Ww1Fib& rFibL) :
 981         Ww1Plc(rFibL, rFibL.GetFIB().fcPlcffndTxtGet(),
 982          rFibL.GetFIB().cbPlcffndTxtGet(), 0) {
 983         }
 984     friend ostream& operator <<(ostream&, Ww1PlcFootnoteTxt&);
 985 };
 986
 987 ///////////////////////////////////////////////////////////// PlcFields
 988 class Ww1PlcFields : public Ww1Plc
 989 {
 990     //USHORT Fill(USHORT, BYTE&, String&, String&, String&);
 991 public:
 992     Ww1PlcFields(Ww1Fib& rFibL, ULONG start, USHORT nBytes)
 993         : Ww1Plc(rFibL, start, nBytes, 2)
 994     {}
 995     W1_FLD* GetData(USHORT nIndex)
 996         { return (W1_FLD*)Ww1Plc::GetData(nIndex); }
 997     ULONG Where(USHORT nIndex)  // absolut im file
 998         { return Ww1Plc::Where(nIndex) + rFib.GetFIB().fcMinGet(); }
 999     friend ostream& operator <<(ostream&, Ww1PlcFields&);
1000 };
1001
1002 ///////////////////////////////////////////////////////////// PlcBookmarks
1003 class Ww1StringList
1004 {
1005     sal_Char** pIdxA;
1006     USHORT nMax;
1007 public:
1008     Ww1StringList( SvStream& rSt, ULONG nFc, USHORT nCb );
1009     ~Ww1StringList()
1010         {   if( pIdxA ) { delete pIdxA[0]; delete pIdxA; } }
1011     const String GetStr( USHORT nNum ) const;
1012     USHORT Count() const    { return nMax; }
1013     BOOL GetError() const   { return (nMax != 0) && !pIdxA; }
1014 };
1015
1016 class Ww1PlcBookmarkTxt: public Ww1StringList
1017 {
1018 public:
1019     Ww1PlcBookmarkTxt(Ww1Fib& rFib) :
1020         Ww1StringList( rFib.GetStream(), rFib.GetFIB().fcSttbfbkmkGet(),
1021                        rFib.GetFIB().cbSttbfbkmkGet() )
1022     {}
1023 };
1024
1025 class Ww1PlcBookmarkPos : public Ww1Plc
1026 {
1027 //  USHORT Fill(USHORT, BYTE&, String&, String&, String&);
1028 public:
1029     Ww1PlcBookmarkPos(Ww1Fib& _rFib, ULONG start, USHORT nBytes, BOOL bEnd)
1030         : Ww1Plc(_rFib, start, nBytes, (bEnd) ? 0 : 2)
1031     {}
1032
1033     BYTE* GetData(USHORT nIndex)    {   return Ww1Plc::GetData(nIndex); }
1034     // Position als CP
1035     ULONG WhereCP(USHORT nIndex)    { return Ww1Plc::Where(nIndex); }
1036     // absolut im file
1037     ULONG Where(USHORT nIndex)
1038     {
1039         return ( nIndex < Count() )
1040                ? Ww1Plc::Where(nIndex) + rFib.GetFIB().fcMinGet()
1041                : 0xffffffff;
1042     }
1043 //  friend ostream& operator <<(ostream&, Ww1PlcBookmarks&);
1044 };
1045
1046 //////////////////////////////////////////////////////////////// PlcHdd
1047 class Ww1PlcHdd : public Ww1Plc
1048 {
1049 public:
1050     Ww1PlcHdd(Ww1Fib& rFibL)
1051         : Ww1Plc(rFibL, rFibL.GetFIB().fcPlcfhddGet(),
1052                     rFibL.GetFIB().cbPlcfhddGet(), 0)
1053     {}
1054 };
1055
1056 /////////////////////////////////////////////////////////////////// Fkp
1057 //
1058 // aehnlich den plcs aufgebaute arrays, die sich auf eine groesze von
1059 // 512 byte beschraenken.
1060 //
1061 class Ww1Fkp
1062 {
1063 protected:
1064     BYTE aFkp[512];
1065     USHORT nItemSize;
1066     BOOL bOK;
1067     BYTE* GetData(USHORT);
1068 public:
1069     Ww1Fkp(SvStream&, ULONG, USHORT);
1070     friend ostream& operator <<(ostream&, Ww1Fkp&);
1071     USHORT Count() const            { return SVBT8ToByte(aFkp+511); }
1072     ULONG Where(USHORT); // wie im entsprechenden fkp
1073 };
1074
1075 //////////////////////////////////////////////////////////////// FkpPap
1076 class Ww1FkpPap : public Ww1Fkp
1077 {
1078 public:
1079     Ww1FkpPap(SvStream& rStream, ULONG ulFilePos)
1080         : Ww1Fkp(rStream, ulFilePos, 1)
1081     {}
1082     friend ostream& operator <<(ostream&, Ww1FkpPap&);
1083     BOOL Fill(USHORT,  BYTE*&, USHORT&);
1084 };
1085
1086 //////////////////////////////////////////////////////////////// FkpChp
1087 class Ww1FkpChp : public Ww1Fkp
1088 {
1089 #ifdef DUMP
1090     SvStream& rStream;
1091     SvStream& GetStream()   { return rStream; }
1092 #endif
1093 public:
1094     Ww1FkpChp(SvStream& rStream, ULONG ulFilePos)
1095         : Ww1Fkp(rStream, ulFilePos, 1)
1096 #ifdef DUMP
1097         , rStream(rStream)
1098 #endif
1099     {}
1100
1101     friend ostream& operator <<(ostream&, Ww1FkpChp&);
1102     BOOL Fill(USHORT, W1_CHP&);
1103 };
1104
1105 ////////////////////////////////////////////////////////////// SprmPapx
1106 class Ww1SprmPapx : public Ww1Sprm
1107 {
1108     W1_PAPX aPapx;
1109     BYTE* Sprm(BYTE* p, USHORT nSize);
1110     USHORT SprmSize(BYTE* p, USHORT nSize);
1111 public:
1112     Ww1SprmPapx(BYTE* p, USHORT nSize);
1113     friend ostream& operator <<(ostream&, Ww1SprmPapx&);
1114     void Start(Ww1Shell&, Ww1Manager&);
1115     void Stop(Ww1Shell&, Ww1Manager&);
1116 };
1117
1118 /////////////////////////////////////////////////////////////// SprmSep
1119 class Ww1SprmSep : public Ww1Sprm
1120 {
1121 public:
1122     Ww1SprmSep(Ww1Fib& rFib, ULONG ulFilePos)
1123         : Ww1Sprm(rFib.GetStream(), ulFilePos)
1124     {}
1125     friend ostream& operator <<(ostream&, Ww1SprmSep&);
1126 };
1127
1128 ///////////////////////////////////////////////////////////////// Assoc
1129 class Ww1Assoc
1130 {
1131     enum fields { FileNext, Dot, Title, Subject, KeyWords, Comments,
1132         Author, LastRevBy, DataDoc, HeaderDoc, Criteria1, Criteria2,
1133         Criteria3, Criteria4, Criteria5, Criteria6, Criteria7, MaxFields };
1134
1135     Ww1Fib& rFib;
1136     sal_Char* pBuffer;
1137     sal_Char* pStrTbl[ MaxFields ];
1138     BOOL bOK;
1139
1140     String GetStr(USHORT);
1141
1142 public:
1143     Ww1Assoc(Ww1Fib&);
1144     ~Ww1Assoc()             { delete pBuffer; }
1145     BOOL GetError() const   { return !bOK; }
1146     friend ostream& operator <<(ostream&, Ww1Assoc&);
1147     void Out(Ww1Shell&);
1148 };
1149
1150 ////////////////////////////////////////////////////////// HeaderFooter
1151 //
1152 // Header/Footer/Footnoteseparators sind einer nach dem naechsten in
1153 // einem eigenen text gespeichert. ein plc trennt diesen text in
1154 // einzelne teile.  diese werden durchnummeriert als ihdd. nun gibt es
1155 // 9 verschiedene funktionen fuer diese texte. wird eine davon
1156 // angefordert, ist es der erste, beim naechstern der 2 ihdd und so
1157 // weiter.  welcher textteil also welcher typ sein wird laeszt sich
1158 // nur bei sequenziellem lesen der datei bestimmen. die 9 typen sind:
1159 // fusznoten-trenner, folge-fusznoten-trenner, folge-fusznoten-notiz,
1160 // gerade-seiten kopfzeilen, ungerade seiten kopfzeilen, dto 2*
1161 // fuszzeilen, kopf & fuszzeilen, wenn erste seite andere zeilen hat.
1162 // HeaderFooter merkt sich fuer jede der 9 die momentane einstellung
1163 // (jedoch nicht die alten) und den naechstvergebbaren ihdd.  ist ein
1164 // teil nicht vorhanden bekommt er den wert 0xffff.
1165 //
1166 class Ww1HeaderFooter : public Ww1PlcHdd
1167 {
1168     USHORT nextIhdd; // naechster textteil im HddText
1169     USHORT nFtnSep; // fusznoten trenner
1170     USHORT nFtnFollowSep; // folge fusznoten trenner
1171     USHORT nFtnNote; // folgefunsznotennotiz
1172     USHORT nEvenHeadL; // kopfzeilen grader seiten
1173     USHORT nOddHeadL; // kopfzeilen ungrader seiten
1174     USHORT nEvenFootL; // fuszzeilen grader seiten
1175     USHORT nOddFootL; // fuszzeilen ungerader seiten
1176     USHORT nFirstHeadL; // kopfzeilen der ersten seite
1177     USHORT nFirstFootL; // fuszzeilen der ersten seite
1178     enum HeaderFooterMode {
1179         None, FtnSep, FtnFollowSep, FtnNote, EvenHeadL, OddHeadL,
1180         EvenFootL, OddFootL, FirstHeadL, MaxHeaderFooterMode
1181     } eHeaderFooterMode;
1182
1183 public:
1184     Ww1HeaderFooter(Ww1Fib& rFibL, USHORT grpfIhdt)
1185         : Ww1PlcHdd(rFibL),
1186         nextIhdd(0),
1187         nFtnSep(0xffff),
1188         nFtnFollowSep(0xffff),
1189         nFtnNote(0xffff),
1190         nEvenHeadL(0xffff),
1191         nOddHeadL(0xffff),
1192         nEvenFootL(0xffff),
1193         nOddFootL(0xffff),
1194         nFirstHeadL(0xffff),
1195         nFirstFootL(0xffff),
1196         eHeaderFooterMode(None)
1197     {
1198         if (grpfIhdt & 0x0001) nFtnSep = nextIhdd++;
1199         if (grpfIhdt & 0x0002) nFtnFollowSep = nextIhdd++;
1200         if (grpfIhdt & 0x0004) nFtnNote = nextIhdd++;
1201     }
1202 //  ~Ww1HeaderFooter() {}
1203     void SetGrpfIhdt(USHORT grpfIhdt)
1204     {
1205         if (grpfIhdt & 0x0001) nEvenHeadL = nextIhdd++;
1206         if (grpfIhdt & 0x0002) nOddHeadL = nextIhdd++;
1207         if (grpfIhdt & 0x0004) nEvenFootL = nextIhdd++;
1208         if (grpfIhdt & 0x0008) nOddFootL = nextIhdd++;
1209         if (grpfIhdt & 0x0010) nFirstHeadL = nextIhdd++;
1210         if (grpfIhdt & 0x0020) nFirstFootL = nextIhdd++;
1211         DBG_ASSERT(nextIhdd<=Count(), "Ww1HeaderFooter");
1212     }
1213     BOOL operator++(int)
1214     {
1215         BOOL bRet = TRUE;
1216         eHeaderFooterMode = (HeaderFooterMode)((short)eHeaderFooterMode + 1);
1217         if( eHeaderFooterMode == MaxHeaderFooterMode)
1218         {
1219             eHeaderFooterMode = None;
1220             bRet = FALSE;
1221         }
1222         return bRet;
1223     }
1224     BOOL FillFtnSep(ULONG& begin, ULONG& end)
1225     {
1226         if (nFtnSep == 0xffff)
1227             return FALSE;
1228         Fill(nFtnSep, begin, end);
1229         return TRUE;
1230     }
1231     BOOL FillFtnFollowSep(ULONG& begin, ULONG& end)
1232     {
1233         if (nFtnFollowSep == 0xffff)
1234             return FALSE;
1235         Fill(nFtnFollowSep, begin, end);
1236         return TRUE;
1237     }
1238     BOOL FillFtnNote(ULONG& begin, ULONG& end)
1239     {
1240         if (nFtnNote == 0xffff)
1241             return FALSE;
1242         Fill(nFtnNote, begin, end);
1243         return TRUE;
1244     }
1245     BOOL FillEvenHeadL(ULONG& begin, ULONG& end)
1246     {
1247         if (nEvenHeadL == 0xffff)
1248             return FALSE;
1249         Fill(nEvenHeadL, begin, end);
1250         return TRUE;
1251     }
1252     BOOL FillOddHeadL(ULONG& begin, ULONG& end)
1253     {
1254         if (nOddHeadL == 0xffff)
1255             return FALSE;
1256         Fill(nOddHeadL, begin, end);
1257         return TRUE;
1258     }
1259     BOOL FillEvenFootL(ULONG& begin, ULONG& end)
1260     {
1261         if (nEvenFootL == 0xffff)
1262             return FALSE;
1263         Fill(nEvenFootL, begin, end);
1264         return TRUE;
1265     }
1266     BOOL FillOddFootL(ULONG& begin, ULONG& end)
1267     {
1268         if (nOddFootL == 0xffff)
1269             return FALSE;
1270         Fill(nOddFootL, begin, end);
1271         return TRUE;
1272     }
1273     BOOL FillFirstHeadL(ULONG& begin, ULONG& end)
1274     {
1275         if (nFirstHeadL == 0xffff)
1276             return FALSE;
1277         Fill(nFirstHeadL, begin, end);
1278         return TRUE;
1279     }
1280     BOOL FillFirstFootL(ULONG& begin, ULONG& end)
1281     {
1282         if (nFirstFootL == 0xffff)
1283             return FALSE;
1284         Fill(nFirstFootL, begin, end);
1285         return TRUE;
1286     }
1287     void Start(Ww1Shell&, Ww1Manager&);
1288     void Stop(Ww1Shell&, Ww1Manager&, sal_Unicode&);
1289 };
1290
1291 //////////////////////////////////////////////////////////////// Fields
1292 class Ww1Fields : public Ww1PlcFields
1293 {
1294     USHORT nPlcIndex;
1295     String sErgebnis; // das von word errechnete ergebniss
1296     SwField* pField;
1297     ULONG Where(USHORT nIndex)  // innerhalb des textes
1298         { return Ww1PlcFields::Where(nIndex) - rFib.GetFIB().fcMinGet(); }
1299
1300 public:
1301     Ww1Fields(Ww1Fib& rFibL, ULONG ulFilePos, USHORT nBytes)
1302         : Ww1PlcFields(rFibL, ulFilePos, nBytes), nPlcIndex(0), pField(0)
1303     {}
1304 //  ~Ww1Fields() {}
1305     // innerhalb des textes
1306     ULONG Where()       { return Where(nPlcIndex); }
1307     void operator++(int)
1308     {
1309         DBG_ASSERT(nPlcIndex+1 <= Count(), "Ww1Fields");
1310         nPlcIndex++;
1311     }
1312     void Seek(ULONG ulNew)      { Ww1PlcFields::Seek(ulNew, nPlcIndex); }
1313     W1_FLD* GetData()
1314     {
1315         DBG_ASSERT(nPlcIndex < Count(), "Ww1Fields");
1316         return Ww1PlcFields::GetData(nPlcIndex);
1317     }
1318     ULONG GetLength();
1319     friend ostream& operator <<(ostream&, Ww1Manager&);
1320     void Start(Ww1Shell&, Ww1Manager&);
1321     void Stop(Ww1Shell&, Ww1Manager&, sal_Unicode&);
1322     void Out(Ww1Shell&, Ww1Manager&, USHORT=0);
1323 };
1324
1325 class Ww1TextFields : public Ww1Fields
1326 {
1327 public:
1328     Ww1TextFields(Ww1Fib& rFibL)
1329         : Ww1Fields(rFibL, rFibL.GetFIB().fcPlcffldMomGet(),
1330                     rFibL.GetFIB().cbPlcffldMomGet())
1331     {}
1332 };
1333
1334 class Ww1FootnoteFields : public Ww1Fields
1335 {
1336 public:
1337     Ww1FootnoteFields(Ww1Fib& rFibL)
1338         : Ww1Fields(rFibL, rFibL.GetFIB().fcPlcffldFtnGet(),
1339                     rFibL.GetFIB().cbPlcffldFtnGet())
1340     {}
1341 };
1342
1343 class Ww1HeaderFooterFields : public Ww1Fields
1344 {
1345 public:
1346     Ww1HeaderFooterFields(Ww1Fib& rFibL)
1347         : Ww1Fields(rFibL, rFibL.GetFIB().fcPlcffldHdrGet(),
1348                     rFibL.GetFIB().cbPlcffldHdrGet())
1349     {}
1350 };
1351
1352 class Ww1MacroFields : public Ww1Fields
1353 {
1354 public:
1355     Ww1MacroFields(Ww1Fib& rFibL)
1356         : Ww1Fields(rFibL, rFibL.GetFIB().fcPlcffldMcrGet(),
1357                     rFibL.GetFIB().cbPlcffldMcrGet())
1358     {}
1359 };
1360
1361 //////////////////////////////////////////////////////////////// Bookmarks
1362 class Ww1Bookmarks
1363 {
1364     Ww1PlcBookmarkTxt aNames;
1365     Ww1PlcBookmarkPos* pPos[2];
1366     Ww1Fib& rFib;
1367
1368     USHORT nPlcIdx[2];
1369     USHORT nIsEnd;
1370     BOOL bOK;
1371 //  ULONG Where(USHORT nIndex) { // innerhalb des textes
1372 //      return Ww1PlcFields::Where(nIndex) - rFib.GetFIB().fcMinGet(); }
1373 public:
1374     Ww1Bookmarks(Ww1Fib& rFib);
1375     ~Ww1Bookmarks()
1376     {
1377             delete pPos[1];
1378             delete pPos[0];
1379     }
1380     ULONG Where() const     { return pPos[nIsEnd]->WhereCP(nPlcIdx[nIsEnd]); }
1381     void operator++(int);
1382     BOOL GetError() const   { return !bOK; }
1383     long GetHandle() const;
1384     BOOL GetIsEnd() const   { return ( nIsEnd ) ? TRUE : FALSE; }
1385     const String GetName() const;
1386     long Len() const;
1387     friend ostream& operator <<(ostream&, Ww1Bookmarks&);
1388     void Start(Ww1Shell&, Ww1Manager&);
1389     void Stop(Ww1Shell&, Ww1Manager&, sal_Unicode&);
1390     void Out(Ww1Shell&, Ww1Manager&, USHORT=0);
1391 };
1392
1393 ///////////////////////////////////////////////////////////// Footnotes
1394 class Ww1Footnotes : public Ww1PlcFootnoteRef
1395 {
1396     USHORT nPlcIndex;
1397     Ww1PlcFootnoteTxt aText;
1398     BOOL bStarted;
1399 public:
1400     Ww1Footnotes(Ww1Fib& rFibL)
1401         : Ww1PlcFootnoteRef(rFibL), nPlcIndex(0), aText(rFibL), bStarted(FALSE)
1402     {}
1403 //  ~Ww1Footnotes() {}
1404     // innerhalb des textes
1405     ULONG Where()
1406     {
1407         ULONG ulRet = 0xffffffff;
1408         if (Count())
1409             ulRet = Ww1PlcFootnoteRef::Where(nPlcIndex);
1410         return ulRet;
1411     }
1412     void operator++(int)
1413     {
1414         DBG_ASSERT(nPlcIndex+1 <= Count(), "Ww1Footnotes");
1415         nPlcIndex++;
1416     }
1417     void Start(Ww1Shell&, Ww1Manager&);
1418     void Stop(Ww1Shell&, Ww1Manager&, sal_Unicode&);
1419 };
1420
1421 /////////////////////////////////////////////////////////////////// Sep
1422 class Ww1Sep : public Ww1PlcSep
1423 {
1424     Ww1HeaderFooter aHdd;
1425     USHORT nPlcIndex;
1426 public:
1427     Ww1Sep(Ww1Fib& rFibL, USHORT grpfIhdt)
1428     : Ww1PlcSep(rFibL), aHdd(rFibL, grpfIhdt), nPlcIndex(0) {}
1429
1430     Ww1HeaderFooter& GetHdd()   { return aHdd; }
1431     void operator++(int)        { nPlcIndex++; }
1432     BYTE* GetData()             { return Ww1PlcSep::GetData(nPlcIndex); }
1433     // innerhalb des textes
1434     ULONG Where()               { return Ww1PlcSep::Where(nPlcIndex); }
1435     void SetGrpfIhdt(BYTE grpfIhdt)
1436     {
1437         GetHdd().SetGrpfIhdt(grpfIhdt);
1438 //      GetHdd().Start(rOut, rMan);
1439     }
1440     void Start(Ww1Shell&, Ww1Manager&);
1441     void Stop(Ww1Shell& rOut, Ww1Manager& rMan, sal_Unicode& c)
1442         { aHdd.Stop(rOut, rMan, c); }
1443 };
1444
1445 /////////////////////////////////////////////////////////////////// Pap
1446 class Ww1Pap : public Ww1PlcPap
1447 {
1448     USHORT nPlcIndex;
1449     USHORT nPushedPlcIndex;
1450     USHORT nFkpIndex;
1451     USHORT nPushedFkpIndex;
1452     ULONG ulOffset;
1453     Ww1FkpPap* pPap;
1454
1455     BOOL FindSprm(USHORT nId, BYTE* pStart, BYTE* pEnd);
1456     void UpdateIdx()
1457     {
1458         if (pPap && nFkpIndex >= pPap->Count() )
1459         {
1460             delete pPap;
1461             pPap = NULL;
1462             nPlcIndex++;
1463         }
1464         if( !pPap )
1465             Where();
1466     }
1467     BOOL HasId0(USHORT nId);
1468
1469 public:
1470     Ww1Pap(Ww1Fib& rFib);
1471     ~Ww1Pap()   { delete pPap; }
1472     ULONG Where( BOOL bSetIndex = TRUE ); // innerhalb des textes
1473     void operator++(int);
1474     BOOL FillStart(BYTE*& pB, USHORT& nSize)
1475     {
1476         UpdateIdx();
1477         return pPap->Fill(nFkpIndex, pB, nSize);
1478     }
1479     BOOL FillStop(BYTE*& pB, USHORT& nSize)
1480     {
1481         return nFkpIndex ? pPap->Fill(nFkpIndex-1, pB, nSize) : FALSE;
1482     }
1483     void Start(Ww1Shell&, Ww1Manager&);
1484     void Stop(Ww1Shell&, Ww1Manager&, sal_Unicode&);
1485     void Seek(ULONG);
1486     void Push(ULONG ulOffsetTmp = 0)
1487     {
1488         DBG_ASSERT(!Pushed(), "Ww1Pap");
1489         nPushedPlcIndex = nPlcIndex;
1490         nPushedFkpIndex = nFkpIndex;
1491         Seek(ulOffsetTmp);
1492         ulOffset = ulOffsetTmp;
1493         delete pPap;
1494         pPap = NULL;
1495     }
1496     BOOL Pushed()
1497     {
1498         return nPushedPlcIndex != 0xffff;
1499     }
1500     void Pop()
1501     {
1502         DBG_ASSERT(Pushed(), "Ww1Pap");
1503         ulOffset = 0;
1504         nPlcIndex = nPushedPlcIndex;
1505         nFkpIndex = nPushedFkpIndex;
1506         nPushedPlcIndex = 0xffff;
1507         nPushedFkpIndex = 0xffff;
1508         delete pPap;
1509         pPap = NULL;
1510         Where( FALSE );
1511     }
1512     BOOL HasId(USHORT nId);
1513 };
1514
1515 /////////////////////////////////////////////////////////////////// Chp
1516 class Ww1Chp : public Ww1PlcChp
1517 {
1518     USHORT nPlcIndex;
1519     USHORT nPushedPlcIndex;
1520     USHORT nFkpIndex;
1521     USHORT nPushedFkpIndex;
1522     ULONG ulOffset;
1523     Ww1FkpChp* pChp;
1524     void UpdateIdx()
1525     {
1526         if (pChp && nFkpIndex >= pChp->Count() )
1527         {
1528             delete pChp;
1529             pChp = NULL;
1530             nPlcIndex++;
1531         }
1532         if( !pChp )
1533             Where();
1534     }
1535
1536 public:
1537     Ww1Chp( Ww1Fib& rFib );
1538     ~Ww1Chp()   { delete pChp; }
1539     ULONG Where( BOOL bSetIndex = TRUE ); // innerhalb des textes
1540     void operator++(int);
1541     BOOL FillStart(W1_CHP& rChp)
1542     {
1543         UpdateIdx();
1544         return pChp->Fill(nFkpIndex, rChp);
1545     }
1546     BOOL FillStop(W1_CHP& rChp)
1547     { return nFkpIndex ? pChp->Fill(nFkpIndex-1, rChp) : FALSE;  }
1548     void Start(Ww1Shell&, Ww1Manager&);
1549     void Stop(Ww1Shell&, Ww1Manager&, sal_Unicode&);
1550     void Seek(ULONG);
1551     void Push(ULONG ulOffsetTmp = 0)
1552     {
1553         DBG_ASSERT(!Pushed(), "Ww1Chp");
1554         nPushedPlcIndex = nPlcIndex;
1555         nPushedFkpIndex = nFkpIndex;
1556         Seek(ulOffsetTmp);
1557         ulOffset = ulOffsetTmp;
1558         delete pChp;
1559         pChp = NULL;
1560     }
1561     BOOL Pushed()               { return nPushedPlcIndex != 0xffff; }
1562     void Pop()
1563     {
1564         DBG_ASSERT(Pushed(), "Ww1Chp");
1565         ulOffset = 0;
1566         nPlcIndex = nPushedPlcIndex;
1567         nFkpIndex = nPushedFkpIndex;
1568         nPushedPlcIndex = 0xffff;
1569         nPushedFkpIndex = 0xffff;
1570         delete pChp;
1571         pChp = NULL;
1572         Where( FALSE );
1573     }
1574 };
1575
1576 /////////////////////////////////////////////////////////////// Manager
1577 //
1578 // zentraler aufhaenger der ww-seite des filters, konstruiert aus dem
1579 // inputstream (ww-datei) enthaelt er alles, was noetig ist, um in die
1580 // shell (pm-seite) gepiped zu werden.
1581 //
1582 class Ww1Manager
1583 {
1584     BOOL bOK;
1585     BOOL bInTtp;
1586     BOOL bInStyle;
1587     BOOL bStopAll;
1588     Ww1Fib aFib;
1589     Ww1Dop aDop;
1590     Ww1Fonts aFonts;
1591 // ab jetzt alles paarig, fuer 'pushed':
1592     Ww1DocText aDoc;
1593     Ww1PlainText* pDoc;
1594     ULONG ulDocSeek;
1595     ULONG* pSeek;
1596     Ww1TextFields aFld;
1597     Ww1Fields* pFld;
1598 // selbst 'push'bar:
1599     Ww1Chp aChp;
1600     Ww1Pap aPap;
1601 // nicht in textbereichen vorhanden, wenn ge'pushed'
1602     Ww1Footnotes aFtn;
1603     Ww1Bookmarks aBooks;
1604     Ww1Sep aSep;
1605
1606     void OutStop( Ww1Shell&, sal_Unicode );
1607     void OutStart( Ww1Shell& );
1608     void Out(Ww1Shell&, sal_Unicode );
1609
1610 public:
1611     Ww1Manager(SvStream& rStrm, ULONG nFieldFlgs);
1612     BOOL GetError() const       { return !bOK; }
1613
1614 // Fuer Tabellen
1615     void SetInTtp(BOOL bSet = TRUE)     { bInTtp = bSet; }
1616     BOOL IsInTtp() const                { return bInTtp; }
1617     void SetInStyle(BOOL bSet = TRUE)   { bInStyle = bSet; }
1618     BOOL IsInStyle() const              { return bInStyle; }
1619     void SetStopAll(BOOL bSet = TRUE)   { bStopAll = bSet; }
1620     BOOL IsStopAll() const              { return bStopAll; }
1621     BOOL HasInTable();
1622     BOOL HasTtp();
1623     BOOL LastHasTtp();
1624
1625 // Fuer Flys
1626     BOOL HasPPc();
1627     BOOL HasPDxaAbs();
1628
1629     Ww1Fib& GetFib()                    { return aFib; }
1630     Ww1PlainText& GetText()             { return *pDoc; }
1631     Ww1Dop& GetDop()                    { return aDop; }
1632     Ww1Sep& GetSep()                    { return aSep; }
1633     // innerhalb des textes
1634     ULONG Where()                       { return pDoc->Where(); }
1635     void Fill( sal_Unicode& rChr )      { pDoc->Out( rChr ); }
1636     BYTE Fill( String& rStr, ULONG ulLen)
1637     {
1638         ulLen += pDoc->Where();
1639         return sal::static_int_cast< BYTE >(pDoc->Out(rStr, ulLen));
1640     }
1641     SvxFontItem GetFont(USHORT nFCode);
1642     friend Ww1Shell& operator <<(Ww1Shell&, Ww1Manager&);
1643     friend ostream& operator <<(ostream&, Ww1Manager&);
1644     BOOL Pushed()                       { return pDoc != &aDoc; }
1645     void Pop();
1646     void Push0(Ww1PlainText* pDoc, ULONG, Ww1Fields* = 0);
1647     void Push1(Ww1PlainText* pDoc, ULONG ulSeek, ULONG ulSeek2 = 0,
1648                Ww1Fields* = 0);
1649 };