sw/source/filter/html/swhtml.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 #ifndef INCLUDED_SW_SOURCE_FILTER_HTML_SWHTML_HXX
  20 #define INCLUDED_SW_SOURCE_FILTER_HTML_SWHTML_HXX
  21
  22 #include <config_java.h>
  23
  24 #include <sfx2/sfxhtml.hxx>
  25 #include <svl/listener.hxx>
  26 #include <svl/macitem.hxx>
  27 #include <svtools/htmltokn.h>
  28 #include <editeng/svxenum.hxx>
  29 #include <rtl/ref.hxx>
  30 #include <rtl/ustrbuf.hxx>
  31 #include <deletelistener.hxx>
  32 #include <fmtftn.hxx>
  33 #include <fltshell.hxx>
  34 #include <swtypes.hxx>
  35 #include <txtftn.hxx>
  36 #include <com/sun/star/drawing/XShape.hpp>
  37 #include <com/sun/star/form/XFormComponent.hpp>
  38 #include <com/sun/star/beans/XPropertySet.hpp>
  39
  40 #include <memory>
  41 #include <utility>
  42 #include <vector>
  43 #include <deque>
  44 #include <stack>
  45 #include <set>
  46
  47 class SfxMedium;
  48 class SfxViewFrame;
  49 class SdrObject;
  50 class SvxMacroTableDtor;
  51 class SwDoc;
  52 class SwPaM;
  53 class SwViewShell;
  54 class SwStartNode;
  55 class SwFormatColl;
  56 class SwField;
  57 class SwHTMLForm_Impl;
  58 class SwApplet_Impl;
  59 struct SwHTMLFootEndNote_Impl;
  60 class HTMLTableCnts;
  61 struct SwPending;
  62 class SvxCSS1PropertyInfo;
  63 struct ImplSVEvent;
  64
  65 constexpr tools::Long HTML_CJK_PARSPACE = o3tl::toTwips(25, o3tl::Length::mm10); // 2.5mm
  66 constexpr tools::Long HTML_CTL_PARSPACE = o3tl::toTwips(25, o3tl::Length::mm10); // 2.5mm
  67
  68 constexpr tools::Long HTML_DFLT_IMG_WIDTH = o3tl::toTwips(2, o3tl::Length::cm); // 2cm
  69 constexpr tools::Long HTML_DFLT_IMG_HEIGHT = o3tl::toTwips(1, o3tl::Length::cm); // 1cm
  70
  71 // some things you often need
  72 extern HTMLOptionEnum<SvxAdjust> const aHTMLPAlignTable[];
  73 extern HTMLOptionEnum<sal_Int16> const aHTMLImgHAlignTable[];
  74 extern HTMLOptionEnum<sal_Int16> const aHTMLImgVAlignTable[];
  75
  76 // attribute stack:
  77
  78 class HTMLAttr;
  79 typedef std::deque<HTMLAttr *> HTMLAttrs;
  80
  81 // Table of attributes: The order here is important: The attributes in the
  82 // beginning of the table will set first in EndAllAttrs.
  83 struct HTMLAttrTable
  84 {
  85     HTMLAttr* pKeep; // frame attributes
  86     HTMLAttr* pBox;
  87     HTMLAttr* pBrush;
  88     HTMLAttr* pBreak;
  89     HTMLAttr* pPageDesc;
  90
  91     HTMLAttr* pFirstLineIndent; // paragraph attributes
  92     HTMLAttr* pTextLeftMargin;
  93     HTMLAttr* pRightMargin;
  94     HTMLAttr* pULSpace;
  95     HTMLAttr* pLineSpacing;
  96     HTMLAttr* pAdjust;
  97     HTMLAttr* pDropCap;
  98     HTMLAttr* pSplit;
  99     HTMLAttr* pWidows;
 100     HTMLAttr* pOrphans;
 101     HTMLAttr* pDirection;
 102
 103     HTMLAttr* pCharFormats; // text attributes
 104     HTMLAttr* pINetFormat;
 105
 106     HTMLAttr* pBold; // character attributes
 107     HTMLAttr* pBoldCJK;
 108     HTMLAttr* pBoldCTL;
 109     HTMLAttr* pItalic;
 110     HTMLAttr* pItalicCJK;
 111     HTMLAttr* pItalicCTL;
 112     HTMLAttr* pStrike;
 113     HTMLAttr* pUnderline;
 114     HTMLAttr* pBlink;
 115     HTMLAttr* pFont;
 116     HTMLAttr* pFontCJK;
 117     HTMLAttr* pFontCTL;
 118     HTMLAttr* pFontHeight;
 119     HTMLAttr* pFontHeightCJK;
 120     HTMLAttr* pFontHeightCTL;
 121     HTMLAttr* pFontColor;
 122     HTMLAttr* pEscapement;
 123     HTMLAttr* pCaseMap;
 124     HTMLAttr* pKerning; // (only for SPACER)
 125     HTMLAttr* pCharBrush; // character background
 126     HTMLAttr* pLanguage;
 127     HTMLAttr* pLanguageCJK;
 128     HTMLAttr* pLanguageCTL;
 129     HTMLAttr* pCharBox;
 130 };
 131
 132 class HTMLAttr
 133 {
 134     friend class SwHTMLParser;
 135     friend class CellSaveStruct;
 136
 137     SwNodeIndex m_nStartPara;
 138     SwNodeIndex m_nEndPara;
 139     sal_Int32 m_nStartContent;
 140     sal_Int32 m_nEndContent;
 141     bool m_bInsAtStart : 1;
 142     bool m_bLikePara : 1; // set attribute above the whole paragraph
 143     bool m_bValid : 1;    // is the attribute valid?
 144
 145     std::unique_ptr<SfxPoolItem> m_pItem;
 146     std::shared_ptr<HTMLAttrTable> m_xAttrTab;
 147     HTMLAttr *m_pNext;   // still to close attributes with different values
 148     HTMLAttr *m_pPrev;   // already closed but not set attributes
 149     HTMLAttr **m_ppHead; // list head
 150
 151     HTMLAttr( const SwPosition& rPos, const SfxPoolItem& rItem,
 152                HTMLAttr **pHd, std::shared_ptr<HTMLAttrTable> xAttrTab );
 153
 154     HTMLAttr( const HTMLAttr &rAttr, const SwNode &rEndPara,
 155                sal_Int32 nEndCnt, HTMLAttr **pHd, std::shared_ptr<HTMLAttrTable> xAttrTab );
 156
 157 public:
 158
 159     ~HTMLAttr();
 160
 161     HTMLAttr *Clone( const SwNode& rEndPara, sal_Int32 nEndCnt ) const;
 162     void Reset( const SwNode& rSttPara, sal_Int32 nSttCnt,
 163                 HTMLAttr **pHd, const std::shared_ptr<HTMLAttrTable>& rAttrTab );
 164     inline void SetStart( const SwPosition& rPos );
 165
 166     SwNodeOffset GetStartParagraphIdx() const { return m_nStartPara.GetIndex(); }
 167     SwNodeOffset GetEndParagraphIdx() const { return m_nEndPara.GetIndex(); }
 168
 169     const SwNodeIndex& GetStartParagraph() const { return m_nStartPara; }
 170     const SwNodeIndex& GetEndParagraph() const { return m_nEndPara; }
 171
 172     sal_Int32 GetStartContent() const { return m_nStartContent; }
 173     sal_Int32 GetEndContent() const { return m_nEndContent; }
 174
 175     bool IsLikePara() const { return m_bLikePara; }
 176     void SetLikePara() { m_bLikePara = true; }
 177
 178           SfxPoolItem& GetItem()        { return *m_pItem; }
 179     const SfxPoolItem& GetItem() const  { return *m_pItem; }
 180
 181     HTMLAttr *GetNext() const { return m_pNext; }
 182     void InsertNext( HTMLAttr *pNxt ) { m_pNext = pNxt; }
 183
 184     HTMLAttr *GetPrev() const { return m_pPrev; }
 185     void InsertPrev( HTMLAttr *pPrv );
 186     void ClearPrev() { m_pPrev = nullptr; }
 187
 188     void SetHead(HTMLAttr **ppHd, const std::shared_ptr<HTMLAttrTable>& rAttrTab)
 189     {
 190         m_ppHead = ppHd;
 191         m_xAttrTab = rAttrTab;
 192     }
 193
 194     // During setting attributes from styles it can happen that these
 195     // shouldn't be set anymore. To delete them would be very expensive, because
 196     // you don't know all the places where they are linked in. Therefore they're
 197     // made invalid and deleted at the next call of SetAttr_().
 198     void Invalidate() { m_bValid = false; }
 199 };
 200
 201 class HTMLAttrContext_SaveDoc;
 202
 203 enum SwHTMLAppendMode {
 204      AM_NORMAL,         // no paragraph spacing handling
 205      AM_NOSPACE,        // set spacing hard to 0cm
 206      AM_SPACE,          // set spacing hard to 0.5cm
 207      AM_SOFTNOSPACE,    // don't set spacing, but save 0cm
 208      AM_NONE            // no append
 209 };
 210
 211 class HTMLAttrContext
 212 {
 213     HTMLAttrs m_aAttrs;      // the attributes created in the context
 214
 215     OUString    m_aClass;          // context class
 216
 217     std::unique_ptr<HTMLAttrContext_SaveDoc> m_pSaveDocContext;
 218     std::unique_ptr<SfxItemSet> m_pFrameItemSet;
 219
 220     HtmlTokenId m_nToken;  // the token of the context
 221
 222     sal_uInt16  m_nTextFormatColl; // a style created in the context or zero
 223
 224     sal_uInt16  m_nLeftMargin;        // a changed left border
 225     sal_uInt16  m_nRightMargin;       // a changed right border
 226     sal_uInt16  m_nFirstLineIndent;   // a changed first line indent
 227
 228     sal_uInt16  m_nUpperSpace;
 229     sal_uInt16  m_nLowerSpace;
 230
 231     SwHTMLAppendMode m_eAppend;
 232
 233     bool    m_bLRSpaceChanged : 1;    // left/right border, changed indent?
 234     bool    m_bULSpaceChanged : 1;    // top/bottom border changed?
 235     bool    m_bDefaultTextFormatColl : 1;// nTextFormatColl is only default
 236     bool    m_bSpansSection : 1;      // the context opens a SwSection
 237     bool    m_bPopStack : 1;          // delete above stack elements
 238     bool    m_bFinishPREListingXMP : 1;
 239     bool    m_bRestartPRE : 1;
 240     bool    m_bRestartXMP : 1;
 241     bool    m_bRestartListing : 1;
 242     bool    m_bHeaderOrFooter : 1;
 243
 244     bool m_bVisible = true;
 245
 246 public:
 247     void ClearSaveDocContext();
 248
 249     HTMLAttrContext( HtmlTokenId nTokn, sal_uInt16 nPoolId, OUString aClass,
 250                       bool bDfltColl=false );
 251     explicit HTMLAttrContext( HtmlTokenId nTokn );
 252     ~HTMLAttrContext();
 253
 254     HtmlTokenId GetToken() const { return m_nToken; }
 255
 256     sal_uInt16 GetTextFormatColl() const { return m_bDefaultTextFormatColl ? 0 : m_nTextFormatColl; }
 257     sal_uInt16 GetDefaultTextFormatColl() const { return m_bDefaultTextFormatColl ? m_nTextFormatColl : 0; }
 258
 259     const OUString& GetClass() const { return m_aClass; }
 260
 261     inline void SetMargins( sal_uInt16 nLeft, sal_uInt16 nRight, short nIndent );
 262
 263     bool IsLRSpaceChanged() const { return m_bLRSpaceChanged; }
 264     inline void GetMargins( sal_uInt16& nLeft, sal_uInt16& nRight,
 265                             short &nIndent ) const;
 266
 267     inline void SetULSpace( sal_uInt16 nUpper, sal_uInt16 nLower );
 268     bool IsULSpaceChanged() const { return m_bULSpaceChanged; }
 269     inline void GetULSpace( sal_uInt16& rUpper, sal_uInt16& rLower ) const;
 270
 271     bool HasAttrs() const { return !m_aAttrs.empty(); }
 272     const HTMLAttrs& GetAttrs() const { return m_aAttrs; }
 273     HTMLAttrs& GetAttrs() { return m_aAttrs; }
 274
 275     void SetSpansSection( bool bSet ) { m_bSpansSection = bSet; }
 276     bool GetSpansSection() const { return m_bSpansSection; }
 277
 278     void SetPopStack( bool bSet ) { m_bPopStack = bSet; }
 279     bool GetPopStack() const { return m_bPopStack; }
 280
 281     bool HasSaveDocContext() const { return m_pSaveDocContext!=nullptr; }
 282     HTMLAttrContext_SaveDoc *GetSaveDocContext( bool bCreate=false );
 283
 284     const SfxItemSet *GetFrameItemSet() const { return m_pFrameItemSet.get(); }
 285     SfxItemSet *GetFrameItemSet( SwDoc *pCreateDoc );
 286
 287     void SetFinishPREListingXMP( bool bSet ) { m_bFinishPREListingXMP = bSet; }
 288     bool IsFinishPREListingXMP() const { return m_bFinishPREListingXMP; }
 289
 290     void SetRestartPRE( bool bSet ) { m_bRestartPRE = bSet; }
 291     bool IsRestartPRE() const { return m_bRestartPRE; }
 292
 293     void SetRestartXMP( bool bSet ) { m_bRestartXMP = bSet; }
 294     bool IsRestartXMP() const { return m_bRestartXMP; }
 295
 296     void SetRestartListing( bool bSet ) { m_bRestartListing = bSet; }
 297     bool IsRestartListing() const { return m_bRestartListing; }
 298
 299     void SetHeaderOrFooter( bool bSet ) { m_bHeaderOrFooter = bSet; }
 300     bool IsHeaderOrFooter() const { return m_bHeaderOrFooter; }
 301
 302     void SetAppendMode( SwHTMLAppendMode eMode ) { m_eAppend = eMode; }
 303     SwHTMLAppendMode GetAppendMode() const { return m_eAppend; }
 304
 305     void SetVisible(bool bVisible) { m_bVisible = bVisible; }
 306     bool IsVisible() const { return m_bVisible; }
 307 };
 308
 309 typedef std::vector<std::unique_ptr<HTMLAttrContext>> HTMLAttrContexts;
 310
 311 class HTMLTable;
 312 class SwCSS1Parser;
 313 class SwHTMLNumRuleInfo;
 314
 315 typedef std::vector<std::unique_ptr<ImageMap>> ImageMaps;
 316
 317 enum class HtmlContextFlags {
 318     ProtectStack    = 0x0001,
 319     StripPara       = 0x0002,
 320     KeepNumrule     = 0x0004,
 321     HeaderDist      = 0x0008,
 322     FooterDist      = 0x0010,
 323     KeepAttrs       = 0x0020,
 324     MultiColMask    = StripPara | KeepNumrule | KeepAttrs // for headers, footers or footnotes
 325 };
 326 namespace o3tl
 327 {
 328     template<> struct typed_flags<HtmlContextFlags> : is_typed_flags<HtmlContextFlags, 0x03f> {};
 329 }
 330
 331 enum class HtmlFrameFormatFlags {
 332     Box                 = 0x0001,
 333     Background          = 0x0002,
 334     Padding             = 0x0004,
 335     Direction           = 0x0008,
 336 };
 337 namespace o3tl
 338 {
 339     template<> struct typed_flags<HtmlFrameFormatFlags> : is_typed_flags<HtmlFrameFormatFlags, 0x0f> {};
 340 }
 341
 342 class SwHTMLFrameFormatListener : public SvtListener
 343 {
 344     SwFrameFormat* m_pFrameFormat;
 345 public:
 346     SwHTMLFrameFormatListener(SwFrameFormat* pFrameFormat);
 347     SwFrameFormat* GetFrameFormat() { return m_pFrameFormat; }
 348     virtual void Notify(const SfxHint&) override;
 349 };
 350
 351 class SwHTMLParser : public SfxHTMLParser, public SvtListener
 352 {
 353     friend class SectionSaveStruct;
 354     friend class CellSaveStruct;
 355     friend class CaptionSaveStruct;
 356
 357     /*
 358      Progress bar
 359      */
 360     std::unique_ptr<ImportProgress> m_xProgress;
 361
 362     OUString      m_aPathToFile;
 363     OUString      m_sBaseURL;
 364     OUString      m_aBasicLib;
 365     OUString      m_aBasicModule;
 366     OUString      m_aScriptSource;  // content of the current script block
 367     OUString      m_aScriptType;    // type of read script (StarBasic/VB/JAVA)
 368     OUString      m_aScriptURL;     // script URL
 369     OUString      m_aStyleSource;   // content of current style sheet
 370     OUString      m_aContents;      // text of current marquee, field and so
 371     OUStringBuffer m_sTitle;
 372     OUString      m_aUnknownToken;  // a started unknown token
 373     OUString      m_aBulletGrfs[MAXLEVEL];
 374     OUString      m_sJmpMark;
 375
 376     std::vector<sal_uInt16>   m_aBaseFontStack; // stack for <BASEFONT>
 377                                 // Bit 0-2: font size (1-7)
 378     std::vector<sal_uInt16>   m_aFontStack;     // stack for <FONT>, <BIG>, <SMALL>
 379                                 // Bit 0-2: font size (1-7)
 380                                 // Bit 15:  font colour was set
 381
 382     HTMLAttrs      m_aSetAttrTab;// "closed", not set attributes
 383     HTMLAttrs      m_aParaAttrs; // temporary paragraph attributes
 384     std::shared_ptr<HTMLAttrTable>  m_xAttrTab;   // "open" attributes
 385     HTMLAttrContexts m_aContexts;// the current context of attribute/token
 386     std::vector<std::unique_ptr<SwHTMLFrameFormatListener>> m_aMoveFlyFrames;// Fly-Frames, the anchor is moved
 387     std::deque<sal_Int32> m_aMoveFlyCnts;// and the Content-Positions
 388     //stray SwTableBoxes which need to be deleted to avoid leaking, but hold
 389     //onto them until parsing is done
 390     std::vector<std::unique_ptr<SwTableBox>> m_aOrphanedTableBoxes;
 391
 392     std::unique_ptr<SwApplet_Impl> m_pAppletImpl; // current applet
 393
 394     std::unique_ptr<SwCSS1Parser> m_pCSS1Parser;   // Style-Sheet-Parser
 395     std::unique_ptr<SwHTMLNumRuleInfo> m_pNumRuleInfo;
 396     std::vector<SwPending>  m_vPendingStack;
 397
 398     rtl::Reference<SwDoc> m_xDoc;
 399     SwPaM           *m_pPam;      // SwPosition should be enough, or ??
 400     SwViewShell       *m_pActionViewShell;  // SwViewShell, where StartAction was called
 401     SwNodeIndex     *m_pSttNdIdx;
 402
 403     std::vector<HTMLTable*> m_aTables;
 404     std::shared_ptr<HTMLTable> m_xTable; // current "outermost" table
 405     SwHTMLForm_Impl* m_pFormImpl;   // current form
 406     rtl::Reference<SdrTextObj> m_pMarquee;    // current marquee
 407     std::unique_ptr<SwField> m_xField; // current field
 408     ImageMap        *m_pImageMap;   // current image map
 409     std::unique_ptr<ImageMaps> m_pImageMaps;  ///< all Image-Maps that have been read
 410     std::unique_ptr<SwHTMLFootEndNote_Impl> m_pFootEndNoteImpl;
 411
 412     Size    m_aHTMLPageSize;      // page size of HTML template
 413
 414     sal_uInt32  m_aFontHeights[7];    // font heights 1-7
 415     ImplSVEvent * m_nEventId;
 416
 417     sal_uInt16  m_nBaseFontStMin;
 418     sal_uInt16  m_nFontStMin;
 419     sal_uInt16  m_nDefListDeep;
 420     sal_uInt16  m_nFontStHeadStart;   // elements in font stack at <Hn>
 421     sal_uInt16  m_nSBModuleCnt;       // counter for basic modules
 422     sal_uInt16  m_nMissingImgMaps;    // How many image maps are still missing?
 423     size_t m_nParaCnt;
 424     size_t m_nContextStMin;           // lower limit of PopContext
 425     size_t m_nContextStAttrMin;       // lower limit of attributes
 426     sal_uInt16  m_nSelectEntryCnt;    // Number of entries in the actual listbox
 427     HtmlTokenId m_nOpenParaToken;     // opened paragraph element
 428
 429     enum class JumpToMarks { NONE, Mark, Table, Region, Graphic };
 430     JumpToMarks m_eJumpTo;
 431
 432 #ifdef DBG_UTIL
 433     sal_uInt16  m_nContinue;        // depth of Continue calls
 434 #endif
 435
 436     SvxAdjust   m_eParaAdjust;    // adjustment of current paragraph
 437     HTMLScriptLanguage m_eScriptLang; // current script language
 438
 439     bool m_bOldIsHTMLMode : 1;    // Was it a HTML document?
 440
 441     bool m_bDocInitialized : 1;   // document resp. shell was initialize
 442                                   // flag to prevent double init via recursion
 443     bool m_bViewCreated : 1;      // the view was already created (asynchronous)
 444     bool m_bSetModEnabled : 1;
 445
 446     bool m_bInFloatingFrame : 1;  // We are in a floating frame
 447     bool m_bInField : 1;
 448     bool m_bKeepUnknown : 1;      // handle unknown/not supported tokens
 449     // 8
 450     bool m_bCallNextToken : 1;    // In tables: call NextToken in any case
 451     bool m_bIgnoreRawData : 1;    // ignore content of script/style
 452     bool m_bLBEntrySelected : 1;  // Is the current option selected?
 453     bool m_bTAIgnoreNewPara : 1;  // ignore next LF in text area?
 454     bool m_bFixMarqueeWidth : 1;  // Change size of marquee?
 455
 456     bool m_bUpperSpace : 1;       // top paragraph spacing is needed
 457     bool m_bNoParSpace : 1;
 458     // 16
 459
 460     bool m_bInNoEmbed : 1;        // we are in a NOEMBED area
 461
 462     bool m_bInTitle : 1;          // we are in title
 463
 464     bool m_bChkJumpMark : 1;      // maybe jump to predetermined mark
 465     bool m_bUpdateDocStat : 1;
 466     bool m_bFixSelectWidth : 1;   // Set new width of select?
 467     bool m_bTextArea : 1;
 468     // 24
 469     bool m_bSelect : 1;
 470     bool m_bInFootEndNoteAnchor : 1;
 471     bool m_bInFootEndNoteSymbol : 1;
 472     bool m_bIgnoreHTMLComments : 1;
 473     bool m_bRemoveHidden : 1; // the filter implementation might set the hidden flag
 474
 475     bool m_bBodySeen : 1;
 476     bool m_bReadingHeaderOrFooter : 1;
 477     bool m_bNotifyMacroEventRead : 1;
 478     bool m_isInTableStructure;
 479
 480     int m_nTableDepth;
 481     int m_nFloatingFrames;
 482     int m_nListItems;
 483
 484     /// the names corresponding to the DOCINFO field subtypes INFO[1-4]
 485     OUString m_InfoNames[4];
 486
 487     SfxViewFrame* m_pTempViewFrame;
 488
 489     bool m_bXHTML = false;
 490     bool m_bReqIF = false;
 491
 492     /**
 493      * Non-owning pointers to already inserted OLE nodes, matching opened
 494      * <object> XHTML elements.
 495      */
 496     std::stack<SwOLENode*> m_aEmbeds;
 497
 498     std::set<OUString> m_aAllowedRTFOLEMimeTypes;
 499
 500     /// This is the URL of the outer <object> data if it's not OLE2 or an image.
 501     OUString m_aEmbedURL;
 502
 503     std::unique_ptr<SfxItemSet> m_pTargetCharAttrs;
 504
 505     void DeleteFormImpl();
 506
 507     void DocumentDetected();
 508     void Show();
 509     void ShowStatline();
 510     SwViewShell *CallStartAction( SwViewShell *pVSh = nullptr, bool bChkPtr = true );
 511     SwViewShell *CallEndAction( bool bChkAction = false, bool bChkPtr = true );
 512     SwViewShell *CheckActionViewShell();
 513
 514     DECL_LINK( AsyncCallback, void*, void );
 515
 516     // set attribute on document
 517     void SetAttr_( bool bChkEnd, bool bBeforeTable, std::deque<std::unique_ptr<HTMLAttr>> *pPostIts );
 518     void SetAttr( bool bChkEnd = true, bool bBeforeTable = false,
 519                          std::deque<std::unique_ptr<HTMLAttr>> *pPostIts = nullptr )
 520     {
 521         if( !m_aSetAttrTab.empty() || !m_aMoveFlyFrames.empty() )
 522             SetAttr_( bChkEnd, bBeforeTable, pPostIts );
 523     }
 524
 525     HTMLAttr **GetAttrTabEntry( sal_uInt16 nWhich );
 526
 527     // create a new text node on PaM position
 528     bool AppendTextNode( SwHTMLAppendMode eMode=AM_NORMAL, bool bUpdateNum=true );
 529     void AddParSpace();
 530
 531     // start/end an attribute
 532     // ppDepAttr indicated an attribute table entry, which attribute has to be
 533     // set, before the attribute is closed
 534     void NewAttr(const std::shared_ptr<HTMLAttrTable>& rAttrTab, HTMLAttr **ppAttr, const SfxPoolItem& rItem);
 535     bool EndAttr( HTMLAttr *pAttr, bool bChkEmpty=true );
 536     void DeleteAttr( HTMLAttr* pAttr );
 537
 538     void EndContextAttrs( HTMLAttrContext *pContext );
 539     void SaveAttrTab(std::shared_ptr<HTMLAttrTable> const & rNewAttrTab);
 540     void SplitAttrTab( const SwPosition& rNewPos );
 541     void SplitAttrTab(std::shared_ptr<HTMLAttrTable> const & rNewAttrTab, bool bMoveEndBack);
 542     void RestoreAttrTab(std::shared_ptr<HTMLAttrTable> const & rNewAttrTab);
 543     void InsertAttr( const SfxPoolItem& rItem, bool bInsAtStart );
 544     void InsertAttrs( std::deque<std::unique_ptr<HTMLAttr>> rAttrs );
 545
 546     bool DoPositioning( SfxItemSet &rItemSet,
 547                         SvxCSS1PropertyInfo &rPropInfo,
 548                         HTMLAttrContext *pContext );
 549     bool CreateContainer( std::u16string_view rClass, SfxItemSet &rItemSet,
 550                           SvxCSS1PropertyInfo &rPropInfo,
 551                           HTMLAttrContext *pContext );
 552     bool EndSection( bool bLFStripped=false );
 553
 554     void InsertAttrs( SfxItemSet &rItemSet, SvxCSS1PropertyInfo const &rPropInfo,
 555                       HTMLAttrContext *pContext, bool bCharLvl=false );
 556     void InsertAttr( HTMLAttr **ppAttr, const SfxPoolItem & rItem,
 557                      HTMLAttrContext *pCntxt );
 558     void SplitPREListingXMP( HTMLAttrContext *pCntxt );
 559     void FixHeaderFooterDistance( bool bHeader, const SwPosition *pOldPos );
 560
 561     void EndContext( HTMLAttrContext *pContext );
 562     void ClearContext( HTMLAttrContext *pContext );
 563
 564     const SwFormatColl *GetCurrFormatColl() const;
 565
 566     SwTwips GetCurrentBrowseWidth();
 567
 568     SwHTMLNumRuleInfo& GetNumInfo() { return *m_pNumRuleInfo; }
 569     // add parameter <bCountedInList>
 570     void SetNodeNum( sal_uInt8 nLevel );
 571
 572     // Manage paragraph styles
 573
 574     // set the style resp. its attributes on the stack
 575     void SetTextCollAttrs( HTMLAttrContext *pContext = nullptr );
 576
 577     void InsertParaAttrs( const SfxItemSet& rItemSet );
 578
 579     // Manage attribute context
 580
 581     // save current context
 582     void PushContext(std::unique_ptr<HTMLAttrContext>& rCntxt)
 583     {
 584         m_aContexts.push_back(std::move(rCntxt));
 585     }
 586
 587     // Fetch top/specified context but not outside the context with token
 588     // nLimit. If bRemove set then remove it.
 589     std::unique_ptr<HTMLAttrContext> PopContext(HtmlTokenId nToken = HtmlTokenId::NONE);
 590
 591     void GetMarginsFromContext( sal_uInt16 &nLeft, sal_uInt16 &nRight, short& nIndent,
 592                                 bool bIgnoreCurrent=false ) const;
 593     void GetMarginsFromContextWithNumberBullet( sal_uInt16 &nLeft, sal_uInt16 &nRight,
 594                                           short& nIndent ) const;
 595     void GetULSpaceFromContext( sal_uInt16 &rUpper, sal_uInt16 &rLower ) const;
 596
 597     void MovePageDescAttrs( SwNode *pSrcNd, SwNodeOffset nDestIdx, bool bFormatBreak );
 598
 599     // Handling of tags at paragraph level
 600
 601     // <P> and <H1> to <H6>
 602     void NewPara();
 603     void EndPara( bool bReal = false );
 604     void NewHeading( HtmlTokenId nToken );
 605     void EndHeading();
 606
 607     // <ADDRESS>, <BLOCKQUOTE> and <PRE>
 608     void NewTextFormatColl( HtmlTokenId nToken, sal_uInt16 nPoolId );
 609     void EndTextFormatColl( HtmlTokenId nToken );
 610
 611     // <DIV> and <CENTER>
 612     void NewDivision( HtmlTokenId nToken );
 613     void EndDivision();
 614
 615     // insert/close Fly-Frames
 616     void InsertFlyFrame( const SfxItemSet& rItemSet, HTMLAttrContext *pCntxt,
 617                          const OUString& rId );
 618
 619     void SaveDocContext( HTMLAttrContext *pCntxt, HtmlContextFlags nFlags,
 620                        const SwPosition *pNewPos );
 621     void RestoreDocContext( HTMLAttrContext *pCntxt );
 622
 623     // end all opened <DIV> areas
 624     bool EndSections( bool bLFStripped );
 625
 626     // <MULTICOL>
 627     void NewMultiCol( sal_uInt16 columnsFromCss=0 );
 628
 629     // <MARQUEE>
 630     void NewMarquee( HTMLTable *pCurTable=nullptr );
 631     void EndMarquee();
 632     void InsertMarqueeText();
 633
 634     // Handling of lists
 635
 636     // order list <OL> and unordered list <UL> with <LI>
 637     void NewNumberBulletList( HtmlTokenId nToken );
 638     void EndNumberBulletList( HtmlTokenId nToken = HtmlTokenId::NONE );
 639     void NewNumberBulletListItem( HtmlTokenId nToken );
 640     void EndNumberBulletListItem( HtmlTokenId nToken, bool bSetColl);
 641
 642     // definitions lists <DL> with <DD>, <DT>
 643     void NewDefList();
 644     void EndDefList();
 645     void NewDefListItem( HtmlTokenId nToken );
 646     void EndDefListItem( HtmlTokenId nToken = HtmlTokenId::NONE );
 647
 648     // Handling of tags on character level
 649
 650     // handle tags like <B>, <I> and so, which enable/disable a certain
 651     // attribute or like <SPAN> get attributes from styles
 652     void NewStdAttr( HtmlTokenId nToken );
 653     void NewStdAttr( HtmlTokenId nToken,
 654                      HTMLAttr **ppAttr, const SfxPoolItem & rItem,
 655                      HTMLAttr **ppAttr2=nullptr, const SfxPoolItem *pItem2=nullptr,
 656                      HTMLAttr **ppAttr3=nullptr, const SfxPoolItem *pItem3=nullptr );
 657     void EndTag( HtmlTokenId nToken );
 658
 659     // handle font attributes
 660     void NewBasefontAttr();             // for <BASEFONT>
 661     void EndBasefontAttr();
 662     void NewFontAttr( HtmlTokenId nToken ); // for <FONT>, <BIG> and <SMALL>
 663     void EndFontAttr( HtmlTokenId nToken );
 664
 665     // tags realized via character styles
 666     void NewCharFormat( HtmlTokenId nToken );
 667
 668     void DeleteSection(SwStartNode* pSttNd);
 669
 670     // <SDFIELD>
 671 public:
 672     static SvxNumType GetNumType( std::u16string_view rStr, SvxNumType eDfltType );
 673 private:
 674     void NewField();
 675     void EndField();
 676     void InsertFieldText();
 677
 678     // <SPACER>
 679     void InsertSpacer();
 680
 681     // Inserting graphics, plug-ins and applets
 682
 683     // search image maps and link with graphic nodes
 684     ImageMap *FindImageMap( std::u16string_view rURL ) const;
 685     void ConnectImageMaps();
 686
 687     // find anchor of Fly-Frames and set corresponding attributes
 688     // in Attrset (htmlgrin.cxx)
 689     void SetAnchorAndAdjustment( sal_Int16 eVertOri,
 690                                  sal_Int16 eHoriOri,
 691                                  const SvxCSS1PropertyInfo &rPropInfo,
 692                                  SfxItemSet& rFrameSet );
 693     void SetAnchorAndAdjustment( sal_Int16 eVertOri,
 694                                  sal_Int16 eHoriOri,
 695                                  SfxItemSet& rFrameSet,
 696                                  bool bDontAppend=false );
 697     void SetAnchorAndAdjustment( const SvxCSS1PropertyInfo &rPropInfo,
 698                                  SfxItemSet &rFrameItemSet );
 699
 700     static void SetFrameFormatAttrs( SfxItemSet &rItemSet,
 701                          HtmlFrameFormatFlags nFlags, SfxItemSet &rFrameItemSet );
 702
 703     // create frames and register auto bound frames
 704     void RegisterFlyFrame( SwFrameFormat *pFlyFrame );
 705
 706     // Adjust the size of the Fly-Frames to requirements and conditions
 707     // (not for graphics, therefore htmlplug.cxx)
 708     static void SetFixSize( const Size& rPixSize, const Size& rTwipDfltSize,
 709                      bool bPercentWidth, bool bPercentHeight,
 710                      SvxCSS1PropertyInfo const &rPropInfo,
 711                      SfxItemSet& rFlyItemSet );
 712     static void SetVarSize( SvxCSS1PropertyInfo const &rPropInfo,
 713                      SfxItemSet& rFlyItemSet, SwTwips nDfltWidth=MINLAY,
 714                      sal_uInt8 nDefaultPercentWidth=0 );
 715     static void SetSpace( const Size& rPixSpace, SfxItemSet &rItemSet,
 716                    SvxCSS1PropertyInfo &rPropInfo, SfxItemSet& rFlyItemSet );
 717
 718     sal_uInt16 IncGrfsThatResizeTable();
 719
 720     void GetDefaultScriptType( ScriptType& rType,
 721                                OUString& rTypeStr ) const;
 722
 723     // the actual insert methods for <IMG>, <EMBED>, <APPLET> and <PARAM>
 724     void InsertImage();     // htmlgrin.cxx
 725     bool InsertEmbed();     // htmlplug.cxx
 726
 727 #if HAVE_FEATURE_JAVA
 728     void NewObject();   // htmlplug.cxx
 729 #endif
 730     void EndObject();       // link CommandLine with applet (htmlplug.cxx)
 731 #if HAVE_FEATURE_JAVA
 732     void InsertApplet();    // htmlplug.cxx
 733 #endif
 734     void EndApplet();       // link CommandLine with applet (htmlplug.cxx)
 735     void InsertParam();     // htmlplug.cxx
 736
 737     void InsertFloatingFrame();
 738
 739     // parse <BODY>-tag: set background graphic and background colour (htmlgrin.cxx)
 740     void InsertBodyOptions();
 741
 742     // Inserting links and bookmarks (htmlgrin.cxx)
 743
 744     // parse <A>-tag: insert a link resp. bookmark
 745     void NewAnchor();
 746     void EndAnchor();
 747
 748     // insert bookmark
 749     void InsertBookmark( const OUString& rName );
 750
 751     void InsertCommentText( std::string_view pTag );
 752     void InsertComment( const OUString& rName, std::string_view pTag = {} );
 753
 754     // Has the current paragraph bookmarks?
 755     bool HasCurrentParaBookmarks( bool bIgnoreStack=false ) const;
 756
 757     // Inserting script/basic elements
 758
 759     // parse the last read basic module (htmlbas.cxx)
 760     void NewScript();
 761     void EndScript();
 762
 763     void AddScriptSource();
 764
 765     // insert event in SFX configuration (htmlbas.cxx)
 766     void InsertBasicDocEvent( const OUString& aEventName, const OUString& rName,
 767                               ScriptType eScrType, const OUString& rScrType );
 768
 769     // Inserting styles
 770
 771     // <STYLE>
 772     void NewStyle();
 773     void EndStyle();
 774
 775     static inline bool HasStyleOptions( std::u16string_view rStyle, std::u16string_view rId,
 776                                  std::u16string_view rClass, const OUString *pLang=nullptr,
 777                                  const OUString *pDir=nullptr );
 778     bool ParseStyleOptions( const OUString &rStyle, const OUString &rId,
 779                             const OUString &rClass, SfxItemSet &rItemSet,
 780                             SvxCSS1PropertyInfo &rPropInfo,
 781                             const OUString *pLang=nullptr, const OUString *pDir=nullptr );
 782
 783     // Inserting Controls and Forms (htmlform.cxx)
 784
 785     // Insert draw object into document
 786     void InsertDrawObject( SdrObject* pNewDrawObj, const Size& rSpace,
 787                            sal_Int16 eVertOri,
 788                            sal_Int16 eHoriOri,
 789                            SfxItemSet& rCSS1ItemSet,
 790                            SvxCSS1PropertyInfo& rCSS1PropInfo );
 791     css::uno::Reference< css::drawing::XShape >  InsertControl(
 792                         const css::uno::Reference< css::form::XFormComponent > & rFormComp,
 793                         const css::uno::Reference< css::beans::XPropertySet > & rFCompPropSet,
 794                         const Size& rSize,
 795                         sal_Int16 eVertOri,
 796                         sal_Int16 eHoriOri,
 797                         SfxItemSet& rCSS1ItemSet,
 798                         SvxCSS1PropertyInfo& rCSS1PropInfo,
 799                         const SvxMacroTableDtor& rMacroTable,
 800                         const std::vector<OUString>& rUnoMacroTable,
 801                         const std::vector<OUString>& rUnoMacroParamTable,
 802                         bool bSetPropSet = true,
 803                         bool bHidden = false );
 804     void SetControlSize( const css::uno::Reference< css::drawing::XShape > & rShape, const Size& rTextSz,
 805                          bool bMinWidth, bool bMinHeight );
 806
 807 public:
 808     static void ResizeDrawObject( SdrObject* pObj, SwTwips nWidth );
 809 private:
 810     static void RegisterDrawObjectToTable( HTMLTable *pCurTable, SdrObject* pObj,
 811                                     sal_uInt8 nWidth );
 812
 813     void NewForm( bool bAppend=true );
 814     void EndForm( bool bAppend=true );
 815
 816     // Insert methods for <INPUT>, <TEXTAREA> and <SELECT>
 817     void InsertInput();
 818
 819     void NewTextArea();
 820     void InsertTextAreaText( HtmlTokenId nToken );
 821     void EndTextArea();
 822
 823     void NewSelect();
 824     void InsertSelectOption();
 825     void InsertSelectText();
 826     void EndSelect();
 827
 828     // Inserting tables (htmltab.cxx)
 829 public:
 830
 831     // Insert box content after the given node
 832     const SwStartNode *InsertTableSection( const SwStartNode *pPrevStNd );
 833
 834     // Insert box content at the end of the table containing the PaM
 835     // and move the PaM into the cell
 836     const SwStartNode *InsertTableSection( sal_uInt16 nPoolId );
 837
 838     // Insert methods for various table tags
 839     std::unique_ptr<HTMLTableCnts> InsertTableContents( bool bHead );
 840
 841 private:
 842     // Create a section for the temporary storage of the table caption
 843     SwStartNode *InsertTempTableCaptionSection();
 844
 845     void BuildTableCell( HTMLTable *pTable, bool bReadOptions, bool bHead );
 846     void BuildTableRow( HTMLTable *pTable, bool bReadOptions,
 847                         SvxAdjust eGrpAdjust, sal_Int16 eVertOri );
 848     void BuildTableSection( HTMLTable *pTable, bool bReadOptions, bool bHead );
 849     void BuildTableColGroup( HTMLTable *pTable, bool bReadOptions );
 850     void BuildTableCaption( HTMLTable *pTable );
 851     std::shared_ptr<HTMLTable> BuildTable(SvxAdjust eCellAdjust,
 852                                           bool bIsParentHead = false,
 853                                           bool bHasParentSection=true,
 854                                           bool bHasToFlow = false);
 855
 856     // misc ...
 857
 858     void ParseMoreMetaOptions();
 859
 860     bool FileDownload( const OUString& rURL, OUString& rStr );
 861     void InsertLink();
 862
 863     void InsertIDOption();
 864     void InsertLineBreak();
 865     void InsertHorzRule();
 866
 867     void FillEndNoteInfo( std::u16string_view aContent );
 868     void FillFootNoteInfo( std::u16string_view aContent );
 869     void InsertFootEndNote( const OUString& rName, bool bEndNote, bool bFixed );
 870     void FinishFootEndNote();
 871     void InsertFootEndNoteText();
 872     SwNodeIndex *GetFootEndNoteSection( const OUString& rName );
 873
 874     sal_Int32 StripTrailingLF();
 875
 876     // Remove empty paragraph at the PaM position
 877     void StripTrailingPara();
 878     // If removing an empty node would corrupt the document
 879     bool CanRemoveNode(SwNodeOffset nNodeIdx) const;
 880
 881     // Are there fly frames in the current paragraph?
 882     bool HasCurrentParaFlys( bool bNoSurroundOnly = false,
 883                              bool bSurroundOnly = false ) const;
 884
 885     class TableDepthGuard
 886     {
 887     private:
 888         SwHTMLParser& m_rParser;
 889     public:
 890         TableDepthGuard(SwHTMLParser& rParser)
 891             : m_rParser(rParser)
 892         {
 893             ++m_rParser.m_nTableDepth;
 894         }
 895         bool TooDeep() const { return m_rParser.m_nTableDepth > 1024; }
 896         ~TableDepthGuard()
 897         {
 898             --m_rParser.m_nTableDepth;
 899         }
 900     };
 901
 902 public:         // used in tables
 903
 904     // Create brush item (with new) or 0
 905     SvxBrushItem* CreateBrushItem( const Color *pColor,
 906                                    const OUString &rImageURL,
 907                                    const OUString &rStyle,
 908                                    const OUString &rId,
 909                                    const OUString &rClass );
 910
 911 protected:
 912     // Executed for each token recognized by CallParser
 913     virtual void NextToken( HtmlTokenId nToken ) override;
 914     virtual ~SwHTMLParser() override;
 915
 916     // If the document is removed, remove the parser as well
 917     virtual void Notify(const SfxHint&) override;
 918
 919     virtual void AddMetaUserDefined( OUString const & i_rMetaName ) override;
 920
 921 public:
 922
 923     SwHTMLParser( SwDoc* pD, SwPaM & rCursor, SvStream& rIn,
 924                     OUString aFileName,
 925                     OUString aBaseURL,
 926                     bool bReadNewDoc,
 927                     SfxMedium* pMed, bool bReadUTF8,
 928                     bool bIgnoreHTMLComments,
 929                     const OUString& rNamespace);
 930
 931     virtual SvParserState CallParser() override;
 932
 933     static sal_uInt16 ToTwips( sal_uInt16 nPixel );
 934
 935     // for reading asynchronously from SvStream
 936     virtual void Continue( HtmlTokenId nToken ) override;
 937
 938     virtual bool ParseMetaOptions( const css::uno::Reference<css::document::XDocumentProperties>&,
 939             SvKeyValueIterator* ) override;
 940
 941
 942     void RegisterHTMLTable(HTMLTable* pNew)
 943     {
 944         m_aTables.push_back(pNew);
 945     }
 946
 947     void DeregisterHTMLTable(HTMLTable* pOld);
 948
 949     SwDoc* GetDoc() const;
 950
 951     bool IsReqIF() const;
 952
 953     bool IsReadingHeaderOrFooter() const { return m_bReadingHeaderOrFooter; }
 954
 955     void NotifyMacroEventRead();
 956
 957     /// Strips query and fragment from a URL path if base URL is a file:// one.
 958     static OUString StripQueryFromPath(std::u16string_view rBase, const OUString& rPath);
 959 };
 960
 961 struct SwPendingData
 962 {
 963     virtual ~SwPendingData() {}
 964 };
 965
 966 struct SwPending
 967 {
 968     HtmlTokenId nToken;
 969     std::unique_ptr<SwPendingData> pData;
 970
 971     SwPending( HtmlTokenId nTkn )
 972         : nToken( nTkn )
 973         {}
 974 };
 975
 976 inline void HTMLAttr::SetStart( const SwPosition& rPos )
 977 {
 978     m_nStartPara = rPos.GetNode();
 979     m_nStartContent = rPos.GetContentIndex();
 980     m_nEndPara = m_nStartPara;
 981     m_nEndContent = m_nStartContent;
 982 }
 983
 984 inline void HTMLAttrContext::SetMargins( sal_uInt16 nLeft, sal_uInt16 nRight,
 985                                           short nIndent )
 986 {
 987     m_nLeftMargin = nLeft;
 988     m_nRightMargin = nRight;
 989     m_nFirstLineIndent = nIndent;
 990     m_bLRSpaceChanged = true;
 991 }
 992
 993 inline void HTMLAttrContext::GetMargins( sal_uInt16& nLeft,
 994                                           sal_uInt16& nRight,
 995                                           short& nIndent ) const
 996 {
 997     if( m_bLRSpaceChanged )
 998     {
 999         nLeft = m_nLeftMargin;
1000         nRight = m_nRightMargin;
1001         nIndent = m_nFirstLineIndent;
1002     }
1003 }
1004
1005 inline void HTMLAttrContext::SetULSpace( sal_uInt16 nUpper, sal_uInt16 nLower )
1006 {
1007     m_nUpperSpace = nUpper;
1008     m_nLowerSpace = nLower;
1009     m_bULSpaceChanged = true;
1010 }
1011
1012 inline void HTMLAttrContext::GetULSpace( sal_uInt16& rUpper,
1013                                           sal_uInt16& rLower ) const
1014 {
1015     if( m_bULSpaceChanged )
1016     {
1017         rUpper = m_nUpperSpace;
1018         rLower = m_nLowerSpace;
1019     }
1020 }
1021
1022 inline bool SwHTMLParser::HasStyleOptions( std::u16string_view rStyle,
1023                                             std::u16string_view rId,
1024                                             std::u16string_view rClass,
1025                                             const OUString *pLang,
1026                                                const OUString *pDir )
1027 {
1028     return !rStyle.empty() || !rId.empty() || !rClass.empty() ||
1029            (pLang && !pLang->isEmpty()) || (pDir && !pDir->isEmpty());
1030 }
1031
1032 class SwTextFootnote;
1033
1034 class SwHTMLTextFootnote
1035 {
1036 private:
1037     OUString m_sName;
1038     SwTextFootnote* m_pTextFootnote;
1039     std::unique_ptr<SvtDeleteListener> m_xDeleteListener;
1040 public:
1041     SwHTMLTextFootnote(OUString rName, SwTextFootnote* pInTextFootnote)
1042         : m_sName(std::move(rName))
1043         , m_pTextFootnote(pInTextFootnote)
1044         , m_xDeleteListener(new SvtDeleteListener(static_cast<SwFormatFootnote&>(pInTextFootnote->GetAttr()).GetNotifier()))
1045     {
1046     }
1047     const OUString& GetName() const
1048     {
1049         return m_sName;
1050     }
1051     const SwNodeIndex* GetStartNode() const
1052     {
1053         if (m_xDeleteListener->WasDeleted())
1054             return nullptr;
1055         return m_pTextFootnote->GetStartNode();
1056     }
1057 };
1058
1059 struct SwHTMLFootEndNote_Impl
1060 {
1061     std::vector<SwHTMLTextFootnote> aTextFootnotes;
1062
1063     OUString sName;
1064     OUString sContent;            // information for the last footnote
1065     bool bEndNote;
1066     bool bFixed;
1067 };
1068
1069 #endif
1070
1071 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */