LibreOffice Module sw (master)  1
htmlcss1.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 <hintids.hxx>
21 #include <svl/itemiter.hxx>
22 #include <svl/whiter.hxx>
23 #include <svl/urihelper.hxx>
24 #include <i18nlangtag/languagetag.hxx>
25 #include <sfx2/docfile.hxx>
26 #include <vcl/svapp.hxx>
27 #include <editeng/fhgtitem.hxx>
28 #include <editeng/brushitem.hxx>
29 #include <editeng/lrspitem.hxx>
30 #include <editeng/ulspitem.hxx>
31 #include <editeng/boxitem.hxx>
32 #include <editeng/flstitem.hxx>
33 #include <editeng/formatbreakitem.hxx>
34 #include <editeng/keepitem.hxx>
35 #include <editeng/fontitem.hxx>
36 #include <editeng/langitem.hxx>
37 #include <editeng/frmdiritem.hxx>
38 #include <svtools/htmltokn.h>
39 #include <svtools/htmlkywd.hxx>
40 #include <fmtpdsc.hxx>
41 #include <fmtanchr.hxx>
42 #include <fmtornt.hxx>
43 #include <fmtsrnd.hxx>
44 #include <fmtfsize.hxx>
45 #include <frmatr.hxx>
46 #include <charfmt.hxx>
47 #include <docary.hxx>
48 #include <svx/svxids.hrc>
49 #include <osl/diagnose.h>
50 
51 #include <doc.hxx>
52 #include <IDocumentStylePoolAccess.hxx>
53 #include <pam.hxx>
54 #include <ndtxt.hxx>
55 #include <poolfmt.hxx>
56 #include <docsh.hxx>
57 #include <paratr.hxx>
58 #include <pagedesc.hxx>
59 #include "css1kywd.hxx"
60 #include "swcss1.hxx"
61 #include "htmlnum.hxx"
62 #include "swhtml.hxx"
63 #include <numrule.hxx>
64 #include "css1atr.hxx"
65 
66 using namespace ::com::sun::star;
67 
68 // How many rows/characters are allowed for DropCaps?
69 // (Are there maybe somewhere else corresponding values?)
70 #define MAX_DROPCAP_LINES 9
71 #define MAX_DROPCAP_CHARS 9
72 
73 static void lcl_swcss1_setEncoding( SwFormat& rFormat, rtl_TextEncoding eEnc );
74 
75 // Implementation of SwCSS1Parsers (actually swcss1.cxx)
76 static const sal_uInt16 aItemIds[] =
77 {
78  RES_BREAK,
79  RES_PAGEDESC,
80  RES_KEEP,
81 };
82 
83 void SwCSS1Parser::ChgPageDesc( const SwPageDesc *pPageDesc,
84  const SwPageDesc& rNewPageDesc )
85 {
86  size_t pos;
87  bool found = m_pDoc->ContainsPageDesc( pPageDesc, &pos );
88  OSL_ENSURE( found, "style not found" );
89  if (found)
90  m_pDoc->ChgPageDesc( pos, rNewPageDesc );
91 }
92 
93 SwCSS1Parser::SwCSS1Parser( SwDoc *pD, const sal_uInt32 aFHeights[7], const OUString& rBaseURL, bool bNewDoc ) :
94  SvxCSS1Parser( pD->GetAttrPool(), rBaseURL,
95  aItemIds, SAL_N_ELEMENTS(aItemIds)),
96  m_pDoc( pD ),
97  m_nDropCapCnt( 0 ),
98  m_bIsNewDoc( bNewDoc ),
99  m_bBodyBGColorSet( false ),
100  m_bBodyBackgroundSet( false ),
101  m_bBodyTextSet( false ),
102  m_bBodyLinkSet( false ),
103  m_bBodyVLinkSet( false ),
104  m_bSetFirstPageDesc( false ),
105  m_bSetRightPageDesc( false ),
106  m_bTableHeaderTextCollSet( false ),
107  m_bTableTextCollSet( false ),
108  m_bLinkCharFormatsSet( false )
109 {
110  m_aFontHeights[0] = aFHeights[0];
111  m_aFontHeights[1] = aFHeights[1];
112  m_aFontHeights[2] = aFHeights[2];
113  m_aFontHeights[3] = aFHeights[3];
114  m_aFontHeights[4] = aFHeights[4];
115  m_aFontHeights[5] = aFHeights[5];
116  m_aFontHeights[6] = aFHeights[6];
117 }
118 
119 SwCSS1Parser::~SwCSS1Parser()
120 {
121 }
122 
123 // Feature: PrintExt
124 bool SwCSS1Parser::SetFormatBreak( SfxItemSet& rItemSet,
125  const SvxCSS1PropertyInfo& rPropInfo )
126 {
127  SvxBreak eBreak = SvxBreak::NONE;
128  bool bKeep = false;
129  bool bSetKeep = false, bSetBreak = false, bSetPageDesc = false;
130  const SwPageDesc *pPageDesc = nullptr;
131  switch( rPropInfo.m_ePageBreakBefore )
132  {
133  case SVX_CSS1_PBREAK_ALWAYS:
134  eBreak = SvxBreak::PageBefore;
135  bSetBreak = true;
136  break;
137  case SVX_CSS1_PBREAK_LEFT:
138  pPageDesc = GetLeftPageDesc( true );
139  bSetPageDesc = true;
140  break;
141  case SVX_CSS1_PBREAK_RIGHT:
142  pPageDesc = GetRightPageDesc( true );
143  bSetPageDesc = true;
144  break;
145  case SVX_CSS1_PBREAK_AUTO:
146  bSetBreak = bSetPageDesc = true;
147  break;
148  default:
149  ;
150  }
151  switch( rPropInfo.m_ePageBreakAfter )
152  {
153  case SVX_CSS1_PBREAK_ALWAYS:
154  case SVX_CSS1_PBREAK_LEFT:
155  case SVX_CSS1_PBREAK_RIGHT:
156  // LEFT/RIGHT also could be set in the previous paragraph
157  eBreak = SvxBreak::PageAfter;
158  bSetBreak = true;
159  break;
160  case SVX_CSS1_PBREAK_AUTO:
161  bSetBreak = bSetKeep = bSetPageDesc = true;
162  break;
163  case SVX_CSS1_PBREAK_AVOID:
164  bKeep = bSetKeep = true;
165  break;
166  default:
167  ;
168  }
169 
170  if( bSetBreak )
171  rItemSet.Put( SvxFormatBreakItem( eBreak, RES_BREAK ) );
172  if( bSetPageDesc )
173  rItemSet.Put( SwFormatPageDesc( pPageDesc ) );
174  if( bSetKeep )
175  rItemSet.Put( SvxFormatKeepItem( bKeep, RES_KEEP ) );
176 
177  return bSetBreak;
178 }
179 
180 static void SetCharFormatAttrs( SwCharFormat *pCharFormat, SfxItemSet& rItemSet )
181 {
182  const SfxPoolItem *pItem;
183  static const sal_uInt16 aWhichIds[3] = { RES_CHRATR_FONTSIZE,RES_CHRATR_CJK_FONTSIZE,
184  RES_CHRATR_CTL_FONTSIZE };
185  for(sal_uInt16 i : aWhichIds)
186  {
187  if( SfxItemState::SET == rItemSet.GetItemState( i, false,
188  &pItem ) &&
189  static_cast<const SvxFontHeightItem *>(pItem)->GetProp() != 100)
190  {
191  // percentage values at the FontHeight item aren't supported
192  rItemSet.ClearItem( i );
193  }
194  }
195 
196  pCharFormat->SetFormatAttr( rItemSet );
197 
198  if( SfxItemState::SET == rItemSet.GetItemState( RES_BACKGROUND, false, &pItem ) )
199  {
200  // A Brush-Item with RES_BACKGROUND must be converted to one
201  // with RES_CHRATR_BACKGROUND
202 
203  SvxBrushItem aBrushItem( *static_cast<const SvxBrushItem *>(pItem) );
204  aBrushItem.SetWhich( RES_CHRATR_BACKGROUND );
205  pCharFormat->SetFormatAttr( aBrushItem );
206  }
207 
208  if( SfxItemState::SET == rItemSet.GetItemState( RES_BOX, false, &pItem ) )
209  {
210  SvxBoxItem aBoxItem( *static_cast<const SvxBoxItem *>(pItem) );
211  aBoxItem.SetWhich( RES_CHRATR_BOX );
212  pCharFormat->SetFormatAttr( aBoxItem );
213  }
214 }
215 
216 void SwCSS1Parser::SetLinkCharFormats()
217 {
218  OSL_ENSURE( !m_bLinkCharFormatsSet, "Call SetLinkCharFormats unnecessary" );
219 
220  SvxCSS1MapEntry *pStyleEntry =
221  GetTag( OOO_STRING_SVTOOLS_HTML_anchor );
222  SwCharFormat *pUnvisited = nullptr, *pVisited = nullptr;
223  if( pStyleEntry )
224  {
225  SfxItemSet& rItemSet = pStyleEntry->GetItemSet();
226  bool bColorSet = (SfxItemState::SET==rItemSet.GetItemState(RES_CHRATR_COLOR,
227  false));
228  pUnvisited = GetCharFormatFromPool( RES_POOLCHR_INET_NORMAL );
229  SetCharFormatAttrs( pUnvisited, rItemSet );
230  m_bBodyLinkSet |= bColorSet;
231 
232  pVisited = GetCharFormatFromPool( RES_POOLCHR_INET_VISIT );
233  SetCharFormatAttrs( pVisited, rItemSet );
234  m_bBodyVLinkSet |= bColorSet;
235  }
236 
237  OUString sTmp = OOO_STRING_SVTOOLS_HTML_anchor ":link";
238 
239  pStyleEntry = GetTag( sTmp );
240  if( pStyleEntry )
241  {
242  SfxItemSet& rItemSet = pStyleEntry->GetItemSet();
243  bool bColorSet = (SfxItemState::SET==rItemSet.GetItemState(RES_CHRATR_COLOR,
244  false));
245  if( !pUnvisited )
246  pUnvisited = GetCharFormatFromPool( RES_POOLCHR_INET_NORMAL );
247  SetCharFormatAttrs( pUnvisited, rItemSet );
248  m_bBodyLinkSet |= bColorSet;
249  }
250 
251  sTmp = OOO_STRING_SVTOOLS_HTML_anchor ":visited";
252 
253  pStyleEntry = GetTag( sTmp );
254  if( pStyleEntry )
255  {
256  SfxItemSet& rItemSet = pStyleEntry->GetItemSet();
257  bool bColorSet = (SfxItemState::SET==rItemSet.GetItemState(RES_CHRATR_COLOR,
258  false));
259  if( !pVisited )
260  pVisited = GetCharFormatFromPool( RES_POOLCHR_INET_VISIT );
261  SetCharFormatAttrs( pVisited, rItemSet );
262  m_bBodyVLinkSet |= bColorSet;
263  }
264 
265  m_bLinkCharFormatsSet = true;
266 }
267 
268 static void SetTextCollAttrs( SwTextFormatColl *pColl, SfxItemSet& rItemSet,
269  SvxCSS1PropertyInfo const & rPropInfo,
270  SwCSS1Parser *pCSS1Parser )
271 {
272  const SfxItemSet& rCollItemSet = pColl->GetAttrSet();
273  const SfxPoolItem *pCollItem, *pItem;
274 
275  // left, right border and first line indentation
276  if( (rPropInfo.m_bLeftMargin || rPropInfo.m_bRightMargin ||
277  rPropInfo.m_bTextIndent) &&
278  (!rPropInfo.m_bLeftMargin || !rPropInfo.m_bRightMargin ||
279  !rPropInfo.m_bTextIndent) &&
280  SfxItemState::SET == rCollItemSet.GetItemState(RES_LR_SPACE,true,&pCollItem) &&
281  SfxItemState::SET == rItemSet.GetItemState(RES_LR_SPACE,false,&pItem) )
282  {
283  const SvxLRSpaceItem *pLRItem = static_cast<const SvxLRSpaceItem *>(pItem);
284 
285  SvxLRSpaceItem aLRItem( *static_cast<const SvxLRSpaceItem *>(pCollItem) );
286  if( rPropInfo.m_bLeftMargin )
287  aLRItem.SetTextLeft( pLRItem->GetTextLeft() );
288  if( rPropInfo.m_bRightMargin )
289  aLRItem.SetRight( pLRItem->GetRight() );
290  if( rPropInfo.m_bTextIndent )
291  aLRItem.SetTextFirstLineOfst( pLRItem->GetTextFirstLineOfst() );
292 
293  rItemSet.Put( aLRItem );
294  }
295 
296  // top and bottom border
297  if( (rPropInfo.m_bTopMargin || rPropInfo.m_bBottomMargin) &&
298  (!rPropInfo.m_bTopMargin || !rPropInfo.m_bBottomMargin) &&
299  SfxItemState::SET == rCollItemSet.GetItemState(RES_UL_SPACE,true,
300  &pCollItem) &&
301  SfxItemState::SET == rItemSet.GetItemState(RES_UL_SPACE,false,&pItem) )
302  {
303  const SvxULSpaceItem *pULItem = static_cast<const SvxULSpaceItem *>(pItem);
304 
305  SvxULSpaceItem aULItem( *static_cast<const SvxULSpaceItem *>(pCollItem) );
306  if( rPropInfo.m_bTopMargin )
307  aULItem.SetUpper( pULItem->GetUpper() );
308  if( rPropInfo.m_bBottomMargin )
309  aULItem.SetLower( pULItem->GetLower() );
310 
311  rItemSet.Put( aULItem );
312  }
313 
314  static const sal_uInt16 aWhichIds[3] = { RES_CHRATR_FONTSIZE,RES_CHRATR_CJK_FONTSIZE,
315  RES_CHRATR_CTL_FONTSIZE };
316  for(sal_uInt16 i : aWhichIds)
317  {
318  if( SfxItemState::SET == rItemSet.GetItemState( i, false,
319  &pItem ) &&
320  static_cast<const SvxFontHeightItem *>(pItem)->GetProp() != 100)
321  {
322  // percentage values at the FontHeight item aren't supported
323  rItemSet.ClearItem( i );
324  }
325  }
326 
327  pCSS1Parser->SetFormatBreak( rItemSet, rPropInfo );
328 
329  pColl->SetFormatAttr( rItemSet );
330 }
331 
332 void SwCSS1Parser::SetTableTextColl( bool bHeader )
333 {
334  OSL_ENSURE( !(bHeader ? m_bTableHeaderTextCollSet : m_bTableTextCollSet),
335  "Call SetTableTextColl unnecessary" );
336 
337  sal_uInt16 nPoolId;
338  OUString sTag;
339  if( bHeader )
340  {
341  nPoolId = RES_POOLCOLL_TABLE_HDLN;
342  sTag = OOO_STRING_SVTOOLS_HTML_tableheader;
343  }
344  else
345  {
346  nPoolId = RES_POOLCOLL_TABLE;
347  sTag = OOO_STRING_SVTOOLS_HTML_tabledata;
348  }
349 
350  SwTextFormatColl *pColl = nullptr;
351 
352  // The following entries will never be used again and may be changed.
353  SvxCSS1MapEntry *pStyleEntry = GetTag( sTag );
354  if( pStyleEntry )
355  {
356  pColl = GetTextFormatColl(nPoolId, OUString());
357  SetTextCollAttrs( pColl, pStyleEntry->GetItemSet(),
358  pStyleEntry->GetPropertyInfo(), this );
359  }
360 
361  OUString sTmp = sTag + " " OOO_STRING_SVTOOLS_HTML_parabreak;
362  pStyleEntry = GetTag( sTmp );
363  if( pStyleEntry )
364  {
365  if( !pColl )
366  pColl = GetTextFormatColl(nPoolId, OUString());
367  SetTextCollAttrs( pColl, pStyleEntry->GetItemSet(),
368  pStyleEntry->GetPropertyInfo(), this );
369  }
370 
371  if( bHeader )
372  m_bTableHeaderTextCollSet = true;
373  else
374  m_bTableTextCollSet = true;
375 }
376 
377 void SwCSS1Parser::SetPageDescAttrs( const SvxBrushItem *pBrush,
378  SfxItemSet *pItemSet2 )
379 {
380  std::shared_ptr<SvxBrushItem> aBrushItem(std::make_shared<SvxBrushItem>(RES_BACKGROUND));
381  std::shared_ptr<SvxBoxItem> aBoxItem(std::make_shared<SvxBoxItem>(RES_BOX));
382  std::shared_ptr<SvxFrameDirectionItem> aFrameDirItem(std::make_shared<SvxFrameDirectionItem>(SvxFrameDirection::Environment, RES_FRAMEDIR));
383  bool bSetBrush = pBrush!=nullptr, bSetBox = false, bSetFrameDir = false;
384  if( pBrush )
385  aBrushItem.reset(static_cast<SvxBrushItem*>(pBrush->Clone()));
386 
387  if( pItemSet2 )
388  {
389  const SfxPoolItem *pItem = nullptr;
390  if( SfxItemState::SET == pItemSet2->GetItemState( RES_BACKGROUND, false,
391  &pItem ) )
392  {
393  // set a background
394  aBrushItem.reset(static_cast<SvxBrushItem*>(pItem->Clone()));
395  pItemSet2->ClearItem( RES_BACKGROUND );
396  bSetBrush = true;
397  }
398 
399  if( SfxItemState::SET == pItemSet2->GetItemState( RES_BOX, false, &pItem ) )
400  {
401  // set a border
402  aBoxItem.reset(static_cast<SvxBoxItem*>(pItem->Clone()));
403  pItemSet2->ClearItem( RES_BOX );
404  bSetBox = true;
405  }
406 
407  if( SfxItemState::SET == pItemSet2->GetItemState( RES_FRAMEDIR, false, &pItem ) )
408  {
409  // set a frame
410  aFrameDirItem.reset(static_cast<SvxFrameDirectionItem*>(pItem->Clone()));
411  pItemSet2->ClearItem( RES_FRAMEDIR );
412  bSetFrameDir = true;
413  }
414  }
415 
416  if( bSetBrush || bSetBox || bSetFrameDir )
417  {
418  static sal_uInt16 aPoolIds[] = { RES_POOLPAGE_HTML, RES_POOLPAGE_FIRST,
419  RES_POOLPAGE_LEFT, RES_POOLPAGE_RIGHT };
420  for(sal_uInt16 i : aPoolIds)
421  {
422  const SwPageDesc *pPageDesc = GetPageDesc( i, false );
423  if( pPageDesc )
424  {
425  SwPageDesc aNewPageDesc( *pPageDesc );
426  SwFrameFormat &rMaster = aNewPageDesc.GetMaster();
427  if( bSetBrush )
428  rMaster.SetFormatAttr( *aBrushItem );
429  if( bSetBox )
430  rMaster.SetFormatAttr( *aBoxItem );
431  if( bSetFrameDir )
432  rMaster.SetFormatAttr( *aFrameDirItem );
433 
434  ChgPageDesc( pPageDesc, aNewPageDesc );
435  }
436  }
437  }
438 }
439 
440 // Feature: PrintExt
441 void SwCSS1Parser::SetPageDescAttrs( const SwPageDesc *pPageDesc,
442  SfxItemSet& rItemSet,
443  const SvxCSS1PropertyInfo& rPropInfo )
444 {
445  if( !pPageDesc )
446  return;
447 
448  SwPageDesc aNewPageDesc( *pPageDesc );
449  SwFrameFormat &rMaster = aNewPageDesc.GetMaster();
450  const SfxItemSet& rPageItemSet = rMaster.GetAttrSet();
451  const SfxPoolItem *pPageItem, *pItem;
452  bool bChanged = false;
453 
454  // left, right border and first line indentation
455  if( (rPropInfo.m_bLeftMargin || rPropInfo.m_bRightMargin) &&
456  SfxItemState::SET == rItemSet.GetItemState(RES_LR_SPACE,false,&pItem) )
457  {
458  if( (!rPropInfo.m_bLeftMargin || !rPropInfo.m_bRightMargin) &&
459  SfxItemState::SET == rPageItemSet.GetItemState(RES_LR_SPACE,
460  true,&pPageItem) )
461  {
462  const SvxLRSpaceItem *pLRItem = static_cast<const SvxLRSpaceItem *>(pItem);
463 
464  SvxLRSpaceItem aLRItem( *static_cast<const SvxLRSpaceItem *>(pPageItem) );
465  if( rPropInfo.m_bLeftMargin )
466  aLRItem.SetLeft( pLRItem->GetLeft() );
467  if( rPropInfo.m_bRightMargin )
468  aLRItem.SetRight( pLRItem->GetRight() );
469 
470  rMaster.SetFormatAttr( aLRItem );
471  }
472  else
473  {
474  rMaster.SetFormatAttr( *pItem );
475  }
476  bChanged = true;
477  }
478 
479  // top and bottom border
480  if( (rPropInfo.m_bTopMargin || rPropInfo.m_bBottomMargin) &&
481  SfxItemState::SET == rItemSet.GetItemState(RES_UL_SPACE,false,&pItem) )
482  {
483  if( (!rPropInfo.m_bTopMargin || !rPropInfo.m_bBottomMargin) &&
484  SfxItemState::SET == rPageItemSet.GetItemState(RES_UL_SPACE,
485  true,&pPageItem) )
486  {
487  const SvxULSpaceItem *pULItem = static_cast<const SvxULSpaceItem *>(pItem);
488 
489  SvxULSpaceItem aULItem( *static_cast<const SvxULSpaceItem *>(pPageItem) );
490  if( rPropInfo.m_bTopMargin )
491  aULItem.SetUpper( pULItem->GetUpper() );
492  if( rPropInfo.m_bBottomMargin )
493  aULItem.SetLower( pULItem->GetLower() );
494 
495  rMaster.SetFormatAttr( aULItem );
496  }
497  else
498  {
499  rMaster.SetFormatAttr( *pItem );
500  }
501  bChanged = true;
502  }
503 
504  // the size
505  if( rPropInfo.m_eSizeType != SVX_CSS1_STYPE_NONE )
506  {
507  if( rPropInfo.m_eSizeType == SVX_CSS1_STYPE_TWIP )
508  {
509  rMaster.SetFormatAttr( SwFormatFrameSize( ATT_FIX_SIZE, rPropInfo.m_nWidth,
510  rPropInfo.m_nHeight ) );
511  bChanged = true;
512  }
513  else
514  {
515  // With "size: auto|portrait|landscape" the current size
516  // of the style remains. If "landscape" and "portrait" then
517  // the landscape flag will be set and maybe the width/height
518  // are swapped.
519  SwFormatFrameSize aFrameSz( rMaster.GetFrameSize() );
520  bool bLandscape = aNewPageDesc.GetLandscape();
521  if( ( bLandscape &&
522  rPropInfo.m_eSizeType == SVX_CSS1_STYPE_PORTRAIT ) ||
523  ( !bLandscape &&
524  rPropInfo.m_eSizeType == SVX_CSS1_STYPE_LANDSCAPE ) )
525  {
526  SwTwips nTmp = aFrameSz.GetHeight();
527  aFrameSz.SetHeight( aFrameSz.GetWidth() );
528  aFrameSz.SetWidth( nTmp );
529  rMaster.SetFormatAttr( aFrameSz );
530  aNewPageDesc.SetLandscape( !bLandscape );
531  bChanged = true;
532  }
533  }
534  }
535 
536  // Is that possible?
537  if( SfxItemState::SET == rItemSet.GetItemState( RES_BACKGROUND, false, &pItem ) )
538  {
539  // set a background
540  rMaster.SetFormatAttr( *pItem );
541  rItemSet.ClearItem( RES_BACKGROUND );
542  bChanged = true;
543  }
544 
545  if( bChanged )
546  ChgPageDesc( pPageDesc, aNewPageDesc );
547 }
548 
549 std::shared_ptr<SvxBrushItem> SwCSS1Parser::makePageDescBackground() const
550 {
551  return m_pDoc->getIDocumentStylePoolAccess().GetPageDescFromPool( RES_POOLPAGE_HTML, false )
552  ->GetMaster().makeBackgroundBrushItem();
553 }
554 
555 Css1ScriptFlags SwCSS1Parser::GetScriptFromClass( OUString& rClass,
556  bool bSubClassOnly )
557 {
558  Css1ScriptFlags nScriptFlags = Css1ScriptFlags::AllMask;
559  sal_Int32 nLen = rClass.getLength();
560  sal_Int32 nPos = nLen > 4 ? rClass.lastIndexOf( '-' ) : -1;
561 
562  if( nPos == -1 )
563  {
564  if( bSubClassOnly )
565  return nScriptFlags;
566  nPos = 0;
567  }
568  else
569  {
570  nPos++;
571  nLen = nLen - nPos;
572  }
573 
574  switch( nLen )
575  {
576  case 3:
577  if( rClass.matchIgnoreAsciiCase( "cjk", nPos ) )
578  {
579  nScriptFlags = Css1ScriptFlags::CJK;
580  }
581  else if( rClass.matchIgnoreAsciiCase( "ctl", nPos ) )
582  {
583  nScriptFlags = Css1ScriptFlags::CTL;
584  }
585  break;
586  case 7:
587  if( rClass.matchIgnoreAsciiCase( "western", nPos ) )
588  {
589  nScriptFlags = Css1ScriptFlags::Western;
590  }
591  break;
592  }
593  if( Css1ScriptFlags::AllMask != nScriptFlags )
594  {
595  if( nPos )
596  {
597  rClass = rClass.copy( 0, nPos-1 );
598  }
599  else
600  {
601  rClass.clear();
602  }
603  }
604 
605  return nScriptFlags;
606 }
607 
608 static CSS1SelectorType GetTokenAndClass( const CSS1Selector *pSelector,
609  OUString& rToken, OUString& rClass,
610  Css1ScriptFlags& rScriptFlags )
611 {
612  rToken = pSelector->GetString();
613  rClass.clear();
614  rScriptFlags = Css1ScriptFlags::AllMask;
615 
616  CSS1SelectorType eType = pSelector->GetType();
617  if( CSS1_SELTYPE_ELEM_CLASS==eType )
618  {
619  sal_Int32 nPos = rToken.indexOf( '.' );
620  OSL_ENSURE( nPos >= 0, "No dot in Class-Selector???" );
621  if( nPos >= 0 )
622  {
623  rClass = rToken.copy( nPos+1 );
624  rToken = rToken.copy( 0, nPos );
625 
626  rScriptFlags = SwCSS1Parser::GetScriptFromClass( rClass, false );
627  if( rClass.isEmpty() )
628  eType = CSS1_SELTYPE_ELEMENT;
629  }
630  }
631 
632  rToken = rToken.toAsciiLowerCase();
633  return eType;
634 }
635 
636 static void RemoveScriptItems( SfxItemSet& rItemSet, Css1ScriptFlags nScript,
637  const SfxItemSet *pParentItemSet = nullptr )
638 {
639  static const sal_uInt16 aWhichIds[3][5] =
640  {
641  { RES_CHRATR_FONT, RES_CHRATR_FONTSIZE, RES_CHRATR_LANGUAGE,
642  RES_CHRATR_POSTURE, RES_CHRATR_WEIGHT },
643  { RES_CHRATR_CJK_FONT, RES_CHRATR_CJK_FONTSIZE, RES_CHRATR_CJK_LANGUAGE,
644  RES_CHRATR_CJK_POSTURE, RES_CHRATR_CJK_WEIGHT },
645  { RES_CHRATR_CTL_FONT, RES_CHRATR_CTL_FONTSIZE, RES_CHRATR_CTL_LANGUAGE,
646  RES_CHRATR_CTL_POSTURE, RES_CHRATR_CTL_WEIGHT }
647  };
648 
649  bool aClearItems[3] = { false, false, false };
650  switch( nScript )
651  {
652  case Css1ScriptFlags::Western:
653  aClearItems[1] = aClearItems[2] = true;
654  break;
655  case Css1ScriptFlags::CJK:
656  aClearItems[0] = aClearItems[2] = true;
657  break;
658  case Css1ScriptFlags::CTL:
659  aClearItems[0] = aClearItems[1] = true;
660  break;
661  case Css1ScriptFlags::AllMask:
662  break;
663  default:
664  OSL_ENSURE( aClearItems[0], "unknown script type" );
665  break;
666  }
667 
668  for( size_t j=0; j < SAL_N_ELEMENTS(aWhichIds); ++j )
669  {
670  for( size_t i=0; i < SAL_N_ELEMENTS(aWhichIds[0]); ++i )
671  {
672  sal_uInt16 nWhich = aWhichIds[j][i];
673  const SfxPoolItem *pItem;
674  if( aClearItems[j] ||
675  (pParentItemSet &&
676  SfxItemState::SET == rItemSet.GetItemState( nWhich, false, &pItem ) &&
677  (0==i ? swhtml_css1atr_equalFontItems( *pItem, pParentItemSet->Get(nWhich ) )
678  : *pItem == pParentItemSet->Get(nWhich ) ) ) )
679  {
680  rItemSet.ClearItem( nWhich );
681  }
682  }
683  }
684 }
685 
686 void SwCSS1Parser::StyleParsed( const CSS1Selector *pSelector,
687  SfxItemSet& rItemSet,
688  SvxCSS1PropertyInfo& rPropInfo )
689 {
690  if( !m_bIsNewDoc )
691  return;
692 
693  CSS1SelectorType eSelType = pSelector->GetType();
694  const CSS1Selector *pNext = pSelector->GetNext();
695 
696  if( CSS1_SELTYPE_ID==eSelType && !pNext )
697  {
698  InsertId( pSelector->GetString(), rItemSet, rPropInfo );
699  }
700  else if( CSS1_SELTYPE_CLASS==eSelType && !pNext )
701  {
702  OUString aClass( pSelector->GetString() );
703  Css1ScriptFlags nScript = GetScriptFromClass( aClass );
704  if( Css1ScriptFlags::AllMask != nScript )
705  {
706  SfxItemSet aScriptItemSet( rItemSet );
707  RemoveScriptItems( aScriptItemSet, nScript );
708  InsertClass( aClass, aScriptItemSet, rPropInfo );
709  }
710  else
711  {
712  InsertClass( aClass, rItemSet, rPropInfo );
713  }
714  }
715  else if( CSS1_SELTYPE_PAGE==eSelType )
716  {
717  if( !pNext ||
718  (CSS1_SELTYPE_PSEUDO == pNext->GetType() &&
719  (pNext->GetString().equalsIgnoreAsciiCase( "left" ) ||
720  pNext->GetString().equalsIgnoreAsciiCase( "right" ) ||
721  pNext->GetString().equalsIgnoreAsciiCase( "first" ) ) ) )
722  {
723  OUString aName;
724  if( pNext )
725  aName = pNext->GetString();
726  InsertPage( aName,
727  pNext != nullptr,
728  rItemSet, rPropInfo );
729  }
730  }
731 
732  if( CSS1_SELTYPE_ELEMENT != eSelType &&
733  CSS1_SELTYPE_ELEM_CLASS != eSelType)
734  return;
735 
736  // get token and class of selector
737  OUString aToken2;
738  OUString aClass;
739  Css1ScriptFlags nScript;
740  eSelType = GetTokenAndClass( pSelector, aToken2, aClass, nScript );
741  HtmlTokenId nToken2 = GetHTMLToken( aToken2 );
742 
743  // and also some information of the next element
744  CSS1SelectorType eNextType = pNext ? pNext->GetType()
745  : CSS1_SELTYPE_ELEMENT;
746 
747  // first some special cases
748  if( CSS1_SELTYPE_ELEMENT==eSelType )
749  {
750  switch( nToken2 )
751  {
752  case HtmlTokenId::ANCHOR_ON:
753  if( !pNext )
754  {
755  InsertTag( aToken2, rItemSet, rPropInfo );
756  return;
757  }
758  else if (CSS1_SELTYPE_PSEUDO == eNextType)
759  {
760  // maybe A:visited or A:link
761 
762  OUString aPseudo( pNext->GetString() );
763  aPseudo = aPseudo.toAsciiLowerCase();
764  bool bInsert = false;
765  switch( aPseudo[0] )
766  {
767  case 'l':
768  if( aPseudo == "link" )
769  {
770  bInsert = true;
771  }
772  break;
773  case 'v':
774  if( aPseudo == "visited" )
775  {
776  bInsert = true;
777  }
778  break;
779  }
780  if( bInsert )
781  {
782  OUString sTmp = aToken2 + ":" + aPseudo;
783  if( Css1ScriptFlags::AllMask != nScript )
784  {
785  SfxItemSet aScriptItemSet( rItemSet );
786  RemoveScriptItems( aScriptItemSet, nScript );
787  InsertTag( sTmp, aScriptItemSet, rPropInfo );
788  }
789  else
790  {
791  InsertTag( sTmp, rItemSet, rPropInfo );
792  }
793  return;
794  }
795  }
796  break;
797  case HtmlTokenId::BODY_ON:
798  if( !pNext )
799  {
800  // BODY
801 
802  // We must test the background before setting, because
803  // in SetPageDescAttrs it will be deleted.
804  const SfxPoolItem *pItem;
805  if( SfxItemState::SET==rItemSet.GetItemState(RES_BACKGROUND,false,&pItem) )
806  {
807  const SvxBrushItem *pBrushItem =
808  static_cast<const SvxBrushItem *>(pItem);
809 
811  if( pBrushItem->GetColor() != COL_TRANSPARENT )
812  m_bBodyBGColorSet = true;
813  if( GPOS_NONE != pBrushItem->GetGraphicPos() )
814  m_bBodyBackgroundSet = true;
815  }
816 
817  // Border and Padding
818  rPropInfo.SetBoxItem( rItemSet, MIN_BORDER_DIST );
819 
820  // Some attributes must be set at the style, the ones which
821  // aren't inherited
822  SetPageDescAttrs( nullptr, &rItemSet );
823 
824  // all remaining options can be set at the default style,
825  // then they're the default
826  if( SfxItemState::SET==rItemSet.GetItemState(RES_CHRATR_COLOR,false) )
827  m_bBodyTextSet = true;
828  SetTextCollAttrs(
829  GetTextCollFromPool( RES_POOLCOLL_STANDARD ),
830  rItemSet, rPropInfo, this );
831 
832  return;
833  }
834  break;
835  default: break;
836  }
837  }
838  else if( CSS1_SELTYPE_ELEM_CLASS==eSelType && HtmlTokenId::ANCHOR_ON==nToken2 &&
839  !pNext && aClass.getLength() >= 9 &&
840  ('s' == aClass[0] || 'S' == aClass[0]) )
841  {
842  sal_uInt16 nPoolFormatId = 0;
843  if( aClass.equalsIgnoreAsciiCase(OOO_STRING_SVTOOLS_HTML_sdendnote_sym) )
844  nPoolFormatId = RES_POOLCHR_ENDNOTE;
845  else if( aClass.equalsIgnoreAsciiCase(OOO_STRING_SVTOOLS_HTML_sdfootnote_sym) )
846  nPoolFormatId = RES_POOLCHR_FOOTNOTE;
847  if( nPoolFormatId )
848  {
849  if( Css1ScriptFlags::AllMask == nScript )
850  {
851  SetCharFormatAttrs( GetCharFormatFromPool(nPoolFormatId), rItemSet );
852  }
853  else
854  {
855  SfxItemSet aScriptItemSet( rItemSet );
856  RemoveScriptItems( aScriptItemSet, nScript );
857  SetCharFormatAttrs( GetCharFormatFromPool(nPoolFormatId),
858  aScriptItemSet);
859  }
860  return;
861  }
862  }
863 
864  // Now the selectors are processed which belong to a paragraph style
865  sal_uInt16 nPoolCollId = 0;
866  switch( nToken2 )
867  {
868  case HtmlTokenId::HEAD1_ON:
869  nPoolCollId = RES_POOLCOLL_HEADLINE1;
870  break;
871  case HtmlTokenId::HEAD2_ON:
872  nPoolCollId = RES_POOLCOLL_HEADLINE2;
873  break;
874  case HtmlTokenId::HEAD3_ON:
875  nPoolCollId = RES_POOLCOLL_HEADLINE3;
876  break;
877  case HtmlTokenId::HEAD4_ON:
878  nPoolCollId = RES_POOLCOLL_HEADLINE4;
879  break;
880  case HtmlTokenId::HEAD5_ON:
881  nPoolCollId = RES_POOLCOLL_HEADLINE5;
882  break;
883  case HtmlTokenId::HEAD6_ON:
884  nPoolCollId = RES_POOLCOLL_HEADLINE6;
885  break;
886  case HtmlTokenId::PARABREAK_ON:
887  if( aClass.getLength() >= 9 &&
888  ('s' == aClass[0] || 'S' == aClass[0]) )
889  {
890  if( aClass.equalsIgnoreAsciiCase(OOO_STRING_SVTOOLS_HTML_sdendnote) )
891  nPoolCollId = RES_POOLCOLL_ENDNOTE;
892  else if( aClass.equalsIgnoreAsciiCase(OOO_STRING_SVTOOLS_HTML_sdfootnote) )
893  nPoolCollId = RES_POOLCOLL_FOOTNOTE;
894 
895  if( nPoolCollId )
896  aClass.clear();
897  else
898  nPoolCollId = RES_POOLCOLL_TEXT;
899  }
900  else
901  {
902  nPoolCollId = RES_POOLCOLL_TEXT;
903  }
904  break;
905  case HtmlTokenId::ADDRESS_ON:
906  nPoolCollId = RES_POOLCOLL_SENDADRESS;
907  break;
908  case HtmlTokenId::BLOCKQUOTE_ON:
909  nPoolCollId = RES_POOLCOLL_HTML_BLOCKQUOTE;
910  break;
911  case HtmlTokenId::DT_ON:
912  nPoolCollId = RES_POOLCOLL_HTML_DT;
913  break;
914  case HtmlTokenId::DD_ON:
915  nPoolCollId = RES_POOLCOLL_HTML_DD;
916  break;
917  case HtmlTokenId::PREFORMTXT_ON:
918  nPoolCollId = RES_POOLCOLL_HTML_PRE;
919  break;
920  case HtmlTokenId::TABLEHEADER_ON:
921  case HtmlTokenId::TABLEDATA_ON:
922  if( CSS1_SELTYPE_ELEMENT==eSelType && !pNext )
923  {
924  InsertTag( aToken2, rItemSet, rPropInfo );
925  return;
926  }
927  else if( CSS1_SELTYPE_ELEMENT==eSelType && pNext &&
928  (CSS1_SELTYPE_ELEMENT==eNextType ||
929  CSS1_SELTYPE_ELEM_CLASS==eNextType) )
930  {
931  // not TH and TD, but TH P and TD P
932  OUString aSubToken, aSubClass;
933  GetTokenAndClass( pNext, aSubToken, aSubClass, nScript );
934  if( HtmlTokenId::PARABREAK_ON == GetHTMLToken( aSubToken ) )
935  {
936  aClass = aSubClass;
937  pNext = pNext->GetNext();
938  eNextType = pNext ? pNext->GetType() : CSS1_SELTYPE_ELEMENT;
939 
940  if( !aClass.isEmpty() || pNext )
941  {
942  nPoolCollId = static_cast< sal_uInt16 >(
943  HtmlTokenId::TABLEHEADER_ON == nToken2 ? RES_POOLCOLL_TABLE_HDLN
944  : RES_POOLCOLL_TABLE );
945  }
946  else
947  {
948  OUString sTmp = aToken2 + " " OOO_STRING_SVTOOLS_HTML_parabreak;
949 
950  if( Css1ScriptFlags::AllMask == nScript )
951  {
952  InsertTag( sTmp, rItemSet, rPropInfo );
953  }
954  else
955  {
956  SfxItemSet aScriptItemSet( rItemSet );
957  RemoveScriptItems( aScriptItemSet, nScript );
958  InsertTag( sTmp, aScriptItemSet, rPropInfo );
959  }
960 
961  return;
962  }
963  }
964  }
965  break;
966 
967  default:
968  ;
969  }
970 
971  if( nPoolCollId )
972  {
973  if( !pNext ||
974  (CSS1_SELTYPE_PSEUDO==eNextType &&
975  pNext->GetString().equalsIgnoreAsciiCase( "first-letter" ) &&
976  SvxAdjust::Left == rPropInfo.m_eFloat) )
977  {
978  // either not a composed selector or a X:first-line { float: left; ... }
979 
980  // search resp. create the style
981  SwTextFormatColl* pColl = GetTextFormatColl(nPoolCollId, OUString());
982  SwTextFormatColl* pParentColl = nullptr;
983  if( !aClass.isEmpty() )
984  {
985  OUString aName( pColl->GetName() );
986  AddClassName( aName, aClass );
987 
988  pParentColl = pColl;
989  pColl = m_pDoc->FindTextFormatCollByName( aName );
990  if( !pColl )
991  pColl = m_pDoc->MakeTextFormatColl( aName, pParentColl );
992  }
993  if( !pNext )
994  {
995  // set only the attributes at the style
996  const SfxPoolItem *pItem;
997  const SvxBoxItem *pBoxItem = nullptr;
998  if( SfxItemState::SET ==
999  pColl->GetAttrSet().GetItemState(RES_BOX,true,&pItem) )
1000  pBoxItem = static_cast<const SvxBoxItem *>(pItem);
1001  rPropInfo.SetBoxItem( rItemSet, MIN_BORDER_DIST, pBoxItem );
1002  if( Css1ScriptFlags::AllMask == nScript && !pParentColl )
1003  {
1004  SetTextCollAttrs( pColl, rItemSet, rPropInfo, this );
1005  }
1006  else
1007  {
1008  SfxItemSet aScriptItemSet( rItemSet );
1009  RemoveScriptItems( aScriptItemSet, nScript,
1010  pParentColl ? &pParentColl->GetAttrSet() : nullptr );
1011  SetTextCollAttrs( pColl, aScriptItemSet, rPropInfo, this );
1012  }
1013  }
1014  else
1015  {
1016  // create a DropCap attribute
1017  SwFormatDrop aDrop( pColl->GetDrop() );
1018  aDrop.GetChars() = 1;
1019 
1020  // set the attributes of the DropCap attribute
1021  if( Css1ScriptFlags::AllMask == nScript )
1022  {
1023  OUString sName(pColl->GetName());
1024  FillDropCap( aDrop, rItemSet, &sName );
1025  }
1026  else
1027  {
1028  SfxItemSet aScriptItemSet( rItemSet );
1029  if( Css1ScriptFlags::Western != nScript )
1030  {
1031  aScriptItemSet.ClearItem( RES_CHRATR_FONT );
1032  aScriptItemSet.ClearItem( RES_CHRATR_LANGUAGE );
1033  aScriptItemSet.ClearItem( RES_CHRATR_POSTURE );
1034  aScriptItemSet.ClearItem( RES_CHRATR_WEIGHT );
1035  }
1036  if( Css1ScriptFlags::CJK != nScript )
1037  {
1038  aScriptItemSet.ClearItem( RES_CHRATR_CJK_FONT );
1039  aScriptItemSet.ClearItem( RES_CHRATR_CJK_LANGUAGE );
1040  aScriptItemSet.ClearItem( RES_CHRATR_CJK_POSTURE );
1041  aScriptItemSet.ClearItem( RES_CHRATR_CJK_WEIGHT );
1042  }
1043  if( Css1ScriptFlags::CTL != nScript )
1044  {
1045  aScriptItemSet.ClearItem( RES_CHRATR_CTL_FONT );
1046  aScriptItemSet.ClearItem( RES_CHRATR_CTL_LANGUAGE );
1047  aScriptItemSet.ClearItem( RES_CHRATR_CTL_POSTURE );
1048  aScriptItemSet.ClearItem( RES_CHRATR_CTL_WEIGHT );
1049  }
1050  OUString sName(pColl->GetName());
1051  FillDropCap( aDrop, aScriptItemSet, &sName );
1052  }
1053 
1054  // Only set the attribute if "float: left" is specified and
1055  // the Initial is over several lines. Otherwise the maybe
1056  // created character style will be later searched and set
1057  // via name.
1058  if( aDrop.GetLines() > 1 &&
1059  (SvxAdjust::Left == rPropInfo.m_eFloat ||
1060  Css1ScriptFlags::AllMask == nScript) )
1061  {
1062  pColl->SetFormatAttr( aDrop );
1063  }
1064  }
1065  }
1066 
1067  return;
1068  }
1069 
1070  // Now the selectors are processed which are belonging to the character
1071  // template. There are no composed ones here.
1072  if( pNext )
1073  return;
1074 
1075  SwCharFormat* pCFormat = GetChrFormat(nToken2, OUString());
1076  if( pCFormat )
1077  {
1078  SwCharFormat *pParentCFormat = nullptr;
1079  if( !aClass.isEmpty() )
1080  {
1081  OUString aName( pCFormat->GetName() );
1082  AddClassName( aName, aClass );
1083  pParentCFormat = pCFormat;
1084 
1085  pCFormat = m_pDoc->FindCharFormatByName( aName );
1086  if( !pCFormat )
1087  {
1088  pCFormat = m_pDoc->MakeCharFormat( aName, pParentCFormat );
1089  pCFormat->SetAuto(false);
1090  }
1091  }
1092 
1093  if( Css1ScriptFlags::AllMask == nScript && !pParentCFormat )
1094  {
1095  SetCharFormatAttrs( pCFormat, rItemSet );
1096  }
1097  else
1098  {
1099  SfxItemSet aScriptItemSet( rItemSet );
1100  RemoveScriptItems( aScriptItemSet, nScript,
1101  pParentCFormat ? &pParentCFormat->GetAttrSet() : nullptr );
1102  SetCharFormatAttrs( pCFormat, aScriptItemSet );
1103  }
1104  }
1105 }
1106 
1107 sal_uInt32 SwCSS1Parser::GetFontHeight( sal_uInt16 nSize ) const
1108 {
1109  return m_aFontHeights[ std::min<sal_uInt16>(nSize,6) ];
1110 }
1111 
1112 const FontList *SwCSS1Parser::GetFontList() const
1113 {
1114  const FontList *pFList = nullptr;
1115  SwDocShell *pDocSh = m_pDoc->GetDocShell();
1116  if( pDocSh )
1117  {
1118  const SvxFontListItem *pFListItem =
1119  static_cast<const SvxFontListItem *>(pDocSh->GetItem(SID_ATTR_CHAR_FONTLIST));
1120  if( pFListItem )
1121  pFList = pFListItem->GetFontList();
1122  }
1123 
1124  return pFList;
1125 }
1126 
1127 SwCharFormat* SwCSS1Parser::GetChrFormat( HtmlTokenId nToken2, const OUString& rClass ) const
1128 {
1129  // search the corresponding style
1130  sal_uInt16 nPoolId = 0;
1131  const sal_Char* sName = nullptr;
1132  switch( nToken2 )
1133  {
1134  case HtmlTokenId::EMPHASIS_ON: nPoolId = RES_POOLCHR_HTML_EMPHASIS; break;
1135  case HtmlTokenId::CITIATION_ON: nPoolId = RES_POOLCHR_HTML_CITIATION; break;
1136  case HtmlTokenId::STRONG_ON: nPoolId = RES_POOLCHR_HTML_STRONG; break;
1137  case HtmlTokenId::CODE_ON: nPoolId = RES_POOLCHR_HTML_CODE; break;
1138  case HtmlTokenId::SAMPLE_ON: nPoolId = RES_POOLCHR_HTML_SAMPLE; break;
1139  case HtmlTokenId::KEYBOARD_ON: nPoolId = RES_POOLCHR_HTML_KEYBOARD; break;
1140  case HtmlTokenId::VARIABLE_ON: nPoolId = RES_POOLCHR_HTML_VARIABLE; break;
1141  case HtmlTokenId::DEFINSTANCE_ON: nPoolId = RES_POOLCHR_HTML_DEFINSTANCE; break;
1142  case HtmlTokenId::TELETYPE_ON: nPoolId = RES_POOLCHR_HTML_TELETYPE; break;
1143 
1144  case HtmlTokenId::SHORTQUOTE_ON: sName = OOO_STRING_SVTOOLS_HTML_shortquote; break;
1145  case HtmlTokenId::LANGUAGE_ON: sName = OOO_STRING_SVTOOLS_HTML_language; break;
1146  case HtmlTokenId::AUTHOR_ON: sName = OOO_STRING_SVTOOLS_HTML_author; break;
1147  case HtmlTokenId::PERSON_ON: sName = OOO_STRING_SVTOOLS_HTML_person; break;
1148  case HtmlTokenId::ACRONYM_ON: sName = OOO_STRING_SVTOOLS_HTML_acronym; break;
1149  case HtmlTokenId::ABBREVIATION_ON: sName = OOO_STRING_SVTOOLS_HTML_abbreviation; break;
1150  case HtmlTokenId::INSERTEDTEXT_ON: sName = OOO_STRING_SVTOOLS_HTML_insertedtext; break;
1151  case HtmlTokenId::DELETEDTEXT_ON: sName = OOO_STRING_SVTOOLS_HTML_deletedtext; break;
1152  default: break;
1153  }
1154 
1155  // search or create the style (only possible with name)
1156  if( !nPoolId && !sName )
1157  return nullptr;
1158 
1159  // search or create style (without class)
1160  SwCharFormat *pCFormat = nullptr;
1161  if( nPoolId )
1162  {
1163  pCFormat = GetCharFormatFromPool( nPoolId );
1164  }
1165  else
1166  {
1167  OUString sCName( OUString::createFromAscii(sName) );
1168  pCFormat = m_pDoc->FindCharFormatByName( sCName );
1169  if( !pCFormat )
1170  {
1171  pCFormat = m_pDoc->MakeCharFormat( sCName, m_pDoc->GetDfltCharFormat() );
1172  pCFormat->SetAuto(false);
1173  }
1174  }
1175 
1176  OSL_ENSURE( pCFormat, "No character style???" );
1177 
1178  // If a class exists, then search for the class style but don't
1179  // create one.
1180  OUString aClass( rClass );
1181  GetScriptFromClass( aClass, false );
1182  if( !aClass.isEmpty() )
1183  {
1184  OUString aTmp( pCFormat->GetName() );
1185  AddClassName( aTmp, aClass );
1186  SwCharFormat *pClassCFormat = m_pDoc->FindCharFormatByName( aTmp );
1187  if( pClassCFormat )
1188  {
1189  pCFormat = pClassCFormat;
1190  }
1191  else
1192  {
1193  const SvxCSS1MapEntry *pClass = GetClass( aClass );
1194  if( pClass )
1195  {
1196  pCFormat = m_pDoc->MakeCharFormat( aTmp, pCFormat );
1197  pCFormat->SetAuto(false);
1198  SfxItemSet aItemSet( pClass->GetItemSet() );
1199  SetCharFormatAttrs( pCFormat, aItemSet );
1200  }
1201  }
1202  }
1203 
1204  return pCFormat;
1205 }
1206 
1207 SwTextFormatColl *SwCSS1Parser::GetTextCollFromPool( sal_uInt16 nPoolId ) const
1208 {
1209  const SwTextFormatColls::size_type nOldArrLen = m_pDoc->GetTextFormatColls()->size();
1210 
1211  SwTextFormatColl *pColl = m_pDoc->getIDocumentStylePoolAccess().GetTextCollFromPool( nPoolId, false );
1212 
1213  if( m_bIsNewDoc )
1214  {
1215  const SwTextFormatColls::size_type nArrLen = m_pDoc->GetTextFormatColls()->size();
1216  for( SwTextFormatColls::size_type i=nOldArrLen; i<nArrLen; ++i )
1217  lcl_swcss1_setEncoding( *(*m_pDoc->GetTextFormatColls())[i],
1218  GetDfltEncoding() );
1219  }
1220 
1221  return pColl;
1222 }
1223 
1224 SwCharFormat *SwCSS1Parser::GetCharFormatFromPool( sal_uInt16 nPoolId ) const
1225 {
1226  const SwCharFormats::size_type nOldArrLen = m_pDoc->GetCharFormats()->size();
1227 
1228  SwCharFormat *pCharFormat = m_pDoc->getIDocumentStylePoolAccess().GetCharFormatFromPool( nPoolId );
1229 
1230  if( m_bIsNewDoc )
1231  {
1232  const SwCharFormats::size_type nArrLen = m_pDoc->GetCharFormats()->size();
1233 
1234  for( SwCharFormats::size_type i=nOldArrLen; i<nArrLen; i++ )
1235  lcl_swcss1_setEncoding( *(*m_pDoc->GetCharFormats())[i],
1236  GetDfltEncoding() );
1237  }
1238 
1239  return pCharFormat;
1240 }
1241 
1242 SwTextFormatColl *SwCSS1Parser::GetTextFormatColl( sal_uInt16 nTextColl,
1243  const OUString& rClass )
1244 {
1245  SwTextFormatColl* pColl = nullptr;
1246 
1247  OUString aClass( rClass );
1248  GetScriptFromClass( aClass, false );
1249  if( RES_POOLCOLL_TEXT == nTextColl && aClass.getLength() >= 9 &&
1250  ('s' == aClass[0] || 'S' == aClass[0] ) )
1251  {
1252  if( aClass.equalsIgnoreAsciiCase(OOO_STRING_SVTOOLS_HTML_sdendnote) )
1253  {
1254  nTextColl = RES_POOLCOLL_ENDNOTE;
1255  aClass.clear();
1256  }
1257  else if( aClass.equalsIgnoreAsciiCase(OOO_STRING_SVTOOLS_HTML_sdfootnote) )
1258  {
1259  nTextColl = RES_POOLCOLL_FOOTNOTE;
1260  aClass.clear();
1261  }
1262  }
1263 
1264  if( USER_FMT & nTextColl ) // one created by Reader
1265  {
1266  OSL_ENSURE( false, "Where does the user style comes from?" );
1267  pColl = GetTextCollFromPool( RES_POOLCOLL_STANDARD );
1268  }
1269  else
1270  {
1271  pColl = GetTextCollFromPool( nTextColl );
1272  }
1273 
1274  OSL_ENSURE( pColl, "No paragraph style???" );
1275  if( !aClass.isEmpty() )
1276  {
1277  OUString aTmp( pColl->GetName() );
1278  AddClassName( aTmp, aClass );
1279  SwTextFormatColl* pClassColl = m_pDoc->FindTextFormatCollByName( aTmp );
1280 
1281  if( !pClassColl &&
1282  (nTextColl==RES_POOLCOLL_TABLE ||
1283  nTextColl==RES_POOLCOLL_TABLE_HDLN) )
1284  {
1285  // In this case there was a <TD><P CLASS=foo>, but no TD.foo
1286  // style was found. The we must use P.foo, if available.
1287  SwTextFormatColl* pCollText =
1288  GetTextCollFromPool( RES_POOLCOLL_TEXT );
1289  aTmp = pCollText->GetName();
1290  AddClassName( aTmp, aClass );
1291  pClassColl = m_pDoc->FindTextFormatCollByName( aTmp );
1292  }
1293 
1294  if( pClassColl )
1295  {
1296  pColl = pClassColl;
1297  }
1298  else
1299  {
1300  const SvxCSS1MapEntry *pClass = GetClass( aClass );
1301  if( pClass )
1302  {
1303  pColl = m_pDoc->MakeTextFormatColl( aTmp, pColl );
1304  SfxItemSet aItemSet( pClass->GetItemSet() );
1305  SvxCSS1PropertyInfo aPropInfo( pClass->GetPropertyInfo() );
1306  aPropInfo.SetBoxItem( aItemSet, MIN_BORDER_DIST );
1307  bool bPositioned = MayBePositioned( pClass->GetPropertyInfo() );
1308  if( bPositioned )
1309  aItemSet.ClearItem( RES_BACKGROUND );
1310  SetTextCollAttrs( pColl, aItemSet, aPropInfo,
1311  this );
1312  }
1313  }
1314 
1315  }
1316 
1317  if( pColl )
1318  lcl_swcss1_setEncoding( *pColl, GetDfltEncoding() );
1319 
1320  return pColl;
1321 }
1322 
1323 SwPageDesc *SwCSS1Parser::GetMasterPageDesc()
1324 {
1325  return m_pDoc->getIDocumentStylePoolAccess().GetPageDescFromPool( RES_POOLPAGE_HTML, false );
1326 }
1327 
1328 static SwPageDesc *FindPageDesc(SwDoc *pDoc, sal_uInt16 nPoolId)
1329 {
1330  size_t nPageDescs = pDoc->GetPageDescCnt();
1331  size_t nPage;
1332  for (nPage=0; nPage < nPageDescs &&
1333  pDoc->GetPageDesc(nPage).GetPoolFormatId() != nPoolId; ++nPage)
1334  ;
1335 
1336  return nPage < nPageDescs ? &pDoc->GetPageDesc(nPage) : nullptr;
1337 }
1338 
1339 const SwPageDesc *SwCSS1Parser::GetPageDesc( sal_uInt16 nPoolId, bool bCreate )
1340 {
1341  if( RES_POOLPAGE_HTML == nPoolId )
1342  return m_pDoc->getIDocumentStylePoolAccess().GetPageDescFromPool( RES_POOLPAGE_HTML, false );
1343 
1344  const SwPageDesc *pPageDesc = FindPageDesc(m_pDoc, nPoolId);
1345  if( !pPageDesc && bCreate )
1346  {
1347  // The first page is created from the right page, if there is one.
1348  SwPageDesc *pMasterPageDesc = nullptr;
1349  if( RES_POOLPAGE_FIRST == nPoolId )
1350  pMasterPageDesc = FindPageDesc(m_pDoc, RES_POOLPAGE_RIGHT);
1351  if( !pMasterPageDesc )
1352  pMasterPageDesc = m_pDoc->getIDocumentStylePoolAccess().GetPageDescFromPool( RES_POOLPAGE_HTML, false );
1353 
1354  // The new page style is created by copying from master
1355  SwPageDesc *pNewPageDesc = m_pDoc->
1356  getIDocumentStylePoolAccess().GetPageDescFromPool( nPoolId, false );
1357 
1358  // therefore we also need the number of the new style
1359  OSL_ENSURE(pNewPageDesc == FindPageDesc(m_pDoc, nPoolId), "page style not found");
1360 
1361  m_pDoc->CopyPageDesc( *pMasterPageDesc, *pNewPageDesc, false );
1362 
1363  // Modify the styles for their new purpose.
1364  const SwPageDesc *pFollow = nullptr;
1365  bool bSetFollowFollow = false;
1366  switch( nPoolId )
1367  {
1368  case RES_POOLPAGE_FIRST:
1369  // If there is already a left page, then is it the follow-up
1370  // style, else it is the HTML style.
1371  pFollow = GetLeftPageDesc();
1372  if( !pFollow )
1373  pFollow = pMasterPageDesc;
1374  break;
1375 
1376  case RES_POOLPAGE_RIGHT:
1377  // If the left style is already created, nothing will happen here.
1378  // Otherwise the left style is created and ensures the link with
1379  // the right style.
1380  GetLeftPageDesc( true );
1381  break;
1382 
1383  case RES_POOLPAGE_LEFT:
1384  // The right style is created if none exists. No links are created.
1385  // If there is already a first page style, then the left style becomes
1386  // follow-up style of the first page.
1387  pFollow = GetRightPageDesc( true );
1388  bSetFollowFollow = true;
1389  {
1390  const SwPageDesc *pFirstPageDesc = GetFirstPageDesc();
1391  if( pFirstPageDesc )
1392  {
1393  SwPageDesc aNewFirstPageDesc( *pFirstPageDesc );
1394  aNewFirstPageDesc.SetFollow( pNewPageDesc );
1395  ChgPageDesc( pFirstPageDesc, aNewFirstPageDesc );
1396  }
1397  }
1398  break;
1399  }
1400 
1401  if( pFollow )
1402  {
1403  SwPageDesc aNewPageDesc( *pNewPageDesc );
1404  aNewPageDesc.SetFollow( pFollow );
1405  ChgPageDesc( pNewPageDesc, aNewPageDesc );
1406 
1407  if( bSetFollowFollow )
1408  {
1409  SwPageDesc aNewFollowPageDesc( *pFollow );
1410  aNewFollowPageDesc.SetFollow( pNewPageDesc );
1411  ChgPageDesc( pFollow, aNewFollowPageDesc );
1412  }
1413  }
1414  pPageDesc = pNewPageDesc;
1415  }
1416 
1417  return pPageDesc;
1418 }
1419 
1420 bool SwCSS1Parser::MayBePositioned( const SvxCSS1PropertyInfo& rPropInfo,
1421  bool bAutoWidth )
1422 {
1423  // abs-pos
1424  // left/top none auto twip perc
1425 
1426  // none Z Z - -
1427  // auto Z Z - -
1428  // twip Z Z S/R -
1429  // perc - - - -
1430 
1431  // - the tag will be positioned absolutely and left/top are both
1432  // present and don't contain a percentage value, or
1433  // - the tag should flow, and
1434  // - a width was specified (needed in both cases)
1435  return ( ( SVX_CSS1_POS_ABSOLUTE == rPropInfo.m_ePosition &&
1436  SVX_CSS1_LTYPE_PERCENTAGE != rPropInfo.m_eLeftType &&
1437  SVX_CSS1_LTYPE_PERCENTAGE != rPropInfo.m_eTopType &&
1438  (SVX_CSS1_LTYPE_TWIP == rPropInfo.m_eLeftType ||
1439  SVX_CSS1_LTYPE_TWIP != rPropInfo.m_eTopType) ) ||
1440  ( SvxAdjust::End != rPropInfo.m_eFloat ) ) &&
1441  ( bAutoWidth ||
1442  SVX_CSS1_LTYPE_TWIP == rPropInfo.m_eWidthType ||
1443  SVX_CSS1_LTYPE_PERCENTAGE == rPropInfo.m_eWidthType );
1444 }
1445 
1446 void SwCSS1Parser::AddClassName( OUString& rFormatName, const OUString& rClass )
1447 {
1448  OSL_ENSURE( !rClass.isEmpty(), "Style class without length?" );
1449 
1450  rFormatName += "." + rClass;
1451 }
1452 
1453 void SwCSS1Parser::FillDropCap( SwFormatDrop& rDrop,
1454  SfxItemSet& rItemSet,
1455  const OUString *pName )
1456 {
1457  // the number of lines matches somehow a percentage value
1458  // for the height (what happens with absolute heights???)
1459  sal_uInt8 nLines = rDrop.GetLines();
1460  const SfxPoolItem *pItem;
1461  if( SfxItemState::SET == rItemSet.GetItemState( RES_CHRATR_FONTSIZE, false, &pItem ) )
1462  {
1463  sal_uInt16 nProp = static_cast<const SvxFontHeightItem *>(pItem)->GetProp();
1464  nLines = static_cast<sal_uInt8>((nProp + 50) / 100);
1465  if( nLines < 1 )
1466  nLines = 1;
1467  else if( nLines > MAX_DROPCAP_LINES )
1468  nLines = MAX_DROPCAP_LINES;
1469 
1470  // Only when nLines>1, then the attribute also is set. Then
1471  // we don't need the font height in the character style.
1472  if( nLines > 1 )
1473  {
1474  rItemSet.ClearItem( RES_CHRATR_FONTSIZE );
1475  rItemSet.ClearItem( RES_CHRATR_CJK_FONTSIZE );
1476  rItemSet.ClearItem( RES_CHRATR_CTL_FONTSIZE );
1477  }
1478  }
1479 
1480  // In case of hard attribution (pName==0) we can stop, if the Initial is
1481  // only one line.
1482  if( nLines<=1 )
1483  return;
1484 
1485  rDrop.GetLines() = nLines;
1486 
1487  // a right border becomes the spacing to text!
1488  if( SfxItemState::SET == rItemSet.GetItemState( RES_LR_SPACE, false, &pItem ) )
1489  {
1490  rDrop.GetDistance() = static_cast< sal_uInt16 >(
1491  static_cast<const SvxLRSpaceItem *>(pItem)->GetRight() );
1492  rItemSet.ClearItem( RES_LR_SPACE );
1493  }
1494 
1495  // for every other attribute create a character style
1496  if( rItemSet.Count() )
1497  {
1498  SwCharFormat *pCFormat = nullptr;
1499  OUString aName;
1500  if( pName )
1501  {
1502  aName = *pName;
1503  aName += ".FL"; // first letter
1504  pCFormat = m_pDoc->FindCharFormatByName( aName );
1505  }
1506  else
1507  {
1508  do
1509  {
1510  aName = "first-letter " + OUString::number( static_cast<sal_Int32>(++m_nDropCapCnt) );
1511  }
1512  while( m_pDoc->FindCharFormatByName(aName) );
1513  }
1514 
1515  if( !pCFormat )
1516  {
1517  pCFormat = m_pDoc->MakeCharFormat( aName, m_pDoc->GetDfltCharFormat() );
1518  pCFormat->SetAuto(false);
1519  }
1520  SetCharFormatAttrs( pCFormat, rItemSet );
1521 
1522  // The character style needs only be set in the attribute, when
1523  // the attribute also is set.
1524  if( nLines > 1 )
1525  rDrop.SetCharFormat( pCFormat );
1526  }
1527 }
1528 
1529 // specific CSS1 of SwHTMLParsers
1530 
1531 HTMLAttr **SwHTMLParser::GetAttrTabEntry( sal_uInt16 nWhich )
1532 {
1533  // find the table entry of the item ...
1534  HTMLAttr **ppAttr = nullptr;
1535  switch( nWhich )
1536  {
1537  case RES_CHRATR_BLINK:
1538  ppAttr = &m_xAttrTab->pBlink;
1539  break;
1540  case RES_CHRATR_CASEMAP:
1541  ppAttr = &m_xAttrTab->pCaseMap;
1542  break;
1543  case RES_CHRATR_COLOR:
1544  ppAttr = &m_xAttrTab->pFontColor;
1545  break;
1546  case RES_CHRATR_CROSSEDOUT:
1547  ppAttr = &m_xAttrTab->pStrike;
1548  break;
1549  case RES_CHRATR_ESCAPEMENT:
1550  ppAttr = &m_xAttrTab->pEscapement;
1551  break;
1552  case RES_CHRATR_FONT:
1553  ppAttr = &m_xAttrTab->pFont;
1554  break;
1555  case RES_CHRATR_CJK_FONT:
1556  ppAttr = &m_xAttrTab->pFontCJK;
1557  break;
1558  case RES_CHRATR_CTL_FONT:
1559  ppAttr = &m_xAttrTab->pFontCTL;
1560  break;
1561  case RES_CHRATR_FONTSIZE:
1562  ppAttr = &m_xAttrTab->pFontHeight;
1563  break;
1564  case RES_CHRATR_CJK_FONTSIZE:
1565  ppAttr = &m_xAttrTab->pFontHeightCJK;
1566  break;
1567  case RES_CHRATR_CTL_FONTSIZE:
1568  ppAttr = &m_xAttrTab->pFontHeightCTL;
1569  break;
1570  case RES_CHRATR_KERNING:
1571  ppAttr = &m_xAttrTab->pKerning;
1572  break;
1573  case RES_CHRATR_POSTURE:
1574  ppAttr = &m_xAttrTab->pItalic;
1575  break;
1576  case RES_CHRATR_CJK_POSTURE:
1577  ppAttr = &m_xAttrTab->pItalicCJK;
1578  break;
1579  case RES_CHRATR_CTL_POSTURE:
1580  ppAttr = &m_xAttrTab->pItalicCTL;
1581  break;
1582  case RES_CHRATR_UNDERLINE:
1583  ppAttr = &m_xAttrTab->pUnderline;
1584  break;
1585  case RES_CHRATR_WEIGHT:
1586  ppAttr = &m_xAttrTab->pBold;
1587  break;
1588  case RES_CHRATR_CJK_WEIGHT:
1589  ppAttr = &m_xAttrTab->pBoldCJK;
1590  break;
1591  case RES_CHRATR_CTL_WEIGHT:
1592  ppAttr = &m_xAttrTab->pBoldCTL;
1593  break;
1594  case RES_CHRATR_BACKGROUND:
1595  ppAttr = &m_xAttrTab->pCharBrush;
1596  break;
1597  case RES_CHRATR_BOX:
1598  ppAttr = &m_xAttrTab->pCharBox;
1599  break;
1600 
1601  case RES_PARATR_LINESPACING:
1602  ppAttr = &m_xAttrTab->pLineSpacing;
1603  break;
1604  case RES_PARATR_ADJUST:
1605  ppAttr = &m_xAttrTab->pAdjust;
1606  break;
1607 
1608  case RES_LR_SPACE:
1609  ppAttr = &m_xAttrTab->pLRSpace;
1610  break;
1611  case RES_UL_SPACE:
1612  ppAttr = &m_xAttrTab->pULSpace;
1613  break;
1614  case RES_BOX:
1615  ppAttr = &m_xAttrTab->pBox;
1616  break;
1617  case RES_BACKGROUND:
1618  ppAttr = &m_xAttrTab->pBrush;
1619  break;
1620  case RES_BREAK:
1621  ppAttr = &m_xAttrTab->pBreak;
1622  break;
1623  case RES_PAGEDESC:
1624  ppAttr = &m_xAttrTab->pPageDesc;
1625  break;
1626  case RES_PARATR_SPLIT:
1627  ppAttr = &m_xAttrTab->pSplit;
1628  break;
1629  case RES_PARATR_WIDOWS:
1630  ppAttr = &m_xAttrTab->pWidows;
1631  break;
1632  case RES_PARATR_ORPHANS:
1633  ppAttr = &m_xAttrTab->pOrphans;
1634  break;
1635  case RES_KEEP:
1636  ppAttr = &m_xAttrTab->pKeep;
1637  break;
1638 
1639  case RES_CHRATR_LANGUAGE:
1640  ppAttr = &m_xAttrTab->pLanguage;
1641  break;
1642  case RES_CHRATR_CJK_LANGUAGE:
1643  ppAttr = &m_xAttrTab->pLanguageCJK;
1644  break;
1645  case RES_CHRATR_CTL_LANGUAGE:
1646  ppAttr = &m_xAttrTab->pLanguageCTL;
1647  break;
1648 
1649  case RES_FRAMEDIR:
1650  ppAttr = &m_xAttrTab->pDirection;
1651  break;
1652  }
1653 
1654  return ppAttr;
1655 }
1656 
1657 void SwHTMLParser::NewStyle()
1658 {
1659  OUString sType;
1660 
1661  const HTMLOptions& rOptions2 = GetOptions();
1662  for (size_t i = rOptions2.size(); i; )
1663  {
1664  const HTMLOption& rOption = rOptions2[--i];
1665  if( HtmlOptionId::TYPE == rOption.GetToken() )
1666  sType = rOption.GetString();
1667  }
1668 
1669  m_bIgnoreRawData = sType.getLength() &&
1670  !sType.getToken(0,';').equalsAscii(sCSS_mimetype);
1671 }
1672 
1673 void SwHTMLParser::EndStyle()
1674 {
1675  m_bIgnoreRawData = false;
1676 
1677  if( !m_aStyleSource.isEmpty() )
1678  {
1679  m_pCSS1Parser->ParseStyleSheet( m_aStyleSource );
1680  m_aStyleSource.clear();
1681  }
1682 }
1683 
1684 bool SwHTMLParser::FileDownload( const OUString& rURL,
1685  OUString& rStr )
1686 {
1687  // depose view (because of reschedule)
1688  SwViewShell *pOldVSh = CallEndAction();
1689 
1690  SfxMedium aDLMedium( rURL, StreamMode::READ | StreamMode::SHARE_DENYWRITE );
1691 
1692  SvStream* pStream = aDLMedium.GetInStream();
1693  if( pStream )
1694  {
1695  SvMemoryStream aStream;
1696  aStream.WriteStream( *pStream );
1697 
1698  rStr = OUString(static_cast<const sal_Char *>(aStream.GetData()), aStream.TellEnd(),
1699  GetSrcEncoding());
1700  }
1701 
1702  // was aborted?
1703  if( ( m_xDoc->GetDocShell() && m_xDoc->GetDocShell()->IsAbortingImport() )
1704  || 1 == m_xDoc->getReferenceCount() )
1705  {
1706  // was the import aborted from SFX?
1707  eState = SvParserState::Error;
1708  pStream = nullptr;
1709  }
1710 
1711  // recreate View
1712  SwViewShell *const pVSh = CallStartAction( pOldVSh );
1713  OSL_ENSURE( pOldVSh == pVSh, "FileDownload: SwViewShell changed on us" );
1714 
1715  return pStream!=nullptr;
1716 }
1717 
1718 void SwHTMLParser::InsertLink()
1719 {
1720  bool bFinishDownload = false;
1721  if( !m_vPendingStack.empty() )
1722  {
1723  OSL_ENSURE( ShouldFinishFileDownload(),
1724  "Pending-Stack without File-Download?" );
1725 
1726  m_vPendingStack.pop_back();
1727  assert( m_vPendingStack.empty() && "Where does the Pending-Stack come from?" );
1728 
1729  bFinishDownload = true;
1730  }
1731  else
1732  {
1733  OUString sRel, sHRef, sType;
1734 
1735  const HTMLOptions& rOptions2 = GetOptions();
1736  for (size_t i = rOptions2.size(); i; )
1737  {
1738  const HTMLOption& rOption = rOptions2[--i];
1739  switch( rOption.GetToken() )
1740  {
1741  case HtmlOptionId::REL:
1742  sRel = rOption.GetString();
1743  break;
1744  case HtmlOptionId::HREF:
1745  sHRef = URIHelper::SmartRel2Abs( INetURLObject( m_sBaseURL ), rOption.GetString(), Link<OUString *, bool>(), false );
1746  break;
1747  case HtmlOptionId::TYPE:
1748  sType = rOption.GetString();
1749  break;
1750  default: break;
1751  }
1752  }
1753 
1754  if( !sHRef.isEmpty() && sRel.equalsIgnoreAsciiCase( "STYLESHEET" ) &&
1755  ( sType.isEmpty() ||
1756  sType.getToken(0,';').equalsAscii(sCSS_mimetype) ) )
1757  {
1758  if( GetMedium() )
1759  {
1760  // start download of style source
1761  StartFileDownload(sHRef);
1762  if( IsParserWorking() )
1763  {
1764  // The style was loaded synchronously and we can call it directly.
1765  bFinishDownload = true;
1766  }
1767  else
1768  {
1769  // The style was load asynchronously and is only available
1770  // on the next continue call. Therefore we must create a
1771  // Pending stack, so that we will return to here.
1772  m_vPendingStack.emplace_back( HtmlTokenId::LINK );
1773  }
1774  }
1775  else
1776  {
1777  // load file synchronous
1778  OUString sSource;
1779  if( FileDownload( sHRef, sSource ) )
1780  m_pCSS1Parser->ParseStyleSheet( sSource );
1781  }
1782  }
1783  }
1784 
1785  if( bFinishDownload )
1786  {
1787  OUString sSource;
1788  if( FinishFileDownload( sSource ) && !sSource.isEmpty() )
1789  m_pCSS1Parser->ParseStyleSheet( sSource );
1790  }
1791 }
1792 
1793 bool SwCSS1Parser::ParseStyleSheet( const OUString& rIn )
1794 {
1795  if( !SvxCSS1Parser::ParseStyleSheet( rIn ) )
1796  return false;
1797 
1798  SwPageDesc *pMasterPageDesc =
1799  m_pDoc->getIDocumentStylePoolAccess().GetPageDescFromPool( RES_POOLPAGE_HTML, false );
1800 
1801  SvxCSS1MapEntry* pPageEntry = GetPage(OUString(), false);
1802  if( pPageEntry )
1803  {
1804  // @page (affects all already existing pages)
1805 
1806  SetPageDescAttrs( pMasterPageDesc, pPageEntry->GetItemSet(),
1807  pPageEntry->GetPropertyInfo() );
1808 
1809  // For all other already existing page styles the attributes
1810  // must also be set
1811 
1812  SetPageDescAttrs( GetFirstPageDesc(), pPageEntry->GetItemSet(),
1813  pPageEntry->GetPropertyInfo() );
1814  SetPageDescAttrs( GetLeftPageDesc(), pPageEntry->GetItemSet(),
1815  pPageEntry->GetPropertyInfo() );
1816  SetPageDescAttrs( GetRightPageDesc(), pPageEntry->GetItemSet(),
1817  pPageEntry->GetPropertyInfo() );
1818 
1819  }
1820 
1821  pPageEntry = GetPage( "first", true );
1822  if( pPageEntry )
1823  {
1824  SetPageDescAttrs( GetFirstPageDesc(true), pPageEntry->GetItemSet(),
1825  pPageEntry->GetPropertyInfo() );
1826  m_bSetFirstPageDesc = true;
1827  }
1828 
1829  pPageEntry = GetPage( "right", true );
1830  if( pPageEntry )
1831  {
1832  SetPageDescAttrs( GetRightPageDesc(true), pPageEntry->GetItemSet(),
1833  pPageEntry->GetPropertyInfo() );
1834  m_bSetRightPageDesc = true;
1835  }
1836 
1837  pPageEntry = GetPage( "left", true );
1838  if( pPageEntry )
1839  SetPageDescAttrs( GetLeftPageDesc(true), pPageEntry->GetItemSet(),
1840  pPageEntry->GetPropertyInfo() );
1841 
1842  return true;
1843 }
1844 
1845 bool SwHTMLParser::ParseStyleOptions( const OUString &rStyle,
1846  const OUString &rId,
1847  const OUString &rClass,
1848  SfxItemSet &rItemSet,
1849  SvxCSS1PropertyInfo &rPropInfo,
1850  const OUString *pLang,
1851  const OUString *pDir )
1852 {
1853  bool bRet = false;
1854 
1855  if( !rClass.isEmpty() )
1856  {
1857  OUString aClass( rClass );
1858  SwCSS1Parser::GetScriptFromClass( aClass );
1859  const SvxCSS1MapEntry *pClass = m_pCSS1Parser->GetClass( aClass );
1860  if( pClass )
1861  {
1862  SvxCSS1Parser::MergeStyles( pClass->GetItemSet(),
1863  pClass->GetPropertyInfo(),
1864  rItemSet, rPropInfo, false );
1865  bRet = true;
1866  }
1867  }
1868 
1869  if( !rId.isEmpty() )
1870  {
1871  const SvxCSS1MapEntry *pId = m_pCSS1Parser->GetId( rId );
1872  if( pId )
1873  SvxCSS1Parser::MergeStyles( pId->GetItemSet(),
1874  pId->GetPropertyInfo(),
1875  rItemSet, rPropInfo, !rClass.isEmpty() );
1876  rPropInfo.m_aId = rId;
1877  bRet = true;
1878  }
1879 
1880  if( !rStyle.isEmpty() )
1881  {
1882  m_pCSS1Parser->ParseStyleOption( rStyle, rItemSet, rPropInfo );
1883  bRet = true;
1884  }
1885 
1886  if( bRet )
1887  rPropInfo.SetBoxItem( rItemSet, MIN_BORDER_DIST );
1888 
1889  if( pLang && !pLang->isEmpty() )
1890  {
1891  LanguageType eLang = LanguageTag::convertToLanguageTypeWithFallback( *pLang );
1892  if( LANGUAGE_DONTKNOW != eLang )
1893  {
1894  SvxLanguageItem aLang( eLang, RES_CHRATR_LANGUAGE );
1895  rItemSet.Put( aLang );
1896  aLang.SetWhich( RES_CHRATR_CJK_LANGUAGE );
1897  rItemSet.Put( aLang );
1898  aLang.SetWhich( RES_CHRATR_CTL_LANGUAGE );
1899  rItemSet.Put( aLang );
1900 
1901  bRet = true;
1902  }
1903  }
1904  if( pDir && !pDir->isEmpty() )
1905  {
1906  OUString aValue( *pDir );
1907  SvxFrameDirection eDir = SvxFrameDirection::Environment;
1908  if (aValue.equalsIgnoreAsciiCase("LTR"))
1909  eDir = SvxFrameDirection::Horizontal_LR_TB;
1910  else if (aValue.equalsIgnoreAsciiCase("RTL"))
1911  eDir = SvxFrameDirection::Horizontal_RL_TB;
1912 
1913  if( SvxFrameDirection::Environment != eDir )
1914  {
1915  SvxFrameDirectionItem aDir( eDir, RES_FRAMEDIR );
1916  rItemSet.Put( aDir );
1917 
1918  bRet = true;
1919  }
1920  }
1921 
1922  return bRet;
1923 }
1924 
1925 void SwHTMLParser::SetAnchorAndAdjustment( const SvxCSS1PropertyInfo &rPropInfo,
1926  SfxItemSet &rFrameItemSet )
1927 {
1928  SwFormatAnchor aAnchor;
1929 
1930  sal_Int16 eHoriOri = text::HoriOrientation::NONE;
1931  sal_Int16 eVertOri = text::VertOrientation::NONE;
1932  sal_Int16 eHoriRel = text::RelOrientation::FRAME;
1933  sal_Int16 eVertRel = text::RelOrientation::FRAME;
1934  SwTwips nHoriPos = 0, nVertPos = 0;
1935  css::text::WrapTextMode eSurround = css::text::WrapTextMode_THROUGH;
1936  if( SVX_CSS1_POS_ABSOLUTE == rPropInfo.m_ePosition )
1937  {
1938  if( SVX_CSS1_LTYPE_TWIP == rPropInfo.m_eLeftType &&
1939  SVX_CSS1_LTYPE_TWIP == rPropInfo.m_eTopType )
1940  {
1941  // Absolute positioned objects are page-bound, when they
1942  // aren't in a frame and otherwise frame-bound.
1943  const SwStartNode *pFlySttNd =
1944  m_pPam->GetPoint()->nNode.GetNode().FindFlyStartNode();
1945  if( pFlySttNd )
1946  {
1947  aAnchor.SetType( RndStdIds::FLY_AT_FLY );
1948  SwPosition aPos( *pFlySttNd );
1949  aAnchor.SetAnchor( &aPos );
1950  }
1951  else
1952  {
1953  aAnchor.SetType( RndStdIds::FLY_AT_PAGE );
1954  aAnchor.SetPageNum( 1 );
1955  }
1956  nHoriPos = rPropInfo.m_nLeft;
1957  nVertPos = rPropInfo.m_nTop;
1958  }
1959  else
1960  {
1961  aAnchor.SetType( RndStdIds::FLY_AT_PARA );
1962  aAnchor.SetAnchor( m_pPam->GetPoint() );
1963  eVertOri = text::VertOrientation::TOP;
1964  eVertRel = text::RelOrientation::CHAR;
1965  if( SVX_CSS1_LTYPE_TWIP == rPropInfo.m_eLeftType )
1966  {
1967  eHoriOri = text::HoriOrientation::NONE;
1968  eHoriRel = text::RelOrientation::PAGE_FRAME;
1969  nHoriPos = rPropInfo.m_nLeft;
1970  }
1971  else
1972  {
1973  eHoriOri = text::HoriOrientation::LEFT;
1974  eHoriRel = text::RelOrientation::FRAME; // to be changed later
1975  }
1976  }
1977  }
1978  else
1979  {
1980  // Flowing object are inserted as paragraph-bound, when the paragraph is
1981  // still empty and otherwise auto-bound.
1982  // Auto-bound frames for the time being inserted at the previous position
1983  // and later moved.
1984  const sal_Int32 nContent = m_pPam->GetPoint()->nContent.GetIndex();
1985  if( nContent )
1986  {
1987  aAnchor.SetType( RndStdIds::FLY_AT_CHAR );
1988  m_pPam->Move( fnMoveBackward );
1989  eVertOri = text::VertOrientation::CHAR_BOTTOM;
1990  eVertRel = text::RelOrientation::CHAR;
1991  }
1992  else
1993  {
1994  aAnchor.SetType( RndStdIds::FLY_AT_PARA );
1995  eVertOri = text::VertOrientation::TOP;
1996  eVertRel = text::RelOrientation::PRINT_AREA;
1997  }
1998 
1999  aAnchor.SetAnchor( m_pPam->GetPoint() );
2000 
2001  if( nContent )
2002  m_pPam->Move( fnMoveForward );
2003 
2004  sal_uInt16 nLeftSpace = 0, nRightSpace = 0;
2005  short nIndent = 0;
2006  GetMarginsFromContextWithNumBul( nLeftSpace, nRightSpace, nIndent );
2007 
2008  if( SvxAdjust::Right==rPropInfo.m_eFloat )
2009  {
2010  eHoriOri = text::HoriOrientation::RIGHT;
2011  eHoriRel = nRightSpace ? text::RelOrientation::PRINT_AREA : text::RelOrientation::FRAME;
2012  eSurround = css::text::WrapTextMode_LEFT;
2013  }
2014  else
2015  {
2016  eHoriOri = text::HoriOrientation::LEFT;
2017  eHoriRel = nLeftSpace ? text::RelOrientation::PRINT_AREA : text::RelOrientation::FRAME;
2018  eSurround = css::text::WrapTextMode_RIGHT;
2019  }
2020  }
2021  rFrameItemSet.Put( aAnchor );
2022 
2023  // positioned absolutely with wrap
2024  rFrameItemSet.Put( SwFormatHoriOrient( nHoriPos, eHoriOri, eHoriRel ) );
2025  rFrameItemSet.Put( SwFormatVertOrient( nVertPos, eVertOri, eVertRel ) );
2026  rFrameItemSet.Put( SwFormatSurround( eSurround ) );
2027 }
2028 
2029 void SwHTMLParser::SetVarSize( SvxCSS1PropertyInfo const &rPropInfo,
2030  SfxItemSet &rFrameItemSet,
2031  SwTwips nDfltWidth, sal_uInt8 nDfltPrcWidth )
2032 {
2033  SwTwips nWidth = nDfltWidth, nHeight = MINFLY;
2034  sal_uInt8 nPrcWidth = nDfltPrcWidth, nPrcHeight = 0;
2035  switch( rPropInfo.m_eWidthType )
2036  {
2037  case SVX_CSS1_LTYPE_PERCENTAGE:
2038  nPrcWidth = rPropInfo.m_nWidth > 0 ? static_cast<sal_uInt8>(rPropInfo.m_nWidth) : 1;
2039  nWidth = MINFLY;
2040  break;
2041  case SVX_CSS1_LTYPE_TWIP:
2042  nWidth = std::max<long>(rPropInfo.m_nWidth, MINFLY);
2043  nPrcWidth = 0;
2044  break;
2045  default:
2046  ;
2047  }
2048  switch( rPropInfo.m_eHeightType )
2049  {
2050  case SVX_CSS1_LTYPE_PERCENTAGE:
2051  nPrcHeight = rPropInfo.m_nHeight > 0 ? static_cast<sal_uInt8>(rPropInfo.m_nHeight) : 1;
2052  break;
2053  case SVX_CSS1_LTYPE_TWIP:
2054  // Netscape and MS-IE interpreting the height incorrectly as minimum height,
2055  // therefore we are doing the same.
2056  nHeight = std::max<long>(rPropInfo.m_nHeight, MINFLY);
2057  break;
2058  default:
2059  ;
2060  }
2061 
2062  SwFormatFrameSize aFrameSize( ATT_MIN_SIZE, nWidth, nHeight );
2063  aFrameSize.SetWidthPercent( nPrcWidth );
2064  aFrameSize.SetHeightPercent( nPrcHeight );
2065  rFrameItemSet.Put( aFrameSize );
2066 }
2067 
2068 void SwHTMLParser::SetFrameFormatAttrs( SfxItemSet &rItemSet,
2069  HtmlFrameFormatFlags nFlags,
2070  SfxItemSet &rFrameItemSet )
2071 {
2072  const SfxPoolItem *pItem;
2073  if( (nFlags & HtmlFrameFormatFlags::Box) &&
2074  SfxItemState::SET==rItemSet.GetItemState( RES_BOX, true, &pItem ) )
2075  {
2076  if( nFlags & HtmlFrameFormatFlags::Padding )
2077  {
2078  SvxBoxItem aBoxItem( *static_cast<const SvxBoxItem *>(pItem) );
2079  // reset all 4 sides to 0
2080  aBoxItem.SetAllDistances(0);
2081  rFrameItemSet.Put( aBoxItem );
2082  }
2083  else
2084  {
2085  rFrameItemSet.Put( *pItem );
2086  }
2087  rItemSet.ClearItem( RES_BOX );
2088  }
2089 
2090  if( (nFlags & HtmlFrameFormatFlags::Background) &&
2091  SfxItemState::SET==rItemSet.GetItemState( RES_BACKGROUND, true, &pItem ) )
2092  {
2093  rFrameItemSet.Put( *pItem );
2094  rItemSet.ClearItem( RES_BACKGROUND );
2095  }
2096 
2097  if( (nFlags & HtmlFrameFormatFlags::Direction) &&
2098  SfxItemState::SET==rItemSet.GetItemState( RES_FRAMEDIR, true, &pItem ) )
2099  {
2100  rFrameItemSet.Put( *pItem );
2101  rItemSet.ClearItem( RES_FRAMEDIR );
2102  }
2103 }
2104 
2105 std::unique_ptr<HTMLAttrContext> SwHTMLParser::PopContext( HtmlTokenId nToken )
2106 {
2107  std::unique_ptr<HTMLAttrContext> xCntxt;
2108 
2109  HTMLAttrContexts::size_type nPos = m_aContexts.size();
2110  if( nPos <= m_nContextStMin )
2111  return nullptr;
2112 
2113  bool bFound = HtmlTokenId::NONE == nToken;
2114  if( nToken != HtmlTokenId::NONE )
2115  {
2116  // search for stack entry of token ...
2117  while( nPos > m_nContextStMin )
2118  {
2119  HtmlTokenId nCntxtToken = m_aContexts[--nPos]->GetToken();
2120  if( nCntxtToken == nToken )
2121  {
2122  bFound = true;
2123  break;
2124  }
2125  else if( nCntxtToken == HtmlTokenId::NONE ) // zero as token doesn't occur
2126  {
2127  break;
2128  }
2129  }
2130  }
2131  else
2132  {
2133  nPos--;
2134  }
2135 
2136  if( bFound )
2137  {
2138  xCntxt = std::move(m_aContexts[nPos]);
2139  m_aContexts.erase( m_aContexts.begin() + nPos );
2140  }
2141 
2142  return xCntxt;
2143 }
2144 
2145 void SwHTMLParser::GetMarginsFromContext( sal_uInt16& nLeft,
2146  sal_uInt16& nRight,
2147  short& nIndent,
2148  bool bIgnoreTopContext ) const
2149 {
2150  HTMLAttrContexts::size_type nPos = m_aContexts.size();
2151  if( bIgnoreTopContext )
2152  {
2153  if( !nPos )
2154  return;
2155  else
2156  nPos--;
2157  }
2158 
2159  while( nPos > m_nContextStAttrMin )
2160  {
2161  const HTMLAttrContext *pCntxt = m_aContexts[--nPos].get();
2162  if( pCntxt->IsLRSpaceChanged() )
2163  {
2164  pCntxt->GetMargins( nLeft, nRight, nIndent );
2165  return;
2166  }
2167  }
2168 }
2169 
2170 void SwHTMLParser::GetMarginsFromContextWithNumBul( sal_uInt16& nLeft,
2171  sal_uInt16& nRight,
2172  short& nIndent ) const
2173 {
2174  GetMarginsFromContext( nLeft, nRight, nIndent );
2175  const SwHTMLNumRuleInfo& rInfo = const_cast<SwHTMLParser*>(this)->GetNumInfo();
2176  if( rInfo.GetDepth() )
2177  {
2178  sal_uInt8 nLevel = static_cast<sal_uInt8>( (rInfo.GetDepth() <= MAXLEVEL ? rInfo.GetDepth()
2179  : MAXLEVEL) - 1 );
2180  const SwNumFormat& rNumFormat = rInfo.GetNumRule()->Get(nLevel);
2181  nLeft = nLeft + rNumFormat.GetAbsLSpace(); //TODO: overflow
2182  nIndent = rNumFormat.GetFirstLineOffset(); //TODO: overflow
2183  }
2184 }
2185 
2186 void SwHTMLParser::GetULSpaceFromContext( sal_uInt16& nUpper,
2187  sal_uInt16& nLower ) const
2188 {
2189  sal_uInt16 nDfltColl = 0;
2190  OUString aDfltClass;
2191 
2192  HTMLAttrContexts::size_type nPos = m_aContexts.size();
2193  while( nPos > m_nContextStAttrMin )
2194  {
2195  const HTMLAttrContext *pCntxt = m_aContexts[--nPos].get();
2196  if( pCntxt->IsULSpaceChanged() )
2197  {
2198  pCntxt->GetULSpace( nUpper, nLower );
2199  return;
2200  }
2201  else if( !nDfltColl )
2202  {
2203  nDfltColl = pCntxt->GetDfltTextFormatColl();
2204  if( nDfltColl )
2205  aDfltClass = pCntxt->GetClass();
2206  }
2207  }
2208 
2209  if( !nDfltColl )
2210  nDfltColl = RES_POOLCOLL_TEXT;
2211 
2212  const SwTextFormatColl *pColl =
2213  m_pCSS1Parser->GetTextFormatColl( nDfltColl, aDfltClass );
2214  const SvxULSpaceItem& rULSpace = pColl->GetULSpace();
2215  nUpper = rULSpace.GetUpper();
2216  nLower = rULSpace.GetLower();
2217 }
2218 
2219 void SwHTMLParser::EndContextAttrs( HTMLAttrContext *pContext )
2220 {
2221  HTMLAttrs &rAttrs = pContext->GetAttrs();
2222  for( auto pAttr : rAttrs )
2223  {
2224  if( RES_PARATR_DROP==pAttr->GetItem().Which() )
2225  {
2226  // Set the number of characters for DropCaps. If it's zero at the
2227  // end, the attribute is set to invalid and then isn't set from SetAttr.
2228  sal_Int32 nChars = m_pPam->GetPoint()->nContent.GetIndex();
2229  if( nChars < 1 )
2230  pAttr->Invalidate();
2231  else if( nChars > MAX_DROPCAP_CHARS )
2232  nChars = MAX_DROPCAP_CHARS;
2233  static_cast<SwFormatDrop&>(pAttr->GetItem()).GetChars() = static_cast<sal_uInt8>(nChars);
2234  }
2235 
2236  EndAttr( pAttr );
2237  }
2238 }
2239 
2240 void SwHTMLParser::InsertParaAttrs( const SfxItemSet& rItemSet )
2241 {
2242  SfxItemIter aIter( rItemSet );
2243 
2244  const SfxPoolItem *pItem = aIter.FirstItem();
2245  while( pItem )
2246  {
2247  // search for the table entry of the item...
2248  sal_uInt16 nWhich = pItem->Which();
2249  HTMLAttr **ppAttr = GetAttrTabEntry( nWhich );
2250 
2251  if( ppAttr )
2252  {
2253  NewAttr(m_xAttrTab, ppAttr, *pItem);
2254  if( RES_PARATR_BEGIN > nWhich )
2255  (*ppAttr)->SetLikePara();
2256  m_aParaAttrs.push_back( *ppAttr );
2257  bool bSuccess = EndAttr( *ppAttr, false );
2258  if (!bSuccess)
2259  m_aParaAttrs.pop_back();
2260  }
2261 
2262  pItem = aIter.NextItem();
2263  }
2264 }
2265 
2266 static void lcl_swcss1_setEncoding( SwFormat& rFormat, rtl_TextEncoding eEnc )
2267 {
2268  if( RTL_TEXTENCODING_DONTKNOW == eEnc )
2269  return;
2270 
2271  const SfxItemSet& rItemSet = rFormat.GetAttrSet();
2272  static const sal_uInt16 aWhichIds[3] = { RES_CHRATR_FONT, RES_CHRATR_CJK_FONT,
2273  RES_CHRATR_CTL_FONT };
2274  const SfxPoolItem *pItem;
2275  for(sal_uInt16 i : aWhichIds)
2276  {
2277  if( SfxItemState::SET == rItemSet.GetItemState( i, false,&pItem ) )
2278  {
2279  const SvxFontItem& rFont = *static_cast<const SvxFontItem *>(pItem);
2280  if( RTL_TEXTENCODING_SYMBOL != rFont.GetCharSet() )
2281  {
2282  SvxFontItem aFont( rFont.GetFamily(), rFont.GetFamilyName(),
2283  rFont.GetStyleName(), rFont.GetPitch(),
2284  eEnc, i);
2285  rFormat.SetFormatAttr( aFont );
2286  }
2287  }
2288  }
2289 }
2290 
2291 void SwCSS1Parser::SetDfltEncoding( rtl_TextEncoding eEnc )
2292 {
2293  if( eEnc != GetDfltEncoding() )
2294  {
2295  if( m_bIsNewDoc )
2296  {
2297  // Set new encoding as pool default
2298  static const sal_uInt16 aWhichIds[3] = { RES_CHRATR_FONT, RES_CHRATR_CJK_FONT,
2299  RES_CHRATR_CTL_FONT };
2300  for(sal_uInt16 i : aWhichIds)
2301  {
2302  const SvxFontItem& rDfltFont =
2303  static_cast<const SvxFontItem&>(m_pDoc->GetDefault( i));
2304  SvxFontItem aFont( rDfltFont.GetFamily(),
2305  rDfltFont.GetFamilyName(),
2306  rDfltFont.GetStyleName(),
2307  rDfltFont.GetPitch(),
2308  eEnc, i );
2309  m_pDoc->SetDefault( aFont );
2310  }
2311 
2312  // Change all paragraph styles that do specify a font.
2313  for( auto pTextFormatColl : *m_pDoc->GetTextFormatColls() )
2314  lcl_swcss1_setEncoding( *pTextFormatColl, eEnc );
2315 
2316  // Change all character styles that do specify a font.
2317  for( auto pCharFormat : *m_pDoc->GetCharFormats() )
2318  lcl_swcss1_setEncoding( *pCharFormat, eEnc );
2319  }
2320 
2321  SvxCSS1Parser::SetDfltEncoding( eEnc );
2322  }
2323 }
2324 
2325 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
IDocumentStylePoolAccess::GetCharFormatFromPool
virtual SwCharFormat * GetCharFormatFromPool(sal_uInt16 nId)=0
SvxLRSpaceItem::GetLeft
long GetLeft() const
SwHTMLParser::m_vPendingStack
std::vector< SwPending > m_vPendingStack
Definition: swhtml.hxx:375
SwDoc::MakeTextFormatColl
SwTextFormatColl * MakeTextFormatColl(const OUString &rFormatName, SwTextFormatColl *pDerivedFrom, bool bBroadcast=false)
Create the FormatCollections.
Definition: docfmt.cxx:901
SvxCSS1Parser::MergeStyles
static void MergeStyles(const SfxItemSet &rSrcSet, const SvxCSS1PropertyInfo &rSrcInfo, SfxItemSet &rTargetSet, SvxCSS1PropertyInfo &rTargetInfo, bool bSmart)
Definition: svxcss1.cxx:919
SwStartNode
Starts a section of nodes in the document model.
Definition: node.hxx:303
HTMLAttrContext::GetULSpace
void GetULSpace(sal_uInt16 &rUpper, sal_uInt16 &rLower) const
Definition: swhtml.hxx:982
SvxBreak
SvxBreak
SwCSS1Parser::GetFirstPageDesc
const SwPageDesc * GetFirstPageDesc(bool bCreate=false)
Definition: swcss1.hxx:158
RES_CHRATR_WEIGHT
#define RES_CHRATR_WEIGHT
Definition: hintids.hxx:83
SwDoc::ContainsPageDesc
bool ContainsPageDesc(const SwPageDesc *pDesc, size_t *pPos) const
Definition: docdesc.cxx:834
SvxCSS1PropertyInfo::m_eLeftType
SvxCSS1LengthType m_eLeftType
Definition: svxcss1.hxx:136
SwHTMLParser::SetAnchorAndAdjustment
void SetAnchorAndAdjustment(sal_Int16 eVertOri, sal_Int16 eHoriOri, const SvxCSS1PropertyInfo &rPropInfo, SfxItemSet &rFrameSet)
Definition: htmlgrin.cxx:153
Css1ScriptFlags
Css1ScriptFlags
Definition: svxcss1.hxx:75
SwCSS1Parser::m_nDropCapCnt
sal_uInt16 m_nDropCapCnt
Definition: swcss1.hxx:44
HTMLOption::GetToken
HtmlOptionId GetToken() const
SvxCSS1PropertyInfo::m_eTopType
SvxCSS1LengthType m_eTopType
Definition: svxcss1.hxx:136
SwCSS1Parser::GetScriptFromClass
static Css1ScriptFlags GetScriptFromClass(OUString &rClass, bool bSubClassOnly=true)
Definition: htmlcss1.cxx:555
SwTextFormatColl
Represents the style of a paragraph.
Definition: fmtcol.hxx:55
SwCSS1Parser::GetTextFormatColl
SwTextFormatColl * GetTextFormatColl(sal_uInt16 nTextColl, const OUString &rClass)
Definition: htmlcss1.cxx:1242
SwPosition
Marks a position in the document model.
Definition: pam.hxx:35
RES_CHRATR_CJK_LANGUAGE
#define RES_CHRATR_CJK_LANGUAGE
Definition: hintids.hxx:92
SwFormatPageDesc
Pagedescriptor Client of SwPageDesc that is "described" by the attribute.
Definition: fmtpdsc.hxx:35
SvxULSpaceItem::GetLower
sal_uInt16 GetLower() const
SwHTMLParser::m_bIgnoreRawData
bool m_bIgnoreRawData
Definition: swhtml.hxx:430
SwCSS1Parser::GetMasterPageDesc
SwPageDesc * GetMasterPageDesc()
Definition: htmlcss1.cxx:1323
RES_CHRATR_FONTSIZE
#define RES_CHRATR_FONTSIZE
Definition: hintids.hxx:76
SvxCSS1Parser::SetDfltEncoding
virtual void SetDfltEncoding(rtl_TextEncoding eEnc)
Definition: svxcss1.cxx:969
RES_CHRATR_LANGUAGE
#define RES_CHRATR_LANGUAGE
Definition: hintids.hxx:78
SwCSS1Parser::~SwCSS1Parser
virtual ~SwCSS1Parser() override
Definition: htmlcss1.cxx:119
SfxHTMLParser::ShouldFinishFileDownload
bool ShouldFinishFileDownload() const
SwDoc::MakeCharFormat
SwCharFormat * MakeCharFormat(const OUString &rFormatName, SwCharFormat *pDerivedFrom, bool bBroadcast=false)
Definition: docfmt.cxx:867
SwCSS1Parser::m_bSetRightPageDesc
bool m_bSetRightPageDesc
Definition: swcss1.hxx:55
SwDoc::GetDocShell
SwDocShell * GetDocShell()
Definition: doc.hxx:1340
SwHTMLParser::FileDownload
bool FileDownload(const OUString &rURL, OUString &rStr)
Definition: htmlcss1.cxx:1684
SvxLRSpaceItem::GetTextFirstLineOfst
short GetTextFirstLineOfst() const
HTMLAttrContext::GetDfltTextFormatColl
sal_uInt16 GetDfltTextFormatColl() const
Definition: swhtml.hxx:248
SfxPoolItem::Clone
virtual SfxPoolItem * Clone(SfxItemPool *pPool=nullptr) const =0
SwPosition::nNode
SwNodeIndex nNode
Definition: pam.hxx:37
GPOS_NONE
GPOS_NONE
SwCSS1Parser::GetTextCollFromPool
SwTextFormatColl * GetTextCollFromPool(sal_uInt16 nPoolId) const
Definition: htmlcss1.cxx:1207
RES_CHRATR_CJK_POSTURE
#define RES_CHRATR_CJK_POSTURE
Definition: hintids.hxx:93
SwDoc::FindTextFormatCollByName
SwTextFormatColl * FindTextFormatCollByName(const OUString &rName) const
Definition: doc.hxx:794
OOO_STRING_SVTOOLS_HTML_tableheader
#define OOO_STRING_SVTOOLS_HTML_tableheader
SvxCSS1MapEntry::GetPropertyInfo
const SvxCSS1PropertyInfo & GetPropertyInfo() const
Definition: svxcss1.hxx:173
SwCSS1Parser::m_bBodyBGColorSet
bool m_bBodyBGColorSet
Definition: swcss1.hxx:48
SwFormatDrop::GetLines
sal_uInt8 GetLines() const
Definition: paratr.hxx:86
MINFLY
#define MINFLY
Definition: swtypes.hxx:65
RES_FRAMEDIR
#define RES_FRAMEDIR
Definition: hintids.hxx:225
SwHTMLParser::NewAttr
void NewAttr(const std::shared_ptr< HTMLAttrTable > &rAttrTab, HTMLAttr **ppAttr, const SfxPoolItem &rItem)
Definition: swhtml.cxx:3017
HTMLOption::GetString
const OUString & GetString() const
SfxHTMLParser::StartFileDownload
void StartFileDownload(const OUString &rURL)
SwDoc
Definition: doc.hxx:185
SwHTMLParser::CallEndAction
SwViewShell * CallEndAction(bool bChkAction=false, bool bChkPtr=true)
Definition: swhtml.cxx:2613
CSS1Selector::GetString
const OUString & GetString() const
Definition: parcss1.hxx:100
SwHTMLParser::m_aContexts
HTMLAttrContexts m_aContexts
Definition: swhtml.hxx:364
HTMLAttrContext::GetClass
const OUString & GetClass() const
Definition: swhtml.hxx:250
RES_CHRATR_CJK_WEIGHT
#define RES_CHRATR_CJK_WEIGHT
Definition: hintids.hxx:94
RES_CHRATR_FONT
#define RES_CHRATR_FONT
Definition: hintids.hxx:75
SvxLRSpaceItem::SetTextLeft
void SetTextLeft(const long nL, const sal_uInt16 nProp=100)
SwCSS1Parser::m_bBodyVLinkSet
bool m_bBodyVLinkSet
Definition: swcss1.hxx:52
SwNodeIndex::GetNode
SwNode & GetNode() const
Definition: ndindex.hxx:118
OOO_STRING_SVTOOLS_HTML_sdfootnote_sym
#define OOO_STRING_SVTOOLS_HTML_sdfootnote_sym
SwTwips
long SwTwips
Definition: swtypes.hxx:49
SwCSS1Parser::GetFontHeight
virtual sal_uInt32 GetFontHeight(sal_uInt16 nSize) const override
Definition: htmlcss1.cxx:1107
SwCSS1Parser::m_bTableTextCollSet
bool m_bTableTextCollSet
Definition: swcss1.hxx:58
SvxFrameDirection
SvxFrameDirection
SvxCSS1Parser::GetDfltEncoding
rtl_TextEncoding GetDfltEncoding() const
Definition: svxcss1.hxx:299
RES_CHRATR_BLINK
#define RES_CHRATR_BLINK
Definition: hintids.hxx:86
RES_CHRATR_CJK_FONT
#define RES_CHRATR_CJK_FONT
Definition: hintids.hxx:90
SwHTMLParser::m_sBaseURL
OUString m_sBaseURL
Definition: swhtml.hxx:342
OOO_STRING_SVTOOLS_HTML_insertedtext
#define OOO_STRING_SVTOOLS_HTML_insertedtext
SwCSS1Parser::m_bBodyLinkSet
bool m_bBodyLinkSet
Definition: swcss1.hxx:51
RES_CHRATR_CJK_FONTSIZE
#define RES_CHRATR_CJK_FONTSIZE
Definition: hintids.hxx:91
SvxCSS1PropertyInfo::SetBoxItem
void SetBoxItem(SfxItemSet &rItemSet, sal_uInt16 nMinBorderDist, const SvxBoxItem *pDflt=nullptr)
Definition: svxcss1.cxx:575
RES_PARATR_SPLIT
#define RES_PARATR_SPLIT
Definition: hintids.hxx:163
SwTextFormatColl::SetFormatAttr
virtual bool SetFormatAttr(const SfxPoolItem &rAttr) override
Override to recognize changes on the and register/unregister the paragragh style at t...
Definition: fmtcol.cxx:330
SwFormatAnchor::SetPageNum
void SetPageNum(sal_uInt16 nNew)
Definition: fmtanchr.hxx:72
ATT_FIX_SIZE
Frame cannot be moved in Var-direction.
Definition: fmtfsize.hxx:38
SvxCSS1PropertyInfo::m_ePageBreakBefore
SvxCSS1PageBreak m_ePageBreakBefore
Definition: svxcss1.hxx:141
SwHTMLParser::InsertLink
void InsertLink()
Definition: htmlcss1.cxx:1718
SvxFontItem::GetPitch
FontPitch GetPitch() const
MIN_BORDER_DIST
#define MIN_BORDER_DIST
Definition: swtypes.hxx:74
SwCSS1Parser::m_aFontHeights
sal_uLong m_aFontHeights[7]
Definition: swcss1.hxx:42
SfxItemIter::FirstItem
const SfxPoolItem * FirstItem()
SvxFontItem::GetFamily
FontFamily GetFamily() const
SwPageDesc::SetFollow
void SetFollow(const SwPageDesc *pNew)
Definition: pagedesc.hxx:290
HtmlFrameFormatFlags
HtmlFrameFormatFlags
Definition: swhtml.hxx:319
SvMemoryStream::TellEnd
virtual sal_uInt64 TellEnd() override
MAX_DROPCAP_CHARS
#define MAX_DROPCAP_CHARS
Definition: htmlcss1.cxx:71
OOO_STRING_SVTOOLS_HTML_tabledata
#define OOO_STRING_SVTOOLS_HTML_tabledata
SvxCSS1PropertyInfo::m_eHeightType
SvxCSS1LengthType m_eHeightType
Definition: svxcss1.hxx:137
SvxCSS1PropertyInfo::m_eSizeType
SvxCSS1SizeType m_eSizeType
Definition: svxcss1.hxx:139
COL_TRANSPARENT
constexpr::Color COL_TRANSPARENT(0xFF, 0xFF, 0xFF, 0xFF)
LanguageTag::convertToLanguageTypeWithFallback
static LanguageType convertToLanguageTypeWithFallback(const OUString &rBcp47)
SvxBrushItem::GetGraphicPos
SvxGraphicPosition GetGraphicPos() const
SwDoc::GetDfltCharFormat
const SwCharFormat * GetDfltCharFormat() const
Definition: doc.hxx:747
SvxLRSpaceItem::SetLeft
void SetLeft(const long nL, const sal_uInt16 nProp=100)
ATT_MIN_SIZE
Value in Var-direction gives minimum (can be exceeded but not be less).
Definition: fmtfsize.hxx:39
SwHTMLParser::GetMarginsFromContext
void GetMarginsFromContext(sal_uInt16 &nLeft, sal_uInt16 &nRight, short &nIndent, bool bIgnoreCurrent=false) const
Definition: htmlcss1.cxx:2145
RES_CHRATR_CTL_FONTSIZE
#define RES_CHRATR_CTL_FONTSIZE
Definition: hintids.hxx:96
SwPosition::nContent
SwIndex nContent
Definition: pam.hxx:38
SwPageDesc::GetPoolFormatId
sal_uInt16 GetPoolFormatId() const
Query and set PoolFormat-Id.
Definition: pagedesc.hxx:253
SwCSS1Parser::SetDfltEncoding
virtual void SetDfltEncoding(rtl_TextEncoding eEnc) override
Definition: htmlcss1.cxx:2291
SwDoc::getIDocumentStylePoolAccess
IDocumentStylePoolAccess const & getIDocumentStylePoolAccess() const
Definition: doc.cxx:458
SvxFontItem::GetCharSet
rtl_TextEncoding GetCharSet() const
SwPageDesc::SetLandscape
void SetLandscape(bool bNew)
Definition: pagedesc.hxx:190
SwHTMLParser::ParseStyleOptions
bool ParseStyleOptions(const OUString &rStyle, const OUString &rId, const OUString &rClass, SfxItemSet &rItemSet, SvxCSS1PropertyInfo &rPropInfo, const OUString *pLang=nullptr, const OUString *pDir=nullptr)
Definition: htmlcss1.cxx:1845
sal_Char
char sal_Char
SvxBrushItem::Clone
virtual SfxPoolItem * Clone(SfxItemPool *pPool=nullptr) const override
SwFormat::GetName
const OUString & GetName() const
Definition: format.hxx:111
HTMLAttrContext::GetAttrs
const HTMLAttrs & GetAttrs() const
Definition: swhtml.hxx:263
SwDoc::GetDefault
const SfxPoolItem & GetDefault(sal_uInt16 nFormatHint) const
Get the default attribute in this document.
Definition: docfmt.cxx:682
CSS1SelectorType
CSS1SelectorType
Definition: parcss1.hxx:65
MAXLEVEL
const sal_uInt8 MAXLEVEL
Definition: swtypes.hxx:95
SwHTMLParser::SetVarSize
static void SetVarSize(SvxCSS1PropertyInfo const &rPropInfo, SfxItemSet &rFlyItemSet, SwTwips nDfltWidth=MINLAY, sal_uInt8 nDltPrcWidth=0)
Definition: htmlcss1.cxx:2029
SfxHTMLParser::FinishFileDownload
bool FinishFileDownload(OUString &rStr)
RES_UL_SPACE
#define RES_UL_SPACE
Definition: hintids.hxx:197
SwHTMLParser::EndStyle
void EndStyle()
Definition: htmlcss1.cxx:1673
SvxCSS1PropertyInfo::m_ePageBreakAfter
SvxCSS1PageBreak m_ePageBreakAfter
Definition: svxcss1.hxx:142
SwCSS1Parser::FillDropCap
void FillDropCap(SwFormatDrop &rDrop, SfxItemSet &rItemSet, const OUString *pName=nullptr)
Definition: htmlcss1.cxx:1453
SwFormatDrop::GetDistance
sal_uInt16 GetDistance() const
Definition: paratr.hxx:95
SvxCSS1Parser::GetTag
SvxCSS1MapEntry * GetTag(const OUString &rTag)
Definition: svxcss1.cxx:804
o3tl::strong_int< sal_uInt16, struct LanguageTypeTag >
GetHTMLToken
HtmlTokenId GetHTMLToken(const OUString &rName)
RES_PARATR_BEGIN
#define RES_PARATR_BEGIN
Definition: hintids.hxx:160
SvxBoxItem::SetAllDistances
void SetAllDistances(sal_uInt16 nNew)
RES_CHRATR_CASEMAP
#define RES_CHRATR_CASEMAP
Definition: hintids.hxx:69
CSS1Parser::ParseStyleSheet
void ParseStyleSheet()
Definition: parcss1.cxx:672
SwHTMLParser::m_pPam
SwPaM * m_pPam
Definition: swhtml.hxx:378
OOO_STRING_SVTOOLS_HTML_sdfootnote
#define OOO_STRING_SVTOOLS_HTML_sdfootnote
SwCSS1Parser::m_bBodyBackgroundSet
bool m_bBodyBackgroundSet
Definition: swcss1.hxx:49
SvxULSpaceItem::SetLower
void SetLower(const sal_uInt16 nL, const sal_uInt16 nProp=100)
IDocumentStylePoolAccess::GetPageDescFromPool
virtual SwPageDesc * GetPageDescFromPool(sal_uInt16 nId, bool bRegardLanguage=true)=0
Return required automatic page style.
SvxFontItem::GetStyleName
const OUString & GetStyleName() const
OOO_STRING_SVTOOLS_HTML_author
#define OOO_STRING_SVTOOLS_HTML_author
SwFormat
Base class for various Writer styles.
Definition: format.hxx:43
SAL_N_ELEMENTS
#define SAL_N_ELEMENTS(arr)
SvxCSS1Parser::InsertPage
void InsertPage(const OUString &rPage, bool bPseudo, const SfxItemSet &rItemSet, const SvxCSS1PropertyInfo &rProp)
Definition: svxcss1.cxx:776
RES_BACKGROUND
#define RES_BACKGROUND
Definition: hintids.hxx:210
SvxBrushItem::GetColor
const Color & GetColor() const
RES_POOLCOLL_TABLE_HDLN
Table of Contents - heading.
Definition: poolfmt.hxx:342
RES_CHRATR_COLOR
#define RES_CHRATR_COLOR
Definition: hintids.hxx:71
SetCharFormatAttrs
static void SetCharFormatAttrs(SwCharFormat *pCharFormat, SfxItemSet &rItemSet)
Definition: htmlcss1.cxx:180
SwCSS1Parser::m_bLinkCharFormatsSet
bool m_bLinkCharFormatsSet
Definition: swcss1.hxx:60
SwHTMLParser::SetFrameFormatAttrs
static void SetFrameFormatAttrs(SfxItemSet &rItemSet, HtmlFrameFormatFlags nFlags, SfxItemSet &rFrameItemSet)
Definition: htmlcss1.cxx:2068
SfxShell::GetItem
const SfxPoolItem * GetItem(sal_uInt16 nSlotId) const
SwPaM::Move
bool Move(SwMoveFnCollection const &fnMove=fnMoveForward, SwGoInDoc fnGo=GoInContent)
Movement of cursor.
Definition: pam.cxx:483
SvxLRSpaceItem::SetRight
void SetRight(const long nR, const sal_uInt16 nProp=100)
SwCSS1Parser::SetLinkCharFormats
void SetLinkCharFormats()
Definition: htmlcss1.cxx:216
SfxHTMLParser::GetMedium
SfxMedium * GetMedium()
SfxItemSet::ClearItem
sal_uInt16 ClearItem(sal_uInt16 nWhich=0)
SwFrameFormat
Style of a layout element.
Definition: frmfmt.hxx:57
HTMLAttrs
std::deque< HTMLAttr * > HTMLAttrs
Definition: swhtml.hxx:73
SwHTMLParser::GetMarginsFromContextWithNumBul
void GetMarginsFromContextWithNumBul(sal_uInt16 &nLeft, sal_uInt16 &nRight, short &nIndent) const
Definition: htmlcss1.cxx:2170
RES_CHRATR_BACKGROUND
#define RES_CHRATR_BACKGROUND
Definition: hintids.hxx:89
SwHTMLNumRuleInfo::GetDepth
sal_uInt16 GetDepth() const
Definition: htmlnum.hxx:73
SfxItemSet::GetItemState
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
SwHTMLParser::m_aStyleSource
OUString m_aStyleSource
Definition: swhtml.hxx:348
HTMLAttrContext::IsLRSpaceChanged
bool IsLRSpaceChanged() const
Definition: swhtml.hxx:254
RES_CHRATR_CTL_FONT
#define RES_CHRATR_CTL_FONT
Definition: hintids.hxx:95
RES_POOLCHR_INET_VISIT
Internet visited.
Definition: poolfmt.hxx:122
SwFormat::GetDrop
const SwFormatDrop & GetDrop(bool=true) const
Definition: paratr.hxx:216
SvxNumberFormat::GetAbsLSpace
sal_Int32 GetAbsLSpace() const
SwHTMLParser::EndContextAttrs
void EndContextAttrs(HTMLAttrContext *pContext)
Definition: htmlcss1.cxx:2219
SwPaM::GetPoint
const SwPosition * GetPoint() const
Definition: pam.hxx:207
RES_POOLPAGE_FIRST
First page.
Definition: poolfmt.hxx:172
RES_CHRATR_BOX
#define RES_CHRATR_BOX
Definition: hintids.hxx:108
SwVectorModifyBase< SwTextFormatColl * >::size_type
std::vector< SwTextFormatColl * >::size_type size_type
Definition: docary.hxx:69
SwCSS1Parser::GetLeftPageDesc
const SwPageDesc * GetLeftPageDesc(bool bCreate=false)
Definition: swcss1.hxx:168
SwDoc::GetPageDesc
const SwPageDesc & GetPageDesc(const size_t i) const
Definition: doc.hxx:875
SwCSS1Parser::AddClassName
static void AddClassName(OUString &rFormatName, const OUString &rClass)
Definition: htmlcss1.cxx:1446
SwFormat::SetAuto
void SetAuto(bool bNew)
Definition: format.hxx:159
SwPageDesc::GetLandscape
bool GetLandscape() const
Definition: pagedesc.hxx:189
OOO_STRING_SVTOOLS_HTML_language
#define OOO_STRING_SVTOOLS_HTML_language
RES_POOLCOLL_TEXT
Text body.
Definition: poolfmt.hxx:251
OOO_STRING_SVTOOLS_HTML_person
#define OOO_STRING_SVTOOLS_HTML_person
sName
OUString sName
i
int i
SwHTMLParser::m_pCSS1Parser
std::unique_ptr< SwCSS1Parser > m_pCSS1Parser
Definition: swhtml.hxx:373
SwFormatAnchor
FlyAnchors.
Definition: fmtanchr.hxx:34
SfxItemSet::Count
sal_uInt16 Count() const
SwCSS1Parser::GetRightPageDesc
const SwPageDesc * GetRightPageDesc(bool bCreate=false)
Definition: swcss1.hxx:163
SfxItemIter::NextItem
const SfxPoolItem * NextItem()
RES_PARATR_ORPHANS
#define RES_PARATR_ORPHANS
Definition: hintids.hxx:164
SwCSS1Parser::GetChrFormat
SwCharFormat * GetChrFormat(HtmlTokenId nToken, const OUString &rClass) const
Definition: htmlcss1.cxx:1127
SwDoc::GetPageDescCnt
size_t GetPageDescCnt() const
Definition: doc.hxx:874
SwFormat::makeBackgroundBrushItem
std::shared_ptr< SvxBrushItem > makeBackgroundBrushItem(bool=true) const
Definition: format.cxx:784
RES_POOLCHR_INET_NORMAL
Internet normal.
Definition: poolfmt.hxx:121
SwVectorModifyBase::size
size_t size() const
Definition: docary.hxx:90
SwHTMLParser::PopContext
std::unique_ptr< HTMLAttrContext > PopContext(HtmlTokenId nToken=HtmlTokenId::NONE)
Definition: htmlcss1.cxx:2105
SvxCSS1Parser::InsertClass
void InsertClass(const OUString &rClass, const SfxItemSet &rItemSet, const SvxCSS1PropertyInfo &rProp)
Definition: svxcss1.cxx:763
LANGUAGE_DONTKNOW
#define LANGUAGE_DONTKNOW
RES_CHRATR_UNDERLINE
#define RES_CHRATR_UNDERLINE
Definition: hintids.hxx:82
SwDoc::ChgPageDesc
void ChgPageDesc(const OUString &rName, const SwPageDesc &)
Definition: docdesc.cxx:860
SvxCSS1PropertyInfo::m_ePosition
SvxCSS1Position m_ePosition
Definition: svxcss1.hxx:120
RES_CHRATR_ESCAPEMENT
#define RES_CHRATR_ESCAPEMENT
Definition: hintids.hxx:74
SwCSS1Parser::SetPageDescAttrs
void SetPageDescAttrs(const SvxBrushItem *pBrush, SfxItemSet *pItemSet=nullptr)
Definition: htmlcss1.cxx:377
pName
sal_uInt16 sal_Char * pName
OOO_STRING_SVTOOLS_HTML_shortquote
#define OOO_STRING_SVTOOLS_HTML_shortquote
SwFormatDrop::GetChars
sal_uInt8 GetChars() const
Definition: paratr.hxx:89
eType
DocumentType const eType
SvxCSS1PropertyInfo::m_eFloat
SvxAdjust m_eFloat
Definition: svxcss1.hxx:118
lcl_swcss1_setEncoding
static void lcl_swcss1_setEncoding(SwFormat &rFormat, rtl_TextEncoding eEnc)
Definition: htmlcss1.cxx:2266
SvStream::WriteStream
SvStream & WriteStream(SvStream &rStream)
RES_POOLPAGE_LEFT
Left page.
Definition: poolfmt.hxx:173
SwHTMLParser::InsertParaAttrs
void InsertParaAttrs(const SfxItemSet &rItemSet)
Definition: htmlcss1.cxx:2240
HTMLAttrContext::GetMargins
void GetMargins(sal_uInt16 &nLeft, sal_uInt16 &nRight, short &nIndent) const
Definition: swhtml.hxx:963
OOO_STRING_SVTOOLS_HTML_deletedtext
#define OOO_STRING_SVTOOLS_HTML_deletedtext
SwCSS1Parser::GetCharFormatFromPool
SwCharFormat * GetCharFormatFromPool(sal_uInt16 nPoolId) const
Definition: htmlcss1.cxx:1224
SwCSS1Parser::GetFontList
virtual const FontList * GetFontList() const override
Definition: htmlcss1.cxx:1112
RES_CHRATR_KERNING
#define RES_CHRATR_KERNING
Definition: hintids.hxx:77
RES_LR_SPACE
#define RES_LR_SPACE
Definition: hintids.hxx:196
SwHTMLParser::m_nContextStMin
size_t m_nContextStMin
Definition: swhtml.hxx:403
OOO_STRING_SVTOOLS_HTML_acronym
#define OOO_STRING_SVTOOLS_HTML_acronym
HtmlTokenId
HtmlTokenId
SwFormat::SetFormatAttr
virtual bool SetFormatAttr(const SfxPoolItem &rAttr)
Definition: format.cxx:460
SvxCSS1Parser::GetPage
SvxCSS1MapEntry * GetPage(const OUString &rPage, bool bPseudo)
Definition: svxcss1.cxx:787
SwFormatFrameSize::SetHeightPercent
void SetHeightPercent(sal_uInt8 n)
Definition: fmtfsize.hxx:93
SwCSS1Parser::SwCSS1Parser
SwCSS1Parser(SwDoc *pDoc, sal_uInt32 const aFHeight[7], const OUString &rBaseURL, bool bNewDoc)
Definition: htmlcss1.cxx:93
SwNumRule::Get
const SwNumFormat & Get(sal_uInt16 i) const
Definition: number.cxx:83
SwCSS1Parser::m_bBodyTextSet
bool m_bBodyTextSet
Definition: swcss1.hxx:50
USER_FMT
const sal_uInt16 USER_FMT
POLLCOLL-groups:
Definition: poolfmt.hxx:63
SwDoc::FindCharFormatByName
SwCharFormat * FindCharFormatByName(const OUString &rName) const
Definition: doc.hxx:766
SvxFontItem::GetFamilyName
const OUString & GetFamilyName() const
SwDoc::SetDefault
void SetDefault(const SfxPoolItem &)
Set attribute as new default attribute in current document.
Definition: docfmt.cxx:554
SwPageDesc::GetMaster
SwFrameFormat & GetMaster()
Definition: pagedesc.hxx:216
SfxItemSet::Put
const SfxPoolItem * Put(const SfxPoolItem &rItem, sal_uInt16 nWhich)
SfxMedium::GetInStream
SvStream * GetInStream()
SwFormat::GetULSpace
const SvxULSpaceItem & GetULSpace(bool=true) const
Definition: frmatr.hxx:76
SwDoc::CopyPageDesc
void CopyPageDesc(const SwPageDesc &rSrcDesc, SwPageDesc &rDstDesc, bool bCopyPoolIds=true)
Copy the complete PageDesc - beyond document and "deep"! Optionally copying of PoolFormatId, -HlpId can be prevented.
Definition: docfmt.cxx:1427
HTMLAttrContext::IsULSpaceChanged
bool IsULSpaceChanged() const
Definition: swhtml.hxx:259
SwCSS1Parser::m_bIsNewDoc
bool const m_bIsNewDoc
Definition: swcss1.hxx:46
SvxCSS1PropertyInfo::m_eWidthType
SvxCSS1LengthType m_eWidthType
Definition: svxcss1.hxx:137
CSS1Selector::GetNext
const CSS1Selector * GetNext() const
Definition: parcss1.hxx:103
SvxLRSpaceItem::SetTextFirstLineOfst
void SetTextFirstLineOfst(const short nF, const sal_uInt16 nProp=100)
SwDoc::GetCharFormats
const SwCharFormats * GetCharFormats() const
Definition: doc.hxx:734
SwHTMLParser::m_aParaAttrs
HTMLAttrs m_aParaAttrs
Definition: swhtml.hxx:362
SwCSS1Parser::ChgPageDesc
void ChgPageDesc(const SwPageDesc *pPageDesc, const SwPageDesc &rNewPageDesc)
Definition: htmlcss1.cxx:83
RemoveScriptItems
static void RemoveScriptItems(SfxItemSet &rItemSet, Css1ScriptFlags nScript, const SfxItemSet *pParentItemSet=nullptr)
Definition: htmlcss1.cxx:636
OOO_STRING_SVTOOLS_HTML_sdendnote
#define OOO_STRING_SVTOOLS_HTML_sdendnote
OOO_STRING_SVTOOLS_HTML_sdendnote_sym
#define OOO_STRING_SVTOOLS_HTML_sdendnote_sym
SwDoc::GetTextFormatColls
const SwTextFormatColls * GetTextFormatColls() const
Definition: doc.hxx:773
SetTextCollAttrs
static void SetTextCollAttrs(SwTextFormatColl *pColl, SfxItemSet &rItemSet, SvxCSS1PropertyInfo const &rPropInfo, SwCSS1Parser *pCSS1Parser)
Definition: htmlcss1.cxx:268
RES_CHRATR_CTL_LANGUAGE
#define RES_CHRATR_CTL_LANGUAGE
Definition: hintids.hxx:97
sal_uInt8
unsigned char sal_uInt8
RES_CHRATR_POSTURE
#define RES_CHRATR_POSTURE
Definition: hintids.hxx:79
RES_CHRATR_CTL_WEIGHT
#define RES_CHRATR_CTL_WEIGHT
Definition: hintids.hxx:99
RES_CHRATR_CTL_POSTURE
#define RES_CHRATR_CTL_POSTURE
Definition: hintids.hxx:98
SwFormatFrameSize::SetWidthPercent
void SetWidthPercent(sal_uInt8 n)
Definition: fmtfsize.hxx:95
fnMoveForward
SwMoveFnCollection const & fnMoveForward
SwPam::Move()/Find() default argument.
Definition: paminit.cxx:59
RES_POOLPAGE_RIGHT
Right page.
Definition: poolfmt.hxx:174
SwCSS1Parser::m_pDoc
SwDoc * m_pDoc
Definition: swcss1.hxx:40
HTMLOptions
::std::vector< HTMLOption > HTMLOptions
SwCSS1Parser::m_bTableHeaderTextCollSet
bool m_bTableHeaderTextCollSet
Definition: swcss1.hxx:57
SwHTMLParser::GetULSpaceFromContext
void GetULSpaceFromContext(sal_uInt16 &rUpper, sal_uInt16 &rLower) const
Definition: htmlcss1.cxx:2186
SwIndex::GetIndex
sal_Int32 GetIndex() const
Definition: index.hxx:95
SwHTMLParser::GetNumInfo
SwHTMLNumRuleInfo & GetNumInfo()
Definition: swhtml.hxx:537
SwCSS1Parser::m_bSetFirstPageDesc
bool m_bSetFirstPageDesc
Definition: swcss1.hxx:54
SwCSS1Parser::GetPageDesc
const SwPageDesc * GetPageDesc(sal_uInt16 nPoolId, bool bCreate)
Definition: htmlcss1.cxx:1339
IDocumentStylePoolAccess::GetTextCollFromPool
virtual SwTextFormatColl * GetTextCollFromPool(sal_uInt16 nId, bool bRegardLanguage=true)=0
Return "Auto-Collection with ID.
SwHTMLParser::EndAttr
bool EndAttr(HTMLAttr *pAttr, bool bChkEmpty=true)
Definition: swhtml.cxx:3033
RES_KEEP
#define RES_KEEP
Definition: hintids.hxx:215
MAX_DROPCAP_LINES
#define MAX_DROPCAP_LINES
Definition: htmlcss1.cxx:70
OOO_STRING_SVTOOLS_HTML_parabreak
#define OOO_STRING_SVTOOLS_HTML_parabreak
RES_PARATR_ADJUST
#define RES_PARATR_ADJUST
Definition: hintids.hxx:162
SwHTMLParser::GetAttrTabEntry
HTMLAttr ** GetAttrTabEntry(sal_uInt16 nWhich)
Definition: htmlcss1.cxx:1531
SwCSS1Parser::SetTableTextColl
void SetTableTextColl(bool bHeader)
Definition: htmlcss1.cxx:332
swhtml_css1atr_equalFontItems
bool swhtml_css1atr_equalFontItems(const SfxPoolItem &r1, const SfxPoolItem &r2)
Definition: css1atr.cxx:999
SwHTMLParser::m_nContextStAttrMin
size_t m_nContextStAttrMin
Definition: swhtml.hxx:404
CSS1Selector::GetType
CSS1SelectorType GetType() const
Definition: parcss1.hxx:99
SvxNumberFormat::GetFirstLineOffset
sal_Int32 GetFirstLineOffset() const
SwFormat::GetFrameSize
const SwFormatFrameSize & GetFrameSize(bool=true) const
Definition: fmtfsize.hxx:104
SvxLRSpaceItem::GetRight
long GetRight() const
fnMoveBackward
SwMoveFnCollection const & fnMoveBackward
Definition: paminit.cxx:58
SwFormatAnchor::SetType
void SetType(RndStdIds nRndId)
Definition: fmtanchr.hxx:71
RES_PARATR_WIDOWS
#define RES_PARATR_WIDOWS
Definition: hintids.hxx:165
aName
OString const aName
SwNode::FindFlyStartNode
const SwStartNode * FindFlyStartNode() const
Definition: node.hxx:198
RES_BOX
#define RES_BOX
Definition: hintids.hxx:211
RES_CHRATR_CROSSEDOUT
#define RES_CHRATR_CROSSEDOUT
Definition: hintids.hxx:73
GetTokenAndClass
static CSS1SelectorType GetTokenAndClass(const CSS1Selector *pSelector, OUString &rToken, OUString &rClass, Css1ScriptFlags &rScriptFlags)
Definition: htmlcss1.cxx:608
SvxCSS1Parser::InsertTag
void InsertTag(const OUString &rTag, const SfxItemSet &rItemSet, const SvxCSS1PropertyInfo &rProp)
Definition: svxcss1.cxx:797
RES_PARATR_DROP
#define RES_PARATR_DROP
Definition: hintids.hxx:168
SwCSS1Parser::makePageDescBackground
std::shared_ptr< SvxBrushItem > makePageDescBackground() const
Definition: htmlcss1.cxx:549
sCSS_mimetype
const sal_Char * sCSS_mimetype
Definition: css1kywd.cxx:22
SwCSS1Parser::SetFormatBreak
bool SetFormatBreak(SfxItemSet &rItemSet, const SvxCSS1PropertyInfo &rPropInfo)
Definition: htmlcss1.cxx:124
SwHTMLParser::m_xAttrTab
std::shared_ptr< HTMLAttrTable > m_xAttrTab
Definition: swhtml.hxx:363
SwHTMLParser::NewStyle
void NewStyle()
Definition: htmlcss1.cxx:1657
SvxFontListItem::GetFontList
const FontList * GetFontList() const
SwFormat::GetAttrSet
const SwAttrSet & GetAttrSet() const
For querying the attribute array.
Definition: format.hxx:116
SwFormatDrop
If SwFormatDrop is a Client, it is the CharFormat that describes the font for the DropCaps...
Definition: paratr.hxx:50
SvxCSS1MapEntry::GetItemSet
const SfxItemSet & GetItemSet() const
Definition: svxcss1.hxx:170
CSS1Selector
A simple selector.
Definition: parcss1.hxx:86
SvxCSS1Parser::InsertId
void InsertId(const OUString &rId, const SfxItemSet &rItemSet, const SvxCSS1PropertyInfo &rProp)
Definition: svxcss1.cxx:750
aItemIds
static const sal_uInt16 aItemIds[]
Definition: htmlcss1.cxx:76
RES_POOLCOLL_TABLE
Subgroup table.
Definition: poolfmt.hxx:341
RES_PAGEDESC
#define RES_PAGEDESC
Definition: hintids.hxx:198
RES_BREAK
#define RES_BREAK
Definition: hintids.hxx:199
OOO_STRING_SVTOOLS_HTML_abbreviation
#define OOO_STRING_SVTOOLS_HTML_abbreviation
SvxLRSpaceItem::GetTextLeft
long GetTextLeft() const
SwHTMLParser::CallStartAction
SwViewShell * CallStartAction(SwViewShell *pVSh=nullptr, bool bChkPtr=true)
Definition: swhtml.cxx:2584
SvxULSpaceItem::SetUpper
void SetUpper(const sal_uInt16 nU, const sal_uInt16 nProp=100)
nPos
sal_Int32 nPos
SwHTMLParser::m_xDoc
rtl::Reference< SwDoc > m_xDoc
Definition: swhtml.hxx:377
SwHTMLNumRuleInfo::GetNumRule
SwNumRule * GetNumRule()
Definition: htmlnum.hxx:69
SvxCSS1Parser::GetClass
const SvxCSS1MapEntry * GetClass(const OUString &rClass) const
Definition: svxcss1.cxx:770
OOO_STRING_SVTOOLS_HTML_anchor
#define OOO_STRING_SVTOOLS_HTML_anchor
SfxPoolItem::Which
sal_uInt16 Which() const
FindPageDesc
static SwPageDesc * FindPageDesc(SwDoc *pDoc, sal_uInt16 nPoolId)
Definition: htmlcss1.cxx:1328
SwFormatDrop::SetCharFormat
void SetCharFormat(SwCharFormat *pNew)
Definition: paratr.cxx:66
SwCSS1Parser::StyleParsed
virtual void StyleParsed(const CSS1Selector *pSelector, SfxItemSet &rItemSet, SvxCSS1PropertyInfo &rPropInfo) override
Definition: htmlcss1.cxx:686
SwCSS1Parser::MayBePositioned
static bool MayBePositioned(const SvxCSS1PropertyInfo &rPropInfo, bool bAutoWidth=false)
Definition: htmlcss1.cxx:1420
RES_PARATR_LINESPACING
#define RES_PARATR_LINESPACING
Definition: hintids.hxx:161
SvMemoryStream::GetData
const void * GetData()
SvxULSpaceItem::GetUpper
sal_uInt16 GetUpper() const
SwFormatAnchor::SetAnchor
void SetAnchor(const SwPosition *pPos)
Definition: atrfrm.cxx:1486
URIHelper::SmartRel2Abs
SVL_DLLPUBLIC OUString SmartRel2Abs(INetURLObject const &rTheBaseURIRef, OUString const &rTheRelURIRef, Link< OUString *, bool > const &rMaybeFileHdl=Link< OUString *, bool >(), bool bCheckFileExists=true, bool bIgnoreFragment=false, INetURLObject::EncodeMechanism eEncodeMechanism=INetURLObject::EncodeMechanism::WasEncoded, INetURLObject::DecodeMechanism eDecodeMechanism=INetURLObject::DecodeMechanism::ToIUri, rtl_TextEncoding eCharset=RTL_TEXTENCODING_UTF8, FSysStyle eStyle=FSysStyle::Detect)
Generated on Sat May 18 2019 02:56:40 for LibreOffice Module sw (master) by   doxygen 1.8.10