LibreOffice Module sw (master)  1
crstrvl.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 <memory>
21 #include <utility>
22 #include <hintids.hxx>
23 #include <comphelper/string.hxx>
24 #include <svl/itemiter.hxx>
25 #include <editeng/lrspitem.hxx>
26 #include <editeng/adjustitem.hxx>
27 #include <editeng/formatbreakitem.hxx>
28 #include <svx/svdobj.hxx>
29 #include <osl/diagnose.h>
30 #include <crsrsh.hxx>
31 #include <doc.hxx>
32 #include <IDocumentUndoRedo.hxx>
33 #include <IDocumentRedlineAccess.hxx>
34 #include <IDocumentFieldsAccess.hxx>
35 #include <IDocumentLayoutAccess.hxx>
36 #include <pagefrm.hxx>
37 #include <cntfrm.hxx>
38 #include <rootfrm.hxx>
39 #include <pam.hxx>
40 #include <ndtxt.hxx>
41 #include <fldbas.hxx>
42 #include <swtable.hxx>
43 #include <docary.hxx>
44 #include <txtfld.hxx>
45 #include <fmtfld.hxx>
46 #include <txtftn.hxx>
47 #include <txtinet.hxx>
48 #include <fmtinfmt.hxx>
49 #include <txttxmrk.hxx>
50 #include <frmfmt.hxx>
51 #include <flyfrm.hxx>
52 #include <viscrs.hxx>
53 #include "callnk.hxx"
54 #include <doctxm.hxx>
55 #include <docfld.hxx>
56 #include <expfld.hxx>
57 #include <reffld.hxx>
58 #include <flddat.hxx>
59 #include <cellatr.hxx>
60 #include <swundo.hxx>
61 #include <redline.hxx>
62 #include <fmtcntnt.hxx>
63 #include <fmthdft.hxx>
64 #include <pagedesc.hxx>
65 #include <fesh.hxx>
66 #include <charfmt.hxx>
67 #include <fmturl.hxx>
68 #include <txtfrm.hxx>
69 #include <wrong.hxx>
70 #include <calbck.hxx>
71 #include <unotools/intlwrapper.hxx>
72 #include <docufld.hxx>
73 #include <svx/srchdlg.hxx>
74 #include <frameformats.hxx>
75 #include <docsh.hxx>
76 #include <wrtsh.hxx>
77 
78 using namespace ::com::sun::star;
79 
80 void SwCursorShell::MoveCursorToNum()
81 {
82  SwCallLink aLk( *this ); // watch Cursor-Moves
83  SwCursorSaveState aSaveState( *m_pCurrentCursor );
84  if( ActionPend() )
85  return;
86  CurrShell aCurr( this );
87  // try to set cursor onto this position, at half of the char-
88  // SRectangle's height
89  Point aPt( m_pCurrentCursor->GetPtPos() );
90  std::pair<Point, bool> const tmp(aPt, true);
91  SwContentFrame * pFrame = m_pCurrentCursor->GetContentNode()->getLayoutFrame(
92  GetLayout(), m_pCurrentCursor->GetPoint(), &tmp);
93  pFrame->GetCharRect( m_aCharRect, *m_pCurrentCursor->GetPoint() );
94  pFrame->Calc(GetOut());
95  if( pFrame->IsVertical() )
96  {
97  aPt.setX(m_aCharRect.Center().getX());
98  aPt.setY(pFrame->getFrameArea().Top() + GetUpDownX());
99  }
100  else
101  {
102  aPt.setY(m_aCharRect.Center().getY());
103  aPt.setX(pFrame->getFrameArea().Left() + GetUpDownX());
104  }
105  pFrame->GetModelPositionForViewPoint( m_pCurrentCursor->GetPoint(), aPt );
106  if ( !m_pCurrentCursor->IsSelOvr( SwCursorSelOverFlags::Toggle |
107  SwCursorSelOverFlags::ChangePos ))
108  {
109  UpdateCursor(SwCursorShell::UPDOWN |
110  SwCursorShell::SCROLLWIN | SwCursorShell::CHKRANGE |
111  SwCursorShell::READONLY );
112  }
113 }
114 
116 void SwCursorShell::GotoNextNum()
117 {
118  if (!SwDoc::GotoNextNum(*m_pCurrentCursor->GetPoint(), GetLayout()))
119  return;
120  MoveCursorToNum();
121 }
122 
123 void SwCursorShell::GotoPrevNum()
124 {
125  if (!SwDoc::GotoPrevNum(*m_pCurrentCursor->GetPoint(), GetLayout()))
126  return;
127  MoveCursorToNum();
128 }
129 
131 bool SwCursorShell::GotoHeaderText()
132 {
133  const SwFrame* pFrame = GetCurrFrame()->FindPageFrame();
134  while( pFrame && !pFrame->IsHeaderFrame() )
135  pFrame = pFrame->GetLower();
136  // found header, search 1. content frame
137  while( pFrame && !pFrame->IsContentFrame() )
138  pFrame = pFrame->GetLower();
139 
140  if( pFrame )
141  {
142  CurrShell aCurr( this );
143  // get header frame
144  SwCallLink aLk( *this ); // watch Cursor-Moves
145  SwCursor *pTmpCursor = getShellCursor( true );
146  SwCursorSaveState aSaveState( *pTmpCursor );
147  pFrame->Calc(GetOut());
148  Point aPt( pFrame->getFrameArea().Pos() + pFrame->getFramePrintArea().Pos() );
149  pFrame->GetModelPositionForViewPoint( pTmpCursor->GetPoint(), aPt );
150  if( !pTmpCursor->IsSelOvr() )
151  UpdateCursor();
152  else
153  pFrame = nullptr;
154  }
155  return nullptr != pFrame;
156 }
157 
159 bool SwCursorShell::GotoFooterText()
160 {
161  const SwPageFrame* pFrame = GetCurrFrame()->FindPageFrame();
162  if( pFrame )
163  {
164  const SwFrame* pLower = pFrame->GetLastLower();
165 
166  while( pLower && !pLower->IsFooterFrame() )
167  pLower = pLower->GetLower();
168  // found footer, search 1. content frame
169  while( pLower && !pLower->IsContentFrame() )
170  pLower = pLower->GetLower();
171 
172  if( pLower )
173  {
174  SwCursor *pTmpCursor = getShellCursor( true );
175  CurrShell aCurr( this );
176  // get position in footer
177  SwCallLink aLk( *this ); // watch Cursor-Moves
178  SwCursorSaveState aSaveState( *pTmpCursor );
179  pLower->Calc(GetOut());
180  Point aPt( pLower->getFrameArea().Pos() + pLower->getFramePrintArea().Pos() );
181  pLower->GetModelPositionForViewPoint( pTmpCursor->GetPoint(), aPt );
182  if( !pTmpCursor->IsSelOvr() )
183  UpdateCursor();
184  else
185  pFrame = nullptr;
186  }
187  else
188  pFrame = nullptr;
189  }
190  else
191  pFrame = nullptr;
192  return nullptr != pFrame;
193 }
194 
195 bool SwCursorShell::SetCursorInHdFt( size_t nDescNo, bool bInHeader )
196 {
197  bool bRet = false;
198  SwDoc *pMyDoc = GetDoc();
199  const SwPageDesc* pDesc = nullptr;
200 
201  CurrShell aCurr( this );
202 
203  if( SIZE_MAX == nDescNo )
204  {
205  // take the current one
206  const SwContentFrame *pCurrFrame = GetCurrFrame();
207  const SwPageFrame* pPage = (pCurrFrame == nullptr) ? nullptr : pCurrFrame->FindPageFrame();
208  if( pPage && pMyDoc->ContainsPageDesc(
209  pPage->GetPageDesc(), &nDescNo) )
210  pDesc = pPage->GetPageDesc();
211  }
212  else
213  if (nDescNo < pMyDoc->GetPageDescCnt())
214  pDesc = &pMyDoc->GetPageDesc( nDescNo );
215 
216  if( pDesc )
217  {
218  // check if the attribute exists
219  const SwFormatContent* pCnt = nullptr;
220  if( bInHeader )
221  {
222  // mirrored pages? ignore for now
223  const SwFormatHeader& rHd = pDesc->GetMaster().GetHeader();
224  if( rHd.GetHeaderFormat() )
225  pCnt = &rHd.GetHeaderFormat()->GetContent();
226  }
227  else
228  {
229  const SwFormatFooter& rFt = pDesc->GetMaster().GetFooter();
230  if( rFt.GetFooterFormat() )
231  pCnt = &rFt.GetFooterFormat()->GetContent();
232  }
233 
234  if( pCnt && pCnt->GetContentIdx() )
235  {
236  SwNodeIndex aIdx( *pCnt->GetContentIdx(), 1 );
237  SwContentNode* pCNd = aIdx.GetNode().GetContentNode();
238  if( !pCNd )
239  pCNd = pMyDoc->GetNodes().GoNext( &aIdx );
240 
241  Point aPt( m_pCurrentCursor->GetPtPos() );
242 
243  std::pair<Point, bool> const tmp(aPt, false);
244  if (pCNd && nullptr != pCNd->getLayoutFrame(GetLayout(), nullptr, &tmp))
245  {
246  // then we can set the cursor in here
247  SwCallLink aLk( *this ); // watch Cursor-Moves
248  SwCursorSaveState aSaveState( *m_pCurrentCursor );
249 
250  ClearMark();
251 
252  SwPosition& rPos = *m_pCurrentCursor->GetPoint();
253  rPos.nNode = *pCNd;
254  rPos.nContent.Assign( pCNd, 0 );
255 
256  bRet = !m_pCurrentCursor->IsSelOvr();
257  if( bRet )
258  UpdateCursor( SwCursorShell::SCROLLWIN | SwCursorShell::CHKRANGE |
259  SwCursorShell::READONLY );
260  }
261  }
262  }
263  return bRet;
264 }
265 
267 bool SwCursorShell::GotoNextTOXBase( const OUString* pName )
268 {
269  bool bRet = false;
270 
271  const SwSectionFormats& rFormats = GetDoc()->GetSections();
272  SwContentNode* pFnd = nullptr;
273  for( SwSectionFormats::size_type n = rFormats.size(); n; )
274  {
275  const SwSection* pSect = rFormats[ --n ]->GetSection();
276  if (SectionType::ToxContent == pSect->GetType())
277  {
278  SwSectionNode const*const pSectNd(
279  pSect->GetFormat()->GetSectionNode());
280  if ( pSectNd
281  && m_pCurrentCursor->GetPoint()->nNode < pSectNd->GetIndex()
282  && (!pFnd || pFnd->GetIndex() > pSectNd->GetIndex())
283  && (!pName || *pName ==
284  static_cast<SwTOXBaseSection const*>(pSect)->GetTOXName()))
285  {
286  SwNodeIndex aIdx(*pSectNd, 1);
287  SwContentNode* pCNd = aIdx.GetNode().GetContentNode();
288  if (!pCNd)
289  pCNd = GetDoc()->GetNodes().GoNext( &aIdx );
290  if (pCNd &&
291  pCNd->EndOfSectionIndex() <= pSectNd->EndOfSectionIndex())
292  {
293  SwContentFrame const*const pCFrame(
294  pCNd->getLayoutFrame(GetLayout()));
295  if (pCFrame &&
296  (IsReadOnlyAvailable() || !pCFrame->IsProtected()))
297  {
298  pFnd = pCNd;
299  }
300  }
301  }
302  }
303  }
304  if( pFnd )
305  {
306  SwCallLink aLk( *this ); // watch Cursor-Moves
307  SwCursorSaveState aSaveState( *m_pCurrentCursor );
308  m_pCurrentCursor->GetPoint()->nNode = *pFnd;
309  m_pCurrentCursor->GetPoint()->nContent.Assign( pFnd, 0 );
310  bRet = !m_pCurrentCursor->IsSelOvr();
311  if( bRet )
312  UpdateCursor(SwCursorShell::SCROLLWIN|SwCursorShell::CHKRANGE|SwCursorShell::READONLY);
313  }
314  return bRet;
315 }
316 
318 bool SwCursorShell::GotoPrevTOXBase( const OUString* pName )
319 {
320  bool bRet = false;
321 
322  const SwSectionFormats& rFormats = GetDoc()->GetSections();
323  SwContentNode* pFnd = nullptr;
324  for( SwSectionFormats::size_type n = rFormats.size(); n; )
325  {
326  const SwSection* pSect = rFormats[ --n ]->GetSection();
327  if (SectionType::ToxContent == pSect->GetType())
328  {
329  SwSectionNode const*const pSectNd(
330  pSect->GetFormat()->GetSectionNode());
331  if ( pSectNd
332  && m_pCurrentCursor->GetPoint()->nNode > pSectNd->EndOfSectionIndex()
333  && (!pFnd || pFnd->GetIndex() < pSectNd->GetIndex())
334  && (!pName || *pName ==
335  static_cast<SwTOXBaseSection const*>(pSect)->GetTOXName()))
336  {
337  SwNodeIndex aIdx(*pSectNd, 1);
338  SwContentNode* pCNd = aIdx.GetNode().GetContentNode();
339  if (!pCNd)
340  pCNd = GetDoc()->GetNodes().GoNext( &aIdx );
341  if (pCNd &&
342  pCNd->EndOfSectionIndex() <= pSectNd->EndOfSectionIndex())
343  {
344  SwContentFrame const*const pCFrame(
345  pCNd->getLayoutFrame(GetLayout()));
346  if (pCFrame &&
347  (IsReadOnlyAvailable() || !pCFrame->IsProtected()))
348  {
349  pFnd = pCNd;
350  }
351  }
352  }
353  }
354  }
355 
356  if( pFnd )
357  {
358  SwCallLink aLk( *this ); // watch Cursor-Moves
359  SwCursorSaveState aSaveState( *m_pCurrentCursor );
360  m_pCurrentCursor->GetPoint()->nNode = *pFnd;
361  m_pCurrentCursor->GetPoint()->nContent.Assign( pFnd, 0 );
362  bRet = !m_pCurrentCursor->IsSelOvr();
363  if( bRet )
364  UpdateCursor(SwCursorShell::SCROLLWIN|SwCursorShell::CHKRANGE|SwCursorShell::READONLY);
365  }
366  return bRet;
367 }
368 
370 void SwCursorShell::GotoTOXMarkBase()
371 {
372  SwTOXMarks aMarks;
373  sal_uInt16 nCnt = SwDoc::GetCurTOXMark(*m_pCurrentCursor->GetPoint(), aMarks);
374  if(!nCnt)
375  return;
376  // Take the 1. and get the index type. Ask it for the actual index.
377  const SwTOXType* pType = aMarks[0]->GetTOXType();
378  auto pContentFrame = pType->FindContentFrame(*GetDoc(), *GetLayout());
379  SwCallLink aLk(*this); // watch Cursor-Moves
380  SwCursorSaveState aSaveState(*m_pCurrentCursor);
381  assert(pContentFrame->IsTextFrame());
382  *m_pCurrentCursor->GetPoint() = static_cast<SwTextFrame const*>(pContentFrame)->MapViewToModelPos(TextFrameIndex(0));
383  if(!m_pCurrentCursor->IsInProtectTable() && !m_pCurrentCursor->IsSelOvr())
384  UpdateCursor(SwCursorShell::SCROLLWIN|SwCursorShell::CHKRANGE|SwCursorShell::READONLY);
385 }
386 
389 bool SwCursorShell::GotoNxtPrvTableFormula( bool bNext, bool bOnlyErrors )
390 {
391  SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::Empty );
392 
393  if( IsTableMode() )
394  return false;
395 
396  bool bFnd = false;
397  SwPosition aOldPos = *m_pCurrentCursor->GetPoint();
398  SwPosition& rPos = *m_pCurrentCursor->GetPoint();
399 
400  Point aPt;
401  SwPosition aFndPos( GetDoc()->GetNodes().GetEndOfContent() );
402  if( !bNext )
403  aFndPos.nNode = 0;
404  SetGetExpField aFndGEF( aFndPos ), aCurGEF( rPos );
405 
406  {
407  const SwNode* pSttNd = rPos.nNode.GetNode().FindTableBoxStartNode();
408  if( pSttNd )
409  {
410  const SwTableBox* pTBox = pSttNd->FindTableNode()->GetTable().
411  GetTableBox( pSttNd->GetIndex() );
412  if( pTBox )
413  aCurGEF = SetGetExpField( *pTBox );
414  }
415  }
416 
417  if( rPos.nNode < GetDoc()->GetNodes().GetEndOfExtras() )
418  {
419  // also at collection use only the first frame
420  std::pair<Point, bool> const tmp(aPt, false);
421  aCurGEF.SetBodyPos( *rPos.nNode.GetNode().GetContentNode()->getLayoutFrame( GetLayout(),
422  &rPos, &tmp) );
423  }
424  {
425  sal_uInt32 nMaxItems = GetDoc()->GetAttrPool().GetItemCount2( RES_BOXATR_FORMULA );
426 
427  if( nMaxItems > 0 )
428  {
429  sal_uInt8 nMaxDo = 2;
430  do {
431  for (const SfxPoolItem* pItem : GetDoc()->GetAttrPool().GetItemSurrogates(RES_BOXATR_FORMULA))
432  {
433  const SwTableBox* pTBox;
434  auto pFormulaItem = dynamic_cast<const SwTableBoxFormula*>(pItem);
435  if( !pFormulaItem )
436  continue;
437  pTBox = pFormulaItem->GetTableBox();
438  if( pTBox &&
439  pTBox->GetSttNd() &&
440  pTBox->GetSttNd()->GetNodes().IsDocNodes() &&
441  ( !bOnlyErrors ||
442  !pFormulaItem->HasValidBoxes() ) )
443  {
444  SwNodeIndex aIdx( *pTBox->GetSttNd() );
445  const SwContentNode* pCNd = GetDoc()->GetNodes().GoNext( &aIdx );
446  std::pair<Point, bool> const tmp(aPt, false);
447  if (pCNd)
448  {
449  const SwContentFrame* pCFrame = pCNd->getLayoutFrame(GetLayout(), nullptr, &tmp);
450  if (pCFrame && (IsReadOnlyAvailable() || !pCFrame->IsProtected() ))
451  {
452  SetGetExpField aCmp( *pTBox );
453  aCmp.SetBodyPos( *pCFrame );
454 
455  if( bNext ? ( aCurGEF < aCmp && aCmp < aFndGEF )
456  : ( aCmp < aCurGEF && aFndGEF < aCmp ))
457  {
458  aFndGEF = aCmp;
459  bFnd = true;
460  }
461  }
462  }
463  }
464  }
465  if( !bFnd )
466  {
467  if( bNext )
468  {
469  rPos.nNode = 0;
470  rPos.nContent = 0;
471  aCurGEF = SetGetExpField( rPos );
472  SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::EndWrapped );
473  }
474  else
475  {
476  aCurGEF = SetGetExpField( SwPosition( GetDoc()->GetNodes().GetEndOfContent() ) );
477  SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::StartWrapped );
478  }
479  }
480  } while( !bFnd && --nMaxDo );
481  }
482  }
483 
484  if( bFnd )
485  {
486  CurrShell aCurr( this );
487  SwCallLink aLk( *this ); // watch Cursor-Moves
488  SwCursorSaveState aSaveState( *m_pCurrentCursor );
489 
490  aFndGEF.GetPosOfContent( rPos );
491  m_pCurrentCursor->DeleteMark();
492 
493  bFnd = !m_pCurrentCursor->IsSelOvr();
494  if( bFnd )
495  UpdateCursor( SwCursorShell::SCROLLWIN | SwCursorShell::CHKRANGE |
496  SwCursorShell::READONLY );
497  }
498  else
499  {
500  rPos = aOldPos;
501  SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::NavElementNotFound );
502  }
503 
504  return bFnd;
505 }
506 
508 bool SwCursorShell::GotoNxtPrvTOXMark( bool bNext )
509 {
510  SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::Empty );
511 
512  if( IsTableMode() )
513  return false;
514 
515  bool bFnd = false;
516  SwPosition& rPos = *m_pCurrentCursor->GetPoint();
517 
518  Point aPt;
519  SwPosition aFndPos( GetDoc()->GetNodes().GetEndOfContent() );
520  if( !bNext )
521  aFndPos.nNode = 0;
522  SetGetExpField aFndGEF( aFndPos ), aCurGEF( rPos );
523 
524  if( rPos.nNode.GetIndex() < GetDoc()->GetNodes().GetEndOfExtras().GetIndex() )
525  {
526  // also at collection use only the first frame
527  std::pair<Point, bool> const tmp(aPt, false);
528  aCurGEF.SetBodyPos( *rPos.nNode.GetNode().
529  GetContentNode()->getLayoutFrame(GetLayout(), &rPos, &tmp));
530  }
531 
532  {
533  const SwTextNode* pTextNd;
534  const SwTextTOXMark* pTextTOX;
535  sal_uInt32 nMaxItems = GetDoc()->GetAttrPool().GetItemCount2( RES_TXTATR_TOXMARK );
536 
537  if( nMaxItems > 0 )
538  {
539  do {
540  for (const SfxPoolItem* pItem : GetDoc()->GetAttrPool().GetItemSurrogates(RES_TXTATR_TOXMARK))
541  {
542  auto pToxMarkItem = dynamic_cast<const SwTOXMark*>(pItem);
543  if( !pToxMarkItem )
544  continue;
545  pTextTOX = pToxMarkItem->GetTextTOXMark();
546  if( !pTextTOX )
547  continue;
548  pTextNd = &pTextTOX->GetTextNode();
549  if( !pTextNd->GetNodes().IsDocNodes() )
550  continue;
551  std::pair<Point, bool> const tmp(aPt, false);
552  const SwContentFrame* pCFrame = pTextNd->getLayoutFrame(GetLayout(), nullptr, &tmp);
553  if( pCFrame && ( IsReadOnlyAvailable() || !pCFrame->IsProtected() ))
554  {
555  SwNodeIndex aNdIndex( *pTextNd ); // UNIX needs this object
556  SetGetExpField aCmp( aNdIndex, *pTextTOX );
557  aCmp.SetBodyPos( *pCFrame );
558 
559  if( bNext ? ( aCurGEF < aCmp && aCmp < aFndGEF )
560  : ( aCmp < aCurGEF && aFndGEF < aCmp ))
561  {
562  aFndGEF = aCmp;
563  bFnd = true;
564  }
565  }
566  }
567  if( !bFnd )
568  {
569  if ( bNext )
570  {
571  rPos.nNode = 0;
572  rPos.nContent = 0;
573  aCurGEF = SetGetExpField( rPos );
574  SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::EndWrapped );
575  }
576  else
577  {
578  aCurGEF = SetGetExpField( SwPosition( GetDoc()->GetNodes().GetEndOfContent() ) );
579  SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::StartWrapped );
580  }
581  }
582  } while ( !bFnd );
583  }
584  else
585  SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::NavElementNotFound );
586  }
587 
588  if( bFnd )
589  {
590  CurrShell aCurr( this );
591  SwCallLink aLk( *this ); // watch Cursor-Moves
592  SwCursorSaveState aSaveState( *m_pCurrentCursor );
593 
594  aFndGEF.GetPosOfContent( rPos );
595 
596  bFnd = !m_pCurrentCursor->IsSelOvr();
597  if( bFnd )
598  UpdateCursor( SwCursorShell::SCROLLWIN | SwCursorShell::CHKRANGE |
599  SwCursorShell::READONLY );
600  }
601  return bFnd;
602 }
603 
605 const SwTOXMark& SwCursorShell::GotoTOXMark( const SwTOXMark& rStart,
606  SwTOXSearch eDir )
607 {
608  CurrShell aCurr( this );
609  SwCallLink aLk( *this ); // watch Cursor-Moves
610  SwCursorSaveState aSaveState( *m_pCurrentCursor );
611 
612  const SwTOXMark& rNewMark = GetDoc()->GotoTOXMark( rStart, eDir,
613  IsReadOnlyAvailable() );
614  // set position
615  SwPosition& rPos = *GetCursor()->GetPoint();
616  rPos.nNode = rNewMark.GetTextTOXMark()->GetTextNode();
617  rPos.nContent.Assign( rPos.nNode.GetNode().GetContentNode(),
618  rNewMark.GetTextTOXMark()->GetStart() );
619 
620  if( !m_pCurrentCursor->IsSelOvr() )
621  UpdateCursor( SwCursorShell::SCROLLWIN | SwCursorShell::CHKRANGE |
622  SwCursorShell::READONLY );
623 
624  return rNewMark;
625 }
626 
628 static void lcl_MakeFieldLst(
629  SetGetExpFields& rLst,
630  const SwFieldType& rFieldType,
631  const bool bInReadOnly,
632  const bool bChkInpFlag = false )
633 {
634  // always search the 1. frame
635  Point aPt;
636  std::vector<SwFormatField*> vFields;
637  rFieldType.GatherFields(vFields, false);
638  for(SwFormatField* pFormatField: vFields)
639  {
640  SwTextField* pTextField = pFormatField->GetTextField();
641  if ( pTextField != nullptr
642  && ( !bChkInpFlag
643  || static_cast<const SwSetExpField*>(pTextField->GetFormatField().GetField())->GetInputFlag() ) )
644  {
645  const SwTextNode& rTextNode = pTextField->GetTextNode();
646  std::pair<Point, bool> const tmp(aPt, false);
647  const SwContentFrame* pCFrame =
648  rTextNode.getLayoutFrame(
649  rTextNode.GetDoc().getIDocumentLayoutAccess().GetCurrentLayout(),
650  nullptr, &tmp);
651  if ( pCFrame != nullptr
652  && ( bInReadOnly || !pCFrame->IsProtected() ) )
653  {
654  std::unique_ptr<SetGetExpField> pNew(new SetGetExpField( SwNodeIndex( rTextNode ), pTextField ));
655  pNew->SetBodyPos( *pCFrame );
656  rLst.insert( std::move(pNew) );
657  }
658  }
659  }
660 }
661 
662 static SetGetExpFields::const_iterator
663 lcl_FindField(bool & o_rFound, SetGetExpFields const& rSrtLst,
664  SwRootFrame const *const pLayout, SwTextNode *const pTextNode,
665  SwTextField const *const pTextField, SwPosition const& rPos,
666  sal_Int32 const nContentOffset)
667 {
668  std::unique_ptr<SetGetExpField> pSrch;
669  std::unique_ptr<SwIndex> pIndex;
670  if (-1 == nContentOffset)
671  {
672  pSrch.reset(new SetGetExpField(rPos.nNode, pTextField, &rPos.nContent));
673  }
674  else
675  {
676  pIndex.reset(new SwIndex(rPos.nNode.GetNode().GetContentNode(), nContentOffset));
677  pSrch.reset(new SetGetExpField(rPos.nNode, pTextField, pIndex.get()));
678  }
679 
680  if (rPos.nNode.GetIndex() < pTextNode->GetNodes().GetEndOfExtras().GetIndex())
681  {
682  // also at collection use only the first frame
683  Point aPt;
684  std::pair<Point, bool> const tmp(aPt, false);
685  pSrch->SetBodyPos(*pTextNode->getLayoutFrame(pLayout, &rPos, &tmp));
686  }
687 
688  SetGetExpFields::const_iterator it = rSrtLst.lower_bound(pSrch.get());
689 
690  o_rFound = (it != rSrtLst.end()) && (**it == *pSrch);
691  return it;
692 }
693 
694 bool SwCursorShell::MoveFieldType(
695  const SwFieldType* pFieldType,
696  const bool bNext,
697  const SwFieldIds nResType,
698  const bool bAddSetExpressionFieldsToInputFields )
699 {
700  // sorted list of all fields
701  SetGetExpFields aSrtLst;
702 
703  if ( pFieldType )
704  {
705  if( SwFieldIds::Input != pFieldType->Which() && !pFieldType->HasWriterListeners() )
706  {
707  return false;
708  }
709 
710  // found Modify object, add all fields to array
711  ::lcl_MakeFieldLst( aSrtLst, *pFieldType, IsReadOnlyAvailable() );
712 
713  if( SwFieldIds::Input == pFieldType->Which() && bAddSetExpressionFieldsToInputFields )
714  {
715  // there are hidden input fields in the set exp. fields
716  const SwFieldTypes& rFieldTypes = *mxDoc->getIDocumentFieldsAccess().GetFieldTypes();
717  const size_t nSize = rFieldTypes.size();
718  for( size_t i=0; i < nSize; ++i )
719  {
720  pFieldType = rFieldTypes[ i ].get();
721  if ( SwFieldIds::SetExp == pFieldType->Which() )
722  {
723  ::lcl_MakeFieldLst( aSrtLst, *pFieldType, IsReadOnlyAvailable(), true );
724  }
725  }
726  }
727  }
728  else
729  {
730  const SwFieldTypes& rFieldTypes = *mxDoc->getIDocumentFieldsAccess().GetFieldTypes();
731  const size_t nSize = rFieldTypes.size();
732  const bool bAllFieldTypes = nResType == SwFieldIds::Unknown;
733  for( size_t i=0; i < nSize; ++i )
734  {
735  pFieldType = rFieldTypes[ i ].get();
736  if (bAllFieldTypes || nResType == pFieldType->Which())
737  {
738  ::lcl_MakeFieldLst( aSrtLst, *pFieldType, IsReadOnlyAvailable() );
739  }
740  }
741  }
742 
743  // found no fields?
744  if( aSrtLst.empty() )
745  return false;
746 
747  SetGetExpFields::const_iterator it;
748  SwCursor* pCursor = getShellCursor( true );
749  {
750  // (1998): Always use field for search so that the right one is found as
751  // well some are in frames that are anchored to a paragraph that has a
752  // field
753  const SwPosition& rPos = *pCursor->GetPoint();
754 
755  SwTextNode* pTNd = rPos.nNode.GetNode().GetTextNode();
756  OSL_ENSURE( pTNd, "No ContentNode" );
757 
758  SwTextField * pTextField = pTNd->GetFieldTextAttrAt( rPos.nContent.GetIndex(), true );
759  const bool bDelField = ( pTextField == nullptr );
760  sal_Int32 nContentOffset = -1;
761 
762  if( bDelField )
763  {
764  // create dummy for the search
765  SwFormatField* pFormatField = new SwFormatField( SwDateTimeField(
766  static_cast<SwDateTimeFieldType*>(mxDoc->getIDocumentFieldsAccess().GetSysFieldType( SwFieldIds::DateTime ) ) ) );
767 
768  pTextField = new SwTextField( *pFormatField, rPos.nContent.GetIndex(),
769  mxDoc->IsClipBoard() );
770  pTextField->ChgTextNode( pTNd );
771  }
772  else
773  {
774  // the cursor might be anywhere inside the input field,
775  // but we will be searching for the field start
776  if (pTextField->Which() == RES_TXTATR_INPUTFIELD
777  && rPos.nContent.GetIndex() != pTextField->GetStart())
778  nContentOffset = pTextField->GetStart();
779  }
780  bool isSrch;
781  it = lcl_FindField(isSrch, aSrtLst,
782  GetLayout(), pTNd, pTextField, rPos, nContentOffset);
783 
784  if( bDelField )
785  {
786  auto const pFormat(static_cast<SwFormatField*>(&pTextField->GetAttr()));
787  delete pTextField;
788  delete pFormat;
789  }
790 
791  if( it != aSrtLst.end() && isSrch ) // found
792  {
793  if( bNext )
794  {
795  if( ++it == aSrtLst.end() )
796  return false; // already at the end
797  }
798  else
799  {
800  if( it == aSrtLst.begin() )
801  return false; // no more steps backward possible
802  --it;
803  }
804  }
805  else // not found
806  {
807  if( bNext )
808  {
809  if( it == aSrtLst.end() )
810  return false;
811  }
812  else
813  {
814  if( it == aSrtLst.begin() )
815  return false; // no more steps backward possible
816  --it;
817  }
818  }
819  }
820  const SetGetExpField& rFnd = **it;
821 
822  CurrShell aCurr( this );
823  SwCallLink aLk( *this ); // watch Cursor-Moves
824  SwCursorSaveState aSaveState( *pCursor );
825 
826  rFnd.GetPosOfContent( *pCursor->GetPoint() );
827  bool bRet = !m_pCurrentCursor->IsSelOvr( SwCursorSelOverFlags::CheckNodeSection |
828  SwCursorSelOverFlags::Toggle );
829  if( bRet )
830  UpdateCursor(SwCursorShell::SCROLLWIN|SwCursorShell::CHKRANGE|SwCursorShell::READONLY);
831  return bRet;
832 }
833 
834 bool SwCursorShell::GotoFormatField( const SwFormatField& rField )
835 {
836  bool bRet = false;
837  SwTextField const*const pTextField(rField.GetTextField());
838  if (pTextField
839  && (!GetLayout()->IsHideRedlines()
840  || !sw::IsFieldDeletedInModel(
841  GetDoc()->getIDocumentRedlineAccess(), *pTextField)))
842  {
843  CurrShell aCurr( this );
844  SwCallLink aLk( *this ); // watch Cursor-Moves
845 
846  SwCursor* pCursor = getShellCursor( true );
847  SwCursorSaveState aSaveState( *pCursor );
848 
849  SwTextNode* pTNd = pTextField->GetpTextNode();
850  pCursor->GetPoint()->nNode = *pTNd;
851  pCursor->GetPoint()->nContent.Assign( pTNd, pTextField->GetStart() );
852 
853  bRet = !pCursor->IsSelOvr();
854  if( bRet )
855  UpdateCursor(SwCursorShell::SCROLLWIN|SwCursorShell::CHKRANGE|SwCursorShell::READONLY);
856  }
857  return bRet;
858 }
859 
860 SwTextField * SwCursorShell::GetTextFieldAtPos(
861  const SwPosition* pPos,
862  const bool bIncludeInputFieldAtStart )
863 {
864  SwTextField* pTextField = nullptr;
865 
866  SwTextNode * const pNode = pPos->nNode.GetNode().GetTextNode();
867  if ( pNode != nullptr )
868  {
869  pTextField = pNode->GetFieldTextAttrAt( pPos->nContent.GetIndex(), bIncludeInputFieldAtStart );
870  }
871 
872  return pTextField;
873 }
874 
875 SwTextField* SwCursorShell::GetTextFieldAtCursor(
876  const SwPaM* pCursor,
877  const bool bIncludeInputFieldAtStart )
878 {
879  SwTextField* pFieldAtCursor = nullptr;
880 
881  SwTextField* pTextField = GetTextFieldAtPos( pCursor->Start(), bIncludeInputFieldAtStart );
882  if ( pTextField != nullptr
883  && pCursor->Start()->nNode == pCursor->End()->nNode )
884  {
885  const sal_Int32 nTextFieldLength =
886  pTextField->End() != nullptr
887  ? *(pTextField->End()) - pTextField->GetStart()
888  : 1;
889  if ( ( pCursor->End()->nContent.GetIndex() - pCursor->Start()->nContent.GetIndex() ) <= nTextFieldLength )
890  {
891  pFieldAtCursor = pTextField;
892  }
893  }
894 
895  return pFieldAtCursor;
896 }
897 
898 SwField* SwCursorShell::GetFieldAtCursor(
899  const SwPaM *const pCursor,
900  const bool bIncludeInputFieldAtStart)
901 {
902  SwTextField *const pField(GetTextFieldAtCursor(pCursor, bIncludeInputFieldAtStart));
903  return pField
904  ? const_cast<SwField*>(pField->GetFormatField().GetField())
905  : nullptr;
906 }
907 
908 SwField* SwCursorShell::GetCurField( const bool bIncludeInputFieldAtStart ) const
909 {
910  SwPaM* pCursor = GetCursor();
911  if ( pCursor->IsMultiSelection() )
912  {
913  // multi selection not handled.
914  return nullptr;
915  }
916 
917  SwField* pCurField = GetFieldAtCursor( pCursor, bIncludeInputFieldAtStart );
918  if ( pCurField != nullptr
919  && SwFieldIds::Table == pCurField->GetTyp()->Which() )
920  {
921  // table formula? convert internal name into external
922  const SwTableNode* pTableNd = IsCursorInTable();
923  static_cast<SwTableField*>(pCurField)->PtrToBoxNm( pTableNd ? &pTableNd->GetTable() : nullptr );
924  }
925 
926  return pCurField;
927 }
928 
929 bool SwCursorShell::CursorInsideInputField() const
930 {
931  for(SwPaM& rCursor : GetCursor()->GetRingContainer())
932  {
933  if (dynamic_cast<const SwTextInputField*>(GetTextFieldAtCursor(&rCursor, true)))
934  return true;
935  }
936  return false;
937 }
938 
939 bool SwCursorShell::PosInsideInputField( const SwPosition& rPos )
940 {
941  return dynamic_cast<const SwTextInputField*>(GetTextFieldAtPos( &rPos, false )) != nullptr;
942 }
943 
944 bool SwCursorShell::DocPtInsideInputField( const Point& rDocPt ) const
945 {
946  SwPosition aPos( *(GetCursor()->Start()) );
947  Point aDocPt( rDocPt );
948  if ( GetLayout()->GetModelPositionForViewPoint( &aPos, aDocPt ) )
949  {
950  return PosInsideInputField( aPos );
951  }
952  return false;
953 }
954 
955 sal_Int32 SwCursorShell::StartOfInputFieldAtPos( const SwPosition& rPos )
956 {
957  const SwTextInputField* pTextInputField = dynamic_cast<const SwTextInputField*>(GetTextFieldAtPos( &rPos, true ));
958  assert(pTextInputField != nullptr
959  && "<SwEditShell::StartOfInputFieldAtPos(..)> - no Input Field at given position");
960  return pTextInputField->GetStart();
961 }
962 
963 sal_Int32 SwCursorShell::EndOfInputFieldAtPos( const SwPosition& rPos )
964 {
965  const SwTextInputField* pTextInputField = dynamic_cast<const SwTextInputField*>(GetTextFieldAtPos( &rPos, true ));
966  assert(pTextInputField != nullptr
967  && "<SwEditShell::EndOfInputFieldAtPos(..)> - no Input Field at given position");
968  return *(pTextInputField->End());
969 }
970 
971 void SwCursorShell::GotoOutline( SwOutlineNodes::size_type nIdx )
972 {
973  SwCursor* pCursor = getShellCursor( true );
974 
975  CurrShell aCurr( this );
976  SwCallLink aLk( *this ); // watch Cursor-Moves
977  SwCursorSaveState aSaveState( *pCursor );
978 
979  const SwNodes& rNds = GetDoc()->GetNodes();
980  SwTextNode* pTextNd = rNds.GetOutLineNds()[ nIdx ]->GetTextNode();
981  pCursor->GetPoint()->nNode = *pTextNd;
982  pCursor->GetPoint()->nContent.Assign( pTextNd, 0 );
983 
984  if( !pCursor->IsSelOvr() )
985  UpdateCursor(SwCursorShell::SCROLLWIN|SwCursorShell::CHKRANGE|SwCursorShell::READONLY);
986 }
987 
988 bool SwCursorShell::GotoOutline( const OUString& rName )
989 {
990  SwCursor* pCursor = getShellCursor( true );
991 
992  CurrShell aCurr( this );
993  SwCallLink aLk( *this ); // watch Cursor-Moves
994  SwCursorSaveState aSaveState( *pCursor );
995 
996  bool bRet = false;
997  if (mxDoc->GotoOutline(*pCursor->GetPoint(), rName, GetLayout())
998  && !pCursor->IsSelOvr())
999  {
1000  UpdateCursor(SwCursorShell::SCROLLWIN|SwCursorShell::CHKRANGE|SwCursorShell::READONLY);
1001  bRet = true;
1002  }
1003  return bRet;
1004 }
1005 
1007 bool SwCursorShell::GotoNextOutline()
1008 {
1009  const SwNodes& rNds = GetDoc()->GetNodes();
1010 
1011  if ( rNds.GetOutLineNds().empty() )
1012  {
1013  SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::NavElementNotFound );
1014  return false;
1015  }
1016 
1017  SwCursor* pCursor = getShellCursor( true );
1018  SwNode* pNd = &(pCursor->GetNode());
1019  SwOutlineNodes::size_type nPos;
1020  bool bUseFirst = !rNds.GetOutLineNds().Seek_Entry( pNd, &nPos );
1021  SwOutlineNodes::size_type const nStartPos(nPos);
1022 
1023  do
1024  {
1025  if (!bUseFirst)
1026  {
1027  ++nPos;
1028  }
1029  if (rNds.GetOutLineNds().size() <= nPos)
1030  {
1031  nPos = 0;
1032  }
1033 
1034  if (bUseFirst)
1035  {
1036  bUseFirst = false;
1037  }
1038  else
1039  {
1040  if (nPos == nStartPos)
1041  {
1042  SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::NavElementNotFound );
1043  return false;
1044  }
1045  }
1046 
1047  pNd = rNds.GetOutLineNds()[ nPos ];
1048  }
1049  while (!sw::IsParaPropsNode(*GetLayout(), *pNd->GetTextNode()));
1050 
1051  if (nPos < nStartPos)
1052  {
1053  SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::EndWrapped );
1054  }
1055  else
1056  {
1057  SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::Empty );
1058  }
1059 
1060  CurrShell aCurr( this );
1061  SwCallLink aLk( *this ); // watch Cursor-Moves
1062  SwCursorSaveState aSaveState( *pCursor );
1063  pCursor->GetPoint()->nNode = *pNd;
1064  pCursor->GetPoint()->nContent.Assign( pNd->GetTextNode(), 0 );
1065 
1066  bool bRet = !pCursor->IsSelOvr();
1067  if( bRet )
1068  UpdateCursor(SwCursorShell::SCROLLWIN|SwCursorShell::CHKRANGE|SwCursorShell::READONLY);
1069  return bRet;
1070 }
1071 
1073 bool SwCursorShell::GotoPrevOutline()
1074 {
1075  const SwNodes& rNds = GetDoc()->GetNodes();
1076 
1077  if ( rNds.GetOutLineNds().empty() )
1078  {
1079  SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::NavElementNotFound );
1080  return false;
1081  }
1082 
1083  SwCursor* pCursor = getShellCursor( true );
1084  SwNode* pNd = &(pCursor->GetNode());
1085  SwOutlineNodes::size_type nPos;
1086  bool bRet = false;
1087  (void)rNds.GetOutLineNds().Seek_Entry(pNd, &nPos);
1088  SwOutlineNodes::size_type const nStartPos(nPos);
1089 
1090  do
1091  {
1092  if (nPos == 0)
1093  {
1094  nPos = rNds.GetOutLineNds().size() - 1;
1095  }
1096  else
1097  {
1098  --nPos; // before
1099  }
1100  if (nPos == nStartPos)
1101  {
1102  pNd = nullptr;
1103  break;
1104  }
1105 
1106  pNd = rNds.GetOutLineNds()[ nPos ];
1107  }
1108  while (!sw::IsParaPropsNode(*GetLayout(), *pNd->GetTextNode()));
1109 
1110  if (pNd)
1111  {
1112  if (nStartPos < nPos)
1113  {
1114  SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::StartWrapped );
1115  }
1116  else
1117  {
1118  SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::Empty );
1119  }
1120  CurrShell aCurr( this );
1121  SwCallLink aLk( *this ); // watch Cursor-Moves
1122  SwCursorSaveState aSaveState( *pCursor );
1123  pCursor->GetPoint()->nNode = *pNd;
1124  pCursor->GetPoint()->nContent.Assign( pNd->GetTextNode(), 0 );
1125 
1126  bRet = !pCursor->IsSelOvr();
1127  if( bRet )
1128  UpdateCursor(SwCursorShell::SCROLLWIN|SwCursorShell::CHKRANGE|SwCursorShell::READONLY);
1129  }
1130  else
1131  {
1132  SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::NavElementNotFound );
1133  }
1134  return bRet;
1135 }
1136 
1138 SwOutlineNodes::size_type SwCursorShell::GetOutlinePos(sal_uInt8 nLevel, SwPaM* pPaM)
1139 {
1140  SwPaM* pCursor = pPaM ? pPaM : getShellCursor(true);
1141  const SwNodes& rNds = GetDoc()->GetNodes();
1142 
1143  SwNode* pNd = &(pCursor->GetNode());
1144  SwOutlineNodes::size_type nPos;
1145  if( rNds.GetOutLineNds().Seek_Entry( pNd, &nPos ))
1146  nPos++; // is at correct position; take next for while
1147 
1148  while( nPos-- ) // check the one in front of the current
1149  {
1150  pNd = rNds.GetOutLineNds()[ nPos ];
1151 
1152  if (sw::IsParaPropsNode(*GetLayout(), *pNd->GetTextNode())
1153  && pNd->GetTextNode()->GetAttrOutlineLevel()-1 <= nLevel)
1154  {
1155  if (pNd->GetIndex() < rNds.GetEndOfExtras().GetIndex()
1156  && pCursor->GetNode().GetIndex() > rNds.GetEndOfExtras().GetIndex())
1157  {
1158  // node found in extras but cursor position is not in extras
1159  return SwOutlineNodes::npos;
1160  }
1161  return nPos;
1162  }
1163  }
1164  return SwOutlineNodes::npos; // no more left
1165 }
1166 
1167 void SwCursorShell::MakeOutlineSel(SwOutlineNodes::size_type nSttPos, SwOutlineNodes::size_type nEndPos,
1168  bool bWithChildren , bool bKillPams)
1169 {
1170  const SwNodes& rNds = GetDoc()->GetNodes();
1171  const SwOutlineNodes& rOutlNds = rNds.GetOutLineNds();
1172  if( rOutlNds.empty() )
1173  return;
1174 
1175  CurrShell aCurr( this );
1176  SwCallLink aLk( *this ); // watch Cursor-Moves
1177 
1178  if( nSttPos > nEndPos ) // parameters switched?
1179  {
1180  OSL_ENSURE( false, "Start > End for array access" );
1181  std::swap(nSttPos, nEndPos);
1182  }
1183 
1184  SwNode* pSttNd = rOutlNds[ nSttPos ];
1185  SwNode* pEndNd = rOutlNds[ nEndPos ];
1186 
1187  if( bWithChildren )
1188  {
1189  const int nLevel = pEndNd->GetTextNode()->GetAttrOutlineLevel()-1;
1190  for( ++nEndPos; nEndPos < rOutlNds.size(); ++nEndPos )
1191  {
1192  pEndNd = rOutlNds[ nEndPos ];
1193  const int nNxtLevel = pEndNd->GetTextNode()->GetAttrOutlineLevel()-1;
1194  if( nNxtLevel <= nLevel )
1195  break; // EndPos is now on the next one
1196  }
1197  }
1198  // if without children then set onto next one
1199  else if( ++nEndPos < rOutlNds.size() )
1200  pEndNd = rOutlNds[ nEndPos ];
1201 
1202  if( nEndPos == rOutlNds.size() ) // no end found
1203  pEndNd = &rNds.GetEndOfContent();
1204 
1205  if( bKillPams )
1206  KillPams();
1207 
1208  SwCursorSaveState aSaveState( *m_pCurrentCursor );
1209 
1210  // set end to the end of the previous content node
1211  m_pCurrentCursor->GetPoint()->nNode = *pSttNd;
1212  m_pCurrentCursor->GetPoint()->nContent.Assign( pSttNd->GetContentNode(), 0 );
1213  m_pCurrentCursor->SetMark();
1214  m_pCurrentCursor->GetPoint()->nNode = *pEndNd;
1215  m_pCurrentCursor->Move( fnMoveBackward, GoInNode ); // end of predecessor
1216 
1217  // and everything is already selected
1218  bool bRet = !m_pCurrentCursor->IsSelOvr();
1219  if( bRet )
1220  UpdateCursor(SwCursorShell::SCROLLWIN|SwCursorShell::CHKRANGE|SwCursorShell::READONLY);
1221 }
1222 
1224 bool SwCursorShell::GotoRefMark( const OUString& rRefMark, sal_uInt16 nSubType,
1225  sal_uInt16 nSeqNo )
1226 {
1227  CurrShell aCurr( this );
1228  SwCallLink aLk( *this ); // watch Cursor-Moves
1229  SwCursorSaveState aSaveState( *m_pCurrentCursor );
1230 
1231  sal_Int32 nPos = -1;
1232  SwTextNode* pTextNd = SwGetRefFieldType::FindAnchor( GetDoc(), rRefMark,
1233  nSubType, nSeqNo, &nPos, nullptr, GetLayout());
1234  if( pTextNd && pTextNd->GetNodes().IsDocNodes() )
1235  {
1236  m_pCurrentCursor->GetPoint()->nNode = *pTextNd;
1237  m_pCurrentCursor->GetPoint()->nContent.Assign( pTextNd, nPos );
1238 
1239  if( !m_pCurrentCursor->IsSelOvr() )
1240  {
1241  UpdateCursor(SwCursorShell::SCROLLWIN|SwCursorShell::CHKRANGE|SwCursorShell::READONLY);
1242  return true;
1243  }
1244  }
1245  return false;
1246 }
1247 
1248 bool SwCursorShell::IsPageAtPos( const Point &rPt ) const
1249 {
1250  if( GetLayout() )
1251  return nullptr != GetLayout()->GetPageAtPos( rPt );
1252  return false;
1253 }
1254 
1255 bool SwCursorShell::GetContentAtPos( const Point& rPt,
1256  SwContentAtPos& rContentAtPos,
1257  bool bSetCursor,
1258  SwRect* pFieldRect )
1259 {
1260  CurrShell aCurr( this );
1261  bool bRet = false;
1262 
1263  if( !IsTableMode() )
1264  {
1265  Point aPt( rPt );
1266  SwPosition aPos( *m_pCurrentCursor->GetPoint() );
1267 
1268  SwTextNode* pTextNd;
1269  SwCursorMoveState aTmpState;
1270  aTmpState.m_bFieldInfo = true;
1271  aTmpState.m_bExactOnly = !( IsAttrAtPos::Outline & rContentAtPos.eContentAtPos );
1272  aTmpState.m_bContentCheck = bool(IsAttrAtPos::ContentCheck & rContentAtPos.eContentAtPos);
1273  aTmpState.m_bSetInReadOnly = IsReadOnlyAvailable();
1274 
1275  SwSpecialPos aSpecialPos;
1276  aTmpState.m_pSpecialPos = ( IsAttrAtPos::SmartTag & rContentAtPos.eContentAtPos ) ?
1277  &aSpecialPos : nullptr;
1278 
1279  const bool bCursorFoundExact = GetLayout()->GetModelPositionForViewPoint( &aPos, aPt, &aTmpState );
1280  pTextNd = aPos.nNode.GetNode().GetTextNode();
1281 
1282  const SwNodes& rNds = GetDoc()->GetNodes();
1283  if( pTextNd
1284  && IsAttrAtPos::Outline & rContentAtPos.eContentAtPos
1285  && !rNds.GetOutLineNds().empty() )
1286  {
1287  // only for nodes in outline nodes
1288  SwOutlineNodes::size_type nPos;
1289  if(rNds.GetOutLineNds().Seek_Entry(pTextNd, &nPos))
1290  {
1291  rContentAtPos.eContentAtPos = IsAttrAtPos::Outline;
1292  rContentAtPos.sStr = sw::GetExpandTextMerged(GetLayout(), *pTextNd, true, false, ExpandMode::ExpandFootnote);
1293  rContentAtPos.aFnd.pNode = pTextNd;
1294  bRet = true;
1295  }
1296  }
1297  else if ( IsAttrAtPos::ContentCheck & rContentAtPos.eContentAtPos
1298  && bCursorFoundExact )
1299  {
1300  bRet = true;
1301  }
1302  else if( pTextNd
1303  && IsAttrAtPos::NumLabel & rContentAtPos.eContentAtPos)
1304  {
1305  bRet = aTmpState.m_bInNumPortion;
1306  rContentAtPos.aFnd.pNode = sw::GetParaPropsNode(*GetLayout(), aPos.nNode);
1307 
1308  Size aSizeLogic(aTmpState.m_nInNumPortionOffset, 0);
1309  Size aSizePixel = GetWin()->LogicToPixel(aSizeLogic);
1310  rContentAtPos.nDist = aSizePixel.Width();
1311  }
1312  else if( bCursorFoundExact && pTextNd )
1313  {
1314  SwContentFrame *pFrame(nullptr);
1315  if( !aTmpState.m_bPosCorr )
1316  {
1317  SwTextAttr* pTextAttr;
1318  if ( IsAttrAtPos::SmartTag & rContentAtPos.eContentAtPos
1319  && !aTmpState.m_bFootnoteNoInfo )
1320  {
1321  const SwWrongList* pSmartTagList = pTextNd->GetSmartTags();
1322  sal_Int32 nCurrent = aPos.nContent.GetIndex();
1323  const sal_Int32 nBegin = nCurrent;
1324  sal_Int32 nLen = 1;
1325 
1326  if (pSmartTagList && pSmartTagList->InWrongWord(nCurrent, nLen) && !pTextNd->IsSymbolAt(nBegin))
1327  {
1328  const sal_uInt16 nIndex = pSmartTagList->GetWrongPos( nBegin );
1329  const SwWrongList* pSubList = pSmartTagList->SubList( nIndex );
1330  if ( pSubList )
1331  {
1332  nCurrent = aTmpState.m_pSpecialPos->nCharOfst;
1333 
1334  if ( pSubList->InWrongWord( nCurrent, nLen ) )
1335  bRet = true;
1336  }
1337  else
1338  bRet = true;
1339 
1340  if( bRet && bSetCursor )
1341  {
1342  SwCursorSaveState aSaveState( *m_pCurrentCursor );
1343  SwCallLink aLk( *this ); // watch Cursor-Moves
1344  m_pCurrentCursor->DeleteMark();
1345  *m_pCurrentCursor->GetPoint() = aPos;
1346  if( m_pCurrentCursor->IsSelOvr( SwCursorSelOverFlags::CheckNodeSection | SwCursorSelOverFlags::Toggle) )
1347  bRet = false;
1348  else
1349  UpdateCursor();
1350  }
1351  if( bRet )
1352  {
1353  rContentAtPos.eContentAtPos = IsAttrAtPos::SmartTag;
1354 
1355  std::pair<Point, bool> tmp(aPt, true);
1356  if (pFieldRect)
1357  {
1358  pFrame = pTextNd->getLayoutFrame(GetLayout(), nullptr, &tmp);
1359  if (pFrame)
1360  pFrame->GetCharRect( *pFieldRect, aPos, &aTmpState );
1361  }
1362  }
1363  }
1364  }
1365 
1366  if ( !bRet
1367  && ( IsAttrAtPos::Field | IsAttrAtPos::ClickField ) & rContentAtPos.eContentAtPos
1368  && !aTmpState.m_bFootnoteNoInfo )
1369  {
1370  pTextAttr = pTextNd->GetFieldTextAttrAt( aPos.nContent.GetIndex() );
1371  const SwField* pField = pTextAttr != nullptr
1372  ? pTextAttr->GetFormatField().GetField()
1373  : nullptr;
1374  if ( IsAttrAtPos::ClickField & rContentAtPos.eContentAtPos
1375  && pField && !pField->HasClickHdl() )
1376  {
1377  pField = nullptr;
1378  }
1379 
1380  if ( pField )
1381  {
1382  if (pFieldRect)
1383  {
1384  std::pair<Point, bool> tmp(aPt, true);
1385  pFrame = pTextNd->getLayoutFrame(GetLayout(), nullptr, &tmp);
1386  if (pFrame)
1387  {
1388  //tdf#116397 now that we looking for the bounds of the field drop the SmartTag
1389  //index within field setting so we don't the bounds of the char within the field
1390  SwSpecialPos* pSpecialPos = aTmpState.m_pSpecialPos;
1391  aTmpState.m_pSpecialPos = nullptr;
1392  pFrame->GetCharRect( *pFieldRect, aPos, &aTmpState );
1393  aTmpState.m_pSpecialPos = pSpecialPos;
1394  }
1395  }
1396 
1397  if( bSetCursor )
1398  {
1399  SwCallLink aLk( *this ); // watch Cursor-Moves
1400  SwCursorSaveState aSaveState( *m_pCurrentCursor );
1401  m_pCurrentCursor->DeleteMark();
1402  *m_pCurrentCursor->GetPoint() = aPos;
1403  if( m_pCurrentCursor->IsSelOvr() )
1404  {
1405  // allow click fields in protected sections
1406  // only placeholder is not possible
1407  if( IsAttrAtPos::Field & rContentAtPos.eContentAtPos
1408  || SwFieldIds::JumpEdit == pField->Which() )
1409  pField = nullptr;
1410  }
1411  else
1412  UpdateCursor();
1413  }
1414  else if( SwFieldIds::Table == pField->Which() &&
1415  static_cast<const SwTableField*>(pField)->IsIntrnlName() )
1416  {
1417  // create from internal (for CORE) the external
1418  // (for UI) formula
1419  const SwTableNode* pTableNd = pTextNd->FindTableNode();
1420  if( pTableNd ) // is in a table
1421  const_cast<SwTableField*>(static_cast<const SwTableField*>(pField))->PtrToBoxNm( &pTableNd->GetTable() );
1422  }
1423  }
1424 
1425  if( pField )
1426  {
1427  rContentAtPos.aFnd.pField = pField;
1428  rContentAtPos.pFndTextAttr = pTextAttr;
1429  rContentAtPos.eContentAtPos = IsAttrAtPos::Field;
1430  bRet = true;
1431  }
1432  }
1433 
1434  if( !bRet && IsAttrAtPos::FormControl & rContentAtPos.eContentAtPos )
1435  {
1436  IDocumentMarkAccess* pMarksAccess = GetDoc()->getIDocumentMarkAccess( );
1437  sw::mark::IFieldmark* pFieldBookmark = pMarksAccess->getFieldmarkFor( aPos );
1438  if (bCursorFoundExact && pFieldBookmark)
1439  {
1440  rContentAtPos.eContentAtPos = IsAttrAtPos::FormControl;
1441  rContentAtPos.aFnd.pFieldmark = pFieldBookmark;
1442  bRet=true;
1443  }
1444  }
1445 
1446  if( !bRet && IsAttrAtPos::Ftn & rContentAtPos.eContentAtPos )
1447  {
1448  if( aTmpState.m_bFootnoteNoInfo )
1449  {
1450  // over the footnote's char
1451  bRet = true;
1452  if( bSetCursor )
1453  {
1454  *m_pCurrentCursor->GetPoint() = aPos;
1455  if( !GotoFootnoteAnchor() )
1456  bRet = false;
1457  }
1458  if( bRet )
1459  rContentAtPos.eContentAtPos = IsAttrAtPos::Ftn;
1460  }
1461  else if ( nullptr != ( pTextAttr = pTextNd->GetTextAttrForCharAt(
1462  aPos.nContent.GetIndex(), RES_TXTATR_FTN )) )
1463  {
1464  bRet = true;
1465  if( bSetCursor )
1466  {
1467  SwCallLink aLk( *this ); // watch Cursor-Moves
1468  SwCursorSaveState aSaveState( *m_pCurrentCursor );
1469  m_pCurrentCursor->GetPoint()->nNode = *static_cast<SwTextFootnote*>(pTextAttr)->GetStartNode();
1470  SwContentNode* pCNd = GetDoc()->GetNodes().GoNextSection(
1471  &m_pCurrentCursor->GetPoint()->nNode,
1472  true, !IsReadOnlyAvailable() );
1473 
1474  if( pCNd )
1475  {
1476  m_pCurrentCursor->GetPoint()->nContent.Assign( pCNd, 0 );
1477  if( m_pCurrentCursor->IsSelOvr( SwCursorSelOverFlags::CheckNodeSection |
1478  SwCursorSelOverFlags::Toggle ))
1479  bRet = false;
1480  else
1481  UpdateCursor();
1482  }
1483  else
1484  bRet = false;
1485  }
1486 
1487  if( bRet )
1488  {
1489  rContentAtPos.eContentAtPos = IsAttrAtPos::Ftn;
1490  rContentAtPos.pFndTextAttr = pTextAttr;
1491  rContentAtPos.aFnd.pAttr = &pTextAttr->GetAttr();
1492 
1493  if (pFieldRect)
1494  {
1495  std::pair<Point, bool> tmp(aPt, true);
1496  pFrame = pTextNd->getLayoutFrame(GetLayout(), nullptr, &tmp);
1497  if (pFrame)
1498  pFrame->GetCharRect( *pFieldRect, aPos, &aTmpState );
1499  }
1500  }
1501  }
1502  }
1503 
1504  if( !bRet
1505  && ( IsAttrAtPos::ToxMark | IsAttrAtPos::RefMark ) & rContentAtPos.eContentAtPos
1506  && !aTmpState.m_bFootnoteNoInfo )
1507  {
1508  pTextAttr = nullptr;
1509  if( IsAttrAtPos::ToxMark & rContentAtPos.eContentAtPos )
1510  {
1511  std::vector<SwTextAttr *> const marks(
1512  pTextNd->GetTextAttrsAt(
1513  aPos.nContent.GetIndex(), RES_TXTATR_TOXMARK));
1514  if (!marks.empty())
1515  { // hmm... can only return 1 here
1516  pTextAttr = *marks.begin();
1517  }
1518  }
1519 
1520  if( !pTextAttr &&
1521  IsAttrAtPos::RefMark & rContentAtPos.eContentAtPos )
1522  {
1523  std::vector<SwTextAttr *> const marks(
1524  pTextNd->GetTextAttrsAt(
1525  aPos.nContent.GetIndex(), RES_TXTATR_REFMARK));
1526  if (!marks.empty())
1527  { // hmm... can only return 1 here
1528  pTextAttr = *marks.begin();
1529  }
1530  }
1531 
1532  if( pTextAttr )
1533  {
1534  bRet = true;
1535  if( bSetCursor )
1536  {
1537  SwCallLink aLk( *this ); // watch Cursor-Moves
1538  SwCursorSaveState aSaveState( *m_pCurrentCursor );
1539  m_pCurrentCursor->DeleteMark();
1540  *m_pCurrentCursor->GetPoint() = aPos;
1541  if( m_pCurrentCursor->IsSelOvr( SwCursorSelOverFlags::CheckNodeSection | SwCursorSelOverFlags::Toggle ) )
1542  bRet = false;
1543  else
1544  UpdateCursor();
1545  }
1546 
1547  if( bRet )
1548  {
1549  const sal_Int32* pEnd = pTextAttr->GetEnd();
1550  if( pEnd )
1551  rContentAtPos.sStr =
1552  pTextNd->GetExpandText(GetLayout(), pTextAttr->GetStart(), *pEnd - pTextAttr->GetStart());
1553  else if( RES_TXTATR_TOXMARK == pTextAttr->Which())
1554  rContentAtPos.sStr =
1555  pTextAttr->GetTOXMark().GetAlternativeText();
1556 
1557  rContentAtPos.eContentAtPos =
1558  RES_TXTATR_TOXMARK == pTextAttr->Which()
1559  ? IsAttrAtPos::ToxMark
1560  : IsAttrAtPos::RefMark;
1561  rContentAtPos.pFndTextAttr = pTextAttr;
1562  rContentAtPos.aFnd.pAttr = &pTextAttr->GetAttr();
1563 
1564  std::pair<Point, bool> tmp(aPt, true);
1565  if (pFieldRect)
1566  {
1567  pFrame = pTextNd->getLayoutFrame(GetLayout(), nullptr, &tmp);
1568  if (pFrame)
1569  pFrame->GetCharRect( *pFieldRect, aPos, &aTmpState );
1570  }
1571  }
1572  }
1573  }
1574 
1575  if ( !bRet
1576  && IsAttrAtPos::InetAttr & rContentAtPos.eContentAtPos
1577  && !aTmpState.m_bFootnoteNoInfo )
1578  {
1579  sal_Int32 index = aPos.nContent.GetIndex();
1580  pTextAttr = pTextNd->GetTextAttrAt(index, RES_TXTATR_INETFMT);
1581 
1582  if(!pTextAttr && index > 0)
1583  pTextAttr = pTextNd->GetTextAttrAt(index - 1, RES_TXTATR_INETFMT);
1584  // "detect" only INetAttrs with URLs
1585  if( pTextAttr && !pTextAttr->GetINetFormat().GetValue().isEmpty() )
1586  {
1587  bRet = true;
1588  if( bSetCursor )
1589  {
1590  SwCursorSaveState aSaveState( *m_pCurrentCursor );
1591  SwCallLink aLk( *this ); // watch Cursor-Moves
1592  m_pCurrentCursor->DeleteMark();
1593  *m_pCurrentCursor->GetPoint() = aPos;
1594  if( m_pCurrentCursor->IsSelOvr( SwCursorSelOverFlags::CheckNodeSection |
1595  SwCursorSelOverFlags::Toggle) )
1596  bRet = false;
1597  else
1598  UpdateCursor();
1599  }
1600  if( bRet )
1601  {
1602  const sal_Int32 nSt = pTextAttr->GetStart();
1603  const sal_Int32 nEnd = *pTextAttr->End();
1604 
1605  rContentAtPos.sStr = pTextNd->GetExpandText(GetLayout(), nSt, nEnd-nSt);
1606 
1607  rContentAtPos.aFnd.pAttr = &pTextAttr->GetAttr();
1608  rContentAtPos.eContentAtPos = IsAttrAtPos::InetAttr;
1609  rContentAtPos.pFndTextAttr = pTextAttr;
1610 
1611  if (pFieldRect)
1612  {
1613  std::pair<Point, bool> tmp(aPt, true);
1614  pFrame = pTextNd->getLayoutFrame(GetLayout(), nullptr, &tmp);
1615  if (pFrame)
1616  {
1617  //get bounding box of range
1618  SwRect aStart;
1619  SwPosition aStartPos(*pTextNd, nSt);
1620  pFrame->GetCharRect(aStart, aStartPos, &aTmpState);
1621  SwRect aEnd;
1622  SwPosition aEndPos(*pTextNd, nEnd);
1623  pFrame->GetCharRect(aEnd, aEndPos, &aTmpState);
1624  if (aStart.Top() != aEnd.Top() || aStart.Bottom() != aEnd.Bottom())
1625  {
1626  aStart.Left(pFrame->getFrameArea().Left());
1627  aEnd.Right(pFrame->getFrameArea().Right());
1628  }
1629  *pFieldRect = aStart.Union(aEnd);
1630  }
1631  }
1632  }
1633  }
1634  }
1635 
1636  if( !bRet && IsAttrAtPos::Redline & rContentAtPos.eContentAtPos )
1637  {
1638  const SwRangeRedline* pRedl = GetDoc()->getIDocumentRedlineAccess().GetRedline(aPos, nullptr);
1639 
1640  if( pRedl )
1641  {
1642  rContentAtPos.aFnd.pRedl = pRedl;
1643  rContentAtPos.eContentAtPos = IsAttrAtPos::Redline;
1644  rContentAtPos.pFndTextAttr = nullptr;
1645  bRet = true;
1646 
1647  if (pFieldRect)
1648  {
1649  std::pair<Point, bool> tmp(aPt, true);
1650  pFrame = pTextNd->getLayoutFrame(GetLayout(), nullptr, &tmp);
1651  if( pFrame )
1652  {
1653  // not sure if this should be limited to one
1654  // paragraph, or mark the entire redline; let's
1655  // leave it limited to one for now...
1656  sal_Int32 nStart;
1657  sal_Int32 nEnd;
1658  pRedl->CalcStartEnd(pTextNd->GetIndex(), nStart, nEnd);
1659  if (nStart == COMPLETE_STRING)
1660  {
1661  // consistency: found pRedl, so there must be
1662  // something in pTextNd
1663  assert(nEnd != COMPLETE_STRING);
1664  nStart = 0;
1665  }
1666  if (nEnd == COMPLETE_STRING)
1667  {
1668  nEnd = pTextNd->Len();
1669  }
1670  //get bounding box of range
1671  SwRect aStart;
1672  pFrame->GetCharRect(aStart, SwPosition(*pTextNd, nStart), &aTmpState);
1673  SwRect aEnd;
1674  pFrame->GetCharRect(aEnd, SwPosition(*pTextNd, nEnd), &aTmpState);
1675  if (aStart.Top() != aEnd.Top() || aStart.Bottom() != aEnd.Bottom())
1676  {
1677  aStart.Left(pFrame->getFrameArea().Left());
1678  aEnd.Right(pFrame->getFrameArea().Right());
1679  }
1680  *pFieldRect = aStart.Union(aEnd);
1681  }
1682  }
1683  }
1684  }
1685  }
1686 
1687  if( !bRet
1688  && ( IsAttrAtPos::TableBoxFml & rContentAtPos.eContentAtPos
1689 #ifdef DBG_UTIL
1690  || IsAttrAtPos::TableBoxValue & rContentAtPos.eContentAtPos
1691 #endif
1692  ) )
1693  {
1694  const SwTableNode* pTableNd;
1695  const SwTableBox* pBox;
1696  const SwStartNode* pSttNd = pTextNd->FindTableBoxStartNode();
1697  const SfxPoolItem* pItem;
1698  if( pSttNd && nullptr != ( pTableNd = pTextNd->FindTableNode()) &&
1699  nullptr != ( pBox = pTableNd->GetTable().GetTableBox(
1700  pSttNd->GetIndex() )) &&
1701 #ifdef DBG_UTIL
1702  ( SfxItemState::SET == pBox->GetFrameFormat()->GetItemState(
1703  RES_BOXATR_FORMULA, false, &pItem ) ||
1704  SfxItemState::SET == pBox->GetFrameFormat()->GetItemState(
1705  RES_BOXATR_VALUE, false, &pItem ))
1706 #else
1707  SfxItemState::SET == pBox->GetFrameFormat()->GetItemState(
1708  RES_BOXATR_FORMULA, false, &pItem )
1709 #endif
1710  )
1711  {
1712  std::pair<Point, bool> tmp(aPt, true);
1713  SwFrame* pF = pTextNd->getLayoutFrame(GetLayout(), nullptr, &tmp);
1714  if( pF )
1715  {
1716  // then the CellFrame
1717  pFrame = static_cast<SwContentFrame*>(pF);
1718  while( pF && !pF->IsCellFrame() )
1719  pF = pF->GetUpper();
1720  }
1721 
1722  if( aTmpState.m_bPosCorr )
1723  {
1724  if( pF && !pF->getFrameArea().IsInside( aPt ))
1725  pF = nullptr;
1726  }
1727  else if( !pF )
1728  pF = pFrame;
1729 
1730  if( pF ) // only then it is valid
1731  {
1732  // create from internal (for CORE) the external
1733  // (for UI) formula
1734  rContentAtPos.eContentAtPos = IsAttrAtPos::TableBoxFml;
1735 #ifdef DBG_UTIL
1736  if( RES_BOXATR_VALUE == pItem->Which() )
1737  rContentAtPos.eContentAtPos = IsAttrAtPos::TableBoxValue;
1738  else
1739 #endif
1740  const_cast<SwTableBoxFormula&>(pItem->StaticWhichCast(RES_BOXATR_FORMULA)).PtrToBoxNm( &pTableNd->GetTable() );
1741 
1742  bRet = true;
1743  if( bSetCursor )
1744  {
1745  SwCallLink aLk( *this ); // watch Cursor-Moves
1746  SwCursorSaveState aSaveState( *m_pCurrentCursor );
1747  *m_pCurrentCursor->GetPoint() = aPos;
1748  if( m_pCurrentCursor->IsSelOvr( SwCursorSelOverFlags::CheckNodeSection |
1749  SwCursorSelOverFlags::Toggle) )
1750  bRet = false;
1751  else
1752  UpdateCursor();
1753  }
1754 
1755  if( bRet )
1756  {
1757  if( pFieldRect )
1758  {
1759  *pFieldRect = pF->getFramePrintArea();
1760  *pFieldRect += pF->getFrameArea().Pos();
1761  }
1762  rContentAtPos.pFndTextAttr = nullptr;
1763  rContentAtPos.aFnd.pAttr = pItem;
1764  }
1765  }
1766  }
1767  }
1768 
1769 #ifdef DBG_UTIL
1770  if( !bRet && IsAttrAtPos::CurrAttrs & rContentAtPos.eContentAtPos )
1771  {
1772  const sal_Int32 n = aPos.nContent.GetIndex();
1773  SfxItemSet aSet( GetDoc()->GetAttrPool(), svl::Items<POOLATTR_BEGIN,
1774  POOLATTR_END - 1> );
1775  if( pTextNd->GetpSwpHints() )
1776  {
1777  for( size_t i = 0; i < pTextNd->GetSwpHints().Count(); ++i )
1778  {
1779  const SwTextAttr* pHt = pTextNd->GetSwpHints().Get(i);
1780  const sal_Int32 nAttrStart = pHt->GetStart();
1781  if( nAttrStart > n ) // over the section
1782  break;
1783 
1784  if( nullptr != pHt->End() && (
1785  ( nAttrStart < n &&
1786  ( pHt->DontExpand() ? n < *pHt->End()
1787  : n <= *pHt->End() )) ||
1788  ( n == nAttrStart &&
1789  ( nAttrStart == *pHt->End() || !n ))) )
1790  {
1791  aSet.Put( pHt->GetAttr() );
1792  }
1793  }
1794  if( pTextNd->HasSwAttrSet() &&
1795  pTextNd->GetpSwAttrSet()->Count() )
1796  {
1797  SfxItemSet aFormatSet( pTextNd->GetSwAttrSet() );
1798  // remove all from format set that are also in TextSet
1799  aFormatSet.Differentiate( aSet );
1800  // now merge all together
1801  aSet.Put( aFormatSet );
1802  }
1803  }
1804  else
1805  pTextNd->SwContentNode::GetAttr( aSet );
1806 
1807  rContentAtPos.sStr = "Pos: (";
1808  rContentAtPos.sStr += OUString::number( aPos.nNode.GetIndex());
1809  rContentAtPos.sStr += ":";
1810  rContentAtPos.sStr += OUString::number( aPos.nContent.GetIndex());
1811  rContentAtPos.sStr += ")";
1812  rContentAtPos.sStr += "\nParagraph Style: ";
1813  rContentAtPos.sStr += pTextNd->GetFormatColl()->GetName();
1814  if( pTextNd->GetCondFormatColl() )
1815  {
1816  rContentAtPos.sStr += "\nConditional Style: " + pTextNd->GetCondFormatColl()->GetName();
1817  }
1818 
1819  if( aSet.Count() )
1820  {
1821  OUStringBuffer sAttrs;
1822  SfxItemIter aIter( aSet );
1823  const SfxPoolItem* pItem = aIter.GetCurItem();
1824  const IntlWrapper aInt(SvtSysLocale().GetUILanguageTag());
1825  do
1826  {
1827  if( !IsInvalidItem( pItem ))
1828  {
1829  OUString aStr;
1830  GetDoc()->GetAttrPool().GetPresentation(*pItem,
1831  MapUnit::MapCM, aStr, aInt);
1832  if (!sAttrs.isEmpty())
1833  sAttrs.append(", ");
1834  sAttrs.append(aStr);
1835  }
1836  pItem = aIter.NextItem();
1837  } while (pItem);
1838  if (!sAttrs.isEmpty())
1839  {
1840  if( !rContentAtPos.sStr.isEmpty() )
1841  rContentAtPos.sStr += "\n";
1842  rContentAtPos.sStr += "Attr: " + sAttrs.toString();
1843  }
1844  }
1845  bRet = true;
1846  rContentAtPos.eContentAtPos = IsAttrAtPos::CurrAttrs;
1847  }
1848 #endif
1849  }
1850  }
1851 
1852  if( !bRet )
1853  {
1854  rContentAtPos.eContentAtPos = IsAttrAtPos::NONE;
1855  rContentAtPos.aFnd.pField = nullptr;
1856  }
1857  return bRet;
1858 }
1859 
1860 // #i90516#
1861 const SwPostItField* SwCursorShell::GetPostItFieldAtCursor() const
1862 {
1863  const SwPostItField* pPostItField = nullptr;
1864 
1865  if ( !IsTableMode() )
1866  {
1867  const SwPosition* pCursorPos = GetCursor_()->GetPoint();
1868  const SwTextNode* pTextNd = pCursorPos->nNode.GetNode().GetTextNode();
1869  if ( pTextNd )
1870  {
1871  SwTextAttr* pTextAttr = pTextNd->GetFieldTextAttrAt( pCursorPos->nContent.GetIndex() );
1872  const SwField* pField = pTextAttr != nullptr ? pTextAttr->GetFormatField().GetField() : nullptr;
1873  if ( pField && pField->Which()== SwFieldIds::Postit )
1874  {
1875  pPostItField = static_cast<const SwPostItField*>(pField);
1876  }
1877  }
1878  }
1879 
1880  return pPostItField;
1881 }
1882 
1884 bool SwContentAtPos::IsInProtectSect() const
1885 {
1886  const SwTextNode* pNd = nullptr;
1887  if( pFndTextAttr )
1888  {
1889  switch( eContentAtPos )
1890  {
1891  case IsAttrAtPos::Field:
1892  case IsAttrAtPos::ClickField:
1893  pNd = static_txtattr_cast<SwTextField const*>(pFndTextAttr)->GetpTextNode();
1894  break;
1895 
1896  case IsAttrAtPos::Ftn:
1897  pNd = &static_cast<const SwTextFootnote*>(pFndTextAttr)->GetTextNode();
1898  break;
1899 
1900  case IsAttrAtPos::InetAttr:
1901  pNd = static_txtattr_cast<SwTextINetFormat const*>(pFndTextAttr)->GetpTextNode();
1902  break;
1903 
1904  default:
1905  break;
1906  }
1907  }
1908 
1909  if( !pNd )
1910  return false;
1911  if( pNd->IsInProtectSect() )
1912  return true;
1913 
1914  const SwContentFrame* pFrame = pNd->getLayoutFrame(pNd->GetDoc().getIDocumentLayoutAccess().GetCurrentLayout(), nullptr, nullptr);
1915  return pFrame && pFrame->IsProtected() ;
1916 }
1917 
1918 bool SwContentAtPos::IsInRTLText()const
1919 {
1920  bool bRet = false;
1921  const SwTextNode* pNd = nullptr;
1922  if (pFndTextAttr && (eContentAtPos == IsAttrAtPos::Ftn))
1923  {
1924  const SwTextFootnote* pTextFootnote = static_cast<const SwTextFootnote*>(pFndTextAttr);
1925  if(pTextFootnote->GetStartNode())
1926  {
1927  SwStartNode* pSttNd = pTextFootnote->GetStartNode()->GetNode().GetStartNode();
1928  SwPaM aTemp( *pSttNd );
1929  aTemp.Move(fnMoveForward, GoInNode);
1930  SwContentNode* pContentNode = aTemp.GetContentNode();
1931  if(pContentNode && pContentNode->IsTextNode())
1932  pNd = pContentNode->GetTextNode();
1933  }
1934  }
1935  if(pNd)
1936  {
1937  SwIterator<SwTextFrame, SwTextNode, sw::IteratorMode::UnwrapMulti> aIter(*pNd);
1938  SwTextFrame* pTmpFrame = aIter.First();
1939  while( pTmpFrame )
1940  {
1941  if ( !pTmpFrame->IsFollow())
1942  {
1943  bRet = pTmpFrame->IsRightToLeft();
1944  break;
1945  }
1946  pTmpFrame = aIter.Next();
1947  }
1948  }
1949  return bRet;
1950 }
1951 
1952 bool SwCursorShell::SelectText( const sal_Int32 nStart,
1953  const sal_Int32 nEnd )
1954 {
1955  CurrShell aCurr( this );
1956  bool bRet = false;
1957 
1958  SwCallLink aLk( *this );
1959  SwCursorSaveState aSaveState( *m_pCurrentCursor );
1960 
1961  SwPosition& rPos = *m_pCurrentCursor->GetPoint();
1962  m_pCurrentCursor->DeleteMark();
1963  rPos.nContent = nStart;
1964  m_pCurrentCursor->SetMark();
1965  rPos.nContent = nEnd;
1966 
1967  if( !m_pCurrentCursor->IsSelOvr() )
1968  {
1969  UpdateCursor();
1970  bRet = true;
1971  }
1972 
1973  return bRet;
1974 }
1975 
1976 bool SwCursorShell::SelectTextAttr( sal_uInt16 nWhich,
1977  bool bExpand,
1978  const SwTextAttr* pTextAttr )
1979 {
1980  CurrShell aCurr( this );
1981  bool bRet = false;
1982 
1983  if( !IsTableMode() )
1984  {
1985  if( !pTextAttr )
1986  {
1987  SwPosition& rPos = *m_pCurrentCursor->GetPoint();
1988  SwTextNode* pTextNd = rPos.nNode.GetNode().GetTextNode();
1989  pTextAttr = pTextNd
1990  ? pTextNd->GetTextAttrAt(rPos.nContent.GetIndex(),
1991  nWhich,
1992  bExpand ? SwTextNode::EXPAND : SwTextNode::DEFAULT)
1993  : nullptr;
1994  }
1995 
1996  if( pTextAttr )
1997  {
1998  const sal_Int32* pEnd = pTextAttr->End();
1999  bRet = SelectText( pTextAttr->GetStart(), ( pEnd ? *pEnd : pTextAttr->GetStart() + 1 ) );
2000  }
2001  }
2002  return bRet;
2003 }
2004 
2005 bool SwCursorShell::GotoINetAttr( const SwTextINetFormat& rAttr )
2006 {
2007  bool bRet = false;
2008  if( rAttr.GetpTextNode() )
2009  {
2010  SwCursor* pCursor = getShellCursor( true );
2011 
2012  CurrShell aCurr( this );
2013  SwCallLink aLk( *this ); // watch Cursor-Moves
2014  SwCursorSaveState aSaveState( *pCursor );
2015 
2016  pCursor->GetPoint()->nNode = *rAttr.GetpTextNode();
2017  pCursor->GetPoint()->nContent.Assign( const_cast<SwTextNode*>(rAttr.GetpTextNode()),
2018  rAttr.GetStart() );
2019  bRet = !pCursor->IsSelOvr();
2020  if( bRet )
2021  UpdateCursor(SwCursorShell::SCROLLWIN|SwCursorShell::CHKRANGE|SwCursorShell::READONLY);
2022  }
2023  return bRet;
2024 }
2025 
2026 const SwFormatINetFormat* SwCursorShell::FindINetAttr( std::u16string_view rName ) const
2027 {
2028  return mxDoc->FindINetAttr( rName );
2029 }
2030 
2031 bool SwCursorShell::GetShadowCursorPos( const Point& rPt, SwFillMode eFillMode,
2032  SwRect& rRect, sal_Int16& rOrient )
2033 {
2034 
2035  CurrShell aCurr( this );
2036  bool bRet = false;
2037 
2038  if (!IsTableMode() && !HasSelection()
2039  && GetDoc()->GetIDocumentUndoRedo().DoesUndo())
2040  {
2041  Point aPt( rPt );
2042  SwPosition aPos( *m_pCurrentCursor->GetPoint() );
2043 
2044  SwFillCursorPos aFPos( eFillMode );
2045  SwCursorMoveState aTmpState( &aFPos );
2046 
2047  if( GetLayout()->GetModelPositionForViewPoint( &aPos, aPt, &aTmpState ) &&
2048  !aPos.nNode.GetNode().IsProtect())
2049  {
2050  // start position in protected section?
2051  rRect = aFPos.aCursor;
2052  rOrient = aFPos.eOrient;
2053  bRet = true;
2054  }
2055  }
2056  return bRet;
2057 }
2058 
2059 bool SwCursorShell::SetShadowCursorPos( const Point& rPt, SwFillMode eFillMode )
2060 {
2061  CurrShell aCurr( this );
2062  bool bRet = false;
2063 
2064  if (!IsTableMode() && !HasSelection()
2065  && GetDoc()->GetIDocumentUndoRedo().DoesUndo())
2066  {
2067  Point aPt( rPt );
2068  SwPosition aPos( *m_pCurrentCursor->GetPoint() );
2069 
2070  SwFillCursorPos aFPos( eFillMode );
2071  SwCursorMoveState aTmpState( &aFPos );
2072 
2073  if( GetLayout()->GetModelPositionForViewPoint( &aPos, aPt, &aTmpState ) )
2074  {
2075  SwCallLink aLk( *this ); // watch Cursor-Moves
2076  StartAction();
2077 
2078  SwContentNode* pCNd = aPos.nNode.GetNode().GetContentNode();
2079  SwUndoId nUndoId = SwUndoId::INS_FROM_SHADOWCRSR;
2080  // If only the paragraph attributes "Adjust" or "LRSpace" are set,
2081  // then the following should not delete those again.
2082  if( 0 == aFPos.nParaCnt + aFPos.nColumnCnt &&
2083  ( SwFillMode::Indent == aFPos.eMode ||
2084  ( text::HoriOrientation::NONE != aFPos.eOrient &&
2085  0 == aFPos.nTabCnt + aFPos.nSpaceCnt )) &&
2086  pCNd && pCNd->Len() )
2087  nUndoId = SwUndoId::EMPTY;
2088 
2089  GetDoc()->GetIDocumentUndoRedo().StartUndo( nUndoId, nullptr );
2090 
2091  SwTextFormatColl* pNextFormat = nullptr;
2092  SwTextNode* pTNd = pCNd ? pCNd->GetTextNode() : nullptr;
2093  if( pTNd )
2094  pNextFormat = &pTNd->GetTextColl()->GetNextTextFormatColl();
2095 
2096  const SwSectionNode* pSectNd = pCNd ? pCNd->FindSectionNode() : nullptr;
2097  if( pSectNd && aFPos.nParaCnt )
2098  {
2099  SwNodeIndex aEnd( aPos.nNode, 1 );
2100  while( aEnd.GetNode().IsEndNode() &&
2101  &aEnd.GetNode() !=
2102  pSectNd->EndOfSectionNode() )
2103  ++aEnd;
2104 
2105  if( aEnd.GetNode().IsEndNode() &&
2106  pCNd->Len() == aPos.nContent.GetIndex() )
2107  aPos.nNode = *pSectNd->EndOfSectionNode();
2108  }
2109 
2110  for( sal_uInt16 n = 0; n < aFPos.nParaCnt + aFPos.nColumnCnt; ++n )
2111  {
2112  GetDoc()->getIDocumentContentOperations().AppendTextNode( aPos );
2113  if( !n && pNextFormat )
2114  {
2115  *m_pCurrentCursor->GetPoint() = aPos;
2116  GetDoc()->SetTextFormatColl( *m_pCurrentCursor, pNextFormat, false );
2117  }
2118  if( n < aFPos.nColumnCnt )
2119  {
2120  *m_pCurrentCursor->GetPoint() = aPos;
2121  GetDoc()->getIDocumentContentOperations().InsertPoolItem( *m_pCurrentCursor,
2122  SvxFormatBreakItem( SvxBreak::ColumnBefore, RES_BREAK ) );
2123  }
2124  }
2125 
2126  *m_pCurrentCursor->GetPoint() = aPos;
2127  switch( aFPos.eMode )
2128  {
2129  case SwFillMode::Indent:
2130  if( nullptr != (pCNd = aPos.nNode.GetNode().GetContentNode() ))
2131  {
2132  SfxItemSet aSet(
2133  GetDoc()->GetAttrPool(),
2134  svl::Items<
2135  RES_PARATR_ADJUST, RES_PARATR_ADJUST,
2136  RES_LR_SPACE, RES_LR_SPACE>);
2137  SvxLRSpaceItem aLR(pCNd->GetAttr(RES_LR_SPACE).StaticWhichCast(RES_LR_SPACE));
2138  aLR.SetTextLeft( aFPos.nTabCnt );
2139  aLR.SetTextFirstLineOffset( 0 );
2140  aSet.Put( aLR );
2141 
2142  const SvxAdjustItem& rAdj = pCNd->GetAttr(RES_PARATR_ADJUST).StaticWhichCast(RES_PARATR_ADJUST);
2143  if( SvxAdjust::Left != rAdj.GetAdjust() )
2144  aSet.Put( SvxAdjustItem( SvxAdjust::Left, RES_PARATR_ADJUST ) );
2145 
2146  GetDoc()->getIDocumentContentOperations().InsertItemSet( *m_pCurrentCursor, aSet );
2147  }
2148  else {
2149  OSL_ENSURE( false, "No ContentNode" );
2150  }
2151  break;
2152 
2153  case SwFillMode::Tab:
2154  case SwFillMode::TabSpace:
2155  case SwFillMode::Space:
2156  {
2157  OUStringBuffer sInsert;
2158  if (aFPos.eMode == SwFillMode::Space)
2159  {
2160  comphelper::string::padToLength(sInsert, sInsert.getLength() + aFPos.nSpaceOnlyCnt, ' ');
2161  }
2162  else
2163  {
2164  if (aFPos.nTabCnt)
2165  comphelper::string::padToLength(sInsert, aFPos.nTabCnt, '\t');
2166  if (aFPos.nSpaceCnt)
2167  comphelper::string::padToLength(sInsert, sInsert.getLength() + aFPos.nSpaceCnt, ' ');
2168  }
2169  if (!sInsert.isEmpty())
2170  GetDoc()->getIDocumentContentOperations().InsertString( *m_pCurrentCursor, sInsert.makeStringAndClear());
2171  }
2172  [[fallthrough]]; // still need to set orientation
2173  case SwFillMode::Margin:
2174  if( text::HoriOrientation::NONE != aFPos.eOrient )
2175  {
2176  SvxAdjustItem aAdj( SvxAdjust::Left, RES_PARATR_ADJUST );
2177  switch( aFPos.eOrient )
2178  {
2179  case text::HoriOrientation::CENTER:
2180  aAdj.SetAdjust( SvxAdjust::Center );
2181  break;
2182  case text::HoriOrientation::RIGHT:
2183  aAdj.SetAdjust( SvxAdjust::Right );
2184  break;
2185  default:
2186  break;
2187  }
2188  GetDoc()->getIDocumentContentOperations().InsertPoolItem( *m_pCurrentCursor, aAdj );
2189  }
2190  break;
2191  }
2192 
2193  GetDoc()->GetIDocumentUndoRedo().EndUndo( nUndoId, nullptr );
2194  EndAction();
2195 
2196  bRet = true;
2197  }
2198  }
2199  return bRet;
2200 }
2201 
2202 const SwRangeRedline* SwCursorShell::SelNextRedline()
2203 {
2204  const SwRangeRedline* pFnd = nullptr;
2205  if( !IsTableMode() )
2206  {
2207  CurrShell aCurr( this );
2208  SwCallLink aLk( *this ); // watch Cursor-Moves
2209  SwCursorSaveState aSaveState( *m_pCurrentCursor );
2210 
2211  // ensure point is at the end so alternating SelNext/SelPrev works
2212  NormalizePam(false);
2213  pFnd = GetDoc()->getIDocumentRedlineAccess().SelNextRedline( *m_pCurrentCursor );
2214 
2215  // at the end of the document, go to the start of the document, and try again
2216  if ( !pFnd )
2217  {
2218  GetDoc()->GetDocShell()->GetWrtShell()->StartOfSection();
2219  pFnd = GetDoc()->getIDocumentRedlineAccess().SelNextRedline( *m_pCurrentCursor );
2220  }
2221 
2222  if( pFnd && !m_pCurrentCursor->IsInProtectTable() && !m_pCurrentCursor->IsSelOvr() )
2223  UpdateCursor( SwCursorShell::SCROLLWIN|SwCursorShell::CHKRANGE|SwCursorShell::READONLY);
2224  else
2225  pFnd = nullptr;
2226  }
2227  return pFnd;
2228 }
2229 
2230 const SwRangeRedline* SwCursorShell::SelPrevRedline()
2231 {
2232  const SwRangeRedline* pFnd = nullptr;
2233  if( !IsTableMode() )
2234  {
2235  CurrShell aCurr( this );
2236  SwCallLink aLk( *this ); // watch Cursor-Moves
2237  SwCursorSaveState aSaveState( *m_pCurrentCursor );
2238 
2239  // ensure point is at the start so alternating SelNext/SelPrev works
2240  NormalizePam(true);
2241  pFnd = GetDoc()->getIDocumentRedlineAccess().SelPrevRedline( *m_pCurrentCursor );
2242 
2243  // at the start of the document, go to the end of the document, and try again
2244  if ( !pFnd )
2245  {
2246  GetDoc()->GetDocShell()->GetWrtShell()->EndOfSection();
2247  pFnd = GetDoc()->getIDocumentRedlineAccess().SelPrevRedline( *m_pCurrentCursor );
2248  }
2249 
2250  if( pFnd && !m_pCurrentCursor->IsInProtectTable() && !m_pCurrentCursor->IsSelOvr() )
2251  UpdateCursor( SwCursorShell::SCROLLWIN|SwCursorShell::CHKRANGE|SwCursorShell::READONLY);
2252  else
2253  pFnd = nullptr;
2254  }
2255  return pFnd;
2256 }
2257 
2258 const SwRangeRedline* SwCursorShell::GotoRedline_( SwRedlineTable::size_type nArrPos, bool bSelect )
2259 {
2260  const SwRangeRedline* pFnd = nullptr;
2261  SwCallLink aLk( *this ); // watch Cursor-Moves
2262  SwCursorSaveState aSaveState( *m_pCurrentCursor );
2263 
2264  pFnd = GetDoc()->getIDocumentRedlineAccess().GetRedlineTable()[ nArrPos ];
2265  if( pFnd )
2266  {
2267  *m_pCurrentCursor->GetPoint() = *pFnd->Start();
2268 
2269  SwNodeIndex* pIdx = &m_pCurrentCursor->GetPoint()->nNode;
2270  if( !pIdx->GetNode().IsContentNode() )
2271  {
2272  SwContentNode* pCNd = GetDoc()->GetNodes().GoNextSection( pIdx,
2273  true, IsReadOnlyAvailable() );
2274  if( pCNd )
2275  {
2276  if( *pIdx <= pFnd->End()->nNode )
2277  m_pCurrentCursor->GetPoint()->nContent.Assign( pCNd, 0 );
2278  else
2279  pFnd = nullptr;
2280  }
2281  }
2282 
2283  if( pFnd && bSelect )
2284  {
2285  m_pCurrentCursor->SetMark();
2286  if( RedlineType::FmtColl == pFnd->GetType() )
2287  {
2288  SwContentNode* pCNd = pIdx->GetNode().GetContentNode();
2289  m_pCurrentCursor->GetPoint()->nContent.Assign( pCNd, pCNd->Len() );
2290  m_pCurrentCursor->GetMark()->nContent.Assign( pCNd, 0 );
2291  }
2292  else
2293  *m_pCurrentCursor->GetPoint() = *pFnd->End();
2294 
2295  pIdx = &m_pCurrentCursor->GetPoint()->nNode;
2296  if( !pIdx->GetNode().IsContentNode() )
2297  {
2298  SwContentNode* pCNd = SwNodes::GoPrevSection( pIdx,
2299  true, IsReadOnlyAvailable() );
2300  if( pCNd )
2301  {
2302  if( *pIdx >= m_pCurrentCursor->GetMark()->nNode )
2303  m_pCurrentCursor->GetPoint()->nContent.Assign( pCNd, pCNd->Len() );
2304  else
2305  pFnd = nullptr;
2306  }
2307  }
2308  }
2309 
2310  if( !pFnd )
2311  {
2312  m_pCurrentCursor->DeleteMark();
2313  m_pCurrentCursor->RestoreSavePos();
2314  }
2315  else if( bSelect && *m_pCurrentCursor->GetMark() == *m_pCurrentCursor->GetPoint() )
2316  m_pCurrentCursor->DeleteMark();
2317 
2318  if( pFnd && !m_pCurrentCursor->IsInProtectTable() && !m_pCurrentCursor->IsSelOvr() )
2319  UpdateCursor( SwCursorShell::SCROLLWIN | SwCursorShell::CHKRANGE
2320  | SwCursorShell::READONLY );
2321  else
2322  {
2323  pFnd = nullptr;
2324  if( bSelect )
2325  m_pCurrentCursor->DeleteMark();
2326  }
2327  }
2328  return pFnd;
2329 }
2330 
2331 const SwRangeRedline* SwCursorShell::GotoRedline( SwRedlineTable::size_type nArrPos, bool bSelect )
2332 {
2333  const SwRangeRedline* pFnd = nullptr;
2334  if( !IsTableMode() )
2335  {
2336  CurrShell aCurr( this );
2337 
2338  const SwRedlineTable& rTable = GetDoc()->getIDocumentRedlineAccess().GetRedlineTable();
2339  const SwRangeRedline* pTmp = rTable[ nArrPos ];
2340  sal_uInt16 nSeqNo = pTmp->GetSeqNo();
2341  if( nSeqNo && bSelect )
2342  {
2343  bool bCheck = false;
2344  int nLoopCnt = 2;
2345  SwRedlineTable::size_type nArrSavPos = nArrPos;
2346 
2347  do {
2348  pTmp = GotoRedline_( nArrPos, true );
2349 
2350  if( !pFnd )
2351  pFnd = pTmp;
2352 
2353  if( pTmp && bCheck )
2354  {
2355  // Check for overlaps. These can happen when FormatColl-
2356  // Redlines were stretched over a whole paragraph
2357  SwPaM* pCur = m_pCurrentCursor;
2358  SwPaM* pNextPam = pCur->GetNext();
2359  SwPosition* pCStt = pCur->Start(), *pCEnd = pCur->End();
2360  while( pCur != pNextPam )
2361  {
2362  const SwPosition *pNStt = pNextPam->Start(),
2363  *pNEnd = pNextPam->End();
2364 
2365  bool bDel = true;
2366  switch( ::ComparePosition( *pCStt, *pCEnd,
2367  *pNStt, *pNEnd ))
2368  {
2369  case SwComparePosition::Inside: // Pos1 is completely in Pos2
2370  if( !pCur->HasMark() )
2371  {
2372  pCur->SetMark();
2373  *pCur->GetMark() = *pNStt;
2374  }
2375  else
2376  *pCStt = *pNStt;
2377  *pCEnd = *pNEnd;
2378  break;
2379 
2380  case SwComparePosition::Outside: // Pos2 is completely in Pos1
2381  case SwComparePosition::Equal: // Pos1 has same size as Pos2
2382  break;
2383 
2384  case SwComparePosition::OverlapBefore: // Pos1 overlaps Pos2 at beginning
2385  if( !pCur->HasMark() )
2386  pCur->SetMark();
2387  *pCEnd = *pNEnd;
2388  break;
2389  case SwComparePosition::OverlapBehind: // Pos1 overlaps Pos2 at end
2390  if( !pCur->HasMark() )
2391  {
2392  pCur->SetMark();
2393  *pCur->GetMark() = *pNStt;
2394  }
2395  else
2396  *pCStt = *pNStt;
2397  break;
2398 
2399  default:
2400  bDel = false;
2401  }
2402 
2403  if( bDel )
2404  {
2405  // not needed anymore
2406  SwPaM* pPrevPam = pNextPam->GetPrev();
2407  delete pNextPam;
2408  pNextPam = pPrevPam;
2409  }
2410  pNextPam = pNextPam->GetNext();
2411  }
2412  }
2413 
2414  SwRedlineTable::size_type nFndPos = 2 == nLoopCnt
2415  ? rTable.FindNextOfSeqNo( nArrPos )
2416  : rTable.FindPrevOfSeqNo( nArrPos );
2417  if( SwRedlineTable::npos != nFndPos ||
2418  ( 0 != ( --nLoopCnt ) && SwRedlineTable::npos != (
2419  nFndPos = rTable.FindPrevOfSeqNo( nArrSavPos ))) )
2420  {
2421  if( pTmp )
2422  {
2423  // create new cursor
2424  CreateCursor();
2425  bCheck = true;
2426  }
2427  nArrPos = nFndPos;
2428  }
2429  else
2430  nLoopCnt = 0;
2431 
2432  } while( nLoopCnt );
2433  }
2434  else
2435  pFnd = GotoRedline_( nArrPos, bSelect );
2436  }
2437  return pFnd;
2438 }
2439 
2440 bool SwCursorShell::SelectNxtPrvHyperlink( bool bNext )
2441 {
2442  SwNodes& rNds = GetDoc()->GetNodes();
2443  const SwNode* pBodyEndNd = &rNds.GetEndOfContent();
2444  const SwNode* pBodySttNd = pBodyEndNd->StartOfSectionNode();
2445  sal_uLong nBodySttNdIdx = pBodySttNd->GetIndex();
2446  Point aPt;
2447 
2448  SetGetExpField aCmpPos( SwPosition( bNext ? *pBodyEndNd : *pBodySttNd ) );
2449  SetGetExpField aCurPos( bNext ? *m_pCurrentCursor->End() : *m_pCurrentCursor->Start() );
2450  if( aCurPos.GetNode() < nBodySttNdIdx )
2451  {
2452  const SwContentNode* pCNd = aCurPos.GetNodeFromContent()->GetContentNode();
2453  std::pair<Point, bool> tmp(aPt, true);
2454  if (pCNd)
2455  {
2456  SwContentFrame* pFrame = pCNd->getLayoutFrame(GetLayout(), nullptr, &tmp);
2457  if( pFrame )
2458  aCurPos.SetBodyPos( *pFrame );
2459  }
2460  }
2461 
2462  // check first all the hyperlink fields
2463  {
2464  const SwTextNode* pTextNd;
2465  const SwCharFormats* pFormats = GetDoc()->GetCharFormats();
2466  for( SwCharFormats::size_type n = pFormats->size(); 1 < n; )
2467  {
2468  SwIterator<SwTextINetFormat,SwCharFormat> aIter(*(*pFormats)[--n]);
2469 
2470  for( SwTextINetFormat* pFnd = aIter.First(); pFnd; pFnd = aIter.Next() )
2471  {
2472  pTextNd = pFnd->GetpTextNode();
2473  if( pTextNd && pTextNd->GetNodes().IsDocNodes() )
2474  {
2475  SwTextINetFormat& rAttr = *pFnd;
2476  SwPosition aTmpPos( *pTextNd );
2477  SetGetExpField aPos( aTmpPos.nNode, rAttr );
2478  if (pTextNd->GetIndex() < nBodySttNdIdx)
2479  {
2480  std::pair<Point, bool> tmp(aPt, true);
2481  SwContentFrame* pFrame = pTextNd->getLayoutFrame(GetLayout(), nullptr, &tmp);
2482  if (pFrame)
2483  {
2484  aPos.SetBodyPos( *pFrame );
2485  }
2486  }
2487 
2488  if( bNext
2489  ? ( aPos < aCmpPos && aCurPos < aPos )
2490  : ( aCmpPos < aPos && aPos < aCurPos ))
2491  {
2492  OUString sText(pTextNd->GetExpandText(GetLayout(),
2493  rAttr.GetStart(),
2494  *rAttr.GetEnd() - rAttr.GetStart() ) );
2495 
2496  sText = sText.replaceAll("\x0a", "");
2497  sText = comphelper::string::strip(sText, ' ');
2498 
2499  if( !sText.isEmpty() )
2500  aCmpPos = aPos;
2501  }
2502  }
2503  }
2504  }
2505  }
2506 
2507  // then check all the Flys with a URL or image map
2508  {
2509  const SwFrameFormats* pFormats = GetDoc()->GetSpzFrameFormats();
2510  for( SwFrameFormats::size_type n = 0, nEnd = pFormats->size(); n < nEnd; ++n )
2511  {
2512  SwFlyFrameFormat* pFormat = static_cast<SwFlyFrameFormat*>((*pFormats)[ n ]);
2513  const SwFormatURL& rURLItem = pFormat->GetURL();
2514  if( rURLItem.GetMap() || !rURLItem.GetURL().isEmpty() )
2515  {
2516  SwFlyFrame* pFly = pFormat->GetFrame( &aPt );
2517  SwPosition aTmpPos( *pBodySttNd );
2518  if( pFly &&
2519  GetBodyTextNode( *GetDoc(), aTmpPos, *pFly->GetLower() ) )
2520  {
2521  SetGetExpField aPos( *pFormat, &aTmpPos );
2522 
2523  if( bNext
2524  ? ( aPos < aCmpPos && aCurPos < aPos )
2525  : ( aCmpPos < aPos && aPos < aCurPos ))
2526  aCmpPos = aPos;
2527  }
2528  }
2529  }
2530  }
2531 
2532  // found any URL ?
2533  bool bRet = false;
2534  const SwTextINetFormat* pFndAttr = aCmpPos.GetINetFormat();
2535  const SwFlyFrameFormat* pFndFormat = aCmpPos.GetFlyFormat();
2536  if( pFndAttr || pFndFormat )
2537  {
2538  CurrShell aCurr( this );
2539  SwCallLink aLk( *this );
2540 
2541  // found a text attribute ?
2542  if( pFndAttr )
2543  {
2544  SwCursorSaveState aSaveState( *m_pCurrentCursor );
2545 
2546  aCmpPos.GetPosOfContent( *m_pCurrentCursor->GetPoint() );
2547  m_pCurrentCursor->DeleteMark();
2548  m_pCurrentCursor->SetMark();
2549  m_pCurrentCursor->GetPoint()->nContent = *pFndAttr->End();
2550 
2551  if( !m_pCurrentCursor->IsInProtectTable() && !m_pCurrentCursor->IsSelOvr() )
2552  {
2553  UpdateCursor( SwCursorShell::SCROLLWIN|SwCursorShell::CHKRANGE|
2554  SwCursorShell::READONLY );
2555  bRet = true;
2556  }
2557  }
2558  // found a draw object ?
2559  else if( RES_DRAWFRMFMT == pFndFormat->Which() )
2560  {
2561  const SdrObject* pSObj = pFndFormat->FindSdrObject();
2562  if (pSObj)
2563  {
2564  static_cast<SwFEShell*>(this)->SelectObj( pSObj->GetCurrentBoundRect().Center() );
2565  MakeSelVisible();
2566  bRet = true;
2567  }
2568  }
2569  else // then is it a fly
2570  {
2571  SwFlyFrame* pFly = pFndFormat->GetFrame(&aPt);
2572  if( pFly )
2573  {
2574  static_cast<SwFEShell*>(this)->SelectFlyFrame( *pFly );
2575  MakeSelVisible();
2576  bRet = true;
2577  }
2578  }
2579  }
2580  return bRet;
2581 }
2582 
2583 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
SwViewShell::GetOut
vcl::RenderContext * GetOut() const
Definition: viewsh.hxx:338
SwNode::FindSectionNode
SwSectionNode * FindSectionNode()
Search section node, in which it is.
Definition: ndsect.cxx:983
SwFieldType
Instances of SwFields and those derived from it occur 0 to n times.
Definition: fldbas.hxx:240
SwNode::EndOfSectionNode
const SwEndNode * EndOfSectionNode() const
Definition: node.hxx:683
SwStartNode
Starts a section of nodes in the document model.
Definition: node.hxx:312
SwContentAtPos::IsInRTLText
bool IsInRTLText() const
Definition: crstrvl.cxx:1918
SwFrame
Base class of the Writer layout elements.
Definition: frame.hxx:313
SwTextFrame
Represents the visualization of a paragraph.
Definition: txtfrm.hxx:158
SwContentNode::Len
virtual sal_Int32 Len() const
Definition: node.cxx:1246
SwPaM::DeleteMark
void DeleteMark()
Definition: pam.hxx:177
SwDoc::ContainsPageDesc
bool ContainsPageDesc(const SwPageDesc *pDesc, size_t *pPos) const
Definition: docdesc.cxx:946
SwCursorShell::KillPams
void KillPams()
Definition: crsrsh.cxx:1022
o3tl::sorted_vector::lower_bound
const_iterator lower_bound(const Value &x) const
SwNode::GetIndex
sal_uLong GetIndex() const
Definition: node.hxx:291
IDocumentRedlineAccess::SelPrevRedline
virtual const SwRangeRedline * SelPrevRedline(SwPaM &rPam) const =0
SwCursorMoveState::m_bFieldInfo
bool m_bFieldInfo
should be fields recognized?
Definition: crstate.hxx:142
SwCursorShell::UpdateCursor
SAL_DLLPRIVATE void UpdateCursor(sal_uInt16 eFlags=SwCursorShell::SCROLLWIN|SwCursorShell::CHKRANGE, bool bIdleEnd=false)
Definition: crsrsh.cxx:1571
SwPaM::GetNode
SwNode & GetNode(bool bPoint=true) const
Definition: pam.hxx:223
SwRect::Right
void Right(const tools::Long nRight)
Definition: swrect.hxx:200
SwCursorShell::GetFieldAtCursor
static SwField * GetFieldAtCursor(const SwPaM *pCursor, const bool bIncludeInputFieldAtStart)
Definition: crstrvl.cxx:898
SwCursorShell::m_pCurrentCursor
SwShellCursor * m_pCurrentCursor
current cursor
Definition: crsrsh.hxx:175
nIndex
sal_Int32 nIndex
SwFlowFrame::IsFollow
bool IsFollow() const
Definition: flowfrm.hxx:166
SwRangeRedline::GetSeqNo
sal_uInt16 GetSeqNo() const
Definition: redline.hxx:221
SwTextFormatColl
Represents the style of a paragraph.
Definition: fmtcol.hxx:56
SfxItemPool::GetPresentation
virtual bool GetPresentation(const SfxPoolItem &rItem, MapUnit ePresentationMetric, OUString &rText, const IntlWrapper &rIntlWrapper) const
SwPosition
Marks a position in the document model.
Definition: pam.hxx:35
SdrObject::GetCurrentBoundRect
virtual const tools::Rectangle & GetCurrentBoundRect() const
SwSpecialPos::nCharOfst
sal_Int32 nCharOfst
Definition: crstate.hxx:110
SwViewShell::GetNodes
const SwNodes & GetNodes() const
Definition: viewsh.cxx:2085
SwCursor::IsInProtectTable
bool IsInProtectTable(bool bMove=false, bool bChgCursor=true)
Definition: swcrsr.cxx:568
SwFormatField::GetField
const SwField * GetField() const
Definition: fmtfld.hxx:110
SwPaM::IsMultiSelection
bool IsMultiSelection() const
Definition: pam.hxx:272
SwRootFrame::GetPageAtPos
const SwPageFrame * GetPageAtPos(const Point &rPt, const Size *pSize=nullptr, bool bExtend=false) const
Point rPt: The point that should be used to find the page Size pSize: If given, we return the (first)...
Definition: findfrm.cxx:573
SwRect::Union
SwRect & Union(const SwRect &rRect)
Definition: swrect.cxx:41
SwCursorShell::GetCursor
SwPaM * GetCursor(bool bMakeTableCursor=true) const
Return pointer to the current shell cursor.
Definition: crsrsh.cxx:195
SwTable::GetTableBox
const SwTableBox * GetTableBox(const OUString &rName, const bool bPerformValidCheck=false) const
Definition: swtable.cxx:1328
SvxAdjustItem::GetAdjust
SvxAdjust GetAdjust() const
ComparePosition
SwComparePosition ComparePosition(const T &rStt1, const T &rEnd1, const T &rStt2, const T &rEnd2)
Definition: pam.hxx:77
IDocumentLayoutAccess::GetCurrentLayout
virtual const SwRootFrame * GetCurrentLayout() const =0
svl::Items
static constexpr auto Items
SwFormat::GetHeader
const SwFormatHeader & GetHeader(bool=true) const
Definition: fmthdft.hxx:97
SwUndoId
SwUndoId
Definition: swundo.hxx:29
SwDoc::GetDocShell
SwDocShell * GetDocShell()
Definition: doc.hxx:1352
GetContentNode
static SwContentNode * GetContentNode(SwDoc &rDoc, SwNodeIndex &rIdx, bool bNext)
Definition: fltshell.cxx:53
SwCursorShell::SelNextRedline
const SwRangeRedline * SelNextRedline()
Definition: crstrvl.cxx:2202
SwCursorShell::CHKRANGE
check overlapping PaMs
Definition: crsrsh.hxx:154
SwRect::Left
void Left(const tools::Long nLeft)
Definition: swrect.hxx:195
SwPosition::nNode
SwNodeIndex nNode
Definition: pam.hxx:37
SwCursorShell::IsTableMode
bool IsTableMode() const
Definition: crsrsh.hxx:643
SwCursorShell::UPDOWN
keep Up/Down on columns
Definition: crsrsh.hxx:152
SwCursorShell::MoveFieldType
bool MoveFieldType(const SwFieldType *pFieldType, const bool bNext, const SwFieldIds nResType=SwFieldIds::Unknown, const bool bAddSetExpressionFieldsToInputFields=true)
Definition: crstrvl.cxx:694
IDocumentContentOperations::InsertItemSet
virtual void InsertItemSet(const SwPaM &rRg, const SfxItemSet &, const SetAttrMode nFlags=SetAttrMode::DEFAULT, SwRootFrame const *pLayout=nullptr)=0
comphelper::string::strip
OString strip(std::string_view rIn, char c)
pDesc
sal_uInt16 char char * pDesc
SwCursorShell::getShellCursor
SwShellCursor * getShellCursor(bool bBlock)
Delivers the current shell cursor.
Definition: crsrsh.cxx:3044
GetBodyTextNode
const SwTextNode * GetBodyTextNode(const SwDoc &rDoc, SwPosition &rPos, const SwFrame &rFrame)
Forward declaration: get "BodyTextNode" for exp.fld in Fly's headers/footers/footnotes.
Definition: expfld.cxx:163
SwTextAttr::GetEnd
virtual const sal_Int32 * GetEnd() const
end position
Definition: txatbase.cxx:48
sal_uLong
sal_uIntPtr sal_uLong
SwTOXMarks
std::vector< SwTOXMark * > SwTOXMarks
Definition: tox.hxx:46
SwRedlineTable::FindPrevOfSeqNo
size_type FindPrevOfSeqNo(size_type nSttPos) const
Definition: docredln.cxx:660
SwFrameAreaDefinition::getFramePrintArea
const SwRect & getFramePrintArea() const
Definition: frame.hxx:179
SwComparePosition::Equal
Pos1 is as large as Pos2.
SwContentAtPos::pAttr
const SfxPoolItem * pAttr
Definition: crsrsh.hxx:96
SwPaM::GetMark
const SwPosition * GetMark() const
Definition: pam.hxx:209
SwFillMode::Margin
only align left, center, right
SwField
Base class of all fields.
Definition: fldbas.hxx:289
SwCursorShell::GotoRedline
const SwRangeRedline * GotoRedline(SwRedlineTable::size_type nArrPos, bool bSelect)
Definition: crstrvl.cxx:2331
SwComparePosition::Inside
Pos1 completely contained in Pos2.
SwContentNode::getLayoutFrame
SwContentFrame * getLayoutFrame(const SwRootFrame *, const SwPosition *pPos=nullptr, std::pair< Point, bool > const *pViewPosAndCalcFrame=nullptr) const
Definition: node.cxx:1213
n
sal_Int64 n
IDocumentUndoRedo::EndUndo
virtual SwUndoId EndUndo(SwUndoId const eUndoId, SwRewriter const *const pRewriter)=0
Closes undo block.
IDocumentMarkAccess
Provides access to the marks of a document.
Definition: IDocumentMarkAccess.hxx:40
SwShellCursor::SetMark
virtual void SetMark() override
Unless this is called, the getter method of Mark will return Point.
Definition: viscrs.cxx:651
SwCursor::IsSelOvr
virtual bool IsSelOvr(SwCursorSelOverFlags eFlags=SwCursorSelOverFlags::CheckNodeSection|SwCursorSelOverFlags::Toggle|SwCursorSelOverFlags::ChangePos)
Definition: swcrsr.cxx:226
SwDoc
Definition: doc.hxx:188
SwNodes::GoPrevSection
static SwContentNode * GoPrevSection(SwNodeIndex *, bool bSkipHidden=true, bool bSkipProtect=true)
Definition: nodes.cxx:1968
SwIterator::Next
TElementType * Next()
Definition: calbck.hxx:333
SwCursorMoveState::m_bSetInReadOnly
bool m_bSetInReadOnly
ReadOnly areas may be entered.
Definition: crstate.hxx:148
SwCursorShell::MakeSelVisible
virtual void MakeSelVisible()
show the current selected "object"
Definition: crsrsh.cxx:3080
RES_BREAK
constexpr TypedWhichId< SvxFormatBreakItem > RES_BREAK(94)
SwCursorMoveState::m_bExactOnly
bool m_bExactOnly
let GetModelPositionForViewPoint look for exact matches only, i.e.
Definition: crstate.hxx:145
SwNodeIndex::GetNode
SwNode & GetNode() const
Definition: ndindex.hxx:119
SwCursorShell::GotoFootnoteAnchor
bool GotoFootnoteAnchor()
jump from footnote to anchor
Definition: trvlfnfl.cxx:162
SwFormatContent
Content, content of frame (header, footer, fly).
Definition: fmtcntnt.hxx:31
SwSection::GetFormat
SwSectionFormat * GetFormat()
Definition: section.hxx:336
SwRect::Pos
void Pos(const Point &rNew)
Definition: swrect.hxx:169
SwDoc::getIDocumentMarkAccess
IDocumentMarkAccess * getIDocumentMarkAccess()
Definition: docbm.cxx:1794
SwDoc::GetIDocumentUndoRedo
IDocumentUndoRedo & GetIDocumentUndoRedo()
Definition: doc.cxx:144
IDocumentContentOperations::InsertPoolItem
virtual bool InsertPoolItem(const SwPaM &rRg, const SfxPoolItem &, const SetAttrMode nFlags=SetAttrMode::DEFAULT, SwRootFrame const *pLayout=nullptr, SwTextAttr **ppNewTextAttr=nullptr)=0
Insert an attribute.
SwFrame::Calc
virtual void Calc(vcl::RenderContext *pRenderContext) const
Definition: trvlfrm.cxx:1788
SwCharFormats::size_type
SwCharFormatsBase::size_type size_type
Definition: charformats.hxx:63
SwFrame::IsCellFrame
bool IsCellFrame() const
Definition: frame.hxx:1223
SwRect
Of course Writer needs its own rectangles.
Definition: swrect.hxx:35
SwTextAttr::Which
sal_uInt16 Which() const
Definition: txatbase.hxx:114
SwTextAttrEnd::GetEnd
virtual const sal_Int32 * GetEnd() const override
end position
Definition: txatbase.cxx:77
SwTextNode::GetTextAttrAt
SwTextAttr * GetTextAttrAt(sal_Int32 const nIndex, sal_uInt16 const nWhich, enum GetTextAttrMode const eMode=DEFAULT) const
get the innermost text attribute covering position nIndex.
Definition: ndtxt.cxx:1716
SwCursorShell::GotoNxtPrvTableFormula
bool GotoNxtPrvTableFormula(bool bNext=true, bool bOnlyErrors=false)
Jump to next/previous table formula Optionally it is possible to also jump to broken formulas...
Definition: crstrvl.cxx:389
RES_BOXATR_VALUE
constexpr TypedWhichId< SwTableBoxValue > RES_BOXATR_VALUE(152)
SwCursorShell::GotoHeaderText
bool GotoHeaderText()
jump from the content to the header
Definition: crstrvl.cxx:131
SwDoc::getIDocumentContentOperations
IDocumentContentOperations const & getIDocumentContentOperations() const
Definition: doc.cxx:315
SwModify::HasWriterListeners
bool HasWriterListeners() const
Definition: calbck.hxx:197
SwRangeRedline::CalcStartEnd
void CalcStartEnd(sal_uLong nNdIdx, sal_Int32 &rStart, sal_Int32 &rEnd) const
Calculates the intersection with text node number nNdIdx.
Definition: docredln.cxx:1303
SwRootFrame
The root element of a Writer document layout.
Definition: rootfrm.hxx:82
SwDoc::GetSpzFrameFormats
const SwFrameFormats * GetSpzFrameFormats() const
Definition: doc.hxx:744
SwTextNode::GetAttrOutlineLevel
int GetAttrOutlineLevel() const
Returns outline level of this text node.
Definition: ndtxt.cxx:4007
SwCursorShell::HasSelection
bool HasSelection() const
Does the current cursor create a selection?
Definition: crsrsh.cxx:2521
SwFieldType::GatherFields
void GatherFields(std::vector< SwFormatField * > &rvFormatFields, bool bCollectOnlyInDocNodes=true) const
Definition: fldbas.cxx:207
SwSectionFormats
Array of Undo-history.
Definition: docary.hxx:192
SwPaM::GetContentNode
SwContentNode * GetContentNode(bool bPoint=true) const
Definition: pam.hxx:229
SwFrame::GetModelPositionForViewPoint
virtual bool GetModelPositionForViewPoint(SwPosition *, Point &, SwCursorMoveState *=nullptr, bool bTestBackground=false) const
Definition: unusedf.cxx:47
Size::Width
constexpr tools::Long Width() const
SfxItemPool::GetItemCount2
sal_uInt32 GetItemCount2(sal_uInt16 nWhich) const
SwRootFrame::GetModelPositionForViewPoint
virtual bool GetModelPositionForViewPoint(SwPosition *, Point &, SwCursorMoveState *=nullptr, bool bTestBackground=false) const override
Primary passes the call to the first page.
Definition: trvlfrm.cxx:425
SwFormatINetFormat::GetValue
const OUString & GetValue() const
Definition: fmtinfmt.hxx:75
SfxItemIter::NextItem
const SfxPoolItem * NextItem()
SvxLRSpaceItem::SetTextLeft
void SetTextLeft(const tools::Long nL, const sal_uInt16 nProp=100)
SwWrongList::SubList
SwWrongList * SubList(sal_uInt16 nIdx) const
Definition: wrong.hxx:343
RES_DRAWFRMFMT
constexpr TypedWhichId< SwDrawFrameFormat > RES_DRAWFRMFMT(159)
SwGetRefFieldType::FindAnchor
static SwTextNode * FindAnchor(SwDoc *pDoc, const OUString &rRefMark, sal_uInt16 nSubType, sal_uInt16 nSeqNo, sal_Int32 *pStt, sal_Int32 *pEnd=nullptr, SwRootFrame const *pLayout=nullptr)
Definition: reffld.cxx:1142
SwTextAttr::GetTOXMark
const SwTOXMark & GetTOXMark() const
Definition: txatbase.hxx:216
SwViewShell::mxDoc
rtl::Reference< SwDoc > mxDoc
The document; never 0.
Definition: viewsh.hxx:171
SwPosition::nContent
SwIndex nContent
Definition: pam.hxx:38
SwFrameAreaDefinition::getFrameArea
const SwRect & getFrameArea() const
Definition: frame.hxx:178
SwCursorShell::NormalizePam
void NormalizePam(bool bPointFirst=true)
Ensure point and mark of the current PaM are in a specific order.
Definition: crsrsh.cxx:970
SwFormatField::GetTextField
const SwTextField * GetTextField() const
Definition: fmtfld.hxx:128
SwSectionFormat::GetSectionNode
SwSectionNode * GetSectionNode()
Definition: section.cxx:957
SwDoc::SetTextFormatColl
bool SetTextFormatColl(const SwPaM &rRg, SwTextFormatColl *pFormat, const bool bReset=true, const bool bResetListAttrs=false, SwRootFrame const *pLayout=nullptr)
Add 4th optional parameter .
Definition: docfmt.cxx:1072
SwTextAttr
A wrapper around SfxPoolItem to store the start position of (usually) a text portion, with an optional end.
Definition: txatbase.hxx:41
IDocumentMarkAccess::getFieldmarkFor
virtual ::sw::mark::IFieldmark * getFieldmarkFor(const SwPosition &pos) const =0
SwTOXSearch
SwTOXSearch
Definition: toxe.hxx:22
SwFillMode::Indent
by left paragraph indentation
SwCursorMoveState::m_nInNumPortionOffset
int m_nInNumPortionOffset
distance from number portion's start
Definition: crstate.hxx:164
SwCursorShell::GetCurField
SwField * GetCurField(const bool bIncludeInputFieldAtStart=false) const
Definition: crstrvl.cxx:908
SwFormatFooter
Footer, for pageformats Client of FrameFormat describing the footer.
Definition: fmthdft.hxx:64
POOLATTR_BEGIN
constexpr sal_uInt16 POOLATTR_BEGIN(HINT_BEGIN)
SwCursorShell::GotoPrevTOXBase
bool GotoPrevTOXBase(const OUString *=nullptr)
jump to previous index
Definition: crstrvl.cxx:318
SwNodeIndex::GetIndex
sal_uLong GetIndex() const
Definition: ndindex.hxx:152
SwTextAttr::GetStart
sal_Int32 GetStart() const
Definition: txatbase.hxx:86
SwContentAtPos::eContentAtPos
IsAttrAtPos eContentAtPos
Definition: crsrsh.hxx:101
SwComparePosition::Outside
Pos2 completely contained in Pos1.
IsAttrAtPos::TableBoxValue
only for debugging
SwContentAtPos::sStr
OUString sStr
Definition: crsrsh.hxx:103
SwTableNode::GetTable
const SwTable & GetTable() const
Definition: node.hxx:499
SwFillMode
SwFillMode
Definition: crstate.hxx:28
SwContentAtPos::aFnd
union SwContentAtPos::@24 aFnd
SwViewShell::GetDoc
SwDoc * GetDoc() const
Definition: viewsh.hxx:281
SwTextAttr::GetFormatField
const SwFormatField & GetFormatField() const
Definition: txatbase.hxx:195
lcl_MakeFieldLst
static void lcl_MakeFieldLst(SetGetExpFields &rLst, const SwFieldType &rFieldType, const bool bInReadOnly, const bool bChkInpFlag=false)
jump to next/previous field type
Definition: crstrvl.cxx:628
SwCursorShell::SelectNxtPrvHyperlink
bool SelectNxtPrvHyperlink(bool bNext)
Definition: crstrvl.cxx:2440
SwViewShell::getIDocumentRedlineAccess
const IDocumentRedlineAccess & getIDocumentRedlineAccess() const
Provides access to the document redline interface.
Definition: viewsh.cxx:2669
o3tl::sorted_vector::size
size_type size() const
RES_TXTATR_FTN
constexpr TypedWhichId< SwFormatFootnote > RES_TXTATR_FTN(58)
SetGetExpField::SetBodyPos
void SetBodyPos(const SwContentFrame &rFrame)
Definition: docfld.cxx:176
SwPaM::GetNext
SwPaM * GetNext()
Definition: pam.hxx:264
SwTableFormula::PtrToBoxNm
void PtrToBoxNm(const SwTable *pTable)
create from the internal formula (for CORE) the external formula (for UI)
Definition: cellfml.cxx:571
SwFrame::GetCharRect
virtual bool GetCharRect(SwRect &, const SwPosition &, SwCursorMoveState *=nullptr, bool bAllowFarAway=true) const
Definition: unusedf.cxx:72
RES_TXTATR_INETFMT
constexpr TypedWhichId< SwFormatINetFormat > RES_TXTATR_INETFMT(51)
SwFrameFormats
Specific frame formats (frames, DrawObjects).
Definition: frameformats.hxx:48
SwContentAtPos::pFieldmark
const sw::mark::IFieldmark * pFieldmark
Definition: crsrsh.hxx:99
SwNodes::GetEndOfContent
SwNode & GetEndOfContent() const
Regular ContentSection (i.e. the BodyText).
Definition: ndarr.hxx:163
SwField::HasClickHdl
bool HasClickHdl() const
Does the field possess an action on its ClickHandler? (e.g. INetFields, ...).
Definition: fldbas.cxx:393
SwCursorShell::GetCursor_
SwShellCursor * GetCursor_()
Definition: crsrsh.hxx:328
SwCursorShell::SelectText
bool SelectText(const sal_Int32 nStart, const sal_Int32 nEnd)
Definition: crstrvl.cxx:1952
SwTOXMark::GetAlternativeText
const OUString & GetAlternativeText() const
Definition: tox.hxx:579
SwNode::IsContentNode
bool IsContentNode() const
Definition: node.hxx:629
SwPaM
PaM is Point and Mark: a selection of the document model.
Definition: pam.hxx:136
SwPaM::Move
bool Move(SwMoveFnCollection const &fnMove=fnMoveForward, SwGoInDoc fnGo=GoInContent)
Movement of cursor.
Definition: pam.cxx:504
SwViewShell::GetAttrPool
const SfxItemPool & GetAttrPool() const
Definition: viewsh.hxx:612
IDocumentContentOperations::InsertString
virtual bool InsertString(const SwPaM &rRg, const OUString &, const SwInsertFlags nInsertMode=SwInsertFlags::EMPTYEXPAND)=0
Insert string into existing text node at position rRg.Point().
pName
sal_uInt16 char * pName
GetStartNode
static SwNodePtr GetStartNode(SwOutlineNodes const *pOutlNds, int nOutlineLevel, SwOutlineNodes::size_type *nOutl)
Definition: docglbl.cxx:89
SwCursorShell::IsCursorInTable
const SwTableNode * IsCursorInTable() const
Definition: crsrsh.hxx:889
SwCursorShell::SetShadowCursorPos
bool SetShadowCursorPos(const Point &rPt, SwFillMode eFillMode)
Definition: crstrvl.cxx:2059
sw::GetExpandTextMerged
OUString GetExpandTextMerged(SwRootFrame const *const pLayout, SwTextNode const &rNode, bool const bWithNumber, bool const bWithSpacesForLevel, ExpandMode const i_mode)
Definition: DocumentOutlineNodesManager.cxx:45
SwCursorShell::GetShadowCursorPos
bool GetShadowCursorPos(const Point &rPt, SwFillMode eFillMode, SwRect &rRect, sal_Int16 &rOrient)
Definition: crstrvl.cxx:2031
SwCursorSaveState
A helper class to save cursor state (position).
Definition: swcrsr.hxx:232
IDocumentUndoRedo::StartUndo
virtual SwUndoId StartUndo(SwUndoId const eUndoId, SwRewriter const *const pRewriter)=0
Opens undo block.
SwFrame::IsContentFrame
bool IsContentFrame() const
Definition: frame.hxx:1227
vcl::Window::LogicToPixel
Point LogicToPixel(const Point &rLogicPt) const
SwOutlineNodes::npos
static constexpr auto npos
Definition: ndarr.hxx:79
SwCursorShell::CreateCursor
SwPaM * CreateCursor()
delete the current cursor and make the following into the current
Definition: crsrsh.cxx:124
i
int i
GoInNode
bool GoInNode(SwPaM &rPam, SwMoveFnCollection const &fnMove)
Definition: pam.cxx:961
SwContentAtPos::pField
const SwField * pField
Definition: crsrsh.hxx:95
SwLayoutFrame::GetLastLower
const SwFrame * GetLastLower() const
Definition: findfrm.cxx:1831
SfxPoolItem::StaticWhichCast
T & StaticWhichCast(TypedWhichId< T > nId)
SwNode::StartOfSectionNode
const SwStartNode * StartOfSectionNode() const
Definition: node.hxx:132
SwNode::GetDoc
SwDoc & GetDoc()
Definition: node.hxx:212
SwFormatFooter::GetFooterFormat
const SwFrameFormat * GetFooterFormat() const
Definition: fmthdft.hxx:85
SwPaM::GetPoint
const SwPosition * GetPoint() const
Definition: pam.hxx:207
SwCursorShell::SetCursorInHdFt
bool SetCursorInHdFt(size_t nDescNo, bool bInHeader)
Definition: crstrvl.cxx:195
SwVectorModifyBase< SwSectionFormat * >::size_type
std::vector< SwSectionFormat * >::size_type size_type
Definition: docary.hxx:67
SwIndex::Assign
SwIndex & Assign(SwIndexReg *, sal_Int32)
Definition: index.cxx:206
SwDoc::GetPageDesc
const SwPageDesc & GetPageDesc(const size_t i) const
Definition: doc.hxx:881
SwFrame::FindPageFrame
SwPageFrame * FindPageFrame()
Definition: frame.hxx:679
SwCursorShell::SelPrevRedline
const SwRangeRedline * SelPrevRedline()
Definition: crstrvl.cxx:2230
SwViewShell::ActionPend
bool ActionPend() const
Definition: viewsh.hxx:196
SwIterator::First
TElementType * First()
Definition: calbck.hxx:325
SwPageFrame::GetPageDesc
SwPageDesc * GetPageDesc()
Definition: pagefrm.hxx:143
SwNode::GetContentNode
SwContentNode * GetContentNode()
Definition: node.hxx:616
SwRedlineTable::size_type
vector_type::size_type size_type
Definition: docary.hxx:223
SfxItemSet::Count
sal_uInt16 Count() const
SwFieldIds
SwFieldIds
Definition: fldbas.hxx:44
SwCursorShell::GotoINetAttr
bool GotoINetAttr(const SwTextINetFormat &rAttr)
Definition: crstrvl.cxx:2005
SwPaM::HasMark
bool HasMark() const
A PaM marks a selection if Point and Mark are distinct positions.
Definition: pam.hxx:205
SwFormat::GetURL
const SwFormatURL & GetURL(bool=true) const
Definition: fmturl.hxx:78
SwFrame::GetUpper
SwLayoutFrame * GetUpper()
Definition: frame.hxx:677
SwIndex
Marks a character position inside a document model node.
Definition: index.hxx:33
SwVectorModifyBase::size
size_t size() const
Definition: docary.hxx:88
SwFormat::GetFooter
const SwFormatFooter & GetFooter(bool=true) const
Definition: fmthdft.hxx:99
SwCursorShell::GotoNextTOXBase
bool GotoNextTOXBase(const OUString *=nullptr)
jump to the next index
Definition: crstrvl.cxx:267
SwCursorShell::IsPageAtPos
bool IsPageAtPos(const Point &rPt) const
Definition: crstrvl.cxx:1248
SwDocShell::GetWrtShell
SwWrtShell * GetWrtShell()
Access to the SwWrtShell belonging to SwView.
Definition: docsh.hxx:224
SetGetExpField::GetFlyFormat
const SwFlyFrameFormat * GetFlyFormat() const
Definition: docfld.hxx:89
SwFormat::GetItemState
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
Definition: format.cxx:388
SwCursorShell::GotoPrevOutline
bool GotoPrevOutline()
jump to previous node with outline num.
Definition: crstrvl.cxx:1073
SwNodeIndex
Marks a node in the document model.
Definition: ndindex.hxx:31
SwTableBox::GetFrameFormat
SwFrameFormat * GetFrameFormat()
Definition: swtable.hxx:434
SwNode::IsEndNode
bool IsEndNode() const
Definition: node.hxx:633
SwNodes::GetOutLineNds
const SwOutlineNodes & GetOutLineNds() const
Array of all OutlineNodes.
Definition: ndarr.hxx:231
SwNode::GetNodes
SwNodes & GetNodes()
Node is in which nodes-array/doc?
Definition: node.hxx:694
static_txtattr_cast
T static_txtattr_cast(S *s)
Definition: txatbase.hxx:241
SwContentAtPos::pNode
SwContentNode * pNode
Definition: crsrsh.hxx:98
sw::Ring< SwViewShell >::GetRingContainer
ring_container GetRingContainer()
o3tl::sorted_vector::end
const_iterator end() const
SwTextNode::GetFieldTextAttrAt
SwTextField * GetFieldTextAttrAt(const sal_Int32 nIndex, const bool bIncludeInputFieldAtStart=false) const
Definition: ndtxt.cxx:1760
SwCursorShell::SelectTextAttr
bool SelectTextAttr(sal_uInt16 nWhich, bool bExpand, const SwTextAttr *pAttr=nullptr)
Definition: crstrvl.cxx:1976
SwCursorShell::GetOutlinePos
SwOutlineNodes::size_type GetOutlinePos(sal_uInt8 nLevel=UCHAR_MAX, SwPaM *pPaM=nullptr)
search "outline position" before previous outline node at given level
Definition: crstrvl.cxx:1138
index
tuple index
o3tl::sorted_vector::empty
bool empty() const
SvxAdjustItem::SetAdjust
void SetAdjust(const SvxAdjust eType)
SwContentAtPos::IsInProtectSect
bool IsInProtectSect() const
is the node in a protected section?
Definition: crstrvl.cxx:1884
SwTextINetFormat::GetpTextNode
const SwTextNode * GetpTextNode() const
Definition: txtinet.hxx:45
SwNode::GetStartNode
SwStartNode * GetStartNode()
Definition: node.hxx:592
SwCursorShell::GotoTOXMarkBase
void GotoTOXMarkBase()
jump to index of TOXMark
Definition: crstrvl.cxx:370
SwContentAtPos::pFndTextAttr
const SwTextAttr * pFndTextAttr
Definition: crsrsh.hxx:104
SwPageFrame
A page of the document layout.
Definition: pagefrm.hxx:57
SwDoc::GotoTOXMark
const SwTOXMark & GotoTOXMark(const SwTOXMark &rCurTOXMark, SwTOXSearch eDir, bool bInReadOnly)
Definition: doctxm.cxx:228
SwWrtShell::StartOfSection
bool StartOfSection(bool bSelect=false)
Definition: move.cxx:308
SvxSearchDialogWrapper::SetSearchLabel
static void SetSearchLabel(const SearchLabel &rSL)
SwDoc::getIDocumentLayoutAccess
IDocumentLayoutAccess const & getIDocumentLayoutAccess() const
Definition: doc.cxx:405
SwCursorShell::GotoRedline_
SAL_DLLPRIVATE const SwRangeRedline * GotoRedline_(SwRedlineTable::size_type nArrPos, bool bSelect)
Definition: crstrvl.cxx:2258
SwCursorShell::EndOfInputFieldAtPos
static sal_Int32 EndOfInputFieldAtPos(const SwPosition &rPos)
Definition: crstrvl.cxx:963
SwPaM::Start
const SwPosition * Start() const
Definition: pam.hxx:212
POOLATTR_END
constexpr sal_uInt16 POOLATTR_END(RES_UNKNOWNATR_END)
SwRect::Center
Point Center() const
Definition: swrect.cxx:35
SwCursorShell::GetUpDownX
tools::Long GetUpDownX() const
Definition: crsrsh.hxx:347
sw::GetParaPropsNode
SwTextNode * GetParaPropsNode(SwRootFrame const &rLayout, SwNodeIndex const &rNode)
Definition: txtfrm.cxx:328
SwField::GetTyp
SwFieldType * GetTyp() const
Definition: fldbas.hxx:392
SwNode::IsInProtectSect
bool IsInProtectSect() const
Is node in a protected area?
Definition: node.cxx:416
SwCharFormats::size
size_t size() const
Definition: charformats.hxx:71
SwFormatContent::GetContentIdx
const SwNodeIndex * GetContentIdx() const
Definition: fmtcntnt.hxx:46
o3tl::sorted_vector::begin
const_iterator begin() const
IDocumentRedlineAccess::GetRedline
virtual const SwRangeRedline * GetRedline(const SwPosition &rPos, SwRedlineTable::size_type *pFndPos) const =0
SwCursorShell::StartAction
void StartAction()
Definition: crsrsh.cxx:227
SwTextNode::EXPAND
DEFAULT: (Start <= nIndex < End)
Definition: ndtxt.hxx:367
SwPaM::GetPrev
SwPaM * GetPrev()
Definition: pam.hxx:268
SwFormatURL::GetMap
const ImageMap * GetMap() const
Definition: fmturl.hxx:68
SwCursorMoveState::m_bFootnoteNoInfo
bool m_bFootnoteNoInfo
recognized footnote numbering
Definition: crstate.hxx:144
SwFormat::Which
sal_uInt16 Which() const
for Querying of Writer-functions.
Definition: format.hxx:82
SwCursorShell::DocPtInsideInputField
bool DocPtInsideInputField(const Point &rDocPt) const
Definition: crstrvl.cxx:944
SwTextTOXMark::GetTextNode
const SwTextNode & GetTextNode() const
Definition: txttxmrk.hxx:49
SwCursorMoveState::m_bInNumPortion
bool m_bInNumPortion
point is in number portion #i23726#
Definition: crstate.hxx:163
SwRedlineTable::FindNextOfSeqNo
size_type FindNextOfSeqNo(size_type nSttPos) const
Definition: docredln.cxx:653
SwViewShell::GetIDocumentUndoRedo
IDocumentUndoRedo const & GetIDocumentUndoRedo() const
Provides access to the document undo/redo interface.
Definition: viewsh.cxx:2679
SwPageDesc::GetMaster
SwFrameFormat & GetMaster()
Definition: pagedesc.hxx:238
SwNode::EndOfSectionIndex
sal_uLong EndOfSectionIndex() const
Definition: node.hxx:678
SfxItemSet::Put
const SfxPoolItem * Put(const SfxPoolItem &rItem, sal_uInt16 nWhich)
SwRect::Bottom
void Bottom(const tools::Long nBottom)
Definition: swrect.hxx:209
SwTextNode
SwTextNode is a paragraph in the document model.
Definition: ndtxt.hxx:79
SwDoc::getIDocumentRedlineAccess
IDocumentRedlineAccess const & getIDocumentRedlineAccess() const
Definition: doc.cxx:335
SwCursorShell::IsReadOnlyAvailable
bool IsReadOnlyAvailable() const
Definition: crsrsh.hxx:474
SwTableBox::GetSttNd
const SwStartNode * GetSttNd() const
Definition: swtable.hxx:448
SwField::Which
SwFieldIds Which() const
ResId.
Definition: fldbas.cxx:245
SwFillMode::Tab
default, fill with tabs
SwTextNode::GetExpandText
OUString GetExpandText(SwRootFrame const *pLayout, const sal_Int32 nIdx=0, const sal_Int32 nLen=-1, const bool bWithNum=false, const bool bAddSpaceAfterListLabelStr=false, const bool bWithSpacesForLevel=false, const ExpandMode eAdditionalMode=ExpandMode::ExpandFootnote) const
add 4th optional parameter indicating, when that a spa...
Definition: ndtxt.cxx:3359
SwDoc::GetCharFormats
const SwCharFormats * GetCharFormats() const
Definition: doc.hxx:740
SwFlyFrame
general base class for all free-flowing frames
Definition: flyfrm.hxx:78
sw::IsFieldDeletedInModel
bool IsFieldDeletedInModel(IDocumentRedlineAccess const &rIDRA, SwTextField const &rTextField)
Definition: DocumentFieldsManager.cxx:65
SwCursorShell::GetCurrFrame
SwContentFrame * GetCurrFrame(const bool bCalcFrame=true) const
Get current frame in which the cursor is positioned.
Definition: crsrsh.cxx:2450
SwComparePosition::OverlapBehind
Pos1 overlaps Pos2 at the end.
sal_uInt8
unsigned char sal_uInt8
SwFillMode::TabSpace
fill with spaces and tabs
SwDoc::GetCurTOXMark
static sal_uInt16 GetCurTOXMark(const SwPosition &rPos, SwTOXMarks &)
Get current table of contents Mark.
Definition: doctxm.cxx:116
SwViewShell::GetWin
vcl::Window * GetWin() const
Definition: viewsh.hxx:337
SwCursorShell::StartOfInputFieldAtPos
static sal_Int32 StartOfInputFieldAtPos(const SwPosition &rPos)
Definition: crstrvl.cxx:955
fnMoveForward
SwMoveFnCollection const & fnMoveForward
SwPam::Move()/Find() default argument.
Definition: paminit.cxx:59
SwWrongList::GetWrongPos
sal_uInt16 GetWrongPos(sal_Int32 nValue) const
Find the first position that is greater or equal to the given value.
Definition: wrong.cxx:190
SwIndex::GetIndex
sal_Int32 GetIndex() const
Definition: index.hxx:91
SwWrongList::InWrongWord
bool InWrongWord(sal_Int32 &rChk, sal_Int32 &rLn) const
If a word is incorrectly selected, this method returns begin and length of it.
Definition: wrong.cxx:102
SwRect::IsInside
bool IsInside(const Point &rPOINT) const
Definition: swrect.cxx:105
SfxItemSet::Differentiate
void Differentiate(const SfxItemSet &rSet)
SwDoc::GetNodes
SwNodes & GetNodes()
Definition: doc.hxx:409
SwCursorShell::MoveCursorToNum
SAL_DLLPRIVATE void MoveCursorToNum()
Definition: crstrvl.cxx:80
RES_BOXATR_FORMULA
constexpr TypedWhichId< SwTableBoxFormula > RES_BOXATR_FORMULA(151)
SetGetExpField::GetINetFormat
const SwTextINetFormat * GetINetFormat() const
Definition: docfld.hxx:87
SwCursorShell::PosInsideInputField
static bool PosInsideInputField(const SwPosition &rPos)
Definition: crstrvl.cxx:939
SwPaM::End
const SwPosition * End() const
Definition: pam.hxx:217
SwFrame::IsRightToLeft
bool IsRightToLeft() const
Definition: frame.hxx:984
SwRect::Top
void Top(const tools::Long nTop)
Definition: swrect.hxx:204
SwRangeRedline::GetType
RedlineType GetType(sal_uInt16 nPos=0) const
Definition: docredln.cxx:1810
SwTextAttr::End
const sal_Int32 * End() const
Definition: txatbase.hxx:152
SwTableBox
SwTableBox is one table cell in the document model.
Definition: swtable.hxx:395
SwCursorShell::FindINetAttr
const SwFormatINetFormat * FindINetAttr(std::u16string_view rName) const
Definition: crstrvl.cxx:2026
SwFrame::GetLower
SwFrame * GetLower()
Definition: findfrm.cxx:170
SwDoc::GotoNextNum
static bool GotoNextNum(SwPosition &, SwRootFrame const *pLayout, bool bOverUpper=true, sal_uInt8 *pUpper=nullptr, sal_uInt8 *pLower=nullptr)
Definition: docnum.cxx:1602
SwShellCursor::GetPtPos
const Point & GetPtPos() const
Definition: viscrs.hxx:141
SwCursorMoveState::m_pSpecialPos
SwSpecialPos * m_pSpecialPos
for positions inside fields
Definition: crstate.hxx:136
IDocumentRedlineAccess::SelNextRedline
virtual const SwRangeRedline * SelNextRedline(SwPaM &rPam) const =0
RES_TXTATR_TOXMARK
constexpr TypedWhichId< SwTOXMark > RES_TXTATR_TOXMARK(47)
RES_LR_SPACE
constexpr TypedWhichId< SvxLRSpaceItem > RES_LR_SPACE(91)
SwCursorShell::SCROLLWIN
scroll window
Definition: crsrsh.hxx:153
sw::IsParaPropsNode
bool IsParaPropsNode(SwRootFrame const &rLayout, SwTextNode const &rNode)
Definition: txtfrm.cxx:311
SwCursorShell::MakeOutlineSel
void MakeOutlineSel(SwOutlineNodes::size_type nSttPos, SwOutlineNodes::size_type nEndPos, bool bWithChildren, bool bKillPams=true)
Definition: crstrvl.cxx:1167
SwFormatHeader
Header, for PageFormats Client of FrameFormat describing the header.
Definition: fmthdft.hxx:33
SwCursorShell::ClearMark
void ClearMark()
Definition: crsrsh.cxx:939
SwDoc::GotoPrevNum
static bool GotoPrevNum(SwPosition &, SwRootFrame const *pLayout, bool bOverUpper=true)
Definition: docnum.cxx:1688
RES_TXTATR_INPUTFIELD
constexpr TypedWhichId< SwFormatField > RES_TXTATR_INPUTFIELD(55)
IDocumentContentOperations::AppendTextNode
virtual bool AppendTextNode(SwPosition &rPos)=0
SwNode::FindTableBoxStartNode
const SwStartNode * FindTableBoxStartNode() const
Definition: node.hxx:197
SwContentAtPos::pRedl
const SwRangeRedline * pRedl
Definition: crsrsh.hxx:97
SwCursorShell::GotoTOXMark
const SwTOXMark & GotoTOXMark(const SwTOXMark &rStart, SwTOXSearch eDir)
traveling between marks
Definition: crstrvl.cxx:605
SwFormat::GetContent
const SwFormatContent & GetContent(bool=true) const
Definition: fmtcntnt.hxx:55
fnMoveBackward
SwMoveFnCollection const & fnMoveBackward
Definition: paminit.cxx:58
SwNode::FindTableNode
SwTableNode * FindTableNode()
Search table node, in which it is.
Definition: node.cxx:357
lcl_FindField
static SetGetExpFields::const_iterator lcl_FindField(bool &o_rFound, SetGetExpFields const &rSrtLst, SwRootFrame const *const pLayout, SwTextNode *const pTextNode, SwTextField const *const pTextField, SwPosition const &rPos, sal_Int32 const nContentOffset)
Definition: crstrvl.cxx:663
SwCursorMoveState::m_bPosCorr
bool m_bPosCorr
Point had to be corrected.
Definition: crstate.hxx:143
SwTextAttr::GetAttr
const SfxPoolItem & GetAttr() const
Definition: txatbase.hxx:163
SwFrame::IsVertical
bool IsVertical() const
Definition: frame.hxx:970
SwTextAttr::DontExpand
bool DontExpand() const
Definition: txatbase.hxx:96
SwCursorShell::GotoPrevNum
void GotoPrevNum()
Definition: crstrvl.cxx:123
SwTextFootnote::GetStartNode
SwNodeIndex * GetStartNode() const
Definition: txtftn.hxx:41
SwNodes::GoNextSection
SwContentNode * GoNextSection(SwNodeIndex *, bool bSkipHidden=true, bool bSkipProtect=true) const
Go to next content-node that is not protected or hidden (Both set FALSE ==> GoNext/GoPrevious!!!).
Definition: nodes.cxx:1916
SwCursorShell::GotoNxtPrvTOXMark
bool GotoNxtPrvTOXMark(bool bNext=true)
jump to next/previous index marker
Definition: crstrvl.cxx:508
SwTOXType::FindContentFrame
SwContentFrame * FindContentFrame(const SwDoc &rDoc, const SwRootFrame &rLayout) const
Definition: tox.hxx:189
SwNodes::IsDocNodes
bool IsDocNodes() const
Is the NodesArray the regular one of Doc? (and not the UndoNds, ...) Implementation in doc...
Definition: nodes.cxx:2329
SwWrtShell::EndOfSection
bool EndOfSection(bool bSelect=false)
Definition: move.cxx:314
SwFrameFormats::size
size_t size() const
Definition: frameformats.hxx:73
SetGetExpField::GetPosOfContent
void GetPosOfContent(SwPosition &rPos) const
Definition: docfld.cxx:158
SwCursorShell::READONLY
make visible in spite of Readonly
Definition: crsrsh.hxx:155
SwTOXMark::GetTextTOXMark
const SwTextTOXMark * GetTextTOXMark() const
Definition: tox.hxx:163
SwFrameFormats::size_type
SwFrameFormatsBase::size_type size_type
Definition: frameformats.hxx:65
SwCursorShell::GetContentAtPos
bool GetContentAtPos(const Point &rPt, SwContentAtPos &rContentAtPos, bool bSetCursor=false, SwRect *pFieldRect=nullptr)
Definition: crstrvl.cxx:1255
SwPaM::SetMark
virtual void SetMark()
Unless this is called, the getter method of Mark will return Point.
Definition: pam.cxx:478
RES_TXTATR_REFMARK
constexpr TypedWhichId< SwFormatRefMark > RES_TXTATR_REFMARK(RES_TXTATR_WITHEND_BEGIN)
SwSection::GetType
SectionType GetType() const
Definition: section.hxx:170
SwOutlineNodes::Seek_Entry
bool Seek_Entry(SwNode *rP, size_type *pnPos) const
Definition: ndnum.cxx:32
IDocumentRedlineAccess::GetRedlineTable
virtual const SwRedlineTable & GetRedlineTable() const =0
SwCursorShell::m_aCharRect
SwRect m_aCharRect
Char-SRectangle on which the cursor is located.
Definition: crsrsh.hxx:164
SwTextField::GetTextNode
SwTextNode & GetTextNode() const
Definition: txtfld.hxx:53
o3tl::sorted_vector::insert
std::pair< const_iterator, bool > insert(Value &&x)
SwContentNode::GetAttr
const SfxPoolItem & GetAttr(sal_uInt16 nWhich, bool bInParent=true) const
SS for PoolItems: hard attributation.
Definition: node.hxx:722
IsInvalidItem
bool IsInvalidItem(const SfxPoolItem *pItem)
o3tl::sorted_vector< SwNode *, CompareSwOutlineNodes >::size_type
std::vector< SwNode * >::size_type size_type
SwNodes::GetEndOfExtras
SwNode & GetEndOfExtras() const
This is the last EndNode of a special section.
Definition: ndarr.hxx:161
SwViewShell::GetLayout
SwRootFrame * GetLayout() const
Definition: viewsh.cxx:2067
SwCursorShell::GetPostItFieldAtCursor
const SwPostItField * GetPostItFieldAtCursor() const
Definition: crstrvl.cxx:1861
SwDoc::GetSections
SwSectionFormats & GetSections()
Definition: doc.hxx:1338
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
SwCursorShell::GetTextFieldAtCursor
static SwTextField * GetTextFieldAtCursor(const SwPaM *pCursor, const bool bIncludeInputFieldAtStart)
Definition: crstrvl.cxx:875
SwNode::IsTextNode
bool IsTextNode() const
Definition: node.hxx:637
SwCursorShell::GotoOutline
bool GotoOutline(const OUString &rName)
Definition: crstrvl.cxx:988
SwRedlineTable::npos
static constexpr size_type npos
Definition: docary.hxx:224
SwCursorShell::GotoNextNum
void GotoNextNum()
go to next/previous point on the same level
Definition: crstrvl.cxx:116
SwFieldType::Which
SwFieldIds Which() const
Definition: fldbas.hxx:272
aStr
aStr
SwNodes::GoNext
SwContentNode * GoNext(SwNodeIndex *) const
Definition: nodes.cxx:1293
SwCursorShell::GotoFormatField
bool GotoFormatField(const SwFormatField &rField)
Definition: crstrvl.cxx:834
SwFrameFormat::FindSdrObject
SdrObject * FindSdrObject()
Definition: frmfmt.hxx:138
SwFrame::IsFooterFrame
bool IsFooterFrame() const
Definition: frame.hxx:1191
COMPLETE_STRING
const sal_Int32 COMPLETE_STRING
Definition: swtypes.hxx:57
SfxPoolItem::Which
sal_uInt16 Which() const
RES_PARATR_ADJUST
constexpr TypedWhichId< SvxAdjustItem > RES_PARATR_ADJUST(64)
SwComparePosition::OverlapBefore
Pos1 overlaps Pos2 at the beginning.
tools::Rectangle::Center
Point Center() const
IsAttrAtPos::CurrAttrs
only for debugging
SwFormatHeader::GetHeaderFormat
const SwFrameFormat * GetHeaderFormat() const
Definition: fmthdft.hxx:54
nPos
sal_uInt16 nPos
SwCursorShell::GotoRefMark
bool GotoRefMark(const OUString &rRefMark, sal_uInt16 nSubType, sal_uInt16 nSeqNo)
jump to reference marker
Definition: crstrvl.cxx:1224
SwFillMode::Space
fill with spaces
o3tl::sorted_vector< std::unique_ptr< SetGetExpField >, o3tl::less_uniqueptr_to< SetGetExpField > >::const_iterator
std::vector< std::unique_ptr< SetGetExpField > >::const_iterator const_iterator
SfxItemIter::GetCurItem
const SfxPoolItem * GetCurItem() const
SwTextFormatColl::GetNextTextFormatColl
SwTextFormatColl & GetNextTextFormatColl() const
Definition: fmtcol.hxx:102
SwDoc::GetAttrPool
const SwAttrPool & GetAttrPool() const
Definition: doc.hxx:1319
SwCursorShell::GotoFooterText
bool GotoFooterText()
jump from the content to the footer
Definition: crstrvl.cxx:159
SwCursor::RestoreSavePos
void RestoreSavePos()
Restore cursor state to the one saved by SwCursorSaveState.
Definition: swcrsr.cxx:2344
SwTextAttr::GetINetFormat
const SwFormatINetFormat & GetINetFormat() const
Definition: txatbase.hxx:228
SwNode::GetTextNode
SwTextNode * GetTextNode()
Inline methods from Node.hxx.
Definition: ndtxt.hxx:850
SwCursorShell::GotoNextOutline
bool GotoNextOutline()
jump to next node with outline num.
Definition: crstrvl.cxx:1007
SwFrame::IsHeaderFrame
bool IsHeaderFrame() const
Definition: frame.hxx:1187
SwFlyFrameFormat::GetFrame
SwFlyFrame * GetFrame(const Point *pDocPos=nullptr) const
Definition: atrfrm.cxx:3154
SwCursorShell::EndAction
void EndAction(const bool bIdleEnd=false)
Definition: crsrsh.cxx:244
SwFrame::IsProtected
bool IsProtected() const
Is the Frame or rather the Section in which it lies protected?
Definition: trvlfrm.cxx:1628
SwFormatURL::GetURL
const OUString & GetURL() const
Definition: fmturl.hxx:66
SwCursorShell::GetTextFieldAtPos
static SwTextField * GetTextFieldAtPos(const SwPosition *pPos, const bool bIncludeInputFieldAtStart)
Definition: crstrvl.cxx:860
SwNode
Base class of the Writer document model elements.
Definition: node.hxx:80
SwTextNode::GetTextColl
SwTextFormatColl * GetTextColl() const
Definition: ndtxt.hxx:844
comphelper::string::padToLength
OStringBuffer & padToLength(OStringBuffer &rBuffer, sal_Int32 nLength, char cFill= '\0')
SwCursorShell::CursorInsideInputField
bool CursorInsideInputField() const
Definition: crstrvl.cxx:929
void
typedef void(CALLTYPE *GetFuncDataPtr)(sal_uInt16 &nNo
Generated on Fri Jul 23 2021 18:17:48 for LibreOffice Module sw (master) by   doxygen 1.8.10