LibreOffice Module sw (master)  1
swhtml.cxx
Go to the documentation of this file.
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 #include <sal/config.h>
21 
22 #include <algorithm>
23 #include <memory>
24 #include <config_java.h>
25 
26 #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
27 #include <com/sun/star/document/XDocumentProperties.hpp>
28 #include <com/sun/star/i18n/ScriptType.hpp>
29 #include <com/sun/star/i18n/XBreakIterator.hpp>
30 #include <comphelper/string.hxx>
31 #include <o3tl/safeint.hxx>
32 #include <rtl/ustrbuf.hxx>
33 #include <svx/svxids.hrc>
34 #if OSL_DEBUG_LEVEL > 0
35 #include <stdlib.h>
36 #endif
37 #include <hintids.hxx>
38 
39 #include <vcl/errinf.hxx>
40 #include <svl/stritem.hxx>
41 #include <vcl/imap.hxx>
42 #include <svtools/htmltokn.h>
43 #include <svtools/htmlkywd.hxx>
44 #include <svtools/ctrltool.hxx>
45 #include <unotools/configmgr.hxx>
46 #include <unotools/pathoptions.hxx>
47 #include <vcl/svapp.hxx>
48 #include <sfx2/event.hxx>
49 #include <sfx2/docfile.hxx>
50 
51 #include <svtools/htmlcfg.hxx>
52 #include <sfx2/linkmgr.hxx>
53 #include <editeng/kernitem.hxx>
54 #include <editeng/boxitem.hxx>
55 #include <editeng/fhgtitem.hxx>
56 #include <editeng/formatbreakitem.hxx>
57 #include <editeng/postitem.hxx>
58 #include <editeng/wghtitem.hxx>
59 #include <editeng/crossedoutitem.hxx>
60 #include <editeng/udlnitem.hxx>
61 #include <editeng/escapementitem.hxx>
62 #include <editeng/blinkitem.hxx>
63 #include <editeng/ulspitem.hxx>
64 #include <editeng/colritem.hxx>
65 #include <editeng/fontitem.hxx>
66 #include <editeng/adjustitem.hxx>
67 #include <editeng/lrspitem.hxx>
68 #include <editeng/protitem.hxx>
69 #include <editeng/flstitem.hxx>
70 #include <svx/unobrushitemhelper.hxx>
71 
72 #include <frmatr.hxx>
73 #include <charatr.hxx>
74 #include <fmtfld.hxx>
75 #include <fmtpdsc.hxx>
76 #include <fmtanchr.hxx>
77 #include <fmtsrnd.hxx>
78 #include <fmtfsize.hxx>
79 #include <fmtclds.hxx>
80 #include <fchrfmt.hxx>
81 #include <fmtinfmt.hxx>
82 #include <fmtfollowtextflow.hxx>
83 #include <fmtornt.hxx>
84 #include <docary.hxx>
85 #include <doc.hxx>
86 #include <IDocumentUndoRedo.hxx>
87 #include <IDocumentSettingAccess.hxx>
88 #include <IDocumentLayoutAccess.hxx>
89 #include <IDocumentLinksAdministration.hxx>
90 #include <IDocumentRedlineAccess.hxx>
91 #include <IDocumentFieldsAccess.hxx>
92 #include <IDocumentStylePoolAccess.hxx>
93 #include <IDocumentStatistics.hxx>
94 #include <IDocumentState.hxx>
95 #include <pam.hxx>
96 #include <ndtxt.hxx>
97 #include <mdiexp.hxx>
98 #include <poolfmt.hxx>
99 #include <pagedesc.hxx>
100 #include <IMark.hxx>
101 #include <docsh.hxx>
102 #include <editsh.hxx>
103 #include <docufld.hxx>
104 #include "swcss1.hxx"
105 #include <fltini.hxx>
106 #include <htmltbl.hxx>
107 #include "htmlnum.hxx"
108 #include "swhtml.hxx"
109 #include "wrthtml.hxx"
110 #include <linkenum.hxx>
111 #include <breakit.hxx>
112 #include <SwAppletImpl.hxx>
113 #include <swdll.hxx>
114 #include <txatbase.hxx>
115 
116 #include <sfx2/viewfrm.hxx>
117 #include <svx/svdobj.hxx>
118 #include <officecfg/Office/Writer.hxx>
119 #include <comphelper/sequenceashashmap.hxx>
120 #include <comphelper/sequence.hxx>
121 
122 #include <swerror.h>
123 #include <ndole.hxx>
124 #include <unoframe.hxx>
125 #include "css1atr.hxx"
126 #include <frameformats.hxx>
127 
128 #define FONTSIZE_MASK 7
129 
130 #define HTML_ESC_PROP 80
131 #define HTML_ESC_SUPER DFLT_ESC_SUPER
132 #define HTML_ESC_SUB DFLT_ESC_SUB
133 
134 #define HTML_SPTYPE_BLOCK 1
135 #define HTML_SPTYPE_HORI 2
136 #define HTML_SPTYPE_VERT 3
137 
138 using editeng::SvxBorderLine;
139 using namespace ::com::sun::star;
140 
141 // <P ALIGN=xxx>, <Hn ALIGN=xxx>, <TD ALIGN=xxx> etc.
142 HTMLOptionEnum<SvxAdjust> const aHTMLPAlignTable[] =
143 {
144  { OOO_STRING_SVTOOLS_HTML_AL_left, SvxAdjust::Left },
145  { OOO_STRING_SVTOOLS_HTML_AL_center, SvxAdjust::Center },
146  { OOO_STRING_SVTOOLS_HTML_AL_middle, SvxAdjust::Center }, // Netscape
147  { OOO_STRING_SVTOOLS_HTML_AL_right, SvxAdjust::Right },
148  { OOO_STRING_SVTOOLS_HTML_AL_justify, SvxAdjust::Block },
149  { OOO_STRING_SVTOOLS_HTML_AL_char, SvxAdjust::Left },
150  { nullptr, SvxAdjust(0) }
151 };
152 
153 // <SPACER TYPE=...>
154 HTMLOptionEnum<sal_uInt16> const aHTMLSpacerTypeTable[] =
155 {
156  { OOO_STRING_SVTOOLS_HTML_SPTYPE_block, HTML_SPTYPE_BLOCK },
157  { OOO_STRING_SVTOOLS_HTML_SPTYPE_horizontal, HTML_SPTYPE_HORI },
158  { OOO_STRING_SVTOOLS_HTML_SPTYPE_vertical, HTML_SPTYPE_VERT },
159  { nullptr, 0 }
160 };
161 
162 HTMLReader::HTMLReader()
163 {
164  m_bTemplateBrowseMode = true;
165 }
166 
167 OUString HTMLReader::GetTemplateName(SwDoc& rDoc) const
168 {
169  if (!rDoc.getIDocumentSettingAccess().get(DocumentSettingId::HTML_MODE))
170  // HTML import into Writer, avoid loading the Writer/Web template.
171  return OUString();
172 
173  const OUString sTemplateWithoutExt("internal/html");
174  SvtPathOptions aPathOpt;
175 
176  // first search for OpenDocument Writer/Web template
177  // OpenDocument Writer/Web template (extension .oth)
178  OUString sTemplate( sTemplateWithoutExt + ".oth" );
179  if (aPathOpt.SearchFile( sTemplate, SvtPathOptions::PATH_TEMPLATE ))
180  return sTemplate;
181 
182  // no OpenDocument Writer/Web template found.
183  // search for OpenOffice.org Writer/Web template
184  sTemplate = sTemplateWithoutExt + ".stw";
185  if (aPathOpt.SearchFile( sTemplate, SvtPathOptions::PATH_TEMPLATE ))
186  return sTemplate;
187 
188  OSL_ENSURE( false, "The default HTML template cannot be found in the defined template directories!");
189 
190  return OUString();
191 }
192 
193 bool HTMLReader::SetStrmStgPtr()
194 {
195  OSL_ENSURE( m_pMedium, "Where is the medium??" );
196 
197  if( m_pMedium->IsRemote() || !m_pMedium->IsStorage() )
198  {
199  m_pStream = m_pMedium->GetInStream();
200  return true;
201  }
202  return false;
203 
204 }
205 
206 // Call for the general Reader-Interface
207 ErrCode HTMLReader::Read( SwDoc &rDoc, const OUString& rBaseURL, SwPaM &rPam, const OUString & rName )
208 {
209  SetupFilterOptions();
210 
211  if( !m_pStream )
212  {
213  OSL_ENSURE( m_pStream, "HTML-Read without stream" );
214  return ERR_SWG_READ_ERROR;
215  }
216 
217  if( !m_bInsertMode )
218  {
219  Reader::ResetFrameFormats( rDoc );
220 
221  // Set the HTML page style, when it isn't a HTML document,
222  // otherwise it's already set.
223  if( !rDoc.getIDocumentSettingAccess().get(DocumentSettingId::HTML_MODE) && m_aNamespace != "reqif-xhtml" )
224  {
225  rDoc.getIDocumentContentOperations().InsertPoolItem( rPam, SwFormatPageDesc(
226  rDoc.getIDocumentStylePoolAccess().GetPageDescFromPool( RES_POOLPAGE_HTML, false )) );
227  }
228  }
229 
230  // so nobody steals the document!
231  rtl::Reference<SwDoc> xHoldAlive(&rDoc);
232  ErrCode nRet = ERRCODE_NONE;
233  tools::SvRef<SwHTMLParser> xParser = new SwHTMLParser( &rDoc, rPam, *m_pStream,
234  rName, rBaseURL, !m_bInsertMode, m_pMedium,
235  IsReadUTF8(),
236  m_bIgnoreHTMLComments, m_aNamespace );
237 
238  SvParserState eState = xParser->CallParser();
239 
240  if( SvParserState::Pending == eState )
241  m_pStream->ResetError();
242  else if( SvParserState::Accepted != eState )
243  {
244  const OUString sErr(OUString::number(static_cast<sal_Int32>(xParser->GetLineNr()))
245  + "," + OUString::number(static_cast<sal_Int32>(xParser->GetLinePos())));
246 
247  // use the stream as transport for error number
248  nRet = *new StringErrorInfo( ERR_FORMAT_ROWCOL, sErr,
249  DialogMask::ButtonsOk | DialogMask::MessageError );
250  }
251 
252  return nRet;
253 }
254 
255 SwHTMLParser::SwHTMLParser( SwDoc* pD, SwPaM& rCursor, SvStream& rIn,
256  const OUString& rPath,
257  const OUString& rBaseURL,
258  bool bReadNewDoc,
259  SfxMedium* pMed, bool bReadUTF8,
260  bool bNoHTMLComments,
261  const OUString& rNamespace )
262  : SfxHTMLParser( rIn, bReadNewDoc, pMed ),
263  m_aPathToFile( rPath ),
264  m_sBaseURL( rBaseURL ),
265  m_xAttrTab(std::make_shared<HTMLAttrTable>()),
266  m_pNumRuleInfo( new SwHTMLNumRuleInfo ),
267  m_xDoc( pD ),
268  m_pActionViewShell( nullptr ),
269  m_pSttNdIdx( nullptr ),
270  m_pFormImpl( nullptr ),
271  m_pMarquee( nullptr ),
272  m_pImageMap( nullptr ),
273  m_nBaseFontStMin( 0 ),
274  m_nFontStMin( 0 ),
275  m_nDefListDeep( 0 ),
276  m_nFontStHeadStart( 0 ),
277  m_nSBModuleCnt( 0 ),
278  m_nMissingImgMaps( 0 ),
279  m_nParaCnt( 5 ),
280  // #i83625#
281  m_nContextStMin( 0 ),
282  m_nContextStAttrMin( 0 ),
283  m_nSelectEntryCnt( 0 ),
284  m_nOpenParaToken( HtmlTokenId::NONE ),
285  m_eJumpTo( JumpToMarks::NONE ),
286 #ifdef DBG_UTIL
287  m_nContinue( 0 ),
288 #endif
289  m_eParaAdjust( SvxAdjust::End ),
290  m_bDocInitalized( false ),
291  m_bSetModEnabled( false ),
292  m_bInFloatingFrame( false ),
293  m_bInField( false ),
294  m_bCallNextToken( false ),
295  m_bIgnoreRawData( false ),
296  m_bLBEntrySelected ( false ),
297  m_bTAIgnoreNewPara ( false ),
298  m_bFixMarqueeWidth ( false ),
299  m_bNoParSpace( false ),
300  m_bInNoEmbed( false ),
301  m_bInTitle( false ),
302  m_bUpdateDocStat( false ),
303  m_bFixSelectWidth( false ),
304  m_bTextArea( false ),
305  m_bSelect( false ),
306  m_bInFootEndNoteAnchor( false ),
307  m_bInFootEndNoteSymbol( false ),
308  m_bIgnoreHTMLComments( bNoHTMLComments ),
309  m_bRemoveHidden( false ),
310  m_bBodySeen( false ),
311  m_bReadingHeaderOrFooter( false ),
312  m_bNotifyMacroEventRead( false ),
313  m_isInTableStructure(false),
314  m_nTableDepth( 0 ),
315  m_pTempViewFrame(nullptr)
316 {
317  // If requested explicitly, then force ignoring of comments (don't create postits for them).
318  if (!utl::ConfigManager::IsFuzzing() && officecfg::Office::Writer::Filter::Import::HTML::IgnoreComments::get())
319  m_bIgnoreHTMLComments = true;
320 
321  m_nEventId = nullptr;
322  m_bUpperSpace = m_bViewCreated = m_bChkJumpMark = false;
323 
324  m_eScriptLang = HTMLScriptLanguage::Unknown;
325 
326  rCursor.DeleteMark();
327  m_pPam = &rCursor; // re-use existing cursor: avoids spurious ~SwIndexReg assert
328  memset(m_xAttrTab.get(), 0, sizeof(HTMLAttrTable));
329 
330  // Read the font sizes 1-7 from the INI file
331  SvxHtmlOptions& rHtmlOptions = SvxHtmlOptions::Get();
332  m_aFontHeights[0] = rHtmlOptions.GetFontSize( 0 ) * 20;
333  m_aFontHeights[1] = rHtmlOptions.GetFontSize( 1 ) * 20;
334  m_aFontHeights[2] = rHtmlOptions.GetFontSize( 2 ) * 20;
335  m_aFontHeights[3] = rHtmlOptions.GetFontSize( 3 ) * 20;
336  m_aFontHeights[4] = rHtmlOptions.GetFontSize( 4 ) * 20;
337  m_aFontHeights[5] = rHtmlOptions.GetFontSize( 5 ) * 20;
338  m_aFontHeights[6] = rHtmlOptions.GetFontSize( 6 ) * 20;
339 
340  m_bKeepUnknown = rHtmlOptions.IsImportUnknown();
341 
342  if(bReadNewDoc)
343  {
344  //CJK has different defaults, so a different object should be used for this
345  //RES_CHARTR_CJK_FONTSIZE is a valid value
346  SvxFontHeightItem aFontHeight(m_aFontHeights[2], 100, RES_CHRATR_FONTSIZE);
347  m_xDoc->SetDefault( aFontHeight );
348  SvxFontHeightItem aFontHeightCJK(m_aFontHeights[2], 100, RES_CHRATR_CJK_FONTSIZE);
349  m_xDoc->SetDefault( aFontHeightCJK );
350  SvxFontHeightItem aFontHeightCTL(m_aFontHeights[2], 100, RES_CHRATR_CTL_FONTSIZE);
351  m_xDoc->SetDefault( aFontHeightCTL );
352 
353  // #i18732# - adjust default of option 'FollowTextFlow'
354  // TODO: not sure what the appropriate default for HTML should be?
355  m_xDoc->SetDefault( SwFormatFollowTextFlow(true) );
356  }
357 
358  // Change to HTML mode during the import, so that the right styles are created
359  m_bOldIsHTMLMode = m_xDoc->getIDocumentSettingAccess().get(DocumentSettingId::HTML_MODE);
360  m_xDoc->getIDocumentSettingAccess().set(DocumentSettingId::HTML_MODE, true);
361 
362  m_pCSS1Parser.reset(new SwCSS1Parser(m_xDoc.get(), *this, m_aFontHeights, m_sBaseURL, IsNewDoc()));
363  m_pCSS1Parser->SetIgnoreFontFamily( rHtmlOptions.IsIgnoreFontFamily() );
364 
365  if( bReadUTF8 )
366  {
367  SetSrcEncoding( RTL_TEXTENCODING_UTF8 );
368  }
369  else
370  {
371  SwDocShell *pDocSh = m_xDoc->GetDocShell();
372  SvKeyValueIterator *pHeaderAttrs =
373  pDocSh->GetHeaderAttributes();
374  if( pHeaderAttrs )
375  SetEncodingByHTTPHeader( pHeaderAttrs );
376  }
377  m_pCSS1Parser->SetDfltEncoding( osl_getThreadTextEncoding() );
378 
379  SwDocShell* pDocSh = m_xDoc->GetDocShell();
380  if( pDocSh )
381  {
382  m_bViewCreated = true; // not, load synchronous
383 
384  // a jump mark is present
385 
386  if( pMed )
387  {
388  m_sJmpMark = pMed->GetURLObject().GetMark();
389  if( !m_sJmpMark.isEmpty() )
390  {
391  m_eJumpTo = JumpToMarks::Mark;
392  sal_Int32 nLastPos = m_sJmpMark.lastIndexOf( cMarkSeparator );
393  sal_Int32 nPos = nLastPos != -1 ? nLastPos : 0;
394 
395  OUString sCmp;
396  if (nPos)
397  {
398  sCmp = m_sJmpMark.copy(nPos + 1).replaceAll(" ", "");
399  }
400 
401  if( !sCmp.isEmpty() )
402  {
403  sCmp = sCmp.toAsciiLowerCase();
404  if( sCmp == "region" )
405  m_eJumpTo = JumpToMarks::Region;
406  else if( sCmp == "table" )
407  m_eJumpTo = JumpToMarks::Table;
408  else if( sCmp == "graphic" )
409  m_eJumpTo = JumpToMarks::Graphic;
410  else if( sCmp == "outline" ||
411  sCmp == "text" ||
412  sCmp == "frame" )
413  m_eJumpTo = JumpToMarks::NONE; // this is nothing valid!
414  else
415  // otherwise this is a normal (book)mark
416  nPos = -1;
417  }
418  else
419  nPos = -1;
420 
421  if( nPos != -1 )
422  m_sJmpMark = m_sJmpMark.copy( 0, nPos );
423  if( m_sJmpMark.isEmpty() )
424  m_eJumpTo = JumpToMarks::NONE;
425  }
426  }
427  }
428 
429  if (!rNamespace.isEmpty())
430  {
431  SetNamespace(rNamespace);
432  m_bXHTML = true;
433  if (rNamespace == "reqif-xhtml")
434  m_bReqIF = true;
435  }
436 
437  // Extract load parameters which are specific to this filter.
438  if (!pMed)
439  {
440  return;
441  }
442 
443  comphelper::SequenceAsHashMap aLoadMap(pMed->GetArgs());
444  auto it = aLoadMap.find("AllowedRTFOLEMimeTypes");
445  if (it == aLoadMap.end())
446  {
447  return;
448  }
449 
450  uno::Sequence<OUString> aTypes;
451  it->second >>= aTypes;
452  m_aAllowedRTFOLEMimeTypes = comphelper::sequenceToContainer<std::set<OUString>>(aTypes);
453 }
454 
455 SwHTMLParser::~SwHTMLParser()
456 {
457 #ifdef DBG_UTIL
458  OSL_ENSURE( !m_nContinue, "DTOR in continue!" );
459 #endif
460 
461  OSL_ENSURE(m_aContexts.empty(), "There are still contexts on the stack");
462  OSL_ENSURE(!m_nContextStMin, "There are protected contexts");
463  m_nContextStMin = 0;
464  while (!m_aContexts.empty())
465  {
466  std::unique_ptr<HTMLAttrContext> xCntxt(PopContext());
467  ClearContext(xCntxt.get());
468  }
469 
470  bool bAsync = m_xDoc->IsInLoadAsynchron();
471  m_xDoc->SetInLoadAsynchron( false );
472  m_xDoc->getIDocumentSettingAccess().set(DocumentSettingId::HTML_MODE, m_bOldIsHTMLMode);
473 
474  if( m_xDoc->GetDocShell() && m_nEventId )
475  Application::RemoveUserEvent( m_nEventId );
476 
477  // the DocumentDetected maybe can delete the DocShells, therefore fetch again
478  if( m_xDoc->GetDocShell() )
479  {
480  // update linked sections
481  sal_uInt16 nLinkMode = m_xDoc->getIDocumentSettingAccess().getLinkUpdateMode( true );
482  if( nLinkMode != NEVER && bAsync &&
483  SfxObjectCreateMode::INTERNAL!=m_xDoc->GetDocShell()->GetCreateMode() )
484  m_xDoc->getIDocumentLinksAdministration().GetLinkManager().UpdateAllLinks( nLinkMode == MANUAL, false, nullptr );
485 
486  if ( m_xDoc->GetDocShell()->IsLoading() )
487  {
488  // #i59688#
489  m_xDoc->GetDocShell()->LoadingFinished();
490  }
491  }
492 
493  delete m_pSttNdIdx;
494 
495  if( !m_aSetAttrTab.empty() )
496  {
497  OSL_ENSURE( m_aSetAttrTab.empty(),"There are still attributes on the stack" );
498  for ( const auto& rpAttr : m_aSetAttrTab )
499  delete rpAttr;
500  m_aSetAttrTab.clear();
501  }
502 
503  m_pCSS1Parser.reset();
504  m_pNumRuleInfo.reset();
505  DeleteFormImpl();
506  m_pFootEndNoteImpl.reset();
507 
508  OSL_ENSURE(!m_xTable, "It exists still an open table");
509  m_pImageMaps.reset();
510 
511  OSL_ENSURE( m_vPendingStack.empty(),
512  "SwHTMLParser::~SwHTMLParser: Here should not be Pending-Stack anymore" );
513  m_vPendingStack.clear();
514 
515  m_xDoc.clear();
516 
517  if ( m_pTempViewFrame )
518  {
519  m_pTempViewFrame->DoClose();
520 
521  // the temporary view frame is hidden, so the hidden flag might need to be removed
522  if ( m_bRemoveHidden && m_xDoc.is() && m_xDoc->GetDocShell() && m_xDoc->GetDocShell()->GetMedium() )
523  m_xDoc->GetDocShell()->GetMedium()->GetItemSet()->ClearItem( SID_HIDDEN );
524  }
525 }
526 
527 IMPL_LINK_NOARG( SwHTMLParser, AsyncCallback, void*, void )
528 {
529  m_nEventId=nullptr;
530 
531  // #i47907# - If the document has already been destructed,
532  // the parser should be aware of this:
533  if( ( m_xDoc->GetDocShell() && m_xDoc->GetDocShell()->IsAbortingImport() )
534  || 1 == m_xDoc->getReferenceCount() )
535  {
536  // was the import aborted by SFX?
537  eState = SvParserState::Error;
538  }
539 
540  GetAsynchCallLink().Call(nullptr);
541 }
542 
543 SvParserState SwHTMLParser::CallParser()
544 {
545  // create temporary index on position 0, so it won't be moved!
546  m_pSttNdIdx = new SwNodeIndex( m_xDoc->GetNodes() );
547  if( !IsNewDoc() ) // insert into existing document ?
548  {
549  const SwPosition* pPos = m_pPam->GetPoint();
550 
551  m_xDoc->getIDocumentContentOperations().SplitNode( *pPos, false );
552 
553  *m_pSttNdIdx = pPos->nNode.GetIndex()-1;
554  m_xDoc->getIDocumentContentOperations().SplitNode( *pPos, false );
555 
556  SwPaM aInsertionRangePam( *pPos );
557 
558  m_pPam->Move( fnMoveBackward );
559 
560  // split any redline over the insertion point
561  aInsertionRangePam.SetMark();
562  *aInsertionRangePam.GetPoint() = *m_pPam->GetPoint();
563  aInsertionRangePam.Move( fnMoveBackward );
564  m_xDoc->getIDocumentRedlineAccess().SplitRedline( aInsertionRangePam );
565 
566  m_xDoc->SetTextFormatColl( *m_pPam,
567  m_pCSS1Parser->GetTextCollFromPool( RES_POOLCOLL_STANDARD ));
568  }
569 
570  if( GetMedium() )
571  {
572  if( !m_bViewCreated )
573  {
574  m_nEventId = Application::PostUserEvent( LINK( this, SwHTMLParser, AsyncCallback ) );
575  }
576  else
577  {
578  m_bViewCreated = true;
579  m_nEventId = nullptr;
580  }
581  }
582  else // show progress bar
583  {
584  rInput.Seek(STREAM_SEEK_TO_END);
585  rInput.ResetError();
586 
587  m_xProgress.reset(new ImportProgress(m_xDoc->GetDocShell(), 0, rInput.Tell()));
588 
589  rInput.Seek(STREAM_SEEK_TO_BEGIN);
590  rInput.ResetError();
591  }
592 
593  StartListening(m_xDoc->GetPageDesc( 0 ).GetNotifier());
594 
595  SvParserState eRet = HTMLParser::CallParser();
596  return eRet;
597 }
598 
599 bool SwHTMLParser::CanRemoveNode(sal_uLong nNodeIdx) const
600 {
601  const SwNode *pPrev = m_xDoc->GetNodes()[nNodeIdx - 1];
602  return pPrev->IsContentNode() || (pPrev->IsEndNode() && pPrev->StartOfSectionNode()->IsSectionNode());
603 }
604 
605 void SwHTMLParser::Continue( HtmlTokenId nToken )
606 {
607 #ifdef DBG_UTIL
608  OSL_ENSURE(!m_nContinue, "Continue in Continue - not supposed to happen");
609  m_nContinue++;
610 #endif
611 
612  // When the import (of SFX) is aborted, an error will be set but
613  // we still continue, so that we clean up properly.
614  OSL_ENSURE( SvParserState::Error!=eState,
615  "SwHTMLParser::Continue: already set an error" );
616  if( m_xDoc->GetDocShell() && m_xDoc->GetDocShell()->IsAbortingImport() )
617  eState = SvParserState::Error;
618 
619  // Fetch SwViewShell from document, save it and set as current.
620  SwViewShell *pInitVSh = CallStartAction();
621 
622  if( SvParserState::Error != eState && GetMedium() && !m_bViewCreated )
623  {
624  // At first call first return, show document and wait for callback
625  // time.
626  // At this point in CallParser only one digit was read and
627  // a SaveState(0) was called.
628  eState = SvParserState::Pending;
629  m_bViewCreated = true;
630  m_xDoc->SetInLoadAsynchron( true );
631 
632 #ifdef DBG_UTIL
633  m_nContinue--;
634 #endif
635 
636  return;
637  }
638 
639  m_bSetModEnabled = false;
640  if( m_xDoc->GetDocShell() )
641  {
642  m_bSetModEnabled = m_xDoc->GetDocShell()->IsEnableSetModified();
643  if( m_bSetModEnabled )
644  {
645  m_xDoc->GetDocShell()->EnableSetModified( false );
646  }
647  }
648 
649  // during import don't call OLE-Modified
650  Link<bool,void> aOLELink( m_xDoc->GetOle2Link() );
651  m_xDoc->SetOle2Link( Link<bool,void>() );
652 
653  bool bModified = m_xDoc->getIDocumentState().IsModified();
654  bool const bWasUndo = m_xDoc->GetIDocumentUndoRedo().DoesUndo();
655  m_xDoc->GetIDocumentUndoRedo().DoUndo(false);
656 
657  // When the import will be aborted, don't call Continue anymore.
658  // If a Pending-Stack exists make sure the stack is ended with a call
659  // of NextToken.
660  if( SvParserState::Error == eState )
661  {
662  OSL_ENSURE( m_vPendingStack.empty() || m_vPendingStack.back().nToken != HtmlTokenId::NONE,
663  "SwHTMLParser::Continue: Pending-Stack without Token" );
664  if( !m_vPendingStack.empty() && m_vPendingStack.back().nToken != HtmlTokenId::NONE )
665  NextToken( m_vPendingStack.back().nToken );
666  OSL_ENSURE( m_vPendingStack.empty(),
667  "SwHTMLParser::Continue: There is again a Pending-Stack" );
668  }
669  else
670  {
671  HTMLParser::Continue( !m_vPendingStack.empty() ? m_vPendingStack.back().nToken : nToken );
672  }
673 
674  // disable progress bar again
675  m_xProgress.reset();
676 
677  bool bLFStripped = false;
678  if( SvParserState::Pending != GetStatus() )
679  {
680  // set the last attributes yet
681  {
682  if( !m_aScriptSource.isEmpty() )
683  {
684  SwScriptFieldType *pType =
685  static_cast<SwScriptFieldType*>(m_xDoc->getIDocumentFieldsAccess().GetSysFieldType( SwFieldIds::Script ));
686 
687  SwScriptField aField( pType, m_aScriptType, m_aScriptSource,
688  false );
689  InsertAttr( SwFormatField( aField ), false );
690  }
691 
692  if( m_pAppletImpl )
693  {
694  if( m_pAppletImpl->GetApplet().is() )
695  EndApplet();
696  else
697  EndObject();
698  }
699 
700  // maybe remove an existing LF after the last paragraph
701  if( IsNewDoc() )
702  bLFStripped = StripTrailingLF() > 0;
703 
704  // close still open numbering
705  while( GetNumInfo().GetNumRule() )
706  EndNumberBulletList();
707 
708  OSL_ENSURE( !m_nContextStMin, "There are protected contexts" );
709  // try this twice, first normally to let m_nContextStMin decrease
710  // naturally and get contexts popped in desired order, and if that
711  // fails force it
712  for (int i = 0; i < 2; ++i)
713  {
714  while (m_aContexts.size() > m_nContextStMin)
715  {
716  std::unique_ptr<HTMLAttrContext> xCntxt(PopContext());
717  if (xCntxt)
718  EndContext(xCntxt.get());
719  }
720  if (!m_nContextStMin)
721  break;
722  OSL_ENSURE(!m_nContextStMin, "There are still protected contexts");
723  m_nContextStMin = 0;
724  }
725 
726  m_aParaAttrs.clear();
727 
728  SetAttr( false );
729 
730  // set the first delayed styles
731  m_pCSS1Parser->SetDelayedStyles();
732  }
733 
734  // again correct the start
735  if( !IsNewDoc() && m_pSttNdIdx->GetIndex() )
736  {
737  SwTextNode* pTextNode = m_pSttNdIdx->GetNode().GetTextNode();
738  SwNodeIndex aNxtIdx( *m_pSttNdIdx );
739  if( pTextNode && pTextNode->CanJoinNext( &aNxtIdx ))
740  {
741  const sal_Int32 nStt = pTextNode->GetText().getLength();
742  // when the cursor is still in the node, then set him at the end
743  if( m_pPam->GetPoint()->nNode == aNxtIdx )
744  {
745  m_pPam->GetPoint()->nNode = *m_pSttNdIdx;
746  m_pPam->GetPoint()->nContent.Assign( pTextNode, nStt );
747  }
748 
749 #if OSL_DEBUG_LEVEL > 0
750 // !!! shouldn't be possible, or ??
751  OSL_ENSURE( m_pSttNdIdx->GetIndex()+1 != m_pPam->GetBound().nNode.GetIndex(),
752  "Pam.Bound1 is still in the node" );
753  OSL_ENSURE( m_pSttNdIdx->GetIndex()+1 != m_pPam->GetBound( false ).nNode.GetIndex(),
754  "Pam.Bound2 is still in the node" );
755 
756  if( m_pSttNdIdx->GetIndex()+1 == m_pPam->GetBound().nNode.GetIndex() )
757  {
758  const sal_Int32 nCntPos = m_pPam->GetBound().nContent.GetIndex();
759  m_pPam->GetBound().nContent.Assign( pTextNode,
760  pTextNode->GetText().getLength() + nCntPos );
761  }
762  if( m_pSttNdIdx->GetIndex()+1 == m_pPam->GetBound( false ).nNode.GetIndex() )
763  {
764  const sal_Int32 nCntPos = m_pPam->GetBound( false ).nContent.GetIndex();
765  m_pPam->GetBound( false ).nContent.Assign( pTextNode,
766  pTextNode->GetText().getLength() + nCntPos );
767  }
768 #endif
769  // Keep character attribute!
770  SwTextNode* pDelNd = aNxtIdx.GetNode().GetTextNode();
771  if (pTextNode->GetText().getLength())
772  pDelNd->FormatToTextAttr( pTextNode );
773  else
774  pTextNode->ChgFormatColl( pDelNd->GetTextColl() );
775  pTextNode->JoinNext();
776  }
777  }
778  }
779 
780  if( SvParserState::Accepted == eState )
781  {
782  if( m_nMissingImgMaps )
783  {
784  // Some Image-Map relations are still missing.
785  // Maybe now the Image-Maps are there?
786  ConnectImageMaps();
787  }
788 
789  // now remove the last useless paragraph
790  SwPosition* pPos = m_pPam->GetPoint();
791  if( !pPos->nContent.GetIndex() && !bLFStripped )
792  {
793  SwTextNode* pCurrentNd;
794  sal_uLong nNodeIdx = pPos->nNode.GetIndex();
795 
796  bool bHasFlysOrMarks =
797  HasCurrentParaFlys() || HasCurrentParaBookmarks( true );
798 
799  if( IsNewDoc() )
800  {
801  if (!m_pPam->GetPoint()->nContent.GetIndex() && CanRemoveNode(nNodeIdx))
802  {
803  SwContentNode* pCNd = m_pPam->GetContentNode();
804  if( pCNd && pCNd->StartOfSectionIndex()+2 <
805  pCNd->EndOfSectionIndex() && !bHasFlysOrMarks )
806  {
807  SwViewShell *pVSh = CheckActionViewShell();
808  SwCursorShell *pCursorSh = dynamic_cast<SwCursorShell *>( pVSh );
809  if( pCursorSh &&
810  pCursorSh->GetCursor()->GetPoint()
811  ->nNode.GetIndex() == nNodeIdx )
812  {
813  pCursorSh->MovePara(GoPrevPara, fnParaEnd );
814  pCursorSh->SetMark();
815  pCursorSh->ClearMark();
816  }
817  m_pPam->GetBound().nContent.Assign( nullptr, 0 );
818  m_pPam->GetBound(false).nContent.Assign( nullptr, 0 );
819  m_xDoc->GetNodes().Delete( m_pPam->GetPoint()->nNode );
820  }
821  }
822  }
823  else if( nullptr != ( pCurrentNd = m_xDoc->GetNodes()[ nNodeIdx ]->GetTextNode()) && !bHasFlysOrMarks )
824  {
825  if( pCurrentNd->CanJoinNext( &pPos->nNode ))
826  {
827  SwTextNode* pNextNd = pPos->nNode.GetNode().GetTextNode();
828  pPos->nContent.Assign( pNextNd, 0 );
829  m_pPam->SetMark(); m_pPam->DeleteMark();
830  pNextNd->JoinPrev();
831  }
832  else if (pCurrentNd->GetText().isEmpty())
833  {
834  pPos->nContent.Assign( nullptr, 0 );
835  m_pPam->SetMark(); m_pPam->DeleteMark();
836  m_xDoc->GetNodes().Delete( pPos->nNode );
837  m_pPam->Move( fnMoveBackward );
838  }
839  }
840  }
841 
842  // annul the SplitNode from the beginning
843  else if( !IsNewDoc() )
844  {
845  if( pPos->nContent.GetIndex() ) // then there was no <p> at the end
846  m_pPam->Move( fnMoveForward, GoInNode ); // therefore to the next
847  SwTextNode* pTextNode = pPos->nNode.GetNode().GetTextNode();
848  SwNodeIndex aPrvIdx( pPos->nNode );
849  if( pTextNode && pTextNode->CanJoinPrev( &aPrvIdx ) &&
850  *m_pSttNdIdx <= aPrvIdx )
851  {
852  // Normally here should take place a JoinNext, but all cursors and
853  // so are registered in pTextNode, so that it MUST remain.
854 
855  // Convert paragraph to character attribute, from Prev adopt
856  // the paragraph attribute and the template!
857  SwTextNode* pPrev = aPrvIdx.GetNode().GetTextNode();
858  pTextNode->ChgFormatColl( pPrev->GetTextColl() );
859  pTextNode->FormatToTextAttr( pPrev );
860  pTextNode->ResetAllAttr();
861 
862  if( pPrev->HasSwAttrSet() )
863  pTextNode->SetAttr( *pPrev->GetpSwAttrSet() );
864 
865  if( &m_pPam->GetBound().nNode.GetNode() == pPrev )
866  m_pPam->GetBound().nContent.Assign( pTextNode, 0 );
867  if( &m_pPam->GetBound(false).nNode.GetNode() == pPrev )
868  m_pPam->GetBound(false).nContent.Assign( pTextNode, 0 );
869 
870  pTextNode->JoinPrev();
871  }
872  }
873 
874  // adjust AutoLoad in DocumentProperties
875  if (!utl::ConfigManager::IsFuzzing() && IsNewDoc())
876  {
877  SwDocShell *pDocShell(m_xDoc->GetDocShell());
878  OSL_ENSURE(pDocShell, "no SwDocShell");
879  if (pDocShell) {
880  uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
881  pDocShell->GetModel(), uno::UNO_QUERY_THROW);
882  uno::Reference<document::XDocumentProperties> xDocProps(
883  xDPS->getDocumentProperties());
884  OSL_ENSURE(xDocProps.is(), "DocumentProperties is null");
885  if ( xDocProps.is() && (xDocProps->getAutoloadSecs() > 0) &&
886  (xDocProps->getAutoloadURL().isEmpty()) )
887  {
888  xDocProps->setAutoloadURL(m_aPathToFile);
889  }
890  }
891  }
892 
893  if( m_bUpdateDocStat )
894  {
895  m_xDoc->getIDocumentStatistics().UpdateDocStat( false, true );
896  }
897  }
898 
899  if( SvParserState::Pending != GetStatus() )
900  {
901  delete m_pSttNdIdx;
902  m_pSttNdIdx = nullptr;
903  }
904 
905  // should the parser be the last one who hold the document, then nothing
906  // has to be done anymore, document will be destroyed shortly!
907  if( 1 < m_xDoc->getReferenceCount() )
908  {
909  if( bWasUndo )
910  {
911  m_xDoc->GetIDocumentUndoRedo().DelAllUndoObj();
912  m_xDoc->GetIDocumentUndoRedo().DoUndo(true);
913  }
914  else if( !pInitVSh )
915  {
916  // When at the beginning of Continue no Shell was available,
917  // it's possible in the meantime one was created.
918  // In that case the bWasUndo flag is wrong and we must
919  // enable Undo.
920  SwViewShell *pTmpVSh = CheckActionViewShell();
921  if( pTmpVSh )
922  {
923  m_xDoc->GetIDocumentUndoRedo().DoUndo(true);
924  }
925  }
926 
927  m_xDoc->SetOle2Link( aOLELink );
928  if( !bModified )
929  m_xDoc->getIDocumentState().ResetModified();
930  if( m_bSetModEnabled && m_xDoc->GetDocShell() )
931  {
932  m_xDoc->GetDocShell()->EnableSetModified();
933  m_bSetModEnabled = false; // this is unnecessary here
934  }
935  }
936 
937  // When the Document-SwVievShell still exists and an Action is open
938  // (doesn't have to be by abort), end the Action, disconnect from Shell
939  // and finally reconstruct the old Shell.
940  CallEndAction( true );
941 
942 #ifdef DBG_UTIL
943  m_nContinue--;
944 #endif
945 }
946 
947 void SwHTMLParser::Notify(const SfxHint& rHint)
948 {
949  if(rHint.GetId() == SfxHintId::Dying)
950  {
951  EndListeningAll();
952  ReleaseRef();
953  }
954 }
955 
956 void SwHTMLParser::DocumentDetected()
957 {
958  OSL_ENSURE( !m_bDocInitalized, "DocumentDetected called multiple times" );
959  m_bDocInitalized = true;
960  if( IsNewDoc() )
961  {
962  if( IsInHeader() )
963  FinishHeader();
964 
965  CallEndAction( true );
966 
967  m_xDoc->GetIDocumentUndoRedo().DoUndo(false);
968  // For DocumentDetected in general a SwViewShell is created.
969  // But it also can be created later, in case the UI is captured.
970  CallStartAction();
971  }
972 }
973 
974 // is called for every token that is recognised in CallParser
975 void SwHTMLParser::NextToken( HtmlTokenId nToken )
976 {
977  if( ( m_xDoc->GetDocShell() && m_xDoc->GetDocShell()->IsAbortingImport() )
978  || 1 == m_xDoc->getReferenceCount() )
979  {
980  // Was the import cancelled by SFX? If a pending stack
981  // exists, clean it.
982  eState = SvParserState::Error;
983  OSL_ENSURE( m_vPendingStack.empty() || m_vPendingStack.back().nToken != HtmlTokenId::NONE,
984  "SwHTMLParser::NextToken: Pending-Stack without token" );
985  if( 1 == m_xDoc->getReferenceCount() || m_vPendingStack.empty() )
986  return ;
987  }
988 
989 #if OSL_DEBUG_LEVEL > 0
990  if( !m_vPendingStack.empty() )
991  {
992  switch( nToken )
993  {
994  // tables are read by recursive method calls
995  case HtmlTokenId::TABLE_ON:
996  // For CSS declarations we might have to wait
997  // for a file download to finish
998  case HtmlTokenId::LINK:
999  // For controls we might have to set the size.
1000  case HtmlTokenId::INPUT:
1001  case HtmlTokenId::TEXTAREA_ON:
1002  case HtmlTokenId::SELECT_ON:
1003  case HtmlTokenId::SELECT_OFF:
1004  break;
1005  default:
1006  OSL_ENSURE( m_vPendingStack.empty(), "Unknown token for Pending-Stack" );
1007  break;
1008  }
1009  }
1010 #endif
1011 
1012  // The following special cases have to be treated before the
1013  // filter detection, because Netscape doesn't reference the content
1014  // of the title for filter detection either.
1015  if( m_vPendingStack.empty() )
1016  {
1017  if( m_bInTitle )
1018  {
1019  switch( nToken )
1020  {
1021  case HtmlTokenId::TITLE_OFF:
1022  {
1023  OUString sTitle = m_sTitle.makeStringAndClear();
1024  if( IsNewDoc() && !sTitle.isEmpty() )
1025  {
1026  if( m_xDoc->GetDocShell() ) {
1027  uno::Reference<document::XDocumentPropertiesSupplier>
1028  xDPS(m_xDoc->GetDocShell()->GetModel(),
1029  uno::UNO_QUERY_THROW);
1030  uno::Reference<document::XDocumentProperties> xDocProps(
1031  xDPS->getDocumentProperties());
1032  OSL_ENSURE(xDocProps.is(), "no DocumentProperties");
1033  if (xDocProps.is()) {
1034  xDocProps->setTitle(sTitle);
1035  }
1036 
1037  m_xDoc->GetDocShell()->SetTitle(sTitle);
1038  }
1039  }
1040  m_bInTitle = false;
1041  break;
1042  }
1043 
1044  case HtmlTokenId::NONBREAKSPACE:
1045  m_sTitle.append(" ");
1046  break;
1047 
1048  case HtmlTokenId::SOFTHYPH:
1049  m_sTitle.append("-");
1050  break;
1051 
1052  case HtmlTokenId::TEXTTOKEN:
1053  m_sTitle.append(aToken);
1054  break;
1055 
1056  default:
1057  m_sTitle.append("<");
1058  if( (nToken >= HtmlTokenId::ONOFF_START) && isOffToken(nToken) )
1059  m_sTitle.append("/");
1060  m_sTitle.append(sSaveToken);
1061  if( !aToken.isEmpty() )
1062  {
1063  m_sTitle.append(" ");
1064  m_sTitle.append(aToken);
1065  }
1066  m_sTitle.append(">");
1067  break;
1068  }
1069 
1070  return;
1071  }
1072  }
1073 
1074  // Find out what type of document it is if we don't know already.
1075  // For Controls this has to be finished before the control is inserted
1076  // because for inserting a View is needed.
1077  if( !m_bDocInitalized )
1078  DocumentDetected();
1079 
1080  bool bGetIDOption = false, bInsertUnknown = false;
1081  bool bUpperSpaceSave = m_bUpperSpace;
1082  m_bUpperSpace = false;
1083 
1084  // The following special cases may or have to be treated after the
1085  // filter detection
1086  if( m_vPendingStack.empty() )
1087  {
1088  if( m_bInFloatingFrame )
1089  {
1090  // <SCRIPT> is ignored here (from us), because it is ignored in
1091  // Applets as well
1092  if( HtmlTokenId::IFRAME_OFF == nToken )
1093  {
1094  m_bCallNextToken = false;
1095  m_bInFloatingFrame = false;
1096  }
1097 
1098  return;
1099  }
1100  else if( m_bInNoEmbed )
1101  {
1102  switch( nToken )
1103  {
1104  case HtmlTokenId::NOEMBED_OFF:
1105  m_aContents = convertLineEnd(m_aContents, GetSystemLineEnd());
1106  InsertComment( m_aContents, OOO_STRING_SVTOOLS_HTML_noembed );
1107  m_aContents.clear();
1108  m_bCallNextToken = false;
1109  m_bInNoEmbed = false;
1110  break;
1111 
1112  case HtmlTokenId::RAWDATA:
1113  InsertCommentText( OOO_STRING_SVTOOLS_HTML_noembed );
1114  break;
1115 
1116  default:
1117  OSL_ENSURE( false, "SwHTMLParser::NextToken: invalid tag" );
1118  break;
1119  }
1120 
1121  return;
1122  }
1123  else if( m_pAppletImpl )
1124  {
1125  // in an applet only <PARAM> tags and the </APPLET> tag
1126  // are of interest for us (for the moment)
1127  // <SCRIPT> is ignored here (from Netscape)!
1128 
1129  switch( nToken )
1130  {
1131  case HtmlTokenId::APPLET_OFF:
1132  m_bCallNextToken = false;
1133  EndApplet();
1134  break;
1135  case HtmlTokenId::OBJECT_OFF:
1136  m_bCallNextToken = false;
1137  EndObject();
1138  break;
1139  case HtmlTokenId::PARAM:
1140  InsertParam();
1141  break;
1142  default: break;
1143  }
1144 
1145  return;
1146  }
1147  else if( m_bTextArea )
1148  {
1149  // in a TextArea everything up to </TEXTAREA> is inserted as text.
1150  // <SCRIPT> is ignored here (from Netscape)!
1151 
1152  switch( nToken )
1153  {
1154  case HtmlTokenId::TEXTAREA_OFF:
1155  m_bCallNextToken = false;
1156  EndTextArea();
1157  break;
1158 
1159  default:
1160  InsertTextAreaText( nToken );
1161  break;
1162  }
1163 
1164  return;
1165  }
1166  else if( m_bSelect )
1167  {
1168  // HAS to be treated after bNoScript!
1169  switch( nToken )
1170  {
1171  case HtmlTokenId::SELECT_OFF:
1172  m_bCallNextToken = false;
1173  EndSelect();
1174  return;
1175 
1176  case HtmlTokenId::OPTION:
1177  InsertSelectOption();
1178  return;
1179 
1180  case HtmlTokenId::TEXTTOKEN:
1181  InsertSelectText();
1182  return;
1183 
1184  case HtmlTokenId::INPUT:
1185  case HtmlTokenId::SCRIPT_ON:
1186  case HtmlTokenId::SCRIPT_OFF:
1187  case HtmlTokenId::NOSCRIPT_ON:
1188  case HtmlTokenId::NOSCRIPT_OFF:
1189  case HtmlTokenId::RAWDATA:
1190  // treat in normal switch
1191  break;
1192 
1193  default:
1194  // ignore
1195  return;
1196  }
1197  }
1198  else if( m_pMarquee )
1199  {
1200  // in a TextArea everything up to </TEXTAREA> is inserted as text.
1201  // The <SCRIPT> tags are ignored from MS-IE, we ignore the whole
1202  // script.
1203  switch( nToken )
1204  {
1205  case HtmlTokenId::MARQUEE_OFF:
1206  m_bCallNextToken = false;
1207  EndMarquee();
1208  break;
1209 
1210  case HtmlTokenId::TEXTTOKEN:
1211  InsertMarqueeText();
1212  break;
1213  default: break;
1214  }
1215 
1216  return;
1217  }
1218  else if( m_bInField )
1219  {
1220  switch( nToken )
1221  {
1222  case HtmlTokenId::SDFIELD_OFF:
1223  m_bCallNextToken = false;
1224  EndField();
1225  break;
1226 
1227  case HtmlTokenId::TEXTTOKEN:
1228  InsertFieldText();
1229  break;
1230  default: break;
1231  }
1232 
1233  return;
1234  }
1235  else if( m_bInFootEndNoteAnchor || m_bInFootEndNoteSymbol )
1236  {
1237  switch( nToken )
1238  {
1239  case HtmlTokenId::ANCHOR_OFF:
1240  EndAnchor();
1241  m_bCallNextToken = false;
1242  break;
1243 
1244  case HtmlTokenId::TEXTTOKEN:
1245  InsertFootEndNoteText();
1246  break;
1247  default: break;
1248  }
1249  return;
1250  }
1251  else if( !m_aUnknownToken.isEmpty() )
1252  {
1253  // Paste content of unknown tags.
1254  // (but surely if we are not in the header section) fdo#36080 fdo#34666
1255  if (!aToken.isEmpty() && !IsInHeader() )
1256  {
1257  if( !m_bDocInitalized )
1258  DocumentDetected();
1259  m_xDoc->getIDocumentContentOperations().InsertString( *m_pPam, aToken );
1260 
1261  // if there are temporary paragraph attributes and the
1262  // paragraph isn't empty then the paragraph attributes
1263  // are final.
1264  m_aParaAttrs.clear();
1265 
1266  SetAttr();
1267  }
1268 
1269  // Unknown token in the header are only closed by a matching
1270  // end-token, </HEAD> or <BODY>. Text inside is ignored.
1271  switch( nToken )
1272  {
1273  case HtmlTokenId::UNKNOWNCONTROL_OFF:
1274  if( m_aUnknownToken != sSaveToken )
1275  return;
1276  [[fallthrough]];
1277  case HtmlTokenId::FRAMESET_ON:
1278  case HtmlTokenId::HEAD_OFF:
1279  case HtmlTokenId::BODY_ON:
1280  case HtmlTokenId::IMAGE: // Don't know why Netscape acts this way.
1281  m_aUnknownToken.clear();
1282  break;
1283  case HtmlTokenId::TEXTTOKEN:
1284  return;
1285  default:
1286  m_aUnknownToken.clear();
1287  break;
1288  }
1289  }
1290  }
1291 
1292  switch( nToken )
1293  {
1294  case HtmlTokenId::BODY_ON:
1295  if (!m_bBodySeen)
1296  {
1297  m_bBodySeen = true;
1298  if( !m_aStyleSource.isEmpty() )
1299  {
1300  m_pCSS1Parser->ParseStyleSheet( m_aStyleSource );
1301  m_aStyleSource.clear();
1302  }
1303  if( IsNewDoc() )
1304  {
1305  InsertBodyOptions();
1306  // If there is a template for the first or the right page,
1307  // it is set here.
1308  const SwPageDesc *pPageDesc = nullptr;
1309  if( m_pCSS1Parser->IsSetFirstPageDesc() )
1310  pPageDesc = m_pCSS1Parser->GetFirstPageDesc();
1311  else if( m_pCSS1Parser->IsSetRightPageDesc() )
1312  pPageDesc = m_pCSS1Parser->GetRightPageDesc();
1313 
1314  if( pPageDesc )
1315  {
1316  m_xDoc->getIDocumentContentOperations().InsertPoolItem( *m_pPam, SwFormatPageDesc( pPageDesc ) );
1317  }
1318  }
1319  }
1320  break;
1321 
1322  case HtmlTokenId::LINK:
1323  InsertLink();
1324  break;
1325 
1326  case HtmlTokenId::BASE:
1327  {
1328  const HTMLOptions& rHTMLOptions = GetOptions();
1329  for (size_t i = rHTMLOptions.size(); i; )
1330  {
1331  const HTMLOption& rOption = rHTMLOptions[--i];
1332  switch( rOption.GetToken() )
1333  {
1334  case HtmlOptionId::HREF:
1335  m_sBaseURL = rOption.GetString();
1336  break;
1337  case HtmlOptionId::TARGET:
1338  if( IsNewDoc() )
1339  {
1340  SwDocShell *pDocShell(m_xDoc->GetDocShell());
1341  OSL_ENSURE(pDocShell, "no SwDocShell");
1342  if (pDocShell) {
1343  uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
1344  pDocShell->GetModel(), uno::UNO_QUERY_THROW);
1345  uno::Reference<document::XDocumentProperties>
1346  xDocProps(xDPS->getDocumentProperties());
1347  OSL_ENSURE(xDocProps.is(),"no DocumentProperties");
1348  if (xDocProps.is()) {
1349  xDocProps->setDefaultTarget(
1350  rOption.GetString());
1351  }
1352  }
1353  }
1354  break;
1355  default: break;
1356  }
1357  }
1358  }
1359  break;
1360 
1361  case HtmlTokenId::META:
1362  {
1363  SvKeyValueIterator *pHTTPHeader = nullptr;
1364  if( IsNewDoc() )
1365  {
1366  SwDocShell *pDocSh = m_xDoc->GetDocShell();
1367  if( pDocSh )
1368  pHTTPHeader = pDocSh->GetHeaderAttributes();
1369  }
1370  SwDocShell *pDocShell(m_xDoc->GetDocShell());
1371  OSL_ENSURE(pDocShell, "no SwDocShell");
1372  if (pDocShell)
1373  {
1374  uno::Reference<document::XDocumentProperties> xDocProps;
1375  if (IsNewDoc())
1376  {
1377  const uno::Reference<document::XDocumentPropertiesSupplier>
1378  xDPS( pDocShell->GetModel(), uno::UNO_QUERY_THROW );
1379  xDocProps = xDPS->getDocumentProperties();
1380  OSL_ENSURE(xDocProps.is(), "DocumentProperties is null");
1381  }
1382  ParseMetaOptions( xDocProps, pHTTPHeader );
1383  }
1384  }
1385  break;
1386 
1387  case HtmlTokenId::TITLE_ON:
1388  m_bInTitle = true;
1389  break;
1390 
1391  case HtmlTokenId::SCRIPT_ON:
1392  NewScript();
1393  break;
1394 
1395  case HtmlTokenId::SCRIPT_OFF:
1396  EndScript();
1397  break;
1398 
1399  case HtmlTokenId::NOSCRIPT_ON:
1400  case HtmlTokenId::NOSCRIPT_OFF:
1401  bInsertUnknown = true;
1402  break;
1403 
1404  case HtmlTokenId::STYLE_ON:
1405  NewStyle();
1406  break;
1407 
1408  case HtmlTokenId::STYLE_OFF:
1409  EndStyle();
1410  break;
1411 
1412  case HtmlTokenId::RAWDATA:
1413  if( !m_bIgnoreRawData )
1414  {
1415  if( IsReadScript() )
1416  {
1417  AddScriptSource();
1418  }
1419  else if( IsReadStyle() )
1420  {
1421  if( !m_aStyleSource.isEmpty() )
1422  m_aStyleSource += "\n";
1423  m_aStyleSource += aToken;
1424  }
1425  }
1426  break;
1427 
1428  case HtmlTokenId::OBJECT_ON:
1429  if (m_bXHTML)
1430  {
1431  if (!InsertEmbed())
1432  InsertImage();
1433  break;
1434  }
1435 #if HAVE_FEATURE_JAVA
1436  NewObject();
1437  m_bCallNextToken = m_pAppletImpl!=nullptr && m_xTable;
1438 #endif
1439  break;
1440 
1441  case HtmlTokenId::OBJECT_OFF:
1442  if (!m_aEmbeds.empty())
1443  m_aEmbeds.pop();
1444  break;
1445 
1446  case HtmlTokenId::APPLET_ON:
1447 #if HAVE_FEATURE_JAVA
1448  InsertApplet();
1449  m_bCallNextToken = m_pAppletImpl!=nullptr && m_xTable;
1450 #endif
1451  break;
1452 
1453  case HtmlTokenId::IFRAME_ON:
1454  InsertFloatingFrame();
1455  m_bCallNextToken = m_bInFloatingFrame && m_xTable;
1456  break;
1457 
1458  case HtmlTokenId::LINEBREAK:
1459  if( !IsReadPRE() )
1460  {
1461  InsertLineBreak();
1462  break;
1463  }
1464  else
1465  bGetIDOption = true;
1466  // <BR>s in <PRE> resemble true LFs, hence no break
1467  [[fallthrough]];
1468 
1469  case HtmlTokenId::NEWPARA:
1470  // CR in PRE/LISTING/XMP
1471  {
1472  if( HtmlTokenId::NEWPARA==nToken ||
1473  m_pPam->GetPoint()->nContent.GetIndex() )
1474  {
1475  AppendTextNode(); // there is no LF at this place
1476  // therefore it will cause no problems
1477  SetTextCollAttrs();
1478  }
1479  // progress bar
1480  if (m_xProgress)
1481  m_xProgress->Update(rInput.Tell());
1482  }
1483  break;
1484 
1485  case HtmlTokenId::NONBREAKSPACE:
1486  m_xDoc->getIDocumentContentOperations().InsertString( *m_pPam, OUString(CHAR_HARDBLANK) );
1487  break;
1488 
1489  case HtmlTokenId::SOFTHYPH:
1490  m_xDoc->getIDocumentContentOperations().InsertString( *m_pPam, OUString(CHAR_SOFTHYPHEN) );
1491  break;
1492 
1493  case HtmlTokenId::LINEFEEDCHAR:
1494  if( m_pPam->GetPoint()->nContent.GetIndex() )
1495  AppendTextNode();
1496  if (!m_xTable && !m_xDoc->IsInHeaderFooter(m_pPam->GetPoint()->nNode))
1497  {
1498  NewAttr(m_xAttrTab, &m_xAttrTab->pBreak, SvxFormatBreakItem(SvxBreak::PageBefore, RES_BREAK));
1499  EndAttr( m_xAttrTab->pBreak, false );
1500  }
1501  break;
1502 
1503  case HtmlTokenId::TEXTTOKEN:
1504  // insert string without spanning attributes at the end.
1505  if( !aToken.isEmpty() && ' '==aToken[0] && !IsReadPRE() )
1506  {
1507  sal_Int32 nPos = m_pPam->GetPoint()->nContent.GetIndex();
1508  const SwTextNode* pTextNode = nPos ? m_pPam->GetPoint()->nNode.GetNode().GetTextNode() : nullptr;
1509  if (pTextNode)
1510  {
1511  const OUString& rText = pTextNode->GetText();
1512  sal_Unicode cLast = rText[--nPos];
1513  if( ' ' == cLast || '\x0a' == cLast)
1514  aToken = aToken.copy(1);
1515  }
1516  else
1517  aToken = aToken.copy(1);
1518 
1519  if( aToken.isEmpty() )
1520  {
1521  m_bUpperSpace = bUpperSpaceSave;
1522  break;
1523  }
1524  }
1525 
1526  if( !aToken.isEmpty() )
1527  {
1528  if( !m_bDocInitalized )
1529  DocumentDetected();
1530 
1531  if (!m_aEmbeds.empty())
1532  {
1533  // The text token is inside an OLE object, which means
1534  // alternate text.
1535  SwOLENode* pOLENode = m_aEmbeds.top();
1536  if (SwFlyFrameFormat* pFormat
1537  = dynamic_cast<SwFlyFrameFormat*>(pOLENode->GetFlyFormat()))
1538  {
1539  if (SdrObject* pObject = SwXFrame::GetOrCreateSdrObject(*pFormat))
1540  {
1541  pObject->SetTitle(pObject->GetTitle() + aToken);
1542  break;
1543  }
1544  }
1545  }
1546 
1547  m_xDoc->getIDocumentContentOperations().InsertString( *m_pPam, aToken );
1548 
1549  // if there are temporary paragraph attributes and the
1550  // paragraph isn't empty then the paragraph attributes
1551  // are final.
1552  m_aParaAttrs.clear();
1553 
1554  SetAttr();
1555  }
1556  break;
1557 
1558  case HtmlTokenId::HORZRULE:
1559  InsertHorzRule();
1560  break;
1561 
1562  case HtmlTokenId::IMAGE:
1563  InsertImage();
1564  // if only the parser references the doc, we can break and set
1565  // an error code
1566  if( 1 == m_xDoc->getReferenceCount() )
1567  {
1568  eState = SvParserState::Error;
1569  }
1570  break;
1571 
1572  case HtmlTokenId::SPACER:
1573  InsertSpacer();
1574  break;
1575 
1576  case HtmlTokenId::EMBED:
1577  InsertEmbed();
1578  break;
1579 
1580  case HtmlTokenId::NOEMBED_ON:
1581  m_bInNoEmbed = true;
1582  m_bCallNextToken = bool(m_xTable);
1583  ReadRawData( OOO_STRING_SVTOOLS_HTML_noembed );
1584  break;
1585 
1586  case HtmlTokenId::DEFLIST_ON:
1587  if( m_nOpenParaToken != HtmlTokenId::NONE )
1588  EndPara();
1589  NewDefList();
1590  break;
1591  case HtmlTokenId::DEFLIST_OFF:
1592  if( m_nOpenParaToken != HtmlTokenId::NONE )
1593  EndPara();
1594  EndDefListItem( HtmlTokenId::NONE );
1595  EndDefList();
1596  break;
1597 
1598  case HtmlTokenId::DD_ON:
1599  case HtmlTokenId::DT_ON:
1600  if( m_nOpenParaToken != HtmlTokenId::NONE )
1601  EndPara();
1602  EndDefListItem();// close <DD>/<DT> and set no template
1603  NewDefListItem( nToken );
1604  break;
1605 
1606  case HtmlTokenId::DD_OFF:
1607  case HtmlTokenId::DT_OFF:
1608  // c.f. HtmlTokenId::LI_OFF
1609  // Actually we should close a DD/DT now.
1610  // But neither Netscape nor Microsoft do this and so don't we.
1611  EndDefListItem( nToken );
1612  break;
1613 
1614  // divisions
1615  case HtmlTokenId::DIVISION_ON:
1616  case HtmlTokenId::CENTER_ON:
1617  if (!m_isInTableStructure)
1618  {
1619  if (m_nOpenParaToken != HtmlTokenId::NONE)
1620  {
1621  if (IsReadPRE())
1622  m_nOpenParaToken = HtmlTokenId::NONE;
1623  else
1624  EndPara();
1625  }
1626  NewDivision( nToken );
1627  }
1628  break;
1629 
1630  case HtmlTokenId::DIVISION_OFF:
1631  case HtmlTokenId::CENTER_OFF:
1632  if (!m_isInTableStructure)
1633  {
1634  if (m_nOpenParaToken != HtmlTokenId::NONE)
1635  {
1636  if (IsReadPRE())
1637  m_nOpenParaToken = HtmlTokenId::NONE;
1638  else
1639  EndPara();
1640  }
1641  EndDivision();
1642  }
1643  break;
1644 
1645  case HtmlTokenId::MULTICOL_ON:
1646  if( m_nOpenParaToken != HtmlTokenId::NONE )
1647  EndPara();
1648  NewMultiCol();
1649  break;
1650 
1651  case HtmlTokenId::MULTICOL_OFF:
1652  if( m_nOpenParaToken != HtmlTokenId::NONE )
1653  EndPara();
1654  EndTag( HtmlTokenId::MULTICOL_ON );
1655  break;
1656 
1657  case HtmlTokenId::MARQUEE_ON:
1658  NewMarquee();
1659  m_bCallNextToken = m_pMarquee!=nullptr && m_xTable;
1660  break;
1661 
1662  case HtmlTokenId::FORM_ON:
1663  NewForm();
1664  break;
1665  case HtmlTokenId::FORM_OFF:
1666  EndForm();
1667  break;
1668 
1669  // templates
1670  case HtmlTokenId::PARABREAK_ON:
1671  if( m_nOpenParaToken != HtmlTokenId::NONE )
1672  EndPara( true );
1673  NewPara();
1674  break;
1675 
1676  case HtmlTokenId::PARABREAK_OFF:
1677  EndPara( true );
1678  break;
1679 
1680  case HtmlTokenId::ADDRESS_ON:
1681  if( m_nOpenParaToken != HtmlTokenId::NONE )
1682  EndPara();
1683  NewTextFormatColl( HtmlTokenId::ADDRESS_ON, RES_POOLCOLL_SENDADRESS );
1684  break;
1685 
1686  case HtmlTokenId::ADDRESS_OFF:
1687  if( m_nOpenParaToken != HtmlTokenId::NONE )
1688  EndPara();
1689  EndTextFormatColl( HtmlTokenId::ADDRESS_OFF );
1690  break;
1691 
1692  case HtmlTokenId::BLOCKQUOTE_ON:
1693  case HtmlTokenId::BLOCKQUOTE30_ON:
1694  if( m_nOpenParaToken != HtmlTokenId::NONE )
1695  EndPara();
1696  NewTextFormatColl( HtmlTokenId::BLOCKQUOTE_ON, RES_POOLCOLL_HTML_BLOCKQUOTE );
1697  break;
1698 
1699  case HtmlTokenId::BLOCKQUOTE_OFF:
1700  case HtmlTokenId::BLOCKQUOTE30_OFF:
1701  if( m_nOpenParaToken != HtmlTokenId::NONE )
1702  EndPara();
1703  EndTextFormatColl( HtmlTokenId::BLOCKQUOTE_ON );
1704  break;
1705 
1706  case HtmlTokenId::PREFORMTXT_ON:
1707  case HtmlTokenId::LISTING_ON:
1708  case HtmlTokenId::XMP_ON:
1709  if( m_nOpenParaToken != HtmlTokenId::NONE )
1710  EndPara();
1711  NewTextFormatColl( nToken, RES_POOLCOLL_HTML_PRE );
1712  break;
1713 
1714  case HtmlTokenId::PREFORMTXT_OFF:
1715  m_bNoParSpace = true; // the last PRE-paragraph gets a spacing
1716  EndTextFormatColl( HtmlTokenId::PREFORMTXT_OFF );
1717  break;
1718 
1719  case HtmlTokenId::LISTING_OFF:
1720  case HtmlTokenId::XMP_OFF:
1721  EndTextFormatColl( nToken );
1722  break;
1723 
1724  case HtmlTokenId::HEAD1_ON:
1725  case HtmlTokenId::HEAD2_ON:
1726  case HtmlTokenId::HEAD3_ON:
1727  case HtmlTokenId::HEAD4_ON:
1728  case HtmlTokenId::HEAD5_ON:
1729  case HtmlTokenId::HEAD6_ON:
1730  if( m_nOpenParaToken != HtmlTokenId::NONE )
1731  {
1732  if( IsReadPRE() )
1733  m_nOpenParaToken = HtmlTokenId::NONE;
1734  else
1735  EndPara();
1736  }
1737  NewHeading( nToken );
1738  break;
1739 
1740  case HtmlTokenId::HEAD1_OFF:
1741  case HtmlTokenId::HEAD2_OFF:
1742  case HtmlTokenId::HEAD3_OFF:
1743  case HtmlTokenId::HEAD4_OFF:
1744  case HtmlTokenId::HEAD5_OFF:
1745  case HtmlTokenId::HEAD6_OFF:
1746  EndHeading();
1747  break;
1748 
1749  case HtmlTokenId::TABLE_ON:
1750  if( !m_vPendingStack.empty() )
1751  BuildTable( SvxAdjust::End );
1752  else
1753  {
1754  if( m_nOpenParaToken != HtmlTokenId::NONE )
1755  EndPara();
1756  OSL_ENSURE(!m_xTable, "table in table not allowed here");
1757  if( !m_xTable && (IsNewDoc() || !m_pPam->GetNode().FindTableNode()) &&
1758  (m_pPam->GetPoint()->nNode.GetIndex() >
1759  m_xDoc->GetNodes().GetEndOfExtras().GetIndex() ||
1760  !m_pPam->GetNode().FindFootnoteStartNode() ) )
1761  {
1762  if ( m_nParaCnt < 5 )
1763  Show(); // show what we have up to here
1764 
1765  SvxAdjust eAdjust = m_xAttrTab->pAdjust
1766  ? static_cast<const SvxAdjustItem&>(m_xAttrTab->pAdjust->GetItem()).
1767  GetAdjust()
1768  : SvxAdjust::End;
1769  BuildTable( eAdjust );
1770  }
1771  else
1772  bInsertUnknown = m_bKeepUnknown;
1773  }
1774  break;
1775 
1776  // lists
1777  case HtmlTokenId::DIRLIST_ON:
1778  case HtmlTokenId::MENULIST_ON:
1779  case HtmlTokenId::ORDERLIST_ON:
1780  case HtmlTokenId::UNORDERLIST_ON:
1781  if( m_nOpenParaToken != HtmlTokenId::NONE )
1782  EndPara();
1783  NewNumberBulletList( nToken );
1784  break;
1785 
1786  case HtmlTokenId::DIRLIST_OFF:
1787  case HtmlTokenId::MENULIST_OFF:
1788  case HtmlTokenId::ORDERLIST_OFF:
1789  case HtmlTokenId::UNORDERLIST_OFF:
1790  if( m_nOpenParaToken != HtmlTokenId::NONE )
1791  EndPara();
1792  EndNumberBulletListItem( HtmlTokenId::NONE, true );
1793  EndNumberBulletList( nToken );
1794  break;
1795 
1796  case HtmlTokenId::LI_ON:
1797  case HtmlTokenId::LISTHEADER_ON:
1798  if( m_nOpenParaToken != HtmlTokenId::NONE &&
1799  (m_pPam->GetPoint()->nContent.GetIndex()
1800  || HtmlTokenId::PARABREAK_ON==m_nOpenParaToken) )
1801  {
1802  // only finish paragraph for <P><LI>, not for <DD><LI>
1803  EndPara();
1804  }
1805 
1806  EndNumberBulletListItem( HtmlTokenId::NONE, false );// close <LI>/<LH> and don't set a template
1807  NewNumberBulletListItem( nToken );
1808  break;
1809 
1810  case HtmlTokenId::LI_OFF:
1811  case HtmlTokenId::LISTHEADER_OFF:
1812  EndNumberBulletListItem( nToken, false );
1813  break;
1814 
1815  // Attribute :
1816  case HtmlTokenId::ITALIC_ON:
1817  {
1818  SvxPostureItem aPosture( ITALIC_NORMAL, RES_CHRATR_POSTURE );
1819  SvxPostureItem aPostureCJK( ITALIC_NORMAL, RES_CHRATR_CJK_POSTURE );
1820  SvxPostureItem aPostureCTL( ITALIC_NORMAL, RES_CHRATR_CTL_POSTURE );
1821  NewStdAttr( HtmlTokenId::ITALIC_ON,
1822  &m_xAttrTab->pItalic, aPosture,
1823  &m_xAttrTab->pItalicCJK, &aPostureCJK,
1824  &m_xAttrTab->pItalicCTL, &aPostureCTL );
1825  }
1826  break;
1827 
1828  case HtmlTokenId::BOLD_ON:
1829  {
1830  SvxWeightItem aWeight( WEIGHT_BOLD, RES_CHRATR_WEIGHT );
1831  SvxWeightItem aWeightCJK( WEIGHT_BOLD, RES_CHRATR_CJK_WEIGHT );
1832  SvxWeightItem aWeightCTL( WEIGHT_BOLD, RES_CHRATR_CTL_WEIGHT );
1833  NewStdAttr( HtmlTokenId::BOLD_ON,
1834  &m_xAttrTab->pBold, aWeight,
1835  &m_xAttrTab->pBoldCJK, &aWeightCJK,
1836  &m_xAttrTab->pBoldCTL, &aWeightCTL );
1837  }
1838  break;
1839 
1840  case HtmlTokenId::STRIKE_ON:
1841  case HtmlTokenId::STRIKETHROUGH_ON:
1842  {
1843  NewStdAttr( HtmlTokenId::STRIKE_ON, &m_xAttrTab->pStrike,
1844  SvxCrossedOutItem(STRIKEOUT_SINGLE, RES_CHRATR_CROSSEDOUT) );
1845  }
1846  break;
1847 
1848  case HtmlTokenId::UNDERLINE_ON:
1849  {
1850  NewStdAttr( HtmlTokenId::UNDERLINE_ON, &m_xAttrTab->pUnderline,
1851  SvxUnderlineItem(LINESTYLE_SINGLE, RES_CHRATR_UNDERLINE) );
1852  }
1853  break;
1854 
1855  case HtmlTokenId::SUPERSCRIPT_ON:
1856  {
1857  NewStdAttr( HtmlTokenId::SUPERSCRIPT_ON, &m_xAttrTab->pEscapement,
1858  SvxEscapementItem(HTML_ESC_SUPER,HTML_ESC_PROP, RES_CHRATR_ESCAPEMENT) );
1859  }
1860  break;
1861 
1862  case HtmlTokenId::SUBSCRIPT_ON:
1863  {
1864  NewStdAttr( HtmlTokenId::SUBSCRIPT_ON, &m_xAttrTab->pEscapement,
1865  SvxEscapementItem(HTML_ESC_SUB,HTML_ESC_PROP, RES_CHRATR_ESCAPEMENT) );
1866  }
1867  break;
1868 
1869  case HtmlTokenId::BLINK_ON:
1870  {
1871  NewStdAttr( HtmlTokenId::BLINK_ON, &m_xAttrTab->pBlink,
1872  SvxBlinkItem( true, RES_CHRATR_BLINK ) );
1873  }
1874  break;
1875 
1876  case HtmlTokenId::SPAN_ON:
1877  NewStdAttr( HtmlTokenId::SPAN_ON );
1878  break;
1879 
1880  case HtmlTokenId::ITALIC_OFF:
1881  case HtmlTokenId::BOLD_OFF:
1882  case HtmlTokenId::STRIKE_OFF:
1883  case HtmlTokenId::UNDERLINE_OFF:
1884  case HtmlTokenId::SUPERSCRIPT_OFF:
1885  case HtmlTokenId::SUBSCRIPT_OFF:
1886  case HtmlTokenId::BLINK_OFF:
1887  case HtmlTokenId::SPAN_OFF:
1888  EndTag( nToken );
1889  break;
1890 
1891  case HtmlTokenId::STRIKETHROUGH_OFF:
1892  EndTag( HtmlTokenId::STRIKE_OFF );
1893  break;
1894 
1895  case HtmlTokenId::BASEFONT_ON:
1896  NewBasefontAttr();
1897  break;
1898  case HtmlTokenId::BASEFONT_OFF:
1899  EndBasefontAttr();
1900  break;
1901  case HtmlTokenId::FONT_ON:
1902  case HtmlTokenId::BIGPRINT_ON:
1903  case HtmlTokenId::SMALLPRINT_ON:
1904  NewFontAttr( nToken );
1905  break;
1906  case HtmlTokenId::FONT_OFF:
1907  case HtmlTokenId::BIGPRINT_OFF:
1908  case HtmlTokenId::SMALLPRINT_OFF:
1909  EndFontAttr( nToken );
1910  break;
1911 
1912  case HtmlTokenId::EMPHASIS_ON:
1913  case HtmlTokenId::CITIATION_ON:
1914  case HtmlTokenId::STRONG_ON:
1915  case HtmlTokenId::CODE_ON:
1916  case HtmlTokenId::SAMPLE_ON:
1917  case HtmlTokenId::KEYBOARD_ON:
1918  case HtmlTokenId::VARIABLE_ON:
1919  case HtmlTokenId::DEFINSTANCE_ON:
1920  case HtmlTokenId::SHORTQUOTE_ON:
1921  case HtmlTokenId::LANGUAGE_ON:
1922  case HtmlTokenId::AUTHOR_ON:
1923  case HtmlTokenId::PERSON_ON:
1924  case HtmlTokenId::ACRONYM_ON:
1925  case HtmlTokenId::ABBREVIATION_ON:
1926  case HtmlTokenId::INSERTEDTEXT_ON:
1927  case HtmlTokenId::DELETEDTEXT_ON:
1928 
1929  case HtmlTokenId::TELETYPE_ON:
1930  NewCharFormat( nToken );
1931  break;
1932 
1933  case HtmlTokenId::SDFIELD_ON:
1934  NewField();
1935  m_bCallNextToken = m_bInField && m_xTable;
1936  break;
1937 
1938  case HtmlTokenId::EMPHASIS_OFF:
1939  case HtmlTokenId::CITIATION_OFF:
1940  case HtmlTokenId::STRONG_OFF:
1941  case HtmlTokenId::CODE_OFF:
1942  case HtmlTokenId::SAMPLE_OFF:
1943  case HtmlTokenId::KEYBOARD_OFF:
1944  case HtmlTokenId::VARIABLE_OFF:
1945  case HtmlTokenId::DEFINSTANCE_OFF:
1946  case HtmlTokenId::SHORTQUOTE_OFF:
1947  case HtmlTokenId::LANGUAGE_OFF:
1948  case HtmlTokenId::AUTHOR_OFF:
1949  case HtmlTokenId::PERSON_OFF:
1950  case HtmlTokenId::ACRONYM_OFF:
1951  case HtmlTokenId::ABBREVIATION_OFF:
1952  case HtmlTokenId::INSERTEDTEXT_OFF:
1953  case HtmlTokenId::DELETEDTEXT_OFF:
1954 
1955  case HtmlTokenId::TELETYPE_OFF:
1956  EndTag( nToken );
1957  break;
1958 
1959  case HtmlTokenId::HEAD_OFF:
1960  if( !m_aStyleSource.isEmpty() )
1961  {
1962  m_pCSS1Parser->ParseStyleSheet( m_aStyleSource );
1963  m_aStyleSource.clear();
1964  }
1965  break;
1966 
1967  case HtmlTokenId::DOCTYPE:
1968  case HtmlTokenId::BODY_OFF:
1969  case HtmlTokenId::HTML_OFF:
1970  case HtmlTokenId::HEAD_ON:
1971  case HtmlTokenId::TITLE_OFF:
1972  break; // don't evaluate further???
1973  case HtmlTokenId::HTML_ON:
1974  {
1975  const HTMLOptions& rHTMLOptions = GetOptions();
1976  for (size_t i = rHTMLOptions.size(); i; )
1977  {
1978  const HTMLOption& rOption = rHTMLOptions[--i];
1979  if( HtmlOptionId::DIR == rOption.GetToken() )
1980  {
1981  const OUString& rDir = rOption.GetString();
1982  SfxItemSet aItemSet( m_xDoc->GetAttrPool(),
1983  m_pCSS1Parser->GetWhichMap() );
1984  SvxCSS1PropertyInfo aPropInfo;
1985  OUString aDummy;
1986  ParseStyleOptions( aDummy, aDummy, aDummy, aItemSet,
1987  aPropInfo, nullptr, &rDir );
1988 
1989  m_pCSS1Parser->SetPageDescAttrs( nullptr, &aItemSet );
1990  break;
1991  }
1992  }
1993  }
1994  break;
1995 
1996  case HtmlTokenId::INPUT:
1997  InsertInput();
1998  break;
1999 
2000  case HtmlTokenId::TEXTAREA_ON:
2001  NewTextArea();
2002  m_bCallNextToken = m_bTextArea && m_xTable;
2003  break;
2004 
2005  case HtmlTokenId::SELECT_ON:
2006  NewSelect();
2007  m_bCallNextToken = m_bSelect && m_xTable;
2008  break;
2009 
2010  case HtmlTokenId::ANCHOR_ON:
2011  NewAnchor();
2012  break;
2013 
2014  case HtmlTokenId::ANCHOR_OFF:
2015  EndAnchor();
2016  break;
2017 
2018  case HtmlTokenId::COMMENT:
2019  if( ( aToken.getLength() > 5 ) && ( ! m_bIgnoreHTMLComments ) )
2020  {
2021  // insert as Post-It
2022  // If there are no space characters right behind
2023  // the <!-- and on front of the -->, leave the comment untouched.
2024  if( ' ' == aToken[ 3 ] &&
2025  ' ' == aToken[ aToken.getLength()-3 ] )
2026  {
2027  OUString aComment( aToken.copy( 3, aToken.getLength()-5 ) );
2028  InsertComment(comphelper::string::strip(aComment, ' '));
2029  }
2030  else
2031  {
2032  OUString aComment = "<" + aToken + ">";
2033  InsertComment( aComment );
2034  }
2035  }
2036  break;
2037 
2038  case HtmlTokenId::MAP_ON:
2039  // Image Maps are read asynchronously: At first only an image map is created
2040  // Areas are processed later. Nevertheless the
2041  // ImageMap is inserted into the IMap-Array, because it might be used
2042  // already.
2043  m_pImageMap = new ImageMap;
2044  if( ParseMapOptions( m_pImageMap) )
2045  {
2046  if (!m_pImageMaps)
2047  m_pImageMaps.reset( new ImageMaps );
2048  m_pImageMaps->push_back(std::unique_ptr<ImageMap>(m_pImageMap));
2049  }
2050  else
2051  {
2052  delete m_pImageMap;
2053  m_pImageMap = nullptr;
2054  }
2055  break;
2056 
2057  case HtmlTokenId::MAP_OFF:
2058  // there is no ImageMap anymore (don't delete IMap, because it's
2059  // already contained in the array!)
2060  m_pImageMap = nullptr;
2061  break;
2062 
2063  case HtmlTokenId::AREA:
2064  if( m_pImageMap )
2065  ParseAreaOptions( m_pImageMap, m_sBaseURL, SvMacroItemId::OnMouseOver,
2066  SvMacroItemId::OnMouseOut );
2067  break;
2068 
2069  case HtmlTokenId::FRAMESET_ON:
2070  bInsertUnknown = m_bKeepUnknown;
2071  break;
2072 
2073  case HtmlTokenId::NOFRAMES_ON:
2074  if( IsInHeader() )
2075  FinishHeader();
2076  bInsertUnknown = m_bKeepUnknown;
2077  break;
2078 
2079  case HtmlTokenId::UNKNOWNCONTROL_ON:
2080  // Ignore content of unknown token in the header, if the token
2081  // does not start with a '!'.
2082  // (but judging from the code, also if does not start with a '%')
2083  // (and also if we're not somewhere we consider PRE)
2084  if( IsInHeader() && !IsReadPRE() && m_aUnknownToken.isEmpty() &&
2085  !sSaveToken.isEmpty() && '!' != sSaveToken[0] &&
2086  '%' != sSaveToken[0] )
2087  m_aUnknownToken = sSaveToken;
2088  [[fallthrough]];
2089 
2090  default:
2091  bInsertUnknown = m_bKeepUnknown;
2092  break;
2093  }
2094 
2095  if( bGetIDOption )
2096  InsertIDOption();
2097 
2098  if( bInsertUnknown )
2099  {
2100  OUStringBuffer aComment("HTML: <");
2101  if( (nToken >= HtmlTokenId::ONOFF_START) && isOffToken(nToken) )
2102  aComment.append("/");
2103  aComment.append(sSaveToken);
2104  if( !aToken.isEmpty() )
2105  {
2106  UnescapeToken();
2107  aComment.append(" ").append(aToken);
2108  }
2109  aComment.append(">");
2110  InsertComment( aComment.makeStringAndClear() );
2111  }
2112 
2113  // if there are temporary paragraph attributes and the
2114  // paragraph isn't empty then the paragraph attributes are final.
2115  if( !m_aParaAttrs.empty() && m_pPam->GetPoint()->nContent.GetIndex() )
2116  m_aParaAttrs.clear();
2117 }
2118 
2119 static void lcl_swhtml_getItemInfo( const HTMLAttr& rAttr,
2120  bool& rScriptDependent,
2121  sal_uInt16& rScriptType )
2122 {
2123  switch( rAttr.GetItem().Which() )
2124  {
2125  case RES_CHRATR_FONT:
2126  case RES_CHRATR_FONTSIZE:
2127  case RES_CHRATR_LANGUAGE:
2128  case RES_CHRATR_POSTURE:
2129  case RES_CHRATR_WEIGHT:
2130  rScriptType = i18n::ScriptType::LATIN;
2131  rScriptDependent = true;
2132  break;
2133  case RES_CHRATR_CJK_FONT:
2134  case RES_CHRATR_CJK_FONTSIZE:
2135  case RES_CHRATR_CJK_LANGUAGE:
2136  case RES_CHRATR_CJK_POSTURE:
2137  case RES_CHRATR_CJK_WEIGHT:
2138  rScriptType = i18n::ScriptType::ASIAN;
2139  rScriptDependent = true;
2140  break;
2141  case RES_CHRATR_CTL_FONT:
2142  case RES_CHRATR_CTL_FONTSIZE:
2143  case RES_CHRATR_CTL_LANGUAGE:
2144  case RES_CHRATR_CTL_POSTURE:
2145  case RES_CHRATR_CTL_WEIGHT:
2146  rScriptType = i18n::ScriptType::COMPLEX;
2147  rScriptDependent = true;
2148  break;
2149  default:
2150  rScriptDependent = false;
2151  break;
2152  }
2153 }
2154 
2155 bool SwHTMLParser::AppendTextNode( SwHTMLAppendMode eMode, bool bUpdateNum )
2156 {
2157  // A hard line break at the end always must be removed.
2158  // A second one we replace with paragraph spacing.
2159  sal_Int32 nLFStripped = StripTrailingLF();
2160  if( (AM_NOSPACE==eMode || AM_SOFTNOSPACE==eMode) && nLFStripped > 1 )
2161  eMode = AM_SPACE;
2162 
2163  // the hard attributes of this paragraph will never be invalid again
2164  m_aParaAttrs.clear();
2165 
2166  SwTextNode *pTextNode = (AM_SPACE==eMode || AM_NOSPACE==eMode) ?
2167  m_pPam->GetPoint()->nNode.GetNode().GetTextNode() : nullptr;
2168 
2169  if (pTextNode)
2170  {
2171  const SvxULSpaceItem& rULSpace =
2172  static_cast<const SvxULSpaceItem&>(pTextNode->SwContentNode::GetAttr( RES_UL_SPACE ));
2173 
2174  bool bChange = AM_NOSPACE==eMode ? rULSpace.GetLower() > 0
2175  : rULSpace.GetLower() == 0;
2176 
2177  if( bChange )
2178  {
2179  const SvxULSpaceItem& rCollULSpace =
2180  pTextNode->GetAnyFormatColl().GetULSpace();
2181 
2182  bool bMayReset = AM_NOSPACE==eMode ? rCollULSpace.GetLower() == 0
2183  : rCollULSpace.GetLower() > 0;
2184 
2185  if( bMayReset &&
2186  rCollULSpace.GetUpper() == rULSpace.GetUpper() )
2187  {
2188  pTextNode->ResetAttr( RES_UL_SPACE );
2189  }
2190  else
2191  {
2192  pTextNode->SetAttr(
2193  SvxULSpaceItem( rULSpace.GetUpper(),
2194  AM_NOSPACE==eMode ? 0 : HTML_PARSPACE, RES_UL_SPACE ) );
2195  }
2196  }
2197  }
2198  m_bNoParSpace = AM_NOSPACE==eMode || AM_SOFTNOSPACE==eMode;
2199 
2200  SwPosition aOldPos( *m_pPam->GetPoint() );
2201 
2202  bool bRet = m_xDoc->getIDocumentContentOperations().AppendTextNode( *m_pPam->GetPoint() );
2203 
2204  // split character attributes and maybe set none,
2205  // which are set for the whole paragraph
2206  const SwNodeIndex& rEndIdx = aOldPos.nNode;
2207  const sal_Int32 nEndCnt = aOldPos.nContent.GetIndex();
2208  const SwPosition& rPos = *m_pPam->GetPoint();
2209 
2210  HTMLAttr** pHTMLAttributes = reinterpret_cast<HTMLAttr**>(m_xAttrTab.get());
2211  for (auto nCnt = sizeof(HTMLAttrTable) / sizeof(HTMLAttr*); nCnt--; ++pHTMLAttributes)
2212  {
2213  HTMLAttr *pAttr = *pHTMLAttributes;
2214  if( pAttr && pAttr->GetItem().Which() < RES_PARATR_BEGIN )
2215  {
2216  bool bWholePara = false;
2217 
2218  while( pAttr )
2219  {
2220  HTMLAttr *pNext = pAttr->GetNext();
2221  if( pAttr->GetSttParaIdx() < rEndIdx.GetIndex() ||
2222  (!bWholePara &&
2223  pAttr->GetSttPara() == rEndIdx &&
2224  pAttr->GetSttCnt() != nEndCnt) )
2225  {
2226  bWholePara =
2227  pAttr->GetSttPara() == rEndIdx &&
2228  pAttr->GetSttCnt() == 0;
2229 
2230  sal_Int32 nStt = pAttr->m_nStartContent;
2231  bool bScript = false;
2232  sal_uInt16 nScriptItem;
2233  bool bInsert = true;
2234  lcl_swhtml_getItemInfo( *pAttr, bScript,
2235  nScriptItem );
2236  // set previous part
2237  if( bScript )
2238  {
2239  const SwTextNode *pTextNd =
2240  pAttr->GetSttPara().GetNode().GetTextNode();
2241  OSL_ENSURE( pTextNd, "No text node" );
2242  if( pTextNd )
2243  {
2244  const OUString& rText = pTextNd->GetText();
2245  sal_uInt16 nScriptText =
2246  g_pBreakIt->GetBreakIter()->getScriptType(
2247  rText, pAttr->GetSttCnt() );
2248  sal_Int32 nScriptEnd = g_pBreakIt->GetBreakIter()
2249  ->endOfScript( rText, nStt, nScriptText );
2250  while (nScriptEnd < nEndCnt && nScriptEnd != -1)
2251  {
2252  if( nScriptItem == nScriptText )
2253  {
2254  HTMLAttr *pSetAttr =
2255  pAttr->Clone( rEndIdx, nScriptEnd );
2256  pSetAttr->m_nStartContent = nStt;
2257  pSetAttr->ClearPrev();
2258  if( !pNext || bWholePara )
2259  {
2260  if (pSetAttr->m_bInsAtStart)
2261  m_aSetAttrTab.push_front( pSetAttr );
2262  else
2263  m_aSetAttrTab.push_back( pSetAttr );
2264  }
2265  else
2266  pNext->InsertPrev( pSetAttr );
2267  }
2268  nStt = nScriptEnd;
2269  nScriptText = g_pBreakIt->GetBreakIter()->getScriptType(
2270  rText, nStt );
2271  nScriptEnd = g_pBreakIt->GetBreakIter()
2272  ->endOfScript( rText, nStt, nScriptText );
2273  }
2274  bInsert = nScriptItem == nScriptText;
2275  }
2276  }
2277  if( bInsert )
2278  {
2279  HTMLAttr *pSetAttr =
2280  pAttr->Clone( rEndIdx, nEndCnt );
2281  pSetAttr->m_nStartContent = nStt;
2282 
2283  // When the attribute is for the whole paragraph, the outer
2284  // attributes aren't effective anymore. Hence it may not be inserted
2285  // in the Prev-List of an outer attribute, because that won't be
2286  // set. That leads to shifting when fields are used.
2287  if( !pNext || bWholePara )
2288  {
2289  if (pSetAttr->m_bInsAtStart)
2290  m_aSetAttrTab.push_front( pSetAttr );
2291  else
2292  m_aSetAttrTab.push_back( pSetAttr );
2293  }
2294  else
2295  pNext->InsertPrev( pSetAttr );
2296  }
2297  else
2298  {
2299  HTMLAttr *pPrev = pAttr->GetPrev();
2300  if( pPrev )
2301  {
2302  // the previous attributes must be set anyway
2303  if( !pNext || bWholePara )
2304  {
2305  if (pPrev->m_bInsAtStart)
2306  m_aSetAttrTab.push_front( pPrev );
2307  else
2308  m_aSetAttrTab.push_back( pPrev );
2309  }
2310  else
2311  pNext->InsertPrev( pPrev );
2312  }
2313  }
2314  pAttr->ClearPrev();
2315  }
2316 
2317  pAttr->SetStart( rPos );
2318  pAttr = pNext;
2319  }
2320  }
2321  }
2322 
2323  if( bUpdateNum )
2324  {
2325  if( GetNumInfo().GetDepth() )
2326  {
2327  sal_uInt8 nLvl = GetNumInfo().GetLevel();
2328  SetNodeNum( nLvl );
2329  }
2330  else
2331  m_pPam->GetNode().GetTextNode()->ResetAttr( RES_PARATR_NUMRULE );
2332  }
2333 
2334  // We must set the attribute of the paragraph before now (because of JavaScript)
2335  SetAttr();
2336 
2337  // Now it is time to get rid of all script dependent hints that are
2338  // equal to the settings in the style
2339  SwTextNode *pTextNd = rEndIdx.GetNode().GetTextNode();
2340  OSL_ENSURE( pTextNd, "There is the txt node" );
2341  size_t nCntAttr = (pTextNd && pTextNd->GetpSwpHints())
2342  ? pTextNd->GetSwpHints().Count() : 0;
2343  if( nCntAttr )
2344  {
2345  // These are the end position of all script dependent hints.
2346  // If we find a hint that starts before the current end position,
2347  // we have to set it. If we find a hint that start behind or at
2348  // that position, we have to take the hint value into account.
2349  // If it is equal to the style, or in fact the paragraph value
2350  // for that hint, the hint is removed. Otherwise its end position
2351  // is remembered.
2352  sal_Int32 aEndPos[15] =
2353  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
2354  SwpHints& rHints = pTextNd->GetSwpHints();
2355  for( size_t i=0; i < nCntAttr; i++ )
2356  {
2357  SwTextAttr *pHt = rHints.Get( i );
2358  sal_uInt16 nWhich = pHt->Which();
2359  sal_Int16 nIdx = 0;
2360  bool bFont = false;
2361  switch( nWhich )
2362  {
2363  case RES_CHRATR_FONT:
2364  nIdx = 0;
2365  bFont = true;
2366  break;
2367  case RES_CHRATR_FONTSIZE:
2368  nIdx = 1;
2369  break;
2370  case RES_CHRATR_LANGUAGE:
2371  nIdx = 2;
2372  break;
2373  case RES_CHRATR_POSTURE:
2374  nIdx = 3;
2375  break;
2376  case RES_CHRATR_WEIGHT:
2377  nIdx = 4;
2378  break;
2379  case RES_CHRATR_CJK_FONT:
2380  nIdx = 5;
2381  bFont = true;
2382  break;
2383  case RES_CHRATR_CJK_FONTSIZE:
2384  nIdx = 6;
2385  break;
2386  case RES_CHRATR_CJK_LANGUAGE:
2387  nIdx = 7;
2388  break;
2389  case RES_CHRATR_CJK_POSTURE:
2390  nIdx = 8;
2391  break;
2392  case RES_CHRATR_CJK_WEIGHT:
2393  nIdx = 9;
2394  break;
2395  case RES_CHRATR_CTL_FONT:
2396  nIdx = 10;
2397  bFont = true;
2398  break;
2399  case RES_CHRATR_CTL_FONTSIZE:
2400  nIdx = 11;
2401  break;
2402  case RES_CHRATR_CTL_LANGUAGE:
2403  nIdx = 12;
2404  break;
2405  case RES_CHRATR_CTL_POSTURE:
2406  nIdx = 13;
2407  break;
2408  case RES_CHRATR_CTL_WEIGHT:
2409  nIdx = 14;
2410  break;
2411  default:
2412  // Skip to next attribute
2413  continue;
2414  }
2415  const sal_Int32 nStt = pHt->GetStart();
2416  if( nStt >= aEndPos[nIdx] )
2417  {
2418  const SfxPoolItem& rItem =
2419  static_cast<const SwContentNode *>(pTextNd)->GetAttr( nWhich );
2420  if( bFont ? swhtml_css1atr_equalFontItems(rItem,pHt->GetAttr())
2421  : rItem == pHt->GetAttr() )
2422  {
2423  // The hint is the same as set in the paragraph and
2424  // therefore, it can be deleted
2425  // CAUTION!!! This WILL delete the hint and it MAY
2426  // also delete the SwpHints!!! To avoid any trouble
2427  // we leave the loop immediately if this is the last
2428  // hint.
2429  pTextNd->DeleteAttribute( pHt );
2430  if( 1 == nCntAttr )
2431  break;
2432  i--;
2433  nCntAttr--;
2434  }
2435  else
2436  {
2437  // The hint is different. Therefore all hints within that
2438  // hint have to be ignored.
2439  aEndPos[nIdx] = pHt->GetEnd() ? *pHt->GetEnd() : nStt;
2440  }
2441  }
2442  else
2443  {
2444  // The hint starts before another one ends.
2445  // The hint in this case is not deleted
2446  OSL_ENSURE( pHt->GetEnd() && *pHt->GetEnd() <= aEndPos[nIdx],
2447  "hints aren't nested properly!" );
2448  }
2449  }
2450  }
2451 
2452  if (!m_xTable && !--m_nParaCnt)
2453  Show();
2454 
2455  return bRet;
2456 }
2457 
2458 void SwHTMLParser::AddParSpace()
2459 {
2460  //If it already has ParSpace, return
2461  if( !m_bNoParSpace )
2462  return;
2463 
2464  m_bNoParSpace = false;
2465 
2466  sal_uLong nNdIdx = m_pPam->GetPoint()->nNode.GetIndex() - 1;
2467 
2468  SwTextNode *pTextNode = m_xDoc->GetNodes()[nNdIdx]->GetTextNode();
2469  if( !pTextNode )
2470  return;
2471 
2472  SvxULSpaceItem rULSpace =
2473  static_cast<const SvxULSpaceItem&>(pTextNode->SwContentNode::GetAttr( RES_UL_SPACE ));
2474  if( !rULSpace.GetLower() )
2475  {
2476  const SvxULSpaceItem& rCollULSpace =
2477  pTextNode->GetAnyFormatColl().GetULSpace();
2478  if( rCollULSpace.GetLower() &&
2479  rCollULSpace.GetUpper() == rULSpace.GetUpper() )
2480  {
2481  pTextNode->ResetAttr( RES_UL_SPACE );
2482  }
2483  else
2484  {
2485  //What I do here, is that I examine the attributes, and if
2486  //I find out, that it's CJK/CTL, then I set the paragraph space
2487  //to the value set in HTML_CJK_PARSPACE/HTML_CTL_PARSPACE.
2488 
2489  bool bIsCJK = false;
2490  bool bIsCTL = false;
2491 
2492  const size_t nCntAttr = pTextNode->GetpSwpHints()
2493  ? pTextNode->GetSwpHints().Count() : 0;
2494 
2495  for(size_t i = 0; i < nCntAttr; ++i)
2496  {
2497  SwTextAttr *const pHt = pTextNode->GetSwpHints().Get(i);
2498  sal_uInt16 const nWhich = pHt->Which();
2499  if (RES_CHRATR_CJK_FONT == nWhich ||
2500  RES_CHRATR_CJK_FONTSIZE == nWhich ||
2501  RES_CHRATR_CJK_LANGUAGE == nWhich ||
2502  RES_CHRATR_CJK_POSTURE == nWhich ||
2503  RES_CHRATR_CJK_WEIGHT == nWhich)
2504  {
2505  bIsCJK = true;
2506  break;
2507  }
2508  if (RES_CHRATR_CTL_FONT == nWhich ||
2509  RES_CHRATR_CTL_FONTSIZE == nWhich ||
2510  RES_CHRATR_CTL_LANGUAGE == nWhich ||
2511  RES_CHRATR_CTL_POSTURE == nWhich ||
2512  RES_CHRATR_CTL_WEIGHT == nWhich)
2513  {
2514  bIsCTL = true;
2515  break;
2516  }
2517  }
2518 
2519  if( bIsCTL )
2520  {
2521  pTextNode->SetAttr(
2522  SvxULSpaceItem( rULSpace.GetUpper(), HTML_CTL_PARSPACE, RES_UL_SPACE ) );
2523  }
2524  else if( bIsCJK )
2525  {
2526  pTextNode->SetAttr(
2527  SvxULSpaceItem( rULSpace.GetUpper(), HTML_CJK_PARSPACE, RES_UL_SPACE ) );
2528  } else {
2529  pTextNode->SetAttr(
2530  SvxULSpaceItem( rULSpace.GetUpper(), HTML_PARSPACE, RES_UL_SPACE ) );
2531  }
2532  }
2533  }
2534 }
2535 
2536 void SwHTMLParser::Show()
2537 {
2538  // Here
2539  // - a EndAction is called, so the document is formatted
2540  // - a Reschedule is called,
2541  // - the own View-Shell is set again
2542  // - and a StartAction is called
2543 
2544  OSL_ENSURE( SvParserState::Working==eState, "Show not in working state - That can go wrong" );
2545  SwViewShell *pOldVSh = CallEndAction();
2546 
2547  Application::Reschedule();
2548 
2549  if( ( m_xDoc->GetDocShell() && m_xDoc->GetDocShell()->IsAbortingImport() )
2550  || 1 == m_xDoc->getReferenceCount() )
2551  {
2552  // was the import aborted by SFX?
2553  eState = SvParserState::Error;
2554  }
2555 
2556  // Fetch the SwViewShell again, as it could be destroyed in Reschedule.
2557  SwViewShell *pVSh = CallStartAction( pOldVSh );
2558 
2559  // is the current node not visible anymore, then we use a bigger increment
2560  if( pVSh )
2561  {
2562  m_nParaCnt = (m_pPam->GetPoint()->nNode.GetNode().IsInVisibleArea(pVSh))
2563  ? 5 : 50;
2564  }
2565 }
2566 
2567 void SwHTMLParser::ShowStatline()
2568 {
2569  // Here
2570  // - a Reschedule is called, so it can be scrolled
2571  // - the own View-Shell is set again
2572  // - a StartAction/EndAction is called, when there was scrolling.
2573 
2574  OSL_ENSURE( SvParserState::Working==eState, "ShowStatLine not in working state - That can go wrong" );
2575 
2576  // scroll bar
2577  if (m_xProgress)
2578  {
2579  m_xProgress->Update(rInput.Tell());
2580  CheckActionViewShell();
2581  }
2582  else
2583  {
2584  Application::Reschedule();
2585 
2586  if( ( m_xDoc->GetDocShell() && m_xDoc->GetDocShell()->IsAbortingImport() )
2587  || 1 == m_xDoc->getReferenceCount() )
2588  // was the import aborted by SFX?
2589  eState = SvParserState::Error;
2590 
2591  SwViewShell *pVSh = CheckActionViewShell();
2592  if( pVSh && pVSh->HasInvalidRect() )
2593  {
2594  CallEndAction( false, false );
2595  CallStartAction( pVSh, false );
2596  }
2597  }
2598 }
2599 
2600 SwViewShell *SwHTMLParser::CallStartAction( SwViewShell *pVSh, bool bChkPtr )
2601 {
2602  OSL_ENSURE( !m_pActionViewShell, "CallStartAction: SwViewShell already set" );
2603 
2604  if( !pVSh || bChkPtr )
2605  {
2606 #if OSL_DEBUG_LEVEL > 0
2607  SwViewShell *pOldVSh = pVSh;
2608 #endif
2609  pVSh = m_xDoc->getIDocumentLayoutAccess().GetCurrentViewShell();
2610 #if OSL_DEBUG_LEVEL > 0
2611  OSL_ENSURE( !pVSh || !pOldVSh || pOldVSh == pVSh, "CallStartAction: Who swapped the SwViewShell?" );
2612  if( pOldVSh && !pVSh )
2613  pVSh = nullptr;
2614 #endif
2615  }
2616  m_pActionViewShell = pVSh;
2617 
2618  if( m_pActionViewShell )
2619  {
2620  if( dynamic_cast< const SwEditShell *>( m_pActionViewShell ) != nullptr )
2621  static_cast<SwEditShell*>(m_pActionViewShell)->StartAction();
2622  else
2623  m_pActionViewShell->StartAction();
2624  }
2625 
2626  return m_pActionViewShell;
2627 }
2628 
2629 SwViewShell *SwHTMLParser::CallEndAction( bool bChkAction, bool bChkPtr )
2630 {
2631  if( bChkPtr )
2632  {
2633  SwViewShell *pVSh = m_xDoc->getIDocumentLayoutAccess().GetCurrentViewShell();
2634  OSL_ENSURE( !pVSh || m_pActionViewShell == pVSh,
2635  "CallEndAction: Who swapped the SwViewShell?" );
2636 #if OSL_DEBUG_LEVEL > 0
2637  if( m_pActionViewShell && !pVSh )
2638  pVSh = nullptr;
2639 #endif
2640  if( pVSh != m_pActionViewShell )
2641  m_pActionViewShell = nullptr;
2642  }
2643 
2644  if( !m_pActionViewShell || (bChkAction && !m_pActionViewShell->ActionPend()) )
2645  return m_pActionViewShell;
2646 
2647  if( dynamic_cast< const SwEditShell *>( m_pActionViewShell ) != nullptr )
2648  {
2649  // Already scrolled?, then make sure that the view doesn't move!
2650  const bool bOldLock = m_pActionViewShell->IsViewLocked();
2651  m_pActionViewShell->LockView( true );
2652  const bool bOldEndActionByVirDev = m_pActionViewShell->IsEndActionByVirDev();
2653  m_pActionViewShell->SetEndActionByVirDev( true );
2654  static_cast<SwEditShell*>(m_pActionViewShell)->EndAction();
2655  m_pActionViewShell->SetEndActionByVirDev( bOldEndActionByVirDev );
2656  m_pActionViewShell->LockView( bOldLock );
2657 
2658  // bChkJumpMark is only set when the object was also found
2659  if( m_bChkJumpMark )
2660  {
2661  const Point aVisSttPos( DOCUMENTBORDER, DOCUMENTBORDER );
2662  if( GetMedium() && aVisSttPos == m_pActionViewShell->VisArea().Pos() )
2663  ::JumpToSwMark( m_pActionViewShell,
2664  GetMedium()->GetURLObject().GetMark() );
2665  m_bChkJumpMark = false;
2666  }
2667  }
2668  else
2669  m_pActionViewShell->EndAction();
2670 
2671  // if the parser holds the last reference to the document, then we can
2672  // abort here and set an error.
2673  if( 1 == m_xDoc->getReferenceCount() )
2674  {
2675  eState = SvParserState::Error;
2676  }
2677 
2678  SwViewShell *pVSh = m_pActionViewShell;
2679  m_pActionViewShell = nullptr;
2680 
2681  return pVSh;
2682 }
2683 
2684 SwViewShell *SwHTMLParser::CheckActionViewShell()
2685 {
2686  SwViewShell *pVSh = m_xDoc->getIDocumentLayoutAccess().GetCurrentViewShell();
2687  OSL_ENSURE( !pVSh || m_pActionViewShell == pVSh,
2688  "CheckActionViewShell: Who has swapped SwViewShell?" );
2689 #if OSL_DEBUG_LEVEL > 0
2690  if( m_pActionViewShell && !pVSh )
2691  pVSh = nullptr;
2692 #endif
2693  if( pVSh != m_pActionViewShell )
2694  m_pActionViewShell = nullptr;
2695 
2696  return m_pActionViewShell;
2697 }
2698 
2699 void SwHTMLParser::SetAttr_( bool bChkEnd, bool bBeforeTable,
2700  std::deque<std::unique_ptr<HTMLAttr>> *pPostIts )
2701 {
2702  std::unique_ptr<SwPaM> pAttrPam( new SwPaM( *m_pPam->GetPoint() ) );
2703  const SwNodeIndex& rEndIdx = m_pPam->GetPoint()->nNode;
2704  const sal_Int32 nEndCnt = m_pPam->GetPoint()->nContent.GetIndex();
2705  HTMLAttr* pAttr;
2706  SwContentNode* pCNd;
2707 
2708  std::vector<std::unique_ptr<HTMLAttr>> aFields;
2709 
2710  for( auto n = m_aSetAttrTab.size(); n; )
2711  {
2712  pAttr = m_aSetAttrTab[ --n ];
2713  sal_uInt16 nWhich = pAttr->m_pItem->Which();
2714 
2715  sal_uLong nEndParaIdx = pAttr->GetEndParaIdx();
2716  bool bSetAttr;
2717  if( bChkEnd )
2718  {
2719  // Set character attribute with end early on, so set them still in
2720  // the current paragraph (because of JavaScript and various "chats"(?)).
2721  // This shouldn't be done for attributes which are used for
2722  // the whole paragraph, because they could be from a paragraph style
2723  // which can't be set. Because the attributes are inserted with
2724  // SETATTR_DONTREPLACE, they should be able to be set later.
2725  bSetAttr = ( nEndParaIdx < rEndIdx.GetIndex() &&
2726  (RES_LR_SPACE != nWhich || !GetNumInfo().GetNumRule()) ) ||
2727  ( !pAttr->IsLikePara() &&
2728  nEndParaIdx == rEndIdx.GetIndex() &&
2729  pAttr->GetEndCnt() < nEndCnt &&
2730  (isCHRATR(nWhich) || isTXTATR_WITHEND(nWhich)) ) ||
2731  ( bBeforeTable &&
2732  nEndParaIdx == rEndIdx.GetIndex() &&
2733  !pAttr->GetEndCnt() );
2734  }
2735  else
2736  {
2737  // Attributes in body nodes array section shouldn't be set if we are in a
2738  // special nodes array section, but vice versa it's possible.
2739  sal_uLong nEndOfIcons = m_xDoc->GetNodes().GetEndOfExtras().GetIndex();
2740  bSetAttr = nEndParaIdx < rEndIdx.GetIndex() ||
2741  rEndIdx.GetIndex() > nEndOfIcons ||
2742  nEndParaIdx <= nEndOfIcons;
2743  }
2744 
2745  if( bSetAttr )
2746  {
2747  // The attribute shouldn't be in the list of temporary paragraph
2748  // attributes, because then it would be deleted.
2749  while( !m_aParaAttrs.empty() )
2750  {
2751  OSL_ENSURE( pAttr != m_aParaAttrs.back(),
2752  "SetAttr: Attribute must not yet be set" );
2753  m_aParaAttrs.pop_back();
2754  }
2755 
2756  // then set it
2757  m_aSetAttrTab.erase( m_aSetAttrTab.begin() + n );
2758 
2759  while( pAttr )
2760  {
2761  HTMLAttr *pPrev = pAttr->GetPrev();
2762  if( !pAttr->m_bValid )
2763  {
2764  // invalid attributes can be deleted
2765  delete pAttr;
2766  pAttr = pPrev;
2767  continue;
2768  }
2769 
2770  pCNd = pAttr->m_nStartPara.GetNode().GetContentNode();
2771  if( !pCNd )
2772  {
2773  // because of the awful deleting of nodes an index can also
2774  // point to an end node :-(
2775  if ( (pAttr->GetSttPara() == pAttr->GetEndPara()) &&
2776  !isTXTATR_NOEND(nWhich) )
2777  {
2778  // when the end index also points to the node, we don't
2779  // need to set attributes anymore, except if it's a text attribute.
2780  delete pAttr;
2781  pAttr = pPrev;
2782  continue;
2783  }
2784  pCNd = m_xDoc->GetNodes().GoNext( &(pAttr->m_nStartPara) );
2785  if( pCNd )
2786  pAttr->m_nStartContent = 0;
2787  else
2788  {
2789  OSL_ENSURE( false, "SetAttr: GoNext() failed!" );
2790  delete pAttr;
2791  pAttr = pPrev;
2792  continue;
2793  }
2794  }
2795  pAttrPam->GetPoint()->nNode = pAttr->m_nStartPara;
2796 
2797  // because of the deleting of BRs the start index can also
2798  // point behind the end the text
2799  if( pAttr->m_nStartContent > pCNd->Len() )
2800  pAttr->m_nStartContent = pCNd->Len();
2801  pAttrPam->GetPoint()->nContent.Assign( pCNd, pAttr->m_nStartContent );
2802 
2803  pAttrPam->SetMark();
2804  if ( (pAttr->GetSttPara() != pAttr->GetEndPara()) &&
2805  !isTXTATR_NOEND(nWhich) )
2806  {
2807  pCNd = pAttr->m_nEndPara.GetNode().GetContentNode();
2808  if( !pCNd )
2809  {
2810  pCNd = SwNodes::GoPrevious( &(pAttr->m_nEndPara) );
2811  if( pCNd )
2812  pAttr->m_nEndContent = pCNd->Len();
2813  else
2814  {
2815  OSL_ENSURE( false, "SetAttr: GoPrevious() failed!" );
2816  pAttrPam->DeleteMark();
2817  delete pAttr;
2818  pAttr = pPrev;
2819  continue;
2820  }
2821  }
2822 
2823  pAttrPam->GetPoint()->nNode = pAttr->m_nEndPara;
2824  }
2825  else if( pAttr->IsLikePara() )
2826  {
2827  pAttr->m_nEndContent = pCNd->Len();
2828  }
2829 
2830  // because of the deleting of BRs the start index can also
2831  // point behind the end the text
2832  if( pAttr->m_nEndContent > pCNd->Len() )
2833  pAttr->m_nEndContent = pCNd->Len();
2834 
2835  pAttrPam->GetPoint()->nContent.Assign( pCNd, pAttr->m_nEndContent );
2836  if( bBeforeTable &&
2837  pAttrPam->GetPoint()->nNode.GetIndex() ==
2838  rEndIdx.GetIndex() )
2839  {
2840  // If we're before inserting a table and the attribute ends
2841  // in the current node, then we must end it in the previous
2842  // node or discard it, if it starts in that node.
2843  if( nWhich != RES_BREAK && nWhich != RES_PAGEDESC &&
2844  !isTXTATR_NOEND(nWhich) )
2845  {
2846  if( pAttrPam->GetMark()->nNode.GetIndex() !=
2847  rEndIdx.GetIndex() )
2848  {
2849  OSL_ENSURE( !pAttrPam->GetPoint()->nContent.GetIndex(),
2850  "Content-Position before table not 0???" );
2851  pAttrPam->Move( fnMoveBackward );
2852  }
2853  else
2854  {
2855  pAttrPam->DeleteMark();
2856  delete pAttr;
2857  pAttr = pPrev;
2858  continue;
2859  }
2860  }
2861  }
2862 
2863  switch( nWhich )
2864  {
2865  case RES_FLTR_BOOKMARK: // insert bookmark
2866  {
2867  const OUString sName( static_cast<SfxStringItem*>(pAttr->m_pItem.get())->GetValue() );
2868  IDocumentMarkAccess* const pMarkAccess = m_xDoc->getIDocumentMarkAccess();
2869  IDocumentMarkAccess::const_iterator_t ppBkmk = pMarkAccess->findMark( sName );
2870  if( ppBkmk != pMarkAccess->getAllMarksEnd() &&
2871  (*ppBkmk)->GetMarkStart() == *pAttrPam->GetPoint() )
2872  break; // do not generate duplicates on this position
2873  pAttrPam->DeleteMark();
2874  const ::sw::mark::IMark* const pNewMark = pMarkAccess->makeMark(
2875  *pAttrPam,
2876  sName,
2877  IDocumentMarkAccess::MarkType::BOOKMARK,
2878  ::sw::mark::InsertMode::New);
2879 
2880  // jump to bookmark
2881  if( JumpToMarks::Mark == m_eJumpTo && pNewMark->GetName() == m_sJmpMark )
2882  {
2883  m_bChkJumpMark = true;
2884  m_eJumpTo = JumpToMarks::NONE;
2885  }
2886  }
2887  break;
2888  case RES_TXTATR_FIELD:
2889  case RES_TXTATR_ANNOTATION:
2890  case RES_TXTATR_INPUTFIELD:
2891  {
2892  SwFieldIds nFieldWhich =
2893  pPostIts
2894  ? static_cast<const SwFormatField *>(pAttr->m_pItem.get())->GetField()->GetTyp()->Which()
2895  : SwFieldIds::Database;
2896  if( pPostIts && (SwFieldIds::Postit == nFieldWhich ||
2897  SwFieldIds::Script == nFieldWhich) )
2898  {
2899  pPostIts->emplace_front( pAttr );
2900  }
2901  else
2902  {
2903  aFields.emplace_back( pAttr);
2904  }
2905  }
2906  pAttrPam->DeleteMark();
2907  pAttr = pPrev;
2908  continue;
2909 
2910  case RES_LR_SPACE:
2911  if( pAttrPam->GetPoint()->nNode.GetIndex() ==
2912  pAttrPam->GetMark()->nNode.GetIndex())
2913  {
2914  // because of numbering set this attribute directly at node
2915  pCNd->SetAttr( *pAttr->m_pItem );
2916  break;
2917  }
2918  OSL_ENSURE( false,
2919  "LRSpace set over multiple paragraphs!" );
2920  [[fallthrough]]; // (shouldn't reach this point anyway)
2921 
2922  // tdf#94088 expand RES_BACKGROUND to the new fill attribute
2923  // definitions in the range [XATTR_FILL_FIRST .. XATTR_FILL_LAST].
2924  // This is the right place in the future if the adapted fill attributes
2925  // may be handled more directly in HTML import to handle them.
2926  case RES_BACKGROUND:
2927  {
2928  const SvxBrushItem& rBrush = static_cast< SvxBrushItem& >(*pAttr->m_pItem);
2929  SfxItemSet aNewSet(m_xDoc->GetAttrPool(), svl::Items<XATTR_FILL_FIRST, XATTR_FILL_LAST>{});
2930 
2931  setSvxBrushItemAsFillAttributesToTargetSet(rBrush, aNewSet);
2932  m_xDoc->getIDocumentContentOperations().InsertItemSet(*pAttrPam, aNewSet, SetAttrMode::DONTREPLACE);
2933  break;
2934  }
2935  default:
2936 
2937  // maybe jump to a bookmark
2938  if( RES_TXTATR_INETFMT == nWhich &&
2939  JumpToMarks::Mark == m_eJumpTo &&
2940  m_sJmpMark == static_cast<SwFormatINetFormat*>(pAttr->m_pItem.get())->GetName() )
2941  {
2942  m_bChkJumpMark = true;
2943  m_eJumpTo = JumpToMarks::NONE;
2944  }
2945 
2946  m_xDoc->getIDocumentContentOperations().InsertPoolItem( *pAttrPam, *pAttr->m_pItem, SetAttrMode::DONTREPLACE );
2947  }
2948  pAttrPam->DeleteMark();
2949 
2950  delete pAttr;
2951  pAttr = pPrev;
2952  }
2953  }
2954  }
2955 
2956  for( auto n = m_aMoveFlyFrames.size(); n; )
2957  {
2958  SwFrameFormat *pFrameFormat = m_aMoveFlyFrames[ --n ];
2959 
2960  const SwFormatAnchor& rAnchor = pFrameFormat->GetAnchor();
2961  OSL_ENSURE( RndStdIds::FLY_AT_PARA == rAnchor.GetAnchorId(),
2962  "Only At-Para flys need special handling" );
2963  const SwPosition *pFlyPos = rAnchor.GetContentAnchor();
2964  sal_uLong nFlyParaIdx = pFlyPos->nNode.GetIndex();
2965  bool bMoveFly;
2966  if( bChkEnd )
2967  {
2968  bMoveFly = nFlyParaIdx < rEndIdx.GetIndex() ||
2969  ( nFlyParaIdx == rEndIdx.GetIndex() &&
2970  m_aMoveFlyCnts[n] < nEndCnt );
2971  }
2972  else
2973  {
2974  sal_uLong nEndOfIcons = m_xDoc->GetNodes().GetEndOfExtras().GetIndex();
2975  bMoveFly = nFlyParaIdx < rEndIdx.GetIndex() ||
2976  rEndIdx.GetIndex() > nEndOfIcons ||
2977  nFlyParaIdx <= nEndOfIcons;
2978  }
2979  if( bMoveFly )
2980  {
2981  pFrameFormat->DelFrames();
2982  *pAttrPam->GetPoint() = *pFlyPos;
2983  pAttrPam->GetPoint()->nContent.Assign( pAttrPam->GetContentNode(),
2984  m_aMoveFlyCnts[n] );
2985  SwFormatAnchor aAnchor( rAnchor );
2986  aAnchor.SetType( RndStdIds::FLY_AT_CHAR );
2987  aAnchor.SetAnchor( pAttrPam->GetPoint() );
2988  pFrameFormat->SetFormatAttr( aAnchor );
2989 
2990  const SwFormatHoriOrient& rHoriOri = pFrameFormat->GetHoriOrient();
2991  if( text::HoriOrientation::LEFT == rHoriOri.GetHoriOrient() )
2992  {
2993  SwFormatHoriOrient aHoriOri( rHoriOri );
2994  aHoriOri.SetRelationOrient( text::RelOrientation::CHAR );
2995  pFrameFormat->SetFormatAttr( aHoriOri );
2996  }
2997  const SwFormatVertOrient& rVertOri = pFrameFormat->GetVertOrient();
2998  if( text::VertOrientation::TOP == rVertOri.GetVertOrient() )
2999  {
3000  SwFormatVertOrient aVertOri( rVertOri );
3001  aVertOri.SetRelationOrient( text::RelOrientation::CHAR );
3002  pFrameFormat->SetFormatAttr( aVertOri );
3003  }
3004 
3005  pFrameFormat->MakeFrames();
3006  m_aMoveFlyFrames.erase( m_aMoveFlyFrames.begin() + n );
3007  m_aMoveFlyCnts.erase( m_aMoveFlyCnts.begin() + n );
3008  }
3009  }
3010  for (auto & field : aFields)
3011  {
3012  pCNd = field->m_nStartPara.GetNode().GetContentNode();
3013  pAttrPam->GetPoint()->nNode = field->m_nStartPara;
3014  pAttrPam->GetPoint()->nContent.Assign( pCNd, field->m_nStartContent );
3015 
3016  if( bBeforeTable &&
3017  pAttrPam->GetPoint()->nNode.GetIndex() == rEndIdx.GetIndex() )
3018  {
3019  OSL_ENSURE( !bBeforeTable, "Aha, the case does occur" );
3020  OSL_ENSURE( !pAttrPam->GetPoint()->nContent.GetIndex(),
3021  "Content-Position before table not 0???" );
3022  // !!!
3023  pAttrPam->Move( fnMoveBackward );
3024  }
3025 
3026  m_xDoc->getIDocumentContentOperations().InsertPoolItem( *pAttrPam, *field->m_pItem );
3027 
3028  field.reset();
3029  }
3030  aFields.clear();
3031 }
3032 
3033 void SwHTMLParser::NewAttr(const std::shared_ptr<HTMLAttrTable>& rAttrTable, HTMLAttr **ppAttr, const SfxPoolItem& rItem )
3034 {
3035  // Font height and font colour as well as escape attributes may not be
3036  // combined. Therefore they're saved in a list and in it the last opened
3037  // attribute is at the beginning and count is always one. For all other
3038  // attributes count is just incremented.
3039  if( *ppAttr )
3040  {
3041  HTMLAttr *pAttr = new HTMLAttr(*m_pPam->GetPoint(), rItem, ppAttr, rAttrTable);
3042  pAttr->InsertNext( *ppAttr );
3043  (*ppAttr) = pAttr;
3044  }
3045  else
3046  (*ppAttr) = new HTMLAttr(*m_pPam->GetPoint(), rItem, ppAttr, rAttrTable);
3047 }
3048 
3049 bool SwHTMLParser::EndAttr( HTMLAttr* pAttr, bool bChkEmpty )
3050 {
3051  bool bRet = true;
3052 
3053  // The list header is saved in the attribute.
3054  HTMLAttr **ppHead = pAttr->m_ppHead;
3055 
3056  OSL_ENSURE( ppHead, "No list header attribute found!" );
3057 
3058  // save the current position as end position
3059  const SwNodeIndex* pEndIdx = &m_pPam->GetPoint()->nNode;
3060  sal_Int32 nEndCnt = m_pPam->GetPoint()->nContent.GetIndex();
3061 
3062  // Is the last started or an earlier started attribute being ended?
3063  HTMLAttr *pLast = nullptr;
3064  if( ppHead && pAttr != *ppHead )
3065  {
3066  // The last started attribute isn't being ended
3067 
3068  // Then we look for attribute which was started immediately afterwards,
3069  // which has also not yet been ended (otherwise it would no longer be
3070  // in the list).
3071  pLast = *ppHead;
3072  while( pLast && pLast->GetNext() != pAttr )
3073  pLast = pLast->GetNext();
3074 
3075  OSL_ENSURE( pLast, "Attribute not found in own list!" );
3076  }
3077 
3078  bool bMoveBack = false;
3079  sal_uInt16 nWhich = pAttr->m_pItem->Which();
3080  if( !nEndCnt && RES_PARATR_BEGIN <= nWhich &&
3081  *pEndIdx != pAttr->GetSttPara() )
3082  {
3083  // Then move back one position in the content!
3084  bMoveBack = m_pPam->Move( fnMoveBackward );
3085  nEndCnt = m_pPam->GetPoint()->nContent.GetIndex();
3086  }
3087 
3088  // now end the attribute
3089  HTMLAttr *pNext = pAttr->GetNext();
3090 
3091  bool bInsert;
3092  sal_uInt16 nScriptItem = 0;
3093  bool bScript = false;
3094  // does it have a non-empty range?
3095  if( !bChkEmpty || (RES_PARATR_BEGIN <= nWhich && bMoveBack) ||
3096  RES_PAGEDESC == nWhich || RES_BREAK == nWhich ||
3097  *pEndIdx != pAttr->GetSttPara() ||
3098  nEndCnt != pAttr->GetSttCnt() )
3099  {
3100  bInsert = true;
3101  // We do some optimization for script dependent attributes here.
3102  if( *pEndIdx == pAttr->GetSttPara() )
3103  {
3104  lcl_swhtml_getItemInfo( *pAttr, bScript, nScriptItem );
3105  }
3106  }
3107  else
3108  {
3109  bInsert = false;
3110  }
3111 
3112  const SwTextNode *pTextNd = (bInsert && bScript) ?
3113  pAttr->GetSttPara().GetNode().GetTextNode() :
3114  nullptr;
3115 
3116  if (pTextNd)
3117  {
3118  const OUString& rText = pTextNd->GetText();
3119  sal_uInt16 nScriptText = g_pBreakIt->GetBreakIter()->getScriptType(
3120  rText, pAttr->GetSttCnt() );
3121  sal_Int32 nScriptEnd = g_pBreakIt->GetBreakIter()
3122  ->endOfScript( rText, pAttr->GetSttCnt(), nScriptText );
3123  while (nScriptEnd < nEndCnt && nScriptEnd != -1)
3124  {
3125  if( nScriptItem == nScriptText )
3126  {
3127  HTMLAttr *pSetAttr = pAttr->Clone( *pEndIdx, nScriptEnd );
3128  pSetAttr->ClearPrev();
3129  if( pNext )
3130  pNext->InsertPrev( pSetAttr );
3131  else
3132  {
3133  if (pSetAttr->m_bInsAtStart)
3134  m_aSetAttrTab.push_front( pSetAttr );
3135  else
3136  m_aSetAttrTab.push_back( pSetAttr );
3137  }
3138  }
3139  pAttr->m_nStartContent = nScriptEnd;
3140  nScriptText = g_pBreakIt->GetBreakIter()->getScriptType(
3141  rText, nScriptEnd );
3142  nScriptEnd = g_pBreakIt->GetBreakIter()
3143  ->endOfScript( rText, nScriptEnd, nScriptText );
3144  }
3145  bInsert = nScriptItem == nScriptText;
3146  }
3147  if( bInsert )
3148  {
3149  pAttr->m_nEndPara = *pEndIdx;
3150  pAttr->m_nEndContent = nEndCnt;
3151  pAttr->m_bInsAtStart = RES_TXTATR_INETFMT != nWhich &&
3152  RES_TXTATR_CHARFMT != nWhich;
3153 
3154  if( !pNext )
3155  {
3156  // No open attributes of that type exists any longer, so all
3157  // can be set. Except they depend on another attribute, then
3158  // they're appended there.
3159  if (pAttr->m_bInsAtStart)
3160  m_aSetAttrTab.push_front( pAttr );
3161  else
3162  m_aSetAttrTab.push_back( pAttr );
3163  }
3164  else
3165  {
3166  // There are other open attributes of that type,
3167  // therefore the setting must be postponed.
3168  // Hence the current attribute is added at the end
3169  // of the Prev-List of the successor.
3170  pNext->InsertPrev( pAttr );
3171  }
3172  }
3173  else
3174  {
3175  // Then don't insert, but delete. Because of the "faking" of styles
3176  // by hard attributing there can be also other empty attributes in the
3177  // Prev-List, which must be set anyway.
3178  HTMLAttr *pPrev = pAttr->GetPrev();
3179  bRet = false;
3180  delete pAttr;
3181 
3182  if( pPrev )
3183  {
3184  // The previous attributes must be set anyway.
3185  if( pNext )
3186  pNext->InsertPrev( pPrev );
3187  else
3188  {
3189  if (pPrev->m_bInsAtStart)
3190  m_aSetAttrTab.push_front( pPrev );
3191  else
3192  m_aSetAttrTab.push_back( pPrev );
3193  }
3194  }
3195 
3196  }
3197 
3198  // If the first attribute of the list was set, then the list header
3199  // must be corrected as well.
3200  if( pLast )
3201  pLast->m_pNext = pNext;
3202  else if( ppHead )
3203  *ppHead = pNext;
3204 
3205  if( bMoveBack )
3206  m_pPam->Move( fnMoveForward );
3207 
3208  return bRet;
3209 }
3210 
3211 void SwHTMLParser::DeleteAttr( HTMLAttr* pAttr )
3212 {
3213  // preliminary paragraph attributes are not allowed here, they could
3214  // be set here and then the pointers become invalid!
3215  OSL_ENSURE(m_aParaAttrs.empty(),
3216  "Danger: there are non-final paragraph attributes");
3217  m_aParaAttrs.clear();
3218 
3219  // The list header is saved in the attribute
3220  HTMLAttr **ppHead = pAttr->m_ppHead;
3221 
3222  OSL_ENSURE( ppHead, "no list header attribute found!" );
3223 
3224  // Is the last started or an earlier started attribute being removed?
3225  HTMLAttr *pLast = nullptr;
3226  if( ppHead && pAttr != *ppHead )
3227  {
3228  // The last started attribute isn't being ended
3229 
3230  // Then we look for attribute which was started immediately afterwards,
3231  // which has also not yet been ended (otherwise it would no longer be
3232  // in the list).
3233  pLast = *ppHead;
3234  while( pLast && pLast->GetNext() != pAttr )
3235  pLast = pLast->GetNext();
3236 
3237  OSL_ENSURE( pLast, "Attribute not found in own list!" );
3238  }
3239 
3240  // now delete the attribute
3241  HTMLAttr *pNext = pAttr->GetNext();
3242  HTMLAttr *pPrev = pAttr->GetPrev();
3243  //hold ref to xAttrTab until end of scope to ensure *ppHead validity
3244  std::shared_ptr<HTMLAttrTable> xKeepAlive(pAttr->m_xAttrTab);
3245  delete pAttr;
3246 
3247  if( pPrev )
3248  {
3249  // The previous attributes must be set anyway.
3250  if( pNext )
3251  pNext->InsertPrev( pPrev );
3252  else
3253  {
3254  if (pPrev->m_bInsAtStart)
3255  m_aSetAttrTab.push_front( pPrev );
3256  else
3257  m_aSetAttrTab.push_back( pPrev );
3258  }
3259  }
3260 
3261  // If the first attribute of the list was deleted, then the list header
3262  // must be corrected as well.
3263  if( pLast )
3264  pLast->m_pNext = pNext;
3265  else if( ppHead )
3266  *ppHead = pNext;
3267 }
3268 
3269 void SwHTMLParser::SaveAttrTab(std::shared_ptr<HTMLAttrTable> const & rNewAttrTab)
3270 {
3271  // preliminary paragraph attributes are not allowed here, they could
3272  // be set here and then the pointers become invalid!
3273  OSL_ENSURE(m_aParaAttrs.empty(),
3274  "Danger: there are non-final paragraph attributes");
3275  m_aParaAttrs.clear();
3276 
3277  HTMLAttr** pHTMLAttributes = reinterpret_cast<HTMLAttr**>(m_xAttrTab.get());
3278  HTMLAttr** pSaveAttributes = reinterpret_cast<HTMLAttr**>(rNewAttrTab.get());
3279 
3280  for (auto nCnt = sizeof(HTMLAttrTable) / sizeof(HTMLAttr*); nCnt--; ++pHTMLAttributes, ++pSaveAttributes)
3281  {
3282  *pSaveAttributes = *pHTMLAttributes;
3283 
3284  HTMLAttr *pAttr = *pSaveAttributes;
3285  while (pAttr)
3286  {
3287  pAttr->SetHead(pSaveAttributes, rNewAttrTab);
3288  pAttr = pAttr->GetNext();
3289  }
3290 
3291  *pHTMLAttributes = nullptr;
3292  }
3293 }
3294 
3295 void SwHTMLParser::SplitAttrTab( std::shared_ptr<HTMLAttrTable> const & rNewAttrTab,
3296  bool bMoveEndBack )
3297 {
3298  // preliminary paragraph attributes are not allowed here, they could
3299  // be set here and then the pointers become invalid!
3300  OSL_ENSURE(m_aParaAttrs.empty(),
3301  "Danger: there are non-final paragraph attributes");
3302  m_aParaAttrs.clear();
3303 
3304  const SwNodeIndex& nSttIdx = m_pPam->GetPoint()->nNode;
3305  SwNodeIndex nEndIdx( nSttIdx );
3306 
3307  // close all still open attributes and re-open them after the table
3308  HTMLAttr** pHTMLAttributes = reinterpret_cast<HTMLAttr**>(m_xAttrTab.get());
3309  HTMLAttr** pSaveAttributes = reinterpret_cast<HTMLAttr**>(rNewAttrTab.get());
3310  bool bSetAttr = true;
3311  const sal_Int32 nSttCnt = m_pPam->GetPoint()->nContent.GetIndex();
3312  sal_Int32 nEndCnt = nSttCnt;
3313 
3314  if( bMoveEndBack )
3315  {
3316  sal_uLong nOldEnd = nEndIdx.GetIndex();
3317  sal_uLong nTmpIdx;
3318  if( ( nTmpIdx = m_xDoc->GetNodes().GetEndOfExtras().GetIndex()) >= nOldEnd ||
3319  ( nTmpIdx = m_xDoc->GetNodes().GetEndOfAutotext().GetIndex()) >= nOldEnd )
3320  {
3321  nTmpIdx = m_xDoc->GetNodes().GetEndOfInserts().GetIndex();
3322  }
3323  SwContentNode* pCNd = SwNodes::GoPrevious(&nEndIdx);
3324 
3325  // Don't set attributes, when the PaM was moved outside of the content area.
3326  bSetAttr = pCNd && nTmpIdx < nEndIdx.GetIndex();
3327 
3328  nEndCnt = (bSetAttr ? pCNd->Len() : 0);
3329  }
3330  for (auto nCnt = sizeof(HTMLAttrTable) / sizeof(HTMLAttr*); nCnt--; (++pHTMLAttributes, ++pSaveAttributes))
3331  {
3332  HTMLAttr *pAttr = *pHTMLAttributes;
3333  *pSaveAttributes = nullptr;
3334  while( pAttr )
3335  {
3336  HTMLAttr *pNext = pAttr->GetNext();
3337  HTMLAttr *pPrev = pAttr->GetPrev();
3338 
3339  if( bSetAttr &&
3340  ( pAttr->GetSttParaIdx() < nEndIdx.GetIndex() ||
3341  (pAttr->GetSttPara() == nEndIdx &&
3342  pAttr->GetSttCnt() != nEndCnt) ) )
3343  {
3344  // The attribute must be set before the list. We need the
3345  // original and therefore we clone it, because pointer to the
3346  // attribute exist in the other contexts. The Next-List is lost
3347  // in doing so, but the Previous-List is preserved.
3348  HTMLAttr *pSetAttr = pAttr->Clone( nEndIdx, nEndCnt );
3349 
3350  if( pNext )
3351  pNext->InsertPrev( pSetAttr );
3352  else
3353  {
3354  if (pSetAttr->m_bInsAtStart)
3355  m_aSetAttrTab.push_front( pSetAttr );
3356  else
3357  m_aSetAttrTab.push_back( pSetAttr );
3358  }
3359  }
3360  else if( pPrev )
3361  {
3362  // If the attribute doesn't need to be set before the table, then
3363  // the previous attributes must still be set.
3364  if( pNext )
3365  pNext->InsertPrev( pPrev );
3366  else
3367  {
3368  if (pPrev->m_bInsAtStart)
3369  m_aSetAttrTab.push_front( pPrev );
3370  else
3371  m_aSetAttrTab.push_back( pPrev );
3372  }
3373  }
3374 
3375  // set the start of the attribute anew and break link
3376  pAttr->Reset(nSttIdx, nSttCnt, pSaveAttributes, rNewAttrTab);
3377 
3378  if (*pSaveAttributes)
3379  {
3380  HTMLAttr *pSAttr = *pSaveAttributes;
3381  while( pSAttr->GetNext() )
3382  pSAttr = pSAttr->GetNext();
3383  pSAttr->InsertNext( pAttr );
3384  }
3385  else
3386  *pSaveAttributes = pAttr;
3387 
3388  pAttr = pNext;
3389  }
3390 
3391  *pHTMLAttributes = nullptr;
3392  }
3393 }
3394 
3395 void SwHTMLParser::RestoreAttrTab(std::shared_ptr<HTMLAttrTable> const & rNewAttrTab)
3396 {
3397  // preliminary paragraph attributes are not allowed here, they could
3398  // be set here and then the pointers become invalid!
3399  OSL_ENSURE(m_aParaAttrs.empty(),
3400  "Danger: there are non-final paragraph attributes");
3401  m_aParaAttrs.clear();
3402 
3403  HTMLAttr** pHTMLAttributes = reinterpret_cast<HTMLAttr**>(m_xAttrTab.get());
3404  HTMLAttr** pSaveAttributes = reinterpret_cast<HTMLAttr**>(rNewAttrTab.get());
3405 
3406  for (auto nCnt = sizeof(HTMLAttrTable) / sizeof(HTMLAttr*); nCnt--; ++pHTMLAttributes, ++pSaveAttributes)
3407  {
3408  OSL_ENSURE(!*pHTMLAttributes, "The attribute table is not empty!");
3409 
3410  *pHTMLAttributes = *pSaveAttributes;
3411 
3412  HTMLAttr *pAttr = *pHTMLAttributes;
3413  while (pAttr)
3414  {
3415  OSL_ENSURE( !pAttr->GetPrev() || !pAttr->GetPrev()->m_ppHead,
3416  "Previous attribute has still a header" );
3417  pAttr->SetHead(pHTMLAttributes, m_xAttrTab);
3418  pAttr = pAttr->GetNext();
3419  }
3420 
3421  *pSaveAttributes = nullptr;
3422  }
3423 }
3424 
3425 void SwHTMLParser::InsertAttr( const SfxPoolItem& rItem, bool bInsAtStart )
3426 {
3427  HTMLAttr* pTmp = new HTMLAttr(*m_pPam->GetPoint(), rItem, nullptr, std::shared_ptr<HTMLAttrTable>());
3428  if (bInsAtStart)
3429  m_aSetAttrTab.push_front( pTmp );
3430  else
3431  m_aSetAttrTab.push_back( pTmp );
3432 }
3433 
3434 void SwHTMLParser::InsertAttrs( std::deque<std::unique_ptr<HTMLAttr>> rAttrs )
3435 {
3436  while( !rAttrs.empty() )
3437  {
3438  std::unique_ptr<HTMLAttr> pAttr = std::move(rAttrs.front());
3439  InsertAttr( pAttr->GetItem(), false );
3440  rAttrs.pop_front();
3441  }
3442 }
3443 
3444 void SwHTMLParser::NewStdAttr( HtmlTokenId nToken )
3445 {
3446  OUString aId, aStyle, aLang, aDir;
3447  OUString aClass;
3448 
3449  const HTMLOptions& rHTMLOptions = GetOptions();
3450  for (size_t i = rHTMLOptions.size(); i; )
3451  {
3452  const HTMLOption& rOption = rHTMLOptions[--i];
3453  switch( rOption.GetToken() )
3454  {
3455  case HtmlOptionId::ID:
3456  aId = rOption.GetString();
3457  break;
3458  case HtmlOptionId::STYLE:
3459  aStyle = rOption.GetString();
3460  break;
3461  case HtmlOptionId::CLASS:
3462  aClass = rOption.GetString();
3463  break;
3464  case HtmlOptionId::LANG:
3465  aLang = rOption.GetString();
3466  break;
3467  case HtmlOptionId::DIR:
3468  aDir = rOption.GetString();
3469  break;
3470  default: break;
3471  }
3472  }
3473 
3474  // create a new context
3475  std::unique_ptr<HTMLAttrContext> xCntxt(new HTMLAttrContext(nToken));
3476 
3477  // parse styles
3478  if( HasStyleOptions( aStyle, aId, aClass, &aLang, &aDir ) )
3479  {
3480  SfxItemSet aItemSet( m_xDoc->GetAttrPool(), m_pCSS1Parser->GetWhichMap() );
3481  SvxCSS1PropertyInfo aPropInfo;
3482 
3483  if( ParseStyleOptions( aStyle, aId, aClass, aItemSet, aPropInfo, &aLang, &aDir ) )
3484  {
3485  if( HtmlTokenId::SPAN_ON != nToken || aClass.isEmpty() ||
3486  !CreateContainer( aClass, aItemSet, aPropInfo, xCntxt.get() ) )
3487  DoPositioning( aItemSet, aPropInfo, xCntxt.get() );
3488  InsertAttrs( aItemSet, aPropInfo, xCntxt.get(), true );
3489  }
3490  }
3491 
3492  // save the context
3493  PushContext(xCntxt);
3494 }
3495 
3496 void SwHTMLParser::NewStdAttr( HtmlTokenId nToken,
3497  HTMLAttr **ppAttr, const SfxPoolItem & rItem,
3498  HTMLAttr **ppAttr2, const SfxPoolItem *pItem2,
3499  HTMLAttr **ppAttr3, const SfxPoolItem *pItem3 )
3500 {
3501  OUString aId, aStyle, aClass, aLang, aDir;
3502 
3503  const HTMLOptions& rHTMLOptions = GetOptions();
3504  for (size_t i = rHTMLOptions.size(); i; )
3505  {
3506  const HTMLOption& rOption = rHTMLOptions[--i];
3507  switch( rOption.GetToken() )
3508  {
3509  case HtmlOptionId::ID:
3510  aId = rOption.GetString();
3511  break;
3512  case HtmlOptionId::STYLE:
3513  aStyle = rOption.GetString();
3514  break;
3515  case HtmlOptionId::CLASS:
3516  aClass = rOption.GetString();
3517  break;
3518  case HtmlOptionId::LANG:
3519  aLang = rOption.GetString();
3520  break;
3521  case HtmlOptionId::DIR:
3522  aDir = rOption.GetString();
3523  break;
3524  default: break;
3525  }
3526  }
3527 
3528  // create a new context
3529  std::unique_ptr<HTMLAttrContext> xCntxt(new HTMLAttrContext(nToken));
3530 
3531  // parse styles
3532  if( HasStyleOptions( aStyle, aId, aClass, &aLang, &aDir ) )
3533  {
3534  SfxItemSet aItemSet( m_xDoc->GetAttrPool(), m_pCSS1Parser->GetWhichMap() );
3535  SvxCSS1PropertyInfo aPropInfo;
3536 
3537  aItemSet.Put( rItem );
3538  if( pItem2 )
3539  aItemSet.Put( *pItem2 );
3540  if( pItem3 )
3541  aItemSet.Put( *pItem3 );
3542 
3543  if( ParseStyleOptions( aStyle, aId, aClass, aItemSet, aPropInfo, &aLang, &aDir ) )
3544  DoPositioning( aItemSet, aPropInfo, xCntxt.get() );
3545 
3546  InsertAttrs( aItemSet, aPropInfo, xCntxt.get(), true );
3547  }
3548  else
3549  {
3550  InsertAttr( ppAttr ,rItem, xCntxt.get() );
3551  if( pItem2 )
3552  {
3553  OSL_ENSURE( ppAttr2, "missing table entry for item2" );
3554  InsertAttr( ppAttr2, *pItem2, xCntxt.get() );
3555  }
3556  if( pItem3 )
3557  {
3558  OSL_ENSURE( ppAttr3, "missing table entry for item3" );
3559  InsertAttr( ppAttr3, *pItem3, xCntxt.get() );
3560  }
3561  }
3562 
3563  // save the context
3564  PushContext(xCntxt);
3565 }
3566 
3567 void SwHTMLParser::EndTag( HtmlTokenId nToken )
3568 {
3569  // fetch context
3570  std::unique_ptr<HTMLAttrContext> xCntxt(PopContext(getOnToken(nToken)));
3571  if (xCntxt)
3572  {
3573  // and maybe end the attributes
3574  EndContext(xCntxt.get());
3575  }
3576 }
3577 
3578 void SwHTMLParser::NewBasefontAttr()
3579 {
3580  OUString aId, aStyle, aClass, aLang, aDir;
3581  sal_uInt16 nSize = 3;
3582 
3583  const HTMLOptions& rHTMLOptions = GetOptions();
3584  for (size_t i = rHTMLOptions.size(); i; )
3585  {
3586  const HTMLOption& rOption = rHTMLOptions[--i];
3587  switch( rOption.GetToken() )
3588  {
3589  case HtmlOptionId::SIZE:
3590  nSize = static_cast<sal_uInt16>(rOption.GetNumber());
3591  break;
3592  case HtmlOptionId::ID:
3593  aId = rOption.GetString();
3594  break;
3595  case HtmlOptionId::STYLE:
3596  aStyle = rOption.GetString();
3597  break;
3598  case HtmlOptionId::CLASS:
3599  aClass = rOption.GetString();
3600  break;
3601  case HtmlOptionId::LANG:
3602  aLang = rOption.GetString();
3603  break;
3604  case HtmlOptionId::DIR:
3605  aDir = rOption.GetString();
3606  break;
3607  default: break;
3608  }
3609  }
3610 
3611  if( nSize < 1 )
3612  nSize = 1;
3613 
3614  if( nSize > 7 )
3615  nSize = 7;
3616 
3617  // create a new context
3618  std::unique_ptr<HTMLAttrContext> xCntxt(new HTMLAttrContext(HtmlTokenId::BASEFONT_ON));
3619 
3620  // parse styles
3621  if( HasStyleOptions( aStyle, aId, aClass, &aLang, &aDir ) )
3622  {
3623  SfxItemSet aItemSet( m_xDoc->GetAttrPool(), m_pCSS1Parser->GetWhichMap() );
3624  SvxCSS1PropertyInfo aPropInfo;
3625 
3626  //CJK has different defaults
3627  SvxFontHeightItem aFontHeight( m_aFontHeights[nSize-1], 100, RES_CHRATR_FONTSIZE );
3628  aItemSet.Put( aFontHeight );
3629  SvxFontHeightItem aFontHeightCJK( m_aFontHeights[nSize-1], 100, RES_CHRATR_CJK_FONTSIZE );
3630  aItemSet.Put( aFontHeightCJK );
3631  //Complex type can contain so many types of letters,
3632  //that it's not really worthy to bother, IMO.
3633  //Still, I have set a default.
3634  SvxFontHeightItem aFontHeightCTL( m_aFontHeights[nSize-1], 100, RES_CHRATR_CTL_FONTSIZE );
3635  aItemSet.Put( aFontHeightCTL );
3636 
3637  if( ParseStyleOptions( aStyle, aId, aClass, aItemSet, aPropInfo, &aLang, &aDir ) )
3638  DoPositioning( aItemSet, aPropInfo, xCntxt.get() );
3639 
3640  InsertAttrs( aItemSet, aPropInfo, xCntxt.get(), true );
3641  }
3642  else
3643  {
3644  SvxFontHeightItem aFontHeight( m_aFontHeights[nSize-1], 100, RES_CHRATR_FONTSIZE );
3645  InsertAttr( &m_xAttrTab->pFontHeight, aFontHeight, xCntxt.get() );
3646  SvxFontHeightItem aFontHeightCJK( m_aFontHeights[nSize-1], 100, RES_CHRATR_CJK_FONTSIZE );
3647  InsertAttr( &m_xAttrTab->pFontHeightCJK, aFontHeightCJK, xCntxt.get() );
3648  SvxFontHeightItem aFontHeightCTL( m_aFontHeights[nSize-1], 100, RES_CHRATR_CTL_FONTSIZE );
3649  InsertAttr( &m_xAttrTab->pFontHeightCTL, aFontHeightCTL, xCntxt.get() );
3650  }
3651 
3652  // save the context
3653  PushContext(xCntxt);
3654 
3655  // save the font size
3656  m_aBaseFontStack.push_back( nSize );
3657 }
3658 
3659 void SwHTMLParser::EndBasefontAttr()
3660 {
3661  EndTag( HtmlTokenId::BASEFONT_ON );
3662 
3663  // avoid stack underflow in tables
3664  if( m_aBaseFontStack.size() > m_nBaseFontStMin )
3665  m_aBaseFontStack.erase( m_aBaseFontStack.begin() + m_aBaseFontStack.size() - 1 );
3666 }
3667 
3668 void SwHTMLParser::NewFontAttr( HtmlTokenId nToken )
3669 {
3670  sal_uInt16 nBaseSize =
3671  ( m_aBaseFontStack.size() > m_nBaseFontStMin
3672  ? (m_aBaseFontStack[m_aBaseFontStack.size()-1] & FONTSIZE_MASK)
3673  : 3 );
3674  sal_uInt16 nFontSize =
3675  ( m_aFontStack.size() > m_nFontStMin
3676  ? (m_aFontStack[m_aFontStack.size()-1] & FONTSIZE_MASK)
3677  : nBaseSize );
3678 
3679  OUString aFace, aId, aStyle, aClass, aLang, aDir;
3680  Color aColor;
3681  sal_uLong nFontHeight = 0; // actual font height to set
3682  sal_uInt16 nSize = 0; // font height in Netscape notation (1-7)
3683  bool bColor = false;
3684 
3685  const HTMLOptions& rHTMLOptions = GetOptions();
3686  for (size_t i = rHTMLOptions.size(); i; )
3687  {
3688  const HTMLOption& rOption = rHTMLOptions[--i];
3689  switch( rOption.GetToken() )
3690  {
3691  case HtmlOptionId::SIZE:
3692  if( HtmlTokenId::FONT_ON==nToken && !rOption.GetString().isEmpty() )
3693  {
3694  sal_Int32 nSSize;
3695  if( '+' == rOption.GetString()[0] ||
3696  '-' == rOption.GetString()[0] )
3697  nSSize = o3tl::saturating_add<sal_Int32>(nBaseSize, rOption.GetSNumber());
3698  else
3699  nSSize = static_cast<sal_Int32>(rOption.GetNumber());
3700 
3701  if( nSSize < 1 )
3702  nSSize = 1;
3703  else if( nSSize > 7 )
3704  nSSize = 7;
3705 
3706  nSize = static_cast<sal_uInt16>(nSSize);
3707  nFontHeight = m_aFontHeights[nSize-1];
3708  }
3709  break;
3710  case HtmlOptionId::COLOR:
3711  if( HtmlTokenId::FONT_ON==nToken )
3712  {
3713  rOption.GetColor( aColor );
3714  bColor = true;
3715  }
3716  break;
3717  case HtmlOptionId::FACE:
3718  if( HtmlTokenId::FONT_ON==nToken )
3719  aFace = rOption.GetString();
3720  break;
3721  case HtmlOptionId::ID:
3722  aId = rOption.GetString();
3723  break;
3724  case HtmlOptionId::STYLE:
3725  aStyle = rOption.GetString();
3726  break;
3727  case HtmlOptionId::CLASS:
3728  aClass = rOption.GetString();
3729  break;
3730  case HtmlOptionId::LANG:
3731  aLang = rOption.GetString();
3732  break;
3733  case HtmlOptionId::DIR:
3734  aDir = rOption.GetString();
3735  break;
3736  default: break;
3737  }
3738  }
3739 
3740  if( HtmlTokenId::FONT_ON != nToken )
3741  {
3742  // HTML_BIGPRINT_ON or HTML_SMALLPRINT_ON
3743 
3744  // In headings the current heading sets the font height
3745  // and not BASEFONT.
3746  const SwFormatColl *pColl = GetCurrFormatColl();
3747  sal_uInt16 nPoolId = pColl ? pColl->GetPoolFormatId() : 0;
3748  if( nPoolId>=RES_POOLCOLL_HEADLINE1 &&
3749  nPoolId<=RES_POOLCOLL_HEADLINE6 )
3750  {
3751  // If the font height in the heading wasn't changed yet,
3752  // then take the one from the style.
3753  if( m_nFontStHeadStart==m_aFontStack.size() )
3754  nFontSize = static_cast< sal_uInt16 >(6 - (nPoolId - RES_POOLCOLL_HEADLINE1));
3755  }
3756  else
3757  nPoolId = 0;
3758 
3759  if( HtmlTokenId::BIGPRINT_ON == nToken )
3760  nSize = ( nFontSize<7 ? nFontSize+1 : 7 );
3761  else
3762  nSize = ( nFontSize>1 ? nFontSize-1 : 1 );
3763 
3764  // If possible in headlines we fetch the new font height
3765  // from the style.
3766  if( nPoolId && nSize>=1 && nSize <=6 )
3767  nFontHeight =
3768  m_pCSS1Parser->GetTextCollFromPool(
3769  RES_POOLCOLL_HEADLINE1+6-nSize )->GetSize().GetHeight();
3770  else
3771  nFontHeight = m_aFontHeights[nSize-1];
3772  }
3773 
3774  OSL_ENSURE( !nSize == !nFontHeight, "HTML-Font-Size != Font-Height" );
3775 
3776  OUString aFontName, aStyleName;
3777  FontFamily eFamily = FAMILY_DONTKNOW; // family and pitch,
3778  FontPitch ePitch = PITCH_DONTKNOW; // if not found
3779  rtl_TextEncoding eEnc = osl_getThreadTextEncoding();
3780 
3781  if( !aFace.isEmpty() && !m_pCSS1Parser->IsIgnoreFontFamily() )
3782  {
3783  const FontList *pFList = nullptr;
3784  SwDocShell *pDocSh = m_xDoc->GetDocShell();
3785  if( pDocSh )
3786  {
3787  const SvxFontListItem *pFListItem =
3788  static_cast<const SvxFontListItem *>(pDocSh->GetItem(SID_ATTR_CHAR_FONTLIST));
3789  if( pFListItem )
3790  pFList = pFListItem->GetFontList();
3791  }
3792 
3793  bool bFound = false;
3794  sal_Int32 nStrPos = 0;
3795  while( nStrPos!= -1 )
3796  {
3797  OUString aFName = aFace.getToken( 0, ',', nStrPos );
3798  aFName = comphelper::string::strip(aFName, ' ');
3799  if( !aFName.isEmpty() )
3800  {
3801  if( !bFound && pFList )
3802  {
3803  sal_Handle hFont = pFList->GetFirstFontMetric( aFName );
3804  if( nullptr != hFont )
3805  {
3806  const FontMetric& rFMetric = FontList::GetFontMetric( hFont );
3807  if( RTL_TEXTENCODING_DONTKNOW != rFMetric.GetCharSet() )
3808  {
3809  bFound = true;
3810  if( RTL_TEXTENCODING_SYMBOL == rFMetric.GetCharSet() )
3811  eEnc = RTL_TEXTENCODING_SYMBOL;
3812  }
3813  }
3814  }
3815  if( !aFontName.isEmpty() )
3816  aFontName += ";";
3817  aFontName += aFName;
3818  }
3819  }
3820  }
3821 
3822  // create a new context
3823  std::unique_ptr<HTMLAttrContext> xCntxt(new HTMLAttrContext(nToken));
3824 
3825  // parse styles
3826  if( HasStyleOptions( aStyle, aId, aClass, &aLang, &aDir ) )
3827  {
3828  SfxItemSet aItemSet( m_xDoc->GetAttrPool(), m_pCSS1Parser->GetWhichMap() );
3829  SvxCSS1PropertyInfo aPropInfo;
3830 
3831  if( nFontHeight )
3832  {
3833  SvxFontHeightItem aFontHeight( nFontHeight, 100, RES_CHRATR_FONTSIZE );
3834  aItemSet.Put( aFontHeight );
3835  SvxFontHeightItem aFontHeightCJK( nFontHeight, 100, RES_CHRATR_CJK_FONTSIZE );
3836  aItemSet.Put( aFontHeightCJK );
3837  SvxFontHeightItem aFontHeightCTL( nFontHeight, 100, RES_CHRATR_CTL_FONTSIZE );
3838  aItemSet.Put( aFontHeightCTL );
3839  }
3840  if( bColor )
3841  aItemSet.Put( SvxColorItem(aColor, RES_CHRATR_COLOR) );
3842  if( !aFontName.isEmpty() )
3843  {
3844  SvxFontItem aFont( eFamily, aFontName, aStyleName, ePitch, eEnc, RES_CHRATR_FONT );
3845  aItemSet.Put( aFont );
3846  SvxFontItem aFontCJK( eFamily, aFontName, aStyleName, ePitch, eEnc, RES_CHRATR_CJK_FONT );
3847  aItemSet.Put( aFontCJK );
3848  SvxFontItem aFontCTL( eFamily, aFontName, aStyleName, ePitch, eEnc, RES_CHRATR_CTL_FONT );
3849  aItemSet.Put( aFontCTL );
3850  }
3851 
3852  if( ParseStyleOptions( aStyle, aId, aClass, aItemSet, aPropInfo, &aLang, &aDir ) )
3853  DoPositioning( aItemSet, aPropInfo, xCntxt.get() );
3854 
3855  InsertAttrs( aItemSet, aPropInfo, xCntxt.get(), true );
3856  }
3857  else
3858  {
3859  if( nFontHeight )
3860  {
3861  SvxFontHeightItem aFontHeight( nFontHeight, 100, RES_CHRATR_FONTSIZE );
3862  InsertAttr( &m_xAttrTab->pFontHeight, aFontHeight, xCntxt.get() );
3863  SvxFontHeightItem aFontHeightCJK( nFontHeight, 100, RES_CHRATR_CJK_FONTSIZE );
3864  InsertAttr( &m_xAttrTab->pFontHeight, aFontHeightCJK, xCntxt.get() );
3865  SvxFontHeightItem aFontHeightCTL( nFontHeight, 100, RES_CHRATR_CTL_FONTSIZE );
3866  InsertAttr( &m_xAttrTab->pFontHeight, aFontHeightCTL, xCntxt.get() );
3867  }
3868  if( bColor )
3869  InsertAttr( &m_xAttrTab->pFontColor, SvxColorItem(aColor, RES_CHRATR_COLOR), xCntxt.get() );
3870  if( !aFontName.isEmpty() )
3871  {
3872  SvxFontItem aFont( eFamily, aFontName, aStyleName, ePitch, eEnc, RES_CHRATR_FONT );
3873  InsertAttr( &m_xAttrTab->pFont, aFont, xCntxt.get() );
3874  SvxFontItem aFontCJK( eFamily, aFontName, aStyleName, ePitch, eEnc, RES_CHRATR_CJK_FONT );
3875  InsertAttr( &m_xAttrTab->pFont, aFontCJK, xCntxt.get() );
3876  SvxFontItem aFontCTL( eFamily, aFontName, aStyleName, ePitch, eEnc, RES_CHRATR_CTL_FONT );
3877  InsertAttr( &m_xAttrTab->pFont, aFontCTL, xCntxt.get() );
3878  }
3879  }
3880 
3881  // save the context
3882  PushContext(xCntxt);
3883 
3884  m_aFontStack.push_back( nSize );
3885 }
3886 
3887 void SwHTMLParser::EndFontAttr( HtmlTokenId nToken )
3888 {
3889  EndTag( nToken );
3890 
3891  // avoid stack underflow in tables
3892  if( m_aFontStack.size() > m_nFontStMin )
3893  m_aFontStack.erase( m_aFontStack.begin() + m_aFontStack.size() - 1 );
3894 }
3895 
3896 void SwHTMLParser::NewPara()
3897 {
3898  if( m_pPam->GetPoint()->nContent.GetIndex() )
3899  AppendTextNode( AM_SPACE );
3900  else
3901  AddParSpace();
3902 
3903  m_eParaAdjust = SvxAdjust::End;
3904  OUString aId, aStyle, aClass, aLang, aDir;
3905 
3906  const HTMLOptions& rHTMLOptions = GetOptions();
3907  for (size_t i = rHTMLOptions.size(); i; )
3908  {
3909  const HTMLOption& rOption = rHTMLOptions[--i];
3910  switch( rOption.GetToken() )
3911  {
3912  case HtmlOptionId::ID:
3913  aId = rOption.GetString();
3914  break;
3915  case HtmlOptionId::ALIGN:
3916  m_eParaAdjust = rOption.GetEnum( aHTMLPAlignTable, m_eParaAdjust );
3917  break;
3918  case HtmlOptionId::STYLE:
3919  aStyle = rOption.GetString();
3920  break;
3921  case HtmlOptionId::CLASS:
3922  aClass = rOption.GetString();
3923  break;
3924  case HtmlOptionId::LANG:
3925  aLang = rOption.GetString();
3926  break;
3927  case HtmlOptionId::DIR:
3928  aDir = rOption.GetString();
3929  break;
3930  default: break;
3931  }
3932  }
3933 
3934  // create a new context
3935  std::unique_ptr<HTMLAttrContext> xCntxt(
3936  !aClass.isEmpty() ? new HTMLAttrContext( HtmlTokenId::PARABREAK_ON,
3937  RES_POOLCOLL_TEXT, aClass )
3938  : new HTMLAttrContext( HtmlTokenId::PARABREAK_ON ));
3939 
3940  // parse styles (Don't consider class. This is only possible as long as none of
3941  // the CSS1 properties of the class must be formatted hard!!!)
3942  if (HasStyleOptions(aStyle, aId, OUString(), &aLang, &aDir))
3943  {
3944  SfxItemSet aItemSet( m_xDoc->GetAttrPool(), m_pCSS1Parser->GetWhichMap() );
3945  SvxCSS1PropertyInfo aPropInfo;
3946 
3947  if (ParseStyleOptions(aStyle, aId, OUString(), aItemSet, aPropInfo, &aLang, &aDir))
3948  {
3949  OSL_ENSURE( aClass.isEmpty() || !m_pCSS1Parser->GetClass( aClass ),
3950  "Class is not considered" );
3951  DoPositioning( aItemSet, aPropInfo, xCntxt.get() );
3952  InsertAttrs( aItemSet, aPropInfo, xCntxt.get() );
3953  }
3954  }
3955 
3956  if( SvxAdjust::End != m_eParaAdjust )
3957  InsertAttr( &m_xAttrTab->pAdjust, SvxAdjustItem(m_eParaAdjust, RES_PARATR_ADJUST), xCntxt.get() );
3958 
3959  // and push on stack
3960  PushContext( xCntxt );
3961 
3962  // set the current style or its attributes
3963  SetTextCollAttrs( !aClass.isEmpty() ? m_aContexts.back().get() : nullptr );
3964 
3965  // progress bar
3966  ShowStatline();
3967 
3968  OSL_ENSURE( m_nOpenParaToken == HtmlTokenId::NONE, "Now an open paragraph element will be lost." );
3969  m_nOpenParaToken = HtmlTokenId::PARABREAK_ON;
3970 }
3971 
3972 void SwHTMLParser::EndPara( bool bReal )
3973 {
3974  if (HtmlTokenId::LI_ON==m_nOpenParaToken && m_xTable)
3975  {
3976 #if OSL_DEBUG_LEVEL > 0
3977  const SwNumRule *pNumRule = m_pPam->GetNode().GetTextNode()->GetNumRule();
3978  OSL_ENSURE( pNumRule, "Where is the NumRule" );
3979 #endif
3980  }
3981 
3982  // Netscape skips empty paragraphs, we do the same.
3983  if( bReal )
3984  {
3985  if( m_pPam->GetPoint()->nContent.GetIndex() )
3986  AppendTextNode( AM_SPACE );
3987  else
3988  AddParSpace();
3989  }
3990 
3991  // If a DD or DT was open, it's an implied definition list,
3992  // which must be closed now.
3993  if( (m_nOpenParaToken == HtmlTokenId::DT_ON || m_nOpenParaToken == HtmlTokenId::DD_ON) &&
3994  m_nDefListDeep)
3995  {
3996  m_nDefListDeep--;
3997  }
3998 
3999  // Pop the context of the stack. It can also be from an
4000  // implied opened definition list.
4001  std::unique_ptr<HTMLAttrContext> xCntxt(
4002  PopContext( m_nOpenParaToken != HtmlTokenId::NONE ? getOnToken(m_nOpenParaToken) : HtmlTokenId::PARABREAK_ON ));
4003 
4004  // close attribute
4005  if (xCntxt)
4006  {
4007  EndContext(xCntxt.get());
4008  SetAttr(); // because of JavaScript set paragraph attributes as fast as possible
4009  xCntxt.reset();
4010  }
4011 
4012  // reset the existing style
4013  if( bReal )
4014  SetTextCollAttrs();
4015 
4016  m_nOpenParaToken = HtmlTokenId::NONE;
4017 }
4018 
4019 void SwHTMLParser::NewHeading( HtmlTokenId nToken )
4020 {
4021  m_eParaAdjust = SvxAdjust::End;
4022 
4023  OUString aId, aStyle, aClass, aLang, aDir;
4024 
4025  const HTMLOptions& rHTMLOptions = GetOptions();
4026  for (size_t i = rHTMLOptions.size(); i; )
4027  {
4028  const HTMLOption& rOption = rHTMLOptions[--i];
4029  switch( rOption.GetToken() )
4030  {
4031  case HtmlOptionId::ID:
4032  aId = rOption.GetString();
4033  break;
4034  case HtmlOptionId::ALIGN:
4035  m_eParaAdjust = rOption.GetEnum( aHTMLPAlignTable, m_eParaAdjust );
4036  break;
4037  case HtmlOptionId::STYLE:
4038  aStyle = rOption.GetString();
4039  break;
4040  case HtmlOptionId::CLASS:
4041  aClass = rOption.GetString();
4042  break;
4043  case HtmlOptionId::LANG:
4044  aLang = rOption.GetString();
4045  break;
4046  case HtmlOptionId::DIR:
4047  aDir = rOption.GetString();
4048  break;
4049  default: break;
4050  }
4051  }
4052 
4053  // open a new paragraph
4054  if( m_pPam->GetPoint()->nContent.GetIndex() )
4055  AppendTextNode( AM_SPACE );
4056  else
4057  AddParSpace();
4058 
4059  // search for the matching style
4060  sal_uInt16 nTextColl;
4061  switch( nToken )
4062  {
4063  case HtmlTokenId::HEAD1_ON: nTextColl = RES_POOLCOLL_HEADLINE1; break;
4064  case HtmlTokenId::HEAD2_ON: nTextColl = RES_POOLCOLL_HEADLINE2; break;
4065  case HtmlTokenId::HEAD3_ON: nTextColl = RES_POOLCOLL_HEADLINE3; break;
4066  case HtmlTokenId::HEAD4_ON: nTextColl = RES_POOLCOLL_HEADLINE4; break;
4067  case HtmlTokenId::HEAD5_ON: nTextColl = RES_POOLCOLL_HEADLINE5; break;
4068  case HtmlTokenId::HEAD6_ON: nTextColl = RES_POOLCOLL_HEADLINE6; break;
4069  default: nTextColl = RES_POOLCOLL_STANDARD; break;
4070  }
4071 
4072  // create the context
4073  std::unique_ptr<HTMLAttrContext> xCntxt(new HTMLAttrContext(nToken, nTextColl, aClass));
4074 
4075  // parse styles (regarding class see also NewPara)
4076  if (HasStyleOptions(aStyle, aId, OUString(), &aLang, &aDir))
4077  {
4078  SfxItemSet aItemSet( m_xDoc->GetAttrPool(), m_pCSS1Parser->GetWhichMap() );
4079  SvxCSS1PropertyInfo aPropInfo;
4080 
4081  if (ParseStyleOptions(aStyle, aId, OUString(), aItemSet, aPropInfo, &aLang, &aDir))
4082  {
4083  OSL_ENSURE( aClass.isEmpty() || !m_pCSS1Parser->GetClass( aClass ),
4084  "Class is not considered" );
4085  DoPositioning( aItemSet, aPropInfo, xCntxt.get() );
4086  InsertAttrs( aItemSet, aPropInfo, xCntxt.get() );
4087  }
4088  }
4089 
4090  if( SvxAdjust::End != m_eParaAdjust )
4091  InsertAttr( &m_xAttrTab->pAdjust, SvxAdjustItem(m_eParaAdjust, RES_PARATR_ADJUST), xCntxt.get() );
4092 
4093  // and push on stack
4094  PushContext(xCntxt);
4095 
4096  // set the current style or its attributes
4097  SetTextCollAttrs(m_aContexts.back().get());
4098 
4099  m_nFontStHeadStart = m_aFontStack.size();
4100 
4101  // progress bar
4102  ShowStatline();
4103 }
4104 
4105 void SwHTMLParser::EndHeading()
4106 {
4107  // open a new paragraph
4108  if( m_pPam->GetPoint()->nContent.GetIndex() )
4109  AppendTextNode( AM_SPACE );
4110  else
4111  AddParSpace();
4112 
4113  // search context matching the token and fetch it from stack
4114  std::unique_ptr<HTMLAttrContext> xCntxt;
4115  auto nPos = m_aContexts.size();
4116  while( !xCntxt && nPos>m_nContextStMin )
4117  {
4118  switch( m_aContexts[--nPos]->GetToken() )
4119  {
4120  case HtmlTokenId::HEAD1_ON:
4121  case HtmlTokenId::HEAD2_ON:
4122  case HtmlTokenId::HEAD3_ON:
4123  case HtmlTokenId::HEAD4_ON:
4124  case HtmlTokenId::HEAD5_ON:
4125  case HtmlTokenId::HEAD6_ON:
4126  xCntxt = std::move(m_aContexts[nPos]);
4127  m_aContexts.erase( m_aContexts.begin() + nPos );
4128  break;
4129  default: break;
4130  }
4131  }
4132 
4133  // and now end attributes
4134  if (xCntxt)
4135  {
4136  EndContext(xCntxt.get());
4137  SetAttr(); // because of JavaScript set paragraph attributes as fast as possible
4138  xCntxt.reset();
4139  }
4140 
4141  // reset existing style
4142  SetTextCollAttrs();
4143 
4144  m_nFontStHeadStart = m_nFontStMin;
4145 }
4146 
4147 void SwHTMLParser::NewTextFormatColl( HtmlTokenId nToken, sal_uInt16 nColl )
4148 {
4149  OUString aId, aStyle, aClass, aLang, aDir;
4150 
4151  const HTMLOptions& rHTMLOptions = GetOptions();
4152  for (size_t i = rHTMLOptions.size(); i; )
4153  {
4154  const HTMLOption& rOption = rHTMLOptions[--i];
4155  switch( rOption.GetToken() )
4156  {
4157  case HtmlOptionId::ID:
4158  aId = rOption.GetString();
4159  break;
4160  case HtmlOptionId::STYLE:
4161  aStyle = rOption.GetString();
4162  break;
4163  case HtmlOptionId::CLASS:
4164  aClass = rOption.GetString();
4165  break;
4166  case HtmlOptionId::LANG:
4167  aLang = rOption.GetString();
4168  break;
4169  case HtmlOptionId::DIR:
4170  aDir = rOption.GetString();
4171  break;
4172  default: break;
4173  }
4174  }
4175 
4176  // open a new paragraph
4177  SwHTMLAppendMode eMode = AM_NORMAL;
4178  switch( nToken )
4179  {
4180  case HtmlTokenId::LISTING_ON:
4181  case HtmlTokenId::XMP_ON:
4182  // These both tags will be mapped to the PRE style. For the case that a
4183  // a CLASS exists we will delete it so that we don't get the CLASS of
4184  // the PRE style.
4185  aClass.clear();
4186  [[fallthrough]];
4187  case HtmlTokenId::BLOCKQUOTE_ON:
4188  case HtmlTokenId::BLOCKQUOTE30_ON:
4189  case HtmlTokenId::PREFORMTXT_ON:
4190  eMode = AM_SPACE;
4191  break;
4192  case HtmlTokenId::ADDRESS_ON:
4193  eMode = AM_NOSPACE; // ADDRESS can follow on a <P> without </P>
4194  break;
4195  case HtmlTokenId::DT_ON:
4196  case HtmlTokenId::DD_ON:
4197  eMode = AM_SOFTNOSPACE;
4198  break;
4199  default:
4200  OSL_ENSURE( false, "unknown style" );
4201  break;
4202  }
4203  if( m_pPam->GetPoint()->nContent.GetIndex() )
4204  AppendTextNode( eMode );
4205  else if( AM_SPACE==eMode )
4206  AddParSpace();
4207 
4208  // ... and save in a context
4209  std::unique_ptr<HTMLAttrContext> xCntxt(new HTMLAttrContext(nToken, nColl, aClass));
4210 
4211  // parse styles (regarding class see also NewPara)
4212  if (HasStyleOptions(aStyle, aId, OUString(), &aLang, &aDir))
4213  {
4214  SfxItemSet aItemSet( m_xDoc->GetAttrPool(), m_pCSS1Parser->GetWhichMap() );
4215  SvxCSS1PropertyInfo aPropInfo;
4216 
4217  if (ParseStyleOptions(aStyle, aId, OUString(), aItemSet, aPropInfo, &aLang, &aDir))
4218  {
4219  OSL_ENSURE( aClass.isEmpty() || !m_pCSS1Parser->GetClass( aClass ),
4220  "Class is not considered" );
4221  DoPositioning( aItemSet, aPropInfo, xCntxt.get() );
4222  InsertAttrs( aItemSet, aPropInfo, xCntxt.get() );
4223  }
4224  }
4225 
4226  PushContext(xCntxt);
4227 
4228  // set the new style
4229  SetTextCollAttrs(m_aContexts.back().get());
4230 
4231  // update progress bar
4232  ShowStatline();
4233 }
4234 
4235 void SwHTMLParser::EndTextFormatColl( HtmlTokenId nToken )
4236 {
4237  SwHTMLAppendMode eMode = AM_NORMAL;
4238  switch( getOnToken(nToken) )
4239  {
4240  case HtmlTokenId::BLOCKQUOTE_ON:
4241  case HtmlTokenId::BLOCKQUOTE30_ON:
4242  case HtmlTokenId::PREFORMTXT_ON:
4243  case HtmlTokenId::LISTING_ON:
4244  case HtmlTokenId::XMP_ON:
4245  eMode = AM_SPACE;
4246  break;
4247  case HtmlTokenId::ADDRESS_ON:
4248  case HtmlTokenId::DT_ON:
4249  case HtmlTokenId::DD_ON:
4250  eMode = AM_SOFTNOSPACE;
4251  break;
4252  default:
4253  OSL_ENSURE( false, "unknown style" );
4254  break;
4255  }
4256  if( m_pPam->GetPoint()->nContent.GetIndex() )
4257  AppendTextNode( eMode );
4258  else if( AM_SPACE==eMode )
4259  AddParSpace();
4260 
4261  // pop current context of stack
4262  std::unique_ptr<HTMLAttrContext> xCntxt(PopContext(getOnToken(nToken)));
4263 
4264  // and now end attributes
4265  if (xCntxt)
4266  {
4267  EndContext(xCntxt.get());
4268  SetAttr(); // because of JavaScript set paragraph attributes as fast as possible
4269  xCntxt.reset();
4270  }
4271 
4272  // reset existing style
4273  SetTextCollAttrs();
4274 }
4275 
4276 void SwHTMLParser::NewDefList()
4277 {
4278  OUString aId, aStyle, aClass, aLang, aDir;
4279 
4280  const HTMLOptions& rHTMLOptions = GetOptions();
4281  for (size_t i = rHTMLOptions.size(); i; )
4282  {
4283  const HTMLOption& rOption = rHTMLOptions[--i];
4284  switch( rOption.GetToken() )
4285  {
4286  case HtmlOptionId::ID:
4287  aId = rOption.GetString();
4288  break;
4289  case HtmlOptionId::STYLE:
4290  aStyle = rOption.GetString();
4291  break;
4292  case HtmlOptionId::CLASS:
4293  aClass = rOption.GetString();
4294  break;
4295  case HtmlOptionId::LANG:
4296  aLang = rOption.GetString();
4297  break;
4298  case HtmlOptionId::DIR:
4299  aDir = rOption.GetString();
4300  break;
4301  default: break;
4302  }
4303  }
4304 
4305  // open a new paragraph
4306  bool bSpace = (GetNumInfo().GetDepth() + m_nDefListDeep) == 0;
4307  if( m_pPam->GetPoint()->nContent.GetIndex() )
4308  AppendTextNode( bSpace ? AM_SPACE : AM_SOFTNOSPACE );
4309  else if( bSpace )
4310  AddParSpace();
4311 
4312  // one level more
4313  m_nDefListDeep++;
4314 
4315  bool bInDD = false, bNotInDD = false;
4316  auto nPos = m_aContexts.size();
4317  while( !bInDD && !bNotInDD && nPos>m_nContextStMin )
4318  {
4319  HtmlTokenId nCntxtToken = m_aContexts[--nPos]->GetToken();
4320  switch( nCntxtToken )
4321  {
4322  case HtmlTokenId::DEFLIST_ON:
4323  case HtmlTokenId::DIRLIST_ON:
4324  case HtmlTokenId::MENULIST_ON:
4325  case HtmlTokenId::ORDERLIST_ON:
4326  case HtmlTokenId::UNORDERLIST_ON:
4327  bNotInDD = true;
4328  break;
4329  case HtmlTokenId::DD_ON:
4330  bInDD = true;
4331  break;
4332  default: break;
4333  }
4334  }
4335 
4336  // ... and save in a context
4337  std::unique_ptr<HTMLAttrContext> xCntxt(new HTMLAttrContext(HtmlTokenId::DEFLIST_ON));
4338 
4339  // in it save also the margins
4340  sal_uInt16 nLeft=0, nRight=0;
4341  short nIndent=0;
4342  GetMarginsFromContext( nLeft, nRight, nIndent );
4343 
4344  // The indentation, which already results from a DL, correlates with a DT
4345  // on the current level and this correlates to a DD from the previous level.
4346  // For a level >=2 we must add DD distance.
4347  if( !bInDD && m_nDefListDeep > 1 )
4348  {
4349 
4350  // and the one of the DT-style of the current level
4351  SvxLRSpaceItem rLRSpace =
4352  m_pCSS1Parser->GetTextFormatColl(RES_POOLCOLL_HTML_DD, OUString())
4353  ->GetLRSpace();
4354  nLeft = nLeft + static_cast< sal_uInt16 >(rLRSpace.GetTextLeft());
4355  }
4356 
4357  xCntxt->SetMargins( nLeft, nRight, nIndent );
4358 
4359  // parse styles
4360  if( HasStyleOptions( aStyle, aId, aClass, &aLang, &aDir ) )
4361  {
4362  SfxItemSet aItemSet( m_xDoc->GetAttrPool(), m_pCSS1Parser->GetWhichMap() );
4363  SvxCSS1PropertyInfo aPropInfo;
4364 
4365  if( ParseStyleOptions( aStyle, aId, aClass, aItemSet, aPropInfo, &aLang, &aDir ) )
4366  {
4367  DoPositioning( aItemSet, aPropInfo, xCntxt.get() );
4368  InsertAttrs( aItemSet, aPropInfo, xCntxt.get() );
4369  }
4370  }
4371 
4372  PushContext(xCntxt);
4373 
4374  // set the attributes of the new style
4375  if( m_nDefListDeep > 1 )
4376  SetTextCollAttrs(m_aContexts.back().get());
4377 }
4378 
4379 void SwHTMLParser::EndDefList()
4380 {
4381  bool bSpace = (GetNumInfo().GetDepth() + m_nDefListDeep) == 1;
4382  if( m_pPam->GetPoint()->nContent.GetIndex() )
4383  AppendTextNode( bSpace ? AM_SPACE : AM_SOFTNOSPACE );
4384  else if( bSpace )
4385  AddParSpace();
4386 
4387  // one level less
4388  if( m_nDefListDeep > 0 )
4389  m_nDefListDeep--;
4390 
4391  // pop current context of stack
4392  std::unique_ptr<HTMLAttrContext> xCntxt(PopContext(HtmlTokenId::DEFLIST_ON));
4393 
4394  // and now end attributes
4395  if (xCntxt)
4396  {
4397  EndContext(xCntxt.get());
4398  SetAttr(); // because of JavaScript set paragraph attributes as fast as possible
4399  xCntxt.reset();
4400  }
4401 
4402  // and set style
4403  SetTextCollAttrs();
4404 }
4405 
4406 void SwHTMLParser::NewDefListItem( HtmlTokenId nToken )
4407 {
4408  // determine if the DD/DT exist in a DL
4409  bool bInDefList = false, bNotInDefList = false;
4410  auto nPos = m_aContexts.size();
4411  while( !bInDefList && !bNotInDefList && nPos>m_nContextStMin )
4412  {
4413  HtmlTokenId nCntxtToken = m_aContexts[--nPos]->GetToken();
4414  switch( nCntxtToken )
4415  {
4416  case HtmlTokenId::DEFLIST_ON:
4417  bInDefList = true;
4418  break;
4419  case HtmlTokenId::DIRLIST_ON:
4420  case HtmlTokenId::MENULIST_ON:
4421  case HtmlTokenId::ORDERLIST_ON:
4422  case HtmlTokenId::UNORDERLIST_ON:
4423  bNotInDefList = true;
4424  break;
4425  default: break;
4426  }
4427  }
4428 
4429  // if not, then implicitly open a new DL
4430  if( !bInDefList )
4431  {
4432  m_nDefListDeep++;
4433  OSL_ENSURE( m_nOpenParaToken == HtmlTokenId::NONE,
4434  "Now an open paragraph element will be lost." );
4435  m_nOpenParaToken = nToken;
4436  }
4437 
4438  NewTextFormatColl( nToken, static_cast< sal_uInt16 >(nToken==HtmlTokenId::DD_ON ? RES_POOLCOLL_HTML_DD
4439  : RES_POOLCOLL_HTML_DT) );
4440 }
4441 
4442 void SwHTMLParser::EndDefListItem( HtmlTokenId nToken )
4443 {
4444  // open a new paragraph
4445  if( nToken == HtmlTokenId::NONE && m_pPam->GetPoint()->nContent.GetIndex() )
4446  AppendTextNode( AM_SOFTNOSPACE );
4447 
4448  // search context matching the token and fetch it from stack
4449  nToken = getOnToken(nToken);
4450  std::unique_ptr<HTMLAttrContext> xCntxt;
4451  auto nPos = m_aContexts.size();
4452  while( !xCntxt && nPos>m_nContextStMin )
4453  {
4454  HtmlTokenId nCntxtToken = m_aContexts[--nPos]->GetToken();
4455  switch( nCntxtToken )
4456  {
4457  case HtmlTokenId::DD_ON:
4458  case HtmlTokenId::DT_ON:
4459  if( nToken == HtmlTokenId::NONE || nToken == nCntxtToken )
4460  {
4461  xCntxt = std::move(m_aContexts[nPos]);
4462  m_aContexts.erase( m_aContexts.begin() + nPos );
4463  }
4464  break;
4465  case HtmlTokenId::DEFLIST_ON:
4466  // don't look at DD/DT outside the current DefList
4467  case HtmlTokenId::DIRLIST_ON:
4468  case HtmlTokenId::MENULIST_ON:
4469  case HtmlTokenId::ORDERLIST_ON:
4470  case HtmlTokenId::UNORDERLIST_ON:
4471  // and also not outside another list
4472  nPos = m_nContextStMin;
4473  break;
4474  default: break;
4475  }
4476  }
4477 
4478  // and now end attributes
4479  if (xCntxt)
4480  {
4481  EndContext(xCntxt.get());
4482  SetAttr(); // because of JavaScript set paragraph attributes as fast as possible
4483  }
4484 }
4485 
4495 bool SwHTMLParser::HasCurrentParaFlys( bool bNoSurroundOnly,
4496  bool bSurroundOnly ) const
4497 {
4498  SwNodeIndex& rNodeIdx = m_pPam->GetPoint()->nNode;
4499 
4500  const SwFrameFormats& rFrameFormatTable = *m_xDoc->GetSpzFrameFormats();
4501 
4502  bool bFound = false;
4503  for ( size_t i=0; i<rFrameFormatTable.size(); i++ )
4504  {
4505  const SwFrameFormat *const pFormat = rFrameFormatTable[i];
4506  SwFormatAnchor const*const pAnchor = &pFormat->GetAnchor();
4507  // A frame was found, when
4508  // - it is paragraph-bound, and
4509  // - is anchored in current paragraph, and
4510  // - every paragraph-bound frame counts, or
4511  // - (only frames without wrapping count and) the frame doesn't have
4512  // a wrapping
4513  SwPosition const*const pAPos = pAnchor->GetContentAnchor();
4514  if (pAPos &&
4515  ((RndStdIds::FLY_AT_PARA == pAnchor->GetAnchorId()) ||
4516  (RndStdIds::FLY_AT_CHAR == pAnchor->GetAnchorId())) &&
4517  pAPos->nNode == rNodeIdx )
4518  {
4519  if( !(bNoSurroundOnly || bSurroundOnly) )
4520  {
4521  bFound = true;
4522  break;
4523  }
4524  else
4525  {
4526  // When looking for frames with wrapping, also disregard
4527  // ones with wrap-through. In this case it's (still) HIDDEN-Controls,
4528  // and you don't want to evade those when positioning.
4529  css::text::WrapTextMode eSurround = pFormat->GetSurround().GetSurround();
4530  if( bNoSurroundOnly )
4531  {
4532  if( css::text::WrapTextMode_NONE==eSurround )
4533  {
4534  bFound = true;
4535  break;
4536  }
4537  }
4538  if( bSurroundOnly )
4539  {
4540  if( css::text::WrapTextMode_NONE==eSurround )
4541  {
4542  bFound = false;
4543  break;
4544  }
4545  else if( css::text::WrapTextMode_THROUGH!=eSurround )
4546  {
4547  bFound = true;
4548  // Continue searching: It's possible that some without
4549  // wrapping will follow...
4550  }
4551  }
4552  }
4553  }
4554  }
4555 
4556  return bFound;
4557 }
4558 
4559 // the special methods for inserting of objects
4560 
4561 const SwFormatColl *SwHTMLParser::GetCurrFormatColl() const
4562 {
4563  const SwContentNode* pCNd = m_pPam->GetContentNode();
4564  return pCNd ? &pCNd->GetAnyFormatColl() : nullptr;
4565 }
4566 
4567 void SwHTMLParser::SetTextCollAttrs( HTMLAttrContext *pContext )
4568 {
4569  SwTextFormatColl *pCollToSet = nullptr; // the style to set
4570  SfxItemSet *pItemSet = nullptr; // set of hard attributes
4571  sal_uInt16 nTopColl = pContext ? pContext->GetTextFormatColl() : 0;
4572  const OUString rTopClass = pContext ? pContext->GetClass() : OUString();
4573  sal_uInt16 nDfltColl = RES_POOLCOLL_TEXT;
4574 
4575  bool bInPRE=false; // some context info
4576 
4577  sal_uInt16 nLeftMargin = 0, nRightMargin = 0; // the margins and
4578  short nFirstLineIndent = 0; // indentations
4579 
4580  for( auto i = m_nContextStAttrMin; i < m_aContexts.size(); ++i )
4581  {
4582  const HTMLAttrContext *pCntxt = m_aContexts[i].get();
4583 
4584  sal_uInt16 nColl = pCntxt->GetTextFormatColl();
4585  if( nColl )
4586  {
4587  // There is a style to set. Then at first we must decide,
4588  // if the style can be set.
4589  bool bSetThis = true;
4590  switch( nColl )
4591  {
4592  case RES_POOLCOLL_HTML_PRE:
4593  bInPRE = true;
4594  break;
4595  case RES_POOLCOLL_TEXT:
4596  // <TD><P CLASS=xxx> must become TD.xxx
4597  if( nDfltColl==RES_POOLCOLL_TABLE ||
4598  nDfltColl==RES_POOLCOLL_TABLE_HDLN )
4599  nColl = nDfltColl;
4600  break;
4601  case RES_POOLCOLL_HTML_HR:
4602  // also <HR> in <PRE> set as style, otherwise it can't
4603  // be exported anymore
4604  break;
4605  default:
4606  if( bInPRE )
4607  bSetThis = false;
4608  break;
4609  }
4610 
4611  SwTextFormatColl *pNewColl =
4612  m_pCSS1Parser->GetTextFormatColl( nColl, pCntxt->GetClass() );
4613 
4614  if( bSetThis )
4615  {
4616  // If now a different style should be set as previously, the
4617  // previous style must be replaced by hard attribution.
4618 
4619  if( pCollToSet )
4620  {
4621  // insert the attributes hard, which previous style sets
4622  if( !pItemSet )
4623  pItemSet = new SfxItemSet( pCollToSet->GetAttrSet() );
4624  else
4625  {
4626  const SfxItemSet& rCollSet = pCollToSet->GetAttrSet();
4627  SfxItemSet aItemSet( *rCollSet.GetPool(),
4628  rCollSet.GetRanges() );
4629  aItemSet.Set( rCollSet );
4630  pItemSet->Put( aItemSet );
4631  }
4632  // but remove the attributes, which the current style sets,
4633  // because otherwise they will be overwritten later
4634  pItemSet->Differentiate( pNewColl->GetAttrSet() );
4635  }
4636 
4637  pCollToSet = pNewColl;
4638  }
4639  else
4640  {
4641  // hard attribution
4642  if( !pItemSet )
4643  pItemSet = new SfxItemSet( pNewColl->GetAttrSet() );
4644  else
4645  {
4646  const SfxItemSet& rCollSet = pNewColl->GetAttrSet();
4647  SfxItemSet aItemSet( *rCollSet.GetPool(),
4648  rCollSet.GetRanges() );
4649  aItemSet.Set( rCollSet );
4650  pItemSet->Put( aItemSet );
4651  }
4652  }
4653  }
4654  else
4655  {
4656  // Maybe a default style exists?
4657  nColl = pCntxt->GetDfltTextFormatColl();
4658  if( nColl )
4659  nDfltColl = nColl;
4660  }
4661 
4662  // if applicable fetch new paragraph indents
4663  if( pCntxt->IsLRSpaceChanged() )
4664  {
4665  sal_uInt16 nLeft=0, nRight=0;
4666 
4667  pCntxt->GetMargins( nLeft, nRight, nFirstLineIndent );
4668  nLeftMargin = nLeft;
4669  nRightMargin = nRight;
4670  }
4671  }
4672 
4673  // If in current context a new style should be set,
4674  // its paragraph margins must be inserted in the context.
4675  if( pContext && nTopColl )
4676  {
4677  // <TD><P CLASS=xxx> must become TD.xxx
4678  if( nTopColl==RES_POOLCOLL_TEXT &&
4679  (nDfltColl==RES_POOLCOLL_TABLE ||
4680  nDfltColl==RES_POOLCOLL_TABLE_HDLN) )
4681  nTopColl = nDfltColl;
4682 
4683  const SwTextFormatColl *pTopColl =
4684  m_pCSS1Parser->GetTextFormatColl( nTopColl, rTopClass );
4685  const SfxItemSet& rItemSet = pTopColl->GetAttrSet();
4686  const SfxPoolItem *pItem;
4687  if( SfxItemState::SET == rItemSet.GetItemState(RES_LR_SPACE,true, &pItem) )
4688  {
4689  const SvxLRSpaceItem *pLRItem =
4690  static_cast<const SvxLRSpaceItem *>(pItem);
4691 
4692  sal_Int32 nLeft = pLRItem->GetTextLeft();
4693  sal_Int32 nRight = pLRItem->GetRight();
4694  nFirstLineIndent = pLRItem->GetTextFirstLineOffset();
4695 
4696  // In Definition lists the margins also contain the margins from the previous levels
4697  if( RES_POOLCOLL_HTML_DD == nTopColl )
4698  {
4699  const SvxLRSpaceItem& rDTLRSpace = m_pCSS1Parser
4700  ->GetTextFormatColl(RES_POOLCOLL_HTML_DT, OUString())
4701  ->GetLRSpace();
4702  nLeft -= rDTLRSpace.GetTextLeft();
4703  nRight -= rDTLRSpace.GetRight();
4704  }
4705  else if( RES_POOLCOLL_HTML_DT == nTopColl )
4706  {
4707  nLeft = 0;
4708  nRight = 0;
4709  }
4710 
4711  // the paragraph margins add up
4712  nLeftMargin = nLeftMargin + static_cast< sal_uInt16 >(nLeft);
4713  nRightMargin = nRightMargin + static_cast< sal_uInt16 >(nRight);
4714 
4715  pContext->SetMargins( nLeftMargin, nRightMargin,
4716  nFirstLineIndent );
4717  }
4718  if( SfxItemState::SET == rItemSet.GetItemState(RES_UL_SPACE,true, &pItem) )
4719  {
4720  const SvxULSpaceItem *pULItem =
4721  static_cast<const SvxULSpaceItem *>(pItem);
4722  pContext->SetULSpace( pULItem->GetUpper(), pULItem->GetLower() );
4723  }
4724  }
4725 
4726  // If no style is set in the context use the text body.
4727  if( !pCollToSet )
4728  {
4729  pCollToSet = m_pCSS1Parser->GetTextCollFromPool( nDfltColl );
4730  const SvxLRSpaceItem& rLRItem = pCollToSet->GetLRSpace();
4731  if( !nLeftMargin )
4732  nLeftMargin = static_cast< sal_uInt16 >(rLRItem.GetTextLeft());
4733  if( !nRightMargin )
4734  nRightMargin = static_cast< sal_uInt16 >(rLRItem.GetRight());
4735  if( !nFirstLineIndent )
4736  nFirstLineIndent = rLRItem.GetTextFirstLineOffset();
4737  }
4738 
4739  // remove previous hard attribution of paragraph
4740  for( auto pParaAttr : m_aParaAttrs )
4741  pParaAttr->Invalidate();
4742  m_aParaAttrs.clear();
4743 
4744  // set the style
4745  m_xDoc->SetTextFormatColl( *m_pPam, pCollToSet );
4746 
4747  // if applicable correct the paragraph indent
4748  const SvxLRSpaceItem& rLRItem = pCollToSet->GetLRSpace();
4749  bool bSetLRSpace = nLeftMargin != rLRItem.GetTextLeft() ||
4750  nFirstLineIndent != rLRItem.GetTextFirstLineOffset() ||
4751  nRightMargin != rLRItem.GetRight();
4752 
4753  if( bSetLRSpace )
4754  {
4755  SvxLRSpaceItem aLRItem( rLRItem );
4756  aLRItem.SetTextLeft( nLeftMargin );
4757  aLRItem.SetRight( nRightMargin );
4758  aLRItem.SetTextFirstLineOffset( nFirstLineIndent );
4759  if( pItemSet )
4760  pItemSet->Put( aLRItem );
4761  else
4762  {
4763  NewAttr(m_xAttrTab, &m_xAttrTab->pLRSpace, aLRItem);
4764  m_xAttrTab->pLRSpace->SetLikePara();
4765  m_aParaAttrs.push_back( m_xAttrTab->pLRSpace );
4766  EndAttr( m_xAttrTab->pLRSpace, false );
4767  }
4768  }
4769 
4770  // and now set the attributes
4771  if( pItemSet )
4772  {
4773  InsertParaAttrs( *pItemSet );
4774  delete pItemSet;
4775  }
4776 }
4777 
4778 void SwHTMLParser::NewCharFormat( HtmlTokenId nToken )
4779 {
4780  OUString aId, aStyle, aLang, aDir;
4781  OUString aClass;
4782 
4783  const HTMLOptions& rHTMLOptions = GetOptions();
4784  for (size_t i = rHTMLOptions.size(); i; )
4785  {
4786  const HTMLOption& rOption = rHTMLOptions[--i];
4787  switch( rOption.GetToken() )
4788  {
4789  case HtmlOptionId::ID:
4790  aId = rOption.GetString();
4791  break;
4792  case HtmlOptionId::STYLE:
4793  aStyle = rOption.GetString();
4794  break;
4795  case HtmlOptionId::CLASS:
4796  aClass = rOption.GetString();
4797  break;
4798  case HtmlOptionId::LANG:
4799  aLang = rOption.GetString();
4800  break;
4801  case HtmlOptionId::DIR:
4802  aDir = rOption.GetString();
4803  break;
4804  default: break;
4805  }
4806  }
4807 
4808  // create a new context
4809  std::unique_ptr<HTMLAttrContext> xCntxt(new HTMLAttrContext(nToken));
4810 
4811  // set the style and save it in the context
4812  SwCharFormat* pCFormat = m_pCSS1Parser->GetChrFormat( nToken, aClass );
4813  OSL_ENSURE( pCFormat, "No character format found for token" );
4814 
4815  // parse styles (regarding class see also NewPara)
4816  if (HasStyleOptions(aStyle, aId, OUString(), &aLang, &aDir))
4817  {
4818  SfxItemSet aItemSet( m_xDoc->GetAttrPool(), m_pCSS1Parser->GetWhichMap() );
4819  SvxCSS1PropertyInfo aPropInfo;
4820 
4821  if (ParseStyleOptions(aStyle, aId, OUString(), aItemSet, aPropInfo, &aLang, &aDir))
4822  {
4823  OSL_ENSURE( aClass.isEmpty() || !m_pCSS1Parser->GetClass( aClass ),
4824  "Class is not considered" );
4825  DoPositioning( aItemSet, aPropInfo, xCntxt.get() );
4826  InsertAttrs( aItemSet, aPropInfo, xCntxt.get(), true );
4827  }
4828  }
4829 
4830  // Character formats are stored in their own stack and can never be inserted
4831  // by styles. Therefore the attribute doesn't exist in CSS1-Which-Range.
4832  if( pCFormat )
4833  InsertAttr( &m_xAttrTab->pCharFormats, SwFormatCharFormat( pCFormat ), xCntxt.get() );
4834 
4835  // save the context
4836  PushContext(xCntxt);
4837 }
4838 
4839 void SwHTMLParser::InsertSpacer()
4840 {
4841  // and if applicable change it via the options
4842  sal_Int16 eVertOri = text::VertOrientation::TOP;
4843  sal_Int16 eHoriOri = text::HoriOrientation::NONE;
4844  Size aSize( 0, 0);
4845  long nSize = 0;
4846  bool bPercentWidth = false;
4847  bool bPercentHeight = false;
4848  sal_uInt16 nType = HTML_SPTYPE_HORI;
4849 
4850  const HTMLOptions& rHTMLOptions = GetOptions();
4851  for (size_t i = rHTMLOptions.size(); i; )
4852  {
4853  const HTMLOption& rOption = rHTMLOptions[--i];
4854  switch( rOption.GetToken() )
4855  {
4856  case HtmlOptionId::TYPE:
4857  rOption.GetEnum( nType, aHTMLSpacerTypeTable );
4858  break;
4859  case HtmlOptionId::ALIGN:
4860  eVertOri =
4861  rOption.GetEnum( aHTMLImgVAlignTable,
4862  eVertOri );
4863  eHoriOri =
4864  rOption.GetEnum( aHTMLImgHAlignTable,
4865  eHoriOri );
4866  break;
4867  case HtmlOptionId::WIDTH:
4868  // First only save as pixel value!
4869  bPercentWidth = (rOption.GetString().indexOf('%') != -1);
4870  aSize.setWidth( static_cast<long>(rOption.GetNumber()) );
4871  break;
4872  case HtmlOptionId::HEIGHT:
4873  // First only save as pixel value!
4874  bPercentHeight = (rOption.GetString().indexOf('%') != -1);
4875  aSize.setHeight( static_cast<long>(rOption.GetNumber()) );
4876  break;
4877  case HtmlOptionId::SIZE:
4878  // First only save as pixel value!
4879  nSize = rOption.GetNumber();
4880  break;
4881  default: break;
4882  }
4883  }
4884 
4885  switch( nType )
4886  {
4887  case HTML_SPTYPE_BLOCK:
4888  {
4889  // create an empty text frame
4890 
4891  // fetch the ItemSet
4892  SfxItemSet aFrameSet( m_xDoc->GetAttrPool(),
4893  svl::Items<RES_FRMATR_BEGIN, RES_FRMATR_END-1>{} );
4894  if( !IsNewDoc() )
4895  Reader::ResetFrameFormatAttrs( aFrameSet );
4896 
4897  // set the anchor and the adjustment
4898  SetAnchorAndAdjustment( eVertOri, eHoriOri, aFrameSet );
4899 
4900  // and the size of the frame
4901  Size aDfltSz( MINFLY, MINFLY );
4902  Size aSpace( 0, 0 );
4903  SfxItemSet aDummyItemSet( m_xDoc->GetAttrPool(),
4904  m_pCSS1Parser->GetWhichMap() );
4905  SvxCSS1PropertyInfo aDummyPropInfo;
4906 
4907  SetFixSize( aSize, aDfltSz, bPercentWidth, bPercentHeight,
4908  aDummyPropInfo, aFrameSet );
4909  SetSpace( aSpace, aDummyItemSet, aDummyPropInfo, aFrameSet );
4910 
4911  // protect the content
4912  SvxProtectItem aProtectItem( RES_PROTECT) ;
4913  aProtectItem.SetContentProtect( true );
4914  aFrameSet.Put( aProtectItem );
4915 
4916  // create the frame
4917  RndStdIds eAnchorId =
4918  aFrameSet.Get(RES_ANCHOR).GetAnchorId();
4919  SwFrameFormat *pFlyFormat = m_xDoc->MakeFlySection( eAnchorId,
4920  m_pPam->GetPoint(), &aFrameSet );
4921  // Possibly create frames and register auto-bound frames.
4922  RegisterFlyFrame( pFlyFormat );
4923  }
4924  break;
4925  case HTML_SPTYPE_VERT:
4926  if( nSize > 0 )
4927  {
4928  if (Application::GetDefaultDevice())
4929  {
4930  nSize = Application::GetDefaultDevice()
4931  ->PixelToLogic( Size(0,nSize),
4932  MapMode(MapUnit::MapTwip) ).Height();
4933  }
4934 
4935  // set a paragraph margin
4936  SwTextNode *pTextNode = nullptr;
4937  if( !m_pPam->GetPoint()->nContent.GetIndex() )
4938  {
4939  // if possible change the bottom paragraph margin
4940  // of previous node
4941 
4942  SetAttr(); // set still open paragraph attributes
4943 
4944  pTextNode = m_xDoc->GetNodes()[m_pPam->GetPoint()->nNode.GetIndex()-1]
4945  ->GetTextNode();
4946 
4947  // If the previous paragraph isn't a text node, then now an
4948  // empty paragraph is created, which already generates a single
4949  // line of spacing.
4950  if( !pTextNode )
4951  nSize = nSize>HTML_PARSPACE ? nSize-HTML_PARSPACE : 0;
4952  }
4953 
4954  if( pTextNode )
4955  {
4956  SvxULSpaceItem aULSpace( static_cast<const SvxULSpaceItem&>(pTextNode
4957  ->SwContentNode::GetAttr( RES_UL_SPACE )) );
4958  aULSpace.SetLower( aULSpace.GetLower() + static_cast<sal_uInt16>(nSize) );
4959  pTextNode->SetAttr( aULSpace );
4960  }
4961  else
4962  {
4963  NewAttr(m_xAttrTab, &m_xAttrTab->pULSpace, SvxULSpaceItem(0, static_cast<sal_uInt16>(nSize), RES_UL_SPACE));
4964  EndAttr( m_xAttrTab->pULSpace, false );
4965 
4966  AppendTextNode(); // Don't change spacing!
4967  }
4968  }
4969  break;
4970  case HTML_SPTYPE_HORI:
4971  if( nSize > 0 )
4972  {
4973  // If the paragraph is still empty, set first line
4974  // indentation, otherwise apply letter spacing over a space.
4975 
4976  if (Application::GetDefaultDevice())
4977  {
4978  nSize = Application::GetDefaultDevice()
4979  ->PixelToLogic( Size(nSize,0),
4980  MapMode(MapUnit::MapTwip) ).Width();
4981  }
4982 
4983  if( !m_pPam->GetPoint()->nContent.GetIndex() )
4984  {
4985  sal_uInt16 nLeft=0, nRight=0;
4986  short nIndent = 0;
4987 
4988  GetMarginsFromContextWithNumberBullet( nLeft, nRight, nIndent );
4989  nIndent = nIndent + static_cast<short>(nSize);
4990 
4991  SvxLRSpaceItem aLRItem( RES_LR_SPACE );
4992  aLRItem.SetTextLeft( nLeft );
4993  aLRItem.SetRight( nRight );
4994  aLRItem.SetTextFirstLineOffset( nIndent );
4995 
4996  NewAttr(m_xAttrTab, &m_xAttrTab->pLRSpace, aLRItem);
4997  EndAttr( m_xAttrTab->pLRSpace, false );
4998  }
4999  else
5000  {
5001  NewAttr(m_xAttrTab, &m_xAttrTab->pKerning, SvxKerningItem( static_cast<short>(nSize), RES_CHRATR_KERNING ));
5002  m_xDoc->getIDocumentContentOperations().InsertString( *m_pPam, " " );
5003  EndAttr( m_xAttrTab->pKerning );
5004  }
5005  }
5006  }
5007 }
5008 
5009 sal_uInt16 SwHTMLParser::ToTwips( sal_uInt16 nPixel )
5010 {
5011  if( nPixel && Application::GetDefaultDevice() )
5012  {
5013  long nTwips = Application::GetDefaultDevice()->PixelToLogic(
5014  Size( nPixel, nPixel ), MapMode( MapUnit::MapTwip ) ).Width();
5015  return static_cast<sal_uInt16>(std::min(nTwips, SwTwips(SAL_MAX_UINT16)));
5016  }
5017  else
5018  return nPixel;
5019 }
5020 
5021 SwTwips SwHTMLParser::GetCurrentBrowseWidth()
5022 {
5023  const SwTwips nWidth = SwHTMLTableLayout::GetBrowseWidth( *m_xDoc );
5024  if( nWidth )
5025  return nWidth;
5026 
5027  if( !m_aHTMLPageSize.Width() )
5028  {
5029  const SwFrameFormat& rPgFormat = m_pCSS1Parser->GetMasterPageDesc()->GetMaster();
5030 
5031  const SwFormatFrameSize& rSz = rPgFormat.GetFrameSize();
5032  const SvxLRSpaceItem& rLR = rPgFormat.GetLRSpace();
5033  const SvxULSpaceItem& rUL = rPgFormat.GetULSpace();
5034  const SwFormatCol& rCol = rPgFormat.GetCol();
5035 
5036  m_aHTMLPageSize.setWidth( rSz.GetWidth() - rLR.GetLeft() - rLR.GetRight() );
5037  m_aHTMLPageSize.setHeight( rSz.GetHeight() - rUL.GetUpper() - rUL.GetLower() );
5038 
5039  if( 1 < rCol.GetNumCols() )
5040  m_aHTMLPageSize.setWidth( m_aHTMLPageSize.Width() / ( rCol.GetNumCols()) );
5041  }
5042 
5043  return m_aHTMLPageSize.Width();
5044 }
5045 
5046 void SwHTMLParser::InsertIDOption()
5047 {
5048  OUString aId;
5049  const HTMLOptions& rHTMLOptions = GetOptions();
5050  for (size_t i = rHTMLOptions.size(); i; )
5051  {
5052  const HTMLOption& rOption = rHTMLOptions[--i];
5053  if( HtmlOptionId::ID==rOption.GetToken() )
5054  {
5055  aId = rOption.GetString();
5056  break;
5057  }
5058  }
5059 
5060  if( !aId.isEmpty() )
5061  InsertBookmark( aId );
5062 }
5063 
5064 void SwHTMLParser::InsertLineBreak()
5065 {
5066  // <BR CLEAR=xxx> is handled as:
5067  // 1.) Only regard the paragraph-bound frames anchored in current paragraph.
5068  // 2.) For left-justified aligned frames, CLEAR=LEFT or ALL, and for right-
5069  // justified aligned frames, CLEAR=RIGHT or ALL, the wrap-through is
5070  // changed as following:
5071  // 3.) If the paragraph contains no text, then the frames don't get a wrapping
5072  // 4.) otherwise a left aligned frame gets a right "only anchor" wrapping
5073  // and a right aligned frame gets a left "only anchor" wrapping.
5074  // 5.) if in a non-empty paragraph the wrapping of a frame is changed,
5075  // then a new paragraph is opened
5076  // 6.) If no wrappings of frames are changed, a hard line break is inserted.
5077 
5078  OUString aId, aStyle, aClass; // the id of bookmark
5079  bool bClearLeft = false, bClearRight = false;
5080  bool bCleared = false; // Was a CLEAR executed?
5081 
5082  // then we fetch the options
5083  const HTMLOptions& rHTMLOptions = GetOptions();
5084  for (size_t i = rHTMLOptions.size(); i; )
5085  {
5086  const HTMLOption& rOption = rHTMLOptions[--i];
5087  switch( rOption.GetToken() )
5088  {
5089  case HtmlOptionId::CLEAR:
5090  {
5091  const OUString &rClear = rOption.GetString();
5092  if( rClear.equalsIgnoreAsciiCase( OOO_STRING_SVTOOLS_HTML_AL_all ) )
5093  {
5094  bClearLeft = true;
5095  bClearRight = true;
5096  }
5097  else if( rClear.equalsIgnoreAsciiCase( OOO_STRING_SVTOOLS_HTML_AL_left ) )
5098  bClearLeft = true;
5099  else if( rClear.equalsIgnoreAsciiCase( OOO_STRING_SVTOOLS_HTML_AL_right ) )
5100  bClearRight = true;
5101  }
5102  break;
5103  case HtmlOptionId::ID:
5104  aId = rOption.GetString();
5105  break;
5106  case HtmlOptionId::STYLE:
5107  aStyle = rOption.GetString();
5108  break;
5109  case HtmlOptionId::CLASS:
5110  aClass = rOption.GetString();
5111  break;
5112  default: break;
5113  }
5114  }
5115 
5116  // CLEAR is only supported for the current paragraph
5117  if( bClearLeft || bClearRight )
5118  {
5119  SwNodeIndex& rNodeIdx = m_pPam->GetPoint()->nNode;
5120  SwTextNode* pTextNd = rNodeIdx.GetNode().GetTextNode();
5121  if( pTextNd )
5122  {
5123  const SwFrameFormats& rFrameFormatTable = *m_xDoc->GetSpzFrameFormats();
5124 
5125  for( size_t i=0; i<rFrameFormatTable.size(); i++ )
5126  {
5127  SwFrameFormat *const pFormat = rFrameFormatTable[i];
5128  SwFormatAnchor const*const pAnchor = &pFormat->GetAnchor();
5129  SwPosition const*const pAPos = pAnchor->GetContentAnchor();
5130  if (pAPos &&
5131  ((RndStdIds::FLY_AT_PARA == pAnchor->GetAnchorId()) ||
5132  (RndStdIds::FLY_AT_CHAR == pAnchor->GetAnchorId())) &&
5133  pAPos->nNode == rNodeIdx &&
5134  pFormat->GetSurround().GetSurround() != css::text::WrapTextMode_NONE )
5135  {
5136  sal_Int16 eHori = RES_DRAWFRMFMT == pFormat->Which()
5137  ? text::HoriOrientation::LEFT
5138  : pFormat->GetHoriOrient().GetHoriOrient();
5139 
5140  css::text::WrapTextMode eSurround = css::text::WrapTextMode_PARALLEL;
5141  if( m_pPam->GetPoint()->nContent.GetIndex() )
5142  {
5143  if( bClearLeft && text::HoriOrientation::LEFT==eHori )
5144  eSurround = css::text::WrapTextMode_RIGHT;
5145  else if( bClearRight && text::HoriOrientation::RIGHT==eHori )
5146  eSurround = css::text::WrapTextMode_LEFT;
5147  }
5148  else if( (bClearLeft && text::HoriOrientation::LEFT==eHori) ||
5149  (bClearRight && text::HoriOrientation::RIGHT==eHori) )
5150  {
5151  eSurround = css::text::WrapTextMode_NONE;
5152  }
5153 
5154  if( css::text::WrapTextMode_PARALLEL != eSurround )
5155  {
5156  SwFormatSurround aSurround( eSurround );
5157  if( css::text::WrapTextMode_NONE != eSurround )
5158  aSurround.SetAnchorOnly( true );
5159  pFormat->SetFormatAttr( aSurround );
5160  bCleared = true;
5161  }
5162  }
5163  }
5164  }
5165  }
5166 
5167  // parse styles
5168  std::shared_ptr<SvxFormatBreakItem> aBreakItem(std::make_shared<SvxFormatBreakItem>(SvxBreak::NONE, RES_BREAK));
5169  bool bBreakItem = false;
5170  if( HasStyleOptions( aStyle, aId, aClass ) )
5171  {
5172  SfxItemSet aItemSet( m_xDoc->GetAttrPool(), m_pCSS1Parser->GetWhichMap() );
5173  SvxCSS1PropertyInfo aPropInfo;
5174 
5175  if( ParseStyleOptions( aStyle, aId, aClass, aItemSet, aPropInfo ) )
5176  {
5177  if( m_pCSS1Parser->SetFormatBreak( aItemSet, aPropInfo ) )
5178  {
5179  aBreakItem.reset(aItemSet.Get(RES_BREAK).Clone());
5180  bBreakItem = true;
5181  }
5182  if( !aPropInfo.m_aId.isEmpty() )
5183  InsertBookmark( aPropInfo.m_aId );
5184  }
5185  }
5186 
5187  if( bBreakItem && SvxBreak::PageAfter == aBreakItem->GetBreak() )
5188  {
5189  NewAttr(m_xAttrTab, &m_xAttrTab->pBreak, *aBreakItem);
5190  EndAttr( m_xAttrTab->pBreak, false );
5191  }
5192 
5193  if( !bCleared && !bBreakItem )
5194  {
5195  // If no CLEAR could or should be executed, a line break will be inserted
5196  m_xDoc->getIDocumentContentOperations().InsertString( *m_pPam, "\x0A" );
5197  }
5198  else if( m_pPam->GetPoint()->nContent.GetIndex() )
5199  {
5200  // If a CLEAR is executed in a non-empty paragraph, then after it
5201  // a new paragraph has to be opened.
5202  // MIB 21.02.97: Here actually we should change the bottom paragraph
5203  // margin to zero. This will fail for something like this <BR ..><P>
5204  // (>Netscape). That's why we don't do it.
5205  AppendTextNode( AM_NOSPACE );
5206  }
5207  if( bBreakItem && SvxBreak::PageBefore == aBreakItem->GetBreak() )
5208  {
5209  NewAttr(m_xAttrTab, &m_xAttrTab->pBreak, *aBreakItem);
5210  EndAttr( m_xAttrTab->pBreak, false );
5211  }
5212 }
5213 
5214 void SwHTMLParser::InsertHorzRule()
5215 {
5216  sal_uInt16 nSize = 0;
5217  sal_uInt16 nWidth = 0;
5218 
5219  SvxAdjust eAdjust = SvxAdjust::End;
5220 
5221  bool bPercentWidth = false;
5222  bool bNoShade = false;
5223  bool bColor = false;
5224 
5225  Color aColor;
5226  OUString aId;
5227 
5228  // let's fetch the options
5229  const HTMLOptions& rHTMLOptions = GetOptions();
5230  for (size_t i = rHTMLOptions.size(); i; )
5231  {
5232  const HTMLOption& rOption = rHTMLOptions[--i];
5233  switch( rOption.GetToken() )
5234  {
5235  case HtmlOptionId::ID:
5236  aId = rOption.GetString();
5237  break;
5238  case HtmlOptionId::SIZE:
5239  nSize = static_cast<sal_uInt16>(rOption.GetNumber());
5240  break;
5241  case HtmlOptionId::WIDTH:
5242  bPercentWidth = (rOption.GetString().indexOf('%') != -1);
5243  nWidth = static_cast<sal_uInt16>(rOption.GetNumber());
5244  if( bPercentWidth && nWidth>=100 )
5245  {
5246  // the default case are 100% lines (no attributes necessary)
5247  nWidth = 0;
5248  bPercentWidth = false;
5249  }
5250  break;
5251  case HtmlOptionId::ALIGN:
5252  eAdjust = rOption.GetEnum( aHTMLPAlignTable, eAdjust );
5253  break;
5254  case HtmlOptionId::NOSHADE:
5255  bNoShade = true;
5256  break;
5257  case HtmlOptionId::COLOR:
5258  rOption.GetColor( aColor );
5259  bColor = true;
5260  break;
5261  default: break;
5262  }
5263  }
5264 
5265  if( m_pPam->GetPoint()->nContent.GetIndex() )
5266  AppendTextNode( AM_NOSPACE );
5267  if( m_nOpenParaToken != HtmlTokenId::NONE )
5268  EndPara();
5269  AppendTextNode();
5270  m_pPam->Move( fnMoveBackward );
5271 
5272  // ...and save in a context
5273  std::unique_ptr<HTMLAttrContext> xCntxt(
5274  new HTMLAttrContext(HtmlTokenId::HORZRULE, RES_POOLCOLL_HTML_HR, OUString()));
5275 
5276  PushContext(xCntxt);
5277 
5278  // set the new style
5279  SetTextCollAttrs(m_aContexts.back().get());
5280 
5281  // the hard attributes of the current paragraph will never become invalid
5282  m_aParaAttrs.clear();
5283 
5284  if( nSize>0 || bColor || bNoShade )
5285  {
5286  // set line colour and/or width
5287  if( !bColor )
5288  aColor = COL_GRAY;
5289 
5290  SvxBorderLine aBorderLine( &aColor );
5291  if( nSize )
5292  {
5293  long nPWidth = 0;
5294  long nPHeight = static_cast<long>(nSize);
5295  SvxCSS1Parser::PixelToTwip( nPWidth, nPHeight );
5296  if ( !bNoShade )
5297  {
5298  aBorderLine.SetBorderLineStyle(SvxBorderLineStyle::DOUBLE);
5299  }
5300  aBorderLine.SetWidth( nPHeight );
5301  }
5302  else if( bNoShade )
5303  {
5304  aBorderLine.SetWidth( DEF_LINE_WIDTH_2 );
5305  }
5306  else
5307  {
5308  aBorderLine.SetBorderLineStyle(SvxBorderLineStyle::DOUBLE);
5309  aBorderLine.SetWidth( DEF_LINE_WIDTH_0 );
5310  }
5311 
5312  SvxBoxItem aBoxItem(RES_BOX);
5313  aBoxItem.SetLine( &aBorderLine, SvxBoxItemLine::BOTTOM );
5314  HTMLAttr* pTmp = new HTMLAttr(*m_pPam->GetPoint(), aBoxItem, nullptr, std::shared_ptr<HTMLAttrTable>());
5315  m_aSetAttrTab.push_back( pTmp );
5316  }
5317  if( nWidth )
5318  {
5319  // If we aren't in a table, then the width value will be "faked" with
5320  // paragraph indents. That makes little sense in a table. In order to
5321  // avoid that the line is considered during the width calculation, it
5322  // still gets an appropriate LRSpace-Item.
5323  if (!m_xTable)
5324  {
5325  // fake length and alignment of line above paragraph indents
5326  long nBrowseWidth = GetCurrentBrowseWidth();
5327  nWidth = bPercentWidth ? static_cast<sal_uInt16>((nWidth*nBrowseWidth) / 100)
5328  : ToTwips( static_cast<sal_uInt16>(nBrowseWidth) );
5329  if( nWidth < MINLAY )
5330  nWidth = MINLAY;
5331 
5332  const SwFormatColl *pColl = (static_cast<long>(nWidth) < nBrowseWidth) ? GetCurrFormatColl() : nullptr;
5333  if (pColl)
5334  {
5335  SvxLRSpaceItem aLRItem( pColl->GetLRSpace() );
5336  long nDist = nBrowseWidth - nWidth;
5337 
5338  switch( eAdjust )
5339  {
5340  case SvxAdjust::Right:
5341  aLRItem.SetTextLeft( static_cast<sal_uInt16>(nDist) );
5342  break;
5343  case SvxAdjust::Left:
5344  aLRItem.SetRight( static_cast<sal_uInt16>(nDist) );
5345  break;
5346  case SvxAdjust::Center:
5347  default:
5348  nDist /= 2;
5349  aLRItem.SetTextLeft( static_cast<sal_uInt16>(nDist) );
5350  aLRItem.SetRight( static_cast<sal_uInt16>(nDist) );
5351  break;
5352  }
5353 
5354  HTMLAttr* pTmp = new HTMLAttr(*m_pPam->GetPoint(), aLRItem, nullptr, std::shared_ptr<HTMLAttrTable>());
5355  m_aSetAttrTab.push_back( pTmp );
5356  }
5357  }
5358  }
5359 
5360  // it's not possible to insert bookmarks in links
5361  if( !aId.isEmpty() )
5362  InsertBookmark( aId );
5363 
5364  // pop current context of stack
5365  std::unique_ptr<HTMLAttrContext> xPoppedContext(PopContext(HtmlTokenId::HORZRULE));
5366  xPoppedContext.reset();
5367 
5368  m_pPam->Move( fnMoveForward );
5369 
5370  // and set the current style in the next paragraph
5371  SetTextCollAttrs();
5372 }
5373 
5374 void SwHTMLParser::ParseMoreMetaOptions()
5375 {
5376  OUString aName, aContent;
5377  bool bHTTPEquiv = false;
5378 
5379  const HTMLOptions& rHTMLOptions = GetOptions();
5380  for (size_t i = rHTMLOptions.size(); i; )
5381  {
5382  const HTMLOption& rOption = rHTMLOptions[--i];
5383  switch( rOption.GetToken() )
5384  {
5385  case HtmlOptionId::NAME:
5386  aName = rOption.