sw/source/filter/ww8/ww8par.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_SW_SOURCE_FILTER_WW8_WW8PAR_HXX
  21 #define INCLUDED_SW_SOURCE_FILTER_WW8_WW8PAR_HXX
  22
  23 #include <rtl/ustring.hxx>
  24 #include <filter/msfilter/msdffimp.hxx>
  25 #include <filter/msfilter/util.hxx>
  26 #include <editeng/frmdir.hxx>
  27 #include <fltshell.hxx>
  28
  29 #include <svx/svdobj.hxx>
  30
  31 #include <vector>
  32 #include <stack>
  33 #include <string_view>
  34 #include <deque>
  35 #include <map>
  36 #include <utility>
  37 #include <memory>
  38
  39 #include "ww8struc.hxx"
  40 #include "ww8scan.hxx"
  41 #include "ww8glsy.hxx"
  42 #include "ww8graf.hxx"
  43 #include "wrtww8.hxx"
  44 #include <msfilter.hxx>
  45 #include <xmloff/odffields.hxx>
  46 #include <IMark.hxx>
  47
  48 #include <com/sun/star/drawing/TextVerticalAdjust.hpp>
  49 #include <swtypes.hxx>
  50 #include <fmtfsize.hxx>
  51 #include <fmtornt.hxx>
  52 #include <fmtsrnd.hxx>
  53 #include <ndtxt.hxx>
  54 #include <editeng/lrspitem.hxx>
  55 #include <o3tl/deleter.hxx>
  56 #include <o3tl/sorted_vector.hxx>
  57 #include <oox/ole/olehelper.hxx>
  58
  59 #define SW_UD_IMAPDATA      2
  60
  61 class SwDoc;
  62 class SwPaM;
  63 class SfxPoolItem;
  64 class SwTextFormatColl;
  65 class SwPageDesc;
  66 class SvxBoxItem;
  67 class SwFormat;
  68 class SwNodeIndex;
  69 class SwFlyFrameFormat;
  70 class SwAttrSet;
  71 class SwNumRule;
  72 class SwFrameFormat;
  73 class Writer;
  74 class SwFormatField;
  75 class WW8Fib;
  76 class WW8PLCFMan;
  77 struct WW8PLCFManResult;
  78 class WW8RStyle;
  79 class WW8PLCF_HdFt;
  80 class WW8ScannerBase;
  81 struct WW8FlyPara;
  82 struct WW8SwFlyPara;
  83 struct WW8_PIC;
  84 class WW8TabDesc;
  85 struct WW8_SHD;
  86 struct WW8_OLST;
  87 class SwNumFormat;
  88 struct WW8_ANLD;
  89 struct WW8_ANLV;
  90 struct WW8_DO;
  91 struct WW8_DPHEAD;
  92 struct WW8_FSPA;
  93 class SdrModel;
  94 class SdrPage;
  95 class SdrObject;
  96 class SdrTextObj;
  97 class SdrUnoObj;
  98 class Size;
  99 class EditEngine;
 100 struct SwPosition;
 101 class WW8ReaderSave;
 102 struct WW8PicDesc;
 103 class Graphic;
 104 class SwFieldType;
 105 class SotStorage;
 106 class SwAttrSet;
 107 class GDIMetaFile;
 108 struct ESelection;
 109 class SfxItemSet;
 110 class OutlinerParaObject;
 111
 112 namespace com::sun::star{
 113     namespace beans{ class XPropertySet;}
 114     namespace form { class XFormComponent;}
 115     namespace drawing{class XShape;}
 116     namespace lang{class XMultiServiceFactory;}
 117 }
 118
 119 // defines only for the WW8-variable of the INI file
 120 #define WW8FL_NO_STYLES      2
 121 #define WW8FL_NO_GRAF     0x80
 122
 123 #define WW8FL_NO_OUTLINE         0x1000
 124 #define WW8FL_NO_IMPLPASP        0x4000  // no implicit para space
 125 #define WW8FL_NO_GRAFLAYER       0x8000
 126
 127 // Add-on-filter-flags, valid from Winword 8 on
 128 #define WW8FL_NO_FLY_FOR_TXBX         1
 129
 130 //            List-Manager (from Ver8 on)
 131
 132 struct WW8LFOInfo;
 133
 134 class WW8Reader : public StgReader
 135 {
 136     std::shared_ptr<SvStream> mDecodedStream;
 137     virtual ErrCode Read(SwDoc &, const OUString& rBaseURL, SwPaM &, const OUString &) override;
 138     ErrCode OpenMainStream( tools::SvRef<SotStorageStream>& rRef, sal_uInt16& rBuffSize );
 139     ErrCode DecryptDRMPackage();
 140 public:
 141     WW8Reader() {}
 142     virtual SwReaderType GetReaderType() override;
 143
 144     virtual bool HasGlossaries() const override;
 145     virtual bool ReadGlossaries( SwTextBlocks&, bool bSaveRelFiles ) const override;
 146 };
 147
 148 class SwWW8ImplReader;
 149 struct WW8LSTInfo;
 150 class WW8ListManager
 151 {
 152 public:
 153     WW8ListManager(SvStream& rSt_, SwWW8ImplReader& rReader_);
 154     //Min and Max possible List Levels in Word
 155     enum ListLevel {nMinLevel=1, nMaxLevel=9};
 156     //the rParaSprms returns back the original word paragraph indent
 157     //sprms which were attached to the original numbering format
 158     SwNumRule* GetNumRuleForActivation(sal_uInt16 nLFOPosition, const sal_uInt8 nLevel,
 159         std::vector<sal_uInt8> &rParaSprms, SwTextNode *pNode=nullptr);
 160     SwNumRule* CreateNextRule(bool bSimple);
 161     ~WW8ListManager() COVERITY_NOEXCEPT_FALSE;
 162     SwNumRule* GetNumRule(size_t i);
 163     size_t GetWW8LSTInfoNum() const{return maLSTInfos.size();}
 164     static SvxNumType GetSvxNumTypeFromMSONFC(sal_uInt16 nMSONFC);
 165
 166 private:
 167     wwSprmParser maSprmParser;
 168     SwWW8ImplReader& rReader;
 169     SwDoc&           rDoc;
 170     const WW8Fib&    rFib;
 171     SvStream&        rSt;
 172     std::vector<std::unique_ptr<WW8LSTInfo>> maLSTInfos;
 173     std::vector<std::unique_ptr<WW8LFOInfo>> m_LFOInfos;// D. from PLF LFO, sorted exactly like in the WW8 Stream
 174     sal_uInt16       nUniqueList; // current number for creating unique list names
 175     SprmResult GrpprlHasSprm(sal_uInt16 nId, sal_uInt8& rSprms, sal_uInt8 nLen);
 176     WW8LSTInfo* GetLSTByListId(    sal_uInt32  nIdLst     ) const;
 177     //the rParaSprms returns back the original word paragraph indent
 178     //sprms which are attached to this numbering level
 179     bool ReadLVL(SwNumFormat& rNumFormat, std::unique_ptr<SfxItemSet>& rpItemSet, sal_uInt16 nLevelStyle,
 180         bool bSetStartNo, sal_uInt16 nLevel, ww::bytes &rParaSprms);
 181
 182     // character attributes from GrpprlChpx
 183     typedef std::unique_ptr<SfxItemSet> WW8aISet[nMaxLevel];
 184     // character style pointer
 185     typedef SwCharFormat* WW8aCFormat[nMaxLevel];
 186
 187     void AdjustLVL(sal_uInt8 nLevel, SwNumRule& rNumRule, WW8aISet const & rListItemSet,
 188         WW8aCFormat& aCharFormat, bool& bNewCharFormatCreated,
 189         const OUString& aPrefix = OUString());
 190
 191     WW8ListManager(const WW8ListManager&) = delete;
 192     WW8ListManager& operator=(const WW8ListManager&) = delete;
 193     sal_uInt16 nLastLFOPosition;
 194 };
 195
 196 struct WW8FlyPara
 197 {                       // WinWord-attributes
 198                         // Attention: *DO NOT* reorder, since parts will be
 199                         // compared using memcmp
 200     bool bVer67;
 201     sal_Int16 nSp26, nSp27;         // raw position
 202     sal_Int16 nSp45, nSp28;         // width / height
 203     sal_Int16 nLeMgn, nRiMgn, nUpMgn, nLoMgn;           // borders
 204     sal_uInt8 nSp29;                 // raw binding + alignment
 205     sal_uInt8 nSp37;                 // Wrap-Mode ( 1 / 2; 0 = no Apo ? )
 206     WW8_BRCVer9_5 brc;          // borders Top, Left, Bottom, Right, Between
 207     bool bBorderLines;          // border lines
 208     bool bGrafApo;              // true: this frame is only used to position
 209                                 // the contained graphics *not* as a character
 210     bool mbVertSet;             // true if vertical positioning has been set
 211
 212     WW8FlyPara(bool bIsVer67, const WW8FlyPara* pSrc = nullptr);
 213     bool operator==(const WW8FlyPara& rSrc) const;
 214     void Read(sal_uInt8 nSprm29, WW8PLCFx_Cp_FKP* pPap);
 215     void ReadFull(sal_uInt8 nSprm29, SwWW8ImplReader* pIo);
 216     void Read(sal_uInt8 nSprm29, WW8RStyle const * pStyle);
 217     void ApplyTabPos(const WW8_TablePos *pTabPos);
 218     bool IsEmpty() const;
 219 };
 220
 221 class SwWW8StyInf
 222 {
 223     OUString        m_sWWStyleName;
 224     sal_uInt16      m_nWWStyleId;
 225 public:
 226     rtl_TextEncoding m_eLTRFontSrcCharSet;    // rtl_TextEncoding for the font
 227     rtl_TextEncoding m_eRTLFontSrcCharSet;    // rtl_TextEncoding for the font
 228     rtl_TextEncoding m_eCJKFontSrcCharSet;    // rtl_TextEncoding for the font
 229     SwFormat*      m_pFormat;
 230     std::shared_ptr<WW8FlyPara> m_xWWFly;
 231     SwNumRule*  m_pOutlineNumrule;
 232     tools::Long        m_nFilePos;
 233     sal_uInt16      m_nBase;
 234     sal_uInt16      m_nFollow;
 235     sal_uInt16      m_nLFOIndex;
 236     sal_uInt8        m_nListLevel;
 237
 238     // WW8 outline level is zero-based:
 239     // 0: outline level 1
 240     // 1: outline level 2
 241     // ...
 242     // 8: outline level 9
 243     // 9: body text
 244     sal_uInt8 mnWW8OutlineLevel;
 245
 246     sal_uInt16  m_n81Flags;           // for bold, italic, ...
 247     sal_uInt16  m_n81BiDiFlags;       // for bold, italic, ...
 248     std::shared_ptr<SvxLRSpaceItem> maWordLR;
 249     bool m_bValid;            // empty of valid
 250     bool m_bImported;         // for recursive imports
 251     bool m_bColl;             // true-> pFormat is SwTextFormatColl
 252     bool m_bImportSkipped;    // only true if !bNewDoc && existing style
 253     bool m_bHasStyNumRule;    // true-> named NumRule in style
 254     bool m_bHasBrokenWW6List; // true-> WW8+ style has a WW7- list
 255     bool m_bListRelevantIndentSet; //true if this style's indent has
 256                                  //been explicitly set, it's set to the value
 257                                  //of pFormat->GetItemState(RES_LR_SPACE, false)
 258                                  //if it was possible to get the ItemState
 259                                  //for L of the LR space independently
 260     bool m_bParaAutoBefore;   // For Auto spacing before a paragraph
 261     bool m_bParaAutoAfter;    // For Auto Spacing after a paragraph
 262     sal_Int16 m_nRelativeJustify;
 263
 264     SwWW8StyInf() :
 265         m_sWWStyleName( OUString() ),
 266         m_nWWStyleId( 0 ),
 267         m_eLTRFontSrcCharSet(0),
 268         m_eRTLFontSrcCharSet(0),
 269         m_eCJKFontSrcCharSet(0),
 270         m_pFormat( nullptr ),
 271         m_pOutlineNumrule( nullptr ),
 272         m_nFilePos( 0 ),
 273         m_nBase( 0 ),
 274         m_nFollow( 0 ),
 275         m_nLFOIndex( USHRT_MAX ),
 276         m_nListLevel(MAXLEVEL),
 277         mnWW8OutlineLevel( MAXLEVEL ),
 278         m_n81Flags( 0 ),
 279         m_n81BiDiFlags(0),
 280         maWordLR(std::make_shared<SvxLRSpaceItem>(RES_LR_SPACE)),
 281         m_bValid(false),
 282         m_bImported(false),
 283         m_bColl(false),
 284         m_bImportSkipped(false),
 285         m_bHasStyNumRule(false),
 286         m_bHasBrokenWW6List(false),
 287         m_bListRelevantIndentSet(false),
 288         m_bParaAutoBefore(false),
 289         m_bParaAutoAfter(false),
 290         m_nRelativeJustify(-1)
 291
 292     {}
 293
 294     void SetOrgWWIdent( const OUString& rName, const sal_uInt16 nId )
 295     {
 296         m_sWWStyleName = rName;
 297         m_nWWStyleId = nId;
 298
 299         // apply default WW8 outline level to WW8 Built-in Heading styles
 300         if (IsWW8BuiltInHeadingStyle())
 301         {
 302             mnWW8OutlineLevel = m_nWWStyleId - 1;
 303         }
 304     }
 305
 306     const OUString& GetOrgWWName() const
 307     {
 308         return m_sWWStyleName;
 309     }
 310
 311     bool HasWW8OutlineLevel() const
 312     {
 313         return (m_pFormat != nullptr && (MAXLEVEL > mnWW8OutlineLevel));
 314     }
 315
 316     bool IsOutlineNumbered() const
 317     {
 318         return m_pOutlineNumrule && HasWW8OutlineLevel();
 319     }
 320
 321     const SwNumRule* GetOutlineNumrule() const
 322     {
 323         return m_pOutlineNumrule;
 324     }
 325     rtl_TextEncoding GetCharSet() const;
 326     rtl_TextEncoding GetCJKCharSet() const;
 327
 328     sal_uInt16 GetWWStyleId() const
 329     {
 330         return m_nWWStyleId;
 331     }
 332
 333     bool IsWW8BuiltInHeadingStyle() const
 334     {
 335         return GetWWStyleId() >= 1 && GetWWStyleId() <= 9;
 336     }
 337
 338     bool IsWW8BuiltInDefaultStyle() const
 339     {
 340         return GetWWStyleId() == 0;
 341     }
 342
 343     static sal_uInt8
 344     WW8OutlineLevelToOutlinelevel(const sal_uInt8 nWW8OutlineLevel)
 345     {
 346         if (nWW8OutlineLevel < MAXLEVEL)
 347         {
 348             if (nWW8OutlineLevel == 9)
 349             {
 350                 return 0; // no outline level --> body text
 351             }
 352             else
 353             {
 354                 return nWW8OutlineLevel + 1; // outline level 1..9
 355             }
 356         }
 357
 358         return 0;
 359     }
 360 };
 361
 362 //            Stack
 363
 364 class SwWW8FltControlStack : public SwFltControlStack
 365 {
 366 private:
 367     SwWW8ImplReader& rReader;
 368     std::unique_ptr<SfxItemSet> m_xScratchSet;
 369     sal_uInt16 nToggleAttrFlags;
 370     sal_uInt16 nToggleBiDiAttrFlags;
 371     SwWW8FltControlStack(const SwWW8FltControlStack&) = delete;
 372     SwWW8FltControlStack& operator=(const SwWW8FltControlStack&) = delete;
 373     const SwNumFormat* GetNumFormatFromStack(const SwPosition &rPos,
 374         const SwTextNode &rTextNode);
 375 protected:
 376     virtual void SetAttrInDoc(const SwPosition& rTmpPos,
 377         SwFltStackEntry& rEntry) override;
 378
 379 public:
 380     SwWW8FltControlStack(SwDoc& rDo, sal_uLong nFieldFl, SwWW8ImplReader& rReader_ )
 381         : SwFltControlStack( rDo, nFieldFl ), rReader( rReader_ ),
 382         nToggleAttrFlags(0), nToggleBiDiAttrFlags(0)
 383     {}
 384
 385     void NewAttr(const SwPosition& rPos, const SfxPoolItem& rAttr);
 386
 387     virtual SwFltStackEntry* SetAttr(const SwPosition& rPos, sal_uInt16 nAttrId, bool bTstEnd=true, tools::Long nHand=LONG_MAX, bool consumedByField=false) override;
 388
 389     void SetToggleAttr(sal_uInt8 nId, bool bOn)
 390     {
 391         if( bOn )
 392             nToggleAttrFlags |= (1 << nId);
 393         else
 394             nToggleAttrFlags &= ~(1 << nId);
 395     }
 396
 397     sal_uInt16 GetToggleAttrFlags() const { return nToggleAttrFlags; }
 398
 399     void SetToggleBiDiAttr(sal_uInt8 nId, bool bOn)
 400     {
 401         if( bOn )
 402             nToggleBiDiAttrFlags |= (1 << nId);
 403         else
 404             nToggleBiDiAttrFlags &= ~(1 << nId);
 405     }
 406
 407     sal_uInt16 GetToggleBiDiAttrFlags() const { return nToggleBiDiAttrFlags; }
 408     void SetToggleAttrFlags(sal_uInt16 nFlags) { nToggleAttrFlags = nFlags; }
 409     void SetToggleBiDiAttrFlags(sal_uInt16 nFlags) {nToggleBiDiAttrFlags = nFlags;}
 410
 411     const SfxPoolItem* GetFormatAttr(const SwPosition& rPos, sal_uInt16 nWhich);
 412     template<class T> const T* GetFormatAttr( const SwPosition& rPos, TypedWhichId<T> nWhich )
 413     {
 414         return static_cast<const T*>(GetFormatAttr(rPos, sal_uInt16(nWhich)));
 415     }
 416     const SfxPoolItem* GetStackAttr(const SwPosition& rPos, sal_uInt16 nWhich);
 417 };
 418
 419 //The only thing this is for is RES_FLTR_ANCHOR, anything else is an error.
 420 //For graphics whose anchoring position would otherwise be automatically moved
 421 //along by the insertion of text.
 422 class SwWW8FltAnchorStack : public SwFltControlStack
 423 {
 424 public:
 425     SwWW8FltAnchorStack(SwDoc& rDo, sal_uLong nFieldFl)
 426         : SwFltControlStack( rDo, nFieldFl ) {}
 427     void AddAnchor(const SwPosition& rPos,SwFrameFormat *pFormat);
 428     void Flush();
 429 private:
 430     SwWW8FltAnchorStack(const SwWW8FltAnchorStack&) = delete;
 431     SwWW8FltAnchorStack& operator=(const SwWW8FltAnchorStack&) = delete;
 432 };
 433
 434
 435 namespace SwWW8
 436 {
 437     struct ltstr
 438     {
 439         bool operator()(const OUString &r1, std::u16string_view r2) const
 440         {
 441             return r1.compareToIgnoreAsciiCase(r2)<0;
 442         }
 443     };
 444
 445     struct ltnode
 446     {
 447         bool operator()(const SwTextNode *r1, const SwTextNode *r2) const
 448         {
 449             return r1->GetIndex() < r2->GetIndex();
 450         }
 451     };
 452 };
 453
 454 class SwWW8ReferencedFltEndStack : public SwFltEndStack
 455 {
 456 public:
 457     SwWW8ReferencedFltEndStack( SwDoc& rDo, sal_uLong nFieldFl )
 458         : SwFltEndStack( rDo, nFieldFl )
 459         , aReferencedTOCBookmarks()
 460     {}
 461
 462     // Keep track of referenced TOC bookmarks in order to suppress the import
 463     // of unreferenced ones.
 464     std::set<OUString, SwWW8::ltstr> aReferencedTOCBookmarks;
 465 protected:
 466     virtual void SetAttrInDoc( const SwPosition& rTmpPos,
 467                                SwFltStackEntry& rEntry ) override;
 468 };
 469
 470 class SwWW8FltRefStack final : public SwFltEndStack
 471 {
 472 public:
 473     SwWW8FltRefStack(SwDoc& rDo, sal_uLong nFieldFl)
 474         : SwFltEndStack( rDo, nFieldFl )
 475         , aFieldVarNames()
 476     {}
 477     bool IsFootnoteEdnBkmField(const SwFormatField& rFormatField, sal_uInt16& rBkmNo);
 478
 479     //Keep track of variable names created with fields, and the bookmark
 480     //mapped to their position, hopefully the same, but very possibly
 481     //an additional pseudo bookmark
 482     std::map<OUString, OUString, SwWW8::ltstr> aFieldVarNames;
 483 private:
 484     SwFltStackEntry *RefToVar(const SwField* pField,SwFltStackEntry& rEntry);
 485     virtual void SetAttrInDoc(const SwPosition& rTmpPos,
 486         SwFltStackEntry& rEntry) override;
 487     SwWW8FltRefStack(const SwWW8FltRefStack&) = delete;
 488     SwWW8FltRefStack& operator=(const SwWW8FltRefStack&) = delete;
 489 };
 490
 491 template< typename Type >
 492 inline bool get_flag( Type nBitField, Type nMask )
 493 { return (nBitField & nMask) != 0; }
 494
 495 template< typename ReturnType, typename Type >
 496 inline ReturnType ulimit_cast( Type nValue, ReturnType nMax )
 497 { return static_cast< ReturnType >( std::min< Type >( nValue, nMax ) ); }
 498
 499 template< typename ReturnType, typename Type >
 500 inline ReturnType ulimit_cast( Type nValue )
 501 { return ulimit_cast( nValue, std::numeric_limits< ReturnType >::max() ); }
 502
 503 class SwMacroInfo : public SdrObjUserData
 504 {
 505 public:
 506     SwMacroInfo();
 507     virtual ~SwMacroInfo() override;
 508
 509     SwMacroInfo(SwMacroInfo const &) = default;
 510     SwMacroInfo(SwMacroInfo &&) = default;
 511     SwMacroInfo & operator =(SwMacroInfo const &) = delete; // due to SdrObjUserData
 512     SwMacroInfo & operator =(SwMacroInfo &&) = delete; // due to SdrObjUserData
 513
 514     virtual std::unique_ptr<SdrObjUserData> Clone( SdrObject* pObj ) const override;
 515
 516     void SetHlink( const OUString& rHlink ) { maHlink = rHlink; }
 517     const OUString& GetHlink() const { return maHlink; }
 518     void SetTarFrame( const OUString& rTarFrame ) { maTarFrame = rTarFrame; }
 519     const OUString& GetTarFrame() const { return maTarFrame; }
 520     void SetShapeId( sal_Int32 rShapeId ) { mnShapeId = rShapeId; }
 521     const sal_Int32& GetShapeId() const { return mnShapeId; }
 522     void SetName( const OUString& rName ) { maNameStr = rName; }
 523     const OUString& GetName() const { return maNameStr; }
 524
 525 private:
 526     sal_Int32 mnShapeId;
 527     OUString maHlink;
 528     OUString maNameStr;
 529     OUString maTarFrame;
 530 };
 531
 532 struct HyperLinksTable
 533 {
 534     OUString hLinkAddr;
 535     OUString tarFrame;
 536 };
 537
 538 namespace sw
 539 {
 540     namespace hack
 541     {
 542         class Position
 543         {
 544         private:
 545             SwNodeIndex maPtNode;
 546             sal_Int32 mnPtContent;
 547         public:
 548             explicit Position(const SwPosition &rPos);
 549             operator SwPosition() const;
 550             const SwNodeIndex& GetPtNode() const { return maPtNode; };
 551             sal_Int32 GetPtContent() const { return mnPtContent; };
 552         };
 553     }
 554
 555     auto FilterControlChars(OUString const& rString) -> OUString;
 556 }
 557
 558 class WW8FieldEntry
 559 {
 560     private:
 561         OUString msBookmarkName;
 562         OUString msMarkType;
 563         OUString msMarkCode;
 564         ::sw::mark::IFieldmark::parameter_map_t maParams;
 565
 566     public:
 567         sw::hack::Position maStartPos;
 568         sal_uInt16 mnFieldId;
 569         sal_uLong mnObjLocFc;
 570         WW8FieldEntry(SwPosition const &rPos, sal_uInt16 nFieldId) noexcept;
 571         WW8FieldEntry(const WW8FieldEntry &rOther) noexcept;
 572         WW8FieldEntry &operator=(const WW8FieldEntry &rOther) noexcept;
 573         void Swap(WW8FieldEntry &rOther) noexcept;
 574
 575         SwNodeIndex GetPtNode() const { return maStartPos.GetPtNode(); };
 576         sal_Int32 GetPtContent() const { return maStartPos.GetPtContent(); };
 577
 578         const OUString& GetBookmarkName() const { return msBookmarkName;}
 579         const OUString& GetBookmarkCode() const { return msMarkCode;}
 580         void SetBookmarkName(const OUString& bookmarkName);
 581         void SetBookmarkType(const OUString& bookmarkType);
 582         void SetBookmarkCode(const OUString& bookmarkCode);
 583         ::sw::mark::IFieldmark::parameter_map_t& getParameters() { return maParams;}
 584 };
 585
 586 //    mini marker for some flags
 587
 588 class WW8ReaderSave
 589 {
 590 private:
 591     WW8PLCFxSaveAll maPLCFxSave;
 592     std::shared_ptr<SwUnoCursor> mxTmpPos;
 593     std::deque<bool> maOldApos;
 594     std::deque<WW8FieldEntry> maOldFieldStack;
 595     std::unique_ptr<SwWW8FltControlStack> mxOldStck;
 596     std::unique_ptr<SwWW8FltAnchorStack> mxOldAnchorStck;
 597     std::unique_ptr<sw::util::RedlineStack> mxOldRedlines;
 598     std::shared_ptr<WW8PLCFMan> mxOldPlcxMan;
 599     std::unique_ptr<WW8FlyPara> mpWFlyPara;
 600     std::unique_ptr<WW8SwFlyPara> mpSFlyPara;
 601     SwPaM* mpPreviousNumPaM;
 602     const SwNumRule* mpPrevNumRule;
 603     std::unique_ptr<WW8TabDesc> mxTableDesc;
 604     int mnInTable;
 605     sal_uInt16 mnCurrentColl;
 606     sal_Unicode mcSymbol;
 607     bool mbIgnoreText;
 608     bool mbSymbol;
 609     bool mbHdFtFootnoteEdn;
 610     bool mbTxbxFlySection;
 611     bool mbAnl;
 612     bool mbInHyperlink;
 613     bool mbPgSecBreak;
 614     bool mbWasParaEnd;
 615     bool mbHasBorder;
 616     bool mbFirstPara;
 617 public:
 618     WW8ReaderSave(SwWW8ImplReader* pRdr, WW8_CP nStart=-1);
 619     void Restore(SwWW8ImplReader* pRdr);
 620     const SwPosition &GetStartPos() const { return *mxTmpPos->GetPoint(); }
 621 };
 622
 623 enum class eF_ResT { OK, TEXT, TAGIGN, READ_FSPA };
 624
 625 class SwWW8Shade
 626 {
 627 public:
 628     Color aColor;
 629     SwWW8Shade(bool bVer67, const WW8_SHD& rSHD);
 630     SwWW8Shade(Color nFore, Color nBack, sal_uInt16 nIndex)
 631     {
 632         SetShade(nFore, nBack, nIndex);
 633     }
 634 private:
 635     void SetShade(Color nFore, Color nBack, sal_uInt16 nIndex);
 636 };
 637
 638 //    Formulas
 639
 640 enum SwWw8ControlType
 641 {
 642     WW8_CT_EDIT,
 643     WW8_CT_CHECKBOX,
 644     WW8_CT_DROPDOWN
 645 };
 646
 647 class WW8FormulaControl
 648 {
 649 protected:
 650     SwWW8ImplReader &mrRdr;
 651
 652     WW8FormulaControl(WW8FormulaControl const&) = delete;
 653     WW8FormulaControl& operator=(WW8FormulaControl const&) = delete;
 654
 655 public:
 656     WW8FormulaControl(const OUString& rN, SwWW8ImplReader &rRdr)
 657         : mrRdr(rRdr), mfUnknown(0), mfDropdownIndex(0),
 658         mfToolTip(0), mfNoMark(0), mfType(0),
 659         mfUnused(0), mhpsCheckBox(20), mnChecked(0), mnMaxLen(0),
 660         mbHelp(false), msName( rN )
 661     {
 662     }
 663     sal_uInt8 mfUnknown:2;
 664     sal_uInt8 mfDropdownIndex:6;
 665     sal_uInt8 mfToolTip:1;
 666     sal_uInt8 mfNoMark:1;
 667     sal_uInt8 mfType:3;
 668     sal_uInt8 mfUnused:3;
 669
 670     sal_uInt16 mhpsCheckBox;
 671     sal_uInt16 mnChecked;
 672
 673     /// FFData.cch in the spec: maximum length, in characters, of the value of the textbox.
 674     sal_uInt16 mnMaxLen;
 675     OUString msTitle;
 676     OUString msDefault;
 677     OUString msFormatting;
 678     bool mbHelp;
 679     OUString msHelp;
 680     OUString msToolTip;
 681     OUString msEntryMcr;
 682     OUString msExitMcr;
 683     std::vector<OUString> maListEntries;
 684     virtual ~WW8FormulaControl() {}
 685     void FormulaRead(SwWw8ControlType nWhich,SvStream *pD);
 686     virtual bool Import(const css::uno::Reference< css::lang::XMultiServiceFactory> &rServiceFactory,
 687         css::uno::Reference< css::form::XFormComponent> &rFComp,
 688         css::awt::Size &rSz) = 0;
 689     OUString msName;
 690 };
 691
 692 class WW8FormulaCheckBox : public WW8FormulaControl
 693 {
 694 private:
 695     WW8FormulaCheckBox(const WW8FormulaCheckBox&) = delete;
 696     WW8FormulaCheckBox& operator=(const WW8FormulaCheckBox&) = delete;
 697
 698 public:
 699     explicit WW8FormulaCheckBox(SwWW8ImplReader &rR);
 700
 701     virtual bool Import(const css::uno::Reference< css::lang::XMultiServiceFactory> &rServiceFactory,
 702         css::uno::Reference< css::form::XFormComponent> &rFComp,
 703         css::awt::Size &rSz) override;
 704 };
 705
 706 class WW8FormulaListBox : public WW8FormulaControl
 707 {
 708 private:
 709     WW8FormulaListBox(const WW8FormulaListBox&) = delete;
 710     WW8FormulaListBox& operator=(const WW8FormulaListBox&) = delete;
 711
 712 public:
 713     explicit WW8FormulaListBox(SwWW8ImplReader &rR);
 714
 715     virtual bool Import(const css::uno::Reference< css::lang::XMultiServiceFactory> &rServiceFactory,
 716         css::uno::Reference< css::form::XFormComponent> &rFComp,
 717         css::awt::Size &rSz) override;
 718 };
 719
 720 class WW8FormulaEditBox : public WW8FormulaControl
 721 {
 722 private:
 723     WW8FormulaEditBox(const WW8FormulaEditBox&) = delete;
 724     WW8FormulaEditBox& operator=(const WW8FormulaEditBox&) = delete;
 725 public:
 726     explicit WW8FormulaEditBox(SwWW8ImplReader &rR);
 727     //no real implementation, return false
 728     virtual bool Import(const css::uno::Reference< css::lang::XMultiServiceFactory> & /* rServiceFactory */,
 729         css::uno::Reference< css::form::XFormComponent> & /* rFComp */,
 730         css::awt::Size & /* rSz */) override { return false; }
 731 };
 732
 733 class SwMSConvertControls: public oox::ole::MSConvertOCXControls
 734 {
 735 public:
 736     SwMSConvertControls( SfxObjectShell const *pDSh, SwPaM *pP );
 737     void InsertFormula( WW8FormulaControl &rFormula);
 738     virtual bool InsertControl(const css::uno::Reference< css::form::XFormComponent >& rFComp,
 739         const css::awt::Size& rSize,
 740         css::uno::Reference<  css::drawing::XShape > *pShape, bool bFloatingCtrl) override;
 741     void ExportControl(WW8Export &rWrt, const SdrUnoObj& rFormObj);
 742     bool ReadOCXStream( tools::SvRef<SotStorage> const & rSrc1,
 743         css::uno::Reference< css::drawing::XShape > *pShapeRef,
 744         bool bFloatingCtrl=false );
 745 private:
 746     SwPaM *pPaM;
 747     sal_uInt32 mnObjectId;
 748 };
 749
 750 class SwMSDffManager : public SvxMSDffManager
 751 {
 752 private:
 753     SwWW8ImplReader& rReader;
 754     SvStream *pFallbackStream;
 755     std::unordered_map<sal_uInt32, Graphic> aOldEscherBlipCache;
 756
 757     virtual bool GetOLEStorageName( sal_uInt32 nOLEId, OUString& rStorageName,
 758         tools::SvRef<SotStorage>& rSrcStorage, css::uno::Reference < css::embed::XStorage >& rDestStorage ) const override;
 759     virtual bool ShapeHasText( sal_uLong nShapeId, sal_uLong nFilePos ) const override;
 760     // #i32596# - new parameter <_nCalledByGroup>, which
 761     // indicates, if the OLE object is imported inside a group object
 762     virtual SdrObject* ImportOLE( sal_uInt32 nOLEId,
 763                                   const Graphic& rGrf,
 764                                   const tools::Rectangle& rBoundRect,
 765                                   const tools::Rectangle& rVisArea,
 766                                   const int _nCalledByGroup ) const override;
 767
 768     SwMSDffManager(const SwMSDffManager&) = delete;
 769     SwMSDffManager& operator=(const SwMSDffManager&) = delete;
 770 public:
 771     static sal_uInt32 GetFilterFlags();
 772     static sal_Int32 GetEscherLineMatch(MSO_LineStyle eStyle, MSO_SPT eShapeType,
 773         sal_Int32 &rThick);
 774     SwMSDffManager( SwWW8ImplReader& rRdr, bool bSkipImages );
 775     void DisableFallbackStream();
 776     void EnableFallbackStream();
 777 protected:
 778     virtual SdrObject* ProcessObj( SvStream& rSt, DffObjData& rObjData, SvxMSDffClientData& rData, tools::Rectangle& rTextRect, SdrObject* pObj ) override;
 779 };
 780
 781 class wwSection
 782 {
 783 public:
 784     explicit wwSection(const SwPosition &rPos);
 785     SEPr maSep;
 786     WW8_BRCVer9 brc[4];
 787     SwNodeIndex maStart;
 788     SwSection *mpSection;
 789     SwPageDesc *mpPage;
 790     SvxFrameDirection meDir;
 791
 792     sal_uInt32 nPgWidth;
 793     sal_uInt32 nPgLeft;
 794     sal_uInt32 nPgRight;
 795     sal_uInt32 nPgGutter;
 796     bool m_bRtlGutter = false;
 797
 798     css::drawing::TextVerticalAdjust mnVerticalAdjustment;
 799     sal_uInt8 mnBorders;
 800     bool mbHasFootnote;
 801     void SetDirection();
 802     bool IsContinuous() const { return maSep.bkc == 0; }
 803     bool IsNotProtected() const { return maSep.fUnlocked != 0; }
 804     bool IsVertical() const;
 805     sal_Int16 NoCols() const { return maSep.ccolM1 + 1; }
 806     sal_Int32 StandardColSeparation() const { return maSep.dxaColumns; }
 807     bool HasTitlePage() const { return maSep.fTitlePage != 0; }
 808     sal_uInt16 PageStartAt() const { return maSep.pgnStart; }
 809     bool PageRestartNo() const { return maSep.fPgnRestart != 0; }
 810     bool IsBiDi() const { return maSep.fBiDi != 0; }
 811     sal_uInt32 GetPageWidth() const { return nPgWidth; }
 812     sal_uInt32 GetTextAreaWidth() const
 813         { return GetPageWidth() - GetPageLeft() - nPgGutter - GetPageRight(); }
 814     sal_uInt32 GetPageHeight() const { return maSep.yaPage; }
 815     sal_uInt32 GetPageLeft() const { return nPgLeft; }
 816     sal_uInt32 GetPageRight() const { return nPgRight; }
 817     bool IsLandScape() const { return maSep.dmOrientPage != 0; }
 818     bool IsFixedHeightHeader() const { return maSep.dyaTop < 0; }
 819     bool IsFixedHeightFooter() const { return maSep.dyaBottom < 0; }
 820 };
 821
 822 class wwSectionManager
 823 {
 824 private:
 825     /*
 826     A queue of the ms sections in the document
 827     */
 828     SwWW8ImplReader& mrReader;
 829     std::deque<wwSection> maSegments;
 830     typedef std::deque<wwSection>::iterator mySegIter;
 831
 832     //Num of page desc's entered into the document
 833     sal_uInt16 mnDesc;
 834
 835     struct wwULSpaceData
 836     {
 837         bool bHasHeader, bHasFooter;
 838         sal_uInt32 nSwHLo, nSwFUp, nSwUp,  nSwLo;
 839         wwULSpaceData()
 840             : bHasHeader(false)
 841             , bHasFooter(false)
 842             , nSwHLo(0)
 843             , nSwFUp(0)
 844             , nSwUp(0)
 845             , nSwLo(0)
 846         {}
 847     };
 848
 849     void SetSegmentToPageDesc(const wwSection &rSection, bool bIgnoreCols);
 850
 851     void GetPageULData(const wwSection &rNewSection,
 852         wwULSpaceData& rData) const;
 853     static void SetPageULSpaceItems(SwFrameFormat &rFormat, wwULSpaceData const & rData,
 854         const wwSection &rSection);
 855
 856     static void SetPage(SwPageDesc &rPageDesc, SwFrameFormat &rFormat,
 857         const wwSection &rSection, bool bIgnoreCols);
 858
 859     static void SetNumberingType(const wwSection &rNewSection, SwPageDesc &rPageDesc);
 860
 861     void SetUseOn(wwSection &rSection);
 862     void SetHdFt(wwSection const &rSection, int nSect, const wwSection *pPrevious);
 863
 864     SwSectionFormat *InsertSection(SwPaM const & rMyPaM, wwSection &rSection);
 865     static bool SetCols(SwFrameFormat &rFormat, const wwSection &rSection,
 866         sal_uInt32 nNetWidth);
 867     bool SectionIsProtected(const wwSection &rSection) const;
 868     static void SetLeftRight(wwSection &rSection);
 869     /*
 870      The segment we're inserting, the start of the segments container, and the
 871      nodeindex of where we want the page break to (normally the segments start
 872      position
 873     */
 874     SwFormatPageDesc SetSwFormatPageDesc(mySegIter const &rIter, mySegIter const &rStart,
 875         bool bIgnoreCols);
 876
 877     wwSectionManager(const wwSectionManager&) = delete;
 878     wwSectionManager& operator=(const wwSectionManager&) = delete;
 879 public:
 880     explicit wwSectionManager(SwWW8ImplReader &rReader) : mrReader(rReader), mnDesc(0)
 881         {}
 882     void SetCurrentSectionHasFootnote();
 883     void SetCurrentSectionVerticalAdjustment(const css::drawing::TextVerticalAdjust nVA);
 884     bool CurrentSectionIsVertical() const;
 885     bool CurrentSectionIsProtected() const;
 886     void PrependedInlineNode(const SwPosition &rPos, const SwNode &rNode);
 887     sal_uInt16 CurrentSectionColCount() const;
 888     bool WillHavePageDescHere(const SwNodeIndex& rIdx) const;
 889     void CreateSep(const tools::Long nTextPos);
 890     void InsertSegments();
 891     void JoinNode(const SwPosition &rPos, const SwNode &rNode);
 892     sal_uInt32 GetPageLeft() const;
 893     sal_uInt32 GetPageRight() const;
 894     sal_uInt32 GetPageWidth() const;
 895     sal_uInt32 GetWWPageTopMargin() const;
 896     sal_uInt32 GetTextAreaWidth() const;
 897 };
 898
 899 //Various writer elements like frames start off containing a blank paragraph,
 900 //sometimes this paragraph turns out to be extraneous, e.g. the frame should
 901 //only contain a table with no trailing paragraph.
 902
 903 //We want to remove these extra paragraphs, but removing them during the parse
 904 //is problematic, because we don't want to remove any paragraphs that are still
 905 //addressed by property entries in a SwFltControlStack which have not yet been
 906 //committed to the document.
 907
 908 //Safest thing is to not delete SwTextNodes from a document during import, and
 909 //remove these extraneous paragraphs at the end after all SwFltControlStack are
 910 //destroyed.
 911 class wwExtraneousParas
 912 {
 913 private:
 914     /*
 915     A vector of SwTextNodes to erase from a document after import is complete
 916     */
 917     std::set<SwTextNode*, SwWW8::ltnode> m_aTextNodes;
 918     SwDoc& m_rDoc;
 919
 920     wwExtraneousParas(wwExtraneousParas const&) = delete;
 921     wwExtraneousParas& operator=(wwExtraneousParas const&) = delete;
 922
 923 public:
 924     explicit wwExtraneousParas(SwDoc &rDoc) : m_rDoc(rDoc) {}
 925     ~wwExtraneousParas() { delete_all_from_doc(); }
 926     void insert(SwTextNode *pTextNode) { m_aTextNodes.insert(pTextNode); }
 927     void check_anchor_destination(SwTextNode *pTextNode)
 928     {
 929         auto it = m_aTextNodes.find(pTextNode);
 930         if (it == m_aTextNodes.end())
 931             return;
 932         SAL_WARN("sw.ww8", "It is unexpected to anchor something in a para scheduled for removal");
 933         m_aTextNodes.erase(it);
 934     }
 935     void delete_all_from_doc();
 936 };
 937
 938 class wwFrameNamer
 939 {
 940 private:
 941     OUString msSeed;
 942     sal_Int32 mnImportedGraphicsCount;
 943     bool mbIsDisabled;
 944
 945     wwFrameNamer(wwFrameNamer const&) = delete;
 946     wwFrameNamer& operator=(wwFrameNamer const&) = delete;
 947
 948 public:
 949     void SetUniqueGraphName(SwFrameFormat *pFrameFormat, std::u16string_view rFixedPart);
 950     wwFrameNamer(bool bIsDisabled, const OUString &rSeed)
 951         : msSeed(rSeed), mnImportedGraphicsCount(0), mbIsDisabled(bIsDisabled)
 952     {
 953     }
 954 };
 955
 956 class wwSectionNamer
 957 {
 958 private:
 959     const SwDoc &mrDoc;
 960     OUString msFileLinkSeed;
 961     int mnFileSectionNo;
 962     wwSectionNamer(const wwSectionNamer&) = delete;
 963     wwSectionNamer& operator=(const wwSectionNamer&) = delete;
 964 public:
 965     OUString UniqueName();
 966     wwSectionNamer(const SwDoc &rDoc, const OUString &rSeed)
 967         : mrDoc(rDoc), msFileLinkSeed(rSeed), mnFileSectionNo(0)
 968         { }
 969 };
 970
 971 class FootnoteDescriptor
 972 {
 973 public:
 974     ManTypes meType;
 975     bool mbAutoNum;
 976     WW8_CP mnStartCp;
 977     WW8_CP mnLen;
 978 };
 979
 980 struct ApoTestResults
 981 {
 982     bool mbStartApo;
 983     bool mbStopApo;
 984     bool m_bHasSprm37;
 985     bool m_bHasSprm29;
 986     sal_uInt8 m_nSprm29;
 987     WW8FlyPara* mpStyleApo;
 988     ApoTestResults()
 989         : mbStartApo(false), mbStopApo(false), m_bHasSprm37(false)
 990         , m_bHasSprm29(false), m_nSprm29(0), mpStyleApo(nullptr) {}
 991     bool HasStartStop() const { return (mbStartApo || mbStopApo); }
 992     bool HasFrame() const { return (m_bHasSprm29 || m_bHasSprm37 || mpStyleApo); }
 993 };
 994
 995 struct ANLDRuleMap
 996 {
 997     OUString msOutlineNumRule;    // WinWord 6 numbering, variant 1
 998     OUString msNumberingNumRule;  // WinWord 6 numbering, variant 2
 999     SwNumRule* GetNumRule(const SwDoc& rDoc, sal_uInt8 nNumType);
1000     void SetNumRule(const OUString& rNumRule, sal_uInt8 nNumType);
1001 };
1002
1003 struct SprmReadInfo;
1004 class SwDocShell;
1005 struct WW8PostProcessAttrsInfo
1006 {
1007     bool mbCopy;
1008     WW8_CP mnCpStart;
1009     WW8_CP mnCpEnd;
1010     SwPaM mPaM;
1011     SfxItemSet mItemSet;
1012
1013     WW8PostProcessAttrsInfo(WW8_CP nCpStart, WW8_CP nCpEnd, SwPaM & rPaM);
1014 };
1015
1016 #define MAX_COL 64  // WW6-description: 32, WW6-UI: 31 & WW8-UI: 63!
1017
1018 struct WW8TabBandDesc
1019 {
1020     WW8TabBandDesc* pNextBand;
1021     short nGapHalf;
1022     short mnDefaultLeft;
1023     short mnDefaultTop;
1024     short mnDefaultRight;
1025     short mnDefaultBottom;
1026     bool mbHasSpacing;
1027     short nLineHeight;
1028     short nRows;
1029     sal_uInt16 maDirections[MAX_COL + 1];
1030     short nCenter[MAX_COL + 1]; // X-edge of all cells of this band
1031     short nWidth[MAX_COL + 1];  // length of all cells of this band
1032     short nWwCols;      // sal_uInt8 would be sufficient, alignment -> short
1033     short nSwCols;      // SW: number of columns for the writer
1034     bool bLEmptyCol;    // SW: an additional empty column at the left
1035     bool bREmptyCol;    // SW: same at the right
1036     bool bCantSplit;
1037     bool bCantSplit90;
1038     WW8_TCell* pTCs;
1039     sal_uInt8 nOverrideSpacing[MAX_COL + 1];
1040     short nOverrideValues[MAX_COL + 1][4];
1041     WW8_SHD* pSHDs;
1042     Color* pNewSHDs;
1043     WW8_BRCVer9 aDefBrcs[6];
1044
1045     bool bExist[MAX_COL];           // does this cell exist ?
1046     sal_uInt8 nTransCell[MAX_COL + 2];  // translation WW-Index -> SW-Index
1047
1048     sal_uInt8 transCell(sal_uInt8 nWwCol) const
1049     {
1050         return nWwCol < SAL_N_ELEMENTS(nTransCell) ? nTransCell[nWwCol] : 0xFF;
1051     }
1052
1053     WW8TabBandDesc();
1054     WW8TabBandDesc(WW8TabBandDesc const & rBand);    // deep copy
1055     ~WW8TabBandDesc();
1056     void ReadDef(bool bVer67, const sal_uInt8* pS, short nLen);
1057     void ProcessDirection(const sal_uInt8* pParams);
1058     void ProcessSprmTSetBRC(int nBrcVer, const sal_uInt8* pParamsTSetBRC, sal_uInt16 nParamsLen);
1059     void ProcessSprmTTableBorders(int nBrcVer, const sal_uInt8* pParams, sal_uInt16 nParamsLen);
1060     void ProcessSprmTDxaCol(const sal_uInt8* pParamsTDxaCol);
1061     void ProcessSprmTDelete(const sal_uInt8* pParamsTDelete);
1062     void ProcessSprmTInsert(const sal_uInt8* pParamsTInsert);
1063     void ProcessSpacing(const sal_uInt8* pParamsTInsert);
1064     void ProcessSpecificSpacing(const sal_uInt8* pParamsTInsert);
1065     void ReadShd(const sal_uInt8* pS );
1066     void ReadNewShd(const sal_uInt8* pS, bool bVer67, sal_uInt8 nStart);
1067
1068     enum wwDIR {wwTOP = 0, wwLEFT = 1, wwBOTTOM = 2, wwRIGHT = 3};
1069
1070 private:
1071     WW8TabBandDesc & operator =(WW8TabBandDesc const &) = default; // only for use in copy ctor
1072 };
1073
1074 //            Storage-Reader
1075
1076 typedef std::set<WW8_CP> cp_set;
1077
1078 class SwWW8ImplReader
1079 {
1080 private:
1081     SwDocShell *m_pDocShell;         // The Real DocShell
1082
1083 friend class WW8RStyle;
1084 friend class WW8TabDesc;
1085 friend class WW8ReaderSave;
1086 friend struct WW8FlyPara;
1087 friend struct WW8SwFlyPara;
1088 friend class WW8FlySet;
1089 friend class SwMSDffManager;
1090 friend class SwWW8FltControlStack;
1091 friend class WW8FormulaControl;
1092 friend class wwSectionManager;
1093
1094 private:
1095
1096     SotStorage* m_pStg;                // Input-Storage
1097     SvStream* m_pStrm;                // Input-(Storage)Stream
1098     SvStream* m_pTableStream;         // Input-(Storage)Stream
1099     SvStream* m_pDataStream;          // Input-(Storage)Stream
1100
1101 // general stuff
1102     SwDoc& m_rDoc;
1103     std::shared_ptr<SwUnoCursor> mpCursor;
1104     SwPaM* m_pPaM;
1105
1106     std::unique_ptr<SwWW8FltControlStack> m_xCtrlStck;    // stack for the attributes
1107
1108     /*
1109     This stack is for redlines, because their sequence of discovery can
1110     be out of order of their order of insertion into the document.
1111     */
1112     std::unique_ptr<sw::util::RedlineStack> m_xRedlineStack;
1113
1114     /*
1115     This stack is for fields that get referenced later, e.g. BookMarks and TOX.
1116     They get inserted at the end of the document, it is the same stack for
1117     headers/footers/main text/textboxes/tables etc...
1118     */
1119     std::unique_ptr<SwWW8ReferencedFltEndStack> m_xReffedStck;
1120
1121     /*
1122     This stack is for fields whose true conversion cannot be determined until
1123     the end of the document, it is the same stack for headers/footers/main
1124     text/textboxes/tables etc... They are things that reference other things
1125     e.g. NoteRef and Ref, they are processed after m_xReffedStck
1126     */
1127     std::unique_ptr<SwWW8FltRefStack> m_xReffingStck;
1128
1129     /*
1130     For graphics anchors. Determines the graphics whose anchors are in the
1131     current paragraph, and works around the difficulty in inserting a graphic
1132     anchored to character before a character to be anchored to has been
1133     inserted. Is emptied at the end of each paragraph.
1134     */
1135     std::unique_ptr<SwWW8FltAnchorStack> m_xAnchorStck;
1136
1137     /*
1138     A stack of fields identifiers to keep track of any open fields that need
1139     to be closed. Generally word fields are inserted as writer fields as soon
1140     as they are encountered, and so their end point is normally unimportant.
1141     But hyperlink fields need to be applied as attributes to text and it is
1142     far easier and safer to set the end point of an attribute when we
1143     encounter the end marker of the field instead of calculating in advance
1144     where the end point will fall, to do so fully correctly duplicates the
1145     main logic of the filter itself.
1146     */
1147     std::deque<WW8FieldEntry> m_aFieldStack;
1148
1149     /*
1150     A stack of open footnotes. Should only be one in it at any time.
1151     */
1152     std::deque<FootnoteDescriptor> m_aFootnoteStack;
1153
1154     /*
1155     A queue of the ms sections in the document
1156     */
1157     wwSectionManager m_aSectionManager;
1158
1159     /*
1160     A vector of surplus-to-requirements paragraph in the final document,
1161     that exist because of quirks of the SwDoc document model and/or API,
1162     which need to be removed.
1163     */
1164     wwExtraneousParas m_aExtraneousParas;
1165
1166     /*
1167     A map of tables to their follow nodes for use in inserting tables into
1168     already existing document, i.e. insert file
1169     */
1170     sw::util::InsertedTablesManager m_aInsertedTables;
1171
1172     /*
1173     Creates unique names to give to (file link) sections (WW1/WW2/...)
1174     */
1175     wwSectionNamer m_aSectionNameGenerator;
1176
1177     /*
1178     Knows how to split a series of bytes into sprms and their arguments
1179     */
1180     std::unique_ptr<wwSprmParser> m_xSprmParser;
1181
1182     /*
1183     Creates unique names to give to graphics
1184     */
1185     wwFrameNamer m_aGrfNameGenerator;
1186
1187     /*
1188     Knows which writer style a given word style should be imported as.
1189     */
1190     sw::util::ParaStyleMapper m_aParaStyleMapper;
1191     sw::util::CharStyleMapper m_aCharStyleMapper;
1192
1193     /*
1194      Stack of textencoding being used as we progress through the document text
1195     */
1196     std::stack<rtl_TextEncoding> m_aFontSrcCharSets;
1197     std::stack<rtl_TextEncoding> m_aFontSrcCJKCharSets;
1198
1199     /*
1200      Progress bar
1201      */
1202     std::unique_ptr<ImportProgress> m_xProgress;
1203
1204     std::unique_ptr<SwMSConvertControls> m_xFormImpl; // implementation of control
1205
1206     SwFlyFrameFormat* m_pFlyFormatOfJustInsertedGraphic;
1207     std::unique_ptr<FrameDeleteWatch> m_xFormatOfJustInsertedApo;
1208     SwPaM* m_pPreviousNumPaM;
1209     const SwNumRule* m_pPrevNumRule;
1210
1211     //Keep track of APO environments
1212     std::deque<bool> m_aApos;
1213     /*
1214     Keep track of generated Ruby character formats we can minimize the
1215     number of character formats created
1216     */
1217     std::vector<const SwCharFormat*> m_aRubyCharFormats;
1218
1219     /*
1220     For fuzzing keep track of source offset of inserted graphics
1221     */
1222     std::set<sal_uLong> m_aGrafPosSet;
1223
1224     std::unique_ptr<WW8PostProcessAttrsInfo> m_pPostProcessAttrsInfo;
1225
1226     std::shared_ptr<WW8Fib> m_xWwFib;
1227     std::unique_ptr<WW8Fonts> m_xFonts;
1228     std::unique_ptr<WW8Dop> m_xWDop;
1229     std::unique_ptr<WW8ListManager, o3tl::default_delete<WW8ListManager>> m_xLstManager;
1230     std::unique_ptr<WW8ScannerBase> m_xSBase;
1231     std::shared_ptr<WW8PLCFMan> m_xPlcxMan;
1232     std::map<short, OUString> m_aLinkStringMap;
1233
1234     o3tl::sorted_vector<const SwNode*> m_aTextNodesHavingFirstLineOfstSet; // #i103711#
1235     o3tl::sorted_vector<const SwNode*> m_aTextNodesHavingLeftIndentSet; // #i105414#
1236
1237     std::unique_ptr<WW8RStyle> m_xStyles;     // pointer to the style reading class
1238     SwFormat* m_pCurrentColl;        // collection to be created now
1239                             // ( always 0 outside of a Style-Def )
1240     std::unique_ptr<SfxItemSet> m_xCurrentItemSet;// character attributes to be read in now
1241                             // (always 0 outside of the WW8ListManager Ctor)
1242     std::vector<SwWW8StyInf> m_vColl;
1243     const SwTextFormatColl* m_pDfltTextFormatColl;    // Default
1244     SwFormat* m_pStandardFormatColl;// "Standard"
1245
1246     std::unique_ptr<WW8PLCF_HdFt> m_xHdFt;        // pointer to Header / Footer - scanner class
1247
1248     std::unique_ptr<WW8FlyPara> m_xWFlyPara;      // WW-parameter
1249     std::unique_ptr<WW8SwFlyPara> m_xSFlyPara;    // Sw parameters created from previous
1250
1251     std::unique_ptr<WW8TabDesc> m_xTableDesc;     // description of table properties
1252     //Keep track of tables within tables
1253     std::stack<std::unique_ptr<WW8TabDesc>> m_aTableStack;
1254
1255     ANLDRuleMap m_aANLDRules;
1256     std::unique_ptr<WW8_OLST> m_xNumOlst;         // position in text
1257
1258     SdrModel* m_pDrawModel;
1259     SdrPage* m_pDrawPg;
1260     std::unique_ptr<EditEngine> m_pDrawEditEngine;
1261     std::unique_ptr<wwZOrderer> m_xWWZOrder;
1262
1263     SwFieldType* m_pNumFieldType;   // for number circle
1264
1265     std::unique_ptr<SwMSDffManager> m_xMSDffManager;
1266
1267     std::optional<std::vector<OUString>> m_xAtnNames;
1268
1269     std::unique_ptr<WW8SmartTagData> m_pSmartTagData;
1270
1271     /// Redlining Authors, map word author key to writer author value
1272     std::map<sal_uInt16, std::size_t> m_aAuthorInfos;
1273     OUString m_sBaseURL;
1274
1275                                 // Ini-Flags:
1276     sal_uInt32 m_nIniFlags;            // flags from writer.ini
1277     sal_uInt32 m_nIniFlags1;           // ditto ( additional flags )
1278     sal_uInt32 m_nFieldFlags;          // ditto for fields
1279     sal_uInt32 m_nFieldTagAlways[3];   // ditto for tagging of fields
1280     sal_uInt32 m_nFieldTagBad[3];      // ditto for tagging of fields that can't be imported
1281     bool m_bRegardHindiDigits;  // import digits in CTL scripts as Hindi numbers
1282
1283     bool m_bDrawCpOValid;
1284     WW8_CP m_nDrawCpO;            // start of Txbx-SubDocs
1285
1286     sal_uLong m_nPicLocFc;            // Picture Location in File (FC)
1287     sal_uLong m_nObjLocFc;            // Object Location in File (FC)
1288
1289     sal_Int32 m_nIniFlyDx;            // X-offset of Flys
1290     sal_Int32 m_nIniFlyDy;            // Y-offset of Flys
1291
1292     rtl_TextEncoding m_eTextCharSet;    // Default charset for Text
1293     rtl_TextEncoding m_eStructCharSet;  // rtl_TextEncoding for structures
1294     rtl_TextEncoding m_eHardCharSet;    // Hard rtl_TextEncoding-Attribute
1295     sal_uInt16 m_nProgress;           // percentage for Progressbar
1296     sal_uInt16 m_nCurrentColl;          // per WW-count
1297     sal_uInt16 m_nFieldNum;             // serial number for that
1298     sal_uInt16 m_nLFOPosition;
1299
1300     short m_nCharFormat;             // per WW-count, <0 for none
1301
1302     short m_nDrawXOfs, m_nDrawYOfs;
1303     short m_nDrawXOfs2, m_nDrawYOfs2;
1304
1305     sal_Unicode m_cSymbol;        // symbol to be read now
1306
1307     sal_uInt8 m_nWantedVersion;        // originally requested WW-Doc version by Writer
1308
1309     sal_uInt8 m_nSwNumLevel;           // level number for outline / enumeration
1310     sal_uInt8 m_nWwNumType;            // outline / number / enumeration
1311     const SwNumRule* m_pChosenWW8OutlineStyle; // copied to the "Outline" Chapter Numbering style
1312     sal_uInt8 m_nListLevel;
1313
1314     bool m_bNewDoc;          // new document?
1315     bool m_bSkipImages;      // skip images for text extraction/indexing
1316     bool m_bReadNoTable;        // no tables
1317     bool m_bPgSecBreak;       // Page- or Sectionbreak is still to be added
1318     bool m_bSpec;             // special char follows in text
1319     bool m_bObj;              // Obj in Text
1320     bool m_bTxbxFlySection;   // FlyFrame that was inserted as replacement for Winword Textbox
1321     bool m_bHasBorder;        // for bundling of the borders
1322     bool m_bSymbol;           // e.g. Symbol instead of Times
1323     bool m_bIgnoreText;       // e.g. for FieldVanish
1324     int  m_nInTable;          // are we currently reading a table?
1325     bool m_bWasTabRowEnd;     // table : Row End Mark
1326     bool m_bWasTabCellEnd;    // table: Cell End Mark
1327
1328     bool m_bAnl;              // enumeration in work
1329                                 // Anl stands for "Autonumber level"
1330
1331     bool m_bHdFtFootnoteEdn;       // special text: header/footer/and so on
1332     bool m_bFootnoteEdn;           // footnote or endnote
1333     bool m_bIsHeader;         // text is read from header ( line height )
1334     bool m_bIsFooter;         // text is read from footer ( line height )
1335
1336     bool m_bIsUnicode;            // current piece of text is encoded as 2-byte Unicode
1337                                 // please do NOT handle this as bit field!
1338
1339     bool m_bCpxStyle;         // style in the complex part
1340     bool m_bStyNormal;        // style with Id 0 is currently read
1341     bool m_bWWBugNormal;      // WW-Version with Bug Dya in Style Normal
1342     bool m_bNoAttrImport;     // ignore attributes for ignoring styles
1343     bool m_bInHyperlink;      // special case for reading 0x01
1344                                    // see also: SwWW8ImplReader::Read_F_Hyperlink()
1345     bool m_bWasParaEnd;
1346
1347     // useful helper variables
1348     bool m_bVer67;            // ( (6 == nVersion) || (7 == nVersion) );
1349     bool m_bVer6;             //   (6 == nVersion);
1350     bool m_bVer7;             //   (7 == nVersion);
1351     bool m_bVer8;             //   (8 == nVersion);
1352
1353     bool m_bEmbeddObj;        // EmbeddField is being read
1354
1355     bool m_bCurrentAND_fNumberAcross; // current active Annotated List Descriptor - ROW flag
1356
1357     bool m_bNoLnNumYet;       // no Line Numbering has been activated yet (we import
1358                             //     the very 1st Line Numbering and ignore the rest)
1359
1360     bool m_bFirstPara;        // first paragraph?
1361     bool m_bFirstParaOfPage;
1362     bool m_bParaAutoBefore;
1363     bool m_bParaAutoAfter;
1364
1365     bool m_bDropCap;
1366     sal_Int32 m_nDropCap;
1367
1368     bool m_bBidi;
1369     bool m_bReadTable;
1370     // Indicate that currently on loading a TOC, managed by Read_F_TOX() and End_Field()
1371     bool m_bLoadingTOXCache;
1372     int m_nEmbeddedTOXLevel;
1373     // Indicate that current on loading a hyperlink, which is inside a TOC; Managed by Read_F_Hyperlink() and End_Field()
1374     bool m_bLoadingTOXHyperlink;
1375     // a document position recorded the after-position of TOC section, managed by Read_F_TOX() and End_Field()
1376     std::unique_ptr<SwPaM> m_pPosAfterTOC;
1377     // used for some dropcap tweaking
1378     SwTextNode* m_pPreviousNode;
1379
1380     std::unique_ptr< SwPosition > m_pLastAnchorPos;
1381
1382     bool m_bCareFirstParaEndInToc;
1383     bool m_bCareLastParaEndInToc;
1384     cp_set m_aTOXEndCps;
1385
1386     bool m_bNotifyMacroEventRead;
1387     bool m_bFuzzing;
1388
1389     const SprmReadInfo& GetSprmReadInfo(sal_uInt16 nId) const;
1390
1391     bool StyleExists(unsigned int nColl) const { return (nColl < m_vColl.size()); }
1392     SwWW8StyInf *GetStyle(sal_uInt16 nColl) const;
1393     void AppendTextNode(SwPosition& rPos);
1394
1395     void Read_HdFt(int nSect, const SwPageDesc *pPrev,
1396         const wwSection &rSection);
1397     void Read_HdFtText(WW8_CP nStartCp, WW8_CP nLen, SwFrameFormat const * pHdFtFormat);
1398     void Read_HdFtTextAsHackedFrame(WW8_CP nStart, WW8_CP nLen,
1399         SwFrameFormat const &rHdFtFormat, sal_uInt16 nPageWidth);
1400
1401     bool isValid_HdFt_CP(WW8_CP nHeaderCP) const;
1402
1403     bool HasOwnHeaderFooter(sal_uInt8 nWhichItems, sal_uInt8 grpfIhdt, int nSect);
1404
1405     void HandleLineNumbering(const wwSection &rSection);
1406
1407     void CopyPageDescHdFt( const SwPageDesc* pOrgPageDesc,
1408                            SwPageDesc* pNewPageDesc, sal_uInt8 nCode );
1409
1410     void DeleteStack(std::unique_ptr<SwFltControlStack> prStck);
1411     void DeleteCtrlStack()
1412     {
1413         DeleteStack(std::move(m_xCtrlStck));
1414     }
1415     void DeleteRefStacks()
1416     {
1417         DeleteStack(std::move(m_xReffedStck));
1418         DeleteStack(std::move(m_xReffingStck));
1419     }
1420     void DeleteAnchorStack()
1421     {
1422         DeleteStack(std::move(m_xAnchorStck));
1423     }
1424     void emulateMSWordAddTextToParagraph(const OUString& rAddString);
1425     void simpleAddTextToParagraph(const OUString& rAddString);
1426     bool HandlePageBreakChar();
1427     bool ReadChar(tools::Long nPosCp, tools::Long nCpOfs);
1428     bool ReadPlainChars(WW8_CP& rPos, sal_Int32 nEnd, sal_Int32 nCpOfs);
1429     bool ReadChars(WW8_CP& rPos, WW8_CP nNextAttr, tools::Long nTextEnd, tools::Long nCpOfs);
1430     static bool LangUsesHindiNumbers(LanguageType nLang);
1431     static sal_Unicode TranslateToHindiNumbers(sal_Unicode);
1432
1433     void SetDocumentGrid(SwFrameFormat &rFormat, const wwSection &rSection);
1434
1435     void ProcessCurrentCollChange(WW8PLCFManResult& rRes, bool* pStartAttr,
1436         bool bCallProcessSpecial);
1437     tools::Long ReadTextAttr(WW8_CP& rTextPos, tools::Long nTextEnd, bool& rbStartLine, int nDepthGuard = 0);
1438     void ReadAttrs(WW8_CP& rTextPos, WW8_CP& rNext, tools::Long nTextEnd, bool& rbStartLine);
1439     void CloseAttrEnds();
1440     bool ReadText(WW8_CP nStartCp, WW8_CP nTextLen, ManTypes nType);
1441
1442     void ReadRevMarkAuthorStrTabl( SvStream& rStrm, sal_Int32 nTablePos,
1443         sal_Int32 nTableSiz, SwDoc& rDoc );
1444
1445     void Read_HdFtFootnoteText(const SwNodeIndex* pSttIdx, WW8_CP nStartCp,
1446                                WW8_CP nLen, ManTypes nType);
1447
1448     void ImportTox( int nFieldId, const OUString& aStr );
1449
1450     void EndSprm( sal_uInt16 nId );
1451     // #i103711#
1452     // #i105414#
1453     void NewAttr( const SfxPoolItem& rAttr,
1454                   const bool bFirstLineOfStSet = false,
1455                   const bool bLeftIndentSet = false );
1456
1457     bool GetFontParams(sal_uInt16, FontFamily&, OUString&, FontPitch&,
1458         rtl_TextEncoding&);
1459     bool SetNewFontAttr(sal_uInt16 nFCode, bool bSetEnums, sal_uInt16 nWhich);
1460     void ResetCharSetVars();
1461     void ResetCJKCharSetVars();
1462
1463     const SfxPoolItem* GetFormatAttr( sal_uInt16 nWhich );
1464     bool JoinNode(SwPaM &rPam, bool bStealAttr = false);
1465
1466     static bool IsBorder(const WW8_BRCVer9* pbrc, bool bChkBtwn = false);
1467
1468     //Set closest writer border equivalent into rBox from pbrc, optionally
1469     //recording true winword dimensions in pSizeArray. nSetBorders to mark a
1470     //border which has been previously set to a value and for which becoming
1471     //empty is valid. Set bCheBtwn to work with paragraphs that have a special
1472     //between paragraphs border
1473
1474     // Note #i20672# we can't properly support between lines so best to ignore
1475     // them for now
1476     static bool SetBorder(SvxBoxItem& rBox, const WW8_BRCVer9* pbrc,
1477         short *pSizeArray=nullptr, sal_uInt8 nSetBorders=0xFF);
1478     static void GetBorderDistance(const WW8_BRCVer9* pbrc, tools::Rectangle& rInnerDist);
1479     static sal_uInt16 GetParagraphAutoSpace(bool fDontUseHTMLAutoSpacing);
1480     static bool SetShadow(SvxShadowItem& rShadow, const short *pSizeArray,
1481         const WW8_BRCVer9& aRightBrc);
1482     //returns true is a shadow was set
1483     static bool SetFlyBordersShadow(SfxItemSet& rFlySet, const WW8_BRCVer9 *pbrc,
1484         short *SizeArray);
1485     static void SetPageBorder(SwFrameFormat &rFormat, const wwSection &rSection);
1486
1487     static sal_Int32 MatchSdrBoxIntoFlyBoxItem( const Color& rLineColor,
1488         MSO_LineStyle eLineStyle, MSO_LineDashing eDashing, MSO_SPT eShapeType, sal_Int32 &rLineWidth,
1489         SvxBoxItem& rBox );
1490     void MatchSdrItemsIntoFlySet( SdrObject const *    pSdrObj, SfxItemSet &aFlySet,
1491         MSO_LineStyle eLineStyle, MSO_LineDashing eDashing, MSO_SPT eShapeType, tools::Rectangle &rInnerDist );
1492     static void AdjustLRWrapForWordMargins(const SvxMSDffImportRec &rRecord,
1493         SvxLRSpaceItem &rLR);
1494     static void AdjustULWrapForWordMargins(const SvxMSDffImportRec &rRecord,
1495         SvxULSpaceItem &rUL);
1496     static void MapWrapIntoFlyFormat(const SvxMSDffImportRec& rRecord, SwFrameFormat& rFlyFormat);
1497
1498     void SetAttributesAtGrfNode(const SvxMSDffImportRec& rRecord, const SwFrameFormat& rFlyFormat,
1499                                 WW8_FSPA const* pF);
1500
1501     bool IsDropCap() const;
1502     bool IsListOrDropcap() const { return (!m_xCurrentItemSet  || m_bDropCap); };
1503
1504     //Apo == Absolutely Positioned Object, MSWord's old-style frames
1505     std::unique_ptr<WW8FlyPara> ConstructApo(const ApoTestResults &rApo,
1506         const WW8_TablePos *pTabPos);
1507     bool StartApo(const ApoTestResults &rApo, const WW8_TablePos *pTabPos);
1508     void StopApo();
1509     bool TestSameApo(const ApoTestResults &rApo, const WW8_TablePos *pTabPos);
1510     ApoTestResults TestApo(int nCellLevel, bool bTableRowEnd,
1511         const WW8_TablePos *pTabPos);
1512     static void StripNegativeAfterIndent(SwFrameFormat const *pFlyFormat);
1513
1514     void EndSpecial();
1515     bool ProcessSpecial(bool &rbReSync, WW8_CP nStartCp);
1516     sal_uInt16 TabRowSprm(int nLevel) const;
1517
1518     bool ReadGrafFile(OUString& rFileName, std::unique_ptr<Graphic>& rpGraphic,
1519        const WW8_PIC& rPic, SvStream* pSt, sal_uLong nFilePos, bool* pDelIt);
1520
1521     static void ReplaceObj(const SdrObject &rReplaceTextObj,
1522         SdrObject &rSubObj);
1523
1524     SwFlyFrameFormat* MakeGrafNotInContent(const WW8PicDesc& rPD,
1525         const Graphic* pGraph, const OUString& rFileName,
1526         const SfxItemSet& rGrfSet);
1527
1528     SwFrameFormat* MakeGrafInContent(const WW8_PIC& rPic, const WW8PicDesc& rPD,
1529         const Graphic* pGraph, const OUString& rFileName,
1530         const SfxItemSet& rGrfSet);
1531
1532     SwFrameFormat *AddAutoAnchor(SwFrameFormat *pFormat);
1533     SwFrameFormat* ImportGraf1(WW8_PIC const & rPic, SvStream* pSt, sal_uLong nFilePos);
1534     SwFrameFormat* ImportGraf(SdrTextObj const * pTextObj = nullptr, SwFrameFormat const * pFlyFormat = nullptr);
1535
1536     SdrObject* ImportOleBase( Graphic& rGraph, const Graphic* pGrf=nullptr,
1537         const SfxItemSet* pFlySet=nullptr, const tools::Rectangle& aVisArea = tools::Rectangle() );
1538
1539     SwFrameFormat* ImportOle( const Graphic* = nullptr, const SfxItemSet* pFlySet = nullptr,
1540         const SfxItemSet* pGrfSet = nullptr, const tools::Rectangle& aVisArea = tools::Rectangle() );
1541     SwFlyFrameFormat* InsertOle(SdrOle2Obj &rObject, const SfxItemSet &rFlySet,
1542         const SfxItemSet *rGrfSet);
1543
1544     bool ImportFormulaControl(WW8FormulaControl &rBox,WW8_CP nStart,
1545         SwWw8ControlType nWhich);
1546
1547     void ImportDop();
1548
1549     //This converts MS Asian Typography information into OOo's
1550     void ImportDopTypography(const WW8DopTypography &rTypo);
1551
1552     ErrCode LoadThroughDecryption(WW8Glossary *pGloss);
1553     ErrCode SetSubStreams(tools::SvRef<SotStorageStream> &rTableStream, tools::SvRef<SotStorageStream> &rDataStream);
1554     ErrCode CoreLoad(WW8Glossary const *pGloss);
1555
1556     void ReadDocVars();
1557
1558     bool StartTable(WW8_CP nStartCp);
1559     bool InEqualApo(int nLvl) const;
1560     bool InLocalApo() const { return InEqualApo(m_nInTable); }
1561     bool InEqualOrHigherApo(int nLvl) const;
1562     void TabCellEnd();
1563     void StopTable();
1564     bool IsInvalidOrToBeMergedTabCell() const;
1565
1566 // Enumerations / lists ( Autonumbered List Data Descriptor )
1567 // list:        ANLD ( Autonumbered List Data Descriptor )
1568 //   one level: ANLV ( Autonumber Level Descriptor )
1569
1570 // Chg7-8:
1571 // lists are separate structures in WW8 that are handled via the following three tables:
1572 // rglst, hpllfo and hsttbListNames
1573 // the corresponding structures are: LSTF, LVLF, LFO LFOLVL
1574
1575     void SetAnlvStrings(SwNumFormat &rNum, int nLevel, WW8_ANLV const &rAV, const sal_uInt8* pText,
1576         size_t nStart, size_t nElements, bool bOutline);
1577     void SetAnld(SwNumRule* pNumR, WW8_ANLD const * pAD, sal_uInt8 nSwLevel, bool bOutLine);
1578     void SetNumOlst( SwNumRule* pNumR, WW8_OLST* pO, sal_uInt8 nSwLevel );
1579     SwNumRule* GetStyRule();
1580
1581     void StartAnl(const sal_uInt8* pSprm13);
1582     void NextAnlLine(const sal_uInt8* pSprm13);
1583     void StopAllAnl(bool bGoBack = true);
1584     void StopAnlToRestart(sal_uInt8 nType, bool bGoBack = true);
1585
1586 // graphics layer
1587
1588     bool ReadGrafStart(void* pData, short nDataSiz, WW8_DPHEAD const * pHd,
1589         SfxAllItemSet &rSet);
1590     SdrObject *ReadLine(WW8_DPHEAD const * pHd, SfxAllItemSet &rSet);
1591     SdrObject *ReadRect(WW8_DPHEAD const * pHd, SfxAllItemSet &rSet);
1592     SdrObject *ReadEllipse(WW8_DPHEAD const * pHd, SfxAllItemSet &rSet);
1593     SdrObject *ReadArc(WW8_DPHEAD const * pHd, SfxAllItemSet &rSet);
1594     SdrObject *ReadPolyLine(WW8_DPHEAD const * pHd, SfxAllItemSet &rSet);
1595     void InsertTxbxStyAttrs( SfxItemSet& rS, sal_uInt16 nColl );
1596     void InsertAttrsAsDrawingAttrs(WW8_CP nStartCp, WW8_CP nEndCp, ManTypes eType, bool bONLYnPicLocFc=false);
1597
1598     bool GetTxbxTextSttEndCp(WW8_CP& rStartCp, WW8_CP& rEndCp, sal_uInt16 nTxBxS,
1599         sal_uInt16 nSequence);
1600     sal_Int32 GetRangeAsDrawingString(OUString& rString, tools::Long StartCp, tools::Long nEndCp, ManTypes eType);
1601     std::optional<OutlinerParaObject> ImportAsOutliner(OUString &rString, WW8_CP nStartCp, WW8_CP nEndCp, ManTypes eType);
1602     void InsertTxbxText(SdrTextObj* pTextObj, Size const * pObjSiz,
1603         sal_uInt16 nTxBxS, sal_uInt16 nSequence, tools::Long nPosCp, SwFrameFormat const * pFlyFormat,
1604         bool bMakeSdrGrafObj, bool& rbEraseTextObj,
1605         bool* pbTestTxbxContainsText = nullptr, tools::Long* pnStartCp = nullptr,
1606         tools::Long* pnEndCp = nullptr, bool* pbContainsGraphics = nullptr,
1607         SvxMSDffImportRec const * pRecord = nullptr);
1608     bool TxbxChainContainsRealText( sal_uInt16 nTxBxS,
1609                                     tools::Long&  rStartCp,
1610                                     tools::Long&  rEndCp );
1611     SdrObject *ReadTextBox(WW8_DPHEAD const * pHd, SfxAllItemSet &rSet);
1612     SdrObject *ReadCaptionBox(WW8_DPHEAD const * pHd, SfxAllItemSet &rSet);
1613     SdrObject *ReadGroup(WW8_DPHEAD const * pHd, SfxAllItemSet &rSet);
1614     SdrObject *ReadGrafPrimitive(short& rLeft, SfxAllItemSet &rSet);
1615     void ReadGrafLayer1(WW8PLCFspecial& rPF, tools::Long nGrafAnchorCp);
1616     SdrObject* CreateContactObject(SwFrameFormat* pFlyFormat);
1617     RndStdIds ProcessEscherAlign(SvxMSDffImportRec& rRecord, WW8_FSPA& rFSPA, SfxItemSet& rFlySet);
1618     bool MiserableRTLGraphicsHack(SwTwips &rLeft, SwTwips nWidth,
1619         sal_Int16 eHoriOri, sal_Int16 eHoriRel);
1620     SwFrameFormat* Read_GrafLayer( tools::Long nGrafAnchorCp );
1621     SwFlyFrameFormat* ImportReplaceableDrawables(SdrObject*& rpObject, SdrObject*& rpOurNewObject,
1622                                                  SvxMSDffImportRec& rRecord, WW8_FSPA& rF,
1623                                                  SfxItemSet& rFlySet);
1624     SwFlyFrameFormat* ConvertDrawTextToFly(SdrObject*& rpObject, SdrObject*& rpOurNewObject,
1625                                            const SvxMSDffImportRec& rRecord, RndStdIds eAnchor,
1626                                            const WW8_FSPA& rF, SfxItemSet& rFlySet);
1627     SwFrameFormat* MungeTextIntoDrawBox(SvxMSDffImportRec& rRecord, tools::Long nGrafAnchorCp,
1628                                         SwFrameFormat* pRetFrameFormat);
1629
1630     void GraphicCtor();
1631     void GraphicDtor();
1632
1633 // other stuff
1634     OUString GetFieldResult( WW8FieldDesc const * pF );
1635     void MakeTagString( OUString& rStr, const OUString& rOrg );
1636     void UpdateFields();
1637     OUString ConvertFFileName(const OUString& rRaw);
1638     WW8_CP Read_F_Tag(WW8FieldDesc* pF);
1639     void InsertTagField( const sal_uInt16 nId, const OUString& rTagText );
1640     tools::Long ImportExtSprm(WW8PLCFManResult* pRes);
1641     void EndExtSprm(sal_uInt16 nSprmId);
1642     void ReadDocInfo();
1643
1644 // Ver8 lists
1645
1646     void RegisterNumFormatOnTextNode(sal_uInt16 nCurrentLFO, sal_uInt8 nCurrentLevel,
1647                                  const bool bSetAttr = true);
1648
1649     void RegisterNumFormatOnStyle(sal_uInt16 nStyle);
1650     void SetStylesList(sal_uInt16 nStyle, sal_uInt16 nCurrentLFO,
1651         sal_uInt8 nCurrentLevel);
1652     void RegisterNumFormat(sal_uInt16 nCurrentLFO, sal_uInt8 nCurrentLevel);
1653
1654 // to be replaced by calls in the appropriate extended SvxMSDffManager
1655
1656     const OUString* GetAnnotationAuthor(sal_uInt16 nIdx);
1657
1658     void GetSmartTagInfo(SwFltRDFMark& rMark);
1659
1660     // interfaces for the toggle attributes
1661     void SetToggleAttr(sal_uInt8 nAttrId, bool bOn);
1662     void SetToggleBiDiAttr(sal_uInt8 nAttrId, bool bOn);
1663     void ChkToggleAttr_( sal_uInt16 nOldStyle81Mask, sal_uInt16 nNewStyle81Mask );
1664
1665     void ChkToggleAttr( sal_uInt16 nOldStyle81Mask, sal_uInt16 nNewStyle81Mask )
1666     {
1667         if( nOldStyle81Mask != nNewStyle81Mask &&
1668             m_xCtrlStck->GetToggleAttrFlags() )
1669             ChkToggleAttr_( nOldStyle81Mask, nNewStyle81Mask );
1670     }
1671
1672     void ChkToggleBiDiAttr_( sal_uInt16 nOldStyle81Mask, sal_uInt16 nNewStyle81Mask );
1673
1674     void ChkToggleBiDiAttr( sal_uInt16 nOldStyle81Mask, sal_uInt16 nNewStyle81Mask )
1675     {
1676         if( nOldStyle81Mask != nNewStyle81Mask &&
1677             m_xCtrlStck->GetToggleBiDiAttrFlags() )
1678             ChkToggleBiDiAttr_( nOldStyle81Mask, nNewStyle81Mask );
1679     }
1680
1681     void PopTableDesc();
1682     void MoveInsideFly(const SwFrameFormat *pFlyFormat);
1683     SwTwips MoveOutsideFly(SwFrameFormat *pFlyFormat, const SwPosition &rPos,
1684         bool bTableJoin = true);
1685
1686     void SetOutlineStyles();
1687
1688     bool SetSpacing(SwPaM &rMyPam, int nSpace, bool bIsUpper);
1689     bool SetUpperSpacing(SwPaM &pMyPam, int nSpace);
1690     bool SetLowerSpacing(SwPaM &rMyPam, int nSpace);
1691
1692     bool IsInlineEscherHack() const
1693         { return !m_aFieldStack.empty() && m_aFieldStack.back().mnFieldId == 95; };
1694
1695     void StoreMacroCmds();
1696
1697     // #i84783#
1698     // determine object attribute "Layout in Table Cell"
1699     bool IsObjectLayoutInTableCell( const sal_uInt32 nLayoutInTableCell ) const;
1700     void ReadGlobalTemplateSettings( std::u16string_view sCreatedFrom, const css::uno::Reference< css::container::XNameContainer >& xPrjNameMap );
1701     SwWW8ImplReader(const SwWW8ImplReader &) = delete;
1702     SwWW8ImplReader& operator=(const SwWW8ImplReader&) = delete;
1703 public:     // really private, but can only be done public
1704     ~SwWW8ImplReader();
1705     sal_uInt16 GetToggleAttrFlags() const;
1706     sal_uInt16 GetToggleBiDiAttrFlags() const;
1707     void SetToggleAttrFlags(sal_uInt16 nFlags);
1708     void SetToggleBiDiAttrFlags(sal_uInt16 nFlags);
1709
1710     tools::Long Read_Footnote(WW8PLCFManResult* pRes);
1711     sal_uInt16 End_Footnote();
1712     tools::Long Read_Field(WW8PLCFManResult* pRes);
1713     sal_uInt16 End_Field();
1714     tools::Long Read_Book(WW8PLCFManResult*);
1715     tools::Long Read_And(WW8PLCFManResult* pRes);
1716     tools::Long Read_AtnBook(WW8PLCFManResult*);
1717     tools::Long Read_FactoidBook(WW8PLCFManResult*);
1718
1719     // attributes
1720
1721     void Read_Special(sal_uInt16, const sal_uInt8*, short nLen);
1722     void Read_Obj(sal_uInt16, const sal_uInt8*, short nLen);
1723     void Read_PicLoc(sal_uInt16, const sal_uInt8* pData, short nLen );
1724     void Read_BoldUsw(sal_uInt16 nId, const sal_uInt8*, short nLen);
1725     void Read_Bidi(sal_uInt16 nId, const sal_uInt8*, short nLen);
1726     void Read_BoldBiDiUsw(sal_uInt16 nId, const sal_uInt8*, short nLen);
1727     void Read_AmbiguousSPRM(sal_uInt16 nId, const sal_uInt8*, short nLen);
1728     void Read_SubSuper(         sal_uInt16, const sal_uInt8*, short nLen );
1729     bool ConvertSubToGraphicPlacement();
1730     static SwFrameFormat *ContainsSingleInlineGraphic(const SwPaM &rRegion);
1731     void Read_SubSuperProp(     sal_uInt16, const sal_uInt8*, short nLen );
1732     void Read_Underline(        sal_uInt16, const sal_uInt8*, short nLen );
1733     void Read_TextColor(         sal_uInt16, const sal_uInt8*, short nLen );
1734     void openFont(sal_uInt16 nFCode, sal_uInt16 nId);
1735     void closeFont(sal_uInt16 nId);
1736     void Read_FontCode(         sal_uInt16, const sal_uInt8*, short nLen );
1737     void Read_FontSize(         sal_uInt16, const sal_uInt8*, short nLen );
1738     void Read_CharSet(sal_uInt16 , const sal_uInt8* pData, short nLen);
1739     void Read_Language(         sal_uInt16, const sal_uInt8*, short nLen );
1740     void Read_CColl(            sal_uInt16, const sal_uInt8*, short nLen );
1741     void Read_Kern(             sal_uInt16, const sal_uInt8* pData, short nLen );
1742     void Read_FontKern(         sal_uInt16, const sal_uInt8* pData, short nLen );
1743     void Read_Emphasis(         sal_uInt16, const sal_uInt8* pData, short nLen );
1744     void Read_ScaleWidth(       sal_uInt16, const sal_uInt8* pData, short nLen );
1745     void Read_Relief(           sal_uInt16, const sal_uInt8* pData, short nLen);
1746     void Read_TextAnim(      sal_uInt16, const sal_uInt8* pData, short nLen);
1747
1748     void Read_NoLineNumb(       sal_uInt16 nId, const sal_uInt8* pData, short nLen );
1749
1750     void Read_LR(               sal_uInt16 nId, const sal_uInt8*, short nLen );
1751     void Read_UL(               sal_uInt16 nId, const sal_uInt8*, short nLen );
1752     void Read_ParaAutoBefore(sal_uInt16 , const sal_uInt8 *pData, short nLen);
1753     void Read_ParaAutoAfter(sal_uInt16 , const sal_uInt8 *pData, short nLen);
1754     void Read_ParaContextualSpacing( sal_uInt16 nId, const sal_uInt8* pData, short nLen );
1755     void Read_LineSpace(        sal_uInt16, const sal_uInt8*, short nLen );
1756
1757     void SetRelativeJustify( bool bRel );
1758     bool IsRelativeJustify();
1759     bool IsRelativeJustify(sal_uInt16 nColl, o3tl::sorted_vector<sal_uInt16>& rVisitedStyles);
1760     void Read_Justify(sal_uInt16, const sal_uInt8*, short nLen);
1761
1762     void Read_IdctHint(sal_uInt16, const sal_uInt8*, short nLen);
1763     bool IsRightToLeft();
1764     void Read_RTLJustify(sal_uInt16, const sal_uInt8*, short nLen);
1765     void Read_Hyphenation(      sal_uInt16, const sal_uInt8* pData, short nLen );
1766     void Read_WidowControl(     sal_uInt16, const sal_uInt8* pData, short nLen );
1767     void Read_AlignFont(        sal_uInt16, const sal_uInt8* pData, short nLen );
1768     void Read_UsePgsuSettings(  sal_uInt16, const sal_uInt8* pData, short nLen );
1769     void Read_KeepLines(        sal_uInt16, const sal_uInt8* pData, short nLen );
1770     void Read_KeepParas(        sal_uInt16, const sal_uInt8* pData, short nLen );
1771     void Read_BreakBefore(      sal_uInt16, const sal_uInt8* pData, short nLen );
1772     void Read_ApoPPC(sal_uInt16, const sal_uInt8* pData, short);
1773
1774     void Read_BoolItem(         sal_uInt16 nId, const sal_uInt8*, short nLen );
1775
1776     void Read_Border(           sal_uInt16 nId, const sal_uInt8* pData, short nLen );
1777     void Read_CharBorder(sal_uInt16 nId, const sal_uInt8* pData, short nLen );
1778     void Read_Tab(              sal_uInt16 nId, const sal_uInt8* pData, short nLen );
1779     void Read_Symbol(sal_uInt16, const sal_uInt8* pData, short nLen);
1780     void Read_FieldVanish(        sal_uInt16 nId, const sal_uInt8* pData, short nLen );
1781
1782     // Revision Marks ( == Redlining )
1783
1784     // insert or delete content (change char attributes resp.)
1785     void Read_CRevisionMark(RedlineType eType, const sal_uInt8* pData, short nLen);
1786     // insert new content
1787     void Read_CFRMark(sal_uInt16 , const sal_uInt8* pData, short nLen);
1788     // delete old content
1789     void Read_CFRMarkDel(sal_uInt16 , const sal_uInt8* pData, short nLen);
1790     // change properties of content (e.g. char formatting)
1791     void Read_CPropRMark(sal_uInt16 , const sal_uInt8* pData, short nLen); // complex!
1792
1793     void Read_TabRowEnd(        sal_uInt16, const sal_uInt8* pData, short nLen );
1794     void Read_TabCellEnd(        sal_uInt16, const sal_uInt8* pData, short nLen );
1795     bool ParseTabPos(WW8_TablePos *aTabPos, WW8PLCFx_Cp_FKP* pPap);
1796     void Read_Shade(            sal_uInt16, const sal_uInt8* pData, short nLen );
1797     void Read_ANLevelNo(        sal_uInt16, const sal_uInt8* pData, short nLen );
1798     void Read_ANLevelDesc(      sal_uInt16, const sal_uInt8* pData, short nLen );
1799
1800     // outline level Ver8
1801     void Read_POutLvl(sal_uInt16, const sal_uInt8* pData, short nLen);
1802
1803     void Read_OLST(             sal_uInt16, const sal_uInt8* pData, short nLen );
1804
1805     void Read_CharShadow(       sal_uInt16, const sal_uInt8* pData, short nLen );
1806     void Read_CharHighlight(    sal_uInt16, const sal_uInt8* pData, short nLen );
1807                                         // Ver8-Listen
1808
1809     void Read_ListLevel(        sal_uInt16 nId, const sal_uInt8* pData, short nLen);
1810
1811     /**
1812      * read and interpret the sprmPIlfo used to determine which list
1813      * contains the paragraph.
1814      * @param     nId   unused (sprm value, 0x460b for sprmPIlfo).
1815      * @param[in] pData operand.
1816      * @param[in] nLen  size of the operand (pData) in byte, should be 2.
1817      *                  -1 to indicate the actual level is finished.
1818      */
1819     void Read_LFOPosition(      sal_uInt16 nId, const sal_uInt8* pData, short nLen);
1820     bool SetTextFormatCollAndListLevel(const SwPaM& rRg, SwWW8StyInf& rStyleInfo);
1821
1822     void Read_StyleCode(sal_uInt16, const sal_uInt8* pData, short nLen);
1823     void Read_Majority(sal_uInt16, const sal_uInt8* , short );
1824     void Read_DoubleLine_Rotate( sal_uInt16, const sal_uInt8* pDATA, short nLen);
1825
1826     void Read_TextForeColor(sal_uInt16, const sal_uInt8* pData, short nLen);
1827     void Read_TextBackColor(sal_uInt16, const sal_uInt8* pData, short nLen);
1828     void Read_ParaBackColor(sal_uInt16, const sal_uInt8* pData, short nLen);
1829     void Read_ParaBiDi(sal_uInt16, const sal_uInt8* pData, short nLen);
1830     static Color ExtractColour(const sal_uInt8* &rpData, bool bVer67);
1831
1832     void Read_TextVerticalAdjustment(sal_uInt16, const sal_uInt8* pData, short nLen);
1833     void Read_UnderlineColor(sal_uInt16, const sal_uInt8* pData, short nLen);
1834     tools::Long MapBookmarkVariables(const WW8FieldDesc* pF, OUString &rOrigName,
1835         const OUString &rData);
1836     OUString GetMappedBookmark(std::u16string_view rOrigName);
1837
1838     // fields
1839     eF_ResT Read_F_Input(WW8FieldDesc*, OUString& rStr);
1840     eF_ResT Read_F_InputVar(WW8FieldDesc*, OUString& rStr);
1841     eF_ResT Read_F_ANumber( WW8FieldDesc*, OUString& );
1842     eF_ResT Read_F_DocInfo( WW8FieldDesc* pF, OUString& rStr );
1843     eF_ResT Read_F_Author( WW8FieldDesc*, OUString& );
1844     eF_ResT Read_F_TemplName( WW8FieldDesc*, OUString& );
1845     SvNumFormatType GetTimeDatePara(OUString const & rStr, sal_uInt32& rFormat, LanguageType &rLang,
1846         int nWhichDefault, bool bHijri = false);
1847     bool ForceFieldLanguage(SwField &rField, LanguageType nLang);
1848     eF_ResT Read_F_DateTime( WW8FieldDesc*, OUString& rStr );
1849     eF_ResT Read_F_FileName( WW8FieldDesc*, OUString& rStr);
1850     eF_ResT Read_F_Num( WW8FieldDesc* pF, OUString& );
1851     eF_ResT Read_F_CurPage( WW8FieldDesc*, OUString& );
1852     eF_ResT Read_F_Ref( WW8FieldDesc* pF, OUString& );
1853
1854     eF_ResT Read_F_Set( WW8FieldDesc*, OUString& rStr );
1855     eF_ResT Read_F_PgRef( WW8FieldDesc*, OUString& rStr );
1856     eF_ResT Read_F_NoteReference( WW8FieldDesc* pF, OUString& rStr );
1857
1858     eF_ResT Read_F_Tox( WW8FieldDesc* pF, OUString& rStr );
1859     eF_ResT Read_F_Symbol( WW8FieldDesc*, OUString& rStr );
1860     eF_ResT Read_F_Embedd( WW8FieldDesc*, OUString& rStr );
1861     eF_ResT Read_F_FormTextBox( WW8FieldDesc* pF, OUString& rStr);
1862     eF_ResT Read_F_FormCheckBox( WW8FieldDesc* pF, OUString& rStr );
1863     eF_ResT Read_F_FormListBox( WW8FieldDesc* pF, OUString& rStr);
1864     css::awt::Size MiserableDropDownFormHack(const OUString &rString,
1865         css::uno::Reference<css::beans::XPropertySet> const & rPropSet);
1866
1867     eF_ResT Read_F_Macro( WW8FieldDesc*, OUString& rStr);
1868     eF_ResT Read_F_DBField( WW8FieldDesc*, OUString& rStr );
1869     eF_ResT Read_F_DBNext( WW8FieldDesc*, OUString& );
1870     eF_ResT Read_F_DBNum( WW8FieldDesc*, OUString& );
1871     eF_ResT Read_F_Equation( WW8FieldDesc*, OUString& );
1872     void Read_SubF_Ruby( msfilter::util::WW8ReadFieldParams& rReadParam);
1873     eF_ResT Read_F_IncludePicture( WW8FieldDesc*, OUString& rStr );
1874     eF_ResT Read_F_IncludeText(    WW8FieldDesc*, OUString& rStr );
1875     eF_ResT Read_F_Seq( WW8FieldDesc*, OUString& rStr );
1876     /// Reads a STYLEREF field.
1877     eF_ResT Read_F_Styleref(WW8FieldDesc*, OUString& rStr);
1878
1879     eF_ResT Read_F_OCX(WW8FieldDesc*, OUString&);
1880     eF_ResT Read_F_Hyperlink(WW8FieldDesc*, OUString& rStr);
1881     eF_ResT Read_F_Shape(WW8FieldDesc* pF, OUString& rStr);
1882     eF_ResT Read_F_HTMLControl( WW8FieldDesc* pF, OUString& rStr);
1883
1884     short ImportSprm(const sal_uInt8* pPos, sal_Int32 nMemLen, sal_uInt16 nId = 0);
1885
1886     bool SearchRowEnd(WW8PLCFx_Cp_FKP* pPap,WW8_CP &rStartCp, int nLevel) const;
1887     /// Seek to the end of the table with pPap, returns true on success.
1888     bool SearchTableEnd(WW8PLCFx_Cp_FKP* pPap) const;
1889     bool FloatingTableConversion(WW8PLCFx_Cp_FKP* pPap);
1890
1891     const WW8Fib& GetFib() const    { return *m_xWwFib; }
1892     SwDoc& GetDoc() const           { return m_rDoc; }
1893     sal_uInt16 GetCurrentColl()  const     { return m_nCurrentColl; }
1894     void SetNCurrentColl( sal_uInt16 nColl ) { m_nCurrentColl = nColl;    }
1895     std::unique_ptr<SfxItemSet> SetCurrentItemSet(std::unique_ptr<SfxItemSet> pItemSet);
1896     sal_uInt16 StyleUsingLFO( sal_uInt16 nLFOIndex ) const ;
1897     const SwFormat* GetStyleWithOrgWWName( std::u16string_view rName ) const ;
1898
1899     static bool GetPictGrafFromStream(Graphic& rGraphic, SvStream& rSrc);
1900     SAL_WARN_UNUSED_RESULT static bool PicRead(SvStream *pDataStream, WW8_PIC *pPic, bool bVer67);
1901     static bool ImportOleWMF(const tools::SvRef<SotStorage>& xSrc1, GDIMetaFile& rWMF, tools::Long& rX,
1902                              tools::Long& rY);
1903     static Color GetCol(sal_uInt8 nIco);
1904
1905     SwWW8ImplReader( sal_uInt8 nVersionPara, SotStorage* pStorage, SvStream* pSt,
1906         SwDoc& rD, const OUString& rBaseURL, bool bNewDoc, bool bSkipImages, SwPosition const &rPos );
1907
1908     const OUString& GetBaseURL() const { return m_sBaseURL; }
1909     // load a complete doc file
1910     ErrCode LoadDoc(WW8Glossary *pGloss=nullptr);
1911     rtl_TextEncoding GetCurrentCharSet();
1912     rtl_TextEncoding GetCurrentCJKCharSet();
1913     rtl_TextEncoding GetCharSetFromLanguage();
1914     rtl_TextEncoding GetCJKCharSetFromLanguage();
1915
1916     void PostProcessAttrs();
1917     void ReadEmbeddedData(SvStream& rStrm, SwDocShell const * pDocShell, struct HyperLinksTable& hlStr);
1918     void NotifyMacroEventRead();
1919 };
1920
1921 bool CanUseRemoteLink(const OUString &rGrfName);
1922 void UseListIndent(SwWW8StyInf &rStyle, const SwNumFormat &rFormat);
1923 void SetStyleIndent(SwWW8StyInf &rStyleInfo, const SwNumFormat &rFormat);
1924 // #i103711#
1925 // #i105414#
1926 void SyncIndentWithList( SvxLRSpaceItem &rLR,
1927                          const SwNumFormat &rFormat,
1928                          const bool bFirstLineOfStSet,
1929                          const bool bLeftIndentSet );
1930 tools::Long GetListFirstLineIndent(const SwNumFormat &rFormat);
1931 OUString BookmarkToWriter(std::u16string_view rBookmark);
1932 bool RTLGraphicsHack(SwTwips &rLeft, SwTwips nWidth,
1933     sal_Int16 eHoriOri, sal_Int16 eHoriRel, SwTwips nPageLeft,
1934     SwTwips nPageRight, SwTwips nPageSize);
1935 void MatchEscherMirrorIntoFlySet(const SvxMSDffImportRec &rRecord,
1936     SfxItemSet &rFlySet);
1937 #endif
1938
1939 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */