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 <svl/zforlist.hxx>
  28 #include <fltshell.hxx>
  29
  30 #include <svx/svdobj.hxx>
  31
  32 #include <utility>
  33 #include <vector>
  34 #include <stack>
  35 #include <string_view>
  36 #include <deque>
  37 #include <map>
  38 #include <memory>
  39 #include <optional>
  40
  41 #include "ww8struc.hxx"
  42 #include "ww8scan.hxx"
  43 #include "ww8glsy.hxx"
  44 #include "ww8graf.hxx"
  45 #include "wrtww8.hxx"
  46 #include <msfilter.hxx>
  47 #include <xmloff/odffields.hxx>
  48 #include <IMark.hxx>
  49
  50 #include <com/sun/star/drawing/TextVerticalAdjust.hpp>
  51 #include <swtypes.hxx>
  52 #include <fmtfsize.hxx>
  53 #include <fmtornt.hxx>
  54 #include <fmtsrnd.hxx>
  55 #include <ndtxt.hxx>
  56 #include <editeng/lrspitem.hxx>
  57 #include <o3tl/sorted_vector.hxx>
  58 #include <oox/ole/olehelper.hxx>
  59
  60 #define SW_UD_IMAPDATA      2
  61
  62 class SwDoc;
  63 class SwPaM;
  64 class SfxPoolItem;
  65 class SwTextFormatColl;
  66 class SwPageDesc;
  67 class SvxBoxItem;
  68 class SwFormat;
  69 class SwNodeIndex;
  70 class SwFlyFrameFormat;
  71 class SwAttrSet;
  72 class SwNumRule;
  73 class SwFrameFormat;
  74 class Writer;
  75 class SwFormatField;
  76 class WW8Fib;
  77 class WW8PLCFMan;
  78 struct WW8PLCFManResult;
  79 class WW8RStyle;
  80 class WW8PLCF_HdFt;
  81 class WW8ScannerBase;
  82 struct WW8FlyPara;
  83 struct WW8SwFlyPara;
  84 struct WW8_PIC;
  85 class WW8TabDesc;
  86 struct WW8_SHD;
  87 struct WW8_OLST;
  88 class SwNumFormat;
  89 struct WW8_ANLD;
  90 struct WW8_ANLV;
  91 struct WW8_DO;
  92 struct WW8_DPHEAD;
  93 struct WW8_FSPA;
  94 class SdrModel;
  95 class SdrPage;
  96 class SdrObject;
  97 class SdrTextObj;
  98 class SdrUnoObj;
  99 class Size;
 100 class EditEngine;
 101 struct SwPosition;
 102 class WW8ReaderSave;
 103 struct WW8PicDesc;
 104 class Graphic;
 105 class SwFieldType;
 106 class SotStorage;
 107 class SwAttrSet;
 108 class GDIMetaFile;
 109 struct ESelection;
 110 class SfxItemSet;
 111 class OutlinerParaObject;
 112 enum class SwLineBreakClear;
 113
 114 namespace com::sun::star{
 115     namespace beans{ class XPropertySet;}
 116     namespace form { class XFormComponent;}
 117     namespace drawing{class XShape;}
 118     namespace lang{class XMultiServiceFactory;}
 119 }
 120
 121 // defines only for the WW8-variable of the INI file
 122 #define WW8FL_NO_STYLES      2
 123 #define WW8FL_NO_GRAF     0x80
 124
 125 #define WW8FL_NO_OUTLINE         0x1000
 126 #define WW8FL_NO_IMPLPASP        0x4000  // no implicit para space
 127 #define WW8FL_NO_GRAFLAYER       0x8000
 128
 129 // Add-on-filter-flags, valid from Winword 8 on
 130 #define WW8FL_NO_FLY_FOR_TXBX         1
 131
 132 //            List-Manager (from Ver8 on)
 133
 134 struct WW8LFOInfo;
 135
 136 class WW8Reader : public StgReader
 137 {
 138     std::shared_ptr<SvStream> mDecodedStream;
 139     virtual ErrCode Read(SwDoc &, const OUString& rBaseURL, SwPaM &, const OUString &) override;
 140     ErrCode OpenMainStream( tools::SvRef<SotStorageStream>& rRef, sal_uInt16& rBuffSize );
 141     ErrCode DecryptDRMPackage();
 142 public:
 143     WW8Reader() {}
 144     virtual SwReaderType GetReaderType() override;
 145
 146     virtual bool HasGlossaries() const override;
 147     virtual bool ReadGlossaries( SwTextBlocks&, bool bSaveRelFiles ) const override;
 148 };
 149
 150 class SwWW8ImplReader;
 151 struct WW8LSTInfo;
 152 class WW8ListManager
 153 {
 154 public:
 155     WW8ListManager(SvStream& rSt_, SwWW8ImplReader& rReader_);
 156     //Min and Max possible List Levels in Word
 157     enum ListLevel {nMinLevel=1, nMaxLevel=9};
 158     //the rParaSprms returns back the original word paragraph indent
 159     //sprms which were attached to the original numbering format
 160     SwNumRule* GetNumRuleForActivation(sal_uInt16 nLFOPosition, const sal_uInt8 nLevel,
 161         std::vector<sal_uInt8> &rParaSprms, SwTextNode *pNode=nullptr);
 162     SwNumRule* CreateNextRule(bool bSimple);
 163     ~WW8ListManager();
 164     SwNumRule* GetNumRule(size_t i);
 165     size_t GetWW8LSTInfoNum() const{return maLSTInfos.size();}
 166     static SvxNumType GetSvxNumTypeFromMSONFC(sal_uInt16 nMSONFC);
 167
 168 private:
 169     wwSprmParser maSprmParser;
 170     SwWW8ImplReader& m_rReader;
 171     SwDoc&           m_rDoc;
 172     const WW8Fib&    m_rFib;
 173     SvStream&        m_rSt;
 174     std::vector<std::unique_ptr<WW8LSTInfo>> maLSTInfos;
 175     std::vector<std::unique_ptr<WW8LFOInfo>> m_LFOInfos;// D. from PLF LFO, sorted exactly like in the WW8 Stream
 176     sal_uInt16       m_nUniqueList; // current number for creating unique list names
 177     SprmResult GrpprlHasSprm(sal_uInt16 nId, sal_uInt8& rSprms, sal_uInt8 nLen);
 178     WW8LSTInfo* GetLSTByListId(    sal_uInt32  nIdLst     ) const;
 179     //the rParaSprms returns back the original word paragraph indent
 180     //sprms which are attached to this numbering level
 181     bool ReadLVL(SwNumFormat& rNumFormat, std::unique_ptr<SfxItemSet>& rpItemSet, sal_uInt16 nLevelStyle,
 182         bool bSetStartNo, sal_uInt16 nLevel, ww::bytes &rParaSprms);
 183
 184     // character attributes from GrpprlChpx
 185     typedef std::unique_ptr<SfxItemSet> WW8aISet[nMaxLevel];
 186     // character style pointer
 187     typedef SwCharFormat* WW8aCFormat[nMaxLevel];
 188
 189     void AdjustLVL(sal_uInt8 nLevel, SwNumRule& rNumRule, WW8aISet const & rListItemSet,
 190         WW8aCFormat& aCharFormat, bool& bNewCharFormatCreated,
 191         const OUString& aPrefix = OUString());
 192
 193     void ImplDestroy();
 194
 195     WW8ListManager(const WW8ListManager&) = delete;
 196     WW8ListManager& operator=(const WW8ListManager&) = delete;
 197     sal_uInt16 m_nLastLFOPosition;
 198 };
 199
 200 struct WW8FlyPara
 201 {                       // WinWord-attributes
 202                         // Attention: *DO NOT* reorder, since parts will be
 203                         // compared using memcmp
 204     bool bVer67;
 205     sal_Int16 nTDxaAbs, nTDyaAbs;         // raw position
 206     sal_Int16 nSp45, nSp28;         // width / height
 207     sal_Int16 nLeftMargin, nRightMargin, nUpperMargin, nLowerMargin;           // borders
 208     sal_uInt8 nTPc;                 // raw binding + alignment
 209     sal_uInt8 nPWr;                 // Wrap-Mode ( 1 / 2; 0 = no Apo ? )
 210     WW8_BRCVer9_5 brc;          // borders Top, Left, Bottom, Right, Between
 211     bool bBorderLines;          // border lines
 212     bool bGrafApo;              // true: this frame is only used to position
 213                                 // the contained graphics *not* as a character
 214     bool mbVertSet;             // true if vertical positioning has been set
 215
 216     WW8FlyPara(bool bIsVer67, const WW8FlyPara* pSrc = nullptr);
 217     bool operator==(const WW8FlyPara& rSrc) const;
 218     void Read(sal_uInt8 nSprmTPc, WW8PLCFx_Cp_FKP* pPap);
 219     void ReadFull(sal_uInt8 nSprm29, SwWW8ImplReader* pIo);
 220     void Read(sal_uInt8 nSprmTPc, WW8RStyle const * pStyle);
 221     void ApplyTabPos(const WW8_TablePos *pTabPos);
 222     bool IsEmpty() const;
 223 };
 224
 225 class SwWW8StyInf
 226 {
 227     OUString        m_sWWStyleName;
 228     sal_uInt16      m_nWWStyleId;
 229 public:
 230     rtl_TextEncoding m_eLTRFontSrcCharSet;    // rtl_TextEncoding for the font
 231     rtl_TextEncoding m_eRTLFontSrcCharSet;    // rtl_TextEncoding for the font
 232     rtl_TextEncoding m_eCJKFontSrcCharSet;    // rtl_TextEncoding for the font
 233     SwFormat*      m_pFormat;
 234     std::shared_ptr<WW8FlyPara> m_xWWFly;
 235     SwNumRule*  m_pOutlineNumrule;
 236     tools::Long        m_nFilePos;
 237     sal_uInt16      m_nBase;
 238     sal_uInt16      m_nFollow;
 239     sal_uInt16      m_nLFOIndex;
 240     sal_uInt8        m_nListLevel;
 241
 242     // WW8 outline level is zero-based:
 243     // 0: outline level 1
 244     // 1: outline level 2
 245     // ...
 246     // 8: outline level 9
 247     // 9: body text
 248     sal_uInt8 mnWW8OutlineLevel;
 249
 250     sal_uInt16  m_n81Flags;           // for bold, italic, ...
 251     sal_uInt16  m_n81BiDiFlags;       // for bold, italic, ...
 252     std::shared_ptr<SvxFirstLineIndentItem> m_pWordFirstLine;
 253     std::shared_ptr<SvxTextLeftMarginItem> m_pWordLeftMargin;
 254     std::shared_ptr<SvxRightMarginItem> m_pWordRightMargin;
 255     bool m_bValid;            // empty of valid
 256     bool m_bImported;         // for recursive imports
 257     bool m_bColl;             // true-> pFormat is SwTextFormatColl
 258     bool m_bImportSkipped;    // only true if !bNewDoc && existing style
 259     bool m_bHasStyNumRule;    // true-> named NumRule in style
 260     bool m_bHasBrokenWW6List; // true-> WW8+ style has a WW7- list
 261     bool m_bListRelevantIndentSet; //true if this style's indent has
 262                                  //been explicitly set, it's set to the value
 263                                  //of pFormat->GetItemState(RES_LR_SPACE, false)
 264                                  //if it was possible to get the ItemState
 265                                  //for L of the LR space independently
 266     bool m_bParaAutoBefore;   // For Auto spacing before a paragraph
 267     bool m_bParaAutoAfter;    // For Auto Spacing after a paragraph
 268     sal_Int16 m_nRelativeJustify;
 269
 270     SwWW8StyInf() :
 271         m_sWWStyleName( OUString() ),
 272         m_nWWStyleId( 0 ),
 273         m_eLTRFontSrcCharSet(0),
 274         m_eRTLFontSrcCharSet(0),
 275         m_eCJKFontSrcCharSet(0),
 276         m_pFormat( nullptr ),
 277         m_pOutlineNumrule( nullptr ),
 278         m_nFilePos( 0 ),
 279         m_nBase( 0 ),
 280         m_nFollow( 0 ),
 281         m_nLFOIndex( USHRT_MAX ),
 282         m_nListLevel(MAXLEVEL),
 283         mnWW8OutlineLevel( MAXLEVEL ),
 284         m_n81Flags( 0 ),
 285         m_n81BiDiFlags(0),
 286         m_pWordFirstLine(std::make_shared<SvxFirstLineIndentItem>(RES_MARGIN_FIRSTLINE)),
 287         m_pWordLeftMargin(std::make_shared<SvxTextLeftMarginItem>(RES_MARGIN_TEXTLEFT)),
 288         m_pWordRightMargin(std::make_shared<SvxRightMarginItem>(RES_MARGIN_RIGHT)),
 289         m_bValid(false),
 290         m_bImported(false),
 291         m_bColl(false),
 292         m_bImportSkipped(false),
 293         m_bHasStyNumRule(false),
 294         m_bHasBrokenWW6List(false),
 295         m_bListRelevantIndentSet(false),
 296         m_bParaAutoBefore(false),
 297         m_bParaAutoAfter(false),
 298         m_nRelativeJustify(-1)
 299
 300     {}
 301
 302     void SetOrgWWIdent( const OUString& rName, const sal_uInt16 nId )
 303     {
 304         m_sWWStyleName = rName;
 305         m_nWWStyleId = nId;
 306
 307         // apply default WW8 outline level to WW8 Built-in Heading styles
 308         if (IsWW8BuiltInHeadingStyle())
 309         {
 310             mnWW8OutlineLevel = m_nWWStyleId - 1;
 311         }
 312     }
 313
 314     const OUString& GetOrgWWName() const
 315     {
 316         return m_sWWStyleName;
 317     }
 318
 319     bool HasWW8OutlineLevel() const
 320     {
 321         return (m_pFormat != nullptr && (MAXLEVEL > mnWW8OutlineLevel));
 322     }
 323
 324     bool IsOutlineNumbered() const
 325     {
 326         return m_pOutlineNumrule && HasWW8OutlineLevel();
 327     }
 328
 329     const SwNumRule* GetOutlineNumrule() const
 330     {
 331         return m_pOutlineNumrule;
 332     }
 333     rtl_TextEncoding GetCharSet() const;
 334     rtl_TextEncoding GetCJKCharSet() const;
 335
 336     sal_uInt16 GetWWStyleId() const
 337     {
 338         return m_nWWStyleId;
 339     }
 340
 341     bool IsWW8BuiltInHeadingStyle() const
 342     {
 343         return GetWWStyleId() >= 1 && GetWWStyleId() <= 9;
 344     }
 345
 346     bool IsWW8BuiltInDefaultStyle() const
 347     {
 348         return GetWWStyleId() == 0;
 349     }
 350
 351     static sal_uInt8
 352     WW8OutlineLevelToOutlinelevel(const sal_uInt8 nWW8OutlineLevel)
 353     {
 354         if (nWW8OutlineLevel < MAXLEVEL)
 355         {
 356             if (nWW8OutlineLevel == 9)
 357             {
 358                 return 0; // no outline level --> body text
 359             }
 360             else
 361             {
 362                 return nWW8OutlineLevel + 1; // outline level 1..9
 363             }
 364         }
 365
 366         return 0;
 367     }
 368 };
 369
 370 //            Stack
 371
 372 class SwWW8FltControlStack : public SwFltControlStack
 373 {
 374 private:
 375     SwWW8ImplReader& m_rReader;
 376     std::unique_ptr<SfxItemSet> m_xScratchSet;
 377     sal_uInt16 m_nToggleAttrFlags;
 378     sal_uInt16 m_nToggleBiDiAttrFlags;
 379     SwWW8FltControlStack(const SwWW8FltControlStack&) = delete;
 380     SwWW8FltControlStack& operator=(const SwWW8FltControlStack&) = delete;
 381     const SwNumFormat* GetNumFormatFromStack(const SwPosition &rPos,
 382         const SwTextNode &rTextNode);
 383 protected:
 384     virtual void SetAttrInDoc(const SwPosition& rTmpPos,
 385         SwFltStackEntry& rEntry) override;
 386
 387 public:
 388     SwWW8FltControlStack(SwDoc& rDo, sal_uLong nFieldFl, SwWW8ImplReader& rReader_ )
 389         : SwFltControlStack( rDo, nFieldFl ), m_rReader( rReader_ ),
 390         m_nToggleAttrFlags(0), m_nToggleBiDiAttrFlags(0)
 391     {}
 392
 393     void NewAttr(const SwPosition& rPos, const SfxPoolItem& rAttr);
 394
 395     virtual SwFltStackEntry* SetAttr(const SwPosition& rPos, sal_uInt16 nAttrId, bool bTstEnd=true, tools::Long nHand=LONG_MAX, bool consumedByField=false) override;
 396
 397     void SetToggleAttr(sal_uInt8 nId, bool bOn)
 398     {
 399         if( bOn )
 400             m_nToggleAttrFlags |= (1 << nId);
 401         else
 402             m_nToggleAttrFlags &= ~(1 << nId);
 403     }
 404
 405     sal_uInt16 GetToggleAttrFlags() const { return m_nToggleAttrFlags; }
 406
 407     void SetToggleBiDiAttr(sal_uInt8 nId, bool bOn)
 408     {
 409         if( bOn )
 410             m_nToggleBiDiAttrFlags |= (1 << nId);
 411         else
 412             m_nToggleBiDiAttrFlags &= ~(1 << nId);
 413     }
 414
 415     sal_uInt16 GetToggleBiDiAttrFlags() const { return m_nToggleBiDiAttrFlags; }
 416     void SetToggleAttrFlags(sal_uInt16 nFlags) { m_nToggleAttrFlags = nFlags; }
 417     void SetToggleBiDiAttrFlags(sal_uInt16 nFlags) {m_nToggleBiDiAttrFlags = nFlags;}
 418
 419     const SfxPoolItem* GetFormatAttr(const SwPosition& rPos, sal_uInt16 nWhich);
 420     template<class T> const T* GetFormatAttr( const SwPosition& rPos, TypedWhichId<T> nWhich )
 421     {
 422         return static_cast<const T*>(GetFormatAttr(rPos, sal_uInt16(nWhich)));
 423     }
 424     const SfxPoolItem* GetStackAttr(const SwPosition& rPos, sal_uInt16 nWhich);
 425 };
 426
 427 //The only thing this is for is RES_FLTR_ANCHOR, anything else is an error.
 428 //For graphics whose anchoring position would otherwise be automatically moved
 429 //along by the insertion of text.
 430 class SwWW8FltAnchorStack : public SwFltControlStack
 431 {
 432 public:
 433     SwWW8FltAnchorStack(SwDoc& rDo, sal_uLong nFieldFl)
 434         : SwFltControlStack( rDo, nFieldFl ) {}
 435     void AddAnchor(const SwPosition& rPos,SwFrameFormat *pFormat);
 436     void Flush();
 437 private:
 438     SwWW8FltAnchorStack(const SwWW8FltAnchorStack&) = delete;
 439     SwWW8FltAnchorStack& operator=(const SwWW8FltAnchorStack&) = delete;
 440 };
 441
 442
 443 namespace SwWW8
 444 {
 445     struct ltstr
 446     {
 447         bool operator()(std::u16string_view r1, std::u16string_view r2) const
 448         {
 449             return o3tl::compareToIgnoreAsciiCase(r1, r2)<0;
 450         }
 451     };
 452 };
 453
 454 class SwWW8ReferencedFltEndStack : public SwFltEndStack
 455 {
 456 public:
 457     SwWW8ReferencedFltEndStack( SwDoc& rDo, sal_uLong nFieldFl )
 458         : SwFltEndStack( rDo, nFieldFl )
 459         , m_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> m_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         , m_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> m_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(std::u16string_view aString) -> 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         const 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 m_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(OUString aN, 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(std::move( aN ))
 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 *m_pPaM;
 747     sal_uInt32 mnObjectId;
 748 };
 749
 750 class SwMSDffManager : public SvxMSDffManager
 751 {
 752 private:
 753     SwWW8ImplReader& m_rReader;
 754     SvStream *m_pFallbackStream;
 755     std::unordered_map<sal_uInt32, Graphic> m_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 rtl::Reference<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 rtl::Reference<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 m_brc[4];
 787     SwNodeIndex maStart;
 788     SwSection *mpSection;
 789     SwPageDesc *mpPage;
 790     SvxFrameDirection meDir;
 791
 792     sal_uInt32 m_nPgWidth;
 793     sal_uInt32 m_nPgLeft;
 794     sal_uInt32 m_nPgRight;
 795     sal_uInt32 m_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 m_nPgWidth; }
 812     sal_uInt32 GetTextAreaWidth() const
 813         { return GetPageWidth() - GetPageLeft() - m_nPgGutter - GetPageRight(); }
 814     sal_uInt32 GetPageHeight() const { return maSep.yaPage; }
 815     sal_uInt32 GetPageLeft() const { return m_nPgLeft; }
 816     sal_uInt32 GetPageRight() const { return m_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 SwNode&) 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 class TextNodeListener : public SwClient
 900 {
 901     SwTextNode *m_pTextNode;
 902
 903 protected:
 904     virtual void SwClientNotify(const SwModify&, const SfxHint&) override;
 905
 906 public:
 907     TextNodeListener(SwTextNode* pTextNode);
 908     bool operator<(const TextNodeListener& rOther) const
 909     {
 910         return m_pTextNode->GetIndex() < rOther.m_pTextNode->GetIndex();
 911     }
 912     void StopListening(SwModify* pTextNode);
 913     SwTextNode* GetTextNode() const { return m_pTextNode; }
 914     virtual void removed(SwModify* pTextNode);
 915     virtual ~TextNodeListener() override;
 916 };
 917
 918 //Various writer elements like frames start off containing a blank paragraph,
 919 //sometimes this paragraph turns out to be extraneous, e.g. the frame should
 920 //only contain a table with no trailing paragraph.
 921
 922 //We want to remove these extra paragraphs, but removing them during the parse
 923 //is problematic, because we don't want to remove any paragraphs that are still
 924 //addressed by property entries in a SwFltControlStack which have not yet been
 925 //committed to the document.
 926
 927 //Safest thing is to not delete SwTextNodes from a document during import, and
 928 //remove these extraneous paragraphs at the end after all SwFltControlStack are
 929 //destroyed.
 930 class wwExtraneousParas
 931 {
 932 private:
 933     class ExtraTextNodeListener : public TextNodeListener
 934     {
 935     private:
 936         wwExtraneousParas* m_pOwner;
 937     public:
 938         ExtraTextNodeListener(SwTextNode* pTextNode, wwExtraneousParas* pOwner)
 939             : TextNodeListener(pTextNode)
 940             , m_pOwner(pOwner)
 941         {
 942         }
 943         virtual void removed(SwModify* pTextNode) override;
 944     };
 945
 946     /*
 947     A vector of SwTextNodes to erase from a document after import is complete
 948     */
 949     std::set<ExtraTextNodeListener> m_aTextNodes;
 950     SwDoc& m_rDoc;
 951
 952     void remove_if_present(SwModify* pModify);
 953
 954     wwExtraneousParas(wwExtraneousParas const&) = delete;
 955     wwExtraneousParas& operator=(wwExtraneousParas const&) = delete;
 956 public:
 957     explicit wwExtraneousParas(SwDoc &rDoc) : m_rDoc(rDoc) {}
 958     ~wwExtraneousParas() { delete_all_from_doc(); }
 959     void insert(SwTextNode *pTextNode);
 960     void remove_if_present(SwTextNode *pTextNode)
 961     {
 962         remove_if_present(static_cast<SwModify*>(pTextNode));
 963     }
 964     void delete_all_from_doc();
 965 };
 966
 967 class wwFrameNamer
 968 {
 969 private:
 970     OUString msSeed;
 971     sal_Int32 mnImportedGraphicsCount;
 972     bool mbIsDisabled;
 973
 974     wwFrameNamer(wwFrameNamer const&) = delete;
 975     wwFrameNamer& operator=(wwFrameNamer const&) = delete;
 976
 977 public:
 978     void SetUniqueGraphName(SwFrameFormat *pFrameFormat, std::u16string_view rFixedPart);
 979     wwFrameNamer(bool bIsDisabled, OUString aSeed)
 980         : msSeed(std::move(aSeed)), mnImportedGraphicsCount(0), mbIsDisabled(bIsDisabled)
 981     {
 982     }
 983 };
 984
 985 class wwSectionNamer
 986 {
 987 private:
 988     const SwDoc &mrDoc;
 989     OUString msFileLinkSeed;
 990     int mnFileSectionNo;
 991     wwSectionNamer(const wwSectionNamer&) = delete;
 992     wwSectionNamer& operator=(const wwSectionNamer&) = delete;
 993 public:
 994     OUString UniqueName();
 995     wwSectionNamer(const SwDoc &rDoc, OUString aSeed)
 996         : mrDoc(rDoc), msFileLinkSeed(std::move(aSeed)), mnFileSectionNo(0)
 997         { }
 998 };
 999
1000 class FootnoteDescriptor
1001 {
1002 public:
1003     ManTypes meType;
1004     bool mbAutoNum;
1005     WW8_CP mnStartCp;
1006     WW8_CP mnLen;
1007 };
1008
1009 struct ApoTestResults
1010 {
1011     bool mbStartApo;
1012     bool mbStopApo;
1013     bool m_bHasSprm37;
1014     bool m_bHasSprm29;
1015     sal_uInt8 m_nSprm29;
1016     WW8FlyPara* mpStyleApo;
1017     ApoTestResults()
1018         : mbStartApo(false), mbStopApo(false), m_bHasSprm37(false)
1019         , m_bHasSprm29(false), m_nSprm29(0), mpStyleApo(nullptr) {}
1020     bool HasStartStop() const { return (mbStartApo || mbStopApo); }
1021     bool HasFrame() const { return (m_bHasSprm29 || m_bHasSprm37 || mpStyleApo); }
1022 };
1023
1024 struct ANLDRuleMap
1025 {
1026     OUString msOutlineNumRule;    // WinWord 6 numbering, variant 1
1027     OUString msNumberingNumRule;  // WinWord 6 numbering, variant 2
1028     SwNumRule* GetNumRule(const SwDoc& rDoc, sal_uInt8 nNumType);
1029     void SetNumRule(const OUString& rNumRule, sal_uInt8 nNumType);
1030 };
1031
1032 struct SprmReadInfo;
1033 class SwDocShell;
1034 struct WW8PostProcessAttrsInfo
1035 {
1036     bool mbCopy;
1037     WW8_CP mnCpStart;
1038     WW8_CP mnCpEnd;
1039     SwPaM mPaM;
1040     SfxItemSet mItemSet;
1041
1042     WW8PostProcessAttrsInfo(WW8_CP nCpStart, WW8_CP nCpEnd, SwPaM & rPaM);
1043 };
1044
1045 #define MAX_COL 64  // WW6-description: 32, WW6-UI: 31 & WW8-UI: 63!
1046
1047 struct WW8TabBandDesc
1048 {
1049     WW8TabBandDesc* pNextBand;
1050     short nGapHalf;
1051     short mnDefaultLeft;
1052     short mnDefaultTop;
1053     short mnDefaultRight;
1054     short mnDefaultBottom;
1055     bool mbHasSpacing;
1056     short nLineHeight;
1057     short nRows;
1058     sal_uInt16 maDirections[MAX_COL + 1];
1059     short nCenter[MAX_COL + 1]; // X-edge of all cells of this band
1060     short nWidth[MAX_COL + 1];  // length of all cells of this band
1061     short nWwCols;      // sal_uInt8 would be sufficient, alignment -> short
1062     short nSwCols;      // SW: number of columns for the writer
1063     bool bLEmptyCol;    // SW: an additional empty column at the left
1064     bool bREmptyCol;    // SW: same at the right
1065     bool bCantSplit;
1066     bool bCantSplit90;
1067     WW8_TCell* pTCs;
1068     sal_uInt8 nOverrideSpacing[MAX_COL + 1];
1069     short nOverrideValues[MAX_COL + 1][4];
1070     WW8_SHD* pSHDs;
1071     Color* pNewSHDs;
1072     WW8_BRCVer9 aDefBrcs[6];
1073
1074     bool bExist[MAX_COL];           // does this cell exist ?
1075     sal_uInt8 nTransCell[MAX_COL + 2];  // translation WW-Index -> SW-Index
1076
1077     sal_uInt8 transCell(sal_uInt8 nWwCol) const
1078     {
1079         return nWwCol < SAL_N_ELEMENTS(nTransCell) ? nTransCell[nWwCol] : 0xFF;
1080     }
1081
1082     WW8TabBandDesc();
1083     WW8TabBandDesc(WW8TabBandDesc const & rBand);    // deep copy
1084     ~WW8TabBandDesc();
1085     void ReadDef(bool bVer67, const sal_uInt8* pS, short nLen);
1086     void ProcessDirection(const sal_uInt8* pParams);
1087     void ProcessSprmTSetBRC(int nBrcVer, const sal_uInt8* pParamsTSetBRC, sal_uInt16 nParamsLen);
1088     void ProcessSprmTTableBorders(int nBrcVer, const sal_uInt8* pParams, sal_uInt16 nParamsLen);
1089     void ProcessSprmTDxaCol(const sal_uInt8* pParamsTDxaCol);
1090     void ProcessSprmTDelete(const sal_uInt8* pParamsTDelete);
1091     void ProcessSprmTInsert(const sal_uInt8* pParamsTInsert);
1092     void ProcessSpacing(const sal_uInt8* pParamsTInsert);
1093     void ProcessSpecificSpacing(const sal_uInt8* pParamsTInsert);
1094     void ReadShd(const sal_uInt8* pS );
1095     void ReadNewShd(const sal_uInt8* pS, bool bVer67, sal_uInt8 nStart);
1096
1097     enum wwDIR {wwTOP = 0, wwLEFT = 1, wwBOTTOM = 2, wwRIGHT = 3};
1098
1099 private:
1100     WW8TabBandDesc & operator =(WW8TabBandDesc const &) = default; // only for use in copy ctor
1101 };
1102
1103 //            Storage-Reader
1104
1105 typedef std::set<WW8_CP> cp_set;
1106
1107 class SwWW8ImplReader
1108 {
1109 private:
1110     SwDocShell *m_pDocShell;         // The Real DocShell
1111
1112 friend class WW8RStyle;
1113 friend class WW8TabDesc;
1114 friend class WW8ReaderSave;
1115 friend struct WW8FlyPara;
1116 friend struct WW8SwFlyPara;
1117 friend class WW8FlySet;
1118 friend class SwMSDffManager;
1119 friend class SwWW8FltControlStack;
1120 friend class WW8FormulaControl;
1121 friend class wwSectionManager;
1122
1123 private:
1124
1125     SotStorage* m_pStg;                // Input-Storage
1126     SvStream* m_pStrm;                // Input-(Storage)Stream
1127     SvStream* m_pTableStream;         // Input-(Storage)Stream
1128     SvStream* m_pDataStream;          // Input-(Storage)Stream
1129
1130 // general stuff
1131     SwDoc& m_rDoc;
1132     std::shared_ptr<SwUnoCursor> mpCursor;
1133     SwPaM* m_pPaM;
1134
1135     std::unique_ptr<SwWW8FltControlStack> m_xCtrlStck;    // stack for the attributes
1136
1137     /*
1138     This stack is for redlines, because their sequence of discovery can
1139     be out of order of their order of insertion into the document.
1140     */
1141     std::unique_ptr<sw::util::RedlineStack> m_xRedlineStack;
1142
1143     /*
1144     This stack is for fields that get referenced later, e.g. BookMarks and TOX.
1145     They get inserted at the end of the document, it is the same stack for
1146     headers/footers/main text/textboxes/tables etc...
1147     */
1148     std::unique_ptr<SwWW8ReferencedFltEndStack> m_xReffedStck;
1149
1150     /*
1151     This stack is for fields whose true conversion cannot be determined until
1152     the end of the document, it is the same stack for headers/footers/main
1153     text/textboxes/tables etc... They are things that reference other things
1154     e.g. NoteRef and Ref, they are processed after m_xReffedStck
1155     */
1156     std::unique_ptr<SwWW8FltRefStack> m_xReffingStck;
1157
1158     /*
1159     For graphics anchors. Determines the graphics whose anchors are in the
1160     current paragraph, and works around the difficulty in inserting a graphic
1161     anchored to character before a character to be anchored to has been
1162     inserted. Is emptied at the end of each paragraph.
1163     */
1164     std::unique_ptr<SwWW8FltAnchorStack> m_xAnchorStck;
1165
1166     /*
1167     A stack of fields identifiers to keep track of any open fields that need
1168     to be closed. Generally word fields are inserted as writer fields as soon
1169     as they are encountered, and so their end point is normally unimportant.
1170     But hyperlink fields need to be applied as attributes to text and it is
1171     far easier and safer to set the end point of an attribute when we
1172     encounter the end marker of the field instead of calculating in advance
1173     where the end point will fall, to do so fully correctly duplicates the
1174     main logic of the filter itself.
1175     */
1176     std::deque<WW8FieldEntry> m_aFieldStack;
1177
1178     /*
1179     A stack of open footnotes. Should only be one in it at any time.
1180     */
1181     std::deque<FootnoteDescriptor> m_aFootnoteStack;
1182
1183     std::optional<SwLineBreakClear> m_oLineBreakClear;
1184
1185     /*
1186     A queue of the ms sections in the document
1187     */
1188     wwSectionManager m_aSectionManager;
1189
1190     /*
1191     A vector of surplus-to-requirements paragraph in the final document,
1192     that exist because of quirks of the SwDoc document model and/or API,
1193     which need to be removed.
1194     */
1195     wwExtraneousParas m_aExtraneousParas;
1196
1197     /*
1198     A map of tables to their follow nodes for use in inserting tables into
1199     already existing document, i.e. insert file
1200     */
1201     sw::util::InsertedTablesManager m_aInsertedTables;
1202
1203     /*
1204     Creates unique names to give to (file link) sections (WW1/WW2/...)
1205     */
1206     wwSectionNamer m_aSectionNameGenerator;
1207
1208     /*
1209     Knows how to split a series of bytes into sprms and their arguments
1210     */
1211     std::optional<wwSprmParser> m_oSprmParser;
1212
1213     /*
1214     Creates unique names to give to graphics
1215     */
1216     wwFrameNamer m_aGrfNameGenerator;
1217
1218     /*
1219     Knows which writer style a given word style should be imported as.
1220     */
1221     sw::util::ParaStyleMapper m_aParaStyleMapper;
1222     sw::util::CharStyleMapper m_aCharStyleMapper;
1223
1224     /*
1225      Stack of textencoding being used as we progress through the document text
1226     */
1227     std::stack<rtl_TextEncoding> m_aFontSrcCharSets;
1228     std::stack<rtl_TextEncoding> m_aFontSrcCJKCharSets;
1229
1230     /*
1231      Progress bar
1232      */
1233     std::unique_ptr<ImportProgress> m_xProgress;
1234
1235     std::unique_ptr<SwMSConvertControls> m_xFormImpl; // implementation of control
1236
1237     SwFlyFrameFormat* m_pFlyFormatOfJustInsertedGraphic;
1238     std::unique_ptr<FrameDeleteWatch> m_xFormatOfJustInsertedApo;
1239     SwPaM* m_pPreviousNumPaM;
1240     const SwNumRule* m_pPrevNumRule;
1241
1242     //Keep track of APO environments
1243     std::deque<bool> m_aApos;
1244     /*
1245     Keep track of generated Ruby character formats we can minimize the
1246     number of character formats created
1247     */
1248     std::vector<const SwCharFormat*> m_aRubyCharFormats;
1249
1250     /*
1251     For fuzzing keep track of source offset of inserted graphics
1252     */
1253     std::set<sal_uLong> m_aGrafPosSet;
1254
1255     std::unique_ptr<WW8PostProcessAttrsInfo> m_pPostProcessAttrsInfo;
1256
1257     std::shared_ptr<WW8Fib> m_xWwFib;
1258     std::unique_ptr<WW8Fonts> m_xFonts;
1259     std::unique_ptr<WW8Dop> m_xWDop;
1260     std::unique_ptr<WW8ListManager> m_xLstManager;
1261     std::unique_ptr<WW8ScannerBase> m_xSBase;
1262     std::shared_ptr<WW8PLCFMan> m_xPlcxMan;
1263     std::map<short, OUString> m_aLinkStringMap;
1264
1265     o3tl::sorted_vector<const SwNode*> m_aTextNodesHavingFirstLineOfstSet; // #i103711#
1266     o3tl::sorted_vector<const SwNode*> m_aTextNodesHavingLeftIndentSet; // #i105414#
1267
1268     std::unique_ptr<WW8RStyle> m_xStyles;     // pointer to the style reading class
1269     SwFormat* m_pCurrentColl;        // collection to be created now
1270                             // ( always 0 outside of a Style-Def )
1271     std::unique_ptr<SfxItemSet> m_xCurrentItemSet;// character attributes to be read in now
1272                             // (always 0 outside of the WW8ListManager Ctor)
1273     std::vector<SwWW8StyInf> m_vColl;
1274     const SwTextFormatColl* m_pDfltTextFormatColl;    // Default
1275     SwFormat* m_pStandardFormatColl;// "Standard"
1276
1277     std::unique_ptr<WW8PLCF_HdFt> m_xHdFt;        // pointer to Header / Footer - scanner class
1278
1279     std::unique_ptr<WW8FlyPara> m_xWFlyPara;      // WW-parameter
1280     std::unique_ptr<WW8SwFlyPara> m_xSFlyPara;    // Sw parameters created from previous
1281
1282     std::unique_ptr<WW8TabDesc> m_xTableDesc;     // description of table properties
1283     //Keep track of tables within tables
1284     std::stack<std::unique_ptr<WW8TabDesc>> m_aTableStack;
1285
1286     ANLDRuleMap m_aANLDRules;
1287     std::unique_ptr<WW8_OLST> m_xNumOlst;         // position in text
1288
1289     SdrModel* m_pDrawModel;
1290     SdrPage* m_pDrawPg;
1291     std::unique_ptr<EditEngine> m_pDrawEditEngine;
1292     std::unique_ptr<wwZOrderer> m_xWWZOrder;
1293
1294     SwFieldType* m_pNumFieldType;   // for number circle
1295
1296     std::unique_ptr<SwMSDffManager> m_xMSDffManager;
1297
1298     std::optional<std::vector<OUString>> m_xAtnNames;
1299
1300     std::unique_ptr<WW8SmartTagData> m_pSmartTagData;
1301
1302     /// Redlining Authors, map word author key to writer author value
1303     std::map<sal_uInt16, std::size_t> m_aAuthorInfos;
1304     OUString m_sBaseURL;
1305
1306                                 // Ini-Flags:
1307     sal_uInt32 m_nIniFlags;            // flags from writer.ini
1308     sal_uInt32 m_nIniFlags1;           // ditto ( additional flags )
1309     sal_uInt32 m_nFieldFlags;          // ditto for fields
1310     sal_uInt32 m_nFieldTagAlways[3];   // ditto for tagging of fields
1311     sal_uInt32 m_nFieldTagBad[3];      // ditto for tagging of fields that can't be imported
1312     bool m_bRegardHindiDigits;  // import digits in CTL scripts as Hindi numbers
1313
1314     bool m_bDrawCpOValid;
1315     WW8_CP m_nDrawCpO;            // start of Txbx-SubDocs
1316
1317     sal_uLong m_nPicLocFc;            // Picture Location in File (FC)
1318     sal_uLong m_nObjLocFc;            // Object Location in File (FC)
1319
1320     sal_Int32 m_nIniFlyDx;            // X-offset of Flys
1321     sal_Int32 m_nIniFlyDy;            // Y-offset of Flys
1322
1323     rtl_TextEncoding m_eTextCharSet;    // Default charset for Text
1324     rtl_TextEncoding m_eStructCharSet;  // rtl_TextEncoding for structures
1325     rtl_TextEncoding m_eHardCharSet;    // Hard rtl_TextEncoding-Attribute
1326     sal_uInt16 m_nProgress;           // percentage for Progressbar
1327     sal_uInt16 m_nCurrentColl;          // per WW-count
1328     sal_uInt16 m_nFieldNum;             // serial number for that
1329     sal_uInt16 m_nLFOPosition;
1330
1331     short m_nCharFormat;             // per WW-count, <0 for none
1332
1333     short m_nDrawXOfs, m_nDrawYOfs;
1334     short m_nDrawXOfs2, m_nDrawYOfs2;
1335
1336     sal_Unicode m_cSymbol;        // symbol to be read now
1337
1338     sal_uInt8 m_nWantedVersion;        // originally requested WW-Doc version by Writer
1339
1340     sal_uInt8 m_nSwNumLevel;           // level number for outline / enumeration
1341     sal_uInt8 m_nWwNumType;            // outline / number / enumeration
1342     const SwNumRule* m_pChosenWW8OutlineStyle; // copied to the "Outline" Chapter Numbering style
1343     sal_uInt8 m_nListLevel;
1344
1345     bool m_bNewDoc;          // new document?
1346     bool m_bSkipImages;      // skip images for text extraction/indexing
1347     bool m_bReadNoTable;        // no tables
1348     bool m_bPgSecBreak;       // Page- or Sectionbreak is still to be added
1349     bool m_bSpec;             // special char follows in text
1350     bool m_bObj;              // Obj in Text
1351     bool m_bTxbxFlySection;   // FlyFrame that was inserted as replacement for Winword Textbox
1352     bool m_bHasBorder;        // for bundling of the borders
1353     bool m_bSymbol;           // e.g. Symbol instead of Times
1354     bool m_bIgnoreText;       // e.g. for FieldVanish
1355     int  m_nInTable;          // are we currently reading a table?
1356     bool m_bWasTabRowEnd;     // table : Row End Mark
1357     bool m_bWasTabCellEnd;    // table: Cell End Mark
1358
1359     bool m_bAnl;              // enumeration in work
1360                                 // Anl stands for "Autonumber level"
1361
1362     bool m_bHdFtFootnoteEdn;       // special text: header/footer/and so on
1363     bool m_bFootnoteEdn;           // footnote or endnote
1364     bool m_bIsHeader;         // text is read from header ( line height )
1365     bool m_bIsFooter;         // text is read from footer ( line height )
1366
1367     bool m_bIsUnicode;            // current piece of text is encoded as 2-byte Unicode
1368                                 // please do NOT handle this as bit field!
1369
1370     bool m_bCpxStyle;         // style in the complex part
1371     bool m_bStyNormal;        // style with Id 0 is currently read
1372     bool m_bWWBugNormal;      // WW-Version with Bug Dya in Style Normal
1373     bool m_bNoAttrImport;     // ignore attributes for ignoring styles
1374     bool m_bInHyperlink;      // special case for reading 0x01
1375                                    // see also: SwWW8ImplReader::Read_F_Hyperlink()
1376     bool m_bWasParaEnd;
1377
1378     // useful helper variables
1379     bool m_bVer67;            // ( (6 == nVersion) || (7 == nVersion) );
1380     bool m_bVer6;             //   (6 == nVersion);
1381     bool m_bVer7;             //   (7 == nVersion);
1382     bool m_bVer8;             //   (8 == nVersion);
1383
1384     bool m_bEmbeddObj;        // EmbeddField is being read
1385
1386     bool m_bCurrentAND_fNumberAcross; // current active Annotated List Descriptor - ROW flag
1387
1388     bool m_bNoLnNumYet;       // no Line Numbering has been activated yet (we import
1389                             //     the very 1st Line Numbering and ignore the rest)
1390
1391     bool m_bFirstPara;        // first paragraph?
1392     bool m_bFirstParaOfPage;
1393     bool m_bParaAutoBefore;
1394     bool m_bParaAutoAfter;
1395
1396     bool m_bDropCap;
1397     sal_Int32 m_nDropCap;
1398
1399     bool m_bBidi;
1400     bool m_bReadTable;
1401     // Indicate that currently on loading a TOC, managed by Read_F_TOX() and End_Field()
1402     bool m_bLoadingTOXCache;
1403     int m_nEmbeddedTOXLevel;
1404     // Indicate that current on loading a hyperlink, which is inside a TOC; Managed by Read_F_Hyperlink() and End_Field()
1405     bool m_bLoadingTOXHyperlink;
1406     // a document position recorded the after-position of TOC section, managed by Read_F_TOX() and End_Field()
1407     std::optional<SwPaM> m_oPosAfterTOC;
1408     // used for some dropcap tweaking
1409     std::unique_ptr<TextNodeListener> m_xPreviousNode;
1410
1411     std::optional< SwPosition > m_oLastAnchorPos;
1412
1413     bool m_bCareFirstParaEndInToc;
1414     bool m_bCareLastParaEndInToc;
1415     cp_set m_aTOXEndCps;
1416
1417     bool m_bNotifyMacroEventRead;
1418     bool m_bFuzzing;
1419
1420     const SprmReadInfo& GetSprmReadInfo(sal_uInt16 nId) const;
1421
1422     bool StyleExists(unsigned int nColl) const { return (nColl < m_vColl.size()); }
1423     SwWW8StyInf *GetStyle(sal_uInt16 nColl) const;
1424     void AppendTextNode(SwPosition& rPos);
1425
1426     void Read_HdFt(int nSect, const SwPageDesc *pPrev,
1427         const wwSection &rSection);
1428     void Read_HdFtText(WW8_CP nStartCp, WW8_CP nLen, SwFrameFormat const * pHdFtFormat);
1429     void Read_HdFtTextAsHackedFrame(WW8_CP nStart, WW8_CP nLen,
1430         SwFrameFormat const &rHdFtFormat, sal_uInt16 nPageWidth);
1431
1432     bool isValid_HdFt_CP(WW8_CP nHeaderCP) const;
1433
1434     bool HasOwnHeaderFooter(sal_uInt8 nWhichItems, sal_uInt8 grpfIhdt, int nSect);
1435
1436     void HandleLineNumbering(const wwSection &rSection);
1437
1438     void CopyPageDescHdFt( const SwPageDesc* pOrgPageDesc,
1439                            SwPageDesc* pNewPageDesc, sal_uInt8 nCode );
1440
1441     void DeleteStack(std::unique_ptr<SwFltControlStack> prStck);
1442     void DeleteCtrlStack()
1443     {
1444         DeleteStack(std::move(m_xCtrlStck));
1445     }
1446     void DeleteRefStacks()
1447     {
1448         DeleteStack(std::move(m_xReffedStck));
1449         DeleteStack(std::move(m_xReffingStck));
1450     }
1451     void DeleteAnchorStack()
1452     {
1453         DeleteStack(std::move(m_xAnchorStck));
1454     }
1455     void emulateMSWordAddTextToParagraph(const OUString& rAddString);
1456     void simpleAddTextToParagraph(std::u16string_view aAddString);
1457     bool HandlePageBreakChar();
1458     bool ReadChar(tools::Long nPosCp, tools::Long nCpOfs);
1459     bool ReadPlainChars(WW8_CP& rPos, sal_Int32 nEnd, sal_Int32 nCpOfs);
1460     bool ReadChars(WW8_CP& rPos, WW8_CP nNextAttr, tools::Long nTextEnd, tools::Long nCpOfs);
1461     static bool LangUsesHindiNumbers(LanguageType nLang);
1462     static sal_Unicode TranslateToHindiNumbers(sal_Unicode);
1463
1464     void SetDocumentGrid(SwFrameFormat &rFormat, const wwSection &rSection);
1465
1466     void ProcessCurrentCollChange(WW8PLCFManResult& rRes, bool* pStartAttr,
1467         bool bCallProcessSpecial);
1468     tools::Long ReadTextAttr(WW8_CP& rTextPos, tools::Long nTextEnd, bool& rbStartLine, int nDepthGuard = 0);
1469     void ReadAttrs(WW8_CP& rTextPos, WW8_CP& rNext, tools::Long nTextEnd, bool& rbStartLine);
1470     void CloseAttrEnds();
1471     bool ReadText(WW8_CP nStartCp, WW8_CP nTextLen, ManTypes nType);
1472
1473     void ReadRevMarkAuthorStrTabl( SvStream& rStrm, sal_Int32 nTablePos,
1474         sal_Int32 nTableSiz, SwDoc& rDoc );
1475
1476     void Read_HdFtFootnoteText(const SwNodeIndex* pSttIdx, WW8_CP nStartCp,
1477                                WW8_CP nLen, ManTypes nType);
1478
1479     void ImportTox( int nFieldId, const OUString& aStr );
1480
1481     void EndSprm( sal_uInt16 nId );
1482     // #i103711#
1483     // #i105414#
1484     void NewAttr( const SfxPoolItem& rAttr,
1485                   const bool bFirstLineOfStSet = false,
1486                   const bool bLeftIndentSet = false );
1487
1488     bool GetFontParams(sal_uInt16, FontFamily&, OUString&, FontPitch&,
1489         rtl_TextEncoding&);
1490     bool SetNewFontAttr(sal_uInt16 nFCode, bool bSetEnums, sal_uInt16 nWhich);
1491     void ResetCharSetVars();
1492     void ResetCJKCharSetVars();
1493
1494     const SfxPoolItem* GetFormatAttr( sal_uInt16 nWhich );
1495     bool JoinNode(SwPaM &rPam, bool bStealAttr = false);
1496
1497     static bool IsBorder(const WW8_BRCVer9* pbrc, bool bChkBtwn = false);
1498
1499     //Set closest writer border equivalent into rBox from pbrc, optionally
1500     //recording true winword dimensions in pSizeArray. nSetBorders to mark a
1501     //border which has been previously set to a value and for which becoming
1502     //empty is valid. Set bCheBtwn to work with paragraphs that have a special
1503     //between paragraphs border
1504
1505     // Note #i20672# we can't properly support between lines so best to ignore
1506     // them for now
1507     static bool SetBorder(SvxBoxItem& rBox, const WW8_BRCVer9* pbrc,
1508         short *pSizeArray=nullptr, sal_uInt8 nSetBorders=0xFF);
1509     static void GetBorderDistance(const WW8_BRCVer9* pbrc, tools::Rectangle& rInnerDist);
1510     static sal_uInt16 GetParagraphAutoSpace(bool fDontUseHTMLAutoSpacing);
1511     static bool SetShadow(SvxShadowItem& rShadow, const short *pSizeArray,
1512         const WW8_BRCVer9& aRightBrc);
1513     //returns true is a shadow was set
1514     static bool SetFlyBordersShadow(SfxItemSet& rFlySet, const WW8_BRCVer9 *pbrc,
1515         short *SizeArray);
1516     static void SetPageBorder(SwFrameFormat &rFormat, const wwSection &rSection);
1517
1518     static sal_Int32 MatchSdrBoxIntoFlyBoxItem( const Color& rLineColor,
1519         MSO_LineStyle eLineStyle, MSO_LineDashing eDashing, MSO_SPT eShapeType, sal_Int32 &rLineWidth,
1520         SvxBoxItem& rBox );
1521     void MatchSdrItemsIntoFlySet( SdrObject const *    pSdrObj, SfxItemSet &aFlySet,
1522         MSO_LineStyle eLineStyle, MSO_LineDashing eDashing, MSO_SPT eShapeType, tools::Rectangle &rInnerDist );
1523     static void AdjustLRWrapForWordMargins(const SvxMSDffImportRec &rRecord,
1524         SvxLRSpaceItem &rLR);
1525     static void AdjustULWrapForWordMargins(const SvxMSDffImportRec &rRecord,
1526         SvxULSpaceItem &rUL);
1527     static void MapWrapIntoFlyFormat(const SvxMSDffImportRec& rRecord, SwFrameFormat& rFlyFormat);
1528
1529     void SetAttributesAtGrfNode(const SvxMSDffImportRec& rRecord, const SwFrameFormat& rFlyFormat,
1530                                 WW8_FSPA const* pF);
1531
1532     bool IsDropCap() const;
1533     bool IsListOrDropcap() const { return (!m_xCurrentItemSet  || m_bDropCap); };
1534
1535     //Apo == Absolutely Positioned Object, MSWord's old-style frames
1536     std::unique_ptr<WW8FlyPara> ConstructApo(const ApoTestResults &rApo,
1537         const WW8_TablePos *pTabPos);
1538     bool StartApo(const ApoTestResults &rApo, const WW8_TablePos *pTabPos);
1539     void StopApo();
1540     bool TestSameApo(const ApoTestResults &rApo, const WW8_TablePos *pTabPos);
1541     ApoTestResults TestApo(int nCellLevel, bool bTableRowEnd,
1542         const WW8_TablePos *pTabPos);
1543     static void StripNegativeAfterIndent(SwFrameFormat const *pFlyFormat);
1544
1545     void EndSpecial();
1546     bool ProcessSpecial(bool &rbReSync, WW8_CP nStartCp);
1547     sal_uInt16 TabRowSprm(int nLevel) const;
1548
1549     bool ReadGrafFile(OUString& rFileName, std::optional<Graphic>& rpGraphic,
1550        const WW8_PIC& rPic, SvStream* pSt, sal_uLong nFilePos, bool* pDelIt);
1551
1552     static void ReplaceObj(const SdrObject &rReplaceTextObj,
1553         SdrObject &rSubObj);
1554
1555     SwFlyFrameFormat* MakeGrafNotInContent(const WW8PicDesc& rPD,
1556         const Graphic* pGraph, const OUString& rFileName,
1557         const SfxItemSet& rGrfSet);
1558
1559     SwFrameFormat* MakeGrafInContent(const WW8_PIC& rPic, const WW8PicDesc& rPD,
1560         const Graphic* pGraph, const OUString& rFileName,
1561         const SfxItemSet& rGrfSet);
1562
1563     SwFrameFormat *AddAutoAnchor(SwFrameFormat *pFormat);
1564     SwFrameFormat* ImportGraf1(WW8_PIC const & rPic, SvStream* pSt, sal_uLong nFilePos);
1565     SwFrameFormat* ImportGraf(SdrTextObj const * pTextObj = nullptr, SwFrameFormat const * pFlyFormat = nullptr);
1566
1567     rtl::Reference<SdrObject> ImportOleBase( Graphic& rGraph, const Graphic* pGrf=nullptr,
1568         const SfxItemSet* pFlySet=nullptr, const tools::Rectangle& aVisArea = tools::Rectangle() );
1569
1570     SwFrameFormat* ImportOle( const Graphic* = nullptr, const SfxItemSet* pFlySet = nullptr,
1571         const SfxItemSet* pGrfSet = nullptr, const tools::Rectangle& aVisArea = tools::Rectangle() );
1572     SwFlyFrameFormat* InsertOle(SdrOle2Obj &rObject, const SfxItemSet &rFlySet,
1573         const SfxItemSet *rGrfSet);
1574
1575     bool ImportFormulaControl(WW8FormulaControl &rBox,WW8_CP nStart,
1576         SwWw8ControlType nWhich);
1577
1578     void ImportDop();
1579
1580     //This converts MS Asian Typography information into OOo's
1581     void ImportDopTypography(const WW8DopTypography &rTypo);
1582
1583     ErrCode LoadThroughDecryption(WW8Glossary *pGloss);
1584     ErrCode SetSubStreams(tools::SvRef<SotStorageStream> &rTableStream, tools::SvRef<SotStorageStream> &rDataStream);
1585     ErrCode CoreLoad(WW8Glossary const *pGloss);
1586
1587     void ReadDocVars();
1588
1589     bool StartTable(WW8_CP nStartCp);
1590     bool InEqualApo(int nLvl) const;
1591     bool InLocalApo() const { return InEqualApo(m_nInTable); }
1592     bool InEqualOrHigherApo(int nLvl) const;
1593     void TabCellEnd();
1594     void StopTable();
1595     bool IsInvalidOrToBeMergedTabCell() const;
1596
1597 // Enumerations / lists ( Autonumbered List Data Descriptor )
1598 // list:        ANLD ( Autonumbered List Data Descriptor )
1599 //   one level: ANLV ( Autonumber Level Descriptor )
1600
1601 // Chg7-8:
1602 // lists are separate structures in WW8 that are handled via the following three tables:
1603 // rglst, hpllfo and hsttbListNames
1604 // the corresponding structures are: LSTF, LVLF, LFO LFOLVL
1605
1606     void SetAnlvStrings(SwNumFormat &rNum, int nLevel, WW8_ANLV const &rAV, const sal_uInt8* pText,
1607         size_t nStart, size_t nElements, bool bOutline);
1608     void SetAnld(SwNumRule* pNumR, WW8_ANLD const * pAD, sal_uInt8 nSwLevel, bool bOutLine);
1609     void SetNumOlst( SwNumRule* pNumR, WW8_OLST* pO, sal_uInt8 nSwLevel );
1610     SwNumRule* GetStyRule();
1611
1612     void StartAnl(const sal_uInt8* pSprm13);
1613     void NextAnlLine(const sal_uInt8* pSprm13);
1614     void StopAllAnl(bool bGoBack = true);
1615     void StopAnlToRestart(sal_uInt8 nType, bool bGoBack = true);
1616
1617 // graphics layer
1618
1619     bool ReadGrafStart(void* pData, short nDataSiz, WW8_DPHEAD const * pHd,
1620         SfxAllItemSet &rSet);
1621     rtl::Reference<SdrObject> ReadLine(WW8_DPHEAD const * pHd, SfxAllItemSet &rSet);
1622     rtl::Reference<SdrObject> ReadRect(WW8_DPHEAD const * pHd, SfxAllItemSet &rSet);
1623     rtl::Reference<SdrObject> ReadEllipse(WW8_DPHEAD const * pHd, SfxAllItemSet &rSet);
1624     rtl::Reference<SdrObject> ReadArc(WW8_DPHEAD const * pHd, SfxAllItemSet &rSet);
1625     rtl::Reference<SdrObject> ReadPolyLine(WW8_DPHEAD const * pHd, SfxAllItemSet &rSet);
1626     void InsertTxbxStyAttrs( SfxItemSet& rS, sal_uInt16 nColl );
1627     void InsertAttrsAsDrawingAttrs(WW8_CP nStartCp, WW8_CP nEndCp, ManTypes eType, bool bONLYnPicLocFc=false);
1628
1629     bool GetTxbxTextSttEndCp(WW8_CP& rStartCp, WW8_CP& rEndCp, sal_uInt16 nTxBxS,
1630         sal_uInt16 nSequence);
1631     sal_Int32 GetRangeAsDrawingString(OUString& rString, tools::Long StartCp, tools::Long nEndCp, ManTypes eType);
1632     std::optional<OutlinerParaObject> ImportAsOutliner(OUString &rString, WW8_CP nStartCp, WW8_CP nEndCp, ManTypes eType);
1633     void InsertTxbxText(SdrTextObj* pTextObj, Size const * pObjSiz,
1634         sal_uInt16 nTxBxS, sal_uInt16 nSequence, tools::Long nPosCp, SwFrameFormat const * pFlyFormat,
1635         bool bMakeSdrGrafObj, bool& rbEraseTextObj,
1636         bool* pbTestTxbxContainsText = nullptr, tools::Long* pnStartCp = nullptr,
1637         tools::Long* pnEndCp = nullptr, bool* pbContainsGraphics = nullptr,
1638         SvxMSDffImportRec const * pRecord = nullptr);
1639     bool TxbxChainContainsRealText( sal_uInt16 nTxBxS,
1640                                     tools::Long&  rStartCp,
1641                                     tools::Long&  rEndCp );
1642     rtl::Reference<SdrObject> ReadTextBox(WW8_DPHEAD const * pHd, SfxAllItemSet &rSet);
1643     rtl::Reference<SdrObject> ReadCaptionBox(WW8_DPHEAD const * pHd, SfxAllItemSet &rSet);
1644     rtl::Reference<SdrObject> ReadGroup(WW8_DPHEAD const * pHd, SfxAllItemSet &rSet);
1645     rtl::Reference<SdrObject> ReadGrafPrimitive(short& rLeft, SfxAllItemSet &rSet);
1646     void ReadGrafLayer1(WW8PLCFspecial& rPF, tools::Long nGrafAnchorCp);
1647     SdrObject* CreateContactObject(SwFrameFormat* pFlyFormat);
1648     RndStdIds ProcessEscherAlign(SvxMSDffImportRec& rRecord, WW8_FSPA& rFSPA, SfxItemSet& rFlySet);
1649     bool MiserableRTLGraphicsHack(SwTwips &rLeft, SwTwips nWidth,
1650         sal_Int16 eHoriOri, sal_Int16 eHoriRel);
1651     SwFrameFormat* Read_GrafLayer( tools::Long nGrafAnchorCp );
1652     SwFlyFrameFormat* ImportReplaceableDrawables(rtl::Reference<SdrObject>& rpObject, rtl::Reference<SdrObject>& rpOurNewObject,
1653                                                  SvxMSDffImportRec& rRecord, WW8_FSPA& rF,
1654                                                  SfxItemSet& rFlySet);
1655     SwFlyFrameFormat* ConvertDrawTextToFly(rtl::Reference<SdrObject>& rpObject, rtl::Reference<SdrObject>& rpOurNewObject,
1656                                            const SvxMSDffImportRec& rRecord, RndStdIds eAnchor,
1657                                            const WW8_FSPA& rF, SfxItemSet& rFlySet);
1658     SwFrameFormat* MungeTextIntoDrawBox(SvxMSDffImportRec& rRecord, tools::Long nGrafAnchorCp,
1659                                         SwFrameFormat* pRetFrameFormat);
1660
1661     void GraphicCtor();
1662     void GraphicDtor();
1663
1664 // other stuff
1665     OUString GetFieldResult( WW8FieldDesc const * pF );
1666     void MakeTagString( OUString& rStr, const OUString& rOrg );
1667     void UpdateFields();
1668     OUString ConvertFFileName(const OUString& rRaw);
1669     WW8_CP Read_F_Tag(WW8FieldDesc* pF);
1670     void InsertTagField( const sal_uInt16 nId, const OUString& rTagText );
1671     tools::Long ImportExtSprm(WW8PLCFManResult* pRes);
1672     void EndExtSprm(sal_uInt16 nSprmId);
1673     void ReadDocInfo();
1674
1675 // Ver8 lists
1676
1677     void RegisterNumFormatOnTextNode(sal_uInt16 nCurrentLFO, sal_uInt8 nCurrentLevel,
1678                                  const bool bSetAttr = true);
1679
1680     void RegisterNumFormatOnStyle(sal_uInt16 nStyle);
1681     void SetStylesList(sal_uInt16 nStyle, sal_uInt16 nCurrentLFO,
1682         sal_uInt8 nCurrentLevel);
1683     void RegisterNumFormat(sal_uInt16 nCurrentLFO, sal_uInt8 nCurrentLevel);
1684
1685 // to be replaced by calls in the appropriate extended SvxMSDffManager
1686
1687     const OUString* GetAnnotationAuthor(sal_uInt16 nIdx);
1688
1689     void GetSmartTagInfo(SwFltRDFMark& rMark);
1690
1691     // interfaces for the toggle attributes
1692     void SetToggleAttr(sal_uInt8 nAttrId, bool bOn);
1693     void SetToggleBiDiAttr(sal_uInt8 nAttrId, bool bOn);
1694     void ChkToggleAttr_( sal_uInt16 nOldStyle81Mask, sal_uInt16 nNewStyle81Mask );
1695
1696     void ChkToggleAttr( sal_uInt16 nOldStyle81Mask, sal_uInt16 nNewStyle81Mask )
1697     {
1698         if( nOldStyle81Mask != nNewStyle81Mask &&
1699             m_xCtrlStck->GetToggleAttrFlags() )
1700             ChkToggleAttr_( nOldStyle81Mask, nNewStyle81Mask );
1701     }
1702
1703     void ChkToggleBiDiAttr_( sal_uInt16 nOldStyle81Mask, sal_uInt16 nNewStyle81Mask );
1704
1705     void ChkToggleBiDiAttr( sal_uInt16 nOldStyle81Mask, sal_uInt16 nNewStyle81Mask )
1706     {
1707         if( nOldStyle81Mask != nNewStyle81Mask &&
1708             m_xCtrlStck->GetToggleBiDiAttrFlags() )
1709             ChkToggleBiDiAttr_( nOldStyle81Mask, nNewStyle81Mask );
1710     }
1711
1712     void PopTableDesc();
1713     void MoveInsideFly(const SwFrameFormat *pFlyFormat);
1714     SwTwips MoveOutsideFly(SwFrameFormat *pFlyFormat, const SwPosition &rPos,
1715         bool bTableJoin = true);
1716
1717     void SetOutlineStyles();
1718
1719     bool SetSpacing(SwPaM &rMyPam, int nSpace, bool bIsUpper);
1720     bool SetUpperSpacing(SwPaM &pMyPam, int nSpace);
1721     bool SetLowerSpacing(SwPaM &rMyPam, int nSpace);
1722
1723     bool IsInlineEscherHack() const
1724         { return !m_aFieldStack.empty() && m_aFieldStack.back().mnFieldId == 95; };
1725
1726     void StoreMacroCmds();
1727
1728     // #i84783#
1729     // determine object attribute "Layout in Table Cell"
1730     bool IsObjectLayoutInTableCell(const sal_uInt32 nGroupShapeBooleanProperties) const;
1731     void ReadGlobalTemplateSettings( std::u16string_view sCreatedFrom, const css::uno::Reference< css::container::XNameContainer >& xPrjNameMap );
1732     SwWW8ImplReader(const SwWW8ImplReader &) = delete;
1733     SwWW8ImplReader& operator=(const SwWW8ImplReader&) = delete;
1734 public:     // really private, but can only be done public
1735     ~SwWW8ImplReader();
1736     sal_uInt16 GetToggleAttrFlags() const;
1737     sal_uInt16 GetToggleBiDiAttrFlags() const;
1738     void SetToggleAttrFlags(sal_uInt16 nFlags);
1739     void SetToggleBiDiAttrFlags(sal_uInt16 nFlags);
1740
1741     tools::Long Read_Footnote(WW8PLCFManResult* pRes);
1742     sal_uInt16 End_Footnote();
1743     tools::Long Read_Field(WW8PLCFManResult* pRes);
1744     sal_uInt16 End_Field();
1745     tools::Long Read_Book(WW8PLCFManResult*);
1746     tools::Long Read_And(WW8PLCFManResult* pRes);
1747     tools::Long Read_AtnBook(WW8PLCFManResult*);
1748     tools::Long Read_FactoidBook(WW8PLCFManResult*);
1749
1750     // attributes
1751
1752     void Read_Special(sal_uInt16, const sal_uInt8*, short nLen);
1753     void Read_Obj(sal_uInt16, const sal_uInt8*, short nLen);
1754     void Read_PicLoc(sal_uInt16, const sal_uInt8* pData, short nLen );
1755     void Read_BoldUsw(sal_uInt16 nId, const sal_uInt8*, short nLen);
1756     void Read_Bidi(sal_uInt16 nId, const sal_uInt8*, short nLen);
1757     void Read_BoldBiDiUsw(sal_uInt16 nId, const sal_uInt8*, short nLen);
1758     void Read_AmbiguousSPRM(sal_uInt16 nId, const sal_uInt8*, short nLen);
1759     void Read_SubSuper(         sal_uInt16, const sal_uInt8*, short nLen );
1760     bool ConvertSubToGraphicPlacement();
1761     static SwFrameFormat *ContainsSingleInlineGraphic(const SwPaM &rRegion);
1762     void Read_SubSuperProp(     sal_uInt16, const sal_uInt8*, short nLen );
1763     void Read_Underline(        sal_uInt16, const sal_uInt8*, short nLen );
1764     void Read_TextColor(         sal_uInt16, const sal_uInt8*, short nLen );
1765     void openFont(sal_uInt16 nFCode, sal_uInt16 nId);
1766     void closeFont(sal_uInt16 nId);
1767     void Read_FontCode(         sal_uInt16, const sal_uInt8*, short nLen );
1768     void Read_FontSize(         sal_uInt16, const sal_uInt8*, short nLen );
1769     void Read_CharSet(sal_uInt16 , const sal_uInt8* pData, short nLen);
1770     void Read_Language(         sal_uInt16, const sal_uInt8*, short nLen );
1771     void Read_CColl(            sal_uInt16, const sal_uInt8*, short nLen );
1772     void Read_Kern(             sal_uInt16, const sal_uInt8* pData, short nLen );
1773     void Read_FontKern(         sal_uInt16, const sal_uInt8* pData, short nLen );
1774     void Read_Emphasis(         sal_uInt16, const sal_uInt8* pData, short nLen );
1775     void Read_ScaleWidth(       sal_uInt16, const sal_uInt8* pData, short nLen );
1776     void Read_Relief(           sal_uInt16, const sal_uInt8* pData, short nLen);
1777     void Read_TextAnim(      sal_uInt16, const sal_uInt8* pData, short nLen);
1778
1779     void Read_NoLineNumb(       sal_uInt16 nId, const sal_uInt8* pData, short nLen );
1780
1781     void Read_LR(               sal_uInt16 nId, const sal_uInt8*, short nLen );
1782     void Read_UL(               sal_uInt16 nId, const sal_uInt8*, short nLen );
1783     void Read_ParaAutoBefore(sal_uInt16 , const sal_uInt8 *pData, short nLen);
1784     void Read_ParaAutoAfter(sal_uInt16 , const sal_uInt8 *pData, short nLen);
1785     void Read_ParaContextualSpacing( sal_uInt16 nId, const sal_uInt8* pData, short nLen );
1786     void Read_LineBreakClear(sal_uInt16 nId, const sal_uInt8* pData, short nLen);
1787     void Read_LineSpace(        sal_uInt16, const sal_uInt8*, short nLen );
1788
1789     void SetRelativeJustify( bool bRel );
1790     bool IsRelativeJustify();
1791     bool IsRelativeJustify(sal_uInt16 nColl, o3tl::sorted_vector<sal_uInt16>& rVisitedStyles);
1792     void Read_Justify(sal_uInt16, const sal_uInt8*, short nLen);
1793
1794     void Read_IdctHint(sal_uInt16, const sal_uInt8*, short nLen);
1795     bool IsRightToLeft();
1796     void Read_RTLJustify(sal_uInt16, const sal_uInt8*, short nLen);
1797     void Read_Hyphenation(      sal_uInt16, const sal_uInt8* pData, short nLen );
1798     void Read_WidowControl(     sal_uInt16, const sal_uInt8* pData, short nLen );
1799     void Read_AlignFont(        sal_uInt16, const sal_uInt8* pData, short nLen );
1800     void Read_UsePgsuSettings(  sal_uInt16, const sal_uInt8* pData, short nLen );
1801     void Read_KeepLines(        sal_uInt16, const sal_uInt8* pData, short nLen );
1802     void Read_KeepParas(        sal_uInt16, const sal_uInt8* pData, short nLen );
1803     void Read_BreakBefore(      sal_uInt16, const sal_uInt8* pData, short nLen );
1804     void Read_ApoPPC(sal_uInt16, const sal_uInt8* pData, short);
1805
1806     void Read_BoolItem(         sal_uInt16 nId, const sal_uInt8*, short nLen );
1807
1808     void Read_Border(           sal_uInt16 nId, const sal_uInt8* pData, short nLen );
1809     void Read_CharBorder(sal_uInt16 nId, const sal_uInt8* pData, short nLen );
1810     void Read_Tab(              sal_uInt16 nId, const sal_uInt8* pData, short nLen );
1811     void Read_Symbol(sal_uInt16, const sal_uInt8* pData, short nLen);
1812     void Read_FieldVanish(        sal_uInt16 nId, const sal_uInt8* pData, short nLen );
1813
1814     // Revision Marks ( == Redlining )
1815
1816     // insert or delete content (change char attributes resp.)
1817     void Read_CRevisionMark(RedlineType eType, const sal_uInt8* pData, short nLen);
1818     // insert new content
1819     void Read_CFRMark(sal_uInt16 , const sal_uInt8* pData, short nLen);
1820     // delete old content
1821     void Read_CFRMarkDel(sal_uInt16 , const sal_uInt8* pData, short nLen);
1822     // change properties of content (e.g. char formatting)
1823     void Read_CPropRMark(sal_uInt16 , const sal_uInt8* pData, short nLen); // complex!
1824
1825     void Read_TabRowEnd(        sal_uInt16, const sal_uInt8* pData, short nLen );
1826     void Read_TabCellEnd(        sal_uInt16, const sal_uInt8* pData, short nLen );
1827     static bool ParseTabPos(WW8_TablePos *aTabPos, WW8PLCFx_Cp_FKP* pPap);
1828     void Read_Shade(            sal_uInt16, const sal_uInt8* pData, short nLen );
1829     void Read_ANLevelNo(        sal_uInt16, const sal_uInt8* pData, short nLen );
1830     void Read_ANLevelDesc(      sal_uInt16, const sal_uInt8* pData, short nLen );
1831
1832     // outline level Ver8
1833     void Read_POutLvl(sal_uInt16, const sal_uInt8* pData, short nLen);
1834
1835     void Read_OLST(             sal_uInt16, const sal_uInt8* pData, short nLen );
1836
1837     void Read_CharShadow(       sal_uInt16, const sal_uInt8* pData, short nLen );
1838     void Read_CharHighlight(    sal_uInt16, const sal_uInt8* pData, short nLen );
1839                                         // Ver8-Listen
1840
1841     void Read_ListLevel(        sal_uInt16 nId, const sal_uInt8* pData, short nLen);
1842
1843     /**
1844      * read and interpret the sprmPIlfo used to determine which list
1845      * contains the paragraph.
1846      * @param     nId   unused (sprm value, 0x460b for sprmPIlfo).
1847      * @param[in] pData operand.
1848      * @param[in] nLen  size of the operand (pData) in byte, should be 2.
1849      *                  -1 to indicate the actual level is finished.
1850      */
1851     void Read_LFOPosition(      sal_uInt16 nId, const sal_uInt8* pData, short nLen);
1852     bool SetTextFormatCollAndListLevel(const SwPaM& rRg, SwWW8StyInf& rStyleInfo);
1853
1854     void Read_StyleCode(sal_uInt16, const sal_uInt8* pData, short nLen);
1855     void Read_Majority(sal_uInt16, const sal_uInt8* , short );
1856     void Read_DoubleLine_Rotate( sal_uInt16, const sal_uInt8* pDATA, short nLen);
1857
1858     void Read_TextForeColor(sal_uInt16, const sal_uInt8* pData, short nLen);
1859     void Read_TextBackColor(sal_uInt16, const sal_uInt8* pData, short nLen);
1860     void Read_ParaBackColor(sal_uInt16, const sal_uInt8* pData, short nLen);
1861     void Read_ParaBiDi(sal_uInt16, const sal_uInt8* pData, short nLen);
1862     static Color ExtractColour(const sal_uInt8* &rpData, bool bVer67);
1863
1864     void Read_TextVerticalAdjustment(sal_uInt16, const sal_uInt8* pData, short nLen);
1865     void Read_UnderlineColor(sal_uInt16, const sal_uInt8* pData, short nLen);
1866     tools::Long MapBookmarkVariables(const WW8FieldDesc* pF, OUString &rOrigName,
1867         const OUString &rData);
1868     OUString GetMappedBookmark(std::u16string_view rOrigName);
1869
1870     // fields
1871     eF_ResT Read_F_Input(WW8FieldDesc*, OUString& rStr);
1872     eF_ResT Read_F_InputVar(WW8FieldDesc*, OUString& rStr);
1873     eF_ResT Read_F_ANumber( WW8FieldDesc*, OUString& );
1874     eF_ResT Read_F_DocInfo( WW8FieldDesc* pF, OUString& rStr );
1875     eF_ResT Read_F_Author( WW8FieldDesc*, OUString& );
1876     eF_ResT Read_F_TemplName( WW8FieldDesc*, OUString& );
1877     SvNumFormatType GetTimeDatePara(std::u16string_view aStr, sal_uInt32& rFormat, LanguageType &rLang,
1878         int nWhichDefault, bool bHijri = false);
1879     bool ForceFieldLanguage(SwField &rField, LanguageType nLang);
1880     eF_ResT Read_F_DateTime( WW8FieldDesc*, OUString& rStr );
1881     eF_ResT Read_F_FileName( WW8FieldDesc*, OUString& rStr);
1882     eF_ResT Read_F_Num( WW8FieldDesc* pF, OUString& );
1883     eF_ResT Read_F_CurPage( WW8FieldDesc*, OUString& );
1884     eF_ResT Read_F_Ref( WW8FieldDesc* pF, OUString& );
1885
1886     eF_ResT Read_F_Set( WW8FieldDesc*, OUString& rStr );
1887     eF_ResT Read_F_PgRef( WW8FieldDesc*, OUString& rStr );
1888     eF_ResT Read_F_NoteReference( WW8FieldDesc* pF, OUString& rStr );
1889
1890     eF_ResT Read_F_Tox( WW8FieldDesc* pF, OUString& rStr );
1891     eF_ResT Read_F_Symbol( WW8FieldDesc*, OUString& rStr );
1892     eF_ResT Read_F_Embedd( WW8FieldDesc*, OUString& rStr );
1893     eF_ResT Read_F_FormTextBox( WW8FieldDesc* pF, OUString& rStr);
1894     eF_ResT Read_F_FormCheckBox( WW8FieldDesc* pF, OUString& rStr );
1895     eF_ResT Read_F_FormListBox( WW8FieldDesc* pF, OUString& rStr);
1896     css::awt::Size MiserableDropDownFormHack(const OUString &rString,
1897         css::uno::Reference<css::beans::XPropertySet> const & rPropSet);
1898
1899     eF_ResT Read_F_Macro( WW8FieldDesc*, OUString& rStr);
1900     eF_ResT Read_F_DBField( WW8FieldDesc*, OUString& rStr );
1901     eF_ResT Read_F_DBNext( WW8FieldDesc*, OUString& );
1902     eF_ResT Read_F_DBNum( WW8FieldDesc*, OUString& );
1903     eF_ResT Read_F_Equation( WW8FieldDesc*, OUString& );
1904     void Read_SubF_Ruby( msfilter::util::WW8ReadFieldParams& rReadParam);
1905     eF_ResT Read_F_IncludePicture( WW8FieldDesc*, OUString& rStr );
1906     eF_ResT Read_F_IncludeText(    WW8FieldDesc*, OUString& rStr );
1907     eF_ResT Read_F_Seq( WW8FieldDesc*, OUString& rStr );
1908     /// Reads a STYLEREF field.
1909     eF_ResT Read_F_Styleref(WW8FieldDesc*, OUString& rStr);
1910
1911     eF_ResT Read_F_OCX(WW8FieldDesc*, OUString&);
1912     eF_ResT Read_F_Hyperlink(WW8FieldDesc*, OUString& rStr);
1913     eF_ResT Read_F_Shape(WW8FieldDesc* pF, OUString& rStr);
1914     eF_ResT Read_F_HTMLControl( WW8FieldDesc* pF, OUString& rStr);
1915
1916     short ImportSprm(const sal_uInt8* pPos, sal_Int32 nMemLen, sal_uInt16 nId = 0);
1917
1918     bool SearchRowEnd(WW8PLCFx_Cp_FKP* pPap,WW8_CP &rStartCp, int nLevel) const;
1919     /// Seek to the end of the table with pPap, returns true on success.
1920     bool SearchTableEnd(WW8PLCFx_Cp_FKP* pPap) const;
1921
1922     const WW8Fib& GetFib() const    { return *m_xWwFib; }
1923     SwDoc& GetDoc() const           { return m_rDoc; }
1924     sal_uInt16 GetCurrentColl()  const     { return m_nCurrentColl; }
1925     void SetNCurrentColl( sal_uInt16 nColl ) { m_nCurrentColl = nColl;    }
1926     std::unique_ptr<SfxItemSet> SetCurrentItemSet(std::unique_ptr<SfxItemSet> pItemSet);
1927     sal_uInt16 StyleUsingLFO( sal_uInt16 nLFOIndex ) const ;
1928     const SwFormat* GetStyleWithOrgWWName( std::u16string_view rName ) const ;
1929
1930     static bool GetPictGrafFromStream(Graphic& rGraphic, SvStream& rSrc);
1931     SAL_WARN_UNUSED_RESULT static bool PicRead(SvStream *pDataStream, WW8_PIC *pPic, bool bVer67);
1932     static bool ImportOleWMF(const tools::SvRef<SotStorage>& xSrc1, GDIMetaFile& rWMF, tools::Long& rX,
1933                              tools::Long& rY);
1934     static Color GetCol(sal_uInt8 nIco);
1935
1936     SwWW8ImplReader( sal_uInt8 nVersionPara, SotStorage* pStorage, SvStream* pSt,
1937         SwDoc& rD, OUString aBaseURL, bool bNewDoc, bool bSkipImages, SwPosition const &rPos );
1938
1939     const OUString& GetBaseURL() const { return m_sBaseURL; }
1940     // load a complete doc file
1941     ErrCode LoadDoc(WW8Glossary *pGloss=nullptr);
1942     rtl_TextEncoding GetCurrentCharSet();
1943     rtl_TextEncoding GetCurrentCJKCharSet();
1944     rtl_TextEncoding GetCharSetFromLanguage();
1945     rtl_TextEncoding GetCJKCharSetFromLanguage();
1946
1947     void PostProcessAttrs();
1948     void ReadEmbeddedData(SvStream& rStrm, SwDocShell const * pDocShell, struct HyperLinksTable& hlStr);
1949     void NotifyMacroEventRead();
1950 };
1951
1952 bool CanUseRemoteLink(const OUString &rGrfName);
1953 void UseListIndent(SwWW8StyInf &rStyle, const SwNumFormat &rFormat);
1954 void SetStyleIndent(SwWW8StyInf &rStyleInfo, const SwNumFormat &rFormat);
1955 // #i103711#
1956 // #i105414#
1957 void SyncIndentWithList( SvxFirstLineIndentItem & rFirstLine,
1958                          SvxTextLeftMarginItem & rLeftMargin,
1959                          const SwNumFormat &rFormat,
1960                          const bool bFirstLineOfStSet,
1961                          const bool bLeftIndentSet );
1962 tools::Long GetListFirstLineIndent(const SwNumFormat &rFormat);
1963 OUString BookmarkToWriter(std::u16string_view rBookmark);
1964 bool RTLGraphicsHack(SwTwips &rLeft, SwTwips nWidth,
1965     sal_Int16 eHoriOri, sal_Int16 eHoriRel, SwTwips nPageLeft,
1966     SwTwips nPageRight, SwTwips nPageSize);
1967 void MatchEscherMirrorIntoFlySet(const SvxMSDffImportRec &rRecord,
1968     SfxItemSet &rFlySet);
1969 #endif
1970
1971 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */