24#include <bookmark.hxx>
40#include <rtl/ustring.hxx>
48#include <libxml/xmlstring.h>
49#include <libxml/xmlwriter.h>
57std::vector<::sw::mark::MarkBase*>::const_iterator
const&
69 : m_pIter(rOther.m_pIter)
80 : m_pIter(std::move(rOther.m_pIter))
86 m_pIter = std::move(rOther.m_pIter);
111 return *m_pIter == *rOther.
m_pIter;
116 return *m_pIter != *rOther.
m_pIter;
120 : m_pIter(
std::in_place)
161 return *m_pIter - *rOther.
m_pIter;
171 return *m_pIter < *rOther.
m_pIter;
175 return *m_pIter > *rOther.
m_pIter;
179 return *m_pIter <= *rOther.
m_pIter;
183 return *m_pIter >= *rOther.
m_pIter;
189 bool lcl_GreaterThan(
const SwPosition& rPos,
const SwNode& rNdIdx, std::optional<sal_Int32> oContentIdx )
191 return oContentIdx.has_value()
198 bool lcl_Lower(
const SwPosition& rPos,
const SwNode& rNdIdx, std::optional<sal_Int32> oContentIdx )
201 || ( oContentIdx.has_value()
206 bool lcl_MarkOrderingByStart(const ::sw::mark::MarkBase *
const pFirst,
207 const ::sw::mark::MarkBase *
const pSecond)
209 SwPosition const& rFirstStart(pFirst->GetMarkStart());
210 SwPosition const& rSecondStart(pSecond->GetMarkStart());
211 if (rFirstStart.GetNode() != rSecondStart.GetNode())
213 return rFirstStart.GetNode() < rSecondStart.GetNode();
215 const sal_Int32 nFirstContent = rFirstStart.GetContentIndex();
216 const sal_Int32 nSecondContent = rSecondStart.GetContentIndex();
217 if (nFirstContent != 0 || nSecondContent != 0)
219 return nFirstContent < nSecondContent;
223 if ((pCRFirst ==
nullptr) == (pCRSecond ==
nullptr))
227 return pCRFirst !=
nullptr;
230 bool lcl_MarkOrderingByEnd(const ::sw::mark::MarkBase *
const pFirst,
231 const ::sw::mark::MarkBase *
const pSecond)
233 return pFirst->GetMarkEnd() < pSecond->GetMarkEnd();
236 void lcl_InsertMarkSorted(MarkManager::container_t& io_vMarks,
244 &lcl_MarkOrderingByStart),
248 void lcl_PositionFromContentNode(
249 std::optional<SwPosition>& rFoundPos,
253 rFoundPos.emplace(*pContentNode, bAtEnd ? pContentNode->
Len() : 0);
260 void lcl_FindExpelPosition(
261 std::optional<SwPosition>& rFoundPos,
267 bool bPosAtEndOfNode =
false;
268 if ( pNode ==
nullptr)
272 bPosAtEndOfNode =
false;
274 if ( pNode ==
nullptr )
278 bPosAtEndOfNode =
true;
280 if ( pNode !=
nullptr )
282 lcl_PositionFromContentNode( rFoundPos, pNode, bPosAtEndOfNode );
286 rFoundPos = rOtherPosition;
289 struct CompareIMarkStartsBefore
305 struct CompareIMarkStartsAfter
315 IMark* lcl_getMarkAfter(
const MarkManager::container_t& rMarks,
const SwPosition& rPos,
318 auto const pMarkAfter = upper_bound(
322 CompareIMarkStartsAfter());
323 if(pMarkAfter == rMarks.end())
325 if (bLoop && rMarks.begin() != rMarks.end())
326 return *rMarks.begin();
333 IMark* lcl_getMarkBefore(
const MarkManager::container_t& rMarks,
const SwPosition& rPos,
337 MarkManager::container_t vCandidates;
339 auto const pCandidatesEnd = upper_bound(
343 CompareIMarkStartsAfter());
344 vCandidates.reserve(pCandidatesEnd - rMarks.begin());
349 back_inserter(vCandidates),
350 [&rPos] (const ::sw::mark::MarkBase *
const pMark) {
return !(pMark->GetMarkEnd() < rPos); } );
352 if(vCandidates.empty())
354 if (bLoop && rMarks.begin() != rMarks.end())
355 return *(rMarks.end() - 1);
360 return *max_element(vCandidates.begin(), vCandidates.end(), &lcl_MarkOrderingByEnd);
363 bool lcl_FixCorrectedMark(
364 const bool bChangedPos,
365 const bool bChangedOPos,
375 if ( ( bChangedPos || bChangedOPos )
376 && io_pMark->IsExpanded()
377 && io_pMark->GetOtherMarkPos().GetNode().FindTableBoxStartNode() !=
378 io_pMark->GetMarkPos().GetNode().FindTableBoxStartNode() )
382 io_pMark->SetMarkPos( io_pMark->GetOtherMarkPos() );
384 io_pMark->ClearOtherMarkPos();
385 DdeBookmark *
const pDdeBkmk =
dynamic_cast< DdeBookmark*
>(io_pMark);
386 if ( pDdeBkmk !=
nullptr
387 && pDdeBkmk->IsServer() )
389 pDdeBkmk->SetRefObject(
nullptr);
396 bool lcl_MarkEqualByStart(const ::sw::mark::MarkBase *
const pFirst,
397 const ::sw::mark::MarkBase *
const pSecond)
399 return !lcl_MarkOrderingByStart(pFirst, pSecond) &&
400 !lcl_MarkOrderingByStart(pSecond, pFirst);
403 MarkManager::container_t::const_iterator lcl_FindMark(
404 MarkManager::container_t& rMarks,
405 const ::sw::mark::MarkBase *
const pMarkToFind)
407 auto ppCurrentMark = lower_bound(
408 rMarks.begin(), rMarks.end(),
409 pMarkToFind, &lcl_MarkOrderingByStart);
413 while (ppCurrentMark != rMarks.end() && lcl_MarkEqualByStart(*ppCurrentMark, pMarkToFind))
415 if(*ppCurrentMark == pMarkToFind)
417 return MarkManager::container_t::const_iterator(std::move(ppCurrentMark));
426 MarkManager::container_t::const_iterator lcl_FindMarkAtPos(
427 MarkManager::container_t& rMarks,
431 for (
auto ppCurrentMark = lower_bound(
432 rMarks.begin(), rMarks.end(),
434 CompareIMarkStartsBefore());
435 ppCurrentMark != rMarks.end();
440 if((*ppCurrentMark)->GetMarkStart() > rPos)
444 return MarkManager::container_t::const_iterator(std::move(ppCurrentMark));
452 MarkManager::container_t::const_iterator lcl_FindMarkByName(
453 const OUString& rName,
454 const MarkManager::container_t::const_iterator& ppMarksBegin,
455 const MarkManager::container_t::const_iterator& ppMarksEnd)
463 void lcl_DebugMarks(MarkManager::container_t
const& rMarks)
465#if OSL_DEBUG_LEVEL > 0
466 SAL_INFO(
"sw.core", rMarks.size() <<
" Marks");
467 for (
auto ppMark = rMarks.begin();
468 ppMark != rMarks.end();
471 IMark* pMark = *ppMark;
472 const SwPosition*
const pStPos = &pMark->GetMarkStart();
473 const SwPosition*
const pEndPos = &pMark->GetMarkEnd();
479 typeid(*pMark).name() <<
" " <<
485 assert(std::is_sorted(rMarks.begin(), rMarks.end(), lcl_MarkOrderingByStart));
491 const std::type_info*
const pMarkTypeInfo = &
typeid(rBkmk);
493 if(*pMarkTypeInfo ==
typeid(UnoMark))
495 else if(*pMarkTypeInfo ==
typeid(DdeBookmark))
497 else if(*pMarkTypeInfo ==
typeid(
Bookmark))
499 else if(*pMarkTypeInfo ==
typeid(CrossRefHeadingBookmark))
501 else if(*pMarkTypeInfo ==
typeid(CrossRefNumItemBookmark))
503 else if(*pMarkTypeInfo ==
typeid(AnnotationMark))
505 else if(*pMarkTypeInfo ==
typeid(TextFieldmark))
507 else if(*pMarkTypeInfo ==
typeid(CheckboxFieldmark))
509 else if(*pMarkTypeInfo ==
typeid(DropDownFieldmark))
511 else if(*pMarkTypeInfo ==
typeid(DateFieldmark))
513 else if(*pMarkTypeInfo ==
typeid(NavigatorReminder))
517 assert(
false &&
"IDocumentMarkAccess::GetType(..)"
518 " - unknown MarkType. This needs to be fixed!");
525 return "__RefHeading__";
550 MarkManager::MarkManager(
SwDoc& rDoc)
552 , m_pLastActiveFieldmark(nullptr)
556 const OUString& rName,
561#if OSL_DEBUG_LEVEL > 0
583 SAL_WARN(
"sw.core",
"MarkManager::makeMark(..)"
584 " - refusing to create mark on non-textnode");
591 SAL_WARN(
"sw.core",
"MarkManager::makeMark(..)"
592 " - refusing to create duplicate CrossRefBookmark");
603 SAL_WARN(
"sw.core",
"MarkManager::makeMark(..)"
604 " - invalid range on point fieldmark");
612 SAL_WARN(
"sw.core",
"MarkManager::makeMark(..)"
613 " - invalid range on fieldmark, different nodes array sections");
622 SAL_WARN(
"sw.core",
"MarkManager::makeMark(..)"
623 " - invalid range on fieldmark, overlaps existing fieldmark or meta-field");
628 std::unique_ptr<::sw::mark::MarkBase> pMark;
632 pMark = std::make_unique<TextFieldmark>(rPaM, rName);
635 pMark = std::make_unique<CheckboxFieldmark>(rPaM, rName);
638 pMark = std::make_unique<DropDownFieldmark>(rPaM, rName);
641 pMark = std::make_unique<DateFieldmark>(rPaM);
644 pMark = std::make_unique<NavigatorReminder>(rPaM);
647 pMark = std::make_unique<Bookmark>(rPaM,
vcl::KeyCode(), rName);
650 pMark = std::make_unique<DdeBookmark>(rPaM);
653 pMark = std::make_unique<CrossRefHeadingBookmark>(rPaM,
vcl::KeyCode(), rName);
656 pMark = std::make_unique<CrossRefNumItemBookmark>(rPaM,
vcl::KeyCode(), rName);
659 pMark = std::make_unique<UnoMark>(rPaM);
662 pMark = std::make_unique<AnnotationMark>( rPaM, rName );
665 assert(pMark &&
"MarkManager::makeMark(..) - Mark was not created.");
667 if(pMark->GetMarkPos() != pMark->GetMarkStart())
712 SwPaM const tmp(pMark->GetMarkPos(), pMark->GetOtherMarkPos());
716 SAL_INFO(
"sw.core",
"--- makeType ---");
724 return pMark.release();
729 const OUString& rName,
730 const OUString& rType,
753 sw::mark::IFieldmark* pFieldMark =
dynamic_cast<sw::mark::IFieldmark*
>( pMark );
755 pFieldMark->SetFieldname( rType );
769 const OUString& rName,
770 const OUString& rType)
799 sw::mark::IFieldmark* pFieldMark =
dynamic_cast<sw::mark::IFieldmark*
>( pMark );
801 pFieldMark->SetFieldname( rType );
823 return *ppExistingMark;
824 const SwPaM aPaM(aPos);
830 const OUString& rName )
841 "<MarkManager::repositionMark(..)>"
842 " - Mark is not in my doc.");
865 const OUString& rNewName )
868 "<MarkManager::renameMark(..)>"
869 " - Mark is not in my doc.");
870 if ( io_pMark->
GetName() == rNewName )
876 const OUString sOldName(pMarkBase->GetName());
877 pMarkBase->SetName(rNewName);
884 std::make_unique<SwUndoRenameBookmark>(sOldName, rNewName,
m_rDoc));
895 const sal_Int32 nOffset)
897 const SwNode*
const pOldNode = &rOldNode;
900 bool isSortingNeeded =
false;
910 bool bChangedPos =
false;
915 isSortingNeeded =
true;
917 bool bChangedOPos =
false;
924 isSortingNeeded =
true;
927 isSortingNeeded |= lcl_FixCorrectedMark(bChangedPos, bChangedOPos, pMark);
934 SAL_INFO(
"sw.core",
"correctMarksAbsolute");
940 const SwNode*
const pOldNode = &rOldNode;
943 bool isSortingNeeded =
false;
950 bool bChangedPos =
false, bChangedOPos =
false;
961 isSortingNeeded =
true;
976 isSortingNeeded |= lcl_FixCorrectedMark(bChangedPos, bChangedOPos, pMark);
983 SAL_INFO(
"sw.core",
"correctMarksRelative");
989 bool const isReplace,
992 std::optional<sal_Int32> oStartContentIdx,
993 std::optional<sal_Int32> oEndContentIdx,
994 bool & rbIsPosInRange,
995 bool & rbIsOtherPosInRange)
1006 rbIsPosInRange = lcl_GreaterThan(pMark->
GetMarkPos(), rStt, oStartContentIdx)
1007 && lcl_Lower(pMark->
GetMarkPos(), rEnd, oEndContentIdx);
1012 if ( oEndContentIdx.has_value()
1015 && ( ( rbIsOtherPosInRange
1023 rbIsPosInRange =
true;
1024 rbIsOtherPosInRange =
true;
1028 && (rbIsOtherPosInRange
1033 bool bDeleteMark =
true;
1040 bDeleteMark = &rStt != &rEnd;
1044 bDeleteMark = rbIsOtherPosInRange
1046 || !oStartContentIdx.has_value()
1068 bool bIsPosInRange(
false);
1069 bool bIsOtherPosInRange(
false);
1070 bool const bDeleteMark =
isDeleteMark(*ppMark, isReplace,
1072 bIsPosInRange, bIsOtherPosInRange);
1085 std::vector<SaveBookmark>* pSaveBkmk,
1086 std::optional<sal_Int32> oStartContentIdx,
1087 std::optional<sal_Int32> oEndContentIdx )
1089 std::vector<const_iterator_t> vMarksToDelete;
1090 bool bIsSortingNeeded =
false;
1093 bool bMarksMoved =
false;
1095 bool bMarksSkipDeletion =
false;
1104 bool bIsPosInRange(
false);
1105 bool bIsOtherPosInRange(
false);
1106 bool const bDeleteMark =
isDeleteMark(pMark,
false, rStt, rEnd, oStartContentIdx, oEndContentIdx, bIsPosInRange, bIsOtherPosInRange);
1109 && ( bIsOtherPosInRange
1116 pSaveBkmk->push_back(
SaveBookmark( *pMark, rStt, oStartContentIdx ) );
1118 vMarksToDelete.emplace_back(ppMark);
1122 bMarksSkipDeletion =
true;
1125 else if ( bIsPosInRange != bIsOtherPosInRange )
1130 std::optional< SwPosition > oNewPos;
1131 if ( oEndContentIdx )
1140 bool bMoveMark =
true;
1151 bMoveMark = pSaveBkmk ==
nullptr;
1160 if ( bIsPosInRange )
1167 bIsSortingNeeded |= lcl_FixCorrectedMark( bIsPosInRange, bIsOtherPosInRange, pMark );
1176 std::vector< std::unique_ptr<ILazyDeleter> > vDelay;
1177 vDelay.reserve(vMarksToDelete.size());
1183 if ( !vMarksToDelete.empty() && bMarksMoved )
1191 for ( std::vector< const_iterator_t >::reverse_iterator pppMark = vMarksToDelete.rbegin();
1192 pppMark != vMarksToDelete.rend();
1195 vDelay.push_back(
deleteMark(*pppMark, pSaveBkmk !=
nullptr));
1201 if (bIsSortingNeeded || (bMarksMoved && bMarksSkipDeletion))
1206 SAL_INFO(
"sw.core",
"deleteMarks");
1217 LazyFieldmarkDeleter(Fieldmark *
const pMark,
SwDoc& rDoc,
bool const isMoveNodes)
1222 virtual ~LazyFieldmarkDeleter()
override
1241 LazyDdeBookmarkDeleter(DdeBookmark *
const pDdeBookmark,
SwDoc& rDoc)
1244 assert(pDdeBookmark);
1246 virtual ~LazyDdeBookmarkDeleter()
override
1254 std::unique_ptr<IDocumentMarkAccess::ILazyDeleter>
1257 std::unique_ptr<ILazyDeleter> ret;
1260 IMark* pMark = *ppMark;
1279 "<MarkManager::deleteMark(..)> - Bookmark not found in Bookmark container.");
1294 "<MarkManager::deleteMark(..)> - Bookmark not found in Bookmark container.");
1311 ret.reset(
new LazyFieldmarkDeleter(
dynamic_cast<Fieldmark*
>(pMark),
m_rDoc, isMoveNodes));
1316 "<MarkManager::deleteMark(..)> - Fieldmark not found in Fieldmark container.");
1325 "<MarkManager::deleteMark(..)> - Annotation Mark not found in Annotation Mark container.");
1339 std::advance(aI, std::distance<container_t::const_iterator>(aI, ppMark.
get()));
1343 ret.reset(
new LazyDdeBookmarkDeleter(pDdeBookmark,
m_rDoc));
1358 "<MarkManager::deleteMark(..)>"
1359 " - Mark is not in my doc.");
1362 auto [it, endIt] = equal_range(
1366 CompareIMarkStartsBefore());
1367 for ( ; it != endIt; ++it)
1428 return std::upper_bound(
1432 CompareIMarkStartsAfter());
1437 auto const pFieldmark = find_if(
1441 return pMark->GetMarkStart() == rPos
1443 || (pMark->GetMarkEnd().GetContentIndex() == rPos.GetContentIndex() + 1
1444 && pMark->GetMarkEnd().GetNode() == rPos.GetNode());
1448 :
dynamic_cast<IFieldmark*
>(*pFieldmark);
1453 auto itFieldmark = find_if(
1456 [&rPos] (const ::sw::mark::MarkBase *
const pMark) { return pMark->IsCoveringPosition(rPos); } );
1459 auto pFieldmark(*itFieldmark);
1461 && (**itFieldmark).GetMarkStart() <= rPos; ++itFieldmark)
1463 if (rPos < (**itFieldmark).GetMarkEnd()
1464 && (pFieldmark->GetMarkStart() < (**itFieldmark).GetMarkStart()
1465 || (**itFieldmark).GetMarkEnd() < pFieldmark->GetMarkEnd()))
1467 pFieldmark = *itFieldmark;
1470 return dynamic_cast<IFieldmark*
>(pFieldmark);
1477 { return pMark->IsCoveringPosition(rPos); });
1487 for (; it !=
m_vBookmarks.end() && (*it)->GetMarkStart() <= rPos; ++it)
1490 if (rPos < (*it)->GetMarkEnd()
1492 || (*it)->GetMarkEnd() < pBookmark->
GetMarkEnd()))
1510 bool bActualChange =
false;
1514 bActualChange =
true;
1521 bActualChange =
true;
1528 bActualChange =
true;
1537 OUString
sName = pFieldmark->GetName();
1538 SwPaM const aPaM(pFieldmark->GetMarkStart());
1550 SwPaM aNewPaM(pFieldmark->GetMarkStart(), pFieldmark->GetMarkEnd());
1583 pNewActiveFieldmark = &rFormField;
1595 if(pNewActiveFieldmark)
1621 pDrowDown->SendLOKShowMessage(pViewShell);
1627 bool bDropDownFieldExist =
false;
1630 IFieldmark *pMark =
dynamic_cast<IFieldmark*
>(*aIter);
1633 bDropDownFieldExist =
true;
1638 if (bDropDownFieldExist)
1653 std::vector<IFieldmark*> aRet;
1663 IFieldmark *pMark =
dynamic_cast<IFieldmark*
>(pI);
1670 aRet.push_back(pMark);
1677 {
return dynamic_cast<IFieldmark*
>(lcl_getMarkAfter(
m_vFieldmarks, rPos, bLoop)); }
1680 {
return dynamic_cast<IFieldmark*
>(lcl_getMarkBefore(
m_vFieldmarks, rPos, bLoop)); }
1705 auto const pAnnotationMark = find_if(
1708 [&rPos] (const ::sw::mark::MarkBase *
const pMark) { return pMark->IsCoveringPosition(rPos); } );
1711 return *pAnnotationMark;
1717 return std::upper_bound(
1721 CompareIMarkStartsAfter());
1726 const OUString& rName,
1749 const OUString & rBookmarkName = (**iter).GetName();
1751 if ( rBookmarkName.startsWith(
"__Annotation__") &&
1758 const SwPaM aPam((**iter).GetMarkStart(), (**pMark).GetMarkEnd());
1777 OSL_ENSURE(rName.getLength(),
1778 "<MarkManager::getUniqueMarkName(..)> - a name should be proposed");
1781 OUString
newName = rName +
"MailMergeMark"
1800 OUString aPrefix =
SwResId(STR_MARK_COPY).replaceFirst(
"%1", rName);
1803 sTmp = aPrefix + OUString::number(nCnt);
1848 (void)xmlTextWriterStartElement(pWriter, BAD_CAST(
"MarkManager"));
1849 for (
const auto & rContainer : aContainers)
1851 if (!rContainer.pContainer->empty())
1853 (void)xmlTextWriterStartElement(pWriter, BAD_CAST(rContainer.pName));
1854 for (
auto it = rContainer.pContainer->begin(); it != rContainer.pContainer->end(); ++it)
1855 (*it)->dumpAsXml(pWriter);
1856 (void)xmlTextWriterEndElement(pWriter);
1859 (void)xmlTextWriterEndElement(pWriter);
1866 bool lcl_Greater(
const SwPosition& rPos,
const SwNode& rNdIdx, std::optional<sal_Int32> oContentIdx )
1868 return rPos.
GetNode() > rNdIdx ||
1880SaveBookmark::SaveBookmark(
1883 std::optional<sal_Int32> oContentIdx)
1896 ::sfx2::Metadatable
const*
const pMetadatable(
1897 dynamic_cast< ::sfx2::Metadatable const*
>(pBookmark));
1929 std::optional<sal_Int32> oContentIdx)
1931 SwPaM aPam(rNewPos);
1937 SAL_WARN(
"sw",
"trying to sent content index, but point node is not a content node");
1953 SAL_WARN(
"sw",
"trying to sent content index, but mark node is not a content node");
1983 ::sfx2::Metadatable *
const pMeta(
1984 dynamic_cast< ::sfx2::Metadatable*
>(pBookmark));
1985 assert(pMeta &&
"metadata undo, but not metadatable?");
1998 std::vector<SaveBookmark> * pSaveBkmk,
1999 std::optional<sal_Int32> oStartContentIdx,
2000 std::optional<sal_Int32> oEndContentIdx)
2004 || (&rStt == &rEnd && (!oStartContentIdx || !oEndContentIdx || *oStartContentIdx >= *oEndContentIdx)))
2019 auto [pRStt, pREnd] = pRedl->StartEnd();
2021 if( lcl_Greater( *pRStt, rStt, oStartContentIdx ) && lcl_Lower( *pRStt, rEnd, oEndContentIdx ))
2023 pRStt->Assign( rEnd );
2024 if( oEndContentIdx )
2025 pRStt->SetContent( *oEndContentIdx );
2035 pRStt->Assign(rStt);
2044 pRStt->AssignEndIndex( *pCNd );
2047 if( lcl_Greater( *pREnd, rStt, oStartContentIdx ) && lcl_Lower( *pREnd, rEnd, oEndContentIdx ))
2049 pREnd->Assign( rStt );
2050 if( oStartContentIdx )
2051 pREnd->SetContent( *oStartContentIdx );
2061 pREnd->Assign(rEnd);
2070 pREnd->AssignEndIndex( *pCNd );
2081 bool isInsideFieldmarkCommand(
false);
2082 bool isInsideFieldmarkResult(
false);
2087 isInsideFieldmarkResult =
true;
2091 isInsideFieldmarkCommand =
true;
2094 if (!cursor.
Left(1))
2099 return InsertText(
nPos, nLen, isInsideFieldmarkCommand, isInsideFieldmarkResult);
virtual bool DeleteAndJoin(SwPaM &, SwDeleteFlags flags=SwDeleteFlags::Default)=0
complete delete of a given PaM
wrapper iterator: wraps iterator of implementation while hiding MarkBase class; only IMark instances ...
bool operator>=(iterator const &rOther) const
iterator & operator+=(difference_type)
iterator & operator=(iterator const &rOther)
::sw::mark::IMark * operator*() const
std::ptrdiff_t difference_type
bool operator!=(iterator const &rOther) const
value_type operator[](difference_type) const
iterator operator+(difference_type) const
bool operator==(iterator const &rOther) const
bool operator<(iterator const &rOther) const
std::vector<::sw::mark::MarkBase * >::const_iterator const & get() const
bool operator>(iterator const &rOther) const
bool operator<=(iterator const &rOther) const
iterator operator-(difference_type) const
iterator & operator-=(difference_type)
std::optional< std::vector<::sw::mark::MarkBase * >::const_iterator > m_pIter
Provides access to the marks of a document.
virtual ::sw::mark::IFieldmark * getFieldmarkFor(const SwPosition &pos) const =0
static SW_DLLPUBLIC OUString GetCrossRefHeadingBookmarkNamePrefix()
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.
virtual void deleteMarks(const SwNode &rStt, const SwNode &rEnd, std::vector< ::sw::mark::SaveBookmark > *pSaveBkmk, std::optional< sal_Int32 > oStartContentIdx, std::optional< sal_Int32 > oEndContentIdx)=0
Deletes marks in a range.
static void DeleteFieldmarkCommand(::sw::mark::IFieldmark const &rMark)
@ CROSSREF_NUMITEM_BOOKMARK
@ CROSSREF_HEADING_BOOKMARK
static SW_DLLPUBLIC bool IsLegalPaMForCrossRefHeadingBookmark(const SwPaM &rPaM)
static SW_DLLPUBLIC MarkType GetType(const ::sw::mark::IMark &rMark)
Returns the MarkType used to create the mark.
virtual const SwRedlineTable & GetRedlineTable() const =0
virtual void SetEnableSetModified(bool bEnableSetModified)=0
virtual void SetModified()=0
Must be called manually at changes of format.
virtual bool IsEnableSetModified() const =0
virtual sal_Int32 Len() const
SwCursor * GetCursor(bool bMakeTableCursor=true) const
Return pointer to the current shell cursor.
bool Left(sal_uInt16 nCnt)
IDocumentState const & getIDocumentState() const
IDocumentContentOperations const & getIDocumentContentOperations() const
IDocumentUndoRedo & GetIDocumentUndoRedo()
IDocumentRedlineAccess const & getIDocumentRedlineAccess() const
IDocumentMarkAccess * getIDocumentMarkAccess()
bool IsInMailMerge() const
Window class for the Writer edit area, this is the one handling mouse and keyboard events and doing t...
Marks a node in the document model.
Base class of the Writer document model elements.
SwTextNode * GetTextNode()
Inline methods from Node.hxx.
SwNodeOffset GetIndex() const
SwNodes & GetNodes()
Node is in which nodes-array/doc?
bool IsContentNode() const
const SwStartNode * StartOfSectionNode() const
SwContentNode * GetContentNode()
static SwContentNode * GoPrevious(SwNodeIndex *)
SwContentNode * GoNext(SwNodeIndex *) const
PaM is Point and Mark: a selection of the document model.
const SwPosition * GetMark() const
virtual void SetMark()
Unless this is called, the getter method of Mark will return Point.
bool ContainsPosition(const SwPosition &rPos) const
const SwPosition * End() const
const SwPosition * GetPoint() const
const SwPosition * Start() const
bool HasMark() const
A PaM marks a selection if Point and Mark are distinct positions.
SwTextNode is a paragraph in the document model.
virtual sal_Int32 Len() const override
SfxViewShell * GetSfxViewShell() const
void sendLOKDeleteCallback()
Fieldmark representing a checkbox form field.
Fieldmark representing a date form field.
Fieldmark representing a drop-down form field.
static void SendLOKHideMessage(const SfxViewShell *pViewShell)
OUString GetFieldname() const override
virtual void Hide(bool hide)=0
virtual const vcl::KeyCode & GetKeyCode() const =0
virtual void SetHideCondition(const OUString &)=0
virtual void SetShortName(const OUString &)=0
virtual void SetKeyCode(const vcl::KeyCode &)=0
virtual const OUString & GetHideCondition() const =0
virtual const OUString & GetShortName() const =0
virtual bool IsHidden() const =0
virtual const SwPosition & GetOtherMarkPos() const =0
virtual bool IsExpanded() const =0
virtual const SwPosition & GetMarkEnd() const =0
virtual const SwPosition & GetMarkStart() const =0
virtual const OUString & GetName() const =0
virtual const SwPosition & GetMarkPos() const =0
virtual void SetOtherMarkPos(const SwPosition &rNewPos)
const OUString & GetName() const override
virtual auto InvalidateFrames() -> void
bool IsExpanded() const override
virtual void SetMarkPos(const SwPosition &rNewPos)
virtual void ClearOtherMarkPos()
SwPosition & GetMarkPos() const override
SwPosition & GetMarkStart() const override
SwPosition & GetOtherMarkPos() const override
virtual sw::mark::IMark * getAnnotationMarkFor(const SwPosition &rPos) const override
virtual ::sw::mark::IMark * getOneInnermostBookmarkFor(const SwPosition &rPos) const override
Get the innermost bookmark that contains rPos.
virtual sal_Int32 getAllMarksCount() const override
returns the number of marks.
virtual const_iterator_t getFieldmarksBegin() const override
returns a STL-like random access iterator to the begin of the sequence of fieldmarks.
virtual bool renameMark(::sw::mark::IMark *io_pMark, const OUString &rNewName) override
Renames an existing Mark, if possible.
virtual void restoreAnnotationMarks(bool bDelete=true) override
virtual const_iterator_t findAnnotationBookmark(const OUString &rName) const override
std::vector< sw::mark::MarkBase * > container_t
virtual void ClearFieldActivation() override
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::IMark * makeAnnotationBookmark(const SwPaM &rPaM, const OUString &rName, IDocumentMarkAccess::MarkType eMark, sw::mark::InsertMode eMode, SwPosition const *pSepPos=nullptr) override
virtual void correctMarksAbsolute(const SwNode &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
virtual void clearAllMarks() override
Clear (deletes) all marks.
virtual const_iterator_t getAllMarksBegin() const override
returns a STL-like random access iterator to the begin of the sequence of marks.
OUString getUniqueMarkName(const OUString &rName) const
virtual const_iterator_t getAnnotationMarksBegin() const override
virtual void assureSortedMarkContainers() const override
virtual sw::mark::IFieldmark * makeNoTextFieldBookmark(const SwPaM &rPaM, const OUString &rName, const OUString &rType) override
void LOKUpdateActiveField(const SfxViewShell *pViewShell)
sw::mark::FieldmarkWithDropDownButton * m_pLastActiveFieldmark
virtual std::vector<::sw::mark::IFieldmark * > getNoTextFieldmarksIn(const SwPaM &rPaM) const override
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 findFirstAnnotationStartsAfter(const SwPosition &rPos) const override
Finds the first mark that is starting after.
virtual sw::mark::IFieldmark * getFieldmarkAfter(const SwPosition &rPos, bool bLoop) const override
container_t m_vFieldmarks
virtual const_iterator_t getAnnotationMarksEnd() const override
MarkBasenameMapUniqueOffset_t m_aMarkBasenameMapUniqueOffset
virtual ::sw::mark::IFieldmark * changeFormFieldmarkType(::sw::mark::IFieldmark *pFieldmark, const OUString &rNewType) override
virtual void correctMarksRelative(const SwNode &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...
virtual void repositionMark(::sw::mark::IMark *io_pMark, const SwPaM &rPaM) override
Moves an existing mark to a new selection and performs needed updates.
virtual void deleteMarks(const SwNode &rStt, const SwNode &rEnd, std::vector< ::sw::mark::SaveBookmark > *pSaveBkmk, std::optional< sal_Int32 > oStartContentIdx, std::optional< sal_Int32 > oEndContentIdx) override
Deletes marks in a range.
virtual sw::mark::IFieldmark * makeFieldBookmark(const SwPaM &rPaM, const OUString &rName, const OUString &rType, SwPosition const *pSepPos=nullptr) override
virtual ::sw::mark::IMark * getMarkForTextNode(const SwTextNode &rTextNode, IDocumentMarkAccess::MarkType eMark) override
Returns a mark in the document for a paragraph.
virtual sal_Int32 getFieldmarksCount() const override
returns the number of IFieldmarks.
void dumpAsXml(xmlTextWriterPtr pWriter) const
virtual sw::mark::IMark * makeAnnotationMark(const SwPaM &rPaM, const OUString &rName) override
virtual const_iterator_t findFirstBookmarkStartsAfter(const SwPosition &rPos) const override
Finds the first mark that is starting after.
virtual ::sw::mark::IFieldmark * getFieldmarkFor(const SwPosition &rPos) 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
virtual const_iterator_t findAnnotationMark(const OUString &rName) const override
virtual ::sw::mark::IFieldmark * getDropDownFor(const SwPosition &rPos) const override
virtual sw::mark::IFieldmark * getFieldmarkBefore(const SwPosition &rPos, bool bLoop) const override
virtual void deleteFieldmarkAt(const SwPosition &rPos) override
virtual const_iterator_t findBookmark(const OUString &rName) const override
Finds a bookmark by name.
virtual sal_Int32 getAnnotationMarksCount() const override
virtual bool isBookmarkDeleted(SwPaM const &rPaM, bool isReplace) const override
check if the selection would delete a BOOKMARK
virtual const_iterator_t getBookmarksEnd() const override
returns a STL-like random access iterator to the end of the sequence of IBookmarks.
virtual std::unique_ptr< ILazyDeleter > deleteMark(const const_iterator_t &ppMark, bool isMoveNodes) override
Deletes a mark.
virtual const_iterator_t getAllMarksEnd() const override
returns a STL-like random access iterator to the end of the sequence of marks.
virtual sal_Int32 getBookmarksCount() const override
returns the number of IBookmarks.
container_t m_vAnnotationMarks
virtual const_iterator_t getBookmarksBegin() const override
returns a STL-like random access iterator to the begin of the sequence the IBookmarks.
virtual const_iterator_t findMark(const OUString &rName) const override
Finds a mark by name.
void SetInDoc(SwDoc *pDoc, const SwNode &, std::optional< sal_Int32 > oContentIdx=std::nullopt)
IDocumentMarkAccess::MarkType m_eOrigBkmType
OUString m_aHideCondition
std::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndo
TOOLS_DLLPUBLIC OString DateTimeToOString(const DateTime &rDateTime)
struct _xmlTextWriter * xmlTextWriterPtr
virtual OUString GetName() const override
constexpr OUStringLiteral S_ANNOTATION_BOOKMARK
std::unique_ptr< Fieldmark > m_pFieldmark
void DelBookmarks(SwNode &rStt, const SwNode &rEnd, std::vector< SaveBookmark > *pSaveBkmk, std::optional< sal_Int32 > oStartContentIdx, std::optional< sal_Int32 > oEndContentIdx)
std::unique_ptr< DdeBookmark > m_pDdeBookmark
#define SAL_WARN(area, stream)
#define SAL_INFO(area, stream)
OUString newName(std::u16string_view aNewPrefix, std::u16string_view aOldPrefix, std::u16string_view old_Name)
bool IsFieldmarkOverlap(SwPaM const &rPaM)
check if rPaM is valid range of new fieldmark
SwPosition FindFieldSep(IFieldmark const &rMark)
return position of the CH_TXT_ATR_FIELDSEP for rMark
static bool isDeleteMark(::sw::mark::MarkBase const *const pMark, bool const isReplace, SwNode const &rStt, SwNode const &rEnd, std::optional< sal_Int32 > oStartContentIdx, std::optional< sal_Int32 > oEndContentIdx, bool &rbIsPosInRange, bool &rbIsOtherPosInRange)
Dialog to specify the properties of date form field.
void UpdateFramesForAddDeleteRedline(SwDoc &rDoc, SwPaM const &rPam)
InsertText MakeInsertText(SwTextNode &rNode, const sal_Int32 nPos, const sal_Int32 nLen)
constexpr SwNodeOffset NODE_OFFSET_MAX(SAL_MAX_INT32)
constexpr OUStringLiteral ODF_FORMCHECKBOX
constexpr OUStringLiteral ODF_FORMDATE
constexpr OUStringLiteral ODF_FORMDROPDOWN
bool CheckNodesRange(const SwNode &rStt, const SwNode &rEnd, bool bChkSection)
Check if the given range is inside one of the defined top-level sections.
To avoid recursive calls of deleteMark, the removal of dummy characters of fieldmarks has to be delay...
Marks a position in the document model.
void Adjust(SwNodeOffset nDelta)
Adjust node position, and resets content position to zero.
void SetContent(sal_Int32 nContentIndex)
Set content index, only valid to call this if the position points to a SwContentNode subclass.
SwNodeOffset GetNodeIndex() const
sal_Int32 GetContentIndex() const
void AdjustContent(sal_Int32 nDelta)
Adjust content index, only valid to call this if the position points to a SwContentNode subclass.
SwDoc & GetDoc() const
Returns the document this position is in.
OUString SwResId(TranslateId aId)