LibreOffice Module sw (master) 1
ftnidx.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 <txtftn.hxx>
21#include <fmtftn.hxx>
22#include <ftninfo.hxx>
23#include <doc.hxx>
26#include <redline.hxx>
27#include <ftnidx.hxx>
28#include <ndtxt.hxx>
29#include <ndindex.hxx>
30#include <section.hxx>
31#include <fmtftntx.hxx>
32#include <rootfrm.hxx>
33#include <txtfrm.hxx>
34
35namespace sw {
36
38 SwTextFootnote const& rTextFootnote)
39{
41 SwPosition const pos(rTextFootnote.GetTextNode(), rTextFootnote.GetStart());
42 SwRangeRedline const*const pRedline(rIDRA.GetRedline(pos, &tmp));
43 return (pRedline
44 && pRedline->GetType() == RedlineType::Delete
45 && *pRedline->GetPoint() != *pRedline->GetMark());
46}
47
48}
49
51
53{
56 return ( nIdxLHS == nIdxRHS && lhs->GetStart() < rhs->GetStart() ) || nIdxLHS < nIdxRHS;
57}
58
60{
61 if( empty() )
62 return;
63
64 // Get the NodesArray using the first foot note's StartIndex
65 SwDoc& rDoc = const_cast<SwDoc&>(rStt.GetDoc());
66 if( rDoc.IsInReading() )
67 return ;
68 SwTextFootnote* pTextFootnote;
69
70 const SwEndNoteInfo& rEndInfo = rDoc.GetEndNoteInfo();
71 const SwFootnoteInfo& rFootnoteInfo = rDoc.GetFootnoteInfo();
73
74 // For normal foot notes we treat per-chapter and per-document numbering
75 // separately. For Endnotes we only have per-document numbering.
76 if( FTNNUM_CHAPTER == rFootnoteInfo.m_eNum )
77 {
78 SwRootFrame const* pLayout(nullptr);
80 // sw_redlinehide: here we need to know if there's *any* layout with
81 // IsHideRedlines(), because then the hidden-numbers have to be updated
82 for (SwRootFrame const* pTmp : layouts)
83 {
84 if (pTmp->IsHideRedlines())
85 {
86 pLayout = pTmp;
87 }
88 }
89
90 const SwOutlineNodes& rOutlNds = rDoc.GetNodes().GetOutLineNds();
91 const SwNode *pChapterStartHidden(&rDoc.GetNodes().GetEndOfExtras());
92 SwNodeOffset nChapterStart(pChapterStartHidden->GetIndex());
93 SwNodeOffset nChapterEnd(rDoc.GetNodes().GetEndOfContent().GetIndex());
94 SwNodeOffset nChapterEndHidden(nChapterEnd);
95 if( !rOutlNds.empty() )
96 {
97 // Find the Chapter's start, which contains rStt
98 size_t n = 0;
99
100 for( ; n < rOutlNds.size(); ++n )
101 if( rOutlNds[ n ]->GetIndex() > rStt.GetIndex() )
102 break; // found it!
103 else if ( rOutlNds[ n ]->GetTextNode()->GetAttrOutlineLevel() == 1 )
104 {
105 nChapterStart = rOutlNds[ n ]->GetIndex();
106 if (!pLayout || sw::IsParaPropsNode(*pLayout, *rOutlNds[n]->GetTextNode()))
107 {
108 pChapterStartHidden = rOutlNds[ n ];
109 }
110 }
111 // now find the end of the range
112 for( ; n < rOutlNds.size(); ++n )
113 if ( rOutlNds[ n ]->GetTextNode()->GetAttrOutlineLevel() == 1 )
114 {
115 nChapterEnd = rOutlNds[ n ]->GetIndex();
116 break;
117 }
118
119 // continue to find end of hidden-chapter
120 for ( ; n < rOutlNds.size(); ++n)
121 {
122 if (rOutlNds[n]->GetTextNode()->GetAttrOutlineLevel() == 1
123 && (!pLayout || sw::IsParaPropsNode(*pLayout, *rOutlNds[n]->GetTextNode())))
124 {
125 nChapterEndHidden = rOutlNds[n]->GetIndex();
126 break;
127 }
128 }
129 }
130
131 size_t nPos = 0;
132 size_t nFootnoteNo = 1;
133 size_t nFootnoteNoHidden = 1;
134 if (SeekEntry( *pChapterStartHidden, &nPos ) && nPos)
135 {
136 // Step forward until the Index is not the same anymore
137 const SwNode* pCmpNd = &rStt;
138 while( nPos && pCmpNd == &((*this)[ --nPos ]->GetTextNode()) )
139 ;
140 ++nPos;
141 }
142
143 if( nPos == size() ) // nothing found
144 return;
145
146 if( rOutlNds.empty() )
147 {
148 nFootnoteNo = nPos+1;
149 if (nPos)
150 {
151 nFootnoteNoHidden = (*this)[nPos - 1]->GetFootnote().GetNumberRLHidden() + 1;
152 }
153 }
154
155 for( ; nPos < size(); ++nPos )
156 {
157 pTextFootnote = (*this)[ nPos ];
158 SwNodeOffset const nNode(pTextFootnote->GetTextNode().GetIndex());
159 if (nChapterEndHidden <= nNode)
160 break;
161
162 const SwFormatFootnote &rFootnote = pTextFootnote->GetFootnote();
163 if( rFootnote.GetNumStr().isEmpty() && !rFootnote.IsEndNote() &&
165 {
166 pTextFootnote->SetNumber(
167 (nChapterStart <= nNode && nNode < nChapterEnd)
168 ? rFootnoteInfo.m_nFootnoteOffset + nFootnoteNo
169 : rFootnote.GetNumber(),
170 rFootnoteInfo.m_nFootnoteOffset + nFootnoteNoHidden,
171 rFootnote.GetNumStr() );
172 if (nChapterStart <= nNode && nNode < nChapterEnd)
173 {
174 ++nFootnoteNo;
175 }
176 if (!IsFootnoteDeleted(rIDRA, *pTextFootnote))
177 {
178 ++nFootnoteNoHidden;
179 }
180 }
181 }
182 }
183
185
186 // unless we have per-document numbering, only look at endnotes here
187 const bool bEndNoteOnly = FTNNUM_DOC != rFootnoteInfo.m_eNum;
188
189 size_t nPos;
190 size_t nFootnoteNo = 1;
191 size_t nEndNo = 1;
192 size_t nFootnoteNoHidden = 1;
193 size_t nEndNoHidden = 1;
194 SwNodeOffset nUpdNdIdx = rStt.GetIndex();
195 for( nPos = 0; nPos < size(); ++nPos )
196 {
197 pTextFootnote = (*this)[ nPos ];
198 if( nUpdNdIdx <= pTextFootnote->GetTextNode().GetIndex() )
199 break;
200
201 const SwFormatFootnote &rFootnote = pTextFootnote->GetFootnote();
202 if( rFootnote.GetNumStr().isEmpty() )
203 {
204 if (!aNumArr.ChkNumber(rIDRA, *pTextFootnote).first)
205 {
206 if( pTextFootnote->GetFootnote().IsEndNote() )
207 {
208 nEndNo++;
209 if (!IsFootnoteDeleted(rIDRA, *pTextFootnote))
210 {
211 ++nEndNoHidden;
212 }
213 }
214 else
215 {
216 nFootnoteNo++;
217 if (!IsFootnoteDeleted(rIDRA, *pTextFootnote))
218 {
219 ++nFootnoteNoHidden;
220 }
221 }
222 }
223 }
224 }
225
226 // Set the array number for all footnotes starting from nPos
227 for( ; nPos < size(); ++nPos )
228 {
229 pTextFootnote = (*this)[ nPos ];
230 const SwFormatFootnote &rFootnote = pTextFootnote->GetFootnote();
231 if( rFootnote.GetNumStr().isEmpty() )
232 {
233 std::pair<sal_uInt16, sal_uInt16> nSectNo = aNumArr.ChkNumber(rIDRA, *pTextFootnote);
234 if (!nSectNo.first && (rFootnote.IsEndNote() || !bEndNoteOnly))
235 {
236 if (rFootnote.IsEndNote())
237 {
238 nSectNo.first = rEndInfo.m_nFootnoteOffset + nEndNo;
239 ++nEndNo;
240 nSectNo.second = rEndInfo.m_nFootnoteOffset + nEndNoHidden;
241 if (!IsFootnoteDeleted(rIDRA, *pTextFootnote))
242 {
243 ++nEndNoHidden;
244 }
245 }
246 else
247 {
248 nSectNo.first = rFootnoteInfo.m_nFootnoteOffset + nFootnoteNo;
249 ++nFootnoteNo;
250 nSectNo.second = rFootnoteInfo.m_nFootnoteOffset + nFootnoteNoHidden;
251 if (!IsFootnoteDeleted(rIDRA, *pTextFootnote))
252 {
253 ++nFootnoteNoHidden;
254 }
255 }
256 }
257
258 if (nSectNo.first)
259 {
260 pTextFootnote->SetNumber(nSectNo.first, nSectNo.second, rFootnote.GetNumStr());
261 }
262 }
263 }
264}
265
267{
268 if( empty() )
269 return;
270
271 // Get the NodesArray via the StartIndex of the first Footnote
272 SwDoc& rDoc = const_cast<SwDoc&>((*this)[ 0 ]->GetTextNode().GetDoc());
273 SwTextFootnote* pTextFootnote;
274 const SwEndNoteInfo& rEndInfo = rDoc.GetEndNoteInfo();
275 const SwFootnoteInfo& rFootnoteInfo = rDoc.GetFootnoteInfo();
277
279
280 SwRootFrame const* pLayout = rDoc.getIDocumentLayoutAccess().GetCurrentLayout();
282 // For normal Footnotes per-chapter and per-document numbering are treated separately.
283 // For Endnotes we only have document-wise numbering.
284 if( FTNNUM_CHAPTER == rFootnoteInfo.m_eNum )
285 {
286 // sw_redlinehide: here we need to know if there's *any* layout with
287 // IsHideRedlines(), because then the hidden-numbers have to be updated
288 for (SwRootFrame const* pTmp : aAllLayouts)
289 {
290 if (pTmp->IsHideRedlines())
291 {
292 pLayout = pTmp;
293 }
294 }
295
296 const SwOutlineNodes& rOutlNds = rDoc.GetNodes().GetOutLineNds();
297 sal_uInt16 nNo = 1; // Number for the Footnotes
298 sal_uInt16 nNoNo = 1;
299 size_t nFootnoteIdx = 0; // Index into theFootnoteIdx array
300 for( size_t n = 0; n < rOutlNds.size(); ++n )
301 {
302 if ( rOutlNds[ n ]->GetTextNode()->GetAttrOutlineLevel() == 1 )
303 {
304 SwNodeOffset nCapStt = rOutlNds[ n ]->GetIndex(); // Start of a new chapter
305 for( ; nFootnoteIdx < size(); ++nFootnoteIdx )
306 {
307 pTextFootnote = (*this)[ nFootnoteIdx ];
308 if( pTextFootnote->GetTextNode().GetIndex() >= nCapStt )
309 break;
310
311 // Endnotes are per-document only
312 const SwFormatFootnote &rFootnote = pTextFootnote->GetFootnote();
313 if( !rFootnote.IsEndNote() && rFootnote.GetNumStr().isEmpty() &&
315 {
316 pTextFootnote->SetNumber(
317 rFootnoteInfo.m_nFootnoteOffset + nNo,
318 rFootnoteInfo.m_nFootnoteOffset + nNoNo,
319 rFootnote.GetNumStr() );
320 ++nNo;
321 if (!IsFootnoteDeleted(rIDRA, *pTextFootnote))
322 {
323 ++nNoNo;
324 }
325 }
326 }
327 if( nFootnoteIdx >= size() )
328 break; // ok, everything is updated
329 nNo = 1;
330 // sw_redlinehide: this means the numbers are layout dependent in chapter case
331 if (!pLayout || sw::IsParaPropsNode(*pLayout, *rOutlNds[ n ]->GetTextNode()))
332 {
333 nNoNo = 1;
334 }
335 }
336 }
337
338 for (nNo = 1, nNoNo = 1; nFootnoteIdx < size(); ++nFootnoteIdx)
339 {
340 // Endnotes are per-document
341 pTextFootnote = (*this)[ nFootnoteIdx ];
342 const SwFormatFootnote &rFootnote = pTextFootnote->GetFootnote();
343 if( !rFootnote.IsEndNote() && rFootnote.GetNumStr().isEmpty() &&
345 {
346 pTextFootnote->SetNumber(
347 rFootnoteInfo.m_nFootnoteOffset + nNo,
348 rFootnoteInfo.m_nFootnoteOffset + nNoNo,
349 rFootnote.GetNumStr() );
350 ++nNo;
351 if (!IsFootnoteDeleted(rIDRA, *pTextFootnote))
352 {
353 ++nNoNo;
354 }
355 }
356 }
357 }
358
359 // We use bool here, so that we also iterate through the Endnotes with a chapter setting.
360 const bool bEndNoteOnly = FTNNUM_DOC != rFootnoteInfo.m_eNum;
361 sal_uInt16 nFootnoteNo = 1;
362 sal_uInt16 nEndnoteNo = 1;
363 sal_uInt16 nFootnoteNoHidden = 1;
364 sal_uInt16 nEndnoteNoHidden = 1;
365 for( size_t nPos = 0; nPos < size(); ++nPos )
366 {
367 pTextFootnote = (*this)[ nPos ];
368 const SwFormatFootnote &rFootnote = pTextFootnote->GetFootnote();
369 if( rFootnote.GetNumStr().isEmpty() )
370 {
371 std::pair<sal_uInt16, sal_uInt16> nSectNo = aNumArr.ChkNumber(rIDRA, *pTextFootnote);
372 if (!nSectNo.first && (rFootnote.IsEndNote() || !bEndNoteOnly))
373 {
374 if (rFootnote.IsEndNote())
375 {
376 nSectNo.first = rEndInfo.m_nFootnoteOffset + nEndnoteNo;
377 ++nEndnoteNo;
378 nSectNo.second = rEndInfo.m_nFootnoteOffset + nEndnoteNoHidden;
379 if (!IsFootnoteDeleted(rIDRA, *pTextFootnote))
380 {
381 ++nEndnoteNoHidden;
382 }
383 }
384 else
385 {
386 nSectNo.first = rFootnoteInfo.m_nFootnoteOffset + nFootnoteNo;
387 ++nFootnoteNo;
388 nSectNo.second = rFootnoteInfo.m_nFootnoteOffset + nFootnoteNoHidden;
389 if (!IsFootnoteDeleted(rIDRA, *pTextFootnote))
390 {
391 ++nFootnoteNoHidden;
392 }
393 }
394 }
395
396 if (nSectNo.first)
397 {
398 pTextFootnote->SetNumber(nSectNo.first, nSectNo.second, rFootnote.GetNumStr());
399 }
400 }
401 }
402
403 if (pLayout && FTNNUM_PAGE == rFootnoteInfo.m_eNum)
404 for( auto aLayout : aAllLayouts )
405 aLayout->UpdateFootnoteNums();
406}
407
408SwTextFootnote* SwFootnoteIdxs::SeekEntry( const SwNode& rPos, size_t* pFndPos ) const
409{
410 SwNodeOffset nIdx = rPos.GetIndex();
411
412 size_t nO = size();
413 size_t nU = 0;
414 if( nO > 0 )
415 {
416 nO--;
417 while( nU <= nO )
418 {
419 const size_t nM = nU + ( nO - nU ) / 2;
420 SwNodeOffset nNdIdx = SwTextFootnote_GetIndex( (*this)[ nM ] );
421 if( nNdIdx == nIdx )
422 {
423 if( pFndPos )
424 *pFndPos = nM;
425 return (*this)[ nM ];
426 }
427 else if( nNdIdx < nIdx )
428 nU = nM + 1;
429 else if( nM == 0 )
430 {
431 if( pFndPos )
432 *pFndPos = nU;
433 return nullptr;
434 }
435 else
436 nO = nM - 1;
437 }
438 }
439 if( pFndPos )
440 *pFndPos = nU;
441 return nullptr;
442}
443
445 const SwTextFootnote& rTextFootnote )
446{
447 sal_uInt16 nWh = rTextFootnote.GetFootnote().IsEndNote() ?
448 sal_uInt16(RES_END_AT_TXTEND) : sal_uInt16(RES_FTN_AT_TXTEND);
449 const SwSectionNode* pNd = rTextFootnote.GetTextNode().FindSectionNode();
450 while( pNd )
451 {
452 sal_uInt16 nVal = static_cast<const SwFormatFootnoteEndAtTextEnd&>(pNd->GetSection().GetFormat()->
453 GetFormatAttr( nWh )).GetValue();
455 break;
456 pNd = pNd->StartOfSectionNode()->FindSectionNode();
457 }
458
459 return pNd;
460}
461
462std::pair<sal_uInt16, sal_uInt16> SwUpdFootnoteEndNtAtEnd::GetNumber(
463 IDocumentRedlineAccess const& rIDRA,
464 const SwTextFootnote& rTextFootnote,
465 const SwSectionNode& rNd )
466{
467 std::pair<sal_uInt16, sal_uInt16> nRet(0, 0);
468 sal_uInt16 nWh;
469 std::vector<const SwSectionNode*>* pArr;
470 std::vector<std::pair<sal_uInt16, sal_uInt16>> *pNum;
471 if( rTextFootnote.GetFootnote().IsEndNote() )
472 {
473 pArr = &m_aEndSections;
474 pNum = &m_aEndNumbers;
475 nWh = RES_END_AT_TXTEND;
476 }
477 else
478 {
479 pArr = &m_aFootnoteSections;
480 pNum = &m_aFootnoteNumbers;
481 nWh = RES_FTN_AT_TXTEND;
482 }
483
484 for( size_t n = pArr->size(); n; )
485 if( (*pArr)[ --n ] == &rNd )
486 {
487 nRet.first = ++((*pNum)[ n ].first);
488 if (!IsFootnoteDeleted(rIDRA, rTextFootnote))
489 {
490 ++((*pNum)[ n ].second);
491 }
492 nRet.second = ((*pNum)[ n ].second);
493 break;
494 }
495
496 if (!nRet.first)
497 {
498 pArr->push_back( &rNd );
499 sal_uInt16 const tmp = static_cast<const SwFormatFootnoteEndAtTextEnd&>(
500 rNd.GetSection().GetFormat()->
501 GetFormatAttr( nWh )).GetOffset();
502 nRet.first = tmp + 1;
503 nRet.second = tmp + 1;
504 pNum->push_back( nRet );
505 }
506 return nRet;
507}
508
509std::pair<sal_uInt16, sal_uInt16> SwUpdFootnoteEndNtAtEnd::ChkNumber(
510 IDocumentRedlineAccess const& rIDRA,
511 const SwTextFootnote& rTextFootnote)
512{
513 const SwSectionNode* pSectNd = FindSectNdWithEndAttr( rTextFootnote );
514 return pSectNd
515 ? GetNumber(rIDRA, rTextFootnote, *pSectNd)
516 : std::pair<sal_uInt16, sal_uInt16>(0, 0);
517}
518
519/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
virtual const SwRootFrame * GetCurrentLayout() const =0
virtual const SwRangeRedline * GetRedline(const SwPosition &rPos, SwRedlineTable::size_type *pFndPos) const =0
Definition: doc.hxx:194
bool IsInReading() const
Definition: doc.hxx:962
const SwFootnoteInfo & GetFootnoteInfo() const
Definition: doc.hxx:638
o3tl::sorted_vector< SwRootFrame * > GetAllLayouts()
Definition: doclay.cxx:1687
SwNodes & GetNodes()
Definition: doc.hxx:417
IDocumentRedlineAccess const & getIDocumentRedlineAccess() const
Definition: doc.cxx:341
IDocumentLayoutAccess const & getIDocumentLayoutAccess() const
Definition: doc.cxx:411
const SwEndNoteInfo & GetEndNoteInfo() const
Definition: doc.hxx:640
sal_uInt16 m_nFootnoteOffset
Definition: ftninfo.hxx:47
void UpdateAllFootnote()
Definition: ftnidx.cxx:266
SwTextFootnote * SeekEntry(const SwNode &rNd, size_t *pPos=nullptr) const
Definition: ftnidx.cxx:408
void UpdateFootnote(const SwNode &rStt)
Definition: ftnidx.cxx:59
SwFootnoteNum m_eNum
Definition: ftninfo.hxx:98
SfxPoolItem subclass that is a wrapper around an SwFootnoteEndPosEnum, i.e.
Definition: fmtftntx.hxx:43
sal_uInt16 GetNumber() const
Definition: fmtftn.hxx:71
const OUString & GetNumStr() const
Definition: fmtftn.hxx:70
bool IsEndNote() const
Definition: fmtftn.hxx:73
Base class of the Writer document model elements.
Definition: node.hxx:98
SwNodeOffset GetIndex() const
Definition: node.hxx:312
SwDoc & GetDoc()
Definition: node.hxx:233
SwSectionNode * FindSectionNode()
Search section node, in which it is.
Definition: ndsect.cxx:981
const SwStartNode * StartOfSectionNode() const
Definition: node.hxx:153
const SwOutlineNodes & GetOutLineNds() const
Array of all OutlineNodes.
Definition: ndarr.hxx:240
SwNode & GetEndOfExtras() const
This is the last EndNode of a special section.
Definition: ndarr.hxx:163
SwNode & GetEndOfContent() const
Regular ContentSection (i.e. the BodyText).
Definition: ndarr.hxx:165
const SwPosition * GetMark() const
Definition: pam.hxx:263
const SwPosition * GetPoint() const
Definition: pam.hxx:261
RedlineType GetType(sal_uInt16 nPos=0) const
Definition: docredln.cxx:1940
vector_type::size_type size_type
Definition: docary.hxx:222
The root element of a Writer document layout.
Definition: rootfrm.hxx:82
const SwSection & GetSection() const
Definition: node.hxx:588
SwSectionFormat * GetFormat()
Definition: section.hxx:337
const SwFormatFootnote & GetFootnote() const
Definition: txatbase.hxx:208
sal_Int32 GetStart() const
Definition: txatbase.hxx:88
void SetNumber(sal_uInt16 nNumber, sal_uInt16 nNumberRLHidden, const OUString &sNumStr)
Definition: atrftn.cxx:357
const SwTextNode & GetTextNode() const
Definition: txtftn.hxx:70
std::vector< const SwSectionNode * > m_aEndSections
Definition: ftnidx.hxx:55
static const SwSectionNode * FindSectNdWithEndAttr(const SwTextFootnote &rTextFootnote)
Definition: ftnidx.cxx:444
std::pair< sal_uInt16, sal_uInt16 > GetNumber(IDocumentRedlineAccess const &, const SwTextFootnote &rTextFootnote, const SwSectionNode &rNd)
Definition: ftnidx.cxx:462
std::vector< std::pair< sal_uInt16, sal_uInt16 > > m_aFootnoteNumbers
Definition: ftnidx.hxx:56
std::pair< sal_uInt16, sal_uInt16 > ChkNumber(IDocumentRedlineAccess const &, const SwTextFootnote &rTextFootnote)
Definition: ftnidx.cxx:509
std::vector< std::pair< sal_uInt16, sal_uInt16 > > m_aEndNumbers
Definition: ftnidx.hxx:56
std::vector< const SwSectionNode * > m_aFootnoteSections
Definition: ftnidx.hxx:55
size_type size() const
@ FTNEND_ATTXTEND_OWNNUMANDFMT
-""- and with own numberformat
Definition: fmtftntx.hxx:33
@ FTNEND_ATTXTEND_OWNNUMSEQ
-""- and with own number sequence
Definition: fmtftntx.hxx:32
#define SwTextFootnote_GetIndex(pFIdx)
Definition: ftnidx.hxx:35
@ FTNNUM_PAGE
Definition: ftninfo.hxx:87
@ FTNNUM_DOC
Definition: ftninfo.hxx:87
@ FTNNUM_CHAPTER
Definition: ftninfo.hxx:87
constexpr TypedWhichId< SwFormatEndAtTextEnd > RES_END_AT_TXTEND(118)
constexpr TypedWhichId< SwFormatFootnoteAtTextEnd > RES_FTN_AT_TXTEND(117)
sal_Int64 n
sal_uInt16 nPos
Dialog to specify the properties of date form field.
bool IsFootnoteDeleted(IDocumentRedlineAccess const &rIDRA, SwTextFootnote const &rTextFootnote)
Definition: ftnidx.cxx:37
bool IsParaPropsNode(SwRootFrame const &rLayout, SwTextNode const &rNode)
Definition: txtfrm.cxx:313
const char GetValue[]
bool operator()(SwTextFootnote *const &lhs, SwTextFootnote *const &rhs) const
Definition: ftnidx.cxx:52
Marks a position in the document model.
Definition: pam.hxx:37
size_t pos