xref: /aoo42x/main/sw/source/ui/wrtsh/select.cxx (revision 796b7e2a)

/**************************************************************
 *
 * 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
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sw.hxx"


#include <limits.h>
#include <hintids.hxx>
#include <sfx2/bindings.hxx>
#include <svl/eitem.hxx>
#include <svl/macitem.hxx>
#include <unotools/charclass.hxx>
#include <editeng/scripttypeitem.hxx>
#include <cmdid.h>
#include <view.hxx>
#include <basesh.hxx>
#include <wrtsh.hxx>
#include <frmatr.hxx>
#include <initui.hxx>
#include <mdiexp.hxx>
#include <fmtcol.hxx>
#include <frmfmt.hxx>
#include <swundo.hxx>               	// fuer Undo-Ids
#include <swevent.hxx>
#include <swdtflvr.hxx>
#include <crsskip.hxx>

#ifndef _DOC_HXX
#include <doc.hxx>
#endif
#if OSL_DEBUG_LEVEL > 1
#include <pam.hxx>
#endif

namespace com { namespace sun { namespace star { namespace util {
	struct SearchOptions;
} } } }

using namespace ::com::sun::star::util;


static long nStartDragX = 0, nStartDragY = 0;
static sal_Bool  bStartDrag = sal_False;

void SwWrtShell::Invalidate()
{
	// to avoid making the slot volatile, invalidate it every time if something could have been changed
	// this is still much cheaper than asking for the state every 200 ms (and avoid background processing)
	GetView().GetViewFrame()->GetBindings().Invalidate( FN_STAT_SELMODE );
}

sal_Bool SwWrtShell::SelNearestWrd()
{
	MV_KONTEXT(this);
	if( !IsInWrd() && !IsEndWrd() && !IsSttWrd() )
		PrvWrd();
	if( IsEndWrd() )
		Left(CRSR_SKIP_CELLS, sal_False, 1, sal_False );
	return SelWrd();
}



sal_Bool SwWrtShell::SelWrd(const Point *pPt, sal_Bool )
{
	sal_Bool bRet;
	{
		MV_KONTEXT(this);
		SttSelect();
		bRet = SwCrsrShell::SelectWord( pPt );
	}
	EndSelect();
	if( bRet )
	{
		bSelWrd = sal_True;
		if(pPt)
			aStart = *pPt;
	}
	return bRet;
}

void SwWrtShell::SelSentence(const Point *pPt, sal_Bool )
{
	{
		MV_KONTEXT(this);
		ClearMark();
        SwCrsrShell::GoStartSentence();
		SttSelect();
        SwCrsrShell::GoEndSentence();
	}
	EndSelect();
	if(pPt)
		aStart = *pPt;
	bSelLn = sal_True;
	bSelWrd = sal_False;	// SelWord abschalten, sonst geht kein SelLine weiter
}

void SwWrtShell::SelPara(const Point *pPt, sal_Bool )
{
    {
        MV_KONTEXT(this);
        ClearMark();
        SwCrsrShell::MovePara( fnParaCurr, fnParaStart );
        SttSelect();
        SwCrsrShell::MovePara( fnParaCurr, fnParaEnd );
    }
    EndSelect();
    if(pPt)
        aStart = *pPt;
    bSelLn = sal_False;
    bSelWrd = sal_False;    // SelWord abschalten, sonst geht kein SelLine weiter
}


long SwWrtShell::SelAll()
{
    const sal_Bool bLockedView = IsViewLocked();
    LockView( sal_True );
    {
        if(bBlockMode)
            LeaveBlockMode();
        MV_KONTEXT(this);
        sal_Bool bMoveTable = sal_False;
        SwPosition *pStartPos = 0;
        SwPosition *pEndPos = 0;
        SwShellCrsr* pTmpCrsr = 0;
        if( !HasWholeTabSelection() )
        {
            if ( IsSelection() && IsCrsrPtAtEnd() )
                SwapPam();
            pTmpCrsr = getShellCrsr( false );
            if( pTmpCrsr )
            {
                pStartPos = new SwPosition( *pTmpCrsr->GetPoint() );
                pEndPos = new SwPosition( *pTmpCrsr->GetMark() );
            }
            Push();
            sal_Bool bIsFullSel = !MoveSection( fnSectionCurr, fnSectionStart);
            SwapPam();
            bIsFullSel &= !MoveSection( fnSectionCurr, fnSectionEnd);
            Pop(sal_False);
            GoStart(sal_True, &bMoveTable, sal_False, !bIsFullSel);
        }
        else
        {
            EnterStdMode();
            SttEndDoc(sal_True);
        }
        SttSelect();
        GoEnd(sal_True, &bMoveTable);

		SwDoc *pDoc = GetDoc();
		if ( pDoc )
		{
			pDoc->SetPrepareSelAll();
		}
        if( pStartPos )
        {
            pTmpCrsr = getShellCrsr( false );
            if( pTmpCrsr )
            {
                // Some special handling for sections (e.g. TOC) at the beginning of the document body
                // to avoid the selection of the first section
                // if the last selection was behind the first section or
                // if the last selection was already the first section
                // In this both cases we select to the end of document
                if( *pTmpCrsr->GetPoint() < *pEndPos ||
                    ( *pStartPos == *pTmpCrsr->GetMark() &&
                      *pEndPos == *pTmpCrsr->GetPoint() ) )
                    SwCrsrShell::SttEndDoc(sal_False);
            }
            delete pStartPos;
            delete pEndPos;
        }
    }
    EndSelect();
    LockView( bLockedView );
    return 1;
}

/*------------------------------------------------------------------------
 Beschreibung:	Textsuche
------------------------------------------------------------------------*/


sal_uLong SwWrtShell::SearchPattern( const SearchOptions& rSearchOpt, sal_Bool bSearchInNotes,
								SwDocPositions eStt, SwDocPositions eEnd,
								FindRanges eFlags, int bReplace )
{
		// keine Erweiterung bestehender Selektionen
	if(!(eFlags & FND_IN_SEL))
		ClearMark();
    sal_Bool bCancel = sal_False;
    sal_uLong nRet = Find( rSearchOpt, bSearchInNotes, eStt, eEnd, bCancel, eFlags, bReplace );
    if(bCancel)
    {
        Undo(1);
        nRet = ULONG_MAX;
    }
    return nRet;
}
/*------------------------------------------------------------------------
 Beschreibung:	Suche nach Vorlagen
------------------------------------------------------------------------*/



sal_uLong SwWrtShell::SearchTempl( const String &rTempl,
							   SwDocPositions eStt, SwDocPositions eEnd,
							   FindRanges eFlags, const String* pReplTempl )
{
		// keine Erweiterung bestehender Selektionen
	if(!(eFlags & FND_IN_SEL))
		ClearMark();
	SwTxtFmtColl *pColl = GetParaStyle(rTempl, SwWrtShell::GETSTYLE_CREATESOME);
	SwTxtFmtColl *pReplaceColl = 0;
	if( pReplTempl )
		pReplaceColl = GetParaStyle(*pReplTempl, SwWrtShell::GETSTYLE_CREATESOME );

    sal_Bool bCancel = sal_False;
    sal_uLong nRet = Find(pColl? *pColl: GetDfltTxtFmtColl(),
							   eStt,eEnd, bCancel, eFlags, pReplaceColl);
    if(bCancel)
    {
        Undo(1);
        nRet = ULONG_MAX;
    }
	return nRet;
}

// Suche nach Attributen ----------------------------------------------------



sal_uLong SwWrtShell::SearchAttr( const SfxItemSet& rFindSet, sal_Bool bNoColls,
								SwDocPositions eStart, SwDocPositions eEnde,
								FindRanges eFlags, const SearchOptions* pSearchOpt,
								const SfxItemSet* pReplaceSet )
{
	// Keine Erweiterung bestehender Selektionen
	if (!(eFlags & FND_IN_SEL))
		ClearMark();

	// Suchen
    sal_Bool bCancel = sal_False;
	sal_uLong nRet = Find( rFindSet, bNoColls, eStart, eEnde, bCancel, eFlags, pSearchOpt, pReplaceSet);

    if(bCancel)
    {
        Undo(1);
        nRet = ULONG_MAX;
    }
	return nRet;
}

// ---------- Selektionsmodi ----------



void SwWrtShell::PushMode()
{
	pModeStack = new ModeStack( pModeStack, bIns, bExtMode, bAddMode, bBlockMode );
}



void SwWrtShell::PopMode()
{
	if ( 0 == pModeStack )
		return;

	if ( bExtMode && !pModeStack->bExt )
		LeaveExtMode();
	if ( bAddMode && !pModeStack->bAdd )
		LeaveAddMode();
	if ( bBlockMode && !pModeStack->bBlock )
		LeaveBlockMode();
	bIns = pModeStack->bIns;

	ModeStack *pTmp = pModeStack->pNext;
	delete pModeStack;
	pModeStack = pTmp;
}

/*
 * Zwei Methoden fuer das Cursorsetzen; die erste mappt auf die
 * gleichnamige Methoden an der CursorShell, die zweite hebt
 * zuerst alle Selektionen auf.
 */



long SwWrtShell::SetCrsr(const Point *pPt, sal_Bool bTextOnly)
{
		/*
		* eine gfs.  bestehende Selektion an der Position des
		* Mausklicks aufheben
		*/
	if(!IsInSelect() && ChgCurrPam(*pPt)) {
		ClearMark();
	}

	return SwCrsrShell::SetCrsr(*pPt, bTextOnly);
}


long SwWrtShell::SetCrsrKillSel(const Point *pPt, sal_Bool bTextOnly )
{
	ACT_KONTEXT(this);
	ResetSelect(pPt,sal_False);
    return SwCrsrShell::SetCrsr(*pPt, bTextOnly);
}



void SwWrtShell::UnSelectFrm()
{
    // Rahmenselektion aufheben mit garantiert ungueltiger Position
	Point aPt(LONG_MIN, LONG_MIN);
    SelectObj(aPt, 0);
	SwTransferable::ClearSelection( *this );
}

/*
 * Aufheben aller Selektionen
 */



long SwWrtShell::ResetSelect(const Point *,sal_Bool)
{
	if(IsSelFrmMode())
	{
		UnSelectFrm();
		LeaveSelFrmMode();
	}
	else
	{
		/* 	ACT_KONTEXT() macht eine Action auf -
			um im Basicablauf keine Probleme mit der
			Shellumschaltung zu bekommen, darf
			GetChgLnk().Call() erst nach
			EndAction() gerufen werden.
		*/
		{
			ACT_KONTEXT(this);
			bSelWrd = bSelLn = sal_False;
			KillPams();
			ClearMark();
            fnKillSel = &SwWrtShell::Ignore;
			fnSetCrsr = &SwWrtShell::SetCrsr;
		}
		/*
			* nach dem Aufheben aller Selektionen koennte ein Update der
			* Attr-Controls notwendig sein.
		*/
		GetChgLnk().Call(this);
	}
	Invalidate();
	SwTransferable::ClearSelection( *this );
	return 1;
}



/*
 * tue nichts
 */
long SwWrtShell::Ignore(const Point *, sal_Bool ) {
	return 1;
}

/*
 * Start eines Selektionsvorganges.
 */



void SwWrtShell::SttSelect()
{
	if(bInSelect)
		return;
	if(!HasMark())
		SetMark();
    if( bBlockMode )
    {
        SwShellCrsr* pTmp = getShellCrsr( true );
        if( !pTmp->HasMark() )
            pTmp->SetMark();
    }
	fnKillSel = &SwWrtShell::Ignore;
	fnSetCrsr = &SwWrtShell::SetCrsr;
	bInSelect = sal_True;
	Invalidate();
	SwTransferable::CreateSelection( *this );
}
/*
 * Ende eines Selektionsvorganges.
 */



void SwWrtShell::EndSelect()
{
	if(!bInSelect || bExtMode)
		return;
	bInSelect = sal_False;
	(this->*fnLeaveSelect)(0,sal_False);
	if(!bAddMode) {
		fnSetCrsr = &SwWrtShell::SetCrsrKillSel;
		fnKillSel = &SwWrtShell::ResetSelect;
	}
}
/* Methode, um eine bestehende wortweise oder zeilenweise Selektion
 * zu erweitern.
 */

inline sal_Bool operator<(const Point &rP1,const Point &rP2)
{
	return rP1.Y() < rP2.Y() || (rP1.Y() == rP2.Y() && rP1.X() < rP2.X());
}



long SwWrtShell::ExtSelWrd(const Point *pPt, sal_Bool )
{
	MV_KONTEXT(this);
	if( IsTableMode() )
		return 1;

	// Bug 66823: actual crsr has in additional mode no selection?
	// Then destroy the actual an go to prev, this will be expand
	if( !HasMark() && GoPrevCrsr() )
	{
		sal_Bool bHasMark = HasMark(); // that's wrong!
		GoNextCrsr();
		if( bHasMark )
		{
			DestroyCrsr();
			GoPrevCrsr();
		}
	}

	// check the direction of the selection with the new point
	sal_Bool bRet = sal_False, bMoveCrsr = sal_True, bToTop = sal_False;
	SwCrsrShell::SelectWord( &aStart );  	// select the startword
	SwCrsrShell::Push();					// save the cursor
	SwCrsrShell::SetCrsr( *pPt );			// and check the direction

	switch( SwCrsrShell::CompareCursor( StackMkCurrPt ))
	{
	case -1:	bToTop = sal_False; 	break;
	case 1: 	bToTop = sal_True;		break;
	default:	bMoveCrsr = sal_False;	break;
	}

	SwCrsrShell::Pop( sal_False );				// retore the saved cursor

	if( bMoveCrsr )
	{
		// select to Top but cursor select to Bottom? or
		// select to Bottom but cursor select to Top? 		--> swap the cursor
		if( bToTop )
			SwapPam();

		SwCrsrShell::Push();		        // save cur cursor
		if( SwCrsrShell::SelectWord( pPt ))	// select the current word
		{
			if( bToTop )
				SwapPam();
			Combine();
			bRet = sal_True;
		}
		else
		{
			SwCrsrShell::Pop( sal_False );
			if( bToTop )
				SwapPam();
		}
	}
	else
		bRet = sal_True;
	return bRet;
}


long SwWrtShell::ExtSelLn(const Point *pPt, sal_Bool )
{
	MV_KONTEXT(this);
	SwCrsrShell::SetCrsr(*pPt);
	if( IsTableMode() )
		return 1;

	// Bug 66823: actual crsr has in additional mode no selection?
	// Then destroy the actual an go to prev, this will be expand
	if( !HasMark() && GoPrevCrsr() )
	{
		sal_Bool bHasMark = HasMark(); // that's wrong!
		GoNextCrsr();
		if( bHasMark )
		{
			DestroyCrsr();
			GoPrevCrsr();
		}
	}

	// ggfs. den Mark der Selektion anpassen
	sal_Bool bToTop = !IsCrsrPtAtEnd();
	SwapPam();

	// der "Mark" muss am Zeilenende/-anfang stehen
    if( bToTop ? !IsEndSentence() : !IsStartSentence() )
	{
		if( bToTop )
		{
			if( !IsEndPara() )
				SwCrsrShell::Right(1,CRSR_SKIP_CHARS);
            SwCrsrShell::GoEndSentence();
		}
		else
            SwCrsrShell::GoStartSentence();
	}
	SwapPam();

    return bToTop ? SwCrsrShell::GoStartSentence() : SwCrsrShell::GoEndSentence();
}


/*
 * zurueck in den Standard Mode: kein Mode, keine Selektionen.
 */

void SwWrtShell::EnterStdMode()
{
	if(bAddMode)
		LeaveAddMode();
	if(bBlockMode)
		LeaveBlockMode();
	bBlockMode = sal_False;
	bExtMode = sal_False;
	bInSelect = sal_False;
    if(IsSelFrmMode())
    {
        UnSelectFrm();
        LeaveSelFrmMode();
    }
    else
    {
        /*  ACT_KONTEXT() opens and action which has to be
            closed prior to the call of
            GetChgLnk().Call()
        */
        {
            ACT_KONTEXT(this);
            bSelWrd = bSelLn = sal_False;
            if( !IsRetainSelection() )
                KillPams();
            ClearMark();
            fnSetCrsr = &SwWrtShell::SetCrsrKillSel;
            fnKillSel = &SwWrtShell::ResetSelect;
        }
    }
	Invalidate();
    SwTransferable::ClearSelection( *this );
}

/*
 * Extended Mode
 */



void SwWrtShell::EnterExtMode()
{
	if(bBlockMode)
	{
		LeaveBlockMode();
		KillPams();
		ClearMark();
	}
	bExtMode = sal_True;
	bAddMode = sal_False;
	bBlockMode = sal_False;
	SttSelect();
}



void SwWrtShell::LeaveExtMode()
{
	bExtMode = sal_False;
	EndSelect();
}
/*
 * Ende einer Selektion; falls die Selektion leer ist,
 * ClearMark().
 */



long SwWrtShell::SttLeaveSelect(const Point *, sal_Bool )
{
	if(SwCrsrShell::HasSelection() && !IsSelTblCells() && bClearMark) {
		return 0;
	}
//	if( IsSelTblCells() ) aSelTblLink.Call(this);
	ClearMark();
	return 1;
}
/*
 * Verlassen des Selektionsmodus in Additional Mode
 */



long SwWrtShell::AddLeaveSelect(const Point *, sal_Bool )
{
	if(IsTableMode()) LeaveAddMode();
	else if(SwCrsrShell::HasSelection())
		CreateCrsr();
	return 1;
}
/*
 * Additional Mode
 */



void SwWrtShell::EnterAddMode()
{
	if(IsTableMode()) return;
	if(bBlockMode)
		LeaveBlockMode();
	fnLeaveSelect = &SwWrtShell::AddLeaveSelect;
	fnKillSel = &SwWrtShell::Ignore;
	fnSetCrsr = &SwWrtShell::SetCrsr;
	bAddMode = sal_True;
	bBlockMode = sal_False;
	bExtMode = sal_False;
	if(SwCrsrShell::HasSelection())
		CreateCrsr();
	Invalidate();
}



void SwWrtShell::LeaveAddMode()
{
	fnLeaveSelect = &SwWrtShell::SttLeaveSelect;
	fnKillSel = &SwWrtShell::ResetSelect;
	fnSetCrsr = &SwWrtShell::SetCrsrKillSel;
	bAddMode = sal_False;
	Invalidate();
}

/*
 * Block Mode
 */

void SwWrtShell::EnterBlockMode()
{
    bBlockMode = sal_False;
    EnterStdMode();
	bBlockMode = sal_True;
    CrsrToBlockCrsr();
	Invalidate();
}



void SwWrtShell::LeaveBlockMode()
{
	bBlockMode = sal_False;
    BlockCrsrToCrsr();
	EndSelect();
	Invalidate();
}

// Einfuegemodus



void SwWrtShell::SetInsMode( sal_Bool bOn )
{
	bIns = bOn;
	SwCrsrShell::SetOverwriteCrsr( !bIns );
	const SfxBoolItem aTmp( SID_ATTR_INSERT, bIns );
	GetView().GetViewFrame()->GetBindings().SetState( aTmp );
	StartAction();
	EndAction();
	Invalidate();
}
//Overwrite mode is incompatible with red-lining
void SwWrtShell::SetRedlineModeAndCheckInsMode( sal_uInt16 eMode )
{
   SetRedlineMode( eMode );
   if (IsRedlineOn())
       SetInsMode( true );
}

/*
 * Rahmen bearbeiten
 */


long SwWrtShell::BeginFrmDrag(const Point *pPt, sal_Bool)
{
	fnDrag = &SwFEShell::Drag;
	if(bStartDrag)
	{
		Point aTmp( nStartDragX, nStartDragY );
		SwFEShell::BeginDrag( &aTmp, sal_False );
	}
	else
		SwFEShell::BeginDrag( pPt, sal_False );
	return 1;
}



void SwWrtShell::EnterSelFrmMode(const Point *pPos)
{
	if(pPos)
	{
		nStartDragX = pPos->X();
		nStartDragY = pPos->Y();
		bStartDrag = sal_True;
	}
	bNoEdit = bLayoutMode = sal_True;
	HideCrsr();

		// gleicher Aufruf von BeginDrag an der SwFEShell
	fnDrag			= &SwWrtShell::BeginFrmDrag;
	fnEndDrag		= &SwWrtShell::UpdateLayoutFrm;
	SwBaseShell::SetFrmMode( FLY_DRAG_START, this );
	Invalidate();
}



void SwWrtShell::LeaveSelFrmMode()
{
	fnDrag			= &SwWrtShell::BeginDrag;
	fnEndDrag		= &SwWrtShell::EndDrag;
	bLayoutMode = sal_False;
	bStartDrag = sal_False;
	Edit();
	SwBaseShell::SetFrmMode( FLY_DRAG_END, this );
	Invalidate();
}
/*------------------------------------------------------------------------
 Beschreibung:	Rahmengebundenes Macro ausfuehren
------------------------------------------------------------------------*/



IMPL_LINK( SwWrtShell, ExecFlyMac, void *, pFlyFmt )
{
	const SwFrmFmt *pFmt = pFlyFmt ? (SwFrmFmt*)pFlyFmt : GetFlyFrmFmt();
	ASSERT(pFmt, kein FrameFormat.);
	const SvxMacroItem &rFmtMac = pFmt->GetMacro();

	if(rFmtMac.HasMacro(SW_EVENT_OBJECT_SELECT))
	{
		const SvxMacro &rMac = rFmtMac.GetMacro(SW_EVENT_OBJECT_SELECT);
		if( IsFrmSelected() )
			bLayoutMode = sal_True;
		CallChgLnk();
		ExecMacro( rMac );
	}
	return 0;
}



long SwWrtShell::UpdateLayoutFrm(const Point *pPt, sal_Bool )
{
		// voerst Dummy
	SwFEShell::EndDrag( pPt, sal_False );
	fnDrag = &SwWrtShell::BeginFrmDrag;
	return 1;
}

/*
 * Handler fuer das Togglen der Modi. Liefern alten Mode zurueck.
 */



long SwWrtShell::ToggleAddMode()
{
	bAddMode ? LeaveAddMode(): EnterAddMode();
	Invalidate();
	return !bAddMode;
}


long SwWrtShell::ToggleBlockMode()
{
	bBlockMode ? LeaveBlockMode(): EnterBlockMode();
	Invalidate();
	return !bBlockMode;
}


long SwWrtShell::ToggleExtMode()
{
	bExtMode ? LeaveExtMode() : EnterExtMode();
	Invalidate();
	return !bExtMode;
}
/*
 * Draggen im Standard Modus (Selektieren von Inhalt)
 */



long SwWrtShell::BeginDrag(const Point * /*pPt*/, sal_Bool )
{
	if(bSelWrd)
	{
		bInSelect = sal_True;
		if( !IsCrsrPtAtEnd() )
			SwapPam();

		fnDrag = &SwWrtShell::ExtSelWrd;
		fnSetCrsr = &SwWrtShell::Ignore;
	}
	else if(bSelLn)
	{
		bInSelect = sal_True;
		fnDrag = &SwWrtShell::ExtSelLn;
		fnSetCrsr = &SwWrtShell::Ignore;
	}
	else
	{
		fnDrag = &SwWrtShell::Drag;
		SttSelect();
	}

	return 1;
}



long SwWrtShell::Drag(const Point *, sal_Bool )
{
	if( IsSelTblCells() )
		aSelTblLink.Call(this);

	return 1;
}



long SwWrtShell::EndDrag(const Point * /*pPt*/, sal_Bool )
{
	fnDrag = &SwWrtShell::BeginDrag;
	if( IsExtSel() )
		LeaveExtSel();

	if( IsSelTblCells() )
		aSelTblLink.Call(this);
	EndSelect();
	return 1;
}

// --> FME 2004-07-30 #i32329# Enhanced table selection
sal_Bool SwWrtShell::SelectTableRowCol( const Point& rPt, const Point* pEnd, bool bRowDrag )
{
    MV_KONTEXT(this);
    SttSelect();
    if(SelTblRowCol( rPt, pEnd, bRowDrag ))
    {
        fnSetCrsr = &SwWrtShell::SetCrsrKillSel;
        fnKillSel = &SwWrtShell::ResetSelect;
        return sal_True;
    }
    return sal_False;
}
// <--

/*------------------------------------------------------------------------
 Beschreibung:  Selektion einer Tabellenzeile / Spalte
------------------------------------------------------------------------*/

sal_Bool SwWrtShell::SelectTableRow()
{
	if ( SelTblRow() )
	{
		fnSetCrsr = &SwWrtShell::SetCrsrKillSel;
		fnKillSel = &SwWrtShell::ResetSelect;
		return sal_True;
	}
	return sal_False;
}



sal_Bool SwWrtShell::SelectTableCol()
{
	if ( SelTblCol() )
	{
		fnSetCrsr = &SwWrtShell::SetCrsrKillSel;
		fnKillSel = &SwWrtShell::ResetSelect;
		return sal_True;
	}
	return sal_False;
}

sal_Bool SwWrtShell::SelectTableCell()
{
    if ( SelTblBox() )
    {
        fnSetCrsr = &SwWrtShell::SetCrsrKillSel;
        fnKillSel = &SwWrtShell::ResetSelect;
        return sal_True;
    }
    return sal_False;
}
/*------------------------------------------------------------------------
 Beschreibung:	  Prueft, ob eine Wortselektion vorliegt.
				  Gemaess den Regeln fuer intelligentes Cut / Paste
				  werden umgebende Spaces rausgeschnitten.
 Return:		  Liefert Art der Wortselektion zurueck.
------------------------------------------------------------------------*/



int SwWrtShell::IntelligentCut(int nSelection, sal_Bool bCut)
{
		// kein intelligentes Drag and Drop bei Mehrfachselektion
		// es existieren mehrere Cursor, da ein zweiter bereits
		// an die Zielposition gesetzt wurde
    if( IsAddMode() || !(nSelection & nsSelectionType::SEL_TXT) )
		return sal_False;

	String sTxt;
	CharClass& rCC = GetAppCharClass();

		// wenn das erste und das letzte Zeichen kein Wortzeichen ist,
		// ist kein Wort selektiert.
	sal_Unicode cPrev = GetChar(sal_False);
	sal_Unicode cNext = GetChar(sal_True, -1);
    if( !cPrev || !cNext ||
		!rCC.isLetterNumeric( ( sTxt = cPrev), 0 ) ||
		!rCC.isLetterNumeric( ( sTxt = cNext), 0 ) )
		return NO_WORD;

	cPrev = GetChar(sal_False, -1);
	cNext = GetChar(sal_True);

	int cWord = NO_WORD;
		// ist ein Wort selektiert?
	if(!cWord && cPrev && cNext &&
		CH_TXTATR_BREAKWORD != cPrev && CH_TXTATR_INWORD != cPrev &&
		CH_TXTATR_BREAKWORD != cNext && CH_TXTATR_INWORD != cNext &&
		!rCC.isLetterNumeric( ( sTxt = cPrev), 0 ) &&
		!rCC.isLetterNumeric( ( sTxt = cNext), 0 ) )
	   cWord = WORD_NO_SPACE;

	if(cWord == WORD_NO_SPACE && ' ' == cPrev )
	{
		cWord = WORD_SPACE_BEFORE;
			// Space davor loeschen
		if(bCut)
		{
			Push();
			if(IsCrsrPtAtEnd())
				SwapPam();
			ClearMark();
			SetMark();
			SwCrsrShell::Left(1,CRSR_SKIP_CHARS);
			SwFEShell::Delete();
			Pop( sal_False );
		}
	}
	else if(cWord == WORD_NO_SPACE && cNext == ' ')
	{
		cWord = WORD_SPACE_AFTER;
			// Space dahinter loeschen
		if(bCut) {
			Push();
			if(!IsCrsrPtAtEnd()) SwapPam();
			ClearMark();
			SetMark();
			SwCrsrShell::Right(1,CRSR_SKIP_CHARS);
			SwFEShell::Delete();
			Pop( sal_False );
		}
	}
	return cWord;
}



	// jump to the next / previous hyperlink - inside text and also
	// on graphics
sal_Bool SwWrtShell::SelectNextPrevHyperlink( sal_Bool bNext )
{
	StartAction();
	sal_Bool bRet = SwCrsrShell::SelectNxtPrvHyperlink( bNext );
	if( !bRet )
	{
		// will we have this feature?
		EnterStdMode();
		if( bNext )
			SttEndDoc(sal_True);
		else
			SttEndDoc(sal_False);
		bRet = SwCrsrShell::SelectNxtPrvHyperlink( bNext );
	}
	EndAction();

	sal_Bool bCreateXSelection = sal_False;
	const sal_Bool bFrmSelected = IsFrmSelected() || IsObjSelected();
	if( IsSelection() )
	{
		if ( bFrmSelected )
			UnSelectFrm();

		// Funktionspointer fuer das Aufheben der Selektion setzen
		// bei Cursor setzen
		fnKillSel = &SwWrtShell::ResetSelect;
		fnSetCrsr = &SwWrtShell::SetCrsrKillSel;
		bCreateXSelection = sal_True;
	}
	else if( bFrmSelected )
	{
		EnterSelFrmMode();
		bCreateXSelection = sal_True;
	}
	else if( (CNT_GRF | CNT_OLE ) & GetCntType() )
	{
		SelectObj( GetCharRect().Pos() );
		EnterSelFrmMode();
		bCreateXSelection = sal_True;
	}

	if( bCreateXSelection )
		SwTransferable::CreateSelection( *this );

	return bRet;
}


/* fuer den Erhalt der Selektion wird nach SetMark() der Cursor
 * nach links bewegt, damit er durch das Einfuegen von Text nicht
 * verschoben wird.  Da auf der CORE-Seite am aktuellen Cursor
 * eine bestehende Selektion aufgehoben wird, wird der Cursor auf
 * den Stack gepushed. Nach dem Verschieben werden sie wieder
 * zusammengefasst. */