24 #include <bookmark.hxx>
40 #include <rtl/ustring.hxx>
48 #include <libxml/xmlstring.h>
49 #include <libxml/xmlwriter.h>
56 std::vector<::sw::mark::MarkBase*>::const_iterator
const&
68 : m_pIter(rOther.m_pIter)
79 : m_pIter(
std::move(rOther.m_pIter))
85 m_pIter = std::move(rOther.m_pIter);
110 return *m_pIter == *rOther.
m_pIter;
115 return *m_pIter != *rOther.
m_pIter;
119 : m_pIter(
std::in_place)
160 return *m_pIter - *rOther.
m_pIter;
170 return *m_pIter < *rOther.
m_pIter;
174 return *m_pIter > *rOther.
m_pIter;
178 return *m_pIter <= *rOther.
m_pIter;
182 return *m_pIter >= *rOther.
m_pIter;
190 return pIdx !=
nullptr
191 ? ( rPos.
nNode > rNdIdx
192 || ( rPos.
nNode == rNdIdx
194 : rPos.
nNode >= rNdIdx;
199 return rPos.
nNode < rNdIdx
201 && rPos.
nNode == rNdIdx
205 bool lcl_MarkOrderingByStart(const ::sw::mark::MarkBase *
const pFirst,
206 const ::sw::mark::MarkBase *
const pSecond)
208 auto const& rFirstStart(pFirst->GetMarkStart());
209 auto const& rSecondStart(pSecond->GetMarkStart());
210 if (rFirstStart.nNode != rSecondStart.nNode)
212 return rFirstStart.nNode < rSecondStart.nNode;
214 const sal_Int32 nFirstContent = rFirstStart.nContent.
GetIndex();
215 const sal_Int32 nSecondContent = rSecondStart.nContent.GetIndex();
216 if (nFirstContent != 0 || nSecondContent != 0)
218 return nFirstContent < nSecondContent;
220 auto *
const pCRFirst (dynamic_cast<::sw::mark::CrossRefBookmark const*>(pFirst));
221 auto *
const pCRSecond(dynamic_cast<::sw::mark::CrossRefBookmark const*>(pSecond));
222 if ((pCRFirst ==
nullptr) == (pCRSecond ==
nullptr))
226 return pCRFirst !=
nullptr;
229 bool lcl_MarkOrderingByEnd(const ::sw::mark::MarkBase *
const pFirst,
230 const ::sw::mark::MarkBase *
const pSecond)
232 return pFirst->GetMarkEnd() < pSecond->GetMarkEnd();
235 void lcl_InsertMarkSorted(MarkManager::container_t& io_vMarks,
243 &lcl_MarkOrderingByStart),
247 std::unique_ptr<SwPosition> lcl_PositionFromContentNode(
251 std::unique_ptr<SwPosition> pResult(
new SwPosition(*pContentNode));
252 pResult->nContent.Assign(pContentNode, bAtEnd ? pContentNode->
Len() : 0);
260 std::unique_ptr<SwPosition> lcl_FindExpelPosition(
266 bool bPosAtEndOfNode =
false;
267 if ( pNode ==
nullptr)
271 bPosAtEndOfNode =
false;
273 if ( pNode ==
nullptr )
277 bPosAtEndOfNode =
true;
279 if ( pNode !=
nullptr )
281 return lcl_PositionFromContentNode( pNode, bPosAtEndOfNode );
284 return std::make_unique<SwPosition>(rOtherPosition);
287 struct CompareIMarkStartsBefore
303 struct CompareIMarkStartsAfter
313 IMark* lcl_getMarkAfter(
const MarkManager::container_t& rMarks,
const SwPosition& rPos)
315 auto const pMarkAfter = upper_bound(
319 CompareIMarkStartsAfter());
320 if(pMarkAfter == rMarks.end())
325 IMark* lcl_getMarkBefore(
const MarkManager::container_t& rMarks,
const SwPosition& rPos)
328 MarkManager::container_t vCandidates;
330 auto const pCandidatesEnd = upper_bound(
334 CompareIMarkStartsAfter());
335 vCandidates.reserve(pCandidatesEnd - rMarks.begin());
340 back_inserter(vCandidates),
341 [&rPos] (const ::sw::mark::MarkBase *
const pMark) {
return !(pMark->
GetMarkEnd() < rPos); } );
343 if(vCandidates.empty())
return nullptr;
345 return *max_element(vCandidates.begin(), vCandidates.end(), &lcl_MarkOrderingByEnd);
348 bool lcl_FixCorrectedMark(
349 const bool bChangedPos,
350 const bool bChangedOPos,
360 if ( ( bChangedPos || bChangedOPos )
361 && io_pMark->IsExpanded()
362 && io_pMark->GetOtherMarkPos().nNode.GetNode().FindTableBoxStartNode() !=
363 io_pMark->GetMarkPos().nNode.GetNode().FindTableBoxStartNode() )
367 io_pMark->SetMarkPos( io_pMark->GetOtherMarkPos() );
369 io_pMark->ClearOtherMarkPos();
370 DdeBookmark *
const pDdeBkmk =
dynamic_cast< DdeBookmark*
>(io_pMark);
371 if ( pDdeBkmk !=
nullptr
372 && pDdeBkmk->IsServer() )
374 pDdeBkmk->SetRefObject(
nullptr);
381 bool lcl_MarkEqualByStart(const ::sw::mark::MarkBase *
const pFirst,
382 const ::sw::mark::MarkBase *
const pSecond)
384 return !lcl_MarkOrderingByStart(pFirst, pSecond) &&
385 !lcl_MarkOrderingByStart(pSecond, pFirst);
388 MarkManager::container_t::const_iterator lcl_FindMark(
389 MarkManager::container_t& rMarks,
390 const ::sw::mark::MarkBase *
const pMarkToFind)
392 auto ppCurrentMark = lower_bound(
393 rMarks.begin(), rMarks.end(),
394 pMarkToFind, &lcl_MarkOrderingByStart);
398 while (ppCurrentMark != rMarks.end() && lcl_MarkEqualByStart(*ppCurrentMark, pMarkToFind))
400 if(*ppCurrentMark == pMarkToFind)
402 return MarkManager::container_t::const_iterator(std::move(ppCurrentMark));
411 MarkManager::container_t::const_iterator lcl_FindMarkAtPos(
412 MarkManager::container_t& rMarks,
416 for (
auto ppCurrentMark = lower_bound(
417 rMarks.begin(), rMarks.end(),
419 CompareIMarkStartsBefore());
420 ppCurrentMark != rMarks.end();
425 if((*ppCurrentMark)->GetMarkStart() > rPos)
429 return MarkManager::container_t::const_iterator(std::move(ppCurrentMark));
437 MarkManager::container_t::const_iterator lcl_FindMarkByName(
438 const OUString& rName,
439 const MarkManager::container_t::const_iterator& ppMarksBegin,
440 const MarkManager::container_t::const_iterator& ppMarksEnd)
448 void lcl_DebugMarks(MarkManager::container_t
const& rMarks)
450 #if OSL_DEBUG_LEVEL > 0
451 SAL_INFO(
"sw.core", rMarks.size() <<
" Marks");
452 for (
auto ppMark = rMarks.begin();
453 ppMark != rMarks.end();
456 IMark* pMark = *ppMark;
457 const SwPosition*
const pStPos = &pMark->GetMarkStart();
458 const SwPosition*
const pEndPos = &pMark->GetMarkEnd();
464 typeid(*pMark).name() <<
" " <<
470 assert(std::is_sorted(rMarks.begin(), rMarks.end(), lcl_MarkOrderingByStart));
476 const std::type_info*
const pMarkTypeInfo = &
typeid(rBkmk);
478 if(*pMarkTypeInfo ==
typeid(UnoMark))
480 else if(*pMarkTypeInfo ==
typeid(DdeBookmark))
482 else if(*pMarkTypeInfo ==
typeid(
Bookmark))
484 else if(*pMarkTypeInfo ==
typeid(CrossRefHeadingBookmark))
486 else if(*pMarkTypeInfo ==
typeid(CrossRefNumItemBookmark))
488 else if(*pMarkTypeInfo ==
typeid(AnnotationMark))
490 else if(*pMarkTypeInfo ==
typeid(TextFieldmark))
492 else if(*pMarkTypeInfo ==
typeid(CheckboxFieldmark))
494 else if(*pMarkTypeInfo ==
typeid(DropDownFieldmark))
496 else if(*pMarkTypeInfo ==
typeid(DateFieldmark))
498 else if(*pMarkTypeInfo ==
typeid(NavigatorReminder))
502 assert(
false &&
"IDocumentMarkAccess::GetType(..)"
503 " - unknown MarkType. This needs to be fixed!");
510 return "__RefHeading__";
530 pam.GetDoc().getIDocumentContentOperations().DeleteAndJoin(pam);
535 MarkManager::MarkManager(
SwDoc& rDoc)
537 , m_pLastActiveFieldmark(nullptr)
541 const OUString& rName,
546 #if OSL_DEBUG_LEVEL > 0
568 SAL_WARN(
"sw.core",
"MarkManager::makeMark(..)"
569 " - refusing to create mark on non-textnode");
576 SAL_WARN(
"sw.core",
"MarkManager::makeMark(..)"
577 " - refusing to create duplicate CrossRefBookmark");
588 SAL_WARN(
"sw.core",
"MarkManager::makeMark(..)"
589 " - invalid range on point fieldmark");
597 SAL_WARN(
"sw.core",
"MarkManager::makeMark(..)"
598 " - invalid range on fieldmark, different nodes array sections");
607 SAL_WARN(
"sw.core",
"MarkManager::makeMark(..)"
608 " - invalid range on fieldmark, overlaps existing fieldmark or meta-field");
613 std::unique_ptr<::sw::mark::MarkBase> pMark;
617 pMark = std::make_unique<TextFieldmark>(rPaM, rName);
620 pMark = std::make_unique<CheckboxFieldmark>(rPaM);
623 pMark = std::make_unique<DropDownFieldmark>(rPaM);
626 pMark = std::make_unique<DateFieldmark>(rPaM);
629 pMark = std::make_unique<NavigatorReminder>(rPaM);
632 pMark = std::make_unique<Bookmark>(rPaM,
vcl::KeyCode(), rName);
635 pMark = std::make_unique<DdeBookmark>(rPaM);
638 pMark = std::make_unique<CrossRefHeadingBookmark>(rPaM,
vcl::KeyCode(), rName);
641 pMark = std::make_unique<CrossRefNumItemBookmark>(rPaM,
vcl::KeyCode(), rName);
644 pMark = std::make_unique<UnoMark>(rPaM);
647 pMark = std::make_unique<AnnotationMark>( rPaM, rName );
650 assert(pMark &&
"MarkManager::makeMark(..) - Mark was not created.");
652 if(pMark->GetMarkPos() != pMark->GetMarkStart())
660 pMark->InitDoc(
m_rDoc, eMode, pSepPos);
697 SwPaM const tmp(pMark->GetMarkPos(), pMark->GetOtherMarkPos());
701 SAL_INFO(
"sw.core",
"--- makeType ---");
709 return pMark.release();
714 const OUString& rName,
715 const OUString& rType,
754 const OUString& rName,
755 const OUString& rType)
807 auto const ppExistingMark = lcl_FindMarkAtPos(
m_vBookmarks, aPos, eType);
809 return *ppExistingMark;
810 const SwPaM aPaM(aPos);
816 const OUString& rName )
827 "<MarkManager::repositionMark(..)>"
828 " - Mark is not in my doc.");
835 pMarkBase->SetMarkPos(*(rPaM.
GetPoint()));
837 pMarkBase->SetOtherMarkPos(*(rPaM.
GetMark()));
839 pMarkBase->ClearOtherMarkPos();
841 if(pMarkBase->GetMarkPos() != pMarkBase->GetMarkStart())
844 pMarkBase->InvalidateFrames();
851 const OUString& rNewName )
854 "<MarkManager::renameMark(..)>"
855 " - Mark is not in my doc.");
856 if ( io_pMark->
GetName() == rNewName )
860 if (::
sw::mark::MarkBase* pMarkBase = dynamic_cast< ::sw::mark::MarkBase* >(io_pMark))
862 const OUString sOldName(pMarkBase->GetName());
863 pMarkBase->SetName(rNewName);
865 if (dynamic_cast< ::sw::mark::Bookmark* >(io_pMark))
870 std::make_unique<SwUndoRenameBookmark>(sOldName, rNewName,
m_rDoc));
881 const sal_Int32 nOffset)
886 bool isSortingNeeded =
false;
896 bool bChangedPos =
false;
901 isSortingNeeded =
true;
903 bool bChangedOPos =
false;
910 isSortingNeeded =
true;
913 isSortingNeeded |= lcl_FixCorrectedMark(bChangedPos, bChangedOPos, pMark);
920 SAL_INFO(
"sw.core",
"correctMarksAbsolute");
929 bool isSortingNeeded =
false;
936 bool bChangedPos =
false, bChangedOPos =
false;
943 if (dynamic_cast< ::sw::mark::CrossRefBookmark *>(pMark))
947 isSortingNeeded =
true;
962 isSortingNeeded |= lcl_FixCorrectedMark(bChangedPos, bChangedOPos, pMark);
969 SAL_INFO(
"sw.core",
"correctMarksRelative");
979 bool & rbIsPosInRange,
980 bool & rbIsOtherPosInRange)
991 rbIsPosInRange = lcl_GreaterThan(pMark->
GetMarkPos(), rStt, pSttIdx)
992 && lcl_Lower(pMark->
GetMarkPos(), rEnd, pEndIdx);
997 if ( pEndIdx !=
nullptr
998 && ( ( rbIsOtherPosInRange
1006 rbIsPosInRange =
true;
1007 rbIsOtherPosInRange =
true;
1011 && (rbIsOtherPosInRange
1016 bool bDeleteMark =
true;
1023 bDeleteMark = rStt != rEnd;
1027 bDeleteMark = rbIsOtherPosInRange
1029 || pSttIdx ==
nullptr
1051 bool bIsPosInRange(
false);
1052 bool bIsOtherPosInRange(
false);
1054 rStart.nNode, rEnd.nNode, &rStart.nContent, &rEnd.nContent,
1055 bIsPosInRange, bIsOtherPosInRange);
1068 std::vector<SaveBookmark>* pSaveBkmk,
1072 std::vector<const_iterator_t> vMarksToDelete;
1073 bool bIsSortingNeeded =
false;
1076 bool bMarksMoved =
false;
1078 bool bMarksSkipDeletion =
false;
1087 bool bIsPosInRange(
false);
1088 bool bIsOtherPosInRange(
false);
1089 bool const bDeleteMark =
isDeleteMark(pMark, rStt, rEnd, pSttIdx, pEndIdx, bIsPosInRange, bIsOtherPosInRange);
1092 && ( bIsOtherPosInRange
1099 pSaveBkmk->push_back(
SaveBookmark( *pMark, rStt, pSttIdx ) );
1101 vMarksToDelete.emplace_back(ppMark);
1105 bMarksSkipDeletion =
true;
1108 else if ( bIsPosInRange != bIsOtherPosInRange )
1113 std::unique_ptr< SwPosition > pNewPos;
1115 if ( pEndIdx !=
nullptr )
1117 pNewPos = std::make_unique< SwPosition >( rEnd, *pEndIdx );
1126 bool bMoveMark =
true;
1137 bMoveMark = pSaveBkmk ==
nullptr;
1146 if ( bIsPosInRange )
1153 bIsSortingNeeded |= lcl_FixCorrectedMark( bIsPosInRange, bIsOtherPosInRange, pMark );
1162 std::vector< std::unique_ptr<ILazyDeleter> > vDelay;
1163 vDelay.reserve(vMarksToDelete.size());
1169 if ( !vMarksToDelete.empty() && bMarksMoved )
1177 for ( std::vector< const_iterator_t >::reverse_iterator pppMark = vMarksToDelete.rbegin();
1178 pppMark != vMarksToDelete.rend();
1181 vDelay.push_back(
deleteMark(*pppMark, pSaveBkmk !=
nullptr));
1187 if (bIsSortingNeeded || (bMarksMoved && bMarksSkipDeletion))
1192 SAL_INFO(
"sw.core",
"deleteMarks");
1203 LazyFieldmarkDeleter(Fieldmark *
const pMark,
SwDoc& rDoc,
bool const isMoveNodes)
1204 : m_pFieldmark(pMark), m_rDoc(rDoc), m_isMoveNodes(isMoveNodes)
1206 assert(m_pFieldmark);
1208 virtual ~LazyFieldmarkDeleter()
override
1216 m_pFieldmark->ReleaseDoc(m_rDoc);
1223 std::unique_ptr<IDocumentMarkAccess::ILazyDeleter>
1226 std::unique_ptr<ILazyDeleter> ret;
1229 IMark* pMark = *ppMark;
1245 "<MarkManager::deleteMark(..)> - Bookmark not found in Bookmark container.");
1262 ret.reset(
new LazyFieldmarkDeleter(dynamic_cast<Fieldmark*>(pMark), m_rDoc, isMoveNodes));
1267 "<MarkManager::deleteMark(..)> - Fieldmark not found in Fieldmark container.");
1276 "<MarkManager::deleteMark(..)> - Annotation Mark not found in Annotation Mark container.");
1293 std::advance(aI, std::distance<container_t::const_iterator>(aI, ppMark.
get()));
1307 "<MarkManager::deleteMark(..)>"
1308 " - Mark is not in my doc.");
1311 auto [it, endIt] = equal_range(
1315 CompareIMarkStartsBefore());
1316 for ( ; it != endIt; ++it)
1332 m_vAllMarks.clear();
1375 return std::upper_bound(
1379 CompareIMarkStartsAfter());
1384 auto const pFieldmark = find_if(
1395 : dynamic_cast<IFieldmark*>(*pFieldmark);
1400 auto itFieldmark = find_if(
1403 [&rPos] (const ::sw::mark::MarkBase *
const pMark) {
return pMark->
IsCoveringPosition(rPos); } );
1406 auto pFieldmark(*itFieldmark);
1408 && (**itFieldmark).GetMarkStart() <= rPos; ++itFieldmark)
1410 if (rPos < (**itFieldmark).GetMarkEnd()
1411 && (pFieldmark->GetMarkStart() < (**itFieldmark).GetMarkStart()
1412 || (**itFieldmark).GetMarkEnd() < pFieldmark->GetMarkEnd()))
1414 pFieldmark = *itFieldmark;
1417 return dynamic_cast<IFieldmark*
>(pFieldmark);
1430 bool bActualChange =
false;
1433 if (!dynamic_cast<::sw::mark::DropDownFieldmark*>(pFieldmark))
1434 bActualChange =
true;
1435 if (!dynamic_cast<::sw::mark::CheckboxFieldmark*>(pFieldmark))
1440 if (!dynamic_cast<::sw::mark::CheckboxFieldmark*>(pFieldmark))
1441 bActualChange =
true;
1442 if (!dynamic_cast<::sw::mark::DropDownFieldmark*>(pFieldmark))
1447 if (!dynamic_cast<::sw::mark::DateFieldmark*>(pFieldmark))
1448 bActualChange =
true;
1449 if (!dynamic_cast<::sw::mark::TextFieldmark*>(pFieldmark))
1463 SwPosition aNewPos (aPaM.GetPoint()->nNode, aPaM.GetPoint()->nContent);
1469 SwPosition aPos (aPaM.GetPoint()->nNode, aPaM.GetPoint()->nContent);
1491 && aPos.nContent.GetIndex() > 0 )
1503 pNewActiveFieldmark = &rFormField;
1515 if(pNewActiveFieldmark)
1541 pDrowDown->SendLOKShowMessage(pViewShell);
1547 bool bDropDownFieldExist =
false;
1553 bDropDownFieldExist =
true;
1558 if (bDropDownFieldExist)
1573 std::vector<IFieldmark*> aRet;
1590 aRet.push_back(pMark);
1625 auto const pAnnotationMark = find_if(
1628 [&rPos] (const ::sw::mark::MarkBase *
const pMark) {
return pMark->
IsCoveringPosition(rPos); } );
1631 return *pAnnotationMark;
1637 return std::upper_bound(
1641 CompareIMarkStartsAfter());
1646 const OUString& rName,
1652 return makeMark( rPaM, sAnnotationBookmarkName, eType, eMode, pSepPos);
1669 const OUString & rBookmarkName = (**iter).GetName();
1671 if ( rBookmarkName.startsWith(
"__Annotation__") &&
1678 const SwPaM aPam((**iter).GetMarkStart(), (**pMark).GetMarkEnd());
1697 OSL_ENSURE(rName.getLength(),
1698 "<MarkManager::getUniqueMarkName(..)> - a name should be proposed");
1701 OUString
newName = rName +
"MailMergeMark"
1722 sTmp = rName + OUString::number(nCnt);
1767 (
void)xmlTextWriterStartElement(pWriter, BAD_CAST(
"MarkManager"));
1768 for (
const auto & rContainer : aContainers)
1770 if (!rContainer.pContainer->empty())
1772 (
void)xmlTextWriterStartElement(pWriter, BAD_CAST(rContainer.pName));
1773 for (
auto it = rContainer.pContainer->begin(); it != rContainer.pContainer->end(); ++it)
1774 (*it)->dumpAsXml(pWriter);
1775 (
void)xmlTextWriterEndElement(pWriter);
1778 (
void)xmlTextWriterEndElement(pWriter);
1798 SaveBookmark::SaveBookmark(
1815 dynamic_cast< ::sfx2::Metadatable const* >(pBookmark));
1861 aPam.GetMark()->nContent.Assign(aPam.GetContentNode(
false),
m_nContent2);
1864 aPam.GetPoint()->nNode +=
m_nNode1;
1869 aPam.GetPoint()->nContent.Assign(aPam.GetContentNode(),
m_nContent1);
1872 && !
CheckNodesRange(aPam.GetPoint()->nNode, aPam.GetMark()->nNode,
true))
1889 dynamic_cast< ::sfx2::Metadatable* >(pBookmark));
1890 assert(pMeta &&
"metadata undo, but not metadatable?");
1903 std::vector<SaveBookmark> * pSaveBkmk,
1909 || (rStt == rEnd && (!pSttIdx || !pEndIdx || pSttIdx->
GetIndex() >= pEndIdx->
GetIndex())))
1925 if( lcl_Greater( *pRStt, rStt, pSttIdx ) && lcl_Lower( *pRStt, rEnd, pEndIdx ))
1927 pRStt->
nNode = rEnd;
1939 pRStt->
nNode = rStt;
1950 if( lcl_Greater( *pREnd, rStt, pSttIdx ) && lcl_Lower( *pREnd, rEnd, pEndIdx ))
1952 pREnd->
nNode = rStt;
1964 pREnd->
nNode = rEnd;
1983 bool isInsideFieldmarkCommand(
false);
1984 bool isInsideFieldmarkResult(
false);
1989 isInsideFieldmarkResult =
true;
1993 isInsideFieldmarkCommand =
true;
1996 if (!cursor.
Left(1))
2001 return SwInsText(nPos, nLen, isInsideFieldmarkCommand, isInsideFieldmarkResult);
virtual sw::mark::IMark * getAnnotationMarkFor(const SwPosition &rPos) const override
virtual sal_Int32 Len() const
static void SendLOKHideMessage(const SfxViewShell *pViewShell)
bool IsInMailMerge() const
virtual const_iterator_t findFirstAnnotationStartsAfter(const SwPosition &rPos) const override
Finds the first mark that is starting after.
virtual sal_Int32 getAllMarksCount() const override
returns the number of marks.
virtual const OUString & GetName() const =0
Marks a position in the document model.
void UpdateFramesForAddDeleteRedline(SwDoc &rDoc, SwPaM const &rPam)
void DelBookmarks(const SwNodeIndex &rStt, const SwNodeIndex &rEnd, std::vector< SaveBookmark > *pSaveBkmk, const SwIndex *pSttIdx, const SwIndex *pEndIdx)
sw::mark::FieldmarkWithDropDownButton * m_pLastActiveFieldmark
constexpr SwNodeOffset NODE_OFFSET_MAX(SAL_MAX_INT32)
virtual const_iterator_t findFirstBookmarkStartsAfter(const SwPosition &rPos) const override
Finds the first mark that is starting after.
virtual void SetFieldname(const OUString &rFieldname)=0
To avoid recursive calls of deleteMark, the removal of dummy characters of fieldmarks has to be delay...
wrapper iterator: wraps iterator of implementation while hiding MarkBase class; only IMark instances ...
std::ptrdiff_t difference_type
virtual sal_Int32 Len() const override
virtual void SetModified()=0
Must be called manually at changes of format.
static SW_DLLPUBLIC MarkType GetType(const ::sw::mark::IMark &rMark)
Returns the MarkType used to create the mark.
container_t m_vFieldmarks
const SwPosition * GetMark() const
OUString getUniqueMarkName(const OUString &rName) const
Provides access to the marks of a document.
bool Left(sal_uInt16 nCnt)
void SetInDoc(SwDoc *pDoc, const SwNodeIndex &, const SwIndex *pIdx=nullptr)
virtual const SwPosition & GetMarkPos() const =0
constexpr OUStringLiteral ODF_FORMDATE
SwPosition FindFieldSep(IFieldmark const &rMark)
return position of the CH_TXT_ATR_FIELDSEP for rMark
virtual ::sw::mark::IFieldmark * getFieldmarkAfter(const SwPosition &rPos) const override
static SwContentNode * GoPrevious(SwNodeIndex *)
OUString newName(std::u16string_view aNewPrefix, const OUString &aOldPrefix, std::u16string_view old_Name)
virtual const_iterator_t getAllMarksBegin() const override
returns a STL-like random access iterator to the begin of the sequence of marks.
void LOKUpdateActiveField(const SfxViewShell *pViewShell)
IDocumentMarkAccess * getIDocumentMarkAccess()
Dialog to specify the properties of date form field.
IDocumentUndoRedo & GetIDocumentUndoRedo()
virtual const_iterator_t getAnnotationMarksBegin() const override
SfxViewShell * GetSfxViewShell() const
virtual const_iterator_t findAnnotationBookmark(const OUString &rName) const override
virtual const_iterator_t getFieldmarksBegin() const override
returns a STL-like random access iterator to the begin of the sequence of fieldmarks.
virtual ::sw::mark::IFieldmark * getFieldmarkFor(const SwPosition &rPos) const override
virtual sw::mark::IFieldmark * makeNoTextFieldBookmark(const SwPaM &rPaM, const OUString &rName, const OUString &rType) override
virtual bool IsExpanded() const override
virtual const_iterator_t getBookmarksEnd() const override
returns a STL-like random access iterator to the end of the sequence of IBookmarks.
virtual const OUString & GetHideCondition() const =0
virtual const OUString & GetName() const override
virtual void clearAllMarks() override
Clear (deletes) all marks.
static SW_DLLPUBLIC OUString GetCrossRefHeadingBookmarkNamePrefix()
static SW_DLLPUBLIC bool IsLegalPaMForCrossRefHeadingBookmark(const SwPaM &rPaM)
bool operator==(iterator const &rOther) const
virtual ::sw::mark::IFieldmark * getFieldmarkAt(const SwPosition &rPos) const override
get Fieldmark for CH_TXT_ATR_FIELDSTART/CH_TXT_ATR_FIELDEND at rPos
virtual ::sw::mark::IFieldmark * getFieldmarkFor(const SwPosition &pos) const =0
virtual ::sw::mark::IMark * makeMark(const SwPaM &rPaM, const OUString &rProposedName, MarkType eMark,::sw::mark::InsertMode eMode, SwPosition const *pSepPos=nullptr)=0
Generates a new mark in the document for a certain selection.
iterator & operator-=(difference_type)
virtual void DoUndo(bool const bDoUndo)=0
Enable/Disable Undo.
void dumpAsXml(xmlTextWriterPtr pWriter) const
bool CheckNodesRange(const SwNodeIndex &rStt, const SwNodeIndex &rEnd, bool bChkSection)
Check if the given range is inside one of the defined top-level sections.
SwNodeOffset GetIndex() const
virtual OUString GetName() const override
virtual void DeregisterFromDoc(SwDoc &rDoc)
virtual bool IsEnableSetModified() const =0
virtual ::sw::mark::IMark * getMarkForTextNode(const SwTextNode &rTextNode, IDocumentMarkAccess::MarkType eMark) override
Returns a mark in the document for a paragraph.
bool operator!=(iterator const &rOther) const
virtual void deleteMarks(const SwNodeIndex &rStt, const SwNodeIndex &rEnd, std::vector< ::sw::mark::SaveBookmark > *pSaveBkmk, const SwIndex *pSttIdx, const SwIndex *pEndIdx) override
Deletes marks in a range.
virtual bool DoesUndo() const =0
Is Undo enabled?
virtual void SetKeyCode(const vcl::KeyCode &)=0
virtual void SetShortName(const OUString &)=0
bool ContainsPosition(const SwPosition &rPos) const
PaM is Point and Mark: a selection of the document model.
virtual void Hide(bool hide)=0
virtual void AppendUndo(std::unique_ptr< SwUndo > pUndo)=0
Add new Undo action.
virtual sal_Int32 getAnnotationMarksCount() const override
virtual ::sw::mark::IMark * makeMark(const SwPaM &rPaM, const OUString &rName, IDocumentMarkAccess::MarkType eMark, sw::mark::InsertMode eMode, SwPosition const *pSepPos=nullptr) override
container_t m_vAnnotationMarks
std::optional< std::vector<::sw::mark::MarkBase * >::const_iterator > m_pIter
virtual void deleteMarks(const SwNodeIndex &rStt, const SwNodeIndex &rEnd, std::vector< ::sw::mark::SaveBookmark > *pSaveBkmk, const SwIndex *pSttIdx, const SwIndex *pEndIdx)=0
Deletes marks in a range.
virtual ::sw::mark::IMark * makeAnnotationBookmark(const SwPaM &rPaM, const OUString &rName, IDocumentMarkAccess::MarkType eMark, sw::mark::InsertMode eMode, SwPosition const *pSepPos=nullptr) override
const SwStartNode * StartOfSectionNode() const
virtual const_iterator_t getFieldmarksEnd() const override
returns a STL-like random access iterator to the end of the sequence of fieldmarks.
virtual const_iterator_t getAnnotationMarksEnd() const override
const SwPosition * GetPoint() const
Window class for the Writer edit area, this is the one handling mouse and keyboard events and doing t...
SwIndex & Assign(SwIndexReg *, sal_Int32)
std::vector< sw::mark::MarkBase * > container_t
virtual void assureSortedMarkContainers() const override
MarkBasenameMapUniqueOffset_t m_aMarkBasenameMapUniqueOffset
SwContentNode * GetContentNode()
bool HasMark() const
A PaM marks a selection if Point and Mark are distinct positions.
virtual const_iterator_t findMark(const OUString &rName) const override
Finds a mark by name.
virtual const OUString & GetShortName() const =0
virtual auto InvalidateFrames() -> void
virtual bool renameMark(::sw::mark::IMark *io_pMark, const OUString &rNewName) override
Renames an existing Mark, if possible.
iterator operator-(difference_type) const
iterator operator+(difference_type) const
Marks a character position inside a document model node.
virtual bool IsCoveringPosition(const SwPosition &rPos) const =0
IDocumentState const & getIDocumentState() const
std::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndo
Marks a node in the document model.
virtual const vcl::KeyCode & GetKeyCode() const =0
std::unique_ptr< Fieldmark > m_pFieldmark
virtual void SetHideCondition(const OUString &)=0
iterator & operator=(iterator const &rOther)
constexpr OUStringLiteral S_ANNOTATION_BOOKMARK
virtual const_iterator_t getAllMarksEnd() const override
returns a STL-like random access iterator to the end of the sequence of marks.
virtual const_iterator_t findAnnotationMark(const OUString &rName) const override
const SwPosition * Start() const
void SetMark(const sw::mark::IMark *pMark)
static bool isDeleteMark(::sw::mark::MarkBase const *const pMark, SwNodeIndex const &rStt, SwNodeIndex const &rEnd, SwIndex const *const pSttIdx, SwIndex const *const pEndIdx, bool &rbIsPosInRange, bool &rbIsOtherPosInRange)
virtual sw::mark::IMark * makeAnnotationMark(const SwPaM &rPaM, const OUString &rName) override
virtual std::unique_ptr< ILazyDeleter > deleteMark(const const_iterator_t &ppMark, bool isMoveNodes) override
Deletes a mark.
virtual SwPosition & GetOtherMarkPos() const override
SwTextNode is a paragraph in the document model.
IDocumentRedlineAccess const & getIDocumentRedlineAccess() const
SwCursor * GetCursor(bool bMakeTableCursor=true) const
Return pointer to the current shell cursor.
virtual sal_Int32 getBookmarksCount() const override
returns the number of IBookmarks.
virtual bool isBookmarkDeleted(SwPaM const &rPaM) const override
check if the selection would delete a BOOKMARK
bool operator<=(iterator const &rOther) const
virtual void correctMarksAbsolute(const SwNodeIndex &rOldNode, const SwPosition &rNewPos, const sal_Int32 nOffset) override
Corrects marks (absolute) This method ignores the previous position of the mark in the paragraph...
virtual void NotifyCursorUpdate(const SwCursorShell &rCursorShell) override
const SwNodes & GetNodes() const
virtual sw::mark::IFieldmark * makeFieldBookmark(const SwPaM &rPaM, const OUString &rName, const OUString &rType, SwPosition const *pSepPos=nullptr) override
#define SAL_INFO(area, stream)
sal_Int32 GetIndex() const
OString DateTimeToOString(const DateTime &rDateTime)
virtual SwPosition & GetMarkPos() const override
bool operator>(iterator const &rOther) const
virtual const_iterator_t findBookmark(const OUString &rName) const override
Finds a bookmark by name.
const SwPosition * End() const
virtual void correctMarksRelative(const SwNodeIndex &rOldNode, const SwPosition &rNewPos, const sal_Int32 nOffset) override
Corrects marks (relative) This method uses the previous position of the mark in the paragraph as offs...
SwDoc & GetDoc() const
Returns the document this position is in.
IDocumentMarkAccess::MarkType m_eOrigBkmType
virtual void SetMarkPos(const SwPosition &rNewPos)
virtual void restoreAnnotationMarks(bool bDelete=true) override
iterator & operator+=(difference_type)
virtual ::sw::mark::IFieldmark * getFieldmarkBefore(const SwPosition &rPos) const override
virtual ::sw::mark::IFieldmark * getDropDownFor(const SwPosition &rPos) const override
virtual const SwPosition & GetMarkEnd() const =0
static void DeleteFieldmarkCommand(::sw::mark::IFieldmark const &rMark)
virtual void deleteFieldmarkAt(const SwPosition &rPos) override
virtual void SetEnableSetModified(bool bEnableSetModified)=0
virtual OUString GetFieldname() const =0
virtual ::sw::mark::IFieldmark * changeFormFieldmarkType(::sw::mark::IFieldmark *pFieldmark, const OUString &rNewType) override
#define SAL_WARN(area, stream)
virtual void ClearFieldActivation() override
constexpr OUStringLiteral ODF_FORMCHECKBOX
struct _xmlTextWriter * xmlTextWriterPtr
virtual const SwPosition & GetMarkStart() const =0
::sw::mark::IMark * operator*() const
virtual void SetOtherMarkPos(const SwPosition &rNewPos)
virtual std::vector<::sw::mark::IFieldmark * > getNoTextFieldmarksIn(const SwPaM &rPaM) const override
virtual const SwRedlineTable & GetRedlineTable() const =0
virtual const_iterator_t getBookmarksBegin() const override
returns a STL-like random access iterator to the begin of the sequence the IBookmarks.
bool IsFieldmarkOverlap(SwPaM const &rPaM)
check if rPaM is valid range of new fieldmark
bool operator<(iterator const &rOther) const
bool operator>=(iterator const &rOther) const
virtual bool IsExpanded() const =0
std::vector<::sw::mark::MarkBase * >::const_iterator const & get() const
constexpr OUStringLiteral ODF_FORMDROPDOWN
value_type operator[](difference_type) const
virtual void repositionMark(::sw::mark::IMark *io_pMark, const SwPaM &rPaM) override
Moves an existing mark to a new selection and performs needed updates.
SwInsText MakeSwInsText(SwTextNode &rNode, sal_Int32 const nPos, sal_Int32 const nLen)
Fieldmark representing a drop-down form field.
SwContentNode * GoNext(SwNodeIndex *) const
virtual bool IsHidden() const =0
OUString m_aHideCondition
virtual OUString GetFieldname() const override
SwTextNode * GetTextNode()
Inline methods from Node.hxx.
virtual const SwPosition & GetOtherMarkPos() const =0
bool m_bDetectedRangeSegmentation false
Base class of the Writer document model elements.