689 lines
22 KiB
C++
689 lines
22 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#include <hintids.hxx>
|
|
#include <wrtsh.hxx>
|
|
#include <swcrsr.hxx>
|
|
#include <editeng/lrspitem.hxx>
|
|
#include <view.hxx>
|
|
#include <drawbase.hxx>
|
|
#include <unobaseclass.hxx>
|
|
#include <fmtanchr.hxx>
|
|
#include <flyfrm.hxx>
|
|
#include <ndtxt.hxx>
|
|
#include <txtfld.hxx>
|
|
#include <docufld.hxx>
|
|
#include <IDocumentUndoRedo.hxx>
|
|
#include <i18nutil/unicode.hxx>
|
|
#include <o3tl/temporary.hxx>
|
|
#include <rtl/character.hxx>
|
|
#include <osl/diagnose.h>
|
|
#include <doc.hxx>
|
|
#include <IDocumentRedlineAccess.hxx>
|
|
#include <IDocumentLayoutAccess.hxx>
|
|
#include <txtfrm.hxx>
|
|
|
|
inline void SwWrtShell::OpenMark()
|
|
{
|
|
StartAllAction();
|
|
ResetCursorStack();
|
|
KillPams();
|
|
SetMark();
|
|
}
|
|
|
|
inline void SwWrtShell::CloseMark( bool bOkFlag )
|
|
{
|
|
if( bOkFlag )
|
|
UpdateAttr();
|
|
else
|
|
SwapPam();
|
|
|
|
ClearMark();
|
|
EndAllAction();
|
|
}
|
|
|
|
|
|
|
|
// #i23725#
|
|
bool SwWrtShell::TryRemoveIndent()
|
|
{
|
|
bool bResult = false;
|
|
|
|
SfxItemSetFixed<RES_MARGIN_FIRSTLINE, RES_MARGIN_FIRSTLINE> aAttrSet(GetAttrPool());
|
|
GetCurAttr(aAttrSet);
|
|
|
|
SvxFirstLineIndentItem firstLine(aAttrSet.Get(RES_MARGIN_FIRSTLINE));
|
|
SvxTextLeftMarginItem leftMargin(aAttrSet.Get(RES_MARGIN_TEXTLEFT));
|
|
short aOldFirstLineOfst = firstLine.ResolveTextFirstLineOffset({});
|
|
|
|
if (aOldFirstLineOfst > 0)
|
|
{
|
|
firstLine.SetTextFirstLineOffset(SvxIndentValue::zero());
|
|
bResult = true;
|
|
}
|
|
else if (aOldFirstLineOfst < 0)
|
|
{
|
|
// this used to call SetLeft() but this should be the same result
|
|
firstLine.SetTextFirstLineOffset(SvxIndentValue::zero());
|
|
leftMargin.SetTextLeft(
|
|
SvxIndentValue::twips(leftMargin.ResolveTextLeft({}) + aOldFirstLineOfst));
|
|
bResult = true;
|
|
}
|
|
else if (leftMargin.GetTextLeft().m_dValue != 0.0)
|
|
{
|
|
leftMargin.SetTextLeft(SvxIndentValue::zero());
|
|
bResult = true;
|
|
}
|
|
|
|
if (bResult)
|
|
{
|
|
aAttrSet.Put(firstLine);
|
|
aAttrSet.Put(leftMargin);
|
|
SetAttrSet(aAttrSet);
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
/** Description: Erase the line. */
|
|
|
|
void SwWrtShell::DelLine()
|
|
{
|
|
SwActContext aActContext(this);
|
|
ResetCursorStack();
|
|
// remember the old cursor
|
|
Push();
|
|
ClearMark();
|
|
SwCursorShell::LeftMargin();
|
|
SetMark();
|
|
SwCursorShell::RightMargin();
|
|
|
|
bool bRet = Delete(false);
|
|
Pop(SwCursorShell::PopMode::DeleteCurrent);
|
|
if( bRet )
|
|
UpdateAttr();
|
|
}
|
|
|
|
void SwWrtShell::DelToStartOfLine()
|
|
{
|
|
OpenMark();
|
|
SwCursorShell::LeftMargin();
|
|
bool bRet = Delete(false);
|
|
CloseMark( bRet );
|
|
}
|
|
|
|
void SwWrtShell::DelToEndOfLine()
|
|
{
|
|
OpenMark();
|
|
SwCursorShell::RightMargin();
|
|
bool bRet = Delete(false);
|
|
CloseMark( bRet );
|
|
}
|
|
|
|
bool SwWrtShell::DelLeft()
|
|
{
|
|
// If it's a Fly, throw it away
|
|
SelectionType nSelType = GetSelectionType();
|
|
const SelectionType nCmp = SelectionType::Frame | SelectionType::Graphic | SelectionType::Ole | SelectionType::DrawObject;
|
|
if( nCmp & nSelType )
|
|
{
|
|
// #108205# Remember object's position.
|
|
Point aTmpPt = GetObjRect().TopLeft();
|
|
|
|
DelSelectedObj();
|
|
|
|
// #108205# Set cursor to remembered position.
|
|
SetCursor(&aTmpPt);
|
|
|
|
LeaveSelFrameMode();
|
|
UnSelectFrame();
|
|
|
|
nSelType = GetSelectionType();
|
|
if ( nCmp & nSelType )
|
|
{
|
|
EnterSelFrameMode();
|
|
GotoNextFly();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// If a selection exists, erase this
|
|
if ( IsSelection() )
|
|
{
|
|
if( !IsBlockMode() || HasSelection() )
|
|
{
|
|
//OS: Once again Basic: SwActContext must be leaved
|
|
//before EnterStdMode!
|
|
{
|
|
SwActContext aActContext(this);
|
|
ResetCursorStack();
|
|
Delete(false, true);
|
|
UpdateAttr();
|
|
}
|
|
if( IsBlockMode() )
|
|
{
|
|
NormalizePam();
|
|
ClearMark();
|
|
EnterBlockMode();
|
|
}
|
|
else
|
|
EnterStdMode();
|
|
return true;
|
|
}
|
|
else
|
|
EnterStdMode();
|
|
}
|
|
|
|
// JP 29.06.95: never erase a table standing in front of it.
|
|
bool bSwap = false;
|
|
const SwTableNode * pWasInTableNd = SwCursorShell::IsCursorInTable();
|
|
|
|
if( SwCursorShell::IsSttPara())
|
|
{
|
|
// Start/EndAllAction to avoid cursor flickering
|
|
UnoActionContext c(GetDoc());
|
|
SwCursorShell::Push();
|
|
|
|
// #i4032# Don't actually call a 'delete' if we
|
|
// changed the table cell, compare DelRight().
|
|
const SwStartNode * pSNdOld = pWasInTableNd ?
|
|
GetCursor()->GetPointNode().FindTableBoxStartNode() :
|
|
nullptr;
|
|
|
|
// If the cursor is at the beginning of a paragraph, try to step
|
|
// backwards. On failure we are done.
|
|
bool bDoSomething = SwCursorShell::Left(1,SwCursorSkipMode::Chars);
|
|
|
|
if (bDoSomething)
|
|
{
|
|
// If the cursor entered or left a table (or both) we are done.
|
|
const SwTableNode* pIsInTableNd = SwCursorShell::IsCursorInTable();
|
|
bDoSomething = pIsInTableNd == pWasInTableNd;
|
|
|
|
if (bDoSomething)
|
|
{
|
|
const SwStartNode* pSNdNew = pIsInTableNd ?
|
|
GetCursor()->GetPointNode().FindTableBoxStartNode() :
|
|
nullptr;
|
|
|
|
// #i4032# Don't actually call a 'delete' if we
|
|
// changed the table cell, compare DelRight().
|
|
bDoSomething = pSNdOld == pSNdNew;
|
|
}
|
|
}
|
|
|
|
if (!bDoSomething)
|
|
{
|
|
// tdf#115132 Restore previous position and we are done
|
|
SwCursorShell::Pop(SwCursorShell::PopMode::DeleteCurrent);
|
|
return false;
|
|
}
|
|
|
|
SwCursorShell::Pop(SwCursorShell::PopMode::DeleteStack);
|
|
|
|
OpenMark();
|
|
SwCursorShell::Right(1,SwCursorSkipMode::Chars);
|
|
SwCursorShell::SwapPam();
|
|
bSwap = true;
|
|
}
|
|
else
|
|
{
|
|
// If we are just to the right to a fieldmark, then remove it completely
|
|
const SwPosition* pCurPos = GetCursor()->GetPoint();
|
|
SwPosition aPrevChar(*pCurPos->GetContentNode(), pCurPos->GetContentIndex() - 1);
|
|
sw::mark::Fieldmark* pFm = getIDocumentMarkAccess()->getFieldmarkAt(aPrevChar);
|
|
if (pFm && pFm->GetMarkEnd() == *pCurPos)
|
|
{
|
|
mxDoc->GetIDocumentUndoRedo().StartUndo(SwUndoId::EMPTY, nullptr);
|
|
IDocumentMarkAccess::DeleteFieldmarkCommand(*pFm);
|
|
getIDocumentMarkAccess()->deleteMark(pFm);
|
|
mxDoc->GetIDocumentUndoRedo().EndUndo(SwUndoId::EMPTY, nullptr);
|
|
return true;
|
|
}
|
|
|
|
OpenMark();
|
|
SwCursorShell::Left(1, SwCursorSkipMode::Chars);
|
|
|
|
// If we are deleting a variation selector, we want to delete the
|
|
// whole sequence.
|
|
sal_uInt32 nCode = GetChar(false);
|
|
if ( rtl::isSurrogate( nCode ) )
|
|
{
|
|
OUString sStr = GetSelText();
|
|
nCode = sStr.iterateCodePoints( &o3tl::temporary(sal_Int32(0)) );
|
|
}
|
|
|
|
if ( unicode::isVariationSelector( nCode ) )
|
|
{
|
|
SwCursorShell::Push();
|
|
SwCursorShell::Left(1, SwCursorSkipMode::Chars);
|
|
SwCursorShell::Pop( SwCursorShell::PopMode::DeleteStack );
|
|
}
|
|
}
|
|
bool bRet = Delete(true, true);
|
|
if( !bRet && bSwap )
|
|
SwCursorShell::SwapPam();
|
|
CloseMark( bRet );
|
|
|
|
return bRet;
|
|
}
|
|
|
|
bool SwWrtShell::DelRight(bool const isReplaceHeuristic)
|
|
{
|
|
// Will be or'ed, if a tableselection exists;
|
|
// will here be implemented on SelectionType::Table
|
|
bool bRet = false;
|
|
SelectionType nSelection = GetSelectionType();
|
|
if(nSelection & SelectionType::TableCell)
|
|
nSelection = SelectionType::Table;
|
|
if(nSelection & SelectionType::Text)
|
|
nSelection = SelectionType::Text;
|
|
|
|
switch( nSelection & ~SelectionType::Ornament & ~SelectionType::Media )
|
|
{
|
|
case SelectionType::PostIt:
|
|
case SelectionType::Text:
|
|
case SelectionType::Table:
|
|
case SelectionType::NumberList:
|
|
// If a selection exists, erase it.
|
|
if( IsSelection() )
|
|
{
|
|
if( !IsBlockMode() || HasSelection() )
|
|
{
|
|
//OS: And once again Basic: SwActContext must be
|
|
//leaved before EnterStdMode !
|
|
{
|
|
SwActContext aActContext(this);
|
|
ResetCursorStack();
|
|
Delete(isReplaceHeuristic);
|
|
UpdateAttr();
|
|
}
|
|
if( IsBlockMode() )
|
|
{
|
|
NormalizePam();
|
|
ClearMark();
|
|
EnterBlockMode();
|
|
}
|
|
else
|
|
EnterStdMode();
|
|
bRet = true;
|
|
break;
|
|
}
|
|
else
|
|
EnterStdMode();
|
|
}
|
|
|
|
if (SwCursorShell::IsEndPara())
|
|
{
|
|
// Start/EndAllAction to avoid cursor flickering
|
|
UnoActionContext c(GetDoc());
|
|
|
|
const SwTableNode* pWasInTableNd = IsCursorInTable();
|
|
// #108049# Save the startnode of the current cell
|
|
const SwStartNode* pSNdOld = pWasInTableNd ?
|
|
GetCursor()->GetPointNode().FindTableBoxStartNode() : nullptr;
|
|
SwTextNode* pOldTextNode = GetCursor()->GetPointNode().GetTextNode();
|
|
bool bCheckDelFull = SelectionType::Text & nSelection && SwCursorShell::IsSttPara();
|
|
bool bDelFull = false;
|
|
bool bDoNothing = false;
|
|
|
|
// #i41424# Introduced a couple of
|
|
// Push()-Pop() pairs here. The reason for this is that a
|
|
// Right()-Left() combination does not make sure, that
|
|
// the cursor will be in its initial state, because there
|
|
// may be a numbering in front of the next paragraph.
|
|
SwCursorShell::Push();
|
|
|
|
if (SwCursorShell::Right(1, SwCursorSkipMode::Chars))
|
|
{
|
|
const SwTableNode* pCurrTableNd = IsCursorInTable();
|
|
bDelFull = bCheckDelFull && pCurrTableNd && pCurrTableNd != pWasInTableNd;
|
|
if (!bDelFull && (IsCursorInTable() || (pCurrTableNd != pWasInTableNd)))
|
|
{
|
|
// #108049# Save the startnode of the current cell.
|
|
// May be different to pSNdOld as we have moved.
|
|
const SwStartNode* pSNdNew = pCurrTableNd ?
|
|
GetCursor()->GetPointNode().FindTableBoxStartNode() : nullptr;
|
|
|
|
// tdf#115132 Only keep cursor position instead of deleting
|
|
// if we have moved to a different cell
|
|
bDoNothing = pSNdOld != pSNdNew;
|
|
}
|
|
}
|
|
|
|
// restore cursor
|
|
SwTextNode* pNewTextNode = GetCursor()->GetPointNode().GetTextNode();
|
|
SwCursorShell::Pop(SwCursorShell::PopMode::DeleteCurrent);
|
|
|
|
if (bDelFull)
|
|
{
|
|
DelFullPara();
|
|
UpdateAttr();
|
|
}
|
|
|
|
if (pOldTextNode && pNewTextNode && pNewTextNode != pOldTextNode)
|
|
{
|
|
SwRootFrame* pLayout = mxDoc->getIDocumentLayoutAccess().GetCurrentLayout();
|
|
if (pLayout)
|
|
{
|
|
auto pOldFrame = static_cast<SwTextFrame*>(pOldTextNode->getLayoutFrame(pLayout));
|
|
auto pNewFrame = static_cast<SwTextFrame*>(pNewTextNode->getLayoutFrame(pLayout));
|
|
if (pOldFrame && pNewFrame && pOldFrame->HasSplitFlyDrawObjs() && pNewFrame->HasSplitFlyDrawObjs())
|
|
{
|
|
// We have a selection where both the old and the new position is an anchor
|
|
// for a potentially split fly. Don't allow join of the nodes in this case,
|
|
// since the layout supports multiple anchors for one split fly, but it
|
|
// doesn't support the usage of the same anchor for multiple split flys.
|
|
bDoNothing = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bDelFull || bDoNothing)
|
|
break;
|
|
}
|
|
|
|
{
|
|
// If we are just ahead of a fieldmark, then remove it completely
|
|
sw::mark::Fieldmark *const pFm = getIDocumentMarkAccess()->getFieldmarkAt(*GetCursor()->GetPoint());
|
|
if (pFm && pFm->GetMarkStart() == *GetCursor()->GetPoint())
|
|
{
|
|
mxDoc->GetIDocumentUndoRedo().StartUndo(SwUndoId::EMPTY, nullptr);
|
|
IDocumentMarkAccess::DeleteFieldmarkCommand(*pFm);
|
|
getIDocumentMarkAccess()->deleteMark(pFm);
|
|
mxDoc->GetIDocumentUndoRedo().EndUndo(SwUndoId::EMPTY, nullptr);
|
|
bRet = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
OpenMark();
|
|
SwCursorShell::Right(1, SwCursorSkipMode::Cells);
|
|
bRet = Delete(true);
|
|
CloseMark( bRet );
|
|
break;
|
|
|
|
case SelectionType::Frame:
|
|
case SelectionType::Graphic:
|
|
case SelectionType::Ole:
|
|
case SelectionType::DrawObject:
|
|
case SelectionType::DrawObjectEditMode:
|
|
case SelectionType::DbForm:
|
|
{
|
|
// Group deletion of the object and its comment together
|
|
// (also as-character anchor conversion at track changes)
|
|
mxDoc->GetIDocumentUndoRedo().StartUndo(SwUndoId::EMPTY, nullptr);
|
|
|
|
// #108205# Remember object's position.
|
|
Point aTmpPt = GetObjRect().TopLeft();
|
|
|
|
// Remember the anchor of the selected object before deletion.
|
|
std::optional<SwPosition> oAnchor;
|
|
RndStdIds eAnchorId = RndStdIds::FLY_AT_PARA;
|
|
SwFlyFrame* pFly = GetSelectedFlyFrame();
|
|
SwFrameFormat* pFormat = nullptr;
|
|
if (pFly)
|
|
{
|
|
pFormat = pFly->GetFormat();
|
|
if (pFormat)
|
|
{
|
|
eAnchorId = pFormat->GetAnchor().GetAnchorId();
|
|
// to-character anchor conversion at track changes
|
|
if ( IsRedlineOn() && (eAnchorId != RndStdIds::FLY_AS_CHAR &&
|
|
eAnchorId != RndStdIds::FLY_AT_CHAR) )
|
|
{
|
|
SfxItemSetFixed<RES_ANCHOR, RES_ANCHOR> aSet(GetAttrPool());
|
|
GetFlyFrameAttr(aSet);
|
|
SwFormatAnchor aAnch(RndStdIds::FLY_AT_CHAR);
|
|
aSet.Put(aAnch);
|
|
SetFlyFrameAttr(aSet);
|
|
eAnchorId = pFormat->GetAnchor().GetAnchorId();
|
|
}
|
|
if ((eAnchorId == RndStdIds::FLY_AS_CHAR || eAnchorId == RndStdIds::FLY_AT_CHAR)
|
|
&& pFormat->GetAnchor().GetAnchorNode())
|
|
{
|
|
oAnchor.emplace(*pFormat->GetAnchor().GetContentAnchor());
|
|
// set cursor before the anchor point
|
|
if ( IsRedlineOn() )
|
|
*GetCurrentShellCursor().GetPoint() = *oAnchor;
|
|
}
|
|
}
|
|
}
|
|
|
|
// track changes: create redline at anchor point of the image to record the deletion
|
|
if ( IsRedlineOn() && oAnchor && SelectionType::Graphic & nSelection && pFormat &&
|
|
( eAnchorId == RndStdIds::FLY_AT_CHAR || eAnchorId == RndStdIds::FLY_AS_CHAR ) )
|
|
{
|
|
sal_Int32 nRedlineLength = 1;
|
|
// create a double CH_TXT_TRACKED_DUMMY_CHAR anchor point of the image to record the
|
|
// deletion, if needed (otherwise use the existing anchor point of the image anchored
|
|
// *as* character)
|
|
if ( eAnchorId == RndStdIds::FLY_AT_CHAR )
|
|
{
|
|
nRedlineLength = 2;
|
|
LeaveSelFrameMode();
|
|
UnSelectFrame();
|
|
RedlineFlags eOld = GetRedlineFlags();
|
|
SetRedlineFlags( eOld | RedlineFlags::Ignore );
|
|
Insert( OUStringChar(CH_TXT_TRACKED_DUMMY_CHAR) +
|
|
OUStringChar(CH_TXT_TRACKED_DUMMY_CHAR) );
|
|
SwFormatAnchor anchor(RndStdIds::FLY_AT_CHAR);
|
|
SwCursorShell::Left(1, SwCursorSkipMode::Chars);
|
|
anchor.SetAnchor(GetCursor()->GetPoint());
|
|
GetDoc()->SetAttr(anchor, *pFormat);
|
|
SetRedlineFlags( eOld );
|
|
SwCursorShell::Left(1, SwCursorSkipMode::Chars);
|
|
}
|
|
OpenMark();
|
|
SwCursorShell::Right(nRedlineLength, SwCursorSkipMode::Chars);
|
|
bRet = Delete(false);
|
|
CloseMark( bRet );
|
|
}
|
|
else
|
|
DelSelectedObj();
|
|
|
|
if (oAnchor)
|
|
{
|
|
SwTextNode* pTextNode = oAnchor->GetNode().GetTextNode();
|
|
if (pTextNode)
|
|
{
|
|
const SwTextField* pField(
|
|
pTextNode->GetFieldTextAttrAt(oAnchor->GetContentIndex(), ::sw::GetTextAttrMode::Default));
|
|
if (pField
|
|
&& dynamic_cast<const SwPostItField*>(pField->GetFormatField().GetField()))
|
|
{
|
|
// Remove the comment of the deleted object.
|
|
*GetCurrentShellCursor().GetPoint() = *oAnchor;
|
|
DelRight();
|
|
}
|
|
}
|
|
}
|
|
|
|
mxDoc->GetIDocumentUndoRedo().EndUndo(SwUndoId::EMPTY, nullptr);
|
|
|
|
// #108205# Set cursor to remembered position.
|
|
SetCursor(&aTmpPt);
|
|
|
|
LeaveSelFrameMode();
|
|
UnSelectFrame();
|
|
OSL_ENSURE( !IsFrameSelected(),
|
|
"<SwWrtShell::DelRight(..)> - <SwWrtShell::UnSelectFrame()> should unmark all objects" );
|
|
// leave draw mode, if necessary.
|
|
{
|
|
if (GetView().GetDrawFuncPtr())
|
|
{
|
|
GetView().GetDrawFuncPtr()->Deactivate();
|
|
GetView().SetDrawFuncPtr(nullptr);
|
|
}
|
|
if ( GetView().IsDrawMode() )
|
|
{
|
|
GetView().LeaveDrawCreate();
|
|
}
|
|
}
|
|
}
|
|
|
|
// <IsFrameSelected()> can't be true - see above.
|
|
{
|
|
nSelection = GetSelectionType();
|
|
if ( SelectionType::Frame & nSelection ||
|
|
SelectionType::Graphic & nSelection ||
|
|
SelectionType::Ole & nSelection ||
|
|
SelectionType::DrawObject & nSelection )
|
|
{
|
|
EnterSelFrameMode();
|
|
GotoNextFly();
|
|
}
|
|
}
|
|
bRet = true;
|
|
break;
|
|
default: break;
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
void SwWrtShell::DelToEndOfPara()
|
|
{
|
|
SwActContext aActContext(this);
|
|
ResetCursorStack();
|
|
Push();
|
|
SetMark();
|
|
if( !MovePara(GoCurrPara,fnParaEnd))
|
|
{
|
|
Pop(SwCursorShell::PopMode::DeleteCurrent);
|
|
return;
|
|
}
|
|
bool bRet = Delete(false);
|
|
Pop(SwCursorShell::PopMode::DeleteCurrent);
|
|
if( bRet )
|
|
UpdateAttr();
|
|
}
|
|
|
|
void SwWrtShell::DelToStartOfPara()
|
|
{
|
|
SwActContext aActContext(this);
|
|
ResetCursorStack();
|
|
Push();
|
|
SetMark();
|
|
if( !MovePara(GoCurrPara,fnParaStart))
|
|
{
|
|
Pop(SwCursorShell::PopMode::DeleteCurrent);
|
|
return;
|
|
}
|
|
bool bRet = Delete(false);
|
|
Pop(SwCursorShell::PopMode::DeleteCurrent);
|
|
if( bRet )
|
|
UpdateAttr();
|
|
}
|
|
|
|
// All erase operations should work with Find instead with
|
|
// Nxt-/PrvDelim, because the latter works with Wrap Around
|
|
// -- that's probably not wished.
|
|
|
|
void SwWrtShell::DelToStartOfSentence()
|
|
{
|
|
if(IsStartOfDoc())
|
|
return;
|
|
OpenMark();
|
|
bool bRet = BwdSentence_() && Delete(false);
|
|
CloseMark( bRet );
|
|
}
|
|
|
|
bool SwWrtShell::DelToEndOfSentence()
|
|
{
|
|
if(IsEndOfDoc())
|
|
return false;
|
|
OpenMark();
|
|
bool bRet(false);
|
|
// fdo#60967: special case that is documented in help: delete
|
|
// paragraph following table if cursor is at end of last cell in table
|
|
if (IsEndOfTable())
|
|
{
|
|
Push();
|
|
ClearMark();
|
|
if (SwCursorShell::Right(1,SwCursorSkipMode::Chars))
|
|
{
|
|
SetMark();
|
|
if (!IsEndPara()) // can only be at the end if it's empty
|
|
{ // for an empty paragraph this would actually select the _next_
|
|
SwCursorShell::MovePara(GoCurrPara, fnParaEnd);
|
|
}
|
|
if (!IsEndOfDoc()) // do not delete last paragraph in body text
|
|
{
|
|
bRet = DelFullPara();
|
|
}
|
|
}
|
|
Pop(SwCursorShell::PopMode::DeleteCurrent);
|
|
}
|
|
else
|
|
{
|
|
bRet = FwdSentence_() && Delete(false);
|
|
}
|
|
CloseMark( bRet );
|
|
return bRet;
|
|
}
|
|
|
|
void SwWrtShell::DelNxtWord()
|
|
{
|
|
if(IsEndOfDoc())
|
|
return;
|
|
SwActContext aActContext(this);
|
|
ResetCursorStack();
|
|
EnterStdMode();
|
|
SetMark();
|
|
if(IsEndWrd() && !IsStartWord())
|
|
NxtWrdForDelete(); // #i92468#
|
|
if(IsStartWord() || IsEndPara())
|
|
NxtWrdForDelete(); // #i92468#
|
|
else
|
|
EndWrd();
|
|
|
|
bool bRet = Delete(false);
|
|
if( bRet )
|
|
UpdateAttr();
|
|
else
|
|
SwapPam();
|
|
ClearMark();
|
|
}
|
|
|
|
void SwWrtShell::DelPrvWord()
|
|
{
|
|
if(IsStartOfDoc())
|
|
return;
|
|
SwActContext aActContext(this);
|
|
ResetCursorStack();
|
|
EnterStdMode();
|
|
SetMark();
|
|
if ( !IsStartWord() ||
|
|
!PrvWrdForDelete() ) // #i92468#
|
|
{
|
|
if (IsEndWrd() || IsSttPara())
|
|
PrvWrdForDelete(); // #i92468#
|
|
else
|
|
SttWrd();
|
|
}
|
|
bool bRet = Delete(false);
|
|
if( bRet )
|
|
UpdateAttr();
|
|
else
|
|
SwapPam();
|
|
ClearMark();
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|