40 #include <rtl/ustring.hxx>
48 #include <libxml/xmlstring.h>
49 #include <libxml/xmlwriter.h>
53 std::vector<::sw::mark::MarkBase*>::const_iterator
const&
60 : m_pIter(new
std::vector<::
sw::mark::MarkBase*>::const_iterator(rIter))
65 : m_pIter(new
std::vector<::
sw::mark::MarkBase*>::const_iterator(*rOther.m_pIter))
71 m_pIter.reset(
new std::vector<::sw::mark::MarkBase*>::const_iterator(*rOther.m_pIter));
76 : m_pIter(
std::move(rOther.m_pIter))
82 m_pIter = std::move(rOther.m_pIter);
111 return *m_pIter == *rOther.
m_pIter;
116 return *m_pIter != *rOther.
m_pIter;
120 : m_pIter(new
std::vector<::
sw::mark::MarkBase*>::const_iterator())
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;
191 return pIdx !=
nullptr
192 ? ( rPos.
nNode > rNdIdx
193 || ( rPos.
nNode == rNdIdx
195 : rPos.
nNode >= rNdIdx;
200 return rPos.
nNode < rNdIdx
202 && rPos.
nNode == rNdIdx
206 bool lcl_MarkOrderingByStart(const ::sw::mark::MarkBase *
const pFirst,
207 const ::sw::mark::MarkBase *
const pSecond)
209 auto const& rFirstStart(pFirst->GetMarkStart());
210 auto const& rSecondStart(pSecond->GetMarkStart());
211 if (rFirstStart.nNode != rSecondStart.nNode)
213 return rFirstStart.nNode < rSecondStart.nNode;
215 const sal_Int32 nFirstContent = rFirstStart.nContent.
GetIndex();
216 const sal_Int32 nSecondContent = rSecondStart.nContent.GetIndex();
217 if (nFirstContent != 0 || nSecondContent != 0)
219 return nFirstContent < nSecondContent;
221 auto *
const pCRFirst (dynamic_cast<::sw::mark::CrossRefBookmark const*>(pFirst));
222 auto *
const pCRSecond(dynamic_cast<::sw::mark::CrossRefBookmark const*>(pSecond));
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 std::unique_ptr<SwPosition> lcl_PositionFromContentNode(
252 std::unique_ptr<SwPosition> pResult(
new SwPosition(*pContentNode));
253 pResult->nContent.Assign(pContentNode, bAtEnd ? pContentNode->
Len() : 0);
261 std::unique_ptr<SwPosition> lcl_FindExpelPosition(
267 bool bPosAtEndOfNode =
false;
268 if ( pNode ==
nullptr)
272 bPosAtEndOfNode =
false;
274 if ( pNode ==
nullptr )
278 bPosAtEndOfNode =
true;
280 if ( pNode !=
nullptr )
282 return lcl_PositionFromContentNode( pNode, bPosAtEndOfNode );
285 return std::make_unique<SwPosition>(rOtherPosition);
288 struct CompareIMarkStartsBefore
304 struct CompareIMarkStartsAfter
314 IMark* lcl_getMarkAfter(
const MarkManager::container_t& rMarks,
const SwPosition& rPos)
316 auto const pMarkAfter = upper_bound(
320 CompareIMarkStartsAfter());
321 if(pMarkAfter == rMarks.end())
326 IMark* lcl_getMarkBefore(
const MarkManager::container_t& rMarks,
const SwPosition& rPos)
329 MarkManager::container_t vCandidates;
331 auto const pCandidatesEnd = upper_bound(
335 CompareIMarkStartsAfter());
336 vCandidates.reserve(pCandidatesEnd - rMarks.begin());
341 back_inserter(vCandidates),
342 [&rPos] (const ::sw::mark::MarkBase *
const pMark) {
return !(pMark->
GetMarkEnd() < rPos); } );
344 if(vCandidates.empty())
return nullptr;
346 return *max_element(vCandidates.begin(), vCandidates.end(), &lcl_MarkOrderingByEnd);
349 bool lcl_FixCorrectedMark(
350 const bool bChangedPos,
351 const bool bChangedOPos,
361 if ( ( bChangedPos || bChangedOPos )
362 && io_pMark->IsExpanded()
363 && io_pMark->GetOtherMarkPos().nNode.GetNode().FindTableBoxStartNode() !=
364 io_pMark->GetMarkPos().nNode.GetNode().FindTableBoxStartNode() )
368 io_pMark->SetMarkPos( io_pMark->GetOtherMarkPos() );
370 io_pMark->ClearOtherMarkPos();
371 DdeBookmark *
const pDdeBkmk =
dynamic_cast< DdeBookmark*
>(io_pMark);
372 if ( pDdeBkmk !=
nullptr
373 && pDdeBkmk->IsServer() )
375 pDdeBkmk->SetRefObject(
nullptr);
382 bool lcl_MarkEqualByStart(const ::sw::mark::MarkBase *
const pFirst,
383 const ::sw::mark::MarkBase *
const pSecond)
385 return !lcl_MarkOrderingByStart(pFirst, pSecond) &&
386 !lcl_MarkOrderingByStart(pSecond, pFirst);
389 MarkManager::container_t::const_iterator lcl_FindMark(
390 MarkManager::container_t& rMarks,
391 const ::sw::mark::MarkBase *
const pMarkToFind)
393 auto ppCurrentMark = lower_bound(
394 rMarks.begin(), rMarks.end(),
395 pMarkToFind, &lcl_MarkOrderingByStart);
399 while (ppCurrentMark != rMarks.end() && lcl_MarkEqualByStart(*ppCurrentMark, pMarkToFind))
401 if(*ppCurrentMark == pMarkToFind)
403 return MarkManager::container_t::const_iterator(std::move(ppCurrentMark));
412 MarkManager::container_t::const_iterator lcl_FindMarkAtPos(
413 MarkManager::container_t& rMarks,
417 for (
auto ppCurrentMark = lower_bound(
418 rMarks.begin(), rMarks.end(),
420 CompareIMarkStartsBefore());
421 ppCurrentMark != rMarks.end();
426 if((*ppCurrentMark)->GetMarkStart() > rPos)
430 return MarkManager::container_t::const_iterator(std::move(ppCurrentMark));
438 MarkManager::container_t::const_iterator lcl_FindMarkByName(
439 const OUString& rName,
440 const MarkManager::container_t::const_iterator& ppMarksBegin,
441 const MarkManager::container_t::const_iterator& ppMarksEnd)
449 void lcl_DebugMarks(MarkManager::container_t
const& rMarks)
451 #if OSL_DEBUG_LEVEL > 0
452 SAL_INFO(
"sw.core", rMarks.size() <<
" Marks");
453 for (
auto ppMark = rMarks.begin();
454 ppMark != rMarks.end();
457 IMark* pMark = *ppMark;
458 const SwPosition*
const pStPos = &pMark->GetMarkStart();
459 const SwPosition*
const pEndPos = &pMark->GetMarkEnd();
465 typeid(*pMark).name() <<
" " <<
471 assert(std::is_sorted(rMarks.begin(), rMarks.end(), lcl_MarkOrderingByStart));
477 const std::type_info*
const pMarkTypeInfo = &
typeid(rBkmk);
479 if(*pMarkTypeInfo ==
typeid(UnoMark))
481 else if(*pMarkTypeInfo ==
typeid(DdeBookmark))
483 else if(*pMarkTypeInfo ==
typeid(
Bookmark))
485 else if(*pMarkTypeInfo ==
typeid(CrossRefHeadingBookmark))
487 else if(*pMarkTypeInfo ==
typeid(CrossRefNumItemBookmark))
489 else if(*pMarkTypeInfo ==
typeid(AnnotationMark))
491 else if(*pMarkTypeInfo ==
typeid(TextFieldmark))
493 else if(*pMarkTypeInfo ==
typeid(CheckboxFieldmark))
495 else if(*pMarkTypeInfo ==
typeid(DropDownFieldmark))
497 else if(*pMarkTypeInfo ==
typeid(DateFieldmark))
499 else if(*pMarkTypeInfo ==
typeid(NavigatorReminder))
503 assert(
false &&
"IDocumentMarkAccess::GetType(..)"
504 " - unknown MarkType. This needs to be fixed!");
511 return "__RefHeading__";
531 pam.GetDoc().getIDocumentContentOperations().DeleteAndJoin(pam);
536 MarkManager::MarkManager(
SwDoc& rDoc)
540 , m_vAnnotationMarks()
542 , m_pLastActiveFieldmark(nullptr)
546 const OUString& rName,
551 #if OSL_DEBUG_LEVEL > 0
573 SAL_WARN(
"sw.core",
"MarkManager::makeMark(..)"
574 " - refusing to create mark on non-textnode");
581 SAL_WARN(
"sw.core",
"MarkManager::makeMark(..)"
582 " - refusing to create duplicate CrossRefBookmark");
593 SAL_WARN(
"sw.core",
"MarkManager::makeMark(..)"
594 " - invalid range on point fieldmark");
602 SAL_WARN(
"sw.core",
"MarkManager::makeMark(..)"
603 " - invalid range on fieldmark, different nodes array sections");
612 SAL_WARN(
"sw.core",
"MarkManager::makeMark(..)"
613 " - invalid range on fieldmark, overlaps existing fieldmark or meta-field");
618 std::unique_ptr<::sw::mark::MarkBase> pMark;
622 pMark = std::make_unique<TextFieldmark>(rPaM, rName);
625 pMark = std::make_unique<CheckboxFieldmark>(rPaM);
628 pMark = std::make_unique<DropDownFieldmark>(rPaM);
631 pMark = std::make_unique<DateFieldmark>(rPaM);
634 pMark = std::make_unique<NavigatorReminder>(rPaM);
637 pMark = std::make_unique<Bookmark>(rPaM,
vcl::KeyCode(), rName);
640 pMark = std::make_unique<DdeBookmark>(rPaM);
643 pMark = std::make_unique<CrossRefHeadingBookmark>(rPaM,
vcl::KeyCode(), rName);
646 pMark = std::make_unique<CrossRefNumItemBookmark>(rPaM,
vcl::KeyCode(), rName);
649 pMark = std::make_unique<UnoMark>(rPaM);
652 pMark = std::make_unique<AnnotationMark>( rPaM, rName );
655 assert(pMark &&
"MarkManager::makeMark(..) - Mark was not created.");
657 if(pMark->GetMarkPos() != pMark->GetMarkStart())
665 pMark->InitDoc(
m_rDoc, eMode, pSepPos);
701 SwPaM const tmp(pMark->GetMarkPos(), pMark->GetOtherMarkPos());
705 SAL_INFO(
"sw.core",
"--- makeType ---");
713 return pMark.release();
718 const OUString& rName,
719 const OUString& rType,
758 const OUString& rName,
759 const OUString& rType)
811 auto const ppExistingMark = lcl_FindMarkAtPos(
m_vBookmarks, aPos, eType);
813 return *ppExistingMark;
814 const SwPaM aPaM(aPos);
820 const OUString& rName )
831 "<MarkManager::repositionMark(..)>"
832 " - Mark is not in my doc.");
839 pMarkBase->SetMarkPos(*(rPaM.
GetPoint()));
841 pMarkBase->SetOtherMarkPos(*(rPaM.
GetMark()));
843 pMarkBase->ClearOtherMarkPos();
845 if(pMarkBase->GetMarkPos() != pMarkBase->GetMarkStart())
848 pMarkBase->InvalidateFrames();
855 const OUString& rNewName )
858 "<MarkManager::renameMark(..)>"
859 " - Mark is not in my doc.");
860 if ( io_pMark->
GetName() == rNewName )
864 if (::
sw::mark::MarkBase* pMarkBase = dynamic_cast< ::sw::mark::MarkBase* >(io_pMark))
866 const OUString sOldName(pMarkBase->GetName());
867 pMarkBase->SetName(rNewName);
869 if (dynamic_cast< ::sw::mark::Bookmark* >(io_pMark))
874 std::make_unique<SwUndoRenameBookmark>(sOldName, rNewName,
m_rDoc));
885 const sal_Int32 nOffset)
890 bool isSortingNeeded =
false;
900 bool bChangedPos =
false;
905 isSortingNeeded =
true;
907 bool bChangedOPos =
false;
914 isSortingNeeded =
true;
917 isSortingNeeded |= lcl_FixCorrectedMark(bChangedPos, bChangedOPos, pMark);
924 SAL_INFO(
"sw.core",
"correctMarksAbsolute");
933 bool isSortingNeeded =
false;
940 bool bChangedPos =
false, bChangedOPos =
false;
947 if (dynamic_cast< ::sw::mark::CrossRefBookmark *>(pMark))
951 isSortingNeeded =
true;
966 isSortingNeeded |= lcl_FixCorrectedMark(bChangedPos, bChangedOPos, pMark);
973 SAL_INFO(
"sw.core",
"correctMarksRelative");
983 bool & rbIsPosInRange,
984 bool & rbIsOtherPosInRange)
995 rbIsPosInRange = lcl_GreaterThan(pMark->
GetMarkPos(), rStt, pSttIdx)
996 && lcl_Lower(pMark->
GetMarkPos(), rEnd, pEndIdx);
1001 if ( pEndIdx !=
nullptr
1002 && ( ( rbIsOtherPosInRange
1010 rbIsPosInRange =
true;
1011 rbIsOtherPosInRange =
true;
1015 && (rbIsOtherPosInRange
1020 bool bDeleteMark =
true;
1027 bDeleteMark = rStt != rEnd;
1031 bDeleteMark = rbIsOtherPosInRange
1033 || pSttIdx ==
nullptr
1055 bool bIsPosInRange(
false);
1056 bool bIsOtherPosInRange(
false);
1058 rStart.nNode, rEnd.nNode, &rStart.nContent, &rEnd.nContent,
1059 bIsPosInRange, bIsOtherPosInRange);
1072 std::vector<SaveBookmark>* pSaveBkmk,
1076 std::vector<const_iterator_t> vMarksToDelete;
1077 bool bIsSortingNeeded =
false;
1080 bool bMarksMoved =
false;
1082 bool bMarksSkipDeletion =
false;
1091 bool bIsPosInRange(
false);
1092 bool bIsOtherPosInRange(
false);
1093 bool const bDeleteMark =
isDeleteMark(pMark, rStt, rEnd, pSttIdx, pEndIdx, bIsPosInRange, bIsOtherPosInRange);
1096 && ( bIsOtherPosInRange
1103 pSaveBkmk->push_back(
SaveBookmark( *pMark, rStt, pSttIdx ) );
1105 vMarksToDelete.emplace_back(ppMark);
1109 bMarksSkipDeletion =
true;
1112 else if ( bIsPosInRange != bIsOtherPosInRange )
1117 std::unique_ptr< SwPosition > pNewPos;
1119 if ( pEndIdx !=
nullptr )
1121 pNewPos = std::make_unique< SwPosition >( rEnd, *pEndIdx );
1130 bool bMoveMark =
true;
1141 bMoveMark = pSaveBkmk ==
nullptr;
1150 if ( bIsPosInRange )
1157 bIsSortingNeeded |= lcl_FixCorrectedMark( bIsPosInRange, bIsOtherPosInRange, pMark );
1166 std::vector< std::unique_ptr<ILazyDeleter> > vDelay;
1167 vDelay.reserve(vMarksToDelete.size());
1173 if ( !vMarksToDelete.empty() && bMarksMoved )
1181 for ( std::vector< const_iterator_t >::reverse_iterator pppMark = vMarksToDelete.rbegin();
1182 pppMark != vMarksToDelete.rend();
1191 if (bIsSortingNeeded || (bMarksMoved && bMarksSkipDeletion))
1196 SAL_INFO(
"sw.core",
"deleteMarks");
1206 LazyFieldmarkDeleter(Fieldmark* pMark,
SwDoc& rDoc)
1207 : m_pFieldmark(pMark), m_rDoc(rDoc)
1211 virtual ~LazyFieldmarkDeleter()
override
1217 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));
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);
1431 bool bActualChange =
false;
1434 if (!dynamic_cast<::sw::mark::DropDownFieldmark*>(pFieldmark))
1435 bActualChange =
true;
1436 if (!dynamic_cast<::sw::mark::CheckboxFieldmark*>(pFieldmark))
1441 if (!dynamic_cast<::sw::mark::CheckboxFieldmark*>(pFieldmark))
1442 bActualChange =
true;
1443 if (!dynamic_cast<::sw::mark::DropDownFieldmark*>(pFieldmark))
1448 if (!dynamic_cast<::sw::mark::DateFieldmark*>(pFieldmark))
1449 bActualChange =
true;
1450 if (!dynamic_cast<::sw::mark::TextFieldmark*>(pFieldmark))
1465 SwPosition aNewPos (aPaM.GetPoint()->nNode, aPaM.GetPoint()->nContent);
1471 SwPosition aPos (aPaM.GetPoint()->nNode, aPaM.GetPoint()->nContent);
1493 && aPos.nContent.GetIndex() > 0 )
1505 pNewActiveFieldmark = &rFormField;
1517 if(pNewActiveFieldmark)
1540 std::vector<IFieldmark*> aRet;
1554 aRet.push_back(pMark);
1589 auto const pAnnotationMark = find_if(
1592 [&rPos] (const ::sw::mark::MarkBase *
const pMark) {
return pMark->
IsCoveringPosition(rPos); } );
1595 return *pAnnotationMark;
1601 return std::upper_bound(
1605 CompareIMarkStartsAfter());
1610 OSL_ENSURE(rName.getLength(),
1611 "<MarkManager::getUniqueMarkName(..)> - a name should be proposed");
1614 OUString
newName = rName +
"MailMergeMark"
1635 sTmp = rName + OUString::number(nCnt);
1680 xmlTextWriterStartElement(pWriter, BAD_CAST(
"MarkManager"));
1681 for (
const auto & rContainer : aContainers)
1683 if (!rContainer.pContainer->empty())
1685 xmlTextWriterStartElement(pWriter, BAD_CAST(rContainer.pName));
1686 for (
auto it = rContainer.pContainer->begin(); it != rContainer.pContainer->end(); ++it)
1687 (*it)->dumpAsXml(pWriter);
1688 xmlTextWriterEndElement(pWriter);
1691 xmlTextWriterEndElement(pWriter);
1711 SaveBookmark::SaveBookmark(
1729 dynamic_cast< ::sfx2::Metadatable const* >(pBookmark));
1775 aPam.GetMark()->nContent.Assign(aPam.GetContentNode(
false),
m_nContent2);
1778 aPam.GetPoint()->nNode +=
m_nNode1;
1783 aPam.GetPoint()->nContent.Assign(aPam.GetContentNode(),
m_nContent1);
1786 && !
CheckNodesRange(aPam.GetPoint()->nNode, aPam.GetMark()->nNode,
true))
1803 dynamic_cast< ::sfx2::Metadatable* >(pBookmark));
1804 assert(pMeta &&
"metadata undo, but not metadatable?");
1817 std::vector<SaveBookmark> * pSaveBkmk,
1823 || (rStt == rEnd && (!pSttIdx || !pEndIdx || pSttIdx->
GetIndex() >= pEndIdx->
GetIndex())))
1839 if( lcl_Greater( *pRStt, rStt, pSttIdx ) && lcl_Lower( *pRStt, rEnd, pEndIdx ))
1841 pRStt->
nNode = rEnd;
1853 pRStt->
nNode = rStt;
1864 if( lcl_Greater( *pREnd, rStt, pSttIdx ) && lcl_Lower( *pREnd, rEnd, pEndIdx ))
1866 pREnd->
nNode = rStt;
1878 pREnd->
nNode = rEnd;
virtual sw::mark::IMark * getAnnotationMarkFor(const SwPosition &rPos) const override
virtual sal_Int32 Len() const
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
SwPaM * GetCursor(bool bMakeTableCursor=true) const
Return pointer to the current shell cursor.
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.
std::unique_ptr< std::vector<::sw::mark::MarkBase * >::const_iterator > m_pIter
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.
void SetInDoc(SwDoc *pDoc, const SwNodeIndex &, const SwIndex *pIdx=nullptr)
virtual const SwPosition & GetMarkPos() const =0
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.
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 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
const BorderLinePrimitive2D *pCandidateB assert(pCandidateA)
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 * 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)
sal_uLong GetIndex() const
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.
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.
struct _xmlTextWriter * xmlTextWriterPtr
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
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.
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 std::unique_ptr< ILazyDeleter > deleteMark(const const_iterator_t &ppMark) override
Deletes a mark.
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)
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 SwPosition & GetOtherMarkPos() const override
SwTextNode is a paragraph in the document model.
IDocumentRedlineAccess const & getIDocumentRedlineAccess() const
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)
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 std::vector< ::sw::mark::IFieldmark * > getDropDownsFor(const SwPaM &rPaM) const 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
virtual const SwPosition & GetMarkStart() const =0
::sw::mark::IMark * operator*() const
virtual void SetOtherMarkPos(const SwPosition &rNewPos)
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
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.
SwContentNode * GoNext(SwNodeIndex *) const
virtual bool IsHidden() const =0
OUString m_aHideCondition
SwTextNode * GetTextNode()
Inline methods from Node.hxx.
virtual const SwPosition & GetOtherMarkPos() const =0
Base class of the Writer document model elements.