/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 * 
 * Copyright 2000, 2010 Oracle and/or its affiliates.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
 ************************************************************************/
#ifndef _CRSRSH_HXX
#define _CRSRSH_HXX

#include <tools/string.hxx>

#include <viewsh.hxx>			// fuer ViewShell
#include <cshtyp.hxx>        	// fuer die CursorShell Typen
#include <crstate.hxx>			// fuer die CursorMove-Staties
#include <tblsel.hxx>				//SwTblSearchType

#if !defined(DBG_UTIL) && !defined(WIN)
// fuer die Inline-Methoden
#include <viscrs.hxx>
#define CRSR_INLINE inline
#else
#define CRSR_INLINE
#endif
namespace com { namespace sun { namespace star { namespace util {
    struct SearchOptions;
} } } }
class KeyCode;
class Region;
namespace binfilter {
class SfxItemSet;
class SfxPoolItem;

// einige Forward Deklarationen


class SpellCheck;
class SwBookmark;
class SwCntntFrm;
class SwCrsrShell;
class SwCursor;
class SwField;
class SwFieldType;
class SwFmt;
class SwFmtFld;
class SwIndex;
class SwNodeIndex;
class SwNode;
class SwNodes;
class SwPaM;
class SwSelBoxes;
class SwShellCrsr;
class SwShellTableCrsr;
class SwTableNode;
class SwTxtFmtColl;
class SwVisCrsr;
class SwTxtINetFmt;
class SwFmtINetFmt;
class SwTxtAttr;
class SwTableBox;
class SwCellFrms;
class SwTOXMark;
class SwRedline;
struct SwPosition;

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


// enum und struktur, um ueber die Doc-Position Informationen zu erfragen

struct SwContentAtPos
{
    enum IsAttrAtPos
    {
        SW_NOTHING 		= 0x0000,
        SW_FIELD		= 0x0001,
        SW_CLICKFIELD	= 0x0002,
        SW_FTN			= 0x0004,
        SW_INETATTR		= 0x0008,
        SW_TABLEBOXFML	= 0x0010,
        SW_REDLINE		= 0x0020,
        SW_OUTLINE		= 0x0040,
        SW_TOXMARK		= 0x0080,
        SW_REFMARK		= 0x0100
#ifdef DBG_UTIL
        ,SW_CURR_ATTRS 		= 0x4000		// nur zum Debuggen
        ,SW_TABLEBOXVALUE	= 0x8000		// nur zum Debuggen
#endif
    } eCntntAtPos;

    union {
        const SwField* pFld;
        const SfxPoolItem* pAttr;
        const SwRedline* pRedl;
    } aFnd;

    String sStr;
    const SwTxtAttr* pFndTxtAttr;

    SwContentAtPos( int eGetAtPos = 0xffff )
        : eCntntAtPos( (IsAttrAtPos)eGetAtPos )
    {
        aFnd.pFld = 0;
        pFndTxtAttr = 0;
    }

    // befindet sich der Node in einem geschuetzten Bereich?
};


// defines fuers GetCharCount
#define GETCHARCOUNT_NONE		0
#define GETCHARCOUNT_PARA 		1
#define GETCHARCOUNT_SECTION 	2


// ReturnWerte von SetCrsr (werden verodert)
const int 	CRSR_NOERROR =	0x00,
            CRSR_POSOLD =	0x01,	// Cursor bleibt an alter Doc-Position
            CRSR_POSCHG =	0x02;	// Position vom Layout veraendert




// die Cursor - Shell
class SwCrsrShell : public ViewShell, public SwModify
{
    friend class SwCallLink;
    friend class SwVisCrsr;
    friend class SwSelPaintRects;
    friend class SwChgLinkFlag;

    friend BOOL GetAutoSumSel( const SwCrsrShell&, SwCellFrms& );

public:     // public, damit defaultet werden kann !!

    /* ein enum fuer den Aufruf von UpdateCrsr */
    enum CrsrFlag {
        UPDOWN		= (1 << 0),     // Up/Down auf Spalte halten
        SCROLLWIN	= (1 << 1),     // Window Scrollen
        CHKRANGE	= (1 << 2),     // ueberpruefen von ueberlappenden PaM's
        NOCALRECT 	= (1 << 3),		// CharRect nicht neu berechnen
        READONLY	= (1 << 4)		// Sichtbar machen trotz Readonly
    };

private:

    SwRect	aCharRect;			// Char-SRectangle auf dem der Cursor steht
    Point	aCrsrHeight;     	// Hohe&Offset von sichtbaren Cursor
    Point 	aOldRBPos;			// Right/Bottom von letzter VisArea
                                // (wird im Invalidate vom Cursor benutzt)


    // um event. Macro was anhaengt auszufuehren.
    Link aFlyMacroLnk;			// Link will be called, if the Crsr is set
                                // into a fly. A macro can be then becalled
    Link aChgLnk;				// link will be called by every attribut/
                                // format changes at cursor position.
    Link aGrfArrivedLnk;		// Link calls to UI if a grafik is arrived


    SwShellCrsr* pCurCrsr; 		// der aktuelle Cursor
    SwShellCrsr* pCrsrStk;		// Stack fuer den Cursor
    SwVisCrsr *pVisCrsr;        // der Sichtbare-Cursor

    SwShellTableCrsr* pTblCrsr;	// Tabellen-Crsr; nur in Tabellen, wenn
                                // die Selection ueber 2 Spalten liegt

    SwNodeIndex* pBoxIdx;		// fuers erkennen der veraenderten
    SwTableBox* pBoxPtr;		// Tabellen-Zelle

    long nUpDownX;				// versuche den Cursor bei Up/Down immer in
                                // der gleichen Spalte zu bewegen
    long nLeftFrmPos;
    ULONG nAktNode;				// save CursorPos at Start-Action
    xub_StrLen nAktCntnt;
    USHORT nAktNdTyp;
    bool bAktSelection;

    /*
     * Mit den Methoden SttCrsrMove und EndCrsrMove wird dieser Zaehler
     * Inc-/Decrementiert. Solange der Zaehler ungleich 0 ist, erfolgt
     * auf den akt. Cursor kein Update. Dadurch koennen "komplizierte"
     * Cursorbewegungen (ueber Find()) realisiert werden.
     */
    USHORT nCrsrMove;
    USHORT nBasicActionCnt;		// Actions, die vom Basic geklammert wurden
    CrsrMoveState eMvState;		// Status fuers Crsr-Travelling - GetCrsrOfst

    BOOL bHasFocus : 1;         // Shell ist in einem Window "aktiv"
    BOOL bSVCrsrVis : 1;		// SV-Cursor Un-/Sichtbar
    BOOL bChgCallFlag : 1;		// Attributaenderung innerhalb von
                                // Start- und EndAction
    BOOL bVisPortChgd : 1;		// befindet sich im VisPortChg-Aufruf
                                // (wird im Invalidate vom Cursor benutzt)

    BOOL bCallChgLnk : 1;		// Flag fuer abgeleitete Klassen:
                                // TRUE -> ChgLnk callen
                                // Zugriff nur ueber SwChgLinkFlag
    BOOL bAllProtect : 1;		// Flag fuer Bereiche
                                // TRUE -> alles geschuetzt / versteckt
    BOOL bInCMvVisportChgd : 1;	// Flag fuer CrsrMoves
                                // TRUE -> die Sicht wurde verschoben
    BOOL bGCAttr : 1;			// TRUE -> es existieren nichtaufgespannte Attr.
    BOOL bIgnoreReadonly : 1;	// TRUE -> Beim naechsten EndAction trotz
                                // Readonly den Crsr sichtbar machen.
    BOOL bSelTblCells : 1;		// TRUE -> Zellen uebers InputWin selektieren
    BOOL bAutoUpdateCells : 1;	// TRUE -> Zellen werden autoformatiert
    BOOL bBasicHideCrsr : 1;	// TRUE -> HideCrsr vom Basic
    BOOL bSetCrsrInReadOnly : 1;// TRUE -> Cursor darf in ReadOnly-Bereiche
    BOOL bOverwriteCrsr : 1;	// TRUE -> show Overwrite Crsr
    // OD 11.02.2003 #100556# - flag to allow/avoid execution of marcos (default: true)
    bool mbMacroExecAllowed : 1;

    void UpdateCrsr( USHORT eFlags
                            =SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE,
                     BOOL bIdleEnd = FALSE );


typedef FASTBOOL (SwCursor:: *FNCrsr)();


protected:

    CRSR_INLINE SwMoveFnCollection* MakeFindRange( USHORT, USHORT, SwPaM* ) const;

    /*
     * Compare-Methode for the StackCursor and the current Cursor.
     * The Methods return -1, 0, 1 for lower, equal, greater. The enum
     * CrsrCompareType says which position is compared.
     */
    enum CrsrCompareType {
        StackPtStackMk,
        StackPtCurrPt,
        StackPtCurrMk,
        StackMkCurrPt,
        StackMkCurrMk,
        CurrPtCurrMk
    };

    USHORT IncBasicAction()				{ return ++nBasicActionCnt; }
    USHORT DecBasicAction()				{ return --nBasicActionCnt; }

    // Setzt alle PaMs in OldNode auf NewPos + Offset
    // Setzt alle PaMs im Bereich von [StartNode, EndNode] nach NewPos

public:
    TYPEINFO();
    SwCrsrShell( SwDoc& rDoc, Window *pWin,
                SwRootFrm * = 0, const SwViewOption *pOpt = 0 );
    virtual ~SwCrsrShell();

    virtual void Modify( SfxPoolItem *pOld, SfxPoolItem *pNew);

    // loesche den aktuellen Cursor und der folgende wird zum Aktuellen
    // TableCursor in normale Cursor verwandeln, Tablemode aufheben

    SwPaM* GetCrsr( FASTBOOL bMakeTblCrsr = TRUE ) const;
    CRSR_INLINE SwCursor* GetSwCrsr( FASTBOOL bMakeTblCrsr = TRUE ) const;
    // nur den akt. Cursor returnen
          SwShellCrsr* _GetCrsr()  						{ return pCurCrsr; }
    const SwShellCrsr* _GetCrsr() const 				{ return pCurCrsr; }

    // alle Cursor aus den ContentNodes entfernen und auf 0 setzen.
    // Wurde aus der FEShell hierher verschoben.

    // gebe den akt. Cursor-Stack zurueck.
    // ( Wird in der EditShell beim Loeschen von Inhalten benoetigt! )
    CRSR_INLINE SwPaM* GetStkCrsr() const;

    // Start der Klammerung, SV-Cursor und selektierte Bereiche hiden
    void StartAction();
    // Ende der Klammerung, SV-Cursor und selektierte Bereiche anzeigen
    void EndAction( const BOOL bIdleEnd = FALSE );

    USHORT GetBasicActionCnt() const 	{ return nBasicActionCnt; }

    // Basiscursortravelling
    long GetUpDownX() const 			{ return nUpDownX; }


    // die Suchfunktionen



    /*
     * Benachrichtung, dass der sichtbare Bereich sich geaendert
     * hat. aVisArea wird neu gesetzt, anschliessend wird
     * gescrollt. Das uebergebene Rectangle liegt auf
     * Pixelgrenzen, um Pixelfehler beim Scrollen zu vermeiden.
     */

    /*
     * Virtuelle PaintMethode, damit die Selection nach dem Paint wieder
     * sichtbar wird.
     */

    // Bereiche


    /**
       Ensure point and mark of the current PaM are in a specific order.

       @param bPointFirst TRUE: If the point is behind the mark then
       swap the PaM. FALSE: If the mark is behind the point then swap
       the PaM.
    */
    void NormalizePam(BOOL bPointFirst = TRUE);


    // erzeuge eine Kopie vom Cursor und speicher diese im Stack
    /*
     *  Loescht einen Cursor (gesteuert durch bOldCrsr)
     * 		- vom Stack oder	( bOldCrsr = TRUE )
     * 		- den aktuellen und der auf dem Stack stehende wird zum aktuellen
     *
     * 	Return:  es war auf dem Stack noch einer vorhanden
     */
    /*
     * Verbinde zwei Cursor miteinander.
     * Loesche vom Stack den obersten und setzen dessen Mark im Aktuellen.
     */

#if !defined(DBG_UTIL)
    void SttCrsrMove() { ++nCrsrMove; StartAction(); }
    void EndCrsrMove( const BOOL bIdleEnd = FALSE )
            { EndAction( bIdleEnd ); --nCrsrMove; }
#else
    void SttCrsrMove();
    void EndCrsrMove( const BOOL bIdleEnd = FALSE );
#endif

    /*
     * Beim Abgeben des Focuses werden die selektierten Bereiche nicht mehr
     * angezeigt; andererseits beim Erhalten des Focuses, werden alle selek-
     * tierten Bereiche wieder angezeigt. (Bereiche muessen neu berechnet
     * werden!)
     */
    BOOL HasShFcs() const { return bHasFocus; }

    // Methoden zum Anzeigen bzw. Verstecken der selektierten Bereiche mit
    // dem sichtbaren Cursor
    void ShowCrsrs( BOOL bCrsrVis );
    // Methoden zum Anzeigen bzw. Verstecken der selektierten Bereiche mit
    // dem sichtbaren Cursor

    FASTBOOL IsOverwriteCrsr() const { return bOverwriteCrsr; }
    void SetOverwriteCrsr( FASTBOOL bFlag ) { bOverwriteCrsr = bFlag; }

    // gebe den aktuellen Frame, in dem der Cursor steht, zurueck
    SwCntntFrm *GetCurrFrm( const BOOL bCalcFrm = TRUE ) const;

    //TRUE wenn der Crsr wenn der Crsr wegen Readonly gehidet ist,
    //FALSE wenn der arbeitet (trotz Readonly).
    FASTBOOL IsCrsrReadonly() const;
    // darf der Cursor in ReadOnlyBereiche?
    FASTBOOL IsReadOnlyAvailable() const { return bSetCrsrInReadOnly; }

    // Methoden fuer aFlyMacroLnk
    void 		SetFlyMacroLnk( const Link& rLnk ) { aFlyMacroLnk = rLnk; }
    const Link& GetFlyMacroLnk() const 			   { return aFlyMacroLnk; }

    // Methoden geben/aendern den Link fuer die Attribut/Format-Aenderungen
    void 		SetChgLnk( const Link &rLnk ) { aChgLnk = rLnk; }
    const Link& GetChgLnk() const 			  { return aChgLnk; }

    // Methoden geben/aendern den Link fuers "Grafik vollstaendig geladen"
    void 		SetGrfArrivedLnk( const Link &rLnk ) { aGrfArrivedLnk = rLnk; }
    const Link& GetGrfArrivedLnk() const 			 { return aGrfArrivedLnk; }

    //ChgLink callen, innerhalb einer Action wird der Ruf verzoegert.
    void CallChgLnk();

    // Abfrage, ob der aktuelle Cursor eine Selektion aufspannt,
    // also, ob Mark gesetzt und SPoint und Mark unterschiedlich sind.
    FASTBOOL HasSelection() const;

    // Abfrage, ob ueberhaupt eine Selektion existiert, sprich der akt. Cursor
    // aufgespannt oder nicht der einzigste ist.
    CRSR_INLINE FASTBOOL IsSelection() const;
        // returns if multiple cursors are available
    CRSR_INLINE FASTBOOL IsMultiSelection() const;

    // Abfrage, ob ein kompletter Absatz selektiert wurde
    // Abfrage, ob die Selektion in einem Absatz ist
    CRSR_INLINE FASTBOOL IsSelOnePara() const;

    //Sollte fuer das Clipboard der WaitPtr geschaltet werden.

    /*
     * liefert das SRectangle, auf dem der Cursor steht.
     */
    const SwRect &GetCharRect() const { return aCharRect; }
    /*
     * liefert zurueck, ob der Cursor sich ganz oder teilweise im
     * sichtbaren Bereich befindet.
     */
    FASTBOOL IsCrsrVisible() const { return VisArea().IsOver( GetCharRect() ); }

    // aktualisiere den Crsrs, d.H. setze ihn wieder in den Content.
    // Das sollte nur aufgerufen werden, wenn der Cursor z.B. beim
    // Loeschen von Rahmen irgendwohin gesetzt wurde. Die Position
    // ergibt sich aus seiner aktuellen Position im Layout !!
    void UpdateCrsrPos();

    // returne den am akt. Cursor selektierten Text. Dieser wird mit
    // Felder etc. aufgefuellt!!
    // gebe nur den Text ab der akt. Cursor Position zurueck (bis zum NodeEnde)
    // retrurne die Anzahl der selektierten Zeichen.
    // Falls keine Selektion vorliegt entscheided nType was selektiert wird
    // bIntrnlChar besagt ob interne Zeichen erhalten bleiben (TRUE) oder
    // ob sie expandiert werden (z.B Felder/...)

    // pruefe ob vom aktuellen Crsr der SPoint/Mark in einer Tabelle stehen
    CRSR_INLINE const SwTableNode* IsCrsrInTbl( BOOL bIsPtInTbl = TRUE ) const;
    // erfrage die Document - Layout - Position vom akt. Crsr
    CRSR_INLINE Point& GetCrsrDocPos( BOOL bPoint = TRUE ) const;
    CRSR_INLINE FASTBOOL IsCrsrPtAtEnd() const;

    CRSR_INLINE const 	SwPaM* GetTblCrs() const;
     CRSR_INLINE 		SwPaM* GetTblCrs();

    // select a table row, column or box (based on the current cursor)

    // zum naechsten/vorhergehenden Punkt auf gleicher Ebene

        // zu diesem Gliederungspunkt
        // zum naechsten/vorhergehenden oder angegebenen OultineNode
        // suche die "Outline-Position" im Nodes-Array vom akt. Kaiptel
        // selektiere den angeben Bereich von OutlineNodes. Optional
        // inclusive der Childs. Die USHORT sind die Positionen im
        // OutlineNds-Array!! (EditShell)


        // ist der Crsr in einer Tabelle und ist die Selection ueber
        // zwei Spalten
    FASTBOOL IsTableMode() const { return 0 != pTblCrsr; }

        // erfrage den Tabellen Crsr; ausserhalb von Tabellen immer 0
    const SwShellTableCrsr* GetTableCrsr() const { return pTblCrsr; }
    SwShellTableCrsr* GetTableCrsr() { return pTblCrsr; }


    // springe in den Header/Footer des angegebenen oder akt. PageDesc
    // is point of cursor in header/footer. pbInHeader return TRUE if it is
    // in a headerframe otherwise in a footerframe

    // springe zum naechsten Verzeichnis [mit dem Namen]
    // springe zum vorherigen Verzeichnis [mit dem Namen]
    // springe zum naechsten (vorherigen) Verzeichniseintrag
    // Zur naechsten/ vorherigen Verzeichnismarke dieses Typs traveln

    // springe zum naechsten (vorherigen) Tabellenformel
    // optional auch nur zu kaputten Formeln springen
    // jump to the next / previous hyperlink - inside text and also
    // on graphics

    // springe zu dieser Refmark

    // hole vom Start/Ende der akt. Selection das nte Zeichen
    // erweiter die akt. Selection am Anfang/Ende um n Zeichen
    // setze nur den sichtbaren Cursor an die angegebene Dokument-Pos.
    // returnt FALSE: wenn der ob der SPoint vom Layout korrigiert wurde.
    // (wird zum Anzeigen von Drag&Drop/Copy-Cursor benoetigt)
    CRSR_INLINE void UnSetVisCrsr();

    // Char Travelling - Methoden (in crstrvl1.cxx)

    // Abfrage vom CrsrTravelling Status
    CrsrMoveState GetMoveState() const { return eMvState; }

    // loesche alle erzeugten Crsr, setze den Tabellen-Crsr und den letzten
    // Cursor auf seinen TextNode (oder StartNode?).
    // Beim naechsten ::GetCrsr werden sie wieder alle erzeugt.
    // Wird fuers Drag&Drop/ClipBorad-Paste in Tabellen benoetigt.

    // erfrage die selektierte "Region" aller Cursor (fuer D&D auf Mac)
    Region GetCrsrRegion() const;

    // gibt es nicht aufgespannte Attribute?
    FASTBOOL IsGCAttr() const { return bGCAttr; }
    void	ClearGCAttr() {	bGCAttr = FALSE; }
    void	UpdateAttr() {	bGCAttr = TRUE; }

    // ist das gesamte Dokument geschuetzt/versteckt?? (fuer UI,..)
    FASTBOOL IsAllProtect() const { return bAllProtect; }

#ifdef SW_CRSR_TIMER
    // setze das Flag am VisCrsr, ob dieser ueber Timer getriggert (TRUE)
    // oder direkt (FALSE) angezeigt wird. (default ist Timer getriggert)
#endif

    // steht der Curor auf einem "Symbol"-Zeichen

    BOOL BasicActionPend() const 	{ return nBasicActionCnt != nStartAction; }

        // springe zum benannten Bereich

    // zeige die aktuelle Selektion an
    virtual void MakeSelVisible();

    // setzte den Cursor auf einen NICHT geschuetzten/versteckten Node



        // Attribut selelktieren

    FASTBOOL CheckTblBoxCntnt( const SwPosition* pPos = 0 );
    void ClearTblBoxCntnt();
    FASTBOOL EndAllTblBoxEdit();

    // wird gerufen, wenn eine Tabellenselektion im UpdateCrsr erzeugt wird,
    // ohne das die UI davon etaws weiss

    void SetSelTblCells( BOOL bFlag )			{ bSelTblCells = bFlag; }
    BOOL IsSelTblCells() const 					{ return bSelTblCells; }

    BOOL IsAutoUpdateCells() const 				{ return bAutoUpdateCells; }
    void SetAutoUpdateCells( BOOL bFlag ) 		{ bAutoUpdateCells = bFlag; }



    // remove all invalid cursors
    void ClearUpCrsrs();

    // OD 11.02.2003 #100556# - set/get flag to allow/avoid execution of macros
    inline void SetMacroExecAllowed( const bool _bMacroExecAllowed )
    {
        mbMacroExecAllowed = _bMacroExecAllowed;
    }
    inline bool IsMacroExecAllowed()
    {
        return mbMacroExecAllowed;
    }
};


class SwChgLinkFlag
{
    BOOL bOldFlag;
    SwCrsrShell& rCrsrShell;
    long nLeftFrmPos;
public:
    SwChgLinkFlag( SwCrsrShell& rShell );
    ~SwChgLinkFlag();
};



// Cursor Inlines:

#if !defined(DBG_UTIL) && !defined(WIN)

inline SwMoveFnCollection* SwCrsrShell::MakeFindRange(
            USHORT nStt, USHORT nEnd, SwPaM* pPam ) const
{
    DBG_BF_ASSERT(0, "STRIP"); return NULL;//STRIP001 return pCurCrsr->MakeFindRange( (SwDocPositions)nStt, (SwDocPositions)nEnd, pPam );
}

inline SwCursor* SwCrsrShell::GetSwCrsr( FASTBOOL bMakeTblCrsr ) const
{
    return (SwCursor*)GetCrsr( bMakeTblCrsr );
}

inline SwPaM* SwCrsrShell::GetStkCrsr() const { return pCrsrStk; }



/*N*/ inline FASTBOOL SwCrsrShell::IsSelection() const
/*N*/ {
/*N*/ 	return IsTableMode() || pCurCrsr->HasMark() ||
/*N*/ 			pCurCrsr->GetNext() != pCurCrsr;
/*N*/ }
inline FASTBOOL SwCrsrShell::IsMultiSelection() const
{
    return pCurCrsr->GetNext() != pCurCrsr;
}

inline FASTBOOL SwCrsrShell::IsSelOnePara() const
{
    return pCurCrsr == pCurCrsr->GetNext() &&
           pCurCrsr->GetPoint()->nNode == pCurCrsr->GetMark()->nNode;
}

inline const SwTableNode* SwCrsrShell::IsCrsrInTbl( BOOL bIsPtInTbl ) const
{
    return pCurCrsr->GetNode( bIsPtInTbl )->FindTableNode();
}

inline FASTBOOL SwCrsrShell::IsCrsrPtAtEnd() const
{
    return pCurCrsr->End() == pCurCrsr->GetPoint();
}

inline Point& SwCrsrShell::GetCrsrDocPos( BOOL bPoint ) const
{
    return bPoint ? pCurCrsr->GetPtPos() : pCurCrsr->GetMkPos();
}

inline const SwPaM* SwCrsrShell::GetTblCrs() const
{
    return pTblCrsr;
}

inline SwPaM* SwCrsrShell::GetTblCrs()
{
    return pTblCrsr;
}

inline void SwCrsrShell::UnSetVisCrsr()
{
    pVisCrsr->Hide();
    pVisCrsr->SetDragCrsr( FALSE );
}

#endif


} //namespace binfilter
#endif 	// _CRSRSH_HXX

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
