LibreOffice Module sw (master)  1
txtfrm.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 <hints.hxx>
22 #include <svl/ctloptions.hxx>
23 #include <sfx2/printer.hxx>
24 #include <sfx2/sfxuno.hxx>
25 #include <editeng/langitem.hxx>
26 #include <editeng/lspcitem.hxx>
27 #include <editeng/lrspitem.hxx>
28 #include <editeng/ulspitem.hxx>
29 #include <editeng/brushitem.hxx>
30 #include <editeng/pgrditem.hxx>
31 #include <editeng/rsiditem.hxx>
32 #include <unotools/configmgr.hxx>
33 #include <swmodule.hxx>
34 #include <SwSmartTagMgr.hxx>
35 #include <doc.hxx>
36 #include <IDocumentSettingAccess.hxx>
37 #include <IDocumentDeviceAccess.hxx>
38 #include <IDocumentFieldsAccess.hxx>
39 #include <rootfrm.hxx>
40 #include <pagefrm.hxx>
41 #include <viewsh.hxx>
42 #include <pam.hxx>
43 #include <ndtxt.hxx>
44 #include <txtatr.hxx>
45 #include <paratr.hxx>
46 #include <viewopt.hxx>
47 #include <dflyobj.hxx>
48 #include <flyfrm.hxx>
49 #include <tabfrm.hxx>
50 #include <frmatr.hxx>
51 #include <frmtool.hxx>
52 #include <pagedesc.hxx>
53 #include <tgrditem.hxx>
54 #include <dbg_lay.hxx>
55 #include <fmtfld.hxx>
56 #include <fmtftn.hxx>
57 #include <txtfld.hxx>
58 #include <txtftn.hxx>
59 #include <charatr.hxx>
60 #include <ftninfo.hxx>
61 #include <fmtline.hxx>
62 #include <txtfrm.hxx>
63 #include <notxtfrm.hxx>
64 #include <sectfrm.hxx>
65 #include "itrform2.hxx"
66 #include "widorp.hxx"
67 #include "txtcache.hxx"
68 #include <fntcache.hxx>
69 #include <SwGrammarMarkUp.hxx>
70 #include <lineinfo.hxx>
71 #include <SwPortionHandler.hxx>
72 #include <dcontact.hxx>
73 #include <sortedobjs.hxx>
74 #include <txtflcnt.hxx>
75 #include <fmtflcnt.hxx>
76 #include <fmtcntnt.hxx>
77 #include <numrule.hxx>
78 #include <swtable.hxx>
79 #include <fldupde.hxx>
80 #include <docufld.hxx>
81 #include <IGrammarContact.hxx>
82 #include <calbck.hxx>
83 #include <ftnidx.hxx>
84 #include <ftnfrm.hxx>
85 
86 
87 namespace sw {
88 
89  MergedAttrIterBase::MergedAttrIterBase(SwTextFrame const& rFrame)
90  : m_pMerged(rFrame.GetMergedPara())
91  , m_pNode(m_pMerged ? nullptr : rFrame.GetTextNodeFirst())
92  , m_CurrentExtent(0)
93  , m_CurrentHint(0)
94  {
95  }
96 
97  SwTextAttr const* MergedAttrIter::NextAttr(SwTextNode const** ppNode)
98  {
99  if (m_pMerged)
100  {
101  while (m_CurrentExtent < m_pMerged->extents.size())
102  {
103  sw::Extent const& rExtent(m_pMerged->extents[m_CurrentExtent]);
104  if (SwpHints const*const pHints = rExtent.pNode->GetpSwpHints())
105  {
106  while (m_CurrentHint < pHints->Count())
107  {
108  SwTextAttr *const pHint(pHints->Get(m_CurrentHint));
109  if (rExtent.nEnd < pHint->GetStart()
110  // <= if it has no end or isn't empty
111  || (rExtent.nEnd == pHint->GetStart()
112  && (!pHint->GetEnd()
113  || *pHint->GetEnd() != pHint->GetStart())))
114  {
115  break;
116  }
117  ++m_CurrentHint;
118  if (rExtent.nStart <= pHint->GetStart())
119  {
120  if (ppNode)
121  {
122  *ppNode = rExtent.pNode;
123  }
124  return pHint;
125  }
126  }
127  }
128  ++m_CurrentExtent;
129  if (m_CurrentExtent < m_pMerged->extents.size() &&
130  rExtent.pNode != m_pMerged->extents[m_CurrentExtent].pNode)
131  {
132  m_CurrentHint = 0; // reset
133  }
134  }
135  return nullptr;
136  }
137  else
138  {
139  SwpHints const*const pHints(m_pNode->GetpSwpHints());
140  if (pHints)
141  {
142  if (m_CurrentHint < pHints->Count())
143  {
144  SwTextAttr const*const pHint(pHints->Get(m_CurrentHint));
145  ++m_CurrentHint;
146  if (ppNode)
147  {
148  *ppNode = m_pNode;
149  }
150  return pHint;
151  }
152  }
153  return nullptr;
154  }
155  }
156 
157  MergedAttrIterByEnd::MergedAttrIterByEnd(SwTextFrame const& rFrame)
158  : m_pNode(rFrame.GetMergedPara() ? nullptr : rFrame.GetTextNodeFirst())
159  , m_CurrentHint(0)
160  {
161  if (!m_pNode)
162  {
163  MergedAttrIterReverse iter(rFrame);
164  SwTextNode const* pNode(nullptr);
165  while (SwTextAttr const* pHint = iter.PrevAttr(&pNode))
166  {
167  m_Hints.emplace_back(pNode, pHint);
168  }
169  }
170  }
171 
172  SwTextAttr const* MergedAttrIterByEnd::NextAttr(SwTextNode const*& rpNode)
173  {
174  if (m_pNode)
175  {
176  SwpHints const*const pHints(m_pNode->GetpSwpHints());
177  if (pHints)
178  {
179  if (m_CurrentHint < pHints->Count())
180  {
181  SwTextAttr const*const pHint(
182  pHints->GetSortedByEnd(m_CurrentHint));
183  ++m_CurrentHint;
184  rpNode = m_pNode;
185  return pHint;
186  }
187  }
188  return nullptr;
189  }
190  else
191  {
192  if (m_CurrentHint < m_Hints.size())
193  {
194  auto const ret = m_Hints[m_Hints.size() - m_CurrentHint - 1];
195  ++m_CurrentHint;
196  rpNode = ret.first;
197  return ret.second;
198  }
199  return nullptr;
200  }
201  }
202 
203  void MergedAttrIterByEnd::PrevAttr()
204  {
205  assert(0 < m_CurrentHint); // should only rewind as far as 0
206  --m_CurrentHint;
207  }
208 
209  MergedAttrIterReverse::MergedAttrIterReverse(SwTextFrame const& rFrame)
210  : MergedAttrIterBase(rFrame)
211  {
212  if (m_pMerged)
213  {
214  m_CurrentExtent = m_pMerged->extents.size();
215  SwpHints const*const pHints(0 < m_CurrentExtent
216  ? m_pMerged->extents[m_CurrentExtent-1].pNode->GetpSwpHints()
217  : nullptr);
218  if (pHints)
219  {
220  pHints->SortIfNeedBe();
221  m_CurrentHint = pHints->Count();
222  }
223  }
224  else
225  {
226  if (SwpHints const*const pHints = m_pNode->GetpSwpHints())
227  {
228  pHints->SortIfNeedBe();
229  m_CurrentHint = pHints->Count();
230  }
231  }
232  }
233 
234  SwTextAttr const* MergedAttrIterReverse::PrevAttr(SwTextNode const** ppNode)
235  {
236  if (m_pMerged)
237  {
238  while (0 < m_CurrentExtent)
239  {
240  sw::Extent const& rExtent(m_pMerged->extents[m_CurrentExtent-1]);
241  if (SwpHints const*const pHints = rExtent.pNode->GetpSwpHints())
242  {
243  while (0 < m_CurrentHint)
244  {
245  SwTextAttr *const pHint(
246  pHints->GetSortedByEnd(m_CurrentHint - 1));
247  if (pHint->GetAnyEnd() < rExtent.nStart
248  // <= if it has end and isn't empty
249  || (pHint->GetEnd()
250  && *pHint->GetEnd() != pHint->GetStart()
251  && *pHint->GetEnd() == rExtent.nStart))
252  {
253  break;
254  }
255  --m_CurrentHint;
256  if (pHint->GetAnyEnd() <= rExtent.nEnd)
257  {
258  if (ppNode)
259  {
260  *ppNode = rExtent.pNode;
261  }
262  return pHint;
263  }
264  }
265  }
266  --m_CurrentExtent;
267  if (0 < m_CurrentExtent &&
268  rExtent.pNode != m_pMerged->extents[m_CurrentExtent-1].pNode)
269  {
270  SwpHints const*const pHints(
271  m_pMerged->extents[m_CurrentExtent-1].pNode->GetpSwpHints());
272  m_CurrentHint = pHints ? pHints->Count() : 0; // reset
273  if (pHints)
274  pHints->SortIfNeedBe();
275  }
276  }
277  return nullptr;
278  }
279  else
280  {
281  SwpHints const*const pHints(m_pNode->GetpSwpHints());
282  if (pHints && 0 < m_CurrentHint)
283  {
284  SwTextAttr const*const pHint(pHints->GetSortedByEnd(m_CurrentHint - 1));
285  --m_CurrentHint;
286  if (ppNode)
287  {
288  *ppNode = m_pNode;
289  }
290  return pHint;
291  }
292  return nullptr;
293  }
294  }
295 
296  bool FrameContainsNode(SwContentFrame const& rFrame, sal_uLong const nNodeIndex)
297  {
298  if (rFrame.IsTextFrame())
299  {
300  SwTextFrame const& rTextFrame(static_cast<SwTextFrame const&>(rFrame));
301  if (sw::MergedPara const*const pMerged = rTextFrame.GetMergedPara())
302  {
303  sal_uLong const nFirst(pMerged->pFirstNode->GetIndex());
304  sal_uLong const nLast(pMerged->pLastNode->GetIndex());
305  return (nFirst <= nNodeIndex && nNodeIndex <= nLast);
306  }
307  else
308  {
309  return rTextFrame.GetTextNodeFirst()->GetIndex() == nNodeIndex;
310  }
311  }
312  else
313  {
314  assert(rFrame.IsNoTextFrame());
315  return static_cast<SwNoTextFrame const&>(rFrame).GetNode()->GetIndex() == nNodeIndex;
316  }
317  }
318 
319  bool IsParaPropsNode(SwRootFrame const& rLayout, SwTextNode const& rNode)
320  {
321  if (rLayout.IsHideRedlines())
322  {
323  if (SwTextFrame const*const pFrame = static_cast<SwTextFrame*>(rNode.getLayoutFrame(&rLayout)))
324  {
325  sw::MergedPara const*const pMerged(pFrame->GetMergedPara());
326  if (pMerged && pMerged->pParaPropsNode != &rNode)
327  {
328  return false;
329  }
330  }
331  }
332  return true;
333  }
334 
335  SwTextNode *
336  GetParaPropsNode(SwRootFrame const& rLayout, SwNodeIndex const& rPos)
337  {
338  SwTextNode *const pTextNode(rPos.GetNode().GetTextNode());
339  if (pTextNode && !sw::IsParaPropsNode(rLayout, *pTextNode))
340  {
341  return static_cast<SwTextFrame*>(pTextNode->getLayoutFrame(&rLayout))->GetMergedPara()->pParaPropsNode;
342  }
343  else
344  {
345  return pTextNode;
346  }
347  }
348 
349  SwPosition
350  GetParaPropsPos(SwRootFrame const& rLayout, SwPosition const& rPos)
351  {
352  SwPosition pos(rPos);
353  SwTextNode const*const pNode(pos.nNode.GetNode().GetTextNode());
354  if (pNode)
355  {
356  pos.nNode = *sw::GetParaPropsNode(rLayout, *pNode);
357  pos.nContent.Assign(pos.nNode.GetNode().GetContentNode(), 0);
358  }
359  return pos;
360  }
361 
362  std::pair<SwTextNode *, SwTextNode *>
363  GetFirstAndLastNode(SwRootFrame const& rLayout, SwNodeIndex const& rPos)
364  {
365  SwTextNode *const pTextNode(rPos.GetNode().GetTextNode());
366  if (pTextNode && rLayout.IsHideRedlines())
367  {
368  if (SwTextFrame const*const pFrame = static_cast<SwTextFrame*>(pTextNode->getLayoutFrame(&rLayout)))
369  {
370  if (sw::MergedPara const*const pMerged = pFrame->GetMergedPara())
371  {
372  return std::make_pair(pMerged->pFirstNode, const_cast<SwTextNode*>(pMerged->pLastNode));
373  }
374  }
375  }
376  return std::make_pair(pTextNode, pTextNode);
377  }
378 
379  SwTextNode const& GetAttrMerged(SfxItemSet & rFormatSet,
380  SwTextNode const& rNode, SwRootFrame const*const pLayout)
381  {
382  rNode.SwContentNode::GetAttr(rFormatSet);
383  if (pLayout && pLayout->IsHideRedlines())
384  {
385  auto pFrame = static_cast<SwTextFrame*>(rNode.getLayoutFrame(pLayout));
386  if (sw::MergedPara const*const pMerged = pFrame ? pFrame->GetMergedPara() : nullptr)
387  {
388  if (pMerged->pFirstNode != &rNode)
389  {
390  rFormatSet.ClearItem(RES_PAGEDESC);
391  rFormatSet.ClearItem(RES_BREAK);
392  static_assert(RES_PAGEDESC + 1 == sal_uInt16(RES_BREAK),
393  "first-node items must be adjacent");
394  SfxItemSet firstSet(*rFormatSet.GetPool(),
395  svl::Items<RES_PAGEDESC, RES_BREAK>{});
396  pMerged->pFirstNode->SwContentNode::GetAttr(firstSet);
397  rFormatSet.Put(firstSet);
398 
399  }
400  if (pMerged->pParaPropsNode != &rNode)
401  {
402  for (sal_uInt16 i = RES_PARATR_BEGIN; i != RES_FRMATR_END; ++i)
403  {
404  if (i != RES_PAGEDESC && i != RES_BREAK)
405  {
406  rFormatSet.ClearItem(i);
407  }
408  }
409  for (sal_uInt16 i = XATTR_FILL_FIRST; i <= XATTR_FILL_LAST; ++i)
410  {
411  rFormatSet.ClearItem(i);
412  }
413  SfxItemSet propsSet(*rFormatSet.GetPool(),
414  svl::Items<RES_PARATR_BEGIN, RES_PAGEDESC,
415  RES_BREAK+1, RES_FRMATR_END,
416  XATTR_FILL_FIRST, XATTR_FILL_LAST+1>{});
417  pMerged->pParaPropsNode->SwContentNode::GetAttr(propsSet);
418  rFormatSet.Put(propsSet);
419  return *pMerged->pParaPropsNode;
420  }
421  // keep all the CHRATR/UNKNOWNATR anyway...
422  }
423  }
424  return rNode;
425  }
426 
427 } // namespace sw
428 
430 void SwTextFrame::SwapWidthAndHeight()
431 {
432  {
433  SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*this);
434 
435  if ( ! mbIsSwapped )
436  {
437  const long nPrtOfstX = aPrt.Pos().X();
438  aPrt.Pos().setX( aPrt.Pos().Y() );
439 
440  if( IsVertLR() )
441  {
442  aPrt.Pos().setY( nPrtOfstX );
443  }
444  else
445  {
446  aPrt.Pos().setY( getFrameArea().Width() - ( nPrtOfstX + aPrt.Width() ) );
447  }
448  }
449  else
450  {
451  const long nPrtOfstY = aPrt.Pos().Y();
452  aPrt.Pos().setY( aPrt.Pos().X() );
453 
454  if( IsVertLR() )
455  {
456  aPrt.Pos().setX( nPrtOfstY );
457  }
458  else
459  {
460  aPrt.Pos().setX( getFrameArea().Height() - ( nPrtOfstY + aPrt.Height() ) );
461  }
462  }
463 
464  const long nPrtWidth = aPrt.Width();
465  aPrt.Width( aPrt.Height() );
466  aPrt.Height( nPrtWidth );
467  }
468 
469  {
470  const long nFrameWidth = getFrameArea().Width();
471  SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this);
472  aFrm.Width( aFrm.Height() );
473  aFrm.Height( nFrameWidth );
474  }
475 
476  mbIsSwapped = ! mbIsSwapped;
477 }
478 
483 void SwTextFrame::SwitchHorizontalToVertical( SwRect& rRect ) const
484 {
485  // calc offset inside frame
486  long nOfstX, nOfstY;
487  if ( IsVertLR() )
488  {
489  if (IsVertLRBT())
490  {
491  // X and Y offsets here mean the position of the point that will be the top left corner
492  // after the switch.
493  nOfstX = rRect.Left() + rRect.Width() - getFrameArea().Left();
494  nOfstY = rRect.Top() - getFrameArea().Top();
495  }
496  else
497  {
498  nOfstX = rRect.Left() - getFrameArea().Left();
499  nOfstY = rRect.Top() - getFrameArea().Top();
500  }
501  }
502  else
503  {
504  nOfstX = rRect.Left() - getFrameArea().Left();
505  nOfstY = rRect.Top() + rRect.Height() - getFrameArea().Top();
506  }
507 
508  const long nWidth = rRect.Width();
509  const long nHeight = rRect.Height();
510 
511  if ( IsVertLR() )
512  {
513  rRect.Left(getFrameArea().Left() + nOfstY);
514  }
515  else
516  {
517  if ( mbIsSwapped )
518  rRect.Left( getFrameArea().Left() + getFrameArea().Height() - nOfstY );
519  else
520  // frame is rotated
521  rRect.Left( getFrameArea().Left() + getFrameArea().Width() - nOfstY );
522  }
523 
524  if (IsVertLRBT())
525  {
526  if (mbIsSwapped)
527  rRect.Top(getFrameArea().Top() + getFrameArea().Width() - nOfstX);
528  else
529  rRect.Top(getFrameArea().Top() + getFrameArea().Height() - nOfstX);
530  }
531  else
532  rRect.Top(getFrameArea().Top() + nOfstX);
533  rRect.Width( nHeight );
534  rRect.Height( nWidth );
535 }
536 
541 void SwTextFrame::SwitchHorizontalToVertical( Point& rPoint ) const
542 {
543  if (IsVertLRBT())
544  {
545  // The horizontal origo is the top left corner, the LRBT origo is the
546  // bottom left corner. Finally x and y has to be swapped.
547  SAL_WARN_IF(!mbIsSwapped, "sw.core",
548  "SwTextFrame::SwitchHorizontalToVertical, IsVertLRBT, not swapped");
549  Point aPoint(rPoint);
550  rPoint.setX(getFrameArea().Left() + (aPoint.Y() - getFrameArea().Top()));
551  // This would be bottom - x delta, but bottom is top + height, finally
552  // width (and not height), as it's swapped.
553  rPoint.setY(getFrameArea().Top() + getFrameArea().Width()
554  - (aPoint.X() - getFrameArea().Left()));
555  return;
556  }
557 
558  // calc offset inside frame
559  const long nOfstX = rPoint.X() - getFrameArea().Left();
560  const long nOfstY = rPoint.Y() - getFrameArea().Top();
561  if ( IsVertLR() )
562  rPoint.setX( getFrameArea().Left() + nOfstY );
563  else
564  {
565  if ( mbIsSwapped )
566  rPoint.setX( getFrameArea().Left() + getFrameArea().Height() - nOfstY );
567  else
568  // calc rotated coords
569  rPoint.setX( getFrameArea().Left() + getFrameArea().Width() - nOfstY );
570  }
571 
572  rPoint.setY( getFrameArea().Top() + nOfstX );
573 }
574 
579 long SwTextFrame::SwitchHorizontalToVertical( long nLimit ) const
580 {
581  Point aTmp( 0, nLimit );
582  SwitchHorizontalToVertical( aTmp );
583  return aTmp.X();
584 }
585 
590 void SwTextFrame::SwitchVerticalToHorizontal( SwRect& rRect ) const
591 {
592  long nOfstX;
593 
594  // calc offset inside frame
595  if ( IsVertLR() )
596  nOfstX = rRect.Left() - getFrameArea().Left();
597  else
598  {
599  if ( mbIsSwapped )
600  nOfstX = getFrameArea().Left() + getFrameArea().Height() - ( rRect.Left() + rRect.Width() );
601  else
602  nOfstX = getFrameArea().Left() + getFrameArea().Width() - ( rRect.Left() + rRect.Width() );
603  }
604 
605  long nOfstY;
606  if (IsVertLRBT())
607  {
608  // Note that mbIsSwapped only affects the frame area, not rRect, so rRect.Height() is used
609  // here unconditionally.
610  if (mbIsSwapped)
611  nOfstY = getFrameArea().Top() + getFrameArea().Width() - (rRect.Top() + rRect.Height());
612  else
613  nOfstY = getFrameArea().Top() + getFrameArea().Height() - (rRect.Top() + rRect.Height());
614  }
615  else
616  nOfstY = rRect.Top() - getFrameArea().Top();
617  const long nWidth = rRect.Height();
618  const long nHeight = rRect.Width();
619 
620  // calc rotated coords
621  rRect.Left( getFrameArea().Left() + nOfstY );
622  rRect.Top( getFrameArea().Top() + nOfstX );
623  rRect.Width( nWidth );
624  rRect.Height( nHeight );
625 }
626 
631 void SwTextFrame::SwitchVerticalToHorizontal( Point& rPoint ) const
632 {
633  long nOfstX;
634 
635  // calc offset inside frame
636  if ( IsVertLR() )
637  // X offset is Y - left.
638  nOfstX = rPoint.X() - getFrameArea().Left();
639  else
640  {
641  // X offset is right - X.
642  if ( mbIsSwapped )
643  nOfstX = getFrameArea().Left() + getFrameArea().Height() - rPoint.X();
644  else
645  nOfstX = getFrameArea().Left() + getFrameArea().Width() - rPoint.X();
646  }
647 
648  long nOfstY;
649  if (IsVertLRBT())
650  {
651  // Y offset is bottom - Y.
652  if (mbIsSwapped)
653  nOfstY = getFrameArea().Top() + getFrameArea().Width() - rPoint.Y();
654  else
655  nOfstY = getFrameArea().Top() + getFrameArea().Height() - rPoint.Y();
656  }
657  else
658  // Y offset is Y - top.
659  nOfstY = rPoint.Y() - getFrameArea().Top();
660 
661  // calc rotated coords
662  rPoint.setX( getFrameArea().Left() + nOfstY );
663  rPoint.setY( getFrameArea().Top() + nOfstX );
664 }
665 
670 long SwTextFrame::SwitchVerticalToHorizontal( long nLimit ) const
671 {
672  Point aTmp( nLimit, 0 );
673  SwitchVerticalToHorizontal( aTmp );
674  return aTmp.Y();
675 }
676 
677 SwFrameSwapper::SwFrameSwapper( const SwTextFrame* pTextFrame, bool bSwapIfNotSwapped )
678  : pFrame( pTextFrame ), bUndo( false )
679 {
680  if (pFrame->IsVertical() && bSwapIfNotSwapped != pFrame->IsSwapped())
681  {
682  bUndo = true;
683  const_cast<SwTextFrame*>(pFrame)->SwapWidthAndHeight();
684  }
685 }
686 
687 SwFrameSwapper::~SwFrameSwapper()
688 {
689  if ( bUndo )
690  const_cast<SwTextFrame*>(pFrame)->SwapWidthAndHeight();
691 }
692 
693 void SwTextFrame::SwitchLTRtoRTL( SwRect& rRect ) const
694 {
695  SwSwapIfNotSwapped swap(const_cast<SwTextFrame *>(this));
696 
697  long nWidth = rRect.Width();
698  rRect.Left( 2 * ( getFrameArea().Left() + getFramePrintArea().Left() ) +
699  getFramePrintArea().Width() - rRect.Right() - 1 );
700 
701  rRect.Width( nWidth );
702 }
703 
704 void SwTextFrame::SwitchLTRtoRTL( Point& rPoint ) const
705 {
706  SwSwapIfNotSwapped swap(const_cast<SwTextFrame *>(this));
707 
708  rPoint.setX( 2 * ( getFrameArea().Left() + getFramePrintArea().Left() ) + getFramePrintArea().Width() - rPoint.X() - 1 );
709 }
710 
711 SwLayoutModeModifier::SwLayoutModeModifier( const OutputDevice& rOutp ) :
712  m_rOut( rOutp ), m_nOldLayoutMode( rOutp.GetLayoutMode() )
713 {
714 }
715 
716 SwLayoutModeModifier::~SwLayoutModeModifier()
717 {
718  const_cast<OutputDevice&>(m_rOut).SetLayoutMode( m_nOldLayoutMode );
719 }
720 
721 void SwLayoutModeModifier::Modify( bool bChgToRTL )
722 {
723  const_cast<OutputDevice&>(m_rOut).SetLayoutMode( bChgToRTL ?
724  ComplexTextLayoutFlags::BiDiStrong | ComplexTextLayoutFlags::BiDiRtl :
725  ComplexTextLayoutFlags::BiDiStrong );
726 }
727 
728 void SwLayoutModeModifier::SetAuto()
729 {
730  const ComplexTextLayoutFlags nNewLayoutMode = m_nOldLayoutMode & ~ComplexTextLayoutFlags::BiDiStrong;
731  const_cast<OutputDevice&>(m_rOut).SetLayoutMode( nNewLayoutMode );
732 }
733 
734 SwDigitModeModifier::SwDigitModeModifier( const OutputDevice& rOutp, LanguageType eCurLang ) :
735  rOut( rOutp ), nOldLanguageType( rOutp.GetDigitLanguage() )
736 {
737  LanguageType eLang = eCurLang;
738  if (utl::ConfigManager::IsFuzzing())
739  eLang = LANGUAGE_ENGLISH_US;
740  else
741  {
742  const SvtCTLOptions::TextNumerals nTextNumerals = SW_MOD()->GetCTLOptions().GetCTLTextNumerals();
743 
744  if ( SvtCTLOptions::NUMERALS_HINDI == nTextNumerals )
745  eLang = LANGUAGE_ARABIC_SAUDI_ARABIA;
746  else if ( SvtCTLOptions::NUMERALS_ARABIC == nTextNumerals )
747  eLang = LANGUAGE_ENGLISH;
748  else if ( SvtCTLOptions::NUMERALS_SYSTEM == nTextNumerals )
749  eLang = ::GetAppLanguage();
750  }
751 
752  const_cast<OutputDevice&>(rOut).SetDigitLanguage( eLang );
753 }
754 
755 SwDigitModeModifier::~SwDigitModeModifier()
756 {
757  const_cast<OutputDevice&>(rOut).SetDigitLanguage( nOldLanguageType );
758 }
759 
760 void SwTextFrame::Init()
761 {
762  OSL_ENSURE( !IsLocked(), "+SwTextFrame::Init: this is locked." );
763  if( !IsLocked() )
764  {
765  ClearPara();
766  ResetBlinkPor();
767  // set flags directly to save a ResetPreps call,
768  // and thereby an unnecessary GetPara call
769  // don't set bOrphan, bLocked or bWait to false!
770  // bOrphan = bFlag7 = bFlag8 = false;
771  }
772 }
773 
774 SwTextFrame::SwTextFrame(SwTextNode * const pNode, SwFrame* pSib,
775  sw::FrameMode const eMode)
776  : SwContentFrame( pNode, pSib )
777  , mnAllLines( 0 )
778  , mnThisLines( 0 )
779  , mnFlyAnchorOfst( 0 )
780  , mnFlyAnchorOfstNoWrap( 0 )
781  , mnFlyAnchorVertOfstNoWrap( 0 )
782  , mnFootnoteLine( 0 )
783  , mnHeightOfLastLine( 0 )
784  , mnAdditionalFirstLineOffset( 0 )
785  , mnOffset( 0 )
786  , mnCacheIndex( USHRT_MAX )
787  , mbLocked( false )
788  , mbWidow( false )
789  , mbJustWidow( false )
790  , mbEmpty( false )
791  , mbInFootnoteConnect( false )
792  , mbFootnote( false )
793  , mbRepaint( false )
794  , mbHasBlinkPortions( false )
795  , mbFieldFollow( false )
796  , mbHasAnimation( false )
797  , mbIsSwapped( false )
798  , mbFollowFormatAllowed( true )
799 {
800  mnFrameType = SwFrameType::Txt;
801  // note: this may call SwClientNotify if it's in a list so do it last
802  // note: this may change this->pRegisteredIn to m_pMergedPara->listeners
803  m_pMergedPara = CheckParaRedlineMerge(*this, *pNode, eMode);
804 }
805 
806 namespace sw {
807 
808 SwTextFrame * MakeTextFrame(SwTextNode & rNode, SwFrame *const pSibling,
809  sw::FrameMode const eMode)
810 {
811  return new SwTextFrame(&rNode, pSibling, eMode);
812 }
813 
814 void RemoveFootnotesForNode(
815  SwRootFrame const& rLayout, SwTextNode const& rTextNode,
816  std::vector<std::pair<sal_Int32, sal_Int32>> const*const pExtents)
817 {
818  if (pExtents && pExtents->empty())
819  {
820  return; // nothing to do
821  }
822  const SwFootnoteIdxs &rFootnoteIdxs = rTextNode.GetDoc()->GetFootnoteIdxs();
823  size_t nPos = 0;
824  sal_uLong const nIndex = rTextNode.GetIndex();
825  rFootnoteIdxs.SeekEntry( rTextNode, &nPos );
826  if (nPos < rFootnoteIdxs.size())
827  {
828  while (nPos && &rTextNode == &(rFootnoteIdxs[ nPos ]->GetTextNode()))
829  --nPos;
830  if (nPos || &rTextNode != &(rFootnoteIdxs[ nPos ]->GetTextNode()))
831  ++nPos;
832  }
833  size_t iter(0);
834  for ( ; nPos < rFootnoteIdxs.size(); ++nPos)
835  {
836  SwTextFootnote* pTextFootnote = rFootnoteIdxs[ nPos ];
837  if (pTextFootnote->GetTextNode().GetIndex() > nIndex)
838  break;
839  if (pExtents)
840  {
841  while ((*pExtents)[iter].second <= pTextFootnote->GetStart())
842  {
843  ++iter;
844  if (iter == pExtents->size())
845  {
846  return;
847  }
848  }
849  if (pTextFootnote->GetStart() < (*pExtents)[iter].first)
850  {
851  continue;
852  }
853  }
854  pTextFootnote->DelFrames(&rLayout);
855  }
856 }
857 
858 } // namespace sw
859 
860 void SwTextFrame::DestroyImpl()
861 {
862  // Remove associated SwParaPortion from s_pTextCache
863  ClearPara();
864 
865  assert(!GetDoc().IsInDtor()); // this shouldn't be happening with ViewShell owning layout
866  if (!GetDoc().IsInDtor() && HasFootnote())
867  {
868  if (m_pMergedPara)
869  {
870  SwTextNode const* pNode(nullptr);
871  for (auto const& e : m_pMergedPara->extents)
872  {
873  if (e.pNode != pNode)
874  {
875  pNode = e.pNode;
876  // sw_redlinehide: not sure if it's necessary to check
877  // if the nodes are still alive here, which would require
878  // accessing WriterMultiListener::m_vDepends
879  sw::RemoveFootnotesForNode(*getRootFrame(), *pNode, nullptr);
880  }
881  }
882  }
883  else
884  {
885  SwTextNode *const pNode(static_cast<SwTextNode*>(GetDep()));
886  if (pNode)
887  {
888  sw::RemoveFootnotesForNode(*getRootFrame(), *pNode, nullptr);
889  }
890  }
891  }
892 
893  SwContentFrame::DestroyImpl();
894 }
895 
896 SwTextFrame::~SwTextFrame()
897 {
898  RemoveFromCache();
899 }
900 
901 namespace sw {
902 
903 // 1. if real insert => correct nStart/nEnd for full nLen
904 // 2. if rl un-delete => do not correct nStart/nEnd but just include un-deleted
905 static TextFrameIndex UpdateMergedParaForInsert(MergedPara & rMerged,
906  bool const isRealInsert,
907  SwTextNode const& rNode, sal_Int32 const nIndex, sal_Int32 const nLen)
908 {
909  assert(!isRealInsert || nLen); // can 0 happen? yes, for redline in empty node
910  assert(nIndex <= rNode.Len());
911  assert(nIndex + nLen <= rNode.Len());
912  assert(rMerged.pFirstNode->GetIndex() <= rNode.GetIndex() && rNode.GetIndex() <= rMerged.pLastNode->GetIndex());
913  if (!nLen)
914  {
915  return TextFrameIndex(0);
916  }
917  OUStringBuffer text(rMerged.mergedText);
918  sal_Int32 nTFIndex(0); // index used for insertion at the end
919  sal_Int32 nInserted(0);
920  bool bInserted(false);
921  bool bFoundNode(false);
922  auto itInsert(rMerged.extents.end());
923  for (auto it = rMerged.extents.begin(); it != rMerged.extents.end(); ++it)
924  {
925  if (it->pNode == &rNode)
926  {
927  if (isRealInsert)
928  {
929  bFoundNode = true;
930  if (it->nStart <= nIndex && nIndex <= it->nEnd)
931  { // note: this can happen only once
932  text.insert(nTFIndex + (nIndex - it->nStart),
933  rNode.GetText().copy(nIndex, nLen));
934  it->nEnd += nLen;
935  nInserted = nLen;
936  assert(!bInserted);
937  bInserted = true;
938  }
939  else if (nIndex < it->nStart)
940  {
941  if (itInsert == rMerged.extents.end())
942  {
943  itInsert = it;
944  }
945  it->nStart += nLen;
946  it->nEnd += nLen;
947  }
948  }
949  else
950  {
951  assert(it == rMerged.extents.begin() || (it-1)->pNode != &rNode || (it-1)->nEnd < nIndex);
952  if (nIndex + nLen < it->nStart)
953  {
954  itInsert = it;
955  break;
956  }
957  if (nIndex < it->nStart)
958  {
959  text.insert(nTFIndex,
960  rNode.GetText().copy(nIndex, it->nStart - nIndex));
961  nInserted += it->nStart - nIndex;
962  it->nStart = nIndex;
963  bInserted = true;
964  }
965  assert(it->nStart <= nIndex);
966  if (nIndex <= it->nEnd)
967  {
968  nTFIndex += it->nEnd - it->nStart;
969  while (it->nEnd < nIndex + nLen)
970  {
971  auto *const pNext(
972  (it+1) != rMerged.extents.end() && (it+1)->pNode == it->pNode
973  ? &*(it+1)
974  : nullptr);
975  if (pNext && pNext->nStart <= nIndex + nLen)
976  {
977  text.insert(nTFIndex,
978  rNode.GetText().copy(it->nEnd, pNext->nStart - it->nEnd));
979  nTFIndex += pNext->nStart - it->nEnd;
980  nInserted += pNext->nStart - it->nEnd;
981  pNext->nStart = it->nStart;
982  it = rMerged.extents.erase(it);
983  }
984  else
985  {
986  text.insert(nTFIndex,
987  rNode.GetText().copy(it->nEnd, nIndex + nLen - it->nEnd));
988  nTFIndex += nIndex + nLen - it->nEnd;
989  nInserted += nIndex + nLen - it->nEnd;
990  it->nEnd = nIndex + nLen;
991  }
992  }
993  bInserted = true;
994  break;
995  }
996  }
997  }
998  else if (rNode.GetIndex() < it->pNode->GetIndex() || bFoundNode)
999  {
1000  if (itInsert == rMerged.extents.end())
1001  {
1002  itInsert = it;
1003  }
1004  break;
1005  }
1006  if (itInsert == rMerged.extents.end())
1007  {
1008  nTFIndex += it->nEnd - it->nStart;
1009  }
1010  }
1011 // assert((bFoundNode || rMerged.extents.empty()) && "text node not found - why is it sending hints to us");
1012  if (!bInserted)
1013  { // must be in a gap
1014  rMerged.extents.emplace(itInsert, const_cast<SwTextNode*>(&rNode), nIndex, nIndex + nLen);
1015  text.insert(nTFIndex, rNode.GetText().copy(nIndex, nLen));
1016  nInserted = nLen;
1017  if (rMerged.extents.size() == 1 // also if it was empty!
1018  || rMerged.pParaPropsNode->GetIndex() < rNode.GetIndex())
1019  { // text inserted after current para-props node
1020  rMerged.pParaPropsNode->RemoveFromListRLHidden();
1021  rMerged.pParaPropsNode = &const_cast<SwTextNode&>(rNode);
1022  rMerged.pParaPropsNode->AddToListRLHidden();
1023  }
1024  }
1025  rMerged.mergedText = text.makeStringAndClear();
1026  return TextFrameIndex(nInserted);
1027 }
1028 
1029 // 1. if real delete => correct nStart/nEnd for full nLen
1030 // 2. if rl delete => do not correct nStart/nEnd but just exclude deleted
1031 TextFrameIndex UpdateMergedParaForDelete(MergedPara & rMerged,
1032  bool const isRealDelete,
1033  SwTextNode const& rNode, sal_Int32 nIndex, sal_Int32 const nLen)
1034 {
1035  assert(nIndex <= rNode.Len());
1036  assert(rMerged.pFirstNode->GetIndex() <= rNode.GetIndex() && rNode.GetIndex() <= rMerged.pLastNode->GetIndex());
1037  OUStringBuffer text(rMerged.mergedText);
1038  sal_Int32 nTFIndex(0);
1039  sal_Int32 nToDelete(nLen);
1040  sal_Int32 nDeleted(0);
1041  size_t nFoundNode(0);
1042  size_t nErased(0);
1043  auto it = rMerged.extents.begin();
1044  for (; it != rMerged.extents.end(); )
1045  {
1046  bool bErase(false);
1047  if (it->pNode == &rNode)
1048  {
1049  ++nFoundNode;
1050  if (nIndex + nToDelete < it->nStart)
1051  {
1052  nToDelete = 0;
1053  if (!isRealDelete)
1054  {
1055  break;
1056  }
1057  it->nStart -= nLen;
1058  it->nEnd -= nLen;
1059  }
1060  else
1061  {
1062  if (nIndex < it->nStart)
1063  {
1064  // do not adjust nIndex into the text frame index space!
1065  nToDelete -= it->nStart - nIndex;
1066  nIndex = it->nStart;
1067  // note: continue with the if check below, no else!
1068  }
1069  if (it->nStart <= nIndex && nIndex < it->nEnd)
1070  {
1071  sal_Int32 const nDeleteHere(nIndex + nToDelete <= it->nEnd
1072  ? nToDelete
1073  : it->nEnd - nIndex);
1074  text.remove(nTFIndex + (nIndex - it->nStart), nDeleteHere);
1075  bErase = nDeleteHere == it->nEnd - it->nStart;
1076  if (bErase)
1077  {
1078  ++nErased;
1079  assert(it->nStart == nIndex);
1080  it = rMerged.extents.erase(it);
1081  }
1082  else if (isRealDelete)
1083  { // adjust for deleted text
1084  it->nStart -= (nLen - nToDelete);
1085  it->nEnd -= (nLen - nToDelete + nDeleteHere);
1086  if (it != rMerged.extents.begin()
1087  && (it-1)->pNode == &rNode
1088  && (it-1)->nEnd == it->nStart)
1089  { // merge adjacent extents
1090  nTFIndex += it->nEnd - it->nStart;
1091  (it-1)->nEnd = it->nEnd;
1092  it = rMerged.extents.erase(it);
1093  bErase = true; // skip increment
1094  }
1095  }
1096  else
1097  { // exclude text marked as deleted
1098  if (nIndex + nDeleteHere == it->nEnd)
1099  {
1100  it->nEnd -= nDeleteHere;
1101  }
1102  else
1103  {
1104  if (nIndex == it->nStart)
1105  {
1106  it->nStart += nDeleteHere;
1107  }
1108  else
1109  {
1110  sal_Int32 const nOldEnd(it->nEnd);
1111  it->nEnd = nIndex;
1112  it = rMerged.extents.emplace(it+1,
1113  it->pNode, nIndex + nDeleteHere, nOldEnd);
1114  }
1115  assert(nDeleteHere == nToDelete);
1116  }
1117  }
1118  nDeleted += nDeleteHere;
1119  nToDelete -= nDeleteHere;
1120  nIndex += nDeleteHere;
1121  if (!isRealDelete && nToDelete == 0)
1122  {
1123  break;
1124  }
1125  }
1126  }
1127  }
1128  else if (nFoundNode != 0)
1129  {
1130  break;
1131  }
1132  if (!bErase)
1133  {
1134  nTFIndex += it->nEnd - it->nStart;
1135  ++it;
1136  }
1137  }
1138 // assert(nFoundNode != 0 && "text node not found - why is it sending hints to us");
1139  assert(nIndex <= rNode.Len() + nLen);
1140  // if there's a remaining deletion, it must be in gap at the end of the node
1141 // can't do: might be last one in node was erased assert(nLen == 0 || rMerged.empty() || (it-1)->nEnd <= nIndex);
1142  // note: if first node gets deleted then that must call DelFrames as
1143  // pFirstNode is never updated
1144  if (nErased && nErased == nFoundNode)
1145  { // all visible text from node was erased
1146 #if 1
1147  if (rMerged.pParaPropsNode == &rNode)
1148  {
1149  rMerged.pParaPropsNode->RemoveFromListRLHidden();
1150  rMerged.pParaPropsNode = rMerged.extents.empty()
1151  ? const_cast<SwTextNode*>(rMerged.pLastNode)
1152  : rMerged.extents.front().pNode;
1153  rMerged.pParaPropsNode->AddToListRLHidden();
1154  }
1155 #endif
1156 // NOPE must listen on all non-hidden nodes; particularly on pLastNode rMerged.listener.EndListening(&const_cast<SwTextNode&>(rNode));
1157  }
1158  rMerged.mergedText = text.makeStringAndClear();
1159  return TextFrameIndex(nDeleted);
1160 }
1161 
1162 std::pair<SwTextNode*, sal_Int32>
1163 MapViewToModel(MergedPara const& rMerged, TextFrameIndex const i_nIndex)
1164 {
1165  sal_Int32 nIndex(i_nIndex);
1166  sw::Extent const* pExtent(nullptr);
1167  for (const auto& rExt : rMerged.extents)
1168  {
1169  pExtent = &rExt;
1170  if (nIndex < (pExtent->nEnd - pExtent->nStart))
1171  {
1172  return std::make_pair(pExtent->pNode, pExtent->nStart + nIndex);
1173  }
1174  nIndex = nIndex - (pExtent->nEnd - pExtent->nStart);
1175  }
1176  assert(nIndex == 0 && "view index out of bounds");
1177  return pExtent
1178  ? std::make_pair(pExtent->pNode, pExtent->nEnd) //1-past-the-end index
1179  : std::make_pair(rMerged.pFirstNode, sal_Int32(0));
1180 }
1181 
1182 TextFrameIndex MapModelToView(MergedPara const& rMerged, SwTextNode const*const pNode, sal_Int32 const nIndex)
1183 {
1184  assert(rMerged.pFirstNode->GetIndex() <= pNode->GetIndex()
1185  && pNode->GetIndex() <= rMerged.pLastNode->GetIndex());
1186  sal_Int32 nRet(0);
1187  bool bFoundNode(false);
1188  for (auto const& e : rMerged.extents)
1189  {
1190  if (pNode->GetIndex() < e.pNode->GetIndex())
1191  {
1192  return TextFrameIndex(nRet);
1193  }
1194  if (e.pNode == pNode)
1195  {
1196  if (e.nStart <= nIndex && nIndex <= e.nEnd)
1197  {
1198  return TextFrameIndex(nRet + (nIndex - e.nStart));
1199  }
1200  else if (nIndex < e.nStart)
1201  {
1202  // in gap before this extent => map to 0 here TODO???
1203  return TextFrameIndex(nRet);
1204  }
1205  bFoundNode = true;
1206  }
1207  else if (bFoundNode)
1208  {
1209  break;
1210  }
1211  nRet += e.nEnd - e.nStart;
1212  }
1213  if (bFoundNode)
1214  {
1215  // must be in a gap at the end of the node
1216  assert(nIndex <= pNode->Len());
1217  return TextFrameIndex(nRet);
1218  }
1219  else if (rMerged.extents.empty())
1220  {
1221  assert(nIndex <= pNode->Len());
1222  return TextFrameIndex(0);
1223  }
1224  return TextFrameIndex(rMerged.mergedText.getLength());
1225 }
1226 
1227 } // namespace sw
1228 
1229 std::pair<SwTextNode*, sal_Int32>
1230 SwTextFrame::MapViewToModel(TextFrameIndex const nIndex) const
1231 {
1232 //nope assert(GetPara());
1233  sw::MergedPara const*const pMerged(GetMergedPara());
1234  if (pMerged)
1235  {
1236  return sw::MapViewToModel(*pMerged, nIndex);
1237  }
1238  else
1239  {
1240  return std::make_pair(static_cast<SwTextNode*>(const_cast<SwModify*>(
1241  SwFrame::GetDep())), sal_Int32(nIndex));
1242  }
1243 }
1244 
1245 SwPosition SwTextFrame::MapViewToModelPos(TextFrameIndex const nIndex) const
1246 {
1247  std::pair<SwTextNode*, sal_Int32> const ret(MapViewToModel(nIndex));
1248  return SwPosition(*ret.first, ret.second);
1249 }
1250 
1251 TextFrameIndex SwTextFrame::MapModelToView(SwTextNode const*const pNode, sal_Int32 const nIndex) const
1252 {
1253 //nope assert(GetPara());
1254  sw::MergedPara const*const pMerged(GetMergedPara());
1255  if (pMerged)
1256  {
1257  return sw::MapModelToView(*pMerged, pNode, nIndex);
1258  }
1259  else
1260  {
1261  assert(static_cast<SwTextNode*>(const_cast<SwModify*>(SwFrame::GetDep())) == pNode);
1262  return TextFrameIndex(nIndex);
1263  }
1264 }
1265 
1266 TextFrameIndex SwTextFrame::MapModelToViewPos(SwPosition const& rPos) const
1267 {
1268  SwTextNode const*const pNode(rPos.nNode.GetNode().GetTextNode());
1269  sal_Int32 const nIndex(rPos.nContent.GetIndex());
1270  return MapModelToView(pNode, nIndex);
1271 }
1272 
1273 void SwTextFrame::SetMergedPara(std::unique_ptr<sw::MergedPara> p)
1274 {
1275  SwTextNode *const pFirst(m_pMergedPara ? m_pMergedPara->pFirstNode : nullptr);
1276  m_pMergedPara = std::move(p);
1277  if (pFirst)
1278  {
1279  if (m_pMergedPara)
1280  {
1281  assert(pFirst == m_pMergedPara->pFirstNode);
1282  }
1283  else
1284  {
1285  pFirst->Add(this); // must register at node again
1286  }
1287  }
1288 }
1289 
1290 const OUString& SwTextFrame::GetText() const
1291 {
1292 //nope assert(GetPara());
1293  sw::MergedPara const*const pMerged(GetMergedPara());
1294  if (pMerged)
1295  return pMerged->mergedText;
1296  else
1297  return static_cast<SwTextNode const*>(SwFrame::GetDep())->GetText();
1298 }
1299 
1300 SwTextNode const* SwTextFrame::GetTextNodeForParaProps() const
1301 {
1302  // FIXME can GetPara be 0 ? yes... this is needed in SwContentNotify::SwContentNotify() which is called before any formatting is started
1303 //nope assert(GetPara());
1304  sw::MergedPara const*const pMerged(GetMergedPara());
1305  if (pMerged)
1306  {
1307 // assert(pMerged->pFirstNode == pMerged->pParaPropsNode); // surprising news!
1308  return pMerged->pParaPropsNode;
1309  }
1310  else
1311  return static_cast<SwTextNode const*>(SwFrame::GetDep());
1312 }
1313 
1314 SwTextNode const* SwTextFrame::GetTextNodeForFirstText() const
1315 {
1316  sw::MergedPara const*const pMerged(GetMergedPara());
1317  if (pMerged)
1318  return pMerged->extents.empty()
1319  ? pMerged->pFirstNode
1320  : pMerged->extents.front().pNode;
1321  else
1322  return static_cast<SwTextNode const*>(SwFrame::GetDep());
1323 }
1324 
1325 SwTextNode const* SwTextFrame::GetTextNodeFirst() const
1326 {
1327 //nope assert(GetPara());
1328  sw::MergedPara const*const pMerged(GetMergedPara());
1329  if (pMerged)
1330  return pMerged->pFirstNode;
1331  else
1332  return static_cast<SwTextNode const*>(SwFrame::GetDep());
1333 }
1334 
1335 SwDoc const& SwTextFrame::GetDoc() const
1336 {
1337  return *GetTextNodeFirst()->GetDoc();
1338 }
1339 
1340 LanguageType SwTextFrame::GetLangOfChar(TextFrameIndex const nIndex,
1341  sal_uInt16 const nScript, bool const bNoChar) const
1342 {
1343  // a single character can be mapped uniquely!
1344  std::pair<SwTextNode const*, sal_Int32> const pos(MapViewToModel(nIndex));
1345  return pos.first->GetLang(pos.second, bNoChar ? 0 : 1, nScript);
1346 }
1347 
1348 void SwTextFrame::ResetPreps()
1349 {
1350  if ( GetCacheIdx() != USHRT_MAX )
1351  {
1352  if (SwParaPortion *pPara = GetPara())
1353  pPara->ResetPreps();
1354  }
1355 }
1356 
1357 bool SwTextFrame::IsHiddenNow() const
1358 {
1359  SwFrameSwapper aSwapper( this, true );
1360 
1361  if( !getFrameArea().Width() && isFrameAreaDefinitionValid() && GetUpper()->isFrameAreaDefinitionValid() ) // invalid when stack overflows (StackHack)!
1362  {
1363 // OSL_FAIL( "SwTextFrame::IsHiddenNow: thin frame" );
1364  return true;
1365  }
1366 
1367  bool bHiddenCharsHidePara(false);
1368  bool bHiddenParaField(false);
1369  if (m_pMergedPara)
1370  {
1371  TextFrameIndex nHiddenStart(COMPLETE_STRING);
1372  TextFrameIndex nHiddenEnd(0);
1373  if (auto const pScriptInfo = GetScriptInfo())
1374  {
1375  pScriptInfo->GetBoundsOfHiddenRange(TextFrameIndex(0),
1376  nHiddenStart, nHiddenEnd);
1377  }
1378  else // ParaPortion is created in Format, but this is called earlier
1379  {
1380  SwScriptInfo aInfo;
1381  aInfo.InitScriptInfo(*m_pMergedPara->pFirstNode, m_pMergedPara.get(), IsRightToLeft());
1382  aInfo.GetBoundsOfHiddenRange(TextFrameIndex(0),
1383  nHiddenStart, nHiddenEnd);
1384  }
1385  if (TextFrameIndex(0) == nHiddenStart &&
1386  TextFrameIndex(GetText().getLength()) <= nHiddenEnd)
1387  {
1388  bHiddenCharsHidePara = true;
1389  }
1390  sw::MergedAttrIter iter(*this);
1391  SwTextNode const* pNode(nullptr);
1392  int nNewResultWeight = 0;
1393  for (SwTextAttr const* pHint = iter.NextAttr(&pNode); pHint; pHint = iter.NextAttr(&pNode))
1394  {
1395  if (pHint->Which() == RES_TXTATR_FIELD)
1396  {
1397  // see also SwpHints::CalcHiddenParaField()
1398  const SwFormatField& rField = pHint->GetFormatField();
1399  int nCurWeight = pNode->FieldCanHideParaWeight(rField.GetField()->GetTyp()->Which());
1400  if (nCurWeight > nNewResultWeight)
1401  {
1402  nNewResultWeight = nCurWeight;
1403  bHiddenParaField = pNode->FieldHidesPara(*rField.GetField());
1404  }
1405  else if (nCurWeight == nNewResultWeight && bHiddenParaField)
1406  {
1407  // Currently, for both supported hiding types (HiddenPara, Database), "Don't hide"
1408  // takes precedence - i.e., if there's a "Don't hide" field of that weight, we only
1409  // care about fields of higher weight.
1410  bHiddenParaField = pNode->FieldHidesPara(*rField.GetField());
1411  }
1412  }
1413  }
1414  }
1415  else
1416  {
1417  bHiddenCharsHidePara = static_cast<SwTextNode const*>(SwFrame::GetDep())->HasHiddenCharAttribute( true );
1418  bHiddenParaField = static_cast<SwTextNode const*>(SwFrame::GetDep())->IsHiddenByParaField();
1419  }
1420  const SwViewShell* pVsh = getRootFrame()->GetCurrShell();
1421 
1422  if ( pVsh && ( bHiddenCharsHidePara || bHiddenParaField ) )
1423  {
1424 
1425  if (
1426  ( bHiddenParaField &&
1427  ( !pVsh->GetViewOptions()->IsShowHiddenPara() &&
1428  !pVsh->GetViewOptions()->IsFieldName() ) ) ||
1429  ( bHiddenCharsHidePara &&
1430  !pVsh->GetViewOptions()->IsShowHiddenChar() ) )
1431  {
1432  return true;
1433  }
1434  }
1435 
1436  return false;
1437 }
1438 
1440 void SwTextFrame::HideHidden()
1441 {
1442  OSL_ENSURE( !GetFollow() && IsHiddenNow(),
1443  "HideHidden on visible frame of hidden frame has follow" );
1444 
1445  HideFootnotes(GetOfst(), TextFrameIndex(COMPLETE_STRING));
1446  HideAndShowObjects();
1447 
1448  // format information is obsolete
1449  ClearPara();
1450 }
1451 
1452 void SwTextFrame::HideFootnotes(TextFrameIndex const nStart, TextFrameIndex const nEnd)
1453 {
1454  SwPageFrame *pPage = nullptr;
1455  sw::MergedAttrIter iter(*this);
1456  SwTextNode const* pNode(nullptr);
1457  for (SwTextAttr const* pHt = iter.NextAttr(&pNode); pHt; pHt = iter.NextAttr(&pNode))
1458  {
1459  if (pHt->Which() == RES_TXTATR_FTN)
1460  {
1461  TextFrameIndex const nIdx(MapModelToView(pNode, pHt->GetStart()));
1462  if (nEnd < nIdx)
1463  break;
1464  if (nStart <= nIdx)
1465  {
1466  if (!pPage)
1467  pPage = FindPageFrame();
1468  pPage->RemoveFootnote( this, static_cast<const SwTextFootnote*>(pHt) );
1469  }
1470  }
1471  }
1472 }
1473 
1483 bool sw_HideObj( const SwTextFrame& _rFrame,
1484  const RndStdIds _eAnchorType,
1485  SwPosition const& rAnchorPos,
1486  SwAnchoredObject* _pAnchoredObj )
1487 {
1488  bool bRet( true );
1489 
1490  if (_eAnchorType == RndStdIds::FLY_AT_CHAR)
1491  {
1492  const IDocumentSettingAccess *const pIDSA = &_rFrame.GetDoc().getIDocumentSettingAccess();
1493  if ( !pIDSA->get(DocumentSettingId::USE_FORMER_TEXT_WRAPPING) &&
1494  !pIDSA->get(DocumentSettingId::OLD_LINE_SPACING) &&
1495  !pIDSA->get(DocumentSettingId::USE_FORMER_OBJECT_POS) &&
1496  pIDSA->get(DocumentSettingId::CONSIDER_WRAP_ON_OBJECT_POSITION) &&
1497  _rFrame.IsInDocBody() && !_rFrame.FindNextCnt() )
1498  {
1499  SwTextNode const& rNode(*rAnchorPos.nNode.GetNode().GetTextNode());
1500  assert(FrameContainsNode(_rFrame, rNode.GetIndex()));
1501  sal_Int32 const nObjAnchorPos(rAnchorPos.nContent.GetIndex());
1502  const sal_Unicode cAnchorChar = nObjAnchorPos < rNode.Len()
1503  ? rNode.GetText()[nObjAnchorPos]
1504  : 0;
1505  if (cAnchorChar == CH_TXTATR_BREAKWORD)
1506  {
1507  const SwTextAttr* const pHint(
1508  rNode.GetTextAttrForCharAt(nObjAnchorPos, RES_TXTATR_FLYCNT));
1509  if ( pHint )
1510  {
1511  const SwFrameFormat* pFrameFormat =
1512  static_cast<const SwTextFlyCnt*>(pHint)->GetFlyCnt().GetFrameFormat();
1513  if ( pFrameFormat->Which() == RES_FLYFRMFMT )
1514  {
1515  SwNodeIndex nContentIndex = *(pFrameFormat->GetContent().GetContentIdx());
1516  ++nContentIndex;
1517  if ( nContentIndex.GetNode().IsNoTextNode() )
1518  {
1519  bRet = false;
1520  // set needed data structure values for object positioning
1521  SwRectFnSet aRectFnSet(&_rFrame);
1522  SwRect aLastCharRect( _rFrame.getFrameArea() );
1523  aRectFnSet.SetWidth( aLastCharRect, 1 );
1524  _pAnchoredObj->maLastCharRect = aLastCharRect;
1525  _pAnchoredObj->mnLastTopOfLine = aRectFnSet.GetTop(aLastCharRect);
1526  }
1527  }
1528  }
1529  }
1530  }
1531  }
1532 
1533  return bRet;
1534 }
1535 
1546 void SwTextFrame::HideAndShowObjects()
1547 {
1548  if ( GetDrawObjs() )
1549  {
1550  if ( IsHiddenNow() )
1551  {
1552  // complete paragraph is hidden. Thus, hide all objects
1553  for (SwAnchoredObject* i : *GetDrawObjs())
1554  {
1555  SdrObject* pObj = i->DrawObj();
1556  SwContact* pContact = static_cast<SwContact*>(pObj->GetUserCall());
1557  // under certain conditions
1558  const RndStdIds eAnchorType( pContact->GetAnchorId() );
1559  if ((eAnchorType != RndStdIds::FLY_AT_CHAR) ||
1560  sw_HideObj(*this, eAnchorType, pContact->GetContentAnchor(),
1561  i ))
1562  {
1563  pContact->MoveObjToInvisibleLayer( pObj );
1564  }
1565  }
1566  }
1567  else
1568  {
1569  // paragraph is visible, but can contain hidden text portion.
1570  // first we check if objects are allowed to be hidden:
1571  const SwViewShell* pVsh = getRootFrame()->GetCurrShell();
1572  const bool bShouldBeHidden = !pVsh || !pVsh->GetWin() ||
1573  !pVsh->GetViewOptions()->IsShowHiddenChar();
1574 
1575  // Thus, show all objects, which are anchored at paragraph and
1576  // hide/show objects, which are anchored at/as character, according
1577  // to the visibility of the anchor character.
1578  for (SwAnchoredObject* i : *GetDrawObjs())
1579  {
1580  SdrObject* pObj = i->DrawObj();
1581  SwContact* pContact = static_cast<SwContact*>(pObj->GetUserCall());
1582  // Determine anchor type only once
1583  const RndStdIds eAnchorType( pContact->GetAnchorId() );
1584 
1585  if (eAnchorType == RndStdIds::FLY_AT_PARA)
1586  {
1587  pContact->MoveObjToVisibleLayer( pObj );
1588  }
1589  else if ((eAnchorType == RndStdIds::FLY_AT_CHAR) ||
1590  (eAnchorType == RndStdIds::FLY_AS_CHAR))
1591  {
1592  sal_Int32 nHiddenStart;
1593  sal_Int32 nHiddenEnd;
1594  const SwPosition& rAnchor = pContact->GetContentAnchor();
1595  SwScriptInfo::GetBoundsOfHiddenRange(
1596  *rAnchor.nNode.GetNode().GetTextNode(),
1597  rAnchor.nContent.GetIndex(), nHiddenStart, nHiddenEnd);
1598  // Under certain conditions
1599  if ( nHiddenStart != COMPLETE_STRING && bShouldBeHidden &&
1600  sw_HideObj(*this, eAnchorType, rAnchor, i))
1601  {
1602  pContact->MoveObjToInvisibleLayer( pObj );
1603  }
1604  else
1605  pContact->MoveObjToVisibleLayer( pObj );
1606  }
1607  else
1608  {
1609  OSL_FAIL( "<SwTextFrame::HideAndShowObjects()> - object not anchored at/inside paragraph!?" );
1610  }
1611  }
1612  }
1613  }
1614 
1615  if (IsFollow())
1616  {
1617  SwTextFrame *pMaster = FindMaster();
1618  OSL_ENSURE(pMaster, "SwTextFrame without master");
1619  if (pMaster)
1620  pMaster->HideAndShowObjects();
1621  }
1622 }
1623 
1630 TextFrameIndex SwTextFrame::FindBrk(const OUString &rText,
1631  const TextFrameIndex nStart,
1632  const TextFrameIndex nEnd)
1633 {
1634  sal_Int32 nFound = sal_Int32(nStart);
1635  const sal_Int32 nEndLine = std::min(sal_Int32(nEnd), rText.getLength() - 1);
1636 
1637  // Skip all leading blanks.
1638  while( nFound <= nEndLine && ' ' == rText[nFound] )
1639  {
1640  nFound++;
1641  }
1642 
1643  // A tricky situation with the TextAttr-Dummy-character (in this case "$"):
1644  // "Dr.$Meyer" at the beginning of the second line. Typing a blank after that
1645  // doesn't result in the word moving into first line, even though that would work.
1646  // For this reason we don't skip the dummy char.
1647  while( nFound <= nEndLine && ' ' != rText[nFound] )
1648  {
1649  nFound++;
1650  }
1651 
1652  return TextFrameIndex(nFound);
1653 }
1654 
1655 bool SwTextFrame::IsIdxInside(TextFrameIndex const nPos, TextFrameIndex const nLen) const
1656 {
1657 // Silence over-eager warning emitted at least by GCC trunk towards 6:
1658 #if defined __GNUC__ && !defined __clang__
1659 #pragma GCC diagnostic push
1660 #pragma GCC diagnostic ignored "-Wstrict-overflow"
1661 #endif
1662  if (nLen != TextFrameIndex(COMPLETE_STRING) && GetOfst() > nPos + nLen) // the range preceded us
1663 #if defined __GNUC__ && !defined __clang__
1664 #pragma GCC diagnostic pop
1665 #endif
1666  return false;
1667 
1668  if( !GetFollow() ) // the range doesn't precede us,
1669  return true; // nobody follows us.
1670 
1671  TextFrameIndex const nMax = GetFollow()->GetOfst();
1672 
1673  // either the range overlap or our text has been deleted
1674  // sw_redlinehide: GetText() should be okay here because it has already
1675  // been updated in the INS/DEL hint case
1676  if (nMax > nPos || nMax > TextFrameIndex(GetText().getLength()))
1677  return true;
1678 
1679  // changes made in the first line of a follow can modify the master
1680  const SwParaPortion* pPara = GetFollow()->GetPara();
1681  return pPara && ( nPos <= nMax + pPara->GetLen() );
1682 }
1683 
1684 inline void SwTextFrame::InvalidateRange(const SwCharRange &aRange, const long nD)
1685 {
1686  if ( IsIdxInside( aRange.Start(), aRange.Len() ) )
1687  InvalidateRange_( aRange, nD );
1688 }
1689 
1690 void SwTextFrame::InvalidateRange_( const SwCharRange &aRange, const long nD)
1691 {
1692  if ( !HasPara() )
1693  { InvalidateSize();
1694  return;
1695  }
1696 
1697  SetWidow( false );
1698  SwParaPortion *pPara = GetPara();
1699 
1700  bool bInv = false;
1701  if( 0 != nD )
1702  {
1703  // In nDelta the differences between old and new
1704  // linelengths are being added, that's why it's negative
1705  // if chars have been added and positive, if chars have
1706  // deleted
1707  pPara->GetDelta() += nD;
1708  bInv = true;
1709  }
1710  SwCharRange &rReformat = pPara->GetReformat();
1711  if(aRange != rReformat) {
1712  if (TextFrameIndex(COMPLETE_STRING) == rReformat.Len())
1713  rReformat = aRange;
1714  else
1715  rReformat += aRange;
1716  bInv = true;
1717  }
1718  if(bInv)
1719  {
1720  InvalidateSize();
1721  }
1722 }
1723 
1724 void SwTextFrame::CalcLineSpace()
1725 {
1726  OSL_ENSURE( ! IsVertical() || ! IsSwapped(),
1727  "SwTextFrame::CalcLineSpace with swapped frame!" );
1728 
1729  if( IsLocked() || !HasPara() )
1730  return;
1731 
1732  if( GetDrawObjs() ||
1733  GetTextNodeForParaProps()->GetSwAttrSet().GetLRSpace().IsAutoFirst())
1734  {
1735  Init();
1736  return;
1737  }
1738 
1739  SwParaPortion *const pPara(GetPara());
1740  assert(pPara);
1741  if (pPara->IsFixLineHeight())
1742  {
1743  Init();
1744  return;
1745  }
1746 
1747  Size aNewSize( getFramePrintArea().SSize() );
1748 
1749  SwTextFormatInfo aInf( getRootFrame()->GetCurrShell()->GetOut(), this );
1750  SwTextFormatter aLine( this, &aInf );
1751  if( aLine.GetDropLines() )
1752  {
1753  Init();
1754  return;
1755  }
1756 
1757  aLine.Top();
1758  aLine.RecalcRealHeight();
1759 
1760  aNewSize.setHeight( (aLine.Y() - getFrameArea().Top()) + aLine.GetLineHeight() );
1761 
1762  SwTwips nDelta = aNewSize.Height() - getFramePrintArea().Height();
1763  // Underflow with free-flying frames
1764  if( aInf.GetTextFly().IsOn() )
1765  {
1766  SwRect aTmpFrame( getFrameArea() );
1767  if( nDelta < 0 )
1768  aTmpFrame.Height( getFramePrintArea().Height() );
1769  else
1770  aTmpFrame.Height( aNewSize.Height() );
1771  if( aInf.GetTextFly().Relax( aTmpFrame ) )
1772  {
1773  Init();
1774  return;
1775  }
1776  }
1777 
1778  if( nDelta )
1779  {
1780  SwTextFrameBreak aBreak( this );
1781  if( GetFollow() || aBreak.IsBreakNow( aLine ) )
1782  {
1783  // if there is a Follow() or if we need to break here, reformat
1784  Init();
1785  }
1786  else
1787  {
1788  // everything is business as usual...
1789  pPara->SetPrepAdjust();
1790  pPara->SetPrep();
1791  }
1792  }
1793 }
1794 
1795 static void lcl_SetWrong( SwTextFrame& rFrame, SwTextNode const& rNode,
1796  sal_Int32 const nPos, sal_Int32 const nCnt, bool const bMove)
1797 {
1798  if ( !rFrame.IsFollow() )
1799  {
1800  SwTextNode* pTextNode = const_cast<SwTextNode*>(&rNode);
1801  IGrammarContact* pGrammarContact = getGrammarContact( *pTextNode );
1802  SwGrammarMarkUp* pWrongGrammar = pGrammarContact ?
1803  pGrammarContact->getGrammarCheck( *pTextNode, false ) :
1804  pTextNode->GetGrammarCheck();
1805  bool bGrammarProxy = pWrongGrammar != pTextNode->GetGrammarCheck();
1806  if( bMove )
1807  {
1808  if( pTextNode->GetWrong() )
1809  pTextNode->GetWrong()->Move( nPos, nCnt );
1810  if( pWrongGrammar )
1811  pWrongGrammar->MoveGrammar( nPos, nCnt );
1812  if( bGrammarProxy && pTextNode->GetGrammarCheck() )
1813  pTextNode->GetGrammarCheck()->MoveGrammar( nPos, nCnt );
1814  if( pTextNode->GetSmartTags() )
1815  pTextNode->GetSmartTags()->Move( nPos, nCnt );
1816  }
1817  else
1818  {
1819  if( pTextNode->GetWrong() )
1820  pTextNode->GetWrong()->Invalidate( nPos, nCnt );
1821  if( pWrongGrammar )
1822  pWrongGrammar->Invalidate( nPos, nCnt );
1823  if( pTextNode->GetSmartTags() )
1824  pTextNode->GetSmartTags()->Invalidate( nPos, nCnt );
1825  }
1826  const sal_Int32 nEnd = nPos + (nCnt > 0 ? nCnt : 1 );
1827  if ( !pTextNode->GetWrong() && !pTextNode->IsWrongDirty() )
1828  {
1829  pTextNode->SetWrong( new SwWrongList( WRONGLIST_SPELL ) );
1830  pTextNode->GetWrong()->SetInvalid( nPos, nEnd );
1831  }
1832  if ( !pTextNode->GetSmartTags() && !pTextNode->IsSmartTagDirty() )
1833  {
1834  pTextNode->SetSmartTags( new SwWrongList( WRONGLIST_SMARTTAG ) );
1835  pTextNode->GetSmartTags()->SetInvalid( nPos, nEnd );
1836  }
1837  pTextNode->SetWrongDirty(SwTextNode::WrongState::TODO);
1838  pTextNode->SetGrammarCheckDirty( true );
1839  pTextNode->SetWordCountDirty( true );
1840  pTextNode->SetAutoCompleteWordDirty( true );
1841  pTextNode->SetSmartTagDirty( true );
1842  }
1843 
1844  SwRootFrame *pRootFrame = rFrame.getRootFrame();
1845  if (pRootFrame)
1846  {
1847  pRootFrame->SetNeedGrammarCheck( true );
1848  }
1849 
1850  SwPageFrame *pPage = rFrame.FindPageFrame();
1851  if( pPage )
1852  {
1853  pPage->InvalidateSpelling();
1854  pPage->InvalidateAutoCompleteWords();
1855  pPage->InvalidateWordCount();
1856  pPage->InvalidateSmartTags();
1857  }
1858 }
1859 
1860 static void lcl_SetScriptInval(SwTextFrame& rFrame, TextFrameIndex const nPos)
1861 {
1862  if( rFrame.GetPara() )
1863  rFrame.GetPara()->GetScriptInfo().SetInvalidityA( nPos );
1864 }
1865 
1866 // note: SwClientNotify will be called once for every frame => just fix own Ofst
1867 static void lcl_ModifyOfst(SwTextFrame & rFrame,
1868  TextFrameIndex const nPos, TextFrameIndex const nLen,
1869  TextFrameIndex (* op)(TextFrameIndex const&, TextFrameIndex const&))
1870 {
1871  assert(nLen != TextFrameIndex(COMPLETE_STRING));
1872  if (rFrame.IsFollow() && nPos < rFrame.GetOfst())
1873  {
1874  rFrame.ManipOfst( std::max(TextFrameIndex(0), op(rFrame.GetOfst(), nLen)) );
1875  }
1876 }
1877 
1878 namespace {
1879 
1880 void UpdateMergedParaForMove(sw::MergedPara & rMerged,
1881  SwTextFrame & rTextFrame,
1882  bool & o_rbRecalcFootnoteFlag,
1883  SwTextNode const& rDestNode,
1884  SwTextNode const& rNode,
1885  sal_Int32 const nDestStart,
1886  sal_Int32 const nSourceStart,
1887  sal_Int32 const nLen)
1888 {
1889  std::vector<std::pair<sal_Int32, sal_Int32>> deleted;
1890  sal_Int32 const nSourceEnd(nSourceStart + nLen);
1891  sal_Int32 nLastEnd(0);
1892  for (const auto& rExt : rMerged.extents)
1893  {
1894  if (rExt.pNode == &rNode)
1895  {
1896  sal_Int32 const nStart(std::max(nLastEnd, nSourceStart));
1897  sal_Int32 const nEnd(std::min(rExt.nStart, nSourceEnd));
1898  if (nStart < nEnd)
1899  {
1900  deleted.emplace_back(nStart, nEnd);
1901  }
1902  nLastEnd = rExt.nEnd;
1903  if (nSourceEnd <= rExt.nEnd)
1904  {
1905  break;
1906  }
1907  }
1908  else if (rNode.GetIndex() < rExt.pNode->GetIndex())
1909  {
1910  break;
1911  }
1912  }
1913  if (nLastEnd != rNode.Len()) // without nLen, string yet to be removed
1914  {
1915  assert(rNode.Len() == 0 || nLastEnd < nSourceEnd);
1916  if (nLastEnd < nSourceEnd)
1917  {
1918  deleted.emplace_back(std::max(nLastEnd, nSourceStart), nSourceEnd);
1919  }
1920  }
1921  if (!deleted.empty())
1922  {
1923  o_rbRecalcFootnoteFlag = true;
1924  for (auto const& it : deleted)
1925  {
1926  sal_Int32 const nStart(it.first - nSourceStart + nDestStart);
1927  TextFrameIndex const nDeleted = UpdateMergedParaForDelete(rMerged, false,
1928  rDestNode, nStart, it.second - it.first);
1929 //FIXME asserts valid for join - but if called from split, the new node isn't there yet and it will be added later... assert(nDeleted);
1930 // assert(nDeleted == it.second - it.first);
1931  if(nDeleted)
1932  {
1933  // InvalidateRange/lcl_SetScriptInval was called sufficiently for SwInsText
1934  lcl_SetWrong(rTextFrame, rDestNode, nStart, it.first - it.second, false);
1935  TextFrameIndex const nIndex(sw::MapModelToView(rMerged, &rDestNode, nStart));
1936  lcl_ModifyOfst(rTextFrame, nIndex, nDeleted, &o3tl::operator-<sal_Int32, Tag_TextFrameIndex>);
1937  }
1938  }
1939  }
1940 }
1941 
1942 } // namespace
1943 
1948 static bool isA11yRelevantAttribute(sal_uInt16 nWhich)
1949 {
1950  return nWhich != RES_CHRATR_RSID;
1951 }
1952 
1953 static bool hasA11yRelevantAttribute( const std::vector<sal_uInt16>& rWhichFmtAttr )
1954 {
1955  for( sal_uInt16 nWhich : rWhichFmtAttr )
1956  if ( isA11yRelevantAttribute( nWhich ) )
1957  return true;
1958 
1959  return false;
1960 }
1961 
1962 // Note: for now this overrides SwClient::SwClientNotify; the intermediary
1963 // classes still override SwClient::Modify, which should continue to work
1964 // as their implementation of SwClientNotify is SwClient's which calls Modify.
1965 // Therefore we also don't need to call SwClient::SwClientNotify(rModify, rHint)
1966 // because that's all it does, and this implementation calls
1967 // SwContentFrame::Modify() when appropriate.
1968 void SwTextFrame::SwClientNotify(SwModify const& rModify, SfxHint const& rHint)
1969 {
1970  SfxPoolItem const* pOld(nullptr);
1971  SfxPoolItem const* pNew(nullptr);
1972  sw::MoveText const* pMoveText(nullptr);
1973  sw::RedlineDelText const* pRedlineDelText(nullptr);
1974  sw::RedlineUnDelText const* pRedlineUnDelText(nullptr);
1975 
1976  if (auto const pHint = dynamic_cast<sw::LegacyModifyHint const*>(&rHint))
1977  {
1978  pOld = pHint->m_pOld;
1979  pNew = pHint->m_pNew;
1980  }
1981  else if (auto const pHt = dynamic_cast<sw::MoveText const*>(&rHint))
1982  {
1983  pMoveText = pHt;
1984  }
1985  else if (auto const pHynt = dynamic_cast<sw::RedlineDelText const*>(&rHint))
1986  {
1987  pRedlineDelText = pHynt;
1988  }
1989  else if (auto const pHnt = dynamic_cast<sw::RedlineUnDelText const*>(&rHint))
1990  {
1991  pRedlineUnDelText = pHnt;
1992  }
1993  else
1994  {
1995  assert(!"unexpected hint");
1996  }
1997 
1998  if (m_pMergedPara)
1999  {
2000  assert(m_pMergedPara->listener.IsListeningTo(&rModify));
2001  }
2002 
2003  SwTextNode const& rNode(static_cast<SwTextNode const&>(rModify));
2004  const sal_uInt16 nWhich = pOld ? pOld->Which() : pNew ? pNew->Which() : 0;
2005 
2006  // modifications concerning frame attributes are processed by the base class
2007  if( IsInRange( aFrameFormatSetRange, nWhich ) || RES_FMT_CHG == nWhich )
2008  {
2009  if (m_pMergedPara)
2010  { // ignore item set changes that don't apply
2011  SwTextNode const*const pAttrNode(
2012  (nWhich == RES_PAGEDESC || nWhich == RES_BREAK)
2013  ? m_pMergedPara->pFirstNode
2014  : m_pMergedPara->pParaPropsNode);
2015  if (pAttrNode != &rModify)
2016  {
2017  return;
2018  }
2019  }
2020  SwContentFrame::Modify( pOld, pNew );
2021  if( nWhich == RES_FMT_CHG && getRootFrame()->GetCurrShell() )
2022  {
2023  // collection has changed
2024  Prepare();
2025  InvalidatePrt_();
2026  lcl_SetWrong( *this, rNode, 0, COMPLETE_STRING, false );
2027  SetDerivedR2L( false );
2028  CheckDirChange();
2029  // Force complete paint due to existing indents.
2030  SetCompletePaint();
2031  InvalidateLineNum();
2032  }
2033  return;
2034  }
2035 
2036  if (m_pMergedPara && m_pMergedPara->pParaPropsNode != &rModify)
2037  {
2038  if (isPARATR(nWhich) || isPARATR_LIST(nWhich)) // FRMATR handled above
2039  {
2040  return; // ignore it
2041  }
2042  }
2043 
2044  Broadcast(SfxHint()); // notify SwAccessibleParagraph
2045 
2046  // while locked ignore all modifications
2047  if( IsLocked() )
2048  return;
2049 
2050  // save stack
2051  // warning: one has to ensure that all variables are set
2052  TextFrameIndex nPos;
2053  TextFrameIndex nLen;
2054  bool bSetFieldsDirty = false;
2055  bool bRecalcFootnoteFlag = false;
2056 
2057  if (pRedlineDelText)
2058  {
2059  if (m_pMergedPara)
2060  {
2061  sal_Int32 const nNPos = pRedlineDelText->nStart;
2062  sal_Int32 const nNLen = pRedlineDelText->nLen;
2063  nPos = MapModelToView(&rNode, nNPos);
2064  // update merged before doing anything else
2065  nLen = UpdateMergedParaForDelete(*m_pMergedPara, false, rNode, nNPos, nNLen);
2066  const sal_Int32 m = -nNLen;
2067  if (nLen && IsIdxInside(nPos, nLen))
2068  {
2069  InvalidateRange( SwCharRange(nPos, TextFrameIndex(1)), m );
2070  }
2071  lcl_SetWrong( *this, rNode, nNPos, m, false );
2072  if (nLen)
2073  {
2074  lcl_SetScriptInval( *this, nPos );
2075  bSetFieldsDirty = bRecalcFootnoteFlag = true;
2076  lcl_ModifyOfst(*this, nPos, nLen, &o3tl::operator-<sal_Int32, Tag_TextFrameIndex>);
2077  }
2078  }
2079  }
2080  else if (pRedlineUnDelText)
2081  {
2082  if (m_pMergedPara)
2083  {
2084  sal_Int32 const nNPos = pRedlineUnDelText->nStart;
2085  sal_Int32 const nNLen = pRedlineUnDelText->nLen;
2086  nPos = MapModelToView(&rNode, nNPos);
2087  nLen = UpdateMergedParaForInsert(*m_pMergedPara, false, rNode, nNPos, nNLen);
2088  if (IsIdxInside(nPos, nLen))
2089  {
2090  if (!nLen)
2091  {
2092  // Refresh NumPortions even when line is empty!
2093  if (nPos)
2094  InvalidateSize();
2095  else
2096  Prepare();
2097  }
2098  else
2099  InvalidateRange_( SwCharRange( nPos, nLen ), nNLen );
2100  }
2101  lcl_SetWrong( *this, rNode, nNPos, nNLen, false );
2102  lcl_SetScriptInval( *this, nPos );
2103  bSetFieldsDirty = true;
2104  lcl_ModifyOfst(*this, nPos, nLen, &o3tl::operator+<sal_Int32, Tag_TextFrameIndex>);
2105  }
2106  }
2107  else if (pMoveText)
2108  {
2109  if (m_pMergedPara
2110  && m_pMergedPara->pFirstNode->GetIndex() <= pMoveText->pDestNode->GetIndex()
2111  && pMoveText->pDestNode->GetIndex() <= m_pMergedPara->pLastNode->GetIndex())
2112  { // if it's not 2 nodes in merged frame, assume the target node doesn't have frames at all
2113  assert(std::abs(static_cast<long>(rNode.GetIndex()) - static_cast<long>(pMoveText->pDestNode->GetIndex())) == 1);
2114  UpdateMergedParaForMove(*m_pMergedPara,
2115  *this,
2116  bRecalcFootnoteFlag,
2117  *pMoveText->pDestNode, rNode,
2118  pMoveText->nDestStart,
2119  pMoveText->nSourceStart,
2120  pMoveText->nLen);
2121  }
2122  else
2123  {
2124  // there is a situation where this is okay: from JoinNext, which will then call CheckResetRedlineMergeFlag, which will then create merged from scratch for this frame
2125  // assert(!m_pMergedPara || !getRootFrame()->IsHideRedlines() || !pMoveText->pDestNode->getLayoutFrame(getRootFrame()));
2126  }
2127  }
2128  else switch (nWhich)
2129  {
2130  case RES_LINENUMBER:
2131  {
2132  assert(false); // should have been forwarded to SwContentFrame
2133  InvalidateLineNum();
2134  }
2135  break;
2136  case RES_INS_TXT:
2137  {
2138  sal_Int32 const nNPos = static_cast<const SwInsText*>(pNew)->nPos;
2139  sal_Int32 const nNLen = static_cast<const SwInsText*>(pNew)->nLen;
2140  nPos = MapModelToView(&rNode, nNPos);
2141  nLen = TextFrameIndex(nNLen);
2142  if (m_pMergedPara)
2143  {
2144  UpdateMergedParaForInsert(*m_pMergedPara, true, rNode, nNPos, nNLen);
2145  }
2146  if( IsIdxInside( nPos, nLen ) )
2147  {
2148  if( !nLen )
2149  {
2150  // Refresh NumPortions even when line is empty!
2151  if( nPos )
2152  InvalidateSize();
2153  else
2154  Prepare();
2155  }
2156  else
2157  InvalidateRange_( SwCharRange( nPos, nLen ), nNLen );
2158  }
2159  lcl_SetWrong( *this, rNode, nNPos, nNLen, true );
2160  lcl_SetScriptInval( *this, nPos );
2161  bSetFieldsDirty = true;
2162  lcl_ModifyOfst(*this, nPos, nLen, &o3tl::operator+<sal_Int32, Tag_TextFrameIndex>);
2163  }
2164  break;
2165  case RES_DEL_CHR:
2166  {
2167  sal_Int32 const nNPos = static_cast<const SwDelChr*>(pNew)->nPos;
2168  nPos = MapModelToView(&rNode, nNPos);
2169  if (m_pMergedPara)
2170  {
2171  nLen = UpdateMergedParaForDelete(*m_pMergedPara, true, rNode, nNPos, 1);
2172  }
2173  else
2174  {
2175  nLen = TextFrameIndex(1);
2176  }
2177  lcl_SetWrong( *this, rNode, nNPos, -1, true );
2178  if (nLen)
2179  {
2180  InvalidateRange( SwCharRange(nPos, nLen), -1 );
2181  lcl_SetScriptInval( *this, nPos );
2182  bSetFieldsDirty = bRecalcFootnoteFlag = true;
2183  lcl_ModifyOfst(*this, nPos, nLen, &o3tl::operator-<sal_Int32, Tag_TextFrameIndex>);
2184  }
2185  }
2186  break;
2187  case RES_DEL_TXT:
2188  {
2189  sal_Int32 const nNPos = static_cast<const SwDelText*>(pNew)->nStart;
2190  sal_Int32 const nNLen = static_cast<const SwDelText*>(pNew)->nLen;
2191  nPos = MapModelToView(&rNode, nNPos);
2192  if (m_pMergedPara)
2193  { // update merged before doing anything else
2194  nLen = UpdateMergedParaForDelete(*m_pMergedPara, true, rNode, nNPos, nNLen);
2195  }
2196  else
2197  {
2198  nLen = TextFrameIndex(nNLen);
2199  }
2200  const sal_Int32 m = -nNLen;
2201  if ((!m_pMergedPara || nLen) && IsIdxInside(nPos, nLen))
2202  {
2203  if( !nLen )
2204  InvalidateSize();
2205  else
2206  InvalidateRange( SwCharRange(nPos, TextFrameIndex(1)), m );
2207  }
2208  lcl_SetWrong( *this, rNode, nNPos, m, true );
2209  if (nLen)
2210  {
2211  lcl_SetScriptInval( *this, nPos );
2212  bSetFieldsDirty = bRecalcFootnoteFlag = true;
2213  lcl_ModifyOfst(*this, nPos, nLen, &o3tl::operator-<sal_Int32, Tag_TextFrameIndex>);
2214  }
2215  }
2216  break;
2217  case RES_UPDATE_ATTR:
2218  {
2219  const SwUpdateAttr* pNewUpdate = static_cast<const SwUpdateAttr*>(pNew);
2220 
2221  sal_Int32 const nNPos = pNewUpdate->getStart();
2222  sal_Int32 const nNLen = pNewUpdate->getEnd() - nNPos;
2223  nPos = MapModelToView(&rNode, nNPos);
2224  nLen = MapModelToView(&rNode, nNPos + nNLen) - nPos;
2225  if( IsIdxInside( nPos, nLen ) )
2226  {
2227  // We need to reformat anyways, even if the invalidated
2228  // range is empty.
2229  // E.g.: empty line, set 14 pt!
2230 
2231  // FootnoteNumbers need to be formatted
2232  if( !nLen )
2233  nLen = TextFrameIndex(1);
2234 
2235  InvalidateRange_( SwCharRange( nPos, nLen) );
2236  const sal_uInt16 nTmp = pNewUpdate->getWhichAttr();
2237 
2238  if( ! nTmp || RES_TXTATR_CHARFMT == nTmp || RES_TXTATR_INETFMT == nTmp || RES_TXTATR_AUTOFMT == nTmp ||
2239  RES_FMT_CHG == nTmp || RES_ATTRSET_CHG == nTmp )
2240  {
2241  lcl_SetWrong( *this, rNode, nNPos, nNPos + nNLen, false );
2242  lcl_SetScriptInval( *this, nPos );
2243  }
2244  }
2245 
2246  if( isA11yRelevantAttribute( pNewUpdate->getWhichAttr() ) &&
2247  hasA11yRelevantAttribute( pNewUpdate->getFmtAttrs() ) )
2248  {
2249  SwViewShell* pViewSh = getRootFrame() ? getRootFrame()->GetCurrShell() : nullptr;
2250  if ( pViewSh )
2251  {
2252  pViewSh->InvalidateAccessibleParaAttrs( *this );
2253  }
2254  }
2255  }
2256  break;
2257  case RES_OBJECTDYING:
2258  break;
2259 
2260  case RES_PARATR_LINESPACING:
2261  {
2262  CalcLineSpace();
2263  InvalidateSize();
2264  InvalidatePrt_();
2265  if( IsInSct() && !GetPrev() )
2266  {
2267  SwSectionFrame *pSect = FindSctFrame();
2268  if( pSect->ContainsAny() == this )
2269  pSect->InvalidatePrt();
2270  }
2271 
2272  // i#11859
2273  // (1) Also invalidate next frame on next page/column.
2274  // (2) Skip empty sections and hidden paragraphs
2275  // Thus, use method <InvalidateNextPrtArea()>
2276  InvalidateNextPrtArea();
2277 
2278  SetCompletePaint();
2279  }
2280  break;
2281 
2282  case RES_TXTATR_FIELD:
2283  case RES_TXTATR_ANNOTATION:
2284  {
2285  sal_Int32 const nNPos = static_cast<const SwFormatField*>(pNew)->GetTextField()->GetStart();
2286  nPos = MapModelToView(&rNode, nNPos);
2287  if (IsIdxInside(nPos, TextFrameIndex(1)))
2288  {
2289  if( pNew == pOld )
2290  {
2291  // only repaint
2292  // opt: invalidate window?
2293  InvalidatePage();
2294  SetCompletePaint();
2295  }
2296  else
2297  InvalidateRange_(SwCharRange(nPos, TextFrameIndex(1)));
2298  }
2299  bSetFieldsDirty = true;
2300  // ST2
2301  if ( SwSmartTagMgr::Get().IsSmartTagsEnabled() )
2302  lcl_SetWrong( *this, rNode, nNPos, nNPos + 1, false );
2303  }
2304  break;
2305 
2306  case RES_TXTATR_FTN :
2307  {
2308  if (!IsInFootnote())
2309  { // the hint may be sent from the anchor node, or from a
2310  // node in the footnote; the anchor index is only valid in the
2311  // anchor node!
2312  assert(&rNode == &static_cast<const SwFormatFootnote*>(pNew)->GetTextFootnote()->GetTextNode());
2313  nPos = MapModelToView(&rNode,
2314  static_cast<const SwFormatFootnote*>(pNew)->GetTextFootnote()->GetStart());
2315  }
2316 #ifdef _MSC_VER
2317  else nPos = TextFrameIndex(42); // shut up MSVC 2017 spurious warning C4701
2318 #endif
2319  if (IsInFootnote() || IsIdxInside(nPos, TextFrameIndex(1)))
2320  Prepare( PREP_FTN, static_cast<const SwFormatFootnote*>(pNew)->GetTextFootnote() );
2321  break;
2322  }
2323 
2324  case RES_ATTRSET_CHG:
2325  {
2326  InvalidateLineNum();
2327 
2328  const SwAttrSet& rNewSet = *static_cast<const SwAttrSetChg*>(pNew)->GetChgSet();
2329  const SfxPoolItem* pItem = nullptr;
2330  int nClear = 0;
2331  sal_uInt16 nCount = rNewSet.Count();
2332 
2333  if( SfxItemState::SET == rNewSet.GetItemState( RES_TXTATR_FTN, false, &pItem ))
2334  {
2335  nPos = MapModelToView(&rNode,
2336  static_cast<const SwFormatFootnote*>(pItem)->GetTextFootnote()->GetStart());
2337  if (IsIdxInside(nPos, TextFrameIndex(1)))
2338  Prepare( PREP_FTN, pNew );
2339  nClear = 0x01;
2340  --nCount;
2341  }
2342 
2343  if( SfxItemState::SET == rNewSet.GetItemState( RES_TXTATR_FIELD, false, &pItem ))
2344  {
2345  nPos = MapModelToView(&rNode,
2346  static_cast<const SwFormatField*>(pItem)->GetTextField()->GetStart());
2347  if (IsIdxInside(nPos, TextFrameIndex(1)))
2348  {
2349  const SfxPoolItem* pOldItem = pOld ?
2350  &(static_cast<const SwAttrSetChg*>(pOld)->GetChgSet()->Get(RES_TXTATR_FIELD)) : nullptr;
2351  if( pItem == pOldItem )
2352  {
2353  InvalidatePage();
2354  SetCompletePaint();
2355  }
2356  else
2357  InvalidateRange_(SwCharRange(nPos, TextFrameIndex(1)));
2358  }
2359  nClear |= 0x02;
2360  --nCount;
2361  }
2362  bool bLineSpace = SfxItemState::SET == rNewSet.GetItemState(
2363  RES_PARATR_LINESPACING, false ),
2364  bRegister = SfxItemState::SET == rNewSet.GetItemState(
2365  RES_PARATR_REGISTER, false );
2366  if ( bLineSpace || bRegister )
2367  {
2368  if (!m_pMergedPara || m_pMergedPara->pParaPropsNode == &rModify)
2369  {
2370  Prepare( bRegister ? PREP_REGISTER : PREP_ADJUST_FRM );
2371  CalcLineSpace();
2372  InvalidateSize();
2373  InvalidatePrt_();
2374 
2375  // i#11859
2376  // (1) Also invalidate next frame on next page/column.
2377  // (2) Skip empty sections and hidden paragraphs
2378  // Thus, use method <InvalidateNextPrtArea()>
2379  InvalidateNextPrtArea();
2380 
2381  SetCompletePaint();
2382  }
2383  nClear |= 0x04;
2384  if ( bLineSpace )
2385  {
2386  --nCount;
2387  if ((!m_pMergedPara || m_pMergedPara->pParaPropsNode == &rModify)
2388  && IsInSct() && !GetPrev())
2389  {
2390  SwSectionFrame *pSect = FindSctFrame();
2391  if( pSect->ContainsAny() == this )
2392  pSect->InvalidatePrt();
2393  }
2394  }
2395  if ( bRegister )
2396  --nCount;
2397  }
2398  if ( SfxItemState::SET == rNewSet.GetItemState( RES_PARATR_SPLIT,
2399  false ))
2400  {
2401  if (!m_pMergedPara || m_pMergedPara->pParaPropsNode == &rModify)
2402  {
2403  if (GetPrev())
2404  CheckKeep();
2405  Prepare();
2406  InvalidateSize();
2407  }
2408  nClear |= 0x08;
2409  --nCount;
2410  }
2411 
2412  if( SfxItemState::SET == rNewSet.GetItemState( RES_BACKGROUND, false)
2413  && (!m_pMergedPara || m_pMergedPara->pParaPropsNode == &rModify)
2414  && !IsFollow() && GetDrawObjs() )
2415  {
2416  SwSortedObjs *pObjs = GetDrawObjs();
2417  for ( size_t i = 0; GetDrawObjs() && i < pObjs->size(); ++i )
2418  {
2419  SwAnchoredObject* pAnchoredObj = (*pObjs)[i];
2420  if ( dynamic_cast< const SwFlyFrame *>( pAnchoredObj ) != nullptr )
2421  {
2422  SwFlyFrame *pFly = static_cast<SwFlyFrame*>(pAnchoredObj);
2423  if( !pFly->IsFlyInContentFrame() )
2424  {
2425  const SvxBrushItem &rBack =
2426  pFly->GetAttrSet()->GetBackground();
2427  // #GetTransChg#
2428  // following condition determines, if the fly frame
2429  // "inherites" the background color of text frame.
2430  // This is the case, if fly frame background
2431  // color is "no fill"/"auto fill" and if the fly frame
2432  // has no background graphic.
2433  // Thus, check complete fly frame background
2434  // color and *not* only its transparency value
2435  if ( (rBack.GetColor() == COL_TRANSPARENT) &&
2436  rBack.GetGraphicPos() == GPOS_NONE )
2437  {
2438  pFly->SetCompletePaint();
2439  pFly->InvalidatePage();
2440  }
2441  }
2442  }
2443  }
2444  }
2445 
2446  if ( SfxItemState::SET ==
2447  rNewSet.GetItemState( RES_TXTATR_CHARFMT, false ) )
2448  {
2449  lcl_SetWrong( *this, rNode, 0, COMPLETE_STRING, false );
2450  lcl_SetScriptInval( *this, TextFrameIndex(0) );
2451  }
2452  else if ( SfxItemState::SET ==
2453  rNewSet.GetItemState( RES_CHRATR_LANGUAGE, false ) ||
2454  SfxItemState::SET ==
2455  rNewSet.GetItemState( RES_CHRATR_CJK_LANGUAGE, false ) ||
2456  SfxItemState::SET ==
2457  rNewSet.GetItemState( RES_CHRATR_CTL_LANGUAGE, false ) )
2458  lcl_SetWrong( *this, rNode, 0, COMPLETE_STRING, false );
2459  else if ( SfxItemState::SET ==
2460  rNewSet.GetItemState( RES_CHRATR_FONT, false ) ||
2461  SfxItemState::SET ==
2462  rNewSet.GetItemState( RES_CHRATR_CJK_FONT, false ) ||
2463  SfxItemState::SET ==
2464  rNewSet.GetItemState( RES_CHRATR_CTL_FONT, false ) )
2465  lcl_SetScriptInval( *this, TextFrameIndex(0) );
2466  else if ( SfxItemState::SET ==
2467  rNewSet.GetItemState( RES_FRAMEDIR, false )
2468  && (!m_pMergedPara || m_pMergedPara->pParaPropsNode == &rModify))
2469  {
2470  SetDerivedR2L( false );
2471  CheckDirChange();
2472  // Force complete paint due to existing indents.
2473  SetCompletePaint();
2474  }
2475 
2476  if( nCount )
2477  {
2478  if( getRootFrame()->GetCurrShell() )
2479  {
2480  Prepare();
2481  InvalidatePrt_();
2482  }
2483 
2484  if (nClear || (m_pMergedPara &&
2485  (m_pMergedPara->pParaPropsNode != &rModify ||
2486  m_pMergedPara->pFirstNode != &rModify)))
2487  {
2488  assert(pOld);
2489  SwAttrSetChg aOldSet( *static_cast<const SwAttrSetChg*>(pOld) );
2490  SwAttrSetChg aNewSet( *static_cast<const SwAttrSetChg*>(pNew) );
2491 
2492  if (m_pMergedPara && m_pMergedPara->pParaPropsNode != &rModify)
2493  {
2494  for (sal_uInt16 i = RES_PARATR_BEGIN; i != RES_FRMATR_END; ++i)
2495  {
2496  if (i != RES_BREAK && i != RES_PAGEDESC)
2497  {
2498  aOldSet.ClearItem(i);
2499  aNewSet.ClearItem(i);
2500  }
2501  }
2502  for (sal_uInt16 i = XATTR_FILL_FIRST; i <= XATTR_FILL_LAST; ++i)
2503  {
2504  aOldSet.ClearItem(i);
2505  aNewSet.ClearItem(i);
2506  }
2507  }
2508  if (m_pMergedPara && m_pMergedPara->pFirstNode != &rModify)
2509  {
2510  aOldSet.ClearItem(RES_BREAK);
2511  aNewSet.ClearItem(RES_BREAK);
2512  aOldSet.ClearItem(RES_PAGEDESC);
2513  aNewSet.ClearItem(RES_PAGEDESC);
2514  }
2515 
2516  if( 0x01 & nClear )
2517  {
2518  aOldSet.ClearItem( RES_TXTATR_FTN );
2519  aNewSet.ClearItem( RES_TXTATR_FTN );
2520  }
2521  if( 0x02 & nClear )
2522  {
2523  aOldSet.ClearItem( RES_TXTATR_FIELD );
2524  aNewSet.ClearItem( RES_TXTATR_FIELD );
2525  }
2526  if ( 0x04 & nClear )
2527  {
2528  if ( bLineSpace )
2529  {
2530  aOldSet.ClearItem( RES_PARATR_LINESPACING );
2531  aNewSet.ClearItem( RES_PARATR_LINESPACING );
2532  }
2533  if ( bRegister )
2534  {
2535  aOldSet.ClearItem( RES_PARATR_REGISTER );
2536  aNewSet.ClearItem( RES_PARATR_REGISTER );
2537  }
2538  }
2539  if ( 0x08 & nClear )
2540  {
2541  aOldSet.ClearItem( RES_PARATR_SPLIT );
2542  aNewSet.ClearItem( RES_PARATR_SPLIT );
2543  }
2544  if (aOldSet.Count() || aNewSet.Count())
2545  {
2546  SwContentFrame::Modify( &aOldSet, &aNewSet );
2547  }
2548  }
2549  else
2550  SwContentFrame::Modify( pOld, pNew );
2551  }
2552 
2553  if (isA11yRelevantAttribute(nWhich))
2554  {
2555  SwViewShell* pViewSh = getRootFrame() ? getRootFrame()->GetCurrShell() : nullptr;
2556  if ( pViewSh )
2557  {
2558  pViewSh->InvalidateAccessibleParaAttrs( *this );
2559  }
2560  }
2561  }
2562  break;
2563 
2564  // Process SwDocPosUpdate
2565  case RES_DOCPOS_UPDATE:
2566  {
2567  if( pOld && pNew )
2568  {
2569  const SwDocPosUpdate *pDocPos = static_cast<const SwDocPosUpdate*>(pOld);
2570  if( pDocPos->nDocPos <= getFrameArea().Top() )
2571  {
2572  const SwFormatField *pField = static_cast<const SwFormatField *>(pNew);
2573  TextFrameIndex const nIndex(MapModelToView(&rNode,
2574  pField->GetTextField()->GetStart()));
2575  InvalidateRange(SwCharRange(nIndex, TextFrameIndex(1)));
2576  }
2577  }
2578  break;
2579  }
2580  case RES_PARATR_SPLIT:
2581  if ( GetPrev() )
2582  CheckKeep();
2583  Prepare();
2584  bSetFieldsDirty = true;
2585  break;
2586  case RES_FRAMEDIR :
2587  assert(false); // should have been forwarded to SwContentFrame
2588  SetDerivedR2L( false );
2589  CheckDirChange();
2590  break;
2591  default:
2592  {
2593  Prepare();
2594  InvalidatePrt_();
2595  if ( !nWhich )
2596  {
2597  // is called by e. g. HiddenPara with 0
2598  SwFrame *pNxt;
2599  if ( nullptr != (pNxt = FindNext()) )
2600  pNxt->InvalidatePrt();
2601  }
2602  }
2603  } // switch
2604 
2605  if( bSetFieldsDirty )
2606  GetDoc().getIDocumentFieldsAccess().SetFieldsDirty( true, &rNode, 1 );
2607 
2608  if ( bRecalcFootnoteFlag )
2609  CalcFootnoteFlag();
2610 }
2611 
2612 bool SwTextFrame::GetInfo( SfxPoolItem &rHint ) const
2613 {
2614  if ( RES_VIRTPAGENUM_INFO == rHint.Which() && IsInDocBody() && ! IsFollow() )
2615  {
2616  SwVirtPageNumInfo &rInfo = static_cast<SwVirtPageNumInfo&>(rHint);
2617  const SwPageFrame *pPage = FindPageFrame();
2618  if ( pPage )
2619  {
2620  if ( pPage == rInfo.GetOrigPage() && !GetPrev() )
2621  {
2622  // this should be the one
2623  // (could only differ temporarily; is that disturbing?)
2624  rInfo.SetInfo( pPage, this );
2625  return false;
2626  }
2627  if ( pPage->GetPhyPageNum() < rInfo.GetOrigPage()->GetPhyPageNum() &&
2628  (!rInfo.GetPage() || pPage->GetPhyPageNum() > rInfo.GetPage()->GetPhyPageNum()))
2629  {
2630  // this could be the one
2631  rInfo.SetInfo( pPage, this );
2632  }
2633  }
2634  }
2635  return true;
2636 }
2637 
2638 void SwTextFrame::PrepWidows( const sal_uInt16 nNeed, bool bNotify )
2639 {
2640  OSL_ENSURE(GetFollow() && nNeed, "+SwTextFrame::Prepare: lost all friends");
2641 
2642  SwParaPortion *pPara = GetPara();
2643  if ( !pPara )
2644  return;
2645  pPara->SetPrepWidows();
2646 
2647  sal_uInt16 nHave = nNeed;
2648 
2649  // We yield a few lines and shrink in CalcPreps()
2650  SwSwapIfNotSwapped swap( this );
2651 
2652  SwTextSizeInfo aInf( this );
2653  SwTextMargin aLine( this, &aInf );
2654  aLine.Bottom();
2655  TextFrameIndex nTmpLen = aLine.GetCurr()->GetLen();
2656  while( nHave && aLine.PrevLine() )
2657  {
2658  if( nTmpLen )
2659  --nHave;
2660  nTmpLen = aLine.GetCurr()->GetLen();
2661  }
2662 
2663  // If it's certain that we can yield lines, the Master needs
2664  // to check the widow rule
2665  if( !nHave )
2666  {
2667  bool bSplit = true;
2668  if( !IsFollow() ) // only a master decides about orphans
2669  {
2670  const WidowsAndOrphans aWidOrp( this );
2671  bSplit = ( aLine.GetLineNr() >= aWidOrp.GetOrphansLines() &&
2672  aLine.GetLineNr() >= aLine.GetDropLines() );
2673  }
2674 
2675  if( bSplit )
2676  {
2677  GetFollow()->SetOfst( aLine.GetEnd() );
2678  aLine.TruncLines( true );
2679  if( pPara->IsFollowField() )
2680  GetFollow()->SetFieldFollow( true );
2681  }
2682  }
2683  if ( bNotify )
2684  {
2685  InvalidateSize_();
2686  InvalidatePage();
2687  }
2688 }
2689 
2690 static bool lcl_ErgoVadis(SwTextFrame* pFrame, TextFrameIndex & rPos, const PrepareHint ePrep)
2691 {
2692  const SwFootnoteInfo &rFootnoteInfo = pFrame->GetDoc().GetFootnoteInfo();
2693  if( ePrep == PREP_ERGOSUM )
2694  {
2695  if( rFootnoteInfo.aErgoSum.isEmpty() )
2696  return false;
2697  rPos = pFrame->GetOfst();
2698  }
2699  else
2700  {
2701  if( rFootnoteInfo.aQuoVadis.isEmpty() )
2702  return false;
2703  if( pFrame->HasFollow() )
2704  rPos = pFrame->GetFollow()->GetOfst();
2705  else
2706  rPos = TextFrameIndex(pFrame->GetText().getLength());
2707  if( rPos )
2708  --rPos; // our last character
2709  }
2710  return true;
2711 }
2712 
2713 // Silence over-eager warning emitted at least by GCC 5.3.1
2714 #if defined __GNUC__ && !defined __clang__
2715 # pragma GCC diagnostic push
2716 # pragma GCC diagnostic ignored "-Wstrict-overflow"
2717 #endif
2718 bool SwTextFrame::Prepare( const PrepareHint ePrep, const void* pVoid,
2719  bool bNotify )
2720 {
2721  bool bParaPossiblyInvalid = false;
2722 
2723  SwFrameSwapper aSwapper( this, false );
2724 
2725  if ( IsEmpty() )
2726  {
2727  switch ( ePrep )
2728  {
2729  case PREP_BOSS_CHGD:
2730  SetInvalidVert( true ); // Test
2731  [[fallthrough]];
2732  case PREP_WIDOWS_ORPHANS:
2733  case PREP_WIDOWS:
2734  case PREP_FTN_GONE : return bParaPossiblyInvalid;
2735 
2736  case PREP_POS_CHGD :
2737  {
2738  // We also need an InvalidateSize for Areas (with and without columns),
2739  // so that we format and bUndersized is set (if needed)
2740  if( IsInFly() || IsInSct() )
2741  {
2742  SwTwips nTmpBottom = GetUpper()->getFrameArea().Top() +
2743  GetUpper()->getFramePrintArea().Bottom();
2744  if( nTmpBottom < getFrameArea().Bottom() )
2745  break;
2746  }
2747  // Are there any free-flying frames on this page?
2748  SwTextFly aTextFly( this );
2749  if( aTextFly.IsOn() )
2750  {
2751  // Does any free-flying frame overlap?
2752  if ( aTextFly.Relax() || IsUndersized() )
2753  break;
2754  }
2755  if (GetTextNodeForParaProps()->GetSwAttrSet().GetRegister().GetValue())
2756  break;
2757 
2758  SwTextGridItem const*const pGrid(GetGridItem(FindPageFrame()));
2759  if (pGrid && GetTextNodeForParaProps()->GetSwAttrSet().GetParaGrid().GetValue())
2760  break;
2761 
2762  // i#28701 - consider anchored objects
2763  if ( GetDrawObjs() )
2764  break;
2765 
2766  return bParaPossiblyInvalid;
2767  }
2768  default:
2769  break;
2770  }
2771  }
2772 
2773  if( !HasPara() && PREP_MUST_FIT != ePrep )
2774  {
2775  SetInvalidVert( true ); // Test
2776  OSL_ENSURE( !IsLocked(), "SwTextFrame::Prepare: three of a perfect pair" );
2777  if ( bNotify )
2778  InvalidateSize();
2779  else
2780  InvalidateSize_();
2781  return bParaPossiblyInvalid;
2782  }
2783 
2784  // Get object from cache while locking
2785  SwTextLineAccess aAccess( this );
2786  SwParaPortion *pPara = aAccess.GetPara();
2787 
2788  switch( ePrep )
2789  {
2790  case PREP_MOVEFTN :
2791  {
2792  SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this);
2793  aFrm.Height(0);
2794  }
2795 
2796  {
2797  SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*this);
2798  aPrt.Height(0);
2799  }
2800 
2801  InvalidatePrt_();
2802  InvalidateSize_();
2803  [[fallthrough]];
2804  case PREP_ADJUST_FRM :
2805  pPara->SetPrepAdjust();
2806  if( IsFootnoteNumFrame() != pPara->IsFootnoteNum() ||
2807  IsUndersized() )
2808  {
2809  InvalidateRange(SwCharRange(TextFrameIndex(0), TextFrameIndex(1)), 1);
2810  if( GetOfst() && !IsFollow() )
2811  SetOfst_(TextFrameIndex(0));
2812  }
2813  break;
2814  case PREP_MUST_FIT :
2815  pPara->SetPrepMustFit(true);
2816  [[fallthrough]];
2817  case PREP_WIDOWS_ORPHANS :
2818  pPara->SetPrepAdjust();
2819  break;
2820  case PREP_WIDOWS :
2821  // MustFit is stronger than anything else
2822  if( pPara->IsPrepMustFit() )
2823  return bParaPossiblyInvalid;
2824  // see comment in WidowsAndOrphans::FindOrphans and CalcPreps()
2825  PrepWidows( *static_cast<const sal_uInt16 *>(pVoid), bNotify );
2826  break;
2827 
2828  case PREP_FTN :
2829  {
2830  SwTextFootnote const *pFootnote = static_cast<SwTextFootnote const *>(pVoid);
2831  if( IsInFootnote() )
2832  {
2833  // Am I the first TextFrame of a footnote?
2834  if( !GetPrev() )
2835  // So we're a TextFrame of the footnote, which has
2836  // to display the footnote number or the ErgoSum text
2837  InvalidateRange(SwCharRange(TextFrameIndex(0), TextFrameIndex(1)), 1);
2838 
2839  if( !GetNext() )
2840  {
2841  // We're the last Footnote; we need to update the
2842  // QuoVadis texts now
2843  const SwFootnoteInfo &rFootnoteInfo = GetDoc().GetFootnoteInfo();
2844  if( !pPara->UpdateQuoVadis( rFootnoteInfo.aQuoVadis ) )
2845  {
2846  TextFrameIndex nPos = pPara->GetParLen();
2847  if( nPos )
2848  --nPos;
2849  InvalidateRange( SwCharRange(nPos, TextFrameIndex(1)), 1);
2850  }
2851  }
2852  }
2853  else
2854  {
2855  // We are the TextFrame _with_ the footnote
2856  TextFrameIndex const nPos = MapModelToView(
2857  &pFootnote->GetTextNode(), pFootnote->GetStart());
2858  InvalidateRange(SwCharRange(nPos, TextFrameIndex(1)), 1);
2859  }
2860  break;
2861  }
2862  case PREP_BOSS_CHGD :
2863  {
2864  // Test
2865  {
2866  SetInvalidVert( false );
2867  bool bOld = IsVertical();
2868  SetInvalidVert( true );
2869  if( bOld != IsVertical() )
2870  InvalidateRange(SwCharRange(GetOfst(), TextFrameIndex(COMPLETE_STRING)));
2871  }
2872 
2873  if( HasFollow() )
2874  {
2875  TextFrameIndex nNxtOfst = GetFollow()->GetOfst();
2876  if( nNxtOfst )
2877  --nNxtOfst;
2878  InvalidateRange(SwCharRange( nNxtOfst, TextFrameIndex(1)), 1);
2879  }
2880  if( IsInFootnote() )
2881  {
2882  TextFrameIndex nPos;
2883  if( lcl_ErgoVadis( this, nPos, PREP_QUOVADIS ) )
2884  InvalidateRange( SwCharRange( nPos, TextFrameIndex(1)) );
2885  if( lcl_ErgoVadis( this, nPos, PREP_ERGOSUM ) )
2886  InvalidateRange( SwCharRange( nPos, TextFrameIndex(1)) );
2887  }
2888  // If we have a page number field, we must invalidate those spots
2889  SwTextNode const* pNode(nullptr);
2890  sw::MergedAttrIter iter(*this);
2891  TextFrameIndex const nEnd = GetFollow()
2892  ? GetFollow()->GetOfst() : TextFrameIndex(COMPLETE_STRING);
2893  for (SwTextAttr const* pHt = iter.NextAttr(&pNode); pHt; pHt = iter.NextAttr(&pNode))
2894  {
2895  TextFrameIndex const nStart(MapModelToView(pNode, pHt->GetStart()));
2896  if (nStart >= GetOfst())
2897  {
2898  if (nStart >= nEnd)
2899  break;
2900 
2901  // If we're flowing back and own a Footnote, the Footnote also flows
2902  // with us. So that it doesn't obstruct us, we send ourselves
2903  // an ADJUST_FRM.
2904  // pVoid != 0 means MoveBwd()
2905  const sal_uInt16 nWhich = pHt->Which();
2906  if (RES_TXTATR_FIELD == nWhich ||
2907  (HasFootnote() && pVoid && RES_TXTATR_FTN == nWhich))
2908  InvalidateRange(SwCharRange(nStart, TextFrameIndex(1)), 1);
2909  }
2910  }
2911  // A new boss, a new chance for growing
2912  if( IsUndersized() )
2913  {
2914  InvalidateSize_();
2915  InvalidateRange(SwCharRange(GetOfst(), TextFrameIndex(1)), 1);
2916  }
2917  break;
2918  }
2919 
2920  case PREP_POS_CHGD :
2921  {
2922  if ( isFramePrintAreaValid() )
2923  {
2924  SwTextGridItem const*const pGrid(GetGridItem(FindPageFrame()));
2925  if (pGrid && GetTextNodeForParaProps()->GetSwAttrSet().GetParaGrid().GetValue())
2926  InvalidatePrt();
2927  }
2928 
2929  // If we don't overlap with anybody:
2930  // did any free-flying frame overlapped _before_ the position change?
2931  bool bFormat = pPara->HasFly();
2932  if( !bFormat )
2933  {
2934  if( IsInFly() )
2935  {
2936  SwTwips nTmpBottom = GetUpper()->getFrameArea().Top() +
2937  GetUpper()->getFramePrintArea().Bottom();
2938  if( nTmpBottom < getFrameArea().Bottom() )
2939  bFormat = true;
2940  }
2941  if( !bFormat )
2942  {
2943  if ( GetDrawObjs() )
2944  {
2945  const size_t nCnt = GetDrawObjs()->size();
2946  for ( size_t i = 0; i < nCnt; ++i )
2947  {
2948  SwAnchoredObject* pAnchoredObj = (*GetDrawObjs())[i];
2949  // i#28701 - consider all
2950  // to-character anchored objects
2951  if ( pAnchoredObj->GetFrameFormat().GetAnchor().GetAnchorId()
2952  == RndStdIds::FLY_AT_CHAR )
2953  {
2954  bFormat = true;
2955  break;
2956  }
2957  }
2958  }
2959  if( !bFormat )
2960  {
2961  // Are there any free-flying frames on this page?
2962  SwTextFly aTextFly( this );
2963  if( aTextFly.IsOn() )
2964  {
2965  // Does any free-flying frame overlap?
2966  bFormat = aTextFly.Relax() || IsUndersized();
2967  }
2968  }
2969  }
2970  }
2971 
2972  if( bFormat )
2973  {
2974  if( !IsLocked() )
2975  {
2976  if( pPara->GetRepaint().HasArea() )
2977  SetCompletePaint();
2978  Init();
2979  pPara = nullptr;
2980  InvalidateSize_();
2981  }
2982  }
2983  else
2984  {
2985  if (GetTextNodeForParaProps()->GetSwAttrSet().GetRegister().GetValue())
2986  bParaPossiblyInvalid = Prepare( PREP_REGISTER, nullptr, bNotify );
2987  // The Frames need to be readjusted, which caused by changes
2988  // in position
2989  else if( HasFootnote() )
2990  {
2991  bParaPossiblyInvalid = Prepare( PREP_ADJUST_FRM, nullptr, bNotify );
2992  InvalidateSize_();
2993  }
2994  else
2995  return bParaPossiblyInvalid; // So that there's no SetPrep()
2996 
2997  if (bParaPossiblyInvalid)
2998  {
2999  // It's possible that pPara was deleted above; retrieve it again
3000  pPara = aAccess.GetPara();
3001  }
3002 
3003  }
3004  break;
3005  }
3006  case PREP_REGISTER:
3007  if (GetTextNodeForParaProps()->GetSwAttrSet().GetRegister().GetValue())
3008  {
3009  pPara->SetPrepAdjust();
3010  CalcLineSpace();
3011 
3012  // It's possible that pPara was deleted above; retrieve it again
3013  bParaPossiblyInvalid = true;
3014  pPara = aAccess.GetPara();
3015 
3016  InvalidateSize();
3017  InvalidatePrt_();
3018  SwFrame* pNxt;
3019  if ( nullptr != ( pNxt = GetIndNext() ) )
3020  {
3021  pNxt->InvalidatePrt_();
3022  if ( pNxt->IsLayoutFrame() )
3023  pNxt->InvalidatePage();
3024  }
3025  SetCompletePaint();
3026  }
3027  break;
3028  case PREP_FTN_GONE :
3029  {
3030  // If a Follow is calling us, because a footnote is being deleted, our last
3031  // line has to be formatted, so that the first line of the Follow can flow up.
3032  // Which had flowed to the next page to be together with the footnote (this is
3033  // especially true for areas with columns)
3034  OSL_ENSURE( GetFollow(), "PREP_FTN_GONE may only be called by Follow" );
3035  TextFrameIndex nPos = GetFollow()->GetOfst();
3036  if( IsFollow() && GetOfst() == nPos ) // If we don't have a mass of text, we call our
3037  FindMaster()->Prepare( PREP_FTN_GONE ); // Master's Prepare
3038  if( nPos )
3039  --nPos; // The char preceding our Follow
3040  InvalidateRange(SwCharRange(nPos, TextFrameIndex(1)));
3041  return bParaPossiblyInvalid;
3042  }
3043  case PREP_ERGOSUM:
3044  case PREP_QUOVADIS:
3045  {
3046  TextFrameIndex nPos;
3047  if( lcl_ErgoVadis( this, nPos, ePrep ) )
3048  InvalidateRange(SwCharRange(nPos, TextFrameIndex(1)));
3049  }
3050  break;
3051  case PREP_FLY_ATTR_CHG:
3052  {
3053  if( pVoid )
3054  {
3055  TextFrameIndex const nWhere = CalcFlyPos( static_cast<SwFrameFormat const *>(pVoid) );
3056  OSL_ENSURE( TextFrameIndex(COMPLETE_STRING) != nWhere, "Prepare: Why me?" );
3057  InvalidateRange(SwCharRange(nWhere, TextFrameIndex(1)));
3058  return bParaPossiblyInvalid;
3059  }
3060  [[fallthrough]]; // else: continue with default case block
3061  }
3062  case PREP_CLEAR:
3063  default:
3064  {
3065  if( IsLocked() )
3066  {
3067  if( PREP_FLY_ARRIVE == ePrep || PREP_FLY_LEAVE == ePrep )
3068  {
3069  TextFrameIndex const nLen = (GetFollow()
3070  ? GetFollow()->GetOfst()
3071  : TextFrameIndex(COMPLETE_STRING))
3072  - GetOfst();
3073  InvalidateRange( SwCharRange( GetOfst(), nLen ) );
3074  }
3075  }
3076  else
3077  {
3078  if( pPara->GetRepaint().HasArea() )
3079  SetCompletePaint();
3080  Init();
3081  pPara = nullptr;
3082  if( GetOfst() && !IsFollow() )
3083  SetOfst_( TextFrameIndex(0) );
3084  if ( bNotify )
3085  InvalidateSize();
3086  else
3087  InvalidateSize_();
3088  }
3089  return bParaPossiblyInvalid; // no SetPrep() happened
3090  }
3091  }
3092  if( pPara )
3093  {
3094  pPara->SetPrep();
3095  }
3096 
3097  return bParaPossiblyInvalid;
3098 }
3099 #if defined __GNUC__ && !defined __clang__
3100 # pragma GCC diagnostic pop
3101 #endif
3102 
3111 class SwTestFormat
3112 {
3113  SwTextFrame *pFrame;
3114  SwParaPortion *pOldPara;
3115  SwRect aOldFrame, aOldPrt;
3116 public:
3117  SwTestFormat( SwTextFrame* pTextFrame, const SwFrame* pPrv, SwTwips nMaxHeight );
3118  ~SwTestFormat();
3119 };
3120 
3121 SwTestFormat::SwTestFormat( SwTextFrame* pTextFrame, const SwFrame* pPre, SwTwips nMaxHeight )
3122  : pFrame( pTextFrame )
3123 {
3124  aOldFrame = pFrame->getFrameArea();
3125  aOldPrt = pFrame->getFramePrintArea();
3126 
3127  SwRectFnSet aRectFnSet(pFrame);
3128  SwTwips nLower = aRectFnSet.GetBottomMargin(*pFrame);
3129 
3130  {
3131  // indeed, here the GetUpper()->getFramePrintArea() gets copied and manipulated
3132  SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*pFrame);
3133  aFrm.setSwRect(pFrame->GetUpper()->getFramePrintArea());
3134  aFrm += pFrame->GetUpper()->getFrameArea().Pos();
3135  aRectFnSet.SetHeight( aFrm, nMaxHeight );
3136 
3137  if( pFrame->GetPrev() )
3138  {
3139  aRectFnSet.SetPosY(
3140  aFrm,
3141  aRectFnSet.GetBottom(pFrame->GetPrev()->getFrameArea()) - ( aRectFnSet.IsVert() ? nMaxHeight + 1 : 0 ) );
3142  }
3143  }
3144 
3145  SwBorderAttrAccess aAccess( SwFrame::GetCache(), pFrame );
3146  const SwBorderAttrs &rAttrs = *aAccess.Get();
3147 
3148  {
3149  SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*pFrame);
3150  aRectFnSet.SetPosX(aPrt, rAttrs.CalcLeft( pFrame ) );
3151  }
3152 
3153  if( pPre )
3154  {
3155  SwTwips nUpper = pFrame->CalcUpperSpace( &rAttrs, pPre );
3156  SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*pFrame);
3157  aRectFnSet.SetPosY(aPrt, nUpper );
3158  }
3159 
3160  {
3161  SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*pFrame);
3162  aRectFnSet.SetHeight( aPrt, std::max( 0L , aRectFnSet.GetHeight(pFrame->getFrameArea()) - aRectFnSet.GetTop(aPrt) - nLower ) );
3163  aRectFnSet.SetWidth( aPrt, aRectFnSet.GetWidth(pFrame->getFrameArea()) - ( rAttrs.CalcLeft( pFrame ) + rAttrs.CalcRight( pFrame ) ) );
3164  }
3165 
3166  pOldPara = pFrame->HasPara() ? pFrame->GetPara() : nullptr;
3167  pFrame->SetPara( new SwParaPortion(), false );
3168  OSL_ENSURE( ! pFrame->IsSwapped(), "A frame is swapped before Format_" );
3169 
3170  if ( pFrame->IsVertical() )
3171  pFrame->SwapWidthAndHeight();
3172 
3173  SwTextFormatInfo aInf( pFrame->getRootFrame()->GetCurrShell()->GetOut(), pFrame, false, true, true );
3174  SwTextFormatter aLine( pFrame, &aInf );
3175 
3176  pFrame->Format_( aLine, aInf );
3177 
3178  if ( pFrame->IsVertical() )
3179  pFrame->SwapWidthAndHeight();
3180 
3181  OSL_ENSURE( ! pFrame->IsSwapped(), "A frame is swapped after Format_" );
3182 }
3183 
3184 SwTestFormat::~SwTestFormat()
3185 {
3186  {
3187  SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*pFrame);
3188  aFrm.setSwRect(aOldFrame);
3189  }
3190 
3191  {
3192  SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*pFrame);
3193  aPrt.setSwRect(aOldPrt);
3194  }
3195 
3196  pFrame->SetPara( pOldPara );
3197 }
3198 
3199 bool SwTextFrame::TestFormat( const SwFrame* pPrv, SwTwips &rMaxHeight, bool &bSplit )
3200 {
3201  PROTOCOL_ENTER( this, PROT::TestFormat, DbgAction::NONE, nullptr )
3202 
3203  if( IsLocked() && GetUpper()->getFramePrintArea().Width() <= 0 )
3204  return false;
3205 
3206  SwTestFormat aSave( this, pPrv, rMaxHeight );
3207 
3208  return SwTextFrame::WouldFit( rMaxHeight, bSplit, true );
3209 }
3210 
3223 bool SwTextFrame::WouldFit( SwTwips &rMaxHeight, bool &bSplit, bool bTst )
3224 {
3225  OSL_ENSURE( ! IsVertical() || ! IsSwapped(),
3226  "SwTextFrame::WouldFit with swapped frame" );
3227  SwRectFnSet aRectFnSet(this);
3228 
3229  if( IsLocked() )
3230  return false;
3231 
3232  // it can happen that the IdleCollector removed the cached information
3233  if( !IsEmpty() )
3234  GetFormatted();
3235 
3236  // i#27801 - correction: 'short cut' for empty paragraph
3237  // can *not* be applied, if test format is in progress. The test format doesn't
3238  // adjust the frame and the printing area - see method <SwTextFrame::Format_(..)>,
3239  // which is called in <SwTextFrame::TestFormat(..)>
3240  if ( IsEmpty() && !bTst )
3241  {
3242  bSplit = false;
3243  SwTwips nHeight = aRectFnSet.IsVert() ? getFramePrintArea().SSize().Width() : getFramePrintArea().SSize().Height();
3244  if( rMaxHeight < nHeight )
3245  return false;
3246  else
3247  {
3248  rMaxHeight -= nHeight;
3249  return true;
3250  }
3251  }
3252 
3253  // GetPara can still be 0 in edge cases
3254  // We return true in order to be reformatted on the new Page
3255  OSL_ENSURE( HasPara() || IsHiddenNow(), "WouldFit: GetFormatted() and then !HasPara()" );
3256  if( !HasPara() || ( !aRectFnSet.GetHeight(getFrameArea()) && IsHiddenNow() ) )
3257  return true;
3258 
3259  // Because the Orphan flag only exists for a short moment, we also check
3260  // whether the Framesize is set to very huge by CalcPreps, in order to
3261  // force a MoveFwd
3262  if( IsWidow() || ( aRectFnSet.IsVert() ?
3263  ( 0 == getFrameArea().Left() ) :
3264  ( LONG_MAX - 20000 < getFrameArea().Bottom() ) ) )
3265  {
3266  SetWidow(false);
3267  if ( GetFollow() )
3268  {
3269  // If we've ended up here due to a Widow request by our Follow, we check
3270  // whether there's a Follow with a real height at all.
3271  // Else (e.g. for newly created SctFrames) we ignore the IsWidow() and
3272  // still check if we can find enough room
3273  if( ( ( ! aRectFnSet.IsVert() && LONG_MAX - 20000 >= getFrameArea().Bottom() ) ||
3274  ( aRectFnSet.IsVert() && 0 < getFrameArea().Left() ) ) &&
3275  ( GetFollow()->IsVertical() ?
3276  !GetFollow()->getFrameArea().Width() :
3277  !GetFollow()->getFrameArea().Height() ) )
3278  {
3279  SwTextFrame* pFoll = GetFollow()->GetFollow();
3280  while( pFoll &&
3281  ( pFoll->IsVertical() ?
3282  !pFoll->getFrameArea().Width() :
3283  !pFoll->getFrameArea().Height() ) )
3284  pFoll = pFoll->GetFollow();
3285  if( pFoll )
3286  return false;
3287  }
3288  else
3289  return false;
3290  }
3291  }
3292 
3293  SwSwapIfNotSwapped swap( this );
3294 
3295  SwTextSizeInfo aInf( this );
3296  SwTextMargin aLine( this, &aInf );
3297 
3298  WidowsAndOrphans aFrameBreak( this, rMaxHeight, bSplit );
3299 
3300  bool bRet = true;
3301 
3302  aLine.Bottom();
3303  // is breaking necessary?
3304  bSplit = !aFrameBreak.IsInside( aLine );
3305  if ( bSplit )
3306  bRet = !aFrameBreak.IsKeepAlways() && aFrameBreak.WouldFit( aLine, rMaxHeight, bTst );
3307  else
3308  {
3309  // we need the total height including the current line
3310  aLine.Top();
3311  do
3312  {
3313  rMaxHeight -= aLine.GetLineHeight();
3314  } while ( aLine.Next() );
3315  }
3316 
3317  return bRet;
3318 }
3319 
3320 sal_uInt16 SwTextFrame::GetParHeight() const
3321 {
3322  OSL_ENSURE( ! IsVertical() || ! IsSwapped(),
3323  "SwTextFrame::GetParHeight with swapped frame" );
3324 
3325  if( !HasPara() )
3326  { // For non-empty paragraphs this is a special case
3327  // For UnderSized we can simply just ask 1 Twip more
3328  sal_uInt16 nRet = static_cast<sal_uInt16>(getFramePrintArea().SSize().Height());
3329  if( IsUndersized() )
3330  {
3331  if( IsEmpty() || GetText().isEmpty() )
3332  nRet = static_cast<sal_uInt16>(EmptyHeight());
3333  else
3334  ++nRet;
3335  }
3336  return nRet;
3337  }
3338 
3339  // TODO: Refactor and improve code
3340  const SwLineLayout* pLineLayout = GetPara();
3341  sal_uInt16 nHeight = pLineLayout ? pLineLayout->GetRealHeight() : 0;
3342 
3343  // Is this paragraph scrolled? Our height until now is at least
3344  // one line height too low then
3345  if( GetOfst() && !IsFollow() )
3346  nHeight *= 2;
3347 
3348  while ( pLineLayout && pLineLayout->GetNext() )
3349  {
3350  pLineLayout = pLineLayout->GetNext();
3351  nHeight = nHeight + pLineLayout->GetRealHeight();
3352  }
3353 
3354  return nHeight;
3355 }
3356 
3360 SwTextFrame* SwTextFrame::GetFormatted( bool bForceQuickFormat )
3361 {
3362  vcl::RenderContext* pRenderContext = getRootFrame()->GetCurrShell()->GetOut();
3363  SwSwapIfSwapped swap( this );
3364 
3365  // In case the SwLineLayout was cleared out of the s_pTextCache, recreate it
3366  // Not for empty paragraphs
3367  if( !HasPara() && !(isFrameAreaDefinitionValid() && IsEmpty()) )
3368  {
3369  // Calc() must be called, because frame position can be wrong
3370  const bool bFormat = isFrameAreaSizeValid();
3371  Calc(pRenderContext); // calls Format() if invalid
3372 
3373  // If the flags were valid (hence bFormat=true), Calc did nothing,
3374  // so Format() must be called manually in order to recreate
3375  // the SwLineLayout that has been deleted from the
3376  // SwTextFrame::s_pTextCache (hence !HasPara() above).
3377  // Optimization with FormatQuick()
3378  if( bFormat && !FormatQuick( bForceQuickFormat ) )
3379  Format(getRootFrame()->GetCurrShell()->GetOut());
3380  }
3381 
3382  return this;
3383 }
3384 
3385 SwTwips SwTextFrame::CalcFitToContent()
3386 {
3387  // i#31490
3388  // If we are currently locked, we better return with a
3389  // fairly reasonable value:
3390  if ( IsLocked() )
3391  return getFramePrintArea().Width();
3392 
3393  SwParaPortion* pOldPara = GetPara();
3394  SwParaPortion *pDummy = new SwParaPortion();
3395  SetPara( pDummy, false );
3396  const SwPageFrame* pPage = FindPageFrame();
3397 
3398  const Point aOldFramePos = getFrameArea().Pos();
3399  const SwTwips nOldFrameWidth = getFrameArea().Width();
3400  const SwTwips nOldPrtWidth = getFramePrintArea().Width();
3401  const SwTwips nPageWidth = GetUpper()->IsVertical() ?
3402  pPage->getFramePrintArea().Height() :
3403  pPage->getFramePrintArea().Width();
3404 
3405  {
3406  SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this);
3407  aFrm.Width( nPageWidth );
3408  }
3409 
3410  {
3411  SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*this);
3412  aPrt.Width( nPageWidth );
3413  }
3414 
3415  // i#25422 objects anchored as character in RTL
3416  if ( IsRightToLeft() )
3417  {
3418  SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this);
3419  aFrm.Pos().AdjustX(nOldFrameWidth - nPageWidth );
3420  }
3421 
3422  TextFrameLockGuard aLock( this );
3423 
3424  SwTextFormatInfo aInf( getRootFrame()->GetCurrShell()->GetOut(), this, false, true, true );
3425  aInf.SetIgnoreFly( true );
3426  SwTextFormatter aLine( this, &aInf );
3427  SwHookOut aHook( aInf );
3428 
3429  // i#54031 - assure minimum of MINLAY twips.
3430  const SwTwips nMax = std::max( SwTwips(MINLAY), aLine.CalcFitToContent_() + 1 );
3431 
3432  {
3433  SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this);
3434  aFrm.Width( nOldFrameWidth );
3435 
3436  // i#25422 objects anchored as character in RTL
3437  if ( IsRightToLeft() )
3438  {
3439  aFrm.Pos() = aOldFramePos;
3440  }
3441  }
3442 
3443  {
3444  SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*this);
3445  aPrt.Width( nOldPrtWidth );
3446  }
3447 
3448  SetPara( pOldPara );
3449 
3450  return nMax;
3451 }
3452 
3459 void SwTextFrame::CalcAdditionalFirstLineOffset()
3460 {
3461  if ( IsLocked() )
3462  return;
3463 
3464  // reset additional first line offset
3465  mnAdditionalFirstLineOffset = 0;
3466 
3467  const SwTextNode* pTextNode( GetTextNodeForParaProps() );
3468  // sw_redlinehide: check that pParaPropsNode is the correct one
3469  assert(pTextNode->IsNumbered(getRootFrame()) == pTextNode->IsNumbered(nullptr));
3470  if (pTextNode->IsNumbered(getRootFrame()) &&
3471  pTextNode->IsCountedInList() && pTextNode->GetNumRule())
3472  {
3473  int nListLevel = pTextNode->GetActualListLevel();
3474 
3475  if (nListLevel < 0)
3476  nListLevel = 0;
3477 
3478  if (nListLevel >= MAXLEVEL)
3479  nListLevel = MAXLEVEL - 1;
3480 
3481  const SwNumFormat& rNumFormat =
3482  pTextNode->GetNumRule()->Get( static_cast<sal_uInt16>(nListLevel) );
3483  if ( rNumFormat.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT )
3484  {
3485  // keep current paragraph portion and apply dummy paragraph portion
3486  SwParaPortion* pOldPara = GetPara();
3487  SwParaPortion *pDummy = new SwParaPortion();
3488  SetPara( pDummy, false );
3489 
3490  // lock paragraph
3491  TextFrameLockGuard aLock( this );
3492 
3493  // simulate text formatting
3494  SwTextFormatInfo aInf( getRootFrame()->GetCurrShell()->GetOut(), this, false, true, true );
3495  aInf.SetIgnoreFly( true );
3496  SwTextFormatter aLine( this, &aInf );
3497  SwHookOut aHook( aInf );
3498  aLine.CalcFitToContent_();
3499 
3500  // determine additional first line offset
3501  const SwLinePortion* pFirstPortion = aLine.GetCurr()->GetFirstPortion();
3502  if ( pFirstPortion->InNumberGrp() && !pFirstPortion->IsFootnoteNumPortion() )
3503  {
3504  SwTwips nNumberPortionWidth( pFirstPortion->Width() );
3505 
3506  const SwLinePortion* pPortion = pFirstPortion->GetNextPortion();
3507  while ( pPortion &&
3508  pPortion->InNumberGrp() && !pPortion->IsFootnoteNumPortion())
3509  {
3510  nNumberPortionWidth += pPortion->Width();
3511  pPortion = pPortion->GetNextPortion();
3512  }
3513 
3514  if ( ( IsRightToLeft() &&
3515  rNumFormat.GetNumAdjust() == SvxAdjust::Left ) ||
3516  ( !IsRightToLeft() &&
3517  rNumFormat.GetNumAdjust() == SvxAdjust::Right ) )
3518  {
3519  mnAdditionalFirstLineOffset = -nNumberPortionWidth;
3520  }
3521  else if ( rNumFormat.GetNumAdjust() == SvxAdjust::Center )
3522  {
3523  mnAdditionalFirstLineOffset = -(nNumberPortionWidth/2);
3524  }
3525  }
3526 
3527  // restore paragraph portion
3528  SetPara( pOldPara );
3529  }
3530  }
3531 }
3532 
3545 void SwTextFrame::CalcHeightOfLastLine( const bool _bUseFont )
3546 {
3547  // i#71281
3548  // Invalidate printing area, if height of last line changes
3549  const SwTwips nOldHeightOfLastLine( mnHeightOfLastLine );
3550 
3551  // determine output device
3552  SwViewShell* pVsh = getRootFrame()->GetCurrShell();
3553  OSL_ENSURE( pVsh, "<SwTextFrame::_GetHeightOfLastLineForPropLineSpacing()> - no SwViewShell" );
3554 
3555  // i#78921
3556  // There could be no <SwViewShell> instance in the case of loading a binary
3557  // StarOffice file format containing an embedded Writer document.
3558  if ( !pVsh )
3559  {
3560  return;
3561  }
3562  OutputDevice* pOut = pVsh->GetOut();
3563  const IDocumentSettingAccess *const pIDSA = &GetDoc().getIDocumentSettingAccess();
3564  if ( !pVsh->GetViewOptions()->getBrowseMode() ||
3565  pVsh->GetViewOptions()->IsPrtFormat() )
3566  {
3567  pOut = GetDoc().getIDocumentDeviceAccess().getReferenceDevice( true );
3568  }
3569  OSL_ENSURE( pOut, "<SwTextFrame::_GetHeightOfLastLineForPropLineSpacing()> - no OutputDevice" );
3570 
3571  if ( !pOut )
3572  {
3573  return;
3574  }
3575 
3576  // determine height of last line
3577  if ( _bUseFont || pIDSA->get(DocumentSettingId::OLD_LINE_SPACING ) )
3578  {
3579  // former determination of last line height for proportional line
3580  // spacing - take height of font set at the paragraph
3581  // FIXME actually... must the font match across all nodes?
3582  SwFont aFont( &GetTextNodeForParaProps()->GetSwAttrSet(), pIDSA );
3583 
3584  // we must ensure that the font is restored correctly on the OutputDevice
3585  // otherwise Last!=Owner could occur
3586  if ( pLastFont )
3587  {
3588  SwFntObj *pOldFont = pLastFont;
3589  pLastFont = nullptr;
3590  aFont.SetFntChg( true );
3591  aFont.ChgPhysFnt( pVsh, *pOut );
3592  mnHeightOfLastLine = aFont.GetHeight( pVsh, *pOut );
3593  assert(pLastFont && "coverity[var_deref_model] - pLastFont should be set in SwSubFont::ChgFnt");
3594  pLastFont->Unlock();
3595  pLastFont = pOldFont;
3596  pLastFont->SetDevFont( pVsh, *pOut );
3597  }
3598  else
3599  {
3600  vcl::Font aOldFont = pOut->GetFont();
3601  aFont.SetFntChg( true );
3602  aFont.ChgPhysFnt( pVsh, *pOut );
3603  mnHeightOfLastLine = aFont.GetHeight( pVsh, *pOut );
3604  assert(pLastFont && "coverity[var_deref_model] - pLastFont should be set in SwSubFont::ChgFnt");
3605  pLastFont->Unlock();
3606  pLastFont = nullptr;
3607  pOut->SetFont( aOldFont );
3608  }
3609  }
3610  else
3611  {
3612  // new determination of last line height - take actually height of last line
3613  // i#89000
3614  // assure same results, if paragraph is undersized
3615  if ( IsUndersized() )
3616  {
3617  mnHeightOfLastLine = 0;
3618  }
3619  else
3620  {
3621  bool bCalcHeightOfLastLine = true;
3622  if ( ( !HasPara() && IsEmpty( ) ) || GetText().isEmpty() )
3623  {
3624  mnHeightOfLastLine = EmptyHeight();
3625  bCalcHeightOfLastLine = false;
3626  }
3627 
3628  if ( bCalcHeightOfLastLine )
3629  {
3630  OSL_ENSURE( HasPara(),
3631  "<SwTextFrame::CalcHeightOfLastLine()> - missing paragraph portions." );
3632  const SwLineLayout* pLineLayout = GetPara();
3633  while ( pLineLayout && pLineLayout->GetNext() )
3634  {
3635  // iteration to last line
3636  pLineLayout = pLineLayout->GetNext();
3637  }
3638  if ( pLineLayout )
3639  {
3640  SwTwips nAscent, nDescent, nDummy1, nDummy2;
3641  // i#47162 - suppress consideration of
3642  // fly content portions and the line portion.
3643  pLineLayout->MaxAscentDescent( nAscent, nDescent,
3644  nDummy1, nDummy2,
3645  nullptr, true );
3646  // i#71281
3647  // Suppress wrong invalidation of printing area, if method is
3648  // called recursive.
3649  // Thus, member <mnHeightOfLastLine> is only set directly, if
3650  // no recursive call is needed.
3651  const SwTwips nNewHeightOfLastLine = nAscent + nDescent;
3652  // i#47162 - if last line only contains
3653  // fly content portions, <mnHeightOfLastLine> is zero.
3654  // In this case determine height of last line by the font
3655  if ( nNewHeightOfLastLine == 0 )
3656  {
3657  CalcHeightOfLastLine( true );
3658  }
3659  else
3660  {
3661  mnHeightOfLastLine = nNewHeightOfLastLine;
3662  }
3663  }
3664  }
3665  }
3666  }
3667  // i#71281
3668  // invalidate printing area, if height of last line changes
3669  if ( mnHeightOfLastLine != nOldHeightOfLastLine )
3670  {
3671  InvalidatePrt();
3672  }
3673 }
3674 
3684 long SwTextFrame::GetLineSpace( const bool _bNoPropLineSpace ) const
3685 {
3686  long nRet = 0;
3687 
3688  const SvxLineSpacingItem &rSpace = GetTextNodeForParaProps()->GetSwAttrSet().GetLineSpacing();
3689 
3690  switch( rSpace.GetInterLineSpaceRule() )
3691  {
3692  case SvxInterLineSpaceRule::Prop:
3693  {
3694  if ( _bNoPropLineSpace )
3695  {
3696  break;
3697  }
3698 
3699  // i#11860 - adjust spacing implementation for object positioning
3700  // - compatibility to MS Word
3701  nRet = GetHeightOfLastLine();
3702 
3703  long nTmp = nRet;
3704  nTmp *= rSpace.GetPropLineSpace();
3705  nTmp /= 100;
3706  nTmp -= nRet;
3707  if ( nTmp > 0 )
3708  nRet = nTmp;
3709  else
3710  nRet = 0;
3711  }
3712  break;
3713  case SvxInterLineSpaceRule::Fix:
3714  {
3715  if ( rSpace.GetInterLineSpace() > 0 )
3716  nRet = rSpace.GetInterLineSpace();
3717  }
3718  break;
3719  default:
3720  break;
3721  }
3722  return nRet;
3723 }
3724 
3725 sal_uInt16 SwTextFrame::FirstLineHeight() const
3726 {
3727  if ( !HasPara() )
3728  {
3729  if( IsEmpty() && isFrameAreaDefinitionValid() )
3730  return IsVertical() ? static_cast<sal_uInt16>(getFramePrintArea().Width()) : static_cast<sal_uInt16>(getFramePrintArea().Height());
3731  return USHRT_MAX;
3732  }
3733  const SwParaPortion *pPara = GetPara();
3734  if ( !pPara )
3735  return USHRT_MAX;
3736 
3737  return pPara->Height();
3738 }
3739 
3740 sal_uInt16 SwTextFrame::GetLineCount(TextFrameIndex const nPos)
3741 {
3742  sal_uInt16 nRet = 0;
3743  SwTextFrame *pFrame = this;
3744  do
3745  {
3746  pFrame->GetFormatted();
3747  if( !pFrame->HasPara() )
3748  break;
3749  SwTextSizeInfo aInf( pFrame );
3750  SwTextMargin aLine( pFrame, &aInf );
3751  if (TextFrameIndex(COMPLETE_STRING) == nPos)
3752  aLine.Bottom();
3753  else
3754  aLine.CharToLine( nPos );
3755  nRet = nRet + aLine.GetLineNr();
3756  pFrame = pFrame->GetFollow();
3757  } while ( pFrame && pFrame->GetOfst() <= nPos );
3758  return nRet;
3759 }
3760 
3761 void SwTextFrame::ChgThisLines()
3762 {
3763  // not necessary to format here (GetFormatted etc.), because we have to come from there!
3764  sal_uLong nNew = 0;
3765  const SwLineNumberInfo &rInf = GetDoc().GetLineNumberInfo();
3766  if ( !GetText().isEmpty() && HasPara() )
3767  {
3768  SwTextSizeInfo aInf( this );
3769  SwTextMargin aLine( this, &aInf );
3770  if ( rInf.IsCountBlankLines() )
3771  {
3772  aLine.Bottom();
3773  nNew = static_cast<sal_uLong>(aLine.GetLineNr());
3774  }
3775  else
3776  {
3777  do
3778  {
3779  if( aLine.GetCurr()->HasContent() )
3780  ++nNew;
3781  } while ( aLine.NextLine() );
3782  }
3783  }
3784  else if ( rInf.IsCountBlankLines() )
3785  nNew = 1;
3786 
3787  if ( nNew != mnThisLines )
3788  {
3789  if (!IsInTab() && GetTextNodeForParaProps()->GetSwAttrSet().GetLineNumber().IsCount())
3790  {
3791  mnAllLines -= mnThisLines;
3792  mnThisLines = nNew;
3793  mnAllLines += mnThisLines;
3794  SwFrame *pNxt = GetNextContentFrame();
3795  while( pNxt && pNxt->IsInTab() )
3796  {
3797  if( nullptr != (pNxt = pNxt->FindTabFrame()) )
3798  pNxt = pNxt->FindNextCnt();
3799  }
3800  if( pNxt )
3801  pNxt->InvalidateLineNum();
3802 
3803  // Extend repaint to the bottom.
3804  if ( HasPara() )
3805  {
3806  SwRepaint& rRepaint = GetPara()->GetRepaint();
3807  rRepaint.Bottom( std::max( rRepaint.Bottom(),
3808  getFrameArea().Top()+getFramePrintArea().Bottom()));
3809  }
3810  }
3811  else // Paragraphs which are not counted should not manipulate the AllLines.
3812  mnThisLines = nNew;
3813  }
3814 }
3815 
3816 void SwTextFrame::RecalcAllLines()
3817 {
3818  ValidateLineNum();
3819 
3820  if ( !IsInTab() )
3821  {
3822  const sal_uLong nOld = GetAllLines();
3823  const SwFormatLineNumber &rLineNum = GetTextNodeForParaProps()->GetSwAttrSet().GetLineNumber();
3824  sal_uLong nNewNum;
3825  const bool bRestart = GetDoc().GetLineNumberInfo().IsRestartEachPage();
3826 
3827  if ( !IsFollow() && rLineNum.GetStartValue() && rLineNum.IsCount() )
3828  nNewNum = rLineNum.GetStartValue() - 1;
3829  // If it is a follow or not has not be considered if it is a restart at each page; the
3830  // restart should also take effect at follows.
3831  else if ( bRestart && FindPageFrame()->FindFirstBodyContent() == this )
3832  {
3833  nNewNum = 0;
3834  }
3835  else
3836  {
3837  SwContentFrame *pPrv = GetPrevContentFrame();
3838  while ( pPrv &&
3839  (pPrv->IsInTab() || pPrv->IsInDocBody() != IsInDocBody()) )
3840  pPrv = pPrv->GetPrevContentFrame();
3841 
3842  // i#78254 Restart line numbering at page change
3843  // First body content may be in table!
3844  if ( bRestart && pPrv && pPrv->FindPageFrame() != FindPageFrame() )
3845  pPrv = nullptr;
3846 
3847  nNewNum = pPrv ? static_cast<SwTextFrame*>(pPrv)->GetAllLines() : 0;
3848  }
3849  if ( rLineNum.IsCount() )
3850  nNewNum += GetThisLines();
3851 
3852  if ( nOld != nNewNum )
3853  {
3854  mnAllLines = nNewNum;
3855  SwContentFrame *pNxt = GetNextContentFrame();
3856  while ( pNxt &&
3857  (pNxt->IsInTab() || pNxt->IsInDocBody() != IsInDocBody()) )
3858  pNxt = pNxt->GetNextContentFrame();
3859  if ( pNxt )
3860  {
3861  if ( pNxt->GetUpper() != GetUpper() )
3862  pNxt->InvalidateLineNum();
3863  else
3864  pNxt->InvalidateLineNum_();
3865  }
3866  }
3867  }
3868 }
3869 
3870 void SwTextFrame::VisitPortions( SwPortionHandler& rPH ) const
3871 {
3872  const SwParaPortion* pPara = isFrameAreaDefinitionValid() ? GetPara() : nullptr;
3873 
3874  if (pPara)
3875  {
3876  if ( IsFollow() )
3877  rPH.Skip( GetOfst() );
3878 
3879  const SwLineLayout* pLine = pPara;
3880  while ( pLine )
3881  {
3882  const SwLinePortion* pPor = pLine->GetFirstPortion();
3883  while ( pPor )
3884  {
3885  pPor->HandlePortion( rPH );
3886  pPor = pPor->GetNextPortion();
3887  }
3888 
3889  rPH.LineBreak(pLine->Width());
3890  pLine = pLine->GetNext();
3891  }
3892  }
3893 
3894  rPH.Finish();
3895 }
3896 
3897 const SwScriptInfo* SwTextFrame::GetScriptInfo() const
3898 {
3899  const SwParaPortion* pPara = GetPara();
3900  return pPara ? &pPara->GetScriptInfo() : nullptr;
3901 }
3902 
3906 static SwTwips lcl_CalcFlyBasePos( const SwTextFrame& rFrame, SwRect aFlyRect,
3907  SwTextFly const & rTextFly )
3908 {
3909  SwRectFnSet aRectFnSet(&rFrame);
3910  SwTwips nRet = rFrame.IsRightToLeft() ?
3911  aRectFnSet.GetRight(rFrame.getFrameArea()) :
3912  aRectFnSet.GetLeft(rFrame.getFrameArea());
3913 
3914  do
3915  {
3916  SwRect aRect = rTextFly.GetFrame( aFlyRect );
3917  if ( 0 != aRectFnSet.GetWidth(aRect) )
3918  {
3919  if ( rFrame.IsRightToLeft() )
3920  {
3921  if ( aRectFnSet.GetRight(aRect) -
3922  aRectFnSet.GetRight(aFlyRect) >= 0 )
3923  {
3924  aRectFnSet.SetRight(
3925 aFlyRect, aRectFnSet.GetLeft(aRect) );
3926  nRet = aRectFnSet.GetLeft(aRect);
3927  }
3928  else
3929  break;
3930  }
3931  else
3932  {
3933  if ( aRectFnSet.GetLeft(aFlyRect) -
3934  aRectFnSet.GetLeft(aRect) >= 0 )
3935  {
3936  aRectFnSet.SetLeft(
3937 aFlyRect, aRectFnSet.GetRight(aRect) + 1 );
3938  nRet = aRectFnSet.GetRight(aRect);
3939  }
3940  else
3941  break;
3942  }
3943  }
3944  else
3945  break;
3946  }
3947  while ( aRectFnSet.GetWidth(aFlyRect) > 0 );
3948 
3949  return nRet;
3950 }
3951 
3952 void SwTextFrame::CalcBaseOfstForFly()
3953 {
3954  OSL_ENSURE( !IsVertical() || !IsSwapped(),
3955  "SwTextFrame::CalcBasePosForFly with swapped frame!" );
3956 
3957  if (!GetDoc().getIDocumentSettingAccess().get(DocumentSettingId::ADD_FLY_OFFSETS))
3958  return;
3959 
3960  SwRectFnSet aRectFnSet(this);
3961 
3962  SwRect aFlyRect( getFrameArea().Pos() + getFramePrintArea().Pos(), getFramePrintArea().SSize() );
3963 
3964  // Get first 'real' line and adjust position and height of line rectangle.
3965  // Correct behaviour if no 'real' line exists
3966  // (empty paragraph with and without a dummy portion)
3967  SwTwips nFlyAnchorVertOfstNoWrap = 0;
3968  {
3969  SwTwips nTop = aRectFnSet.GetTop(aFlyRect);
3970  const SwLineLayout* pLay = GetPara();
3971  SwTwips nLineHeight = 200;
3972  while( pLay && pLay->IsDummy() && pLay->GetNext() )
3973  {
3974  nTop += pLay->Height();
3975  nFlyAnchorVertOfstNoWrap += pLay->Height();
3976  pLay = pLay->GetNext();
3977  }
3978  if ( pLay )
3979  {
3980  nLineHeight = pLay->Height();
3981  }
3982  aRectFnSet.SetTopAndHeight( aFlyRect, nTop, nLineHeight );
3983  }
3984 
3985  SwTextFly aTextFly( this );
3986  aTextFly.SetIgnoreCurrentFrame( true );
3987  aTextFly.SetIgnoreContour( true );
3988  // ignore objects in page header|footer for
3989  // text frames not in page header|footer
3990  aTextFly.SetIgnoreObjsInHeaderFooter( true );
3991  SwTwips nRet1 = lcl_CalcFlyBasePos( *this, aFlyRect, aTextFly );
3992  aTextFly.SetIgnoreCurrentFrame( false );
3993  SwTwips nRet2 = lcl_CalcFlyBasePos( *this, aFlyRect, aTextFly );
3994 
3995  // make values relative to frame start position
3996  SwTwips nLeft = IsRightToLeft() ?
3997  aRectFnSet.GetRight(getFrameArea()) :
3998  aRectFnSet.GetLeft(getFrameArea());
3999 
4000  mnFlyAnchorOfst = nRet1 - nLeft;
4001  mnFlyAnchorOfstNoWrap = nRet2 - nLeft;
4002 
4003  if (!GetDoc().getIDocumentSettingAccess().get(DocumentSettingId::ADD_VERTICAL_FLY_OFFSETS))
4004  return;
4005 
4006  if (mnFlyAnchorOfstNoWrap > 0)
4007  mnFlyAnchorVertOfstNoWrap = nFlyAnchorVertOfstNoWrap;
4008 }
4009 
4010 SwTwips SwTextFrame::GetBaseVertOffsetForFly(bool bIgnoreFlysAnchoredAtThisFrame) const
4011 {
4012  return bIgnoreFlysAnchoredAtThisFrame ? 0 : mnFlyAnchorVertOfstNoWrap;
4013 }
4014 
4018 void SwTextFrame::repaintTextFrames( const SwTextNode& rNode )
4019 {
4020  SwIterator<SwTextFrame, SwTextNode, sw::IteratorMode::UnwrapMulti> aIter(rNode);
4021  for( const SwTextFrame *pFrame = aIter.First(); pFrame; pFrame = aIter.Next() )
4022  {
4023  SwRect aRec( pFrame->GetPaintArea() );
4024  const SwRootFrame *pRootFrame = pFrame->getRootFrame();
4025  SwViewShell *pCurShell = pRootFrame ? pRootFrame->GetCurrShell() : nullptr;
4026  if( pCurShell )
4027  pCurShell->InvalidateWindows( aRec );
4028  }
4029 }
4030 
4031 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
SwTextFrame::HideHidden
void HideHidden()
Removes Textfrm's attachments, when it's hidden.
Definition: txtfrm.cxx:1440
DbgAction::NONE
SwTextNode::SetWordCountDirty
void SetWordCountDirty(bool bNew) const
Definition: txtedt.cxx:2225
SwViewShell::GetOut
vcl::RenderContext * GetOut() const
Definition: viewsh.hxx:341
SfxBoolItem::GetValue
bool GetValue() const
SwTextFrame::GetParHeight
sal_uInt16 GetParHeight() const
Returns the sum of line height in pLine.
Definition: txtfrm.cxx:3320
pLastFont
SwFntObj * pLastFont
Definition: fntcache.cxx:69
SwTextFrame::CalcAdditionalFirstLineOffset
void CalcAdditionalFirstLineOffset()
Simulate format for a list item paragraph, whose list level attributes are in LABEL_ALIGNMENT mode...
Definition: txtfrm.cxx:3459
SwTextFrame::Init
void Init()
This is public, as it needs to be called by some methods in order to save the Prepare USE WITH CAUTIO...
Definition: txtfrm.cxx:760
SwLineLayout::HasContent
bool HasContent() const
Definition: porlay.hxx:123
SwContact
Base class for the following contact objects (frame + draw objects).
Definition: dcontact.hxx:66
SwFrame
Base class of the Writer layout elements.
Definition: frame.hxx:295
SwTextFrame
Represents the visualization of a paragraph.
Definition: txtfrm.hxx:149
SwTextFrame::SwitchVerticalToHorizontal
void SwitchVerticalToHorizontal(SwRect &rRect) const
Calculates the coordinates of a rectangle when switching from vertical to horizontal layout...
Definition: txtfrm.cxx:590
SwParaPortion::IsFootnoteNum
bool IsFootnoteNum() const
Definition: porlay.hxx:298
SwRectFnSet::SetTopAndHeight
void SetTopAndHeight(SwRect &rRect, long nTop, long nHeight) const
Definition: frame.hxx:1404
SwTextFrame::GetBaseVertOffsetForFly
SwTwips GetBaseVertOffsetForFly(bool bIgnoreFlysAnchoredAtThisFrame) const
Definition: txtfrm.cxx:4010
SwNode::GetIndex
sal_uLong GetIndex() const
Definition: node.hxx:282
SwModify::Add
void Add(SwClient *pDepend)
Definition: calbck.cxx:217
SwFlowFrame::IsFollow
bool IsFollow() const
Definition: flowfrm.hxx:166
sw::RedlineDelText::nStart
sal_Int32 const nStart
Definition: hints.hxx:115
SwFrame::GetDrawObjs
const SwSortedObjs * GetDrawObjs() const
Definition: frame.hxx:543
SvxLineSpacingItem::GetPropLineSpace
sal_uInt16 GetPropLineSpace() const
SwTextFly::SetIgnoreCurrentFrame
void SetIgnoreCurrentFrame(bool bNew)
Definition: txtfly.hxx:361
SwTextFrame::EmptyHeight
SwTwips EmptyHeight() const
Definition: porrst.cxx:207
SwTextIter::GetLineNr
sal_uInt16 GetLineNr() const
Definition: itrtxt.hxx:87
SwDigitModeModifier::nOldLanguageType
LanguageType const nOldLanguageType
Definition: txtfrm.hxx:942
SwPosition
Marks a position in the document model.
Definition: pam.hxx:35
sw::GetAttrMerged
SwTextNode const & GetAttrMerged(SfxItemSet &rFormatSet, SwTextNode const &rNode, SwRootFrame const *pLayout)
Definition: txtfrm.cxx:379
SwParaPortion::SetPrepAdjust
void SetPrepAdjust()
Definition: porlay.hxx:290
RES_CHRATR_CJK_LANGUAGE
#define RES_CHRATR_CJK_LANGUAGE
Definition: hintids.hxx:92
SwContentFrame::GetNextContentFrame
SwContentFrame * GetNextContentFrame() const
Definition: cntfrm.hxx:98
SwFormatField::GetField
const SwField * GetField() const
Definition: fmtfld.hxx:71
lcl_CalcFlyBasePos
static SwTwips lcl_CalcFlyBasePos(const SwTextFrame &rFrame, SwRect aFlyRect, SwTextFly const &rTextFly)
Helper function for SwTextFrame::CalcBasePosForFly()
Definition: txtfrm.cxx:3906
GetNode
SwContentNode * GetNode(SwPaM &rPam, bool &rbFirst, SwMoveFnCollection const &fnMove, bool const bInReadOnly, SwRootFrame const *const i_pLayout)
This function returns the next node in direction of search.
Definition: pam.cxx:754
SwFrame::IsInDocBody
bool IsInDocBody() const
Definition: frame.hxx:919
SwFrame::IsInFly
bool IsInFly() const
Definition: frame.hxx:937
sw::MoveText::nSourceStart
sal_Int32 nSourceStart
Definition: hints.hxx:105
LANGUAGE_ARABIC_SAUDI_ARABIA
#define LANGUAGE_ARABIC_SAUDI_ARABIA
SwTestFormat::aOldPrt
SwRect aOldPrt
Definition: txtfrm.cxx:3115
SwFrame::IsInSct
bool IsInSct() const
Definition: frame.hxx:943
SwTextFrame::GetLangOfChar
LanguageType GetLangOfChar(TextFrameIndex nIndex, sal_uInt16 nScript, bool bNoChar=false) const
Definition: txtfrm.cxx:1340
SwDigitModeModifier::SwDigitModeModifier
SwDigitModeModifier(const OutputDevice &rOutp, LanguageType eCurLang)
Definition: txtfrm.cxx:734
SwDigitModeModifier::rOut
const OutputDevice & rOut
Definition: txtfrm.hxx:941
RES_ATTRSET_CHG
#define RES_ATTRSET_CHG
Definition: hintids.hxx:285
SwDoc::GetLineNumberInfo
const SwLineNumberInfo & GetLineNumberInfo() const
Definition: lineinfo.cxx:50
SwPosSize::Height
sal_uInt16 Height() const
Definition: possiz.hxx:44
RES_CHRATR_LANGUAGE
#define RES_CHRATR_LANGUAGE
Definition: hintids.hxx:78
LANGUAGE_ENGLISH_US
#define LANGUAGE_ENGLISH_US
SwLineLayout::GetNext
SwLineLayout * GetNext()
Definition: porlay.hxx:143
SwTextNode::GetText
const OUString & GetText() const
Definition: ndtxt.hxx:211
SwTextFrame::IsSwapped
bool IsSwapped() const
Definition: txtfrm.hxx:524
SwAttrSet::GetBackground
const SvxBrushItem & GetBackground(bool=true) const
Definition: frmatr.hxx:58
RES_INS_TXT
#define RES_INS_TXT
Definition: hintids.hxx:286
SwTextNode::IsWrongDirty
bool IsWrongDirty() const
Definition: txtedt.cxx:2251
SwTextIter::NextLine
const SwLineLayout * NextLine()
Definition: itrtxt.cxx:125
SwLinePortion::InNumberGrp
bool InNumberGrp() const
Definition: porlin.hxx:101
SwTextNode::FieldHidesPara
bool FieldHidesPara(const SwField &rField) const
Definition: ndtxt.hxx:716
SwParaPortion::GetDelta
long & GetDelta()
Definition: porlay.hxx:268
SwTextNode::GetpSwpHints
SwpHints * GetpSwpHints()
Definition: ndtxt.hxx:219
GetValue
std::string GetValue
SwTextFrame::HasPara
bool HasPara() const
Definition: txtfrm.hxx:808
SwDoc::getIDocumentDeviceAccess
IDocumentDeviceAccess const & getIDocumentDeviceAccess() const
Definition: doc.cxx:270
SwTextFrame::CalcBaseOfstForFly
void CalcBaseOfstForFly()
Definition: txtfrm.cxx:3952
SwViewShell::InvalidateAccessibleParaAttrs
void InvalidateAccessibleParaAttrs(const SwTextFrame &rTextFrame)
invalidate attributes for paragraphs and paragraph's characters
Definition: viewsh.cxx:2449
SwWrongList::Move
void Move(sal_Int32 nPos, sal_Int32 nDiff)
Change all values after the given position.
Definition: wrong.cxx:266
RES_DEL_CHR
#define RES_DEL_CHR
Definition: hintids.hxx:287
Size::Height
long Height() const
SwPosition::nNode
SwNodeIndex nNode
Definition: pam.hxx:37
GPOS_NONE
GPOS_NONE
IGrammarContact::getGrammarCheck
virtual SwGrammarMarkUp * getGrammarCheck(SwTextNode &rTextNode, bool bCreate)=0
getGrammarCheck checks if the given text node is blocked by the current cursor if not...
SwFrame::SetCompletePaint
void SetCompletePaint() const
Definition: frame.hxx:970
SwTextLineAccess::GetPara
SwParaPortion * GetPara()
Definition: txtcache.cxx:49
SwFrame::IsInFootnote
bool IsInFootnote() const
Definition: frame.hxx:925
SwFrame::GetDep
SwModify * GetDep()
use these so we can grep for SwFrame's GetRegisteredIn accesses beware that SwTextFrame may return sw...
Definition: frame.hxx:457
SwTextFrame::SwitchHorizontalToVertical
void SwitchHorizontalToVertical(SwRect &rRect) const
Calculates the coordinates of a rectangle when switching from horizontal to vertical layout...
Definition: txtfrm.cxx:483
SwTextFrame::InvalidateRange_
void InvalidateRange_(const SwCharRange &, const long=0)
Definition: txtfrm.cxx:1690
SwTextFrame::repaintTextFrames
static void repaintTextFrames(const SwTextNode &rNode)
Repaint all text frames of the given text node.
Definition: txtfrm.cxx:4018
SwRootFrame::SetNeedGrammarCheck
void SetNeedGrammarCheck(bool bVal)
Definition: rootfrm.hxx:260
SwFrameAreaDefinition::FrameAreaWriteAccess::setSwRect
void setSwRect(const SwRect &rNew)
Definition: frame.hxx:194
SwFrame::SetDerivedR2L
void SetDerivedR2L(bool bNew)
Definition: frame.hxx:610
SwTextFrame::CalcFitToContent
SwTwips CalcFitToContent()
Simulates a formatting as if there were not right margin or Flys or other obstacles and returns the w...
Definition: txtfrm.cxx:3385
SwTextNode::Len
virtual sal_Int32 Len() const override
Definition: ndtxt.cxx:284
sal_uLong
sal_uIntPtr sal_uLong
RES_FRAMEDIR
#define RES_FRAMEDIR
Definition: hintids.hxx:225
SwFrameAreaDefinition::getFramePrintArea
const SwRect & getFramePrintArea() const
Definition: frame.hxx:176
SwTextFrame::GetInfo
virtual bool GetInfo(SfxPoolItem &) const override
Definition: txtfrm.cxx:2612
SwFrame::InvalidateLineNum_
void InvalidateLineNum_()
Definition: frame.hxx:773
SwPortionHandler
The SwPortionHandler interface implements a visitor for the layout engine's text portions.
Definition: SwPortionHandler.hxx:45
MINLAY
#define MINLAY
Definition: swtypes.hxx:66
SwScriptInfo::SetInvalidityA
void SetInvalidityA(const TextFrameIndex nPos)
Definition: scriptinfo.hxx:108
SwTestFormat::aOldFrame
SwRect aOldFrame
Definition: txtfrm.cxx:3115
SwTextFrame::SwTextFrame
SwTextFrame(SwTextNode *const, SwFrame *, sw::FrameMode eMode)
Definition: txtfrm.cxx:774
SwFrame::GetCache
static SwCache & GetCache()
Definition: frame.hxx:500
SwTextFrame::GetLineSpace
long GetLineSpace(const bool _bNoPropLineSpacing=false) const
Returns the additional line spacing for the next paragraph.
Definition: txtfrm.cxx:3684
SwTextFrame::GetTextNodeForFirstText
SwTextNode const * GetTextNodeForFirstText() const
Definition: txtfrm.cxx:1314
SwTextFrame::GetMergedPara
sw::MergedPara * GetMergedPara()
Definition: txtfrm.hxx:438
SwTextFly
The purpose of this class is to be the universal interface between formatting/text output and the pos...
Definition: txtfly.hxx:119
SwRectFnSet::SetPosX
void SetPosX(SwRect &rRect, long nNew) const
Definition: frame.hxx:1376
RES_FRMATR_END
#define RES_FRMATR_END
Definition: hintids.hxx:236
SwContentNode::getLayoutFrame
SwContentFrame * getLayoutFrame(const SwRootFrame *, const SwPosition *pPos=nullptr, std::pair< Point, bool > const *pViewPosAndCalcFrame=nullptr) const
Definition: node.cxx:1148
SwFrame::InvalidateSize_
void InvalidateSize_()
Definition: frame.hxx:749
SwDoc
Definition: doc.hxx:185
SwIterator::Next
TElementType * Next()
Definition: calbck.hxx:376
SwFlowFrame::HasFollow
bool HasFollow() const
Definition: flowfrm.hxx:165
SwTextFrame::GetPara
SwParaPortion * GetPara()
Definition: txtcache.cxx:89
SwRect::Height
void Height(long nNew)
Definition: swrect.hxx:189
sw::MergedAttrIterReverse::PrevAttr
SwTextAttr const * PrevAttr(SwTextNode const **ppNode=nullptr)
Definition: txtfrm.cxx:234
SwTextFormatInfo::SetIgnoreFly
void SetIgnoreFly(const bool bNew)
Definition: inftxt.hxx:576
SwRectFnSet::GetBottom
long GetBottom(const SwRect &rRect) const
Definition: frame.hxx:1354
SwTextFrame::GetOfst
TextFrameIndex GetOfst() const
Definition: txtfrm.hxx:426
RES_CHRATR_FONT
#define RES_CHRATR_FONT
Definition: hintids.hxx:75
SwNodeIndex::GetNode
SwNode & GetNode() const
Definition: ndindex.hxx:118
SwTwips
long SwTwips
Definition: swtypes.hxx:49
SwTextIter::CharToLine
void CharToLine(TextFrameIndex)
Definition: itrtxt.cxx:194
RES_PARATR_REGISTER
#define RES_PARATR_REGISTER
Definition: hintids.hxx:169
SwTextFrame::Format_
void Format_(vcl::RenderContext *pRenderContext, SwParaPortion *pPara)
Definition: frmform.cxx:1687
PROT::TestFormat
SwRectFnSet::IsVert
bool IsVert() const
Definition: frame.hxx:1343
sw::RedlineUnDelText::nStart
sal_Int32 nStart
Definition: hints.hxx:125
SwTextIter::Next
const SwLineLayout * Next()
Definition: itrtxt.cxx:109
SwTextNode::IsSmartTagDirty
bool IsSmartTagDirty() const
Definition: txtedt.cxx:2277
SwTextFrame::HideAndShowObjects
void HideAndShowObjects()
Hides respectively shows objects, which are anchored at paragraph, at/as a character of the paragraph...
Definition: txtfrm.cxx:1546
SwRect::Pos
void Pos(const Point &rNew)
Definition: swrect.hxx:167
WidowsAndOrphans::WouldFit
bool WouldFit(SwTextMargin &rLine, SwTwips &rMaxHeight, bool bTest)
Definition: widorp.cxx:478
sw
Dialog to specify the properties of date form field.
Definition: accfrmobj.cxx:38
SwFrame::FindNext
SwFrame * FindNext()
Definition: frame.hxx:1117
RES_CHRATR_CJK_FONT
#define RES_CHRATR_CJK_FONT
Definition: hintids.hxx:90
SwFrame::Calc
virtual void Calc(vcl::RenderContext *pRenderContext) const
Definition: trvlfrm.cxx:1788
SwLineLayout::MaxAscentDescent
void MaxAscentDescent(SwTwips &_orAscent, SwTwips &_orDescent, SwTwips &_orObjAscent, SwTwips &_orObjDescent, const SwLinePortion *_pDontConsiderPortion=nullptr, const bool _bNoFlyCntPorAndLinePor=false) const
determine ascent and descent for positioning of as-character anchored object
Definition: porlay.cxx:609
SwTextFrameBreak::IsKeepAlways
bool IsKeepAlways() const
Definition: widorp.hxx:38
SwRect
Of course Writer needs its own rectangles.
Definition: swrect.hxx:34
RES_TXTATR_CHARFMT
#define RES_TXTATR_CHARFMT
Definition: hintids.hxx:142
SwBorderAttrs::CalcRight
long CalcRight(const SwFrame *pCaller) const
Definition: frmtool.cxx:2108
SwTextFrame::GetText
const OUString & GetText() const
Returns the text portion we want to edit (for inline see underneath)
Definition: txtfrm.cxx:1290
RES_PARATR_SPLIT
#define RES_PARATR_SPLIT
Definition: hintids.hxx:163
SwViewOption::IsShowHiddenPara
bool IsShowHiddenPara() const
Definition: viewopt.hxx:358
SwLineNumberInfo::IsCountBlankLines
bool IsCountBlankLines() const
Definition: lineinfo.hxx:84
SwTextNode::SetSmartTags
void SetSmartTags(SwWrongList *pNew, bool bDelete=true)
Definition: txtedt.cxx:2200
SwTextIter::Y
SwTwips Y() const
Definition: itrtxt.hxx:90
RES_DOCPOS_UPDATE
#define RES_DOCPOS_UPDATE
Definition: hintids.hxx:291
SwTextNode::SetGrammarCheckDirty
void SetGrammarCheckDirty(bool bNew) const
Definition: txtedt.cxx:2256
SwRootFrame
The root element of a Writer document layout.
Definition: rootfrm.hxx:79
sw::Extent::pNode
SwTextNode * pNode
Definition: txtfrm.hxx:85
SwParaPortion
Collection of SwLineLayout instances, represents the paragraph text in Writer layout.
Definition: porlay.hxx:229
WidowsAndOrphans::GetOrphansLines
sal_uInt16 GetOrphansLines() const
Definition: widorp.hxx:61
SwTextFrame::SetPara
void SetPara(SwParaPortion *pNew, bool bDelete=true)
Definition: txtcache.cxx:128
SwVirtPageNumInfo::GetPage
const SwPageFrame * GetPage()
Definition: hints.hxx:271
SwDocPosUpdate::nDocPos
const SwTwips nDocPos
Definition: hints.hxx:186
SwTextNode::GetActualListLevel
int GetActualListLevel() const
Returns the actual list level of this text node, when it is a list item.
Definition: ndtxt.cxx:4096
SwFrame::ValidateLineNum
void ValidateLineNum()
Definition: frame.hxx:738
SwTextFrame::TestFormat
bool TestFormat(const SwFrame *pPrv, SwTwips &nMaxHeight, bool &bSplit)
The WouldFit equivalent for temporarily rewired TextFrames nMaxHeight returns the required size here ...
Definition: txtfrm.cxx:3199
SwFrameAreaDefinition::isFrameAreaDefinitionValid
bool isFrameAreaDefinitionValid() const
Definition: frame.hxx:167
SwCharRange::Start
TextFrameIndex & Start()
Definition: porlay.hxx:45
sw::MergedAttrIter::NextAttr
SwTextAttr const * NextAttr(SwTextNode const **ppNode=nullptr)
Definition: txtfrm.cxx:97
SwTextFrame::CalcFootnoteFlag
void CalcFootnoteFlag(TextFrameIndex nStop=TextFrameIndex(COMPLETE_STRING))
Does the Frame have a local footnote (in this Frame or Follow)?
Definition: txtftn.cxx:86
SwRectFnSet::SetPosY
void SetPosY(SwRect &rRect, long nNew) const
Definition: frame.hxx:1377
SwFrame::CheckDirChange
void CheckDirChange()
checks the layout direction and invalidates the lower frames recursively, if necessary.
Definition: ssfrm.cxx:190
SwFrame::IsVertLRBT
bool IsVertLRBT() const
Definition: frame.hxx:959
SwPortionHandler::Finish
virtual void Finish()=0
end of paragraph.
SwTextFrame::FormatQuick
bool FormatQuick(bool bForceQuickFormat)
Definition: frmform.cxx:1962
CreateNameFlags::Bottom
SwPageFrame::GetPhyPageNum
sal_uInt16 GetPhyPageNum() const
Definition: pagefrm.hxx:190
SwTextFrame::IsHiddenNow
bool IsHiddenNow() const
Hidden.
Definition: txtfrm.cxx:1357
SwTextFrame::CalcLineSpace
void CalcLineSpace()
Definition: txtfrm.cxx:1724
SwDoc::getIDocumentFieldsAccess
IDocumentFieldsAccess const & getIDocumentFieldsAccess() const
Definition: doc.cxx:389
SwBorderAttrs::CalcLeft
long CalcLeft(const SwFrame *pCaller) const
Definition: frmtool.cxx:2156
CH_TXTATR_BREAKWORD
#define CH_TXTATR_BREAKWORD
Definition: hintids.hxx:43
sw::MoveText::nDestStart
sal_Int32 nDestStart
Definition: hints.hxx:104
SwTextFly::GetFrame
SwRect GetFrame(const SwRect &rPortion) const
Definition: txtfly.hxx:356
RES_UPDATE_ATTR
#define RES_UPDATE_ATTR
Definition: hintids.hxx:289
SwAttrSet::GetRegister
const SwRegisterItem & GetRegister(bool=true) const
Definition: paratr.hxx:184
SwViewOption::IsFieldName
bool IsFieldName() const
Definition: viewopt.hxx:252
SwFlowFrame::CalcUpperSpace
SwTwips CalcUpperSpace(const SwBorderAttrs *pAttrs=nullptr, const SwFrame *pPr=nullptr, const bool _bConsiderGrid=true) const
method to determine the upper space hold by the frame
Definition: flowfrm.cxx:1389
getGrammarContact
IGrammarContact * getGrammarContact(const SwTextNode &rTextNode)
getGrammarContact() delivers the grammar contact of the document (for a given textnode) ...
Definition: docnew.cxx:797
sal_Unicode
sal_uInt16 sal_Unicode
COL_TRANSPARENT
constexpr::Color COL_TRANSPARENT(0xFF, 0xFF, 0xFF, 0xFF)
SwFrame::InvalidateNextPrtArea
void InvalidateNextPrtArea()
method to invalidate printing area of next frame #i11859#
Definition: findfrm.cxx:1279
SwAnchoredObject
wrapper class for the positioning of Writer fly frames and drawing objects
Definition: anchoredobject.hxx:44
sw::MergedAttrIterByEnd::m_Hints
std::vector< std::pair< SwTextNode const *, SwTextAttr const * > > m_Hints
Definition: txtfrm.hxx:1007
SwLineNumberInfo::IsRestartEachPage
bool IsRestartEachPage() const
Definition: lineinfo.hxx:90
SwTextFrame::mnAllLines
sal_uLong mnAllLines
Definition: txtfrm.hxx:166
SwUpdateAttr::getEnd
sal_Int32 getEnd() const
Definition: hints.hxx:150
SwTextFrame::GetScriptInfo
const SwScriptInfo * GetScriptInfo() const
Returns the script info stored at the paraportion.
Definition: txtfrm.cxx:3897
SvxBrushItem::GetGraphicPos
SvxGraphicPosition GetGraphicPos() const
SwTextNode::RemoveFromListRLHidden
void RemoveFromListRLHidden()
Definition: ndtxt.cxx:4331
SwpHints::SortIfNeedBe
void SortIfNeedBe() const
Trigger the sorting if necessary.
Definition: ndhints.hxx:176
SwRect::Top
void Top(const long nTop)
Definition: swrect.hxx:202
sw::RedlineDelText
new delete redline is created
Definition: hints.hxx:112
XATTR_FILL_LAST
#define XATTR_FILL_LAST
SwPosition::nContent
SwIndex nContent
Definition: pam.hxx:38
SwFrameAreaDefinition::getFrameArea
const SwRect & getFrameArea() const
Definition: frame.hxx:175
Point::setX
void setX(long nX)
SwFormatField::GetTextField
const SwTextField * GetTextField() const
Definition: fmtfld.hxx:89
SwViewOption::getBrowseMode
bool getBrowseMode() const
Definition: viewopt.hxx:433
XATTR_FILL_FIRST
#define XATTR_FILL_FIRST
OutputDevice::GetFont
const vcl::Font & GetFont() const
SwTextFrame::GetThisLines
sal_uLong GetThisLines() const
Definition: txtfrm.hxx:657
SwFrame::IsInTab
bool IsInTab() const
Definition: frame.hxx:931
sw::CheckParaRedlineMerge
std::unique_ptr< sw::MergedPara > CheckParaRedlineMerge(SwTextFrame &rFrame, SwTextNode &rTextNode, FrameMode eMode)
Definition: redlnitr.cxx:54
SwTextFrame::ResetBlinkPor
void ResetBlinkPor() const
Definition: txtfrm.hxx:873
SwVirtPageNumInfo::SetInfo
void SetInfo(const SwPageFrame *pPg, const SwFrame *pF)
Definition: hints.hxx:274
sw::Extent::nEnd
sal_Int32 nEnd
Definition: txtfrm.hxx:87
utl::ConfigManager::IsFuzzing
static bool IsFuzzing()
SwTestFormat::SwTestFormat
SwTestFormat(SwTextFrame *pTextFrame, const SwFrame *pPrv, SwTwips nMaxHeight)
Definition: txtfrm.cxx:3121
SwRectFnSet::GetBottomMargin
long GetBottomMargin(const SwFrame &rFrame) const
Definition: frame.hxx:1380
SwFrame::IsTextFrame
bool IsTextFrame() const
Definition: frame.hxx:1210
SwTextFrame::GetCacheIdx
sal_uInt16 GetCacheIdx() const
Definition: txtfrm.hxx:602
SwTextAttr::GetStart
sal_Int32 GetStart() const
Definition: txatbase.hxx:82
SwFont::SetFntChg
void SetFntChg(const bool bNew)
Definition: swfont.hxx:208
MAXLEVEL
const sal_uInt8 MAXLEVEL
Definition: swtypes.hxx:95
sw::UpdateMergedParaForDelete
TextFrameIndex UpdateMergedParaForDelete(MergedPara &rMerged, bool isRealDelete, SwTextNode const &rNode, sal_Int32 nIndex, sal_Int32 nLen)
Definition: txtfrm.cxx:1031
SwScriptInfo::InitScriptInfo
void InitScriptInfo(const SwTextNode &rNode, sw::MergedPara const *pMerged, bool bRTL)
Definition: porlay.cxx:743
SwParaPortion::HasFly
bool HasFly() const
Definition: porlay.hxx:281
SwFrameSwapper::pFrame
const SwTextFrame * pFrame
Definition: txtfrm.hxx:921
SwLayoutModeModifier::m_rOut
const OutputDevice & m_rOut
Definition: txtfrm.hxx:930
IDocumentFieldsAccess::SetFieldsDirty
virtual bool SetFieldsDirty(bool b, const SwNode *pChk, sal_uLong nLen)=0
IsInRange
bool IsInRange(const sal_uInt16 *pRange, const sal_uInt16 nId)
check if ID is in range of attribute set IDs
Definition: swatrset.cxx:441
SwTextFrame::mnThisLines
sal_uLong mnThisLines
Definition: txtfrm.hxx:167
SwTextFrame::~SwTextFrame
virtual ~SwTextFrame() override
Definition: txtfrm.cxx:896
SwPortionHandler::LineBreak
virtual void LineBreak(sal_Int32 nWidth)=0
line break.
SwFormatLineNumber::GetStartValue
sal_uLong GetStartValue() const
Definition: fmtline.hxx:57
o3tl::strong_int< sal_uInt16, struct LanguageTypeTag >
sw::MergedPara
Describes parts of multiple text nodes, which will form a text frame, even when redlines are hidden a...
Definition: txtfrm.hxx:954
RES_PARATR_BEGIN
#define RES_PARATR_BEGIN
Definition: hintids.hxx:160
SwContentFrame::GetPrevContentFrame
SwContentFrame * GetPrevContentFrame() const
Definition: cntfrm.hxx:106
SwRectFnSet::GetLeft
long GetLeft(const SwRect &rRect) const
Definition: frame.hxx:1355
SwRectFnSet::GetRight
long GetRight(const SwRect &rRect) const
Definition: frame.hxx:1356
SwRect::Right
void Right(const long nRight)
Definition: swrect.hxx:198
SwFont::ChgPhysFnt
void ChgPhysFnt(SwViewShell const *pSh, OutputDevice &rOut)
Definition: swfont.cxx:972
Point::setY
void setY(long nY)
SwTextNode::SetWrongDirty
void SetWrongDirty(WrongState eNew) const
Definition: txtedt.cxx:2238
SwFlyFrame::IsFlyInContentFrame
bool IsFlyInContentFrame() const
Definition: flyfrm.hxx:193
o3tl::sorted_vector::size
size_type size() const
SwUpdateAttr::getStart
sal_Int32 getStart() const
Definition: hints.hxx:145
SwTextFrame::SetOfst_
void SetOfst_(TextFrameIndex nNewOfst)
Definition: frmform.cxx:763
SwContact::MoveObjToVisibleLayer
virtual void MoveObjToVisibleLayer(SdrObject *_pDrawObj)
method to move drawing object to corresponding visible layer
Definition: dcontact.cxx:213
SwTextFrame::Prepare
virtual bool Prepare(const PrepareHint ePrep=PREP_CLEAR, const void *pVoid=nullptr, bool bNotify=true) override
SwContentFrame: the shortcut for the Frames If the void* casts wrongly, it's its own fault! The void*...
Definition: txtfrm.cxx:2718
lcl_ModifyOfst
static void lcl_ModifyOfst(SwTextFrame &rFrame, TextFrameIndex const nPos, TextFrameIndex const nLen, TextFrameIndex(*op)(TextFrameIndex const &, TextFrameIndex const &))
Definition: txtfrm.cxx:1867
SwTextFrame::GetFollow
SwTextFrame * GetFollow()
Definition: txtfrm.hxx:844
SwFrame::GetAttrSet
const SwAttrSet * GetAttrSet() const
WARNING: this may not return correct RES_PAGEDESC/RES_BREAK items for SwTextFrame, use GetBreakItem()/GetPageDescItem() instead.
Definition: findfrm.cxx:674
sw::FrameMode
FrameMode
Definition: txtfrm.hxx:102
SwTextFly::SetIgnoreObjsInHeaderFooter
void SetIgnoreObjsInHeaderFooter(const bool bNew)
Definition: txtfly.hxx:371
sw::MergedPara::extents
std::vector< Extent > extents
Definition: txtfrm.hxx:957
SwParaPortion::IsFollowField
bool IsFollowField() const
Definition: porlay.hxx:293
isA11yRelevantAttribute
static bool isA11yRelevantAttribute(sal_uInt16 nWhich)
Related: fdo#56031 filter out attribute changes that don't matter for humans/a11y to stop flooding th...
Definition: txtfrm.cxx:1948
RES_BACKGROUND
#define RES_BACKGROUND
Definition: hintids.hxx:210
SwGrammarMarkUp::MoveGrammar
void MoveGrammar(sal_Int32 nPos, sal_Int32 nDiff)
Definition: SwGrammarMarkUp.cxx:39
SwTextFrame::PrepWidows
void PrepWidows(const sal_uInt16 nNeed, bool bNotify)
Definition: txtfrm.cxx:2638
SvxBrushItem::GetColor
const Color & GetColor() const
RES_FLYFRMFMT
#define RES_FLYFRMFMT
Definition: hintids.hxx:274
SwRectFnSet::SetHeight
void SetHeight(SwRect &rRect, long nNew) const
Definition: frame.hxx:1367
SwTextFrame::IsEmpty
bool IsEmpty() const
Definition: txtfrm.hxx:509
SwTextFrame::ResetPreps
void ResetPreps()
Definition: txtfrm.cxx:1348
sw::Extent
Describes a part of a single text node, which will be part of a text frame, even when redlines are hi...
Definition: txtfrm.hxx:83
swap
void swap(cow_wrapper< T, P > &a, cow_wrapper< T, P > &b)
SwTextFrame::GetTextNodeFirst
SwTextNode * GetTextNodeFirst()
Definition: txtfrm.hxx:445
SwFrame::SetInvalidVert
void SetInvalidVert(bool bNew)
Definition: frame.hxx:608
sw::FrameContainsNode
bool FrameContainsNode(SwContentFrame const &rFrame, sal_uLong nNodeIndex)
Definition: txtfrm.cxx:296
SwFrame::IsInDtor
bool IsInDtor() const
Definition: frame.hxx:868
SwTextFrame::GetTextNodeForParaProps
SwTextNode const * GetTextNodeForParaProps() const
Definition: txtfrm.cxx:1300
SwPageFrame::InvalidateAutoCompleteWords
void InvalidateAutoCompleteWords() const
Definition: pagefrm.hxx:376
SwTextFrame::mnFlyAnchorOfst
SwTwips mnFlyAnchorOfst
Definition: txtfrm.hxx:171
sw::RedlineUnDelText
delete redline is removed
Definition: hints.hxx:122
SwTextFly::SetIgnoreContour
void SetIgnoreContour(bool bNew)
Definition: txtfly.hxx:366
SwFootnoteIdxs::SeekEntry
SwTextFootnote * SeekEntry(const SwNodeIndex &rIdx, size_t *pPos=nullptr) const
Definition: ftnidx.cxx:409
SwVirtPageNumInfo::GetOrigPage
const SwPageFrame * GetOrigPage()
Definition: hints.hxx:272
SwLinePortion::IsFootnoteNumPortion
bool IsFootnoteNumPortion() const
Definition: porlin.hxx:118
SfxItemSet::ClearItem
sal_uInt16 ClearItem(sal_uInt16 nWhich=0)
SwFrameFormat
Style of a layout element.
Definition: frmfmt.hxx:57
SwTextFrame::IsWidow
bool IsWidow() const
Definition: txtfrm.hxx:507
SwTextFormatter::CalcFitToContent_
SwTwips CalcFitToContent_()
Definition: itrform2.cxx:1912
PrepareHint
PrepareHint
Definition: swtypes.hxx:204
SwTextIter::Bottom
void Bottom()
Definition: itrtxt.cxx:186
SwRectFnSet::SetWidth
void SetWidth(SwRect &rRect, long nNew) const
Definition: frame.hxx:1366
SwTextFrame::MapModelToViewPos
TextFrameIndex MapModelToViewPos(SwPosition const &rPos) const
Definition: txtfrm.cxx:1266
SW_MOD
#define SW_MOD()
Definition: swmodule.hxx:256
SwFrame::InvalidateLineNum
void InvalidateLineNum()
Definition: frame.hxx:1026
SwLineLayout::IsDummy
bool IsDummy() const
Definition: porlay.hxx:135
SfxItemSet::GetItemState
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
SwFrame::InvalidatePrt
void InvalidatePrt()
Definition: frame.hxx:1012
SwPageFrame::InvalidateSpelling
void InvalidateSpelling() const
Definition: pagefrm.hxx:367
SwFormat::GetAnchor
const SwFormatAnchor & GetAnchor(bool=true) const
Definition: fmtanchr.hxx:81
RES_CHRATR_CTL_FONT
#define RES_CHRATR_CTL_FONT
Definition: hintids.hxx:95
SwTextNode::SetSmartTagDirty
void SetSmartTagDirty(bool bNew) const
Definition: txtedt.cxx:2269
SwLayoutModeModifier::m_nOldLayoutMode
ComplexTextLayoutFlags const m_nOldLayoutMode
Definition: txtfrm.hxx:931
SwLineLayout
Collection of SwLinePortion instances, representing one line of text.
Definition: porlay.hxx:78
RES_DEL_TXT
#define RES_DEL_TXT
Definition: hintids.hxx:288
SwTextFrameBreak::IsInside
bool IsInside(SwTextMargin const &rLine) const
BP 18.6.93: Widows.
Definition: widorp.cxx:104
SwTextIter::Top
void Top()
Definition: itrtxt.hxx:99
SwFrame::GetIndNext
SwFrame * GetIndNext()
Definition: frame.hxx:705
SwIndex::Assign
SwIndex & Assign(SwIndexReg *, sal_Int32)
Definition: index.cxx:198
SwFormatAnchor::GetAnchorId
RndStdIds GetAnchorId() const
Definition: fmtanchr.hxx:65
SwSmartTagMgr::Get
static SwSmartTagMgr & Get()
Definition: SwSmartTagMgr.cxx:31
RES_TXTATR_FTN
#define RES_TXTATR_FTN
Definition: hintids.hxx:152
SwSortedObjs::size
size_t size() const
Definition: sortedobjs.cxx:42
SwTextPaintInfo::GetTextFly
SwTextFly & GetTextFly()
Definition: inftxt.hxx:390
ComplexTextLayoutFlags
ComplexTextLayoutFlags
SwFrame::FindPageFrame
SwPageFrame * FindPageFrame()
Definition: frame.hxx:658
SwTextFrame::GetAllLines
sal_uLong GetAllLines() const
For displaying the line numbers.
Definition: txtfrm.hxx:656
SwFrameSwapper
Helper class which can be used instead of the macros if a function has too many returns.
Definition: txtfrm.hxx:919
SwParaPortion::GetReformat
SwCharRange & GetReformat()
Definition: porlay.hxx:266
SwContact::GetAnchorId
RndStdIds GetAnchorId() const
Definition: dcontact.hxx:145
SwTextFormatter::RecalcRealHeight
void RecalcRealHeight()
Definition: itrform2.cxx:1674
Count
Count
sw::MapModelToView
TextFrameIndex MapModelToView(MergedPara const &, SwTextNode const *pNode, sal_Int32 nIndex)
Definition: txtfrm.cxx:1182
SwFrame::FindNextCnt
SwContentFrame * FindNextCnt(const bool _bInSameFootnote=false)
Definition: findfrm.cxx:190
SwIterator::First
TElementType * First()
Definition: calbck.hxx:345
GetGridItem
SwTextGridItem const * GetGridItem(SwPageFrame const *const)
Definition: pagechg.cxx:2516
i
int i
SwTextFrame::ManipOfst
void ManipOfst(TextFrameIndex const nNewOfst)
Definition: txtfrm.hxx:429
SwNode::GetContentNode
SwContentNode * GetContentNode()
Definition: node.hxx:615
SwFrame::InvalidatePage
void InvalidatePage(const SwPageFrame *pPage=nullptr) const
Invalidates the page in which the Frame is currently placed.
Definition: wsfrm.cxx:598
SwLineLayout::GetFirstPortion
SwLinePortion * GetFirstPortion() const
Definition: porlay.cxx:673
SfxItemSet::Count
sal_uInt16 Count() const
sw::MergedAttrIterBase
iterate SwTextAttr in potentially merged text frame
Definition: txtfrm.hxx:981
SwFont::GetHeight
long GetHeight() const
Definition: swfont.hxx:283
sw::MapViewToModel
std::pair< SwTextNode *, sal_Int32 > MapViewToModel(MergedPara const &, TextFrameIndex nIndex)
Definition: txtfrm.cxx:1163
SwNode::GetDoc
SwDoc * GetDoc()
Definition: node.hxx:702
SwTextNode::SetAutoCompleteWordDirty
void SetAutoCompleteWordDirty(bool bNew) const
Definition: txtedt.cxx:2282
SwFrame::GetUpper
SwLayoutFrame * GetUpper()
Definition: frame.hxx:656
SwRect::HasArea
bool HasArea() const
Definition: swrect.hxx:290
SwTextFly::Relax
bool Relax(const SwRect &rRect)
If there is no flying object frame standing in rRect (usually the current row), then we are turning o...
Definition: txtfly.hxx:318
SwPageFrame::InvalidateSmartTags
void InvalidateSmartTags() const
Definition: pagefrm.hxx:372
SwFrameAreaDefinition::isFramePrintAreaValid
bool isFramePrintAreaValid() const
Definition: frame.hxx:164
SwTextNode::GetGrammarCheck
SwGrammarMarkUp * GetGrammarCheck()
Definition: txtedt.cxx:2190
SwFlowFrame::IsUndersized
bool IsUndersized() const
Definition: flowfrm.hxx:158
sw::MergedPara::pParaPropsNode
SwTextNode * pParaPropsNode
most paragraph properties are taken from the first non-empty node
Definition: txtfrm.hxx:962
SwTextNode::GetNumRule
SwNumRule * GetNumRule(bool bInParent=true) const
Returns numbering rule of this text node.
Definition: ndtxt.cxx:2813
SwLinePortion::HandlePortion
virtual void HandlePortion(SwPortionHandler &rPH) const
Definition: porlin.cxx:319
SwWrongList::Invalidate
void Invalidate(sal_Int32 nBegin, sal_Int32 nEnd)
Definition: wrong.cxx:425
IDocumentSettingAccess
Provides access to settings of a document.
Definition: IDocumentSettingAccess.hxx:109
SwNode::IsNoTextNode
bool IsNoTextNode() const
Definition: node.hxx:648
SvxLineSpacingItem::GetInterLineSpaceRule
SvxInterLineSpaceRule GetInterLineSpaceRule() const
SwFrame::GetPrev
SwFrame * GetPrev()
Definition: frame.hxx:655
SwTextFrame::GetFormatted
SwTextFrame * GetFormatted(bool bForceQuickFormat=false)
In case the SwLineLayout was cleared out of the s_pTextCache, recreate it.
Definition: txtfrm.cxx:3360
sw::RemoveFootnotesForNode
void RemoveFootnotesForNode(SwRootFrame const &rLayout, SwTextNode const &rTextNode, std::vector< std::pair< sal_Int32, sal_Int32 >> const *const pExtents)
Definition: txtfrm.cxx:814
SwLayoutModeModifier::Modify
void Modify(bool bChgToRTL)
Definition: txtfrm.cxx:721
SwTextIter::GetLineHeight
sal_uInt16 GetLineHeight() const
Definition: itrtxt.hxx:116
SwTextNode::GetSmartTags
SwWrongList * GetSmartTags()
Definition: txtedt.cxx:2215
SwNodeIndex
Marks a node in the document model.
Definition: ndindex.hxx:31
RES_LINENUMBER
#define RES_LINENUMBER
Definition: hintids.hxx:221
SvxNumberFormat::GetNumAdjust
SvxAdjust GetNumAdjust() const
sw::MoveText::nLen
sal_Int32 nLen
Definition: hints.hxx:106
SwTextFrame::RecalcAllLines
void RecalcAllLines()
Definition: txtfrm.cxx:3816
SwTextFrame::RemoveFromCache
void RemoveFromCache()
Removes this frame completely from the Cache.
Definition: txtcache.cxx:119
SwAttrSet::GetLineSpacing
const SvxLineSpacingItem & GetLineSpacing(bool=true) const
Definition: paratr.hxx:178
sw::MoveText
text is moved into pDestNode
Definition: hints.hxx:100
SwTextIter::TruncLines
void TruncLines(bool bNoteFollow=false)
Definition: itrtxt.cxx:324
sw::MergedPara::mergedText
OUString mergedText
note: cannot be const currently to avoid UB because SwTextGuess::Guess const_casts it and modifies it...
Definition: txtfrm.hxx:960
sw::MoveText::pDestNode
SwTextNode * pDestNode
Definition: hints.hxx:103
SwRect::SSize
void SSize(const Size &rNew)
Definition: swrect.hxx:176
SwFootnoteInfo::aErgoSum
OUString aErgoSum
Definition: ftninfo.hxx:95
SwTextFrame::IsLocked
bool IsLocked() const
Definition: txtfrm.hxx:505
SwParaPortion::GetParLen
TextFrameIndex GetParLen() const
Definition: porlay.cxx:2163
SwFrameAreaDefinition::isFrameAreaSizeValid
bool isFrameAreaSizeValid() const
Definition: frame.hxx:163
lcl_SetScriptInval
static void lcl_SetScriptInval(SwTextFrame &rFrame, TextFrameIndex const nPos)
Definition: txtfrm.cxx:1860
SvxNumberFormat::GetPositionAndSpaceMode
SvxNumPositionAndSpaceMode GetPositionAndSpaceMode() const
SwLinePortion::GetLen
TextFrameIndex GetLen() const
Definition: porlin.hxx:73
RES_FMT_CHG
#define RES_FMT_CHG
Definition: hintids.hxx:284
SwTextFrame::CalcHeightOfLastLine
void CalcHeightOfLastLine(const bool _bUseFont=false)
method to determine height of last line, needed for proportional line spacing
Definition: txtfrm.cxx:3545
RES_TXTATR_INETFMT
#define RES_TXTATR_INETFMT
Definition: hintids.hxx:141
SwPageFrame
A page of the document layout.
Definition: pagefrm.hxx:40
SfxItemSet::GetPool
SfxItemPool * GetPool() const
Point::X
long X() const
sw::MakeTextFrame
SwTextFrame * MakeTextFrame(SwTextNode &rNode, SwFrame *, sw::FrameMode eMode)
Definition: txtfrm.cxx:808
SwTextFrame::MapViewToModel
std::pair< SwTextNode *, sal_Int32 > MapViewToModel(TextFrameIndex nIndex) const
map position in potentially merged text frame to SwPosition
Definition: txtfrm.cxx:1230
SwViewShell::InvalidateWindows
void InvalidateWindows(const SwRect &rRect)
Definition: viewsh.cxx:550
LONG_MAX
const long LONG_MAX
SwTextFrame::Format
virtual void Format(vcl::RenderContext *pRenderContext, const SwBorderAttrs *pAttrs=nullptr) override
Definition: frmform.cxx:1748
SvxLineSpacingItem::GetInterLineSpace
short GetInterLineSpace() const
SwLineNumberInfo
< purpose of derivation from SwClient: character style for displaying the numbers.
Definition: lineinfo.hxx:37
SwBorderAttrAccess::Get
SwBorderAttrs * Get()
Definition: frmtool.cxx:2440
sw::GetParaPropsNode
SwTextNode * GetParaPropsNode(SwRootFrame const &rLayout, SwNodeIndex const &rNode)
Definition: txtfrm.cxx:336
isPARATR
bool isPARATR(const sal_uInt16 nWhich)
Definition: hintids.hxx:360
SwField::GetTyp
SwFieldType * GetTyp() const
Definition: fldbas.hxx:382
SwFrame::InvalidateSize
void InvalidateSize()
Definition: frame.hxx:1005
SwFrame::FindSctFrame
SwSectionFrame * FindSctFrame()
Definition: frame.hxx:1091
SwFormatContent::GetContentIdx
const SwNodeIndex * GetContentIdx() const
Definition: fmtcntnt.hxx:46
SwRectFnSet::SetLeft
void SetLeft(SwRect &rRect, long nNew) const
Definition: frame.hxx:1364
sw::MergedAttrIterByEnd::MergedAttrIterByEnd
MergedAttrIterByEnd(SwTextFrame const &rFrame)
Definition: txtfrm.cxx:157
aFrameFormatSetRange
sal_uInt16 const aFrameFormatSetRange[]
Definition: init.cxx:234
SwTextFrame::InvalidateRange
void InvalidateRange(const SwCharRange &, const long=0)
Definition: txtfrm.cxx:1684
sw::GetParaPropsPos
SwPosition GetParaPropsPos(SwRootFrame const &rLayout, SwPosition const &rPos)
Definition: txtfrm.cxx:350
SwFootnoteBossFrame::RemoveFootnote
bool RemoveFootnote(const SwContentFrame *, const SwTextFootnote *, bool bPrep=true)
Definition: ftnfrm.cxx:1671
SwTextFrame::SwitchLTRtoRTL
void SwitchLTRtoRTL(SwRect &rRect) const
Calculates the coordinates of a rectangle when switching from LTR to RTL layout.
Definition: txtfrm.cxx:693
SwFormat::Which
sal_uInt16 Which() const
for Querying of Writer-functions.
Definition: format.hxx:78
SwLinePortion
Base class for anything that can be part of a line in the Writer layout.
Definition: porlin.hxx:49
SwNumRule::Get
const SwNumFormat & Get(sal_uInt16 i) const
Definition: number.cxx:83
SwTextFrame::IsFootnoteNumFrame
bool IsFootnoteNumFrame() const
Am I a FootnoteFrame, with a number at the start of the paragraph?
Definition: txtfrm.hxx:611
SwRectFnSet::GetWidth
long GetWidth(const SwRect &rRect) const
Definition: frame.hxx:1357
SwAttrSetChg::Count
sal_uInt16 Count() const
Definition: hints.hxx:245
SwFrame::IsLayoutFrame
bool IsLayoutFrame() const
Definition: frame.hxx:1146
SwParaPortion::IsPrepMustFit
bool IsPrepMustFit() const
Definition: porlay.hxx:289
SwRect::Left
void Left(const long nLeft)
Definition: swrect.hxx:193
SfxItemSet::Put
const SfxPoolItem * Put(const SfxPoolItem &rItem, sal_uInt16 nWhich)
SwTextNode
SwTextNode is a paragraph in the document model.
Definition: ndtxt.hxx:79
SwRect::Bottom
void Bottom(const long nBottom)
Definition: swrect.hxx:207
SwTextFrame::SetOfst
void SetOfst(TextFrameIndex nNewOfst)
Definition: txtfrm.hxx:854
SfxBroadcaster::Broadcast
void Broadcast(const SfxHint &rHint)
SwTextFrame::GetLineCount
sal_uInt16 GetLineCount(TextFrameIndex nPos)
Determines the line count.
Definition: txtfrm.cxx:3740
SwFntObj::SetDevFont
void SetDevFont(const SwViewShell *pSh, OutputDevice &rOut)
Definition: fntcache.cxx:643
RES_VIRTPAGENUM_INFO
#define RES_VIRTPAGENUM_INFO
Definition: hintids.hxx:302
SwTextFrameBreak::IsBreakNow
bool IsBreakNow(SwTextMargin &rLine)
Definition: widorp.cxx:168
RES_TXTATR_FIELD
#define RES_TXTATR_FIELD
Definition: hintids.hxx:150
LANGUAGE_ENGLISH
#define LANGUAGE_ENGLISH
SwFrame::IsVertLR
bool IsVertLR() const
Definition: frame.hxx:955
RES_TXTATR_AUTOFMT
#define RES_TXTATR_AUTOFMT
Definition: hintids.hxx:140
SwpHints
An SwTextAttr container, stores all directly formatted text portions for a text node.
Definition: ndhints.hxx:67
SwTextFrame::mnAdditionalFirstLineOffset
SwTwips mnAdditionalFirstLineOffset
Definition: txtfrm.hxx:184
SwFlyFrame
general base class for all free-flowing frames
Definition: flyfrm.hxx:60
SwFlowFrame::CheckKeep
void CheckKeep()
Definition: flowfrm.cxx:144
SwAnchoredObject::GetFrameFormat
virtual SwFrameFormat & GetFrameFormat()=0
SAL_WARN_IF
#define SAL_WARN_IF(condition, area, stream)
sw::RedlineDelText::nLen
sal_Int32 const nLen
Definition: hints.hxx:116
SwContentFrame::FindMaster
SwTextFrame * FindMaster() const
Definition: flowfrm.cxx:679
RES_CHRATR_CTL_LANGUAGE
#define RES_CHRATR_CTL_LANGUAGE
Definition: hintids.hxx:97
dbg_lay.hxx
SwTextNode::IsNumbered
bool IsNumbered(SwRootFrame const *pLayout=nullptr) const
Returns is this text node is numbered.
Definition: ndtxt.cxx:2888
SwParaPortion::GetRepaint
SwRepaint & GetRepaint()
Definition: porlay.hxx:264
SwTextFrame::ClearPara
void ClearPara()
Removes the Line information from the Cache but retains the entry itself.
Definition: txtcache.cxx:103
SwViewShell::GetViewOptions
const SwViewOption * GetViewOptions() const
Definition: viewsh.hxx:426
SwRect::Width
void Width(long nNew)
Definition: swrect.hxx:185
SwViewShell::GetWin
vcl::Window * GetWin() const
Definition: viewsh.hxx:340
SwLayoutFrame::ContainsAny
const SwFrame * ContainsAny(const bool _bInvestigateFootnoteForSections=false) const
Method doesn't investigate content of footnotes by default.
Definition: findfrm.cxx:125
OutputDevice::SetFont
void SetFont(const vcl::Font &rNewFont)
USHRT_MAX
const o3tl::enumarray< SvxAdjust, unsigned short > aSvxToUnoAdjust USHRT_MAX
Definition: unosett.cxx:261
sw::MergedAttrIterByEnd::m_pNode
SwTextNode const *const m_pNode
Definition: txtfrm.hxx:1008
RES_TXTATR_ANNOTATION
#define RES_TXTATR_ANNOTATION
Definition: hintids.hxx:153
sw::MergedAttrIterBase::MergedAttrIterBase
MergedAttrIterBase(SwTextFrame const &rFrame)
Definition: txtfrm.cxx:89
sw::UpdateMergedParaForInsert
static TextFrameIndex UpdateMergedParaForInsert(MergedPara &rMerged, bool const isRealInsert, SwTextNode const &rNode, sal_Int32 const nIndex, sal_Int32 const nLen)
Definition: txtfrm.cxx:905
SwTextFrame::SetFieldFollow
void SetFieldFollow(const bool bNew)
Definition: txtfrm.hxx:238
SwTextFrame::MapModelToView
TextFrameIndex MapModelToView(SwTextNode const *pNode, sal_Int32 nIndex) const
Definition: txtfrm.cxx:1251
SwIndex::GetIndex
sal_Int32 GetIndex() const
Definition: index.hxx:95
SwTextNode::IsCountedInList
bool IsCountedInList() const
Definition: ndtxt.cxx:4239
SwFrame::IsNoTextFrame
bool IsNoTextFrame() const
Definition: frame.hxx:1214
SwTextFrame::GetHeightOfLastLine
SwTwips GetHeightOfLastLine() const
Definition: txtfrm.hxx:756
SwTextFrame::SetMergedPara
void SetMergedPara(std::unique_ptr< sw::MergedPara > p)
Definition: txtfrm.cxx:1273
SwTextFrame::SwapWidthAndHeight
void SwapWidthAndHeight()
Swaps width and height of the text frame.
Definition: txtfrm.cxx:430
GetAppLanguage
LanguageType GetAppLanguage()
Definition: init.cxx:765
SwDoc::getIDocumentSettingAccess
IDocumentSettingAccess const & getIDocumentSettingAccess() const
Definition: doc.cxx:208
sw::MergedAttrIterBase::m_pMerged
sw::MergedPara const * m_pMerged
Definition: txtfrm.hxx:985
SwTextFrame::mnFlyAnchorOfstNoWrap
SwTwips mnFlyAnchorOfstNoWrap
Definition: txtfrm.hxx:173
SwFrame::IsRightToLeft
bool IsRightToLeft() const
Definition: frame.hxx:963
SwTextFrame::m_pMergedPara
std::unique_ptr< sw::MergedPara > m_pMergedPara
redline merge data
Definition: txtfrm.hxx:187
SwTextNode::SetWrong
void SetWrong(SwWrongList *pNew, bool bDelete=true)
Definition: txtedt.cxx:2155
SwTextFrame::FindBrk
static TextFrameIndex FindBrk(const OUString &rText, TextFrameIndex nStart, TextFrameIndex nEnd)
Returns the first possible break point in the current line.
Definition: txtfrm.cxx:1630
IGrammarContact
Organizer of the contact between SwTextNodes and grammar checker.
Definition: IGrammarContact.hxx:29
SwFrame::mnFrameType
SwFrameType mnFrameType
Definition: frame.hxx:395
sw::Extent::nStart
sal_Int32 nStart
Definition: txtfrm.hxx:86
SwRectFnSet::SetRight
void SetRight(SwRect &rRect, long nNew) const
Definition: frame.hxx:1365
SwTextFrame::CalcFlyPos
TextFrameIndex CalcFlyPos(SwFrameFormat const *pSearch)
Calculates the position of FlyInContentFrames.
Definition: porfly.cxx:186
SwTextNode::GetWrong
SwWrongList * GetWrong()
Definition: txtedt.cxx:2167
IDocumentDeviceAccess::getReferenceDevice
virtual OutputDevice * getReferenceDevice(bool bCreate) const =0
Returns the current reference device.
SwPosSize::Width
sal_uInt16 Width() const
Definition: possiz.hxx:46
sw::MergedAttrIterReverse::MergedAttrIterReverse
MergedAttrIterReverse(SwTextFrame const &rFrame)
Definition: txtfrm.cxx:209
SwTextIter::PrevLine
const SwLineLayout * PrevLine()
Definition: itrtxt.cxx:171
SwViewOption::IsPrtFormat
bool IsPrtFormat() const
Definition: viewopt.hxx:502
sw_HideObj
bool sw_HideObj(const SwTextFrame &_rFrame, const RndStdIds _eAnchorType, SwPosition const &rAnchorPos, SwAnchoredObject *_pAnchoredObj)
as-character anchored graphics, which are used for a graphic bullet list.
Definition: txtfrm.cxx:1483
SwParaPortion::GetScriptInfo
SwScriptInfo & GetScriptInfo()
Definition: porlay.hxx:270
getLength
double getLength(const B2DPolygon &rCandidate)
SwUpdateAttr::getFmtAttrs
const std::vector< sal_uInt16 > & getFmtAttrs() const
Definition: hints.hxx:160
SwParaPortion::SetPrep
void SetPrep()
Definition: porlay.hxx:284
sw::IsParaPropsNode
bool IsParaPropsNode(SwRootFrame const &rLayout, SwTextNode const &rNode)
Definition: txtfrm.cxx:319
sw::RedlineUnDelText::nLen
sal_Int32 nLen
Definition: hints.hxx:126
SwPortionHandler::Skip
virtual void Skip(TextFrameIndex nLength)=0
skip characters.
SwRectFnSet::GetHeight
long GetHeight(const SwRect &rRect) const
Definition: frame.hxx:1358
SwRootFrame::IsHideRedlines
bool IsHideRedlines() const
Replacement for sw::DocumentRedlineManager::GetRedlineFlags() (this is layout-level redline hiding)...
Definition: rootfrm.hxx:416
SwContact::MoveObjToInvisibleLayer
virtual void MoveObjToInvisibleLayer(SdrObject *_pDrawObj)
method to move drawing object to corresponding invisible layer
Definition: dcontact.cxx:240
RES_TXTATR_FLYCNT
#define RES_TXTATR_FLYCNT
Definition: hintids.hxx:151
SwTextFrame::SetWidow
void SetWidow(const bool bNew)
Definition: txtfrm.hxx:235
IDocumentSettingAccess::get
virtual bool get(DocumentSettingId id) const =0
Return the specified document setting.
SwTextFootnote::DelFrames
void DelFrames(const SwRootFrame *)
Definition: atrftn.cxx:448
SwContentNode::GetSwAttrSet
const SwAttrSet & GetSwAttrSet() const
Does node has already its own auto-attributes? Access to SwAttrSet.
Definition: node.hxx:723
SwFormat::GetContent
const SwFormatContent & GetContent(bool=true) const
Definition: fmtcntnt.hxx:55
lcl_SetWrong
static void lcl_SetWrong(SwTextFrame &rFrame, SwTextNode const &rNode, sal_Int32 const nPos, sal_Int32 const nCnt, bool const bMove)
Definition: txtfrm.cxx:1795
SwTestFormat::pOldPara
SwParaPortion * pOldPara
Definition: txtfrm.cxx:3114
SwParaPortion::IsFixLineHeight
bool IsFixLineHeight() const
Definition: porlay.hxx:295
SwCacheObj::Unlock
void Unlock()
Definition: swcache.cxx:483
SwScriptInfo::GetBoundsOfHiddenRange
static bool GetBoundsOfHiddenRange(const SwTextNode &rNode, sal_Int32 nPos, sal_Int32 &rnStartPos, sal_Int32 &rnEndPos, std::vector< sal_Int32 > *pList=nullptr)
Hidden text range information - static and non-version.
Definition: porlay.cxx:1546
SwParaPortion::SetPrepMustFit
void SetPrepMustFit(const bool bNew)
Definition: porlay.hxx:288
SwParaPortion::SetPrepWidows
void SetPrepWidows()
Definition: porlay.hxx:286
SwLineLayout::GetRealHeight
sal_uInt16 GetRealHeight() const
Definition: porlay.hxx:153
lcl_ErgoVadis
static bool lcl_ErgoVadis(SwTextFrame *pFrame, TextFrameIndex &rPos, const PrepareHint ePrep)
Definition: txtfrm.cxx:2690
text
def text(shape, st)
SwTextIter::GetCurr
const SwLineLayout * GetCurr() const
Definition: itrtxt.hxx:83
RES_OBJECTDYING
#define RES_OBJECTDYING
Definition: hintids.hxx:283
sw::MergedPara::pLastNode
SwTextNode const * pLastNode
mainly for sanity checks
Definition: txtfrm.hxx:966
SwFrame::IsVertical
bool IsVertical() const
Definition: frame.hxx:949
sw::MergedAttrIterByEnd::NextAttr
SwTextAttr const * NextAttr(SwTextNode const *&rpNode)
Definition: txtfrm.cxx:172
SwDocPosUpdate
SwDocPosUpdate is sent to signal that only the frames from or to a specified document-global position...
Definition: hints.hxx:183
SwTextFrame::DestroyImpl
virtual void DestroyImpl() override
Definition: txtfrm.cxx:860
SwRectFnSet::GetTop
long GetTop(const SwRect &rRect) const
Definition: frame.hxx:1353
SwFrame::InvalidatePrt_
void InvalidatePrt_()
Definition: frame.hxx:757
SwDoc::GetFootnoteIdxs
SwFootnoteIdxs & GetFootnoteIdxs()
Definition: doc.hxx:627
SwAttrSetChg::ClearItem
void ClearItem(sal_uInt16 nWhichL)
Definition: hints.cxx:128
SwTextNode::AddToListRLHidden
void AddToListRLHidden()
Definition: ndtxt.cxx:4300
RndStdIds
RndStdIds
SwTextFrame::GetDoc
SwDoc & GetDoc()
Definition: txtfrm.hxx:448
SwTextFrame::mnHeightOfLastLine
SwTwips mnHeightOfLastLine
Definition: txtfrm.hxx:179
SwTextFrame::WouldFit
virtual bool WouldFit(SwTwips &nMaxHeight, bool &bSplit, bool bTst) override
nMaxHeight is the required height bSplit indicates, that the paragraph has to be split bTst indicates...
Definition: txtfrm.cxx:3223
SwTextNode::FieldCanHideParaWeight
int FieldCanHideParaWeight(SwFieldIds eFieldId) const
Definition: ndtxt.hxx:712
SwTestFormat
Small Helper class: Prepares a test format.
Definition: txtfrm.cxx:3111
SwTextFly::IsOn
bool IsOn() const
Definition: txtfly.hxx:313
hasA11yRelevantAttribute
static bool hasA11yRelevantAttribute(const std::vector< sal_uInt16 > &rWhichFmtAttr)
Definition: txtfrm.cxx:1953
Left
Left
sw::MergedPara::pFirstNode
SwTextNode *const pFirstNode
except break attributes, those are taken from the first node
Definition: txtfrm.hxx:964
SwViewOption::IsShowHiddenChar
bool IsShowHiddenChar(bool bHard=false) const
Definition: viewopt.hxx:282
SwUpdateAttr::getWhichAttr
sal_uInt16 getWhichAttr() const
Definition: hints.hxx:155
SwTextFrame::mnFlyAnchorVertOfstNoWrap
SwTwips mnFlyAnchorVertOfstNoWrap
The y position for wrap-through flys anchored at this paragraph.
Definition: txtfrm.hxx:175
SwFormatLineNumber::IsCount
bool IsCount() const
Definition: fmtline.hxx:58
SwTextIter::GetEnd
TextFrameIndex GetEnd() const
Definition: itrtxt.hxx:89
SwTextMargin::GetDropLines
sal_uInt16 GetDropLines() const
Definition: itrtxt.hxx:202
SwTextFrame::FirstLineHeight
sal_uInt16 FirstLineHeight() const
Returns the first line height.
Definition: txtfrm.cxx:3725
RES_PAGEDESC
#define RES_PAGEDESC
Definition: hintids.hxx:198
SwTextFrame::VisitPortions
void VisitPortions(SwPortionHandler &rPH) const
Visit all portions for Accessibility.
Definition: txtfrm.cxx:3870
RES_BREAK
#define RES_BREAK
Definition: hintids.hxx:199
SwLinePortion::GetNextPortion
SwLinePortion * GetNextPortion() const
Definition: porlin.hxx:71
SwPageFrame::InvalidateWordCount
void InvalidateWordCount() const
Definition: pagefrm.hxx:380
SwRootFrame::GetCurrShell
SwViewShell * GetCurrShell() const
Definition: rootfrm.hxx:204
nPos
sal_Int32 nPos
TextFrameIndex
o3tl::strong_int< sal_Int32, struct Tag_TextFrameIndex > TextFrameIndex
Denotes a character index in a text frame at a layout level, after extent mapping from a text node at...
Definition: TextFrameIndex.hxx:22
SwSortedObjs
class for collecting anchored objects
Definition: sortedobjs.hxx:48
SwTextFrame::MapViewToModelPos
SwPosition MapViewToModelPos(TextFrameIndex nIndex) const
Definition: txtfrm.cxx:1245
SwCharRange::Len
TextFrameIndex & Len()
Definition: porlay.hxx:49
SwFieldType::Which
SwFieldIds Which() const
Definition: fldbas.hxx:265
SdrObject::GetUserCall
SdrObjUserCall * GetUserCall() const
SwTextFrame::IsIdxInside
bool IsIdxInside(TextFrameIndex nPos, TextFrameIndex nLen) const
Definition: txtfrm.cxx:1655
SwContact::GetContentAnchor
const SwPosition & GetContentAnchor() const
Definition: dcontact.hxx:152
SwTextFootnote::GetTextNode
const SwTextNode & GetTextNode() const
Definition: txtftn.hxx:69
SwDoc::GetFootnoteInfo
const SwFootnoteInfo & GetFootnoteInfo() const
Definition: doc.hxx:623
COMPLETE_STRING
const sal_Int32 COMPLETE_STRING
Definition: swtypes.hxx:61
SfxPoolItem::Which
sal_uInt16 Which() const
SwFrame::getRootFrame
SwRootFrame * getRootFrame()
Definition: frame.hxx:657
SwContentFrame::Modify
virtual void Modify(const SfxPoolItem *, const SfxPoolItem *) override
Definition: wsfrm.cxx:2303
SwTextFrame::mbIsSwapped
bool mbIsSwapped
Definition: txtfrm.hxx:224
SwWrongList::SetInvalid
void SetInvalid(sal_Int32 nBegin, sal_Int32 nEnd)
Definition: wrong.cxx:253
SwTextFrame::HideFootnotes
void HideFootnotes(TextFrameIndex nStart, TextFrameIndex nEnd)
Definition: txtfrm.cxx:1452
Point::Y
long Y() const
SwTextFrame::SwClientNotify
virtual void SwClientNotify(SwModify const &rModify, SfxHint const &rHint) override
Definition: txtfrm.cxx:1968
sw::GetFirstAndLastNode
std::pair< SwTextNode *, SwTextNode * > GetFirstAndLastNode(SwRootFrame const &rLayout, SwNodeIndex const &rPos)
Definition: txtfrm.cxx:363
SwNode::GetTextNode
SwTextNode * GetTextNode()
Inline methods from Node.hxx.
Definition: ndtxt.hxx:843
SwContentFrame::DestroyImpl
virtual void DestroyImpl() override
Definition: ssfrm.cxx:421
RES_PARATR_LINESPACING
#define RES_PARATR_LINESPACING
Definition: hintids.hxx:161
SwFootnoteInfo::aQuoVadis
OUString aQuoVadis
Definition: ftninfo.hxx:94
RES_CHRATR_RSID
#define RES_CHRATR_RSID
Definition: hintids.hxx:107
isPARATR_LIST
bool isPARATR_LIST(const sal_uInt16 nWhich)
Definition: hintids.hxx:364
SwTextFrame::ChgThisLines
void ChgThisLines()
Definition: txtfrm.cxx:3761
PROTOCOL_ENTER
#define PROTOCOL_ENTER(pFrame, nFunc, nAct, pPar)
Definition: dbg_lay.hxx:92
SwFrame::FindTabFrame
SwTabFrame * FindTabFrame()
Definition: frame.hxx:1075
SwTestFormat::pFrame
SwTextFrame * pFrame
Definition: txtfrm.cxx:3113
SwFrameSwapper::SwFrameSwapper
SwFrameSwapper(const SwTextFrame *pFrame, bool bSwapIfNotSwapped)
Definition: txtfrm.cxx:677
SwFrame::GetNext
SwFrame * GetNext()
Definition: frame.hxx:654
SwAttrSet::GetLineNumber
const SwFormatLineNumber & GetLineNumber(bool=true) const
Definition: fmtline.hxx:64
SwLayoutModeModifier::SwLayoutModeModifier
SwLayoutModeModifier(const OutputDevice &rOutp)
Definition: txtfrm.cxx:711
sw::MergedAttrIterBase::m_pNode
SwTextNode const * m_pNode
Definition: txtfrm.hxx:986
SwTextFrame::HasFootnote
bool HasFootnote() const
Definition: txtfrm.hxx:510
Size::setHeight
void setHeight(long nHeight)
SwParaPortion::UpdateQuoVadis
bool UpdateQuoVadis(const OUString &rQuo)
Is called in SwTextFrame::Prepare()
Definition: txtftn.cxx:1492
Generated on Mon Sep 16 2019 02:17:31 for LibreOffice Module sw (master) by   doxygen 1.8.10